diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/transport/gnunet-communicator-udp.c | 372 | ||||
-rw-r--r-- | src/transport/test_communicator_basic.c | 174 |
2 files changed, 363 insertions, 183 deletions
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c index 5ca5a4e86..579f744e5 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/transport/gnunet-communicator-udp.c | |||
@@ -75,6 +75,9 @@ | |||
75 | */ | 75 | */ |
76 | #define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS | 76 | #define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS |
77 | 77 | ||
78 | #define WORKING_QUEUE_INTERVALL \ | ||
79 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1) | ||
80 | |||
78 | /** | 81 | /** |
79 | * AES key size. | 82 | * AES key size. |
80 | */ | 83 | */ |
@@ -90,6 +93,8 @@ | |||
90 | */ | 93 | */ |
91 | #define GCM_TAG_SIZE (128 / 8) | 94 | #define GCM_TAG_SIZE (128 / 8) |
92 | 95 | ||
96 | #define GENERATE_AT_ONCE 20 | ||
97 | |||
93 | /** | 98 | /** |
94 | * If we fall below this number of available KCNs, | 99 | * If we fall below this number of available KCNs, |
95 | * we generate additional ACKs until we reach | 100 | * we generate additional ACKs until we reach |
@@ -500,6 +505,12 @@ struct SenderAddress | |||
500 | unsigned int num_secrets; | 505 | unsigned int num_secrets; |
501 | 506 | ||
502 | /** | 507 | /** |
508 | * Number of BOX keys from ACKs we have currently | ||
509 | * available for this sender. | ||
510 | */ | ||
511 | unsigned int acks_available; | ||
512 | |||
513 | /** | ||
503 | * Which network type does this queue use? | 514 | * Which network type does this queue use? |
504 | */ | 515 | */ |
505 | enum GNUNET_NetworkType nt; | 516 | enum GNUNET_NetworkType nt; |
@@ -796,26 +807,15 @@ bi_destroy (struct BroadcastInterface *bi) | |||
796 | static void | 807 | static void |
797 | receiver_destroy (struct ReceiverAddress *receiver) | 808 | receiver_destroy (struct ReceiverAddress *receiver) |
798 | { | 809 | { |
799 | struct GNUNET_MQ_Handle *mq; | ||
800 | 810 | ||
801 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 811 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
802 | "Disconnecting receiver for peer `%s'\n", | 812 | "Disconnecting receiver for peer `%s'\n", |
803 | GNUNET_i2s (&receiver->target)); | 813 | GNUNET_i2s (&receiver->target)); |
804 | if (NULL != (mq = receiver->kx_mq)) | ||
805 | { | ||
806 | receiver->kx_mq = NULL; | ||
807 | GNUNET_MQ_destroy (mq); | ||
808 | } | ||
809 | if (NULL != receiver->kx_qh) | 814 | if (NULL != receiver->kx_qh) |
810 | { | 815 | { |
811 | GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh); | 816 | GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh); |
812 | receiver->kx_qh = NULL; | 817 | receiver->kx_qh = NULL; |
813 | } | 818 | } |
814 | if (NULL != (mq = receiver->d_mq)) | ||
815 | { | ||
816 | receiver->d_mq = NULL; | ||
817 | GNUNET_MQ_destroy (mq); | ||
818 | } | ||
819 | if (NULL != receiver->d_qh) | 819 | if (NULL != receiver->d_qh) |
820 | { | 820 | { |
821 | GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh); | 821 | GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh); |
@@ -847,6 +847,7 @@ kce_destroy (struct KeyCacheEntry *kce) | |||
847 | struct SharedSecret *ss = kce->ss; | 847 | struct SharedSecret *ss = kce->ss; |
848 | 848 | ||
849 | ss->active_kce_count--; | 849 | ss->active_kce_count--; |
850 | ss->sender->acks_available--; | ||
850 | GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce); | 851 | GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce); |
851 | GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache, | 852 | GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache, |
852 | &kce->kid, | 853 | &kce->kid, |
@@ -902,6 +903,7 @@ kce_generate (struct SharedSecret *ss, uint32_t seq) | |||
902 | get_kid (&ss->master, seq, &kce->kid); | 903 | get_kid (&ss->master, seq, &kce->kid); |
903 | GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce); | 904 | GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce); |
904 | ss->active_kce_count++; | 905 | ss->active_kce_count++; |
906 | ss->sender->acks_available++; | ||
905 | (void) GNUNET_CONTAINER_multishortmap_put ( | 907 | (void) GNUNET_CONTAINER_multishortmap_put ( |
906 | key_cache, | 908 | key_cache, |
907 | &kce->kid, | 909 | &kce->kid, |
@@ -930,12 +932,19 @@ secret_destroy (struct SharedSecret *ss) | |||
930 | { | 932 | { |
931 | GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss); | 933 | GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss); |
932 | sender->num_secrets--; | 934 | sender->num_secrets--; |
935 | sender->acks_available -= ss->active_kce_count; | ||
936 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
937 | "%u acks available after secrect destroy.\n", | ||
938 | sender->acks_available); | ||
933 | } | 939 | } |
934 | if (NULL != (receiver = ss->receiver)) | 940 | if (NULL != (receiver = ss->receiver)) |
935 | { | 941 | { |
936 | GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); | 942 | GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); |
937 | receiver->num_secrets--; | 943 | receiver->num_secrets--; |
938 | receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used); | 944 | receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used); |
945 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
946 | "%u acks available after secrect destroy.\n", | ||
947 | receiver->acks_available); | ||
939 | } | 948 | } |
940 | while (NULL != (kce = ss->kce_head)) | 949 | while (NULL != (kce = ss->kce_head)) |
941 | kce_destroy (kce); | 950 | kce_destroy (kce); |
@@ -1250,6 +1259,10 @@ setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, | |||
1250 | &receiver->target.public_key, | 1259 | &receiver->target.public_key, |
1251 | &ss->master); | 1260 | &ss->master); |
1252 | calculate_cmac (ss); | 1261 | calculate_cmac (ss); |
1262 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1263 | "Created cmac %s for secret %p.\n", | ||
1264 | GNUNET_h2s (&ss->cmac), | ||
1265 | ss); | ||
1253 | ss->receiver = receiver; | 1266 | ss->receiver = receiver; |
1254 | GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss); | 1267 | GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss); |
1255 | receiver->num_secrets++; | 1268 | receiver->num_secrets++; |
@@ -1298,12 +1311,11 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value) | |||
1298 | 1311 | ||
1299 | allowed = ntohl (ack->sequence_max); | 1312 | allowed = ntohl (ack->sequence_max); |
1300 | 1313 | ||
1314 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1315 | "%u > %u (%u)\n", allowed, ss->sequence_allowed, | ||
1316 | receiver->acks_available); | ||
1301 | if (allowed > ss->sequence_allowed) | 1317 | if (allowed > ss->sequence_allowed) |
1302 | { | 1318 | { |
1303 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1304 | "%u > %u (%u)\n", allowed, ss->sequence_allowed, | ||
1305 | receiver->acks_available); | ||
1306 | |||
1307 | receiver->acks_available += (allowed - ss->sequence_allowed); | 1319 | receiver->acks_available += (allowed - ss->sequence_allowed); |
1308 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1320 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1309 | "Tell transport we have more acks!\n"); | 1321 | "Tell transport we have more acks!\n"); |
@@ -1312,6 +1324,9 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value) | |||
1312 | (allowed | 1324 | (allowed |
1313 | - ss->sequence_allowed), | 1325 | - ss->sequence_allowed), |
1314 | 1); | 1326 | 1); |
1327 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1328 | "%u acks made available.\n", | ||
1329 | receiver->acks_available); | ||
1315 | ss->sequence_allowed = allowed; | 1330 | ss->sequence_allowed = allowed; |
1316 | /* move ss to head to avoid discarding it anytime soon! */ | 1331 | /* move ss to head to avoid discarding it anytime soon! */ |
1317 | GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); | 1332 | GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); |
@@ -1370,6 +1385,19 @@ try_handle_plaintext (struct SenderAddress *sender, | |||
1370 | } | 1385 | } |
1371 | } | 1386 | } |
1372 | 1387 | ||
1388 | static void | ||
1389 | kce_generate_cb (void *cls) | ||
1390 | { | ||
1391 | struct SharedSecret *ss = cls; | ||
1392 | |||
1393 | for (int i = 0; i < GENERATE_AT_ONCE; i++) | ||
1394 | kce_generate (ss, ++ss->sequence_allowed); | ||
1395 | |||
1396 | /*GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL, | ||
1397 | kce_generate_cb, | ||
1398 | ss);*/ | ||
1399 | |||
1400 | } | ||
1373 | 1401 | ||
1374 | /** | 1402 | /** |
1375 | * We established a shared secret with a sender. We should try to send | 1403 | * We established a shared secret with a sender. We should try to send |
@@ -1392,7 +1420,12 @@ consider_ss_ack (struct SharedSecret *ss) | |||
1392 | (MAX_SQN_DELTA < | 1420 | (MAX_SQN_DELTA < |
1393 | ss->kce_head->sequence_number - ss->kce_tail->sequence_number)) | 1421 | ss->kce_head->sequence_number - ss->kce_tail->sequence_number)) |
1394 | kce_destroy (ss->kce_tail); | 1422 | kce_destroy (ss->kce_tail); |
1395 | if (ss->active_kce_count < KCN_THRESHOLD) | 1423 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1424 | "%u active count and %u acks available\n", | ||
1425 | ss->active_kce_count, | ||
1426 | ss->sender->acks_available); | ||
1427 | if ((ss->active_kce_count < KCN_THRESHOLD) && (ss->sender->acks_available < | ||
1428 | KCN_TARGET) ) | ||
1396 | { | 1429 | { |
1397 | struct UDPAck ack; | 1430 | struct UDPAck ack; |
1398 | 1431 | ||
@@ -1403,15 +1436,19 @@ consider_ss_ack (struct SharedSecret *ss) | |||
1403 | * we only generate a single KCE to prevent | 1436 | * we only generate a single KCE to prevent |
1404 | * unnecessary overhead. | 1437 | * unnecessary overhead. |
1405 | */ | 1438 | */ |
1406 | if (0 < ss->active_kce_count) { | 1439 | GNUNET_SCHEDULER_add_now (kce_generate_cb, ss); |
1440 | /*if (0 < ss->sequence_allowed) | ||
1441 | { | ||
1407 | while (ss->active_kce_count < KCN_TARGET) | 1442 | while (ss->active_kce_count < KCN_TARGET) |
1408 | kce_generate (ss, ++ss->sequence_allowed); | 1443 | kce_generate (ss, ++ss->sequence_allowed); |
1409 | } else { | ||
1410 | kce_generate (ss, ++ss->sequence_allowed); | ||
1411 | } | 1444 | } |
1445 | else {*/ | ||
1446 | /*kce_generate (ss, ++ss->sequence_allowed); | ||
1447 | kce_generate (ss, ++ss->sequence_allowed);*/ | ||
1448 | // } | ||
1412 | ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK); | 1449 | ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK); |
1413 | ack.header.size = htons (sizeof(ack)); | 1450 | ack.header.size = htons (sizeof(ack)); |
1414 | ack.sequence_max = htonl (ss->sequence_allowed); | 1451 | ack.sequence_max = htonl (ss->sequence_allowed + GENERATE_AT_ONCE); |
1415 | ack.cmac = ss->cmac; | 1452 | ack.cmac = ss->cmac; |
1416 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1453 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1417 | "Notifying transport of UDPAck %s\n", | 1454 | "Notifying transport of UDPAck %s\n", |
@@ -1452,6 +1489,10 @@ decrypt_box (const struct UDPBox *box, | |||
1452 | 1, | 1489 | 1, |
1453 | GNUNET_NO); | 1490 | GNUNET_NO); |
1454 | kce_destroy (kce); | 1491 | kce_destroy (kce); |
1492 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1493 | "decrypting of UDPBox with kid %s and cmac %s failed\n", | ||
1494 | GNUNET_sh2s (&box->kid), | ||
1495 | GNUNET_h2s (&ss->cmac)); | ||
1455 | return; | 1496 | return; |
1456 | } | 1497 | } |
1457 | kce_destroy (kce); | 1498 | kce_destroy (kce); |
@@ -1459,6 +1500,9 @@ decrypt_box (const struct UDPBox *box, | |||
1459 | "# bytes decrypted with BOX", | 1500 | "# bytes decrypted with BOX", |
1460 | sizeof(out_buf), | 1501 | sizeof(out_buf), |
1461 | GNUNET_NO); | 1502 | GNUNET_NO); |
1503 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1504 | "decrypted UDPBox with kid %s\n", | ||
1505 | GNUNET_sh2s (&box->kid)); | ||
1462 | try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf)); | 1506 | try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf)); |
1463 | consider_ss_ack (ss); | 1507 | consider_ss_ack (ss); |
1464 | } | 1508 | } |
@@ -1517,7 +1561,7 @@ find_sender_by_address (void *cls, | |||
1517 | * might already have one, so a fresh one is only allocated | 1561 | * might already have one, so a fresh one is only allocated |
1518 | * if one does not yet exist for @a address. | 1562 | * if one does not yet exist for @a address. |
1519 | * | 1563 | * |
1520 | * @param target peer to generate address for | 1564 | * @param target peer to generate address for (can be NULL, if we already have one). |
1521 | * @param address target address | 1565 | * @param address target address |
1522 | * @param address_len number of bytes in @a address | 1566 | * @param address_len number of bytes in @a address |
1523 | * @return data structure to keep track of key material for | 1567 | * @return data structure to keep track of key material for |
@@ -1530,14 +1574,14 @@ setup_sender (const struct GNUNET_PeerIdentity *target, | |||
1530 | { | 1574 | { |
1531 | struct SenderAddress *sender; | 1575 | struct SenderAddress *sender; |
1532 | struct SearchContext sc = { .address = address, | 1576 | struct SearchContext sc = { .address = address, |
1533 | .address_len = address_len, | 1577 | .address_len = address_len, |
1534 | .sender = NULL }; | 1578 | .sender = NULL }; |
1535 | 1579 | ||
1536 | GNUNET_CONTAINER_multipeermap_get_multiple (senders, | 1580 | GNUNET_CONTAINER_multipeermap_get_multiple (senders, |
1537 | target, | 1581 | target, |
1538 | &find_sender_by_address, | 1582 | &find_sender_by_address, |
1539 | &sc); | 1583 | &sc); |
1540 | if (NULL != sc.sender) | 1584 | if ((NULL != sc.sender)||(NULL == target)) |
1541 | { | 1585 | { |
1542 | reschedule_sender_timeout (sc.sender); | 1586 | reschedule_sender_timeout (sc.sender); |
1543 | return sc.sender; | 1587 | return sc.sender; |
@@ -1547,10 +1591,10 @@ setup_sender (const struct GNUNET_PeerIdentity *target, | |||
1547 | sender->address = GNUNET_memdup (address, address_len); | 1591 | sender->address = GNUNET_memdup (address, address_len); |
1548 | sender->address_len = address_len; | 1592 | sender->address_len = address_len; |
1549 | (void) GNUNET_CONTAINER_multipeermap_put ( | 1593 | (void) GNUNET_CONTAINER_multipeermap_put ( |
1550 | senders, | 1594 | senders, |
1551 | &sender->target, | 1595 | &sender->target, |
1552 | sender, | 1596 | sender, |
1553 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 1597 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
1554 | GNUNET_STATISTICS_set (stats, | 1598 | GNUNET_STATISTICS_set (stats, |
1555 | "# senders active", | 1599 | "# senders active", |
1556 | GNUNET_CONTAINER_multipeermap_size (receivers), | 1600 | GNUNET_CONTAINER_multipeermap_size (receivers), |
@@ -1587,10 +1631,10 @@ verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, | |||
1587 | uhs.ephemeral = *ephemeral; | 1631 | uhs.ephemeral = *ephemeral; |
1588 | uhs.monotonic_time = uc->monotonic_time; | 1632 | uhs.monotonic_time = uc->monotonic_time; |
1589 | return GNUNET_CRYPTO_eddsa_verify ( | 1633 | return GNUNET_CRYPTO_eddsa_verify ( |
1590 | GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, | 1634 | GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, |
1591 | &uhs, | 1635 | &uhs, |
1592 | &uc->sender_sig, | 1636 | &uc->sender_sig, |
1593 | &uc->sender.public_key); | 1637 | &uc->sender.public_key); |
1594 | } | 1638 | } |
1595 | 1639 | ||
1596 | 1640 | ||
@@ -1610,22 +1654,22 @@ sockaddr_to_udpaddr_string (const struct sockaddr *address, | |||
1610 | 1654 | ||
1611 | switch (address->sa_family) | 1655 | switch (address->sa_family) |
1612 | { | 1656 | { |
1613 | case AF_INET: | 1657 | case AF_INET: |
1614 | GNUNET_asprintf (&ret, | 1658 | GNUNET_asprintf (&ret, |
1615 | "%s-%s", | 1659 | "%s-%s", |
1616 | COMMUNICATOR_ADDRESS_PREFIX, | 1660 | COMMUNICATOR_ADDRESS_PREFIX, |
1617 | GNUNET_a2s (address, address_len)); | 1661 | GNUNET_a2s (address, address_len)); |
1618 | break; | 1662 | break; |
1619 | 1663 | ||
1620 | case AF_INET6: | 1664 | case AF_INET6: |
1621 | GNUNET_asprintf (&ret, | 1665 | GNUNET_asprintf (&ret, |
1622 | "%s-%s", | 1666 | "%s-%s", |
1623 | COMMUNICATOR_ADDRESS_PREFIX, | 1667 | COMMUNICATOR_ADDRESS_PREFIX, |
1624 | GNUNET_a2s (address, address_len)); | 1668 | GNUNET_a2s (address, address_len)); |
1625 | break; | 1669 | break; |
1626 | 1670 | ||
1627 | default: | 1671 | default: |
1628 | GNUNET_assert (0); | 1672 | GNUNET_assert (0); |
1629 | } | 1673 | } |
1630 | return ret; | 1674 | return ret; |
1631 | } | 1675 | } |
@@ -1660,7 +1704,8 @@ sock_read (void *cls) | |||
1660 | return; | 1704 | return; |
1661 | } | 1705 | } |
1662 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1663 | "Read %lu bytes\n", rcvd); | 1707 | "Read %lu bytes.\n", |
1708 | rcvd); | ||
1664 | /* first, see if it is a UDPBox */ | 1709 | /* first, see if it is a UDPBox */ |
1665 | if (rcvd > sizeof(struct UDPBox)) | 1710 | if (rcvd > sizeof(struct UDPBox)) |
1666 | { | 1711 | { |
@@ -1674,6 +1719,9 @@ sock_read (void *cls) | |||
1674 | decrypt_box (box, (size_t) rcvd, kce); | 1719 | decrypt_box (box, (size_t) rcvd, kce); |
1675 | return; | 1720 | return; |
1676 | } | 1721 | } |
1722 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1723 | "No kid %s.\n", | ||
1724 | GNUNET_sh2s (&box->kid)); | ||
1677 | } | 1725 | } |
1678 | 1726 | ||
1679 | /* next, check if it is a broadcast */ | 1727 | /* next, check if it is a broadcast */ |
@@ -1731,7 +1779,8 @@ sock_read (void *cls) | |||
1731 | kx = (const struct InitialKX *) buf; | 1779 | kx = (const struct InitialKX *) buf; |
1732 | ss = setup_shared_secret_dec (&kx->ephemeral); | 1780 | ss = setup_shared_secret_dec (&kx->ephemeral); |
1733 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1781 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1734 | "Before DEC\n"); | 1782 | "Before DEC with ephemeral %s\n", |
1783 | GNUNET_e2s (&kx->ephemeral)); | ||
1735 | 1784 | ||
1736 | if (GNUNET_OK != try_decrypt (ss, | 1785 | if (GNUNET_OK != try_decrypt (ss, |
1737 | kx->gcm_tag, | 1786 | kx->gcm_tag, |
@@ -1744,10 +1793,10 @@ sock_read (void *cls) | |||
1744 | "Unable to decrypt tag, dropping...\n"); | 1793 | "Unable to decrypt tag, dropping...\n"); |
1745 | GNUNET_free (ss); | 1794 | GNUNET_free (ss); |
1746 | GNUNET_STATISTICS_update ( | 1795 | GNUNET_STATISTICS_update ( |
1747 | stats, | 1796 | stats, |
1748 | "# messages dropped (no kid, AEAD decryption failed)", | 1797 | "# messages dropped (no kid, AEAD decryption failed)", |
1749 | 1, | 1798 | 1, |
1750 | GNUNET_NO); | 1799 | GNUNET_NO); |
1751 | return; | 1800 | return; |
1752 | } | 1801 | } |
1753 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1802 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -1768,6 +1817,10 @@ sock_read (void *cls) | |||
1768 | "Before SETUP_SENDER\n"); | 1817 | "Before SETUP_SENDER\n"); |
1769 | 1818 | ||
1770 | calculate_cmac (ss); | 1819 | calculate_cmac (ss); |
1820 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1821 | "Got cmac %s for secret %p.\n", | ||
1822 | GNUNET_h2s (&ss->cmac), | ||
1823 | ss); | ||
1771 | sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen); | 1824 | sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen); |
1772 | ss->sender = sender; | 1825 | ss->sender = sender; |
1773 | GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss); | 1826 | GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss); |
@@ -1778,9 +1831,12 @@ sock_read (void *cls) | |||
1778 | 1, | 1831 | 1, |
1779 | GNUNET_NO); | 1832 | GNUNET_NO); |
1780 | try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc)); | 1833 | try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc)); |
1834 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1835 | "We have %u secrets\n", | ||
1836 | sender->num_secrets); | ||
1837 | /*if (sender->num_secrets > MAX_SECRETS) | ||
1838 | secret_destroy (sender->ss_tail);*/ | ||
1781 | consider_ss_ack (ss); | 1839 | consider_ss_ack (ss); |
1782 | if (sender->num_secrets > MAX_SECRETS) | ||
1783 | secret_destroy (sender->ss_tail); | ||
1784 | } | 1840 | } |
1785 | } | 1841 | } |
1786 | 1842 | ||
@@ -1859,9 +1915,9 @@ udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) | |||
1859 | else | 1915 | else |
1860 | { | 1916 | { |
1861 | GNUNET_log ( | 1917 | GNUNET_log ( |
1862 | GNUNET_ERROR_TYPE_ERROR, | 1918 | GNUNET_ERROR_TYPE_ERROR, |
1863 | "BINDTO specification `%s' invalid: last ':' not followed by number\n", | 1919 | "BINDTO specification `%s' invalid: last ':' not followed by number\n", |
1864 | bindto); | 1920 | bindto); |
1865 | GNUNET_free (cp); | 1921 | GNUNET_free (cp); |
1866 | return NULL; | 1922 | return NULL; |
1867 | } | 1923 | } |
@@ -1939,8 +1995,8 @@ do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size) | |||
1939 | memcpy (pad, &hdr, sizeof(hdr)); | 1995 | memcpy (pad, &hdr, sizeof(hdr)); |
1940 | } | 1996 | } |
1941 | GNUNET_assert ( | 1997 | GNUNET_assert ( |
1942 | 0 == | 1998 | 0 == |
1943 | gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad))); | 1999 | gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad))); |
1944 | } | 2000 | } |
1945 | 2001 | ||
1946 | 2002 | ||
@@ -1982,6 +2038,8 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq, | |||
1982 | GNUNET_CRYPTO_ecdhe_key_create (&epriv); | 2038 | GNUNET_CRYPTO_ecdhe_key_create (&epriv); |
1983 | 2039 | ||
1984 | ss = setup_shared_secret_enc (&epriv, receiver); | 2040 | ss = setup_shared_secret_enc (&epriv, receiver); |
2041 | /*if (receiver->num_secrets > MAX_SECRETS) | ||
2042 | secret_destroy (receiver->ss_tail);*/ | ||
1985 | setup_cipher (&ss->master, 0, &out_cipher); | 2043 | setup_cipher (&ss->master, 0, &out_cipher); |
1986 | /* compute 'uc' */ | 2044 | /* compute 'uc' */ |
1987 | uc.sender = my_identity; | 2045 | uc.sender = my_identity; |
@@ -2007,13 +2065,13 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq, | |||
2007 | dpos += sizeof(uc); | 2065 | dpos += sizeof(uc); |
2008 | /* Append encrypted payload to dgram */ | 2066 | /* Append encrypted payload to dgram */ |
2009 | GNUNET_assert ( | 2067 | GNUNET_assert ( |
2010 | 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); | 2068 | 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); |
2011 | dpos += msize; | 2069 | dpos += msize; |
2012 | do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); | 2070 | do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); |
2013 | /* Datagram starts with kx */ | 2071 | /* Datagram starts with kx */ |
2014 | kx.ephemeral = uhs.ephemeral; | 2072 | kx.ephemeral = uhs.ephemeral; |
2015 | GNUNET_assert ( | 2073 | GNUNET_assert ( |
2016 | 0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag))); | 2074 | 0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag))); |
2017 | gcry_cipher_close (out_cipher); | 2075 | gcry_cipher_close (out_cipher); |
2018 | memcpy (dgram, &kx, sizeof(kx)); | 2076 | memcpy (dgram, &kx, sizeof(kx)); |
2019 | if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock, | 2077 | if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock, |
@@ -2023,8 +2081,10 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq, | |||
2023 | receiver->address_len)) | 2081 | receiver->address_len)) |
2024 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); | 2082 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); |
2025 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2083 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2026 | "Sending KX to %s\n", GNUNET_a2s (receiver->address, | 2084 | "Sending KX to %s with ephemeral %s\n", |
2027 | receiver->address_len)); | 2085 | GNUNET_a2s (receiver->address, |
2086 | receiver->address_len), | ||
2087 | GNUNET_e2s (&kx.ephemeral)); | ||
2028 | GNUNET_MQ_impl_send_continue (mq); | 2088 | GNUNET_MQ_impl_send_continue (mq); |
2029 | } | 2089 | } |
2030 | 2090 | ||
@@ -2045,6 +2105,11 @@ mq_send_d (struct GNUNET_MQ_Handle *mq, | |||
2045 | struct ReceiverAddress *receiver = impl_state; | 2105 | struct ReceiverAddress *receiver = impl_state; |
2046 | uint16_t msize = ntohs (msg->size); | 2106 | uint16_t msize = ntohs (msg->size); |
2047 | 2107 | ||
2108 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2109 | "sending to receiver %s with %u acks available.\n", | ||
2110 | receiver->foreign_addr, | ||
2111 | receiver->acks_available); | ||
2112 | |||
2048 | GNUNET_assert (mq == receiver->d_mq); | 2113 | GNUNET_assert (mq == receiver->d_mq); |
2049 | if ((msize > receiver->d_mtu) || | 2114 | if ((msize > receiver->d_mtu) || |
2050 | (0 == receiver->acks_available)) | 2115 | (0 == receiver->acks_available)) |
@@ -2069,12 +2134,16 @@ mq_send_d (struct GNUNET_MQ_Handle *mq, | |||
2069 | 2134 | ||
2070 | box = (struct UDPBox *) dgram; | 2135 | box = (struct UDPBox *) dgram; |
2071 | ss->sequence_used++; | 2136 | ss->sequence_used++; |
2137 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2138 | "get kid with sequence number %u and cmac %s.\n", | ||
2139 | ss->sequence_used, | ||
2140 | GNUNET_h2s (&ss->cmac)); | ||
2072 | get_kid (&ss->master, ss->sequence_used, &box->kid); | 2141 | get_kid (&ss->master, ss->sequence_used, &box->kid); |
2073 | setup_cipher (&ss->master, ss->sequence_used, &out_cipher); | 2142 | setup_cipher (&ss->master, ss->sequence_used, &out_cipher); |
2074 | /* Append encrypted payload to dgram */ | 2143 | /* Append encrypted payload to dgram */ |
2075 | dpos = sizeof(struct UDPBox); | 2144 | dpos = sizeof(struct UDPBox); |
2076 | GNUNET_assert ( | 2145 | GNUNET_assert ( |
2077 | 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); | 2146 | 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); |
2078 | dpos += msize; | 2147 | dpos += msize; |
2079 | do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); | 2148 | do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); |
2080 | GNUNET_assert (0 == gcry_cipher_gettag (out_cipher, | 2149 | GNUNET_assert (0 == gcry_cipher_gettag (out_cipher, |
@@ -2087,8 +2156,19 @@ mq_send_d (struct GNUNET_MQ_Handle *mq, | |||
2087 | receiver->address, | 2156 | receiver->address, |
2088 | receiver->address_len)) | 2157 | receiver->address_len)) |
2089 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); | 2158 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); |
2159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2160 | "Sending UDPBox to %s with shared secrect %p and kid %s\n", | ||
2161 | GNUNET_a2s ( | ||
2162 | receiver->address, | ||
2163 | receiver | ||
2164 | ->address_len), | ||
2165 | ss, | ||
2166 | GNUNET_sh2s (&box->kid)); | ||
2090 | GNUNET_MQ_impl_send_continue (mq); | 2167 | GNUNET_MQ_impl_send_continue (mq); |
2091 | receiver->acks_available--; | 2168 | receiver->acks_available--; |
2169 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2170 | "%u acks available after sending.\n", | ||
2171 | receiver->acks_available); | ||
2092 | if (0 == receiver->acks_available) | 2172 | if (0 == receiver->acks_available) |
2093 | { | 2173 | { |
2094 | /* We have no more ACKs */ | 2174 | /* We have no more ACKs */ |
@@ -2205,25 +2285,25 @@ setup_receiver_mq (struct ReceiverAddress *receiver) | |||
2205 | // GNUNET_assert (NULL == receiver->mq); | 2285 | // GNUNET_assert (NULL == receiver->mq); |
2206 | switch (receiver->address->sa_family) | 2286 | switch (receiver->address->sa_family) |
2207 | { | 2287 | { |
2208 | case AF_INET: | 2288 | case AF_INET: |
2209 | base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */ | 2289 | base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */ |
2210 | - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */ | 2290 | - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */ |
2211 | - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; | 2291 | - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; |
2212 | break; | 2292 | break; |
2213 | 2293 | ||
2214 | case AF_INET6: | 2294 | case AF_INET6: |
2215 | base_mtu = 1280 /* Minimum MTU required by IPv6 */ | 2295 | base_mtu = 1280 /* Minimum MTU required by IPv6 */ |
2216 | - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */ | 2296 | - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */ |
2217 | - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; | 2297 | - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; |
2218 | break; | 2298 | break; |
2219 | 2299 | ||
2220 | default: | 2300 | default: |
2221 | GNUNET_assert (0); | 2301 | GNUNET_assert (0); |
2222 | break; | 2302 | break; |
2223 | } | 2303 | } |
2224 | /* MTU based on full KX messages */ | 2304 | /* MTU based on full KX messages */ |
2225 | receiver->kx_mtu = base_mtu - sizeof(struct InitialKX) /* 48 */ | 2305 | receiver->kx_mtu = base_mtu - sizeof(struct InitialKX) /* 48 */ |
2226 | - sizeof(struct UDPConfirmation); /* 104 */ | 2306 | - sizeof(struct UDPConfirmation); /* 104 */ |
2227 | /* MTU based on BOXed messages */ | 2307 | /* MTU based on BOXed messages */ |
2228 | receiver->d_mtu = base_mtu - sizeof(struct UDPBox); | 2308 | receiver->d_mtu = base_mtu - sizeof(struct UDPBox); |
2229 | 2309 | ||
@@ -2314,10 +2394,10 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) | |||
2314 | receiver->target = *peer; | 2394 | receiver->target = *peer; |
2315 | receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len); | 2395 | receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len); |
2316 | (void) GNUNET_CONTAINER_multipeermap_put ( | 2396 | (void) GNUNET_CONTAINER_multipeermap_put ( |
2317 | receivers, | 2397 | receivers, |
2318 | &receiver->target, | 2398 | &receiver->target, |
2319 | receiver, | 2399 | receiver, |
2320 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 2400 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
2321 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2401 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2322 | "Added %s to receivers\n", | 2402 | "Added %s to receivers\n", |
2323 | GNUNET_i2s_full (&receiver->target)); | 2403 | GNUNET_i2s_full (&receiver->target)); |
@@ -2553,55 +2633,55 @@ ifc_broadcast (void *cls) | |||
2553 | 2633 | ||
2554 | switch (bi->sa->sa_family) | 2634 | switch (bi->sa->sa_family) |
2555 | { | 2635 | { |
2556 | case AF_INET: { | 2636 | case AF_INET: { |
2557 | static int yes = 1; | 2637 | static int yes = 1; |
2558 | static int no = 0; | 2638 | static int no = 0; |
2559 | ssize_t sent; | 2639 | ssize_t sent; |
2560 | 2640 | ||
2561 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, | 2641 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, |
2562 | SOL_SOCKET, | 2642 | SOL_SOCKET, |
2563 | SO_BROADCAST, | 2643 | SO_BROADCAST, |
2564 | &yes, | 2644 | &yes, |
2565 | sizeof(int))) | 2645 | sizeof(int))) |
2566 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); | 2646 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); |
2567 | sent = GNUNET_NETWORK_socket_sendto (udp_sock, | 2647 | sent = GNUNET_NETWORK_socket_sendto (udp_sock, |
2568 | &bi->bcm, | 2648 | &bi->bcm, |
2569 | sizeof(bi->bcm), | 2649 | sizeof(bi->bcm), |
2570 | bi->ba, | 2650 | bi->ba, |
2571 | bi->salen); | 2651 | bi->salen); |
2572 | if (-1 == sent) | 2652 | if (-1 == sent) |
2573 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); | 2653 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); |
2574 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, | 2654 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, |
2575 | SOL_SOCKET, | 2655 | SOL_SOCKET, |
2576 | SO_BROADCAST, | 2656 | SO_BROADCAST, |
2577 | &no, | 2657 | &no, |
2578 | sizeof(int))) | 2658 | sizeof(int))) |
2579 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); | 2659 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); |
2580 | break; | 2660 | break; |
2581 | } | 2661 | } |
2582 | 2662 | ||
2583 | case AF_INET6: { | 2663 | case AF_INET6: { |
2584 | ssize_t sent; | 2664 | ssize_t sent; |
2585 | struct sockaddr_in6 dst; | 2665 | struct sockaddr_in6 dst; |
2586 | 2666 | ||
2587 | dst.sin6_family = AF_INET6; | 2667 | dst.sin6_family = AF_INET6; |
2588 | dst.sin6_port = htons (my_port); | 2668 | dst.sin6_port = htons (my_port); |
2589 | dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr; | 2669 | dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr; |
2590 | dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id; | 2670 | dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id; |
2591 | 2671 | ||
2592 | sent = GNUNET_NETWORK_socket_sendto (udp_sock, | 2672 | sent = GNUNET_NETWORK_socket_sendto (udp_sock, |
2593 | &bi->bcm, | 2673 | &bi->bcm, |
2594 | sizeof(bi->bcm), | 2674 | sizeof(bi->bcm), |
2595 | (const struct sockaddr *) &dst, | 2675 | (const struct sockaddr *) &dst, |
2596 | sizeof(dst)); | 2676 | sizeof(dst)); |
2597 | if (-1 == sent) | 2677 | if (-1 == sent) |
2598 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); | 2678 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); |
2599 | break; | 2679 | break; |
2600 | } | 2680 | } |
2601 | 2681 | ||
2602 | default: | 2682 | default: |
2603 | GNUNET_break (0); | 2683 | GNUNET_break (0); |
2604 | break; | 2684 | break; |
2605 | } | 2685 | } |
2606 | } | 2686 | } |
2607 | 2687 | ||
@@ -2683,7 +2763,7 @@ iface_proc (void *cls, | |||
2683 | (const struct sockaddr_in6 *) broadcast_addr; | 2763 | (const struct sockaddr_in6 *) broadcast_addr; |
2684 | 2764 | ||
2685 | GNUNET_assert ( | 2765 | GNUNET_assert ( |
2686 | 1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr)); | 2766 | 1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr)); |
2687 | 2767 | ||
2688 | /* http://tools.ietf.org/html/rfc2553#section-5.2: | 2768 | /* http://tools.ietf.org/html/rfc2553#section-5.2: |
2689 | * | 2769 | * |
@@ -2820,17 +2900,17 @@ run (void *cls, | |||
2820 | GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); | 2900 | GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); |
2821 | switch (in->sa_family) | 2901 | switch (in->sa_family) |
2822 | { | 2902 | { |
2823 | case AF_INET: | 2903 | case AF_INET: |
2824 | my_port = ntohs (((struct sockaddr_in *) in)->sin_port); | 2904 | my_port = ntohs (((struct sockaddr_in *) in)->sin_port); |
2825 | break; | 2905 | break; |
2826 | 2906 | ||
2827 | case AF_INET6: | 2907 | case AF_INET6: |
2828 | my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port); | 2908 | my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port); |
2829 | break; | 2909 | break; |
2830 | 2910 | ||
2831 | default: | 2911 | default: |
2832 | GNUNET_break (0); | 2912 | GNUNET_break (0); |
2833 | my_port = 0; | 2913 | my_port = 0; |
2834 | } | 2914 | } |
2835 | stats = GNUNET_STATISTICS_create ("C-UDP", cfg); | 2915 | stats = GNUNET_STATISTICS_create ("C-UDP", cfg); |
2836 | senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES); | 2916 | senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES); |
@@ -2845,9 +2925,9 @@ run (void *cls, | |||
2845 | if (NULL == my_private_key) | 2925 | if (NULL == my_private_key) |
2846 | { | 2926 | { |
2847 | GNUNET_log ( | 2927 | GNUNET_log ( |
2848 | GNUNET_ERROR_TYPE_ERROR, | 2928 | GNUNET_ERROR_TYPE_ERROR, |
2849 | _ ( | 2929 | _ ( |
2850 | "Transport service is lacking key configuration settings. Exiting.\n")); | 2930 | "Transport service is lacking key configuration settings. Exiting.\n")); |
2851 | GNUNET_SCHEDULER_shutdown (); | 2931 | GNUNET_SCHEDULER_shutdown (); |
2852 | return; | 2932 | return; |
2853 | } | 2933 | } |
@@ -2923,8 +3003,8 @@ main (int argc, char *const *argv) | |||
2923 | options, | 3003 | options, |
2924 | &run, | 3004 | &run, |
2925 | NULL)) | 3005 | NULL)) |
2926 | ? 0 | 3006 | ? 0 |
2927 | : 1; | 3007 | : 1; |
2928 | GNUNET_free_nz ((void *) argv); | 3008 | GNUNET_free_nz ((void *) argv); |
2929 | return ret; | 3009 | return ret; |
2930 | } | 3010 | } |
diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c index e3573ac2c..2d550dc16 100644 --- a/src/transport/test_communicator_basic.c +++ b/src/transport/test_communicator_basic.c | |||
@@ -82,6 +82,9 @@ static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *my_tc; | |||
82 | 82 | ||
83 | static unsigned int iterations_left = TOTAL_ITERATIONS; | 83 | static unsigned int iterations_left = TOTAL_ITERATIONS; |
84 | 84 | ||
85 | #define DELAY \ | ||
86 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1000) | ||
87 | |||
85 | #define SHORT_BURST_WINDOW \ | 88 | #define SHORT_BURST_WINDOW \ |
86 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2) | 89 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2) |
87 | 90 | ||
@@ -97,13 +100,21 @@ enum TestPhase | |||
97 | }; | 100 | }; |
98 | 101 | ||
99 | 102 | ||
100 | static size_t num_sent = 0; | 103 | static size_t num_sent_short = 0; |
104 | |||
105 | static size_t num_sent_long = 0; | ||
106 | |||
107 | static size_t num_sent_size = 0; | ||
101 | 108 | ||
102 | static uint32_t ack = 0; | 109 | static uint32_t ack = 0; |
103 | 110 | ||
104 | static enum TestPhase phase; | 111 | static enum TestPhase phase; |
105 | 112 | ||
106 | static size_t num_received = 0; | 113 | static size_t num_received_short = 0; |
114 | |||
115 | static size_t num_received_long = 0; | ||
116 | |||
117 | static size_t num_received_size = 0; | ||
107 | 118 | ||
108 | static uint64_t avg_latency = 0; | 119 | static uint64_t avg_latency = 0; |
109 | 120 | ||
@@ -230,6 +241,10 @@ make_payload (size_t payload_size) | |||
230 | static void | 241 | static void |
231 | latency_timeout (void *cls) | 242 | latency_timeout (void *cls) |
232 | { | 243 | { |
244 | |||
245 | size_t num_sent = 0; | ||
246 | size_t num_received = 0; | ||
247 | |||
233 | to_task = NULL; | 248 | to_task = NULL; |
234 | if (GNUNET_TIME_absolute_get_remaining (timeout).rel_value_us > 0) | 249 | if (GNUNET_TIME_absolute_get_remaining (timeout).rel_value_us > 0) |
235 | { | 250 | { |
@@ -239,6 +254,21 @@ latency_timeout (void *cls) | |||
239 | return; | 254 | return; |
240 | } | 255 | } |
241 | 256 | ||
257 | switch (phase) | ||
258 | { | ||
259 | case TP_BURST_SHORT: | ||
260 | num_sent = num_sent_short; | ||
261 | num_received = num_received_short; | ||
262 | break; | ||
263 | case TP_BURST_LONG: | ||
264 | num_sent = num_sent_long; | ||
265 | num_received = num_received_long; | ||
266 | break; | ||
267 | case TP_SIZE_CHECK: | ||
268 | num_sent = num_sent_size; | ||
269 | num_received = num_received_size; | ||
270 | break; | ||
271 | } | ||
242 | LOG (GNUNET_ERROR_TYPE_ERROR, | 272 | LOG (GNUNET_ERROR_TYPE_ERROR, |
243 | "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n", | 273 | "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n", |
244 | phase, num_sent, num_received); | 274 | phase, num_sent, num_received); |
@@ -246,6 +276,8 @@ latency_timeout (void *cls) | |||
246 | GNUNET_SCHEDULER_shutdown (); | 276 | GNUNET_SCHEDULER_shutdown (); |
247 | } | 277 | } |
248 | 278 | ||
279 | /*static void | ||
280 | size_test (void *cls);*/ | ||
249 | 281 | ||
250 | static void | 282 | static void |
251 | size_test (void *cls) | 283 | size_test (void *cls) |
@@ -253,6 +285,9 @@ size_test (void *cls) | |||
253 | char *payload; | 285 | char *payload; |
254 | size_t max_size = 64000; | 286 | size_t max_size = 64000; |
255 | 287 | ||
288 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
289 | "size_test_cb %u\n", | ||
290 | num_sent_size); | ||
256 | GNUNET_assert (TP_SIZE_CHECK == phase); | 291 | GNUNET_assert (TP_SIZE_CHECK == phase); |
257 | if (LONG_MESSAGE_SIZE != long_message_size) | 292 | if (LONG_MESSAGE_SIZE != long_message_size) |
258 | max_size = long_message_size; | 293 | max_size = long_message_size; |
@@ -260,7 +295,7 @@ size_test (void *cls) | |||
260 | return; /* Leave some room for our protocol, so not 2^16 exactly */ | 295 | return; /* Leave some room for our protocol, so not 2^16 exactly */ |
261 | ack += 10; | 296 | ack += 10; |
262 | payload = make_payload (ack); | 297 | payload = make_payload (ack); |
263 | num_sent++; | 298 | num_sent_size++; |
264 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, | 299 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, |
265 | (ack < max_size) | 300 | (ack < max_size) |
266 | ? &size_test | 301 | ? &size_test |
@@ -272,17 +307,34 @@ size_test (void *cls) | |||
272 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); | 307 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); |
273 | } | 308 | } |
274 | 309 | ||
310 | /*static void | ||
311 | size_test (void *cls) | ||
312 | { | ||
313 | GNUNET_SCHEDULER_add_delayed (DELAY, | ||
314 | &size_test_cb, | ||
315 | NULL); | ||
316 | }*/ | ||
317 | |||
318 | static void | ||
319 | long_test (void *cls); | ||
275 | 320 | ||
276 | static void | 321 | static void |
277 | long_test (void *cls) | 322 | long_test_cb (void *cls) |
278 | { | 323 | { |
279 | char *payload; | 324 | char *payload; |
280 | 325 | ||
326 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
327 | "long_test_cb %u/%u\n", | ||
328 | num_sent_long, | ||
329 | num_received_long); | ||
281 | payload = make_payload (long_message_size); | 330 | payload = make_payload (long_message_size); |
282 | num_sent++; | 331 | num_sent_long++; |
283 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, | 332 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, |
284 | (BURST_PACKETS == | 333 | ((BURST_PACKETS |
285 | num_sent) | 334 | * 0.91 == |
335 | num_received_long) || | ||
336 | (BURST_PACKETS == | ||
337 | num_sent_long)) | ||
286 | ? NULL | 338 | ? NULL |
287 | : &long_test, | 339 | : &long_test, |
288 | NULL, | 340 | NULL, |
@@ -292,17 +344,37 @@ long_test (void *cls) | |||
292 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); | 344 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); |
293 | } | 345 | } |
294 | 346 | ||
347 | static void | ||
348 | long_test (void *cls) | ||
349 | { | ||
350 | /*LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
351 | "long_test %u\n", | ||
352 | num_sent_long);*/ | ||
353 | GNUNET_SCHEDULER_add_delayed (DELAY, | ||
354 | &long_test_cb, | ||
355 | NULL); | ||
356 | } | ||
295 | 357 | ||
296 | static void | 358 | static void |
297 | short_test (void *cls) | 359 | short_test (void *cls); |
360 | |||
361 | static void | ||
362 | short_test_cb (void *cls) | ||
298 | { | 363 | { |
299 | char *payload; | 364 | char *payload; |
300 | 365 | ||
366 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
367 | "short_test_cb %u/%u\n", | ||
368 | num_sent_short, | ||
369 | num_received_short); | ||
301 | payload = make_payload (SHORT_MESSAGE_SIZE); | 370 | payload = make_payload (SHORT_MESSAGE_SIZE); |
302 | num_sent++; | 371 | num_sent_short++; |
303 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, | 372 | GNUNET_TRANSPORT_TESTING_transport_communicator_send (my_tc, |
304 | (BURST_PACKETS == | 373 | ((BURST_PACKETS |
305 | num_sent) | 374 | * 0.91 == |
375 | num_received_short) || | ||
376 | (BURST_PACKETS == | ||
377 | num_sent_short)) | ||
306 | ? NULL | 378 | ? NULL |
307 | : &short_test, | 379 | : &short_test, |
308 | NULL, | 380 | NULL, |
@@ -312,6 +384,14 @@ short_test (void *cls) | |||
312 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); | 384 | timeout = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_SECONDS); |
313 | } | 385 | } |
314 | 386 | ||
387 | static void | ||
388 | short_test (void *cls) | ||
389 | { | ||
390 | GNUNET_SCHEDULER_add_delayed (DELAY, | ||
391 | &short_test_cb, | ||
392 | NULL); | ||
393 | } | ||
394 | |||
315 | 395 | ||
316 | static int test_prepared = GNUNET_NO; | 396 | static int test_prepared = GNUNET_NO; |
317 | 397 | ||
@@ -388,10 +468,23 @@ update_avg_latency (const char*payload) | |||
388 | struct GNUNET_TIME_AbsoluteNBO *ts_n; | 468 | struct GNUNET_TIME_AbsoluteNBO *ts_n; |
389 | struct GNUNET_TIME_Absolute ts; | 469 | struct GNUNET_TIME_Absolute ts; |
390 | struct GNUNET_TIME_Relative latency; | 470 | struct GNUNET_TIME_Relative latency; |
471 | size_t num_received = 0; | ||
391 | 472 | ||
392 | ts_n = (struct GNUNET_TIME_AbsoluteNBO *) payload; | 473 | ts_n = (struct GNUNET_TIME_AbsoluteNBO *) payload; |
393 | ts = GNUNET_TIME_absolute_ntoh (*ts_n); | 474 | ts = GNUNET_TIME_absolute_ntoh (*ts_n); |
394 | latency = GNUNET_TIME_absolute_get_duration (ts); | 475 | latency = GNUNET_TIME_absolute_get_duration (ts); |
476 | switch (phase) | ||
477 | { | ||
478 | case TP_BURST_SHORT: | ||
479 | num_received = num_received_short; | ||
480 | break; | ||
481 | case TP_BURST_LONG: | ||
482 | num_received = num_received_long; | ||
483 | break; | ||
484 | case TP_SIZE_CHECK: | ||
485 | num_received = num_received_size; | ||
486 | break; | ||
487 | } | ||
395 | if (1 >= num_received) | 488 | if (1 >= num_received) |
396 | avg_latency = latency.rel_value_us; | 489 | avg_latency = latency.rel_value_us; |
397 | else | 490 | else |
@@ -400,7 +493,6 @@ update_avg_latency (const char*payload) | |||
400 | 493 | ||
401 | } | 494 | } |
402 | 495 | ||
403 | |||
404 | /** | 496 | /** |
405 | * @brief Handle an incoming message | 497 | * @brief Handle an incoming message |
406 | * | 498 | * |
@@ -412,7 +504,8 @@ update_avg_latency (const char*payload) | |||
412 | */ | 504 | */ |
413 | static void | 505 | static void |
414 | incoming_message_cb (void *cls, | 506 | incoming_message_cb (void *cls, |
415 | struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle | 507 | struct |
508 | GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle | ||
416 | *tc_h, | 509 | *tc_h, |
417 | const char*payload, | 510 | const char*payload, |
418 | size_t payload_len) | 511 | size_t payload_len) |
@@ -433,30 +526,31 @@ incoming_message_cb (void *cls, | |||
433 | case TP_BURST_SHORT: | 526 | case TP_BURST_SHORT: |
434 | { | 527 | { |
435 | GNUNET_assert (SHORT_MESSAGE_SIZE == payload_len); | 528 | GNUNET_assert (SHORT_MESSAGE_SIZE == payload_len); |
436 | num_received++; | 529 | num_received_short++; |
437 | duration = GNUNET_TIME_absolute_get_duration (start_short); | 530 | duration = GNUNET_TIME_absolute_get_duration (start_short); |
438 | update_avg_latency (payload); | 531 | update_avg_latency (payload); |
439 | if (num_received == BURST_PACKETS) | 532 | if (num_received_short == BURST_PACKETS * 0.91) |
440 | { | 533 | { |
441 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 534 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
442 | "Short size packet test done.\n"); | 535 | "Short size packet test done.\n"); |
443 | char *goodput = GNUNET_STRINGS_byte_size_fancy ((SHORT_MESSAGE_SIZE | 536 | char *goodput = GNUNET_STRINGS_byte_size_fancy ((SHORT_MESSAGE_SIZE |
444 | * num_received * 1000 | 537 | * num_received_short |
538 | * 1000 | ||
445 | * 1000) | 539 | * 1000) |
446 | / duration.rel_value_us); | 540 | / duration.rel_value_us); |
447 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 541 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
448 | "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", | 542 | "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", |
449 | (unsigned long) num_received, | 543 | (unsigned long) num_received_short, |
450 | (unsigned long) num_sent, | 544 | (unsigned long) num_sent_short, |
451 | (unsigned long long) duration.rel_value_us, | 545 | (unsigned long long) duration.rel_value_us, |
452 | goodput, | 546 | goodput, |
453 | (unsigned long long) avg_latency); | 547 | (unsigned long long) avg_latency); |
454 | GNUNET_free (goodput); | 548 | GNUNET_free (goodput); |
455 | start_long = GNUNET_TIME_absolute_get (); | 549 | start_long = GNUNET_TIME_absolute_get (); |
456 | phase = TP_BURST_LONG; | 550 | phase = TP_BURST_LONG; |
457 | num_sent = 0; | 551 | // num_sent_short = 0; |
458 | avg_latency = 0; | 552 | avg_latency = 0; |
459 | num_received = 0; | 553 | // num_received = 0; |
460 | long_test (NULL); | 554 | long_test (NULL); |
461 | } | 555 | } |
462 | break; | 556 | break; |
@@ -467,32 +561,34 @@ incoming_message_cb (void *cls, | |||
467 | { | 561 | { |
468 | LOG (GNUNET_ERROR_TYPE_WARNING, | 562 | LOG (GNUNET_ERROR_TYPE_WARNING, |
469 | "Ignoring packet with wrong length\n"); | 563 | "Ignoring packet with wrong length\n"); |
470 | return; // Ignore | 564 | return; // Ignore |
471 | } | 565 | } |
472 | num_received++; | 566 | num_received_long++; |
473 | duration = GNUNET_TIME_absolute_get_duration (start_long); | 567 | duration = GNUNET_TIME_absolute_get_duration (start_long); |
474 | update_avg_latency (payload); | 568 | update_avg_latency (payload); |
475 | if (num_received == BURST_PACKETS) | 569 | if (num_received_long == BURST_PACKETS * 0.91) |
476 | { | 570 | { |
477 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 571 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
478 | "Long size packet test done.\n"); | 572 | "Long size packet test done.\n"); |
479 | char *goodput = GNUNET_STRINGS_byte_size_fancy ((long_message_size | 573 | char *goodput = GNUNET_STRINGS_byte_size_fancy ((long_message_size |
480 | * num_received * 1000 | 574 | * num_received_long |
575 | * 1000 | ||
481 | * 1000) | 576 | * 1000) |
482 | / duration.rel_value_us); | 577 | / duration. |
578 | rel_value_us); | ||
483 | 579 | ||
484 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 580 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
485 | "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", | 581 | "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n", |
486 | (unsigned long) num_received, | 582 | (unsigned long) num_received_long, |
487 | (unsigned long) num_sent, | 583 | (unsigned long) num_sent_long, |
488 | (unsigned long long) duration.rel_value_us, | 584 | (unsigned long long) duration.rel_value_us, |
489 | goodput, | 585 | goodput, |
490 | (unsigned long long) avg_latency); | 586 | (unsigned long long) avg_latency); |
491 | GNUNET_free (goodput); | 587 | GNUNET_free (goodput); |
492 | ack = 0; | 588 | ack = 0; |
493 | phase = TP_SIZE_CHECK; | 589 | phase = TP_SIZE_CHECK; |
494 | num_received = 0; | 590 | // num_received = 0; |
495 | num_sent = 0; | 591 | // num_sent_long = 0; |
496 | avg_latency = 0; | 592 | avg_latency = 0; |
497 | size_test (NULL); | 593 | size_test (NULL); |
498 | } | 594 | } |
@@ -505,25 +601,29 @@ incoming_message_cb (void *cls, | |||
505 | GNUNET_assert (TP_SIZE_CHECK == phase); | 601 | GNUNET_assert (TP_SIZE_CHECK == phase); |
506 | if (LONG_MESSAGE_SIZE != long_message_size) | 602 | if (LONG_MESSAGE_SIZE != long_message_size) |
507 | max_size = long_message_size; | 603 | max_size = long_message_size; |
508 | num_received++; | 604 | num_received_size++; |
509 | update_avg_latency (payload); | 605 | update_avg_latency (payload); |
510 | if (num_received >= (max_size) / 10) | 606 | if (num_received_size >= (max_size) / 10) |
511 | { | 607 | { |
512 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 608 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
513 | "Size packet test done.\n"); | 609 | "Size packet test done.\n"); |
514 | LOG (GNUNET_ERROR_TYPE_MESSAGE, | 610 | LOG (GNUNET_ERROR_TYPE_MESSAGE, |
515 | "%lu/%lu packets -- avg latency: %llu us\n", | 611 | "%lu/%lu packets -- avg latency: %llu us\n", |
516 | (unsigned long) num_received, | 612 | (unsigned long) num_received_size, |
517 | (unsigned long) num_sent, | 613 | (unsigned long) num_sent_size, |
518 | (unsigned long long) avg_latency); | 614 | (unsigned long long) avg_latency); |
519 | num_received = 0; | 615 | num_received_size = 0; |
520 | num_sent = 0; | 616 | num_sent_size = 0; |
521 | avg_latency = 0; | 617 | avg_latency = 0; |
522 | iterations_left--; | 618 | iterations_left--; |
523 | if (0 != iterations_left) | 619 | if (0 != iterations_left) |
524 | { | 620 | { |
525 | start_short = GNUNET_TIME_absolute_get (); | 621 | start_short = GNUNET_TIME_absolute_get (); |
526 | phase = TP_BURST_SHORT; | 622 | phase = TP_BURST_SHORT; |
623 | num_sent_short = 0; | ||
624 | num_sent_long = 0; | ||
625 | num_received_short = 0; | ||
626 | num_received_long = 0; | ||
527 | short_test (NULL); | 627 | short_test (NULL); |
528 | break; | 628 | break; |
529 | } | 629 | } |
@@ -561,8 +661,8 @@ static void | |||
561 | run (void *cls) | 661 | run (void *cls) |
562 | { | 662 | { |
563 | ret = 0; | 663 | ret = 0; |
564 | num_received = 0; | 664 | // num_received = 0; |
565 | num_sent = 0; | 665 | // num_sent = 0; |
566 | for (unsigned int i = 0; i < NUM_PEERS; i++) | 666 | for (unsigned int i = 0; i < NUM_PEERS; i++) |
567 | { | 667 | { |
568 | tc_hs[i] = GNUNET_TRANSPORT_TESTING_transport_communicator_service_start ( | 668 | tc_hs[i] = GNUNET_TRANSPORT_TESTING_transport_communicator_service_start ( |