mirror of
https://github.com/transmission/transmission
synced 2024-12-25 01:03:01 +00:00
cc204e0b2c
* refactor: prefer "using" over "typedef"
260 lines
6.5 KiB
C++
260 lines
6.5 KiB
C++
/*
|
|
* This file Copyright (C) 2007-2014 Mnemosyne LLC
|
|
*
|
|
* It may be used under the GNU GPL versions 2 or 3
|
|
* or any future license endorsed by Mnemosyne LLC.
|
|
*
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <time.h>
|
|
#include <inttypes.h>
|
|
|
|
#include <event2/util.h> /* evutil_inet_ntop() */
|
|
|
|
#define ENABLE_STRNATPMPERR
|
|
#include "natpmp.h"
|
|
|
|
#include "transmission.h"
|
|
#include "natpmp_local.h"
|
|
#include "log.h"
|
|
#include "net.h" /* tr_netCloseSocket */
|
|
#include "port-forwarding.h"
|
|
#include "utils.h"
|
|
|
|
#define LIFETIME_SECS 3600
|
|
#define COMMAND_WAIT_SECS 8
|
|
|
|
static char const* getKey(void)
|
|
{
|
|
return _("Port Forwarding (NAT-PMP)");
|
|
}
|
|
|
|
enum tr_natpmp_state
|
|
{
|
|
TR_NATPMP_IDLE,
|
|
TR_NATPMP_ERR,
|
|
TR_NATPMP_DISCOVER,
|
|
TR_NATPMP_RECV_PUB,
|
|
TR_NATPMP_SEND_MAP,
|
|
TR_NATPMP_RECV_MAP,
|
|
TR_NATPMP_SEND_UNMAP,
|
|
TR_NATPMP_RECV_UNMAP
|
|
};
|
|
|
|
struct tr_natpmp
|
|
{
|
|
bool has_discovered;
|
|
bool is_mapped;
|
|
|
|
tr_port public_port;
|
|
tr_port private_port;
|
|
|
|
time_t renew_time;
|
|
time_t command_time;
|
|
tr_natpmp_state state;
|
|
natpmp_t natpmp;
|
|
};
|
|
|
|
/**
|
|
***
|
|
**/
|
|
|
|
static void logVal(char const* func, int ret)
|
|
{
|
|
if (ret == NATPMP_TRYAGAIN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (ret >= 0)
|
|
{
|
|
tr_logAddNamedInfo(getKey(), _("%s succeeded (%d)"), func, ret);
|
|
}
|
|
else
|
|
{
|
|
tr_logAddNamedDbg(
|
|
getKey(),
|
|
"%s failed. Natpmp returned %d (%s); errno is %d (%s)",
|
|
func,
|
|
ret,
|
|
strnatpmperr(ret),
|
|
errno,
|
|
tr_strerror(errno));
|
|
}
|
|
}
|
|
|
|
struct tr_natpmp* tr_natpmpInit(void)
|
|
{
|
|
struct tr_natpmp* nat;
|
|
|
|
nat = tr_new0(struct tr_natpmp, 1);
|
|
nat->state = TR_NATPMP_DISCOVER;
|
|
nat->public_port = 0;
|
|
nat->private_port = 0;
|
|
nat->natpmp.s = TR_BAD_SOCKET; /* socket */
|
|
return nat;
|
|
}
|
|
|
|
void tr_natpmpClose(tr_natpmp* nat)
|
|
{
|
|
if (nat != nullptr)
|
|
{
|
|
closenatpmp(&nat->natpmp);
|
|
tr_free(nat);
|
|
}
|
|
}
|
|
|
|
static bool canSendCommand(struct tr_natpmp const* nat)
|
|
{
|
|
return tr_time() >= nat->command_time;
|
|
}
|
|
|
|
static void setCommandTime(struct tr_natpmp* nat)
|
|
{
|
|
nat->command_time = tr_time() + COMMAND_WAIT_SECS;
|
|
}
|
|
|
|
tr_port_forwarding tr_natpmpPulse(struct tr_natpmp* nat, tr_port private_port, bool is_enabled, tr_port* public_port)
|
|
{
|
|
tr_port_forwarding ret;
|
|
|
|
if (is_enabled && nat->state == TR_NATPMP_DISCOVER)
|
|
{
|
|
int val = initnatpmp(&nat->natpmp, 0, 0);
|
|
logVal("initnatpmp", val);
|
|
val = sendpublicaddressrequest(&nat->natpmp);
|
|
logVal("sendpublicaddressrequest", val);
|
|
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
|
|
nat->has_discovered = true;
|
|
setCommandTime(nat);
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_RECV_PUB && canSendCommand(nat))
|
|
{
|
|
natpmpresp_t response;
|
|
int const val = readnatpmpresponseorretry(&nat->natpmp, &response);
|
|
logVal("readnatpmpresponseorretry", val);
|
|
|
|
if (val >= 0)
|
|
{
|
|
char str[128];
|
|
evutil_inet_ntop(AF_INET, &response.pnu.publicaddress.addr, str, sizeof(str));
|
|
tr_logAddNamedInfo(getKey(), _("Found public address \"%s\""), str);
|
|
nat->state = TR_NATPMP_IDLE;
|
|
}
|
|
else if (val != NATPMP_TRYAGAIN)
|
|
{
|
|
nat->state = TR_NATPMP_ERR;
|
|
}
|
|
}
|
|
|
|
if ((nat->state == TR_NATPMP_IDLE || nat->state == TR_NATPMP_ERR) && (nat->is_mapped) &&
|
|
(!is_enabled || nat->private_port != private_port))
|
|
{
|
|
nat->state = TR_NATPMP_SEND_UNMAP;
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_SEND_UNMAP && canSendCommand(nat))
|
|
{
|
|
int const val = sendnewportmappingrequest(&nat->natpmp, NATPMP_PROTOCOL_TCP, nat->private_port, nat->public_port, 0);
|
|
logVal("sendnewportmappingrequest", val);
|
|
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_UNMAP;
|
|
setCommandTime(nat);
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_RECV_UNMAP)
|
|
{
|
|
natpmpresp_t resp;
|
|
int const val = readnatpmpresponseorretry(&nat->natpmp, &resp);
|
|
logVal("readnatpmpresponseorretry", val);
|
|
|
|
if (val >= 0)
|
|
{
|
|
int const unmapped_port = resp.pnu.newportmapping.privateport;
|
|
|
|
tr_logAddNamedInfo(getKey(), _("no longer forwarding port %d"), unmapped_port);
|
|
|
|
if (nat->private_port == unmapped_port)
|
|
{
|
|
nat->private_port = 0;
|
|
nat->public_port = 0;
|
|
nat->state = TR_NATPMP_IDLE;
|
|
nat->is_mapped = false;
|
|
}
|
|
}
|
|
else if (val != NATPMP_TRYAGAIN)
|
|
{
|
|
nat->state = TR_NATPMP_ERR;
|
|
}
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_IDLE)
|
|
{
|
|
if (is_enabled && !nat->is_mapped && nat->has_discovered)
|
|
{
|
|
nat->state = TR_NATPMP_SEND_MAP;
|
|
}
|
|
else if (nat->is_mapped && tr_time() >= nat->renew_time)
|
|
{
|
|
nat->state = TR_NATPMP_SEND_MAP;
|
|
}
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_SEND_MAP && canSendCommand(nat))
|
|
{
|
|
int const val = sendnewportmappingrequest(&nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS);
|
|
logVal("sendnewportmappingrequest", val);
|
|
nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
|
|
setCommandTime(nat);
|
|
}
|
|
|
|
if (nat->state == TR_NATPMP_RECV_MAP)
|
|
{
|
|
natpmpresp_t resp;
|
|
int const val = readnatpmpresponseorretry(&nat->natpmp, &resp);
|
|
logVal("readnatpmpresponseorretry", val);
|
|
|
|
if (val >= 0)
|
|
{
|
|
nat->state = TR_NATPMP_IDLE;
|
|
nat->is_mapped = true;
|
|
nat->renew_time = tr_time() + (resp.pnu.newportmapping.lifetime / 2);
|
|
nat->private_port = resp.pnu.newportmapping.privateport;
|
|
nat->public_port = resp.pnu.newportmapping.mappedpublicport;
|
|
tr_logAddNamedInfo(getKey(), _("Port %d forwarded successfully"), nat->private_port);
|
|
}
|
|
else if (val != NATPMP_TRYAGAIN)
|
|
{
|
|
nat->state = TR_NATPMP_ERR;
|
|
}
|
|
}
|
|
|
|
switch (nat->state)
|
|
{
|
|
case TR_NATPMP_IDLE:
|
|
*public_port = nat->public_port;
|
|
return nat->is_mapped ? TR_PORT_MAPPED : TR_PORT_UNMAPPED;
|
|
|
|
case TR_NATPMP_DISCOVER:
|
|
ret = TR_PORT_UNMAPPED;
|
|
break;
|
|
|
|
case TR_NATPMP_RECV_PUB:
|
|
case TR_NATPMP_SEND_MAP:
|
|
case TR_NATPMP_RECV_MAP:
|
|
ret = TR_PORT_MAPPING;
|
|
break;
|
|
|
|
case TR_NATPMP_SEND_UNMAP:
|
|
case TR_NATPMP_RECV_UNMAP:
|
|
ret = TR_PORT_UNMAPPING;
|
|
break;
|
|
|
|
default:
|
|
ret = TR_PORT_ERROR;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|