summaryrefslogtreecommitdiff
path: root/core/DHT.h
blob: 7d926b13a721321093fa10f33803ac1c6a2652d8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
/* DHT.h
 *
 * An implementation of the DHT as seen in http://wiki.tox.im/index.php/DHT
 *
 *  Copyright (C) 2013 Tox project All Rights Reserved.
 *
 *  This file is part of Tox.
 *
 *  Tox is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Tox is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Tox.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DHT_H
#define DHT_H

#include "net_crypto.h"

#ifdef __cplusplus
extern "C" {
#endif


/* size of the client_id in bytes */
#define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES

/* maximum number of clients stored per friend. */
#define MAX_FRIEND_CLIENTS 8

/* A list of the clients mathematically closest to ours. */
#define LCLIENT_LIST 32

/* The list of ip ports along with the ping_id of what we sent them and a timestamp */
#define LPING_ARRAY 256 //NOTE Deprecated (doesn't do anything)

#define LSEND_NODES_ARRAY LPING_ARRAY/2

/*Maximum newly announced nodes to ping per TIME_TOPING seconds*/
#define MAX_TOPING 16

typedef struct {
    uint8_t     client_id[CLIENT_ID_SIZE];
    IP_Port     ip_port;
    uint64_t    timestamp;
    uint64_t    last_pinged;

    /* Returned by this node. Either our friend or us */
    IP_Port     ret_ip_port;
    uint64_t    ret_timestamp;
} Client_data;

/*----------------------------------------------------------------------------------*/

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;
    uint64_t    punching_timestamp;
    uint64_t    recvNATping_timestamp;
    uint64_t    NATping_id;
    uint64_t    NATping_timestamp;
} DHT_Friend;

typedef struct {
    uint8_t     client_id[CLIENT_ID_SIZE];
    IP_Port     ip_port;
} Node_format;

typedef struct {
    IP_Port     ip_port;
    uint64_t    ping_id;
    uint64_t    timestamp;
} Pinged;

/*----------------------------------------------------------------------------------*/
typedef struct {
    Net_Crypto *c;
    Client_data  close_clientlist[LCLIENT_LIST];
    DHT_Friend      *friends_list;
    uint16_t     num_friends;
    Pinged       send_nodes[LSEND_NODES_ARRAY];
    Node_format  toping[MAX_TOPING];
    uint64_t     last_toping;
    uint64_t close_lastgetnodes;
    void * ping;
} DHT;
/*----------------------------------------------------------------------------------*/

Client_data *DHT_get_close_list(DHT * dht);

/* Add a new friend to the friends list
    client_id must be CLIENT_ID_SIZE bytes long.
    returns 0 if success
    returns 1 if failure (friends list is full) */
int DHT_addfriend(DHT * dht, uint8_t *client_id);

/* Delete a friend from the friends list
    client_id must be CLIENT_ID_SIZE bytes long.
    returns 0 if success
    returns 1 if failure (client_id not in friends list) */
int DHT_delfriend(DHT * dht, uint8_t *client_id);

/* Get ip of friend
    client_id must be CLIENT_ID_SIZE bytes long.
    ip must be 4 bytes long.
    port must be 2 bytes long.
    returns ip if success
    returns ip of 0 if failure (This means the friend is either offline or we have not found him yet.)
    returns ip of 1 if friend is not in list. */
IP_Port DHT_getfriendip(DHT * dht, uint8_t *client_id);

/* Run this function at least a couple times per second (It's the main loop) */
void do_DHT(DHT * dht);

/* Use this function to bootstrap the client
    Sends a get nodes request to the given node with ip port and public_key */
void DHT_bootstrap(DHT * dht, IP_Port ip_port, uint8_t *public_key);

/* Add nodes to the toping list
   all nodes in this list are pinged every TIME_TOPING seconds
   and are then removed from the list.
   if the list is full the nodes farthest from our client_id are replaced
   the purpose of this list is to enable quick integration of new nodes into the
   network while preventing amplification attacks.
   return 0 if node was added
   return -1 if node was not added */
int add_toping(DHT * dht, uint8_t *client_id, IP_Port ip_port);

/* ROUTING FUNCTIONS */

/* send the given packet to node with client_id
    returns -1 if failure */
int route_packet(DHT * dht, uint8_t *client_id, uint8_t *packet, uint32_t length);

/* Send the following packet to everyone who tells us they are connected to friend_id
    returns the number of nodes it sent the packet to */
int route_tofriend(DHT * dht, uint8_t *friend_id, uint8_t *packet, uint32_t length);

/* NAT PUNCHING FUNCTIONS */

/* Puts all the different ips returned by the nodes for a friend_id into array ip_portlist
    ip_portlist must be at least MAX_FRIEND_CLIENTS big
    returns the number of ips returned
    returns -1 if no such friend*/
int friend_ips(DHT * dht, IP_Port *ip_portlist, uint8_t *friend_id);

/* SAVE/LOAD functions */

/* get the size of the DHT (for saving) */
uint32_t DHT_size(DHT * dht);

/* save the DHT in data where data is an array of size DHT_size() */
void DHT_save(DHT * dht, uint8_t *data);

/* init DHT */
DHT * new_DHT(Net_Crypto *c);

void kill_DHT(DHT * dht);

/* load the DHT from data of size size;
    return -1 if failure
    return 0 if success */
int DHT_load(DHT * dht, uint8_t *data, uint32_t size);

/* returns 0 if we are not connected to the DHT
    returns 1 if we are */
int DHT_isconnected(DHT * dht);

void addto_lists(DHT * dht, IP_Port ip_port, uint8_t *client_id);

#ifdef __cplusplus
}
#endif

#endif