diff options
40 files changed, 1703 insertions, 574 deletions
diff --git a/src/conversation/conversation.h b/src/conversation/conversation.h index d244f5163..ee4ca372c 100644 --- a/src/conversation/conversation.h +++ b/src/conversation/conversation.h | |||
@@ -105,9 +105,13 @@ struct ClientPhoneRingMessage | |||
105 | uint32_t cid GNUNET_PACKED; | 105 | uint32_t cid GNUNET_PACKED; |
106 | 106 | ||
107 | /** | 107 | /** |
108 | * Who is calling us? | 108 | * The identity key length |
109 | */ | ||
110 | uint32_t key_len; | ||
111 | |||
112 | /** | ||
113 | * followed by who is calling us?, a public key | ||
109 | */ | 114 | */ |
110 | struct GNUNET_IDENTITY_PublicKey caller_id; | ||
111 | }; | 115 | }; |
112 | 116 | ||
113 | 117 | ||
@@ -230,9 +234,13 @@ struct ClientCallMessage | |||
230 | struct GNUNET_HashCode line_port; | 234 | struct GNUNET_HashCode line_port; |
231 | 235 | ||
232 | /** | 236 | /** |
233 | * Identity of the caller. | 237 | * The identity key length |
238 | */ | ||
239 | uint32_t key_len; | ||
240 | |||
241 | /** | ||
242 | * followed by the identity of the caller. | ||
234 | */ | 243 | */ |
235 | struct GNUNET_IDENTITY_PrivateKey caller_id; | ||
236 | }; | 244 | }; |
237 | 245 | ||
238 | 246 | ||
@@ -301,19 +309,24 @@ struct CadetPhoneRingMessage | |||
301 | uint32_t reserved GNUNET_PACKED; | 309 | uint32_t reserved GNUNET_PACKED; |
302 | 310 | ||
303 | /** | 311 | /** |
304 | * Who is calling us? (also who is signing). | 312 | * When does the signature expire? |
305 | */ | 313 | */ |
306 | struct GNUNET_IDENTITY_PublicKey caller_id; | 314 | struct GNUNET_TIME_AbsoluteNBO expiration_time; |
307 | 315 | ||
308 | /** | 316 | /** |
309 | * When does the signature expire? | 317 | * The length of the key |
310 | */ | 318 | */ |
311 | struct GNUNET_TIME_AbsoluteNBO expiration_time; | 319 | uint32_t key_len; |
320 | |||
321 | /** | ||
322 | * The length of the signature | ||
323 | */ | ||
324 | uint32_t sig_len; | ||
312 | 325 | ||
313 | /** | 326 | /** |
314 | * Signature over a `struct CadetPhoneRingInfoPS` | 327 | * Followed by the public key of who is calling us? (also who is signing). |
328 | * followed by the signature over a `struct CadetPhoneRingInfoPS` | ||
315 | */ | 329 | */ |
316 | struct GNUNET_IDENTITY_Signature signature; | ||
317 | }; | 330 | }; |
318 | 331 | ||
319 | 332 | ||
diff --git a/src/conversation/conversation_api.c b/src/conversation/conversation_api.c index 2ede33586..9c4c520be 100644 --- a/src/conversation/conversation_api.c +++ b/src/conversation/conversation_api.c | |||
@@ -238,7 +238,19 @@ transmit_phone_audio (void *cls, | |||
238 | e); | 238 | e); |
239 | } | 239 | } |
240 | 240 | ||
241 | 241 | /** | |
242 | * We received a `struct ClientPhoneRingMessage` | ||
243 | * | ||
244 | * @param cls the `struct GNUNET_CONVERSATION_Phone` | ||
245 | * @param ring the message | ||
246 | */ | ||
247 | static enum GNUNET_GenericReturnValue | ||
248 | check_phone_ring (void *cls, | ||
249 | const struct ClientPhoneRingMessage *ring) | ||
250 | { | ||
251 | //FIXME | ||
252 | return GNUNET_OK; | ||
253 | } | ||
242 | /** | 254 | /** |
243 | * We received a `struct ClientPhoneRingMessage` | 255 | * We received a `struct ClientPhoneRingMessage` |
244 | * | 256 | * |
@@ -251,7 +263,11 @@ handle_phone_ring (void *cls, | |||
251 | { | 263 | { |
252 | struct GNUNET_CONVERSATION_Phone *phone = cls; | 264 | struct GNUNET_CONVERSATION_Phone *phone = cls; |
253 | struct GNUNET_CONVERSATION_Caller *caller; | 265 | struct GNUNET_CONVERSATION_Caller *caller; |
266 | struct GNUNET_IDENTITY_PublicKey caller_id; | ||
267 | size_t key_len; | ||
268 | size_t read; | ||
254 | 269 | ||
270 | key_len = ntohl (ring->key_len); | ||
255 | switch (phone->state) | 271 | switch (phone->state) |
256 | { | 272 | { |
257 | case PS_REGISTER: | 273 | case PS_REGISTER: |
@@ -259,12 +275,22 @@ handle_phone_ring (void *cls, | |||
259 | break; | 275 | break; |
260 | 276 | ||
261 | case PS_READY: | 277 | case PS_READY: |
278 | if ((GNUNET_SYSERR == | ||
279 | GNUNET_IDENTITY_read_public_key_from_buffer (&ring[1], | ||
280 | key_len, | ||
281 | &caller_id, | ||
282 | &read)) || | ||
283 | (read != key_len)) | ||
284 | { | ||
285 | GNUNET_break (0); | ||
286 | break; | ||
287 | } | ||
262 | caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller); | 288 | caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller); |
263 | caller->phone = phone; | 289 | caller->phone = phone; |
264 | GNUNET_CONTAINER_DLL_insert (phone->caller_head, | 290 | GNUNET_CONTAINER_DLL_insert (phone->caller_head, |
265 | phone->caller_tail, | 291 | phone->caller_tail, |
266 | caller); | 292 | caller); |
267 | caller->caller_id = ring->caller_id; | 293 | caller->caller_id = caller_id; |
268 | caller->cid = ring->cid; | 294 | caller->cid = ring->cid; |
269 | caller->state = CS_RINGING; | 295 | caller->state = CS_RINGING; |
270 | phone->event_handler (phone->event_handler_cls, | 296 | phone->event_handler (phone->event_handler_cls, |
@@ -562,10 +588,10 @@ static void | |||
562 | reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone) | 588 | reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone) |
563 | { | 589 | { |
564 | struct GNUNET_MQ_MessageHandler handlers[] = { | 590 | struct GNUNET_MQ_MessageHandler handlers[] = { |
565 | GNUNET_MQ_hd_fixed_size (phone_ring, | 591 | GNUNET_MQ_hd_var_size (phone_ring, |
566 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, | 592 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING, |
567 | struct ClientPhoneRingMessage, | 593 | struct ClientPhoneRingMessage, |
568 | phone), | 594 | phone), |
569 | GNUNET_MQ_hd_fixed_size (phone_hangup, | 595 | GNUNET_MQ_hd_fixed_size (phone_hangup, |
570 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | 596 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, |
571 | struct ClientPhoneHangupMessage, | 597 | struct ClientPhoneHangupMessage, |
diff --git a/src/conversation/conversation_api_call.c b/src/conversation/conversation_api_call.c index 909b603ac..129192bf0 100644 --- a/src/conversation/conversation_api_call.c +++ b/src/conversation/conversation_api_call.c | |||
@@ -455,6 +455,8 @@ handle_gns_response (void *cls, | |||
455 | struct GNUNET_CONVERSATION_Call *call = cls; | 455 | struct GNUNET_CONVERSATION_Call *call = cls; |
456 | struct GNUNET_MQ_Envelope *e; | 456 | struct GNUNET_MQ_Envelope *e; |
457 | struct ClientCallMessage *ccm; | 457 | struct ClientCallMessage *ccm; |
458 | const struct GNUNET_IDENTITY_PrivateKey *caller_id; | ||
459 | size_t key_len; | ||
458 | 460 | ||
459 | (void) was_gns; | 461 | (void) was_gns; |
460 | GNUNET_break (NULL != call->gns_lookup); | 462 | GNUNET_break (NULL != call->gns_lookup); |
@@ -472,11 +474,15 @@ handle_gns_response (void *cls, | |||
472 | GNUNET_memcpy (&call->phone_record, | 474 | GNUNET_memcpy (&call->phone_record, |
473 | rd[i].data, | 475 | rd[i].data, |
474 | rd[i].data_size); | 476 | rd[i].data_size); |
475 | e = GNUNET_MQ_msg (ccm, | 477 | caller_id = GNUNET_IDENTITY_ego_get_private_key (call->caller_id); |
476 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL); | 478 | key_len = GNUNET_IDENTITY_private_key_get_length (caller_id); |
479 | e = GNUNET_MQ_msg_extra (ccm, key_len, | ||
480 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL); | ||
477 | ccm->line_port = call->phone_record.line_port; | 481 | ccm->line_port = call->phone_record.line_port; |
478 | ccm->target = call->phone_record.peer; | 482 | ccm->target = call->phone_record.peer; |
479 | ccm->caller_id = *GNUNET_IDENTITY_ego_get_private_key (call->caller_id); | 483 | GNUNET_IDENTITY_write_private_key_to_buffer (caller_id, |
484 | &ccm[1], key_len); | ||
485 | ccm->key_len = htonl (key_len); | ||
480 | GNUNET_MQ_send (call->mq, | 486 | GNUNET_MQ_send (call->mq, |
481 | e); | 487 | e); |
482 | call->state = CS_RINGING; | 488 | call->state = CS_RINGING; |
diff --git a/src/conversation/gnunet-service-conversation.c b/src/conversation/gnunet-service-conversation.c index a69c95a80..a551bed1a 100644 --- a/src/conversation/gnunet-service-conversation.c +++ b/src/conversation/gnunet-service-conversation.c | |||
@@ -729,6 +729,18 @@ handle_client_audio_message (void *cls, const struct ClientAudioMessage *msg) | |||
729 | GNUNET_SERVICE_client_continue (line->client); | 729 | GNUNET_SERVICE_client_continue (line->client); |
730 | } | 730 | } |
731 | 731 | ||
732 | /** | ||
733 | * Function to handle a ring message incoming over cadet | ||
734 | * | ||
735 | * @param cls closure, NULL | ||
736 | * @param msg the incoming message | ||
737 | */ | ||
738 | static enum GNUNET_GenericReturnValue | ||
739 | check_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg) | ||
740 | { | ||
741 | //FIXME | ||
742 | return GNUNET_OK; | ||
743 | } | ||
732 | 744 | ||
733 | /** | 745 | /** |
734 | * Function to handle a ring message incoming over cadet | 746 | * Function to handle a ring message incoming over cadet |
@@ -744,19 +756,40 @@ handle_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg) | |||
744 | struct GNUNET_MQ_Envelope *env; | 756 | struct GNUNET_MQ_Envelope *env; |
745 | struct ClientPhoneRingMessage *cring; | 757 | struct ClientPhoneRingMessage *cring; |
746 | struct CadetPhoneRingInfoPS rs; | 758 | struct CadetPhoneRingInfoPS rs; |
759 | struct GNUNET_IDENTITY_PublicKey identity; | ||
760 | struct GNUNET_IDENTITY_Signature sig; | ||
761 | size_t key_len; | ||
762 | size_t sig_len; | ||
763 | size_t read; | ||
747 | 764 | ||
748 | rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING); | 765 | rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING); |
749 | rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS)); | 766 | rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS)); |
750 | rs.line_port = line->line_port; | 767 | rs.line_port = line->line_port; |
751 | rs.target_peer = my_identity; | 768 | rs.target_peer = my_identity; |
752 | rs.expiration_time = msg->expiration_time; | 769 | rs.expiration_time = msg->expiration_time; |
753 | 770 | key_len = ntohl (msg->key_len); | |
771 | sig_len = ntohl (msg->sig_len); | ||
772 | |||
773 | if ((GNUNET_SYSERR == | ||
774 | GNUNET_IDENTITY_read_public_key_from_buffer (&msg[1], | ||
775 | key_len, | ||
776 | &identity, | ||
777 | &read)) || | ||
778 | (read != key_len)) | ||
779 | { | ||
780 | GNUNET_break_op (0); | ||
781 | destroy_line_cadet_channels (ch); | ||
782 | return; | ||
783 | } | ||
784 | GNUNET_IDENTITY_read_signature_from_buffer (&sig, | ||
785 | (char*) &msg[1] + read, | ||
786 | sig_len); | ||
754 | if (GNUNET_OK != | 787 | if (GNUNET_OK != |
755 | GNUNET_IDENTITY_signature_verify ( | 788 | GNUNET_IDENTITY_signature_verify ( |
756 | GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, | 789 | GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING, |
757 | &rs, | 790 | &rs, |
758 | &msg->signature, | 791 | &sig, |
759 | &msg->caller_id)) | 792 | &identity)) |
760 | { | 793 | { |
761 | GNUNET_break_op (0); | 794 | GNUNET_break_op (0); |
762 | destroy_line_cadet_channels (ch); | 795 | destroy_line_cadet_channels (ch); |
@@ -782,9 +815,12 @@ handle_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg) | |||
782 | } | 815 | } |
783 | GNUNET_CADET_receive_done (ch->channel); | 816 | GNUNET_CADET_receive_done (ch->channel); |
784 | ch->status = CS_CALLEE_RINGING; | 817 | ch->status = CS_CALLEE_RINGING; |
785 | env = GNUNET_MQ_msg (cring, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING); | 818 | env = GNUNET_MQ_msg_extra (cring, |
819 | key_len, | ||
820 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING); | ||
786 | cring->cid = ch->cid; | 821 | cring->cid = ch->cid; |
787 | cring->caller_id = msg->caller_id; | 822 | memcpy (&cring[1], &msg[1], key_len); |
823 | cring->key_len = msg->key_len; | ||
788 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 824 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
789 | "Sending RING message to client. CID is %u\n", | 825 | "Sending RING message to client. CID is %u\n", |
790 | (unsigned int) ch->cid); | 826 | (unsigned int) ch->cid); |
@@ -1080,6 +1116,18 @@ inbound_end (void *cls, const struct GNUNET_CADET_Channel *channel) | |||
1080 | clean_up_channel (ch); | 1116 | clean_up_channel (ch); |
1081 | } | 1117 | } |
1082 | 1118 | ||
1119 | /** | ||
1120 | * Function to handle call request from the client | ||
1121 | * | ||
1122 | * @param cls the `struct Line` the message is about | ||
1123 | * @param msg the message from the client | ||
1124 | */ | ||
1125 | static enum GNUNET_GenericReturnValue | ||
1126 | check_client_call_message (void *cls, const struct ClientCallMessage *msg) | ||
1127 | { | ||
1128 | // FIXME | ||
1129 | return GNUNET_OK; | ||
1130 | } | ||
1083 | 1131 | ||
1084 | /** | 1132 | /** |
1085 | * Function to handle call request from the client | 1133 | * Function to handle call request from the client |
@@ -1117,6 +1165,14 @@ handle_client_call_message (void *cls, const struct ClientCallMessage *msg) | |||
1117 | struct GNUNET_MQ_Envelope *e; | 1165 | struct GNUNET_MQ_Envelope *e; |
1118 | struct CadetPhoneRingMessage *ring; | 1166 | struct CadetPhoneRingMessage *ring; |
1119 | struct CadetPhoneRingInfoPS rs; | 1167 | struct CadetPhoneRingInfoPS rs; |
1168 | struct GNUNET_IDENTITY_PrivateKey caller_id; | ||
1169 | struct GNUNET_IDENTITY_PublicKey caller_id_pub; | ||
1170 | struct GNUNET_IDENTITY_Signature sig; | ||
1171 | ssize_t written; | ||
1172 | size_t key_len; | ||
1173 | size_t pkey_len; | ||
1174 | size_t sig_len; | ||
1175 | size_t read; | ||
1120 | 1176 | ||
1121 | line->line_port = msg->line_port; | 1177 | line->line_port = msg->line_port; |
1122 | rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING); | 1178 | rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING); |
@@ -1136,10 +1192,27 @@ handle_client_call_message (void *cls, const struct ClientCallMessage *msg) | |||
1136 | &inbound_end, | 1192 | &inbound_end, |
1137 | cadet_handlers); | 1193 | cadet_handlers); |
1138 | ch->mq = GNUNET_CADET_get_mq (ch->channel); | 1194 | ch->mq = GNUNET_CADET_get_mq (ch->channel); |
1139 | e = GNUNET_MQ_msg (ring, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING); | 1195 | key_len = ntohl (msg->key_len); |
1140 | GNUNET_IDENTITY_key_get_public (&msg->caller_id, &ring->caller_id); | 1196 | GNUNET_IDENTITY_read_private_key_from_buffer (&msg[1], |
1197 | key_len, | ||
1198 | &caller_id, | ||
1199 | &read); | ||
1200 | GNUNET_assert (read == key_len); | ||
1201 | GNUNET_IDENTITY_sign (&caller_id, &rs, &sig); | ||
1202 | sig_len = GNUNET_IDENTITY_signature_get_length (&sig); | ||
1203 | GNUNET_IDENTITY_key_get_public (&caller_id, &caller_id_pub); | ||
1204 | pkey_len = GNUNET_IDENTITY_public_key_get_length (&caller_id_pub); | ||
1205 | e = GNUNET_MQ_msg_extra (ring, pkey_len + sig_len, | ||
1206 | GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING); | ||
1207 | written = GNUNET_IDENTITY_write_public_key_to_buffer (&caller_id_pub, | ||
1208 | &ring[1], | ||
1209 | pkey_len); | ||
1141 | ring->expiration_time = rs.expiration_time; | 1210 | ring->expiration_time = rs.expiration_time; |
1142 | GNUNET_IDENTITY_sign (&msg->caller_id, &rs, &ring->signature); | 1211 | ring->key_len = htonl (pkey_len); |
1212 | ring->sig_len = htonl (sig_len); | ||
1213 | GNUNET_IDENTITY_write_signature_to_buffer (&sig, | ||
1214 | (char *) &ring[1] + written, | ||
1215 | sig_len); | ||
1143 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n"); | 1216 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n"); |
1144 | GNUNET_MQ_send (ch->mq, e); | 1217 | GNUNET_MQ_send (ch->mq, e); |
1145 | GNUNET_SERVICE_client_continue (line->client); | 1218 | GNUNET_SERVICE_client_continue (line->client); |
@@ -1246,10 +1319,10 @@ handle_client_register_message (void *cls, | |||
1246 | { | 1319 | { |
1247 | struct Line *line = cls; | 1320 | struct Line *line = cls; |
1248 | struct GNUNET_MQ_MessageHandler cadet_handlers[] = | 1321 | struct GNUNET_MQ_MessageHandler cadet_handlers[] = |
1249 | { GNUNET_MQ_hd_fixed_size (cadet_ring_message, | 1322 | { GNUNET_MQ_hd_var_size (cadet_ring_message, |
1250 | GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING, | 1323 | GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING, |
1251 | struct CadetPhoneRingMessage, | 1324 | struct CadetPhoneRingMessage, |
1252 | NULL), | 1325 | NULL), |
1253 | GNUNET_MQ_hd_fixed_size (cadet_hangup_message, | 1326 | GNUNET_MQ_hd_fixed_size (cadet_hangup_message, |
1254 | GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP, | 1327 | GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP, |
1255 | struct CadetPhoneHangupMessage, | 1328 | struct CadetPhoneHangupMessage, |
@@ -1367,10 +1440,10 @@ GNUNET_SERVICE_MAIN ( | |||
1367 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, | 1440 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP, |
1368 | struct ClientPhoneHangupMessage, | 1441 | struct ClientPhoneHangupMessage, |
1369 | NULL), | 1442 | NULL), |
1370 | GNUNET_MQ_hd_fixed_size (client_call_message, | 1443 | GNUNET_MQ_hd_var_size (client_call_message, |
1371 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, | 1444 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL, |
1372 | struct ClientCallMessage, | 1445 | struct ClientCallMessage, |
1373 | NULL), | 1446 | NULL), |
1374 | GNUNET_MQ_hd_var_size (client_audio_message, | 1447 | GNUNET_MQ_hd_var_size (client_audio_message, |
1375 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, | 1448 | GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO, |
1376 | struct ClientAudioMessage, | 1449 | struct ClientAudioMessage, |
diff --git a/src/conversation/test_conversation_api.c b/src/conversation/test_conversation_api.c index 41ef75821..22e9b1dd9 100644 --- a/src/conversation/test_conversation_api.c +++ b/src/conversation/test_conversation_api.c | |||
@@ -386,21 +386,20 @@ call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code) | |||
386 | static void | 386 | static void |
387 | caller_ego_create_cont (void *cls, | 387 | caller_ego_create_cont (void *cls, |
388 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 388 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
389 | const char *emsg) | 389 | enum GNUNET_ErrorCode ec) |
390 | { | 390 | { |
391 | (void) cls; | 391 | (void) cls; |
392 | op = NULL; | 392 | op = NULL; |
393 | GNUNET_assert (NULL == emsg); | 393 | GNUNET_assert (GNUNET_EC_NONE == ec); |
394 | } | 394 | } |
395 | 395 | ||
396 | 396 | ||
397 | static void | 397 | static void |
398 | namestore_put_cont (void *cls, int32_t success, const char *emsg) | 398 | namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec) |
399 | { | 399 | { |
400 | (void) cls; | 400 | (void) cls; |
401 | qe = NULL; | 401 | qe = NULL; |
402 | GNUNET_assert (GNUNET_YES == success); | 402 | GNUNET_assert (GNUNET_EC_NONE == ec); |
403 | GNUNET_assert (NULL == emsg); | ||
404 | GNUNET_assert (NULL == op); | 403 | GNUNET_assert (NULL == op); |
405 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, | 404 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, |
406 | GNUNET_IDENTITY_TYPE_ECDSA, | 405 | GNUNET_IDENTITY_TYPE_ECDSA, |
@@ -468,11 +467,11 @@ identity_cb (void *cls, | |||
468 | static void | 467 | static void |
469 | phone_ego_create_cont (void *cls, | 468 | phone_ego_create_cont (void *cls, |
470 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 469 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
471 | const char *emsg) | 470 | enum GNUNET_ErrorCode ec) |
472 | { | 471 | { |
473 | (void) cls; | 472 | (void) cls; |
474 | op = NULL; | 473 | op = NULL; |
475 | GNUNET_assert (NULL == emsg); | 474 | GNUNET_assert (GNUNET_EC_NONE == ec); |
476 | } | 475 | } |
477 | 476 | ||
478 | 477 | ||
diff --git a/src/conversation/test_conversation_api_reject.c b/src/conversation/test_conversation_api_reject.c index 15728123b..a7aab069f 100644 --- a/src/conversation/test_conversation_api_reject.c +++ b/src/conversation/test_conversation_api_reject.c | |||
@@ -239,21 +239,20 @@ call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code) | |||
239 | static void | 239 | static void |
240 | caller_ego_create_cont (void *cls, | 240 | caller_ego_create_cont (void *cls, |
241 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 241 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
242 | const char *emsg) | 242 | enum GNUNET_ErrorCode ec) |
243 | { | 243 | { |
244 | (void) cls; | 244 | (void) cls; |
245 | op = NULL; | 245 | op = NULL; |
246 | GNUNET_assert (NULL == emsg); | 246 | GNUNET_assert (GNUNET_EC_NONE == ec); |
247 | } | 247 | } |
248 | 248 | ||
249 | 249 | ||
250 | static void | 250 | static void |
251 | namestore_put_cont (void *cls, int32_t success, const char *emsg) | 251 | namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec) |
252 | { | 252 | { |
253 | (void) cls; | 253 | (void) cls; |
254 | qe = NULL; | 254 | qe = NULL; |
255 | GNUNET_assert (GNUNET_YES == success); | 255 | GNUNET_assert (GNUNET_EC_NONE == ec); |
256 | GNUNET_assert (NULL == emsg); | ||
257 | GNUNET_assert (NULL == op); | 256 | GNUNET_assert (NULL == op); |
258 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, | 257 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, |
259 | GNUNET_IDENTITY_TYPE_ECDSA, | 258 | GNUNET_IDENTITY_TYPE_ECDSA, |
@@ -321,11 +320,11 @@ identity_cb (void *cls, | |||
321 | static void | 320 | static void |
322 | phone_ego_create_cont (void *cls, | 321 | phone_ego_create_cont (void *cls, |
323 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 322 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
324 | const char *emsg) | 323 | enum GNUNET_ErrorCode ec) |
325 | { | 324 | { |
326 | (void) cls; | 325 | (void) cls; |
327 | op = NULL; | 326 | op = NULL; |
328 | GNUNET_assert (NULL == emsg); | 327 | GNUNET_assert (GNUNET_EC_NONE == ec); |
329 | } | 328 | } |
330 | 329 | ||
331 | 330 | ||
diff --git a/src/conversation/test_conversation_api_twocalls.c b/src/conversation/test_conversation_api_twocalls.c index 9abf91d0b..1bd2b4e22 100644 --- a/src/conversation/test_conversation_api_twocalls.c +++ b/src/conversation/test_conversation_api_twocalls.c | |||
@@ -508,21 +508,20 @@ call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code) | |||
508 | static void | 508 | static void |
509 | caller_ego_create_cont (void *cls, | 509 | caller_ego_create_cont (void *cls, |
510 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 510 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
511 | const char *emsg) | 511 | enum GNUNET_ErrorCode ec) |
512 | { | 512 | { |
513 | (void) cls; | 513 | (void) cls; |
514 | op = NULL; | 514 | op = NULL; |
515 | GNUNET_assert (NULL == emsg); | 515 | GNUNET_assert (GNUNET_EC_NONE == ec); |
516 | } | 516 | } |
517 | 517 | ||
518 | 518 | ||
519 | static void | 519 | static void |
520 | namestore_put_cont (void *cls, int32_t success, const char *emsg) | 520 | namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec) |
521 | { | 521 | { |
522 | (void) cls; | 522 | (void) cls; |
523 | qe = NULL; | 523 | qe = NULL; |
524 | GNUNET_assert (GNUNET_YES == success); | 524 | GNUNET_assert (GNUNET_EC_NONE == ec); |
525 | GNUNET_assert (NULL == emsg); | ||
526 | GNUNET_assert (NULL == op); | 525 | GNUNET_assert (NULL == op); |
527 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, | 526 | op = GNUNET_IDENTITY_create (id, "caller-ego", NULL, |
528 | GNUNET_IDENTITY_TYPE_ECDSA, | 527 | GNUNET_IDENTITY_TYPE_ECDSA, |
@@ -597,11 +596,11 @@ identity_cb (void *cls, | |||
597 | static void | 596 | static void |
598 | phone_ego_create_cont (void *cls, | 597 | phone_ego_create_cont (void *cls, |
599 | const struct GNUNET_IDENTITY_PrivateKey *pk, | 598 | const struct GNUNET_IDENTITY_PrivateKey *pk, |
600 | const char *emsg) | 599 | enum GNUNET_ErrorCode ec) |
601 | { | 600 | { |
602 | (void) cls; | 601 | (void) cls; |
603 | op = NULL; | 602 | op = NULL; |
604 | GNUNET_assert (NULL == emsg); | 603 | GNUNET_assert (GNUNET_EC_NONE == ec); |
605 | } | 604 | } |
606 | 605 | ||
607 | 606 | ||
diff --git a/src/gns/plugin_gnsrecord_gns.c b/src/gns/plugin_gnsrecord_gns.c index 0ce782a43..296957f19 100644 --- a/src/gns/plugin_gnsrecord_gns.c +++ b/src/gns/plugin_gnsrecord_gns.c | |||
@@ -178,7 +178,7 @@ gns_string_to_value (void *cls, | |||
178 | s); | 178 | s); |
179 | return GNUNET_SYSERR; | 179 | return GNUNET_SYSERR; |
180 | } | 180 | } |
181 | *data_size = GNUNET_IDENTITY_key_get_length (&pk); | 181 | *data_size = GNUNET_IDENTITY_public_key_get_length (&pk); |
182 | if (GNUNET_OK != | 182 | if (GNUNET_OK != |
183 | GNUNET_GNSRECORD_data_from_identity (&pk, | 183 | GNUNET_GNSRECORD_data_from_identity (&pk, |
184 | (char **) data, | 184 | (char **) data, |
diff --git a/src/gnsrecord/gnsrecord_misc.c b/src/gnsrecord/gnsrecord_misc.c index 742eaf186..97ca7b135 100644 --- a/src/gnsrecord/gnsrecord_misc.c +++ b/src/gnsrecord/gnsrecord_misc.c | |||
@@ -304,7 +304,7 @@ GNUNET_GNSRECORD_data_from_identity (const struct | |||
304 | { | 304 | { |
305 | char *tmp; | 305 | char *tmp; |
306 | *type = ntohl (key->type); | 306 | *type = ntohl (key->type); |
307 | *data_size = GNUNET_IDENTITY_key_get_length (key) - sizeof (key->type); | 307 | *data_size = GNUNET_IDENTITY_public_key_get_length (key) - sizeof (key->type); |
308 | if (0 == *data_size) | 308 | if (0 == *data_size) |
309 | return GNUNET_SYSERR; | 309 | return GNUNET_SYSERR; |
310 | tmp = GNUNET_malloc (*data_size); | 310 | tmp = GNUNET_malloc (*data_size); |
diff --git a/src/gnsrecord/gnunet-gnsrecord-tvg.c b/src/gnsrecord/gnunet-gnsrecord-tvg.c index 4d5eb73b3..91abe1954 100644 --- a/src/gnsrecord/gnunet-gnsrecord-tvg.c +++ b/src/gnsrecord/gnunet-gnsrecord-tvg.c | |||
@@ -154,10 +154,10 @@ run_pkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char *label) | |||
154 | sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1); | 154 | sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey), 8, 1); |
155 | printf ("\n"); | 155 | printf ("\n"); |
156 | printf ("Zone identifier (ztype|zkey):\n"); | 156 | printf ("Zone identifier (ztype|zkey):\n"); |
157 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | 157 | GNUNET_assert (0 < GNUNET_IDENTITY_public_key_get_length (&id_pub)); |
158 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | 158 | print_bytes (&id_pub, GNUNET_IDENTITY_public_key_get_length (&id_pub), 8); |
159 | GNUNET_STRINGS_data_to_string (&id_pub, | 159 | GNUNET_STRINGS_data_to_string (&id_pub, |
160 | GNUNET_IDENTITY_key_get_length (&id_pub), | 160 | GNUNET_IDENTITY_public_key_get_length (&id_pub), |
161 | ztld, | 161 | ztld, |
162 | sizeof (ztld)); | 162 | sizeof (ztld)); |
163 | printf ("\n"); | 163 | printf ("\n"); |
@@ -280,10 +280,10 @@ run_edkey (struct GNUNET_GNSRECORD_Data *rd, int rd_count, const char*label) | |||
280 | GNUNET_CRYPTO_EddsaPrivateKey), 8); | 280 | GNUNET_CRYPTO_EddsaPrivateKey), 8); |
281 | printf ("\n"); | 281 | printf ("\n"); |
282 | printf ("Zone identifier (ztype|zkey):\n"); | 282 | printf ("Zone identifier (ztype|zkey):\n"); |
283 | GNUNET_assert (0 < GNUNET_IDENTITY_key_get_length (&id_pub)); | 283 | GNUNET_assert (0 < GNUNET_IDENTITY_public_key_get_length (&id_pub)); |
284 | print_bytes (&id_pub, GNUNET_IDENTITY_key_get_length (&id_pub), 8); | 284 | print_bytes (&id_pub, GNUNET_IDENTITY_public_key_get_length (&id_pub), 8); |
285 | GNUNET_STRINGS_data_to_string (&id_pub, | 285 | GNUNET_STRINGS_data_to_string (&id_pub, |
286 | GNUNET_IDENTITY_key_get_length (&id_pub), | 286 | GNUNET_IDENTITY_public_key_get_length (&id_pub), |
287 | ztld, | 287 | ztld, |
288 | sizeof (ztld)); | 288 | sizeof (ztld)); |
289 | printf ("\n"); | 289 | printf ("\n"); |
diff --git a/src/identity/Makefile.am b/src/identity/Makefile.am index 12d3906a8..be6bbf822 100644 --- a/src/identity/Makefile.am +++ b/src/identity/Makefile.am | |||
@@ -54,6 +54,7 @@ libexec_PROGRAMS = \ | |||
54 | gnunet_service_identity_SOURCES = \ | 54 | gnunet_service_identity_SOURCES = \ |
55 | gnunet-service-identity.c | 55 | gnunet-service-identity.c |
56 | gnunet_service_identity_LDADD = \ | 56 | gnunet_service_identity_LDADD = \ |
57 | libgnunetidentity.la \ | ||
57 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 58 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
58 | $(top_builddir)/src/util/libgnunetutil.la \ | 59 | $(top_builddir)/src/util/libgnunetutil.la \ |
59 | $(GN_LIBINTL) | 60 | $(GN_LIBINTL) |
diff --git a/src/identity/gnunet-service-identity.c b/src/identity/gnunet-service-identity.c index 5e3f7bb35..f1156e0b6 100644 --- a/src/identity/gnunet-service-identity.c +++ b/src/identity/gnunet-service-identity.c | |||
@@ -236,13 +236,18 @@ create_update_message (struct Ego *ego) | |||
236 | struct UpdateMessage *um; | 236 | struct UpdateMessage *um; |
237 | struct GNUNET_MQ_Envelope *env; | 237 | struct GNUNET_MQ_Envelope *env; |
238 | size_t name_len; | 238 | size_t name_len; |
239 | ssize_t key_len; | ||
239 | 240 | ||
241 | key_len = GNUNET_IDENTITY_private_key_get_length (&ego->pk); | ||
240 | name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1); | 242 | name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1); |
241 | env = GNUNET_MQ_msg_extra (um, name_len, GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE); | 243 | env = GNUNET_MQ_msg_extra (um, name_len + key_len, |
244 | GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE); | ||
242 | um->name_len = htons (name_len); | 245 | um->name_len = htons (name_len); |
243 | um->end_of_list = htons (GNUNET_NO); | 246 | um->end_of_list = htons (GNUNET_NO); |
244 | um->private_key = ego->pk; | ||
245 | GNUNET_memcpy (&um[1], ego->identifier, name_len); | 247 | GNUNET_memcpy (&um[1], ego->identifier, name_len); |
248 | GNUNET_IDENTITY_write_private_key_to_buffer (&ego->pk, | ||
249 | ((char*) &um[1]) + name_len, | ||
250 | key_len); | ||
246 | return env; | 251 | return env; |
247 | } | 252 | } |
248 | 253 | ||
@@ -412,15 +417,19 @@ notify_listeners (struct Ego *ego) | |||
412 | { | 417 | { |
413 | struct UpdateMessage *um; | 418 | struct UpdateMessage *um; |
414 | size_t name_len; | 419 | size_t name_len; |
420 | ssize_t key_len; | ||
415 | 421 | ||
416 | name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1); | 422 | name_len = (NULL == ego->identifier) ? 0 : (strlen (ego->identifier) + 1); |
417 | um = GNUNET_malloc (sizeof(struct UpdateMessage) + name_len); | 423 | key_len = GNUNET_IDENTITY_private_key_get_length (&ego->pk); |
424 | um = GNUNET_malloc (sizeof(struct UpdateMessage) + name_len + key_len); | ||
418 | um->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE); | 425 | um->header.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE); |
419 | um->header.size = htons (sizeof(struct UpdateMessage) + name_len); | 426 | um->header.size = htons (sizeof(struct UpdateMessage) + name_len + key_len); |
420 | um->name_len = htons (name_len); | 427 | um->name_len = htons (name_len); |
421 | um->end_of_list = htons (GNUNET_NO); | 428 | um->end_of_list = htons (GNUNET_NO); |
422 | um->private_key = ego->pk; | ||
423 | GNUNET_memcpy (&um[1], ego->identifier, name_len); | 429 | GNUNET_memcpy (&um[1], ego->identifier, name_len); |
430 | GNUNET_IDENTITY_write_private_key_to_buffer (&ego->pk, | ||
431 | ((char*) &um[1]) + name_len, | ||
432 | key_len); | ||
424 | GNUNET_notification_context_broadcast (nc, &um->header, GNUNET_NO); | 433 | GNUNET_notification_context_broadcast (nc, &um->header, GNUNET_NO); |
425 | GNUNET_free (um); | 434 | GNUNET_free (um); |
426 | } | 435 | } |
@@ -439,6 +448,7 @@ check_create_message (void *cls, | |||
439 | { | 448 | { |
440 | uint16_t size; | 449 | uint16_t size; |
441 | uint16_t name_len; | 450 | uint16_t name_len; |
451 | size_t key_len; | ||
442 | const char *str; | 452 | const char *str; |
443 | 453 | ||
444 | size = ntohs (msg->header.size); | 454 | size = ntohs (msg->header.size); |
@@ -448,13 +458,14 @@ check_create_message (void *cls, | |||
448 | return GNUNET_SYSERR; | 458 | return GNUNET_SYSERR; |
449 | } | 459 | } |
450 | name_len = ntohs (msg->name_len); | 460 | name_len = ntohs (msg->name_len); |
461 | key_len = ntohl (msg->key_len); | ||
451 | GNUNET_break (0 == ntohs (msg->reserved)); | 462 | GNUNET_break (0 == ntohs (msg->reserved)); |
452 | if (name_len + sizeof(struct CreateRequestMessage) != size) | 463 | if (name_len + key_len + sizeof(struct CreateRequestMessage) != size) |
453 | { | 464 | { |
454 | GNUNET_break (0); | 465 | GNUNET_break (0); |
455 | return GNUNET_SYSERR; | 466 | return GNUNET_SYSERR; |
456 | } | 467 | } |
457 | str = (const char *) &msg[1]; | 468 | str = (const char *) &msg[1] + key_len; |
458 | if ('\0' != str[name_len - 1]) | 469 | if ('\0' != str[name_len - 1]) |
459 | { | 470 | { |
460 | GNUNET_break (0); | 471 | GNUNET_break (0); |
@@ -474,14 +485,28 @@ static void | |||
474 | handle_create_message (void *cls, | 485 | handle_create_message (void *cls, |
475 | const struct CreateRequestMessage *crm) | 486 | const struct CreateRequestMessage *crm) |
476 | { | 487 | { |
488 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
477 | struct GNUNET_SERVICE_Client *client = cls; | 489 | struct GNUNET_SERVICE_Client *client = cls; |
478 | struct Ego *ego; | 490 | struct Ego *ego; |
479 | char *str; | 491 | char *str; |
480 | char *fn; | 492 | char *fn; |
493 | size_t key_len; | ||
494 | size_t kb_read; | ||
481 | 495 | ||
482 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREATE message from client\n"); | 496 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREATE message from client\n"); |
483 | str = GNUNET_strdup ((const char *) &crm[1]); | 497 | key_len = ntohl (crm->key_len); |
484 | GNUNET_STRINGS_utf8_tolower ((const char *) &crm[1], str); | 498 | if ((GNUNET_SYSERR == |
499 | GNUNET_IDENTITY_read_private_key_from_buffer (&crm[1], | ||
500 | key_len, | ||
501 | &private_key, | ||
502 | &kb_read)) || | ||
503 | (kb_read != key_len)) | ||
504 | { | ||
505 | GNUNET_SERVICE_client_drop (client); | ||
506 | return; | ||
507 | } | ||
508 | str = GNUNET_strdup ((const char *) &crm[1] + key_len); | ||
509 | GNUNET_STRINGS_utf8_tolower ((const char *) &crm[1] + key_len, str); | ||
485 | for (ego = ego_head; NULL != ego; ego = ego->next) | 510 | for (ego = ego_head; NULL != ego; ego = ego->next) |
486 | { | 511 | { |
487 | if (0 == strcmp (ego->identifier, str)) | 512 | if (0 == strcmp (ego->identifier, str)) |
@@ -494,7 +519,7 @@ handle_create_message (void *cls, | |||
494 | } | 519 | } |
495 | } | 520 | } |
496 | ego = GNUNET_new (struct Ego); | 521 | ego = GNUNET_new (struct Ego); |
497 | ego->pk = crm->private_key; | 522 | ego->pk = private_key; |
498 | ego->identifier = GNUNET_strdup (str); | 523 | ego->identifier = GNUNET_strdup (str); |
499 | GNUNET_CONTAINER_DLL_insert (ego_head, | 524 | GNUNET_CONTAINER_DLL_insert (ego_head, |
500 | ego_tail, | 525 | ego_tail, |
@@ -503,7 +528,7 @@ handle_create_message (void *cls, | |||
503 | fn = get_ego_filename (ego); | 528 | fn = get_ego_filename (ego); |
504 | if (GNUNET_OK != | 529 | if (GNUNET_OK != |
505 | GNUNET_DISK_fn_write (fn, | 530 | GNUNET_DISK_fn_write (fn, |
506 | &crm->private_key, | 531 | &private_key, |
507 | sizeof(struct GNUNET_IDENTITY_PrivateKey), | 532 | sizeof(struct GNUNET_IDENTITY_PrivateKey), |
508 | GNUNET_DISK_PERM_USER_READ | 533 | GNUNET_DISK_PERM_USER_READ |
509 | | GNUNET_DISK_PERM_USER_WRITE)) | 534 | | GNUNET_DISK_PERM_USER_WRITE)) |
diff --git a/src/identity/identity.h b/src/identity/identity.h index 57ce091b8..dc57ee11e 100644 --- a/src/identity/identity.h +++ b/src/identity/identity.h | |||
@@ -128,12 +128,8 @@ struct UpdateMessage | |||
128 | */ | 128 | */ |
129 | uint16_t end_of_list GNUNET_PACKED; | 129 | uint16_t end_of_list GNUNET_PACKED; |
130 | 130 | ||
131 | /** | ||
132 | * The private key | ||
133 | */ | ||
134 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
135 | |||
136 | /* followed by 0-terminated ego name */ | 131 | /* followed by 0-terminated ego name */ |
132 | /* followed by the private key */ | ||
137 | }; | 133 | }; |
138 | 134 | ||
139 | 135 | ||
@@ -158,12 +154,11 @@ struct CreateRequestMessage | |||
158 | */ | 154 | */ |
159 | uint16_t reserved GNUNET_PACKED; | 155 | uint16_t reserved GNUNET_PACKED; |
160 | 156 | ||
161 | /** | 157 | uint32_t key_len GNUNET_PACKED; |
162 | * The private key | ||
163 | */ | ||
164 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
165 | 158 | ||
166 | /* followed by 0-terminated identity name */ | 159 | /* |
160 | * Followed by the private key | ||
161 | * followed by 0-terminated identity name */ | ||
167 | }; | 162 | }; |
168 | 163 | ||
169 | 164 | ||
diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c index d41e05104..4abd62434 100644 --- a/src/identity/identity_api.c +++ b/src/identity/identity_api.c | |||
@@ -164,7 +164,7 @@ GNUNET_IDENTITY_ego_get_anonymous () | |||
164 | anon.pub.type = htonl (GNUNET_IDENTITY_TYPE_ECDSA); | 164 | anon.pub.type = htonl (GNUNET_IDENTITY_TYPE_ECDSA); |
165 | anon.pk.ecdsa_key = *GNUNET_CRYPTO_ecdsa_key_get_anonymous (); | 165 | anon.pk.ecdsa_key = *GNUNET_CRYPTO_ecdsa_key_get_anonymous (); |
166 | GNUNET_CRYPTO_hash (&anon.pk, | 166 | GNUNET_CRYPTO_hash (&anon.pk, |
167 | sizeof(anon.pk), | 167 | GNUNET_IDENTITY_private_key_get_length (&anon.pk), |
168 | &anon.id); | 168 | &anon.id); |
169 | setup = 1; | 169 | setup = 1; |
170 | return &anon; | 170 | return &anon; |
@@ -194,8 +194,7 @@ GNUNET_IDENTITY_key_get_public (const struct | |||
194 | return GNUNET_OK; | 194 | return GNUNET_OK; |
195 | } | 195 | } |
196 | 196 | ||
197 | 197 | static enum GNUNET_GenericReturnValue | |
198 | static int | ||
199 | private_key_create (enum GNUNET_IDENTITY_KeyType ktype, | 198 | private_key_create (enum GNUNET_IDENTITY_KeyType ktype, |
200 | struct GNUNET_IDENTITY_PrivateKey *key) | 199 | struct GNUNET_IDENTITY_PrivateKey *key) |
201 | { | 200 | { |
@@ -368,7 +367,7 @@ check_identity_update (void *cls, | |||
368 | uint16_t name_len = ntohs (um->name_len); | 367 | uint16_t name_len = ntohs (um->name_len); |
369 | const char *str = (const char *) &um[1]; | 368 | const char *str = (const char *) &um[1]; |
370 | 369 | ||
371 | if ((size != name_len + sizeof(struct UpdateMessage)) || | 370 | if ((size < name_len + sizeof(struct UpdateMessage)) || |
372 | ((0 != name_len) && ('\0' != str[name_len - 1]))) | 371 | ((0 != name_len) && ('\0' != str[name_len - 1]))) |
373 | { | 372 | { |
374 | GNUNET_break (0); | 373 | GNUNET_break (0); |
@@ -390,9 +389,13 @@ handle_identity_update (void *cls, | |||
390 | { | 389 | { |
391 | struct GNUNET_IDENTITY_Handle *h = cls; | 390 | struct GNUNET_IDENTITY_Handle *h = cls; |
392 | uint16_t name_len = ntohs (um->name_len); | 391 | uint16_t name_len = ntohs (um->name_len); |
393 | const char *str = (0 == name_len) ? NULL : (const char *) &um[1]; | 392 | const char *str; |
393 | size_t key_len; | ||
394 | size_t kb_read; | ||
394 | struct GNUNET_HashCode id; | 395 | struct GNUNET_HashCode id; |
395 | struct GNUNET_IDENTITY_Ego *ego; | 396 | struct GNUNET_IDENTITY_Ego *ego; |
397 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
398 | const char *tmp; | ||
396 | 399 | ||
397 | if (GNUNET_YES == ntohs (um->end_of_list)) | 400 | if (GNUNET_YES == ntohs (um->end_of_list)) |
398 | { | 401 | { |
@@ -401,8 +404,18 @@ handle_identity_update (void *cls, | |||
401 | h->cb (h->cb_cls, NULL, NULL, NULL); | 404 | h->cb (h->cb_cls, NULL, NULL, NULL); |
402 | return; | 405 | return; |
403 | } | 406 | } |
404 | GNUNET_CRYPTO_hash (&um->private_key, | 407 | tmp = (const char*) &um[1]; |
405 | sizeof (um->private_key), | 408 | str = (0 == name_len) ? NULL : tmp; |
409 | memset (&private_key, 0, sizeof (private_key)); | ||
410 | key_len = ntohs (um->header.size) - name_len; | ||
411 | GNUNET_assert (GNUNET_SYSERR != | ||
412 | GNUNET_IDENTITY_read_private_key_from_buffer (tmp + name_len, | ||
413 | key_len, | ||
414 | &private_key, | ||
415 | &kb_read)); | ||
416 | GNUNET_assert (0 <= GNUNET_IDENTITY_private_key_get_length (&private_key)); | ||
417 | GNUNET_CRYPTO_hash (&private_key, | ||
418 | GNUNET_IDENTITY_private_key_get_length (&private_key), | ||
406 | &id); | 419 | &id); |
407 | ego = GNUNET_CONTAINER_multihashmap_get (h->egos, | 420 | ego = GNUNET_CONTAINER_multihashmap_get (h->egos, |
408 | &id); | 421 | &id); |
@@ -418,7 +431,7 @@ handle_identity_update (void *cls, | |||
418 | } | 431 | } |
419 | ego = GNUNET_new (struct GNUNET_IDENTITY_Ego); | 432 | ego = GNUNET_new (struct GNUNET_IDENTITY_Ego); |
420 | ego->pub_initialized = GNUNET_NO; | 433 | ego->pub_initialized = GNUNET_NO; |
421 | ego->pk = um->private_key; | 434 | ego->pk = private_key; |
422 | ego->name = GNUNET_strdup (str); | 435 | ego->name = GNUNET_strdup (str); |
423 | ego->id = id; | 436 | ego->id = id; |
424 | GNUNET_assert (GNUNET_YES == | 437 | GNUNET_assert (GNUNET_YES == |
@@ -572,10 +585,12 @@ GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h, | |||
572 | GNUNET_IDENTITY_CreateContinuation cont, | 585 | GNUNET_IDENTITY_CreateContinuation cont, |
573 | void *cont_cls) | 586 | void *cont_cls) |
574 | { | 587 | { |
588 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
575 | struct GNUNET_IDENTITY_Operation *op; | 589 | struct GNUNET_IDENTITY_Operation *op; |
576 | struct GNUNET_MQ_Envelope *env; | 590 | struct GNUNET_MQ_Envelope *env; |
577 | struct CreateRequestMessage *crm; | 591 | struct CreateRequestMessage *crm; |
578 | size_t slen; | 592 | size_t slen; |
593 | size_t key_len; | ||
579 | 594 | ||
580 | if (NULL == h->mq) | 595 | if (NULL == h->mq) |
581 | return NULL; | 596 | return NULL; |
@@ -590,18 +605,23 @@ GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h, | |||
590 | op->create_cont = cont; | 605 | op->create_cont = cont; |
591 | op->cls = cont_cls; | 606 | op->cls = cont_cls; |
592 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 607 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
593 | env = GNUNET_MQ_msg_extra (crm, slen, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE); | ||
594 | crm->name_len = htons (slen); | ||
595 | crm->reserved = htons (0); | ||
596 | if (NULL == privkey) | 608 | if (NULL == privkey) |
597 | { | 609 | { |
598 | GNUNET_assert (GNUNET_OK == | 610 | GNUNET_assert (GNUNET_OK == |
599 | private_key_create (ktype, &crm->private_key)); | 611 | private_key_create (ktype, &private_key)); |
600 | } | 612 | } |
601 | else | 613 | else |
602 | crm->private_key = *privkey; | 614 | private_key = *privkey; |
603 | op->pk = crm->private_key; | 615 | key_len = GNUNET_IDENTITY_private_key_get_length (&private_key); |
604 | GNUNET_memcpy (&crm[1], name, slen); | 616 | env = GNUNET_MQ_msg_extra (crm, slen + key_len, GNUNET_MESSAGE_TYPE_IDENTITY_CREATE); |
617 | crm->name_len = htons (slen); | ||
618 | crm->reserved = htons (0); | ||
619 | GNUNET_IDENTITY_write_private_key_to_buffer (&private_key, | ||
620 | &crm[1], | ||
621 | key_len); | ||
622 | crm->key_len = htonl (key_len); | ||
623 | op->pk = private_key; | ||
624 | GNUNET_memcpy ((char*) &crm[1] + key_len, name, slen); | ||
605 | GNUNET_MQ_send (h->mq, env); | 625 | GNUNET_MQ_send (h->mq, env); |
606 | return op; | 626 | return op; |
607 | } | 627 | } |
@@ -780,8 +800,9 @@ check_key_type (uint32_t type) | |||
780 | } | 800 | } |
781 | 801 | ||
782 | 802 | ||
783 | static ssize_t | 803 | ssize_t |
784 | private_key_get_length (const struct GNUNET_IDENTITY_PrivateKey *key) | 804 | GNUNET_IDENTITY_private_key_get_length (const struct |
805 | GNUNET_IDENTITY_PrivateKey *key) | ||
785 | { | 806 | { |
786 | switch (ntohl (key->type)) | 807 | switch (ntohl (key->type)) |
787 | { | 808 | { |
@@ -792,6 +813,8 @@ private_key_get_length (const struct GNUNET_IDENTITY_PrivateKey *key) | |||
792 | return sizeof (key->type) + sizeof (key->eddsa_key); | 813 | return sizeof (key->type) + sizeof (key->eddsa_key); |
793 | break; | 814 | break; |
794 | default: | 815 | default: |
816 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
817 | "Got key type %u\n", ntohl (key->type)); | ||
795 | GNUNET_break (0); | 818 | GNUNET_break (0); |
796 | } | 819 | } |
797 | return -1; | 820 | return -1; |
@@ -799,7 +822,8 @@ private_key_get_length (const struct GNUNET_IDENTITY_PrivateKey *key) | |||
799 | 822 | ||
800 | 823 | ||
801 | ssize_t | 824 | ssize_t |
802 | GNUNET_IDENTITY_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key) | 825 | GNUNET_IDENTITY_public_key_get_length (const struct |
826 | GNUNET_IDENTITY_PublicKey *key) | ||
803 | { | 827 | { |
804 | switch (ntohl (key->type)) | 828 | switch (ntohl (key->type)) |
805 | { | 829 | { |
@@ -813,36 +837,99 @@ GNUNET_IDENTITY_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key) | |||
813 | return -1; | 837 | return -1; |
814 | } | 838 | } |
815 | 839 | ||
816 | |||
817 | ssize_t | 840 | ssize_t |
818 | GNUNET_IDENTITY_read_key_from_buffer (struct GNUNET_IDENTITY_PublicKey *key, | 841 | GNUNET_IDENTITY_private_key_length_by_type (enum GNUNET_IDENTITY_KeyType kt) |
819 | const void *buffer, | 842 | { |
820 | size_t len) | 843 | switch (kt) |
844 | { | ||
845 | case GNUNET_IDENTITY_TYPE_ECDSA: | ||
846 | return sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey); | ||
847 | break; | ||
848 | case GNUNET_IDENTITY_TYPE_EDDSA: | ||
849 | return sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey); | ||
850 | break; | ||
851 | default: | ||
852 | GNUNET_break (0); | ||
853 | } | ||
854 | return -1; | ||
855 | } | ||
856 | |||
857 | |||
858 | |||
859 | enum GNUNET_GenericReturnValue | ||
860 | GNUNET_IDENTITY_read_public_key_from_buffer (const void *buffer, | ||
861 | size_t len, | ||
862 | struct GNUNET_IDENTITY_PublicKey * | ||
863 | key, | ||
864 | size_t *kb_read) | ||
821 | { | 865 | { |
822 | if (len < sizeof (key->type)) | 866 | if (len < sizeof (key->type)) |
823 | return -1; | 867 | return GNUNET_SYSERR; |
824 | GNUNET_memcpy (&key->type, | 868 | GNUNET_memcpy (&key->type, |
825 | buffer, | 869 | buffer, |
826 | sizeof (key->type)); | 870 | sizeof (key->type)); |
827 | ssize_t length = GNUNET_IDENTITY_key_get_length (key); | 871 | ssize_t length = GNUNET_IDENTITY_public_key_get_length (key); |
872 | if (len < length) | ||
873 | return GNUNET_SYSERR; | ||
874 | if (length < 0) | ||
875 | return GNUNET_SYSERR; | ||
876 | GNUNET_memcpy (&key->ecdsa_key, | ||
877 | buffer + sizeof (key->type), | ||
878 | length - sizeof (key->type)); | ||
879 | *kb_read = length; | ||
880 | return GNUNET_OK; | ||
881 | } | ||
882 | |||
883 | |||
884 | ssize_t | ||
885 | GNUNET_IDENTITY_write_public_key_to_buffer (const struct | ||
886 | GNUNET_IDENTITY_PublicKey *key, | ||
887 | void*buffer, | ||
888 | size_t len) | ||
889 | { | ||
890 | const ssize_t length = GNUNET_IDENTITY_public_key_get_length (key); | ||
828 | if (len < length) | 891 | if (len < length) |
829 | return -1; | 892 | return -1; |
830 | if (length < 0) | 893 | if (length < 0) |
831 | return -2; | 894 | return -2; |
895 | GNUNET_memcpy (buffer, &(key->type), sizeof (key->type)); | ||
896 | GNUNET_memcpy (buffer + sizeof (key->type), &(key->ecdsa_key), length | ||
897 | - sizeof (key->type)); | ||
898 | return length; | ||
899 | } | ||
900 | |||
901 | enum GNUNET_GenericReturnValue | ||
902 | GNUNET_IDENTITY_read_private_key_from_buffer (const void *buffer, | ||
903 | size_t len, | ||
904 | struct | ||
905 | GNUNET_IDENTITY_PrivateKey *key, | ||
906 | size_t *kb_read) | ||
907 | { | ||
908 | if (len < sizeof (key->type)) | ||
909 | return GNUNET_SYSERR; | ||
910 | GNUNET_memcpy (&key->type, | ||
911 | buffer, | ||
912 | sizeof (key->type)); | ||
913 | ssize_t length = GNUNET_IDENTITY_private_key_get_length (key); | ||
914 | if (len < length) | ||
915 | return GNUNET_SYSERR; | ||
916 | if (length < 0) | ||
917 | return GNUNET_SYSERR; | ||
832 | GNUNET_memcpy (&key->ecdsa_key, | 918 | GNUNET_memcpy (&key->ecdsa_key, |
833 | buffer + sizeof (key->type), | 919 | buffer + sizeof (key->type), |
834 | length - sizeof (key->type)); | 920 | length - sizeof (key->type)); |
835 | return length; | 921 | *kb_read = length; |
922 | return GNUNET_OK; | ||
836 | } | 923 | } |
837 | 924 | ||
838 | 925 | ||
839 | ssize_t | 926 | ssize_t |
840 | GNUNET_IDENTITY_write_key_to_buffer (const struct | 927 | GNUNET_IDENTITY_write_private_key_to_buffer (const struct |
841 | GNUNET_IDENTITY_PublicKey *key, | 928 | GNUNET_IDENTITY_PrivateKey *key, |
842 | void*buffer, | 929 | void *buffer, |
843 | size_t len) | 930 | size_t len) |
844 | { | 931 | { |
845 | const ssize_t length = GNUNET_IDENTITY_key_get_length (key); | 932 | const ssize_t length = GNUNET_IDENTITY_private_key_get_length (key); |
846 | if (len < length) | 933 | if (len < length) |
847 | return -1; | 934 | return -1; |
848 | if (length < 0) | 935 | if (length < 0) |
@@ -1123,7 +1210,7 @@ char * | |||
1123 | GNUNET_IDENTITY_public_key_to_string (const struct | 1210 | GNUNET_IDENTITY_public_key_to_string (const struct |
1124 | GNUNET_IDENTITY_PublicKey *key) | 1211 | GNUNET_IDENTITY_PublicKey *key) |
1125 | { | 1212 | { |
1126 | size_t size = GNUNET_IDENTITY_key_get_length (key); | 1213 | size_t size = GNUNET_IDENTITY_public_key_get_length (key); |
1127 | return GNUNET_STRINGS_data_to_string_alloc (key, | 1214 | return GNUNET_STRINGS_data_to_string_alloc (key, |
1128 | size); | 1215 | size); |
1129 | } | 1216 | } |
@@ -1133,7 +1220,7 @@ char * | |||
1133 | GNUNET_IDENTITY_private_key_to_string (const struct | 1220 | GNUNET_IDENTITY_private_key_to_string (const struct |
1134 | GNUNET_IDENTITY_PrivateKey *key) | 1221 | GNUNET_IDENTITY_PrivateKey *key) |
1135 | { | 1222 | { |
1136 | size_t size = private_key_get_length (key); | 1223 | size_t size = GNUNET_IDENTITY_private_key_get_length (key); |
1137 | return GNUNET_STRINGS_data_to_string_alloc (key, | 1224 | return GNUNET_STRINGS_data_to_string_alloc (key, |
1138 | size); | 1225 | size); |
1139 | } | 1226 | } |
diff --git a/src/identity/identity_api_lookup.c b/src/identity/identity_api_lookup.c index 51afb2515..4cc0b6334 100644 --- a/src/identity/identity_api_lookup.c +++ b/src/identity/identity_api_lookup.c | |||
@@ -105,7 +105,7 @@ check_identity_update (void *cls, const struct UpdateMessage *um) | |||
105 | uint16_t name_len = ntohs (um->name_len); | 105 | uint16_t name_len = ntohs (um->name_len); |
106 | const char *str = (const char *) &um[1]; | 106 | const char *str = (const char *) &um[1]; |
107 | 107 | ||
108 | if ((size != name_len + sizeof(struct UpdateMessage)) || | 108 | if ((size < name_len + sizeof(struct UpdateMessage)) || |
109 | ((0 != name_len) && ('\0' != str[name_len - 1]))) | 109 | ((0 != name_len) && ('\0' != str[name_len - 1]))) |
110 | { | 110 | { |
111 | GNUNET_break (0); | 111 | GNUNET_break (0); |
@@ -126,14 +126,29 @@ handle_identity_update (void *cls, const struct UpdateMessage *um) | |||
126 | { | 126 | { |
127 | struct GNUNET_IDENTITY_EgoLookup *el = cls; | 127 | struct GNUNET_IDENTITY_EgoLookup *el = cls; |
128 | uint16_t name_len = ntohs (um->name_len); | 128 | uint16_t name_len = ntohs (um->name_len); |
129 | const char *str = (0 == name_len) ? NULL : (const char *) &um[1]; | 129 | const char *str; |
130 | size_t key_len; | ||
131 | size_t kb_read; | ||
130 | struct GNUNET_HashCode id; | 132 | struct GNUNET_HashCode id; |
131 | struct GNUNET_IDENTITY_Ego ego; | 133 | struct GNUNET_IDENTITY_Ego ego; |
134 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
135 | const char *tmp; | ||
136 | |||
132 | memset (&ego, 0, sizeof (ego)); | 137 | memset (&ego, 0, sizeof (ego)); |
133 | 138 | ||
134 | GNUNET_break (GNUNET_YES != ntohs (um->end_of_list)); | 139 | GNUNET_break (GNUNET_YES != ntohs (um->end_of_list)); |
135 | GNUNET_CRYPTO_hash (&um->private_key, sizeof(um->private_key), &id); | 140 | tmp = (const char*) &um[1]; |
136 | ego.pk = um->private_key; | 141 | str = (0 == name_len) ? NULL : tmp; |
142 | memset (&private_key, 0, sizeof (private_key)); | ||
143 | key_len = ntohs (um->header.size) - sizeof (*um) - name_len; | ||
144 | GNUNET_assert (GNUNET_SYSERR != | ||
145 | GNUNET_IDENTITY_read_private_key_from_buffer (tmp + name_len, | ||
146 | key_len, | ||
147 | &private_key, | ||
148 | &kb_read)); | ||
149 | GNUNET_assert (key_len == kb_read); | ||
150 | GNUNET_CRYPTO_hash (&private_key, sizeof (private_key), &id); | ||
151 | ego.pk = private_key; | ||
137 | ego.name = (char *) str; | 152 | ego.name = (char *) str; |
138 | ego.id = id; | 153 | ego.id = id; |
139 | el->cb (el->cb_cls, &ego); | 154 | el->cb (el->cb_cls, &ego); |
diff --git a/src/identity/identity_api_suffix_lookup.c b/src/identity/identity_api_suffix_lookup.c index 2667ddbc8..fa6bd8310 100644 --- a/src/identity/identity_api_suffix_lookup.c +++ b/src/identity/identity_api_suffix_lookup.c | |||
@@ -108,7 +108,7 @@ check_identity_update (void *cls, const struct UpdateMessage *um) | |||
108 | const char *str = (const char *) &um[1]; | 108 | const char *str = (const char *) &um[1]; |
109 | 109 | ||
110 | (void) cls; | 110 | (void) cls; |
111 | if ((size != name_len + sizeof(struct UpdateMessage)) || | 111 | if ((size < name_len + sizeof(struct UpdateMessage)) || |
112 | ((0 != name_len) && ('\0' != str[name_len - 1]))) | 112 | ((0 != name_len) && ('\0' != str[name_len - 1]))) |
113 | { | 113 | { |
114 | GNUNET_break (0); | 114 | GNUNET_break (0); |
@@ -129,9 +129,23 @@ handle_identity_update (void *cls, const struct UpdateMessage *um) | |||
129 | { | 129 | { |
130 | struct GNUNET_IDENTITY_EgoSuffixLookup *el = cls; | 130 | struct GNUNET_IDENTITY_EgoSuffixLookup *el = cls; |
131 | uint16_t name_len = ntohs (um->name_len); | 131 | uint16_t name_len = ntohs (um->name_len); |
132 | const char *str = (0 == name_len) ? NULL : (const char *) &um[1]; | 132 | const char *str; |
133 | 133 | size_t key_len; | |
134 | el->cb (el->cb_cls, &um->private_key, str); | 134 | size_t kb_read; |
135 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
136 | const char *tmp; | ||
137 | |||
138 | tmp = (const char*) &um[1]; | ||
139 | str = (0 == name_len) ? NULL : tmp; | ||
140 | memset (&private_key, 0, sizeof (private_key)); | ||
141 | key_len = ntohs (um->header.size) - name_len; | ||
142 | GNUNET_assert (GNUNET_SYSERR != | ||
143 | GNUNET_IDENTITY_read_private_key_from_buffer (tmp + name_len, | ||
144 | key_len, | ||
145 | &private_key, | ||
146 | &kb_read)); | ||
147 | GNUNET_assert (key_len == kb_read); | ||
148 | el->cb (el->cb_cls, &private_key, str); | ||
135 | GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (el); | 149 | GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (el); |
136 | } | 150 | } |
137 | 151 | ||
diff --git a/src/identity/test_identity_messages.sh b/src/identity/test_identity_messages.sh index daecb1ed2..0879061e4 100755 --- a/src/identity/test_identity_messages.sh +++ b/src/identity/test_identity_messages.sh | |||
@@ -27,7 +27,7 @@ gnunet-identity -D recipientego -c test_identity.conf | |||
27 | gnunet-arm -e -c test_identity.conf | 27 | gnunet-arm -e -c test_identity.conf |
28 | if [ "$TEST_MSG" != "$MSG_DEC" ] | 28 | if [ "$TEST_MSG" != "$MSG_DEC" ] |
29 | then | 29 | then |
30 | echo "Failed - $TEST_MSG != $MSG_DEC" | 30 | echo "Failed - \"$TEST_MSG\" != \"$MSG_DEC\"" |
31 | exit 1 | 31 | exit 1 |
32 | fi | 32 | fi |
33 | 33 | ||
diff --git a/src/include/gnunet_identity_service.h b/src/include/gnunet_identity_service.h index d234ff552..cd745ba51 100644 --- a/src/include/gnunet_identity_service.h +++ b/src/include/gnunet_identity_service.h | |||
@@ -85,11 +85,10 @@ struct GNUNET_IDENTITY_Handle; | |||
85 | */ | 85 | */ |
86 | struct GNUNET_IDENTITY_Ego; | 86 | struct GNUNET_IDENTITY_Ego; |
87 | 87 | ||
88 | // FIXME: these types are NOT packed, | ||
89 | // NOT 64-bit aligned, but used in messages!!?? | ||
90 | |||
91 | /** | 88 | /** |
92 | * A private key for an identity as per LSD0001. | 89 | * A private key for an identity as per LSD0001. |
90 | * Note that these types are NOT packed and MUST NOT be used in RPC | ||
91 | * messages. Use the respective serialization functions. | ||
93 | */ | 92 | */ |
94 | struct GNUNET_IDENTITY_PrivateKey | 93 | struct GNUNET_IDENTITY_PrivateKey |
95 | { | 94 | { |
@@ -406,8 +405,7 @@ GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op); | |||
406 | * @return -1 on error, else the compacted length of the key. | 405 | * @return -1 on error, else the compacted length of the key. |
407 | */ | 406 | */ |
408 | ssize_t | 407 | ssize_t |
409 | GNUNET_IDENTITY_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key); | 408 | GNUNET_IDENTITY_public_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key); |
410 | |||
411 | 409 | ||
412 | /** | 410 | /** |
413 | * Reads a #GNUNET_IDENTITY_PublicKey from a compact buffer. | 411 | * Reads a #GNUNET_IDENTITY_PublicKey from a compact buffer. |
@@ -416,15 +414,32 @@ GNUNET_IDENTITY_key_get_length (const struct GNUNET_IDENTITY_PublicKey *key); | |||
416 | * If the buffer is too small, the function returns -1 as error. | 414 | * If the buffer is too small, the function returns -1 as error. |
417 | * If the buffer does not contain a valid key, it returns -2 as error. | 415 | * If the buffer does not contain a valid key, it returns -2 as error. |
418 | * | 416 | * |
419 | * @param key the key | ||
420 | * @param buffer the buffer | 417 | * @param buffer the buffer |
421 | * @param len the length of buffer | 418 | * @param len the length of buffer |
422 | * @return -1 or -2 on error, else the amount of bytes read from the buffer | 419 | * @param key the key |
420 | * @param the amount of bytes read from the buffer | ||
421 | * @return GNUNET_SYSERR on error | ||
422 | */ | ||
423 | enum GNUNET_GenericReturnValue | ||
424 | GNUNET_IDENTITY_read_public_key_from_buffer (const void *buffer, | ||
425 | size_t len, | ||
426 | struct | ||
427 | GNUNET_IDENTITY_PublicKey *key, | ||
428 | size_t *read); | ||
429 | |||
430 | /** | ||
431 | * Get the compacted length of a #GNUNET_IDENTITY_PrivateKey. | ||
432 | * Compacted means that it returns the minimum number of bytes this | ||
433 | * key is long, as opposed to the union structure inside | ||
434 | * #GNUNET_IDENTITY_PrivateKey. | ||
435 | * Useful for compact serializations. | ||
436 | * | ||
437 | * @param key the key. | ||
438 | * @return -1 on error, else the compacted length of the key. | ||
423 | */ | 439 | */ |
424 | ssize_t | 440 | ssize_t |
425 | GNUNET_IDENTITY_read_key_from_buffer (struct GNUNET_IDENTITY_PublicKey *key, | 441 | GNUNET_IDENTITY_private_key_get_length (const struct |
426 | const void*buffer, | 442 | GNUNET_IDENTITY_PrivateKey *key); |
427 | size_t len); | ||
428 | 443 | ||
429 | 444 | ||
430 | /** | 445 | /** |
@@ -440,10 +455,49 @@ GNUNET_IDENTITY_read_key_from_buffer (struct GNUNET_IDENTITY_PublicKey *key, | |||
440 | * @return -1 or -2 on error, else the amount of bytes written to the buffer | 455 | * @return -1 or -2 on error, else the amount of bytes written to the buffer |
441 | */ | 456 | */ |
442 | ssize_t | 457 | ssize_t |
443 | GNUNET_IDENTITY_write_key_to_buffer (const struct | 458 | GNUNET_IDENTITY_write_public_key_to_buffer (const struct |
444 | GNUNET_IDENTITY_PublicKey *key, | 459 | GNUNET_IDENTITY_PublicKey *key, |
445 | void*buffer, | 460 | void*buffer, |
446 | size_t len); | 461 | size_t len); |
462 | |||
463 | |||
464 | /** | ||
465 | * Reads a #GNUNET_IDENTITY_PrivateKey from a compact buffer. | ||
466 | * The buffer has to contain at least the compacted length of | ||
467 | * a #GNUNET_IDENTITY_PrivateKey in bytes. | ||
468 | * If the buffer is too small, the function returns GNUNET_SYSERR as error. | ||
469 | * | ||
470 | * @param buffer the buffer | ||
471 | * @param len the length of buffer | ||
472 | * @param key the key | ||
473 | * @param the amount of bytes read from the buffer | ||
474 | * @return GNUNET_SYSERR on error | ||
475 | */ | ||
476 | enum GNUNET_GenericReturnValue | ||
477 | GNUNET_IDENTITY_read_private_key_from_buffer (const void*buffer, | ||
478 | size_t len, | ||
479 | struct | ||
480 | GNUNET_IDENTITY_PrivateKey *key, | ||
481 | size_t *read); | ||
482 | |||
483 | |||
484 | /** | ||
485 | * Writes a #GNUNET_IDENTITY_PrivateKey to a compact buffer. | ||
486 | * The buffer requires space for at least the compacted length of | ||
487 | * a #GNUNET_IDENTITY_PrivateKey in bytes. | ||
488 | * If the buffer is too small, the function returns -1 as error. | ||
489 | * If the key is not valid, it returns -2 as error. | ||
490 | * | ||
491 | * @param key the key | ||
492 | * @param buffer the buffer | ||
493 | * @param len the length of buffer | ||
494 | * @return -1 or -2 on error, else the amount of bytes written to the buffer | ||
495 | */ | ||
496 | ssize_t | ||
497 | GNUNET_IDENTITY_write_private_key_to_buffer (const struct | ||
498 | GNUNET_IDENTITY_PrivateKey *key, | ||
499 | void*buffer, | ||
500 | size_t len); | ||
447 | 501 | ||
448 | 502 | ||
449 | /** | 503 | /** |
diff --git a/src/include/gnunet_reclaim_service.h b/src/include/gnunet_reclaim_service.h index e9e0f144d..a3f6c19b6 100644 --- a/src/include/gnunet_reclaim_service.h +++ b/src/include/gnunet_reclaim_service.h | |||
@@ -498,6 +498,43 @@ GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h); | |||
498 | void | 498 | void |
499 | GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op); | 499 | GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op); |
500 | 500 | ||
501 | /** | ||
502 | * Get serialized ticket size | ||
503 | * | ||
504 | * @param tkt the ticket | ||
505 | * @return the buffer length requirement for a serialization | ||
506 | */ | ||
507 | size_t | ||
508 | GNUNET_RECLAIM_ticket_serialize_get_size (const struct GNUNET_RECLAIM_Ticket *tkt); | ||
509 | |||
510 | /** | ||
511 | * Deserializes a ticket | ||
512 | * | ||
513 | * @param buffer the buffer to read from | ||
514 | * @param len the length of the buffer | ||
515 | * @param tkt the ticket to write to (must be allocated) | ||
516 | * @param kb_read how many bytes were read from buffer | ||
517 | * @return GNUNET_SYSERR on error | ||
518 | */ | ||
519 | enum GNUNET_GenericReturnValue | ||
520 | GNUNET_RECLAIM_read_ticket_from_buffer (const void *buffer, | ||
521 | size_t len, | ||
522 | struct GNUNET_RECLAIM_Ticket *tkt, | ||
523 | size_t *tb_read); | ||
524 | |||
525 | /** | ||
526 | * Serializes a ticket | ||
527 | * | ||
528 | * @param tkt the ticket to serialize | ||
529 | * @param buffer the buffer to serialize to (must be allocated with sufficient size | ||
530 | * @param len the length of the buffer | ||
531 | * @return the number of written bytes or < 0 on error | ||
532 | */ | ||
533 | ssize_t | ||
534 | GNUNET_RECLAIM_write_ticket_to_buffer (const struct | ||
535 | GNUNET_RECLAIM_Ticket *tkt, | ||
536 | void *buffer, | ||
537 | size_t len); | ||
501 | 538 | ||
502 | #if 0 /* keep Emacsens' auto-indent happy */ | 539 | #if 0 /* keep Emacsens' auto-indent happy */ |
503 | { | 540 | { |
diff --git a/src/namestore/Makefile.am b/src/namestore/Makefile.am index 2a1558e09..fb2a670bc 100644 --- a/src/namestore/Makefile.am +++ b/src/namestore/Makefile.am | |||
@@ -179,7 +179,6 @@ gnunet_namestore_fcfsd_CFLAGS = $(MHD_CFLAGS) $(AM_CFLAGS) | |||
179 | 179 | ||
180 | gnunet_service_namestore_SOURCES = \ | 180 | gnunet_service_namestore_SOURCES = \ |
181 | gnunet-service-namestore.c | 181 | gnunet-service-namestore.c |
182 | |||
183 | gnunet_service_namestore_LDADD = \ | 182 | gnunet_service_namestore_LDADD = \ |
184 | $(top_builddir)/src/namecache/libgnunetnamecache.la \ | 183 | $(top_builddir)/src/namecache/libgnunetnamecache.la \ |
185 | $(top_builddir)/src/gnsrecord/libgnunetgnsrecord.la \ | 184 | $(top_builddir)/src/gnsrecord/libgnunetgnsrecord.la \ |
diff --git a/src/namestore/gnunet-namestore.c b/src/namestore/gnunet-namestore.c index 843158c68..6444d446d 100644 --- a/src/namestore/gnunet-namestore.c +++ b/src/namestore/gnunet-namestore.c | |||
@@ -129,11 +129,6 @@ static struct GNUNET_IDENTITY_EgoLookup *el; | |||
129 | static struct GNUNET_IDENTITY_Handle *idh; | 129 | static struct GNUNET_IDENTITY_Handle *idh; |
130 | 130 | ||
131 | /** | 131 | /** |
132 | * Obtain default ego | ||
133 | */ | ||
134 | struct GNUNET_IDENTITY_Operation *get_default; | ||
135 | |||
136 | /** | ||
137 | * Name of the ego controlling the zone. | 132 | * Name of the ego controlling the zone. |
138 | */ | 133 | */ |
139 | static char *ego_name; | 134 | static char *ego_name; |
@@ -342,10 +337,10 @@ do_shutdown (void *cls) | |||
342 | struct MarkedRecord *mrec; | 337 | struct MarkedRecord *mrec; |
343 | struct MarkedRecord *mrec_tmp; | 338 | struct MarkedRecord *mrec_tmp; |
344 | (void) cls; | 339 | (void) cls; |
345 | if (NULL != get_default) | 340 | if (NULL != ego_name) |
346 | { | 341 | { |
347 | GNUNET_IDENTITY_cancel (get_default); | 342 | GNUNET_free (ego_name); |
348 | get_default = NULL; | 343 | ego_name = NULL; |
349 | } | 344 | } |
350 | if (NULL != purge_task) | 345 | if (NULL != purge_task) |
351 | { | 346 | { |
@@ -1530,7 +1525,7 @@ run_with_zone_pkey (const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
1530 | } | 1525 | } |
1531 | memset (&rd, 0, sizeof(rd)); | 1526 | memset (&rd, 0, sizeof(rd)); |
1532 | rd.data = &pkey; | 1527 | rd.data = &pkey; |
1533 | rd.data_size = GNUNET_IDENTITY_key_get_length (&pkey); | 1528 | rd.data_size = GNUNET_IDENTITY_public_key_get_length (&pkey); |
1534 | rd.record_type = ntohl (pkey.type); | 1529 | rd.record_type = ntohl (pkey.type); |
1535 | rd.expiration_time = etime; | 1530 | rd.expiration_time = etime; |
1536 | if (GNUNET_YES == etime_is_rel) | 1531 | if (GNUNET_YES == etime_is_rel) |
@@ -1589,8 +1584,6 @@ identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego) | |||
1589 | return; | 1584 | return; |
1590 | } | 1585 | } |
1591 | zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego); | 1586 | zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego); |
1592 | GNUNET_free (ego_name); | ||
1593 | ego_name = NULL; | ||
1594 | run_with_zone_pkey (cfg); | 1587 | run_with_zone_pkey (cfg); |
1595 | } | 1588 | } |
1596 | 1589 | ||
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c index 92c81c4eb..f0739cbeb 100644 --- a/src/namestore/gnunet-service-namestore.c +++ b/src/namestore/gnunet-service-namestore.c | |||
@@ -711,6 +711,7 @@ send_lookup_response_with_filter (struct NamestoreClient *nc, | |||
711 | unsigned int res_count; | 711 | unsigned int res_count; |
712 | unsigned int rd_nf_count; | 712 | unsigned int rd_nf_count; |
713 | size_t name_len; | 713 | size_t name_len; |
714 | size_t key_len; | ||
714 | ssize_t rd_ser_len; | 715 | ssize_t rd_ser_len; |
715 | char *name_tmp; | 716 | char *name_tmp; |
716 | char *rd_ser; | 717 | char *rd_ser; |
@@ -778,16 +779,20 @@ send_lookup_response_with_filter (struct NamestoreClient *nc, | |||
778 | GNUNET_SERVICE_client_drop (nc->client); | 779 | GNUNET_SERVICE_client_drop (nc->client); |
779 | return 0; | 780 | return 0; |
780 | } | 781 | } |
782 | key_len = GNUNET_IDENTITY_private_key_get_length (zone_key); | ||
781 | env = GNUNET_MQ_msg_extra (zir_msg, | 783 | env = GNUNET_MQ_msg_extra (zir_msg, |
782 | name_len + rd_ser_len, | 784 | name_len + rd_ser_len + key_len, |
783 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT); | 785 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT); |
784 | zir_msg->gns_header.r_id = htonl (request_id); | 786 | zir_msg->gns_header.r_id = htonl (request_id); |
785 | zir_msg->name_len = htons (name_len); | 787 | zir_msg->name_len = htons (name_len); |
786 | zir_msg->rd_count = htons (res_count); | 788 | zir_msg->rd_count = htons (res_count); |
787 | zir_msg->rd_len = htons ((uint16_t) rd_ser_len); | 789 | zir_msg->rd_len = htons ((uint16_t) rd_ser_len); |
788 | zir_msg->private_key = *zone_key; | 790 | zir_msg->key_len = htonl (key_len); |
791 | GNUNET_IDENTITY_write_private_key_to_buffer (zone_key, | ||
792 | &zir_msg[1], | ||
793 | key_len); | ||
789 | zir_msg->expire = GNUNET_TIME_absolute_hton (block_exp); | 794 | zir_msg->expire = GNUNET_TIME_absolute_hton (block_exp); |
790 | name_tmp = (char *) &zir_msg[1]; | 795 | name_tmp = (char *) &zir_msg[1] + key_len; |
791 | GNUNET_memcpy (name_tmp, name, name_len); | 796 | GNUNET_memcpy (name_tmp, name, name_len); |
792 | rd_ser = &name_tmp[name_len]; | 797 | rd_ser = &name_tmp[name_len]; |
793 | GNUNET_assert ( | 798 | GNUNET_assert ( |
@@ -1309,16 +1314,17 @@ check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) | |||
1309 | { | 1314 | { |
1310 | uint32_t name_len; | 1315 | uint32_t name_len; |
1311 | size_t src_size; | 1316 | size_t src_size; |
1317 | size_t key_len; | ||
1312 | 1318 | ||
1313 | (void) cls; | 1319 | (void) cls; |
1314 | name_len = ntohl (ll_msg->label_len); | 1320 | name_len = ntohl (ll_msg->label_len); |
1321 | key_len = ntohl (ll_msg->key_len); | ||
1315 | src_size = ntohs (ll_msg->gns_header.header.size); | 1322 | src_size = ntohs (ll_msg->gns_header.header.size); |
1316 | if (name_len != src_size - sizeof(struct LabelLookupMessage)) | 1323 | if (name_len + key_len != src_size - sizeof(struct LabelLookupMessage)) |
1317 | { | 1324 | { |
1318 | GNUNET_break (0); | 1325 | GNUNET_break (0); |
1319 | return GNUNET_SYSERR; | 1326 | return GNUNET_SYSERR; |
1320 | } | 1327 | } |
1321 | GNUNET_MQ_check_zero_termination (ll_msg); | ||
1322 | return GNUNET_OK; | 1328 | return GNUNET_OK; |
1323 | } | 1329 | } |
1324 | 1330 | ||
@@ -1332,6 +1338,7 @@ check_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) | |||
1332 | static void | 1338 | static void |
1333 | handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) | 1339 | handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) |
1334 | { | 1340 | { |
1341 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
1335 | struct NamestoreClient *nc = cls; | 1342 | struct NamestoreClient *nc = cls; |
1336 | struct GNUNET_MQ_Envelope *env; | 1343 | struct GNUNET_MQ_Envelope *env; |
1337 | struct LabelLookupResponseMessage *llr_msg; | 1344 | struct LabelLookupResponseMessage *llr_msg; |
@@ -1341,8 +1348,23 @@ handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) | |||
1341 | char *conv_name; | 1348 | char *conv_name; |
1342 | uint32_t name_len; | 1349 | uint32_t name_len; |
1343 | int res; | 1350 | int res; |
1344 | 1351 | size_t key_len; | |
1345 | name_tmp = (const char *) &ll_msg[1]; | 1352 | size_t kb_read; |
1353 | |||
1354 | key_len = ntohl (ll_msg->key_len); | ||
1355 | if ((GNUNET_SYSERR == | ||
1356 | GNUNET_IDENTITY_read_private_key_from_buffer (&ll_msg[1], | ||
1357 | key_len, | ||
1358 | &zone, | ||
1359 | &kb_read)) || | ||
1360 | (kb_read != key_len)) | ||
1361 | { | ||
1362 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1363 | "Error reading private key\n"); | ||
1364 | GNUNET_SERVICE_client_drop (nc->client); | ||
1365 | return; | ||
1366 | } | ||
1367 | name_tmp = (const char *) &ll_msg[1] + key_len; | ||
1346 | GNUNET_SERVICE_client_continue (nc->client); | 1368 | GNUNET_SERVICE_client_continue (nc->client); |
1347 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1369 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1348 | "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n", | 1370 | "Received NAMESTORE_RECORD_LOOKUP message for name `%s'\n", |
@@ -1366,37 +1388,38 @@ handle_record_lookup (void *cls, const struct LabelLookupMessage *ll_msg) | |||
1366 | rlc.res_rd_count = 0; | 1388 | rlc.res_rd_count = 0; |
1367 | rlc.res_rd = NULL; | 1389 | rlc.res_rd = NULL; |
1368 | rlc.rd_ser_len = 0; | 1390 | rlc.rd_ser_len = 0; |
1369 | rlc.nick = get_nick_record (&ll_msg->zone); | 1391 | rlc.nick = get_nick_record (&zone); |
1370 | if (GNUNET_YES != ntohl (ll_msg->is_edit_request)) | 1392 | if (GNUNET_YES != ntohl (ll_msg->is_edit_request)) |
1371 | res = nc->GSN_database->lookup_records (nc->GSN_database->cls, | 1393 | res = nc->GSN_database->lookup_records (nc->GSN_database->cls, |
1372 | &ll_msg->zone, | 1394 | &zone, |
1373 | conv_name, | 1395 | conv_name, |
1374 | &lookup_it, | 1396 | &lookup_it, |
1375 | &rlc); | 1397 | &rlc); |
1376 | else | 1398 | else |
1377 | res = nc->GSN_database->edit_records (nc->GSN_database->cls, | 1399 | res = nc->GSN_database->edit_records (nc->GSN_database->cls, |
1378 | &ll_msg->zone, | 1400 | &zone, |
1379 | conv_name, | 1401 | conv_name, |
1380 | &lookup_it, | 1402 | &lookup_it, |
1381 | &rlc); | 1403 | &rlc); |
1382 | 1404 | ||
1383 | env = | 1405 | env = |
1384 | GNUNET_MQ_msg_extra (llr_msg, | 1406 | GNUNET_MQ_msg_extra (llr_msg, |
1385 | name_len + rlc.rd_ser_len, | 1407 | key_len + name_len + rlc.rd_ser_len, |
1386 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE); | 1408 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE); |
1387 | llr_msg->gns_header.r_id = ll_msg->gns_header.r_id; | 1409 | llr_msg->gns_header.r_id = ll_msg->gns_header.r_id; |
1388 | llr_msg->private_key = ll_msg->zone; | 1410 | GNUNET_memcpy (&llr_msg[1], &ll_msg[1], key_len); |
1411 | llr_msg->key_len = ll_msg->key_len; | ||
1389 | llr_msg->name_len = htons (name_len); | 1412 | llr_msg->name_len = htons (name_len); |
1390 | llr_msg->rd_count = htons (rlc.res_rd_count); | 1413 | llr_msg->rd_count = htons (rlc.res_rd_count); |
1391 | llr_msg->rd_len = htons (rlc.rd_ser_len); | 1414 | llr_msg->rd_len = htons (rlc.rd_ser_len); |
1392 | res_name = (char *) &llr_msg[1]; | 1415 | res_name = ((char *) &llr_msg[1]) + key_len; |
1393 | if (GNUNET_YES == rlc.found) | 1416 | if (GNUNET_YES == rlc.found) |
1394 | llr_msg->found = htons (GNUNET_YES); | 1417 | llr_msg->found = htons (GNUNET_YES); |
1395 | else if (GNUNET_SYSERR == res) | 1418 | else if (GNUNET_SYSERR == res) |
1396 | llr_msg->found = htons (GNUNET_SYSERR); | 1419 | llr_msg->found = htons (GNUNET_SYSERR); |
1397 | else | 1420 | else |
1398 | llr_msg->found = htons (GNUNET_NO); | 1421 | llr_msg->found = htons (GNUNET_NO); |
1399 | GNUNET_memcpy (&llr_msg[1], conv_name, name_len); | 1422 | GNUNET_memcpy (res_name, conv_name, name_len); |
1400 | GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len); | 1423 | GNUNET_memcpy (&res_name[name_len], rlc.res_rd, rlc.rd_ser_len); |
1401 | GNUNET_MQ_send (nc->mq, env); | 1424 | GNUNET_MQ_send (nc->mq, env); |
1402 | GNUNET_free (rlc.res_rd); | 1425 | GNUNET_free (rlc.res_rd); |
@@ -1418,11 +1441,14 @@ check_record_store (void *cls, const struct RecordStoreMessage *rp_msg) | |||
1418 | size_t msg_size; | 1441 | size_t msg_size; |
1419 | size_t min_size_exp; | 1442 | size_t min_size_exp; |
1420 | size_t rd_set_count; | 1443 | size_t rd_set_count; |
1444 | size_t key_len; | ||
1421 | 1445 | ||
1422 | (void) cls; | 1446 | (void) cls; |
1423 | msg_size = ntohs (rp_msg->gns_header.header.size); | 1447 | msg_size = ntohs (rp_msg->gns_header.header.size); |
1424 | rd_set_count = ntohs (rp_msg->rd_set_count); | 1448 | rd_set_count = ntohs (rp_msg->rd_set_count); |
1425 | min_size_exp = sizeof(struct RecordStoreMessage) + sizeof (struct RecordSet) | 1449 | key_len = ntohl (rp_msg->key_len); |
1450 | |||
1451 | min_size_exp = sizeof(*rp_msg) + key_len + sizeof (struct RecordSet) | ||
1426 | * rd_set_count; | 1452 | * rd_set_count; |
1427 | if (msg_size < min_size_exp) | 1453 | if (msg_size < min_size_exp) |
1428 | { | 1454 | { |
@@ -1701,24 +1727,40 @@ store_record_set (struct NamestoreClient *nc, | |||
1701 | static void | 1727 | static void |
1702 | handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg) | 1728 | handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg) |
1703 | { | 1729 | { |
1730 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
1704 | struct NamestoreClient *nc = cls; | 1731 | struct NamestoreClient *nc = cls; |
1705 | uint32_t rid; | 1732 | uint32_t rid; |
1706 | uint16_t rd_set_count; | 1733 | uint16_t rd_set_count; |
1707 | const char *buf; | 1734 | const char *buf; |
1708 | ssize_t read; | 1735 | ssize_t read; |
1736 | size_t key_len; | ||
1737 | size_t kb_read; | ||
1709 | struct StoreActivity *sa; | 1738 | struct StoreActivity *sa; |
1710 | struct RecordSet *rs; | 1739 | struct RecordSet *rs; |
1711 | enum GNUNET_ErrorCode res; | 1740 | enum GNUNET_ErrorCode res; |
1712 | 1741 | ||
1742 | key_len = ntohl (rp_msg->key_len); | ||
1743 | if ((GNUNET_SYSERR == | ||
1744 | GNUNET_IDENTITY_read_private_key_from_buffer (&rp_msg[1], | ||
1745 | key_len, | ||
1746 | &zone, | ||
1747 | &kb_read)) || | ||
1748 | (kb_read != key_len)) | ||
1749 | { | ||
1750 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1751 | "Error reading private key\n"); | ||
1752 | GNUNET_SERVICE_client_drop (nc->client); | ||
1753 | return; | ||
1754 | } | ||
1713 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1755 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1714 | "Received NAMESTORE_RECORD_STORE message\n"); | 1756 | "Received NAMESTORE_RECORD_STORE message\n"); |
1715 | rid = ntohl (rp_msg->gns_header.r_id); | 1757 | rid = ntohl (rp_msg->gns_header.r_id); |
1716 | rd_set_count = ntohs (rp_msg->rd_set_count); | 1758 | rd_set_count = ntohs (rp_msg->rd_set_count); |
1717 | buf = (const char *) &rp_msg[1]; | 1759 | buf = (const char *) &rp_msg[1] + key_len; |
1718 | for (int i = 0; i < rd_set_count; i++) | 1760 | for (int i = 0; i < rd_set_count; i++) |
1719 | { | 1761 | { |
1720 | rs = (struct RecordSet *) buf; | 1762 | rs = (struct RecordSet *) buf; |
1721 | res = store_record_set (nc, &rp_msg->private_key, | 1763 | res = store_record_set (nc, &zone, |
1722 | rs, &read); | 1764 | rs, &read); |
1723 | if (GNUNET_EC_NONE != res) | 1765 | if (GNUNET_EC_NONE != res) |
1724 | { | 1766 | { |
@@ -1735,11 +1777,11 @@ handle_record_store (void *cls, const struct RecordStoreMessage *rp_msg) | |||
1735 | sa->nc = nc; | 1777 | sa->nc = nc; |
1736 | sa->rs = (struct RecordSet *) &sa[1]; | 1778 | sa->rs = (struct RecordSet *) &sa[1]; |
1737 | sa->rd_set_count = rd_set_count; | 1779 | sa->rd_set_count = rd_set_count; |
1738 | GNUNET_memcpy (&sa[1], (char *) &rp_msg[1], | 1780 | GNUNET_memcpy (&sa[1], (char *) &rp_msg[1] + key_len, |
1739 | ntohs (rp_msg->gns_header.header.size) - sizeof (*rp_msg)); | 1781 | ntohs (rp_msg->gns_header.header.size) - sizeof (*rp_msg)); |
1740 | sa->rid = rid; | 1782 | sa->rid = rid; |
1741 | sa->rd_set_pos = 0; | 1783 | sa->rd_set_pos = 0; |
1742 | sa->private_key = rp_msg->private_key; | 1784 | sa->private_key = zone; |
1743 | sa->zm_pos = monitor_head; | 1785 | sa->zm_pos = monitor_head; |
1744 | sa->uncommited = nc->in_transaction; | 1786 | sa->uncommited = nc->in_transaction; |
1745 | continue_store_activity (sa, GNUNET_YES); | 1787 | continue_store_activity (sa, GNUNET_YES); |
@@ -1913,6 +1955,7 @@ handle_zone_to_name_it (void *cls, | |||
1913 | struct GNUNET_MQ_Envelope *env; | 1955 | struct GNUNET_MQ_Envelope *env; |
1914 | struct ZoneToNameResponseMessage *ztnr_msg; | 1956 | struct ZoneToNameResponseMessage *ztnr_msg; |
1915 | size_t name_len; | 1957 | size_t name_len; |
1958 | size_t key_len; | ||
1916 | ssize_t rd_ser_len; | 1959 | ssize_t rd_ser_len; |
1917 | size_t msg_size; | 1960 | size_t msg_size; |
1918 | char *name_tmp; | 1961 | char *name_tmp; |
@@ -1931,7 +1974,9 @@ handle_zone_to_name_it (void *cls, | |||
1931 | ztn_ctx->ec = htonl (GNUNET_EC_NAMESTORE_UNKNOWN); | 1974 | ztn_ctx->ec = htonl (GNUNET_EC_NAMESTORE_UNKNOWN); |
1932 | return; | 1975 | return; |
1933 | } | 1976 | } |
1934 | msg_size = sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len; | 1977 | key_len = GNUNET_IDENTITY_private_key_get_length (zone_key); |
1978 | msg_size = sizeof(struct ZoneToNameResponseMessage) | ||
1979 | + name_len + rd_ser_len + key_len; | ||
1935 | if (msg_size >= GNUNET_MAX_MESSAGE_SIZE) | 1980 | if (msg_size >= GNUNET_MAX_MESSAGE_SIZE) |
1936 | { | 1981 | { |
1937 | GNUNET_break (0); | 1982 | GNUNET_break (0); |
@@ -1940,7 +1985,7 @@ handle_zone_to_name_it (void *cls, | |||
1940 | } | 1985 | } |
1941 | env = | 1986 | env = |
1942 | GNUNET_MQ_msg_extra (ztnr_msg, | 1987 | GNUNET_MQ_msg_extra (ztnr_msg, |
1943 | name_len + rd_ser_len, | 1988 | key_len + name_len + rd_ser_len, |
1944 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); | 1989 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE); |
1945 | ztnr_msg->gns_header.header.size = htons (msg_size); | 1990 | ztnr_msg->gns_header.header.size = htons (msg_size); |
1946 | ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid); | 1991 | ztnr_msg->gns_header.r_id = htonl (ztn_ctx->rid); |
@@ -1948,8 +1993,11 @@ handle_zone_to_name_it (void *cls, | |||
1948 | ztnr_msg->rd_len = htons (rd_ser_len); | 1993 | ztnr_msg->rd_len = htons (rd_ser_len); |
1949 | ztnr_msg->rd_count = htons (rd_count); | 1994 | ztnr_msg->rd_count = htons (rd_count); |
1950 | ztnr_msg->name_len = htons (name_len); | 1995 | ztnr_msg->name_len = htons (name_len); |
1951 | ztnr_msg->zone = *zone_key; | 1996 | ztnr_msg->key_len = htonl (key_len); |
1952 | name_tmp = (char *) &ztnr_msg[1]; | 1997 | GNUNET_IDENTITY_write_private_key_to_buffer (zone_key, |
1998 | &ztnr_msg[1], | ||
1999 | key_len); | ||
2000 | name_tmp = (char *) &ztnr_msg[1] + key_len; | ||
1953 | GNUNET_memcpy (name_tmp, name, name_len); | 2001 | GNUNET_memcpy (name_tmp, name, name_len); |
1954 | rd_tmp = &name_tmp[name_len]; | 2002 | rd_tmp = &name_tmp[name_len]; |
1955 | GNUNET_assert ( | 2003 | GNUNET_assert ( |
@@ -1959,6 +2007,13 @@ handle_zone_to_name_it (void *cls, | |||
1959 | GNUNET_MQ_send (ztn_ctx->nc->mq, env); | 2007 | GNUNET_MQ_send (ztn_ctx->nc->mq, env); |
1960 | } | 2008 | } |
1961 | 2009 | ||
2010 | static enum GNUNET_GenericReturnValue | ||
2011 | check_zone_to_name (void *cls, | ||
2012 | const struct ZoneToNameMessage *zis_msg) | ||
2013 | { | ||
2014 | return GNUNET_OK; | ||
2015 | } | ||
2016 | |||
1962 | 2017 | ||
1963 | /** | 2018 | /** |
1964 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME message | 2019 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME message |
@@ -1969,18 +2024,52 @@ handle_zone_to_name_it (void *cls, | |||
1969 | static void | 2024 | static void |
1970 | handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg) | 2025 | handle_zone_to_name (void *cls, const struct ZoneToNameMessage *ztn_msg) |
1971 | { | 2026 | { |
2027 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
2028 | struct GNUNET_IDENTITY_PublicKey value_zone; | ||
1972 | struct NamestoreClient *nc = cls; | 2029 | struct NamestoreClient *nc = cls; |
1973 | struct ZoneToNameCtx ztn_ctx; | 2030 | struct ZoneToNameCtx ztn_ctx; |
1974 | struct GNUNET_MQ_Envelope *env; | 2031 | struct GNUNET_MQ_Envelope *env; |
1975 | struct ZoneToNameResponseMessage *ztnr_msg; | 2032 | struct ZoneToNameResponseMessage *ztnr_msg; |
2033 | size_t key_len; | ||
2034 | size_t pkey_len; | ||
2035 | size_t kb_read; | ||
1976 | 2036 | ||
1977 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n"); | 2037 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME message\n"); |
1978 | ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id); | 2038 | ztn_ctx.rid = ntohl (ztn_msg->gns_header.r_id); |
1979 | ztn_ctx.nc = nc; | 2039 | ztn_ctx.nc = nc; |
1980 | ztn_ctx.ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND; | 2040 | ztn_ctx.ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND; |
2041 | key_len = ntohl (ztn_msg->key_len); | ||
2042 | if ((GNUNET_SYSERR == | ||
2043 | GNUNET_IDENTITY_read_private_key_from_buffer (&ztn_msg[1], | ||
2044 | key_len, | ||
2045 | &zone, | ||
2046 | &kb_read)) || | ||
2047 | (kb_read != key_len)) | ||
2048 | { | ||
2049 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2050 | "Error parsing private key.\n"); | ||
2051 | GNUNET_SERVICE_client_drop (nc->client); | ||
2052 | GNUNET_break (0); | ||
2053 | return; | ||
2054 | } | ||
2055 | pkey_len = ntohl (ztn_msg->pkey_len); | ||
2056 | if ((GNUNET_SYSERR == | ||
2057 | GNUNET_IDENTITY_read_public_key_from_buffer ((char*) &ztn_msg[1] | ||
2058 | + key_len, | ||
2059 | pkey_len, | ||
2060 | &value_zone, | ||
2061 | &kb_read)) || | ||
2062 | (kb_read != pkey_len)) | ||
2063 | { | ||
2064 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2065 | "Error parsing public key.\n"); | ||
2066 | GNUNET_SERVICE_client_drop (nc->client); | ||
2067 | GNUNET_break (0); | ||
2068 | return; | ||
2069 | } | ||
1981 | if (GNUNET_SYSERR == nc->GSN_database->zone_to_name (nc->GSN_database->cls, | 2070 | if (GNUNET_SYSERR == nc->GSN_database->zone_to_name (nc->GSN_database->cls, |
1982 | &ztn_msg->zone, | 2071 | &zone, |
1983 | &ztn_msg->value_zone, | 2072 | &value_zone, |
1984 | &handle_zone_to_name_it, | 2073 | &handle_zone_to_name_it, |
1985 | &ztn_ctx)) | 2074 | &ztn_ctx)) |
1986 | { | 2075 | { |
@@ -2133,6 +2222,24 @@ run_zone_iteration_round (struct ZoneIteration *zi, uint64_t limit) | |||
2133 | zone_iteration_done_client_continue (zi); | 2222 | zone_iteration_done_client_continue (zi); |
2134 | } | 2223 | } |
2135 | 2224 | ||
2225 | static enum GNUNET_GenericReturnValue | ||
2226 | check_iteration_start (void *cls, | ||
2227 | const struct ZoneIterationStartMessage *zis_msg) | ||
2228 | { | ||
2229 | uint16_t size; | ||
2230 | size_t key_len; | ||
2231 | |||
2232 | size = ntohs (zis_msg->gns_header.header.size); | ||
2233 | key_len = ntohs (zis_msg->key_len); | ||
2234 | |||
2235 | if (size < key_len + sizeof(*zis_msg)) | ||
2236 | { | ||
2237 | GNUNET_break (0); | ||
2238 | return GNUNET_SYSERR; | ||
2239 | } | ||
2240 | return GNUNET_OK; | ||
2241 | } | ||
2242 | |||
2136 | 2243 | ||
2137 | /** | 2244 | /** |
2138 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START message | 2245 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START message |
@@ -2144,18 +2251,35 @@ static void | |||
2144 | handle_iteration_start (void *cls, | 2251 | handle_iteration_start (void *cls, |
2145 | const struct ZoneIterationStartMessage *zis_msg) | 2252 | const struct ZoneIterationStartMessage *zis_msg) |
2146 | { | 2253 | { |
2254 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
2147 | struct NamestoreClient *nc = cls; | 2255 | struct NamestoreClient *nc = cls; |
2148 | struct ZoneIteration *zi; | 2256 | struct ZoneIteration *zi; |
2257 | size_t key_len; | ||
2258 | size_t kb_read; | ||
2149 | 2259 | ||
2150 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2260 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2151 | "Received ZONE_ITERATION_START message\n"); | 2261 | "Received ZONE_ITERATION_START message\n"); |
2262 | key_len = ntohl (zis_msg->key_len); | ||
2152 | zi = GNUNET_new (struct ZoneIteration); | 2263 | zi = GNUNET_new (struct ZoneIteration); |
2264 | if (0 < key_len) | ||
2265 | { | ||
2266 | if ((GNUNET_SYSERR == | ||
2267 | GNUNET_IDENTITY_read_private_key_from_buffer (&zis_msg[1], | ||
2268 | key_len, | ||
2269 | &zone, | ||
2270 | &kb_read)) || | ||
2271 | (kb_read != key_len)) | ||
2272 | { | ||
2273 | GNUNET_SERVICE_client_drop (nc->client); | ||
2274 | GNUNET_free (zi); | ||
2275 | return; | ||
2276 | } | ||
2277 | zi->zone = zone; | ||
2278 | } | ||
2153 | zi->request_id = ntohl (zis_msg->gns_header.r_id); | 2279 | zi->request_id = ntohl (zis_msg->gns_header.r_id); |
2154 | zi->filter = ntohs (zis_msg->filter); | 2280 | zi->filter = ntohs (zis_msg->filter); |
2155 | zi->offset = 0; | 2281 | zi->offset = 0; |
2156 | zi->nc = nc; | 2282 | zi->nc = nc; |
2157 | zi->zone = zis_msg->zone; | ||
2158 | |||
2159 | GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi); | 2283 | GNUNET_CONTAINER_DLL_insert (nc->op_head, nc->op_tail, zi); |
2160 | run_zone_iteration_round (zi, 1); | 2284 | run_zone_iteration_round (zi, 1); |
2161 | } | 2285 | } |
@@ -2349,6 +2473,24 @@ monitor_iterate_cb (void *cls, | |||
2349 | } | 2473 | } |
2350 | } | 2474 | } |
2351 | 2475 | ||
2476 | static enum GNUNET_GenericReturnValue | ||
2477 | check_monitor_start (void *cls, | ||
2478 | const struct ZoneMonitorStartMessage *zis_msg) | ||
2479 | { | ||
2480 | uint16_t size; | ||
2481 | size_t key_len; | ||
2482 | |||
2483 | size = ntohs (zis_msg->header.size); | ||
2484 | key_len = ntohs (zis_msg->key_len); | ||
2485 | |||
2486 | if (size < key_len + sizeof(*zis_msg)) | ||
2487 | { | ||
2488 | GNUNET_break (0); | ||
2489 | return GNUNET_SYSERR; | ||
2490 | } | ||
2491 | return GNUNET_OK; | ||
2492 | } | ||
2493 | |||
2352 | 2494 | ||
2353 | /** | 2495 | /** |
2354 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START message | 2496 | * Handles a #GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START message |
@@ -2360,14 +2502,33 @@ static void | |||
2360 | handle_monitor_start (void *cls, const struct | 2502 | handle_monitor_start (void *cls, const struct |
2361 | ZoneMonitorStartMessage *zis_msg) | 2503 | ZoneMonitorStartMessage *zis_msg) |
2362 | { | 2504 | { |
2505 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
2363 | struct NamestoreClient *nc = cls; | 2506 | struct NamestoreClient *nc = cls; |
2364 | struct ZoneMonitor *zm; | 2507 | struct ZoneMonitor *zm; |
2508 | size_t key_len; | ||
2509 | size_t kb_read; | ||
2365 | 2510 | ||
2366 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2511 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2367 | "Received ZONE_MONITOR_START message\n"); | 2512 | "Received ZONE_MONITOR_START message\n"); |
2368 | zm = GNUNET_new (struct ZoneMonitor); | 2513 | zm = GNUNET_new (struct ZoneMonitor); |
2369 | zm->nc = nc; | 2514 | zm->nc = nc; |
2370 | zm->zone = zis_msg->zone; | 2515 | key_len = ntohl (zis_msg->key_len); |
2516 | if (0 < key_len) | ||
2517 | { | ||
2518 | if ((GNUNET_SYSERR == | ||
2519 | GNUNET_IDENTITY_read_private_key_from_buffer (&zis_msg[1], | ||
2520 | key_len, | ||
2521 | &zone, | ||
2522 | &kb_read)) || | ||
2523 | (kb_read != key_len)) | ||
2524 | { | ||
2525 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
2526 | "Error reading private key\n"); | ||
2527 | GNUNET_SERVICE_client_drop (nc->client); | ||
2528 | return; | ||
2529 | } | ||
2530 | zm->zone = zone; | ||
2531 | } | ||
2371 | zm->limit = 1; | 2532 | zm->limit = 1; |
2372 | zm->filter = ntohs (zis_msg->filter); | 2533 | zm->filter = ntohs (zis_msg->filter); |
2373 | zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first)); | 2534 | zm->in_first_iteration = (GNUNET_YES == ntohl (zis_msg->iterate_first)); |
@@ -2557,14 +2718,14 @@ GNUNET_SERVICE_MAIN ( | |||
2557 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, | 2718 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, |
2558 | struct LabelLookupMessage, | 2719 | struct LabelLookupMessage, |
2559 | NULL), | 2720 | NULL), |
2560 | GNUNET_MQ_hd_fixed_size (zone_to_name, | 2721 | GNUNET_MQ_hd_var_size (zone_to_name, |
2561 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, | 2722 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, |
2562 | struct ZoneToNameMessage, | 2723 | struct ZoneToNameMessage, |
2563 | NULL), | 2724 | NULL), |
2564 | GNUNET_MQ_hd_fixed_size (iteration_start, | 2725 | GNUNET_MQ_hd_var_size (iteration_start, |
2565 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, | 2726 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, |
2566 | struct ZoneIterationStartMessage, | 2727 | struct ZoneIterationStartMessage, |
2567 | NULL), | 2728 | NULL), |
2568 | GNUNET_MQ_hd_fixed_size (iteration_next, | 2729 | GNUNET_MQ_hd_fixed_size (iteration_next, |
2569 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, | 2730 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, |
2570 | struct ZoneIterationNextMessage, | 2731 | struct ZoneIterationNextMessage, |
@@ -2573,10 +2734,10 @@ GNUNET_SERVICE_MAIN ( | |||
2573 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, | 2734 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, |
2574 | struct ZoneIterationStopMessage, | 2735 | struct ZoneIterationStopMessage, |
2575 | NULL), | 2736 | NULL), |
2576 | GNUNET_MQ_hd_fixed_size (monitor_start, | 2737 | GNUNET_MQ_hd_var_size (monitor_start, |
2577 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, | 2738 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START, |
2578 | struct ZoneMonitorStartMessage, | 2739 | struct ZoneMonitorStartMessage, |
2579 | NULL), | 2740 | NULL), |
2580 | GNUNET_MQ_hd_fixed_size (monitor_next, | 2741 | GNUNET_MQ_hd_fixed_size (monitor_next, |
2581 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, | 2742 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, |
2582 | struct ZoneMonitorNextMessage, | 2743 | struct ZoneMonitorNextMessage, |
diff --git a/src/namestore/namestore.h b/src/namestore/namestore.h index 37c1576bc..0b50ac1ab 100644 --- a/src/namestore/namestore.h +++ b/src/namestore/namestore.h | |||
@@ -91,16 +91,17 @@ struct RecordStoreMessage | |||
91 | struct GNUNET_NAMESTORE_Header gns_header; | 91 | struct GNUNET_NAMESTORE_Header gns_header; |
92 | 92 | ||
93 | /** | 93 | /** |
94 | * The private key of the authority. | 94 | * Number of record sets |
95 | */ | 95 | */ |
96 | struct GNUNET_IDENTITY_PrivateKey private_key; | 96 | uint16_t rd_set_count; |
97 | 97 | ||
98 | /** | 98 | /** |
99 | * Number of record sets | 99 | * Length of the zone key |
100 | */ | 100 | */ |
101 | uint16_t rd_set_count; | 101 | uint32_t key_len GNUNET_PACKED; |
102 | 102 | ||
103 | /** | 103 | /** |
104 | * Followed by the private zone key | ||
104 | * Followed by rd_set_count RecordSets | 105 | * Followed by rd_set_count RecordSets |
105 | */ | 106 | */ |
106 | }; | 107 | }; |
@@ -150,11 +151,12 @@ struct LabelLookupMessage | |||
150 | uint16_t filter; | 151 | uint16_t filter; |
151 | 152 | ||
152 | /** | 153 | /** |
153 | * The private key of the zone to look up in | 154 | * Length of the zone key |
154 | */ | 155 | */ |
155 | struct GNUNET_IDENTITY_PrivateKey zone; | 156 | uint32_t key_len GNUNET_PACKED; |
156 | 157 | ||
157 | /* followed by: | 158 | /* followed by: |
159 | * the private zone key | ||
158 | * name with length name_len | 160 | * name with length name_len |
159 | */ | 161 | */ |
160 | }; | 162 | }; |
@@ -192,11 +194,12 @@ struct LabelLookupResponseMessage | |||
192 | int16_t found GNUNET_PACKED; | 194 | int16_t found GNUNET_PACKED; |
193 | 195 | ||
194 | /** | 196 | /** |
195 | * The private key of the authority. | 197 | * Length of the zone key |
196 | */ | 198 | */ |
197 | struct GNUNET_IDENTITY_PrivateKey private_key; | 199 | uint32_t key_len GNUNET_PACKED; |
198 | 200 | ||
199 | /* followed by: | 201 | /* followed by: |
202 | * the private zone key | ||
200 | * name with length name_len | 203 | * name with length name_len |
201 | * serialized record data with rd_count records | 204 | * serialized record data with rd_count records |
202 | */ | 205 | */ |
@@ -214,14 +217,20 @@ struct ZoneToNameMessage | |||
214 | struct GNUNET_NAMESTORE_Header gns_header; | 217 | struct GNUNET_NAMESTORE_Header gns_header; |
215 | 218 | ||
216 | /** | 219 | /** |
217 | * The private key of the zone to look up in | 220 | * Length of the zone key |
221 | */ | ||
222 | uint32_t key_len GNUNET_PACKED; | ||
223 | |||
224 | /** | ||
225 | * Length of the public value zone key | ||
218 | */ | 226 | */ |
219 | struct GNUNET_IDENTITY_PrivateKey zone; | 227 | uint32_t pkey_len GNUNET_PACKED; |
220 | 228 | ||
221 | /** | 229 | /** |
222 | * The public key of the target zone | 230 | * Followed by |
231 | * - the private zone key to look up in | ||
232 | * - the public key of the target zone | ||
223 | */ | 233 | */ |
224 | struct GNUNET_IDENTITY_PublicKey value_zone; | ||
225 | }; | 234 | }; |
226 | 235 | ||
227 | 236 | ||
@@ -259,11 +268,12 @@ struct ZoneToNameResponseMessage | |||
259 | int32_t ec GNUNET_PACKED; | 268 | int32_t ec GNUNET_PACKED; |
260 | 269 | ||
261 | /** | 270 | /** |
262 | * The private key of the zone that contained the name. | 271 | * Length of the zone key |
263 | */ | 272 | */ |
264 | struct GNUNET_IDENTITY_PrivateKey zone; | 273 | uint32_t key_len GNUNET_PACKED; |
265 | 274 | ||
266 | /* followed by: | 275 | /* followed by: |
276 | * the private zone key | ||
267 | * name with length name_len | 277 | * name with length name_len |
268 | * serialized record data with rd_count records | 278 | * serialized record data with rd_count records |
269 | */ | 279 | */ |
@@ -307,11 +317,12 @@ struct RecordResultMessage | |||
307 | uint16_t reserved GNUNET_PACKED; | 317 | uint16_t reserved GNUNET_PACKED; |
308 | 318 | ||
309 | /** | 319 | /** |
310 | * The private key of the authority. | 320 | * Length of the zone key |
311 | */ | 321 | */ |
312 | struct GNUNET_IDENTITY_PrivateKey private_key; | 322 | uint32_t key_len GNUNET_PACKED; |
313 | 323 | ||
314 | /* followed by: | 324 | /* followed by: |
325 | * the private key of the authority | ||
315 | * name with length name_len | 326 | * name with length name_len |
316 | * serialized record data with rd_count records | 327 | * serialized record data with rd_count records |
317 | */ | 328 | */ |
@@ -386,9 +397,13 @@ struct ZoneMonitorStartMessage | |||
386 | uint16_t reserved; | 397 | uint16_t reserved; |
387 | 398 | ||
388 | /** | 399 | /** |
389 | * Zone key. | 400 | * Length of the zone key |
401 | */ | ||
402 | uint32_t key_len GNUNET_PACKED; | ||
403 | |||
404 | /** | ||
405 | * Followed by the private zone key. | ||
390 | */ | 406 | */ |
391 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
392 | }; | 407 | }; |
393 | 408 | ||
394 | 409 | ||
@@ -427,11 +442,6 @@ struct ZoneIterationStartMessage | |||
427 | struct GNUNET_NAMESTORE_Header gns_header; | 442 | struct GNUNET_NAMESTORE_Header gns_header; |
428 | 443 | ||
429 | /** | 444 | /** |
430 | * Zone key. All zeros for "all zones". | ||
431 | */ | ||
432 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
433 | |||
434 | /** | ||
435 | * Record set filter control flags. | 445 | * Record set filter control flags. |
436 | * See GNUNET_NAMESTORE_Filter enum. | 446 | * See GNUNET_NAMESTORE_Filter enum. |
437 | */ | 447 | */ |
@@ -441,6 +451,15 @@ struct ZoneIterationStartMessage | |||
441 | * Reserved for alignment | 451 | * Reserved for alignment |
442 | */ | 452 | */ |
443 | uint16_t reserved; | 453 | uint16_t reserved; |
454 | |||
455 | /** | ||
456 | * Length of the zone key | ||
457 | */ | ||
458 | uint32_t key_len GNUNET_PACKED; | ||
459 | |||
460 | /** | ||
461 | * Followed by the private zone key (optional) | ||
462 | */ | ||
444 | }; | 463 | }; |
445 | 464 | ||
446 | 465 | ||
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c index 41c1fcc73..e020b9e42 100644 --- a/src/namestore/namestore_api.c +++ b/src/namestore/namestore_api.c | |||
@@ -401,18 +401,20 @@ check_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg) | |||
401 | size_t msg_len; | 401 | size_t msg_len; |
402 | size_t name_len; | 402 | size_t name_len; |
403 | size_t rd_len; | 403 | size_t rd_len; |
404 | size_t key_len; | ||
404 | 405 | ||
405 | (void) cls; | 406 | (void) cls; |
406 | rd_len = ntohs (msg->rd_len); | 407 | rd_len = ntohs (msg->rd_len); |
407 | msg_len = ntohs (msg->gns_header.header.size); | 408 | msg_len = ntohs (msg->gns_header.header.size); |
408 | name_len = ntohs (msg->name_len); | 409 | name_len = ntohs (msg->name_len); |
409 | exp_msg_len = sizeof(*msg) + name_len + rd_len; | 410 | key_len = ntohl (msg->key_len); |
411 | exp_msg_len = sizeof(*msg) + name_len + rd_len + key_len; | ||
410 | if (msg_len != exp_msg_len) | 412 | if (msg_len != exp_msg_len) |
411 | { | 413 | { |
412 | GNUNET_break (0); | 414 | GNUNET_break (0); |
413 | return GNUNET_SYSERR; | 415 | return GNUNET_SYSERR; |
414 | } | 416 | } |
415 | name = (const char *) &msg[1]; | 417 | name = (const char *) &msg[1] + key_len; |
416 | if ((name_len > 0) && ('\0' != name[name_len - 1])) | 418 | if ((name_len > 0) && ('\0' != name[name_len - 1])) |
417 | { | 419 | { |
418 | GNUNET_break (0); | 420 | GNUNET_break (0); |
@@ -443,10 +445,13 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg) | |||
443 | { | 445 | { |
444 | struct GNUNET_NAMESTORE_Handle *h = cls; | 446 | struct GNUNET_NAMESTORE_Handle *h = cls; |
445 | struct GNUNET_NAMESTORE_QueueEntry *qe; | 447 | struct GNUNET_NAMESTORE_QueueEntry *qe; |
448 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
446 | const char *name; | 449 | const char *name; |
447 | const char *rd_tmp; | 450 | const char *rd_tmp; |
448 | size_t name_len; | 451 | size_t name_len; |
449 | size_t rd_len; | 452 | size_t rd_len; |
453 | size_t key_len; | ||
454 | size_t kbytes_read; | ||
450 | unsigned int rd_count; | 455 | unsigned int rd_count; |
451 | int16_t found = (int16_t) ntohs (msg->found); | 456 | int16_t found = (int16_t) ntohs (msg->found); |
452 | 457 | ||
@@ -458,12 +463,19 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg) | |||
458 | rd_len = ntohs (msg->rd_len); | 463 | rd_len = ntohs (msg->rd_len); |
459 | rd_count = ntohs (msg->rd_count); | 464 | rd_count = ntohs (msg->rd_count); |
460 | name_len = ntohs (msg->name_len); | 465 | name_len = ntohs (msg->name_len); |
461 | name = (const char *) &msg[1]; | 466 | key_len = ntohl (msg->key_len); |
467 | GNUNET_assert (GNUNET_SYSERR != | ||
468 | GNUNET_IDENTITY_read_private_key_from_buffer (&msg[1], | ||
469 | key_len, | ||
470 | &private_key, | ||
471 | &kbytes_read)); | ||
472 | GNUNET_assert (kbytes_read == key_len); | ||
473 | name = (const char *) &msg[1] + key_len; | ||
462 | if (GNUNET_NO == found) | 474 | if (GNUNET_NO == found) |
463 | { | 475 | { |
464 | /* label was not in namestore */ | 476 | /* label was not in namestore */ |
465 | if (NULL != qe->proc) | 477 | if (NULL != qe->proc) |
466 | qe->proc (qe->proc_cls, &msg->private_key, name, 0, NULL); | 478 | qe->proc (qe->proc_cls, &private_key, name, 0, NULL); |
467 | free_qe (qe); | 479 | free_qe (qe); |
468 | return; | 480 | return; |
469 | } | 481 | } |
@@ -486,7 +498,7 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg) | |||
486 | name = NULL; | 498 | name = NULL; |
487 | if (NULL != qe->proc) | 499 | if (NULL != qe->proc) |
488 | qe->proc (qe->proc_cls, | 500 | qe->proc (qe->proc_cls, |
489 | &msg->private_key, | 501 | &private_key, |
490 | name, | 502 | name, |
491 | rd_count, | 503 | rd_count, |
492 | (rd_count > 0) ? rd : NULL); | 504 | (rd_count > 0) ? rd : NULL); |
@@ -506,33 +518,35 @@ handle_lookup_result (void *cls, const struct LabelLookupResponseMessage *msg) | |||
506 | static int | 518 | static int |
507 | check_record_result (void *cls, const struct RecordResultMessage *msg) | 519 | check_record_result (void *cls, const struct RecordResultMessage *msg) |
508 | { | 520 | { |
509 | static struct GNUNET_IDENTITY_PrivateKey priv_dummy; | ||
510 | const char *name; | 521 | const char *name; |
511 | size_t msg_len; | 522 | size_t msg_len; |
512 | size_t name_len; | 523 | size_t name_len; |
513 | size_t rd_len; | 524 | size_t rd_len; |
525 | size_t key_len; | ||
514 | 526 | ||
515 | (void) cls; | 527 | (void) cls; |
516 | rd_len = ntohs (msg->rd_len); | 528 | rd_len = ntohs (msg->rd_len); |
517 | msg_len = ntohs (msg->gns_header.header.size); | 529 | msg_len = ntohs (msg->gns_header.header.size); |
530 | key_len = ntohl (msg->key_len); | ||
518 | name_len = ntohs (msg->name_len); | 531 | name_len = ntohs (msg->name_len); |
519 | if (0 != ntohs (msg->reserved)) | 532 | if (0 != ntohs (msg->reserved)) |
520 | { | 533 | { |
521 | GNUNET_break (0); | 534 | GNUNET_break (0); |
522 | return GNUNET_SYSERR; | 535 | return GNUNET_SYSERR; |
523 | } | 536 | } |
524 | if (msg_len != sizeof(struct RecordResultMessage) + name_len + rd_len) | 537 | if (msg_len != sizeof(struct RecordResultMessage) + key_len + name_len |
538 | + rd_len) | ||
525 | { | 539 | { |
526 | GNUNET_break (0); | 540 | GNUNET_break (0); |
527 | return GNUNET_SYSERR; | 541 | return GNUNET_SYSERR; |
528 | } | 542 | } |
529 | name = (const char *) &msg[1]; | 543 | name = (const char *) &msg[1] + key_len; |
530 | if ((0 == name_len) || ('\0' != name[name_len - 1])) | 544 | if ((0 == name_len) || ('\0' != name[name_len - 1])) |
531 | { | 545 | { |
532 | GNUNET_break (0); | 546 | GNUNET_break (0); |
533 | return GNUNET_SYSERR; | 547 | return GNUNET_SYSERR; |
534 | } | 548 | } |
535 | if (0 == GNUNET_memcmp (&msg->private_key, &priv_dummy)) | 549 | if (0 == key_len) |
536 | { | 550 | { |
537 | GNUNET_break (0); | 551 | GNUNET_break (0); |
538 | return GNUNET_SYSERR; | 552 | return GNUNET_SYSERR; |
@@ -554,16 +568,20 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg) | |||
554 | struct GNUNET_NAMESTORE_Handle *h = cls; | 568 | struct GNUNET_NAMESTORE_Handle *h = cls; |
555 | struct GNUNET_NAMESTORE_QueueEntry *qe; | 569 | struct GNUNET_NAMESTORE_QueueEntry *qe; |
556 | struct GNUNET_NAMESTORE_ZoneIterator *ze; | 570 | struct GNUNET_NAMESTORE_ZoneIterator *ze; |
571 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
557 | const char *name; | 572 | const char *name; |
558 | const char *rd_tmp; | 573 | const char *rd_tmp; |
559 | size_t name_len; | 574 | size_t name_len; |
560 | size_t rd_len; | 575 | size_t rd_len; |
576 | size_t key_len; | ||
577 | size_t kbytes_read; | ||
561 | unsigned int rd_count; | 578 | unsigned int rd_count; |
562 | 579 | ||
563 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n"); | 580 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n"); |
564 | rd_len = ntohs (msg->rd_len); | 581 | rd_len = ntohs (msg->rd_len); |
565 | rd_count = ntohs (msg->rd_count); | 582 | rd_count = ntohs (msg->rd_count); |
566 | name_len = ntohs (msg->name_len); | 583 | name_len = ntohs (msg->name_len); |
584 | key_len = ntohl (msg->key_len); | ||
567 | ze = find_zi (h, ntohl (msg->gns_header.r_id)); | 585 | ze = find_zi (h, ntohl (msg->gns_header.r_id)); |
568 | qe = find_qe (h, ntohl (msg->gns_header.r_id)); | 586 | qe = find_qe (h, ntohl (msg->gns_header.r_id)); |
569 | if ((NULL == ze) && (NULL == qe)) | 587 | if ((NULL == ze) && (NULL == qe)) |
@@ -574,7 +592,13 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg) | |||
574 | force_reconnect (h); | 592 | force_reconnect (h); |
575 | return; | 593 | return; |
576 | } | 594 | } |
577 | name = (const char *) &msg[1]; | 595 | name = (const char *) &msg[1] + key_len; |
596 | GNUNET_assert (GNUNET_SYSERR != | ||
597 | GNUNET_IDENTITY_read_private_key_from_buffer (&msg[1], | ||
598 | key_len, | ||
599 | &private_key, | ||
600 | &kbytes_read)); | ||
601 | GNUNET_assert (kbytes_read == key_len); | ||
578 | rd_tmp = &name[name_len]; | 602 | rd_tmp = &name[name_len]; |
579 | { | 603 | { |
580 | struct GNUNET_GNSRECORD_Data rd[rd_count]; | 604 | struct GNUNET_GNSRECORD_Data rd[rd_count]; |
@@ -588,7 +612,7 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg) | |||
588 | { | 612 | { |
589 | if (NULL != qe->proc) | 613 | if (NULL != qe->proc) |
590 | qe->proc (qe->proc_cls, | 614 | qe->proc (qe->proc_cls, |
591 | &msg->private_key, | 615 | &private_key, |
592 | name, | 616 | name, |
593 | rd_count, | 617 | rd_count, |
594 | (rd_count > 0) ? rd : NULL); | 618 | (rd_count > 0) ? rd : NULL); |
@@ -598,9 +622,9 @@ handle_record_result (void *cls, const struct RecordResultMessage *msg) | |||
598 | if (NULL != ze) | 622 | if (NULL != ze) |
599 | { | 623 | { |
600 | if (NULL != ze->proc) | 624 | if (NULL != ze->proc) |
601 | ze->proc (ze->proc_cls, &msg->private_key, name, rd_count, rd); | 625 | ze->proc (ze->proc_cls, &private_key, name, rd_count, rd); |
602 | if (NULL != ze->proc2) | 626 | if (NULL != ze->proc2) |
603 | ze->proc2 (ze->proc_cls, &msg->private_key, name, | 627 | ze->proc2 (ze->proc_cls, &private_key, name, |
604 | rd_count, rd, GNUNET_TIME_absolute_ntoh (msg->expire)); | 628 | rd_count, rd, GNUNET_TIME_absolute_ntoh (msg->expire)); |
605 | return; | 629 | return; |
606 | } | 630 | } |
@@ -680,20 +704,23 @@ check_zone_to_name_response (void *cls, | |||
680 | { | 704 | { |
681 | size_t name_len; | 705 | size_t name_len; |
682 | size_t rd_ser_len; | 706 | size_t rd_ser_len; |
707 | size_t key_len; | ||
683 | const char *name_tmp; | 708 | const char *name_tmp; |
684 | 709 | ||
685 | (void) cls; | 710 | (void) cls; |
686 | if (GNUNET_EC_NONE != ntohl (msg->ec)) | 711 | if (GNUNET_EC_NONE != ntohl (msg->ec)) |
687 | return GNUNET_OK; | 712 | return GNUNET_OK; |
713 | key_len = ntohl (msg->key_len); | ||
688 | name_len = ntohs (msg->name_len); | 714 | name_len = ntohs (msg->name_len); |
689 | rd_ser_len = ntohs (msg->rd_len); | 715 | rd_ser_len = ntohs (msg->rd_len); |
690 | if (ntohs (msg->gns_header.header.size) != | 716 | if (ntohs (msg->gns_header.header.size) != |
691 | sizeof(struct ZoneToNameResponseMessage) + name_len + rd_ser_len) | 717 | sizeof(struct ZoneToNameResponseMessage) + key_len + name_len |
718 | + rd_ser_len) | ||
692 | { | 719 | { |
693 | GNUNET_break (0); | 720 | GNUNET_break (0); |
694 | return GNUNET_SYSERR; | 721 | return GNUNET_SYSERR; |
695 | } | 722 | } |
696 | name_tmp = (const char *) &msg[1]; | 723 | name_tmp = (const char *) &msg[1] + key_len; |
697 | if ((name_len > 0) && ('\0' != name_tmp[name_len - 1])) | 724 | if ((name_len > 0) && ('\0' != name_tmp[name_len - 1])) |
698 | { | 725 | { |
699 | GNUNET_break (0); | 726 | GNUNET_break (0); |
@@ -716,12 +743,15 @@ handle_zone_to_name_response (void *cls, | |||
716 | { | 743 | { |
717 | struct GNUNET_NAMESTORE_Handle *h = cls; | 744 | struct GNUNET_NAMESTORE_Handle *h = cls; |
718 | struct GNUNET_NAMESTORE_QueueEntry *qe; | 745 | struct GNUNET_NAMESTORE_QueueEntry *qe; |
746 | struct GNUNET_IDENTITY_PrivateKey zone; | ||
719 | enum GNUNET_ErrorCode res; | 747 | enum GNUNET_ErrorCode res; |
720 | size_t name_len; | 748 | size_t name_len; |
721 | size_t rd_ser_len; | 749 | size_t rd_ser_len; |
722 | unsigned int rd_count; | 750 | unsigned int rd_count; |
723 | const char *name_tmp; | 751 | const char *name_tmp; |
724 | const char *rd_tmp; | 752 | const char *rd_tmp; |
753 | size_t key_len; | ||
754 | size_t kbytes_read; | ||
725 | 755 | ||
726 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n"); | 756 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n"); |
727 | qe = find_qe (h, ntohl (msg->gns_header.r_id)); | 757 | qe = find_qe (h, ntohl (msg->gns_header.r_id)); |
@@ -732,6 +762,13 @@ handle_zone_to_name_response (void *cls, | |||
732 | return; | 762 | return; |
733 | } | 763 | } |
734 | res = ntohl (msg->ec); | 764 | res = ntohl (msg->ec); |
765 | key_len = ntohl (msg->key_len); | ||
766 | GNUNET_assert (GNUNET_SYSERR != | ||
767 | GNUNET_IDENTITY_read_private_key_from_buffer (&msg[1], | ||
768 | key_len, | ||
769 | &zone, | ||
770 | &kbytes_read)); | ||
771 | GNUNET_assert (kbytes_read == key_len); | ||
735 | switch (res) | 772 | switch (res) |
736 | { | 773 | { |
737 | break; | 774 | break; |
@@ -740,7 +777,7 @@ handle_zone_to_name_response (void *cls, | |||
740 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 777 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
741 | "Namestore has no result for zone to name mapping \n"); | 778 | "Namestore has no result for zone to name mapping \n"); |
742 | if (NULL != qe->proc) | 779 | if (NULL != qe->proc) |
743 | qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL); | 780 | qe->proc (qe->proc_cls, &zone, NULL, 0, NULL); |
744 | free_qe (qe); | 781 | free_qe (qe); |
745 | return; | 782 | return; |
746 | 783 | ||
@@ -750,7 +787,7 @@ handle_zone_to_name_response (void *cls, | |||
750 | name_len = ntohs (msg->name_len); | 787 | name_len = ntohs (msg->name_len); |
751 | rd_count = ntohs (msg->rd_count); | 788 | rd_count = ntohs (msg->rd_count); |
752 | rd_ser_len = ntohs (msg->rd_len); | 789 | rd_ser_len = ntohs (msg->rd_len); |
753 | name_tmp = (const char *) &msg[1]; | 790 | name_tmp = (const char *) &msg[1] + key_len; |
754 | rd_tmp = &name_tmp[name_len]; | 791 | rd_tmp = &name_tmp[name_len]; |
755 | { | 792 | { |
756 | struct GNUNET_GNSRECORD_Data rd[rd_count]; | 793 | struct GNUNET_GNSRECORD_Data rd[rd_count]; |
@@ -762,7 +799,7 @@ handle_zone_to_name_response (void *cls, | |||
762 | rd)); | 799 | rd)); |
763 | /* normal end, call continuation with result */ | 800 | /* normal end, call continuation with result */ |
764 | if (NULL != qe->proc) | 801 | if (NULL != qe->proc) |
765 | qe->proc (qe->proc_cls, &msg->zone, name_tmp, rd_count, rd); | 802 | qe->proc (qe->proc_cls, &zone, name_tmp, rd_count, rd); |
766 | /* return is important here: break would call continuation with error! */ | 803 | /* return is important here: break would call continuation with error! */ |
767 | free_qe (qe); | 804 | free_qe (qe); |
768 | return; | 805 | return; |
@@ -1050,7 +1087,10 @@ GNUNET_NAMESTORE_records_store2 ( | |||
1050 | ssize_t sret; | 1087 | ssize_t sret; |
1051 | int i; | 1088 | int i; |
1052 | size_t rd_set_len = 0; | 1089 | size_t rd_set_len = 0; |
1053 | size_t max_len = UINT16_MAX - sizeof (struct RecordStoreMessage); | 1090 | size_t key_len = 0; |
1091 | size_t max_len; | ||
1092 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1093 | max_len = UINT16_MAX - key_len - sizeof (struct RecordStoreMessage); | ||
1054 | 1094 | ||
1055 | *rds_sent = 0; | 1095 | *rds_sent = 0; |
1056 | for (i = 0; i < rd_set_count; i++) | 1096 | for (i = 0; i < rd_set_count; i++) |
@@ -1093,17 +1133,19 @@ GNUNET_NAMESTORE_records_store2 ( | |||
1093 | qe->cont_cls = cont_cls; | 1133 | qe->cont_cls = cont_cls; |
1094 | qe->op_id = rid; | 1134 | qe->op_id = rid; |
1095 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); | 1135 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); |
1096 | |||
1097 | /* setup msg */ | 1136 | /* setup msg */ |
1098 | env = GNUNET_MQ_msg_extra (msg, | 1137 | env = GNUNET_MQ_msg_extra (msg, |
1099 | rd_set_len, | 1138 | key_len + rd_set_len, |
1100 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE); | 1139 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE); |
1101 | GNUNET_assert (NULL != msg); | 1140 | GNUNET_assert (NULL != msg); |
1102 | GNUNET_assert (NULL != env); | 1141 | GNUNET_assert (NULL != env); |
1103 | msg->gns_header.r_id = htonl (rid); | 1142 | msg->gns_header.r_id = htonl (rid); |
1143 | msg->key_len = htonl (key_len); | ||
1104 | msg->rd_set_count = htons ((uint16_t) (*rds_sent)); | 1144 | msg->rd_set_count = htons ((uint16_t) (*rds_sent)); |
1105 | msg->private_key = *pkey; | 1145 | GNUNET_IDENTITY_write_private_key_to_buffer (pkey, |
1106 | rd_set = (struct RecordSet*) &msg[1]; | 1146 | &msg[1], |
1147 | key_len); | ||
1148 | rd_set = (struct RecordSet*) (((char*) &msg[1]) + key_len); | ||
1107 | for (int i = 0; i < *rds_sent; i++) | 1149 | for (int i = 0; i < *rds_sent; i++) |
1108 | { | 1150 | { |
1109 | label = record_info[i].a_label; | 1151 | label = record_info[i].a_label; |
@@ -1162,6 +1204,7 @@ records_lookup ( | |||
1162 | struct GNUNET_MQ_Envelope *env; | 1204 | struct GNUNET_MQ_Envelope *env; |
1163 | struct LabelLookupMessage *msg; | 1205 | struct LabelLookupMessage *msg; |
1164 | size_t label_len; | 1206 | size_t label_len; |
1207 | size_t key_len; | ||
1165 | 1208 | ||
1166 | if (1 == (label_len = strlen (label) + 1)) | 1209 | if (1 == (label_len = strlen (label) + 1)) |
1167 | { | 1210 | { |
@@ -1178,15 +1221,20 @@ records_lookup ( | |||
1178 | qe->op_id = get_op_id (h); | 1221 | qe->op_id = get_op_id (h); |
1179 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); | 1222 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); |
1180 | 1223 | ||
1224 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1181 | env = GNUNET_MQ_msg_extra (msg, | 1225 | env = GNUNET_MQ_msg_extra (msg, |
1182 | label_len, | 1226 | label_len + key_len, |
1183 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP); | 1227 | GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP); |
1184 | msg->gns_header.r_id = htonl (qe->op_id); | 1228 | msg->gns_header.r_id = htonl (qe->op_id); |
1185 | msg->zone = *pkey; | 1229 | GNUNET_IDENTITY_write_private_key_to_buffer (pkey, |
1230 | &msg[1], | ||
1231 | key_len); | ||
1232 | |||
1233 | msg->key_len = htonl (key_len); | ||
1186 | msg->is_edit_request = htonl (is_edit_request); | 1234 | msg->is_edit_request = htonl (is_edit_request); |
1187 | msg->label_len = htonl (label_len); | 1235 | msg->label_len = htonl (label_len); |
1188 | msg->filter = htons (filter); | 1236 | msg->filter = htons (filter); |
1189 | GNUNET_memcpy (&msg[1], label, label_len); | 1237 | GNUNET_memcpy (((char*) &msg[1]) + key_len, label, label_len); |
1190 | if (NULL == h->mq) | 1238 | if (NULL == h->mq) |
1191 | qe->env = env; | 1239 | qe->env = env; |
1192 | else | 1240 | else |
@@ -1257,6 +1305,8 @@ GNUNET_NAMESTORE_zone_to_name ( | |||
1257 | struct GNUNET_MQ_Envelope *env; | 1305 | struct GNUNET_MQ_Envelope *env; |
1258 | struct ZoneToNameMessage *msg; | 1306 | struct ZoneToNameMessage *msg; |
1259 | uint32_t rid; | 1307 | uint32_t rid; |
1308 | size_t key_len; | ||
1309 | ssize_t pkey_len; | ||
1260 | 1310 | ||
1261 | rid = get_op_id (h); | 1311 | rid = get_op_id (h); |
1262 | qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry); | 1312 | qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry); |
@@ -1268,10 +1318,17 @@ GNUNET_NAMESTORE_zone_to_name ( | |||
1268 | qe->op_id = rid; | 1318 | qe->op_id = rid; |
1269 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); | 1319 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe); |
1270 | 1320 | ||
1271 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME); | 1321 | key_len = GNUNET_IDENTITY_private_key_get_length (zone); |
1322 | pkey_len = GNUNET_IDENTITY_public_key_get_length (value_zone); | ||
1323 | env = GNUNET_MQ_msg_extra (msg, key_len + pkey_len, | ||
1324 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME); | ||
1272 | msg->gns_header.r_id = htonl (rid); | 1325 | msg->gns_header.r_id = htonl (rid); |
1273 | msg->zone = *zone; | 1326 | msg->key_len = htonl (key_len); |
1274 | msg->value_zone = *value_zone; | 1327 | msg->pkey_len = htonl (pkey_len); |
1328 | GNUNET_IDENTITY_write_private_key_to_buffer (zone, &msg[1], key_len); | ||
1329 | GNUNET_IDENTITY_write_public_key_to_buffer (value_zone, | ||
1330 | (char*) &msg[1] + key_len, | ||
1331 | pkey_len); | ||
1275 | if (NULL == h->mq) | 1332 | if (NULL == h->mq) |
1276 | qe->env = env; | 1333 | qe->env = env; |
1277 | else | 1334 | else |
@@ -1295,6 +1352,7 @@ GNUNET_NAMESTORE_zone_iteration_start ( | |||
1295 | struct GNUNET_MQ_Envelope *env; | 1352 | struct GNUNET_MQ_Envelope *env; |
1296 | struct ZoneIterationStartMessage *msg; | 1353 | struct ZoneIterationStartMessage *msg; |
1297 | uint32_t rid; | 1354 | uint32_t rid; |
1355 | size_t key_len = 0; | ||
1298 | 1356 | ||
1299 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n"); | 1357 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n"); |
1300 | rid = get_op_id (h); | 1358 | rid = get_op_id (h); |
@@ -1308,12 +1366,18 @@ GNUNET_NAMESTORE_zone_iteration_start ( | |||
1308 | it->proc_cls = proc_cls; | 1366 | it->proc_cls = proc_cls; |
1309 | it->op_id = rid; | 1367 | it->op_id = rid; |
1310 | if (NULL != zone) | 1368 | if (NULL != zone) |
1369 | { | ||
1311 | it->zone = *zone; | 1370 | it->zone = *zone; |
1371 | key_len = GNUNET_IDENTITY_private_key_get_length (zone); | ||
1372 | } | ||
1312 | GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it); | 1373 | GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it); |
1313 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START); | 1374 | env = GNUNET_MQ_msg_extra (msg, |
1375 | key_len, | ||
1376 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START); | ||
1314 | msg->gns_header.r_id = htonl (rid); | 1377 | msg->gns_header.r_id = htonl (rid); |
1378 | msg->key_len = htonl (key_len); | ||
1315 | if (NULL != zone) | 1379 | if (NULL != zone) |
1316 | msg->zone = *zone; | 1380 | GNUNET_IDENTITY_write_private_key_to_buffer (zone, &msg[1], key_len); |
1317 | if (NULL == h->mq) | 1381 | if (NULL == h->mq) |
1318 | it->env = env; | 1382 | it->env = env; |
1319 | else | 1383 | else |
@@ -1337,6 +1401,7 @@ GNUNET_NAMESTORE_zone_iteration_start2 ( | |||
1337 | struct GNUNET_MQ_Envelope *env; | 1401 | struct GNUNET_MQ_Envelope *env; |
1338 | struct ZoneIterationStartMessage *msg; | 1402 | struct ZoneIterationStartMessage *msg; |
1339 | uint32_t rid; | 1403 | uint32_t rid; |
1404 | size_t key_len = 0; | ||
1340 | 1405 | ||
1341 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n"); | 1406 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n"); |
1342 | rid = get_op_id (h); | 1407 | rid = get_op_id (h); |
@@ -1350,13 +1415,19 @@ GNUNET_NAMESTORE_zone_iteration_start2 ( | |||
1350 | it->proc_cls = proc_cls; | 1415 | it->proc_cls = proc_cls; |
1351 | it->op_id = rid; | 1416 | it->op_id = rid; |
1352 | if (NULL != zone) | 1417 | if (NULL != zone) |
1418 | { | ||
1353 | it->zone = *zone; | 1419 | it->zone = *zone; |
1420 | key_len = GNUNET_IDENTITY_private_key_get_length (zone); | ||
1421 | } | ||
1354 | GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it); | 1422 | GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it); |
1355 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START); | 1423 | env = GNUNET_MQ_msg_extra (msg, |
1424 | key_len, | ||
1425 | GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START); | ||
1356 | msg->gns_header.r_id = htonl (rid); | 1426 | msg->gns_header.r_id = htonl (rid); |
1427 | msg->key_len = htonl (key_len); | ||
1357 | msg->filter = htons ((uint16_t) filter); | 1428 | msg->filter = htons ((uint16_t) filter); |
1358 | if (NULL != zone) | 1429 | if (NULL != zone) |
1359 | msg->zone = *zone; | 1430 | GNUNET_IDENTITY_write_private_key_to_buffer (zone, &msg[1], key_len); |
1360 | if (NULL == h->mq) | 1431 | if (NULL == h->mq) |
1361 | it->env = env; | 1432 | it->env = env; |
1362 | else | 1433 | else |
diff --git a/src/namestore/namestore_api_monitor.c b/src/namestore/namestore_api_monitor.c index 56ae8cb53..81ea41f7d 100644 --- a/src/namestore/namestore_api_monitor.c +++ b/src/namestore/namestore_api_monitor.c | |||
@@ -98,6 +98,11 @@ struct GNUNET_NAMESTORE_ZoneMonitor | |||
98 | * Do we first iterate over all existing records? | 98 | * Do we first iterate over all existing records? |
99 | */ | 99 | */ |
100 | int iterate_first; | 100 | int iterate_first; |
101 | |||
102 | /** | ||
103 | * Zone key length | ||
104 | */ | ||
105 | uint32_t key_len; | ||
101 | }; | 106 | }; |
102 | 107 | ||
103 | 108 | ||
@@ -146,10 +151,12 @@ check_result (void *cls, const struct RecordResultMessage *lrm) | |||
146 | unsigned rd_count; | 151 | unsigned rd_count; |
147 | const char *name_tmp; | 152 | const char *name_tmp; |
148 | const char *rd_ser_tmp; | 153 | const char *rd_ser_tmp; |
154 | size_t key_len; | ||
149 | 155 | ||
156 | (void) zm; | ||
157 | key_len = ntohl (lrm->key_len); | ||
150 | (void) cls; | 158 | (void) cls; |
151 | if ((0 != GNUNET_memcmp (&lrm->private_key, &zm->zone)) && | 159 | if (0 == key_len) |
152 | (GNUNET_NO == GNUNET_is_zero (&zm->zone))) | ||
153 | { | 160 | { |
154 | GNUNET_break (0); | 161 | GNUNET_break (0); |
155 | return GNUNET_SYSERR; | 162 | return GNUNET_SYSERR; |
@@ -163,7 +170,7 @@ check_result (void *cls, const struct RecordResultMessage *lrm) | |||
163 | GNUNET_break (0); | 170 | GNUNET_break (0); |
164 | return GNUNET_SYSERR; | 171 | return GNUNET_SYSERR; |
165 | } | 172 | } |
166 | exp_lrm_len = sizeof(struct RecordResultMessage) + name_len + rd_len; | 173 | exp_lrm_len = sizeof(struct RecordResultMessage) + name_len + rd_len + key_len; |
167 | if (lrm_len != exp_lrm_len) | 174 | if (lrm_len != exp_lrm_len) |
168 | { | 175 | { |
169 | GNUNET_break (0); | 176 | GNUNET_break (0); |
@@ -174,7 +181,7 @@ check_result (void *cls, const struct RecordResultMessage *lrm) | |||
174 | GNUNET_break (0); | 181 | GNUNET_break (0); |
175 | return GNUNET_SYSERR; | 182 | return GNUNET_SYSERR; |
176 | } | 183 | } |
177 | name_tmp = (const char *) &lrm[1]; | 184 | name_tmp = (const char *) &lrm[1] + key_len; |
178 | if (name_tmp[name_len - 1] != '\0') | 185 | if (name_tmp[name_len - 1] != '\0') |
179 | { | 186 | { |
180 | GNUNET_break (0); | 187 | GNUNET_break (0); |
@@ -206,16 +213,26 @@ static void | |||
206 | handle_result (void *cls, const struct RecordResultMessage *lrm) | 213 | handle_result (void *cls, const struct RecordResultMessage *lrm) |
207 | { | 214 | { |
208 | struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls; | 215 | struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls; |
216 | struct GNUNET_IDENTITY_PrivateKey private_key; | ||
209 | size_t name_len; | 217 | size_t name_len; |
210 | size_t rd_len; | 218 | size_t rd_len; |
219 | size_t key_len; | ||
220 | size_t kbytes_read; | ||
211 | unsigned rd_count; | 221 | unsigned rd_count; |
212 | const char *name_tmp; | 222 | const char *name_tmp; |
213 | const char *rd_ser_tmp; | 223 | const char *rd_ser_tmp; |
214 | 224 | ||
225 | key_len = ntohl (lrm->key_len); | ||
215 | rd_len = ntohs (lrm->rd_len); | 226 | rd_len = ntohs (lrm->rd_len); |
216 | rd_count = ntohs (lrm->rd_count); | 227 | rd_count = ntohs (lrm->rd_count); |
217 | name_len = ntohs (lrm->name_len); | 228 | name_len = ntohs (lrm->name_len); |
218 | name_tmp = (const char *) &lrm[1]; | 229 | name_tmp = (const char *) &lrm[1] + key_len; |
230 | GNUNET_assert (GNUNET_SYSERR != | ||
231 | GNUNET_IDENTITY_read_private_key_from_buffer (&lrm[1], | ||
232 | key_len, | ||
233 | &private_key, | ||
234 | &kbytes_read)); | ||
235 | GNUNET_assert (kbytes_read == key_len); | ||
219 | rd_ser_tmp = (const char *) &name_tmp[name_len]; | 236 | rd_ser_tmp = (const char *) &name_tmp[name_len]; |
220 | { | 237 | { |
221 | struct GNUNET_GNSRECORD_Data rd[rd_count]; | 238 | struct GNUNET_GNSRECORD_Data rd[rd_count]; |
@@ -224,10 +241,10 @@ handle_result (void *cls, const struct RecordResultMessage *lrm) | |||
224 | GNUNET_OK == | 241 | GNUNET_OK == |
225 | GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd)); | 242 | GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd)); |
226 | if (NULL != zm->monitor2) | 243 | if (NULL != zm->monitor2) |
227 | zm->monitor2 (zm->monitor_cls, &lrm->private_key, name_tmp, | 244 | zm->monitor2 (zm->monitor_cls, &private_key, name_tmp, |
228 | rd_count, rd, GNUNET_TIME_absolute_ntoh (lrm->expire)); | 245 | rd_count, rd, GNUNET_TIME_absolute_ntoh (lrm->expire)); |
229 | else | 246 | else |
230 | zm->monitor (zm->monitor_cls, &lrm->private_key, name_tmp, rd_count, rd); | 247 | zm->monitor (zm->monitor_cls, &private_key, name_tmp, rd_count, rd); |
231 | } | 248 | } |
232 | } | 249 | } |
233 | 250 | ||
@@ -283,9 +300,15 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm) | |||
283 | zm); | 300 | zm); |
284 | if (NULL == zm->mq) | 301 | if (NULL == zm->mq) |
285 | return; | 302 | return; |
286 | env = GNUNET_MQ_msg (sm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START); | 303 | env = GNUNET_MQ_msg_extra (sm, |
304 | zm->key_len, | ||
305 | GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START); | ||
287 | sm->iterate_first = htonl (zm->iterate_first); | 306 | sm->iterate_first = htonl (zm->iterate_first); |
288 | sm->zone = zm->zone; | 307 | if (0 < zm->key_len) |
308 | GNUNET_IDENTITY_write_private_key_to_buffer (&zm->zone, | ||
309 | &sm[1], | ||
310 | zm->key_len); | ||
311 | sm->key_len = htonl (zm->key_len); | ||
289 | sm->filter = htons (zm->filter); | 312 | sm->filter = htons (zm->filter); |
290 | GNUNET_MQ_send (zm->mq, env); | 313 | GNUNET_MQ_send (zm->mq, env); |
291 | } | 314 | } |
@@ -307,7 +330,10 @@ GNUNET_NAMESTORE_zone_monitor_start ( | |||
307 | 330 | ||
308 | zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor); | 331 | zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor); |
309 | if (NULL != zone) | 332 | if (NULL != zone) |
333 | { | ||
334 | zm->key_len = GNUNET_IDENTITY_private_key_get_length (zone); | ||
310 | zm->zone = *zone; | 335 | zm->zone = *zone; |
336 | } | ||
311 | zm->iterate_first = iterate_first; | 337 | zm->iterate_first = iterate_first; |
312 | zm->error_cb = error_cb; | 338 | zm->error_cb = error_cb; |
313 | zm->error_cb_cls = error_cb_cls; | 339 | zm->error_cb_cls = error_cb_cls; |
@@ -342,7 +368,10 @@ GNUNET_NAMESTORE_zone_monitor_start2 ( | |||
342 | 368 | ||
343 | zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor); | 369 | zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor); |
344 | if (NULL != zone) | 370 | if (NULL != zone) |
371 | { | ||
372 | zm->key_len = GNUNET_IDENTITY_private_key_get_length (zone); | ||
345 | zm->zone = *zone; | 373 | zm->zone = *zone; |
374 | } | ||
346 | zm->iterate_first = iterate_first; | 375 | zm->iterate_first = iterate_first; |
347 | zm->error_cb = error_cb; | 376 | zm->error_cb = error_cb; |
348 | zm->error_cb_cls = error_cb_cls; | 377 | zm->error_cb_cls = error_cb_cls; |
diff --git a/src/reclaim/Makefile.am b/src/reclaim/Makefile.am index d29b5857a..37af360c8 100644 --- a/src/reclaim/Makefile.am +++ b/src/reclaim/Makefile.am | |||
@@ -138,6 +138,7 @@ libgnunetreclaim_la_SOURCES = \ | |||
138 | reclaim_credential.h | 138 | reclaim_credential.h |
139 | libgnunetreclaim_la_LIBADD = \ | 139 | libgnunetreclaim_la_LIBADD = \ |
140 | $(top_builddir)/src/util/libgnunetutil.la \ | 140 | $(top_builddir)/src/util/libgnunetutil.la \ |
141 | $(top_builddir)/src/identity/libgnunetidentity.la \ | ||
141 | $(GN_LIBINTL) $(XLIB) | 142 | $(GN_LIBINTL) $(XLIB) |
142 | libgnunetreclaim_la_LDFLAGS = \ | 143 | libgnunetreclaim_la_LDFLAGS = \ |
143 | $(GN_LIB_LDFLAGS) \ | 144 | $(GN_LIB_LDFLAGS) \ |
diff --git a/src/reclaim/gnunet-service-reclaim.c b/src/reclaim/gnunet-service-reclaim.c index 5c484e55d..ea97f8749 100644 --- a/src/reclaim/gnunet-service-reclaim.c +++ b/src/reclaim/gnunet-service-reclaim.c | |||
@@ -657,18 +657,27 @@ send_ticket_result (const struct IdpClient *client, | |||
657 | struct TicketResultMessage *irm; | 657 | struct TicketResultMessage *irm; |
658 | struct GNUNET_MQ_Envelope *env; | 658 | struct GNUNET_MQ_Envelope *env; |
659 | size_t pres_len = 0; | 659 | size_t pres_len = 0; |
660 | size_t tkt_len = 0; | ||
661 | ssize_t written; | ||
662 | char *buf; | ||
660 | 663 | ||
661 | if (NULL != presentations) | 664 | if (NULL != presentations) |
662 | { | 665 | { |
663 | pres_len = | 666 | pres_len = |
664 | GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations); | 667 | GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations); |
665 | } | 668 | } |
669 | if (NULL != ticket) | ||
670 | tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket); | ||
666 | env = GNUNET_MQ_msg_extra (irm, | 671 | env = GNUNET_MQ_msg_extra (irm, |
667 | pres_len, | 672 | pres_len + tkt_len, |
668 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | 673 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); |
674 | buf = (char*) &irm[1]; | ||
669 | if (NULL != ticket) | 675 | if (NULL != ticket) |
670 | { | 676 | { |
671 | irm->ticket = *ticket; | 677 | irm->tkt_len = htonl (tkt_len); |
678 | written = GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len); | ||
679 | GNUNET_assert (0 <= written); | ||
680 | buf += written; | ||
672 | } | 681 | } |
673 | // TODO add success member | 682 | // TODO add success member |
674 | irm->id = htonl (r_id); | 683 | irm->id = htonl (r_id); |
@@ -676,7 +685,7 @@ send_ticket_result (const struct IdpClient *client, | |||
676 | if (NULL != presentations) | 685 | if (NULL != presentations) |
677 | { | 686 | { |
678 | GNUNET_RECLAIM_presentation_list_serialize (presentations, | 687 | GNUNET_RECLAIM_presentation_list_serialize (presentations, |
679 | (char*) &irm[1]); | 688 | buf); |
680 | } | 689 | } |
681 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); | 690 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); |
682 | GNUNET_MQ_send (client->mq, env); | 691 | GNUNET_MQ_send (client->mq, env); |
@@ -732,11 +741,15 @@ check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im) | |||
732 | { | 741 | { |
733 | uint16_t size; | 742 | uint16_t size; |
734 | size_t attrs_len; | 743 | size_t attrs_len; |
744 | size_t key_len; | ||
745 | size_t pkey_len; | ||
735 | 746 | ||
736 | size = ntohs (im->header.size); | 747 | size = ntohs (im->header.size); |
737 | attrs_len = ntohs (im->attr_len); | 748 | attrs_len = ntohs (im->attr_len); |
738 | 749 | key_len = ntohl (im->key_len); | |
739 | if (attrs_len > size - sizeof(struct IssueTicketMessage)) | 750 | pkey_len = ntohl (im->pkey_len); |
751 | if (size != attrs_len + key_len + pkey_len + sizeof(struct | ||
752 | IssueTicketMessage)) | ||
740 | { | 753 | { |
741 | GNUNET_break (0); | 754 | GNUNET_break (0); |
742 | return GNUNET_SYSERR; | 755 | return GNUNET_SYSERR; |
@@ -758,12 +771,43 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im) | |||
758 | struct IdpClient *idp = cls; | 771 | struct IdpClient *idp = cls; |
759 | struct GNUNET_RECLAIM_AttributeList *attrs; | 772 | struct GNUNET_RECLAIM_AttributeList *attrs; |
760 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 773 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
774 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
775 | struct GNUNET_IDENTITY_PublicKey rp; | ||
761 | size_t attrs_len; | 776 | size_t attrs_len; |
777 | size_t key_len; | ||
778 | size_t pkey_len; | ||
779 | size_t read; | ||
780 | char *buf; | ||
762 | 781 | ||
763 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n"); | 782 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n"); |
783 | key_len = ntohl (im->key_len); | ||
784 | buf = (char *) &im[1]; | ||
785 | if ((GNUNET_SYSERR == | ||
786 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
787 | &identity, &read)) || | ||
788 | (read != key_len)) | ||
789 | { | ||
790 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
791 | "Failed to read private key\n"); | ||
792 | GNUNET_SERVICE_client_drop (idp->client); | ||
793 | return; | ||
794 | } | ||
795 | buf += read; | ||
796 | pkey_len = ntohl (im->pkey_len); | ||
797 | if ((GNUNET_SYSERR == | ||
798 | GNUNET_IDENTITY_read_public_key_from_buffer (buf, pkey_len, | ||
799 | &rp, &read)) || | ||
800 | (read != pkey_len)) | ||
801 | { | ||
802 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
803 | "Failed to read public key\n"); | ||
804 | GNUNET_SERVICE_client_drop (idp->client); | ||
805 | return; | ||
806 | } | ||
807 | buf += read; | ||
764 | tio = GNUNET_new (struct TicketIssueOperation); | 808 | tio = GNUNET_new (struct TicketIssueOperation); |
765 | attrs_len = ntohs (im->attr_len); | 809 | attrs_len = ntohs (im->attr_len); |
766 | attrs = GNUNET_RECLAIM_attribute_list_deserialize ((char *) &im[1], | 810 | attrs = GNUNET_RECLAIM_attribute_list_deserialize (buf, |
767 | attrs_len); | 811 | attrs_len); |
768 | for (le = attrs->list_head; NULL != le; le = le->next) | 812 | for (le = attrs->list_head; NULL != le; le = le->next) |
769 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 813 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -772,9 +816,9 @@ handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im) | |||
772 | tio->r_id = ntohl (im->id); | 816 | tio->r_id = ntohl (im->id); |
773 | tio->client = idp; | 817 | tio->client = idp; |
774 | GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio); | 818 | GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio); |
775 | RECLAIM_TICKETS_issue (&im->identity, | 819 | RECLAIM_TICKETS_issue (&identity, |
776 | attrs, | 820 | attrs, |
777 | &im->rp, | 821 | &rp, |
778 | &issue_ticket_result_cb, | 822 | &issue_ticket_result_cb, |
779 | tio); | 823 | tio); |
780 | GNUNET_SERVICE_client_continue (idp->client); | 824 | GNUNET_SERVICE_client_continue (idp->client); |
@@ -846,15 +890,44 @@ handle_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm) | |||
846 | { | 890 | { |
847 | struct TicketRevocationOperation *rop; | 891 | struct TicketRevocationOperation *rop; |
848 | struct IdpClient *idp = cls; | 892 | struct IdpClient *idp = cls; |
893 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
894 | struct GNUNET_RECLAIM_Ticket ticket; | ||
895 | size_t key_len; | ||
896 | size_t tkt_len; | ||
897 | size_t read; | ||
898 | char *buf; | ||
849 | 899 | ||
850 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n"); | 900 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n"); |
901 | key_len = ntohl (rm->key_len); | ||
902 | buf = (char *) &rm[1]; | ||
903 | if ((GNUNET_SYSERR == | ||
904 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
905 | &identity, &read)) || | ||
906 | (read != key_len)) | ||
907 | { | ||
908 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
909 | "Failed to read private key\n"); | ||
910 | GNUNET_SERVICE_client_drop (idp->client); | ||
911 | return; | ||
912 | } | ||
913 | buf += read; | ||
914 | tkt_len = ntohl (rm->tkt_len); | ||
915 | if ((GNUNET_SYSERR == | ||
916 | GNUNET_RECLAIM_read_ticket_from_buffer (buf, key_len, | ||
917 | &ticket, &read)) || | ||
918 | (read != tkt_len)) | ||
919 | { | ||
920 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
921 | "Failed to read ticket\n"); | ||
922 | GNUNET_SERVICE_client_drop (idp->client); | ||
923 | return; | ||
924 | } | ||
851 | rop = GNUNET_new (struct TicketRevocationOperation); | 925 | rop = GNUNET_new (struct TicketRevocationOperation); |
852 | rop->r_id = ntohl (rm->id); | 926 | rop->r_id = ntohl (rm->id); |
853 | rop->client = idp; | 927 | rop->client = idp; |
854 | GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop); | 928 | GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop); |
855 | rop->rh | 929 | rop->rh |
856 | = RECLAIM_TICKETS_revoke (&rm->ticket, &rm->identity, &revoke_result_cb, | 930 | = RECLAIM_TICKETS_revoke (&ticket, &identity, &revoke_result_cb, rop); |
857 | rop); | ||
858 | GNUNET_SERVICE_client_continue (idp->client); | 931 | GNUNET_SERVICE_client_continue (idp->client); |
859 | } | 932 | } |
860 | 933 | ||
@@ -882,6 +955,8 @@ consume_result_cb (void *cls, | |||
882 | char *data_tmp; | 955 | char *data_tmp; |
883 | size_t attrs_len = 0; | 956 | size_t attrs_len = 0; |
884 | size_t pres_len = 0; | 957 | size_t pres_len = 0; |
958 | size_t key_len; | ||
959 | ssize_t written; | ||
885 | 960 | ||
886 | if (GNUNET_OK != success) | 961 | if (GNUNET_OK != success) |
887 | { | 962 | { |
@@ -890,17 +965,23 @@ consume_result_cb (void *cls, | |||
890 | attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); | 965 | attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); |
891 | pres_len = GNUNET_RECLAIM_presentation_list_serialize_get_size ( | 966 | pres_len = GNUNET_RECLAIM_presentation_list_serialize_get_size ( |
892 | presentations); | 967 | presentations); |
968 | key_len = GNUNET_IDENTITY_public_key_get_length (identity); | ||
893 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 969 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
894 | "Sending CONSUME_TICKET_RESULT message\n"); | 970 | "Sending CONSUME_TICKET_RESULT message\n"); |
895 | env = GNUNET_MQ_msg_extra (crm, | 971 | env = GNUNET_MQ_msg_extra (crm, |
896 | attrs_len + pres_len, | 972 | attrs_len + pres_len + key_len, |
897 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); | 973 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT); |
898 | crm->id = htonl (cop->r_id); | 974 | crm->id = htonl (cop->r_id); |
899 | crm->attrs_len = htons (attrs_len); | 975 | crm->attrs_len = htons (attrs_len); |
900 | crm->presentations_len = htons (pres_len); | 976 | crm->presentations_len = htons (pres_len); |
901 | crm->identity = *identity; | 977 | crm->key_len = htonl (key_len); |
902 | crm->result = htonl (success); | 978 | crm->result = htonl (success); |
903 | data_tmp = (char *) &crm[1]; | 979 | data_tmp = (char *) &crm[1]; |
980 | written = GNUNET_IDENTITY_write_public_key_to_buffer (identity, | ||
981 | data_tmp, | ||
982 | key_len); | ||
983 | GNUNET_assert (0 <= written); | ||
984 | data_tmp += written; | ||
904 | GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp); | 985 | GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp); |
905 | data_tmp += attrs_len; | 986 | data_tmp += attrs_len; |
906 | GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp); | 987 | GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp); |
@@ -924,7 +1005,7 @@ check_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm) | |||
924 | uint16_t size; | 1005 | uint16_t size; |
925 | 1006 | ||
926 | size = ntohs (cm->header.size); | 1007 | size = ntohs (cm->header.size); |
927 | if (size != sizeof(struct ConsumeTicketMessage)) | 1008 | if (size <= sizeof(struct ConsumeTicketMessage)) |
928 | { | 1009 | { |
929 | GNUNET_break (0); | 1010 | GNUNET_break (0); |
930 | return GNUNET_SYSERR; | 1011 | return GNUNET_SYSERR; |
@@ -944,13 +1025,43 @@ handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm) | |||
944 | { | 1025 | { |
945 | struct ConsumeTicketOperation *cop; | 1026 | struct ConsumeTicketOperation *cop; |
946 | struct IdpClient *idp = cls; | 1027 | struct IdpClient *idp = cls; |
1028 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
1029 | struct GNUNET_RECLAIM_Ticket ticket; | ||
1030 | size_t key_len; | ||
1031 | size_t tkt_len; | ||
1032 | size_t read; | ||
1033 | char *buf; | ||
947 | 1034 | ||
948 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n"); | 1035 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n"); |
1036 | key_len = ntohl (cm->key_len); | ||
1037 | buf = (char *) &cm[1]; | ||
1038 | if ((GNUNET_SYSERR == | ||
1039 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
1040 | &identity, &read)) || | ||
1041 | (read != key_len)) | ||
1042 | { | ||
1043 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1044 | "Failed to read private key\n"); | ||
1045 | GNUNET_SERVICE_client_drop (idp->client); | ||
1046 | return; | ||
1047 | } | ||
1048 | buf += read; | ||
1049 | tkt_len = ntohl (cm->tkt_len); | ||
1050 | if ((GNUNET_SYSERR == | ||
1051 | GNUNET_RECLAIM_read_ticket_from_buffer (buf, tkt_len, | ||
1052 | &ticket, &read)) || | ||
1053 | (read != tkt_len)) | ||
1054 | { | ||
1055 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1056 | "Failed to read ticket\n"); | ||
1057 | GNUNET_SERVICE_client_drop (idp->client); | ||
1058 | return; | ||
1059 | } | ||
949 | cop = GNUNET_new (struct ConsumeTicketOperation); | 1060 | cop = GNUNET_new (struct ConsumeTicketOperation); |
950 | cop->r_id = ntohl (cm->id); | 1061 | cop->r_id = ntohl (cm->id); |
951 | cop->client = idp; | 1062 | cop->client = idp; |
952 | cop->ch | 1063 | cop->ch |
953 | = RECLAIM_TICKETS_consume (&cm->identity, &cm->ticket, &consume_result_cb, | 1064 | = RECLAIM_TICKETS_consume (&identity, &ticket, &consume_result_cb, |
954 | cop); | 1065 | cop); |
955 | GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop); | 1066 | GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop); |
956 | GNUNET_SERVICE_client_continue (idp->client); | 1067 | GNUNET_SERVICE_client_continue (idp->client); |
@@ -1077,21 +1188,37 @@ handle_attribute_store_message (void *cls, | |||
1077 | { | 1188 | { |
1078 | struct AttributeStoreHandle *ash; | 1189 | struct AttributeStoreHandle *ash; |
1079 | struct IdpClient *idp = cls; | 1190 | struct IdpClient *idp = cls; |
1191 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
1080 | size_t data_len; | 1192 | size_t data_len; |
1193 | size_t key_len; | ||
1194 | size_t read; | ||
1195 | char *buf; | ||
1081 | 1196 | ||
1082 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n"); | 1197 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n"); |
1083 | 1198 | ||
1084 | data_len = ntohs (sam->attr_len); | 1199 | data_len = ntohs (sam->attr_len); |
1085 | 1200 | key_len = ntohl (sam->key_len); | |
1201 | buf = (char *) &sam[1]; | ||
1202 | if ((GNUNET_SYSERR == | ||
1203 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
1204 | &identity, &read)) || | ||
1205 | (read != key_len)) | ||
1206 | { | ||
1207 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1208 | "Failed to read private key\n"); | ||
1209 | GNUNET_SERVICE_client_drop (idp->client); | ||
1210 | return; | ||
1211 | } | ||
1212 | buf += read; | ||
1086 | ash = GNUNET_new (struct AttributeStoreHandle); | 1213 | ash = GNUNET_new (struct AttributeStoreHandle); |
1087 | GNUNET_RECLAIM_attribute_deserialize ((char *) &sam[1], | 1214 | GNUNET_RECLAIM_attribute_deserialize (buf, |
1088 | data_len, | 1215 | data_len, |
1089 | &ash->claim); | 1216 | &ash->claim); |
1090 | 1217 | ||
1091 | ash->r_id = ntohl (sam->id); | 1218 | ash->r_id = ntohl (sam->id); |
1092 | ash->identity = sam->identity; | 1219 | ash->identity = identity; |
1093 | ash->exp.rel_value_us = GNUNET_ntohll (sam->exp); | 1220 | ash->exp.rel_value_us = GNUNET_ntohll (sam->exp); |
1094 | GNUNET_IDENTITY_key_get_public (&sam->identity, &ash->identity_pkey); | 1221 | GNUNET_IDENTITY_key_get_public (&identity, &ash->identity_pkey); |
1095 | 1222 | ||
1096 | GNUNET_SERVICE_client_continue (idp->client); | 1223 | GNUNET_SERVICE_client_continue (idp->client); |
1097 | ash->client = idp; | 1224 | ash->client = idp; |
@@ -1262,20 +1389,36 @@ handle_credential_store_message (void *cls, | |||
1262 | { | 1389 | { |
1263 | struct AttributeStoreHandle *ash; | 1390 | struct AttributeStoreHandle *ash; |
1264 | struct IdpClient *idp = cls; | 1391 | struct IdpClient *idp = cls; |
1392 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
1265 | size_t data_len; | 1393 | size_t data_len; |
1394 | size_t key_len; | ||
1395 | size_t read; | ||
1396 | char *buf; | ||
1266 | 1397 | ||
1267 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n"); | 1398 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n"); |
1268 | 1399 | ||
1269 | data_len = ntohs (sam->attr_len); | 1400 | data_len = ntohs (sam->attr_len); |
1270 | 1401 | key_len = ntohl (sam->key_len); | |
1402 | buf = (char *) &sam[1]; | ||
1403 | if ((GNUNET_SYSERR == | ||
1404 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
1405 | &identity, &read)) || | ||
1406 | (read != key_len)) | ||
1407 | { | ||
1408 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1409 | "Failed to read private key\n"); | ||
1410 | GNUNET_SERVICE_client_drop (idp->client); | ||
1411 | return; | ||
1412 | } | ||
1413 | buf += read; | ||
1271 | ash = GNUNET_new (struct AttributeStoreHandle); | 1414 | ash = GNUNET_new (struct AttributeStoreHandle); |
1272 | ash->credential = GNUNET_RECLAIM_credential_deserialize ((char *) &sam[1], | 1415 | ash->credential = GNUNET_RECLAIM_credential_deserialize (buf, |
1273 | data_len); | 1416 | data_len); |
1274 | 1417 | ||
1275 | ash->r_id = ntohl (sam->id); | 1418 | ash->r_id = ntohl (sam->id); |
1276 | ash->identity = sam->identity; | 1419 | ash->identity = identity; |
1277 | ash->exp.rel_value_us = GNUNET_ntohll (sam->exp); | 1420 | ash->exp.rel_value_us = GNUNET_ntohll (sam->exp); |
1278 | GNUNET_IDENTITY_key_get_public (&sam->identity, &ash->identity_pkey); | 1421 | GNUNET_IDENTITY_key_get_public (&identity, &ash->identity_pkey); |
1279 | 1422 | ||
1280 | GNUNET_SERVICE_client_continue (idp->client); | 1423 | GNUNET_SERVICE_client_continue (idp->client); |
1281 | ash->client = idp; | 1424 | ash->client = idp; |
@@ -1717,20 +1860,36 @@ handle_attribute_delete_message (void *cls, | |||
1717 | { | 1860 | { |
1718 | struct AttributeDeleteHandle *adh; | 1861 | struct AttributeDeleteHandle *adh; |
1719 | struct IdpClient *idp = cls; | 1862 | struct IdpClient *idp = cls; |
1863 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
1720 | size_t data_len; | 1864 | size_t data_len; |
1865 | size_t key_len; | ||
1866 | size_t read; | ||
1867 | char *buf; | ||
1721 | 1868 | ||
1722 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n"); | 1869 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n"); |
1723 | 1870 | ||
1724 | data_len = ntohs (dam->attr_len); | 1871 | data_len = ntohs (dam->attr_len); |
1725 | 1872 | key_len = ntohl (dam->key_len); | |
1873 | buf = (char *) &dam[1]; | ||
1874 | if ((GNUNET_SYSERR == | ||
1875 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
1876 | &identity, &read)) || | ||
1877 | (read != key_len)) | ||
1878 | { | ||
1879 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1880 | "Failed to read private key\n"); | ||
1881 | GNUNET_SERVICE_client_drop (idp->client); | ||
1882 | return; | ||
1883 | } | ||
1884 | buf += read; | ||
1726 | adh = GNUNET_new (struct AttributeDeleteHandle); | 1885 | adh = GNUNET_new (struct AttributeDeleteHandle); |
1727 | GNUNET_RECLAIM_attribute_deserialize ((char *) &dam[1], | 1886 | GNUNET_RECLAIM_attribute_deserialize (buf, |
1728 | data_len, | 1887 | data_len, |
1729 | &adh->claim); | 1888 | &adh->claim); |
1730 | adh->credential = NULL; | 1889 | adh->credential = NULL; |
1731 | 1890 | ||
1732 | adh->r_id = ntohl (dam->id); | 1891 | adh->r_id = ntohl (dam->id); |
1733 | adh->identity = dam->identity; | 1892 | adh->identity = identity; |
1734 | adh->label | 1893 | adh->label |
1735 | = GNUNET_STRINGS_data_to_string_alloc (&adh->claim->id, | 1894 | = GNUNET_STRINGS_data_to_string_alloc (&adh->claim->id, |
1736 | sizeof(adh->claim->id)); | 1895 | sizeof(adh->claim->id)); |
@@ -1808,19 +1967,35 @@ handle_credential_delete_message (void *cls, | |||
1808 | { | 1967 | { |
1809 | struct AttributeDeleteHandle *adh; | 1968 | struct AttributeDeleteHandle *adh; |
1810 | struct IdpClient *idp = cls; | 1969 | struct IdpClient *idp = cls; |
1970 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
1811 | size_t data_len; | 1971 | size_t data_len; |
1972 | size_t key_len; | ||
1973 | size_t read; | ||
1974 | char *buf; | ||
1812 | 1975 | ||
1813 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n"); | 1976 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n"); |
1814 | 1977 | ||
1815 | data_len = ntohs (dam->attr_len); | 1978 | data_len = ntohs (dam->attr_len); |
1816 | 1979 | key_len = ntohl (dam->key_len); | |
1980 | buf = (char *) &dam[1]; | ||
1981 | if ((GNUNET_SYSERR == | ||
1982 | GNUNET_IDENTITY_read_private_key_from_buffer (buf, key_len, | ||
1983 | &identity, &read)) || | ||
1984 | (read != key_len)) | ||
1985 | { | ||
1986 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1987 | "Failed to read private key\n"); | ||
1988 | GNUNET_SERVICE_client_drop (idp->client); | ||
1989 | return; | ||
1990 | } | ||
1991 | buf += read; | ||
1817 | adh = GNUNET_new (struct AttributeDeleteHandle); | 1992 | adh = GNUNET_new (struct AttributeDeleteHandle); |
1818 | adh->credential = GNUNET_RECLAIM_credential_deserialize ((char *) &dam[1], | 1993 | adh->credential = GNUNET_RECLAIM_credential_deserialize (buf, |
1819 | data_len); | 1994 | data_len); |
1820 | adh->claim = NULL; | 1995 | adh->claim = NULL; |
1821 | 1996 | ||
1822 | adh->r_id = ntohl (dam->id); | 1997 | adh->r_id = ntohl (dam->id); |
1823 | adh->identity = dam->identity; | 1998 | adh->identity = identity; |
1824 | adh->label | 1999 | adh->label |
1825 | = GNUNET_STRINGS_data_to_string_alloc (&adh->credential->id, | 2000 | = GNUNET_STRINGS_data_to_string_alloc (&adh->credential->id, |
1826 | sizeof(adh->credential->id)); | 2001 | sizeof(adh->credential->id)); |
@@ -1858,6 +2033,7 @@ attr_iter_finished (void *cls) | |||
1858 | env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); | 2033 | env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); |
1859 | arm->id = htonl (ai->request_id); | 2034 | arm->id = htonl (ai->request_id); |
1860 | arm->attr_len = htons (0); | 2035 | arm->attr_len = htons (0); |
2036 | arm->pkey_len = htonl (0); | ||
1861 | GNUNET_MQ_send (ai->client->mq, env); | 2037 | GNUNET_MQ_send (ai->client->mq, env); |
1862 | GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head, | 2038 | GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head, |
1863 | ai->client->attr_iter_tail, | 2039 | ai->client->attr_iter_tail, |
@@ -1899,7 +2075,10 @@ attr_iter_cb (void *cls, | |||
1899 | { | 2075 | { |
1900 | struct Iterator *ai = cls; | 2076 | struct Iterator *ai = cls; |
1901 | struct GNUNET_MQ_Envelope *env; | 2077 | struct GNUNET_MQ_Envelope *env; |
2078 | struct GNUNET_IDENTITY_PublicKey identity; | ||
1902 | char *data_tmp; | 2079 | char *data_tmp; |
2080 | size_t key_len; | ||
2081 | ssize_t written; | ||
1903 | 2082 | ||
1904 | if ((rd_count != 1) || | 2083 | if ((rd_count != 1) || |
1905 | (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd->record_type)) | 2084 | (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd->record_type)) |
@@ -1912,18 +2091,44 @@ attr_iter_cb (void *cls, | |||
1912 | label); | 2091 | label); |
1913 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2092 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1914 | "Sending ATTRIBUTE_RESULT message\n"); | 2093 | "Sending ATTRIBUTE_RESULT message\n"); |
2094 | GNUNET_IDENTITY_key_get_public (zone, &identity); | ||
2095 | key_len = GNUNET_IDENTITY_public_key_get_length (&identity); | ||
1915 | env = GNUNET_MQ_msg_extra (arm, | 2096 | env = GNUNET_MQ_msg_extra (arm, |
1916 | rd->data_size, | 2097 | rd->data_size + key_len, |
1917 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); | 2098 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT); |
1918 | arm->id = htonl (ai->request_id); | 2099 | arm->id = htonl (ai->request_id); |
1919 | arm->attr_len = htons (rd->data_size); | 2100 | arm->attr_len = htons (rd->data_size); |
1920 | GNUNET_IDENTITY_key_get_public (zone, &arm->identity); | ||
1921 | data_tmp = (char *) &arm[1]; | 2101 | data_tmp = (char *) &arm[1]; |
2102 | arm->pkey_len = htonl (key_len); | ||
2103 | written = GNUNET_IDENTITY_write_public_key_to_buffer (&identity, | ||
2104 | data_tmp, | ||
2105 | key_len); | ||
2106 | GNUNET_assert (0 <= written); | ||
2107 | data_tmp += written; | ||
1922 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); | 2108 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); |
1923 | GNUNET_MQ_send (ai->client->mq, env); | 2109 | GNUNET_MQ_send (ai->client->mq, env); |
1924 | } | 2110 | } |
1925 | 2111 | ||
1926 | 2112 | ||
2113 | static enum GNUNET_GenericReturnValue | ||
2114 | check_iteration_start ( | ||
2115 | void *cls, | ||
2116 | const struct AttributeIterationStartMessage *ais_msg) | ||
2117 | { | ||
2118 | uint16_t size; | ||
2119 | size_t key_len; | ||
2120 | |||
2121 | size = ntohs (ais_msg->header.size); | ||
2122 | key_len = ntohs (ais_msg->key_len); | ||
2123 | |||
2124 | if (size < key_len + sizeof(*ais_msg)) | ||
2125 | { | ||
2126 | GNUNET_break (0); | ||
2127 | return GNUNET_SYSERR; | ||
2128 | } | ||
2129 | return GNUNET_OK; | ||
2130 | } | ||
2131 | |||
1927 | /** | 2132 | /** |
1928 | * Iterate over zone to get attributes | 2133 | * Iterate over zone to get attributes |
1929 | * | 2134 | * |
@@ -1936,13 +2141,29 @@ handle_iteration_start (void *cls, | |||
1936 | { | 2141 | { |
1937 | struct IdpClient *idp = cls; | 2142 | struct IdpClient *idp = cls; |
1938 | struct Iterator *ai; | 2143 | struct Iterator *ai; |
2144 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
2145 | size_t key_len; | ||
2146 | size_t read; | ||
1939 | 2147 | ||
1940 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1941 | "Received ATTRIBUTE_ITERATION_START message\n"); | 2149 | "Received ATTRIBUTE_ITERATION_START message\n"); |
2150 | key_len = ntohl (ais_msg->key_len); | ||
2151 | if ((GNUNET_SYSERR == | ||
2152 | GNUNET_IDENTITY_read_private_key_from_buffer (&ais_msg[1], | ||
2153 | key_len, | ||
2154 | &identity, | ||
2155 | &read)) || | ||
2156 | (read != key_len)) | ||
2157 | { | ||
2158 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
2159 | "Failed to read private key.\n"); | ||
2160 | GNUNET_SERVICE_client_drop (idp->client); | ||
2161 | return; | ||
2162 | } | ||
1942 | ai = GNUNET_new (struct Iterator); | 2163 | ai = GNUNET_new (struct Iterator); |
1943 | ai->request_id = ntohl (ais_msg->id); | 2164 | ai->request_id = ntohl (ais_msg->id); |
1944 | ai->client = idp; | 2165 | ai->client = idp; |
1945 | ai->identity = ais_msg->identity; | 2166 | ai->identity = identity; |
1946 | 2167 | ||
1947 | GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai); | 2168 | GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai); |
1948 | ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh, | 2169 | ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh, |
@@ -2084,7 +2305,10 @@ cred_iter_cb (void *cls, | |||
2084 | struct Iterator *ai = cls; | 2305 | struct Iterator *ai = cls; |
2085 | struct GNUNET_MQ_Envelope *env; | 2306 | struct GNUNET_MQ_Envelope *env; |
2086 | struct CredentialResultMessage *arm; | 2307 | struct CredentialResultMessage *arm; |
2308 | struct GNUNET_IDENTITY_PublicKey identity; | ||
2087 | char *data_tmp; | 2309 | char *data_tmp; |
2310 | size_t key_len; | ||
2311 | ssize_t written; | ||
2088 | 2312 | ||
2089 | if ((rd_count != 1) || | 2313 | if ((rd_count != 1) || |
2090 | (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL != rd->record_type)) | 2314 | (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL != rd->record_type)) |
@@ -2096,18 +2320,42 @@ cred_iter_cb (void *cls, | |||
2096 | label); | 2320 | label); |
2097 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2321 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2098 | "Sending CREDENTIAL_RESULT message\n"); | 2322 | "Sending CREDENTIAL_RESULT message\n"); |
2323 | GNUNET_IDENTITY_key_get_public (zone, &identity); | ||
2324 | key_len = GNUNET_IDENTITY_public_key_get_length (&identity); | ||
2099 | env = GNUNET_MQ_msg_extra (arm, | 2325 | env = GNUNET_MQ_msg_extra (arm, |
2100 | rd->data_size, | 2326 | rd->data_size + key_len, |
2101 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT); | 2327 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT); |
2102 | arm->id = htonl (ai->request_id); | 2328 | arm->id = htonl (ai->request_id); |
2103 | arm->credential_len = htons (rd->data_size); | 2329 | arm->credential_len = htons (rd->data_size); |
2104 | GNUNET_IDENTITY_key_get_public (zone, &arm->identity); | ||
2105 | data_tmp = (char *) &arm[1]; | 2330 | data_tmp = (char *) &arm[1]; |
2331 | written = GNUNET_IDENTITY_write_public_key_to_buffer (&identity, | ||
2332 | data_tmp, | ||
2333 | key_len); | ||
2334 | GNUNET_assert (written >= 0); | ||
2335 | data_tmp += written; | ||
2106 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); | 2336 | GNUNET_memcpy (data_tmp, rd->data, rd->data_size); |
2107 | |||
2108 | GNUNET_MQ_send (ai->client->mq, env); | 2337 | GNUNET_MQ_send (ai->client->mq, env); |
2109 | } | 2338 | } |
2110 | 2339 | ||
2340 | static enum GNUNET_GenericReturnValue | ||
2341 | check_credential_iteration_start ( | ||
2342 | void *cls, | ||
2343 | const struct CredentialIterationStartMessage *cis_msg) | ||
2344 | { | ||
2345 | uint16_t size; | ||
2346 | size_t key_len; | ||
2347 | |||
2348 | size = ntohs (cis_msg->header.size); | ||
2349 | key_len = ntohs (cis_msg->key_len); | ||
2350 | |||
2351 | if (size < key_len + sizeof(*cis_msg)) | ||
2352 | { | ||
2353 | GNUNET_break (0); | ||
2354 | return GNUNET_SYSERR; | ||
2355 | } | ||
2356 | return GNUNET_OK; | ||
2357 | } | ||
2358 | |||
2111 | 2359 | ||
2112 | /** | 2360 | /** |
2113 | * Iterate over zone to get attributes | 2361 | * Iterate over zone to get attributes |
@@ -2122,13 +2370,29 @@ handle_credential_iteration_start (void *cls, | |||
2122 | { | 2370 | { |
2123 | struct IdpClient *idp = cls; | 2371 | struct IdpClient *idp = cls; |
2124 | struct Iterator *ai; | 2372 | struct Iterator *ai; |
2373 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
2374 | size_t key_len; | ||
2375 | size_t read; | ||
2125 | 2376 | ||
2126 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2377 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2127 | "Received CREDENTIAL_ITERATION_START message\n"); | 2378 | "Received CREDENTIAL_ITERATION_START message\n"); |
2379 | key_len = ntohl (ais_msg->key_len); | ||
2380 | if ((GNUNET_SYSERR == | ||
2381 | GNUNET_IDENTITY_read_private_key_from_buffer (&ais_msg[1], | ||
2382 | key_len, | ||
2383 | &identity, | ||
2384 | &read)) || | ||
2385 | (read != key_len)) | ||
2386 | { | ||
2387 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
2388 | "Failed to read private key.\n"); | ||
2389 | GNUNET_SERVICE_client_drop (idp->client); | ||
2390 | return; | ||
2391 | } | ||
2128 | ai = GNUNET_new (struct Iterator); | 2392 | ai = GNUNET_new (struct Iterator); |
2129 | ai->request_id = ntohl (ais_msg->id); | 2393 | ai->request_id = ntohl (ais_msg->id); |
2130 | ai->client = idp; | 2394 | ai->client = idp; |
2131 | ai->identity = ais_msg->identity; | 2395 | ai->identity = identity; |
2132 | 2396 | ||
2133 | GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail, | 2397 | GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail, |
2134 | ai); | 2398 | ai); |
@@ -2227,8 +2491,16 @@ ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket) | |||
2227 | struct TicketIteration *ti = cls; | 2491 | struct TicketIteration *ti = cls; |
2228 | struct GNUNET_MQ_Envelope *env; | 2492 | struct GNUNET_MQ_Envelope *env; |
2229 | struct TicketResultMessage *trm; | 2493 | struct TicketResultMessage *trm; |
2494 | size_t tkt_len; | ||
2230 | 2495 | ||
2231 | env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | 2496 | if (NULL == ticket) |
2497 | tkt_len = 0; | ||
2498 | else | ||
2499 | tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket); | ||
2500 | |||
2501 | env = GNUNET_MQ_msg_extra (trm, | ||
2502 | tkt_len, | ||
2503 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT); | ||
2232 | if (NULL == ticket) | 2504 | if (NULL == ticket) |
2233 | { | 2505 | { |
2234 | /* send empty response to indicate end of list */ | 2506 | /* send empty response to indicate end of list */ |
@@ -2238,8 +2510,11 @@ ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket) | |||
2238 | } | 2510 | } |
2239 | else | 2511 | else |
2240 | { | 2512 | { |
2241 | trm->ticket = *ticket; | 2513 | GNUNET_RECLAIM_write_ticket_to_buffer (ticket, |
2514 | &trm[1], | ||
2515 | tkt_len); | ||
2242 | } | 2516 | } |
2517 | trm->tkt_len = htonl (tkt_len); | ||
2243 | trm->id = htonl (ti->r_id); | 2518 | trm->id = htonl (ti->r_id); |
2244 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); | 2519 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n"); |
2245 | GNUNET_MQ_send (ti->client->mq, env); | 2520 | GNUNET_MQ_send (ti->client->mq, env); |
@@ -2247,6 +2522,24 @@ ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket) | |||
2247 | GNUNET_free (ti); | 2522 | GNUNET_free (ti); |
2248 | } | 2523 | } |
2249 | 2524 | ||
2525 | static enum GNUNET_GenericReturnValue | ||
2526 | check_ticket_iteration_start ( | ||
2527 | void *cls, | ||
2528 | const struct TicketIterationStartMessage *tis_msg) | ||
2529 | { | ||
2530 | uint16_t size; | ||
2531 | size_t key_len; | ||
2532 | |||
2533 | size = ntohs (tis_msg->header.size); | ||
2534 | key_len = ntohs (tis_msg->key_len); | ||
2535 | |||
2536 | if (size < key_len + sizeof(*tis_msg)) | ||
2537 | { | ||
2538 | GNUNET_break (0); | ||
2539 | return GNUNET_SYSERR; | ||
2540 | } | ||
2541 | return GNUNET_OK; | ||
2542 | } | ||
2250 | 2543 | ||
2251 | /** | 2544 | /** |
2252 | * Client requests a ticket iteration | 2545 | * Client requests a ticket iteration |
@@ -2259,20 +2552,35 @@ handle_ticket_iteration_start ( | |||
2259 | void *cls, | 2552 | void *cls, |
2260 | const struct TicketIterationStartMessage *tis_msg) | 2553 | const struct TicketIterationStartMessage *tis_msg) |
2261 | { | 2554 | { |
2555 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
2262 | struct IdpClient *client = cls; | 2556 | struct IdpClient *client = cls; |
2263 | struct TicketIteration *ti; | 2557 | struct TicketIteration *ti; |
2558 | size_t key_len; | ||
2559 | size_t read; | ||
2264 | 2560 | ||
2265 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2561 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2266 | "Received TICKET_ITERATION_START message\n"); | 2562 | "Received TICKET_ITERATION_START message\n"); |
2563 | key_len = ntohl (tis_msg->key_len); | ||
2564 | if ((GNUNET_SYSERR == | ||
2565 | GNUNET_IDENTITY_read_private_key_from_buffer (&tis_msg[1], | ||
2566 | key_len, | ||
2567 | &identity, | ||
2568 | &read)) || | ||
2569 | (read != key_len)) | ||
2570 | { | ||
2571 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
2572 | "Failed to read private key\n"); | ||
2573 | GNUNET_SERVICE_client_drop (client->client); | ||
2574 | return; | ||
2575 | } | ||
2267 | ti = GNUNET_new (struct TicketIteration); | 2576 | ti = GNUNET_new (struct TicketIteration); |
2268 | ti->r_id = ntohl (tis_msg->id); | 2577 | ti->r_id = ntohl (tis_msg->id); |
2269 | ti->client = client; | 2578 | ti->client = client; |
2270 | |||
2271 | GNUNET_CONTAINER_DLL_insert (client->ticket_iter_head, | 2579 | GNUNET_CONTAINER_DLL_insert (client->ticket_iter_head, |
2272 | client->ticket_iter_tail, | 2580 | client->ticket_iter_tail, |
2273 | ti); | 2581 | ti); |
2274 | ti->iter | 2582 | ti->iter |
2275 | = RECLAIM_TICKETS_iteration_start (&tis_msg->identity, &ticket_iter_cb, ti); | 2583 | = RECLAIM_TICKETS_iteration_start (&identity, &ticket_iter_cb, ti); |
2276 | GNUNET_SERVICE_client_continue (client->client); | 2584 | GNUNET_SERVICE_client_continue (client->client); |
2277 | } | 2585 | } |
2278 | 2586 | ||
@@ -2451,10 +2759,10 @@ GNUNET_SERVICE_MAIN ( | |||
2451 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, | 2759 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, |
2452 | struct AttributeDeleteMessage, | 2760 | struct AttributeDeleteMessage, |
2453 | NULL), | 2761 | NULL), |
2454 | GNUNET_MQ_hd_fixed_size (iteration_start, | 2762 | GNUNET_MQ_hd_var_size (iteration_start, |
2455 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, | 2763 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, |
2456 | struct AttributeIterationStartMessage, | 2764 | struct AttributeIterationStartMessage, |
2457 | NULL), | 2765 | NULL), |
2458 | GNUNET_MQ_hd_fixed_size (iteration_next, | 2766 | GNUNET_MQ_hd_fixed_size (iteration_next, |
2459 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, | 2767 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, |
2460 | struct AttributeIterationNextMessage, | 2768 | struct AttributeIterationNextMessage, |
@@ -2463,10 +2771,10 @@ GNUNET_SERVICE_MAIN ( | |||
2463 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, | 2771 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, |
2464 | struct AttributeIterationStopMessage, | 2772 | struct AttributeIterationStopMessage, |
2465 | NULL), | 2773 | NULL), |
2466 | GNUNET_MQ_hd_fixed_size (credential_iteration_start, | 2774 | GNUNET_MQ_hd_var_size (credential_iteration_start, |
2467 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, | 2775 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, |
2468 | struct CredentialIterationStartMessage, | 2776 | struct CredentialIterationStartMessage, |
2469 | NULL), | 2777 | NULL), |
2470 | GNUNET_MQ_hd_fixed_size (credential_iteration_next, | 2778 | GNUNET_MQ_hd_fixed_size (credential_iteration_next, |
2471 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, | 2779 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, |
2472 | struct CredentialIterationNextMessage, | 2780 | struct CredentialIterationNextMessage, |
@@ -2484,10 +2792,10 @@ GNUNET_SERVICE_MAIN ( | |||
2484 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, | 2792 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, |
2485 | struct ConsumeTicketMessage, | 2793 | struct ConsumeTicketMessage, |
2486 | NULL), | 2794 | NULL), |
2487 | GNUNET_MQ_hd_fixed_size (ticket_iteration_start, | 2795 | GNUNET_MQ_hd_var_size (ticket_iteration_start, |
2488 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, | 2796 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, |
2489 | struct TicketIterationStartMessage, | 2797 | struct TicketIterationStartMessage, |
2490 | NULL), | 2798 | NULL), |
2491 | GNUNET_MQ_hd_fixed_size (ticket_iteration_next, | 2799 | GNUNET_MQ_hd_fixed_size (ticket_iteration_next, |
2492 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, | 2800 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, |
2493 | struct TicketIterationNextMessage, | 2801 | struct TicketIterationNextMessage, |
diff --git a/src/reclaim/gnunet-service-reclaim_tickets.c b/src/reclaim/gnunet-service-reclaim_tickets.c index 9552094f1..5e2a5e974 100644 --- a/src/reclaim/gnunet-service-reclaim_tickets.c +++ b/src/reclaim/gnunet-service-reclaim_tickets.c | |||
@@ -742,7 +742,8 @@ rvk_move_attr_cb (void *cls, | |||
742 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n", | 742 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding credential %s\n", |
743 | new_label); | 743 | new_label); |
744 | GNUNET_free (credential); | 744 | GNUNET_free (credential); |
745 | } else { | 745 | } |
746 | else { | ||
746 | memcpy (&new_rd[i], &rd[i], sizeof (struct GNUNET_GNSRECORD_Data)); | 747 | memcpy (&new_rd[i], &rd[i], sizeof (struct GNUNET_GNSRECORD_Data)); |
747 | } | 748 | } |
748 | } | 749 | } |
@@ -1197,9 +1198,11 @@ RECLAIM_TICKETS_consume (const struct GNUNET_IDENTITY_PrivateKey *id, | |||
1197 | label = | 1198 | label = |
1198 | GNUNET_STRINGS_data_to_string_alloc (&cth->ticket.rnd, | 1199 | GNUNET_STRINGS_data_to_string_alloc (&cth->ticket.rnd, |
1199 | sizeof(cth->ticket.rnd)); | 1200 | sizeof(cth->ticket.rnd)); |
1201 | char *str = GNUNET_IDENTITY_public_key_to_string (&cth->ticket.identity); | ||
1200 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1202 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1201 | "Looking for AuthZ info under %s\n", | 1203 | "Looking for AuthZ info under %s in %s\n", |
1202 | label); | 1204 | label, str); |
1205 | GNUNET_free (str); | ||
1203 | cth->lookup_start_time = GNUNET_TIME_absolute_get (); | 1206 | cth->lookup_start_time = GNUNET_TIME_absolute_get (); |
1204 | cth->lookup_request = | 1207 | cth->lookup_request = |
1205 | GNUNET_GNS_lookup (gns, | 1208 | GNUNET_GNS_lookup (gns, |
@@ -1289,6 +1292,7 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1289 | struct GNUNET_RECLAIM_PresentationListEntry *ple; | 1292 | struct GNUNET_RECLAIM_PresentationListEntry *ple; |
1290 | struct GNUNET_GNSRECORD_Data *attrs_record; | 1293 | struct GNUNET_GNSRECORD_Data *attrs_record; |
1291 | char *label; | 1294 | char *label; |
1295 | char *tkt_data; | ||
1292 | int i; | 1296 | int i; |
1293 | int j; | 1297 | int j; |
1294 | int attrs_count = 0; | 1298 | int attrs_count = 0; |
@@ -1376,8 +1380,13 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1376 | } | 1380 | } |
1377 | } | 1381 | } |
1378 | } | 1382 | } |
1379 | attrs_record[i].data = &ih->ticket; | 1383 | attrs_record[i].data_size = |
1380 | attrs_record[i].data_size = sizeof(struct GNUNET_RECLAIM_Ticket); | 1384 | GNUNET_RECLAIM_ticket_serialize_get_size (&ih->ticket); |
1385 | tkt_data = GNUNET_malloc (attrs_record[i].data_size); | ||
1386 | GNUNET_RECLAIM_write_ticket_to_buffer (&ih->ticket, | ||
1387 | tkt_data, | ||
1388 | attrs_record[i].data_size); | ||
1389 | attrs_record[i].data = tkt_data; | ||
1381 | attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us; | 1390 | attrs_record[i].expiration_time = ticket_refresh_interval.rel_value_us; |
1382 | attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET; | 1391 | attrs_record[i].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET; |
1383 | attrs_record[i].flags = | 1392 | attrs_record[i].flags = |
@@ -1387,6 +1396,13 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1387 | label = | 1396 | label = |
1388 | GNUNET_STRINGS_data_to_string_alloc (&ih->ticket.rnd, | 1397 | GNUNET_STRINGS_data_to_string_alloc (&ih->ticket.rnd, |
1389 | sizeof(ih->ticket.rnd)); | 1398 | sizeof(ih->ticket.rnd)); |
1399 | struct GNUNET_IDENTITY_PublicKey pub; | ||
1400 | GNUNET_IDENTITY_key_get_public (&ih->identity, | ||
1401 | &pub); | ||
1402 | char *str = GNUNET_IDENTITY_public_key_to_string (&pub); | ||
1403 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1404 | "Storing AuthZ information under %s in %s\n", label, str); | ||
1405 | GNUNET_free (str); | ||
1390 | // Publish record | 1406 | // Publish record |
1391 | ih->ns_qe = GNUNET_NAMESTORE_records_store (nsh, | 1407 | ih->ns_qe = GNUNET_NAMESTORE_records_store (nsh, |
1392 | &ih->identity, | 1408 | &ih->identity, |
@@ -1404,6 +1420,7 @@ issue_ticket (struct TicketIssueHandle *ih) | |||
1404 | char *ptr = (char*) attrs_record[j].data; | 1420 | char *ptr = (char*) attrs_record[j].data; |
1405 | GNUNET_free (ptr); | 1421 | GNUNET_free (ptr); |
1406 | } | 1422 | } |
1423 | GNUNET_free (tkt_data); | ||
1407 | GNUNET_free (attrs_record); | 1424 | GNUNET_free (attrs_record); |
1408 | GNUNET_free (label); | 1425 | GNUNET_free (label); |
1409 | } | 1426 | } |
@@ -1454,7 +1471,7 @@ filter_tickets_cb (void *cls, | |||
1454 | const struct GNUNET_GNSRECORD_Data *rd) | 1471 | const struct GNUNET_GNSRECORD_Data *rd) |
1455 | { | 1472 | { |
1456 | struct TicketIssueHandle *tih = cls; | 1473 | struct TicketIssueHandle *tih = cls; |
1457 | struct GNUNET_RECLAIM_Ticket *ticket = NULL; | 1474 | struct GNUNET_RECLAIM_Ticket ticket; |
1458 | struct GNUNET_RECLAIM_Presentation *presentation; | 1475 | struct GNUNET_RECLAIM_Presentation *presentation; |
1459 | struct GNUNET_RECLAIM_PresentationList *ticket_presentations; | 1476 | struct GNUNET_RECLAIM_PresentationList *ticket_presentations; |
1460 | struct GNUNET_RECLAIM_Credential *cred; | 1477 | struct GNUNET_RECLAIM_Credential *cred; |
@@ -1462,6 +1479,7 @@ filter_tickets_cb (void *cls, | |||
1462 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 1479 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
1463 | unsigned int attr_cnt = 0; | 1480 | unsigned int attr_cnt = 0; |
1464 | unsigned int pres_cnt = 0; | 1481 | unsigned int pres_cnt = 0; |
1482 | int ticket_found = GNUNET_NO; | ||
1465 | 1483 | ||
1466 | for (le = tih->attrs->list_head; NULL != le; le = le->next) | 1484 | for (le = tih->attrs->list_head; NULL != le; le = le->next) |
1467 | { | 1485 | { |
@@ -1473,6 +1491,7 @@ filter_tickets_cb (void *cls, | |||
1473 | // ticket search | 1491 | // ticket search |
1474 | unsigned int found_attrs_cnt = 0; | 1492 | unsigned int found_attrs_cnt = 0; |
1475 | unsigned int found_pres_cnt = 0; | 1493 | unsigned int found_pres_cnt = 0; |
1494 | size_t read; | ||
1476 | ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); | 1495 | ticket_presentations = GNUNET_new (struct GNUNET_RECLAIM_PresentationList); |
1477 | 1496 | ||
1478 | for (int i = 0; i < rd_count; i++) | 1497 | for (int i = 0; i < rd_count; i++) |
@@ -1480,16 +1499,28 @@ filter_tickets_cb (void *cls, | |||
1480 | // found ticket | 1499 | // found ticket |
1481 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type) | 1500 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET == rd[i].record_type) |
1482 | { | 1501 | { |
1483 | ticket = (struct GNUNET_RECLAIM_Ticket *) rd[i].data; | 1502 | if ((GNUNET_SYSERR == |
1503 | GNUNET_RECLAIM_read_ticket_from_buffer (rd[i].data, | ||
1504 | rd[i].data_size, | ||
1505 | &ticket, | ||
1506 | &read)) || | ||
1507 | (read != rd[i].data_size)) | ||
1508 | { | ||
1509 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1510 | "Failed to deserialize ticket from record\n"); | ||
1511 | continue; | ||
1512 | } | ||
1484 | // cmp audience | 1513 | // cmp audience |
1514 | // FIXME this is ugly, GNUNET_IDENTITY_PublicKey cannot be compared | ||
1515 | // like this | ||
1485 | if (0 == memcmp (&tih->ticket.audience, | 1516 | if (0 == memcmp (&tih->ticket.audience, |
1486 | &ticket->audience, | 1517 | &ticket.audience, |
1487 | sizeof(struct GNUNET_IDENTITY_PublicKey))) | 1518 | sizeof(struct GNUNET_IDENTITY_PublicKey))) |
1488 | { | 1519 | { |
1489 | tih->ticket = *ticket; | 1520 | tih->ticket = ticket; |
1521 | ticket_found = GNUNET_YES; | ||
1490 | continue; | 1522 | continue; |
1491 | } | 1523 | } |
1492 | ticket = NULL; | ||
1493 | } | 1524 | } |
1494 | 1525 | ||
1495 | // cmp requested attributes with ticket attributes | 1526 | // cmp requested attributes with ticket attributes |
@@ -1573,7 +1604,7 @@ filter_tickets_cb (void *cls, | |||
1573 | */ | 1604 | */ |
1574 | if ((attr_cnt == found_attrs_cnt) && | 1605 | if ((attr_cnt == found_attrs_cnt) && |
1575 | (pres_cnt == found_pres_cnt) && | 1606 | (pres_cnt == found_pres_cnt) && |
1576 | (NULL != ticket)) | 1607 | (GNUNET_YES == ticket_found)) |
1577 | { | 1608 | { |
1578 | GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it); | 1609 | GNUNET_NAMESTORE_zone_iteration_stop (tih->ns_it); |
1579 | tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL); | 1610 | tih->cb (tih->cb_cls, &tih->ticket, ticket_presentations, GNUNET_OK, NULL); |
@@ -1683,12 +1714,25 @@ collect_tickets_cb (void *cls, | |||
1683 | const struct GNUNET_GNSRECORD_Data *rd) | 1714 | const struct GNUNET_GNSRECORD_Data *rd) |
1684 | { | 1715 | { |
1685 | struct RECLAIM_TICKETS_Iterator *iter = cls; | 1716 | struct RECLAIM_TICKETS_Iterator *iter = cls; |
1717 | struct GNUNET_RECLAIM_Ticket ticket; | ||
1718 | size_t read; | ||
1686 | 1719 | ||
1687 | for (int i = 0; i < rd_count; i++) | 1720 | for (int i = 0; i < rd_count; i++) |
1688 | { | 1721 | { |
1689 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type) | 1722 | if (GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET != rd[i].record_type) |
1690 | continue; | 1723 | continue; |
1691 | iter->cb (iter->cb_cls, (struct GNUNET_RECLAIM_Ticket *) rd[i].data); | 1724 | if ((GNUNET_SYSERR == |
1725 | GNUNET_RECLAIM_read_ticket_from_buffer (rd[i].data, | ||
1726 | rd[i].data_size, | ||
1727 | &ticket, | ||
1728 | &read)) || | ||
1729 | (read != rd[i].data_size)) | ||
1730 | { | ||
1731 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1732 | "Failed to deserialize ticket from record\n"); | ||
1733 | continue; | ||
1734 | } | ||
1735 | iter->cb (iter->cb_cls, &ticket); | ||
1692 | return; | 1736 | return; |
1693 | } | 1737 | } |
1694 | GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1); | 1738 | GNUNET_NAMESTORE_zone_iterator_next (iter->ns_it, 1); |
diff --git a/src/reclaim/reclaim.h b/src/reclaim/reclaim.h index aae8ee89a..5813beaf7 100644 --- a/src/reclaim/reclaim.h +++ b/src/reclaim/reclaim.h | |||
@@ -45,6 +45,11 @@ struct AttributeStoreMessage | |||
45 | struct GNUNET_MessageHeader header; | 45 | struct GNUNET_MessageHeader header; |
46 | 46 | ||
47 | /** | 47 | /** |
48 | * The expiration interval of the attribute | ||
49 | */ | ||
50 | uint64_t exp GNUNET_PACKED; | ||
51 | |||
52 | /** | ||
48 | * Unique identifier for this request (for key collisions). | 53 | * Unique identifier for this request (for key collisions). |
49 | */ | 54 | */ |
50 | uint32_t id GNUNET_PACKED; | 55 | uint32_t id GNUNET_PACKED; |
@@ -55,16 +60,13 @@ struct AttributeStoreMessage | |||
55 | uint32_t attr_len GNUNET_PACKED; | 60 | uint32_t attr_len GNUNET_PACKED; |
56 | 61 | ||
57 | /** | 62 | /** |
58 | * The expiration interval of the attribute | 63 | * The length of the private key |
59 | */ | ||
60 | uint64_t exp GNUNET_PACKED; | ||
61 | |||
62 | /** | ||
63 | * Identity | ||
64 | */ | 64 | */ |
65 | struct GNUNET_IDENTITY_PrivateKey identity; | 65 | uint32_t key_len GNUNET_PACKED; |
66 | 66 | ||
67 | /* followed by the serialized attribute */ | 67 | /* |
68 | * followed by the zone private key | ||
69 | * followed by the serialized attribute */ | ||
68 | }; | 70 | }; |
69 | 71 | ||
70 | 72 | ||
@@ -89,9 +91,9 @@ struct AttributeDeleteMessage | |||
89 | uint32_t attr_len GNUNET_PACKED; | 91 | uint32_t attr_len GNUNET_PACKED; |
90 | 92 | ||
91 | /** | 93 | /** |
92 | * Identity | 94 | * The length of the private key |
93 | */ | 95 | */ |
94 | struct GNUNET_IDENTITY_PrivateKey identity; | 96 | uint32_t key_len GNUNET_PACKED; |
95 | 97 | ||
96 | /* followed by the serialized attribute */ | 98 | /* followed by the serialized attribute */ |
97 | }; | 99 | }; |
@@ -149,11 +151,13 @@ struct AttributeResultMessage | |||
149 | uint16_t reserved GNUNET_PACKED; | 151 | uint16_t reserved GNUNET_PACKED; |
150 | 152 | ||
151 | /** | 153 | /** |
152 | * The public key of the identity. | 154 | * The length of the public key |
153 | */ | 155 | */ |
154 | struct GNUNET_IDENTITY_PublicKey identity; | 156 | uint32_t pkey_len GNUNET_PACKED; |
155 | 157 | ||
156 | /* followed by: | 158 | /** |
159 | * followed by the public key key. | ||
160 | * followed by: | ||
157 | * serialized attribute data | 161 | * serialized attribute data |
158 | */ | 162 | */ |
159 | }; | 163 | }; |
@@ -184,11 +188,13 @@ struct CredentialResultMessage | |||
184 | uint16_t reserved GNUNET_PACKED; | 188 | uint16_t reserved GNUNET_PACKED; |
185 | 189 | ||
186 | /** | 190 | /** |
187 | * The public key of the identity. | 191 | * The length of the public key |
188 | */ | 192 | */ |
189 | struct GNUNET_IDENTITY_PublicKey identity; | 193 | uint32_t key_len GNUNET_PACKED; |
190 | 194 | ||
191 | /* followed by: | 195 | /** |
196 | * followed by the private key. | ||
197 | * followed by: | ||
192 | * serialized credential data | 198 | * serialized credential data |
193 | */ | 199 | */ |
194 | }; | 200 | }; |
@@ -210,9 +216,13 @@ struct AttributeIterationStartMessage | |||
210 | uint32_t id GNUNET_PACKED; | 216 | uint32_t id GNUNET_PACKED; |
211 | 217 | ||
212 | /** | 218 | /** |
213 | * Identity. | 219 | * The length of the private key |
220 | */ | ||
221 | uint32_t key_len GNUNET_PACKED; | ||
222 | |||
223 | /** | ||
224 | * followed by the private key. | ||
214 | */ | 225 | */ |
215 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
216 | }; | 226 | }; |
217 | 227 | ||
218 | 228 | ||
@@ -249,9 +259,13 @@ struct CredentialIterationStartMessage | |||
249 | uint32_t id GNUNET_PACKED; | 259 | uint32_t id GNUNET_PACKED; |
250 | 260 | ||
251 | /** | 261 | /** |
252 | * Identity. | 262 | * The length of the private key |
263 | */ | ||
264 | uint32_t key_len GNUNET_PACKED; | ||
265 | |||
266 | /** | ||
267 | * followed by the private key. | ||
253 | */ | 268 | */ |
254 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
255 | }; | 269 | }; |
256 | 270 | ||
257 | 271 | ||
@@ -321,9 +335,13 @@ struct TicketIterationStartMessage | |||
321 | uint32_t id GNUNET_PACKED; | 335 | uint32_t id GNUNET_PACKED; |
322 | 336 | ||
323 | /** | 337 | /** |
324 | * Identity. | 338 | * The length of the private key |
339 | */ | ||
340 | uint32_t key_len GNUNET_PACKED; | ||
341 | |||
342 | /** | ||
343 | * followed by the private key. | ||
325 | */ | 344 | */ |
326 | struct GNUNET_IDENTITY_PrivateKey identity; | ||
327 | }; | 345 | }; |
328 | 346 | ||
329 | 347 | ||
@@ -377,21 +395,25 @@ struct IssueTicketMessage | |||
377 | uint32_t id GNUNET_PACKED; | 395 | uint32_t id GNUNET_PACKED; |
378 | 396 | ||
379 | /** | 397 | /** |
380 | * Identity. | 398 | * length of serialized attribute list |
381 | */ | 399 | */ |
382 | struct GNUNET_IDENTITY_PrivateKey identity; | 400 | uint32_t attr_len GNUNET_PACKED; |
383 | 401 | ||
384 | /** | 402 | /** |
385 | * Requesting party. | 403 | * The length of the identity private key |
386 | */ | 404 | */ |
387 | struct GNUNET_IDENTITY_PublicKey rp; | 405 | uint32_t key_len GNUNET_PACKED; |
388 | 406 | ||
389 | /** | 407 | /** |
390 | * length of serialized attribute list | 408 | * The length of the relying party public key |
391 | */ | 409 | */ |
392 | uint32_t attr_len GNUNET_PACKED; | 410 | uint32_t pkey_len GNUNET_PACKED; |
393 | 411 | ||
394 | // Followed by a serialized attribute list | 412 | /** |
413 | * Followed by the private key. | ||
414 | * Followed by the public key. | ||
415 | * Followed by a serialized attribute list | ||
416 | */ | ||
395 | }; | 417 | }; |
396 | 418 | ||
397 | /** | 419 | /** |
@@ -410,19 +432,20 @@ struct RevokeTicketMessage | |||
410 | uint32_t id GNUNET_PACKED; | 432 | uint32_t id GNUNET_PACKED; |
411 | 433 | ||
412 | /** | 434 | /** |
413 | * Identity. | 435 | * The length of the private key |
414 | */ | 436 | */ |
415 | struct GNUNET_IDENTITY_PrivateKey identity; | 437 | uint32_t key_len GNUNET_PACKED; |
416 | 438 | ||
417 | /** | 439 | /** |
418 | * length of serialized attribute list | 440 | * The length of the ticket |
419 | */ | 441 | */ |
420 | uint32_t attrs_len GNUNET_PACKED; | 442 | uint32_t tkt_len GNUNET_PACKED; |
421 | 443 | ||
422 | /** | 444 | /** |
423 | * The ticket to revoke | 445 | * Followed by the serialized ticket. |
446 | * Followed by the private key. | ||
447 | * Followed by a serialized attribute list | ||
424 | */ | 448 | */ |
425 | struct GNUNET_RECLAIM_Ticket ticket; | ||
426 | }; | 449 | }; |
427 | 450 | ||
428 | /** | 451 | /** |
@@ -463,16 +486,19 @@ struct TicketResultMessage | |||
463 | uint32_t id GNUNET_PACKED; | 486 | uint32_t id GNUNET_PACKED; |
464 | 487 | ||
465 | /** | 488 | /** |
466 | * Length of new presentations created | 489 | * Ticket length |
467 | */ | 490 | */ |
468 | uint32_t presentations_len GNUNET_PACKED; | 491 | uint32_t tkt_len GNUNET_PACKED; |
469 | 492 | ||
470 | /** | 493 | /** |
471 | * The new ticket | 494 | * Length of new presentations created |
472 | */ | 495 | */ |
473 | struct GNUNET_RECLAIM_Ticket ticket; | 496 | uint32_t presentations_len GNUNET_PACKED; |
474 | 497 | ||
475 | /* Followed by the serialized GNUNET_RECLAIM_PresentationList */ | 498 | /* |
499 | * Followed by the serialized ticket | ||
500 | * Followed by the serialized GNUNET_RECLAIM_PresentationList | ||
501 | */ | ||
476 | }; | 502 | }; |
477 | 503 | ||
478 | /** | 504 | /** |
@@ -491,14 +517,19 @@ struct ConsumeTicketMessage | |||
491 | uint32_t id GNUNET_PACKED; | 517 | uint32_t id GNUNET_PACKED; |
492 | 518 | ||
493 | /** | 519 | /** |
494 | * Identity. | 520 | * The length of the private key |
495 | */ | 521 | */ |
496 | struct GNUNET_IDENTITY_PrivateKey identity; | 522 | uint32_t key_len GNUNET_PACKED; |
497 | 523 | ||
498 | /** | 524 | /** |
499 | * The ticket to consume | 525 | * The length of the ticket |
526 | */ | ||
527 | uint32_t tkt_len GNUNET_PACKED; | ||
528 | |||
529 | /** | ||
530 | * Followed by the private key. | ||
531 | * Followed by the serialized ticket. | ||
500 | */ | 532 | */ |
501 | struct GNUNET_RECLAIM_Ticket ticket; | ||
502 | }; | 533 | }; |
503 | 534 | ||
504 | /** | 535 | /** |
@@ -537,11 +568,13 @@ struct ConsumeTicketResultMessage | |||
537 | uint16_t reserved GNUNET_PACKED; | 568 | uint16_t reserved GNUNET_PACKED; |
538 | 569 | ||
539 | /** | 570 | /** |
540 | * The public key of the identity. | 571 | * The length of the private key |
541 | */ | 572 | */ |
542 | struct GNUNET_IDENTITY_PublicKey identity; | 573 | uint32_t key_len GNUNET_PACKED; |
543 | 574 | ||
544 | /* followed by: | 575 | /** |
576 | * Followed by the private key. | ||
577 | * followed by: | ||
545 | * serialized attributes data | 578 | * serialized attributes data |
546 | */ | 579 | */ |
547 | }; | 580 | }; |
diff --git a/src/reclaim/reclaim_api.c b/src/reclaim/reclaim_api.c index 6f55d62e4..efc45e616 100644 --- a/src/reclaim/reclaim_api.c +++ b/src/reclaim/reclaim_api.c | |||
@@ -567,12 +567,13 @@ check_consume_ticket_result (void *cls, | |||
567 | size_t msg_len; | 567 | size_t msg_len; |
568 | size_t attrs_len; | 568 | size_t attrs_len; |
569 | size_t pl_len; | 569 | size_t pl_len; |
570 | size_t key_len; | ||
570 | 571 | ||
571 | msg_len = ntohs (msg->header.size); | 572 | msg_len = ntohs (msg->header.size); |
572 | attrs_len = ntohs (msg->attrs_len); | 573 | attrs_len = ntohs (msg->attrs_len); |
574 | key_len = ntohl (msg->key_len); | ||
573 | pl_len = ntohs (msg->presentations_len); | 575 | pl_len = ntohs (msg->presentations_len); |
574 | if (msg_len != | 576 | if (msg_len != sizeof(*msg) + attrs_len + pl_len + key_len) |
575 | sizeof(struct ConsumeTicketResultMessage) + attrs_len + pl_len) | ||
576 | { | 577 | { |
577 | GNUNET_break (0); | 578 | GNUNET_break (0); |
578 | return GNUNET_SYSERR; | 579 | return GNUNET_SYSERR; |
@@ -592,14 +593,18 @@ static void | |||
592 | handle_consume_ticket_result (void *cls, | 593 | handle_consume_ticket_result (void *cls, |
593 | const struct ConsumeTicketResultMessage *msg) | 594 | const struct ConsumeTicketResultMessage *msg) |
594 | { | 595 | { |
596 | struct GNUNET_IDENTITY_PublicKey identity; | ||
595 | struct GNUNET_RECLAIM_Handle *h = cls; | 597 | struct GNUNET_RECLAIM_Handle *h = cls; |
596 | struct GNUNET_RECLAIM_Operation *op; | 598 | struct GNUNET_RECLAIM_Operation *op; |
597 | size_t attrs_len; | 599 | size_t attrs_len; |
598 | size_t pl_len; | 600 | size_t pl_len; |
601 | size_t key_len; | ||
602 | size_t read; | ||
599 | uint32_t r_id = ntohl (msg->id); | 603 | uint32_t r_id = ntohl (msg->id); |
600 | char *read_ptr; | 604 | char *read_ptr; |
601 | 605 | ||
602 | attrs_len = ntohs (msg->attrs_len); | 606 | attrs_len = ntohs (msg->attrs_len); |
607 | key_len = ntohl (msg->key_len); | ||
603 | pl_len = ntohs (msg->presentations_len); | 608 | pl_len = ntohs (msg->presentations_len); |
604 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing ticket result.\n"); | 609 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing ticket result.\n"); |
605 | 610 | ||
@@ -615,15 +620,22 @@ handle_consume_ticket_result (void *cls, | |||
615 | struct GNUNET_RECLAIM_AttributeListEntry *le; | 620 | struct GNUNET_RECLAIM_AttributeListEntry *le; |
616 | struct GNUNET_RECLAIM_PresentationList *pl; | 621 | struct GNUNET_RECLAIM_PresentationList *pl; |
617 | struct GNUNET_RECLAIM_PresentationListEntry *ple; | 622 | struct GNUNET_RECLAIM_PresentationListEntry *ple; |
623 | read_ptr = (char *) &msg[1]; | ||
624 | GNUNET_assert (GNUNET_SYSERR != | ||
625 | GNUNET_IDENTITY_read_public_key_from_buffer (read_ptr, | ||
626 | key_len, | ||
627 | &identity, | ||
628 | &read)); | ||
629 | read_ptr += read; | ||
618 | attrs = | 630 | attrs = |
619 | GNUNET_RECLAIM_attribute_list_deserialize ((char *) &msg[1], attrs_len); | 631 | GNUNET_RECLAIM_attribute_list_deserialize (read_ptr, attrs_len); |
620 | read_ptr = ((char *) &msg[1]) + attrs_len; | 632 | read_ptr += attrs_len; |
621 | pl = GNUNET_RECLAIM_presentation_list_deserialize (read_ptr, pl_len); | 633 | pl = GNUNET_RECLAIM_presentation_list_deserialize (read_ptr, pl_len); |
622 | if (NULL != op->atr_cb) | 634 | if (NULL != op->atr_cb) |
623 | { | 635 | { |
624 | if (NULL == attrs) | 636 | if (NULL == attrs) |
625 | { | 637 | { |
626 | op->atr_cb (op->cls, &msg->identity, NULL, NULL); | 638 | op->atr_cb (op->cls, &identity, NULL, NULL); |
627 | } | 639 | } |
628 | else | 640 | else |
629 | { | 641 | { |
@@ -638,7 +650,7 @@ handle_consume_ticket_result (void *cls, | |||
638 | GNUNET_RECLAIM_id_is_equal (&le->attribute->credential, | 650 | GNUNET_RECLAIM_id_is_equal (&le->attribute->credential, |
639 | &ple->presentation->credential_id)) | 651 | &ple->presentation->credential_id)) |
640 | { | 652 | { |
641 | op->atr_cb (op->cls, &msg->identity, | 653 | op->atr_cb (op->cls, &identity, |
642 | le->attribute, ple->presentation); | 654 | le->attribute, ple->presentation); |
643 | break; | 655 | break; |
644 | } | 656 | } |
@@ -647,7 +659,7 @@ handle_consume_ticket_result (void *cls, | |||
647 | } | 659 | } |
648 | else // No credentials | 660 | else // No credentials |
649 | { | 661 | { |
650 | op->atr_cb (op->cls, &msg->identity, | 662 | op->atr_cb (op->cls, &identity, |
651 | le->attribute, NULL); | 663 | le->attribute, NULL); |
652 | } | 664 | } |
653 | } | 665 | } |
@@ -679,10 +691,12 @@ check_attribute_result (void *cls, const struct AttributeResultMessage *msg) | |||
679 | { | 691 | { |
680 | size_t msg_len; | 692 | size_t msg_len; |
681 | size_t attr_len; | 693 | size_t attr_len; |
694 | size_t key_len; | ||
682 | 695 | ||
683 | msg_len = ntohs (msg->header.size); | 696 | msg_len = ntohs (msg->header.size); |
684 | attr_len = ntohs (msg->attr_len); | 697 | attr_len = ntohs (msg->attr_len); |
685 | if (msg_len != sizeof(struct AttributeResultMessage) + attr_len) | 698 | key_len = ntohl (msg->pkey_len); |
699 | if (msg_len != sizeof(*msg) + attr_len + key_len) | ||
686 | { | 700 | { |
687 | GNUNET_break (0); | 701 | GNUNET_break (0); |
688 | return GNUNET_SYSERR; | 702 | return GNUNET_SYSERR; |
@@ -701,17 +715,20 @@ check_attribute_result (void *cls, const struct AttributeResultMessage *msg) | |||
701 | static void | 715 | static void |
702 | handle_attribute_result (void *cls, const struct AttributeResultMessage *msg) | 716 | handle_attribute_result (void *cls, const struct AttributeResultMessage *msg) |
703 | { | 717 | { |
704 | static struct GNUNET_IDENTITY_PrivateKey identity_dummy; | 718 | static struct GNUNET_IDENTITY_PublicKey identity; |
705 | struct GNUNET_RECLAIM_Handle *h = cls; | 719 | struct GNUNET_RECLAIM_Handle *h = cls; |
706 | struct GNUNET_RECLAIM_AttributeIterator *it; | 720 | struct GNUNET_RECLAIM_AttributeIterator *it; |
707 | struct GNUNET_RECLAIM_Operation *op; | 721 | struct GNUNET_RECLAIM_Operation *op; |
708 | size_t attr_len; | 722 | size_t attr_len; |
723 | size_t key_len; | ||
724 | size_t read; | ||
709 | uint32_t r_id = ntohl (msg->id); | 725 | uint32_t r_id = ntohl (msg->id); |
726 | char *buf; | ||
710 | 727 | ||
711 | attr_len = ntohs (msg->attr_len); | 728 | attr_len = ntohs (msg->attr_len); |
729 | key_len = ntohl (msg->pkey_len); | ||
712 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n"); | 730 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n"); |
713 | 731 | ||
714 | |||
715 | for (it = h->it_head; NULL != it; it = it->next) | 732 | for (it = h->it_head; NULL != it; it = it->next) |
716 | if (it->r_id == r_id) | 733 | if (it->r_id == r_id) |
717 | break; | 734 | break; |
@@ -721,8 +738,8 @@ handle_attribute_result (void *cls, const struct AttributeResultMessage *msg) | |||
721 | if ((NULL == it) && (NULL == op)) | 738 | if ((NULL == it) && (NULL == op)) |
722 | return; | 739 | return; |
723 | 740 | ||
724 | if ((0 == | 741 | buf = (char *) &msg[1]; |
725 | (memcmp (&msg->identity, &identity_dummy, sizeof(identity_dummy))))) | 742 | if (0 == key_len) |
726 | { | 743 | { |
727 | if ((NULL == it) && (NULL == op)) | 744 | if ((NULL == it) && (NULL == op)) |
728 | { | 745 | { |
@@ -748,17 +765,22 @@ handle_attribute_result (void *cls, const struct AttributeResultMessage *msg) | |||
748 | 765 | ||
749 | { | 766 | { |
750 | struct GNUNET_RECLAIM_Attribute *attr; | 767 | struct GNUNET_RECLAIM_Attribute *attr; |
751 | GNUNET_RECLAIM_attribute_deserialize ((char *) &msg[1], attr_len, | 768 | GNUNET_assert (GNUNET_SYSERR != |
752 | &attr); | 769 | GNUNET_IDENTITY_read_public_key_from_buffer (buf, |
770 | key_len, | ||
771 | &identity, | ||
772 | &read)); | ||
773 | buf += read; | ||
774 | GNUNET_RECLAIM_attribute_deserialize (buf, attr_len, &attr); | ||
753 | if (NULL != it) | 775 | if (NULL != it) |
754 | { | 776 | { |
755 | if (NULL != it->proc) | 777 | if (NULL != it->proc) |
756 | it->proc (it->proc_cls, &msg->identity, attr); | 778 | it->proc (it->proc_cls, &identity, attr); |
757 | } | 779 | } |
758 | else if (NULL != op) | 780 | else if (NULL != op) |
759 | { | 781 | { |
760 | if (NULL != op->ar_cb) | 782 | if (NULL != op->ar_cb) |
761 | op->ar_cb (op->cls, &msg->identity, attr); | 783 | op->ar_cb (op->cls, &identity, attr); |
762 | } | 784 | } |
763 | GNUNET_free (attr); | 785 | GNUNET_free (attr); |
764 | return; | 786 | return; |
@@ -780,10 +802,12 @@ check_credential_result (void *cls, const struct CredentialResultMessage *msg) | |||
780 | { | 802 | { |
781 | size_t msg_len; | 803 | size_t msg_len; |
782 | size_t cred_len; | 804 | size_t cred_len; |
805 | size_t key_len; | ||
783 | 806 | ||
784 | msg_len = ntohs (msg->header.size); | 807 | msg_len = ntohs (msg->header.size); |
785 | cred_len = ntohs (msg->credential_len); | 808 | cred_len = ntohs (msg->credential_len); |
786 | if (msg_len != sizeof(struct CredentialResultMessage) + cred_len) | 809 | key_len = ntohl (msg->key_len); |
810 | if (msg_len != sizeof(*msg) + cred_len + key_len) | ||
787 | { | 811 | { |
788 | GNUNET_break (0); | 812 | GNUNET_break (0); |
789 | return GNUNET_SYSERR; | 813 | return GNUNET_SYSERR; |
@@ -803,13 +827,17 @@ static void | |||
803 | handle_credential_result (void *cls, const struct | 827 | handle_credential_result (void *cls, const struct |
804 | CredentialResultMessage *msg) | 828 | CredentialResultMessage *msg) |
805 | { | 829 | { |
806 | static struct GNUNET_IDENTITY_PrivateKey identity_dummy; | 830 | struct GNUNET_IDENTITY_PublicKey identity; |
807 | struct GNUNET_RECLAIM_Handle *h = cls; | 831 | struct GNUNET_RECLAIM_Handle *h = cls; |
808 | struct GNUNET_RECLAIM_CredentialIterator *it; | 832 | struct GNUNET_RECLAIM_CredentialIterator *it; |
809 | struct GNUNET_RECLAIM_Operation *op; | 833 | struct GNUNET_RECLAIM_Operation *op; |
810 | size_t att_len; | 834 | size_t att_len; |
835 | size_t key_len; | ||
836 | size_t read; | ||
811 | uint32_t r_id = ntohl (msg->id); | 837 | uint32_t r_id = ntohl (msg->id); |
838 | char *buf; | ||
812 | 839 | ||
840 | key_len = ntohl (msg->key_len); | ||
813 | att_len = ntohs (msg->credential_len); | 841 | att_len = ntohs (msg->credential_len); |
814 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing credential result.\n"); | 842 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing credential result.\n"); |
815 | 843 | ||
@@ -823,8 +851,17 @@ handle_credential_result (void *cls, const struct | |||
823 | if ((NULL == it) && (NULL == op)) | 851 | if ((NULL == it) && (NULL == op)) |
824 | return; | 852 | return; |
825 | 853 | ||
826 | if ((0 == | 854 | buf = (char *) &msg[1]; |
827 | (memcmp (&msg->identity, &identity_dummy, sizeof(identity_dummy))))) | 855 | if (0 < key_len) |
856 | { | ||
857 | GNUNET_assert (GNUNET_SYSERR != | ||
858 | GNUNET_IDENTITY_read_public_key_from_buffer (buf, | ||
859 | key_len, | ||
860 | &identity, | ||
861 | &read)); | ||
862 | buf += read; | ||
863 | } | ||
864 | if (0 == key_len) | ||
828 | { | 865 | { |
829 | if ((NULL == it) && (NULL == op)) | 866 | if ((NULL == it) && (NULL == op)) |
830 | { | 867 | { |
@@ -850,17 +887,17 @@ handle_credential_result (void *cls, const struct | |||
850 | 887 | ||
851 | { | 888 | { |
852 | struct GNUNET_RECLAIM_Credential *att; | 889 | struct GNUNET_RECLAIM_Credential *att; |
853 | att = GNUNET_RECLAIM_credential_deserialize ((char *) &msg[1], att_len); | 890 | att = GNUNET_RECLAIM_credential_deserialize (buf, att_len); |
854 | 891 | ||
855 | if (NULL != it) | 892 | if (NULL != it) |
856 | { | 893 | { |
857 | if (NULL != it->proc) | 894 | if (NULL != it->proc) |
858 | it->proc (it->proc_cls, &msg->identity, att); | 895 | it->proc (it->proc_cls, &identity, att); |
859 | } | 896 | } |
860 | else if (NULL != op) | 897 | else if (NULL != op) |
861 | { | 898 | { |
862 | if (NULL != op->at_cb) | 899 | if (NULL != op->at_cb) |
863 | op->at_cb (op->cls, &msg->identity, att); | 900 | op->at_cb (op->cls, &identity, att); |
864 | } | 901 | } |
865 | GNUNET_free (att); | 902 | GNUNET_free (att); |
866 | return; | 903 | return; |
@@ -882,10 +919,12 @@ check_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
882 | { | 919 | { |
883 | size_t msg_len; | 920 | size_t msg_len; |
884 | size_t pres_len; | 921 | size_t pres_len; |
922 | size_t tkt_len; | ||
885 | 923 | ||
886 | msg_len = ntohs (msg->header.size); | 924 | msg_len = ntohs (msg->header.size); |
887 | pres_len = ntohs (msg->presentations_len); | 925 | pres_len = ntohs (msg->presentations_len); |
888 | if (msg_len != sizeof(struct TicketResultMessage) + pres_len) | 926 | tkt_len = ntohl (msg->tkt_len); |
927 | if (msg_len != sizeof(*msg) + pres_len + tkt_len) | ||
889 | { | 928 | { |
890 | GNUNET_break (0); | 929 | GNUNET_break (0); |
891 | return GNUNET_SYSERR; | 930 | return GNUNET_SYSERR; |
@@ -909,9 +948,14 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
909 | struct GNUNET_RECLAIM_TicketIterator *it; | 948 | struct GNUNET_RECLAIM_TicketIterator *it; |
910 | struct GNUNET_RECLAIM_PresentationList *presentation; | 949 | struct GNUNET_RECLAIM_PresentationList *presentation; |
911 | uint32_t r_id = ntohl (msg->id); | 950 | uint32_t r_id = ntohl (msg->id); |
912 | static const struct GNUNET_RECLAIM_Ticket ticket; | 951 | struct GNUNET_RECLAIM_Ticket ticket; |
913 | uint32_t pres_len = ntohs (msg->presentations_len); | 952 | size_t pres_len; |
953 | size_t tkt_len; | ||
954 | size_t tb_read; | ||
955 | char *buf; | ||
914 | 956 | ||
957 | tkt_len = ntohl (msg->tkt_len); | ||
958 | pres_len = ntohs (msg->presentations_len); | ||
915 | for (op = handle->op_head; NULL != op; op = op->next) | 959 | for (op = handle->op_head; NULL != op; op = op->next) |
916 | if (op->r_id == r_id) | 960 | if (op->r_id == r_id) |
917 | break; | 961 | break; |
@@ -920,15 +964,21 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
920 | break; | 964 | break; |
921 | if ((NULL == op) && (NULL == it)) | 965 | if ((NULL == op) && (NULL == it)) |
922 | return; | 966 | return; |
967 | buf = (char*) &msg[1]; | ||
968 | GNUNET_assert (GNUNET_SYSERR != | ||
969 | GNUNET_RECLAIM_read_ticket_from_buffer (buf, | ||
970 | tkt_len, | ||
971 | &ticket, | ||
972 | &tb_read)); | ||
973 | buf += tb_read; | ||
923 | if (NULL != op) | 974 | if (NULL != op) |
924 | { | 975 | { |
925 | if (0 < pres_len) | 976 | if (0 < pres_len) |
926 | presentation = GNUNET_RECLAIM_presentation_list_deserialize ( | 977 | presentation = GNUNET_RECLAIM_presentation_list_deserialize ( |
927 | (char*) &msg[1], | 978 | buf, |
928 | pres_len); | 979 | pres_len); |
929 | GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op); | 980 | GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op); |
930 | if (0 == | 981 | if (0 == tb_read) |
931 | memcmp (&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket))) | ||
932 | { | 982 | { |
933 | if (NULL != op->ti_cb) | 983 | if (NULL != op->ti_cb) |
934 | op->ti_cb (op->cls, NULL, NULL); | 984 | op->ti_cb (op->cls, NULL, NULL); |
@@ -937,7 +987,7 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
937 | { | 987 | { |
938 | if (NULL != op->ti_cb) | 988 | if (NULL != op->ti_cb) |
939 | op->ti_cb (op->cls, | 989 | op->ti_cb (op->cls, |
940 | &msg->ticket, | 990 | &ticket, |
941 | (0 < pres_len) ? presentation : NULL); | 991 | (0 < pres_len) ? presentation : NULL); |
942 | } | 992 | } |
943 | if (0 < pres_len) | 993 | if (0 < pres_len) |
@@ -947,8 +997,7 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
947 | } | 997 | } |
948 | else if (NULL != it) | 998 | else if (NULL != it) |
949 | { | 999 | { |
950 | if (0 == | 1000 | if (0 == tkt_len) |
951 | memcmp (&msg->ticket, &ticket, sizeof(struct GNUNET_RECLAIM_Ticket))) | ||
952 | { | 1001 | { |
953 | GNUNET_CONTAINER_DLL_remove (handle->ticket_it_head, | 1002 | GNUNET_CONTAINER_DLL_remove (handle->ticket_it_head, |
954 | handle->ticket_it_tail, | 1003 | handle->ticket_it_tail, |
@@ -959,7 +1008,7 @@ handle_ticket_result (void *cls, const struct TicketResultMessage *msg) | |||
959 | else | 1008 | else |
960 | { | 1009 | { |
961 | if (NULL != it->tr_cb) | 1010 | if (NULL != it->tr_cb) |
962 | it->tr_cb (it->cls, &msg->ticket); | 1011 | it->tr_cb (it->cls, &ticket); |
963 | } | 1012 | } |
964 | return; | 1013 | return; |
965 | } | 1014 | } |
@@ -1110,18 +1159,6 @@ GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h) | |||
1110 | } | 1159 | } |
1111 | 1160 | ||
1112 | 1161 | ||
1113 | /** | ||
1114 | * Store an attribute. If the attribute is already present, | ||
1115 | * it is replaced with the new attribute. | ||
1116 | * | ||
1117 | * @param h handle to the re:claimID service | ||
1118 | * @param pkey private key of the identity | ||
1119 | * @param attr the attribute value | ||
1120 | * @param exp_interval the relative expiration interval for the attribute | ||
1121 | * @param cont continuation to call when done | ||
1122 | * @param cont_cls closure for @a cont | ||
1123 | * @return handle to abort the request | ||
1124 | */ | ||
1125 | struct GNUNET_RECLAIM_Operation * | 1162 | struct GNUNET_RECLAIM_Operation * |
1126 | GNUNET_RECLAIM_attribute_store ( | 1163 | GNUNET_RECLAIM_attribute_store ( |
1127 | struct GNUNET_RECLAIM_Handle *h, | 1164 | struct GNUNET_RECLAIM_Handle *h, |
@@ -1134,6 +1171,9 @@ GNUNET_RECLAIM_attribute_store ( | |||
1134 | struct GNUNET_RECLAIM_Operation *op; | 1171 | struct GNUNET_RECLAIM_Operation *op; |
1135 | struct AttributeStoreMessage *sam; | 1172 | struct AttributeStoreMessage *sam; |
1136 | size_t attr_len; | 1173 | size_t attr_len; |
1174 | size_t key_len; | ||
1175 | ssize_t written; | ||
1176 | char *buf; | ||
1137 | 1177 | ||
1138 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1178 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1139 | op->h = h; | 1179 | op->h = h; |
@@ -1141,15 +1181,20 @@ GNUNET_RECLAIM_attribute_store ( | |||
1141 | op->cls = cont_cls; | 1181 | op->cls = cont_cls; |
1142 | op->r_id = h->r_id_gen++; | 1182 | op->r_id = h->r_id_gen++; |
1143 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1183 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1184 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1144 | attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr); | 1185 | attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr); |
1145 | op->env = GNUNET_MQ_msg_extra (sam, | 1186 | op->env = GNUNET_MQ_msg_extra (sam, |
1146 | attr_len, | 1187 | attr_len + key_len, |
1147 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE); | 1188 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE); |
1148 | sam->identity = *pkey; | 1189 | sam->key_len = htonl (key_len); |
1190 | buf = (char *) &sam[1]; | ||
1191 | written = GNUNET_IDENTITY_write_private_key_to_buffer (pkey, buf, key_len); | ||
1192 | GNUNET_assert (0 < written); | ||
1193 | buf += written; | ||
1149 | sam->id = htonl (op->r_id); | 1194 | sam->id = htonl (op->r_id); |
1150 | sam->exp = GNUNET_htonll (exp_interval->rel_value_us); | 1195 | sam->exp = GNUNET_htonll (exp_interval->rel_value_us); |
1151 | 1196 | ||
1152 | GNUNET_RECLAIM_attribute_serialize (attr, (char *) &sam[1]); | 1197 | GNUNET_RECLAIM_attribute_serialize (attr, buf); |
1153 | 1198 | ||
1154 | sam->attr_len = htons (attr_len); | 1199 | sam->attr_len = htons (attr_len); |
1155 | if (NULL != h->mq) | 1200 | if (NULL != h->mq) |
@@ -1158,17 +1203,6 @@ GNUNET_RECLAIM_attribute_store ( | |||
1158 | } | 1203 | } |
1159 | 1204 | ||
1160 | 1205 | ||
1161 | /** | ||
1162 | * Delete an attribute. Tickets used to share this attribute are updated | ||
1163 | * accordingly. | ||
1164 | * | ||
1165 | * @param h handle to the re:claimID service | ||
1166 | * @param pkey Private key of the identity to add an attribute to | ||
1167 | * @param attr The attribute | ||
1168 | * @param cont Continuation to call when done | ||
1169 | * @param cont_cls Closure for @a cont | ||
1170 | * @return handle Used to to abort the request | ||
1171 | */ | ||
1172 | struct GNUNET_RECLAIM_Operation * | 1206 | struct GNUNET_RECLAIM_Operation * |
1173 | GNUNET_RECLAIM_attribute_delete ( | 1207 | GNUNET_RECLAIM_attribute_delete ( |
1174 | struct GNUNET_RECLAIM_Handle *h, | 1208 | struct GNUNET_RECLAIM_Handle *h, |
@@ -1180,6 +1214,9 @@ GNUNET_RECLAIM_attribute_delete ( | |||
1180 | struct GNUNET_RECLAIM_Operation *op; | 1214 | struct GNUNET_RECLAIM_Operation *op; |
1181 | struct AttributeDeleteMessage *dam; | 1215 | struct AttributeDeleteMessage *dam; |
1182 | size_t attr_len; | 1216 | size_t attr_len; |
1217 | size_t key_len; | ||
1218 | ssize_t written; | ||
1219 | char *buf; | ||
1183 | 1220 | ||
1184 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1221 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1185 | op->h = h; | 1222 | op->h = h; |
@@ -1187,13 +1224,18 @@ GNUNET_RECLAIM_attribute_delete ( | |||
1187 | op->cls = cont_cls; | 1224 | op->cls = cont_cls; |
1188 | op->r_id = h->r_id_gen++; | 1225 | op->r_id = h->r_id_gen++; |
1189 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1226 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1227 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1190 | attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr); | 1228 | attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr); |
1191 | op->env = GNUNET_MQ_msg_extra (dam, | 1229 | op->env = GNUNET_MQ_msg_extra (dam, |
1192 | attr_len, | 1230 | attr_len + key_len, |
1193 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE); | 1231 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE); |
1194 | dam->identity = *pkey; | 1232 | dam->key_len = htonl (key_len); |
1233 | buf = (char *) &dam[1]; | ||
1234 | written = GNUNET_IDENTITY_write_private_key_to_buffer (pkey, buf, key_len); | ||
1235 | GNUNET_assert (0 < written); | ||
1236 | buf += written; | ||
1195 | dam->id = htonl (op->r_id); | 1237 | dam->id = htonl (op->r_id); |
1196 | GNUNET_RECLAIM_attribute_serialize (attr, (char *) &dam[1]); | 1238 | GNUNET_RECLAIM_attribute_serialize (attr, buf); |
1197 | 1239 | ||
1198 | dam->attr_len = htons (attr_len); | 1240 | dam->attr_len = htons (attr_len); |
1199 | if (NULL != h->mq) | 1241 | if (NULL != h->mq) |
@@ -1214,22 +1256,30 @@ GNUNET_RECLAIM_credential_store ( | |||
1214 | struct GNUNET_RECLAIM_Operation *op; | 1256 | struct GNUNET_RECLAIM_Operation *op; |
1215 | struct AttributeStoreMessage *sam; | 1257 | struct AttributeStoreMessage *sam; |
1216 | size_t attr_len; | 1258 | size_t attr_len; |
1259 | size_t key_len; | ||
1260 | ssize_t written; | ||
1261 | char *buf; | ||
1217 | 1262 | ||
1218 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1263 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1219 | op->h = h; | 1264 | op->h = h; |
1220 | op->as_cb = cont; | 1265 | op->as_cb = cont; |
1221 | op->cls = cont_cls; | 1266 | op->cls = cont_cls; |
1222 | op->r_id = h->r_id_gen++; | 1267 | op->r_id = h->r_id_gen++; |
1268 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1223 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1269 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1224 | attr_len = GNUNET_RECLAIM_credential_serialize_get_size (credential); | 1270 | attr_len = GNUNET_RECLAIM_credential_serialize_get_size (credential); |
1225 | op->env = GNUNET_MQ_msg_extra (sam, | 1271 | op->env = GNUNET_MQ_msg_extra (sam, |
1226 | attr_len, | 1272 | attr_len + key_len, |
1227 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE); | 1273 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE); |
1228 | sam->identity = *pkey; | 1274 | sam->key_len = htonl (key_len); |
1275 | buf = (char *) &sam[1]; | ||
1276 | written = GNUNET_IDENTITY_write_private_key_to_buffer (pkey, buf, key_len); | ||
1277 | GNUNET_assert (0 <= written); | ||
1278 | buf += written; | ||
1229 | sam->id = htonl (op->r_id); | 1279 | sam->id = htonl (op->r_id); |
1230 | sam->exp = GNUNET_htonll (exp_interval->rel_value_us); | 1280 | sam->exp = GNUNET_htonll (exp_interval->rel_value_us); |
1231 | 1281 | ||
1232 | GNUNET_RECLAIM_credential_serialize (credential, (char *) &sam[1]); | 1282 | GNUNET_RECLAIM_credential_serialize (credential, buf); |
1233 | 1283 | ||
1234 | sam->attr_len = htons (attr_len); | 1284 | sam->attr_len = htons (attr_len); |
1235 | if (NULL != h->mq) | 1285 | if (NULL != h->mq) |
@@ -1249,20 +1299,28 @@ GNUNET_RECLAIM_credential_delete ( | |||
1249 | struct GNUNET_RECLAIM_Operation *op; | 1299 | struct GNUNET_RECLAIM_Operation *op; |
1250 | struct AttributeDeleteMessage *dam; | 1300 | struct AttributeDeleteMessage *dam; |
1251 | size_t attr_len; | 1301 | size_t attr_len; |
1302 | size_t key_len; | ||
1303 | ssize_t written; | ||
1304 | char *buf; | ||
1252 | 1305 | ||
1253 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1306 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1254 | op->h = h; | 1307 | op->h = h; |
1255 | op->as_cb = cont; | 1308 | op->as_cb = cont; |
1256 | op->cls = cont_cls; | 1309 | op->cls = cont_cls; |
1257 | op->r_id = h->r_id_gen++; | 1310 | op->r_id = h->r_id_gen++; |
1311 | key_len = GNUNET_IDENTITY_private_key_get_length (pkey); | ||
1258 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1312 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1259 | attr_len = GNUNET_RECLAIM_credential_serialize_get_size (attr); | 1313 | attr_len = GNUNET_RECLAIM_credential_serialize_get_size (attr); |
1260 | op->env = GNUNET_MQ_msg_extra (dam, | 1314 | op->env = GNUNET_MQ_msg_extra (dam, |
1261 | attr_len, | 1315 | attr_len + key_len, |
1262 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE); | 1316 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE); |
1263 | dam->identity = *pkey; | 1317 | dam->key_len = htonl (key_len); |
1318 | buf = (char *) &dam[1]; | ||
1319 | written = GNUNET_IDENTITY_write_private_key_to_buffer (pkey, buf, key_len); | ||
1320 | GNUNET_assert (0 <= written); | ||
1321 | buf += written; | ||
1264 | dam->id = htonl (op->r_id); | 1322 | dam->id = htonl (op->r_id); |
1265 | GNUNET_RECLAIM_credential_serialize (attr, (char *) &dam[1]); | 1323 | GNUNET_RECLAIM_credential_serialize (attr, buf); |
1266 | 1324 | ||
1267 | dam->attr_len = htons (attr_len); | 1325 | dam->attr_len = htons (attr_len); |
1268 | if (NULL != h->mq) | 1326 | if (NULL != h->mq) |
@@ -1271,30 +1329,6 @@ GNUNET_RECLAIM_credential_delete ( | |||
1271 | } | 1329 | } |
1272 | 1330 | ||
1273 | 1331 | ||
1274 | /** | ||
1275 | * List all attributes for a local identity. | ||
1276 | * This MUST lock the `struct GNUNET_RECLAIM_Handle` | ||
1277 | * for any other calls than #GNUNET_RECLAIM_get_attributes_next() and | ||
1278 | * #GNUNET_RECLAIM_get_attributes_stop. @a proc will be called once | ||
1279 | * immediately, and then again after | ||
1280 | * #GNUNET_RECLAIM_get_attributes_next() is invoked. | ||
1281 | * | ||
1282 | * On error (disconnect), @a error_cb will be invoked. | ||
1283 | * On normal completion, @a finish_cb proc will be | ||
1284 | * invoked. | ||
1285 | * | ||
1286 | * @param h Handle to the re:claimID service | ||
1287 | * @param identity Identity to iterate over | ||
1288 | * @param error_cb Function to call on error (i.e. disconnect), | ||
1289 | * the handle is afterwards invalid | ||
1290 | * @param error_cb_cls Closure for @a error_cb | ||
1291 | * @param proc Function to call on each attribute | ||
1292 | * @param proc_cls Closure for @a proc | ||
1293 | * @param finish_cb Function to call on completion | ||
1294 | * the handle is afterwards invalid | ||
1295 | * @param finish_cb_cls Closure for @a finish_cb | ||
1296 | * @return an iterator Handle to use for iteration | ||
1297 | */ | ||
1298 | struct GNUNET_RECLAIM_AttributeIterator * | 1332 | struct GNUNET_RECLAIM_AttributeIterator * |
1299 | GNUNET_RECLAIM_get_attributes_start ( | 1333 | GNUNET_RECLAIM_get_attributes_start ( |
1300 | struct GNUNET_RECLAIM_Handle *h, | 1334 | struct GNUNET_RECLAIM_Handle *h, |
@@ -1310,6 +1344,7 @@ GNUNET_RECLAIM_get_attributes_start ( | |||
1310 | struct GNUNET_MQ_Envelope *env; | 1344 | struct GNUNET_MQ_Envelope *env; |
1311 | struct AttributeIterationStartMessage *msg; | 1345 | struct AttributeIterationStartMessage *msg; |
1312 | uint32_t rid; | 1346 | uint32_t rid; |
1347 | size_t key_len; | ||
1313 | 1348 | ||
1314 | rid = h->r_id_gen++; | 1349 | rid = h->r_id_gen++; |
1315 | it = GNUNET_new (struct GNUNET_RECLAIM_AttributeIterator); | 1350 | it = GNUNET_new (struct GNUNET_RECLAIM_AttributeIterator); |
@@ -1322,11 +1357,15 @@ GNUNET_RECLAIM_get_attributes_start ( | |||
1322 | it->proc_cls = proc_cls; | 1357 | it->proc_cls = proc_cls; |
1323 | it->r_id = rid; | 1358 | it->r_id = rid; |
1324 | it->identity = *identity; | 1359 | it->identity = *identity; |
1360 | key_len = GNUNET_IDENTITY_private_key_get_length (identity); | ||
1325 | GNUNET_CONTAINER_DLL_insert_tail (h->it_head, h->it_tail, it); | 1361 | GNUNET_CONTAINER_DLL_insert_tail (h->it_head, h->it_tail, it); |
1326 | env = | 1362 | env = |
1327 | GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START); | 1363 | GNUNET_MQ_msg_extra (msg, |
1364 | key_len, | ||
1365 | GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START); | ||
1328 | msg->id = htonl (rid); | 1366 | msg->id = htonl (rid); |
1329 | msg->identity = *identity; | 1367 | msg->key_len = htonl (key_len); |
1368 | GNUNET_IDENTITY_write_private_key_to_buffer (identity, &msg[1], key_len); | ||
1330 | if (NULL == h->mq) | 1369 | if (NULL == h->mq) |
1331 | it->env = env; | 1370 | it->env = env; |
1332 | else | 1371 | else |
@@ -1349,13 +1388,6 @@ GNUNET_RECLAIM_get_attributes_next (struct GNUNET_RECLAIM_AttributeIterator *it) | |||
1349 | } | 1388 | } |
1350 | 1389 | ||
1351 | 1390 | ||
1352 | /** | ||
1353 | * Stops iteration and releases the handle for further calls. Must | ||
1354 | * be called on any iteration that has not yet completed prior to calling | ||
1355 | * #GNUNET_RECLAIM_disconnect. | ||
1356 | * | ||
1357 | * @param it the iterator | ||
1358 | */ | ||
1359 | void | 1391 | void |
1360 | GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it) | 1392 | GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it) |
1361 | { | 1393 | { |
@@ -1374,30 +1406,6 @@ GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it) | |||
1374 | } | 1406 | } |
1375 | 1407 | ||
1376 | 1408 | ||
1377 | /** | ||
1378 | * List all credentials for a local identity. | ||
1379 | * This MUST lock the `struct GNUNET_RECLAIM_Handle` | ||
1380 | * for any other calls than #GNUNET_RECLAIM_get_credentials_next() and | ||
1381 | * #GNUNET_RECLAIM_get_credentials_stop. @a proc will be called once | ||
1382 | * immediately, and then again after | ||
1383 | * #GNUNET_RECLAIM_get_credentials_next() is invoked. | ||
1384 | * | ||
1385 | * On error (disconnect), @a error_cb will be invoked. | ||
1386 | * On normal completion, @a finish_cb proc will be | ||
1387 | * invoked. | ||
1388 | * | ||
1389 | * @param h Handle to the re:claimID service | ||
1390 | * @param identity Identity to iterate over | ||
1391 | * @param error_cb Function to call on error (i.e. disconnect), | ||
1392 | * the handle is afterwards invalid | ||
1393 | * @param error_cb_cls Closure for @a error_cb | ||
1394 | * @param proc Function to call on each credential | ||
1395 | * @param proc_cls Closure for @a proc | ||
1396 | * @param finish_cb Function to call on completion | ||
1397 | * the handle is afterwards invalid | ||
1398 | * @param finish_cb_cls Closure for @a finish_cb | ||
1399 | * @return an iterator Handle to use for iteration | ||
1400 | */ | ||
1401 | struct GNUNET_RECLAIM_CredentialIterator * | 1409 | struct GNUNET_RECLAIM_CredentialIterator * |
1402 | GNUNET_RECLAIM_get_credentials_start ( | 1410 | GNUNET_RECLAIM_get_credentials_start ( |
1403 | struct GNUNET_RECLAIM_Handle *h, | 1411 | struct GNUNET_RECLAIM_Handle *h, |
@@ -1413,6 +1421,7 @@ GNUNET_RECLAIM_get_credentials_start ( | |||
1413 | struct GNUNET_MQ_Envelope *env; | 1421 | struct GNUNET_MQ_Envelope *env; |
1414 | struct CredentialIterationStartMessage *msg; | 1422 | struct CredentialIterationStartMessage *msg; |
1415 | uint32_t rid; | 1423 | uint32_t rid; |
1424 | size_t key_len; | ||
1416 | 1425 | ||
1417 | rid = h->r_id_gen++; | 1426 | rid = h->r_id_gen++; |
1418 | ait = GNUNET_new (struct GNUNET_RECLAIM_CredentialIterator); | 1427 | ait = GNUNET_new (struct GNUNET_RECLAIM_CredentialIterator); |
@@ -1425,12 +1434,15 @@ GNUNET_RECLAIM_get_credentials_start ( | |||
1425 | ait->proc_cls = proc_cls; | 1434 | ait->proc_cls = proc_cls; |
1426 | ait->r_id = rid; | 1435 | ait->r_id = rid; |
1427 | ait->identity = *identity; | 1436 | ait->identity = *identity; |
1437 | key_len = GNUNET_IDENTITY_private_key_get_length (identity); | ||
1428 | GNUNET_CONTAINER_DLL_insert_tail (h->ait_head, h->ait_tail, ait); | 1438 | GNUNET_CONTAINER_DLL_insert_tail (h->ait_head, h->ait_tail, ait); |
1429 | env = | 1439 | env = |
1430 | GNUNET_MQ_msg (msg, | 1440 | GNUNET_MQ_msg_extra (msg, |
1431 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START); | 1441 | key_len, |
1442 | GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START); | ||
1432 | msg->id = htonl (rid); | 1443 | msg->id = htonl (rid); |
1433 | msg->identity = *identity; | 1444 | msg->key_len = htonl (key_len); |
1445 | GNUNET_IDENTITY_write_private_key_to_buffer (identity, &msg[1], key_len); | ||
1434 | if (NULL == h->mq) | 1446 | if (NULL == h->mq) |
1435 | ait->env = env; | 1447 | ait->env = env; |
1436 | else | 1448 | else |
@@ -1486,23 +1498,35 @@ GNUNET_RECLAIM_ticket_issue ( | |||
1486 | struct GNUNET_RECLAIM_Operation *op; | 1498 | struct GNUNET_RECLAIM_Operation *op; |
1487 | struct IssueTicketMessage *tim; | 1499 | struct IssueTicketMessage *tim; |
1488 | size_t attr_len; | 1500 | size_t attr_len; |
1501 | size_t key_len; | ||
1502 | size_t rpk_len; | ||
1503 | ssize_t written; | ||
1504 | char *buf; | ||
1489 | 1505 | ||
1490 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1506 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1491 | op->h = h; | 1507 | op->h = h; |
1492 | op->ti_cb = cb; | 1508 | op->ti_cb = cb; |
1493 | op->cls = cb_cls; | 1509 | op->cls = cb_cls; |
1494 | op->r_id = h->r_id_gen++; | 1510 | op->r_id = h->r_id_gen++; |
1511 | key_len = GNUNET_IDENTITY_private_key_get_length (iss); | ||
1512 | rpk_len = GNUNET_IDENTITY_public_key_get_length (rp); | ||
1495 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1513 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1496 | attr_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); | 1514 | attr_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs); |
1497 | op->env = GNUNET_MQ_msg_extra (tim, | 1515 | op->env = GNUNET_MQ_msg_extra (tim, |
1498 | attr_len, | 1516 | attr_len + key_len + rpk_len, |
1499 | GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET); | 1517 | GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET); |
1500 | tim->identity = *iss; | 1518 | tim->key_len = htonl (key_len); |
1501 | tim->rp = *rp; | 1519 | tim->pkey_len = htonl (rpk_len); |
1520 | buf = (char *) &tim[1]; | ||
1521 | written = GNUNET_IDENTITY_write_private_key_to_buffer (iss, buf, key_len); | ||
1522 | GNUNET_assert (0 <= written); | ||
1523 | buf += written; | ||
1524 | written = GNUNET_IDENTITY_write_public_key_to_buffer (rp, buf, rpk_len); | ||
1525 | GNUNET_assert (0 <= written); | ||
1526 | buf += written; | ||
1502 | tim->id = htonl (op->r_id); | 1527 | tim->id = htonl (op->r_id); |
1503 | 1528 | ||
1504 | GNUNET_RECLAIM_attribute_list_serialize (attrs, (char *) &tim[1]); | 1529 | GNUNET_RECLAIM_attribute_list_serialize (attrs, buf); |
1505 | |||
1506 | tim->attr_len = htons (attr_len); | 1530 | tim->attr_len = htons (attr_len); |
1507 | if (NULL != h->mq) | 1531 | if (NULL != h->mq) |
1508 | GNUNET_MQ_send_copy (h->mq, op->env); | 1532 | GNUNET_MQ_send_copy (h->mq, op->env); |
@@ -1532,17 +1556,28 @@ GNUNET_RECLAIM_ticket_consume ( | |||
1532 | { | 1556 | { |
1533 | struct GNUNET_RECLAIM_Operation *op; | 1557 | struct GNUNET_RECLAIM_Operation *op; |
1534 | struct ConsumeTicketMessage *ctm; | 1558 | struct ConsumeTicketMessage *ctm; |
1559 | size_t key_len; | ||
1560 | size_t tkt_len; | ||
1561 | char *buf; | ||
1535 | 1562 | ||
1536 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1563 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
1537 | op->h = h; | 1564 | op->h = h; |
1538 | op->atr_cb = cb; | 1565 | op->atr_cb = cb; |
1539 | op->cls = cb_cls; | 1566 | op->cls = cb_cls; |
1540 | op->r_id = h->r_id_gen++; | 1567 | op->r_id = h->r_id_gen++; |
1568 | key_len = GNUNET_IDENTITY_private_key_get_length (identity); | ||
1569 | tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket); | ||
1541 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1570 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1542 | op->env = GNUNET_MQ_msg (ctm, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET); | 1571 | op->env = GNUNET_MQ_msg_extra (ctm, |
1543 | ctm->identity = *identity; | 1572 | key_len + tkt_len, |
1573 | GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET); | ||
1574 | ctm->key_len = htonl (key_len); | ||
1575 | buf = (char*) &ctm[1]; | ||
1576 | GNUNET_IDENTITY_write_private_key_to_buffer (identity, buf, key_len); | ||
1577 | buf += key_len; | ||
1578 | ctm->tkt_len = htonl (tkt_len); | ||
1579 | GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len); | ||
1544 | ctm->id = htonl (op->r_id); | 1580 | ctm->id = htonl (op->r_id); |
1545 | ctm->ticket = *ticket; | ||
1546 | if (NULL != h->mq) | 1581 | if (NULL != h->mq) |
1547 | GNUNET_MQ_send_copy (h->mq, op->env); | 1582 | GNUNET_MQ_send_copy (h->mq, op->env); |
1548 | else | 1583 | else |
@@ -1551,23 +1586,6 @@ GNUNET_RECLAIM_ticket_consume ( | |||
1551 | } | 1586 | } |
1552 | 1587 | ||
1553 | 1588 | ||
1554 | /** | ||
1555 | * Lists all tickets that have been issued to remote | ||
1556 | * identites (relying parties) | ||
1557 | * | ||
1558 | * @param h the reclaim to use | ||
1559 | * @param identity the issuing identity | ||
1560 | * @param error_cb function to call on error (i.e. disconnect), | ||
1561 | * the handle is afterwards invalid | ||
1562 | * @param error_cb_cls closure for @a error_cb | ||
1563 | * @param proc function to call on each ticket; it | ||
1564 | * will be called repeatedly with a value (if available) | ||
1565 | * @param proc_cls closure for @a proc | ||
1566 | * @param finish_cb function to call on completion | ||
1567 | * the handle is afterwards invalid | ||
1568 | * @param finish_cb_cls closure for @a finish_cb | ||
1569 | * @return an iterator handle to use for iteration | ||
1570 | */ | ||
1571 | struct GNUNET_RECLAIM_TicketIterator * | 1589 | struct GNUNET_RECLAIM_TicketIterator * |
1572 | GNUNET_RECLAIM_ticket_iteration_start ( | 1590 | GNUNET_RECLAIM_ticket_iteration_start ( |
1573 | struct GNUNET_RECLAIM_Handle *h, | 1591 | struct GNUNET_RECLAIM_Handle *h, |
@@ -1583,6 +1601,7 @@ GNUNET_RECLAIM_ticket_iteration_start ( | |||
1583 | struct GNUNET_MQ_Envelope *env; | 1601 | struct GNUNET_MQ_Envelope *env; |
1584 | struct TicketIterationStartMessage *msg; | 1602 | struct TicketIterationStartMessage *msg; |
1585 | uint32_t rid; | 1603 | uint32_t rid; |
1604 | size_t key_len; | ||
1586 | 1605 | ||
1587 | rid = h->r_id_gen++; | 1606 | rid = h->r_id_gen++; |
1588 | it = GNUNET_new (struct GNUNET_RECLAIM_TicketIterator); | 1607 | it = GNUNET_new (struct GNUNET_RECLAIM_TicketIterator); |
@@ -1594,10 +1613,17 @@ GNUNET_RECLAIM_ticket_iteration_start ( | |||
1594 | it->tr_cb = proc; | 1613 | it->tr_cb = proc; |
1595 | it->cls = proc_cls; | 1614 | it->cls = proc_cls; |
1596 | it->r_id = rid; | 1615 | it->r_id = rid; |
1616 | |||
1617 | key_len = GNUNET_IDENTITY_private_key_get_length (identity); | ||
1597 | GNUNET_CONTAINER_DLL_insert_tail (h->ticket_it_head, h->ticket_it_tail, it); | 1618 | GNUNET_CONTAINER_DLL_insert_tail (h->ticket_it_head, h->ticket_it_tail, it); |
1598 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START); | 1619 | env = GNUNET_MQ_msg_extra (msg, |
1620 | key_len, | ||
1621 | GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START); | ||
1599 | msg->id = htonl (rid); | 1622 | msg->id = htonl (rid); |
1600 | msg->identity = *identity; | 1623 | msg->key_len = htonl (key_len); |
1624 | GNUNET_IDENTITY_write_private_key_to_buffer (identity, | ||
1625 | &msg[1], | ||
1626 | key_len); | ||
1601 | if (NULL == h->mq) | 1627 | if (NULL == h->mq) |
1602 | it->env = env; | 1628 | it->env = env; |
1603 | else | 1629 | else |
@@ -1674,6 +1700,10 @@ GNUNET_RECLAIM_ticket_revoke ( | |||
1674 | struct GNUNET_RECLAIM_Operation *op; | 1700 | struct GNUNET_RECLAIM_Operation *op; |
1675 | struct RevokeTicketMessage *msg; | 1701 | struct RevokeTicketMessage *msg; |
1676 | uint32_t rid; | 1702 | uint32_t rid; |
1703 | size_t key_len; | ||
1704 | size_t tkt_len; | ||
1705 | ssize_t written; | ||
1706 | char *buf; | ||
1677 | 1707 | ||
1678 | rid = h->r_id_gen++; | 1708 | rid = h->r_id_gen++; |
1679 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); | 1709 | op = GNUNET_new (struct GNUNET_RECLAIM_Operation); |
@@ -1682,10 +1712,23 @@ GNUNET_RECLAIM_ticket_revoke ( | |||
1682 | op->cls = cb_cls; | 1712 | op->cls = cb_cls; |
1683 | op->r_id = rid; | 1713 | op->r_id = rid; |
1684 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); | 1714 | GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op); |
1685 | op->env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET); | 1715 | key_len = GNUNET_IDENTITY_private_key_get_length (identity); |
1716 | tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket); | ||
1717 | op->env = GNUNET_MQ_msg_extra (msg, | ||
1718 | key_len + tkt_len, | ||
1719 | GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET); | ||
1686 | msg->id = htonl (rid); | 1720 | msg->id = htonl (rid); |
1687 | msg->identity = *identity; | 1721 | msg->key_len = htonl (key_len); |
1688 | msg->ticket = *ticket; | 1722 | msg->tkt_len = htonl (tkt_len); |
1723 | buf = (char*) &msg[1]; | ||
1724 | written = GNUNET_IDENTITY_write_private_key_to_buffer (identity, | ||
1725 | buf, | ||
1726 | key_len); | ||
1727 | GNUNET_assert (0 <= written); | ||
1728 | buf += written; | ||
1729 | GNUNET_RECLAIM_write_ticket_to_buffer (ticket, | ||
1730 | buf, | ||
1731 | tkt_len); | ||
1689 | if (NULL != h->mq) | 1732 | if (NULL != h->mq) |
1690 | { | 1733 | { |
1691 | GNUNET_MQ_send (h->mq, op->env); | 1734 | GNUNET_MQ_send (h->mq, op->env); |
@@ -1694,5 +1737,78 @@ GNUNET_RECLAIM_ticket_revoke ( | |||
1694 | return op; | 1737 | return op; |
1695 | } | 1738 | } |
1696 | 1739 | ||
1740 | size_t | ||
1741 | GNUNET_RECLAIM_ticket_serialize_get_size (const struct | ||
1742 | GNUNET_RECLAIM_Ticket *tkt) | ||
1743 | { | ||
1744 | size_t size = sizeof (tkt->rnd); | ||
1745 | size += GNUNET_IDENTITY_public_key_get_length (&tkt->identity); | ||
1746 | size += GNUNET_IDENTITY_public_key_get_length (&tkt->audience); | ||
1747 | return size; | ||
1748 | } | ||
1749 | |||
1750 | enum GNUNET_GenericReturnValue | ||
1751 | GNUNET_RECLAIM_read_ticket_from_buffer (const void *buffer, | ||
1752 | size_t len, | ||
1753 | struct GNUNET_RECLAIM_Ticket *tkt, | ||
1754 | size_t *tb_read) | ||
1755 | { | ||
1756 | const char *tmp = buffer; | ||
1757 | size_t read = 0; | ||
1758 | size_t left = len; | ||
1759 | if (GNUNET_SYSERR == | ||
1760 | GNUNET_IDENTITY_read_public_key_from_buffer (tmp, | ||
1761 | left, | ||
1762 | &tkt->identity, | ||
1763 | &read)) | ||
1764 | return GNUNET_SYSERR; | ||
1765 | left -= read; | ||
1766 | tmp += read; | ||
1767 | if (GNUNET_SYSERR == | ||
1768 | GNUNET_IDENTITY_read_public_key_from_buffer (tmp, | ||
1769 | left, | ||
1770 | &tkt->audience, | ||
1771 | &read)) | ||
1772 | return GNUNET_SYSERR; | ||
1773 | left -= read; | ||
1774 | tmp += read; | ||
1775 | if (left < sizeof (tkt->rnd)) | ||
1776 | return GNUNET_SYSERR; | ||
1777 | memcpy (&tkt->rnd, tmp, sizeof (tkt->rnd)); | ||
1778 | *tb_read = tmp - (char*) buffer + sizeof (tkt->rnd); | ||
1779 | return GNUNET_OK; | ||
1780 | } | ||
1781 | |||
1782 | |||
1783 | ssize_t | ||
1784 | GNUNET_RECLAIM_write_ticket_to_buffer (const struct | ||
1785 | GNUNET_RECLAIM_Ticket *tkt, | ||
1786 | void *buffer, | ||
1787 | size_t len) | ||
1788 | { | ||
1789 | char *tmp = buffer; | ||
1790 | size_t left = len; | ||
1791 | ssize_t written = 0; | ||
1792 | written = GNUNET_IDENTITY_write_public_key_to_buffer (&tkt->identity, | ||
1793 | buffer, | ||
1794 | left); | ||
1795 | if (0 > written) | ||
1796 | return written; | ||
1797 | left -= written; | ||
1798 | tmp += written; | ||
1799 | written = GNUNET_IDENTITY_write_public_key_to_buffer (&tkt->audience, | ||
1800 | tmp, | ||
1801 | left); | ||
1802 | if (0 > written) | ||
1803 | return written; | ||
1804 | left -= written; | ||
1805 | tmp += written; | ||
1806 | if (left < sizeof (tkt->rnd)) | ||
1807 | return -1; | ||
1808 | memcpy (tmp, &tkt->rnd, sizeof (tkt->rnd)); | ||
1809 | return tmp - (char*) buffer + sizeof (tkt->rnd); | ||
1810 | } | ||
1811 | |||
1812 | |||
1697 | 1813 | ||
1698 | /* end of reclaim_api.c */ | 1814 | /* end of reclaim_api.c */ |
diff --git a/src/reclaim/test_did_helper.c b/src/reclaim/test_did_helper.c index 698edf180..446c199fc 100644 --- a/src/reclaim/test_did_helper.c +++ b/src/reclaim/test_did_helper.c | |||
@@ -78,8 +78,9 @@ test_GNUNET_DID_did_to_pkey () | |||
78 | DID_did_to_pkey ((char *) test_did, &pkey); | 78 | DID_did_to_pkey ((char *) test_did, &pkey); |
79 | 79 | ||
80 | GNUNET_assert (test_pkey.type = pkey.type); | 80 | GNUNET_assert (test_pkey.type = pkey.type); |
81 | GNUNET_assert (strcmp (pkey.eddsa_key.q_y, | 81 | GNUNET_assert (memcmp (&pkey.eddsa_key, |
82 | test_pkey.eddsa_key.q_y) == 0); | 82 | &test_pkey.eddsa_key, |
83 | sizeof (test_pkey.eddsa_key)) == 0); | ||
83 | } | 84 | } |
84 | 85 | ||
85 | // void | 86 | // void |
diff --git a/src/reclaim/test_reclaim.conf b/src/reclaim/test_reclaim.conf index 2dc53fe81..faa195ae1 100644 --- a/src/reclaim/test_reclaim.conf +++ b/src/reclaim/test_reclaim.conf | |||
@@ -13,9 +13,13 @@ PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=$GNUNET_TMP/r | |||
13 | [transport] | 13 | [transport] |
14 | PLUGINS = | 14 | PLUGINS = |
15 | 15 | ||
16 | [zonemaster] | ||
17 | START_ON_DEMAND = YES | ||
18 | IMMEDIATE_START = YES | ||
19 | |||
16 | [reclaim] | 20 | [reclaim] |
17 | START_ON_DEMAND = YES | 21 | START_ON_DEMAND = YES |
18 | TICKET_REFRESH_INTERVAL = 30 s | 22 | TICKET_REFRESH_INTERVAL = 1 h |
19 | #PREFIX = valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --log-file=$GNUNET_TMP/idplog | 23 | #PREFIX = valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --log-file=$GNUNET_TMP/idplog |
20 | 24 | ||
21 | [gns] | 25 | [gns] |
diff --git a/src/reclaim/test_reclaim_attribute.sh b/src/reclaim/test_reclaim_attribute.sh index 744c898ed..17f7863d4 100755 --- a/src/reclaim/test_reclaim_attribute.sh +++ b/src/reclaim/test_reclaim_attribute.sh | |||
@@ -29,7 +29,7 @@ gnunet-identity -C testego -c test_reclaim.conf | |||
29 | gnunet-identity -C rpego -c test_reclaim.conf | 29 | gnunet-identity -C rpego -c test_reclaim.conf |
30 | TEST_KEY=$(gnunet-identity -d -e testego -q -c test_reclaim.conf) | 30 | TEST_KEY=$(gnunet-identity -d -e testego -q -c test_reclaim.conf) |
31 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf | 31 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf |
32 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf > /dev/null 2>&1 | 32 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf |
33 | if test $? != 0 | 33 | if test $? != 0 |
34 | then | 34 | then |
35 | echo "Failed." | 35 | echo "Failed." |
diff --git a/src/reclaim/test_reclaim_consume.sh b/src/reclaim/test_reclaim_consume.sh index c012862c3..8a88136c6 100755 --- a/src/reclaim/test_reclaim_consume.sh +++ b/src/reclaim/test_reclaim_consume.sh | |||
@@ -25,6 +25,7 @@ which timeout >/dev/null 2>&1 && DO_TIMEOUT="timeout 30" | |||
25 | TEST_ATTR="test" | 25 | TEST_ATTR="test" |
26 | gnunet-arm -s -c test_reclaim.conf | 26 | gnunet-arm -s -c test_reclaim.conf |
27 | #gnunet-arm -i rest -c test_reclaim.conf | 27 | #gnunet-arm -i rest -c test_reclaim.conf |
28 | gnunet-arm -I | ||
28 | gnunet-identity -C testego -c test_reclaim.conf | 29 | gnunet-identity -C testego -c test_reclaim.conf |
29 | gnunet-identity -C rpego -c test_reclaim.conf | 30 | gnunet-identity -C rpego -c test_reclaim.conf |
30 | SUBJECT_KEY=$(gnunet-identity -d -e rpego -q -c test_reclaim.conf) | 31 | SUBJECT_KEY=$(gnunet-identity -d -e rpego -q -c test_reclaim.conf) |
@@ -32,7 +33,10 @@ TEST_KEY=$(gnunet-identity -d -e testego -q -c test_reclaim.conf) | |||
32 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf | 33 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf |
33 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf | 34 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf |
34 | TICKET=$(gnunet-reclaim -e testego -i "email,name" -r $SUBJECT_KEY -c test_reclaim.conf | awk '{print $1}') | 35 | TICKET=$(gnunet-reclaim -e testego -i "email,name" -r $SUBJECT_KEY -c test_reclaim.conf | awk '{print $1}') |
35 | gnunet-reclaim -e rpego -C $TICKET -c test_reclaim.conf #>/dev/null 2>&1 | 36 | gnunet-namestore -z testego -D -c test_reclaim.conf |
37 | gnunet-identity -d -c test_reclaim.conf | ||
38 | sleep 1 | ||
39 | gnunet-reclaim -e rpego -C $TICKET -c test_reclaim.conf | ||
36 | 40 | ||
37 | RES=$? | 41 | RES=$? |
38 | gnunet-identity -D testego -c test_reclaim.conf | 42 | gnunet-identity -D testego -c test_reclaim.conf |
diff --git a/src/reclaim/test_reclaim_issue.sh b/src/reclaim/test_reclaim_issue.sh index cfddc9407..63140e54c 100755 --- a/src/reclaim/test_reclaim_issue.sh +++ b/src/reclaim/test_reclaim_issue.sh | |||
@@ -29,8 +29,8 @@ gnunet-identity -C testego -c test_reclaim.conf | |||
29 | gnunet-identity -C rpego -c test_reclaim.conf | 29 | gnunet-identity -C rpego -c test_reclaim.conf |
30 | SUBJECT_KEY=$(gnunet-identity -d -e rpego -q -c test_reclaim.conf) | 30 | SUBJECT_KEY=$(gnunet-identity -d -e rpego -q -c test_reclaim.conf) |
31 | TEST_KEY=$(gnunet-identity -d -e testego -q -c test_reclaim.conf) | 31 | TEST_KEY=$(gnunet-identity -d -e testego -q -c test_reclaim.conf) |
32 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf > /dev/null 2>&1 | 32 | gnunet-reclaim -e testego -a email -V john@doe.gnu -c test_reclaim.conf |
33 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf > /dev/null 2>&1 | 33 | gnunet-reclaim -e testego -a name -V John -c test_reclaim.conf |
34 | #gnunet-reclaim -e testego -D -c test_reclaim.conf | 34 | #gnunet-reclaim -e testego -D -c test_reclaim.conf |
35 | gnunet-reclaim -e testego -i "email,name" -r $SUBJECT_KEY -c test_reclaim.conf > /dev/null 2>&1 | 35 | gnunet-reclaim -e testego -i "email,name" -r $SUBJECT_KEY -c test_reclaim.conf > /dev/null 2>&1 |
36 | if test $? != 0 | 36 | if test $? != 0 |
diff --git a/src/revocation/gnunet-revocation-tvg.c b/src/revocation/gnunet-revocation-tvg.c index 682f41530..a126709ce 100644 --- a/src/revocation/gnunet-revocation-tvg.c +++ b/src/revocation/gnunet-revocation-tvg.c | |||
@@ -115,14 +115,14 @@ run (void *cls, | |||
115 | GNUNET_IDENTITY_key_get_public (&id_priv, | 115 | GNUNET_IDENTITY_key_get_public (&id_priv, |
116 | &id_pub); | 116 | &id_pub); |
117 | GNUNET_STRINGS_data_to_string (&id_pub, | 117 | GNUNET_STRINGS_data_to_string (&id_pub, |
118 | GNUNET_IDENTITY_key_get_length (&id_pub), | 118 | GNUNET_IDENTITY_public_key_get_length (&id_pub), |
119 | ztld, | 119 | ztld, |
120 | sizeof (ztld)); | 120 | sizeof (ztld)); |
121 | fprintf (stdout, "Zone private key (d, big-endian scalar):\n"); | 121 | fprintf (stdout, "Zone private key (d, big-endian scalar):\n"); |
122 | print_bytes_ (&id_priv.ecdsa_key, sizeof(id_priv.ecdsa_key), 8, 1); | 122 | print_bytes_ (&id_priv.ecdsa_key, sizeof(id_priv.ecdsa_key), 8, 1); |
123 | fprintf (stdout, "\n"); | 123 | fprintf (stdout, "\n"); |
124 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); | 124 | fprintf (stdout, "Zone identifier (ztype|zkey):\n"); |
125 | key_len = GNUNET_IDENTITY_key_get_length (&id_pub); | 125 | key_len = GNUNET_IDENTITY_public_key_get_length (&id_pub); |
126 | GNUNET_assert (0 < key_len); | 126 | GNUNET_assert (0 < key_len); |
127 | print_bytes (&id_pub, key_len, 8); | 127 | print_bytes (&id_pub, key_len, 8); |
128 | fprintf (stdout, "\n"); | 128 | fprintf (stdout, "\n"); |
diff --git a/src/revocation/gnunet-revocation.c b/src/revocation/gnunet-revocation.c index a7f96385c..853ca0f71 100644 --- a/src/revocation/gnunet-revocation.c +++ b/src/revocation/gnunet-revocation.c | |||
@@ -343,7 +343,7 @@ ego_callback (void *cls, struct GNUNET_IDENTITY_Ego *ego) | |||
343 | GNUNET_DISK_fn_read (filename, proof_of_work, | 343 | GNUNET_DISK_fn_read (filename, proof_of_work, |
344 | GNUNET_REVOCATION_MAX_PROOF_SIZE)))) | 344 | GNUNET_REVOCATION_MAX_PROOF_SIZE)))) |
345 | { | 345 | { |
346 | ssize_t ksize = GNUNET_IDENTITY_key_get_length (&key); | 346 | ssize_t ksize = GNUNET_IDENTITY_public_key_get_length (&key); |
347 | if (0 > ksize) | 347 | if (0 > ksize) |
348 | { | 348 | { |
349 | fprintf (stderr, | 349 | fprintf (stderr, |
diff --git a/src/revocation/gnunet-service-revocation.c b/src/revocation/gnunet-service-revocation.c index 4494ade83..fe74201f3 100644 --- a/src/revocation/gnunet-service-revocation.c +++ b/src/revocation/gnunet-service-revocation.c | |||
@@ -316,7 +316,7 @@ publicize_rm (const struct RevokeMessage *rm) | |||
316 | const struct GNUNET_IDENTITY_PublicKey *pk | 316 | const struct GNUNET_IDENTITY_PublicKey *pk |
317 | = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; | 317 | = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; |
318 | 318 | ||
319 | pklen = GNUNET_IDENTITY_key_get_length (pk); | 319 | pklen = GNUNET_IDENTITY_public_key_get_length (pk); |
320 | if (0 > pklen) | 320 | if (0 > pklen) |
321 | { | 321 | { |
322 | GNUNET_break_op (0); | 322 | GNUNET_break_op (0); |
@@ -950,7 +950,7 @@ run (void *cls, | |||
950 | GNUNET_REVOCATION_PowP *) &rm[1]; | 950 | GNUNET_REVOCATION_PowP *) &rm[1]; |
951 | ssize_t ksize; | 951 | ssize_t ksize; |
952 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; | 952 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; |
953 | ksize = GNUNET_IDENTITY_key_get_length (pk); | 953 | ksize = GNUNET_IDENTITY_public_key_get_length (pk); |
954 | if (0 > ksize) | 954 | if (0 > ksize) |
955 | { | 955 | { |
956 | GNUNET_break_op (0); | 956 | GNUNET_break_op (0); |
diff --git a/src/revocation/plugin_block_revocation.c b/src/revocation/plugin_block_revocation.c index 12ec555e4..0c81440eb 100644 --- a/src/revocation/plugin_block_revocation.c +++ b/src/revocation/plugin_block_revocation.c | |||
@@ -56,10 +56,10 @@ struct InternalContext | |||
56 | */ | 56 | */ |
57 | static enum GNUNET_GenericReturnValue | 57 | static enum GNUNET_GenericReturnValue |
58 | block_plugin_revocation_check_query (void *cls, | 58 | block_plugin_revocation_check_query (void *cls, |
59 | enum GNUNET_BLOCK_Type type, | 59 | enum GNUNET_BLOCK_Type type, |
60 | const struct GNUNET_HashCode *query, | 60 | const struct GNUNET_HashCode *query, |
61 | const void *xquery, | 61 | const void *xquery, |
62 | size_t xquery_size) | 62 | size_t xquery_size) |
63 | { | 63 | { |
64 | (void) cls; | 64 | (void) cls; |
65 | (void) query; | 65 | (void) query; |
@@ -86,16 +86,16 @@ block_plugin_revocation_check_query (void *cls, | |||
86 | */ | 86 | */ |
87 | static enum GNUNET_GenericReturnValue | 87 | static enum GNUNET_GenericReturnValue |
88 | block_plugin_revocation_check_block (void *cls, | 88 | block_plugin_revocation_check_block (void *cls, |
89 | enum GNUNET_BLOCK_Type type, | 89 | enum GNUNET_BLOCK_Type type, |
90 | const void *block, | 90 | const void *block, |
91 | size_t block_size) | 91 | size_t block_size) |
92 | { | 92 | { |
93 | struct InternalContext *ic = cls; | 93 | struct InternalContext *ic = cls; |
94 | const struct RevokeMessage *rm = block; | 94 | const struct RevokeMessage *rm = block; |
95 | const struct GNUNET_REVOCATION_PowP *pow | 95 | const struct GNUNET_REVOCATION_PowP *pow |
96 | = (const struct GNUNET_REVOCATION_PowP *) &rm[1]; | 96 | = (const struct GNUNET_REVOCATION_PowP *) &rm[1]; |
97 | struct GNUNET_IDENTITY_PublicKey pk; | 97 | struct GNUNET_IDENTITY_PublicKey pk; |
98 | ssize_t pklen; | 98 | size_t pklen; |
99 | size_t left; | 99 | size_t left; |
100 | 100 | ||
101 | if (GNUNET_BLOCK_TYPE_REVOCATION != type) | 101 | if (GNUNET_BLOCK_TYPE_REVOCATION != type) |
@@ -114,9 +114,10 @@ block_plugin_revocation_check_block (void *cls, | |||
114 | return GNUNET_NO; | 114 | return GNUNET_NO; |
115 | } | 115 | } |
116 | left = block_size - sizeof (*rm) - sizeof (*pow); | 116 | left = block_size - sizeof (*rm) - sizeof (*pow); |
117 | pklen = GNUNET_IDENTITY_read_key_from_buffer (&pk, | 117 | GNUNET_IDENTITY_read_public_key_from_buffer (&pow[1], |
118 | &pow[1], | 118 | left, |
119 | left); | 119 | &pk, |
120 | &pklen); | ||
120 | if (0 > pklen) | 121 | if (0 > pklen) |
121 | { | 122 | { |
122 | GNUNET_break_op (0); | 123 | GNUNET_break_op (0); |
@@ -152,14 +153,14 @@ block_plugin_revocation_check_block (void *cls, | |||
152 | */ | 153 | */ |
153 | static enum GNUNET_BLOCK_ReplyEvaluationResult | 154 | static enum GNUNET_BLOCK_ReplyEvaluationResult |
154 | block_plugin_revocation_check_reply ( | 155 | block_plugin_revocation_check_reply ( |
155 | void *cls, | 156 | void *cls, |
156 | enum GNUNET_BLOCK_Type type, | 157 | enum GNUNET_BLOCK_Type type, |
157 | struct GNUNET_BLOCK_Group *group, | 158 | struct GNUNET_BLOCK_Group *group, |
158 | const struct GNUNET_HashCode *query, | 159 | const struct GNUNET_HashCode *query, |
159 | const void *xquery, | 160 | const void *xquery, |
160 | size_t xquery_size, | 161 | size_t xquery_size, |
161 | const void *reply_block, | 162 | const void *reply_block, |
162 | size_t reply_block_size) | 163 | size_t reply_block_size) |
163 | { | 164 | { |
164 | (void) cls; | 165 | (void) cls; |
165 | (void) group; | 166 | (void) group; |
@@ -199,7 +200,7 @@ block_plugin_revocation_get_key (void *cls, | |||
199 | const struct GNUNET_REVOCATION_PowP *pow | 200 | const struct GNUNET_REVOCATION_PowP *pow |
200 | = (const struct GNUNET_REVOCATION_PowP *) &rm[1]; | 201 | = (const struct GNUNET_REVOCATION_PowP *) &rm[1]; |
201 | struct GNUNET_IDENTITY_PublicKey pk; | 202 | struct GNUNET_IDENTITY_PublicKey pk; |
202 | ssize_t pklen; | 203 | size_t pklen; |
203 | size_t left; | 204 | size_t left; |
204 | 205 | ||
205 | if (GNUNET_BLOCK_TYPE_REVOCATION != type) | 206 | if (GNUNET_BLOCK_TYPE_REVOCATION != type) |
@@ -218,9 +219,10 @@ block_plugin_revocation_get_key (void *cls, | |||
218 | return GNUNET_NO; | 219 | return GNUNET_NO; |
219 | } | 220 | } |
220 | left = block_size - sizeof (*rm) - sizeof (*pow); | 221 | left = block_size - sizeof (*rm) - sizeof (*pow); |
221 | pklen = GNUNET_IDENTITY_read_key_from_buffer (&pk, | 222 | GNUNET_IDENTITY_read_public_key_from_buffer (&pow[1], |
222 | &pow[1], | 223 | left, |
223 | left); | 224 | &pk, |
225 | &pklen); | ||
224 | if (0 > pklen) | 226 | if (0 > pklen) |
225 | { | 227 | { |
226 | GNUNET_break_op (0); | 228 | GNUNET_break_op (0); |
@@ -242,7 +244,7 @@ void * | |||
242 | libgnunet_plugin_block_revocation_init (void *cls) | 244 | libgnunet_plugin_block_revocation_init (void *cls) |
243 | { | 245 | { |
244 | static const enum GNUNET_BLOCK_Type types[] = { | 246 | static const enum GNUNET_BLOCK_Type types[] = { |
245 | GNUNET_BLOCK_TYPE_REVOCATION, | 247 | GNUNET_BLOCK_TYPE_REVOCATION, |
246 | GNUNET_BLOCK_TYPE_ANY /* end of list */ | 248 | GNUNET_BLOCK_TYPE_ANY /* end of list */ |
247 | }; | 249 | }; |
248 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; | 250 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; |
diff --git a/src/revocation/revocation_api.c b/src/revocation/revocation_api.c index 78b3c083a..34b4eddd7 100644 --- a/src/revocation/revocation_api.c +++ b/src/revocation/revocation_api.c | |||
@@ -407,14 +407,14 @@ REV_create_signature_message (const struct GNUNET_REVOCATION_PowP *pow) | |||
407 | size_t ksize; | 407 | size_t ksize; |
408 | 408 | ||
409 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; | 409 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; |
410 | ksize = GNUNET_IDENTITY_key_get_length (pk); | 410 | ksize = GNUNET_IDENTITY_public_key_get_length (pk); |
411 | spurp = GNUNET_malloc (sizeof (*spurp) + ksize); | 411 | spurp = GNUNET_malloc (sizeof (*spurp) + ksize); |
412 | spurp->timestamp = pow->timestamp; | 412 | spurp->timestamp = pow->timestamp; |
413 | spurp->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_REVOCATION); | 413 | spurp->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_REVOCATION); |
414 | spurp->purpose.size = htonl (sizeof(*spurp) + ksize); | 414 | spurp->purpose.size = htonl (sizeof(*spurp) + ksize); |
415 | GNUNET_IDENTITY_write_key_to_buffer (pk, | 415 | GNUNET_IDENTITY_write_public_key_to_buffer (pk, |
416 | (char*) &spurp[1], | 416 | (char*) &spurp[1], |
417 | ksize); | 417 | ksize); |
418 | return spurp; | 418 | return spurp; |
419 | } | 419 | } |
420 | 420 | ||
@@ -426,14 +426,15 @@ check_signature_identity (const struct GNUNET_REVOCATION_PowP *pow, | |||
426 | unsigned char *sig; | 426 | unsigned char *sig; |
427 | size_t ksize; | 427 | size_t ksize; |
428 | 428 | ||
429 | ksize = GNUNET_IDENTITY_key_get_length (key); | 429 | ksize = GNUNET_IDENTITY_public_key_get_length (key); |
430 | spurp = REV_create_signature_message (pow); | 430 | spurp = REV_create_signature_message (pow); |
431 | sig = ((unsigned char*) &pow[1] + ksize); | 431 | sig = ((unsigned char*) &pow[1] + ksize); |
432 | if (GNUNET_OK != | 432 | if (GNUNET_OK != |
433 | GNUNET_IDENTITY_signature_verify_raw_ (GNUNET_SIGNATURE_PURPOSE_REVOCATION, | 433 | GNUNET_IDENTITY_signature_verify_raw_ ( |
434 | &spurp->purpose, | 434 | GNUNET_SIGNATURE_PURPOSE_REVOCATION, |
435 | sig, | 435 | &spurp->purpose, |
436 | key)) | 436 | sig, |
437 | key)) | ||
437 | { | 438 | { |
438 | return GNUNET_SYSERR; | 439 | return GNUNET_SYSERR; |
439 | } | 440 | } |
@@ -503,7 +504,7 @@ GNUNET_REVOCATION_check_pow (const struct GNUNET_REVOCATION_PowP *pow, | |||
503 | GNUNET_memcpy (&buf[sizeof(uint64_t)], | 504 | GNUNET_memcpy (&buf[sizeof(uint64_t)], |
504 | &pow->timestamp, | 505 | &pow->timestamp, |
505 | sizeof (uint64_t)); | 506 | sizeof (uint64_t)); |
506 | pklen = GNUNET_IDENTITY_key_get_length (pk); | 507 | pklen = GNUNET_IDENTITY_public_key_get_length (pk); |
507 | if (0 > pklen) | 508 | if (0 > pklen) |
508 | { | 509 | { |
509 | GNUNET_break (0); | 510 | GNUNET_break (0); |
@@ -578,7 +579,7 @@ sign_pow_identity (const struct GNUNET_IDENTITY_PrivateKey *key, | |||
578 | ts = GNUNET_TIME_absolute_subtract (ts, | 579 | ts = GNUNET_TIME_absolute_subtract (ts, |
579 | GNUNET_TIME_UNIT_WEEKS); | 580 | GNUNET_TIME_UNIT_WEEKS); |
580 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; | 581 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; |
581 | ksize = GNUNET_IDENTITY_key_get_length (pk); | 582 | ksize = GNUNET_IDENTITY_public_key_get_length (pk); |
582 | pow->timestamp = GNUNET_TIME_absolute_hton (ts); | 583 | pow->timestamp = GNUNET_TIME_absolute_hton (ts); |
583 | rp = REV_create_signature_message (pow); | 584 | rp = REV_create_signature_message (pow); |
584 | sig = ((char*) &pow[1]) + ksize; | 585 | sig = ((char*) &pow[1]) + ksize; |
@@ -691,7 +692,7 @@ GNUNET_REVOCATION_pow_round (struct GNUNET_REVOCATION_PowCalculationHandle *pc) | |||
691 | GNUNET_memcpy (&buf[sizeof(uint64_t)], | 692 | GNUNET_memcpy (&buf[sizeof(uint64_t)], |
692 | &pc->pow->timestamp, | 693 | &pc->pow->timestamp, |
693 | sizeof (uint64_t)); | 694 | sizeof (uint64_t)); |
694 | ksize = GNUNET_IDENTITY_key_get_length (pk); | 695 | ksize = GNUNET_IDENTITY_public_key_get_length (pk); |
695 | GNUNET_assert (0 < ksize); | 696 | GNUNET_assert (0 < ksize); |
696 | GNUNET_memcpy (&buf[sizeof(uint64_t) * 2], | 697 | GNUNET_memcpy (&buf[sizeof(uint64_t) * 2], |
697 | pk, | 698 | pk, |
@@ -749,7 +750,7 @@ GNUNET_REVOCATION_proof_get_size (const struct GNUNET_REVOCATION_PowP *pow) | |||
749 | 750 | ||
750 | size = sizeof (struct GNUNET_REVOCATION_PowP); | 751 | size = sizeof (struct GNUNET_REVOCATION_PowP); |
751 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; | 752 | pk = (const struct GNUNET_IDENTITY_PublicKey *) &pow[1]; |
752 | ksize = GNUNET_IDENTITY_key_get_length (pk); | 753 | ksize = GNUNET_IDENTITY_public_key_get_length (pk); |
753 | size += ksize; | 754 | size += ksize; |
754 | size += GNUNET_IDENTITY_signature_get_raw_length_by_type (pk->type); | 755 | size += GNUNET_IDENTITY_signature_get_raw_length_by_type (pk->type); |
755 | return size; | 756 | return size; |