diff options
-rw-r--r-- | src/cadet/gnunet-service-cadet_connection.c | 1163 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_connection.h | 146 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_local.c | 2 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_peer.c | 1404 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_peer.h | 108 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_tunnel.c | 33 | ||||
-rw-r--r-- | src/cadet/gnunet-service-cadet_tunnel.h | 12 |
7 files changed, 1015 insertions, 1853 deletions
diff --git a/src/cadet/gnunet-service-cadet_connection.c b/src/cadet/gnunet-service-cadet_connection.c index 0c11c24df..29695243f 100644 --- a/src/cadet/gnunet-service-cadet_connection.c +++ b/src/cadet/gnunet-service-cadet_connection.c | |||
@@ -268,7 +268,7 @@ struct CadetConnectionQueue | |||
268 | /** | 268 | /** |
269 | * Peer queue handle, to cancel if necessary. | 269 | * Peer queue handle, to cancel if necessary. |
270 | */ | 270 | */ |
271 | struct CadetPeerQueue *q; | 271 | struct CadetPeerQueue *peer_q; |
272 | 272 | ||
273 | /** | 273 | /** |
274 | * Continuation to call once sent. | 274 | * Continuation to call once sent. |
@@ -312,7 +312,8 @@ static struct GNUNET_CONTAINER_MultiHashMap *connections; | |||
312 | 312 | ||
313 | /** | 313 | /** |
314 | * How many connections are we willing to maintain. | 314 | * How many connections are we willing to maintain. |
315 | * Local connections are always allowed, even if there are more connections than max. | 315 | * Local connections are always allowed, |
316 | * even if there are more connections than max. | ||
316 | */ | 317 | */ |
317 | static unsigned long long max_connections; | 318 | static unsigned long long max_connections; |
318 | 319 | ||
@@ -621,40 +622,94 @@ send_ack (struct CadetConnection *c, unsigned int buffer, int fwd, int force) | |||
621 | 622 | ||
622 | 623 | ||
623 | /** | 624 | /** |
625 | * Update performance information if we are a connection's endpoint. | ||
626 | * | ||
627 | * @param c Connection to update. | ||
628 | * @param wait How much time did we wait to send the last message. | ||
629 | * @param size Size of the last message. | ||
630 | */ | ||
631 | static void | ||
632 | update_perf (struct CadetConnection *c, | ||
633 | struct GNUNET_TIME_Relative wait, | ||
634 | uint16_t size) | ||
635 | { | ||
636 | struct CadetConnectionPerformance *p; | ||
637 | double usecsperbyte; | ||
638 | |||
639 | if (NULL == c->perf) | ||
640 | return; /* Only endpoints are interested in timing. */ | ||
641 | |||
642 | p = c->perf; | ||
643 | usecsperbyte = ((double) wait.rel_value_us) / size; | ||
644 | if (p->size == AVG_MSGS) | ||
645 | { | ||
646 | /* Array is full. Substract oldest value, add new one and store. */ | ||
647 | p->avg -= (p->usecsperbyte[p->idx] / AVG_MSGS); | ||
648 | p->usecsperbyte[p->idx] = usecsperbyte; | ||
649 | p->avg += (p->usecsperbyte[p->idx] / AVG_MSGS); | ||
650 | } | ||
651 | else | ||
652 | { | ||
653 | /* Array not yet full. Add current value to avg and store. */ | ||
654 | p->usecsperbyte[p->idx] = usecsperbyte; | ||
655 | p->avg *= p->size; | ||
656 | p->avg += p->usecsperbyte[p->idx]; | ||
657 | p->size++; | ||
658 | p->avg /= p->size; | ||
659 | } | ||
660 | p->idx = (p->idx + 1) % AVG_MSGS; | ||
661 | } | ||
662 | |||
663 | |||
664 | /** | ||
624 | * Callback called when a connection queued message is sent. | 665 | * Callback called when a connection queued message is sent. |
625 | * | 666 | * |
626 | * Calculates the average time and connection packet tracking. | 667 | * Calculates the average time and connection packet tracking. |
627 | * | 668 | * |
628 | * @param cls Closure (ConnectionQueue Handle). | 669 | * @param cls Closure (ConnectionQueue Handle), can be NULL. |
629 | * @param c Connection this message was on. | 670 | * @param c Connection this message was on. |
671 | * @param fwd Was this a FWD going message? | ||
630 | * @param sent Was it really sent? (Could have been canceled) | 672 | * @param sent Was it really sent? (Could have been canceled) |
631 | * @param type Type of message sent. | 673 | * @param type Type of message sent. |
632 | * @param pid Packet ID, or 0 if not applicable (create, destroy, etc). | 674 | * @param payload_type Type of payload, if applicable. |
633 | * @param fwd Was this a FWD going message? | 675 | * @param pid Message ID, or 0 if not applicable (create, destroy, etc). |
634 | * @param size Size of the message. | 676 | * @param size Size of the message. |
635 | * @param wait Time spent waiting for core (only the time for THIS message) | 677 | * @param wait Time spent waiting for core (only the time for THIS message) |
636 | * @return #GNUNET_YES if connection was destroyed, #GNUNET_NO otherwise. | ||
637 | */ | 678 | */ |
638 | static int | 679 | static void |
639 | conn_message_sent (void *cls, | 680 | conn_message_sent (void *cls, |
640 | struct CadetConnection *c, int sent, | 681 | struct CadetConnection *c, int fwd, int sent, |
641 | uint16_t type, uint32_t pid, int fwd, size_t size, | 682 | uint16_t type, uint16_t payload_type, uint32_t pid, |
683 | size_t size, | ||
642 | struct GNUNET_TIME_Relative wait) | 684 | struct GNUNET_TIME_Relative wait) |
643 | { | 685 | { |
644 | struct CadetConnectionPerformance *p; | ||
645 | struct CadetFlowControl *fc; | ||
646 | struct CadetConnectionQueue *q = cls; | 686 | struct CadetConnectionQueue *q = cls; |
647 | double usecsperbyte; | 687 | struct CadetFlowControl *fc; |
648 | int forced; | 688 | int forced; |
649 | 689 | ||
650 | GCC_check_connections (); | 690 | GCC_check_connections (); |
651 | LOG (GNUNET_ERROR_TYPE_DEBUG, "connection message_sent\n"); | ||
652 | 691 | ||
692 | /* If c is NULL, nothing to update. */ | ||
693 | if (NULL == c) | ||
694 | { | ||
695 | if (type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN | ||
696 | && type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY) | ||
697 | { | ||
698 | LOG (GNUNET_ERROR_TYPE_ERROR, "Message %s sent on NULL connection!\n", | ||
699 | GC_m2s (type)); | ||
700 | } | ||
701 | GCC_check_connections (); | ||
702 | return; | ||
703 | } | ||
704 | |||
705 | LOG (GNUNET_ERROR_TYPE_DEBUG, "connection message_sent\n"); | ||
653 | GCC_debug (c, GNUNET_ERROR_TYPE_DEBUG); | 706 | GCC_debug (c, GNUNET_ERROR_TYPE_DEBUG); |
654 | 707 | ||
708 | /* Update flow control info. */ | ||
655 | fc = fwd ? &c->fwd_fc : &c->bck_fc; | 709 | fc = fwd ? &c->fwd_fc : &c->bck_fc; |
656 | LOG (GNUNET_ERROR_TYPE_DEBUG, " %ssent %s %s pid %u\n", | 710 | LOG (GNUNET_ERROR_TYPE_DEBUG, " %ssent %s %s pid %u\n", |
657 | sent ? "" : "not ", GC_f2s (fwd), GC_m2s (type), pid); | 711 | sent ? "" : "not ", GC_f2s (fwd), |
712 | GC_m2s (type), GC_m2s (payload_type), pid); | ||
658 | if (NULL != q) | 713 | if (NULL != q) |
659 | { | 714 | { |
660 | forced = q->forced; | 715 | forced = q->forced; |
@@ -674,17 +729,7 @@ conn_message_sent (void *cls, | |||
674 | { | 729 | { |
675 | forced = GNUNET_NO; | 730 | forced = GNUNET_NO; |
676 | } | 731 | } |
677 | if (NULL == c) | 732 | |
678 | { | ||
679 | if (type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN | ||
680 | && type != GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY) | ||
681 | { | ||
682 | LOG (GNUNET_ERROR_TYPE_ERROR, "Message %s sent on NULL connection!\n", | ||
683 | GC_m2s (type)); | ||
684 | } | ||
685 | GCC_check_connections (); | ||
686 | return GNUNET_NO; | ||
687 | } | ||
688 | LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P- %p %u\n", c, c->pending_messages); | 733 | LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P- %p %u\n", c, c->pending_messages); |
689 | c->pending_messages--; | 734 | c->pending_messages--; |
690 | if ( (GNUNET_YES == c->destroy) && | 735 | if ( (GNUNET_YES == c->destroy) && |
@@ -694,8 +739,9 @@ conn_message_sent (void *cls, | |||
694 | "! destroying connection!\n"); | 739 | "! destroying connection!\n"); |
695 | GCC_destroy (c); | 740 | GCC_destroy (c); |
696 | GCC_check_connections (); | 741 | GCC_check_connections (); |
697 | return GNUNET_YES; | 742 | return; |
698 | } | 743 | } |
744 | |||
699 | /* Send ACK if needed, after accounting for sent ID in fc->queue_n */ | 745 | /* Send ACK if needed, after accounting for sent ID in fc->queue_n */ |
700 | switch (type) | 746 | switch (type) |
701 | { | 747 | { |
@@ -758,30 +804,8 @@ conn_message_sent (void *cls, | |||
758 | } | 804 | } |
759 | LOG (GNUNET_ERROR_TYPE_DEBUG, "! message sent!\n"); | 805 | LOG (GNUNET_ERROR_TYPE_DEBUG, "! message sent!\n"); |
760 | 806 | ||
761 | if (NULL == c->perf) | 807 | update_perf (c, wait, size); |
762 | return GNUNET_NO; /* Only endpoints are interested in timing. */ | ||
763 | |||
764 | p = c->perf; | ||
765 | usecsperbyte = ((double) wait.rel_value_us) / size; | ||
766 | if (p->size == AVG_MSGS) | ||
767 | { | ||
768 | /* Array is full. Substract oldest value, add new one and store. */ | ||
769 | p->avg -= (p->usecsperbyte[p->idx] / AVG_MSGS); | ||
770 | p->usecsperbyte[p->idx] = usecsperbyte; | ||
771 | p->avg += (p->usecsperbyte[p->idx] / AVG_MSGS); | ||
772 | } | ||
773 | else | ||
774 | { | ||
775 | /* Array not yet full. Add current value to avg and store. */ | ||
776 | p->usecsperbyte[p->idx] = usecsperbyte; | ||
777 | p->avg *= p->size; | ||
778 | p->avg += p->usecsperbyte[p->idx]; | ||
779 | p->size++; | ||
780 | p->avg /= p->size; | ||
781 | } | ||
782 | p->idx = (p->idx + 1) % AVG_MSGS; | ||
783 | GCC_check_connections (); | 808 | GCC_check_connections (); |
784 | return GNUNET_NO; | ||
785 | } | 809 | } |
786 | 810 | ||
787 | 811 | ||
@@ -950,27 +974,26 @@ is_ooo_ok (uint32_t last_pid_recv, uint32_t ooo_pid, uint32_t ooo_bitmap) | |||
950 | * Is traffic coming from this sender 'FWD' traffic? | 974 | * Is traffic coming from this sender 'FWD' traffic? |
951 | * | 975 | * |
952 | * @param c Connection to check. | 976 | * @param c Connection to check. |
953 | * @param sender Peer identity of neighbor. | 977 | * @param sender Short peer identity of neighbor. |
954 | * | 978 | * |
955 | * @return #GNUNET_YES in case the sender is the 'prev' hop and therefore | 979 | * @return #GNUNET_YES in case the sender is the 'prev' hop and therefore |
956 | * the traffic is 'FWD'. | 980 | * the traffic is 'FWD'. |
957 | * #GNUNET_NO for BCK. | 981 | * #GNUNET_NO for BCK. |
958 | * #GNUNET_SYSERR for errors. | 982 | * #GNUNET_SYSERR for errors (sender isn't a hop in the connection). |
959 | */ | 983 | */ |
960 | static int | 984 | static int |
961 | is_fwd (const struct CadetConnection *c, | 985 | is_fwd (const struct CadetConnection *c, |
962 | const struct GNUNET_PeerIdentity *sender) | 986 | const struct CadetPeer *sender) |
963 | { | 987 | { |
964 | GNUNET_PEER_Id id; | 988 | GNUNET_PEER_Id id; |
965 | 989 | ||
966 | id = GNUNET_PEER_search (sender); | 990 | id = GCP_get_short_id (sender); |
967 | if (GCP_get_short_id (get_prev_hop (c)) == id) | 991 | if (GCP_get_short_id (get_prev_hop (c)) == id) |
968 | return GNUNET_YES; | 992 | return GNUNET_YES; |
969 | 993 | ||
970 | if (GCP_get_short_id (get_next_hop (c)) == id) | 994 | if (GCP_get_short_id (get_next_hop (c)) == id) |
971 | return GNUNET_NO; | 995 | return GNUNET_NO; |
972 | 996 | ||
973 | GNUNET_break (0); | ||
974 | return GNUNET_SYSERR; | 997 | return GNUNET_SYSERR; |
975 | } | 998 | } |
976 | 999 | ||
@@ -979,29 +1002,40 @@ is_fwd (const struct CadetConnection *c, | |||
979 | * Sends a CONNECTION ACK message in reponse to a received CONNECTION_CREATE | 1002 | * Sends a CONNECTION ACK message in reponse to a received CONNECTION_CREATE |
980 | * or a first CONNECTION_ACK directed to us. | 1003 | * or a first CONNECTION_ACK directed to us. |
981 | * | 1004 | * |
982 | * @param connection Connection to confirm. | 1005 | * @param c Connection to confirm. |
983 | * @param fwd Should we send it FWD? (root->dest) | 1006 | * @param fwd Should we send it FWD? (root->dest) |
984 | * (First (~SYNACK) goes BCK, second (~ACK) goes FWD) | 1007 | * (First (~SYNACK) goes BCK, second (~ACK) goes FWD) |
985 | */ | 1008 | */ |
986 | static void | 1009 | static void |
987 | send_connection_ack (struct CadetConnection *connection, int fwd) | 1010 | send_connection_ack (struct CadetConnection *c, int fwd) |
988 | { | 1011 | { |
1012 | struct GNUNET_CADET_ConnectionACK msg; | ||
989 | struct CadetTunnel *t; | 1013 | struct CadetTunnel *t; |
990 | size_t size = sizeof (struct GNUNET_CADET_ConnectionACK); | 1014 | size_t size = sizeof (struct GNUNET_CADET_ConnectionACK); |
991 | 1015 | ||
992 | GCC_check_connections (); | 1016 | GCC_check_connections (); |
993 | t = connection->t; | 1017 | t = c->t; |
994 | LOG (GNUNET_ERROR_TYPE_INFO, | 1018 | LOG (GNUNET_ERROR_TYPE_INFO, |
995 | "==> { C %s ACK} %19s on conn %s (%p) %s [%5u]\n", | 1019 | "==> { C %s ACK} %19s on conn %s (%p) %s [%5u]\n", |
996 | GC_f2s (!fwd), "", GCC_2s (connection), connection, GC_f2s (fwd), size); | 1020 | GC_f2s (!fwd), "", GCC_2s (c), c, GC_f2s (fwd), size); |
997 | GCP_queue_add (get_hop (connection, fwd), NULL, | 1021 | |
998 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, UINT16_MAX, 0, | 1022 | msg.header.size = htons (sizeof (struct GNUNET_CADET_ConnectionACK)); |
999 | size, connection, fwd, &conn_message_sent, NULL); | 1023 | msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK); |
1000 | connection->pending_messages++; | 1024 | msg.cid = c->id; |
1025 | |||
1026 | GNUNET_assert (NULL == c->maintenance_q); | ||
1027 | c->maintenance_q = GCP_send (get_hop (c, fwd), &msg.header, | ||
1028 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, 0, | ||
1029 | c, fwd, | ||
1030 | &conn_message_sent, NULL); | ||
1031 | LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P+ %p %u (conn`ACK)\n", | ||
1032 | c, c->pending_messages); | ||
1033 | c->pending_messages++; | ||
1034 | |||
1001 | if (CADET_TUNNEL_NEW == GCT_get_cstate (t)) | 1035 | if (CADET_TUNNEL_NEW == GCT_get_cstate (t)) |
1002 | GCT_change_cstate (t, CADET_TUNNEL_WAITING); | 1036 | GCT_change_cstate (t, CADET_TUNNEL_WAITING); |
1003 | if (CADET_CONNECTION_READY != connection->state) | 1037 | if (CADET_CONNECTION_READY != c->state) |
1004 | connection_change_state (connection, CADET_CONNECTION_SENT); | 1038 | connection_change_state (c, CADET_CONNECTION_SENT); |
1005 | GCC_check_connections (); | 1039 | GCC_check_connections (); |
1006 | } | 1040 | } |
1007 | 1041 | ||
@@ -1042,17 +1076,15 @@ send_broken (struct CadetConnection *c, | |||
1042 | * @param connection_id Connection ID. | 1076 | * @param connection_id Connection ID. |
1043 | * @param id1 Peer that has disconnected, probably local peer. | 1077 | * @param id1 Peer that has disconnected, probably local peer. |
1044 | * @param id2 Peer that has disconnected can be NULL if unknown. | 1078 | * @param id2 Peer that has disconnected can be NULL if unknown. |
1045 | * @param peer Peer to notify (neighbor who sent the connection). | 1079 | * @param neighbor Peer to notify (neighbor who sent the connection). |
1046 | */ | 1080 | */ |
1047 | static void | 1081 | static void |
1048 | send_broken_unknown (const struct GNUNET_CADET_Hash *connection_id, | 1082 | send_broken_unknown (const struct GNUNET_CADET_Hash *connection_id, |
1049 | const struct GNUNET_PeerIdentity *id1, | 1083 | const struct GNUNET_PeerIdentity *id1, |
1050 | const struct GNUNET_PeerIdentity *id2, | 1084 | const struct GNUNET_PeerIdentity *id2, |
1051 | const struct GNUNET_PeerIdentity *peer_id) | 1085 | struct CadetPeer *neighbor) |
1052 | { | 1086 | { |
1053 | struct GNUNET_CADET_ConnectionBroken *msg; | 1087 | struct GNUNET_CADET_ConnectionBroken *msg; |
1054 | struct CadetPeerQueue *q; | ||
1055 | struct CadetPeer *neighbor; | ||
1056 | 1088 | ||
1057 | GCC_check_connections (); | 1089 | GCC_check_connections (); |
1058 | LOG (GNUNET_ERROR_TYPE_INFO, "--> BROKEN on unknown connection %s\n", | 1090 | LOG (GNUNET_ERROR_TYPE_INFO, "--> BROKEN on unknown connection %s\n", |
@@ -1067,14 +1099,10 @@ send_broken_unknown (const struct GNUNET_CADET_Hash *connection_id, | |||
1067 | msg->peer2 = *id2; | 1099 | msg->peer2 = *id2; |
1068 | else | 1100 | else |
1069 | memset (&msg->peer2, 0, sizeof (msg->peer2)); | 1101 | memset (&msg->peer2, 0, sizeof (msg->peer2)); |
1070 | neighbor = GCP_get (peer_id, GNUNET_NO); /* We MUST know neighbor. */ | 1102 | GNUNET_assert (NULL != GCP_send (neighbor, &msg->header, |
1071 | GNUNET_assert (NULL != neighbor); | 1103 | UINT16_MAX, 2, |
1072 | q = GCP_queue_add (neighbor, msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, | 1104 | NULL, GNUNET_SYSERR, /* connection, fwd */ |
1073 | UINT16_MAX, 2, | 1105 | NULL, NULL)); /* continuation */ |
1074 | sizeof (struct GNUNET_CADET_ConnectionBroken), | ||
1075 | NULL, GNUNET_SYSERR, /* connection, fwd */ | ||
1076 | NULL, NULL); /* continuation */ | ||
1077 | GNUNET_assert (NULL != q); | ||
1078 | GCC_check_connections (); | 1106 | GCC_check_connections (); |
1079 | } | 1107 | } |
1080 | 1108 | ||
@@ -1311,38 +1339,6 @@ schedule_next_keepalive (struct CadetConnection *c, int fwd) | |||
1311 | 1339 | ||
1312 | 1340 | ||
1313 | /** | 1341 | /** |
1314 | * @brief Re-initiate traffic on this connection if necessary. | ||
1315 | * | ||
1316 | * Check if there is traffic queued towards this peer | ||
1317 | * and the core transmit handle is NULL (traffic was stalled). | ||
1318 | * If so, call core tmt rdy. | ||
1319 | * | ||
1320 | * @param c Connection on which initiate traffic. | ||
1321 | * @param fwd Is this about fwd traffic? | ||
1322 | */ | ||
1323 | static void | ||
1324 | connection_unlock_queue (struct CadetConnection *c, int fwd) | ||
1325 | { | ||
1326 | struct CadetPeer *peer; | ||
1327 | |||
1328 | GCC_check_connections (); | ||
1329 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1330 | "connection_unlock_queue %s on %s\n", | ||
1331 | GC_f2s (fwd), GCC_2s (c)); | ||
1332 | |||
1333 | if (GCC_is_terminal (c, fwd)) | ||
1334 | { | ||
1335 | LOG (GNUNET_ERROR_TYPE_DEBUG, " is terminal, can unlock!\n"); | ||
1336 | return; | ||
1337 | } | ||
1338 | |||
1339 | peer = get_hop (c, fwd); | ||
1340 | GCP_queue_unlock (peer, c); | ||
1341 | GCC_check_connections (); | ||
1342 | } | ||
1343 | |||
1344 | |||
1345 | /** | ||
1346 | * Cancel all transmissions that belong to a certain connection. | 1342 | * Cancel all transmissions that belong to a certain connection. |
1347 | * | 1343 | * |
1348 | * If the connection is scheduled for destruction and no more messages are left, | 1344 | * If the connection is scheduled for destruction and no more messages are left, |
@@ -1356,7 +1352,6 @@ connection_cancel_queues (struct CadetConnection *c, | |||
1356 | int fwd) | 1352 | int fwd) |
1357 | { | 1353 | { |
1358 | struct CadetFlowControl *fc; | 1354 | struct CadetFlowControl *fc; |
1359 | struct CadetPeer *peer; | ||
1360 | 1355 | ||
1361 | GCC_check_connections (); | 1356 | GCC_check_connections (); |
1362 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 1357 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
@@ -1380,8 +1375,6 @@ connection_cancel_queues (struct CadetConnection *c, | |||
1380 | GCC_cancel (fc->poll_msg); | 1375 | GCC_cancel (fc->poll_msg); |
1381 | LOG (GNUNET_ERROR_TYPE_DEBUG, " cancelled POLL msg for fc %p\n", fc); | 1376 | LOG (GNUNET_ERROR_TYPE_DEBUG, " cancelled POLL msg for fc %p\n", fc); |
1382 | } | 1377 | } |
1383 | peer = get_hop (c, fwd); | ||
1384 | GCP_queue_cancel (peer, c); | ||
1385 | GCC_check_connections (); | 1378 | GCC_check_connections (); |
1386 | } | 1379 | } |
1387 | 1380 | ||
@@ -1471,53 +1464,6 @@ connection_poll (void *cls) | |||
1471 | 1464 | ||
1472 | 1465 | ||
1473 | /** | 1466 | /** |
1474 | * Resend all queued messages for a connection on other connections of the | ||
1475 | * same tunnel, if possible. The connection WILL BE DESTROYED by this function. | ||
1476 | * | ||
1477 | * @param c Connection whose messages to resend. | ||
1478 | * @param fwd Resend fwd messages? | ||
1479 | */ | ||
1480 | static void | ||
1481 | resend_messages_and_destroy (struct CadetConnection *c, int fwd) | ||
1482 | { | ||
1483 | struct GNUNET_MessageHeader *out_msg; | ||
1484 | struct CadetTunnel *t = c->t; | ||
1485 | struct CadetPeer *neighbor; | ||
1486 | unsigned int pending; | ||
1487 | int destroyed; | ||
1488 | |||
1489 | GCC_check_connections (); | ||
1490 | mark_destroyed (c); | ||
1491 | |||
1492 | destroyed = GNUNET_NO; | ||
1493 | neighbor = get_hop (c, fwd); | ||
1494 | pending = c->pending_messages; | ||
1495 | |||
1496 | while (NULL != (out_msg = GCP_connection_pop (neighbor, c, &destroyed))) | ||
1497 | { | ||
1498 | if (NULL != t) | ||
1499 | GCT_resend_message (out_msg, t); | ||
1500 | GNUNET_free (out_msg); | ||
1501 | } | ||
1502 | |||
1503 | /* All pending messages should have been popped, | ||
1504 | * and the connection destroyed by the continuation. | ||
1505 | */ | ||
1506 | if (GNUNET_YES != destroyed) | ||
1507 | { | ||
1508 | if (0 != pending) | ||
1509 | { | ||
1510 | GNUNET_break (0); | ||
1511 | GCC_debug (c, GNUNET_ERROR_TYPE_ERROR); | ||
1512 | if (NULL != t) GCT_debug (t, GNUNET_ERROR_TYPE_ERROR); | ||
1513 | } | ||
1514 | GCC_destroy (c); | ||
1515 | } | ||
1516 | GCC_check_connections (); | ||
1517 | } | ||
1518 | |||
1519 | |||
1520 | /** | ||
1521 | * Generic connection timeout implementation. | 1467 | * Generic connection timeout implementation. |
1522 | * | 1468 | * |
1523 | * Timeout function due to lack of keepalive/traffic from an endpoint. | 1469 | * Timeout function due to lack of keepalive/traffic from an endpoint. |
@@ -1529,10 +1475,7 @@ resend_messages_and_destroy (struct CadetConnection *c, int fwd) | |||
1529 | static void | 1475 | static void |
1530 | connection_timeout (struct CadetConnection *c, int fwd) | 1476 | connection_timeout (struct CadetConnection *c, int fwd) |
1531 | { | 1477 | { |
1532 | struct CadetFlowControl *reverse_fc; | ||
1533 | |||
1534 | GCC_check_connections (); | 1478 | GCC_check_connections (); |
1535 | reverse_fc = fwd ? &c->bck_fc : &c->fwd_fc; | ||
1536 | 1479 | ||
1537 | LOG (GNUNET_ERROR_TYPE_INFO, | 1480 | LOG (GNUNET_ERROR_TYPE_INFO, |
1538 | "Connection %s %s timed out. Destroying.\n", | 1481 | "Connection %s %s timed out. Destroying.\n", |
@@ -1546,17 +1489,13 @@ connection_timeout (struct CadetConnection *c, int fwd) | |||
1546 | return; | 1489 | return; |
1547 | } | 1490 | } |
1548 | 1491 | ||
1549 | /* If dest, salvage queued traffic. */ | 1492 | /* If dest, send "broken" notification. */ |
1550 | if (GCC_is_terminal (c, fwd)) | 1493 | if (GCC_is_terminal (c, fwd)) |
1551 | { | 1494 | { |
1552 | const struct GNUNET_PeerIdentity *next_hop; | 1495 | struct CadetPeer *next_hop; |
1553 | 1496 | ||
1554 | next_hop = GCP_get_id (fwd ? get_prev_hop (c) : get_next_hop (c)); | 1497 | next_hop = fwd ? get_prev_hop (c) : get_next_hop (c); |
1555 | send_broken_unknown (&c->id, &my_full_id, NULL, next_hop); | 1498 | send_broken_unknown (&c->id, &my_full_id, NULL, next_hop); |
1556 | if (0 < reverse_fc->queue_n) | ||
1557 | resend_messages_and_destroy (c, !fwd); | ||
1558 | GCC_check_connections (); | ||
1559 | return; | ||
1560 | } | 1499 | } |
1561 | 1500 | ||
1562 | GCC_destroy (c); | 1501 | GCC_destroy (c); |
@@ -1907,13 +1846,13 @@ add_to_peer (struct CadetConnection *c, | |||
1907 | * Log receipt of message on stderr (INFO level). | 1846 | * Log receipt of message on stderr (INFO level). |
1908 | * | 1847 | * |
1909 | * @param message Message received. | 1848 | * @param message Message received. |
1910 | * @param peer Peer who sent the message. | 1849 | * @param peer Peer who sent the message. |
1911 | * @param hash Connection ID. | 1850 | * @param conn_id Connection ID of the message. |
1912 | */ | 1851 | */ |
1913 | static void | 1852 | static void |
1914 | log_message (const struct GNUNET_MessageHeader *message, | 1853 | log_message (const struct GNUNET_MessageHeader *message, |
1915 | const struct GNUNET_PeerIdentity *peer, | 1854 | const struct CadetPeer *peer, |
1916 | const struct GNUNET_CADET_Hash *hash) | 1855 | const struct GNUNET_CADET_Hash *conn_id) |
1917 | { | 1856 | { |
1918 | uint16_t size; | 1857 | uint16_t size; |
1919 | uint16_t type; | 1858 | uint16_t type; |
@@ -1933,8 +1872,8 @@ log_message (const struct GNUNET_MessageHeader *message, | |||
1933 | arrow = "--"; | 1872 | arrow = "--"; |
1934 | } | 1873 | } |
1935 | LOG (GNUNET_ERROR_TYPE_INFO, "<%s %s on conn %s from %s, %6u bytes\n", | 1874 | LOG (GNUNET_ERROR_TYPE_INFO, "<%s %s on conn %s from %s, %6u bytes\n", |
1936 | arrow, GC_m2s (type), GNUNET_h2s (GC_h2hc (hash)), | 1875 | arrow, GC_m2s (type), GNUNET_h2s (GC_h2hc (conn_id)), |
1937 | GNUNET_i2s (peer), (unsigned int) size); | 1876 | GCP_2s(peer), (unsigned int) size); |
1938 | } | 1877 | } |
1939 | 1878 | ||
1940 | /******************************************************************************/ | 1879 | /******************************************************************************/ |
@@ -1942,22 +1881,17 @@ log_message (const struct GNUNET_MessageHeader *message, | |||
1942 | /******************************************************************************/ | 1881 | /******************************************************************************/ |
1943 | 1882 | ||
1944 | /** | 1883 | /** |
1945 | * Core handler for connection creation. | 1884 | * Handler for connection creation. |
1946 | * | 1885 | * |
1947 | * @param cls Closure (unused). | 1886 | * @param peer Message sender (neighbor). |
1948 | * @param peer Sender (neighbor). | 1887 | * @param msg Message itself. |
1949 | * @param message Message. | ||
1950 | * @return #GNUNET_OK to keep the connection open, | ||
1951 | * #GNUNET_SYSERR to close it (signal serious error) | ||
1952 | */ | 1888 | */ |
1953 | int | 1889 | void |
1954 | GCC_handle_create (void *cls, | 1890 | GCC_handle_create (struct CadetPeer *peer, |
1955 | const struct GNUNET_PeerIdentity *peer, | 1891 | const struct GNUNET_CADET_ConnectionCreate *msg) |
1956 | const struct GNUNET_MessageHeader *message) | ||
1957 | { | 1892 | { |
1958 | struct GNUNET_CADET_ConnectionCreate *msg; | 1893 | const struct GNUNET_CADET_Hash *cid; |
1959 | struct GNUNET_PeerIdentity *id; | 1894 | struct GNUNET_PeerIdentity *id; |
1960 | struct GNUNET_CADET_Hash *cid; | ||
1961 | struct CadetPeerPath *path; | 1895 | struct CadetPeerPath *path; |
1962 | struct CadetPeer *dest_peer; | 1896 | struct CadetPeer *dest_peer; |
1963 | struct CadetPeer *orig_peer; | 1897 | struct CadetPeer *orig_peer; |
@@ -1966,38 +1900,26 @@ GCC_handle_create (void *cls, | |||
1966 | uint16_t size; | 1900 | uint16_t size; |
1967 | 1901 | ||
1968 | GCC_check_connections (); | 1902 | GCC_check_connections (); |
1969 | /* Check size */ | 1903 | size = ntohs (msg->header.size); |
1970 | size = ntohs (message->size); | ||
1971 | if (size < sizeof (struct GNUNET_CADET_ConnectionCreate)) | ||
1972 | { | ||
1973 | GNUNET_break_op (0); | ||
1974 | return GNUNET_OK; | ||
1975 | } | ||
1976 | 1904 | ||
1977 | /* Calculate hops */ | 1905 | /* Calculate hops */ |
1978 | size -= sizeof (struct GNUNET_CADET_ConnectionCreate); | 1906 | size -= sizeof (struct GNUNET_CADET_ConnectionCreate); |
1979 | if (size % sizeof (struct GNUNET_PeerIdentity)) | ||
1980 | { | ||
1981 | GNUNET_break_op (0); | ||
1982 | return GNUNET_OK; | ||
1983 | } | ||
1984 | if (0 != size % sizeof (struct GNUNET_PeerIdentity)) | 1907 | if (0 != size % sizeof (struct GNUNET_PeerIdentity)) |
1985 | { | 1908 | { |
1986 | GNUNET_break_op (0); | 1909 | GNUNET_break_op (0); |
1987 | return GNUNET_OK; | 1910 | return; |
1988 | } | 1911 | } |
1989 | size /= sizeof (struct GNUNET_PeerIdentity); | 1912 | size /= sizeof (struct GNUNET_PeerIdentity); |
1990 | if (1 > size) | 1913 | if (1 > size) |
1991 | { | 1914 | { |
1992 | GNUNET_break_op (0); | 1915 | GNUNET_break_op (0); |
1993 | return GNUNET_OK; | 1916 | return; |
1994 | } | 1917 | } |
1995 | LOG (GNUNET_ERROR_TYPE_DEBUG, " path has %u hops.\n", size); | 1918 | LOG (GNUNET_ERROR_TYPE_DEBUG, " path has %u hops.\n", size); |
1996 | 1919 | ||
1997 | /* Get parameters */ | 1920 | /* Get parameters */ |
1998 | msg = (struct GNUNET_CADET_ConnectionCreate *) message; | ||
1999 | cid = &msg->cid; | 1921 | cid = &msg->cid; |
2000 | log_message (message, peer, cid); | 1922 | log_message (&msg->header, peer, cid); |
2001 | id = (struct GNUNET_PeerIdentity *) &msg[1]; | 1923 | id = (struct GNUNET_PeerIdentity *) &msg[1]; |
2002 | LOG (GNUNET_ERROR_TYPE_DEBUG, " origin: %s\n", GNUNET_i2s (id)); | 1924 | LOG (GNUNET_ERROR_TYPE_DEBUG, " origin: %s\n", GNUNET_i2s (id)); |
2003 | 1925 | ||
@@ -2012,16 +1934,15 @@ GCC_handle_create (void *cls, | |||
2012 | /* Path was malformed, probably our own ID was not in it. */ | 1934 | /* Path was malformed, probably our own ID was not in it. */ |
2013 | GNUNET_STATISTICS_update (stats, "# malformed paths", 1, GNUNET_NO); | 1935 | GNUNET_STATISTICS_update (stats, "# malformed paths", 1, GNUNET_NO); |
2014 | GNUNET_break_op (0); | 1936 | GNUNET_break_op (0); |
2015 | return GNUNET_OK; | 1937 | return; |
2016 | } | 1938 | } |
2017 | |||
2018 | if (0 == own_pos) | 1939 | if (0 == own_pos) |
2019 | { | 1940 | { |
2020 | /* We received this request from a neighbor, we cannot be origin */ | 1941 | /* We received this request from a neighbor, we cannot be origin */ |
2021 | GNUNET_STATISTICS_update (stats, "# fake paths", 1, GNUNET_NO); | 1942 | GNUNET_STATISTICS_update (stats, "# fake paths", 1, GNUNET_NO); |
2022 | GNUNET_break_op (0); | 1943 | GNUNET_break_op (0); |
2023 | path_destroy (path); | 1944 | path_destroy (path); |
2024 | return GNUNET_OK; | 1945 | return; |
2025 | } | 1946 | } |
2026 | 1947 | ||
2027 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Own position: %u\n", own_pos); | 1948 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Own position: %u\n", own_pos); |
@@ -2035,14 +1956,14 @@ GCC_handle_create (void *cls, | |||
2035 | GNUNET_break (0); | 1956 | GNUNET_break (0); |
2036 | path_destroy (path); | 1957 | path_destroy (path); |
2037 | GCC_check_connections (); | 1958 | GCC_check_connections (); |
2038 | return GNUNET_OK; | 1959 | return; |
2039 | } | 1960 | } |
2040 | send_broken_unknown (cid, &my_full_id, | 1961 | send_broken_unknown (cid, &my_full_id, |
2041 | GNUNET_PEER_resolve2 (path->peers[own_pos + 1]), | 1962 | GNUNET_PEER_resolve2 (path->peers[own_pos + 1]), |
2042 | peer); | 1963 | peer); |
2043 | path_destroy (path); | 1964 | path_destroy (path); |
2044 | GCC_check_connections (); | 1965 | GCC_check_connections (); |
2045 | return GNUNET_OK; | 1966 | return; |
2046 | } | 1967 | } |
2047 | GCP_add_path_to_all (path, GNUNET_NO); | 1968 | GCP_add_path_to_all (path, GNUNET_NO); |
2048 | connection_reset_timeout (c, GNUNET_YES); | 1969 | connection_reset_timeout (c, GNUNET_YES); |
@@ -2092,40 +2013,32 @@ GCC_handle_create (void *cls, | |||
2092 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Retransmitting.\n"); | 2013 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Retransmitting.\n"); |
2093 | GCP_add_path (dest_peer, path_duplicate (path), GNUNET_NO); | 2014 | GCP_add_path (dest_peer, path_duplicate (path), GNUNET_NO); |
2094 | GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_NO); | 2015 | GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_NO); |
2095 | GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, | 2016 | GNUNET_assert (NULL == |
2096 | GNUNET_YES, GNUNET_YES, | 2017 | GCC_send_prebuilt_message (&msg->header, 0, 0, c, |
2097 | NULL, NULL)); | 2018 | GNUNET_YES, GNUNET_YES, |
2019 | NULL, NULL)); | ||
2098 | } | 2020 | } |
2099 | path_destroy (path); | 2021 | path_destroy (path); |
2100 | GCC_check_connections (); | 2022 | GCC_check_connections (); |
2101 | return GNUNET_OK; | ||
2102 | } | 2023 | } |
2103 | 2024 | ||
2104 | 2025 | ||
2105 | /** | 2026 | /** |
2106 | * Core handler for path confirmations. | 2027 | * Handler for connection confirmations. |
2107 | * | 2028 | * |
2108 | * @param cls closure | 2029 | * @param peer Message sender (neighbor). |
2109 | * @param message message | 2030 | * @param msg Message itself. |
2110 | * @param peer peer identity this notification is about | ||
2111 | * @return #GNUNET_OK to keep the connection open, | ||
2112 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2113 | */ | 2031 | */ |
2114 | int | 2032 | void |
2115 | GCC_handle_confirm (void *cls, | 2033 | GCC_handle_confirm (struct CadetPeer *peer, |
2116 | const struct GNUNET_PeerIdentity *peer, | 2034 | const struct GNUNET_CADET_ConnectionACK *msg) |
2117 | const struct GNUNET_MessageHeader *message) | ||
2118 | { | 2035 | { |
2119 | struct GNUNET_CADET_ConnectionACK *msg; | ||
2120 | struct CadetConnection *c; | 2036 | struct CadetConnection *c; |
2121 | struct CadetPeerPath *p; | ||
2122 | struct CadetPeer *pi; | ||
2123 | enum CadetConnectionState oldstate; | 2037 | enum CadetConnectionState oldstate; |
2124 | int fwd; | 2038 | int fwd; |
2125 | 2039 | ||
2126 | GCC_check_connections (); | 2040 | GCC_check_connections (); |
2127 | msg = (struct GNUNET_CADET_ConnectionACK *) message; | 2041 | log_message (&msg->header, peer, &msg->cid); |
2128 | log_message (message, peer, &msg->cid); | ||
2129 | c = connection_get (&msg->cid); | 2042 | c = connection_get (&msg->cid); |
2130 | if (NULL == c) | 2043 | if (NULL == c) |
2131 | { | 2044 | { |
@@ -2135,30 +2048,30 @@ GCC_handle_confirm (void *cls, | |||
2135 | " don't know the connection!\n"); | 2048 | " don't know the connection!\n"); |
2136 | send_broken_unknown (&msg->cid, &my_full_id, NULL, peer); | 2049 | send_broken_unknown (&msg->cid, &my_full_id, NULL, peer); |
2137 | GCC_check_connections (); | 2050 | GCC_check_connections (); |
2138 | return GNUNET_OK; | 2051 | return; |
2139 | } | 2052 | } |
2140 | |||
2141 | if (GNUNET_NO != c->destroy) | 2053 | if (GNUNET_NO != c->destroy) |
2142 | { | 2054 | { |
2143 | GNUNET_assert (CADET_CONNECTION_DESTROYED == c->state); | 2055 | GNUNET_assert (CADET_CONNECTION_DESTROYED == c->state); |
2056 | GNUNET_STATISTICS_update (stats, "# control on dying connection", | ||
2057 | 1, GNUNET_NO); | ||
2144 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 2058 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2145 | "connection %s being destroyed, ignoring confirm\n", | 2059 | "connection %s being destroyed, ignoring confirm\n", |
2146 | GCC_2s (c)); | 2060 | GCC_2s (c)); |
2147 | GCC_check_connections (); | 2061 | GCC_check_connections (); |
2148 | return GNUNET_OK; | 2062 | return; |
2149 | } | 2063 | } |
2150 | 2064 | ||
2151 | oldstate = c->state; | 2065 | oldstate = c->state; |
2152 | LOG (GNUNET_ERROR_TYPE_DEBUG, " via peer %s\n", GNUNET_i2s (peer)); | 2066 | LOG (GNUNET_ERROR_TYPE_DEBUG, " via peer %s\n", GCP_2s (peer)); |
2153 | pi = GCP_get (peer, GNUNET_YES); | 2067 | if (get_next_hop (c) == peer) |
2154 | if (get_next_hop (c) == pi) | ||
2155 | { | 2068 | { |
2156 | LOG (GNUNET_ERROR_TYPE_DEBUG, " SYNACK\n"); | 2069 | LOG (GNUNET_ERROR_TYPE_DEBUG, " SYNACK\n"); |
2157 | fwd = GNUNET_NO; | 2070 | fwd = GNUNET_NO; |
2158 | if (CADET_CONNECTION_SENT == oldstate) | 2071 | if (CADET_CONNECTION_SENT == oldstate) |
2159 | connection_change_state (c, CADET_CONNECTION_ACK); | 2072 | connection_change_state (c, CADET_CONNECTION_ACK); |
2160 | } | 2073 | } |
2161 | else if (get_prev_hop (c) == pi) | 2074 | else if (get_prev_hop (c) == peer) |
2162 | { | 2075 | { |
2163 | LOG (GNUNET_ERROR_TYPE_DEBUG, " FINAL ACK\n"); | 2076 | LOG (GNUNET_ERROR_TYPE_DEBUG, " FINAL ACK\n"); |
2164 | fwd = GNUNET_YES; | 2077 | fwd = GNUNET_YES; |
@@ -2166,17 +2079,18 @@ GCC_handle_confirm (void *cls, | |||
2166 | } | 2079 | } |
2167 | else | 2080 | else |
2168 | { | 2081 | { |
2082 | GNUNET_STATISTICS_update (stats, "# control on connection from wrong peer", | ||
2083 | 1, GNUNET_NO); | ||
2169 | GNUNET_break_op (0); | 2084 | GNUNET_break_op (0); |
2170 | return GNUNET_OK; | 2085 | return; |
2171 | } | 2086 | } |
2172 | 2087 | ||
2173 | connection_reset_timeout (c, fwd); | 2088 | connection_reset_timeout (c, fwd); |
2174 | 2089 | ||
2175 | /* Add path to peers? */ | 2090 | /* Add path to peers? */ |
2176 | p = c->path; | 2091 | if (NULL != c->path) |
2177 | if (NULL != p) | ||
2178 | { | 2092 | { |
2179 | GCP_add_path_to_all (p, GNUNET_YES); | 2093 | GCP_add_path_to_all (c->path, GNUNET_YES); |
2180 | } | 2094 | } |
2181 | else | 2095 | else |
2182 | { | 2096 | { |
@@ -2184,12 +2098,12 @@ GCC_handle_confirm (void *cls, | |||
2184 | } | 2098 | } |
2185 | 2099 | ||
2186 | /* Message for us as creator? */ | 2100 | /* Message for us as creator? */ |
2187 | if (GCC_is_origin (c, GNUNET_YES)) | 2101 | if (GNUNET_YES == GCC_is_origin (c, GNUNET_YES)) |
2188 | { | 2102 | { |
2189 | if (GNUNET_NO != fwd) | 2103 | if (GNUNET_NO != fwd) |
2190 | { | 2104 | { |
2191 | GNUNET_break_op (0); | 2105 | GNUNET_break (0); |
2192 | return GNUNET_OK; | 2106 | return; |
2193 | } | 2107 | } |
2194 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Connection (SYN)ACK for us!\n"); | 2108 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Connection (SYN)ACK for us!\n"); |
2195 | 2109 | ||
@@ -2197,7 +2111,7 @@ GCC_handle_confirm (void *cls, | |||
2197 | if (CADET_CONNECTION_SENT == oldstate) | 2111 | if (CADET_CONNECTION_SENT == oldstate) |
2198 | connection_reset_timeout (c, GNUNET_YES); | 2112 | connection_reset_timeout (c, GNUNET_YES); |
2199 | 2113 | ||
2200 | /* Change connection state */ | 2114 | /* Change connection state, send ACK */ |
2201 | connection_change_state (c, CADET_CONNECTION_READY); | 2115 | connection_change_state (c, CADET_CONNECTION_READY); |
2202 | send_connection_ack (c, GNUNET_YES); | 2116 | send_connection_ack (c, GNUNET_YES); |
2203 | 2117 | ||
@@ -2205,7 +2119,7 @@ GCC_handle_confirm (void *cls, | |||
2205 | if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t)) | 2119 | if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t)) |
2206 | GCT_change_cstate (c->t, CADET_TUNNEL_READY); | 2120 | GCT_change_cstate (c->t, CADET_TUNNEL_READY); |
2207 | GCC_check_connections (); | 2121 | GCC_check_connections (); |
2208 | return GNUNET_OK; | 2122 | return; |
2209 | } | 2123 | } |
2210 | 2124 | ||
2211 | /* Message for us as destination? */ | 2125 | /* Message for us as destination? */ |
@@ -2213,8 +2127,8 @@ GCC_handle_confirm (void *cls, | |||
2213 | { | 2127 | { |
2214 | if (GNUNET_YES != fwd) | 2128 | if (GNUNET_YES != fwd) |
2215 | { | 2129 | { |
2216 | GNUNET_break_op (0); | 2130 | GNUNET_break (0); |
2217 | return GNUNET_OK; | 2131 | return; |
2218 | } | 2132 | } |
2219 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Connection ACK for us!\n"); | 2133 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Connection ACK for us!\n"); |
2220 | 2134 | ||
@@ -2226,41 +2140,34 @@ GCC_handle_confirm (void *cls, | |||
2226 | if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t)) | 2140 | if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t)) |
2227 | GCT_change_cstate (c->t, CADET_TUNNEL_READY); | 2141 | GCT_change_cstate (c->t, CADET_TUNNEL_READY); |
2228 | GCC_check_connections (); | 2142 | GCC_check_connections (); |
2229 | return GNUNET_OK; | 2143 | return; |
2230 | } | 2144 | } |
2231 | 2145 | ||
2232 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not for us, retransmitting...\n"); | 2146 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not for us, retransmitting...\n"); |
2233 | GNUNET_assert (NULL == | 2147 | GNUNET_assert (NULL == |
2234 | GCC_send_prebuilt_message (message, 0, 0, c, fwd, | 2148 | GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, |
2235 | GNUNET_YES, NULL, NULL)); | 2149 | GNUNET_YES, NULL, NULL)); |
2236 | GCC_check_connections (); | 2150 | GCC_check_connections (); |
2237 | return GNUNET_OK; | 2151 | return; |
2238 | } | 2152 | } |
2239 | 2153 | ||
2240 | 2154 | ||
2241 | /** | 2155 | /** |
2242 | * Core handler for notifications of broken connections. | 2156 | * Handler for notifications of broken connections. |
2243 | * | 2157 | * |
2244 | * @param cls Closure (unused). | 2158 | * @param peer Message sender (neighbor). |
2245 | * @param id Peer identity of sending neighbor. | 2159 | * @param msg Message itself. |
2246 | * @param message Message. | ||
2247 | * @return #GNUNET_OK to keep the connection open, | ||
2248 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2249 | */ | 2160 | */ |
2250 | int | 2161 | void |
2251 | GCC_handle_broken (void* cls, | 2162 | GCC_handle_broken (struct CadetPeer *peer, |
2252 | const struct GNUNET_PeerIdentity* id, | 2163 | const struct GNUNET_CADET_ConnectionBroken *msg) |
2253 | const struct GNUNET_MessageHeader* message) | ||
2254 | { | 2164 | { |
2255 | struct GNUNET_CADET_ConnectionBroken *msg; | ||
2256 | struct CadetConnection *c; | 2165 | struct CadetConnection *c; |
2257 | struct CadetTunnel *t; | 2166 | struct CadetTunnel *t; |
2258 | int pending; | ||
2259 | int fwd; | 2167 | int fwd; |
2260 | 2168 | ||
2261 | GCC_check_connections (); | 2169 | GCC_check_connections (); |
2262 | msg = (struct GNUNET_CADET_ConnectionBroken *) message; | 2170 | log_message (&msg->header, peer, &msg->cid); |
2263 | log_message (message, id, &msg->cid); | ||
2264 | LOG (GNUNET_ERROR_TYPE_DEBUG, " regarding %s\n", | 2171 | LOG (GNUNET_ERROR_TYPE_DEBUG, " regarding %s\n", |
2265 | GNUNET_i2s (&msg->peer1)); | 2172 | GNUNET_i2s (&msg->peer1)); |
2266 | LOG (GNUNET_ERROR_TYPE_DEBUG, " regarding %s\n", | 2173 | LOG (GNUNET_ERROR_TYPE_DEBUG, " regarding %s\n", |
@@ -2269,13 +2176,21 @@ GCC_handle_broken (void* cls, | |||
2269 | if (NULL == c) | 2176 | if (NULL == c) |
2270 | { | 2177 | { |
2271 | LOG (GNUNET_ERROR_TYPE_DEBUG, " duplicate CONNECTION_BROKEN\n"); | 2178 | LOG (GNUNET_ERROR_TYPE_DEBUG, " duplicate CONNECTION_BROKEN\n"); |
2179 | GNUNET_STATISTICS_update (stats, "# duplicate CONNECTION_BROKEN", | ||
2180 | 1, GNUNET_NO); | ||
2272 | GCC_check_connections (); | 2181 | GCC_check_connections (); |
2273 | return GNUNET_OK; | 2182 | return; |
2274 | } | 2183 | } |
2275 | 2184 | ||
2276 | t = c->t; | 2185 | t = c->t; |
2277 | 2186 | ||
2278 | fwd = is_fwd (c, id); | 2187 | fwd = is_fwd (c, peer); |
2188 | if (GNUNET_SYSERR == fwd) | ||
2189 | { | ||
2190 | GNUNET_break_op (0); | ||
2191 | GCC_check_connections (); | ||
2192 | return; | ||
2193 | } | ||
2279 | mark_destroyed (c); | 2194 | mark_destroyed (c); |
2280 | if (GCC_is_terminal (c, fwd)) | 2195 | if (GCC_is_terminal (c, fwd)) |
2281 | { | 2196 | { |
@@ -2286,7 +2201,7 @@ GCC_handle_broken (void* cls, | |||
2286 | /* A terminal connection should not have 't' set to NULL. */ | 2201 | /* A terminal connection should not have 't' set to NULL. */ |
2287 | GNUNET_break (0); | 2202 | GNUNET_break (0); |
2288 | GCC_debug (c, GNUNET_ERROR_TYPE_ERROR); | 2203 | GCC_debug (c, GNUNET_ERROR_TYPE_ERROR); |
2289 | return GNUNET_OK; | 2204 | return; |
2290 | } | 2205 | } |
2291 | endpoint = GCP_get_short (c->path->peers[c->path->length - 1], GNUNET_YES); | 2206 | endpoint = GCP_get_short (c->path->peers[c->path->length - 1], GNUNET_YES); |
2292 | if (2 < c->path->length) | 2207 | if (2 < c->path->length) |
@@ -2297,44 +2212,35 @@ GCC_handle_broken (void* cls, | |||
2297 | GCT_remove_connection (t, c); | 2212 | GCT_remove_connection (t, c); |
2298 | c->t = NULL; | 2213 | c->t = NULL; |
2299 | 2214 | ||
2300 | pending = c->pending_messages; | 2215 | GCC_destroy (c); |
2301 | if (0 < pending) | ||
2302 | resend_messages_and_destroy (c, !fwd); | ||
2303 | else | ||
2304 | GCC_destroy (c); | ||
2305 | } | 2216 | } |
2306 | else | 2217 | else |
2307 | { | 2218 | { |
2308 | GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd, | 2219 | GNUNET_assert (NULL == |
2309 | GNUNET_YES, NULL, NULL)); | 2220 | GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, |
2221 | GNUNET_YES, NULL, NULL)); | ||
2310 | connection_cancel_queues (c, !fwd); | 2222 | connection_cancel_queues (c, !fwd); |
2311 | } | 2223 | } |
2312 | GCC_check_connections (); | 2224 | GCC_check_connections (); |
2313 | return GNUNET_OK; | 2225 | return; |
2314 | } | 2226 | } |
2315 | 2227 | ||
2316 | 2228 | ||
2317 | /** | 2229 | /** |
2318 | * Core handler for tunnel destruction | 2230 | * Handler for notifications of destroyed connections. |
2319 | * | 2231 | * |
2320 | * @param cls Closure (unused). | 2232 | * @param peer Message sender (neighbor). |
2321 | * @param peer Peer identity of sending neighbor. | 2233 | * @param msg Message itself. |
2322 | * @param message Message. | ||
2323 | * @return #GNUNET_OK to keep the connection open, | ||
2324 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2325 | */ | 2234 | */ |
2326 | int | 2235 | void |
2327 | GCC_handle_destroy (void *cls, | 2236 | GCC_handle_destroy (struct CadetPeer *peer, |
2328 | const struct GNUNET_PeerIdentity *peer, | 2237 | const struct GNUNET_CADET_ConnectionDestroy *msg) |
2329 | const struct GNUNET_MessageHeader *message) | ||
2330 | { | 2238 | { |
2331 | const struct GNUNET_CADET_ConnectionDestroy *msg; | ||
2332 | struct CadetConnection *c; | 2239 | struct CadetConnection *c; |
2333 | int fwd; | 2240 | int fwd; |
2334 | 2241 | ||
2335 | GCC_check_connections (); | 2242 | GCC_check_connections (); |
2336 | msg = (const struct GNUNET_CADET_ConnectionDestroy *) message; | 2243 | log_message (&msg->header, peer, &msg->cid); |
2337 | log_message (message, peer, &msg->cid); | ||
2338 | c = connection_get (&msg->cid); | 2244 | c = connection_get (&msg->cid); |
2339 | if (NULL == c) | 2245 | if (NULL == c) |
2340 | { | 2246 | { |
@@ -2346,20 +2252,23 @@ GCC_handle_destroy (void *cls, | |||
2346 | "# control on unknown connection", | 2252 | "# control on unknown connection", |
2347 | 1, GNUNET_NO); | 2253 | 1, GNUNET_NO); |
2348 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 2254 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2349 | " connection unknown: already destroyed?\n"); | 2255 | " connection unknown destroyed: previously destroyed?\n"); |
2350 | GCC_check_connections (); | 2256 | GCC_check_connections (); |
2351 | return GNUNET_OK; | 2257 | return; |
2352 | } | 2258 | } |
2259 | |||
2353 | fwd = is_fwd (c, peer); | 2260 | fwd = is_fwd (c, peer); |
2354 | if (GNUNET_SYSERR == fwd) | 2261 | if (GNUNET_SYSERR == fwd) |
2355 | { | 2262 | { |
2356 | GNUNET_break_op (0); /* FIXME */ | 2263 | GNUNET_break_op (0); |
2357 | return GNUNET_OK; | 2264 | GCC_check_connections (); |
2265 | return; | ||
2358 | } | 2266 | } |
2267 | |||
2359 | if (GNUNET_NO == GCC_is_terminal (c, fwd)) | 2268 | if (GNUNET_NO == GCC_is_terminal (c, fwd)) |
2360 | { | 2269 | { |
2361 | GNUNET_assert (NULL == | 2270 | GNUNET_assert (NULL == |
2362 | GCC_send_prebuilt_message (message, 0, 0, c, fwd, | 2271 | GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, |
2363 | GNUNET_YES, NULL, NULL)); | 2272 | GNUNET_YES, NULL, NULL)); |
2364 | } | 2273 | } |
2365 | else if (0 == c->pending_messages) | 2274 | else if (0 == c->pending_messages) |
@@ -2367,7 +2276,7 @@ GCC_handle_destroy (void *cls, | |||
2367 | LOG (GNUNET_ERROR_TYPE_DEBUG, " directly destroying connection!\n"); | 2276 | LOG (GNUNET_ERROR_TYPE_DEBUG, " directly destroying connection!\n"); |
2368 | GCC_destroy (c); | 2277 | GCC_destroy (c); |
2369 | GCC_check_connections (); | 2278 | GCC_check_connections (); |
2370 | return GNUNET_OK; | 2279 | return; |
2371 | } | 2280 | } |
2372 | mark_destroyed (c); | 2281 | mark_destroyed (c); |
2373 | if (NULL != c->t) | 2282 | if (NULL != c->t) |
@@ -2376,7 +2285,139 @@ GCC_handle_destroy (void *cls, | |||
2376 | c->t = NULL; | 2285 | c->t = NULL; |
2377 | } | 2286 | } |
2378 | GCC_check_connections (); | 2287 | GCC_check_connections (); |
2379 | return GNUNET_OK; | 2288 | return; |
2289 | } | ||
2290 | |||
2291 | |||
2292 | /** | ||
2293 | * Handler for cadet network traffic hop-by-hop acks. | ||
2294 | * | ||
2295 | * @param peer Message sender (neighbor). | ||
2296 | * @param msg Message itself. | ||
2297 | */ | ||
2298 | void | ||
2299 | GCC_handle_ack (struct CadetPeer *peer, | ||
2300 | const struct GNUNET_CADET_ACK *msg) | ||
2301 | { | ||
2302 | struct CadetConnection *c; | ||
2303 | struct CadetFlowControl *fc; | ||
2304 | uint32_t ack; | ||
2305 | int fwd; | ||
2306 | |||
2307 | GCC_check_connections (); | ||
2308 | log_message (&msg->header, peer, &msg->cid); | ||
2309 | c = connection_get (&msg->cid); | ||
2310 | if (NULL == c) | ||
2311 | { | ||
2312 | GNUNET_STATISTICS_update (stats, | ||
2313 | "# ack on unknown connection", | ||
2314 | 1, | ||
2315 | GNUNET_NO); | ||
2316 | send_broken_unknown (&msg->cid, | ||
2317 | &my_full_id, | ||
2318 | NULL, | ||
2319 | peer); | ||
2320 | GCC_check_connections (); | ||
2321 | return; | ||
2322 | } | ||
2323 | |||
2324 | /* Is this a forward or backward ACK? */ | ||
2325 | if (get_next_hop (c) == peer) | ||
2326 | { | ||
2327 | fc = &c->fwd_fc; | ||
2328 | fwd = GNUNET_YES; | ||
2329 | } | ||
2330 | else if (get_prev_hop (c) == peer) | ||
2331 | { | ||
2332 | fc = &c->bck_fc; | ||
2333 | fwd = GNUNET_NO; | ||
2334 | } | ||
2335 | else | ||
2336 | { | ||
2337 | GNUNET_break_op (0); | ||
2338 | return; | ||
2339 | } | ||
2340 | |||
2341 | ack = ntohl (msg->ack); | ||
2342 | LOG (GNUNET_ERROR_TYPE_DEBUG, " %s ACK %u (was %u)\n", | ||
2343 | GC_f2s (fwd), ack, fc->last_ack_recv); | ||
2344 | if (GC_is_pid_bigger (ack, fc->last_ack_recv)) | ||
2345 | fc->last_ack_recv = ack; | ||
2346 | |||
2347 | /* Cancel polling if the ACK is big enough. */ | ||
2348 | if (NULL != fc->poll_task && | ||
2349 | GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent)) | ||
2350 | { | ||
2351 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Cancel poll\n"); | ||
2352 | GNUNET_SCHEDULER_cancel (fc->poll_task); | ||
2353 | fc->poll_task = NULL; | ||
2354 | fc->poll_time = GNUNET_TIME_UNIT_SECONDS; | ||
2355 | } | ||
2356 | |||
2357 | GCC_check_connections (); | ||
2358 | } | ||
2359 | |||
2360 | |||
2361 | /** | ||
2362 | * Handler for cadet network traffic hop-by-hop data counter polls. | ||
2363 | * | ||
2364 | * @param peer Message sender (neighbor). | ||
2365 | * @param msg Message itself. | ||
2366 | */ | ||
2367 | void | ||
2368 | GCC_handle_poll (struct CadetPeer *peer, | ||
2369 | const struct GNUNET_CADET_Poll *msg) | ||
2370 | { | ||
2371 | struct CadetConnection *c; | ||
2372 | struct CadetFlowControl *fc; | ||
2373 | uint32_t pid; | ||
2374 | int fwd; | ||
2375 | |||
2376 | GCC_check_connections (); | ||
2377 | log_message (&msg->header, peer, &msg->cid); | ||
2378 | c = connection_get (&msg->cid); | ||
2379 | if (NULL == c) | ||
2380 | { | ||
2381 | GNUNET_STATISTICS_update (stats, "# poll on unknown connection", 1, | ||
2382 | GNUNET_NO); | ||
2383 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2384 | "POLL message on unknown connection %s!\n", | ||
2385 | GNUNET_h2s (GC_h2hc (&msg->cid))); | ||
2386 | send_broken_unknown (&msg->cid, | ||
2387 | &my_full_id, | ||
2388 | NULL, | ||
2389 | peer); | ||
2390 | GCC_check_connections (); | ||
2391 | return; | ||
2392 | } | ||
2393 | |||
2394 | /* Is this a forward or backward ACK? | ||
2395 | * Note: a poll should never be needed in a loopback case, | ||
2396 | * since there is no possiblility of packet loss there, so | ||
2397 | * this way of discerining FWD/BCK should not be a problem. | ||
2398 | */ | ||
2399 | if (get_next_hop (c) == peer) | ||
2400 | { | ||
2401 | LOG (GNUNET_ERROR_TYPE_DEBUG, " FWD FC\n"); | ||
2402 | fc = &c->fwd_fc; | ||
2403 | } | ||
2404 | else if (get_prev_hop (c) == peer) | ||
2405 | { | ||
2406 | LOG (GNUNET_ERROR_TYPE_DEBUG, " BCK FC\n"); | ||
2407 | fc = &c->bck_fc; | ||
2408 | } | ||
2409 | else | ||
2410 | { | ||
2411 | GNUNET_break_op (0); | ||
2412 | return; | ||
2413 | } | ||
2414 | |||
2415 | pid = ntohl (msg->pid); | ||
2416 | LOG (GNUNET_ERROR_TYPE_DEBUG, " PID %u, OLD %u\n", pid, fc->last_pid_recv); | ||
2417 | fc->last_pid_recv = pid; | ||
2418 | fwd = fc == &c->bck_fc; | ||
2419 | GCC_send_ack (c, fwd, GNUNET_YES); | ||
2420 | GCC_check_connections (); | ||
2380 | } | 2421 | } |
2381 | 2422 | ||
2382 | 2423 | ||
@@ -2386,34 +2427,26 @@ GCC_handle_destroy (void *cls, | |||
2386 | * Updates the PID, state and timeout values for the connection. | 2427 | * Updates the PID, state and timeout values for the connection. |
2387 | * | 2428 | * |
2388 | * @param message Message to check. It must belong to an existing connection. | 2429 | * @param message Message to check. It must belong to an existing connection. |
2389 | * @param minimum_size The message cannot be smaller than this value. | ||
2390 | * @param cid Connection ID (even if @a c is NULL, the ID is still needed). | 2430 | * @param cid Connection ID (even if @a c is NULL, the ID is still needed). |
2391 | * @param c Connection this message should belong. If NULL, check fails. | 2431 | * @param c Connection this message should belong. If NULL, check fails. |
2392 | * @param neighbor Neighbor that sent the message. | 2432 | * @param sender Neighbor that sent the message. |
2433 | * | ||
2434 | * @return #GNUNET_YES if the message goes FWD. | ||
2435 | * #GNUNET_NO if it goes BCK. | ||
2436 | * #GNUNET_SYSERR if there is an error (unauthorized sender, ...). | ||
2393 | */ | 2437 | */ |
2394 | static int | 2438 | static int |
2395 | check_message (const struct GNUNET_MessageHeader *message, | 2439 | check_message (const struct GNUNET_MessageHeader *message, |
2396 | size_t minimum_size, | ||
2397 | const struct GNUNET_CADET_Hash* cid, | 2440 | const struct GNUNET_CADET_Hash* cid, |
2398 | struct CadetConnection *c, | 2441 | struct CadetConnection *c, |
2399 | const struct GNUNET_PeerIdentity *neighbor, | 2442 | struct CadetPeer *sender, |
2400 | uint32_t pid) | 2443 | uint32_t pid) |
2401 | { | 2444 | { |
2402 | GNUNET_PEER_Id neighbor_id; | ||
2403 | struct CadetFlowControl *fc; | 2445 | struct CadetFlowControl *fc; |
2404 | struct CadetPeer *hop; | 2446 | struct CadetPeer *hop; |
2405 | int fwd; | 2447 | int fwd; |
2406 | uint16_t type; | 2448 | uint16_t type; |
2407 | 2449 | ||
2408 | /* Check size */ | ||
2409 | if (ntohs (message->size) < minimum_size) | ||
2410 | { | ||
2411 | GNUNET_break_op (0); | ||
2412 | LOG (GNUNET_ERROR_TYPE_WARNING, "Size %u < %u\n", | ||
2413 | ntohs (message->size), minimum_size); | ||
2414 | return GNUNET_SYSERR; | ||
2415 | } | ||
2416 | |||
2417 | /* Check connection */ | 2450 | /* Check connection */ |
2418 | if (NULL == c) | 2451 | if (NULL == c) |
2419 | { | 2452 | { |
@@ -2427,14 +2460,13 @@ check_message (const struct GNUNET_MessageHeader *message, | |||
2427 | send_broken_unknown (cid, | 2460 | send_broken_unknown (cid, |
2428 | &my_full_id, | 2461 | &my_full_id, |
2429 | NULL, | 2462 | NULL, |
2430 | neighbor); | 2463 | sender); |
2431 | return GNUNET_SYSERR; | 2464 | return GNUNET_SYSERR; |
2432 | } | 2465 | } |
2433 | 2466 | ||
2434 | /* Check if origin is as expected */ | 2467 | /* Check if origin is as expected */ |
2435 | neighbor_id = GNUNET_PEER_search (neighbor); | ||
2436 | hop = get_prev_hop (c); | 2468 | hop = get_prev_hop (c); |
2437 | if (neighbor_id == GCP_get_short_id (hop)) | 2469 | if (sender == hop) |
2438 | { | 2470 | { |
2439 | fwd = GNUNET_YES; | 2471 | fwd = GNUNET_YES; |
2440 | } | 2472 | } |
@@ -2442,7 +2474,7 @@ check_message (const struct GNUNET_MessageHeader *message, | |||
2442 | { | 2474 | { |
2443 | hop = get_next_hop (c); | 2475 | hop = get_next_hop (c); |
2444 | GNUNET_break (hop == c->next_peer); | 2476 | GNUNET_break (hop == c->next_peer); |
2445 | if (neighbor_id == GCP_get_short_id (hop)) | 2477 | if (sender == hop) |
2446 | { | 2478 | { |
2447 | fwd = GNUNET_NO; | 2479 | fwd = GNUNET_NO; |
2448 | } | 2480 | } |
@@ -2508,123 +2540,111 @@ check_message (const struct GNUNET_MessageHeader *message, | |||
2508 | 2540 | ||
2509 | 2541 | ||
2510 | /** | 2542 | /** |
2511 | * Generic handler for cadet network encrypted traffic. | 2543 | * Handler for key exchange traffic (Axolotl KX). |
2512 | * | 2544 | * |
2513 | * @param peer Peer identity this notification is about. | 2545 | * @param peer Message sender (neighbor). |
2514 | * @param msg Encrypted message. | 2546 | * @param msg Message itself. |
2515 | * @return #GNUNET_OK to keep the connection open, | ||
2516 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2517 | */ | 2547 | */ |
2518 | static int | 2548 | void |
2519 | handle_cadet_encrypted (const struct GNUNET_PeerIdentity *peer, | 2549 | GCC_handle_kx (struct CadetPeer *peer, |
2520 | const struct GNUNET_MessageHeader *message) | 2550 | const struct GNUNET_CADET_KX *msg) |
2521 | { | 2551 | { |
2522 | const struct GNUNET_CADET_AX *ax_msg; | ||
2523 | const struct GNUNET_CADET_Hash* cid; | 2552 | const struct GNUNET_CADET_Hash* cid; |
2524 | struct CadetConnection *c; | 2553 | struct CadetConnection *c; |
2525 | size_t minimum_size; | ||
2526 | size_t overhead; | ||
2527 | uint32_t pid; | ||
2528 | int fwd; | 2554 | int fwd; |
2529 | 2555 | ||
2530 | GCC_check_connections (); | 2556 | GCC_check_connections (); |
2531 | GNUNET_assert (GNUNET_MESSAGE_TYPE_CADET_AX == ntohs (message->type)); | 2557 | cid = &msg->cid; |
2532 | overhead = sizeof (struct GNUNET_CADET_AX); | 2558 | log_message (&msg->header, peer, cid); |
2533 | ax_msg = (const struct GNUNET_CADET_AX *) message; | 2559 | |
2534 | cid = &ax_msg->cid; | ||
2535 | pid = ntohl (ax_msg->pid); | ||
2536 | log_message (message, peer, cid); | ||
2537 | |||
2538 | minimum_size = sizeof (struct GNUNET_MessageHeader) + overhead; | ||
2539 | c = connection_get (cid); | 2560 | c = connection_get (cid); |
2540 | fwd = check_message (message, | 2561 | fwd = check_message (&msg->header, |
2541 | minimum_size, | ||
2542 | cid, | 2562 | cid, |
2543 | c, | 2563 | c, |
2544 | peer, | 2564 | peer, |
2545 | pid); | 2565 | 0); |
2546 | 2566 | ||
2547 | /* If something went wrong, discard message. */ | 2567 | /* If something went wrong, discard message. */ |
2548 | if (GNUNET_SYSERR == fwd) | 2568 | if (GNUNET_SYSERR == fwd) |
2549 | { | 2569 | { |
2570 | GNUNET_break_op (0); | ||
2550 | GCC_check_connections (); | 2571 | GCC_check_connections (); |
2551 | return GNUNET_OK; | 2572 | return; |
2552 | } | 2573 | } |
2553 | 2574 | ||
2554 | /* Is this message for us? */ | 2575 | /* Is this message for us? */ |
2555 | if (GCC_is_terminal (c, fwd)) | 2576 | if (GCC_is_terminal (c, fwd)) |
2556 | { | 2577 | { |
2557 | GNUNET_STATISTICS_update (stats, "# received encrypted", 1, GNUNET_NO); | 2578 | LOG (GNUNET_ERROR_TYPE_DEBUG, " message for us!\n"); |
2558 | 2579 | GNUNET_STATISTICS_update (stats, "# received KX", 1, GNUNET_NO); | |
2559 | if (NULL == c->t) | 2580 | if (NULL == c->t) |
2560 | { | 2581 | { |
2561 | GNUNET_break (GNUNET_NO != c->destroy); | 2582 | GNUNET_break (0); |
2562 | return GNUNET_OK; | 2583 | return; |
2563 | } | 2584 | } |
2564 | GCT_handle_encrypted (c->t, message); | 2585 | GCT_handle_kx (c->t, &msg[1].header); |
2565 | GCC_send_ack (c, fwd, GNUNET_NO); | ||
2566 | GCC_check_connections (); | 2586 | GCC_check_connections (); |
2567 | return GNUNET_OK; | 2587 | return; |
2568 | } | 2588 | } |
2569 | 2589 | ||
2570 | /* Message not for us: forward to next hop */ | 2590 | /* Message not for us: forward to next hop */ |
2571 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not for us, retransmitting...\n"); | 2591 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not for us, retransmitting...\n"); |
2572 | GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO); | 2592 | GNUNET_STATISTICS_update (stats, "# messages forwarded", 1, GNUNET_NO); |
2573 | GNUNET_assert (NULL == GCC_send_prebuilt_message (message, 0, 0, c, fwd, | 2593 | GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, |
2574 | GNUNET_NO, NULL, NULL)); | 2594 | GNUNET_NO, NULL, NULL)); |
2575 | GCC_check_connections (); | 2595 | GCC_check_connections (); |
2576 | return GNUNET_OK; | ||
2577 | } | 2596 | } |
2578 | 2597 | ||
2579 | 2598 | ||
2580 | /** | 2599 | /** |
2581 | * Generic handler for cadet network encrypted traffic. | 2600 | * Handler for encrypted cadet network traffic (channel mgmt, data). |
2582 | * | 2601 | * |
2583 | * @param peer Peer identity this notification is about. | 2602 | * @param peer Message sender (neighbor). |
2584 | * @param msg Encrypted message. | 2603 | * @param msg Message itself. |
2585 | * @return #GNUNET_OK to keep the connection open, | ||
2586 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2587 | */ | 2604 | */ |
2588 | static int | 2605 | void |
2589 | handle_cadet_kx (const struct GNUNET_PeerIdentity *peer, | 2606 | GCC_handle_encrypted (struct CadetPeer *peer, |
2590 | const struct GNUNET_CADET_KX *msg) | 2607 | const struct GNUNET_CADET_AX *msg) |
2591 | { | 2608 | { |
2592 | const struct GNUNET_CADET_Hash* cid; | 2609 | const struct GNUNET_CADET_Hash* cid; |
2593 | struct CadetConnection *c; | 2610 | struct CadetConnection *c; |
2594 | size_t expected_size; | 2611 | uint32_t pid; |
2595 | int fwd; | 2612 | int fwd; |
2596 | 2613 | ||
2597 | GCC_check_connections (); | 2614 | GCC_check_connections (); |
2598 | cid = &msg->cid; | 2615 | cid = &msg->cid; |
2616 | pid = ntohl (msg->pid); | ||
2599 | log_message (&msg->header, peer, cid); | 2617 | log_message (&msg->header, peer, cid); |
2600 | 2618 | ||
2601 | expected_size = sizeof (struct GNUNET_CADET_KX) | ||
2602 | + sizeof (struct GNUNET_MessageHeader); | ||
2603 | c = connection_get (cid); | 2619 | c = connection_get (cid); |
2604 | fwd = check_message (&msg->header, | 2620 | fwd = check_message (&msg->header, |
2605 | expected_size, | ||
2606 | cid, | 2621 | cid, |
2607 | c, | 2622 | c, |
2608 | peer, | 2623 | peer, |
2609 | 0); | 2624 | pid); |
2610 | 2625 | ||
2611 | /* If something went wrong, discard message. */ | 2626 | /* If something went wrong, discard message. */ |
2612 | if (GNUNET_SYSERR == fwd) | 2627 | if (GNUNET_SYSERR == fwd) |
2613 | return GNUNET_OK; | 2628 | { |
2629 | GNUNET_break_op (0); | ||
2630 | GCC_check_connections (); | ||
2631 | return; | ||
2632 | } | ||
2614 | 2633 | ||
2615 | /* Is this message for us? */ | 2634 | /* Is this message for us? */ |
2616 | if (GCC_is_terminal (c, fwd)) | 2635 | if (GCC_is_terminal (c, fwd)) |
2617 | { | 2636 | { |
2618 | LOG (GNUNET_ERROR_TYPE_DEBUG, " message for us!\n"); | 2637 | GNUNET_STATISTICS_update (stats, "# received encrypted", 1, GNUNET_NO); |
2619 | GNUNET_STATISTICS_update (stats, "# received KX", 1, GNUNET_NO); | 2638 | |
2620 | if (NULL == c->t) | 2639 | if (NULL == c->t) |
2621 | { | 2640 | { |
2622 | GNUNET_break (0); | 2641 | GNUNET_break (GNUNET_NO != c->destroy); |
2623 | return GNUNET_OK; | 2642 | return; |
2624 | } | 2643 | } |
2625 | GCT_handle_kx (c->t, &msg[1].header); | 2644 | GCT_handle_encrypted (c->t, &msg->header); |
2645 | GCC_send_ack (c, fwd, GNUNET_NO); | ||
2626 | GCC_check_connections (); | 2646 | GCC_check_connections (); |
2627 | return GNUNET_OK; | 2647 | return; |
2628 | } | 2648 | } |
2629 | 2649 | ||
2630 | /* Message not for us: forward to next hop */ | 2650 | /* Message not for us: forward to next hop */ |
@@ -2633,259 +2653,6 @@ handle_cadet_kx (const struct GNUNET_PeerIdentity *peer, | |||
2633 | GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, | 2653 | GNUNET_assert (NULL == GCC_send_prebuilt_message (&msg->header, 0, 0, c, fwd, |
2634 | GNUNET_NO, NULL, NULL)); | 2654 | GNUNET_NO, NULL, NULL)); |
2635 | GCC_check_connections (); | 2655 | GCC_check_connections (); |
2636 | return GNUNET_OK; | ||
2637 | } | ||
2638 | |||
2639 | |||
2640 | /** | ||
2641 | * Core handler for key exchange traffic (ephemeral key, ping, pong). | ||
2642 | * | ||
2643 | * @param cls Closure (unused). | ||
2644 | * @param message Message received. | ||
2645 | * @param peer Peer who sent the message. | ||
2646 | * @return #GNUNET_OK to keep the connection open, | ||
2647 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2648 | */ | ||
2649 | int | ||
2650 | GCC_handle_kx (void *cls, | ||
2651 | const struct GNUNET_PeerIdentity *peer, | ||
2652 | const struct GNUNET_MessageHeader *message) | ||
2653 | { | ||
2654 | GCC_check_connections (); | ||
2655 | return handle_cadet_kx (peer, (struct GNUNET_CADET_KX *) message); | ||
2656 | } | ||
2657 | |||
2658 | |||
2659 | /** | ||
2660 | * Core handler for encrypted cadet network traffic (channel mgmt, data). | ||
2661 | * | ||
2662 | * @param cls Closure (unused). | ||
2663 | * @param message Message received. | ||
2664 | * @param peer Peer who sent the message. | ||
2665 | * @return #GNUNET_OK to keep the connection open, | ||
2666 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2667 | */ | ||
2668 | int | ||
2669 | GCC_handle_encrypted (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
2670 | const struct GNUNET_MessageHeader *message) | ||
2671 | { | ||
2672 | GCC_check_connections (); | ||
2673 | return handle_cadet_encrypted (peer, message); | ||
2674 | } | ||
2675 | |||
2676 | |||
2677 | /** | ||
2678 | * Core handler for cadet network traffic point-to-point acks. | ||
2679 | * | ||
2680 | * @param cls closure | ||
2681 | * @param message message | ||
2682 | * @param peer peer identity this notification is about | ||
2683 | * @return #GNUNET_OK to keep the connection open, | ||
2684 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2685 | */ | ||
2686 | int | ||
2687 | GCC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
2688 | const struct GNUNET_MessageHeader *message) | ||
2689 | { | ||
2690 | struct GNUNET_CADET_ACK *msg; | ||
2691 | struct CadetConnection *c; | ||
2692 | struct CadetFlowControl *fc; | ||
2693 | GNUNET_PEER_Id id; | ||
2694 | uint32_t ack; | ||
2695 | int fwd; | ||
2696 | |||
2697 | GCC_check_connections (); | ||
2698 | msg = (struct GNUNET_CADET_ACK *) message; | ||
2699 | log_message (message, peer, &msg->cid); | ||
2700 | c = connection_get (&msg->cid); | ||
2701 | if (NULL == c) | ||
2702 | { | ||
2703 | GNUNET_STATISTICS_update (stats, | ||
2704 | "# ack on unknown connection", | ||
2705 | 1, | ||
2706 | GNUNET_NO); | ||
2707 | send_broken_unknown (&msg->cid, | ||
2708 | &my_full_id, | ||
2709 | NULL, | ||
2710 | peer); | ||
2711 | GCC_check_connections (); | ||
2712 | return GNUNET_OK; | ||
2713 | } | ||
2714 | |||
2715 | /* Is this a forward or backward ACK? */ | ||
2716 | id = GNUNET_PEER_search (peer); | ||
2717 | if (GCP_get_short_id (get_next_hop (c)) == id) | ||
2718 | { | ||
2719 | fc = &c->fwd_fc; | ||
2720 | fwd = GNUNET_YES; | ||
2721 | } | ||
2722 | else if (GCP_get_short_id (get_prev_hop (c)) == id) | ||
2723 | { | ||
2724 | fc = &c->bck_fc; | ||
2725 | fwd = GNUNET_NO; | ||
2726 | } | ||
2727 | else | ||
2728 | { | ||
2729 | GNUNET_break_op (0); | ||
2730 | return GNUNET_OK; | ||
2731 | } | ||
2732 | |||
2733 | ack = ntohl (msg->ack); | ||
2734 | LOG (GNUNET_ERROR_TYPE_DEBUG, " %s ACK %u (was %u)\n", | ||
2735 | GC_f2s (fwd), ack, fc->last_ack_recv); | ||
2736 | if (GC_is_pid_bigger (ack, fc->last_ack_recv)) | ||
2737 | fc->last_ack_recv = ack; | ||
2738 | |||
2739 | /* Cancel polling if the ACK is big enough. */ | ||
2740 | if (NULL != fc->poll_task && | ||
2741 | GC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent)) | ||
2742 | { | ||
2743 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Cancel poll\n"); | ||
2744 | GNUNET_SCHEDULER_cancel (fc->poll_task); | ||
2745 | fc->poll_task = NULL; | ||
2746 | fc->poll_time = GNUNET_TIME_UNIT_SECONDS; | ||
2747 | } | ||
2748 | |||
2749 | connection_unlock_queue (c, fwd); | ||
2750 | GCC_check_connections (); | ||
2751 | return GNUNET_OK; | ||
2752 | } | ||
2753 | |||
2754 | |||
2755 | /** | ||
2756 | * Core handler for cadet network traffic point-to-point ack polls. | ||
2757 | * | ||
2758 | * @param cls closure | ||
2759 | * @param message message | ||
2760 | * @param peer peer identity this notification is about | ||
2761 | * @return #GNUNET_OK to keep the connection open, | ||
2762 | * #GNUNET_SYSERR to close it (signal serious error) | ||
2763 | */ | ||
2764 | int | ||
2765 | GCC_handle_poll (void *cls, | ||
2766 | const struct GNUNET_PeerIdentity *peer, | ||
2767 | const struct GNUNET_MessageHeader *message) | ||
2768 | { | ||
2769 | struct GNUNET_CADET_Poll *msg; | ||
2770 | struct CadetConnection *c; | ||
2771 | struct CadetFlowControl *fc; | ||
2772 | GNUNET_PEER_Id id; | ||
2773 | uint32_t pid; | ||
2774 | int fwd; | ||
2775 | |||
2776 | GCC_check_connections (); | ||
2777 | msg = (struct GNUNET_CADET_Poll *) message; | ||
2778 | log_message (message, peer, &msg->cid); | ||
2779 | c = connection_get (&msg->cid); | ||
2780 | if (NULL == c) | ||
2781 | { | ||
2782 | GNUNET_STATISTICS_update (stats, "# poll on unknown connection", 1, | ||
2783 | GNUNET_NO); | ||
2784 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2785 | "POLL message on unknown connection %s!\n", | ||
2786 | GNUNET_h2s (GC_h2hc (&msg->cid))); | ||
2787 | send_broken_unknown (&msg->cid, | ||
2788 | &my_full_id, | ||
2789 | NULL, | ||
2790 | peer); | ||
2791 | GCC_check_connections (); | ||
2792 | return GNUNET_OK; | ||
2793 | } | ||
2794 | |||
2795 | /* Is this a forward or backward ACK? | ||
2796 | * Note: a poll should never be needed in a loopback case, | ||
2797 | * since there is no possiblility of packet loss there, so | ||
2798 | * this way of discerining FWD/BCK should not be a problem. | ||
2799 | */ | ||
2800 | id = GNUNET_PEER_search (peer); | ||
2801 | if (GCP_get_short_id (get_next_hop (c)) == id) | ||
2802 | { | ||
2803 | LOG (GNUNET_ERROR_TYPE_DEBUG, " FWD FC\n"); | ||
2804 | fc = &c->fwd_fc; | ||
2805 | } | ||
2806 | else if (GCP_get_short_id (get_prev_hop (c)) == id) | ||
2807 | { | ||
2808 | LOG (GNUNET_ERROR_TYPE_DEBUG, " BCK FC\n"); | ||
2809 | fc = &c->bck_fc; | ||
2810 | } | ||
2811 | else | ||
2812 | { | ||
2813 | GNUNET_break_op (0); | ||
2814 | return GNUNET_OK; | ||
2815 | } | ||
2816 | |||
2817 | pid = ntohl (msg->pid); | ||
2818 | LOG (GNUNET_ERROR_TYPE_DEBUG, " PID %u, OLD %u\n", pid, fc->last_pid_recv); | ||
2819 | fc->last_pid_recv = pid; | ||
2820 | fwd = fc == &c->bck_fc; | ||
2821 | GCC_send_ack (c, fwd, GNUNET_YES); | ||
2822 | GCC_check_connections (); | ||
2823 | |||
2824 | return GNUNET_OK; | ||
2825 | } | ||
2826 | |||
2827 | |||
2828 | /** | ||
2829 | * Send an ACK on the appropriate connection/channel, depending on | ||
2830 | * the direction and the position of the peer. | ||
2831 | * | ||
2832 | * @param c Which connection to send the hop-by-hop ACK. | ||
2833 | * @param fwd Is this a fwd ACK? (will go dest->root). | ||
2834 | * @param force Send the ACK even if suboptimal (e.g. requested by POLL). | ||
2835 | */ | ||
2836 | void | ||
2837 | GCC_send_ack (struct CadetConnection *c, int fwd, int force) | ||
2838 | { | ||
2839 | unsigned int buffer; | ||
2840 | |||
2841 | GCC_check_connections (); | ||
2842 | LOG (GNUNET_ERROR_TYPE_DEBUG, "GCC send %s ACK on %s\n", | ||
2843 | GC_f2s (fwd), GCC_2s (c)); | ||
2844 | |||
2845 | if (NULL == c) | ||
2846 | { | ||
2847 | GNUNET_break (0); | ||
2848 | return; | ||
2849 | } | ||
2850 | |||
2851 | if (GNUNET_NO != c->destroy) | ||
2852 | { | ||
2853 | LOG (GNUNET_ERROR_TYPE_DEBUG, " being destroyed, why bother...\n"); | ||
2854 | GCC_check_connections (); | ||
2855 | return; | ||
2856 | } | ||
2857 | |||
2858 | /* Get available buffer space */ | ||
2859 | if (GCC_is_terminal (c, fwd)) | ||
2860 | { | ||
2861 | LOG (GNUNET_ERROR_TYPE_DEBUG, " getting from all channels\n"); | ||
2862 | buffer = GCT_get_channels_buffer (c->t); | ||
2863 | } | ||
2864 | else | ||
2865 | { | ||
2866 | LOG (GNUNET_ERROR_TYPE_DEBUG, " getting from one connection\n"); | ||
2867 | buffer = GCC_get_buffer (c, fwd); | ||
2868 | } | ||
2869 | LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer available: %u\n", buffer); | ||
2870 | if (0 == buffer && GNUNET_NO == force) | ||
2871 | { | ||
2872 | GCC_check_connections (); | ||
2873 | return; | ||
2874 | } | ||
2875 | |||
2876 | /* Send available buffer space */ | ||
2877 | if (GCC_is_origin (c, fwd)) | ||
2878 | { | ||
2879 | GNUNET_assert (NULL != c->t); | ||
2880 | LOG (GNUNET_ERROR_TYPE_DEBUG, " sending on channels...\n"); | ||
2881 | GCT_unchoke_channels (c->t); | ||
2882 | } | ||
2883 | else | ||
2884 | { | ||
2885 | LOG (GNUNET_ERROR_TYPE_DEBUG, " sending on connection\n"); | ||
2886 | send_ack (c, buffer, fwd, force); | ||
2887 | } | ||
2888 | GCC_check_connections (); | ||
2889 | } | 2656 | } |
2890 | 2657 | ||
2891 | 2658 | ||
@@ -2974,12 +2741,13 @@ GCC_shutdown (void) | |||
2974 | * Create a connection. | 2741 | * Create a connection. |
2975 | * | 2742 | * |
2976 | * @param cid Connection ID (either created locally or imposed remotely). | 2743 | * @param cid Connection ID (either created locally or imposed remotely). |
2977 | * @param t Tunnel this connection belongs to (or NULL); | 2744 | * @param t Tunnel this connection belongs to (or NULL for transit connections); |
2978 | * @param path Path this connection has to use (copy is made). | 2745 | * @param path Path this connection has to use (copy is made). |
2979 | * @param own_pos Own position in the @c path path. | 2746 | * @param own_pos Own position in the @c path path. |
2980 | * | 2747 | * |
2981 | * @return Newly created connection, NULL in case of error (own id not in path). | 2748 | * @return Newly created connection. |
2982 | */ | 2749 | * NULL in case of error: own id not in path, wrong neighbors, ... |
2750 | */ | ||
2983 | struct CadetConnection * | 2751 | struct CadetConnection * |
2984 | GCC_new (const struct GNUNET_CADET_Hash *cid, | 2752 | GCC_new (const struct GNUNET_CADET_Hash *cid, |
2985 | struct CadetTunnel *t, | 2753 | struct CadetTunnel *t, |
@@ -3036,6 +2804,14 @@ GCC_new (const struct GNUNET_CADET_Hash *cid, | |||
3036 | } | 2804 | } |
3037 | 2805 | ||
3038 | 2806 | ||
2807 | /** | ||
2808 | * Connection is no longer needed: destroy it. | ||
2809 | * | ||
2810 | * Cancels all pending traffic (including possible DESTROY messages), all | ||
2811 | * maintenance tasks and removes the connection from neighbor peers and tunnel. | ||
2812 | * | ||
2813 | * @param c Connection to destroy. | ||
2814 | */ | ||
3039 | void | 2815 | void |
3040 | GCC_destroy (struct CadetConnection *c) | 2816 | GCC_destroy (struct CadetConnection *c) |
3041 | { | 2817 | { |
@@ -3428,6 +3204,7 @@ GCC_is_direct (struct CadetConnection *c) | |||
3428 | * @param message Message to send. Function makes a copy of it. | 3204 | * @param message Message to send. Function makes a copy of it. |
3429 | * If message is not hop-by-hop, decrements TTL of copy. | 3205 | * If message is not hop-by-hop, decrements TTL of copy. |
3430 | * @param payload_type Type of payload, in case the message is encrypted. | 3206 | * @param payload_type Type of payload, in case the message is encrypted. |
3207 | * @param payload_id ID of the payload (PID, ACK, ...). | ||
3431 | * @param c Connection on which this message is transmitted. | 3208 | * @param c Connection on which this message is transmitted. |
3432 | * @param fwd Is this a fwd message? | 3209 | * @param fwd Is this a fwd message? |
3433 | * @param force Force the connection to accept the message (buffer overfill). | 3210 | * @param force Force the connection to accept the message (buffer overfill). |
@@ -3446,7 +3223,7 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3446 | { | 3223 | { |
3447 | struct CadetFlowControl *fc; | 3224 | struct CadetFlowControl *fc; |
3448 | struct CadetConnectionQueue *q; | 3225 | struct CadetConnectionQueue *q; |
3449 | void *data; | 3226 | struct GNUNET_MessageHeader *copy; |
3450 | size_t size; | 3227 | size_t size; |
3451 | uint16_t type; | 3228 | uint16_t type; |
3452 | int droppable; | 3229 | int droppable; |
@@ -3460,8 +3237,8 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3460 | } | 3237 | } |
3461 | 3238 | ||
3462 | size = ntohs (message->size); | 3239 | size = ntohs (message->size); |
3463 | data = GNUNET_malloc (size); | 3240 | copy = GNUNET_malloc (size); |
3464 | GNUNET_memcpy (data, message, size); | 3241 | GNUNET_memcpy (copy, message, size); |
3465 | type = ntohs (message->type); | 3242 | type = ntohs (message->type); |
3466 | LOG (GNUNET_ERROR_TYPE_INFO, | 3243 | LOG (GNUNET_ERROR_TYPE_INFO, |
3467 | "--> %s (%s %4u) on conn %s (%p) %s [%5u]\n", | 3244 | "--> %s (%s %4u) on conn %s (%p) %s [%5u]\n", |
@@ -3478,7 +3255,7 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3478 | struct GNUNET_CADET_ConnectionBroken *bmsg; | 3255 | struct GNUNET_CADET_ConnectionBroken *bmsg; |
3479 | 3256 | ||
3480 | case GNUNET_MESSAGE_TYPE_CADET_AX: | 3257 | case GNUNET_MESSAGE_TYPE_CADET_AX: |
3481 | axmsg = (struct GNUNET_CADET_AX *) data; | 3258 | axmsg = (struct GNUNET_CADET_AX *) copy; |
3482 | axmsg->cid = c->id; | 3259 | axmsg->cid = c->id; |
3483 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N+ %p %u\n", fc, fc->queue_n); | 3260 | LOG (GNUNET_ERROR_TYPE_DEBUG, " Q_N+ %p %u\n", fc, fc->queue_n); |
3484 | LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid sent %u\n", fc->last_pid_sent); | 3261 | LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid sent %u\n", fc->last_pid_sent); |
@@ -3494,41 +3271,42 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3494 | break; | 3271 | break; |
3495 | 3272 | ||
3496 | case GNUNET_MESSAGE_TYPE_CADET_KX: | 3273 | case GNUNET_MESSAGE_TYPE_CADET_KX: |
3497 | kmsg = (struct GNUNET_CADET_KX *) data; | 3274 | kmsg = (struct GNUNET_CADET_KX *) copy; |
3498 | kmsg->cid = c->id; | 3275 | kmsg->cid = c->id; |
3499 | break; | 3276 | break; |
3500 | 3277 | ||
3501 | case GNUNET_MESSAGE_TYPE_CADET_ACK: | 3278 | case GNUNET_MESSAGE_TYPE_CADET_ACK: |
3502 | amsg = (struct GNUNET_CADET_ACK *) data; | 3279 | amsg = (struct GNUNET_CADET_ACK *) copy; |
3503 | amsg->cid = c->id; | 3280 | amsg->cid = c->id; |
3504 | LOG (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", ntohl (amsg->ack)); | 3281 | LOG (GNUNET_ERROR_TYPE_DEBUG, " ack %u\n", ntohl (amsg->ack)); |
3505 | droppable = GNUNET_NO; | 3282 | droppable = GNUNET_NO; |
3506 | break; | 3283 | break; |
3507 | 3284 | ||
3508 | case GNUNET_MESSAGE_TYPE_CADET_POLL: | 3285 | case GNUNET_MESSAGE_TYPE_CADET_POLL: |
3509 | pmsg = (struct GNUNET_CADET_Poll *) data; | 3286 | pmsg = (struct GNUNET_CADET_Poll *) copy; |
3510 | pmsg->cid = c->id; | 3287 | pmsg->cid = c->id; |
3511 | LOG (GNUNET_ERROR_TYPE_DEBUG, " POLL %u\n", ntohl (pmsg->pid)); | 3288 | LOG (GNUNET_ERROR_TYPE_DEBUG, " POLL %u\n", ntohl (pmsg->pid)); |
3512 | droppable = GNUNET_NO; | 3289 | droppable = GNUNET_NO; |
3513 | break; | 3290 | break; |
3514 | 3291 | ||
3515 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | 3292 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: |
3516 | dmsg = (struct GNUNET_CADET_ConnectionDestroy *) data; | 3293 | dmsg = (struct GNUNET_CADET_ConnectionDestroy *) copy; |
3517 | dmsg->cid = c->id; | 3294 | dmsg->cid = c->id; |
3518 | break; | 3295 | break; |
3519 | 3296 | ||
3520 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | 3297 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: |
3521 | bmsg = (struct GNUNET_CADET_ConnectionBroken *) data; | 3298 | bmsg = (struct GNUNET_CADET_ConnectionBroken *) copy; |
3522 | bmsg->cid = c->id; | 3299 | bmsg->cid = c->id; |
3523 | break; | 3300 | break; |
3524 | 3301 | ||
3525 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: | 3302 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: |
3526 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: | 3303 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: |
3304 | GNUNET_break (0); /* Should've used specific functions. */ | ||
3527 | break; | 3305 | break; |
3528 | 3306 | ||
3529 | default: | 3307 | default: |
3530 | GNUNET_break (0); | 3308 | GNUNET_break (0); |
3531 | GNUNET_free (data); | 3309 | GNUNET_free (copy); |
3532 | return NULL; | 3310 | return NULL; |
3533 | } | 3311 | } |
3534 | 3312 | ||
@@ -3543,7 +3321,7 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3543 | { | 3321 | { |
3544 | fc->queue_n--; | 3322 | fc->queue_n--; |
3545 | } | 3323 | } |
3546 | GNUNET_free (data); | 3324 | GNUNET_free (copy); |
3547 | return NULL; /* Drop this message */ | 3325 | return NULL; /* Drop this message */ |
3548 | } | 3326 | } |
3549 | 3327 | ||
@@ -3553,12 +3331,14 @@ GCC_send_prebuilt_message (const struct GNUNET_MessageHeader *message, | |||
3553 | 3331 | ||
3554 | q = GNUNET_new (struct CadetConnectionQueue); | 3332 | q = GNUNET_new (struct CadetConnectionQueue); |
3555 | q->forced = !droppable; | 3333 | q->forced = !droppable; |
3556 | q->q = GCP_queue_add (get_hop (c, fwd), data, type, payload_type, payload_id, | 3334 | q->peer_q = GCP_send (get_hop (c, fwd), copy, |
3557 | size, c, fwd, &conn_message_sent, q); | 3335 | payload_type, payload_id, |
3558 | if (NULL == q->q) | 3336 | c, fwd, |
3337 | &conn_message_sent, q); | ||
3338 | if (NULL == q->peer_q) | ||
3559 | { | 3339 | { |
3560 | LOG (GNUNET_ERROR_TYPE_DEBUG, "dropping msg on %s, NULL q\n", GCC_2s (c)); | 3340 | LOG (GNUNET_ERROR_TYPE_DEBUG, "dropping msg on %s, NULL q\n", GCC_2s (c)); |
3561 | GNUNET_free (data); | 3341 | GNUNET_free (copy); |
3562 | GNUNET_free (q); | 3342 | GNUNET_free (q); |
3563 | GCC_check_connections (); | 3343 | GCC_check_connections (); |
3564 | return NULL; | 3344 | return NULL; |
@@ -3584,8 +3364,8 @@ GCC_cancel (struct CadetConnectionQueue *q) | |||
3584 | { | 3364 | { |
3585 | LOG (GNUNET_ERROR_TYPE_DEBUG, "! GCC cancel message\n"); | 3365 | LOG (GNUNET_ERROR_TYPE_DEBUG, "! GCC cancel message\n"); |
3586 | 3366 | ||
3587 | /* queue destroy calls message_sent, which calls q->cont and frees q */ | 3367 | /* send_cancel calls message_sent, which calls q->cont and frees q */ |
3588 | GCP_queue_destroy (q->q, GNUNET_YES, GNUNET_NO, 0); | 3368 | GCP_send_cancel (q->peer_q); |
3589 | GCC_check_connections (); | 3369 | GCC_check_connections (); |
3590 | } | 3370 | } |
3591 | 3371 | ||
@@ -3594,35 +3374,116 @@ GCC_cancel (struct CadetConnectionQueue *q) | |||
3594 | * Sends a CREATE CONNECTION message for a path to a peer. | 3374 | * Sends a CREATE CONNECTION message for a path to a peer. |
3595 | * Changes the connection and tunnel states if necessary. | 3375 | * Changes the connection and tunnel states if necessary. |
3596 | * | 3376 | * |
3597 | * @param connection Connection to create. | 3377 | * @param c Connection to create. |
3598 | */ | 3378 | */ |
3599 | void | 3379 | void |
3600 | GCC_send_create (struct CadetConnection *connection) | 3380 | GCC_send_create (struct CadetConnection *c) |
3601 | { | 3381 | { |
3602 | enum CadetTunnelCState state; | 3382 | enum CadetTunnelCState state; |
3603 | size_t size; | 3383 | size_t size; |
3604 | 3384 | ||
3605 | GCC_check_connections (); | 3385 | GCC_check_connections (); |
3606 | size = sizeof (struct GNUNET_CADET_ConnectionCreate); | 3386 | size = sizeof (struct GNUNET_CADET_ConnectionCreate); |
3607 | size += connection->path->length * sizeof (struct GNUNET_PeerIdentity); | 3387 | size += c->path->length * sizeof (struct GNUNET_PeerIdentity); |
3388 | { | ||
3389 | /* Allocate message on the stack */ | ||
3390 | unsigned char cbuf[size]; | ||
3391 | struct GNUNET_CADET_ConnectionCreate *msg; | ||
3392 | struct GNUNET_PeerIdentity *peers; | ||
3393 | |||
3394 | msg = (struct GNUNET_CADET_ConnectionCreate *) cbuf; | ||
3395 | msg->header.size = htons (size); | ||
3396 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE); | ||
3397 | msg->cid = *GCC_get_id (c); | ||
3398 | peers = (struct GNUNET_PeerIdentity *) &msg[1]; | ||
3399 | for (int i = 0; i < c->path->length; i++) | ||
3400 | { | ||
3401 | GNUNET_PEER_resolve (c->path->peers[i], peers++); | ||
3402 | } | ||
3403 | GNUNET_assert (NULL == c->maintenance_q); | ||
3404 | c->maintenance_q = GCP_send (get_next_hop (c), | ||
3405 | &msg->header, | ||
3406 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0, | ||
3407 | c, GNUNET_YES, | ||
3408 | &conn_message_sent, NULL); | ||
3409 | } | ||
3608 | 3410 | ||
3609 | LOG (GNUNET_ERROR_TYPE_INFO, "==> %s %19s on conn %s (%p) FWD [%5u]\n", | 3411 | LOG (GNUNET_ERROR_TYPE_INFO, "==> %s %19s on conn %s (%p) FWD [%5u]\n", |
3610 | GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE), "", | 3412 | GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE), "", |
3611 | GCC_2s (connection), connection, size); | 3413 | GCC_2s (c), c, size); |
3612 | LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P+ %p %u (create)\n", | 3414 | LOG (GNUNET_ERROR_TYPE_DEBUG, " C_P+ %p %u (create)\n", |
3613 | connection, connection->pending_messages); | 3415 | c, c->pending_messages); |
3614 | connection->pending_messages++; | 3416 | c->pending_messages++; |
3615 | |||
3616 | connection->maintenance_q = | ||
3617 | GCP_queue_add (get_next_hop (connection), NULL, | ||
3618 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, UINT16_MAX, 0, | ||
3619 | size, connection, GNUNET_YES, &conn_message_sent, NULL); | ||
3620 | 3417 | ||
3621 | state = GCT_get_cstate (connection->t); | 3418 | state = GCT_get_cstate (c->t); |
3622 | if (CADET_TUNNEL_SEARCHING == state || CADET_TUNNEL_NEW == state) | 3419 | if (CADET_TUNNEL_SEARCHING == state || CADET_TUNNEL_NEW == state) |
3623 | GCT_change_cstate (connection->t, CADET_TUNNEL_WAITING); | 3420 | GCT_change_cstate (c->t, CADET_TUNNEL_WAITING); |
3624 | if (CADET_CONNECTION_NEW == connection->state) | 3421 | if (CADET_CONNECTION_NEW == c->state) |
3625 | connection_change_state (connection, CADET_CONNECTION_SENT); | 3422 | connection_change_state (c, CADET_CONNECTION_SENT); |
3423 | GCC_check_connections (); | ||
3424 | } | ||
3425 | |||
3426 | |||
3427 | /** | ||
3428 | * Send an ACK on the appropriate connection/channel, depending on | ||
3429 | * the direction and the position of the peer. | ||
3430 | * | ||
3431 | * @param c Which connection to send the hop-by-hop ACK. | ||
3432 | * @param fwd Is this a fwd ACK? (will go dest->root). | ||
3433 | * @param force Send the ACK even if suboptimal (e.g. requested by POLL). | ||
3434 | */ | ||
3435 | void | ||
3436 | GCC_send_ack (struct CadetConnection *c, int fwd, int force) | ||
3437 | { | ||
3438 | unsigned int buffer; | ||
3439 | |||
3440 | GCC_check_connections (); | ||
3441 | LOG (GNUNET_ERROR_TYPE_DEBUG, "GCC send %s ACK on %s\n", | ||
3442 | GC_f2s (fwd), GCC_2s (c)); | ||
3443 | |||
3444 | if (NULL == c) | ||
3445 | { | ||
3446 | GNUNET_break (0); | ||
3447 | return; | ||
3448 | } | ||
3449 | |||
3450 | if (GNUNET_NO != c->destroy) | ||
3451 | { | ||
3452 | LOG (GNUNET_ERROR_TYPE_DEBUG, " being destroyed, why bother...\n"); | ||
3453 | GCC_check_connections (); | ||
3454 | return; | ||
3455 | } | ||
3456 | |||
3457 | /* Get available buffer space */ | ||
3458 | if (GCC_is_terminal (c, fwd)) | ||
3459 | { | ||
3460 | LOG (GNUNET_ERROR_TYPE_DEBUG, " getting from all channels\n"); | ||
3461 | buffer = GCT_get_channels_buffer (c->t); | ||
3462 | } | ||
3463 | else | ||
3464 | { | ||
3465 | LOG (GNUNET_ERROR_TYPE_DEBUG, " getting from one connection\n"); | ||
3466 | buffer = GCC_get_buffer (c, fwd); | ||
3467 | } | ||
3468 | LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer available: %u\n", buffer); | ||
3469 | if (0 == buffer && GNUNET_NO == force) | ||
3470 | { | ||
3471 | GCC_check_connections (); | ||
3472 | return; | ||
3473 | } | ||
3474 | |||
3475 | /* Send available buffer space */ | ||
3476 | if (GNUNET_YES == GCC_is_origin (c, fwd)) | ||
3477 | { | ||
3478 | GNUNET_assert (NULL != c->t); | ||
3479 | LOG (GNUNET_ERROR_TYPE_DEBUG, " sending on channels...\n"); | ||
3480 | GCT_unchoke_channels (c->t); | ||
3481 | } | ||
3482 | else | ||
3483 | { | ||
3484 | LOG (GNUNET_ERROR_TYPE_DEBUG, " sending on connection\n"); | ||
3485 | send_ack (c, buffer, fwd, force); | ||
3486 | } | ||
3626 | GCC_check_connections (); | 3487 | GCC_check_connections (); |
3627 | } | 3488 | } |
3628 | 3489 | ||
diff --git a/src/cadet/gnunet-service-cadet_connection.h b/src/cadet/gnunet-service-cadet_connection.h index e96e2f24c..6302cd898 100644 --- a/src/cadet/gnunet-service-cadet_connection.h +++ b/src/cadet/gnunet-service-cadet_connection.h | |||
@@ -118,90 +118,86 @@ typedef void | |||
118 | 118 | ||
119 | 119 | ||
120 | /** | 120 | /** |
121 | * Core handler for connection creation. | 121 | * Handler for connection creation. |
122 | * | 122 | * |
123 | * @param cls Closure (unused). | 123 | * @param peer Message sender (neighbor). |
124 | * @param peer Sender (neighbor). | 124 | * @param msg Message itself. |
125 | * @param message Message. | ||
126 | * @return #GNUNET_OK to keep the connection open, | ||
127 | * #GNUNET_SYSERR to close it (signal serious error) | ||
128 | */ | 125 | */ |
129 | int | 126 | void |
130 | GCC_handle_create (void *cls, | 127 | GCC_handle_create (struct CadetPeer *peer, |
131 | const struct GNUNET_PeerIdentity *peer, | 128 | const struct GNUNET_CADET_ConnectionCreate *msg); |
132 | const struct GNUNET_MessageHeader *message); | ||
133 | 129 | ||
134 | 130 | ||
135 | /** | 131 | /** |
136 | * Core handler for path confirmations. | 132 | * Handler for connection confirmations. |
137 | * | 133 | * |
138 | * @param cls closure | 134 | * @param peer Message sender (neighbor). |
139 | * @param message message | 135 | * @param msg Message itself. |
140 | * @param peer peer identity this notification is about | ||
141 | * @return #GNUNET_OK to keep the connection open, | ||
142 | * #GNUNET_SYSERR to close it (signal serious error) | ||
143 | */ | 136 | */ |
144 | int | 137 | void |
145 | GCC_handle_confirm (void *cls, | 138 | GCC_handle_confirm (struct CadetPeer *peer, |
146 | const struct GNUNET_PeerIdentity *peer, | 139 | const struct GNUNET_CADET_ConnectionACK *msg); |
147 | const struct GNUNET_MessageHeader *message); | ||
148 | 140 | ||
149 | 141 | ||
150 | /** | 142 | /** |
151 | * Core handler for notifications of broken paths | 143 | * Handler for notifications of broken connections. |
152 | * | 144 | * |
153 | * @param cls Closure (unused). | 145 | * @param peer Message sender (neighbor). |
154 | * @param id Peer identity of sending neighbor. | 146 | * @param msg Message itself. |
155 | * @param message Message. | ||
156 | * @return #GNUNET_OK to keep the connection open, | ||
157 | * #GNUNET_SYSERR to close it (signal serious error) | ||
158 | */ | 147 | */ |
159 | int | 148 | void |
160 | GCC_handle_broken (void* cls, | 149 | GCC_handle_broken (struct CadetPeer *peer, |
161 | const struct GNUNET_PeerIdentity* id, | 150 | const struct GNUNET_CADET_ConnectionBroken *msg); |
162 | const struct GNUNET_MessageHeader* message); | ||
163 | 151 | ||
164 | /** | 152 | /** |
165 | * Core handler for tunnel destruction | 153 | * Handler for notifications of destroyed connections. |
166 | * | 154 | * |
167 | * @param cls Closure (unused). | 155 | * @param peer Message sender (neighbor). |
168 | * @param peer Peer identity of sending neighbor. | 156 | * @param msg Message itself. |
169 | * @param message Message. | ||
170 | * | ||
171 | * @return GNUNET_OK to keep the connection open, | ||
172 | * GNUNET_SYSERR to close it (signal serious error) | ||
173 | */ | 157 | */ |
174 | int | 158 | void |
175 | GCC_handle_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, | 159 | GCC_handle_destroy (struct CadetPeer *peer, |
176 | const struct GNUNET_MessageHeader *message); | 160 | const struct GNUNET_CADET_ConnectionDestroy *msg); |
177 | 161 | ||
178 | /** | 162 | /** |
179 | * Core handler for key exchange traffic (ephemeral key, ping, pong). | 163 | * Handler for cadet network traffic hop-by-hop acks. |
180 | * | 164 | * |
181 | * @param cls Closure (unused). | 165 | * @param peer Message sender (neighbor). |
182 | * @param message Message received. | 166 | * @param msg Message itself. |
183 | * @param peer Peer who sent the message. | 167 | */ |
168 | void | ||
169 | GCC_handle_ack (struct CadetPeer *peer, | ||
170 | const struct GNUNET_CADET_ACK *msg); | ||
171 | |||
172 | /** | ||
173 | * Handler for cadet network traffic hop-by-hop data counter polls. | ||
184 | * | 174 | * |
185 | * @return GNUNET_OK to keep the connection open, | 175 | * @param peer Message sender (neighbor). |
186 | * GNUNET_SYSERR to close it (signal serious error) | 176 | * @param msg Message itself. |
187 | */ | 177 | */ |
188 | int | 178 | void |
189 | GCC_handle_kx (void *cls, const struct GNUNET_PeerIdentity *peer, | 179 | GCC_handle_poll (struct CadetPeer *peer, |
190 | const struct GNUNET_MessageHeader *message); | 180 | const struct GNUNET_CADET_Poll *msg); |
191 | 181 | ||
192 | /** | 182 | /** |
193 | * Core handler for encrypted cadet network traffic (channel mgmt, data). | 183 | * Handler for key exchange traffic (Axolotl KX). |
194 | * | 184 | * |
195 | * @param cls Closure (unused). | 185 | * @param peer Message sender (neighbor). |
196 | * @param message Message received. | 186 | * @param msg Message itself. |
197 | * @param peer Peer who sent the message. | 187 | */ |
188 | void | ||
189 | GCC_handle_kx (struct CadetPeer *peer, | ||
190 | const struct GNUNET_CADET_KX *msg); | ||
191 | |||
192 | /** | ||
193 | * Handler for encrypted cadet network traffic (channel mgmt, data). | ||
198 | * | 194 | * |
199 | * @return GNUNET_OK to keep the connection open, | 195 | * @param peer Message sender (neighbor). |
200 | * GNUNET_SYSERR to close it (signal serious error) | 196 | * @param msg Message itself. |
201 | */ | 197 | */ |
202 | int | 198 | void |
203 | GCC_handle_encrypted (void *cls, const struct GNUNET_PeerIdentity *peer, | 199 | GCC_handle_encrypted (struct CadetPeer *peer, |
204 | const struct GNUNET_MessageHeader *message); | 200 | const struct GNUNET_CADET_AX *msg); |
205 | 201 | ||
206 | /** | 202 | /** |
207 | * Core handler for axolotl key exchange traffic. | 203 | * Core handler for axolotl key exchange traffic. |
@@ -230,34 +226,6 @@ GCC_handle_ax (void *cls, const struct GNUNET_PeerIdentity *peer, | |||
230 | struct GNUNET_MessageHeader *message); | 226 | struct GNUNET_MessageHeader *message); |
231 | 227 | ||
232 | /** | 228 | /** |
233 | * Core handler for cadet network traffic point-to-point acks. | ||
234 | * | ||
235 | * @param cls closure | ||
236 | * @param message message | ||
237 | * @param peer peer identity this notification is about | ||
238 | * | ||
239 | * @return GNUNET_OK to keep the connection open, | ||
240 | * GNUNET_SYSERR to close it (signal serious error) | ||
241 | */ | ||
242 | int | ||
243 | GCC_handle_ack (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
244 | const struct GNUNET_MessageHeader *message); | ||
245 | |||
246 | /** | ||
247 | * Core handler for cadet network traffic point-to-point ack polls. | ||
248 | * | ||
249 | * @param cls closure | ||
250 | * @param message message | ||
251 | * @param peer peer identity this notification is about | ||
252 | * | ||
253 | * @return GNUNET_OK to keep the connection open, | ||
254 | * GNUNET_SYSERR to close it (signal serious error) | ||
255 | */ | ||
256 | int | ||
257 | GCC_handle_poll (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
258 | const struct GNUNET_MessageHeader *message); | ||
259 | |||
260 | /** | ||
261 | * Core handler for cadet keepalives. | 229 | * Core handler for cadet keepalives. |
262 | * | 230 | * |
263 | * @param cls closure | 231 | * @param cls closure |
@@ -301,11 +269,12 @@ GCC_shutdown (void); | |||
301 | * Create a connection. | 269 | * Create a connection. |
302 | * | 270 | * |
303 | * @param cid Connection ID (either created locally or imposed remotely). | 271 | * @param cid Connection ID (either created locally or imposed remotely). |
304 | * @param t Tunnel this connection belongs to (or NULL); | 272 | * @param t Tunnel this connection belongs to (or NULL for transit connections); |
305 | * @param path Path this connection has to use (copy is made). | 273 | * @param path Path this connection has to use (copy is made). |
306 | * @param own_pos Own position in the @c path path. | 274 | * @param own_pos Own position in the @c path path. |
307 | * | 275 | * |
308 | * @return Newly created connection, NULL in case of error (own id not in path). | 276 | * @return Newly created connection. |
277 | * NULL in case of error: own id not in path, wrong neighbors, ... | ||
309 | */ | 278 | */ |
310 | struct CadetConnection * | 279 | struct CadetConnection * |
311 | GCC_new (const struct GNUNET_CADET_Hash *cid, | 280 | GCC_new (const struct GNUNET_CADET_Hash *cid, |
@@ -525,6 +494,7 @@ GCC_cancel (struct CadetConnectionQueue *q); | |||
525 | * @param message Message to send. Function makes a copy of it. | 494 | * @param message Message to send. Function makes a copy of it. |
526 | * If message is not hop-by-hop, decrements TTL of copy. | 495 | * If message is not hop-by-hop, decrements TTL of copy. |
527 | * @param payload_type Type of payload, in case the message is encrypted. | 496 | * @param payload_type Type of payload, in case the message is encrypted. |
497 | * @param payload_id ID of the payload (PID, ACK, ...). | ||
528 | * @param c Connection on which this message is transmitted. | 498 | * @param c Connection on which this message is transmitted. |
529 | * @param fwd Is this a fwd message? | 499 | * @param fwd Is this a fwd message? |
530 | * @param force Force the connection to accept the message (buffer overfill). | 500 | * @param force Force the connection to accept the message (buffer overfill). |
diff --git a/src/cadet/gnunet-service-cadet_local.c b/src/cadet/gnunet-service-cadet_local.c index 303eaee86..9be1224c1 100644 --- a/src/cadet/gnunet-service-cadet_local.c +++ b/src/cadet/gnunet-service-cadet_local.c | |||
@@ -720,8 +720,6 @@ show_peer_iterator (void *cls, | |||
720 | struct CadetPeer *p = value; | 720 | struct CadetPeer *p = value; |
721 | struct CadetTunnel *t; | 721 | struct CadetTunnel *t; |
722 | 722 | ||
723 | GCP_debug (p, GNUNET_ERROR_TYPE_ERROR); | ||
724 | |||
725 | t = GCP_get_tunnel (p); | 723 | t = GCP_get_tunnel (p); |
726 | if (NULL != t) | 724 | if (NULL != t) |
727 | GCT_debug (t, GNUNET_ERROR_TYPE_ERROR); | 725 | GCT_debug (t, GNUNET_ERROR_TYPE_ERROR); |
diff --git a/src/cadet/gnunet-service-cadet_peer.c b/src/cadet/gnunet-service-cadet_peer.c index 64d9168fd..5ccd8f014 100644 --- a/src/cadet/gnunet-service-cadet_peer.c +++ b/src/cadet/gnunet-service-cadet_peer.c | |||
@@ -44,164 +44,145 @@ | |||
44 | /******************************** STRUCTS **********************************/ | 44 | /******************************** STRUCTS **********************************/ |
45 | /******************************************************************************/ | 45 | /******************************************************************************/ |
46 | 46 | ||
47 | |||
47 | /** | 48 | /** |
48 | * Struct containing info about a queued transmission to this peer | 49 | * Struct containing all information regarding a given peer |
49 | */ | 50 | */ |
50 | struct CadetPeerQueue | 51 | struct CadetPeer |
51 | { | 52 | { |
52 | /** | 53 | /** |
53 | * DLL next | 54 | * ID of the peer |
54 | */ | 55 | */ |
55 | struct CadetPeerQueue *next; | 56 | GNUNET_PEER_Id id; |
56 | 57 | ||
57 | /** | 58 | /** |
58 | * DLL previous | 59 | * Last time we heard from this peer |
59 | */ | 60 | */ |
60 | struct CadetPeerQueue *prev; | 61 | struct GNUNET_TIME_Absolute last_contact; |
61 | 62 | ||
62 | /** | 63 | /** |
63 | * Peer this transmission is directed to. | 64 | * Paths to reach the peer, ordered by ascending hop count |
64 | */ | 65 | */ |
65 | struct CadetPeer *peer; | 66 | struct CadetPeerPath *path_head; |
66 | 67 | ||
67 | /** | 68 | /** |
68 | * Connection this message belongs to. | 69 | * Paths to reach the peer, ordered by ascending hop count |
69 | */ | 70 | */ |
70 | struct CadetConnection *c; | 71 | struct CadetPeerPath *path_tail; |
71 | 72 | ||
72 | /** | 73 | /** |
73 | * Is FWD in c? | 74 | * Handle to stop the DHT search for paths to this peer |
74 | */ | 75 | */ |
75 | int fwd; | 76 | struct GCD_search_handle *search_h; |
76 | 77 | ||
77 | /** | 78 | /** |
78 | * Pointer to info stucture used as cls. | 79 | * Handle to stop the DHT search for paths to this peer |
79 | */ | 80 | */ |
80 | void *cls; | 81 | struct GNUNET_SCHEDULER_Task *search_delayed; |
81 | 82 | ||
82 | /** | 83 | /** |
83 | * Type of message | 84 | * Tunnel to this peer, if any. |
84 | */ | 85 | */ |
85 | uint16_t type; | 86 | struct CadetTunnel *tunnel; |
86 | 87 | ||
87 | /** | 88 | /** |
88 | * Type of message | 89 | * Connections that go through this peer; indexed by tid. |
89 | */ | 90 | */ |
90 | uint16_t payload_type; | 91 | struct GNUNET_CONTAINER_MultiHashMap *connections; |
91 | 92 | ||
92 | /** | 93 | /** |
93 | * Type of message | 94 | * Handle for core transmissions. |
94 | */ | 95 | */ |
95 | uint32_t payload_id; | 96 | struct GNUNET_MQ_Handle *core_mq; |
96 | 97 | ||
97 | /** | 98 | /** |
98 | * Size of the message | 99 | * How many messages are in the queue to this peer. |
99 | */ | 100 | */ |
100 | size_t size; | 101 | unsigned int queue_n; |
101 | 102 | ||
102 | /** | 103 | /** |
103 | * Set when this message starts waiting for CORE. | 104 | * Hello message. |
104 | */ | 105 | */ |
105 | struct GNUNET_TIME_Absolute start_waiting; | 106 | struct GNUNET_HELLO_Message* hello; |
106 | 107 | ||
107 | /** | 108 | /** |
108 | * Function to call on sending. | 109 | * Handle to us offering the HELLO to the transport. |
109 | */ | 110 | */ |
110 | GCP_sent cont; | 111 | struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer; |
111 | 112 | ||
112 | /** | 113 | /** |
113 | * Closure for callback. | 114 | * Handle to our ATS request asking ATS to suggest an address |
115 | * to TRANSPORT for this peer (to establish a direct link). | ||
114 | */ | 116 | */ |
115 | void *cont_cls; | 117 | struct GNUNET_ATS_ConnectivitySuggestHandle *connectivity_suggestion; |
118 | |||
116 | }; | 119 | }; |
117 | 120 | ||
118 | 121 | ||
119 | /** | 122 | /** |
120 | * Struct containing all information regarding a given peer | 123 | * Information about a queued message on the peer level. |
121 | */ | 124 | */ |
122 | struct CadetPeer | 125 | struct CadetPeerQueue { |
123 | { | ||
124 | /** | ||
125 | * ID of the peer | ||
126 | */ | ||
127 | GNUNET_PEER_Id id; | ||
128 | 126 | ||
129 | /** | 127 | /** |
130 | * Last time we heard from this peer | 128 | * Envelope to cancel message before MQ sends it. |
131 | */ | ||
132 | struct GNUNET_TIME_Absolute last_contact; | ||
133 | |||
134 | /** | ||
135 | * Paths to reach the peer, ordered by ascending hop count | ||
136 | */ | 129 | */ |
137 | struct CadetPeerPath *path_head; | 130 | struct GNUNET_MQ_Envelope *env; |
138 | 131 | ||
139 | /** | 132 | /** |
140 | * Paths to reach the peer, ordered by ascending hop count | 133 | * Peer (neighbor) this message is being sent to. |
141 | */ | 134 | */ |
142 | struct CadetPeerPath *path_tail; | 135 | struct CadetPeer *peer; |
143 | |||
144 | /** | ||
145 | * Handle to stop the DHT search for paths to this peer | ||
146 | */ | ||
147 | struct GCD_search_handle *search_h; | ||
148 | |||
149 | /** | ||
150 | * Handle to stop the DHT search for paths to this peer | ||
151 | */ | ||
152 | struct GNUNET_SCHEDULER_Task *search_delayed; | ||
153 | 136 | ||
154 | /** | 137 | /** |
155 | * Tunnel to this peer, if any. | 138 | * Continuation to call to notify higher layers about message sent. |
156 | */ | 139 | */ |
157 | struct CadetTunnel *tunnel; | 140 | GCP_sent cont; |
158 | 141 | ||
159 | /** | 142 | /** |
160 | * Connections that go through this peer; indexed by tid. | 143 | * Closure for @a cont. |
161 | */ | 144 | */ |
162 | struct GNUNET_CONTAINER_MultiHashMap *connections; | 145 | void *cont_cls; |
163 | 146 | ||
164 | /** | 147 | /** |
165 | * Handle for queued transmissions | 148 | * Time when message was queued for sending. |
166 | */ | 149 | */ |
167 | struct GNUNET_CORE_TransmitHandle *core_transmit; | 150 | struct GNUNET_TIME_Absolute queue_timestamp; |
168 | 151 | ||
169 | /** | 152 | /** |
170 | * Timestamp | 153 | * #GNUNET_YES if message was management traffic (POLL, ACK, ...). |
171 | */ | 154 | */ |
172 | struct GNUNET_TIME_Absolute tmt_time; | 155 | int management_traffic; |
173 | 156 | ||
174 | /** | 157 | /** |
175 | * Transmission queue to core DLL head | 158 | * Message type. |
176 | */ | 159 | */ |
177 | struct CadetPeerQueue *queue_head; | 160 | uint16_t type; |
178 | 161 | ||
179 | /** | 162 | /** |
180 | * Transmission queue to core DLL tail | 163 | * Message size. |
181 | */ | 164 | */ |
182 | struct CadetPeerQueue *queue_tail; | 165 | uint16_t size; |
183 | 166 | ||
184 | /** | 167 | /** |
185 | * How many messages are in the queue to this peer. | 168 | * Type of the message's payload, if it was encrypted data. |
186 | */ | 169 | */ |
187 | unsigned int queue_n; | 170 | uint16_t payload_type; |
188 | 171 | ||
189 | /** | 172 | /** |
190 | * Hello message. | 173 | *ID of the payload (PID, ACK #, ...). |
191 | */ | 174 | */ |
192 | struct GNUNET_HELLO_Message* hello; | 175 | uint16_t payload_id; |
193 | 176 | ||
194 | /** | 177 | /** |
195 | * Handle to us offering the HELLO to the transport. | 178 | * Connection this message was sent on. |
196 | */ | 179 | */ |
197 | struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer; | 180 | struct CadetConnection *c; |
198 | 181 | ||
199 | /** | 182 | /** |
200 | * Handle to our ATS request asking ATS to suggest an address | 183 | * Direction in @a c this message was send on (#GNUNET_YES = FWD). |
201 | * to TRANSPORT for this peer (to establish a direct link). | ||
202 | */ | 184 | */ |
203 | struct GNUNET_ATS_ConnectivitySuggestHandle *connectivity_suggestion; | 185 | int c_fwd; |
204 | |||
205 | }; | 186 | }; |
206 | 187 | ||
207 | 188 | ||
@@ -261,98 +242,6 @@ static int in_shutdown; | |||
261 | 242 | ||
262 | 243 | ||
263 | /******************************************************************************/ | 244 | /******************************************************************************/ |
264 | /***************************** DEBUG *********************************/ | ||
265 | /******************************************************************************/ | ||
266 | |||
267 | /** | ||
268 | * Log all kinds of info about the queueing status of a peer. | ||
269 | * | ||
270 | * @param p Peer whose queue to show. | ||
271 | * @param level Error level to use for logging. | ||
272 | */ | ||
273 | static void | ||
274 | queue_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level) | ||
275 | { | ||
276 | struct GNUNET_TIME_Relative core_wait_time; | ||
277 | struct CadetPeerQueue *q; | ||
278 | int do_log; | ||
279 | |||
280 | do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK), | ||
281 | "cadet-p2p", | ||
282 | __FILE__, __FUNCTION__, __LINE__); | ||
283 | if (0 == do_log) | ||
284 | return; | ||
285 | |||
286 | LOG2 (level, "QQQ Message queue towards %s\n", GCP_2s (p)); | ||
287 | LOG2 (level, "QQQ queue length: %u\n", p->queue_n); | ||
288 | LOG2 (level, "QQQ core tmt rdy: %p\n", p->core_transmit); | ||
289 | if (NULL != p->core_transmit) | ||
290 | { | ||
291 | core_wait_time = GNUNET_TIME_absolute_get_duration (p->tmt_time); | ||
292 | LOG2 (level, "QQQ core called %s ago\n", | ||
293 | GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_NO)); | ||
294 | } | ||
295 | for (q = p->queue_head; NULL != q; q = q->next) | ||
296 | { | ||
297 | LOG2 (level, "QQQ - %s %s on %s\n", | ||
298 | GC_m2s (q->type), GC_f2s (q->fwd), GCC_2s (q->c)); | ||
299 | LOG2 (level, "QQQ payload %s, %u\n", | ||
300 | GC_m2s (q->payload_type), q->payload_id); | ||
301 | LOG2 (level, "QQQ size: %u bytes\n", q->size); | ||
302 | } | ||
303 | |||
304 | LOG2 (level, "QQQ End queue towards %s\n", GCP_2s (p)); | ||
305 | } | ||
306 | |||
307 | |||
308 | /** | ||
309 | * Log all kinds of info about a peer. | ||
310 | * | ||
311 | * @param peer Peer. | ||
312 | */ | ||
313 | void | ||
314 | GCP_debug (const struct CadetPeer *p, enum GNUNET_ErrorType level) | ||
315 | { | ||
316 | struct CadetPeerPath *path; | ||
317 | unsigned int conns; | ||
318 | int do_log; | ||
319 | |||
320 | do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK), | ||
321 | "cadet-p2p", | ||
322 | __FILE__, __FUNCTION__, __LINE__); | ||
323 | if (0 == do_log) | ||
324 | return; | ||
325 | |||
326 | if (NULL == p) | ||
327 | { | ||
328 | LOG2 (level, "PPP DEBUG PEER NULL\n"); | ||
329 | return; | ||
330 | } | ||
331 | |||
332 | LOG2 (level, "PPP DEBUG PEER %s\n", GCP_2s (p)); | ||
333 | LOG2 (level, "PPP last contact %s\n", | ||
334 | GNUNET_STRINGS_absolute_time_to_string (p->last_contact)); | ||
335 | for (path = p->path_head; NULL != path; path = path->next) | ||
336 | { | ||
337 | char *s; | ||
338 | |||
339 | s = path_2s (path); | ||
340 | LOG2 (level, "PPP path: %s\n", s); | ||
341 | GNUNET_free (s); | ||
342 | } | ||
343 | |||
344 | LOG2 (level, "PPP core transmit handle %p\n", p->core_transmit); | ||
345 | LOG2 (level, "PPP DHT GET handle %p\n", p->search_h); | ||
346 | conns = 0; | ||
347 | if (NULL != p->connections) | ||
348 | conns += GNUNET_CONTAINER_multihashmap_size (p->connections); | ||
349 | LOG2 (level, "PPP # connections over link to peer: %u\n", conns); | ||
350 | queue_debug (p, level); | ||
351 | LOG2 (level, "PPP DEBUG END\n"); | ||
352 | } | ||
353 | |||
354 | |||
355 | /******************************************************************************/ | ||
356 | /***************************** CORE HELPERS *********************************/ | 245 | /***************************** CORE HELPERS *********************************/ |
357 | /******************************************************************************/ | 246 | /******************************************************************************/ |
358 | 247 | ||
@@ -415,12 +304,16 @@ pop_direct_path (struct CadetPeer *peer) | |||
415 | /** | 304 | /** |
416 | * Method called whenever a given peer connects. | 305 | * Method called whenever a given peer connects. |
417 | * | 306 | * |
418 | * @param cls closure | 307 | * @param cls Core closure (unused). |
419 | * @param peer peer identity this notification is about | 308 | * @param peer Peer identity this notification is about |
309 | * @param mq Message Queue to this peer. | ||
310 | * | ||
311 | * @return Internal closure for handlers (CadetPeer struct). | ||
420 | */ | 312 | */ |
421 | static void | 313 | static void * |
422 | core_connect (void *cls, | 314 | core_connect_handler (void *cls, |
423 | const struct GNUNET_PeerIdentity *peer) | 315 | const struct GNUNET_PeerIdentity *peer, |
316 | struct GNUNET_MQ_Handle *mq) | ||
424 | { | 317 | { |
425 | struct CadetPeer *neighbor; | 318 | struct CadetPeer *neighbor; |
426 | struct CadetPeerPath *path; | 319 | struct CadetPeerPath *path; |
@@ -431,6 +324,8 @@ core_connect (void *cls, | |||
431 | sizeof (own_id), | 324 | sizeof (own_id), |
432 | "%s", | 325 | "%s", |
433 | GNUNET_i2s (&my_full_id)); | 326 | GNUNET_i2s (&my_full_id)); |
327 | |||
328 | /* Save a path to the neighbor */ | ||
434 | neighbor = GCP_get (peer, GNUNET_YES); | 329 | neighbor = GCP_get (peer, GNUNET_YES); |
435 | if (myid == neighbor->id) | 330 | if (myid == neighbor->id) |
436 | { | 331 | { |
@@ -448,11 +343,14 @@ core_connect (void *cls, | |||
448 | path = path_new (2); | 343 | path = path_new (2); |
449 | path->peers[1] = neighbor->id; | 344 | path->peers[1] = neighbor->id; |
450 | GNUNET_PEER_change_rc (neighbor->id, 1); | 345 | GNUNET_PEER_change_rc (neighbor->id, 1); |
346 | GNUNET_assert (NULL == neighbor->core_mq); | ||
347 | neighbor->core_mq = mq; | ||
451 | } | 348 | } |
452 | path->peers[0] = myid; | 349 | path->peers[0] = myid; |
453 | GNUNET_PEER_change_rc (myid, 1); | 350 | GNUNET_PEER_change_rc (myid, 1); |
454 | GCP_add_path (neighbor, path, GNUNET_YES); | 351 | GCP_add_path (neighbor, path, GNUNET_YES); |
455 | 352 | ||
353 | /* Create the connections hashmap */ | ||
456 | GNUNET_assert (NULL == neighbor->connections); | 354 | GNUNET_assert (NULL == neighbor->connections); |
457 | neighbor->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO); | 355 | neighbor->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO); |
458 | GNUNET_STATISTICS_update (stats, | 356 | GNUNET_STATISTICS_update (stats, |
@@ -462,42 +360,47 @@ core_connect (void *cls, | |||
462 | 360 | ||
463 | if ( (NULL != GCP_get_tunnel (neighbor)) && | 361 | if ( (NULL != GCP_get_tunnel (neighbor)) && |
464 | (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer)) ) | 362 | (0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer)) ) |
363 | { | ||
465 | GCP_connect (neighbor); | 364 | GCP_connect (neighbor); |
365 | } | ||
466 | GCC_check_connections (); | 366 | GCC_check_connections (); |
367 | |||
368 | return neighbor; | ||
467 | } | 369 | } |
468 | 370 | ||
469 | 371 | ||
470 | /** | 372 | /** |
471 | * Method called whenever a peer disconnects. | 373 | * Method called whenever a peer disconnects. |
472 | * | 374 | * |
473 | * @param cls closure | 375 | * @param cls Core closure (unused). |
474 | * @param peer peer identity this notification is about | 376 | * @param peer Peer identity this notification is about. |
377 | * @param internal_cls Internal closure (CadetPeer struct). | ||
475 | */ | 378 | */ |
476 | static void | 379 | static void |
477 | core_disconnect (void *cls, | 380 | core_disconnect_handler (void *cls, |
478 | const struct GNUNET_PeerIdentity *peer) | 381 | const struct GNUNET_PeerIdentity *peer, |
382 | void *internal_cls) | ||
479 | { | 383 | { |
480 | struct CadetPeer *p; | 384 | struct CadetPeer *p = internal_cls; |
481 | struct CadetPeerPath *direct_path; | 385 | struct CadetPeerPath *direct_path; |
482 | char own_id[16]; | 386 | char own_id[16]; |
483 | 387 | ||
484 | GCC_check_connections (); | 388 | GCC_check_connections (); |
485 | strncpy (own_id, GNUNET_i2s (&my_full_id), 16); | 389 | strncpy (own_id, GNUNET_i2s (&my_full_id), 16); |
486 | own_id[15] = '\0'; | 390 | own_id[15] = '\0'; |
487 | p = GNUNET_CONTAINER_multipeermap_get (peers, peer); | ||
488 | if (NULL == p) | ||
489 | { | ||
490 | GNUNET_break (GNUNET_YES == in_shutdown); | ||
491 | return; | ||
492 | } | ||
493 | if (myid == p->id) | 391 | if (myid == p->id) |
392 | { | ||
494 | LOG (GNUNET_ERROR_TYPE_INFO, | 393 | LOG (GNUNET_ERROR_TYPE_INFO, |
495 | "DISCONNECTED %s (self)\n", | 394 | "DISCONNECTED %s (self)\n", |
496 | own_id); | 395 | own_id); |
396 | } | ||
497 | else | 397 | else |
398 | { | ||
498 | LOG (GNUNET_ERROR_TYPE_INFO, | 399 | LOG (GNUNET_ERROR_TYPE_INFO, |
499 | "DISCONNECTED %s <= %s\n", | 400 | "DISCONNECTED %s <= %s\n", |
500 | own_id, GNUNET_i2s (peer)); | 401 | own_id, GNUNET_i2s (peer)); |
402 | p->core_mq = NULL; | ||
403 | } | ||
501 | direct_path = pop_direct_path (p); | 404 | direct_path = pop_direct_path (p); |
502 | if (NULL != p->connections) | 405 | if (NULL != p->connections) |
503 | { | 406 | { |
@@ -507,12 +410,6 @@ core_disconnect (void *cls, | |||
507 | GNUNET_CONTAINER_multihashmap_destroy (p->connections); | 410 | GNUNET_CONTAINER_multihashmap_destroy (p->connections); |
508 | p->connections = NULL; | 411 | p->connections = NULL; |
509 | } | 412 | } |
510 | if (NULL != p->core_transmit) | ||
511 | { | ||
512 | GNUNET_CORE_notify_transmit_ready_cancel (p->core_transmit); | ||
513 | p->core_transmit = NULL; | ||
514 | p->tmt_time.abs_value_us = 0; | ||
515 | } | ||
516 | GNUNET_STATISTICS_update (stats, | 413 | GNUNET_STATISTICS_update (stats, |
517 | "# peers", | 414 | "# peers", |
518 | -1, | 415 | -1, |
@@ -522,167 +419,283 @@ core_disconnect (void *cls, | |||
522 | } | 419 | } |
523 | 420 | ||
524 | 421 | ||
422 | /******************************************************************************/ | ||
423 | /******************************************************************************/ | ||
424 | /******************************************************************************/ | ||
425 | /******************************************************************************/ | ||
426 | /******************************************************************************/ | ||
427 | |||
525 | /** | 428 | /** |
526 | * Functions to handle messages from core | 429 | * Check if the create_connection message has the appropriate size. |
527 | */ | 430 | * |
528 | static struct GNUNET_CORE_MessageHandler core_handlers[] = { | 431 | * @param cls Closure (unused). |
529 | {&GCC_handle_create, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, 0}, | 432 | * @param msg Message to check. |
530 | {&GCC_handle_confirm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, | 433 | * |
531 | sizeof (struct GNUNET_CADET_ConnectionACK)}, | 434 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. |
532 | {&GCC_handle_broken, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, | 435 | */ |
533 | sizeof (struct GNUNET_CADET_ConnectionBroken)}, | 436 | static int |
534 | {&GCC_handle_destroy, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, | 437 | check_create (void *cls, const struct GNUNET_CADET_ConnectionCreate *msg) |
535 | sizeof (struct GNUNET_CADET_ConnectionDestroy)}, | 438 | { |
536 | {&GCC_handle_ack, GNUNET_MESSAGE_TYPE_CADET_ACK, | 439 | uint16_t size; |
537 | sizeof (struct GNUNET_CADET_ACK)}, | ||
538 | {&GCC_handle_poll, GNUNET_MESSAGE_TYPE_CADET_POLL, | ||
539 | sizeof (struct GNUNET_CADET_Poll)}, | ||
540 | {&GCC_handle_kx, GNUNET_MESSAGE_TYPE_CADET_KX, 0}, | ||
541 | {&GCC_handle_encrypted, GNUNET_MESSAGE_TYPE_CADET_AX, 0}, | ||
542 | {NULL, 0, 0} | ||
543 | }; | ||
544 | 440 | ||
441 | size = ntohs (msg->header.size); | ||
442 | if (size < sizeof (*msg)) | ||
443 | { | ||
444 | GNUNET_break_op (0); | ||
445 | return GNUNET_NO; | ||
446 | } | ||
447 | return GNUNET_YES; | ||
448 | } | ||
545 | 449 | ||
546 | /** | 450 | /** |
547 | * To be called on core init/fail. | 451 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE |
548 | * | 452 | * |
549 | * @param cls Closure (config) | 453 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
550 | * @param identity the public identity of this peer | 454 | * @param msg Message itself. |
551 | */ | 455 | */ |
552 | static void | 456 | static void |
553 | core_init (void *cls, | 457 | handle_create (void *cls, const struct GNUNET_CADET_ConnectionCreate *msg) |
554 | const struct GNUNET_PeerIdentity *identity) | ||
555 | { | 458 | { |
556 | const struct GNUNET_CONFIGURATION_Handle *c = cls; | 459 | struct CadetPeer *peer = cls; |
557 | static int i = 0; | 460 | GCC_handle_create (peer, msg); |
461 | } | ||
558 | 462 | ||
559 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n"); | 463 | |
560 | if (0 != memcmp (identity, &my_full_id, sizeof (my_full_id))) | 464 | /** |
561 | { | 465 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK |
562 | LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n")); | 466 | * |
563 | LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (identity)); | 467 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
564 | LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id)); | 468 | * @param msg Message itself. |
565 | GNUNET_CORE_disconnect (core_handle); | 469 | */ |
566 | core_handle = GNUNET_CORE_connect (c, /* Main configuration */ | 470 | static void |
567 | NULL, /* Closure passed to CADET functions */ | 471 | handle_confirm (void *cls, const struct GNUNET_CADET_ConnectionACK *msg) |
568 | &core_init, /* Call core_init once connected */ | 472 | { |
569 | &core_connect, /* Handle connects */ | 473 | struct CadetPeer *peer = cls; |
570 | &core_disconnect, /* remove peers on disconnects */ | 474 | GCC_handle_confirm (peer, msg); |
571 | NULL, /* Don't notify about all incoming messages */ | ||
572 | GNUNET_NO, /* For header only in notification */ | ||
573 | NULL, /* Don't notify about all outbound messages */ | ||
574 | GNUNET_NO, /* For header-only out notification */ | ||
575 | core_handlers); /* Register these handlers */ | ||
576 | if (10 < i++) | ||
577 | GNUNET_assert (0); | ||
578 | } | ||
579 | GML_start (); | ||
580 | } | 475 | } |
581 | 476 | ||
582 | 477 | ||
583 | /** | 478 | /** |
584 | * Core callback to write a pre-constructed data packet to core buffer | 479 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN |
585 | * | 480 | * |
586 | * @param cls Closure (CadetTransmissionDescriptor with data in "data" member). | 481 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
587 | * @param size Number of bytes available in buf. | 482 | * @param msg Message itself. |
588 | * @param buf Where the to write the message. | 483 | */ |
589 | * | 484 | static void |
590 | * @return number of bytes written to buf | 485 | handle_broken (void *cls, const struct GNUNET_CADET_ConnectionBroken *msg) |
591 | */ | ||
592 | static size_t | ||
593 | send_core_data_raw (void *cls, size_t size, void *buf) | ||
594 | { | 486 | { |
595 | struct GNUNET_MessageHeader *msg = cls; | 487 | struct CadetPeer *peer = cls; |
596 | size_t total_size; | 488 | GCC_handle_broken (peer, msg); |
489 | } | ||
597 | 490 | ||
598 | GNUNET_assert (NULL != msg); | ||
599 | total_size = ntohs (msg->size); | ||
600 | 491 | ||
601 | if (total_size > size) | 492 | /** |
602 | { | 493 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY |
603 | GNUNET_break (0); | 494 | * |
604 | return 0; | 495 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
605 | } | 496 | * @param msg Message itself. |
606 | GNUNET_memcpy (buf, msg, total_size); | 497 | */ |
607 | GNUNET_free (cls); | 498 | static void |
608 | return total_size; | 499 | handle_destroy (void *cls, const struct GNUNET_CADET_ConnectionDestroy *msg) |
500 | { | ||
501 | struct CadetPeer *peer = cls; | ||
502 | GCC_handle_destroy (peer, msg); | ||
609 | } | 503 | } |
610 | 504 | ||
611 | 505 | ||
612 | /** | 506 | /** |
613 | * Function to send a create connection message to a peer. | 507 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_ACK |
614 | * | 508 | * |
615 | * @param c Connection to create. | 509 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
616 | * @param size number of bytes available in buf | 510 | * @param msg Message itself. |
617 | * @param buf where the callee should write the message | ||
618 | * @return number of bytes written to buf | ||
619 | */ | 511 | */ |
620 | static size_t | 512 | static void |
621 | send_core_connection_create (struct CadetConnection *c, size_t size, void *buf) | 513 | handle_ack (void *cls, const struct GNUNET_CADET_ACK *msg) |
622 | { | 514 | { |
623 | struct GNUNET_CADET_ConnectionCreate *msg; | 515 | struct CadetPeer *peer = cls; |
624 | struct GNUNET_PeerIdentity *peer_ptr; | 516 | GCC_handle_ack (peer, msg); |
625 | const struct CadetPeerPath *p = GCC_get_path (c); | 517 | } |
626 | size_t size_needed; | ||
627 | int i; | ||
628 | 518 | ||
629 | if (NULL == p) | ||
630 | return 0; | ||
631 | 519 | ||
632 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION CREATE...\n"); | 520 | /** |
633 | size_needed = | 521 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_POLL |
634 | sizeof (struct GNUNET_CADET_ConnectionCreate) + | 522 | * |
635 | p->length * sizeof (struct GNUNET_PeerIdentity); | 523 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
524 | * @param msg Message itself. | ||
525 | */ | ||
526 | static void | ||
527 | handle_poll (void *cls, const struct GNUNET_CADET_Poll *msg) | ||
528 | { | ||
529 | struct CadetPeer *peer = cls; | ||
530 | GCC_handle_poll (peer, msg); | ||
531 | } | ||
636 | 532 | ||
637 | if (size < size_needed || NULL == buf) | 533 | |
534 | /** | ||
535 | * Check if the Key eXchange message has the appropriate size. | ||
536 | * | ||
537 | * @param cls Closure (unused). | ||
538 | * @param msg Message to check. | ||
539 | * | ||
540 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. | ||
541 | */ | ||
542 | static int | ||
543 | check_kx (void *cls, const struct GNUNET_CADET_KX *msg) | ||
544 | { | ||
545 | uint16_t size; | ||
546 | uint16_t expected_size; | ||
547 | |||
548 | size = ntohs (msg->header.size); | ||
549 | expected_size = sizeof (struct GNUNET_CADET_KX) | ||
550 | + sizeof (struct GNUNET_MessageHeader); | ||
551 | |||
552 | if (size < expected_size) | ||
638 | { | 553 | { |
639 | GNUNET_break (0); | 554 | GNUNET_break_op (0); |
640 | return 0; | 555 | return GNUNET_NO; |
641 | } | 556 | } |
642 | msg = (struct GNUNET_CADET_ConnectionCreate *) buf; | 557 | return GNUNET_YES; |
643 | msg->header.size = htons (size_needed); | 558 | } |
644 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE); | ||
645 | msg->cid = *GCC_get_id (c); | ||
646 | 559 | ||
647 | peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1]; | 560 | /** |
648 | for (i = 0; i < p->length; i++) | 561 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_KX |
562 | * | ||
563 | * @param cls Closure (CadetPeer for neighbor that sent the message). | ||
564 | * @param msg Message itself. | ||
565 | */ | ||
566 | static void | ||
567 | handle_kx (void *cls, const struct GNUNET_CADET_KX *msg) | ||
568 | { | ||
569 | struct CadetPeer *peer = cls; | ||
570 | GCC_handle_kx (peer, msg); | ||
571 | } | ||
572 | |||
573 | |||
574 | /** | ||
575 | * Check if the encrypted message has the appropriate size. | ||
576 | * | ||
577 | * @param cls Closure (unused). | ||
578 | * @param msg Message to check. | ||
579 | * | ||
580 | * @return #GNUNET_YES if size is correct, #GNUNET_NO otherwise. | ||
581 | */ | ||
582 | static int | ||
583 | check_encrypted (void *cls, const struct GNUNET_CADET_AX *msg) | ||
584 | { | ||
585 | uint16_t size; | ||
586 | uint16_t minimum_size; | ||
587 | |||
588 | size = ntohs (msg->header.size); | ||
589 | minimum_size = sizeof (struct GNUNET_CADET_AX) | ||
590 | + sizeof (struct GNUNET_MessageHeader); | ||
591 | |||
592 | if (size < minimum_size) | ||
649 | { | 593 | { |
650 | GNUNET_PEER_resolve (p->peers[i], peer_ptr++); | 594 | GNUNET_break_op (0); |
595 | return GNUNET_NO; | ||
651 | } | 596 | } |
597 | return GNUNET_YES; | ||
598 | } | ||
652 | 599 | ||
653 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 600 | /** |
654 | "CONNECTION CREATE (%u bytes long) sent!\n", | 601 | * Handle for #GNUNET_MESSAGE_TYPE_CADET_AX (AXolotl encrypted traffic). |
655 | size_needed); | 602 | * |
656 | return size_needed; | 603 | * @param cls Closure (CadetPeer for neighbor that sent the message). |
604 | * @param msg Message itself. | ||
605 | */ | ||
606 | static void | ||
607 | handle_encrypted (void *cls, const struct GNUNET_CADET_AX *msg) | ||
608 | { | ||
609 | struct CadetPeer *peer = cls; | ||
610 | GCC_handle_encrypted (peer, msg); | ||
657 | } | 611 | } |
658 | 612 | ||
659 | 613 | ||
660 | /** | 614 | /** |
661 | * Creates a path ack message in buf and frees all unused resources. | 615 | * To be called on core init/fail. |
662 | * | 616 | * |
663 | * @param c Connection to send an ACK on. | 617 | * @param cls Closure (config) |
664 | * @param size number of bytes available in buf | 618 | * @param identity The public identity of this peer. |
665 | * @param buf where the callee should write the message | 619 | */ |
620 | static void | ||
621 | core_init_notify (void *cls, | ||
622 | const struct GNUNET_PeerIdentity *identity); | ||
623 | |||
624 | |||
625 | static void | ||
626 | connect_to_core (const struct GNUNET_CONFIGURATION_Handle *c) | ||
627 | { | ||
628 | struct GNUNET_MQ_MessageHandler core_handlers[] = { | ||
629 | GNUNET_MQ_hd_var_size (create, | ||
630 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE, | ||
631 | struct GNUNET_CADET_ConnectionCreate, | ||
632 | NULL), | ||
633 | GNUNET_MQ_hd_fixed_size (confirm, | ||
634 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK, | ||
635 | struct GNUNET_CADET_ConnectionACK, | ||
636 | NULL), | ||
637 | GNUNET_MQ_hd_fixed_size (broken, | ||
638 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN, | ||
639 | struct GNUNET_CADET_ConnectionBroken, | ||
640 | NULL), | ||
641 | GNUNET_MQ_hd_fixed_size (destroy, | ||
642 | GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY, | ||
643 | struct GNUNET_CADET_ConnectionDestroy, | ||
644 | NULL), | ||
645 | GNUNET_MQ_hd_fixed_size (ack, | ||
646 | GNUNET_MESSAGE_TYPE_CADET_ACK, | ||
647 | struct GNUNET_CADET_ACK, | ||
648 | NULL), | ||
649 | GNUNET_MQ_hd_fixed_size (poll, | ||
650 | GNUNET_MESSAGE_TYPE_CADET_POLL, | ||
651 | struct GNUNET_CADET_Poll, | ||
652 | NULL), | ||
653 | GNUNET_MQ_hd_var_size (kx, | ||
654 | GNUNET_MESSAGE_TYPE_CADET_KX, | ||
655 | struct GNUNET_CADET_KX, | ||
656 | NULL), | ||
657 | GNUNET_MQ_hd_var_size (encrypted, | ||
658 | GNUNET_MESSAGE_TYPE_CADET_AX, | ||
659 | struct GNUNET_CADET_AX, | ||
660 | NULL), | ||
661 | GNUNET_MQ_handler_end () | ||
662 | }; | ||
663 | core_handle = GNUNET_CORE_connecT (c, NULL, | ||
664 | &core_init_notify, | ||
665 | &core_connect_handler, | ||
666 | &core_disconnect_handler, | ||
667 | core_handlers); | ||
668 | } | ||
669 | |||
670 | /******************************************************************************/ | ||
671 | /******************************************************************************/ | ||
672 | /******************************************************************************/ | ||
673 | /******************************************************************************/ | ||
674 | /******************************************************************************/ | ||
675 | |||
676 | /** | ||
677 | * To be called on core init/fail. | ||
666 | * | 678 | * |
667 | * @return number of bytes written to buf | 679 | * @param cls Closure (config) |
680 | * @param identity The public identity of this peer. | ||
668 | */ | 681 | */ |
669 | static size_t | 682 | static void |
670 | send_core_connection_ack (struct CadetConnection *c, size_t size, void *buf) | 683 | core_init_notify (void *cls, |
684 | const struct GNUNET_PeerIdentity *core_identity) | ||
671 | { | 685 | { |
672 | struct GNUNET_CADET_ConnectionACK *msg = buf; | 686 | const struct GNUNET_CONFIGURATION_Handle *c = cls; |
673 | 687 | ||
674 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n"); | 688 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Core init\n"); |
675 | if (sizeof (struct GNUNET_CADET_ConnectionACK) > size) | 689 | if (0 != memcmp (core_identity, &my_full_id, sizeof (my_full_id))) |
676 | { | 690 | { |
677 | GNUNET_break (0); | 691 | LOG (GNUNET_ERROR_TYPE_ERROR, _("Wrong CORE service\n")); |
678 | return 0; | 692 | LOG (GNUNET_ERROR_TYPE_ERROR, " core id %s\n", GNUNET_i2s (core_identity)); |
693 | LOG (GNUNET_ERROR_TYPE_ERROR, " my id %s\n", GNUNET_i2s (&my_full_id)); | ||
694 | GNUNET_CORE_disconnecT (core_handle); | ||
695 | connect_to_core (c); | ||
696 | return; | ||
679 | } | 697 | } |
680 | msg->header.size = htons (sizeof (struct GNUNET_CADET_ConnectionACK)); | 698 | GML_start (); |
681 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK); | ||
682 | msg->cid = *GCC_get_id (c); | ||
683 | |||
684 | LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTION ACK sent!\n"); | ||
685 | return sizeof (struct GNUNET_CADET_ConnectionACK); | ||
686 | } | 699 | } |
687 | 700 | ||
688 | 701 | ||
@@ -697,8 +710,11 @@ send_core_connection_ack (struct CadetConnection *c, size_t size, void *buf) | |||
697 | * @param q Queued message | 710 | * @param q Queued message |
698 | * | 711 | * |
699 | * @return CORE priority to use. | 712 | * @return CORE priority to use. |
713 | * | ||
714 | * FIXME make static | ||
715 | * FIXME use when sending | ||
700 | */ | 716 | */ |
701 | static enum GNUNET_CORE_Priority | 717 | enum GNUNET_CORE_Priority |
702 | get_priority (struct CadetPeerQueue *q) | 718 | get_priority (struct CadetPeerQueue *q) |
703 | { | 719 | { |
704 | enum GNUNET_CORE_Priority low; | 720 | enum GNUNET_CORE_Priority low; |
@@ -711,7 +727,7 @@ get_priority (struct CadetPeerQueue *q) | |||
711 | } | 727 | } |
712 | 728 | ||
713 | /* Relayed traffic has lower priority, our own traffic has higher */ | 729 | /* Relayed traffic has lower priority, our own traffic has higher */ |
714 | if (NULL == q->c || GNUNET_NO == GCC_is_origin (q->c, q->fwd)) | 730 | if (NULL == q->c || GNUNET_NO == GCC_is_origin (q->c, q->c_fwd)) |
715 | { | 731 | { |
716 | low = GNUNET_CORE_PRIO_BEST_EFFORT; | 732 | low = GNUNET_CORE_PRIO_BEST_EFFORT; |
717 | high = GNUNET_CORE_PRIO_URGENT; | 733 | high = GNUNET_CORE_PRIO_URGENT; |
@@ -784,20 +800,6 @@ peer_destroy (struct CadetPeer *peer) | |||
784 | GNUNET_ATS_connectivity_suggest_cancel (peer->connectivity_suggestion); | 800 | GNUNET_ATS_connectivity_suggest_cancel (peer->connectivity_suggestion); |
785 | peer->connectivity_suggestion = NULL; | 801 | peer->connectivity_suggestion = NULL; |
786 | } | 802 | } |
787 | while (NULL != peer->queue_head) | ||
788 | { | ||
789 | /* This function destroys the current peer->queue_head but | ||
790 | * replaces it with the next in the queue, so it is correct | ||
791 | * to while() here. | ||
792 | */ | ||
793 | GCP_queue_destroy (peer->queue_head, GNUNET_YES, GNUNET_NO, 0); | ||
794 | } | ||
795 | if (NULL != peer->core_transmit) | ||
796 | { | ||
797 | GNUNET_break (0); /* GCP_queue_destroy should've cancelled it! */ | ||
798 | GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit); | ||
799 | peer->core_transmit = NULL; | ||
800 | } | ||
801 | 803 | ||
802 | GNUNET_free_non_null (peer->hello); | 804 | GNUNET_free_non_null (peer->hello); |
803 | GNUNET_free (peer); | 805 | GNUNET_free (peer); |
@@ -831,7 +833,6 @@ shutdown_peer (void *cls, | |||
831 | } | 833 | } |
832 | 834 | ||
833 | 835 | ||
834 | |||
835 | /** | 836 | /** |
836 | * Check if peer is searching for a path (either active or delayed search). | 837 | * Check if peer is searching for a path (either active or delayed search). |
837 | * | 838 | * |
@@ -996,64 +997,6 @@ peer_get_best_path (const struct CadetPeer *peer) | |||
996 | 997 | ||
997 | 998 | ||
998 | /** | 999 | /** |
999 | * Is this queue element sendable? | ||
1000 | * | ||
1001 | * - All management traffic is always sendable. | ||
1002 | * - For payload traffic, check the connection flow control. | ||
1003 | * | ||
1004 | * @param q Queue element to inspect. | ||
1005 | * @return #GNUNET_YES if it is sendable, #GNUNET_NO otherwise. | ||
1006 | */ | ||
1007 | static int | ||
1008 | queue_is_sendable (struct CadetPeerQueue *q) | ||
1009 | { | ||
1010 | /* Is PID-independent? */ | ||
1011 | switch (q->type) | ||
1012 | { | ||
1013 | case GNUNET_MESSAGE_TYPE_CADET_ACK: | ||
1014 | case GNUNET_MESSAGE_TYPE_CADET_POLL: | ||
1015 | case GNUNET_MESSAGE_TYPE_CADET_KX: | ||
1016 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: | ||
1017 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: | ||
1018 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | ||
1019 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | ||
1020 | return GNUNET_YES; | ||
1021 | |||
1022 | case GNUNET_MESSAGE_TYPE_CADET_AX: | ||
1023 | break; | ||
1024 | |||
1025 | default: | ||
1026 | GNUNET_break (0); | ||
1027 | } | ||
1028 | |||
1029 | return GCC_is_sendable (q->c, q->fwd); | ||
1030 | } | ||
1031 | |||
1032 | |||
1033 | /** | ||
1034 | * Get first sendable message. | ||
1035 | * | ||
1036 | * @param peer The destination peer. | ||
1037 | * | ||
1038 | * @return First transmittable message, if any. Otherwise, NULL. | ||
1039 | */ | ||
1040 | static struct CadetPeerQueue * | ||
1041 | peer_get_first_message (const struct CadetPeer *peer) | ||
1042 | { | ||
1043 | struct CadetPeerQueue *q; | ||
1044 | |||
1045 | for (q = peer->queue_head; NULL != q; q = q->next) | ||
1046 | { | ||
1047 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Checking q:%p on c:%s\n", q, GCC_2s (q->c)); | ||
1048 | if (queue_is_sendable (q)) | ||
1049 | return q; | ||
1050 | } | ||
1051 | |||
1052 | return NULL; | ||
1053 | } | ||
1054 | |||
1055 | |||
1056 | /** | ||
1057 | * Function to process paths received for a new peer addition. The recorded | 1000 | * Function to process paths received for a new peer addition. The recorded |
1058 | * paths form the initial tunnel, which can be optimized later. | 1001 | * paths form the initial tunnel, which can be optimized later. |
1059 | * Called on each result obtained for the DHT search. | 1002 | * Called on each result obtained for the DHT search. |
@@ -1090,19 +1033,6 @@ search_handler (void *cls, const struct CadetPeerPath *path) | |||
1090 | 1033 | ||
1091 | 1034 | ||
1092 | /** | 1035 | /** |
1093 | * Adjust core requested size to accomodate an ACK. | ||
1094 | * | ||
1095 | * @param message_size Requested size. | ||
1096 | * | ||
1097 | * @return Size enough to fit @c message_size and an ACK. | ||
1098 | */ | ||
1099 | static size_t | ||
1100 | get_core_size (size_t message_size) | ||
1101 | { | ||
1102 | return message_size + sizeof (struct GNUNET_CADET_ACK); | ||
1103 | } | ||
1104 | |||
1105 | /** | ||
1106 | * Test if a message type is connection management traffic | 1036 | * Test if a message type is connection management traffic |
1107 | * or regular payload traffic. | 1037 | * or regular payload traffic. |
1108 | * | 1038 | * |
@@ -1119,85 +1049,13 @@ is_connection_management (uint16_t type) | |||
1119 | 1049 | ||
1120 | 1050 | ||
1121 | /** | 1051 | /** |
1122 | * Fill a core buffer with the appropriate data for the queued message. | ||
1123 | * | ||
1124 | * @param queue Queue element for the message. | ||
1125 | * @param buf Core buffer to fill. | ||
1126 | * @param size Size remaining in @c buf. | ||
1127 | * @param[out] pid In case its an encrypted payload, set payload. | ||
1128 | * | ||
1129 | * @return Bytes written to @c buf. | ||
1130 | */ | ||
1131 | static size_t | ||
1132 | fill_buf (struct CadetPeerQueue *queue, void *buf, size_t size, uint32_t *pid) | ||
1133 | { | ||
1134 | struct CadetConnection *c = queue->c; | ||
1135 | size_t msg_size; | ||
1136 | |||
1137 | switch (queue->type) | ||
1138 | { | ||
1139 | case GNUNET_MESSAGE_TYPE_CADET_AX: | ||
1140 | *pid = GCC_get_pid (queue->c, queue->fwd); | ||
1141 | LOG (GNUNET_ERROR_TYPE_DEBUG, " ax payload ID %u\n", *pid); | ||
1142 | msg_size = send_core_data_raw (queue->cls, size, buf); | ||
1143 | ((struct GNUNET_CADET_AX *) buf)->pid = htonl (*pid); | ||
1144 | break; | ||
1145 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | ||
1146 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | ||
1147 | case GNUNET_MESSAGE_TYPE_CADET_KX: | ||
1148 | case GNUNET_MESSAGE_TYPE_CADET_ACK: | ||
1149 | case GNUNET_MESSAGE_TYPE_CADET_POLL: | ||
1150 | LOG (GNUNET_ERROR_TYPE_DEBUG, " raw %s\n", GC_m2s (queue->type)); | ||
1151 | msg_size = send_core_data_raw (queue->cls, size, buf); | ||
1152 | break; | ||
1153 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: | ||
1154 | LOG (GNUNET_ERROR_TYPE_DEBUG, " path create\n"); | ||
1155 | if (GCC_is_origin (c, GNUNET_YES)) | ||
1156 | msg_size = send_core_connection_create (c, size, buf); | ||
1157 | else | ||
1158 | msg_size = send_core_data_raw (queue->cls, size, buf); | ||
1159 | break; | ||
1160 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: | ||
1161 | LOG (GNUNET_ERROR_TYPE_DEBUG, " path ack\n"); | ||
1162 | if (GCC_is_origin (c, GNUNET_NO) || | ||
1163 | GCC_is_origin (c, GNUNET_YES)) | ||
1164 | { | ||
1165 | msg_size = send_core_connection_ack (c, size, buf); | ||
1166 | } | ||
1167 | else | ||
1168 | { | ||
1169 | msg_size = send_core_data_raw (queue->cls, size, buf); | ||
1170 | } | ||
1171 | break; | ||
1172 | case GNUNET_MESSAGE_TYPE_CADET_DATA: | ||
1173 | case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_CREATE: | ||
1174 | case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY: | ||
1175 | /* This should be encapsulted */ | ||
1176 | msg_size = 0; | ||
1177 | GNUNET_assert (0); | ||
1178 | break; | ||
1179 | default: | ||
1180 | GNUNET_break (0); | ||
1181 | LOG (GNUNET_ERROR_TYPE_WARNING, " type unknown: %u\n", queue->type); | ||
1182 | msg_size = 0; | ||
1183 | } | ||
1184 | |||
1185 | GNUNET_assert (size >= msg_size); | ||
1186 | |||
1187 | return msg_size; | ||
1188 | } | ||
1189 | |||
1190 | |||
1191 | /** | ||
1192 | * Debug function should NEVER return true in production code, useful to | 1052 | * Debug function should NEVER return true in production code, useful to |
1193 | * simulate losses for testcases. | 1053 | * simulate losses for testcases. |
1194 | * | 1054 | * |
1195 | * @param q Queue handle with info about the message. | ||
1196 | * | ||
1197 | * @return #GNUNET_YES or #GNUNET_NO with the decision to drop. | 1055 | * @return #GNUNET_YES or #GNUNET_NO with the decision to drop. |
1198 | */ | 1056 | */ |
1199 | static int | 1057 | static int |
1200 | should_I_drop (struct CadetPeerQueue *q) | 1058 | should_I_drop (void) |
1201 | { | 1059 | { |
1202 | if (0 == drop_percent) | 1060 | if (0 == drop_percent) |
1203 | return GNUNET_NO; | 1061 | return GNUNET_NO; |
@@ -1209,297 +1067,87 @@ should_I_drop (struct CadetPeerQueue *q) | |||
1209 | } | 1067 | } |
1210 | 1068 | ||
1211 | 1069 | ||
1212 | /** | ||
1213 | * Core callback to write a queued packet to core buffer | ||
1214 | * | ||
1215 | * @param cls Closure (peer info). | ||
1216 | * @param size Number of bytes available in buf. | ||
1217 | * @param buf Where the to write the message. | ||
1218 | * | ||
1219 | * @return number of bytes written to buf | ||
1220 | */ | ||
1221 | static size_t | ||
1222 | queue_send (void *cls, size_t size, void *buf) | ||
1223 | { | ||
1224 | struct CadetPeer *peer = cls; | ||
1225 | struct CadetConnection *c; | ||
1226 | struct CadetPeerQueue *queue; | ||
1227 | struct GNUNET_TIME_Relative core_wait_time; | ||
1228 | const char *wait_s; | ||
1229 | const struct GNUNET_PeerIdentity *dst_id; | ||
1230 | size_t msg_size; | ||
1231 | size_t total_size; | ||
1232 | size_t rest; | ||
1233 | char *dst; | ||
1234 | uint32_t pid; | ||
1235 | |||
1236 | GCC_check_connections (); | ||
1237 | LOG (GNUNET_ERROR_TYPE_DEBUG, "\n"); | ||
1238 | LOG (GNUNET_ERROR_TYPE_DEBUG, "\n"); | ||
1239 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue send towards %s (max %u)\n", | ||
1240 | GCP_2s (peer), size); | ||
1241 | |||
1242 | /* Sanity checking */ | ||
1243 | if (NULL == buf || 0 == size) | ||
1244 | { | ||
1245 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not allowed/\n"); | ||
1246 | if (GNUNET_NO == in_shutdown) | ||
1247 | { | ||
1248 | queue = peer_get_first_message (peer); | ||
1249 | if (NULL == queue) | ||
1250 | { | ||
1251 | peer->core_transmit = NULL; | ||
1252 | peer->tmt_time.abs_value_us = 0; | ||
1253 | GCC_check_connections (); | ||
1254 | return 0; | ||
1255 | } | ||
1256 | dst_id = GNUNET_PEER_resolve2 (peer->id); | ||
1257 | peer->core_transmit = | ||
1258 | GNUNET_CORE_notify_transmit_ready (core_handle, | ||
1259 | GNUNET_NO, get_priority (queue), | ||
1260 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1261 | dst_id, | ||
1262 | get_core_size (queue->size), | ||
1263 | &queue_send, | ||
1264 | peer); | ||
1265 | peer->tmt_time = GNUNET_TIME_absolute_get (); | ||
1266 | } | ||
1267 | else | ||
1268 | { | ||
1269 | peer->core_transmit = NULL; | ||
1270 | peer->tmt_time.abs_value_us = 0; | ||
1271 | } | ||
1272 | GCC_check_connections (); | ||
1273 | return 0; | ||
1274 | } | ||
1275 | |||
1276 | /* Init */ | ||
1277 | rest = size; | ||
1278 | total_size = 0; | ||
1279 | dst = (char *) buf; | ||
1280 | pid = 0; | ||
1281 | peer->core_transmit = NULL; | ||
1282 | queue = peer_get_first_message (peer); | ||
1283 | if (NULL == queue) | ||
1284 | { | ||
1285 | GNUNET_break (0); /* Core tmt_rdy should've been canceled */ | ||
1286 | peer->tmt_time.abs_value_us = 0; | ||
1287 | return 0; | ||
1288 | } | ||
1289 | core_wait_time = GNUNET_TIME_absolute_get_duration (peer->tmt_time); | ||
1290 | wait_s = GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES); | ||
1291 | if (core_wait_time.rel_value_us >= 1000000) | ||
1292 | { | ||
1293 | LOG (GNUNET_ERROR_TYPE_WARNING, | ||
1294 | " %s: core wait time %s (> 1 second) for %u bytes\n", | ||
1295 | GCP_2s (peer), wait_s, queue->size); | ||
1296 | } | ||
1297 | peer->tmt_time.abs_value_us = 0; | ||
1298 | |||
1299 | /* Copy all possible messages to the core buffer */ | ||
1300 | while (NULL != queue && rest >= queue->size) | ||
1301 | { | ||
1302 | c = queue->c; | ||
1303 | |||
1304 | LOG (GNUNET_ERROR_TYPE_DEBUG, " on conn %s %s\n", | ||
1305 | GCC_2s (c), GC_f2s(queue->fwd)); | ||
1306 | LOG (GNUNET_ERROR_TYPE_DEBUG, " size %u ok (%u/%u)\n", | ||
1307 | queue->size, total_size, size); | ||
1308 | |||
1309 | msg_size = fill_buf (queue, (void *) dst, size, &pid); | ||
1310 | |||
1311 | if (should_I_drop (queue)) | ||
1312 | { | ||
1313 | LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n", | ||
1314 | GC_m2s (queue->type), GC_m2s (queue->payload_type), | ||
1315 | queue->payload_id, GCC_2s (c), GC_f2s (queue->fwd)); | ||
1316 | msg_size = 0; | ||
1317 | } | ||
1318 | else | ||
1319 | { | ||
1320 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
1321 | ">>> %s (%s %4u) on conn %s (%p) %s [%5u], after %s\n", | ||
1322 | GC_m2s (queue->type), GC_m2s (queue->payload_type), | ||
1323 | queue->payload_id, GCC_2s (c), c, | ||
1324 | GC_f2s (queue->fwd), msg_size, wait_s); | ||
1325 | } | ||
1326 | total_size += msg_size; | ||
1327 | rest -= msg_size; | ||
1328 | dst = &dst[msg_size]; | ||
1329 | msg_size = 0; | ||
1330 | |||
1331 | /* Free queue, but cls was freed by send_core_* in fill_buf. */ | ||
1332 | (void) GCP_queue_destroy (queue, GNUNET_NO, GNUNET_YES, pid); | ||
1333 | |||
1334 | /* Next! */ | ||
1335 | queue = peer_get_first_message (peer); | ||
1336 | } | ||
1337 | |||
1338 | /* If more data in queue, send next */ | ||
1339 | if (NULL != queue) | ||
1340 | { | ||
1341 | LOG (GNUNET_ERROR_TYPE_DEBUG, " more data! (%u)\n", queue->size); | ||
1342 | if (NULL == peer->core_transmit) | ||
1343 | { | ||
1344 | dst_id = GNUNET_PEER_resolve2 (peer->id); | ||
1345 | peer->core_transmit = | ||
1346 | GNUNET_CORE_notify_transmit_ready (core_handle, | ||
1347 | GNUNET_NO, get_priority (queue), | ||
1348 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1349 | dst_id, | ||
1350 | get_core_size (queue->size), | ||
1351 | &queue_send, | ||
1352 | peer); | ||
1353 | peer->tmt_time = GNUNET_TIME_absolute_get (); | ||
1354 | queue->start_waiting = GNUNET_TIME_absolute_get (); | ||
1355 | } | ||
1356 | else | ||
1357 | { | ||
1358 | LOG (GNUNET_ERROR_TYPE_DEBUG, "* tmt rdy called somewhere else\n"); | ||
1359 | } | ||
1360 | // GCC_start_poll (); FIXME needed? | ||
1361 | } | ||
1362 | else | ||
1363 | { | ||
1364 | // GCC_stop_poll(); FIXME needed? | ||
1365 | } | ||
1366 | |||
1367 | LOG (GNUNET_ERROR_TYPE_DEBUG, " return %d\n", total_size); | ||
1368 | queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG); | ||
1369 | GCC_check_connections (); | ||
1370 | return total_size; | ||
1371 | } | ||
1372 | |||
1373 | |||
1374 | /******************************************************************************/ | 1070 | /******************************************************************************/ |
1375 | /******************************** API ***********************************/ | 1071 | /******************************** API ***********************************/ |
1376 | /******************************************************************************/ | 1072 | /******************************************************************************/ |
1377 | 1073 | ||
1378 | |||
1379 | /** | 1074 | /** |
1380 | * Free a transmission that was already queued with all resources | 1075 | * Call the continuation after a message has been sent or dropped. |
1381 | * associated to the request. | ||
1382 | * | ||
1383 | * If connection was marked to be destroyed, and this was the last queued | ||
1384 | * message on it, the connection will be free'd as a result. | ||
1385 | * | 1076 | * |
1386 | * @param queue Queue handler to cancel. | 1077 | * @param q Queue handle. |
1387 | * @param clear_cls Is it necessary to free associated cls? | 1078 | * @param sent #GNUNET_YES if was sent to CORE, #GNUNET_NO if dropped. |
1388 | * @param sent Was it really sent? (Could have been canceled) | ||
1389 | * @param pid PID, if relevant (was sent and was a payload message). | ||
1390 | * | ||
1391 | * @return #GNUNET_YES if connection was destroyed as a result, | ||
1392 | * #GNUNET_NO otherwise. | ||
1393 | */ | 1079 | */ |
1394 | int | 1080 | static void |
1395 | GCP_queue_destroy (struct CadetPeerQueue *queue, | 1081 | call_peer_cont (const struct CadetPeerQueue *q, int sent) |
1396 | int clear_cls, | ||
1397 | int sent, | ||
1398 | uint32_t pid) | ||
1399 | { | 1082 | { |
1400 | struct CadetPeer *peer; | 1083 | LOG (GNUNET_ERROR_TYPE_DEBUG, " core mq just sent %s\n", GC_m2s (q->type)); |
1401 | int connection_destroyed; | 1084 | if (NULL != q->cont) |
1402 | |||
1403 | GCC_check_connections (); | ||
1404 | peer = queue->peer; | ||
1405 | LOG (GNUNET_ERROR_TYPE_DEBUG, "queue destroy %s\n", GC_m2s (queue->type)); | ||
1406 | if (GNUNET_YES == clear_cls) | ||
1407 | { | ||
1408 | LOG (GNUNET_ERROR_TYPE_DEBUG, " free cls\n"); | ||
1409 | switch (queue->type) | ||
1410 | { | ||
1411 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | ||
1412 | LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n"); | ||
1413 | /* fall through */ | ||
1414 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: | ||
1415 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: | ||
1416 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | ||
1417 | case GNUNET_MESSAGE_TYPE_CADET_KX: | ||
1418 | case GNUNET_MESSAGE_TYPE_CADET_AX: | ||
1419 | case GNUNET_MESSAGE_TYPE_CADET_ACK: | ||
1420 | case GNUNET_MESSAGE_TYPE_CADET_POLL: | ||
1421 | GNUNET_free_non_null (queue->cls); | ||
1422 | break; | ||
1423 | |||
1424 | default: | ||
1425 | GNUNET_break (0); | ||
1426 | LOG (GNUNET_ERROR_TYPE_ERROR, " type %s unknown!\n", | ||
1427 | GC_m2s (queue->type)); | ||
1428 | } | ||
1429 | } | ||
1430 | GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue); | ||
1431 | |||
1432 | if (!is_connection_management (queue->type)) | ||
1433 | { | ||
1434 | peer->queue_n--; | ||
1435 | } | ||
1436 | |||
1437 | if (NULL != queue->cont) | ||
1438 | { | 1085 | { |
1439 | struct GNUNET_TIME_Relative wait_time; | 1086 | struct GNUNET_TIME_Relative wait_time; |
1440 | 1087 | ||
1441 | wait_time = GNUNET_TIME_absolute_get_duration (queue->start_waiting); | 1088 | wait_time = GNUNET_TIME_absolute_get_duration (q->queue_timestamp); |
1442 | LOG (GNUNET_ERROR_TYPE_DEBUG, " calling callback, time elapsed %s\n", | 1089 | LOG (GNUNET_ERROR_TYPE_DEBUG, " calling callback, time elapsed %s\n", |
1443 | GNUNET_STRINGS_relative_time_to_string (wait_time, GNUNET_NO)); | 1090 | GNUNET_STRINGS_relative_time_to_string (wait_time, GNUNET_NO)); |
1444 | connection_destroyed = queue->cont (queue->cont_cls, | 1091 | q->cont (q->cont_cls, |
1445 | queue->c, sent, queue->type, pid, | 1092 | q->c, q->c_fwd, sent, |
1446 | queue->fwd, queue->size, wait_time); | 1093 | q->type, q->payload_type, q->payload_id, |
1447 | } | 1094 | q->size, wait_time); |
1448 | else | ||
1449 | { | ||
1450 | connection_destroyed = GNUNET_NO; | ||
1451 | } | 1095 | } |
1096 | } | ||
1452 | 1097 | ||
1453 | if (NULL == peer_get_first_message (peer) && NULL != peer->core_transmit) | 1098 | |
1099 | /** | ||
1100 | * Function called by MQ when a message is sent to CORE. | ||
1101 | * | ||
1102 | * @param cls Closure (queue handle). | ||
1103 | */ | ||
1104 | static void | ||
1105 | mq_sent (void *cls) | ||
1106 | { | ||
1107 | struct CadetPeerQueue *q = cls; | ||
1108 | |||
1109 | if (GNUNET_NO == q->management_traffic) | ||
1454 | { | 1110 | { |
1455 | GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit); | 1111 | q->peer->queue_n--; |
1456 | peer->core_transmit = NULL; | ||
1457 | peer->tmt_time.abs_value_us = 0; | ||
1458 | } | 1112 | } |
1459 | 1113 | call_peer_cont (q, GNUNET_YES); | |
1460 | GNUNET_free (queue); | 1114 | GNUNET_free (q); |
1461 | GCC_check_connections (); | ||
1462 | return connection_destroyed; | ||
1463 | } | 1115 | } |
1464 | 1116 | ||
1465 | 1117 | ||
1466 | /** | 1118 | /** |
1467 | * @brief Queue and pass message to core when possible. | 1119 | * @brief Send a message to another peer (using CORE). |
1468 | * | 1120 | * |
1469 | * @param peer Peer towards which to queue the message. | 1121 | * @param peer Peer towards which to queue the message. |
1470 | * @param cls Closure (@c type dependant). It will be used by queue_send to | 1122 | * @param message Message to send. |
1471 | * build the message to be sent if not already prebuilt. | 1123 | * @param payload_type Type of the message's payload, for debug messages. |
1472 | * @param type Type of the message. | ||
1473 | * @param payload_type Type of the message's payload | ||
1474 | * 0 if the message is a retransmission (unknown payload). | 1124 | * 0 if the message is a retransmission (unknown payload). |
1475 | * UINT16_MAX if the message does not have payload. | 1125 | * UINT16_MAX if the message does not have payload. |
1476 | * @param payload_id ID of the payload (MID, ACK #, etc) | 1126 | * @param payload_id ID of the payload (MID, ACK #, etc) |
1477 | * @param size Size of the message. | ||
1478 | * @param c Connection this message belongs to (can be NULL). | 1127 | * @param c Connection this message belongs to (can be NULL). |
1479 | * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!) | 1128 | * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!) |
1480 | * @param cont Continuation to be called once CORE has taken the message. | 1129 | * @param cont Continuation to be called once CORE has sent the message. |
1481 | * @param cont_cls Closure for @c cont. | 1130 | * @param cont_cls Closure for @c cont. |
1482 | * | 1131 | * |
1483 | * @return Handle to cancel the message before it is sent. Once cont is called | 1132 | * @return A handle to the message in the queue or NULL (if dropped). |
1484 | * message has been sent and therefore the handle is no longer valid. | ||
1485 | */ | 1133 | */ |
1486 | struct CadetPeerQueue * | 1134 | struct CadetPeerQueue * |
1487 | GCP_queue_add (struct CadetPeer *peer, | 1135 | GCP_send (struct CadetPeer *peer, |
1488 | void *cls, | 1136 | const struct GNUNET_MessageHeader *message, |
1489 | uint16_t type, | 1137 | uint16_t payload_type, |
1490 | uint16_t payload_type, | 1138 | uint32_t payload_id, |
1491 | uint32_t payload_id, | 1139 | struct CadetConnection *c, |
1492 | size_t size, | 1140 | int fwd, |
1493 | struct CadetConnection *c, | 1141 | GCP_sent cont, |
1494 | int fwd, | 1142 | void *cont_cls) |
1495 | GCP_sent cont, | ||
1496 | void *cont_cls) | ||
1497 | { | 1143 | { |
1498 | struct CadetPeerQueue *q; | 1144 | struct CadetPeerQueue *q; |
1499 | int priority; | 1145 | uint16_t type; |
1500 | int call_core; | 1146 | uint16_t size; |
1501 | 1147 | ||
1502 | GCC_check_connections (); | 1148 | GCC_check_connections (); |
1149 | type = ntohs (message->type); | ||
1150 | size = ntohs (message->size); | ||
1503 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 1151 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1504 | "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n", | 1152 | "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n", |
1505 | GC_m2s (type), GC_m2s (payload_type), payload_id, | 1153 | GC_m2s (type), GC_m2s (payload_type), payload_id, |
@@ -1508,282 +1156,68 @@ GCP_queue_add (struct CadetPeer *peer, | |||
1508 | if (NULL == peer->connections) | 1156 | if (NULL == peer->connections) |
1509 | { | 1157 | { |
1510 | /* We are not connected to this peer, ignore request. */ | 1158 | /* We are not connected to this peer, ignore request. */ |
1159 | GNUNET_break (0); | ||
1511 | LOG (GNUNET_ERROR_TYPE_INFO, "%s not a neighbor\n", GCP_2s (peer)); | 1160 | LOG (GNUNET_ERROR_TYPE_INFO, "%s not a neighbor\n", GCP_2s (peer)); |
1512 | GNUNET_STATISTICS_update (stats, "# messages dropped due to wrong hop", 1, | 1161 | GNUNET_STATISTICS_update (stats, "# messages dropped due to wrong hop", 1, |
1513 | GNUNET_NO); | 1162 | GNUNET_NO); |
1514 | return NULL; | 1163 | return NULL; |
1515 | } | 1164 | } |
1516 | 1165 | ||
1517 | priority = 0; | ||
1518 | if (is_connection_management (type)) | ||
1519 | { | ||
1520 | priority = 100; | ||
1521 | } | ||
1522 | LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority); | ||
1523 | |||
1524 | call_core = (NULL == c || GNUNET_MESSAGE_TYPE_CADET_KX == type) ? | ||
1525 | GNUNET_YES : GCC_is_sendable (c, fwd); | ||
1526 | q = GNUNET_new (struct CadetPeerQueue); | 1166 | q = GNUNET_new (struct CadetPeerQueue); |
1527 | q->cls = cls; | 1167 | q->env = GNUNET_MQ_msg_copy (message); |
1168 | q->peer = peer; | ||
1169 | q->cont = cont; | ||
1170 | q->cont_cls = cont_cls; | ||
1171 | q->queue_timestamp = GNUNET_TIME_absolute_get (); | ||
1172 | q->management_traffic = is_connection_management (type); | ||
1528 | q->type = type; | 1173 | q->type = type; |
1174 | q->size = size; | ||
1529 | q->payload_type = payload_type; | 1175 | q->payload_type = payload_type; |
1530 | q->payload_id = payload_id; | 1176 | q->payload_id = payload_id; |
1531 | q->size = size; | ||
1532 | q->peer = peer; | ||
1533 | q->c = c; | 1177 | q->c = c; |
1534 | q->fwd = fwd; | 1178 | q->c_fwd = fwd; |
1535 | q->cont = cont; | 1179 | GNUNET_MQ_notify_sent (q->env, mq_sent, q); |
1536 | q->cont_cls = cont_cls; | ||
1537 | if (100 > priority) | ||
1538 | { | ||
1539 | GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, q); | ||
1540 | peer->queue_n++; | ||
1541 | } | ||
1542 | else | ||
1543 | { | ||
1544 | GNUNET_CONTAINER_DLL_insert (peer->queue_head, peer->queue_tail, q); | ||
1545 | call_core = GNUNET_YES; | ||
1546 | } | ||
1547 | 1180 | ||
1548 | q->start_waiting = GNUNET_TIME_absolute_get (); | 1181 | if (GNUNET_YES == q->management_traffic) |
1549 | if (NULL == peer->core_transmit && GNUNET_YES == call_core) | ||
1550 | { | 1182 | { |
1551 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 1183 | GNUNET_MQ_send (peer->core_mq, q->env); // FIXME implement "_urgent", use |
1552 | "calling core tmt rdy towards %s for %u bytes\n", | ||
1553 | GCP_2s (peer), size); | ||
1554 | peer->core_transmit = | ||
1555 | GNUNET_CORE_notify_transmit_ready (core_handle, | ||
1556 | GNUNET_NO, get_priority (q), | ||
1557 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1558 | GNUNET_PEER_resolve2 (peer->id), | ||
1559 | get_core_size (size), | ||
1560 | &queue_send, peer); | ||
1561 | peer->tmt_time = GNUNET_TIME_absolute_get (); | ||
1562 | } | ||
1563 | else if (GNUNET_NO == call_core) | ||
1564 | { | ||
1565 | LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s not needed\n", | ||
1566 | GCP_2s (peer)); | ||
1567 | |||
1568 | } | 1184 | } |
1569 | else | 1185 | else |
1570 | { | 1186 | { |
1571 | struct GNUNET_TIME_Relative elapsed; | 1187 | if (GNUNET_YES == should_I_drop()) |
1572 | elapsed = GNUNET_TIME_absolute_get_duration (peer->tmt_time); | ||
1573 | LOG (GNUNET_ERROR_TYPE_DEBUG, "core tmt rdy towards %s already called %s\n", | ||
1574 | GCP_2s (peer), | ||
1575 | GNUNET_STRINGS_relative_time_to_string (elapsed, GNUNET_NO)); | ||
1576 | |||
1577 | } | ||
1578 | queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG); | ||
1579 | GCC_check_connections (); | ||
1580 | return q; | ||
1581 | } | ||
1582 | |||
1583 | |||
1584 | /** | ||
1585 | * Cancel all queued messages to a peer that belong to a certain connection. | ||
1586 | * | ||
1587 | * @param peer Peer towards whom to cancel. | ||
1588 | * @param c Connection whose queued messages to cancel. Might be destroyed by | ||
1589 | * the sent continuation call. | ||
1590 | */ | ||
1591 | void | ||
1592 | GCP_queue_cancel (struct CadetPeer *peer, | ||
1593 | struct CadetConnection *c) | ||
1594 | { | ||
1595 | struct CadetPeerQueue *q; | ||
1596 | struct CadetPeerQueue *next; | ||
1597 | struct CadetPeerQueue *prev; | ||
1598 | int connection_destroyed; | ||
1599 | |||
1600 | GCC_check_connections (); | ||
1601 | connection_destroyed = GNUNET_NO; | ||
1602 | for (q = peer->queue_head; NULL != q; q = next) | ||
1603 | { | ||
1604 | prev = q->prev; | ||
1605 | if (q->c == c) | ||
1606 | { | ||
1607 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1608 | "GMP queue cancel %s\n", | ||
1609 | GC_m2s (q->type)); | ||
1610 | GNUNET_assert (GNUNET_NO == connection_destroyed); | ||
1611 | if (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY == q->type) | ||
1612 | { | ||
1613 | q->c = NULL; | ||
1614 | } | ||
1615 | else | ||
1616 | { | ||
1617 | connection_destroyed = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0); | ||
1618 | } | ||
1619 | |||
1620 | /* Get next from prev, q->next might be already freed: | ||
1621 | * queue destroy -> callback -> GCC_destroy -> cancel_queues -> here | ||
1622 | */ | ||
1623 | if (NULL == prev) | ||
1624 | next = peer->queue_head; | ||
1625 | else | ||
1626 | next = prev->next; | ||
1627 | } | ||
1628 | else | ||
1629 | { | ||
1630 | next = q->next; | ||
1631 | } | ||
1632 | } | ||
1633 | |||
1634 | if ( (NULL == peer->queue_head) && | ||
1635 | (NULL != peer->core_transmit) ) | ||
1636 | { | ||
1637 | GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit); | ||
1638 | peer->core_transmit = NULL; | ||
1639 | peer->tmt_time.abs_value_us = 0; | ||
1640 | } | ||
1641 | GCC_check_connections (); | ||
1642 | } | ||
1643 | |||
1644 | |||
1645 | /** | ||
1646 | * Get the first transmittable message for a connection. | ||
1647 | * | ||
1648 | * @param peer Neighboring peer. | ||
1649 | * @param c Connection. | ||
1650 | * | ||
1651 | * @return First transmittable message. | ||
1652 | */ | ||
1653 | static struct CadetPeerQueue * | ||
1654 | connection_get_first_message (struct CadetPeer *peer, struct CadetConnection *c) | ||
1655 | { | ||
1656 | struct CadetPeerQueue *q; | ||
1657 | |||
1658 | for (q = peer->queue_head; NULL != q; q = q->next) | ||
1659 | { | ||
1660 | if (q->c != c) | ||
1661 | continue; | ||
1662 | if (queue_is_sendable (q)) | ||
1663 | { | 1188 | { |
1664 | LOG (GNUNET_ERROR_TYPE_DEBUG, " sendable!!\n"); | 1189 | LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n", |
1665 | return q; | 1190 | GC_m2s (q->type), GC_m2s (q->payload_type), |
1191 | q->payload_id, GCC_2s (c), GC_f2s (q->c_fwd)); | ||
1192 | GNUNET_MQ_discard (q->env); | ||
1193 | call_peer_cont (q, GNUNET_NO); | ||
1194 | GNUNET_free (q); | ||
1195 | return NULL; | ||
1666 | } | 1196 | } |
1667 | LOG (GNUNET_ERROR_TYPE_DEBUG, " not sendable\n"); | 1197 | GNUNET_MQ_send (peer->core_mq, q->env); |
1198 | peer->queue_n++; | ||
1668 | } | 1199 | } |
1669 | 1200 | ||
1670 | return NULL; | ||
1671 | } | ||
1672 | |||
1673 | |||
1674 | /** | ||
1675 | * Get the first message for a connection and unqueue it. | ||
1676 | * | ||
1677 | * Only tunnel (or higher) level messages are unqueued. Connection specific | ||
1678 | * messages are silently destroyed upon encounter. | ||
1679 | * | ||
1680 | * @param peer Neighboring peer. | ||
1681 | * @param c Connection. | ||
1682 | * @param destroyed[in/out] Was the connection destroyed (prev/as a result)?. | ||
1683 | * Can NOT be NULL. | ||
1684 | * | ||
1685 | * @return First message for this connection. | ||
1686 | */ | ||
1687 | struct GNUNET_MessageHeader * | ||
1688 | GCP_connection_pop (struct CadetPeer *peer, | ||
1689 | struct CadetConnection *c, | ||
1690 | int *destroyed) | ||
1691 | { | ||
1692 | struct CadetPeerQueue *q; | ||
1693 | struct CadetPeerQueue *next; | ||
1694 | struct GNUNET_MessageHeader *msg; | ||
1695 | int dest; | ||
1696 | |||
1697 | GCC_check_connections (); | ||
1698 | GNUNET_assert (NULL != destroyed); | ||
1699 | LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on conn %p\n", c); | ||
1700 | for (q = peer->queue_head; NULL != q; q = next) | ||
1701 | { | ||
1702 | next = q->next; | ||
1703 | if (q->c != c) | ||
1704 | continue; | ||
1705 | LOG (GNUNET_ERROR_TYPE_DEBUG, " - queued: %s (%s %u), cont: %p\n", | ||
1706 | GC_m2s (q->type), GC_m2s (q->payload_type), q->payload_id, | ||
1707 | q->cont); | ||
1708 | switch (q->type) | ||
1709 | { | ||
1710 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE: | ||
1711 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_ACK: | ||
1712 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY: | ||
1713 | case GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN: | ||
1714 | case GNUNET_MESSAGE_TYPE_CADET_ACK: | ||
1715 | case GNUNET_MESSAGE_TYPE_CADET_POLL: | ||
1716 | dest = GCP_queue_destroy (q, GNUNET_YES, GNUNET_NO, 0); | ||
1717 | if (GNUNET_YES == dest) | ||
1718 | { | ||
1719 | GNUNET_break (GNUNET_NO == *destroyed); | ||
1720 | *destroyed = GNUNET_YES; | ||
1721 | } | ||
1722 | continue; | ||
1723 | |||
1724 | case GNUNET_MESSAGE_TYPE_CADET_KX: | ||
1725 | case GNUNET_MESSAGE_TYPE_CADET_AX: | ||
1726 | case GNUNET_MESSAGE_TYPE_CADET_AX_KX: | ||
1727 | msg = (struct GNUNET_MessageHeader *) q->cls; | ||
1728 | dest = GCP_queue_destroy (q, GNUNET_NO, GNUNET_NO, 0); | ||
1729 | if (GNUNET_YES == dest) | ||
1730 | { | ||
1731 | GNUNET_break (GNUNET_NO == *destroyed); | ||
1732 | *destroyed = GNUNET_YES; | ||
1733 | } | ||
1734 | return msg; | ||
1735 | |||
1736 | default: | ||
1737 | GNUNET_break (0); | ||
1738 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Unknown message %s\n", GC_m2s (q->type)); | ||
1739 | } | ||
1740 | } | ||
1741 | GCC_check_connections (); | 1201 | GCC_check_connections (); |
1742 | return NULL; | 1202 | return q; |
1743 | } | 1203 | } |
1744 | 1204 | ||
1745 | 1205 | ||
1746 | /** | 1206 | /** |
1747 | * Unlock a possibly locked queue for a connection. | 1207 | * Cancel sending a message. Message must have been sent with |
1208 | * #GCP_send before. May not be called after the notify sent | ||
1209 | * callback has been called. | ||
1748 | * | 1210 | * |
1749 | * If there is a message that can be sent on this connection, call core for it. | 1211 | * It DOES call the continuation given to #GCP_send. |
1750 | * Otherwise (if core transmit is already called or there is no sendable | ||
1751 | * message) do nothing. | ||
1752 | * | 1212 | * |
1753 | * @param peer Peer who keeps the queue. | 1213 | * @param q Queue handle to cancel |
1754 | * @param c Connection whose messages to unlock. | ||
1755 | */ | 1214 | */ |
1756 | void | 1215 | void |
1757 | GCP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c) | 1216 | GCP_send_cancel (struct CadetPeerQueue *q) |
1758 | { | 1217 | { |
1759 | struct CadetPeerQueue *q; | 1218 | call_peer_cont (q, GNUNET_NO); |
1760 | size_t size; | 1219 | GNUNET_MQ_send_cancel (q->env); |
1761 | 1220 | GNUNET_free (q); | |
1762 | GCC_check_connections (); | ||
1763 | if (NULL != peer->core_transmit) | ||
1764 | { | ||
1765 | LOG (GNUNET_ERROR_TYPE_DEBUG, " already unlocked!\n"); | ||
1766 | return; /* Already unlocked */ | ||
1767 | } | ||
1768 | |||
1769 | q = connection_get_first_message (peer, c); | ||
1770 | if (NULL == q) | ||
1771 | { | ||
1772 | LOG (GNUNET_ERROR_TYPE_DEBUG, " queue empty!\n"); | ||
1773 | return; /* Nothing to transmit */ | ||
1774 | } | ||
1775 | |||
1776 | size = q->size; | ||
1777 | peer->core_transmit = | ||
1778 | GNUNET_CORE_notify_transmit_ready (core_handle, | ||
1779 | GNUNET_NO, get_priority (q), | ||
1780 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1781 | GNUNET_PEER_resolve2 (peer->id), | ||
1782 | get_core_size (size), | ||
1783 | &queue_send, | ||
1784 | peer); | ||
1785 | peer->tmt_time = GNUNET_TIME_absolute_get (); | ||
1786 | GCC_check_connections (); | ||
1787 | } | 1221 | } |
1788 | 1222 | ||
1789 | 1223 | ||
@@ -1824,23 +1258,12 @@ GCP_init (const struct GNUNET_CONFIGURATION_Handle *c) | |||
1824 | LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); | 1258 | LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n"); |
1825 | } | 1259 | } |
1826 | ats_ch = GNUNET_ATS_connectivity_init (c); | 1260 | ats_ch = GNUNET_ATS_connectivity_init (c); |
1827 | core_handle = GNUNET_CORE_connect (c, /* Main configuration */ | 1261 | connect_to_core (c); |
1828 | NULL, /* Closure passed to CADET functions */ | ||
1829 | &core_init, /* Call core_init once connected */ | ||
1830 | &core_connect, /* Handle connects */ | ||
1831 | &core_disconnect, /* remove peers on disconnects */ | ||
1832 | NULL, /* Don't notify about all incoming messages */ | ||
1833 | GNUNET_NO, /* For header only in notification */ | ||
1834 | NULL, /* Don't notify about all outbound messages */ | ||
1835 | GNUNET_NO, /* For header-only out notification */ | ||
1836 | core_handlers); /* Register these handlers */ | ||
1837 | if (NULL == core_handle) | 1262 | if (NULL == core_handle) |
1838 | { | 1263 | { |
1839 | GNUNET_break (0); | 1264 | GNUNET_break (0); |
1840 | GNUNET_SCHEDULER_shutdown (); | 1265 | GNUNET_SCHEDULER_shutdown (); |
1841 | return; | ||
1842 | } | 1266 | } |
1843 | |||
1844 | } | 1267 | } |
1845 | 1268 | ||
1846 | 1269 | ||
@@ -1853,13 +1276,10 @@ GCP_shutdown (void) | |||
1853 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 1276 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1854 | "Shutting down peer subsystem\n"); | 1277 | "Shutting down peer subsystem\n"); |
1855 | in_shutdown = GNUNET_YES; | 1278 | in_shutdown = GNUNET_YES; |
1856 | GNUNET_CONTAINER_multipeermap_iterate (peers, | ||
1857 | &shutdown_peer, | ||
1858 | NULL); | ||
1859 | if (NULL != core_handle) | 1279 | if (NULL != core_handle) |
1860 | { | 1280 | { |
1861 | GNUNET_CORE_disconnect (core_handle); | 1281 | GNUNET_CORE_disconnecT (core_handle); |
1862 | core_handle = NULL; | 1282 | core_handle = NULL; |
1863 | } | 1283 | } |
1864 | if (NULL != ats_ch) | 1284 | if (NULL != ats_ch) |
1865 | { | 1285 | { |
@@ -1867,6 +1287,12 @@ GCP_shutdown (void) | |||
1867 | ats_ch = NULL; | 1287 | ats_ch = NULL; |
1868 | } | 1288 | } |
1869 | GNUNET_PEER_change_rc (myid, -1); | 1289 | GNUNET_PEER_change_rc (myid, -1); |
1290 | /* With MQ API, CORE calls the disconnect handler for every peer | ||
1291 | * after calling GNUNET_CORE_disconnecT, shutdown must occur *after* that. | ||
1292 | */ | ||
1293 | GNUNET_CONTAINER_multipeermap_iterate (peers, | ||
1294 | &shutdown_peer, | ||
1295 | NULL); | ||
1870 | GNUNET_CONTAINER_multipeermap_destroy (peers); | 1296 | GNUNET_CONTAINER_multipeermap_destroy (peers); |
1871 | peers = NULL; | 1297 | peers = NULL; |
1872 | } | 1298 | } |
@@ -2054,7 +1480,6 @@ GCP_is_neighbor (const struct CadetPeer *peer) | |||
2054 | } | 1480 | } |
2055 | 1481 | ||
2056 | /* Is not a neighbor but connections is not NULL, probably disconnecting */ | 1482 | /* Is not a neighbor but connections is not NULL, probably disconnecting */ |
2057 | GNUNET_break (0); | ||
2058 | return GNUNET_NO; | 1483 | return GNUNET_NO; |
2059 | } | 1484 | } |
2060 | 1485 | ||
@@ -2254,7 +1679,8 @@ GCP_add_path_to_all (const struct CadetPeerPath *p, int confirmed) | |||
2254 | { | 1679 | { |
2255 | unsigned int i; | 1680 | unsigned int i; |
2256 | 1681 | ||
2257 | /* TODO: invert and add */ | 1682 | /* TODO: invert and add to origin */ |
1683 | /* TODO: replace all "GCP_add_path" with this, make the other one static */ | ||
2258 | GCC_check_connections (); | 1684 | GCC_check_connections (); |
2259 | for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ; | 1685 | for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ; |
2260 | for (i++; i < p->length; i++) | 1686 | for (i++; i < p->length; i++) |
diff --git a/src/cadet/gnunet-service-cadet_peer.h b/src/cadet/gnunet-service-cadet_peer.h index 950c68fb6..093cfa21a 100644 --- a/src/cadet/gnunet-service-cadet_peer.h +++ b/src/cadet/gnunet-service-cadet_peer.h | |||
@@ -47,7 +47,7 @@ extern "C" | |||
47 | struct CadetPeer; | 47 | struct CadetPeer; |
48 | 48 | ||
49 | /** | 49 | /** |
50 | * Struct containing info about a queued transmission to this peer | 50 | * Handle to queued messages on a peer level. |
51 | */ | 51 | */ |
52 | struct CadetPeerQueue; | 52 | struct CadetPeerQueue; |
53 | 53 | ||
@@ -59,18 +59,19 @@ struct CadetPeerQueue; | |||
59 | * | 59 | * |
60 | * @param cls Closure. | 60 | * @param cls Closure. |
61 | * @param c Connection this message was on. | 61 | * @param c Connection this message was on. |
62 | * @param fwd Was this a FWD going message? | ||
62 | * @param sent Was it really sent? (Could have been canceled) | 63 | * @param sent Was it really sent? (Could have been canceled) |
63 | * @param type Type of message sent. | 64 | * @param type Type of message sent. |
64 | * @param pid Packet ID, or 0 if not applicable (create, destroy, etc). | 65 | * @param payload_type Type of payload, if applicable. |
65 | * @param fwd Was this a FWD going message? | 66 | * @param pid Message ID, or 0 if not applicable (create, destroy, etc). |
66 | * @param size Size of the message. | 67 | * @param size Size of the message. |
67 | * @param wait Time spent waiting for core (only the time for THIS message) | 68 | * @param wait Time spent waiting for core (only the time for THIS message) |
68 | * @return #GNUNET_YES if connection was destroyed, #GNUNET_NO otherwise. | ||
69 | */ | 69 | */ |
70 | typedef int | 70 | typedef void |
71 | (*GCP_sent) (void *cls, | 71 | (*GCP_sent) (void *cls, |
72 | struct CadetConnection *c, int sent, | 72 | struct CadetConnection *c, int fwd, int sent, |
73 | uint16_t type, uint32_t pid, int fwd, size_t size, | 73 | uint16_t type, uint16_t payload_type, uint32_t pid, |
74 | size_t size, | ||
74 | struct GNUNET_TIME_Relative wait); | 75 | struct GNUNET_TIME_Relative wait); |
75 | 76 | ||
76 | /** | 77 | /** |
@@ -146,97 +147,40 @@ void | |||
146 | GCP_connect (struct CadetPeer *peer); | 147 | GCP_connect (struct CadetPeer *peer); |
147 | 148 | ||
148 | /** | 149 | /** |
149 | * Free a transmission that was already queued with all resources | 150 | * @brief Send a message to another peer (using CORE). |
150 | * associated to the request. | ||
151 | * | ||
152 | * If connection was marked to be destroyed, and this was the last queued | ||
153 | * message on it, the connection will be free'd as a result. | ||
154 | * | ||
155 | * @param queue Queue handler to cancel. | ||
156 | * @param clear_cls Is it necessary to free associated cls? | ||
157 | * @param sent Was it really sent? (Could have been canceled) | ||
158 | * @param pid PID, if relevant (was sent and was a payload message). | ||
159 | * | ||
160 | * @return #GNUNET_YES if connection was destroyed as a result, | ||
161 | * #GNUNET_NO otherwise. | ||
162 | */ | ||
163 | int | ||
164 | GCP_queue_destroy (struct CadetPeerQueue *queue, int clear_cls, | ||
165 | int sent, uint32_t pid); | ||
166 | |||
167 | /** | ||
168 | * @brief Queue and pass message to core when possible. | ||
169 | * | 151 | * |
170 | * @param peer Peer towards which to queue the message. | 152 | * @param peer Peer towards which to queue the message. |
171 | * @param cls Closure (@c type dependant). It will be used by queue_send to | 153 | * @param message Message to send. |
172 | * build the message to be sent if not already prebuilt. | 154 | * @param payload_type Type of the message's payload, for debug messages. |
173 | * @param type Type of the message. | ||
174 | * @param payload_type Type of the message's payload | ||
175 | * 0 if the message is a retransmission (unknown payload). | 155 | * 0 if the message is a retransmission (unknown payload). |
176 | * UINT16_MAX if the message does not have payload. | 156 | * UINT16_MAX if the message does not have payload. |
177 | * @param payload_id ID of the payload (MID, ACK #, etc) | 157 | * @param payload_id ID of the payload (MID, ACK #, etc) |
178 | * @param size Size of the message. | ||
179 | * @param c Connection this message belongs to (can be NULL). | 158 | * @param c Connection this message belongs to (can be NULL). |
180 | * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!) | 159 | * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!) |
181 | * @param cont Continuation to be called once CORE has taken the message. | 160 | * @param cont Continuation to be called once CORE has sent the message. |
182 | * @param cont_cls Closure for @c cont. | 161 | * @param cont_cls Closure for @c cont. |
183 | * | ||
184 | * @return Handle to cancel the message before it is sent. Once cont is called | ||
185 | * message has been sent and therefore the handle is no longer valid. | ||
186 | */ | 162 | */ |
187 | struct CadetPeerQueue * | 163 | struct CadetPeerQueue * |
188 | GCP_queue_add (struct CadetPeer *peer, | 164 | GCP_send (struct CadetPeer *peer, |
189 | void *cls, | 165 | const struct GNUNET_MessageHeader *message, |
190 | uint16_t type, | 166 | uint16_t payload_type, |
191 | uint16_t payload_type, | 167 | uint32_t payload_id, |
192 | uint32_t payload_id, | 168 | struct CadetConnection *c, |
193 | size_t size, | 169 | int fwd, |
194 | struct CadetConnection *c, | 170 | GCP_sent cont, |
195 | int fwd, | 171 | void *cont_cls); |
196 | GCP_sent cont, | ||
197 | void *cont_cls); | ||
198 | |||
199 | /** | ||
200 | * Cancel all queued messages to a peer that belong to a certain connection. | ||
201 | * | ||
202 | * @param peer Peer towards whom to cancel. | ||
203 | * @param c Connection whose queued messages to cancel. Might be destroyed by | ||
204 | * the sent continuation call. | ||
205 | */ | ||
206 | void | ||
207 | GCP_queue_cancel (struct CadetPeer *peer, struct CadetConnection *c); | ||
208 | |||
209 | /** | ||
210 | * Get the first message for a connection and unqueue it. | ||
211 | * | ||
212 | * Only tunnel (or higher) level messages are unqueued. Connection specific | ||
213 | * messages are silently destroyed upon encounter. | ||
214 | * | ||
215 | * @param peer Neighboring peer. | ||
216 | * @param c Connection. | ||
217 | * @param destroyed[in/out] Was the connection destroyed as a result?. | ||
218 | * Can NOT be NULL. | ||
219 | * | ||
220 | * | ||
221 | * @return First message for this connection. | ||
222 | */ | ||
223 | struct GNUNET_MessageHeader * | ||
224 | GCP_connection_pop (struct CadetPeer *peer, | ||
225 | struct CadetConnection *c, | ||
226 | int *destroyed); | ||
227 | 172 | ||
228 | /** | 173 | /** |
229 | * Unlock a possibly locked queue for a connection. | 174 | * Cancel sending a message. Message must have been sent with |
175 | * #GCP_send before. May not be called after the notify sent | ||
176 | * callback has been called. | ||
230 | * | 177 | * |
231 | * If there is a message that can be sent on this connection, call core for it. | 178 | * It does NOT call the continuation given to #GCP_send. |
232 | * Otherwise (if core transmit is already called or there is no sendable | ||
233 | * message) do nothing. | ||
234 | * | 179 | * |
235 | * @param peer Peer who keeps the queue. | 180 | * @param q Queue handle to cancel |
236 | * @param c Connection whose messages to unlock. | ||
237 | */ | 181 | */ |
238 | void | 182 | void |
239 | GCP_queue_unlock (struct CadetPeer *peer, struct CadetConnection *c); | 183 | GCP_send_cancel (struct CadetPeerQueue *q); |
240 | 184 | ||
241 | /** | 185 | /** |
242 | * Set tunnel. | 186 | * Set tunnel. |
diff --git a/src/cadet/gnunet-service-cadet_tunnel.c b/src/cadet/gnunet-service-cadet_tunnel.c index 0ede4a886..e60c3c023 100644 --- a/src/cadet/gnunet-service-cadet_tunnel.c +++ b/src/cadet/gnunet-service-cadet_tunnel.c | |||
@@ -1600,7 +1600,6 @@ send_kx (struct CadetTunnel *t, | |||
1600 | { | 1600 | { |
1601 | GNUNET_break (0); | 1601 | GNUNET_break (0); |
1602 | GCT_debug (t, GNUNET_ERROR_TYPE_ERROR); | 1602 | GCT_debug (t, GNUNET_ERROR_TYPE_ERROR); |
1603 | GCP_debug (t->peer, GNUNET_ERROR_TYPE_ERROR); | ||
1604 | } | 1603 | } |
1605 | return NULL; | 1604 | return NULL; |
1606 | } | 1605 | } |
@@ -2245,6 +2244,10 @@ GCT_handle_encrypted (struct CadetTunnel *t, | |||
2245 | * | 2244 | * |
2246 | * @param t Tunnel on which the message came. | 2245 | * @param t Tunnel on which the message came. |
2247 | * @param message Payload of KX message. | 2246 | * @param message Payload of KX message. |
2247 | * | ||
2248 | * FIXME: not needed anymore | ||
2249 | * - substitute with call to kx_ax | ||
2250 | * - eliminate encapsulation | ||
2248 | */ | 2251 | */ |
2249 | void | 2252 | void |
2250 | GCT_handle_kx (struct CadetTunnel *t, | 2253 | GCT_handle_kx (struct CadetTunnel *t, |
@@ -3367,34 +3370,6 @@ GCT_send_ax_kx (struct CadetTunnel *t, int force_reply) | |||
3367 | 3370 | ||
3368 | 3371 | ||
3369 | /** | 3372 | /** |
3370 | * Sends an already built and encrypted message on a tunnel, choosing the best | ||
3371 | * connection. Useful for re-queueing messages queued on a destroyed connection. | ||
3372 | * | ||
3373 | * @param message Message to send. Function modifies it. | ||
3374 | * @param t Tunnel on which this message is transmitted. | ||
3375 | */ | ||
3376 | void | ||
3377 | GCT_resend_message (const struct GNUNET_MessageHeader *message, | ||
3378 | struct CadetTunnel *t) | ||
3379 | { | ||
3380 | struct CadetConnection *c; | ||
3381 | int fwd; | ||
3382 | |||
3383 | c = tunnel_get_connection (t); | ||
3384 | if (NULL == c) | ||
3385 | { | ||
3386 | /* TODO queue in tunnel, marked as encrypted */ | ||
3387 | LOG (GNUNET_ERROR_TYPE_DEBUG, "No connection available, dropping.\n"); | ||
3388 | return; | ||
3389 | } | ||
3390 | fwd = GCC_is_origin (c, GNUNET_YES); | ||
3391 | GNUNET_break (NULL == GCC_send_prebuilt_message (message, UINT16_MAX, 0, | ||
3392 | c, fwd, | ||
3393 | GNUNET_YES, NULL, NULL)); | ||
3394 | } | ||
3395 | |||
3396 | |||
3397 | /** | ||
3398 | * Is the tunnel directed towards the local peer? | 3373 | * Is the tunnel directed towards the local peer? |
3399 | * | 3374 | * |
3400 | * @param t Tunnel. | 3375 | * @param t Tunnel. |
diff --git a/src/cadet/gnunet-service-cadet_tunnel.h b/src/cadet/gnunet-service-cadet_tunnel.h index ca553a7d3..8d65cbebd 100644 --- a/src/cadet/gnunet-service-cadet_tunnel.h +++ b/src/cadet/gnunet-service-cadet_tunnel.h | |||
@@ -504,18 +504,6 @@ GCT_send_ax_kx (struct CadetTunnel *t, int force_reply); | |||
504 | 504 | ||
505 | 505 | ||
506 | /** | 506 | /** |
507 | * Sends an already built and encrypted message on a tunnel, choosing the best | ||
508 | * connection. Useful for re-queueing messages queued on a destroyed connection. | ||
509 | * | ||
510 | * @param message Message to send. Function modifies it. | ||
511 | * @param t Tunnel on which this message is transmitted. | ||
512 | */ | ||
513 | void | ||
514 | GCT_resend_message (const struct GNUNET_MessageHeader *message, | ||
515 | struct CadetTunnel *t); | ||
516 | |||
517 | |||
518 | /** | ||
519 | * Is the tunnel directed towards the local peer? | 507 | * Is the tunnel directed towards the local peer? |
520 | * | 508 | * |
521 | * @param t Tunnel. | 509 | * @param t Tunnel. |