diff options
Diffstat (limited to 'src/messenger/messenger_api_message.c')
-rw-r--r-- | src/messenger/messenger_api_message.c | 489 |
1 files changed, 279 insertions, 210 deletions
diff --git a/src/messenger/messenger_api_message.c b/src/messenger/messenger_api_message.c index 3d9e125a4..881b18bb5 100644 --- a/src/messenger/messenger_api_message.c +++ b/src/messenger/messenger_api_message.c | |||
@@ -41,7 +41,8 @@ struct GNUNET_MESSENGER_ShortMessage | |||
41 | struct GNUNET_MESSENGER_Message* | 41 | struct GNUNET_MESSENGER_Message* |
42 | create_message (enum GNUNET_MESSENGER_MessageKind kind) | 42 | create_message (enum GNUNET_MESSENGER_MessageKind kind) |
43 | { | 43 | { |
44 | struct GNUNET_MESSENGER_Message *message = GNUNET_new(struct GNUNET_MESSENGER_Message); | 44 | struct GNUNET_MESSENGER_Message *message = GNUNET_new (struct |
45 | GNUNET_MESSENGER_Message); | ||
45 | 46 | ||
46 | message->header.kind = kind; | 47 | message->header.kind = kind; |
47 | 48 | ||
@@ -67,32 +68,36 @@ create_message (enum GNUNET_MESSENGER_MessageKind kind) | |||
67 | return message; | 68 | return message; |
68 | } | 69 | } |
69 | 70 | ||
71 | |||
70 | struct GNUNET_MESSENGER_Message* | 72 | struct GNUNET_MESSENGER_Message* |
71 | copy_message (const struct GNUNET_MESSENGER_Message *message) | 73 | copy_message (const struct GNUNET_MESSENGER_Message *message) |
72 | { | 74 | { |
73 | GNUNET_assert(message); | 75 | GNUNET_assert (message); |
74 | 76 | ||
75 | struct GNUNET_MESSENGER_Message *copy = GNUNET_new(struct GNUNET_MESSENGER_Message); | 77 | struct GNUNET_MESSENGER_Message *copy = GNUNET_new (struct |
78 | GNUNET_MESSENGER_Message); | ||
76 | 79 | ||
77 | GNUNET_memcpy(copy, message, sizeof(struct GNUNET_MESSENGER_Message)); | 80 | GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message)); |
78 | 81 | ||
79 | switch (message->header.kind) | 82 | switch (message->header.kind) |
80 | { | 83 | { |
81 | case GNUNET_MESSENGER_KIND_NAME: | 84 | case GNUNET_MESSENGER_KIND_NAME: |
82 | copy->body.name.name = GNUNET_strdup(message->body.name.name); | 85 | copy->body.name.name = GNUNET_strdup (message->body.name.name); |
83 | break; | 86 | break; |
84 | case GNUNET_MESSENGER_KIND_TEXT: | 87 | case GNUNET_MESSENGER_KIND_TEXT: |
85 | copy->body.text.text = GNUNET_strdup(message->body.text.text); | 88 | copy->body.text.text = GNUNET_strdup (message->body.text.text); |
86 | break; | 89 | break; |
87 | case GNUNET_MESSENGER_KIND_FILE: | 90 | case GNUNET_MESSENGER_KIND_FILE: |
88 | copy->body.file.uri = GNUNET_strdup(message->body.file.uri); | 91 | copy->body.file.uri = GNUNET_strdup (message->body.file.uri); |
89 | break; | 92 | break; |
90 | case GNUNET_MESSENGER_KIND_PRIVATE: | 93 | case GNUNET_MESSENGER_KIND_PRIVATE: |
91 | copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc(copy->body.privacy.length) : NULL; | 94 | copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc ( |
95 | copy->body.privacy.length) : NULL; | ||
92 | 96 | ||
93 | if (copy->body.privacy.data) | 97 | if (copy->body.privacy.data) |
94 | { | 98 | { |
95 | GNUNET_memcpy(copy->body.privacy.data, message->body.privacy.data, copy->body.privacy.length); | 99 | GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data, |
100 | copy->body.privacy.length); | ||
96 | } | 101 | } |
97 | 102 | ||
98 | break; | 103 | break; |
@@ -103,6 +108,7 @@ copy_message (const struct GNUNET_MESSENGER_Message *message) | |||
103 | return copy; | 108 | return copy; |
104 | } | 109 | } |
105 | 110 | ||
111 | |||
106 | static void | 112 | static void |
107 | destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, | 113 | destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, |
108 | struct GNUNET_MESSENGER_MessageBody *body) | 114 | struct GNUNET_MESSENGER_MessageBody *body) |
@@ -110,44 +116,47 @@ destroy_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
110 | switch (kind) | 116 | switch (kind) |
111 | { | 117 | { |
112 | case GNUNET_MESSENGER_KIND_NAME: | 118 | case GNUNET_MESSENGER_KIND_NAME: |
113 | GNUNET_free(body->name.name); | 119 | GNUNET_free (body->name.name); |
114 | break; | 120 | break; |
115 | case GNUNET_MESSENGER_KIND_TEXT: | 121 | case GNUNET_MESSENGER_KIND_TEXT: |
116 | GNUNET_free(body->text.text); | 122 | GNUNET_free (body->text.text); |
117 | break; | 123 | break; |
118 | case GNUNET_MESSENGER_KIND_FILE: | 124 | case GNUNET_MESSENGER_KIND_FILE: |
119 | GNUNET_free(body->file.uri); | 125 | GNUNET_free (body->file.uri); |
120 | break; | 126 | break; |
121 | case GNUNET_MESSENGER_KIND_PRIVATE: | 127 | case GNUNET_MESSENGER_KIND_PRIVATE: |
122 | GNUNET_free(body->privacy.data); | 128 | GNUNET_free (body->privacy.data); |
123 | break; | 129 | break; |
124 | default: | 130 | default: |
125 | break; | 131 | break; |
126 | } | 132 | } |
127 | } | 133 | } |
128 | 134 | ||
135 | |||
129 | void | 136 | void |
130 | cleanup_message (struct GNUNET_MESSENGER_Message *message) | 137 | cleanup_message (struct GNUNET_MESSENGER_Message *message) |
131 | { | 138 | { |
132 | GNUNET_assert(message); | 139 | GNUNET_assert (message); |
133 | 140 | ||
134 | destroy_message_body (message->header.kind, &(message->body)); | 141 | destroy_message_body (message->header.kind, &(message->body)); |
135 | } | 142 | } |
136 | 143 | ||
144 | |||
137 | void | 145 | void |
138 | destroy_message (struct GNUNET_MESSENGER_Message *message) | 146 | destroy_message (struct GNUNET_MESSENGER_Message *message) |
139 | { | 147 | { |
140 | GNUNET_assert(message); | 148 | GNUNET_assert (message); |
141 | 149 | ||
142 | destroy_message_body (message->header.kind, &(message->body)); | 150 | destroy_message_body (message->header.kind, &(message->body)); |
143 | 151 | ||
144 | GNUNET_free(message); | 152 | GNUNET_free (message); |
145 | } | 153 | } |
146 | 154 | ||
155 | |||
147 | int | 156 | int |
148 | is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) | 157 | is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) |
149 | { | 158 | { |
150 | GNUNET_assert(message); | 159 | GNUNET_assert (message); |
151 | 160 | ||
152 | if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) || | 161 | if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) || |
153 | (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) || | 162 | (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) || |
@@ -159,15 +168,18 @@ is_message_session_bound (const struct GNUNET_MESSENGER_Message *message) | |||
159 | return GNUNET_NO; | 168 | return GNUNET_NO; |
160 | } | 169 | } |
161 | 170 | ||
171 | |||
162 | static void | 172 | static void |
163 | fold_short_message (const struct GNUNET_MESSENGER_Message *message, | 173 | fold_short_message (const struct GNUNET_MESSENGER_Message *message, |
164 | struct GNUNET_MESSENGER_ShortMessage *shortened) | 174 | struct GNUNET_MESSENGER_ShortMessage *shortened) |
165 | { | 175 | { |
166 | shortened->kind = message->header.kind; | 176 | shortened->kind = message->header.kind; |
167 | 177 | ||
168 | GNUNET_memcpy(&(shortened->body), &(message->body), sizeof(struct GNUNET_MESSENGER_MessageBody)); | 178 | GNUNET_memcpy (&(shortened->body), &(message->body), sizeof(struct |
179 | GNUNET_MESSENGER_MessageBody)); | ||
169 | } | 180 | } |
170 | 181 | ||
182 | |||
171 | static void | 183 | static void |
172 | unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, | 184 | unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, |
173 | struct GNUNET_MESSENGER_Message *message) | 185 | struct GNUNET_MESSENGER_Message *message) |
@@ -176,9 +188,11 @@ unfold_short_message (struct GNUNET_MESSENGER_ShortMessage *shortened, | |||
176 | 188 | ||
177 | message->header.kind = shortened->kind; | 189 | message->header.kind = shortened->kind; |
178 | 190 | ||
179 | GNUNET_memcpy(&(message->body), &(shortened->body), sizeof(struct GNUNET_MESSENGER_MessageBody)); | 191 | GNUNET_memcpy (&(message->body), &(shortened->body), sizeof(struct |
192 | GNUNET_MESSENGER_MessageBody)); | ||
180 | } | 193 | } |
181 | 194 | ||
195 | |||
182 | #define member_size(type, member) sizeof(((type*) NULL)->member) | 196 | #define member_size(type, member) sizeof(((type*) NULL)->member) |
183 | 197 | ||
184 | static uint16_t | 198 | static uint16_t |
@@ -189,40 +203,43 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind) | |||
189 | switch (kind) | 203 | switch (kind) |
190 | { | 204 | { |
191 | case GNUNET_MESSENGER_KIND_INFO: | 205 | case GNUNET_MESSENGER_KIND_INFO: |
192 | length += member_size(struct GNUNET_MESSENGER_Message, body.info.messenger_version); | 206 | length += member_size (struct GNUNET_MESSENGER_Message, |
207 | body.info.messenger_version); | ||
193 | break; | 208 | break; |
194 | case GNUNET_MESSENGER_KIND_PEER: | 209 | case GNUNET_MESSENGER_KIND_PEER: |
195 | length += member_size(struct GNUNET_MESSENGER_Message, body.peer.peer); | 210 | length += member_size (struct GNUNET_MESSENGER_Message, body.peer.peer); |
196 | break; | 211 | break; |
197 | case GNUNET_MESSENGER_KIND_ID: | 212 | case GNUNET_MESSENGER_KIND_ID: |
198 | length += member_size(struct GNUNET_MESSENGER_Message, body.id.id); | 213 | length += member_size (struct GNUNET_MESSENGER_Message, body.id.id); |
199 | break; | 214 | break; |
200 | case GNUNET_MESSENGER_KIND_MISS: | 215 | case GNUNET_MESSENGER_KIND_MISS: |
201 | length += member_size(struct GNUNET_MESSENGER_Message, body.miss.peer); | 216 | length += member_size (struct GNUNET_MESSENGER_Message, body.miss.peer); |
202 | break; | 217 | break; |
203 | case GNUNET_MESSENGER_KIND_MERGE: | 218 | case GNUNET_MESSENGER_KIND_MERGE: |
204 | length += member_size(struct GNUNET_MESSENGER_Message, body.merge.previous); | 219 | length += member_size (struct GNUNET_MESSENGER_Message, |
220 | body.merge.previous); | ||
205 | break; | 221 | break; |
206 | case GNUNET_MESSENGER_KIND_REQUEST: | 222 | case GNUNET_MESSENGER_KIND_REQUEST: |
207 | length += member_size(struct GNUNET_MESSENGER_Message, body.request.hash); | 223 | length += member_size (struct GNUNET_MESSENGER_Message, body.request.hash); |
208 | break; | 224 | break; |
209 | case GNUNET_MESSENGER_KIND_INVITE: | 225 | case GNUNET_MESSENGER_KIND_INVITE: |
210 | length += member_size(struct GNUNET_MESSENGER_Message, body.invite.door); | 226 | length += member_size (struct GNUNET_MESSENGER_Message, body.invite.door); |
211 | length += member_size(struct GNUNET_MESSENGER_Message, body.invite.key); | 227 | length += member_size (struct GNUNET_MESSENGER_Message, body.invite.key); |
212 | break; | 228 | break; |
213 | case GNUNET_MESSENGER_KIND_TEXT: | 229 | case GNUNET_MESSENGER_KIND_TEXT: |
214 | break; | 230 | break; |
215 | case GNUNET_MESSENGER_KIND_FILE: | 231 | case GNUNET_MESSENGER_KIND_FILE: |
216 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.key); | 232 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.key); |
217 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.hash); | 233 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.hash); |
218 | length += member_size(struct GNUNET_MESSENGER_Message, body.file.name); | 234 | length += member_size (struct GNUNET_MESSENGER_Message, body.file.name); |
219 | break; | 235 | break; |
220 | case GNUNET_MESSENGER_KIND_PRIVATE: | 236 | case GNUNET_MESSENGER_KIND_PRIVATE: |
221 | length += member_size(struct GNUNET_MESSENGER_Message, body.privacy.key); | 237 | length += member_size (struct GNUNET_MESSENGER_Message, body.privacy.key); |
222 | break; | 238 | break; |
223 | case GNUNET_MESSENGER_KIND_DELETE: | 239 | case GNUNET_MESSENGER_KIND_DELETE: |
224 | length += member_size(struct GNUNET_MESSENGER_Message, body.deletion.hash); | 240 | length += member_size (struct GNUNET_MESSENGER_Message, body.deletion.hash); |
225 | length += member_size(struct GNUNET_MESSENGER_Message, body.deletion.delay); | 241 | length += member_size (struct GNUNET_MESSENGER_Message, |
242 | body.deletion.delay); | ||
226 | break; | 243 | break; |
227 | default: | 244 | default: |
228 | break; | 245 | break; |
@@ -231,6 +248,7 @@ get_message_body_kind_size (enum GNUNET_MESSENGER_MessageKind kind) | |||
231 | return length; | 248 | return length; |
232 | } | 249 | } |
233 | 250 | ||
251 | |||
234 | typedef uint32_t kind_t; | 252 | typedef uint32_t kind_t; |
235 | 253 | ||
236 | uint16_t | 254 | uint16_t |
@@ -241,9 +259,9 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
241 | 259 | ||
242 | if (GNUNET_YES == include_header) | 260 | if (GNUNET_YES == include_header) |
243 | { | 261 | { |
244 | length += member_size(struct GNUNET_MESSENGER_Message, header.timestamp); | 262 | length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp); |
245 | length += member_size(struct GNUNET_MESSENGER_Message, header.sender_id); | 263 | length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id); |
246 | length += member_size(struct GNUNET_MESSENGER_Message, header.previous); | 264 | length += member_size (struct GNUNET_MESSENGER_Message, header.previous); |
247 | } | 265 | } |
248 | 266 | ||
249 | length += sizeof(kind_t); | 267 | length += sizeof(kind_t); |
@@ -251,6 +269,7 @@ get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
251 | return length + get_message_body_kind_size (kind); | 269 | return length + get_message_body_kind_size (kind); |
252 | } | 270 | } |
253 | 271 | ||
272 | |||
254 | static uint16_t | 273 | static uint16_t |
255 | get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | 274 | get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, |
256 | const struct GNUNET_MESSENGER_MessageBody *body) | 275 | const struct GNUNET_MESSENGER_MessageBody *body) |
@@ -260,13 +279,13 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
260 | switch (kind) | 279 | switch (kind) |
261 | { | 280 | { |
262 | case GNUNET_MESSENGER_KIND_JOIN: | 281 | case GNUNET_MESSENGER_KIND_JOIN: |
263 | length += GNUNET_IDENTITY_public_key_get_length(&(body->join.key)); | 282 | length += GNUNET_IDENTITY_public_key_get_length (&(body->join.key)); |
264 | break; | 283 | break; |
265 | case GNUNET_MESSENGER_KIND_NAME: | 284 | case GNUNET_MESSENGER_KIND_NAME: |
266 | length += (body->name.name ? strlen (body->name.name) : 0); | 285 | length += (body->name.name ? strlen (body->name.name) : 0); |
267 | break; | 286 | break; |
268 | case GNUNET_MESSENGER_KIND_KEY: | 287 | case GNUNET_MESSENGER_KIND_KEY: |
269 | length += GNUNET_IDENTITY_public_key_get_length(&(body->key.key)); | 288 | length += GNUNET_IDENTITY_public_key_get_length (&(body->key.key)); |
270 | break; | 289 | break; |
271 | case GNUNET_MESSENGER_KIND_TEXT: | 290 | case GNUNET_MESSENGER_KIND_TEXT: |
272 | length += strlen (body->text.text); | 291 | length += strlen (body->text.text); |
@@ -284,16 +303,18 @@ get_message_body_size (enum GNUNET_MESSENGER_MessageKind kind, | |||
284 | return length; | 303 | return length; |
285 | } | 304 | } |
286 | 305 | ||
306 | |||
287 | uint16_t | 307 | uint16_t |
288 | get_message_size (const struct GNUNET_MESSENGER_Message *message, | 308 | get_message_size (const struct GNUNET_MESSENGER_Message *message, |
289 | int include_header) | 309 | int include_header) |
290 | { | 310 | { |
291 | GNUNET_assert(message); | 311 | GNUNET_assert (message); |
292 | 312 | ||
293 | uint16_t length = 0; | 313 | uint16_t length = 0; |
294 | 314 | ||
295 | if (GNUNET_YES == include_header) | 315 | if (GNUNET_YES == include_header) |
296 | length += GNUNET_IDENTITY_signature_get_length(&(message->header.signature)); | 316 | length += GNUNET_IDENTITY_signature_get_length ( |
317 | &(message->header.signature)); | ||
297 | 318 | ||
298 | length += get_message_kind_size (message->header.kind, include_header); | 319 | length += get_message_kind_size (message->header.kind, include_header); |
299 | length += get_message_body_size (message->header.kind, &(message->body)); | 320 | length += get_message_body_size (message->header.kind, &(message->body)); |
@@ -301,6 +322,7 @@ get_message_size (const struct GNUNET_MESSENGER_Message *message, | |||
301 | return length; | 322 | return length; |
302 | } | 323 | } |
303 | 324 | ||
325 | |||
304 | static uint16_t | 326 | static uint16_t |
305 | get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, | 327 | get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, |
306 | int include_body) | 328 | int include_body) |
@@ -309,19 +331,24 @@ get_short_message_size (const struct GNUNET_MESSENGER_ShortMessage *message, | |||
309 | 331 | ||
310 | if (message) | 332 | if (message) |
311 | return minimum_size + get_message_body_kind_size (message->kind) | 333 | return minimum_size + get_message_body_kind_size (message->kind) |
312 | + (include_body == GNUNET_YES? get_message_body_size (message->kind, &(message->body)) : 0); | 334 | + (include_body == GNUNET_YES? get_message_body_size (message->kind, |
335 | &(message->body)) | ||
336 | : 0); | ||
313 | else | 337 | else |
314 | return minimum_size; | 338 | return minimum_size; |
315 | } | 339 | } |
316 | 340 | ||
341 | |||
317 | static uint16_t | 342 | static uint16_t |
318 | calc_usual_padding () | 343 | calc_usual_padding () |
319 | { | 344 | { |
320 | uint16_t padding = 0; | 345 | uint16_t padding = 0; |
321 | uint16_t kind_size; | 346 | uint16_t kind_size; |
322 | 347 | ||
323 | for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) { | 348 | for (int i = 0; i <= GNUNET_MESSENGER_KIND_MAX; i++) |
324 | kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i, GNUNET_YES); | 349 | { |
350 | kind_size = get_message_kind_size ((enum GNUNET_MESSENGER_MessageKind) i, | ||
351 | GNUNET_YES); | ||
325 | 352 | ||
326 | if (kind_size > padding) | 353 | if (kind_size > padding) |
327 | padding = kind_size; | 354 | padding = kind_size; |
@@ -330,6 +357,7 @@ calc_usual_padding () | |||
330 | return padding + GNUNET_MESSENGER_PADDING_MIN; | 357 | return padding + GNUNET_MESSENGER_PADDING_MIN; |
331 | } | 358 | } |
332 | 359 | ||
360 | |||
333 | #define max(x, y) (x > y? x : y) | 361 | #define max(x, y) (x > y? x : y) |
334 | 362 | ||
335 | static uint16_t | 363 | static uint16_t |
@@ -337,13 +365,13 @@ calc_padded_length (uint16_t length) | |||
337 | { | 365 | { |
338 | static uint16_t usual_padding = 0; | 366 | static uint16_t usual_padding = 0; |
339 | 367 | ||
340 | if (!usual_padding) | 368 | if (! usual_padding) |
341 | usual_padding = calc_usual_padding(); | 369 | usual_padding = calc_usual_padding (); |
342 | 370 | ||
343 | const uint16_t padded_length = max( | 371 | const uint16_t padded_length = max ( |
344 | length + GNUNET_MESSENGER_PADDING_MIN, | 372 | length + GNUNET_MESSENGER_PADDING_MIN, |
345 | usual_padding | 373 | usual_padding |
346 | ); | 374 | ); |
347 | 375 | ||
348 | if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0) | 376 | if (padded_length <= GNUNET_MESSENGER_PADDING_LEVEL0) |
349 | return GNUNET_MESSENGER_PADDING_LEVEL0; | 377 | return GNUNET_MESSENGER_PADDING_LEVEL0; |
@@ -358,35 +386,36 @@ calc_padded_length (uint16_t length) | |||
358 | 386 | ||
359 | } | 387 | } |
360 | 388 | ||
389 | |||
361 | #define min(x, y) (x < y? x : y) | 390 | #define min(x, y) (x < y? x : y) |
362 | 391 | ||
363 | #define encode_step_ext(dst, offset, src, size) do { \ | 392 | #define encode_step_ext(dst, offset, src, size) do { \ |
364 | GNUNET_memcpy(dst + offset, src, size); \ | 393 | GNUNET_memcpy (dst + offset, src, size); \ |
365 | offset += size; \ | 394 | offset += size; \ |
366 | } while (0) | 395 | } while (0) |
367 | 396 | ||
368 | #define encode_step(dst, offset, src) do { \ | 397 | #define encode_step(dst, offset, src) do { \ |
369 | encode_step_ext(dst, offset, src, sizeof(*src)); \ | 398 | encode_step_ext (dst, offset, src, sizeof(*src)); \ |
370 | } while (0) | 399 | } while (0) |
371 | 400 | ||
372 | #define encode_step_key(dst, offset, src, length) do { \ | 401 | #define encode_step_key(dst, offset, src, length) do { \ |
373 | ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer( \ | 402 | ssize_t result = GNUNET_IDENTITY_write_public_key_to_buffer ( \ |
374 | src, dst + offset, length - offset \ | 403 | src, dst + offset, length - offset \ |
375 | ); \ | 404 | ); \ |
376 | if (result < 0) \ | 405 | if (result < 0) \ |
377 | GNUNET_break (0); \ | 406 | GNUNET_break (0); \ |
378 | else \ | 407 | else \ |
379 | offset += result; \ | 408 | offset += result; \ |
380 | } while (0) | 409 | } while (0) |
381 | 410 | ||
382 | #define encode_step_signature(dst, offset, src, length) do { \ | 411 | #define encode_step_signature(dst, offset, src, length) do { \ |
383 | ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer( \ | 412 | ssize_t result = GNUNET_IDENTITY_write_signature_to_buffer ( \ |
384 | src, dst + offset, length - offset \ | 413 | src, dst + offset, length - offset \ |
385 | ); \ | 414 | ); \ |
386 | if (result < 0) \ | 415 | if (result < 0) \ |
387 | GNUNET_break (0); \ | 416 | GNUNET_break (0); \ |
388 | else \ | 417 | else \ |
389 | offset += result; \ | 418 | offset += result; \ |
390 | } while (0) | 419 | } while (0) |
391 | 420 | ||
392 | static void | 421 | static void |
@@ -400,55 +429,63 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
400 | switch (kind) | 429 | switch (kind) |
401 | { | 430 | { |
402 | case GNUNET_MESSENGER_KIND_INFO: | 431 | case GNUNET_MESSENGER_KIND_INFO: |
403 | version = GNUNET_htobe32(body->info.messenger_version); | 432 | version = GNUNET_htobe32 (body->info.messenger_version); |
404 | 433 | ||
405 | encode_step(buffer, offset, &version); | 434 | encode_step (buffer, offset, &version); |
406 | break; | 435 | break; |
407 | case GNUNET_MESSENGER_KIND_JOIN: | 436 | case GNUNET_MESSENGER_KIND_JOIN: |
408 | encode_step_key(buffer, offset, &(body->join.key), length); | 437 | encode_step_key (buffer, offset, &(body->join.key), length); |
409 | break; | 438 | break; |
410 | case GNUNET_MESSENGER_KIND_NAME: | 439 | case GNUNET_MESSENGER_KIND_NAME: |
411 | if (body->name.name) | 440 | if (body->name.name) |
412 | encode_step_ext(buffer, offset, body->name.name, min(length - offset, strlen(body->name.name))); | 441 | encode_step_ext (buffer, offset, body->name.name, min (length - offset, |
442 | strlen ( | ||
443 | body->name.name))); | ||
413 | break; | 444 | break; |
414 | case GNUNET_MESSENGER_KIND_KEY: | 445 | case GNUNET_MESSENGER_KIND_KEY: |
415 | encode_step_key(buffer, offset, &(body->key.key), length); | 446 | encode_step_key (buffer, offset, &(body->key.key), length); |
416 | break; | 447 | break; |
417 | case GNUNET_MESSENGER_KIND_PEER: | 448 | case GNUNET_MESSENGER_KIND_PEER: |
418 | encode_step(buffer, offset, &(body->peer.peer)); | 449 | encode_step (buffer, offset, &(body->peer.peer)); |
419 | break; | 450 | break; |
420 | case GNUNET_MESSENGER_KIND_ID: | 451 | case GNUNET_MESSENGER_KIND_ID: |
421 | encode_step(buffer, offset, &(body->id.id)); | 452 | encode_step (buffer, offset, &(body->id.id)); |
422 | break; | 453 | break; |
423 | case GNUNET_MESSENGER_KIND_MISS: | 454 | case GNUNET_MESSENGER_KIND_MISS: |
424 | encode_step(buffer, offset, &(body->miss.peer)); | 455 | encode_step (buffer, offset, &(body->miss.peer)); |
425 | break; | 456 | break; |
426 | case GNUNET_MESSENGER_KIND_MERGE: | 457 | case GNUNET_MESSENGER_KIND_MERGE: |
427 | encode_step(buffer, offset, &(body->merge.previous)); | 458 | encode_step (buffer, offset, &(body->merge.previous)); |
428 | break; | 459 | break; |
429 | case GNUNET_MESSENGER_KIND_REQUEST: | 460 | case GNUNET_MESSENGER_KIND_REQUEST: |
430 | encode_step(buffer, offset, &(body->request.hash)); | 461 | encode_step (buffer, offset, &(body->request.hash)); |
431 | break; | 462 | break; |
432 | case GNUNET_MESSENGER_KIND_INVITE: | 463 | case GNUNET_MESSENGER_KIND_INVITE: |
433 | encode_step(buffer, offset, &(body->invite.door)); | 464 | encode_step (buffer, offset, &(body->invite.door)); |
434 | encode_step(buffer, offset, &(body->invite.key)); | 465 | encode_step (buffer, offset, &(body->invite.key)); |
435 | break; | 466 | break; |
436 | case GNUNET_MESSENGER_KIND_TEXT: | 467 | case GNUNET_MESSENGER_KIND_TEXT: |
437 | encode_step_ext(buffer, offset, body->text.text, min(length - offset, strlen(body->text.text))); | 468 | encode_step_ext (buffer, offset, body->text.text, min (length - offset, |
469 | strlen ( | ||
470 | body->text.text))); | ||
438 | break; | 471 | break; |
439 | case GNUNET_MESSENGER_KIND_FILE: | 472 | case GNUNET_MESSENGER_KIND_FILE: |
440 | encode_step(buffer, offset, &(body->file.key)); | 473 | encode_step (buffer, offset, &(body->file.key)); |
441 | encode_step(buffer, offset, &(body->file.hash)); | 474 | encode_step (buffer, offset, &(body->file.hash)); |
442 | encode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name)); | 475 | encode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name)); |
443 | encode_step_ext(buffer, offset, body->file.uri, min(length - offset, strlen(body->file.uri))); | 476 | encode_step_ext (buffer, offset, body->file.uri, min (length - offset, |
477 | strlen ( | ||
478 | body->file.uri))); | ||
444 | break; | 479 | break; |
445 | case GNUNET_MESSENGER_KIND_PRIVATE: | 480 | case GNUNET_MESSENGER_KIND_PRIVATE: |
446 | encode_step(buffer, offset, &(body->privacy.key)); | 481 | encode_step (buffer, offset, &(body->privacy.key)); |
447 | encode_step_ext(buffer, offset, body->privacy.data, min(length - offset, body->privacy.length)); | 482 | encode_step_ext (buffer, offset, body->privacy.data, min (length - offset, |
483 | body->privacy. | ||
484 | length)); | ||
448 | break; | 485 | break; |
449 | case GNUNET_MESSENGER_KIND_DELETE: | 486 | case GNUNET_MESSENGER_KIND_DELETE: |
450 | encode_step(buffer, offset, &(body->deletion.hash)); | 487 | encode_step (buffer, offset, &(body->deletion.hash)); |
451 | encode_step(buffer, offset, &(body->deletion.delay)); | 488 | encode_step (buffer, offset, &(body->deletion.delay)); |
452 | break; | 489 | break; |
453 | default: | 490 | default: |
454 | break; | 491 | break; |
@@ -460,43 +497,48 @@ encode_message_body (enum GNUNET_MESSENGER_MessageKind kind, | |||
460 | const uint16_t padding = length - offset; | 497 | const uint16_t padding = length - offset; |
461 | const uint16_t used_padding = sizeof(padding) + sizeof(char); | 498 | const uint16_t used_padding = sizeof(padding) + sizeof(char); |
462 | 499 | ||
463 | GNUNET_assert(padding >= used_padding); | 500 | GNUNET_assert (padding >= used_padding); |
464 | 501 | ||
465 | buffer[offset++] = '\0'; | 502 | buffer[offset++] = '\0'; |
466 | 503 | ||
467 | if (padding > used_padding) | 504 | if (padding > used_padding) |
468 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset, padding - used_padding); | 505 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, buffer + offset, |
506 | padding - used_padding); | ||
469 | 507 | ||
470 | GNUNET_memcpy(buffer + length - sizeof(padding), &padding, sizeof(padding)); | 508 | GNUNET_memcpy (buffer + length - sizeof(padding), &padding, sizeof(padding)); |
471 | } | 509 | } |
472 | 510 | ||
511 | |||
473 | void | 512 | void |
474 | encode_message (const struct GNUNET_MESSENGER_Message *message, | 513 | encode_message (const struct GNUNET_MESSENGER_Message *message, |
475 | uint16_t length, | 514 | uint16_t length, |
476 | char *buffer, | 515 | char *buffer, |
477 | int include_header) | 516 | int include_header) |
478 | { | 517 | { |
479 | GNUNET_assert((message) && (buffer)); | 518 | GNUNET_assert ((message) && (buffer)); |
480 | 519 | ||
481 | uint16_t offset = 0; | 520 | uint16_t offset = 0; |
482 | 521 | ||
483 | if (GNUNET_YES == include_header) | 522 | if (GNUNET_YES == include_header) |
484 | encode_step_signature(buffer, offset, &(message->header.signature), length); | 523 | encode_step_signature (buffer, offset, &(message->header.signature), |
524 | length); | ||
485 | 525 | ||
486 | const kind_t kind = GNUNET_htobe32((kind_t) message->header.kind); | 526 | const kind_t kind = GNUNET_htobe32 ((kind_t) message->header.kind); |
487 | 527 | ||
488 | if (GNUNET_YES == include_header) | 528 | if (GNUNET_YES == include_header) |
489 | { | 529 | { |
490 | encode_step(buffer, offset, &(message->header.timestamp)); | 530 | encode_step (buffer, offset, &(message->header.timestamp)); |
491 | encode_step(buffer, offset, &(message->header.sender_id)); | 531 | encode_step (buffer, offset, &(message->header.sender_id)); |
492 | encode_step(buffer, offset, &(message->header.previous)); | 532 | encode_step (buffer, offset, &(message->header.previous)); |
493 | } | 533 | } |
494 | 534 | ||
495 | encode_step(buffer, offset, &kind); | 535 | encode_step (buffer, offset, &kind); |
496 | 536 | ||
497 | encode_message_body (message->header.kind, &(message->body), length, buffer, offset); | 537 | encode_message_body (message->header.kind, &(message->body), length, buffer, |
538 | offset); | ||
498 | } | 539 | } |
499 | 540 | ||
541 | |||
500 | static void | 542 | static void |
501 | encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, | 543 | encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, |
502 | uint16_t length, | 544 | uint16_t length, |
@@ -505,46 +547,47 @@ encode_short_message (const struct GNUNET_MESSENGER_ShortMessage *message, | |||
505 | struct GNUNET_HashCode hash; | 547 | struct GNUNET_HashCode hash; |
506 | uint16_t offset = sizeof(hash); | 548 | uint16_t offset = sizeof(hash); |
507 | 549 | ||
508 | const kind_t kind = GNUNET_htobe32((kind_t) message->kind); | 550 | const kind_t kind = GNUNET_htobe32 ((kind_t) message->kind); |
509 | 551 | ||
510 | encode_step(buffer, offset, &kind); | 552 | encode_step (buffer, offset, &kind); |
511 | 553 | ||
512 | encode_message_body (message->kind, &(message->body), length, buffer, offset); | 554 | encode_message_body (message->kind, &(message->body), length, buffer, offset); |
513 | 555 | ||
514 | GNUNET_CRYPTO_hash( | 556 | GNUNET_CRYPTO_hash ( |
515 | buffer + sizeof(hash), | 557 | buffer + sizeof(hash), |
516 | length - sizeof(hash), | 558 | length - sizeof(hash), |
517 | &hash | 559 | &hash |
518 | ); | 560 | ); |
519 | 561 | ||
520 | GNUNET_memcpy(buffer, &hash, sizeof(hash)); | 562 | GNUNET_memcpy (buffer, &hash, sizeof(hash)); |
521 | } | 563 | } |
522 | 564 | ||
565 | |||
523 | #define decode_step_ext(src, offset, dst, size) do { \ | 566 | #define decode_step_ext(src, offset, dst, size) do { \ |
524 | GNUNET_memcpy(dst, src + offset, size); \ | 567 | GNUNET_memcpy (dst, src + offset, size); \ |
525 | offset += size; \ | 568 | offset += size; \ |
526 | } while (0) | 569 | } while (0) |
527 | 570 | ||
528 | #define decode_step(src, offset, dst) do { \ | 571 | #define decode_step(src, offset, dst) do { \ |
529 | decode_step_ext(src, offset, dst, sizeof(*dst)); \ | 572 | decode_step_ext (src, offset, dst, sizeof(*dst)); \ |
530 | } while (0) | 573 | } while (0) |
531 | 574 | ||
532 | #define decode_step_malloc(src, offset, dst, size, zero) do { \ | 575 | #define decode_step_malloc(src, offset, dst, size, zero) do { \ |
533 | dst = GNUNET_malloc(size + zero); \ | 576 | dst = GNUNET_malloc (size + zero); \ |
534 | if (zero) dst[size] = 0; \ | 577 | if (zero) dst[size] = 0; \ |
535 | decode_step_ext(src, offset, dst, size); \ | 578 | decode_step_ext (src, offset, dst, size); \ |
536 | } while (0) | 579 | } while (0) |
537 | 580 | ||
538 | #define decode_step_key(src, offset, dst, length) do { \ | 581 | #define decode_step_key(src, offset, dst, length) do { \ |
539 | enum GNUNET_GenericReturnValue result; \ | 582 | enum GNUNET_GenericReturnValue result; \ |
540 | size_t read; \ | 583 | size_t read; \ |
541 | result = GNUNET_IDENTITY_read_public_key_from_buffer( \ | 584 | result = GNUNET_IDENTITY_read_public_key_from_buffer ( \ |
542 | src + offset, length - offset, dst, &read \ | 585 | src + offset, length - offset, dst, &read \ |
543 | ); \ | 586 | ); \ |
544 | if (GNUNET_SYSERR == result) \ | 587 | if (GNUNET_SYSERR == result) \ |
545 | GNUNET_break(0); \ | 588 | GNUNET_break (0); \ |
546 | else \ | 589 | else \ |
547 | offset += read; \ | 590 | offset += read; \ |
548 | } while (0) | 591 | } while (0) |
549 | 592 | ||
550 | static uint16_t | 593 | static uint16_t |
@@ -556,7 +599,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
556 | { | 599 | { |
557 | uint16_t padding = 0; | 600 | uint16_t padding = 0; |
558 | 601 | ||
559 | GNUNET_memcpy(&padding, buffer + length - sizeof(padding), sizeof(padding)); | 602 | GNUNET_memcpy (&padding, buffer + length - sizeof(padding), sizeof(padding)); |
560 | 603 | ||
561 | if (padding > length - offset) | 604 | if (padding > length - offset) |
562 | padding = 0; | 605 | padding = 0; |
@@ -572,59 +615,59 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
572 | switch (*kind) | 615 | switch (*kind) |
573 | { | 616 | { |
574 | case GNUNET_MESSENGER_KIND_INFO: { | 617 | case GNUNET_MESSENGER_KIND_INFO: { |
575 | decode_step(buffer, offset, &version); | 618 | decode_step (buffer, offset, &version); |
576 | 619 | ||
577 | body->info.messenger_version = GNUNET_be32toh(version); | 620 | body->info.messenger_version = GNUNET_be32toh (version); |
578 | break; | 621 | break; |
579 | } case GNUNET_MESSENGER_KIND_JOIN: { | 622 | } case GNUNET_MESSENGER_KIND_JOIN: { |
580 | decode_step_key(buffer, offset, &(body->join.key), length); | 623 | decode_step_key (buffer, offset, &(body->join.key), length); |
581 | break; | 624 | break; |
582 | } case GNUNET_MESSENGER_KIND_NAME: | 625 | } case GNUNET_MESSENGER_KIND_NAME: |
583 | if (length - offset > 0) | 626 | if (length - offset > 0) |
584 | decode_step_malloc(buffer, offset, body->name.name, length - offset, 1); | 627 | decode_step_malloc (buffer, offset, body->name.name, length - offset, 1); |
585 | else | 628 | else |
586 | body->name.name = NULL; | 629 | body->name.name = NULL; |
587 | break; | 630 | break; |
588 | case GNUNET_MESSENGER_KIND_KEY: | 631 | case GNUNET_MESSENGER_KIND_KEY: |
589 | decode_step_key(buffer, offset, &(body->key.key), length); | 632 | decode_step_key (buffer, offset, &(body->key.key), length); |
590 | break; | 633 | break; |
591 | case GNUNET_MESSENGER_KIND_PEER: | 634 | case GNUNET_MESSENGER_KIND_PEER: |
592 | decode_step(buffer, offset, &(body->peer.peer)); | 635 | decode_step (buffer, offset, &(body->peer.peer)); |
593 | break; | 636 | break; |
594 | case GNUNET_MESSENGER_KIND_ID: | 637 | case GNUNET_MESSENGER_KIND_ID: |
595 | decode_step(buffer, offset, &(body->id.id)); | 638 | decode_step (buffer, offset, &(body->id.id)); |
596 | break; | 639 | break; |
597 | case GNUNET_MESSENGER_KIND_MISS: | 640 | case GNUNET_MESSENGER_KIND_MISS: |
598 | decode_step(buffer, offset, &(body->miss.peer)); | 641 | decode_step (buffer, offset, &(body->miss.peer)); |
599 | break; | 642 | break; |
600 | case GNUNET_MESSENGER_KIND_MERGE: | 643 | case GNUNET_MESSENGER_KIND_MERGE: |
601 | decode_step(buffer, offset, &(body->merge.previous)); | 644 | decode_step (buffer, offset, &(body->merge.previous)); |
602 | break; | 645 | break; |
603 | case GNUNET_MESSENGER_KIND_REQUEST: | 646 | case GNUNET_MESSENGER_KIND_REQUEST: |
604 | decode_step(buffer, offset, &(body->request.hash)); | 647 | decode_step (buffer, offset, &(body->request.hash)); |
605 | break; | 648 | break; |
606 | case GNUNET_MESSENGER_KIND_INVITE: | 649 | case GNUNET_MESSENGER_KIND_INVITE: |
607 | decode_step(buffer, offset, &(body->invite.door)); | 650 | decode_step (buffer, offset, &(body->invite.door)); |
608 | decode_step(buffer, offset, &(body->invite.key)); | 651 | decode_step (buffer, offset, &(body->invite.key)); |
609 | break; | 652 | break; |
610 | case GNUNET_MESSENGER_KIND_TEXT: | 653 | case GNUNET_MESSENGER_KIND_TEXT: |
611 | decode_step_malloc(buffer, offset, body->text.text, length - offset, 1); | 654 | decode_step_malloc (buffer, offset, body->text.text, length - offset, 1); |
612 | break; | 655 | break; |
613 | case GNUNET_MESSENGER_KIND_FILE: | 656 | case GNUNET_MESSENGER_KIND_FILE: |
614 | decode_step(buffer, offset, &(body->file.key)); | 657 | decode_step (buffer, offset, &(body->file.key)); |
615 | decode_step(buffer, offset, &(body->file.hash)); | 658 | decode_step (buffer, offset, &(body->file.hash)); |
616 | decode_step_ext(buffer, offset, body->file.name, sizeof(body->file.name)); | 659 | decode_step_ext (buffer, offset, body->file.name, sizeof(body->file.name)); |
617 | decode_step_malloc(buffer, offset, body->file.uri, length - offset, 1); | 660 | decode_step_malloc (buffer, offset, body->file.uri, length - offset, 1); |
618 | break; | 661 | break; |
619 | case GNUNET_MESSENGER_KIND_PRIVATE: | 662 | case GNUNET_MESSENGER_KIND_PRIVATE: |
620 | decode_step(buffer, offset, &(body->privacy.key)); | 663 | decode_step (buffer, offset, &(body->privacy.key)); |
621 | 664 | ||
622 | body->privacy.length = (length - offset); | 665 | body->privacy.length = (length - offset); |
623 | decode_step_malloc(buffer, offset, body->privacy.data, length - offset, 0); | 666 | decode_step_malloc (buffer, offset, body->privacy.data, length - offset, 0); |
624 | break; | 667 | break; |
625 | case GNUNET_MESSENGER_KIND_DELETE: | 668 | case GNUNET_MESSENGER_KIND_DELETE: |
626 | decode_step(buffer, offset, &(body->deletion.hash)); | 669 | decode_step (buffer, offset, &(body->deletion.hash)); |
627 | decode_step(buffer, offset, &(body->deletion.delay)); | 670 | decode_step (buffer, offset, &(body->deletion.delay)); |
628 | break; | 671 | break; |
629 | default: | 672 | default: |
630 | *kind = GNUNET_MESSENGER_KIND_UNKNOWN; | 673 | *kind = GNUNET_MESSENGER_KIND_UNKNOWN; |
@@ -634,6 +677,7 @@ decode_message_body (enum GNUNET_MESSENGER_MessageKind *kind, | |||
634 | return padding; | 677 | return padding; |
635 | } | 678 | } |
636 | 679 | ||
680 | |||
637 | int | 681 | int |
638 | decode_message (struct GNUNET_MESSENGER_Message *message, | 682 | decode_message (struct GNUNET_MESSENGER_Message *message, |
639 | uint16_t length, | 683 | uint16_t length, |
@@ -641,19 +685,20 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
641 | int include_header, | 685 | int include_header, |
642 | uint16_t *padding) | 686 | uint16_t *padding) |
643 | { | 687 | { |
644 | GNUNET_assert( | 688 | GNUNET_assert ( |
645 | (message) && | 689 | (message) && |
646 | (buffer) && | 690 | (buffer) && |
647 | (length >= get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN, include_header)) | 691 | (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, |
648 | ); | 692 | include_header)) |
693 | ); | ||
649 | 694 | ||
650 | uint16_t offset = 0; | 695 | uint16_t offset = 0; |
651 | 696 | ||
652 | if (GNUNET_YES == include_header) | 697 | if (GNUNET_YES == include_header) |
653 | { | 698 | { |
654 | ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer( | 699 | ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer ( |
655 | &(message->header.signature), buffer, length - offset | 700 | &(message->header.signature), buffer, length - offset |
656 | ); | 701 | ); |
657 | 702 | ||
658 | if (result < 0) | 703 | if (result < 0) |
659 | return GNUNET_NO; | 704 | return GNUNET_NO; |
@@ -663,26 +708,30 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
663 | 708 | ||
664 | const uint16_t count = length - offset; | 709 | const uint16_t count = length - offset; |
665 | 710 | ||
666 | if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, include_header)) | 711 | if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN, |
712 | include_header)) | ||
667 | return GNUNET_NO; | 713 | return GNUNET_NO; |
668 | 714 | ||
669 | kind_t kind; | 715 | kind_t kind; |
670 | 716 | ||
671 | if (GNUNET_YES == include_header) | 717 | if (GNUNET_YES == include_header) |
672 | { | 718 | { |
673 | decode_step(buffer, offset, &(message->header.timestamp)); | 719 | decode_step (buffer, offset, &(message->header.timestamp)); |
674 | decode_step(buffer, offset, &(message->header.sender_id)); | 720 | decode_step (buffer, offset, &(message->header.sender_id)); |
675 | decode_step(buffer, offset, &(message->header.previous)); | 721 | decode_step (buffer, offset, &(message->header.previous)); |
676 | } | 722 | } |
677 | 723 | ||
678 | decode_step(buffer, offset, &kind); | 724 | decode_step (buffer, offset, &kind); |
679 | 725 | ||
680 | message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh(kind); | 726 | message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh ( |
727 | kind); | ||
681 | 728 | ||
682 | if (count < get_message_kind_size (message->header.kind, include_header)) | 729 | if (count < get_message_kind_size (message->header.kind, include_header)) |
683 | return GNUNET_NO; | 730 | return GNUNET_NO; |
684 | 731 | ||
685 | const uint16_t result = decode_message_body (&(message->header.kind), &(message->body), length, buffer, offset); | 732 | const uint16_t result = decode_message_body (&(message->header.kind), |
733 | &(message->body), length, buffer, | ||
734 | offset); | ||
686 | 735 | ||
687 | if (padding) | 736 | if (padding) |
688 | *padding = result; | 737 | *padding = result; |
@@ -690,6 +739,7 @@ decode_message (struct GNUNET_MESSENGER_Message *message, | |||
690 | return GNUNET_YES; | 739 | return GNUNET_YES; |
691 | } | 740 | } |
692 | 741 | ||
742 | |||
693 | static int | 743 | static int |
694 | decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | 744 | decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, |
695 | uint16_t length, | 745 | uint16_t length, |
@@ -701,27 +751,28 @@ decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | |||
701 | if (length < get_short_message_size (NULL, GNUNET_NO)) | 751 | if (length < get_short_message_size (NULL, GNUNET_NO)) |
702 | return GNUNET_NO; | 752 | return GNUNET_NO; |
703 | 753 | ||
704 | GNUNET_memcpy(&hash, buffer, sizeof(hash)); | 754 | GNUNET_memcpy (&hash, buffer, sizeof(hash)); |
705 | 755 | ||
706 | GNUNET_CRYPTO_hash( | 756 | GNUNET_CRYPTO_hash ( |
707 | buffer + sizeof(hash), | 757 | buffer + sizeof(hash), |
708 | length - sizeof(hash), | 758 | length - sizeof(hash), |
709 | &expected | 759 | &expected |
710 | ); | 760 | ); |
711 | 761 | ||
712 | if (0 != GNUNET_CRYPTO_hash_cmp(&hash, &expected)) | 762 | if (0 != GNUNET_CRYPTO_hash_cmp (&hash, &expected)) |
713 | return GNUNET_NO; | 763 | return GNUNET_NO; |
714 | 764 | ||
715 | kind_t kind; | 765 | kind_t kind; |
716 | 766 | ||
717 | decode_step(buffer, offset, &kind); | 767 | decode_step (buffer, offset, &kind); |
718 | 768 | ||
719 | message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh(kind); | 769 | message->kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (kind); |
720 | 770 | ||
721 | if (length < get_short_message_size (message, GNUNET_NO)) | 771 | if (length < get_short_message_size (message, GNUNET_NO)) |
722 | return GNUNET_NO; | 772 | return GNUNET_NO; |
723 | 773 | ||
724 | decode_message_body (&(message->kind), &(message->body), length, buffer, offset); | 774 | decode_message_body (&(message->kind), &(message->body), length, buffer, |
775 | offset); | ||
725 | 776 | ||
726 | if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind) | 777 | if (GNUNET_MESSENGER_KIND_UNKNOWN == message->kind) |
727 | return GNUNET_NO; | 778 | return GNUNET_NO; |
@@ -729,21 +780,23 @@ decode_short_message (struct GNUNET_MESSENGER_ShortMessage *message, | |||
729 | return GNUNET_YES; | 780 | return GNUNET_YES; |
730 | } | 781 | } |
731 | 782 | ||
783 | |||
732 | void | 784 | void |
733 | hash_message (const struct GNUNET_MESSENGER_Message *message, | 785 | hash_message (const struct GNUNET_MESSENGER_Message *message, |
734 | uint16_t length, | 786 | uint16_t length, |
735 | const char *buffer, | 787 | const char *buffer, |
736 | struct GNUNET_HashCode *hash) | 788 | struct GNUNET_HashCode *hash) |
737 | { | 789 | { |
738 | GNUNET_assert((message) && (buffer) && (hash)); | 790 | GNUNET_assert ((message) && (buffer) && (hash)); |
739 | 791 | ||
740 | const ssize_t offset = GNUNET_IDENTITY_signature_get_length( | 792 | const ssize_t offset = GNUNET_IDENTITY_signature_get_length ( |
741 | &(message->header.signature) | 793 | &(message->header.signature) |
742 | ); | 794 | ); |
743 | 795 | ||
744 | GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash); | 796 | GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash); |
745 | } | 797 | } |
746 | 798 | ||
799 | |||
747 | void | 800 | void |
748 | sign_message (struct GNUNET_MESSENGER_Message *message, | 801 | sign_message (struct GNUNET_MESSENGER_Message *message, |
749 | uint16_t length, | 802 | uint16_t length, |
@@ -751,7 +804,7 @@ sign_message (struct GNUNET_MESSENGER_Message *message, | |||
751 | const struct GNUNET_HashCode *hash, | 804 | const struct GNUNET_HashCode *hash, |
752 | const struct GNUNET_IDENTITY_PrivateKey *key) | 805 | const struct GNUNET_IDENTITY_PrivateKey *key) |
753 | { | 806 | { |
754 | GNUNET_assert((message) && (buffer) && (hash) && (key)); | 807 | GNUNET_assert ((message) && (buffer) && (hash) && (key)); |
755 | 808 | ||
756 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n", | 809 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n", |
757 | GNUNET_h2s (hash)); | 810 | GNUNET_h2s (hash)); |
@@ -761,23 +814,24 @@ sign_message (struct GNUNET_MESSENGER_Message *message, | |||
761 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 814 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
762 | signature.purpose.size = htonl (sizeof(signature)); | 815 | signature.purpose.size = htonl (sizeof(signature)); |
763 | 816 | ||
764 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 817 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
765 | GNUNET_IDENTITY_sign(key, &signature, &(message->header.signature)); | 818 | GNUNET_IDENTITY_sign (key, &signature, &(message->header.signature)); |
766 | 819 | ||
767 | message->header.signature.type = key->type; | 820 | message->header.signature.type = key->type; |
768 | 821 | ||
769 | uint16_t offset = 0; | 822 | uint16_t offset = 0; |
770 | encode_step_signature(buffer, offset, &(message->header.signature), length); | 823 | encode_step_signature (buffer, offset, &(message->header.signature), length); |
771 | } | 824 | } |
772 | 825 | ||
826 | |||
773 | void | 827 | void |
774 | sign_message_by_peer (struct GNUNET_MESSENGER_Message *message, | 828 | sign_message_by_peer (struct GNUNET_MESSENGER_Message *message, |
775 | uint16_t length, | 829 | uint16_t length, |
776 | char *buffer, | 830 | char *buffer, |
777 | const struct GNUNET_HashCode *hash, | 831 | const struct GNUNET_HashCode *hash, |
778 | const struct GNUNET_CONFIGURATION_Handle* cfg) | 832 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
779 | { | 833 | { |
780 | GNUNET_assert((message) && (buffer) && (hash) && (cfg)); | 834 | GNUNET_assert ((message) && (buffer) && (hash) && (cfg)); |
781 | 835 | ||
782 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n", | 836 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n", |
783 | GNUNET_h2s (hash)); | 837 | GNUNET_h2s (hash)); |
@@ -787,21 +841,24 @@ sign_message_by_peer (struct GNUNET_MESSENGER_Message *message, | |||
787 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 841 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
788 | signature.purpose.size = htonl (sizeof(signature)); | 842 | signature.purpose.size = htonl (sizeof(signature)); |
789 | 843 | ||
790 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 844 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
791 | GNUNET_CRYPTO_sign_by_peer_identity(cfg, &signature.purpose, &(message->header.signature.eddsa_signature)); | 845 | GNUNET_CRYPTO_sign_by_peer_identity (cfg, &signature.purpose, |
846 | &(message->header.signature. | ||
847 | eddsa_signature)); | ||
792 | 848 | ||
793 | message->header.signature.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA); | 849 | message->header.signature.type = htonl (GNUNET_IDENTITY_TYPE_EDDSA); |
794 | 850 | ||
795 | uint16_t offset = 0; | 851 | uint16_t offset = 0; |
796 | encode_step_signature(buffer, offset, &(message->header.signature), length); | 852 | encode_step_signature (buffer, offset, &(message->header.signature), length); |
797 | } | 853 | } |
798 | 854 | ||
855 | |||
799 | int | 856 | int |
800 | verify_message (const struct GNUNET_MESSENGER_Message *message, | 857 | verify_message (const struct GNUNET_MESSENGER_Message *message, |
801 | const struct GNUNET_HashCode *hash, | 858 | const struct GNUNET_HashCode *hash, |
802 | const struct GNUNET_IDENTITY_PublicKey *key) | 859 | const struct GNUNET_IDENTITY_PublicKey *key) |
803 | { | 860 | { |
804 | GNUNET_assert((message) && (hash) && (key)); | 861 | GNUNET_assert ((message) && (hash) && (key)); |
805 | 862 | ||
806 | if (key->type != message->header.signature.type) | 863 | if (key->type != message->header.signature.type) |
807 | return GNUNET_SYSERR; | 864 | return GNUNET_SYSERR; |
@@ -811,18 +868,20 @@ verify_message (const struct GNUNET_MESSENGER_Message *message, | |||
811 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 868 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
812 | signature.purpose.size = htonl (sizeof(signature)); | 869 | signature.purpose.size = htonl (sizeof(signature)); |
813 | 870 | ||
814 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 871 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
815 | 872 | ||
816 | return GNUNET_IDENTITY_signature_verify (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature, | 873 | return GNUNET_IDENTITY_signature_verify ( |
817 | &(message->header.signature), key); | 874 | GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature, |
875 | &(message->header.signature), key); | ||
818 | } | 876 | } |
819 | 877 | ||
878 | |||
820 | int | 879 | int |
821 | verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message, | 880 | verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message, |
822 | const struct GNUNET_HashCode *hash, | 881 | const struct GNUNET_HashCode *hash, |
823 | const struct GNUNET_PeerIdentity *identity) | 882 | const struct GNUNET_PeerIdentity *identity) |
824 | { | 883 | { |
825 | GNUNET_assert((message) && (hash) && (identity)); | 884 | GNUNET_assert ((message) && (hash) && (identity)); |
826 | 885 | ||
827 | if (ntohl (GNUNET_IDENTITY_TYPE_EDDSA) != message->header.signature.type) | 886 | if (ntohl (GNUNET_IDENTITY_TYPE_EDDSA) != message->header.signature.type) |
828 | return GNUNET_SYSERR; | 887 | return GNUNET_SYSERR; |
@@ -832,19 +891,22 @@ verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message, | |||
832 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); | 891 | signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE); |
833 | signature.purpose.size = htonl (sizeof(signature)); | 892 | signature.purpose.size = htonl (sizeof(signature)); |
834 | 893 | ||
835 | GNUNET_memcpy(&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); | 894 | GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode)); |
836 | 895 | ||
837 | return GNUNET_CRYPTO_verify_peer_identity (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature.purpose, | 896 | return GNUNET_CRYPTO_verify_peer_identity ( |
838 | &(message->header.signature.eddsa_signature), identity); | 897 | GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature.purpose, |
898 | &(message->header.signature. | ||
899 | eddsa_signature), identity); | ||
839 | } | 900 | } |
840 | 901 | ||
902 | |||
841 | int | 903 | int |
842 | encrypt_message (struct GNUNET_MESSENGER_Message *message, | 904 | encrypt_message (struct GNUNET_MESSENGER_Message *message, |
843 | const struct GNUNET_IDENTITY_PublicKey *key) | 905 | const struct GNUNET_IDENTITY_PublicKey *key) |
844 | { | 906 | { |
845 | GNUNET_assert((message) && (key)); | 907 | GNUNET_assert ((message) && (key)); |
846 | 908 | ||
847 | if (GNUNET_YES == is_service_message(message)) | 909 | if (GNUNET_YES == is_service_message (message)) |
848 | return GNUNET_NO; | 910 | return GNUNET_NO; |
849 | 911 | ||
850 | struct GNUNET_MESSENGER_ShortMessage shortened; | 912 | struct GNUNET_MESSENGER_ShortMessage shortened; |
@@ -854,7 +916,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
854 | const uint16_t length = get_short_message_size (&shortened, GNUNET_YES); | 916 | const uint16_t length = get_short_message_size (&shortened, GNUNET_YES); |
855 | const uint16_t padded_length = calc_padded_length ( | 917 | const uint16_t padded_length = calc_padded_length ( |
856 | length + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES | 918 | length + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES |
857 | ); | 919 | ); |
858 | 920 | ||
859 | message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE; | 921 | message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE; |
860 | message->body.privacy.data = GNUNET_malloc (padded_length); | 922 | message->body.privacy.data = GNUNET_malloc (padded_length); |
@@ -862,7 +924,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
862 | 924 | ||
863 | const uint16_t encoded_length = ( | 925 | const uint16_t encoded_length = ( |
864 | padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES | 926 | padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES |
865 | ); | 927 | ); |
866 | 928 | ||
867 | encode_short_message (&shortened, encoded_length, message->body.privacy.data); | 929 | encode_short_message (&shortened, encoded_length, message->body.privacy.data); |
868 | 930 | ||
@@ -882,6 +944,7 @@ encrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
882 | return GNUNET_YES; | 944 | return GNUNET_YES; |
883 | } | 945 | } |
884 | 946 | ||
947 | |||
885 | int | 948 | int |
886 | decrypt_message (struct GNUNET_MESSENGER_Message *message, | 949 | decrypt_message (struct GNUNET_MESSENGER_Message *message, |
887 | const struct GNUNET_IDENTITY_PrivateKey *key) | 950 | const struct GNUNET_IDENTITY_PrivateKey *key) |
@@ -900,7 +963,7 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
900 | 963 | ||
901 | const uint16_t encoded_length = ( | 964 | const uint16_t encoded_length = ( |
902 | padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES | 965 | padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES |
903 | ); | 966 | ); |
904 | 967 | ||
905 | if (GNUNET_OK != GNUNET_IDENTITY_decrypt (message->body.privacy.data, | 968 | if (GNUNET_OK != GNUNET_IDENTITY_decrypt (message->body.privacy.data, |
906 | padded_length, | 969 | padded_length, |
@@ -929,6 +992,7 @@ decrypt_message (struct GNUNET_MESSENGER_Message *message, | |||
929 | return GNUNET_YES; | 992 | return GNUNET_YES; |
930 | } | 993 | } |
931 | 994 | ||
995 | |||
932 | struct GNUNET_MQ_Envelope* | 996 | struct GNUNET_MQ_Envelope* |
933 | pack_message (struct GNUNET_MESSENGER_Message *message, | 997 | pack_message (struct GNUNET_MESSENGER_Message *message, |
934 | struct GNUNET_HashCode *hash, | 998 | struct GNUNET_HashCode *hash, |
@@ -936,22 +1000,24 @@ pack_message (struct GNUNET_MESSENGER_Message *message, | |||
936 | int mode, | 1000 | int mode, |
937 | const void *cls) | 1001 | const void *cls) |
938 | { | 1002 | { |
939 | GNUNET_assert(message); | 1003 | GNUNET_assert (message); |
940 | 1004 | ||
941 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Packing message kind=%u and sender: %s\n", | 1005 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
942 | message->header.kind, GNUNET_sh2s(&(message->header.sender_id))); | 1006 | "Packing message kind=%u and sender: %s\n", |
1007 | message->header.kind, GNUNET_sh2s (&(message->header.sender_id))); | ||
943 | 1008 | ||
944 | struct GNUNET_MessageHeader *header; | 1009 | struct GNUNET_MessageHeader *header; |
945 | 1010 | ||
946 | const uint16_t length = get_message_size (message, GNUNET_YES); | 1011 | const uint16_t length = get_message_size (message, GNUNET_YES); |
947 | const uint16_t padded_length = calc_padded_length(length); | 1012 | const uint16_t padded_length = calc_padded_length (length); |
948 | 1013 | ||
949 | struct GNUNET_MQ_Envelope *env; | 1014 | struct GNUNET_MQ_Envelope *env; |
950 | char *buffer; | 1015 | char *buffer; |
951 | 1016 | ||
952 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode) | 1017 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode) |
953 | { | 1018 | { |
954 | env = GNUNET_MQ_msg_extra(header, padded_length, GNUNET_MESSAGE_TYPE_CADET_CLI); | 1019 | env = GNUNET_MQ_msg_extra (header, padded_length, |
1020 | GNUNET_MESSAGE_TYPE_CADET_CLI); | ||
955 | 1021 | ||
956 | buffer = (char*) &(header[1]); | 1022 | buffer = (char*) &(header[1]); |
957 | } | 1023 | } |
@@ -959,7 +1025,7 @@ pack_message (struct GNUNET_MESSENGER_Message *message, | |||
959 | { | 1025 | { |
960 | env = NULL; | 1026 | env = NULL; |
961 | 1027 | ||
962 | buffer = GNUNET_malloc(padded_length); | 1028 | buffer = GNUNET_malloc (padded_length); |
963 | } | 1029 | } |
964 | 1030 | ||
965 | encode_message (message, padded_length, buffer, GNUNET_YES); | 1031 | encode_message (message, padded_length, buffer, GNUNET_YES); |
@@ -973,11 +1039,12 @@ pack_message (struct GNUNET_MESSENGER_Message *message, | |||
973 | } | 1039 | } |
974 | 1040 | ||
975 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode) | 1041 | if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode) |
976 | GNUNET_free(buffer); | 1042 | GNUNET_free (buffer); |
977 | 1043 | ||
978 | return env; | 1044 | return env; |
979 | } | 1045 | } |
980 | 1046 | ||
1047 | |||
981 | int | 1048 | int |
982 | is_peer_message (const struct GNUNET_MESSENGER_Message *message) | 1049 | is_peer_message (const struct GNUNET_MESSENGER_Message *message) |
983 | { | 1050 | { |
@@ -993,10 +1060,11 @@ is_peer_message (const struct GNUNET_MESSENGER_Message *message) | |||
993 | } | 1060 | } |
994 | } | 1061 | } |
995 | 1062 | ||
1063 | |||
996 | int | 1064 | int |
997 | is_service_message (const struct GNUNET_MESSENGER_Message *message) | 1065 | is_service_message (const struct GNUNET_MESSENGER_Message *message) |
998 | { | 1066 | { |
999 | if (GNUNET_YES == is_peer_message(message)) | 1067 | if (GNUNET_YES == is_peer_message (message)) |
1000 | return GNUNET_YES; | 1068 | return GNUNET_YES; |
1001 | 1069 | ||
1002 | switch (message->header.kind) | 1070 | switch (message->header.kind) |
@@ -1036,10 +1104,11 @@ is_service_message (const struct GNUNET_MESSENGER_Message *message) | |||
1036 | } | 1104 | } |
1037 | } | 1105 | } |
1038 | 1106 | ||
1107 | |||
1039 | int | 1108 | int |
1040 | filter_message_sending (const struct GNUNET_MESSENGER_Message *message) | 1109 | filter_message_sending (const struct GNUNET_MESSENGER_Message *message) |
1041 | { | 1110 | { |
1042 | if (GNUNET_YES == is_peer_message(message)) | 1111 | if (GNUNET_YES == is_peer_message (message)) |
1043 | return GNUNET_SYSERR; // Requires signature of peer rather than ego! | 1112 | return GNUNET_SYSERR; // Requires signature of peer rather than ego! |
1044 | 1113 | ||
1045 | switch (message->header.kind) | 1114 | switch (message->header.kind) |