diff options
author | Martin Schanzenbach <schanzen@gnunet.org> | 2022-10-29 18:06:26 +0900 |
---|---|---|
committer | Martin Schanzenbach <schanzen@gnunet.org> | 2022-10-29 18:06:26 +0900 |
commit | 0f2da4636e108c70697c589d9e38781f2bafefba (patch) | |
tree | 0e831befd71d4323596cdae55e8431df7720c531 | |
parent | 4e2259f14be320c8e2fe2a672a473e09677269c4 (diff) | |
download | gnunet-0f2da4636e108c70697c589d9e38781f2bafefba.tar.gz gnunet-0f2da4636e108c70697c589d9e38781f2bafefba.zip |
IDENTITY
This commit is a major rework of the unclean GNUNET_IDENTITY_*Key
structures and its use in serialized objects (e.g. RPC messages).
The structures are now no longer to be used directly but instead through
their serialization helper functions whenever needed.
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; |