1 #include "config.h"
2 #include <razorback/debug.h>
3 #include <razorback/messages.h>
4 #include <razorback/log.h>
5 #include <razorback/list.h>
6
7 #include "messages/core.h"
8 #include "messages/cnc/core.h"
9 #include "init.h"
10
11 #include <string.h>
12 static struct List * handlerList = NULL;
13 static bool Message_Add_Directed_Headers(struct Message *message, const uuid_t source, const uuid_t dest);
14
15
16 static int MessageHeader_KeyCmp(void *a, void *id);
17 static int MessageHeader_Cmp(void *a, void *b);
18 static void MessageHeader_Delete(void *a);
19
20 static int MessageHandler_KeyCmp(void *a, void *id);
21 static int MessageHandler_Cmp(void *a, void *b);
22 static void MessageHandler_Delete(void *a);
23
24 struct Message *
Message_Create(uint32_t type,uint32_t version,size_t msgSize)25 Message_Create(uint32_t type, uint32_t version, size_t msgSize)
26 {
27 struct Message *message;
28 if ((message = calloc(1,sizeof(struct Message))) == NULL)
29 return NULL;
30 message->type = type;
31 message->version = version;
32 if (msgSize > 0)
33 {
34 if ((message->message = calloc(1,msgSize)) == NULL)
35 return NULL;
36 }
37 message->headers = Message_Header_List_Create();
38 return message;
39 }
40
41 SO_PUBLIC void
Message_Destroy(struct Message * message)42 Message_Destroy(struct Message *message)
43 {
44 ASSERT(message != NULL);
45 if (message == NULL)
46 return;
47
48 if (message->message != NULL)
49 free(message->message);
50
51 if (message->serialized != NULL)
52 free(message->serialized);
53
54 List_Destroy(message->headers);
55 free(message);
56 }
57
58 SO_PUBLIC bool
Message_Add_Header(struct List * headers,const char * p_sName,const char * p_sValue)59 Message_Add_Header(struct List *headers, const char *p_sName, const char *p_sValue)
60 {
61 struct MessageHeader *l_pHeader;
62 if ((l_pHeader = calloc(1, sizeof (struct MessageHeader))) == NULL)
63 {
64 rzb_log(LOG_ERR, "%s: Failed to alloc new header", __func__);
65 return false;
66 }
67 if ((l_pHeader->sName = calloc(1, strlen(p_sName)+1)) == NULL)
68 {
69 rzb_log(LOG_ERR, "%s: Failed to alloc new header name", __func__);
70 free(l_pHeader);
71 return false;
72 }
73 if ((l_pHeader->sValue = calloc(1, strlen(p_sValue)+1)) == NULL)
74 {
75 rzb_log(LOG_ERR, "%s: Failed to alloc new header value", __func__);
76 free(l_pHeader->sName);
77 free(l_pHeader);
78 return false;
79 }
80 strcpy(l_pHeader->sName, p_sName);
81 strcpy(l_pHeader->sValue, p_sValue);
82 List_Push(headers, l_pHeader);
83 return true;
84 }
85
86
87 SO_PUBLIC struct List *
Message_Header_List_Create(void)88 Message_Header_List_Create(void)
89 {
90 return List_Create(LIST_MODE_GENERIC,
91 MessageHeader_Cmp,
92 MessageHeader_KeyCmp,
93 MessageHeader_Delete,
94 NULL, NULL, NULL);
95 }
96
97 static int
MessageHeader_KeyCmp(void * a,void * id)98 MessageHeader_KeyCmp(void *a, void *id)
99 {
100 struct MessageHeader *item = (struct MessageHeader *)a;
101 char *key = id;
102 return strcmp(item->sName, key);
103 }
104
105 static int
MessageHeader_Cmp(void * a,void * b)106 MessageHeader_Cmp(void *a, void *b)
107 {
108 struct MessageHeader *iA = (struct MessageHeader *)a;
109 struct MessageHeader *iB = (struct MessageHeader *)b;
110 if (a == b)
111 return 0;
112 if ( (strcmp(iA->sName, iA->sName) == 0) ||
113 ( strcmp(iA->sValue, iB->sValue) == 0 ))
114 {
115 return 0;
116 }
117 return -1;
118
119 }
120
121 static void
MessageHeader_Delete(void * a)122 MessageHeader_Delete(void *a)
123 {
124 struct MessageHeader *header = a;
125 free(header->sName);
126 free(header->sValue);
127 free(header);
128 }
129
130
131 bool
Message_Init()132 Message_Init()
133 {
134 handlerList = List_Create(LIST_MODE_GENERIC,
135 MessageHandler_Cmp,
136 MessageHandler_KeyCmp,
137 MessageHandler_Delete,
138 NULL, NULL, NULL);
139
140 if (handlerList == NULL)
141 return false;
142
143 MessageBlockSubmission_Init();
144 MessageCacheReq_Init();
145 MessageCacheResp_Init();
146 MessageInspectionSubmission_Init();
147 MessageJudgmentSubmission_Init();
148 MessageLogSubmission_Init();
149 MessageLogSubmission_Init();
150 MessageAlertPrimary_Init();
151 MessageAlertChild_Init();
152 MessageOutputLog_Init();
153 MessageOutputEvent_Init();
154
155 Message_CnC_Bye_Init();
156 Message_CnC_CacheClear_Init();
157 Message_CnC_ConfigAck_Init();
158 Message_CnC_ConfigUpdate_Init();
159 Message_CnC_Error_Init();
160 Message_CnC_Go_Init();
161 Message_CnC_Hello_Init();
162 Message_CnC_Pause_Init();
163 Message_CnC_Paused_Init();
164 Message_CnC_RegReq_Init();
165 Message_CnC_RegResp_Init();
166 Message_CnC_Running_Init();
167 Message_CnC_Term_Init();
168 Message_CnC_ReReg_Init();
169
170 return true;
171 }
172
173 bool
Message_Setup(struct Message * message)174 Message_Setup(struct Message *message)
175 {
176 struct MessageHandler *handler = NULL;
177
178 handler = List_Find(handlerList, &message->type);
179 if (handler == NULL)
180 return false;
181
182 message->serialize = handler->serialize;
183 message->deserialize = handler->deserialize;
184 message->destroy = handler->destroy;
185
186 return true;
187 }
188
Message_Register_Handler(struct MessageHandler * handler)189 bool Message_Register_Handler(struct MessageHandler *handler)
190 {
191 return List_Push(handlerList, handler);
192 }
193
194
195
196 static int
MessageHandler_KeyCmp(void * a,void * id)197 MessageHandler_KeyCmp(void *a, void *id)
198 {
199 struct MessageHandler *item = (struct MessageHandler *)a;
200 uint32_t *key = id;
201 return (item->type - *key);
202 }
203
204 static int
MessageHandler_Cmp(void * a,void * b)205 MessageHandler_Cmp(void *a, void *b)
206 {
207 struct MessageHandler *iA = (struct MessageHandler *)a;
208 struct MessageHandler *iB = (struct MessageHandler *)b;
209 if (a == b)
210 return 0;
211 return (iA->type - iB->type);
212 }
213
214 static void
MessageHandler_Delete(void * a)215 MessageHandler_Delete(void *a)
216 {
217 }
218
219 static bool
Message_Add_Directed_Headers(struct Message * message,const uuid_t source,const uuid_t dest)220 Message_Add_Directed_Headers(struct Message *message, const uuid_t source, const uuid_t dest)
221 {
222 char uuid[UUID_STRING_LENGTH];
223 uuid_unparse(source, uuid);
224 Message_Add_Header(message->headers, MSG_CNC_HEADER_SOURCE, uuid);
225 uuid_unparse(dest, uuid);
226 Message_Add_Header(message->headers, MSG_CNC_HEADER_DEST, uuid);
227
228 return true;
229 }
230
231 SO_PUBLIC struct Message *
Message_Create_Directed(uint32_t type,uint32_t version,size_t msgSize,const uuid_t source,const uuid_t dest)232 Message_Create_Directed(uint32_t type, uint32_t version,
233 size_t msgSize, const uuid_t source, const uuid_t dest)
234 {
235 struct Message *msg;
236 if ((msg = Message_Create(type, version, msgSize)) == NULL)
237 return NULL;
238
239 Message_Add_Directed_Headers(msg, source, dest);
240 return msg;
241 }
242
243 SO_PUBLIC struct Message *
Message_Create_Broadcast(uint32_t type,uint32_t version,size_t msgSize,const uuid_t source)244 Message_Create_Broadcast(uint32_t type, uint32_t version,
245 size_t msgSize, const uuid_t source)
246 {
247 struct Message *msg;
248 uuid_t dest;
249 uuid_clear(dest);
250
251 if ((msg = Message_Create(type, version, msgSize)) == NULL)
252 return NULL;
253
254 Message_Add_Directed_Headers(msg, source, dest);
255 return msg;
256 }
257
258 SO_PUBLIC bool
Message_Serialize_Empty(struct Message * message,int mode)259 Message_Serialize_Empty(struct Message *message, int mode)
260 {
261 ASSERT(message != NULL);
262 if ( message == NULL )
263 return false;
264
265
266 switch (mode)
267 {
268 case MESSAGE_MODE_BIN:
269 case MESSAGE_MODE_JSON:
270 break;
271 default:
272 rzb_log(LOG_ERR, "%s: Invalid serialization mode", __func__);
273 return false;
274 }
275 if ((message->serialized = calloc(2, sizeof(char))) == NULL)
276 return false;
277
278 message->serialized[0]=' ';
279 message->serialized[1]='\0';
280 message->length=1;
281
282 return true;
283 }
284
285 SO_PUBLIC bool
Message_Deserialize_Empty(struct Message * message,int mode)286 Message_Deserialize_Empty(struct Message *message, int mode)
287 {
288 ASSERT(message != NULL);
289 if ( message == NULL )
290 return false;
291
292
293 switch (mode)
294 {
295 case MESSAGE_MODE_BIN:
296 case MESSAGE_MODE_JSON:
297 return true;
298 default:
299 rzb_log(LOG_ERR, "%s: Invalid serialization mode", __func__);
300 return false;
301 }
302 return false;
303 }
304
305 SO_PUBLIC bool
Message_Get_Nuggets(struct Message * message,uuid_t source,uuid_t dest)306 Message_Get_Nuggets(struct Message *message, uuid_t source, uuid_t dest)
307 {
308 struct MessageHeader *header;
309
310 ASSERT(message != NULL);
311 if (message == NULL)
312 return false;
313
314 if ((header = List_Find(message->headers, (void *)MSG_CNC_HEADER_DEST)) == NULL)
315 return false;
316
317 if (uuid_parse(header->sValue, dest) != 0)
318 return false;
319
320 if ((header = List_Find(message->headers, (void *)MSG_CNC_HEADER_SOURCE)) == NULL)
321 return false;
322
323 if (uuid_parse(header->sValue, source) != 0)
324 return false;
325
326 return true;
327 }
328
329