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
194
195
196
197
198
199
200
201
202
203
204
205
206
|
/* SPDX-License-Identifier: GPL-3.0-or-later
* Copyright © 2016-2020 The TokTok team.
* Copyright © 2013 Tox project.
*/
#ifndef C_TOXCORE_TOXCORE_TOX_PRIVATE_H
#define C_TOXCORE_TOXCORE_TOX_PRIVATE_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "tox.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef uint64_t tox_mono_time_cb(void *user_data);
struct Tox_System {
tox_mono_time_cb *mono_time_callback;
void *mono_time_user_data;
const struct Random *rng;
const struct Network *ns;
const struct Memory *mem;
};
Tox_System tox_default_system(void);
void tox_lock(const Tox *tox);
void tox_unlock(const Tox *tox);
const Tox_System *tox_get_system(Tox *tox);
/**
* Set the callback for the `friend_lossy_packet` event for a specific packet ID.
* Pass NULL to unset.
*
* allowed packet ID range:
* from `PACKET_ID_RANGE_LOSSY_START` to `PACKET_ID_RANGE_LOSSY_END` (both inclusive)
*/
void tox_callback_friend_lossy_packet_per_pktid(Tox *tox, tox_friend_lossy_packet_cb *callback, uint8_t pktid);
/**
* Set the callback for the `friend_lossless_packet` event for a specific packet ID.
* Pass NULL to unset.
*
* allowed packet ID range:
* from `PACKET_ID_RANGE_LOSSLESS_CUSTOM_START` to `PACKET_ID_RANGE_LOSSLESS_CUSTOM_END` (both inclusive)
* and
* `PACKET_ID_MSI`
*/
void tox_callback_friend_lossless_packet_per_pktid(Tox *tox, tox_friend_lossless_packet_cb *callback, uint8_t pktid);
void tox_set_av_object(Tox *tox, void *object);
void *tox_get_av_object(const Tox *tox);
/*******************************************************************************
*
* :: DHT network queries.
*
******************************************************************************/
/**
* The minimum size of an IP string buffer in bytes.
*/
#define TOX_DHT_NODE_IP_STRING_SIZE 96
uint32_t tox_dht_node_ip_string_size(void);
/**
* The size of a DHT node public key in bytes.
*/
#define TOX_DHT_NODE_PUBLIC_KEY_SIZE 32
uint32_t tox_dht_node_public_key_size(void);
/**
* @param public_key The node's public key.
* @param ip The node's IP address, represented as a null terminated string.
* @param port The node's port.
*/
typedef void tox_dht_get_nodes_response_cb(Tox *tox, const uint8_t *public_key, const char *ip, uint16_t port,
void *user_data);
/**
* Set the callback for the `dht_get_nodes_response` event. Pass NULL to unset.
*
* This event is triggered when a getnodes response is received from a DHT peer.
*/
void tox_callback_dht_get_nodes_response(Tox *tox, tox_dht_get_nodes_response_cb *callback);
typedef enum Tox_Err_Dht_Get_Nodes {
/**
* The function returned successfully.
*/
TOX_ERR_DHT_GET_NODES_OK,
/**
* UDP is disabled in tox options; the DHT can only be queried when UDP is enabled.
*/
TOX_ERR_DHT_GET_NODES_UDP_DISABLED,
/**
* One of the arguments to the function was NULL when it was not expected.
*/
TOX_ERR_DHT_GET_NODES_NULL,
/**
* The supplied port is invalid.
*/
TOX_ERR_DHT_GET_NODES_BAD_PORT,
/**
* The supplied IP address is invalid.
*/
TOX_ERR_DHT_GET_NODES_BAD_IP,
/**
* The getnodes request failed. This usually means the packet failed to send.
*/
TOX_ERR_DHT_GET_NODES_FAIL,
} Tox_Err_Dht_Get_Nodes;
/**
* This function sends a getnodes request to a DHT node for its peers that
* are "close" to the passed target public key according to the distance metric used
* by the DHT implementation.
*
* @param public_key The public key of the node that we wish to query. This key must be
* at least `TOX_DHT_NODE_PUBLIC_KEY_SIZE` bytes in length.
* @param ip A NULL terminated string representing the IP address of the node we wish to query.
* @param port The port of the node we wish to query.
* @param target_public_key The public key for which we want to find close nodes.
*
* @return true on success.
*/
bool tox_dht_get_nodes(const Tox *tox, const uint8_t *public_key, const char *ip, uint16_t port,
const uint8_t *target_public_key, Tox_Err_Dht_Get_Nodes *error);
/**
* This function returns the ratio of close dht nodes that are known to support announce/store.
* This function returns the number of DHT nodes in the closelist.
*
* @return number
*/
uint16_t tox_dht_get_num_closelist(const Tox *tox);
/**
* This function returns the number of DHT nodes in the closelist,
* that are capable to store annouce data (introduced in version 0.2.18).
*
* @return number
*/
uint16_t tox_dht_get_num_closelist_announce_capable(const Tox *tox);
/*******************************************************************************
*
* :: DHT groupchat queries.
*
******************************************************************************/
/**
* Maximum size of a peer IP address string.
*/
#define TOX_GROUP_PEER_IP_STRING_MAX_LENGTH 96
uint32_t tox_group_peer_ip_string_max_length(void);
/**
* Return the length of the peer's IP address in string form. If the group number or ID
* is invalid, the return value is unspecified.
*
* @param group_number The group number of the group we wish to query.
* @param peer_id The ID of the peer whose IP address length we want to retrieve.
*/
size_t tox_group_peer_get_ip_address_size(const Tox *tox, uint32_t group_number, uint32_t peer_id,
Tox_Err_Group_Peer_Query *error);
/**
* Write the IP address associated with the designated peer_id for the designated group number
* to ip_addr.
*
* If the peer is forcing TCP connections a placeholder value will be written instead,
* indicating that their real IP address is unknown to us.
*
* If `peer_id` designates ourself, it will write either our own IP address or a placeholder value,
* depending on whether or not we're forcing TCP connections.
*
* Call tox_group_peer_get_ip_address_size to determine the allocation size for the `ip_addr` parameter.
*
* @param group_number The group number of the group we wish to query.
* @param peer_id The ID of the peer whose public key we wish to retrieve.
* @param ip_addr A valid memory region large enough to store the IP address string.
* If this parameter is NULL, this function call has no effect.
*
* @return true on success.
*/
bool tox_group_peer_get_ip_address(const Tox *tox, uint32_t group_number, uint32_t peer_id, uint8_t *ip_addr,
Tox_Err_Group_Peer_Query *error);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* C_TOXCORE_TOXCORE_TOX_PRIVATE_H */
|
