GNUnet 0.22.1
gnunet-service-nat_mini.c File Reference

functions for interaction with miniupnp; tested with miniupnpc 1.5 More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet-service-nat_mini.h"
#include "nat.h"
Include dependency graph for gnunet-service-nat_mini.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_NAT_ExternalHandle
 Opaque handle to cancel "GNUNET_NAT_mini_get_external_ipv4" operation. More...
 
struct  GNUNET_NAT_MiniHandle
 Handle to a mapping created with upnpc. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "nat", __VA_ARGS__)
 
#define MAP_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
 How long do we give upnpc to create a mapping? More...
 
#define UNMAP_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 How long do we give upnpc to remove a mapping? More...
 
#define MAP_REFRESH_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 How often do we check for changes in the mapping? More...
 

Functions

static void read_external_ipv4 (void *cls)
 Read the output of external-ip into buf. More...
 
static void signal_external_ip_error (void *cls)
 (Asynchronously) signal error invoking external-ip to client. More...
 
struct GNUNET_NAT_ExternalHandleGNUNET_NAT_mini_get_external_ipv4_ (GNUNET_NAT_IPCallback cb, void *cb_cls)
 Try to get the external IPv4 address of this peer. More...
 
void GNUNET_NAT_mini_get_external_ipv4_cancel_ (struct GNUNET_NAT_ExternalHandle *eh)
 Cancel operation. More...
 
static void do_refresh (void *cls)
 Run "upnpc -l" to find out if our mapping changed. More...
 
static void process_map_output (void *cls, const char *line)
 Process the output from the "upnpc -r" command. More...
 
static void run_upnpc_r (struct GNUNET_NAT_MiniHandle *mini)
 Run "upnpc -r" to map our internal port. More...
 
static void process_refresh_output (void *cls, const char *line)
 Process the output from "upnpc -l" to see if our external mapping changed. More...
 
struct GNUNET_NAT_MiniHandleGNUNET_NAT_mini_map_start (uint16_t port, int is_tcp, GNUNET_NAT_MiniAddressCallback ac, void *ac_cls)
 Start mapping the given port using (mini)upnpc. More...
 
static void process_unmap_output (void *cls, const char *line)
 Process output from our 'unmap' command. More...
 
void GNUNET_NAT_mini_map_stop (struct GNUNET_NAT_MiniHandle *mini)
 Remove a mapping created with (mini)upnpc. More...
 

Detailed Description

functions for interaction with miniupnp; tested with miniupnpc 1.5

Author
Christian Grothoff

Definition in file gnunet-service-nat_mini.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "nat", __VA_ARGS__)

Definition at line 32 of file gnunet-service-nat_mini.c.

◆ MAP_TIMEOUT

How long do we give upnpc to create a mapping?

Definition at line 37 of file gnunet-service-nat_mini.c.

◆ UNMAP_TIMEOUT

#define UNMAP_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

How long do we give upnpc to remove a mapping?

Definition at line 42 of file gnunet-service-nat_mini.c.

◆ MAP_REFRESH_FREQ

#define MAP_REFRESH_FREQ    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)

How often do we check for changes in the mapping?

Definition at line 48 of file gnunet-service-nat_mini.c.

Function Documentation

◆ read_external_ipv4()

static void read_external_ipv4 ( void *  cls)
static

Read the output of external-ip into buf.

When complete, parse the address and call our callback.

Parameters
clsthe struct GNUNET_NAT_ExternalHandle

Definition at line 113 of file gnunet-service-nat_mini.c.

114{
115 struct GNUNET_NAT_ExternalHandle *eh = cls;
116 ssize_t ret;
117 struct in_addr addr;
118
119 eh->task = NULL;
121 &eh->buf[eh->off],
122 sizeof(eh->buf) - eh->off);
123 if (ret > 0)
124 {
125 /* try to read more */
126 eh->off += ret;
128 eh->r,
130 eh);
131 return;
132 }
134 if ((eh->off > 7) && (eh->buf[eh->off - 1] == '\n'))
135 {
136 eh->buf[eh->off - 1] = '\0';
137 if (1 == inet_pton (AF_INET, eh->buf, &addr))
138 {
139 if (0 == addr.s_addr)
140 eh->ret =
142 else
144 }
145 }
146 eh->cb (eh->cb_cls,
147 (GNUNET_NAT_ERROR_SUCCESS == eh->ret) ? &addr : NULL,
148 eh->ret);
150}
static int ret
Final status code.
Definition: gnunet-arm.c:93
void GNUNET_NAT_mini_get_external_ipv4_cancel_(struct GNUNET_NAT_ExternalHandle *eh)
Cancel operation.
static void read_external_ipv4(void *cls)
Read the output of external-ip into buf.
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:623
@ GNUNET_NAT_ERROR_SUCCESS
Just the default.
@ GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID
‘external-ip’ command output invalid
@ GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID
"no valid address was returned by `external-ip'"
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1660
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Opaque handle to cancel "GNUNET_NAT_mini_get_external_ipv4" operation.
size_t off
Number of bytes in buf that are valid.
GNUNET_NAT_IPCallback cb
Function to call with the result.
const struct GNUNET_DISK_FileHandle * r
Read handle of opipe.
enum GNUNET_NAT_StatusCode ret
Error code for better debugging and user feedback.
char buf[17]
Destination of our read operation (output of 'external-ip').
struct GNUNET_SCHEDULER_Task * task
Read task.

References GNUNET_NAT_ExternalHandle::buf, GNUNET_NAT_ExternalHandle::cb, GNUNET_NAT_ExternalHandle::cb_cls, GNUNET_DISK_file_read(), GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_NAT_ExternalHandle::off, GNUNET_NAT_ExternalHandle::r, read_external_ipv4(), ret, GNUNET_NAT_ExternalHandle::ret, and GNUNET_NAT_ExternalHandle::task.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), and read_external_ipv4().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ signal_external_ip_error()

static void signal_external_ip_error ( void *  cls)
static

(Asynchronously) signal error invoking external-ip to client.

Parameters
clsthe struct GNUNET_NAT_ExternalHandle (freed)

Definition at line 159 of file gnunet-service-nat_mini.c.

160{
161 struct GNUNET_NAT_ExternalHandle *eh = cls;
162
163 eh->task = NULL;
164 eh->cb (eh->cb_cls, NULL, eh->ret);
165 GNUNET_free (eh);
166}
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_NAT_ExternalHandle::cb, GNUNET_NAT_ExternalHandle::cb_cls, GNUNET_free, GNUNET_NAT_ExternalHandle::ret, and GNUNET_NAT_ExternalHandle::task.

Referenced by GNUNET_NAT_mini_get_external_ipv4_().

Here is the caller graph for this function:

◆ GNUNET_NAT_mini_get_external_ipv4_()

struct GNUNET_NAT_ExternalHandle * GNUNET_NAT_mini_get_external_ipv4_ ( GNUNET_NAT_IPCallback  cb,
void *  cb_cls 
)

Try to get the external IPv4 address of this peer.

Parameters
cbfunction to call with result
cb_clsclosure for cb
Returns
handle for cancellation (can only be used until cb is called), never NULL

Definition at line 177 of file gnunet-service-nat_mini.c.

178{
179 struct GNUNET_NAT_ExternalHandle *eh;
180
182 eh->cb = cb;
183 eh->cb_cls = cb_cls;
185 if (GNUNET_SYSERR ==
186 GNUNET_OS_check_helper_binary ("external-ip", GNUNET_NO, NULL))
187 {
188 LOG (GNUNET_ERROR_TYPE_INFO, _ ("`external-ip' command not found\n"));
191 return eh;
192 }
194 "Running `external-ip' to determine our external IP\n");
196 if (NULL == eh->opipe)
197 {
200 return eh;
201 }
203 NULL,
204 eh->opipe,
205 NULL,
206 "external-ip",
207 "external-ip",
208 NULL);
209 if (NULL == eh->eip)
210 {
214 return eh;
215 }
219 eh->r,
221 eh);
222 return eh;
223}
static void signal_external_ip_error(void *cls)
(Asynchronously) signal error invoking external-ip to client.
#define LOG(kind,...)
const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
Get the handle to a particular pipe end.
Definition: disk.c:1618
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1445
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1588
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Closes one half of an interprocess channel.
Definition: disk.c:1535
@ GNUNET_DISK_PF_BLOCKING_RW
Configure both pipe ends for blocking operations if set.
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.
@ GNUNET_NO
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
@ GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED
Failed to run external-ip command.
@ GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND
‘external-ip’ command not found
@ GNUNET_NAT_ERROR_IPC_FAILURE
IPC Failure.
struct GNUNET_OS_Process * GNUNET_OS_start_process(enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename,...)
Start a process.
Definition: os_priority.c:627
enum GNUNET_GenericReturnValue GNUNET_OS_check_helper_binary(const char *binary, bool check_suid, const char *params)
Check whether an executable exists and possibly if the suid bit is set on the file.
@ GNUNET_OS_INHERIT_STD_NONE
No standard streams should be inherited.
Definition: gnunet_os_lib.h:77
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1303
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
struct GNUNET_OS_Process * eip
Handle to external-ip process.
struct GNUNET_DISK_PipeHandle * opipe
Handle to stdout pipe of external-ip.

References _, GNUNET_NAT_ExternalHandle::cb, GNUNET_NAT_ExternalHandle::cb_cls, GNUNET_NAT_ExternalHandle::eip, GNUNET_DISK_PF_BLOCKING_RW, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_close_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED, GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND, GNUNET_NAT_ERROR_IPC_FAILURE, GNUNET_NAT_ERROR_SUCCESS, GNUNET_new, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_start_process(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, LOG, GNUNET_NAT_ExternalHandle::opipe, GNUNET_NAT_ExternalHandle::r, read_external_ipv4(), GNUNET_NAT_ExternalHandle::ret, signal_external_ip_error(), and GNUNET_NAT_ExternalHandle::task.

Referenced by run_external_ip().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_NAT_mini_get_external_ipv4_cancel_()

void GNUNET_NAT_mini_get_external_ipv4_cancel_ ( struct GNUNET_NAT_ExternalHandle eh)

Cancel operation.

Parameters
ehoperation to cancel

Definition at line 232 of file gnunet-service-nat_mini.c.

233{
234 if (NULL != eh->eip)
235 {
236 (void) GNUNET_OS_process_kill (eh->eip, SIGKILL);
239 }
240 if (NULL != eh->opipe)
241 {
243 eh->opipe = NULL;
244 }
245 if (NULL != eh->task)
246 {
248 eh->task = NULL;
249 }
250 GNUNET_free (eh);
251}
@ GNUNET_OK
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:260
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:210
enum GNUNET_GenericReturnValue GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:878
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979

References GNUNET_NAT_ExternalHandle::eip, GNUNET_break, GNUNET_DISK_pipe_close(), GNUNET_free, GNUNET_OK, GNUNET_OS_process_destroy(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_SCHEDULER_cancel(), GNUNET_NAT_ExternalHandle::opipe, and GNUNET_NAT_ExternalHandle::task.

Referenced by GN_nat_status_changed(), read_external_ipv4(), and run_external_ip().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_refresh()

static void do_refresh ( void *  cls)
static

Run "upnpc -l" to find out if our mapping changed.

Parameters
clsthe struct GNUNET_NAT_MiniHandle

Definition at line 475 of file gnunet-service-nat_mini.c.

476{
477 struct GNUNET_NAT_MiniHandle *mini = cls;
478 int ac;
479
480 mini->refresh_task =
483 "Running `upnpc' to check if our mapping still exists\n");
484 mini->found = GNUNET_NO;
485 ac = GNUNET_NO;
486 if (NULL != mini->map_cmd)
487 {
488 /* took way too long, abort it! */
490 mini->map_cmd = NULL;
491 ac = GNUNET_YES;
492 }
493 if (NULL != mini->refresh_cmd)
494 {
495 /* took way too long, abort it! */
497 mini->refresh_cmd = NULL;
498 ac = GNUNET_YES;
499 }
501 mini,
503 "upnpc",
504 "upnpc",
505 "-l",
506 NULL);
507 if (GNUNET_YES == ac)
508 mini->ac (mini->ac_cls,
510 NULL,
511 0,
513}
#define MAP_TIMEOUT
How long do we give upnpc to create a mapping?
#define MAP_REFRESH_FREQ
How often do we check for changes in the mapping?
static void process_refresh_output(void *cls, const char *line)
Process the output from "upnpc -l" to see if our external mapping changed.
static void do_refresh(void *cls)
Run "upnpc -l" to find out if our mapping changed.
@ GNUNET_YES
@ GNUNET_NAT_ERROR_UPNPC_TIMEOUT
‘upnpc’ command took too long, process killed
void GNUNET_OS_command_stop(struct GNUNET_OS_CommandHandle *cmd)
Stop/kill a command.
Definition: os_priority.c:948
struct GNUNET_OS_CommandHandle * GNUNET_OS_command_run(GNUNET_OS_LineProcessor proc, void *proc_cls, struct GNUNET_TIME_Relative timeout, const char *binary,...)
Run the given command line and call the given function for each line of the output.
Definition: os_priority.c:1022
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:1276
Handle to a mapping created with upnpc.
struct GNUNET_OS_CommandHandle * map_cmd
Command used to install the map.
struct GNUNET_OS_CommandHandle * refresh_cmd
Command used to refresh our map information.
void * ac_cls
Closure for ac.
GNUNET_NAT_MiniAddressCallback ac
Function to call on mapping changes.
struct GNUNET_SCHEDULER_Task * refresh_task
We check the mapping periodically to see if it still works.
int found
Did we find our mapping during refresh scan?

References GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, do_refresh(), GNUNET_NAT_MiniHandle::found, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NAT_ERROR_UPNPC_TIMEOUT, GNUNET_NO, GNUNET_OS_command_run(), GNUNET_OS_command_stop(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_YES, LOG, GNUNET_NAT_MiniHandle::map_cmd, MAP_REFRESH_FREQ, MAP_TIMEOUT, process_refresh_output(), GNUNET_NAT_MiniHandle::refresh_cmd, and GNUNET_NAT_MiniHandle::refresh_task.

Referenced by do_refresh(), GNUNET_NAT_mini_map_start(), and process_map_output().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_map_output()

static void process_map_output ( void *  cls,
const char *  line 
)
static

Process the output from the "upnpc -r" command.

Process the output from the 'upnpc -r' command.

Parameters
clsthe struct GNUNET_NAT_MiniHandle
lineline of output, NULL at the end

Definition at line 523 of file gnunet-service-nat_mini.c.

524{
525 struct GNUNET_NAT_MiniHandle *mini = cls;
526 const char *ipaddr;
527 char *ipa;
528 const char *pstr;
529 unsigned int port;
530
531 if (NULL == line)
532 {
534 mini->map_cmd = NULL;
535 if (GNUNET_YES != mini->did_map)
536 mini->ac (mini->ac_cls,
538 NULL,
539 0,
541 if (NULL == mini->refresh_task)
542 mini->refresh_task =
544 return;
545 }
546 /*
547 * The upnpc output we're after looks like this:
548 *
549 * "external 87.123.42.204:3000 TCP is redirected to internal 192.168.2.150:3000"
550 */if ((NULL == (ipaddr = strstr (line, " "))) ||
551 (NULL == (pstr = strstr (ipaddr, ":"))) ||
552 (1 != sscanf (pstr + 1, "%u", &port)))
553 {
554 return; /* skip line */
555 }
556 ipa = GNUNET_strdup (ipaddr + 1);
557 strstr (ipa, ":")[0] = '\0';
558 if (1 != inet_pton (AF_INET, ipa, &mini->current_addr.sin_addr))
559 {
560 GNUNET_free (ipa);
561 return; /* skip line */
562 }
563 GNUNET_free (ipa);
564
565 mini->current_addr.sin_port = htons (port);
566 mini->current_addr.sin_family = AF_INET;
567#if HAVE_SOCKADDR_IN_SIN_LEN
568 mini->current_addr.sin_len = sizeof(struct sockaddr_in);
569#endif
570 mini->did_map = GNUNET_YES;
571 mini->ac (mini->ac_cls,
573 (const struct sockaddr *) &mini->current_addr,
574 sizeof(mini->current_addr),
576}
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static char * line
Desired phone line (string to be converted to a hash).
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
@ GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED
‘upnpc’ command failed to establish port mapping
int did_map
Did we succeed with creating a mapping?
struct sockaddr_in current_addr
Our current external mapping (if we have one).

References GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, GNUNET_NAT_MiniHandle::current_addr, GNUNET_NAT_MiniHandle::did_map, do_refresh(), GNUNET_free, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED, GNUNET_OS_command_stop(), GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, line, GNUNET_NAT_MiniHandle::map_cmd, MAP_REFRESH_FREQ, port, and GNUNET_NAT_MiniHandle::refresh_task.

Referenced by run_upnpc_r().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run_upnpc_r()

static void run_upnpc_r ( struct GNUNET_NAT_MiniHandle mini)
static

Run "upnpc -r" to map our internal port.

Parameters
miniour handle

Definition at line 345 of file gnunet-service-nat_mini.c.

346{
347 char pstr[6];
348
349 GNUNET_snprintf (pstr, sizeof(pstr), "%u", (unsigned int) mini->port);
351 mini,
353 "upnpc",
354 "upnpc",
355 "-r",
356 pstr,
357 mini->is_tcp ? "tcp" : "udp",
358 NULL);
359 if (NULL == mini->map_cmd)
360 {
361 mini->ac (mini->ac_cls,
363 NULL,
364 0,
366 return;
367 }
368}
static void process_map_output(void *cls, const char *line)
Process the output from the "upnpc -r" command.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
@ GNUNET_NAT_ERROR_UPNPC_FAILED
Failed to run upnpc command.
uint16_t port
Which port are we mapping?
int is_tcp
Are we mapping TCP or UDP?

References GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, GNUNET_NAT_ERROR_UPNPC_FAILED, GNUNET_OS_command_run(), GNUNET_snprintf(), GNUNET_SYSERR, GNUNET_NAT_MiniHandle::is_tcp, GNUNET_NAT_MiniHandle::map_cmd, MAP_TIMEOUT, GNUNET_NAT_MiniHandle::port, and process_map_output().

Referenced by GNUNET_NAT_mini_map_start(), and process_refresh_output().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_refresh_output()

static void process_refresh_output ( void *  cls,
const char *  line 
)
static

Process the output from "upnpc -l" to see if our external mapping changed.

If so, do the notifications.

Parameters
clsthe struct GNUNET_NAT_MiniHandle
lineline of output, NULL at the end

Definition at line 379 of file gnunet-service-nat_mini.c.

380{
381 struct GNUNET_NAT_MiniHandle *mini = cls;
382 char pstr[9];
383 const char *s;
384 unsigned int nport;
385 struct in_addr exip;
386
387 if (NULL == line)
388 {
390 mini->refresh_cmd = NULL;
391 if (GNUNET_NO == mini->found)
392 {
393 /* mapping disappeared, try to re-create */
394 if (GNUNET_YES == mini->did_map)
395 {
396 mini->ac (mini->ac_cls,
397 GNUNET_NO,
398 (const struct sockaddr *) &mini->current_addr,
399 sizeof(mini->current_addr),
401 mini->did_map = GNUNET_NO;
402 }
403 run_upnpc_r (mini);
404 }
405 return;
406 }
407 if (! mini->did_map)
408 return; /* never mapped, won't find our mapping anyway */
409
410 /* we're looking for output of the form:
411 * "ExternalIPAddress = 12.134.41.124" */
412
413 s = strstr (line, "ExternalIPAddress = ");
414 if (NULL != s)
415 {
416 s += strlen ("ExternalIPAddress = ");
417 if (1 != inet_pton (AF_INET, s, &exip))
418 return; /* skip */
419 if (exip.s_addr == mini->current_addr.sin_addr.s_addr)
420 return; /* no change */
421 /* update mapping */
422 mini->ac (mini->ac_cls,
423 GNUNET_NO,
424 (const struct sockaddr *) &mini->current_addr,
425 sizeof(mini->current_addr),
427 mini->current_addr.sin_addr = exip;
428 mini->ac (mini->ac_cls,
430 (const struct sockaddr *) &mini->current_addr,
431 sizeof(mini->current_addr),
433 return;
434 }
435 /*
436 * we're looking for output of the form:
437 *
438 * "0 TCP 3000->192.168.2.150:3000 'libminiupnpc' ''"
439 * "1 UDP 3001->192.168.2.150:3001 'libminiupnpc' ''"
440 *
441 * the pattern we look for is:
442 *
443 * "%s TCP PORT->STRING:OURPORT *" or
444 * "%s UDP PORT->STRING:OURPORT *"
445 */GNUNET_snprintf (pstr, sizeof(pstr), ":%u ", mini->port);
446 if (NULL == (s = strstr (line, "->")))
447 return; /* skip */
448 if (NULL == strstr (s, pstr))
449 return; /* skip */
450 if (1 != sscanf (line,
451 (mini->is_tcp) ? "%*u TCP %u->%*s:%*u %*s"
452 : "%*u UDP %u->%*s:%*u %*s",
453 &nport))
454 return; /* skip */
455 mini->found = GNUNET_YES;
456 if (nport == ntohs (mini->current_addr.sin_port))
457 return; /* no change */
458
459 /* external port changed, update mapping */
460 mini->ac (mini->ac_cls,
461 GNUNET_NO,
462 (const struct sockaddr *) &mini->current_addr,
463 sizeof(mini->current_addr),
465 mini->current_addr.sin_port = htons ((uint16_t) nport);
466 mini->ac (mini->ac_cls,
468 (const struct sockaddr *) &mini->current_addr,
469 sizeof(mini->current_addr),
471}
static void run_upnpc_r(struct GNUNET_NAT_MiniHandle *mini)
Run "upnpc -r" to map our internal port.

References GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, GNUNET_NAT_MiniHandle::current_addr, GNUNET_NAT_MiniHandle::did_map, GNUNET_NAT_MiniHandle::found, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NO, GNUNET_OS_command_stop(), GNUNET_snprintf(), GNUNET_YES, GNUNET_NAT_MiniHandle::is_tcp, line, GNUNET_NAT_MiniHandle::port, GNUNET_NAT_MiniHandle::refresh_cmd, and run_upnpc_r().

Referenced by do_refresh().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_NAT_mini_map_start()

struct GNUNET_NAT_MiniHandle * GNUNET_NAT_mini_map_start ( uint16_t  port,
int  is_tcp,
GNUNET_NAT_MiniAddressCallback  ac,
void *  ac_cls 
)

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.

Parameters
portport to map
is_tcpGNUNET_YES to map TCP, GNUNET_NO for UDP
acfunction to call with mapping result
ac_clsclosure for ac
Returns
NULL on error (no 'upnpc' installed)

Definition at line 593 of file gnunet-service-nat_mini.c.

597{
599
601 {
602 LOG (GNUNET_ERROR_TYPE_INFO, _ ("`upnpc' command not found\n"));
604 return NULL;
605 }
606 LOG (GNUNET_ERROR_TYPE_DEBUG, "Running `upnpc' to install mapping\n");
608 ret->ac = ac;
609 ret->ac_cls = ac_cls;
610 ret->is_tcp = is_tcp;
611 ret->port = port;
612 ret->refresh_task =
615 return ret;
616}
@ GNUNET_NAT_ERROR_UPNPC_NOT_FOUND
upnpc command not found

References _, GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, do_refresh(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_NAT_ERROR_UPNPC_NOT_FOUND, GNUNET_new, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_NAT_MiniHandle::is_tcp, LOG, MAP_REFRESH_FREQ, port, ret, and run_upnpc_r().

Referenced by handle_register().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_unmap_output()

static void process_unmap_output ( void *  cls,
const char *  line 
)
static

Process output from our 'unmap' command.

Parameters
clsthe struct GNUNET_NAT_MiniHandle
lineline of output, NULL at the end

Definition at line 626 of file gnunet-service-nat_mini.c.

627{
628 struct GNUNET_NAT_MiniHandle *mini = cls;
629
630 if (NULL == line)
631 {
632 LOG (GNUNET_ERROR_TYPE_DEBUG, "UPnP unmap done\n");
634 mini->unmap_cmd = NULL;
635 GNUNET_free (mini);
636 return;
637 }
638 /* we don't really care about the output... */
639}
struct GNUNET_OS_CommandHandle * unmap_cmd
Command used to remove the mapping.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_OS_command_stop(), line, LOG, and GNUNET_NAT_MiniHandle::unmap_cmd.

Referenced by GNUNET_NAT_mini_map_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_NAT_mini_map_stop()

void GNUNET_NAT_mini_map_stop ( struct GNUNET_NAT_MiniHandle mini)

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.

Parameters
minithe handle

Definition at line 643 of file gnunet-service-nat_mini.c.

644{
645 char pstr[6];
646
647 if (NULL != mini->refresh_task)
648 {
650 mini->refresh_task = NULL;
651 }
652 if (NULL != mini->refresh_cmd)
653 {
655 mini->refresh_cmd = NULL;
656 }
657 if (NULL != mini->map_cmd)
658 {
660 mini->map_cmd = NULL;
661 }
662 if (GNUNET_NO == mini->did_map)
663 {
664 GNUNET_free (mini);
665 return;
666 }
667 mini->ac (mini->ac_cls,
668 GNUNET_NO,
669 (const struct sockaddr *) &mini->current_addr,
670 sizeof(mini->current_addr),
672 /* Note: oddly enough, deletion uses the external port whereas
673 * addition uses the internal port; this rarely matters since they
674 * often are the same, but it might... */
675 GNUNET_snprintf (pstr,
676 sizeof(pstr),
677 "%u",
678 (unsigned int) ntohs (mini->current_addr.sin_port));
680 "Unmapping port %u with UPnP\n",
681 ntohs (mini->current_addr.sin_port));
683 mini,
685 "upnpc",
686 "upnpc",
687 "-d",
688 pstr,
689 mini->is_tcp ? "tcp" : "udp",
690 NULL);
691}
#define UNMAP_TIMEOUT
How long do we give upnpc to remove a mapping?
static void process_unmap_output(void *cls, const char *line)
Process output from our 'unmap' command.

References GNUNET_NAT_MiniHandle::ac, GNUNET_NAT_MiniHandle::ac_cls, GNUNET_NAT_MiniHandle::current_addr, GNUNET_NAT_MiniHandle::did_map, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NO, GNUNET_OS_command_run(), GNUNET_OS_command_stop(), GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_NAT_MiniHandle::is_tcp, LOG, GNUNET_NAT_MiniHandle::map_cmd, process_unmap_output(), GNUNET_NAT_MiniHandle::refresh_cmd, GNUNET_NAT_MiniHandle::refresh_task, GNUNET_NAT_MiniHandle::unmap_cmd, and UNMAP_TIMEOUT.

Referenced by client_disconnect_cb().

Here is the call graph for this function:
Here is the caller graph for this function: