mirror/transmission
1
0
Fork 0
mirror of https://github.com/transmission/transmission synced 2024-12-30 19:46:56 +00:00
Code Issues Releases Wiki Activity
transmission/libtransmission/upnp.c

315 lines
8.2 KiB
C
Raw Blame History

/*
* This file Copyright (C) Mnemosyne LLC
*
* This file is licensed by the GPL version 2. Works owned by the
* Transmission project are granted a special exemption to clause 2 (b)
* so that the bulk of its code can remain under the MIT license.
* This exemption does not extend to derived works not owned by
* the Transmission project.
*
* $Id$
*/
#include <assert.h>
#include <errno.h>
#ifdef SYSTEM_MINIUPNP
#include <miniupnpc/miniupnpc.h>
#include <miniupnpc/upnpcommands.h>
#else
#include <miniupnp/miniupnpc.h>
#include <miniupnp/upnpcommands.h>
#endif
#ifdef SYS_DARWIN
#define HAVE_MINIUPNP_16 1
#endif
#include "transmission.h"
#include "log.h"
#include "port-forwarding.h"
#include "session.h"
#include "upnp.h"
#include "utils.h"
static const char *
getKey (void) { return _("Port Forwarding (UPnP)"); }
typedef enum
{
TR_UPNP_IDLE,
TR_UPNP_ERR,
TR_UPNP_DISCOVER,
TR_UPNP_MAP,
TR_UPNP_UNMAP
}
tr_upnp_state;
struct tr_upnp
{
bool hasDiscovered;
struct UPNPUrls urls;
struct IGDdatas data;
int port;
char lanaddr[16];
unsigned int isMapped;
tr_upnp_state state;
};
/**
***
**/
tr_upnp*
tr_upnpInit (void)
{
tr_upnp * ret = tr_new0 (tr_upnp, 1);
ret->state = TR_UPNP_DISCOVER;
ret->port = -1;
return ret;
}
void
tr_upnpClose (tr_upnp * handle)
{
assert (!handle->isMapped);
assert ((handle->state == TR_UPNP_IDLE)
|| (handle->state == TR_UPNP_ERR)
|| (handle->state == TR_UPNP_DISCOVER));
if (handle->hasDiscovered)
FreeUPNPUrls (&handle->urls);
tr_free (handle);
}
/**
*** Wrappers for miniupnpc functions
**/
static struct UPNPDev *
tr_upnpDiscover (int msec)
{
struct UPNPDev * ret = NULL;
#if defined (HAVE_MINIUPNP_16)
int err = UPNPDISCOVER_SUCCESS;
ret = upnpDiscover (msec, NULL, NULL, 0, 0, &err);
if (err != UPNPDISCOVER_SUCCESS)
#elif defined (HAVE_MINIUPNP_15)
ret = upnpDiscover (msec, NULL, NULL, 0);
if (ret == NULL)
#endif
tr_logAddNamedDbg (getKey (), "upnpDiscover failed (errno %d - %s)", errno, tr_strerror (errno));
return ret;
}
static int
tr_upnpGetSpecificPortMappingEntry (tr_upnp * handle, const char * proto)
{
int err;
char intClient[16];
char intPort[16];
char portStr[16];
*intClient = '\0';
*intPort = '\0';
tr_snprintf (portStr, sizeof (portStr), "%d", (int)handle->port);
#if defined (HAVE_MINIUPNP_16)
err = UPNP_GetSpecificPortMappingEntry (handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort, NULL, NULL, NULL);
#elif defined (HAVE_MINIUPNP_15)
err = UPNP_GetSpecificPortMappingEntry (handle->urls.controlURL, handle->data.first.servicetype, portStr, proto, intClient, intPort);
#else
err = UPNPCOMMAND_UNKNOWN_ERROR;
#endif
return err;
}
static int
tr_upnpAddPortMapping (const tr_upnp * handle, const char * proto, tr_port port, const char * desc)
{
int err;
const int old_errno = errno;
char portStr[16];
errno = 0;
tr_snprintf (portStr, sizeof (portStr), "%d", (int)port);
#if defined (HAVE_MINIUPNP_16)
err = UPNP_AddPortMapping (handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL, NULL);
#elif defined (HAVE_MINIUPNP_15)
err = UPNP_AddPortMapping (handle->urls.controlURL, handle->data.first.servicetype, portStr, portStr, handle->lanaddr, desc, proto, NULL);
#else
err = UPNPCOMMAND_UNKNOWN_ERROR;
#endif
if (err)
tr_logAddNamedDbg (getKey (), "%s Port forwarding failed with error %d (errno %d - %s)", proto, err, errno, tr_strerror (errno));
errno = old_errno;
return err;
}
static void
tr_upnpDeletePortMapping (const tr_upnp * handle, const char * proto, tr_port port)
{
char portStr[16];
tr_snprintf (portStr, sizeof (portStr), "%d", (int)port);
UPNP_DeletePortMapping (handle->urls.controlURL,
handle->data.first.servicetype,
portStr, proto, NULL);
}
/**
***
**/
enum
{
UPNP_IGD_NONE = 0,
UPNP_IGD_VALID_CONNECTED = 1,
UPNP_IGD_VALID_NOT_CONNECTED = 2,
UPNP_IGD_INVALID = 3
};
int
tr_upnpPulse (tr_upnp * handle,
int port,
int isEnabled,
int doPortCheck)
{
int ret;
if (isEnabled && (handle->state == TR_UPNP_DISCOVER))
{
struct UPNPDev * devlist;
devlist = tr_upnpDiscover (2000);
errno = 0;
if (UPNP_GetValidIGD (devlist, &handle->urls, &handle->data,
handle->lanaddr, sizeof (handle->lanaddr)) == UPNP_IGD_VALID_CONNECTED)
{
tr_logAddNamedInfo (getKey (), _(
"Found Internet Gateway Device \"%s\""),
handle->urls.controlURL);
tr_logAddNamedInfo (getKey (), _(
"Local Address is \"%s\""), handle->lanaddr);
handle->state = TR_UPNP_IDLE;
handle->hasDiscovered = 1;
}
else
{
handle->state = TR_UPNP_ERR;
tr_logAddNamedDbg (
getKey (), "UPNP_GetValidIGD failed (errno %d - %s)",
errno,
tr_strerror (errno));
tr_logAddNamedDbg (
getKey (),
"If your router supports UPnP, please make sure UPnP is enabled!");
}
freeUPNPDevlist (devlist);
}
if (handle->state == TR_UPNP_IDLE)
{
if (handle->isMapped && (!isEnabled || (handle->port != port)))
handle->state = TR_UPNP_UNMAP;
}
if (isEnabled && handle->isMapped && doPortCheck)
{
if ((tr_upnpGetSpecificPortMappingEntry (handle, "TCP") != UPNPCOMMAND_SUCCESS) ||
(tr_upnpGetSpecificPortMappingEntry (handle, "UDP") != UPNPCOMMAND_SUCCESS))
{
tr_logAddNamedInfo (getKey (), _("Port %d isn't forwarded"), handle->port);
handle->isMapped = false;
}
}
if (handle->state == TR_UPNP_UNMAP)
{
tr_upnpDeletePortMapping (handle, "TCP", handle->port);
tr_upnpDeletePortMapping (handle, "UDP", handle->port);
tr_logAddNamedInfo (getKey (),
_("Stopping port forwarding through \"%s\", service \"%s\""),
handle->urls.controlURL, handle->data.first.servicetype);
handle->isMapped = 0;
handle->state = TR_UPNP_IDLE;
handle->port = -1;
}
if (handle->state == TR_UPNP_IDLE)
{
if (isEnabled && !handle->isMapped)
handle->state = TR_UPNP_MAP;
}
if (handle->state == TR_UPNP_MAP)
{
int err_tcp = -1;
int err_udp = -1;
errno = 0;
if (!handle->urls.controlURL || !handle->data.first.servicetype)
handle->isMapped = 0;
else
{
char desc[64];
tr_snprintf (desc, sizeof (desc), "%s at %d", TR_NAME, port);
err_tcp = tr_upnpAddPortMapping (handle, "TCP", port, desc);
err_udp = tr_upnpAddPortMapping (handle, "UDP", port, desc);
handle->isMapped = !err_tcp | !err_udp;
}
tr_logAddNamedInfo (getKey (),
_("Port forwarding through \"%s\", service \"%s\". (local address: %s:%d)"),
handle->urls.controlURL, handle->data.first.servicetype,
handle->lanaddr, port);
if (handle->isMapped)
{
tr_logAddNamedInfo (getKey (), "%s", _("Port forwarding successful!"));
handle->port = port;
handle->state = TR_UPNP_IDLE;
}
else
{
tr_logAddNamedDbg (getKey (), "If your router supports UPnP, please make sure UPnP is enabled!");
handle->port = -1;
handle->state = TR_UPNP_ERR;
}
}
switch (handle->state)
{
case TR_UPNP_DISCOVER:
ret = TR_PORT_UNMAPPED; break;
case TR_UPNP_MAP:
ret = TR_PORT_MAPPING; break;
case TR_UPNP_UNMAP:
ret = TR_PORT_UNMAPPING; break;
case TR_UPNP_IDLE:
ret = handle->isMapped ? TR_PORT_MAPPED
: TR_PORT_UNMAPPED; break;
default:
ret = TR_PORT_ERROR; break;
}
return ret;
}
Reference in a new issue View git blame Copy permalink