GNUnet  0.17.6
nat_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2007-2017 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
29 #include "platform.h"
30 #include "gnunet_nat_service.h"
31 #include "nat.h"
32 #include "nat_stun.h"
33 
34 
38 struct AddrEntry
39 {
43  struct AddrEntry *next;
44 
48  struct AddrEntry *prev;
49 
54  void *app_ctx;
55 
60 
64  socklen_t addrlen;
65 };
66 
67 
72 {
77 
82 
87 
91  struct AddrEntry *ae_head;
92 
96  struct AddrEntry *ae_tail;
97 
102 
107 
112 
117 
122 };
123 
124 
130 static void
131 do_connect (void *cls);
132 
133 
139 static void
141 {
142  struct AddrEntry *ae;
143 
144  if (NULL != nh->mq)
145  {
147  nh->mq = NULL;
148  }
149  while (NULL != (ae = nh->ae_head))
150  {
153  &ae->app_ctx,
154  GNUNET_NO,
155  ae->ac,
156  (const struct sockaddr *) &ae[1],
157  ae->addrlen);
158  GNUNET_free (ae);
159  }
161  nh->reconnect_task =
163 }
164 
165 
173 static int
175  void *cls,
177 {
178  if (ntohs (crm->header.size) != sizeof(*crm) + sizeof(struct sockaddr_in))
179  {
180  GNUNET_break (0);
181  return GNUNET_SYSERR;
182  }
183  return GNUNET_OK;
184 }
185 
186 
193 static void
195  void *cls,
197 {
198  struct GNUNET_NAT_Handle *nh = cls;
199 
201  (const struct sockaddr *) &crm[1],
202  sizeof(struct sockaddr_in));
203 }
204 
205 
213 static int
215  void *cls,
217 {
218  size_t alen = ntohs (acn->header.size) - sizeof(*acn);
219 
220  switch (alen)
221  {
222  case sizeof(struct sockaddr_in): {
223  const struct sockaddr_in *s4 = (const struct sockaddr_in *) &acn[1];
224  if (AF_INET != s4->sin_family)
225  {
226  GNUNET_break (0);
227  return GNUNET_SYSERR;
228  }
229  }
230  break;
231 
232  case sizeof(struct sockaddr_in6): {
233  const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) &acn[1];
234  if (AF_INET6 != s6->sin6_family)
235  {
236  GNUNET_break (0);
237  return GNUNET_SYSERR;
238  }
239  }
240  break;
241 
242  default:
243  GNUNET_break (0);
244  return GNUNET_SYSERR;
245  }
246  return GNUNET_OK;
247 }
248 
249 
256 static void
258  void *cls,
260 {
261  struct GNUNET_NAT_Handle *nh = cls;
262  size_t alen = ntohs (acn->header.size) - sizeof(*acn);
263  const struct sockaddr *sa = (const struct sockaddr *) &acn[1];
265  struct AddrEntry *ae;
266 
268  "Received address change notification\n");
269  ac = (enum GNUNET_NAT_AddressClass) ntohl (acn->addr_class);
270  if (GNUNET_YES == ntohl (acn->add_remove))
271  {
272  ae = GNUNET_malloc (sizeof(*ae) + alen);
273  ae->ac = ac;
274  ae->addrlen = alen;
275  GNUNET_memcpy (&ae[1], sa, alen);
278  &ae->app_ctx,
279  ntohl (acn->add_remove),
280  ac,
281  sa,
282  alen);
283  }
284  else
285  {
286  for (ae = nh->ae_head; NULL != ae; ae = ae->next)
287  if ((ae->addrlen == alen) && (0 == memcmp (&ae[1], sa, alen)))
288  break;
289  if (NULL == ae)
290  {
291  GNUNET_break (0);
292  reconnect (nh);
293  return;
294  }
297  &ae->app_ctx,
298  ntohl (acn->add_remove),
299  ac,
300  sa,
301  alen);
302  GNUNET_free (ae);
303  }
304 }
305 
306 
313 static void
314 mq_error_handler (void *cls,
315  enum GNUNET_MQ_Error error)
316 {
317  struct GNUNET_NAT_Handle *nh = cls;
318 
319  reconnect (nh);
320 }
321 
322 
328 static void
329 do_connect (void *cls)
330 {
331  struct GNUNET_NAT_Handle *nh = cls;
334  connection_reversal_request,
337  nh),
339  address_change_notification,
342  nh),
344  };
345  struct GNUNET_MQ_Envelope *env;
346 
347  nh->reconnect_task = NULL;
348  nh->mq =
350  "nat",
351  handlers,
353  nh);
354  if (NULL == nh->mq)
355  {
356  reconnect (nh);
357  return;
358  }
360  GNUNET_MQ_send (nh->mq,
361  env);
362 }
363 
364 
385 struct GNUNET_NAT_Handle *
387  const char *config_section,
388  uint8_t proto,
389  unsigned int num_addrs,
390  const struct sockaddr **addrs,
391  const socklen_t *addrlens,
394  void *callback_cls)
395 {
396  struct GNUNET_NAT_Handle *nh;
397  struct GNUNET_NAT_RegisterMessage *rm;
398  size_t len;
399  size_t str_len;
400  char *off;
401 
402  len = 0;
403  for (unsigned int i = 0; i < num_addrs; i++)
404  len += addrlens[i];
405  str_len = strlen (config_section) + 1;
406  len += str_len;
407  if ( (len > GNUNET_MAX_MESSAGE_SIZE - sizeof(*rm)) ||
408  (num_addrs > UINT16_MAX) ||
409  (str_len > UINT16_MAX) )
410  {
411  GNUNET_break (0);
412  return NULL;
413  }
414  rm = GNUNET_malloc (sizeof(*rm) + len);
415  rm->header.size = htons (sizeof(*rm) + len);
418  if (NULL != address_callback)
420  if (NULL != reversal_callback)
422  rm->proto = proto;
423  rm->str_len = htons (str_len);
424  rm->num_addrs = htons ((uint16_t) num_addrs);
425  off = (char *) &rm[1];
426  for (unsigned int i = 0; i < num_addrs; i++)
427  {
428  switch (addrs[i]->sa_family)
429  {
430  case AF_INET:
431  if (sizeof(struct sockaddr_in) != addrlens[i])
432  {
433  GNUNET_break (0);
434  GNUNET_free (rm);
435  return NULL;
436  }
437  break;
438 
439  case AF_INET6:
440  if (sizeof(struct sockaddr_in6) != addrlens[i])
441  {
442  GNUNET_break (0);
443  GNUNET_free (rm);
444  return NULL;
445  }
446  break;
447 
448 #if AF_UNIX
449  case AF_UNIX:
450  if (sizeof(struct sockaddr_un) != addrlens[i])
451  {
452  GNUNET_break (0);
453  GNUNET_free (rm);
454  return NULL;
455  }
456  break;
457 #endif
458  default:
459  GNUNET_break (0);
460  GNUNET_free (rm);
461  return NULL;
462  }
463  GNUNET_memcpy (off, addrs[i], addrlens[i]);
464  off += addrlens[i];
465  }
466  GNUNET_memcpy (off, config_section, str_len);
467 
468  nh = GNUNET_new (struct GNUNET_NAT_Handle);
469  nh->reg = &rm->header;
470  nh->cfg = cfg;
471  nh->address_callback = address_callback;
473  nh->callback_cls = callback_cls;
474  do_connect (nh);
475  return nh;
476 }
477 
478 
487 static enum GNUNET_GenericReturnValue
488 test_stun_packet (const void *data, size_t len)
489 {
490  const struct stun_header *hdr;
491  const struct stun_attr *attr;
492  uint32_t advertised_message_size;
493  uint32_t message_magic_cookie;
494 
495  /* On entry, 'len' is the length of the UDP payload. After the
496  * initial checks it becomes the size of unprocessed options,
497  * while 'data' is advanced accordingly.
498  */
499  if (len < sizeof(struct stun_header))
500  {
502  "STUN packet too short (only %d, wanting at least %d)\n",
503  (int) len,
504  (int) sizeof(struct stun_header));
505  return GNUNET_NO;
506  }
507  hdr = (const struct stun_header *) data;
508  /* Skip header as it is already in hdr */
509  len -= sizeof(struct stun_header);
510  data += sizeof(struct stun_header);
511 
512  /* len as advertised in the message */
513  advertised_message_size = ntohs (hdr->msglen);
514 
515  message_magic_cookie = ntohl (hdr->magic);
516  /* Compare if the cookie match */
517  if (STUN_MAGIC_COOKIE != message_magic_cookie)
518  {
519  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Invalid magic cookie for STUN\n");
520  return GNUNET_NO;
521  }
522 
523  if (advertised_message_size > len)
524  {
526  "Scrambled STUN packet length (got %d, expecting %d)\n",
527  advertised_message_size,
528  (int) len);
529  return GNUNET_NO;
530  }
531  len = advertised_message_size;
532  while (len > 0)
533  {
534  if (len < sizeof(struct stun_attr))
535  {
537  "Attribute too short in STUN packet (got %d, expecting %d)\n",
538  (int) len,
539  (int) sizeof(struct stun_attr));
540  return GNUNET_NO;
541  }
542  attr = (const struct stun_attr *) data;
543 
544  /* compute total attribute length */
545  advertised_message_size = ntohs (attr->len) + sizeof(struct stun_attr);
546 
547  /* Check if we still have space in our buffer */
548  if (advertised_message_size > len)
549  {
550  GNUNET_log (
552  "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n",
553  advertised_message_size,
554  (int) len);
555  return GNUNET_NO;
556  }
557  data += advertised_message_size;
558  len -= advertised_message_size;
559  }
561  "STUN Packet, msg %04x, length: %d\n",
562  ntohs (hdr->msgtype),
563  advertised_message_size);
564  return GNUNET_OK;
565 }
566 
567 
591 int
593  const struct sockaddr *sender_addr,
594  size_t sender_addr_len,
595  const void *data,
596  size_t data_size)
597 {
598  struct GNUNET_MQ_Envelope *env;
599  struct GNUNET_NAT_HandleStunMessage *hsn;
600  char *buf;
601 
603  return GNUNET_NO;
604  if (NULL == nh->mq)
605  return GNUNET_SYSERR;
606  env = GNUNET_MQ_msg_extra (hsn,
607  data_size + sender_addr_len,
609  hsn->sender_addr_size = htons ((uint16_t) sender_addr_len);
610  hsn->payload_size = htons ((uint16_t) data_size);
611  buf = (char *) &hsn[1];
612  GNUNET_memcpy (buf, sender_addr, sender_addr_len);
613  buf += sender_addr_len;
615  GNUNET_MQ_send (nh->mq, env);
616  return GNUNET_OK;
617 }
618 
619 
633 int
635  const void *addr,
636  socklen_t addrlen)
637 {
638  struct AddrEntry *ae;
639 
640  if ((addrlen != sizeof(struct sockaddr_in)) &&
641  (addrlen != sizeof(struct sockaddr_in6)))
642  {
643  GNUNET_break (0);
644  return GNUNET_SYSERR;
645  }
646  for (ae = nh->ae_head; NULL != ae; ae = ae->next)
647  if ((addrlen == ae->addrlen) && (0 == memcmp (addr, &ae[1], addrlen)))
648  return GNUNET_YES;
649  return GNUNET_NO;
650 }
651 
652 
665 int
667  const struct sockaddr_in *local_sa,
668  const struct sockaddr_in *remote_sa)
669 {
670  struct GNUNET_MQ_Envelope *env;
672  char *buf;
673 
674  if (NULL == nh->mq)
675  return GNUNET_SYSERR;
676  GNUNET_break (AF_INET == local_sa->sin_family);
677  GNUNET_break (AF_INET == remote_sa->sin_family);
678  env =
679  GNUNET_MQ_msg_extra (req,
680  2 * sizeof(struct sockaddr_in),
682  req->local_addr_size = htons (sizeof(struct sockaddr_in));
683  req->remote_addr_size = htons (sizeof(struct sockaddr_in));
684  buf = (char *) &req[1];
685  GNUNET_memcpy (buf, local_sa, sizeof(struct sockaddr_in));
686  buf += sizeof(struct sockaddr_in);
687  GNUNET_memcpy (buf, remote_sa, sizeof(struct sockaddr_in));
688  GNUNET_MQ_send (nh->mq, env);
689  return GNUNET_OK;
690 }
691 
692 
700 void
702 {
703  if (NULL != nh->mq)
704  {
706  nh->mq = NULL;
707  }
708  if (NULL != nh->reconnect_task)
709  {
711  nh->reconnect_task = NULL;
712  }
713  GNUNET_free (nh->reg);
714  GNUNET_free (nh);
715 }
716 
717 
718 /* end of nat_api.c */
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
uint32_t data
The data value.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static struct GNUNET_NAT_Handle * nh
Handle to NAT operation.
Definition: gnunet-nat.c:80
static uint8_t proto
Protocol to use.
Definition: gnunet-nat.c:60
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
static void reversal_callback(void *cls, const struct sockaddr_in *ra)
We got a connection reversal request from another peer.
static char buf[2048]
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1055
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:96
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_MQ_Error
Error codes for the queue.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:56
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:535
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685
int GNUNET_NAT_request_reversal(struct GNUNET_NAT_Handle *nh, const struct sockaddr_in *local_sa, const struct sockaddr_in *remote_sa)
We learned about a peer (possibly behind NAT) so run the gnunet-nat-client to send dummy ICMP respons...
Definition: nat_api.c:666
void(* GNUNET_NAT_ReversalCallback)(void *cls, const struct sockaddr *remote_addr, socklen_t remote_addrlen)
Signature of the callback passed to GNUNET_NAT_register().
void GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh)
Stop port redirection and public IP address detection for the given handle.
Definition: nat_api.c:701
void(* GNUNET_NAT_AddressCallback)(void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of ...
int GNUNET_NAT_stun_handle_packet(struct GNUNET_NAT_Handle *nh, const struct sockaddr *sender_addr, size_t sender_addr_len, const void *data, size_t data_size)
Handle an incoming STUN message.
Definition: nat_api.c:592
GNUNET_NAT_AddressClass
Some addresses contain sensitive information or are not suitable for global distribution.
struct GNUNET_NAT_Handle * GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, 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)
Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on...
Definition: nat_api.c:386
int GNUNET_NAT_test_address(struct GNUNET_NAT_Handle *nh, const void *addr, socklen_t addrlen)
Test if the given address is (currently) a plausible IP address for this peer.
Definition: nat_api.c:634
#define GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE
Message to from NAT service notifying us that one of our addresses changed.
#define GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED
Message to from NAT service notifying us that connection reversal was requested by another peer.
#define GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL
Message to ask NAT service to request connection reversal.
#define GNUNET_MESSAGE_TYPE_NAT_REGISTER
Message to ask NAT service to register a client.
#define GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN
Message to ask NAT service to handle a STUN packet.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Messages for interaction with gnunet-nat-server and gnunet-nat-service.
@ GNUNET_NAT_RF_ADDRESSES
This client wants to be informed about changes to our applicable addresses.
Definition: nat.h:82
@ GNUNET_NAT_RF_NONE
This client does not want any notifications.
Definition: nat.h:76
@ GNUNET_NAT_RF_REVERSAL
This client supports address reversal.
Definition: nat.h:87
static int check_connection_reversal_request(void *cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm)
Check connection reversal request.
Definition: nat_api.c:174
static enum GNUNET_GenericReturnValue test_stun_packet(const void *data, size_t len)
Check if an incoming message is a STUN message.
Definition: nat_api.c:488
static void handle_address_change_notification(void *cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *acn)
Handle connection reversal request.
Definition: nat_api.c:257
static void do_connect(void *cls)
Task to connect to the NAT service.
Definition: nat_api.c:329
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Handle queue errors by reconnecting to NAT.
Definition: nat_api.c:314
static void reconnect(struct GNUNET_NAT_Handle *nh)
Task to connect to the NAT service.
Definition: nat_api.c:140
static int check_address_change_notification(void *cls, const struct GNUNET_NAT_AddressChangeNotificationMessage *acn)
Check address change notification.
Definition: nat_api.c:214
static void handle_connection_reversal_request(void *cls, const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm)
Handle connection reversal request.
Definition: nat_api.c:194
Message types for STUN server resolution.
#define STUN_MAGIC_COOKIE
Definition: nat_stun.h:34
Entry in DLL of addresses of this peer.
Definition: nat_api.c:39
struct AddrEntry * next
DLL.
Definition: nat_api.c:43
struct AddrEntry * prev
DLL.
Definition: nat_api.c:48
enum GNUNET_NAT_AddressClass ac
Address class of the address.
Definition: nat_api.c:59
void * app_ctx
Place where the application can store data (on add, and retrieve on remove).
Definition: nat_api.c:54
socklen_t addrlen
Number of bytes that follow.
Definition: nat_api.c:64
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Service notifying the client about changes in the set of addresses it has.
Definition: nat.h:202
int32_t add_remove
GNUNET_YES to add, GNUNET_NO to remove the address from the list.
Definition: nat.h:211
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE.
Definition: nat.h:206
uint32_t addr_class
Type of the address, an enum GNUNET_NAT_AddressClass in NBO.
Definition: nat.h:216
Service telling a client that connection reversal was requested.
Definition: nat.h:187
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED.
Definition: nat.h:191
Client telling the service to (possibly) handle a STUN message.
Definition: nat.h:135
uint16_t payload_size
Number of bytes of payload included, in NBO.
Definition: nat.h:149
uint16_t sender_addr_size
Size of the sender address included, in NBO.
Definition: nat.h:144
Handle for active NAT registrations.
Definition: nat_api.c:72
struct GNUNET_TIME_Relative reconnect_delay
How long to wait until we reconnect.
Definition: nat_api.c:121
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we use.
Definition: nat_api.c:76
void * callback_cls
Closure for the various callbacks.
Definition: nat_api.c:111
struct AddrEntry * ae_head
Head of address DLL.
Definition: nat_api.c:91
struct GNUNET_MQ_Handle * mq
Message queue for communicating with the NAT service.
Definition: nat_api.c:81
struct GNUNET_SCHEDULER_Task * reconnect_task
Task scheduled to reconnect to the service.
Definition: nat_api.c:116
struct GNUNET_MessageHeader * reg
Our registration message.
Definition: nat_api.c:86
struct AddrEntry * ae_tail
Tail of address DLL.
Definition: nat_api.c:96
GNUNET_NAT_ReversalCallback reversal_callback
Function to call when another peer requests connection reversal.
Definition: nat_api.c:106
GNUNET_NAT_AddressCallback address_callback
Function to call when our addresses change.
Definition: nat_api.c:101
Message sent by a client to register with its addresses.
Definition: nat.h:95
uint16_t num_addrs
Number of addresses that this service is bound to that follow.
Definition: nat.h:122
uint16_t str_len
Number of bytes in the string that follow which specifies a section name in the configuration.
Definition: nat.h:115
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_NAT_REGISTER.
Definition: nat.h:99
uint8_t flags
An enum GNUNET_NAT_RegisterFlags.
Definition: nat.h:104
uint8_t proto
Client's IPPROTO, e.g.
Definition: nat.h:109
Client asking the service to initiate connection reversal.
Definition: nat.h:161
uint16_t local_addr_size
Size of the local address included, in NBO.
Definition: nat.h:170
uint16_t remote_addr_size
Size of the remote address included, in NBO.
Definition: nat.h:175
Entry in list of pending tasks.
Definition: scheduler.c:135
Time for relative time used by GNUnet, in microseconds.
uint16_t attr
Definition: nat_stun.h:53
uint16_t msglen
Definition: nat_stun.h:45
uint16_t msgtype
Definition: nat_stun.h:44
uint32_t magic
Definition: nat_stun.h:46