mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/libtransmission/natpmp.c

785 lines
22 KiB
C
Raw Blame History

/******************************************************************************
* $Id$
*
* Copyright (c) 2006 Transmission authors and contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*****************************************************************************/
#include "transmission.h"
#define PMP_PORT 5351
#define PMP_MCAST_ADDR "224.0.0.1"
#define PMP_INITIAL_DELAY 250 /* ms, 1/4 second */
#define PMP_TOTAL_DELAY 120000 /* ms, 2 minutes */
#define PMP_VERSION 0
#define PMP_OPCODE_GETIP 0
#define PMP_OPCODE_ADDUDP 1
#define PMP_OPCODE_ADDTCP 2
#define PMP_LIFETIME 3600 /* secs, one hour */
#define PMP_RESULT_OK 0
#define PMP_RESULT_BADVERS 1
#define PMP_RESULT_REFUSED 2
#define PMP_RESULT_NETDOWN 3
#define PMP_RESULT_NOMEM 4
#define PMP_RESULT_BADOPCODE 5
#define PMP_OPCODE_FROM_RESPONSE( op ) ( 0x80 ^ (op) )
#define PMP_OPCODE_TO_RESPONSE( op ) ( 0x80 | (op) )
#define PMP_OPCODE_IS_RESPONSE( op ) ( 0x80 & (op) )
#define PMP_TOBUF16( buf, num ) ( *( (uint16_t *) (buf) ) = htons( (num) ) )
#define PMP_TOBUF32( buf, num ) ( *( (uint32_t *) (buf) ) = htonl( (num) ) )
#define PMP_FROMBUF16( buf ) ( htons( *( (uint16_t *) (buf) ) ) )
#define PMP_FROMBUF32( buf ) ( htonl( *( (uint32_t *) (buf) ) ) )
typedef struct tr_natpmp_uptime_s
{
time_t when;
uint32_t uptime;
} tr_natpmp_uptime_t;
typedef struct tr_natpmp_req_s
{
unsigned int adding : 1;
unsigned int nobodyhome : 1;
unsigned int tmpfail : 1;
int fd;
int delay;
uint64_t retry;
uint64_t timeout;
int askport;
int gotport;
} tr_natpmp_req_t;
struct tr_natpmp_s
{
#define PMP_STATE_IDLE 1
#define PMP_STATE_ADDING 2
#define PMP_STATE_DELETING 3
#define PMP_STATE_MAPPED 4
#define PMP_STATE_FAILED 5
#define PMP_STATE_NOBODYHOME 6
#define PMP_STATE_TMPFAIL 7
char state;
unsigned int active : 1;
unsigned int mapped : 1;
struct in_addr dest;
int newport;
int mappedport;
uint64_t renew;
tr_natpmp_req_t * req;
tr_natpmp_uptime_t uptime;
int mcastfd;
};
typedef struct tr_natpmp_parse_s
{
unsigned int tmpfail : 1;
uint32_t seconds;
uint16_t port;
uint32_t lifetime;
}
tr_natpmp_parse_t;
static int
checktime( tr_natpmp_uptime_t * uptime, uint32_t seen );
static void
killsock( int * fd );
static tr_natpmp_req_t *
newreq( int adding, struct in_addr addr, int port );
static void
killreq( tr_natpmp_req_t ** req );
static void
resetreq( tr_natpmp_req_t * req );
static tr_tristate_t
pulsereq( tr_natpmp_t * req );
static int
sendreq( tr_natpmp_req_t * req );
static int
mcastsetup();
static void
mcastpulse( tr_natpmp_t * pmp );
static tr_tristate_t
parseresponse( uint8_t * buf, int len, int port, tr_natpmp_parse_t * parse );
tr_natpmp_t *
tr_natpmpInit()
{
tr_natpmp_t * pmp;
pmp = calloc( 1, sizeof( *pmp ) );
if( NULL == pmp )
{
return NULL;
}
pmp->state = PMP_STATE_IDLE;
pmp->mcastfd = -1;
if( tr_getDefaultRoute( &pmp->dest ) || INADDR_ANY == pmp->dest.s_addr )
{
pmp->dest.s_addr = INADDR_NONE;
}
if( INADDR_NONE == pmp->dest.s_addr )
{
tr_dbg( "nat-pmp device is unknown" );
}
else
{
char addrstr[INET_ADDRSTRLEN];
tr_netNtop( &pmp->dest, addrstr, sizeof( addrstr ) );
tr_dbg( "nat-pmp device is %s", addrstr );
}
return pmp;
}
void
tr_natpmpStart( tr_natpmp_t * pmp )
{
if( !pmp->active )
{
tr_inf( "starting nat-pmp" );
pmp->active = 1;
if( 0 > pmp->mcastfd )
{
pmp->mcastfd = mcastsetup();
}
}
}
void
tr_natpmpStop( tr_natpmp_t * pmp )
{
if( pmp->active )
{
tr_inf( "stopping nat-pmp" );
pmp->active = 0;
killsock( &pmp->mcastfd );
switch( pmp->state )
{
case PMP_STATE_IDLE:
break;
case PMP_STATE_ADDING:
pmp->state = PMP_STATE_IDLE;
tr_dbg( "nat-pmp state add -> idle" );
if( NULL != pmp->req )
{
pmp->mappedport = pmp->req->gotport;
killreq( &pmp->req );
pmp->state = PMP_STATE_DELETING;
tr_dbg( "nat-pmp state idle -> del" );
}
break;
case PMP_STATE_DELETING:
break;
case PMP_STATE_MAPPED:
pmp->state = PMP_STATE_DELETING;
tr_dbg( "nat-pmp state mapped -> del" );
break;
case PMP_STATE_FAILED:
case PMP_STATE_NOBODYHOME:
case PMP_STATE_TMPFAIL:
break;
default:
assert( 0 );
break;
}
}
}
int
tr_natpmpStatus( tr_natpmp_t * pmp )
{
int ret;
if( !pmp->active )
{
ret = ( PMP_STATE_DELETING == pmp->state ?
TR_NAT_TRAVERSAL_UNMAPPING : TR_NAT_TRAVERSAL_DISABLED );
}
else if( pmp->mapped )
{
ret = TR_NAT_TRAVERSAL_MAPPED;
}
else
{
switch( pmp->state )
{
case PMP_STATE_IDLE:
case PMP_STATE_ADDING:
case PMP_STATE_DELETING:
ret = TR_NAT_TRAVERSAL_MAPPING;
break;
case PMP_STATE_FAILED:
case PMP_STATE_TMPFAIL:
ret = TR_NAT_TRAVERSAL_ERROR;
break;
case PMP_STATE_NOBODYHOME:
ret = TR_NAT_TRAVERSAL_NOTFOUND;
break;
case PMP_STATE_MAPPED:
default:
/* if pmp->state is PMP_STATE_MAPPED then pmp->mapped
should be true */
assert( 0 );
ret = TR_NAT_TRAVERSAL_ERROR;
break;
}
}
return ret;
}
void
tr_natpmpForwardPort( tr_natpmp_t * pmp, int port )
{
tr_inf( "nat-pmp set port %i", port );
pmp->newport = port;
}
void
tr_natpmpClose( tr_natpmp_t * pmp )
{
/* try to send at least one delete request if we have a port mapping */
tr_natpmpStop( pmp );
tr_natpmpPulse( pmp, NULL );
killreq( &pmp->req );
free( pmp );
}
void
tr_natpmpPulse( tr_natpmp_t * pmp, int * publicPort )
{
if( 0 <= pmp->mcastfd )
{
mcastpulse( pmp );
}
if( pmp->active || PMP_STATE_DELETING == pmp->state )
{
switch( pmp->state )
{
case PMP_STATE_IDLE:
case PMP_STATE_TMPFAIL:
if( 0 < pmp->newport )
{
tr_dbg( "nat-pmp state %s -> add with port %i",
( PMP_STATE_IDLE == pmp->state ? "idle" : "err" ),
pmp->newport );
pmp->state = PMP_STATE_ADDING;
}
break;
case PMP_STATE_ADDING:
if( NULL == pmp->req )
{
if( 0 >= pmp->newport )
{
tr_dbg( "nat-pmp state add -> idle, no port" );
pmp->state = PMP_STATE_IDLE;
}
else if( INADDR_NONE == pmp->dest.s_addr )
{
tr_dbg( "nat-pmp state add -> fail, no default route" );
pmp->state = PMP_STATE_FAILED;
}
else
{
pmp->req = newreq( 1, pmp->dest, pmp->newport );
if( NULL == pmp->req )
{
pmp->state = PMP_STATE_FAILED;
tr_dbg( "nat-pmp state add -> fail on req init" );
}
}
}
if( PMP_STATE_ADDING == pmp->state )
{
switch( pulsereq( pmp ) )
{
case TR_NET_ERROR:
if( pmp->req->nobodyhome )
{
pmp->state = PMP_STATE_NOBODYHOME;
tr_dbg( "nat-pmp state add -> nobodyhome on pulse" );
}
else if( pmp->req->tmpfail )
{
pmp->state = PMP_STATE_TMPFAIL;
tr_dbg( "nat-pmp state add -> err on pulse" );
if( pmp->req->askport == pmp->newport )
{
pmp->newport = 0;
}
}
else
{
pmp->state = PMP_STATE_FAILED;
tr_dbg( "nat-pmp state add -> fail on pulse" );
}
killreq( &pmp->req );
break;
case TR_NET_OK:
pmp->mappedport = pmp->req->gotport;
if( pmp->mappedport != pmp->newport &&
pmp->newport == pmp->req->askport )
{
pmp->newport = pmp->req->gotport;
}
killreq( &pmp->req );
pmp->state = PMP_STATE_MAPPED;
pmp->mapped = 1;
tr_dbg( "nat-pmp state add -> mapped with port %i",
pmp->mappedport);
tr_inf( "nat-pmp mapped port %i", pmp->mappedport );
break;
case TR_NET_WAIT:
break;
}
}
break;
case PMP_STATE_DELETING:
if( NULL == pmp->req )
{
assert( 0 < pmp->mappedport );
pmp->req = newreq( 0, pmp->dest, pmp->mappedport );
if( NULL == pmp->req )
{
pmp->state = PMP_STATE_FAILED;
tr_dbg( "nat-pmp state del -> fail on req init" );
}
}
if( PMP_STATE_DELETING == pmp->state )
{
switch( pulsereq( pmp ) )
{
case TR_NET_ERROR:
if( pmp->req->nobodyhome )
{
pmp->mapped = 0;
pmp->state = PMP_STATE_NOBODYHOME;
tr_dbg( "nat-pmp state del -> nobodyhome on pulse" );
}
else if( pmp->req->tmpfail )
{
pmp->mapped = 0;
pmp->state = PMP_STATE_TMPFAIL;
tr_dbg( "nat-pmp state del -> err on pulse" );
pmp->mappedport = -1;
}
else
{
pmp->state = PMP_STATE_FAILED;
tr_dbg( "nat-pmp state del -> fail on pulse" );
}
killreq( &pmp->req );
break;
case TR_NET_OK:
tr_dbg( "nat-pmp state del -> idle with port %i",
pmp->req->askport);
tr_inf( "nat-pmp unmapped port %i",
pmp->req->askport );
pmp->mapped = 0;
pmp->mappedport = -1;
killreq( &pmp->req );
pmp->state = PMP_STATE_IDLE;
break;
case TR_NET_WAIT:
break;
}
}
break;
case PMP_STATE_MAPPED:
if( pmp->newport != pmp->mappedport )
{
tr_dbg( "nat-pmp state mapped -> del, port from %i to %i",
pmp->mappedport, pmp->newport );
pmp->state = PMP_STATE_DELETING;
}
else if( tr_date() > pmp->renew )
{
pmp->state = PMP_STATE_ADDING;
tr_dbg( "nat-pmp state mapped -> add for renewal" );
}
break;
case PMP_STATE_FAILED:
case PMP_STATE_NOBODYHOME:
break;
default:
assert( 0 );
break;
}
}
if( NULL != publicPort )
{
*publicPort = -1;
}
}
static int
checktime( tr_natpmp_uptime_t * uptime, uint32_t cursecs )
{
time_t now;
int ret;
uint32_t estimated;
now = time( NULL );
ret = 0;
if( 0 < uptime->when )
{
estimated = ( ( now - uptime->when ) * 7 / 8 ) + uptime->uptime;
if( estimated > cursecs )
{
ret = 1;
}
}
uptime->when = now;
uptime->uptime = cursecs;
return ret;
}
static void
killsock( int * fd )
{
if( 0 <= *fd )
{
tr_netClose( *fd );
*fd = -1;
}
}
static tr_natpmp_req_t *
newreq( int adding, struct in_addr addr, int port )
{
tr_natpmp_req_t * ret;
ret = calloc( 1, sizeof( *ret ) );
if( NULL == ret )
{
return NULL;
}
ret->fd = tr_netOpenUDP( addr, htons( PMP_PORT ), 1 );
if( 0 > ret->fd )
{
free( ret );
return NULL;
}
ret->adding = adding;
ret->askport = port;
ret->gotport = port;
resetreq( ret );
if( sendreq( ret ) )
{
killreq( &ret );
return NULL;
}
return ret;
}
static void
killreq( tr_natpmp_req_t ** req )
{
if( NULL != *req )
{
killsock( &(*req)->fd );
free( *req );
*req = NULL;
}
}
static void
resetreq( tr_natpmp_req_t * req )
{
uint64_t now;
now = tr_date();
req->delay = PMP_INITIAL_DELAY;
req->retry = now;
req->timeout = now + PMP_TOTAL_DELAY;
}
static tr_tristate_t
pulsereq( tr_natpmp_t * pmp )
{
tr_natpmp_req_t * req = pmp->req;
struct sockaddr_in sin;
uint8_t buf[16];
int res;
uint64_t now;
tr_tristate_t ret;
tr_natpmp_parse_t parse;
now = tr_date();
/* check for timeout */
if( now >= req->timeout )
{
tr_dbg( "nat-pmp request timed out" );
req->nobodyhome = 1;
return TR_NET_ERROR;
}
/* send another request if it's been long enough */
if( now >= req->retry && sendreq( req ) )
{
return TR_NET_ERROR;
}
/* check for incoming packets */
res = tr_netRecvFrom( req->fd, buf, sizeof( buf ), &sin );
if( TR_NET_BLOCK & res )
{
return TR_NET_WAIT;
}
else if( TR_NET_CLOSE & res )
{
if( ECONNRESET == errno || ECONNREFUSED == errno )
{
tr_dbg( "nat-pmp not supported by device" );
req->nobodyhome = 1;
}
else
{
tr_inf( "error reading nat-pmp response (%s)", strerror( errno ) );
}
return TR_NET_ERROR;
}
/* parse the packet */
tr_dbg( "nat-pmp read %i byte response", res );
ret = parseresponse( buf, res, req->askport, &parse );
req->tmpfail = parse.tmpfail;
/* check for device reset */
if( checktime( &pmp->uptime, parse.seconds ) )
{
pmp->renew = 0;
tr_inf( "detected nat-pmp device reset" );
resetreq( req );
ret = TR_NET_WAIT;
}
if( TR_NET_OK == ret && req->adding )
{
if( req->askport != parse.port )
{
tr_dbg( "nat-pmp received %i for public port instead of %i",
parse.port, req->askport );
req->gotport = parse.port;
}
tr_dbg( "nat-pmp set renew to half of %u", parse.lifetime );
pmp->renew = now + ( parse.lifetime / 2 * 1000 );
}
return ret;
}
static int
sendreq( tr_natpmp_req_t * req )
{
uint8_t buf[12];
int res;
memset( buf, 0, sizeof( buf ) );
buf[0] = PMP_VERSION;
buf[1] = PMP_OPCODE_ADDTCP;
PMP_TOBUF16( buf + 4, req->askport );
if( req->adding )
{
PMP_TOBUF16( buf + 6, req->askport );
PMP_TOBUF32( buf + 8, PMP_LIFETIME );
}
res = tr_netSend( req->fd, buf, sizeof( buf ) );
if( TR_NET_CLOSE & res && EHOSTUNREACH == errno )
{
res = TR_NET_BLOCK;
}
if( TR_NET_CLOSE & res )
{
tr_err( "failed to send nat-pmp request (%s)", strerror( errno ) );
return 1;
}
else if( !( TR_NET_BLOCK & res ) )
{
/* XXX is it all right to assume the entire thing is written? */
req->retry = tr_date() + req->delay;
req->delay *= 2;
}
return 0;
}
static int
mcastsetup()
{
int fd;
struct in_addr addr;
addr.s_addr = inet_addr( PMP_MCAST_ADDR );
fd = tr_netMcastOpen( PMP_PORT, addr );
if( 0 > fd )
{
return -1;
}
tr_dbg( "nat-pmp create multicast socket %i", fd );
return fd;
}
static void
mcastpulse( tr_natpmp_t * pmp )
{
struct sockaddr_in sin;
uint8_t buf[16];
int res;
char dbgstr[INET_ADDRSTRLEN];
tr_natpmp_parse_t parse;
res = tr_netRecvFrom( pmp->mcastfd, buf, sizeof( buf ), &sin );
if( TR_NET_BLOCK & res )
{
return;
}
else if( TR_NET_CLOSE & res )
{
tr_err( "error reading nat-pmp multicast message" );
killsock( &pmp->mcastfd );
return;
}
tr_netNtop( &sin.sin_addr, dbgstr, sizeof( dbgstr ) );
tr_dbg( "nat-pmp read %i byte multicast packet from %s", res, dbgstr );
if( pmp->dest.s_addr != sin.sin_addr.s_addr )
{
tr_dbg( "nat-pmp ignoring multicast packet from unknown host %s",
dbgstr );
return;
}
if( TR_NET_OK == parseresponse( buf, res, -1, &parse ) )
{
if( checktime( &pmp->uptime, parse.seconds ) )
{
pmp->renew = 0;
tr_inf( "detected nat-pmp device reset" );
if( NULL != pmp->req )
{
resetreq( pmp->req );
}
}
if( PMP_STATE_NOBODYHOME == pmp->state )
{
tr_dbg( "nat-pmp state notfound -> idle" );
pmp->state = PMP_STATE_IDLE;
}
}
}
static tr_tristate_t
parseresponse( uint8_t * buf, int len, int port, tr_natpmp_parse_t * parse )
{
int version, respopcode, opcode, wantedopcode, rescode, privport;
memset( parse, 0, sizeof( *parse ) );
if( 8 > len )
{
tr_err( "read truncated %i byte nat-pmp response packet", len );
return TR_NET_ERROR;
}
/* parse the first 8 bytes: version, opcode, and result code */
version = buf[0];
respopcode = buf[1];
opcode = PMP_OPCODE_FROM_RESPONSE( respopcode );
wantedopcode = ( 0 < port ? PMP_OPCODE_ADDTCP : PMP_OPCODE_GETIP );
rescode = PMP_FROMBUF16( buf + 2 );
if( PMP_VERSION != version )
{
tr_err( "unknown nat-pmp version %hhu", buf[0] );
return TR_NET_ERROR;
}
if( !PMP_OPCODE_IS_RESPONSE( respopcode ) )
{
tr_dbg( "nat-pmp ignoring request packet" );
return TR_NET_WAIT;
}
if( wantedopcode != opcode )
{
tr_err( "unknown nat-pmp opcode %hhu", opcode );
return TR_NET_ERROR;
}
switch( rescode )
{
case PMP_RESULT_OK:
break;
case PMP_RESULT_REFUSED:
tr_err( "nat-pmp mapping failed: refused/unauthorized/disabled" );
parse->tmpfail = 1;
return TR_NET_ERROR;
case PMP_RESULT_NETDOWN:
tr_err( "nat-pmp mapping failed: network down" );
parse->tmpfail = 1;
return TR_NET_ERROR;
case PMP_RESULT_NOMEM:
tr_err( "nat-pmp mapping refused: insufficient resources" );
parse->tmpfail = 1;
return TR_NET_ERROR;
default:
tr_err( "nat-pmp mapping refused: unknown result code: %hu",
rescode );
return TR_NET_ERROR;
}
parse->seconds = PMP_FROMBUF32( buf + 4 );
if( PMP_OPCODE_ADDTCP == opcode )
{
if( 16 > len )
{
tr_err( "read truncated %i byte nat-pmp response packet", len );
return TR_NET_ERROR;
}
privport = PMP_FROMBUF16( buf + 8 );
parse->port = PMP_FROMBUF16( buf + 10 );
parse->lifetime = PMP_FROMBUF32( buf + 12 );
if( port != privport )
{
tr_dbg( "nat-pmp ignoring message for port %i, expected port %i",
privport, port );
return TR_NET_WAIT;
}
}
return TR_NET_OK;
}
Reference in New Issue View Git Blame Copy Permalink