/usr/include/gnunet/gnunet_nat_lib.h is in gnunet-dev 0.10.1-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 | /*
This file is part of GNUnet.
(C) 2007-2014 Christian Grothoff (and other contributing authors)
GNUnet 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, or (at your
option) any later version.
GNUnet 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 GNUnet; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
/**
* @file include/gnunet_nat_lib.h
* @brief Library handling UPnP and NAT-PMP port forwarding and
* external IP address retrieval
* @author Christian Grothoff
* @author Milan Bouchet-Valat
*/
#ifndef GNUNET_NAT_LIB_H
#define GNUNET_NAT_LIB_H
#include "gnunet_util_lib.h"
/**
* Signature of the callback passed to #GNUNET_NAT_register() for
* a function to call whenever our set of 'valid' addresses changes.
*
* @param cls closure
* @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean
* the previous (now invalid) one
* @param addr either the previous or the new public IP address
* @param addrlen actual length of the @a addr
*/
typedef void
(*GNUNET_NAT_AddressCallback) (void *cls,
int add_remove,
const struct sockaddr *addr,
socklen_t addrlen);
/**
* Signature of the callback passed to #GNUNET_NAT_register().
* for a function to call whenever someone asks us to do connection
* reversal.
*
* @param cls closure
* @param addr public IP address of the other peer
* @param addrlen actual lenght of the @a addr
*/
typedef void
(*GNUNET_NAT_ReversalCallback) (void *cls,
const struct sockaddr *addr,
socklen_t addrlen);
/**
* Handle for active NAT registrations.
*/
struct GNUNET_NAT_Handle;
/**
* Attempt to enable port redirection and detect public IP address
* contacting UPnP or NAT-PMP routers on the local network. Use addr
* to specify to which of the local host's addresses should the
* external port be mapped. The port is taken from the corresponding
* sockaddr_in[6] field. The NAT module should call the given
* callback for any 'plausible' external address.
*
* @param cfg configuration to use
* @param is_tcp #GNUNET_YES for TCP, #GNUNET_NO for UDP
* @param adv_port advertised port (port we are either bound to or that our OS
* locally performs redirection from to our bound port).
* @param num_addrs number of addresses in @a addrs
* @param addrs list of local addresses packets should be redirected to
* @param addrlens actual lengths of the addresses in @a addrs
* @param address_callback function to call everytime the public IP address changes
* @param reversal_callback function to call if someone wants connection reversal from us,
* NULL if connection reversal is not supported
* @param callback_cls closure for callbacks
* @return NULL on error, otherwise handle that can be used to unregister
*/
struct GNUNET_NAT_Handle *
GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
int is_tcp,
uint16_t adv_port,
unsigned int num_addrs,
const struct sockaddr **addrs,
const socklen_t *addrlens,
GNUNET_NAT_AddressCallback address_callback,
GNUNET_NAT_ReversalCallback reversal_callback,
void *callback_cls);
/**
* Test if the given address is (currently) a plausible IP address for
* this peer.
*
* @param h the handle returned by register
* @param addr IP address to test (IPv4 or IPv6)
* @param addrlen number of bytes in @a addr
* @return #GNUNET_YES if the address is plausible,
* #GNUNET_NO if the address is not plausible,
* #GNUNET_SYSERR if the address is malformed
*/
int
GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h,
const void *addr,
socklen_t addrlen);
/**
* We learned about a peer (possibly behind NAT) so run the
* gnunet-nat-client to send dummy ICMP responses to cause
* that peer to connect to us (connection reversal).
*
* @param h handle (used for configuration)
* @param sa the address of the peer (IPv4-only)
* @return #GNUNET_SYSERR on error, #GNUNET_NO if nat client is disabled,
* #GNUNET_OK otherwise
*/
int
GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
const struct sockaddr_in *sa);
/**
* Stop port redirection and public IP address detection for the given
* handle. This frees the handle, after having sent the needed
* commands to close open ports.
*
* @param h the handle to stop
*/
void
GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h);
/**
* Handle to a NAT test.
*/
struct GNUNET_NAT_Test;
/**
* Function called to report success or failure for
* NAT configuration test.
*
* @param cls closure
* @param success #GNUNET_OK on success, #GNUNET_NO on failure,
* #GNUNET_SYSERR if the test could not be
* properly started (internal failure)
* @param emsg NULL on success, otherwise may include an error message
*/
typedef void (*GNUNET_NAT_TestCallback) (void *cls,
int success,
const char *emsg);
/**
* Start testing if NAT traversal works using the
* given configuration (IPv4-only).
*
* @param cfg configuration for the NAT traversal
* @param is_tcp #GNUNET_YES to test TCP, #GNUNET_NO to test UDP
* @param bnd_port port to bind to, 0 for connection reversal
* @param adv_port externally advertised port to use
* @param report function to call with the result of the test
* @param report_cls closure for @a report
* @return handle to cancel NAT test
*/
struct GNUNET_NAT_Test *
GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
int is_tcp,
uint16_t bnd_port,
uint16_t adv_port,
GNUNET_NAT_TestCallback report,
void *report_cls);
/**
* Stop an active NAT test.
*
* @param tst test to stop.
*/
void
GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst);
/**
* Signature of a callback that is given an IP address.
*
* @param cls closure
* @param addr the address, NULL on errors
* @param emsg NULL on success, otherwise may include an error message
*/
typedef void (*GNUNET_NAT_IPCallback) (void *cls,
const struct in_addr *addr,
const char *emsg);
/**
* Opaque handle to cancel #GNUNET_NAT_mini_get_external_ipv4() operation.
*/
struct GNUNET_NAT_ExternalHandle;
/**
* Try to get the external IPv4 address of this peer.
*
* @param timeout when to fail
* @param cb function to call with result
* @param cb_cls closure for @a cb
* @return handle for cancellation (can only be used until @a cb is called), NULL on error
*/
struct GNUNET_NAT_ExternalHandle *
GNUNET_NAT_mini_get_external_ipv4 (struct GNUNET_TIME_Relative timeout,
GNUNET_NAT_IPCallback cb,
void *cb_cls);
/**
* Cancel operation.
*
* @param eh operation to cancel
*/
void
GNUNET_NAT_mini_get_external_ipv4_cancel (struct GNUNET_NAT_ExternalHandle *eh);
/**
* Handle to a mapping created with upnpc.
*/
struct GNUNET_NAT_MiniHandle;
/**
* Signature of the callback passed to #GNUNET_NAT_register() for
* a function to call whenever our set of 'valid' addresses changes.
*
* @param cls closure
* @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean
* the previous (now invalid) one
* @param addr either the previous or the new public IP address
* @param addrlen actual length of the @a addr
*/
typedef void
(*GNUNET_NAT_MiniAddressCallback) (void *cls,
int add_remove,
const struct sockaddr *addr,
socklen_t addrlen,
const char *emsg);
/**
* Start mapping the given port using (mini)upnpc. This function
* should typically not be used directly (it is used within the
* general-purpose #GNUNET_NAT_register() code). However, it can be
* used if specifically UPnP-based NAT traversal is to be used or
* tested.
*
* @param port port to map
* @param is_tcp #GNUNET_YES to map TCP, #GNUNET_NO for UDP
* @param ac function to call with mapping result
* @param ac_cls closure for @a ac
* @return NULL on error
*/
struct GNUNET_NAT_MiniHandle *
GNUNET_NAT_mini_map_start (uint16_t port,
int is_tcp,
GNUNET_NAT_MiniAddressCallback ac,
void *ac_cls);
/**
* Remove a mapping created with (mini)upnpc. Calling
* this function will give 'upnpc' 1s to remove the mapping,
* so while this function is non-blocking, a task will be
* left with the scheduler for up to 1s past this call.
*
* @param mini the handle
*/
void
GNUNET_NAT_mini_map_stop (struct GNUNET_NAT_MiniHandle *mini);
/**
* Handle to auto-configuration in progress.
*/
struct GNUNET_NAT_AutoHandle;
/**
* Function called with the result from the autoconfiguration.
*
* @param cls closure
* @param diff minimal suggested changes to the original configuration
* to make it work (as best as we can)
* @param emsg NULL on success, otherwise may include an error message
*/
typedef void
(*GNUNET_NAT_AutoResultCallback)(void *cls,
const struct GNUNET_CONFIGURATION_Handle *diff,
const char *emsg);
/**
* Start auto-configuration routine. The resolver service should
* be available when this function is called.
*
* @param cfg initial configuration
* @param cb function to call with autoconfiguration result
* @param cb_cls closure for @a cb
* @return handle to cancel operation
*/
struct GNUNET_NAT_AutoHandle *
GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_NAT_AutoResultCallback cb,
void *cb_cls);
/**
* Abort autoconfiguration.
*
* @param ah handle for operation to abort
*/
void
GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah);
#endif
/* end of gnunet_nat_lib.h */
|