diff --git a/testing/DHT_test.c b/testing/DHT_test.c index 3cd1bce6..492586fc 100644 --- a/testing/DHT_test.c +++ b/testing/DHT_test.c @@ -52,26 +52,40 @@ #define PORT 33445 +void print_assoc(IPPTsPng *assoc, uint8_t ours) +{ + IP_Port *ipp = &assoc->ip_port; + printf("\nIP: %s Port: %u", ip_ntoa(&ipp->ip), ntohs(ipp->port)); + printf("\nTimestamp: %llu", (long long unsigned int) assoc->timestamp); + printf("\nLast pinged: %llu\n", (long long unsigned int) assoc->last_pinged); + + ipp = &assoc->ret_ip_port; + if (ours) + printf("OUR IP: %s Port: %u\n", ip_ntoa(&ipp->ip), ntohs(ipp->port)); + else + printf("RET IP: %s Port: %u\n", ip_ntoa(&ipp->ip), ntohs(ipp->port)); + printf("Timestamp: %llu\n", (long long unsigned int) assoc->ret_timestamp); +} + void print_clientlist(DHT *dht) { uint32_t i, j; - IP_Port p_ip; printf("___________________CLOSE________________________________\n"); for (i = 0; i < LCLIENT_LIST; i++) { + Client_data *client = &dht->close_clientlist[i]; printf("ClientID: "); for (j = 0; j < CLIENT_ID_SIZE; j++) { - printf("%02hhX", dht->close_clientlist[i].client_id[j]); + printf("%02hhX", client->client_id[j]); } - p_ip = dht->close_clientlist[i].ip_port; - printf("\nIP: %s Port: %u", ip_ntoa(&p_ip.ip), ntohs(p_ip.port)); - printf("\nTimestamp: %llu", (long long unsigned int) dht->close_clientlist[i].timestamp); - printf("\nLast pinged: %llu\n", (long long unsigned int) dht->close_clientlist[i].last_pinged); - p_ip = dht->close_clientlist[i].ret_ip_port; - printf("OUR IP: %s Port: %u\n", ip_ntoa(&p_ip.ip), ntohs(p_ip.port)); - printf("Timestamp: %llu\n", (long long unsigned int) dht->close_clientlist[i].ret_timestamp); +#ifdef CLIENT_ONETOONE_IP + print_assoc(&client->assoc, 1); +#else + print_assoc(&client->assoc4, 1); + print_assoc(&client->assoc6, 1); +#endif } } @@ -95,22 +109,22 @@ void print_friendlist(DHT *dht) printf("\nCLIENTS IN LIST:\n\n"); for (i = 0; i < MAX_FRIEND_CLIENTS; i++) { + Client_data *client = &dht->friends_list[k].client_list[i]; printf("ClientID: "); for (j = 0; j < CLIENT_ID_SIZE; j++) { - if (dht->friends_list[k].client_list[i].client_id[j] < 16) + if (client->client_id[j] < 16) printf("0"); - printf("%hhX", dht->friends_list[k].client_list[i].client_id[j]); + printf("%hhX", client->client_id[j]); } - p_ip = dht->friends_list[k].client_list[i].ip_port; - printf("\nIP: %s:%u", ip_ntoa(&p_ip.ip), ntohs(p_ip.port)); - printf("\nTimestamp: %llu", (long long unsigned int) dht->friends_list[k].client_list[i].timestamp); - printf("\nLast pinged: %llu\n", (long long unsigned int) dht->friends_list[k].client_list[i].last_pinged); - p_ip = dht->friends_list[k].client_list[i].ret_ip_port; - printf("ret IP: %s:%u\n", ip_ntoa(&p_ip.ip), ntohs(p_ip.port)); - printf("Timestamp: %llu\n", (long long unsigned int)dht->friends_list[k].client_list[i].ret_timestamp); +#ifdef CLIENT_ONETOONE_IP + print_assoc(&client->assoc, 0); +#else + print_assoc(&client->assoc4, 0); + print_assoc(&client->assoc6, 0); +#endif } } } diff --git a/toxcore/DHT.c b/toxcore/DHT.c index db3c5883..1c550628 100644 --- a/toxcore/DHT.c +++ b/toxcore/DHT.c @@ -43,7 +43,7 @@ #define PING_TIMEOUT 5 /* The timeout after which a node is discarded completely. */ -#define Kill_NODE_TIMEOUT 300 +#define KILL_NODE_TIMEOUT 300 /* Ping interval in seconds for each node in our lists. */ #define PING_INTERVAL 60 @@ -136,6 +136,7 @@ static int client_or_ip_port_in_list(Client_data *list, uint32_t length, uint8_t uint32_t i; uint64_t temp_time = unix_time(); +#ifdef CLIENT_ONETOONE_IP uint8_t candropipv4 = 1; if (ip_port.ip.family == AF_INET6) { @@ -143,35 +144,71 @@ static int client_or_ip_port_in_list(Client_data *list, uint32_t length, uint8_t /* ipv6: count how many spots are used */ for (i = 0; i < length; i++) - if (list[i].ip_port.ip.family == AF_INET6) + if (list[i].assoc.ip_port.ip.family == AF_INET6) ipv6cnt++; /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */ if (ipv6cnt > length / 2) candropipv4 = 0; } +#endif /* if client_id is in list, find it and maybe overwrite ip_port */ for (i = 0; i < length; ++i) if (id_equal(list[i].client_id, client_id)) { + /* Refresh the client timestamp. */ +#ifdef CLIENT_ONETOONE_IP /* if we got "too many" ipv6 addresses already, keep the ipv4 address */ - if (!candropipv4 && (list[i].ip_port.ip.family == AF_INET)) + if (!candropipv4 && (list[i].assoc.ip_port.ip.family == AF_INET)) return 1; - /* Refresh the client timestamp. */ - list[i].timestamp = temp_time; - list[i].ip_port = ip_port; + list[i].assoc.ip_port = ip_port; + list[i].assoc.timestamp = temp_time; +#else + if (ip_port.ip.family == AF_INET) { + list[i].assoc4.ip_port = ip_port; + list[i].assoc4.timestamp = temp_time; + } else if (ip_port.ip.family == AF_INET6) { + list[i].assoc6.ip_port = ip_port; + list[i].assoc6.timestamp = temp_time; + } +#endif return 1; } - /* client_id not in list yet: find ip_port to overwrite */ - for (i = 0; i < length; ++i) - if (ipport_equal(&list[i].ip_port, &ip_port)) { - /* Refresh the client timestamp. */ - list[i].timestamp = temp_time; + /* client_id not in list yet: see if we can find an identical ip_port, in + * that case we kill the old client_id by overwriting it with the new one + * TODO: maybe we SHOULDN'T do that if that client_id is in a friend_list + * and the one who is the actual friend's client_id/address set? */ + for (i = 0; i < length; ++i) { +#ifdef CLIENT_ONETOONE_IP + if (ipport_equal(&list[i].assoc.ip_port, &ip_port)) { + /* Initialize client timestamp. */ + list[i].assoc.timestamp = temp_time; memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); return 1; } +#else + /* MAYBE: check the other address, if valid, don't nuke? */ + if ((ip_port.ip.family == AF_INET) && ipport_equal(&list[i].assoc4.ip_port, &ip_port)) { + /* Initialize client timestamp. */ + list[i].assoc4.timestamp = temp_time; + memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); + + /* kill the other address, if it was set */ + memset(&list[i].assoc6, 0, sizeof(list[i].assoc6)); + return 1; + } else if ((ip_port.ip.family == AF_INET6) && ipport_equal(&list[i].assoc6.ip_port, &ip_port)) { + /* Initialize client timestamp. */ + list[i].assoc6.timestamp = temp_time; + memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE); + + /* kill the other address, if it was set */ + memset(&list[i].assoc4, 0, sizeof(list[i].assoc4)); + return 1; + } +#endif + } return 0; } @@ -215,17 +252,30 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod sa_family_t sa_family, Client_data *client_list, uint32_t client_list_length, time_t timestamp, int *num_nodes_ptr) { + if ((sa_family != AF_INET) && (sa_family != AF_INET6)) + return; + int num_nodes = *num_nodes_ptr; int tout, inlist, ipv46x, j, closest; uint32_t i; for (i = 0; i < client_list_length; i++) { Client_data *client = &client_list[i]; - tout = is_timeout(timestamp, client->timestamp, BAD_NODE_TIMEOUT); + IPPTsPng *ipptp = NULL; +#ifdef CLIENT_ONETOONE_IP + ipptp = &client->assoc; +#else + if (sa_family == AF_INET) + ipptp = &client->assoc4; + else + ipptp = &client->assoc6; +#endif + + tout = is_timeout(timestamp, ipptp->timestamp, BAD_NODE_TIMEOUT); inlist = client_in_nodelist(nodes_list, MAX_SENT_NODES, client->client_id); #ifdef TOX_ENABLE_IPV6 - IP *client_ip = &client->ip_port.ip; + IP *client_ip = &ipptp->ip_port.ip; /* * Careful: AF_INET isn't seen as AF_INET on dual-stack sockets for @@ -237,7 +287,8 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod if ((dht->c->lossless_udp->net->family == AF_INET6) && (client_ip->family == AF_INET6)) { /* socket is AF_INET6, address claims AF_INET6: - * check for embedded IPv4-in-IPv6 */ + * check for embedded IPv4-in-IPv6 (shouldn't happen anymore, + * all storing functions should already convert down to IPv4) */ if (IN6_IS_ADDR_V4MAPPED(&client_ip->ip6.in6_addr)) ip_treat_as_family = AF_INET; } @@ -256,7 +307,7 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod client->client_id, CLIENT_ID_SIZE ); - nodes_list[num_nodes].ip_port = client->ip_port; + nodes_list[num_nodes].ip_port = ipptp->ip_port; num_nodes++; } else { /* see if node_list contains a client_id that's "further away" @@ -274,7 +325,7 @@ static void get_close_nodes_inner(DHT *dht, uint8_t *client_id, Node_format *nod client->client_id, CLIENT_ID_SIZE); - nodes_list[j].ip_port = client->ip_port; + nodes_list[j].ip_port = ipptp->ip_port; break; } } @@ -315,9 +366,13 @@ static int replace_bad( Client_data *list, uint8_t *client_id, IP_Port ip_port ) { + if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6)) + return 1; + uint32_t i; uint64_t temp_time = unix_time(); +#ifdef CLIENT_ONETOONE_IP uint8_t candropipv4 = 1; if (ip_port.ip.family == AF_INET6) { @@ -325,26 +380,39 @@ static int replace_bad( Client_data *list, /* ipv6: count how many spots are used */ for (i = 0; i < length; i++) - if (list[i].ip_port.ip.family == AF_INET6) + if (list[i].assoc.ip_port.ip.family == AF_INET6) ipv6cnt++; /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */ if (ipv6cnt > length / 2) candropipv4 = 0; } - +#endif for (i = 0; i < length; ++i) { /* If node is bad */ Client_data *client = &list[i]; + IPPTsPng *ipptp = NULL; - if ((candropipv4 || (client->ip_port.ip.family == AF_INET6)) && - is_timeout(temp_time, client->timestamp, BAD_NODE_TIMEOUT)) { +#ifdef CLIENT_ONETOONE_IP + ipptp = &client->assoc; + if ((candropipv4 || (ipptp->ip_port.ip.family == AF_INET6)) && + is_timeout(temp_time, ipptp->timestamp, BAD_NODE_TIMEOUT)) { +#else + if (ip_port.ip.family == AF_INET) + ipptp = &client->assoc4; + else + ipptp = &client->assoc6; + + if (is_timeout(temp_time, ipptp->timestamp, BAD_NODE_TIMEOUT)) { +#endif memcpy(client->client_id, client_id, CLIENT_ID_SIZE); - client->ip_port = ip_port; - client->timestamp = temp_time; - ip_reset(&client->ret_ip_port.ip); - client->ret_ip_port.port = 0; - client->ret_timestamp = 0; + ipptp->ip_port = ip_port; + ipptp->timestamp = temp_time; + + ip_reset(&ipptp->ret_ip_port.ip); + ipptp->ret_ip_port.port = 0; + ipptp->ret_timestamp = 0; + return 0; } } @@ -381,8 +449,14 @@ static int replace_good( Client_data *list, IP_Port ip_port, uint8_t *comp_client_id ) { + if ((ip_port.ip.family != AF_INET) && (ip_port.ip.family != AF_INET6)) + return 1; + sort_list(list, length, comp_client_id); + int8_t replace = -1; + +#ifdef CLIENT_ONETOONE_IP uint8_t candropipv4 = 1; if (ip_port.ip.family == AF_INET6) { @@ -390,7 +464,7 @@ static int replace_good( Client_data *list, /* ipv6: count how many spots are used */ for (i = 0; i < length; i++) - if (list[i].ip_port.ip.family == AF_INET6) + if (list[i].assoc.ip_port.ip.family == AF_INET6) ipv6cnt++; /* more than half the list filled with ipv6: block ipv4->ipv6 overwrite */ @@ -398,7 +472,6 @@ static int replace_good( Client_data *list, candropipv4 = 0; } - int8_t replace = -1; uint32_t i; if (candropipv4) { @@ -414,8 +487,10 @@ static int replace_good( Client_data *list, * so the furthest element is the first, NOT the last (at least that's * what the comment above sort_list() claims) */ +#endif if (id_closest(comp_client_id, list[0].client_id, client_id) == 2) replace = 0; +#ifdef CLIENT_ONETOONE_IP } else { /* ipv6 case without a right to push out an ipv4: only look for ipv6 * addresses, the first one we find is either closer (then we can skip @@ -424,7 +499,7 @@ static int replace_good( Client_data *list, for (i = 0; i < length; i++) { Client_data *client = &list[i]; - if (client->ip_port.ip.family == AF_INET6) { + if (client->assoc.ip_port.ip.family == AF_INET6) { if (id_closest(comp_client_id, list[i].client_id, client_id) == 2) replace = i; @@ -432,18 +507,29 @@ static int replace_good( Client_data *list, } } } +#endif if (replace != -1) { #ifdef DEBUG assert(replace >= 0 && replace < length); #endif Client_data *client = &list[replace]; + IPPTsPng *ipptp = NULL; +#ifdef CLIENT_ONETOONE_IP + ipptp = &client->assoc; +#else + if (ip_port.ip.family == AF_INET) + ipptp = &client->assoc4; + else + ipptp = &client->assoc6; +#endif memcpy(client->client_id, client_id, CLIENT_ID_SIZE); - client->ip_port = ip_port; - client->timestamp = unix_time(); - ip_reset(&client->ret_ip_port.ip); - client->ret_ip_port.port = 0; - client->ret_timestamp = 0; + ipptp->ip_port = ip_port; + ipptp->timestamp = unix_time(); + + ip_reset(&ipptp->ret_ip_port.ip); + ipptp->ret_ip_port.port = 0; + ipptp->ret_timestamp = 0; return 0; } @@ -496,25 +582,48 @@ static void returnedip_ports(DHT *dht, IP_Port ip_port, uint8_t *client_id, uint uint32_t i, j; uint64_t temp_time = unix_time(); - if (id_equal(client_id, dht->c->self_public_key)) { + /* convert IPv4-in-IPv6 to IPv4 */ + if ((ip_port.ip.family == AF_INET6) && IN6_IS_ADDR_V4MAPPED(&ip_port.ip.ip6.in6_addr)) { + ip_port.ip.family = AF_INET; + ip_port.ip.ip4.uint32 = ip_port.ip.ip6.uint32[3]; + } + if (id_equal(client_id, dht->c->self_public_key)) { for (i = 0; i < LCLIENT_LIST; ++i) { if (id_equal(nodeclient_id, dht->close_clientlist[i].client_id)) { - dht->close_clientlist[i].ret_ip_port = ip_port; - dht->close_clientlist[i].ret_timestamp = temp_time; +#ifdef CLIENT_ONETOONE_IP + dht->close_clientlist[i].assoc.ret_ip_port = ip_port; + dht->close_clientlist[i].assoc.ret_timestamp = temp_time; +#else + if (ip_port.ip.family == AF_INET) { + dht->close_clientlist[i].assoc4.ret_ip_port = ip_port; + dht->close_clientlist[i].assoc4.ret_timestamp = temp_time; + } else if (ip_port.ip.family == AF_INET6) { + dht->close_clientlist[i].assoc6.ret_ip_port = ip_port; + dht->close_clientlist[i].assoc6.ret_timestamp = temp_time; + } +#endif return; } } } else { - for (i = 0; i < dht->num_friends; ++i) { if (id_equal(client_id, dht->friends_list[i].client_id)) { - for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { if (id_equal(nodeclient_id, dht->friends_list[i].client_list[j].client_id)) { - dht->friends_list[i].client_list[j].ret_ip_port = ip_port; - dht->friends_list[i].client_list[j].ret_timestamp = temp_time; +#ifdef CLIENT_ONETOONE_IP + dht->friends_list[i].client_list[j].assoc.ret_ip_port = ip_port; + dht->friends_list[i].client_list[j].assoc.ret_timestamp = temp_time; +#else + if (ip_port.ip.family == AF_INET) { + dht->friends_list[i].client_list[j].assoc4.ret_ip_port = ip_port; + dht->friends_list[i].client_list[j].assoc4.ret_timestamp = temp_time; + } else if (ip_port.ip.family == AF_INET6) { + dht->friends_list[i].client_list[j].assoc6.ret_ip_port = ip_port; + dht->friends_list[i].client_list[j].assoc6.ret_timestamp = temp_time; + } +#endif return; } } @@ -897,14 +1006,29 @@ static void get_bunchnodes(DHT *dht, Client_data *list, uint16_t length, uint16_ uint64_t temp_time = unix_time(); uint32_t i, num = 0; - for (i = 0; i < length; ++i) - if (ipport_isset(&(list[i].ip_port)) && !is_timeout(temp_time, list[i].ret_timestamp, BAD_NODE_TIMEOUT)) { - getnodes(dht, list[i].ip_port, list[i].client_id, client_id); - ++num; + for (i = 0; i < length; ++i) { + IPPTsPng *assoc; +#ifdef CLIENT_ONETOONE_IP + assoc = &list[i].assoc; + if (1) { +#else + uint32_t a; + for (a = 0; a < 2; a++) { + if (!a) + assoc = &list[i].assoc6; + else + assoc = &list[i].assoc4; +#endif + if (ipport_isset(&(assoc->ip_port)) && + !is_timeout(temp_time, assoc->ret_timestamp, BAD_NODE_TIMEOUT)) { + getnodes(dht, assoc->ip_port, list[i].client_id, client_id); + ++num; - if (num >= max_num) - return; + if (num >= max_num) + return; + } } + } } int DHT_addfriend(DHT *dht, uint8_t *client_id) @@ -922,7 +1046,7 @@ int DHT_addfriend(DHT *dht, uint8_t *client_id) memset(&dht->friends_list[dht->num_friends], 0, sizeof(DHT_Friend)); memcpy(dht->friends_list[dht->num_friends].client_id, client_id, CLIENT_ID_SIZE); - dht->friends_list[dht->num_friends].NATping_id = ((uint64_t)random_int() << 32) + random_int(); + dht->friends_list[dht->num_friends].nat.NATping_id = ((uint64_t)random_int() << 32) + random_int(); ++dht->num_friends; get_bunchnodes(dht, dht->close_clientlist, LCLIENT_LIST, MAX_FRIEND_CLIENTS, client_id);/*TODO: make this better?*/ return 0; @@ -976,10 +1100,25 @@ int DHT_getfriendip(DHT *dht, uint8_t *client_id, IP_Port *ip_port) /* Equal */ if (id_equal(dht->friends_list[i].client_id, client_id)) { for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { - if (id_equal(dht->friends_list[i].client_list[j].client_id, client_id) - && !is_timeout(temp_time, dht->friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT)) { - *ip_port = dht->friends_list[i].client_list[j].ip_port; - return 1; + Client_data *client = &dht->friends_list[i].client_list[j]; + if (id_equal(client->client_id, client_id)) { + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &client->assoc; + if (1) { +#else + uint32_t a; + for (a = 0; a < 2; a++) { + if (!a) + assoc = &client->assoc6; + else + assoc = &client->assoc4; +#endif + if (!is_timeout(temp_time, assoc->timestamp, BAD_NODE_TIMEOUT)) { + *ip_port = assoc->ip_port; + return 1; + } + } } } @@ -990,44 +1129,66 @@ int DHT_getfriendip(DHT *dht, uint8_t *client_id, IP_Port *ip_port) return -1; } +static void do_ping_and_sendnode_requests(DHT *dht, uint64_t *lastgetnode, uint8_t *client_id, + Client_data *list, uint32_t list_count) +{ + uint32_t i; + uint64_t temp_time = unix_time(); + + uint32_t num_nodes = 0; + Client_data *client_list[list_count]; + IPPTsPng *assoc_list[list_count]; + + for (i = 0; i < list_count; i++) { + /* If node is not dead. */ + Client_data *client = &list[i]; + IPPTsPng *assoc; +#ifdef CLIENT_ONETOONE_IP + assoc = &client->assoc; + if (1) { +#else + uint32_t a; + for (a = 0; a < 2; a++) { + if (!a) + assoc = &client->assoc6; + else + assoc = &client->assoc4; +#endif + + if (!is_timeout(temp_time, assoc->timestamp, KILL_NODE_TIMEOUT)) { + if (is_timeout(temp_time, assoc->last_pinged, PING_INTERVAL)) { + send_ping_request(dht->ping, assoc->ip_port, client->client_id ); + assoc->last_pinged = temp_time; + } + + /* If node is good. */ + if (!is_timeout(temp_time, assoc->timestamp, BAD_NODE_TIMEOUT)) { + client_list[num_nodes] = client; + assoc_list[num_nodes] = assoc; + ++num_nodes; + } + } + } + } + + if ((num_nodes != 0) && + is_timeout(temp_time, *lastgetnode, GET_NODE_INTERVAL)) { + uint32_t rand_node = rand() % num_nodes; + getnodes(dht, assoc_list[rand_node]->ip_port, client_list[rand_node]->client_id, + client_id); + *lastgetnode = temp_time; + } +} + /* Ping each client in the "friends" list every PING_INTERVAL seconds. Send a get nodes request * every GET_NODE_INTERVAL seconds to a random good node for each "friend" in our "friends" list. */ static void do_DHT_friends(DHT *dht) { - uint32_t i, j; - uint64_t temp_time = unix_time(); - uint32_t rand_node; - uint32_t index[MAX_FRIEND_CLIENTS]; - - for (i = 0; i < dht->num_friends; ++i) { - uint32_t num_nodes = 0; - - for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { - /* If node is not dead. */ - if (!is_timeout(temp_time, dht->friends_list[i].client_list[j].timestamp, Kill_NODE_TIMEOUT)) { - if ((dht->friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) { - send_ping_request(dht->ping, dht->friends_list[i].client_list[j].ip_port, - dht->friends_list[i].client_list[j].client_id ); - dht->friends_list[i].client_list[j].last_pinged = temp_time; - } - - /* If node is good. */ - if (!is_timeout(temp_time, dht->friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT)) { - index[num_nodes] = j; - ++num_nodes; - } - } - } - - if (dht->friends_list[i].lastgetnode + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) { - rand_node = rand() % num_nodes; - getnodes(dht, dht->friends_list[i].client_list[index[rand_node]].ip_port, - dht->friends_list[i].client_list[index[rand_node]].client_id, - dht->friends_list[i].client_id ); - dht->friends_list[i].lastgetnode = temp_time; - } - } + uint32_t i; + for (i = 0; i < dht->num_friends; ++i) + do_ping_and_sendnode_requests(dht, &dht->friends_list[i].lastgetnode, dht->friends_list[i].client_id, + dht->friends_list[i].client_list, MAX_FRIEND_CLIENTS); } /* Ping each client in the close nodes list every PING_INTERVAL seconds. @@ -1035,36 +1196,8 @@ static void do_DHT_friends(DHT *dht) */ static void do_Close(DHT *dht) { - uint32_t i; - uint64_t temp_time = unix_time(); - uint32_t num_nodes = 0; - uint32_t rand_node; - uint32_t index[LCLIENT_LIST]; - - for (i = 0; i < LCLIENT_LIST; ++i) { - /* If node is not dead. */ - if (!is_timeout(temp_time, dht->close_clientlist[i].timestamp, Kill_NODE_TIMEOUT)) { - if ((dht->close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) { - send_ping_request(dht->ping, dht->close_clientlist[i].ip_port, - dht->close_clientlist[i].client_id ); - dht->close_clientlist[i].last_pinged = temp_time; - } - - /* If node is good. */ - if (!is_timeout(temp_time, dht->close_clientlist[i].timestamp, BAD_NODE_TIMEOUT)) { - index[num_nodes] = i; - ++num_nodes; - } - } - } - - if (dht->close_lastgetnodes + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) { - rand_node = rand() % num_nodes; - getnodes(dht, dht->close_clientlist[index[rand_node]].ip_port, - dht->close_clientlist[index[rand_node]].client_id, - dht->c->self_public_key ); - dht->close_lastgetnodes = temp_time; - } + do_ping_and_sendnode_requests(dht, &dht->close_lastgetnodes, dht->c->self_public_key, + dht->close_clientlist, LCLIENT_LIST); } void DHT_bootstrap(DHT *dht, IP_Port ip_port, uint8_t *public_key) @@ -1116,8 +1249,20 @@ int route_packet(DHT *dht, uint8_t *client_id, uint8_t *packet, uint32_t length) uint32_t i; for (i = 0; i < LCLIENT_LIST; ++i) { - if (id_equal(client_id, dht->close_clientlist[i].client_id)) - return sendpacket(dht->c->lossless_udp->net, dht->close_clientlist[i].ip_port, packet, length); + if (id_equal(client_id, dht->close_clientlist[i].client_id)) { + Client_data *client = &dht->close_clientlist[i]; +#ifdef CLIENT_ONETOONE_IP + if (ip_isset(&client->assoc.ip_port.ip)) + return sendpacket(dht->c->lossless_udp->net, dht->close_clientlist[i].assoc.ip_port, packet, length); +#else + if (ip_isset(&client->assoc6.ip_port.ip)) + return sendpacket(dht->c->lossless_udp->net, client->assoc6.ip_port, packet, length); + else if (ip_isset(&client->assoc4.ip_port.ip)) + return sendpacket(dht->c->lossless_udp->net, client->assoc4.ip_port, packet, length); + else + break; +#endif + } } return -1; @@ -1132,8 +1277,7 @@ int route_packet(DHT *dht, uint8_t *client_id, uint8_t *packet, uint32_t length) */ static int friend_iplist(DHT *dht, IP_Port *ip_portlist, uint16_t friend_num) { - int num_ips = 0; - uint32_t i; + int i, num_ips = 0; uint64_t temp_time = unix_time(); if (friend_num >= dht->num_friends) @@ -1142,18 +1286,89 @@ static int friend_iplist(DHT *dht, IP_Port *ip_portlist, uint16_t friend_num) DHT_Friend *friend = &dht->friends_list[friend_num]; Client_data *client; - for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { - client = &(friend->client_list[i]); +#ifndef CLIENT_ONETOONE_IP + /* extra legwork, because having the outside allocating the space for us + * is *usually* good(tm) (bites us in the behind in this case though) */ + int client_friend = -1; + uint8_t client_friend_flags = 0; + uint32_t a; - if (id_equal(client->client_id, friend->client_id) && !is_timeout(temp_time, client->timestamp, BAD_NODE_TIMEOUT)) - return 0; + for(a = 0; a < 2; a++) +#endif + for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { + client = &(friend->client_list[i]); - /* If ip is not zero and node is good. */ - if (ip_isset(&client->ret_ip_port.ip) && !is_timeout(temp_time, client->ret_timestamp, BAD_NODE_TIMEOUT)) { - ip_portlist[num_ips] = client->ret_ip_port; - ++num_ips; + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &client->assoc; +#else + /* this is the one place where ipv4 is favored over ipv6, because + * we can't be sure there's enough space to return both, and we do + * need to return IPv4 (because of the majority of the people still + * lacking IPv6 connectivity) */ + if (!a) + assoc = &client->assoc4; + else + assoc = &client->assoc6; +#endif + if (id_equal(client->client_id, friend->client_id) && + !is_timeout(temp_time, assoc->timestamp, BAD_NODE_TIMEOUT)) + return 0; + + /* If ip is not zero and node is good. */ + if (ip_isset(&assoc->ret_ip_port.ip) && !is_timeout(temp_time, assoc->ret_timestamp, BAD_NODE_TIMEOUT)) { + ip_portlist[num_ips] = assoc->ret_ip_port; + ++num_ips; + +#ifndef CLIENT_ONETOONE_IP + if ((client_friend == -1) && id_equal(client->client_id, friend->client_id)) + client_friend = i; + + if (client_friend == i) + client_friend_flags |= 1 << a; + + if (num_ips == MAX_FRIEND_CLIENTS) { + /* if we got "real" IP addresses for the friend and we added + * the ipv4 one, but (maybe) couldn't add the ipv6 one + * due to space constraints... */ + if ((client_friend != -1) && (client_friend_flags == 1)) { + assoc = &friend->client_list[client_friend].assoc6; + + /* but the IPv6 address WOULD be valid... (which also + * means there is DEFINITELY a functioning IPv6 stack + * and connectivity!) */ + if (ip_isset(&assoc->ret_ip_port.ip) && + !is_timeout(temp_time, assoc->ret_timestamp, BAD_NODE_TIMEOUT)) { + uint32_t r; + + /* then kick another entry out: + * first, try to find an IPv6 entry to kick + * (don't need to look for friend's, because he + * definitely hasn't been added yet) */ + for (r = 0; r < MAX_FRIEND_CLIENTS; r++) + if (ip_portlist[r].ip.family == AF_INET6) { + ip_portlist[r] = assoc->ip_port; + return num_ips; + } + + /* no IPv6 found to kick: + * kick the first IPv4 that is NOT the friend's one */ + for (r = 0; r < MAX_FRIEND_CLIENTS; r++) + if ((ip_portlist[r].ip.family == AF_INET) && + !ipport_equal(&ip_portlist[r], &assoc->ip_port)) { + ip_portlist[r] = assoc->ip_port; + return num_ips; + } + + /* shouldn't be reached... */ + } + } + + return num_ips; + } +#endif + } } - } return num_ips; } @@ -1177,23 +1392,39 @@ int route_tofriend(DHT *dht, uint8_t *friend_id, uint8_t *packet, uint32_t lengt int ip_num = friend_iplist(dht, ip_list, num); if (ip_num < (MAX_FRIEND_CLIENTS / 2)) - return 0; + return 0; /* Reason for that? */ uint64_t temp_time = unix_time(); DHT_Friend *friend = &dht->friends_list[num]; Client_data *client; - for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { - client = &friend->client_list[i]; +#ifndef CLIENT_ONETOONE_IP + /* extra legwork, because having the outside allocating the space for us + * is *usually* good(tm) (bites us in the behind in this case though) */ + uint32_t a; - /* If ip is not zero and node is good. */ - if (ip_isset(&client->ret_ip_port.ip) && !is_timeout(temp_time, client->ret_timestamp, BAD_NODE_TIMEOUT)) { - int retval = sendpacket(dht->c->lossless_udp->net, client->ip_port, packet, length); + for(a = 0; a < 2; a++) +#endif + for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { + client = &friend->client_list[i]; + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &client->assoc; +#else + if (!a) + assoc = &client->assoc4; + else + assoc = &client->assoc6; +#endif + /* If ip is not zero and node is good. */ + if (ip_isset(&assoc->ret_ip_port.ip) && + !is_timeout(temp_time, assoc->ret_timestamp, BAD_NODE_TIMEOUT)) { + int retval = sendpacket(dht->c->lossless_udp->net, assoc->ip_port, packet, length); - if ((unsigned int)retval == length) - ++sent; + if ((unsigned int)retval == length) + ++sent; + } } - } return sent; } @@ -1212,20 +1443,35 @@ static int routeone_tofriend(DHT *dht, uint8_t *friend_id, uint8_t *packet, uint DHT_Friend *friend = &dht->friends_list[num]; Client_data *client; - IP_Port ip_list[MAX_FRIEND_CLIENTS]; + IP_Port ip_list[MAX_FRIEND_CLIENTS * 2]; int n = 0; uint32_t i; uint64_t temp_time = unix_time(); - for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { - client = &friend->client_list[i]; +#ifndef CLIENT_ONETOONE_IP + /* extra legwork, because having the outside allocating the space for us + * is *usually* good(tm) (bites us in the behind in this case though) */ + uint32_t a; - /* If ip is not zero and node is good. */ - if (ip_isset(&client->ret_ip_port.ip) && !is_timeout(temp_time, client->ret_timestamp, BAD_NODE_TIMEOUT)) { - ip_list[n] = client->ip_port; - ++n; + for(a = 0; a < 2; a++) +#endif + for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) { + client = &friend->client_list[i]; + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &client->assoc; +#else + if (!a) + assoc = &client->assoc4; + else + assoc = &client->assoc6; +#endif + /* If ip is not zero and node is good. */ + if (ip_isset(&assoc->ret_ip_port.ip) && !is_timeout(temp_time, assoc->ret_timestamp, BAD_NODE_TIMEOUT)) { + ip_list[n] = assoc->ip_port; + ++n; + } } - } if (n < 1) return 0; @@ -1308,12 +1554,12 @@ static int handle_NATping(void *object, IP_Port source, uint8_t *source_pubkey, if (packet[0] == NAT_PING_REQUEST) { /* 1 is reply */ send_NATping(dht, source_pubkey, ping_id, NAT_PING_RESPONSE); - friend->recvNATping_timestamp = unix_time(); + friend->nat.recvNATping_timestamp = unix_time(); return 0; } else if (packet[0] == NAT_PING_RESPONSE) { - if (friend->NATping_id == ping_id) { - friend->NATping_id = ((uint64_t)random_int() << 32) + random_int(); - friend->hole_punching = 1; + if (friend->nat.NATping_id == ping_id) { + friend->nat.NATping_id = ((uint64_t)random_int() << 32) + random_int(); + friend->nat.hole_punching = 1; return 0; } } @@ -1378,9 +1624,9 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports, return; uint32_t i; - uint32_t top = dht->friends_list[friend_num].punching_index + MAX_PUNCHING_PORTS; + uint32_t top = dht->friends_list[friend_num].nat.punching_index + MAX_PUNCHING_PORTS; - for (i = dht->friends_list[friend_num].punching_index; i != top; i++) { + for (i = dht->friends_list[friend_num].nat.punching_index; i != top; i++) { /* TODO: Improve port guessing algorithm. */ uint16_t port = port_list[(i / 2) % numports] + (i / (2 * numports)) * ((i % 2) ? -1 : 1); IP_Port pinging; @@ -1389,7 +1635,7 @@ static void punch_holes(DHT *dht, IP ip, uint16_t *port_list, uint16_t numports, send_ping_request(dht->ping, pinging, dht->friends_list[friend_num].client_id); } - dht->friends_list[friend_num].punching_index = i; + dht->friends_list[friend_num].nat.punching_index = i; } static void do_NAT(DHT *dht) @@ -1405,14 +1651,14 @@ static void do_NAT(DHT *dht) if (num < MAX_FRIEND_CLIENTS / 2) continue; - if (dht->friends_list[i].NATping_timestamp + PUNCH_INTERVAL < temp_time) { - send_NATping(dht, dht->friends_list[i].client_id, dht->friends_list[i].NATping_id, NAT_PING_REQUEST); - dht->friends_list[i].NATping_timestamp = temp_time; + if (dht->friends_list[i].nat.NATping_timestamp + PUNCH_INTERVAL < temp_time) { + send_NATping(dht, dht->friends_list[i].client_id, dht->friends_list[i].nat.NATping_id, NAT_PING_REQUEST); + dht->friends_list[i].nat.NATping_timestamp = temp_time; } - if (dht->friends_list[i].hole_punching == 1 && - dht->friends_list[i].punching_timestamp + PUNCH_INTERVAL < temp_time && - dht->friends_list[i].recvNATping_timestamp + PUNCH_INTERVAL * 2 >= temp_time) { + if (dht->friends_list[i].nat.hole_punching == 1 && + dht->friends_list[i].nat.punching_timestamp + PUNCH_INTERVAL < temp_time && + dht->friends_list[i].nat.recvNATping_timestamp + PUNCH_INTERVAL * 2 >= temp_time) { IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS / 2); @@ -1423,8 +1669,8 @@ static void do_NAT(DHT *dht) uint16_t numports = NAT_getports(port_list, ip_list, num, ip); punch_holes(dht, ip, port_list, numports, i); - dht->friends_list[i].punching_timestamp = temp_time; - dht->friends_list[i].hole_punching = 0; + dht->friends_list[i].nat.punching_timestamp = temp_time; + dht->friends_list[i].nat.hole_punching = 0; } } } @@ -1496,16 +1742,17 @@ void DHT_save_old(DHT *dht, uint8_t *data) */ int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size) { - if (size < sizeof(dht->close_clientlist)) { + size_t clientlist_oldsize = sizeof(Client_data_old) * LCLIENT_LIST; + if (size < clientlist_oldsize) { #ifdef DEBUG fprintf(stderr, "DHT_load: Expected at least %u bytes, got %u.\n", sizeof(dht->close_clientlist), size); #endif return -1; } - uint32_t friendlistsize = size - sizeof(dht->close_clientlist); + uint32_t friendlistsize = size - clientlist_oldsize; - if (friendlistsize % sizeof(DHT_Friend) != 0) { + if (friendlistsize % sizeof(DHT_Friend_old) != 0) { #ifdef DEBUG fprintf(stderr, "DHT_load: Expected a multiple of %u, got %u.\n", sizeof(DHT_Friend), friendlistsize); #endif @@ -1513,11 +1760,11 @@ int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size) } uint32_t i, j; - Client_data *client; - uint16_t friends_num = friendlistsize / sizeof(DHT_Friend); + Client_data_old *client; + uint16_t friends_num = friendlistsize / sizeof(DHT_Friend_old); if (friends_num != 0) { - DHT_Friend *tempfriends_list = (DHT_Friend *)(data + sizeof(dht->close_clientlist)); + DHT_Friend_old *tempfriends_list = (DHT_Friend_old *)(data + sizeof(dht->close_clientlist)); for (i = 0; i < friends_num; ++i) { DHT_addfriend(dht, tempfriends_list[i].client_id); @@ -1525,17 +1772,17 @@ int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size) for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { client = &tempfriends_list[i].client_list[j]; - if (client->timestamp != 0) - getnodes(dht, client->ip_port, client->client_id, tempfriends_list[i].client_id); + if (client->assoc.timestamp != 0) + getnodes(dht, client->assoc.ip_port, client->client_id, tempfriends_list[i].client_id); } } } - Client_data *tempclose_clientlist = (Client_data *)data; + Client_data_old *tempclose_clientlist = (Client_data_old *)data; for (i = 0; i < LCLIENT_LIST; ++i) { - if (tempclose_clientlist[i].timestamp != 0) - DHT_bootstrap(dht, tempclose_clientlist[i].ip_port, + if (tempclose_clientlist[i].assoc.timestamp != 0) + DHT_bootstrap(dht, tempclose_clientlist[i].assoc.ip_port, tempclose_clientlist[i].client_id ); } @@ -1548,8 +1795,10 @@ int DHT_load_old(DHT *dht, uint8_t *data, uint32_t size) #define DHT_STATE_COOKIE_GLOBAL 0x159000d #define DHT_STATE_COOKIE_TYPE 0x11ce -#define DHT_STATE_TYPE_FRIENDS 1 -#define DHT_STATE_TYPE_CLIENTS 2 +#define DHT_STATE_TYPE_FRIENDS 1 +#define DHT_STATE_TYPE_CLIENTS 2 +#define DHT_STATE_TYPE_FRIENDS_ASSOC46 3 +#define DHT_STATE_TYPE_CLIENTS_ASSOC46 4 /* Get the size of the DHT (for saving). */ uint32_t DHT_size(DHT *dht) @@ -1557,7 +1806,12 @@ uint32_t DHT_size(DHT *dht) uint32_t num = 0, i; for (i = 0; i < LCLIENT_LIST; ++i) - if (dht->close_clientlist[i].timestamp != 0) +#ifdef CLIENT_ONETOONE_IP + if (dht->close_clientlist[i].assoc.timestamp != 0) +#else + if ((dht->close_clientlist[i].assoc4.timestamp != 0) || + (dht->close_clientlist[i].assoc6.timestamp != 0)) +#endif num++; uint32_t size32 = sizeof(uint32_t), sizesubhead = size32 * 2; @@ -1584,7 +1838,11 @@ void DHT_save(DHT *dht, uint8_t *data) data += sizeof(uint32_t); len = sizeof(DHT_Friend) * dht->num_friends; +#ifdef CLIENT_ONETOONE_IP type = DHT_STATE_TYPE_FRIENDS; +#else + type = DHT_STATE_TYPE_FRIENDS_ASSOC46; +#endif data = z_state_save_subheader(data, len, type); memcpy(data, dht->friends_list, len); data += len; @@ -1592,18 +1850,32 @@ void DHT_save(DHT *dht, uint8_t *data) uint32_t num = 0, i; for (i = 0; i < LCLIENT_LIST; ++i) - if (dht->close_clientlist[i].timestamp != 0) +#ifdef CLIENT_ONETOONE_IP + if (dht->close_clientlist[i].assoc.timestamp != 0) +#else + if ((dht->close_clientlist[i].assoc4.timestamp != 0) || + (dht->close_clientlist[i].assoc6.timestamp != 0)) +#endif num++; len = num * sizeof(Client_data); +#ifdef CLIENT_ONETOONE_IP type = DHT_STATE_TYPE_CLIENTS; +#else + type = DHT_STATE_TYPE_CLIENTS_ASSOC46; +#endif data = z_state_save_subheader(data, len, type); if (num) { Client_data *clients = (Client_data *)data; for (num = 0, i = 0; i < LCLIENT_LIST; ++i) - if (dht->close_clientlist[i].timestamp != 0) +#ifdef CLIENT_ONETOONE_IP + if (dht->close_clientlist[i].assoc.timestamp != 0) +#else + if ((dht->close_clientlist[i].assoc4.timestamp != 0) || + (dht->close_clientlist[i].assoc6.timestamp != 0)) +#endif memcpy(&clients[num++], &dht->close_clientlist[i], sizeof(Client_data)); } @@ -1617,35 +1889,81 @@ static int dht_load_state_callback(void *outer, uint8_t *data, uint32_t length, switch (type) { case DHT_STATE_TYPE_FRIENDS: - if (length % sizeof(DHT_Friend) != 0) + if (length % sizeof(DHT_Friend_old) != 0) break; - DHT_Friend *friend_list = (DHT_Friend *)data; - num = length / sizeof(DHT_Friend); + { /* localize declarations */ + DHT_Friend_old *friend_list = (DHT_Friend_old *)data; + num = length / sizeof(DHT_Friend_old); - for (i = 0; i < num; ++i) { - DHT_addfriend(dht, friend_list[i].client_id); + for (i = 0; i < num; ++i) { + DHT_addfriend(dht, friend_list[i].client_id); - for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { - Client_data *client = &friend_list[i].client_list[j]; + for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { + Client_data_old *client = &friend_list[i].client_list[j]; - if (client->timestamp != 0) - getnodes(dht, client->ip_port, client->client_id, friend_list[i].client_id); + if (client->assoc.timestamp != 0) + getnodes(dht, client->assoc.ip_port, client->client_id, friend_list[i].client_id); + } } - } + } /* localize declarations */ break; case DHT_STATE_TYPE_CLIENTS: - if ((length % sizeof(Client_data)) != 0) + if ((length % sizeof(Client_data_old)) != 0) break; - num = length / sizeof(Client_data); - Client_data *client_list = (Client_data *)data; + { /* localize declarations */ + num = length / sizeof(Client_data_old); + Client_data_old *client_list = (Client_data_old *)data; - for (i = 0; i < num; ++i) - if (client_list[i].timestamp != 0) - DHT_bootstrap(dht, client_list[i].ip_port, client_list[i].client_id); + for (i = 0; i < num; ++i) + if (client_list[i].assoc.timestamp != 0) + DHT_bootstrap(dht, client_list[i].assoc.ip_port, client_list[i].client_id); + } /* localize declarations */ + + break; + + case DHT_STATE_TYPE_FRIENDS_ASSOC46: + if (length % sizeof(DHT_Friend_new) != 0) + break; + + { /* localize declarations */ + DHT_Friend_new *friend_list = (DHT_Friend_new *)data; + num = length / sizeof(DHT_Friend_new); + + for (i = 0; i < num; ++i) { + DHT_addfriend(dht, friend_list[i].client_id); + + for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) { + Client_data_new *client = &friend_list[i].client_list[j]; + + if (client->assoc4.timestamp != 0) + getnodes(dht, client->assoc4.ip_port, client->client_id, friend_list[i].client_id); + if (client->assoc6.timestamp != 0) + getnodes(dht, client->assoc6.ip_port, client->client_id, friend_list[i].client_id); + } + } + } /* localize declarations */ + + break; + + case DHT_STATE_TYPE_CLIENTS_ASSOC46: + if ((length % sizeof(Client_data_new)) != 0) + break; + + { /* localize declarations */ + num = length / sizeof(Client_data_new); + Client_data_new *client_list = (Client_data_new *)data; + + for (i = 0; i < num; ++i) { + if (client_list[i].assoc4.timestamp != 0) + DHT_bootstrap(dht, client_list[i].assoc4.ip_port, client_list[i].client_id); + if (client_list[i].assoc6.timestamp != 0) + DHT_bootstrap(dht, client_list[i].assoc6.ip_port, client_list[i].client_id); + } + } /* localize declarations */ break; @@ -1685,7 +2003,13 @@ int DHT_isconnected(DHT *dht) uint64_t temp_time = unix_time(); for (i = 0; i < LCLIENT_LIST; ++i) { - if (!is_timeout(temp_time, dht->close_clientlist[i].timestamp, BAD_NODE_TIMEOUT)) + Client_data *client = &dht->close_clientlist[i]; +#ifdef CLIENT_ONETOONE_IP + if (!is_timeout(temp_time, client->assoc.timestamp, BAD_NODE_TIMEOUT)) +#else + if (!is_timeout(temp_time, client->assoc4.timestamp, BAD_NODE_TIMEOUT) || + !is_timeout(temp_time, client->assoc6.timestamp, BAD_NODE_TIMEOUT)) +#endif return 1; } diff --git a/toxcore/DHT.h b/toxcore/DHT.h index 7cb3198d..46193b56 100644 --- a/toxcore/DHT.h +++ b/toxcore/DHT.h @@ -44,7 +44,6 @@ #define MAX_TOPING 16 typedef struct { - uint8_t client_id[CLIENT_ID_SIZE]; IP_Port ip_port; uint64_t timestamp; uint64_t last_pinged; @@ -52,19 +51,22 @@ typedef struct { /* Returned by this node. Either our friend or us. */ IP_Port ret_ip_port; uint64_t ret_timestamp; -} Client_data; +} IPPTsPng; + +typedef struct { + uint8_t client_id[CLIENT_ID_SIZE]; + IPPTsPng assoc; +} Client_data_old; + +typedef struct { + uint8_t client_id[CLIENT_ID_SIZE]; + IPPTsPng assoc4; + IPPTsPng assoc6; +} Client_data_new; /*----------------------------------------------------------------------------------*/ typedef struct { - uint8_t client_id[CLIENT_ID_SIZE]; - Client_data client_list[MAX_FRIEND_CLIENTS]; - - /* Time at which the last get_nodes request was sent. */ - uint64_t lastgetnode; - - /* Symetric NAT hole punching stuff. */ - /* 1 if currently hole punching, otherwise 0 */ uint8_t hole_punching; uint32_t punching_index; @@ -72,7 +74,38 @@ typedef struct { uint64_t recvNATping_timestamp; uint64_t NATping_id; uint64_t NATping_timestamp; -} DHT_Friend; +} NAT; + +typedef struct { + uint8_t client_id[CLIENT_ID_SIZE]; + Client_data_old client_list[MAX_FRIEND_CLIENTS]; + + /* Time at which the last get_nodes request was sent. */ + uint64_t lastgetnode; + + /* Symetric NAT hole punching stuff. */ + NAT nat; +} DHT_Friend_old; + +typedef struct { + uint8_t client_id[CLIENT_ID_SIZE]; + Client_data_new client_list[MAX_FRIEND_CLIENTS]; + + /* Time at which the last get_nodes request was sent. */ + uint64_t lastgetnode; + + /* Symetric NAT hole punching stuff. */ + NAT nat; +} DHT_Friend_new; + +/* #define CLIENT_ONETOONE_IP */ +#ifdef CLIENT_ONETOONE_IP +typedef Client_data_old Client_data; +typedef DHT_Friend_old DHT_Friend; +#else +typedef Client_data_new Client_data; +typedef DHT_Friend_new DHT_Friend; +#endif /* this must be kept even if IP_Port is expanded: wire compatibility */ typedef struct { diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c index f22a8d57..8ad15bc1 100644 --- a/toxcore/Messenger.c +++ b/toxcore/Messenger.c @@ -1296,18 +1296,23 @@ void doMessenger(Messenger *m) for (client = 0; client < LCLIENT_LIST; client++) { Client_data *cptr = &m->dht->close_clientlist[client]; + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &cptr->assoc; +#else + for (assoc = &cptr->assoc4; assoc != &cptr->assoc6; assoc = &cptr->assoc6) +#endif + if (ip_isset(&assoc->ip_port.ip)) { + last_pinged = lastdump - assoc->last_pinged; - if (ip_isset(&cptr->ip_port.ip)) { - last_pinged = lastdump - cptr->last_pinged; + if (last_pinged > 999) + last_pinged = 999; - if (last_pinged > 999) - last_pinged = 999; - - snprintf(logbuffer, sizeof(logbuffer), "C[%2u] %s:%u [%3u] %s\n", - client, ip_ntoa(&cptr->ip_port.ip), ntohs(cptr->ip_port.port), - last_pinged, ID2String(cptr->client_id)); - loglog(logbuffer); - } + snprintf(logbuffer, sizeof(logbuffer), "C[%2u] %s:%u [%3u] %s\n", + client, ip_ntoa(&assoc->ip_port.ip), ntohs(assoc->ip_port.port), + last_pinged, ID2String(cptr->client_id)); + loglog(logbuffer); + } } loglog(" = = = = = = = = \n"); @@ -1350,16 +1355,24 @@ void doMessenger(Messenger *m) for (client = 0; client < MAX_FRIEND_CLIENTS; client++) { Client_data *cptr = &dhtfptr->client_list[client]; - last_pinged = lastdump - cptr->last_pinged; + IPPTsPng *assoc = NULL; +#ifdef CLIENT_ONETOONE_IP + assoc = &cptr->assoc; +#else + for (assoc = &cptr->assoc4; assoc != &cptr->assoc6; assoc = &cptr->assoc6) +#endif + if (ip_isset(&assoc->ip_port.ip)) { + last_pinged = lastdump - assoc->last_pinged; - if (last_pinged > 999) - last_pinged = 999; + if (last_pinged > 999) + last_pinged = 999; - snprintf(logbuffer, sizeof(logbuffer), "F[%2u] => C[%2u] %s:%u [%3u] %s\n", - friend, client, ip_ntoa(&cptr->ip_port.ip), - ntohs(cptr->ip_port.port), last_pinged, - ID2String(cptr->client_id)); - loglog(logbuffer); + snprintf(logbuffer, sizeof(logbuffer), "F[%2u] => C[%2u] %s:%u [%3u] %s\n", + friend, client, ip_ntoa(&assoc->ip_port.ip), + ntohs(assoc->ip_port.port), last_pinged, + ID2String(cptr->client_id)); + loglog(logbuffer); + } } } diff --git a/toxcore/util.h b/toxcore/util.h index 9e4ac79a..13ab4792 100644 --- a/toxcore/util.h +++ b/toxcore/util.h @@ -20,8 +20,6 @@ typedef int (*load_state_callback_func)(void *outer, uint8_t *data, uint32_t len int load_state(load_state_callback_func load_state_callback, void *outer, uint8_t *data, uint32_t length, uint16_t cookie_inner); -#undef LOGGING -/* #define LOGGING */ #ifdef LOGGING extern char logbuffer[512]; void loginit(uint16_t port);