2008-05-18 16:44:30 +00:00
|
|
|
/*
|
|
|
|
* This file Copyright (C) 2008 Charles Kerr <charles@rebelbase.com>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2008-05-28 17:17:12 +00:00
|
|
|
* $Id$
|
2008-05-18 16:44:30 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <assert.h>
|
2008-06-04 17:14:58 +00:00
|
|
|
#include <ctype.h> /* isdigit */
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdlib.h> /* strtol */
|
2008-05-18 16:44:30 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
#include <unistd.h> /* unlink */
|
|
|
|
|
2008-05-19 00:22:04 +00:00
|
|
|
#include <libevent/event.h>
|
2008-06-05 16:23:03 +00:00
|
|
|
#include <shttpd/defs.h> /* edit_passwords */
|
2008-05-19 00:22:04 +00:00
|
|
|
#include <shttpd/shttpd.h>
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
#include "transmission.h"
|
2008-06-30 21:11:53 +00:00
|
|
|
#include "bencode.h"
|
2008-07-16 17:47:20 +00:00
|
|
|
#include "list.h"
|
2008-07-11 04:07:14 +00:00
|
|
|
#include "platform.h"
|
2008-05-18 16:44:30 +00:00
|
|
|
#include "rpc.h"
|
|
|
|
#include "rpc-server.h"
|
|
|
|
#include "utils.h"
|
|
|
|
|
2008-06-02 19:57:16 +00:00
|
|
|
#define MY_NAME "RPC Server"
|
2008-06-05 16:23:03 +00:00
|
|
|
#define MY_REALM "Transmission RPC Server"
|
2008-06-02 19:57:16 +00:00
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
#define ACTIVE_INTERVAL_MSEC 40
|
|
|
|
#define INACTIVE_INTERVAL_MSEC 500
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
struct tr_rpc_server
|
|
|
|
{
|
|
|
|
int port;
|
2008-06-05 02:07:17 +00:00
|
|
|
time_t lastRequestTime;
|
2008-05-18 16:44:30 +00:00
|
|
|
struct shttpd_ctx * ctx;
|
|
|
|
tr_handle * session;
|
|
|
|
struct event timer;
|
2008-06-05 16:23:03 +00:00
|
|
|
int isPasswordEnabled;
|
|
|
|
char * username;
|
|
|
|
char * password;
|
2008-05-18 16:44:30 +00:00
|
|
|
char * acl;
|
2008-07-16 17:47:20 +00:00
|
|
|
tr_list * connections;
|
2008-05-18 16:44:30 +00:00
|
|
|
};
|
|
|
|
|
2008-06-05 04:02:46 +00:00
|
|
|
#define dbgmsg(fmt...) tr_deepLog(__FILE__, __LINE__, MY_NAME, ##fmt )
|
|
|
|
|
2008-06-30 21:11:53 +00:00
|
|
|
static const char*
|
|
|
|
tr_memmem( const char * s1, size_t l1,
|
|
|
|
const char * s2, size_t l2 )
|
|
|
|
{
|
2008-07-16 17:47:20 +00:00
|
|
|
if (!l2) return s1;
|
|
|
|
while (l1 >= l2) {
|
|
|
|
l1--;
|
|
|
|
if (!memcmp(s1,s2,l2))
|
|
|
|
return s1;
|
|
|
|
s1++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
***
|
|
|
|
**/
|
|
|
|
|
|
|
|
struct ConnBuf
|
|
|
|
{
|
|
|
|
char * key;
|
|
|
|
time_t lastActivity;
|
|
|
|
struct evbuffer * in;
|
|
|
|
struct evbuffer * out;
|
|
|
|
};
|
|
|
|
|
|
|
|
static char*
|
|
|
|
buildKey( struct shttpd_arg * arg )
|
|
|
|
{
|
|
|
|
return tr_strdup_printf( "%s %s",
|
|
|
|
shttpd_get_env( arg, "REMOTE_ADDR" ),
|
|
|
|
shttpd_get_env( arg, "REQUEST_URI" ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ConnBuf*
|
|
|
|
getBuffer( tr_rpc_server * server, struct shttpd_arg * arg )
|
|
|
|
{
|
|
|
|
tr_list * l;
|
|
|
|
char * key = buildKey( arg );
|
|
|
|
struct ConnBuf * found = NULL;
|
|
|
|
|
|
|
|
for( l=server->connections; l && !found; l=l->next )
|
|
|
|
{
|
|
|
|
struct ConnBuf * buf = l->data;
|
|
|
|
if( !strcmp( key, buf->key ) )
|
|
|
|
found = buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( found == NULL )
|
|
|
|
{
|
|
|
|
found = tr_new0( struct ConnBuf, 1 );
|
|
|
|
found->lastActivity = time( NULL );
|
|
|
|
found->key = tr_strdup( key );
|
|
|
|
found->in = evbuffer_new( );
|
|
|
|
found->out = evbuffer_new( );
|
|
|
|
tr_list_append( &server->connections, found );
|
|
|
|
}
|
|
|
|
|
|
|
|
tr_free( key );
|
|
|
|
return found;
|
2008-06-30 21:11:53 +00:00
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
static void
|
|
|
|
pruneBuf( tr_rpc_server * server, struct ConnBuf * buf )
|
|
|
|
{
|
|
|
|
tr_list_remove_data( &server->connections, buf );
|
|
|
|
|
|
|
|
evbuffer_free( buf->in );
|
|
|
|
evbuffer_free( buf->out );
|
|
|
|
tr_free( buf->key );
|
|
|
|
tr_free( buf );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
***
|
|
|
|
**/
|
|
|
|
|
2008-06-30 21:11:53 +00:00
|
|
|
static void
|
|
|
|
handle_upload( struct shttpd_arg * arg )
|
|
|
|
{
|
|
|
|
struct tr_rpc_server * s = arg->user_data;
|
|
|
|
s->lastRequestTime = time( NULL );
|
2008-07-16 17:47:20 +00:00
|
|
|
struct ConnBuf * cbuf = getBuffer( s, arg );
|
2008-06-30 21:11:53 +00:00
|
|
|
|
|
|
|
/* if we haven't parsed the POST, do that now */
|
2008-07-16 17:47:20 +00:00
|
|
|
if( !EVBUFFER_LENGTH( cbuf->out ) )
|
2008-06-30 21:11:53 +00:00
|
|
|
{
|
|
|
|
/* if we haven't finished reading the POST, read more now */
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_add( cbuf->in, arg->in.buf, arg->in.len );
|
2008-07-01 02:33:31 +00:00
|
|
|
arg->in.num_bytes = arg->in.len;
|
2008-06-30 21:11:53 +00:00
|
|
|
if( arg->flags & SHTTPD_MORE_POST_DATA )
|
|
|
|
return;
|
|
|
|
|
|
|
|
const char * query_string = shttpd_get_env( arg, "QUERY_STRING" );
|
|
|
|
const char * content_type = shttpd_get_header( arg, "Content-Type" );
|
|
|
|
const char * delim;
|
2008-07-16 17:47:20 +00:00
|
|
|
const char * in = (const char *) EVBUFFER_DATA( cbuf->in );
|
|
|
|
size_t inlen = EVBUFFER_LENGTH( cbuf->in );
|
2008-06-30 21:11:53 +00:00
|
|
|
char * boundary = tr_strdup_printf( "--%s", strstr( content_type, "boundary=" ) + strlen( "boundary=" ) );
|
|
|
|
const size_t boundary_len = strlen( boundary );
|
|
|
|
char buf[64];
|
|
|
|
int paused = ( query_string != NULL )
|
|
|
|
&& ( shttpd_get_var( "paused", query_string, strlen( query_string ), buf, sizeof( buf ) ) == 4 )
|
|
|
|
&& ( !strcmp( buf, "true" ) );
|
|
|
|
|
|
|
|
delim = tr_memmem( in, inlen, boundary, boundary_len );
|
|
|
|
if( delim ) do
|
|
|
|
{
|
|
|
|
size_t part_len;
|
|
|
|
const char * part = delim + boundary_len;
|
|
|
|
inlen -= ( part - in );
|
|
|
|
in = part;
|
|
|
|
delim = tr_memmem( in, inlen, boundary, boundary_len );
|
|
|
|
part_len = delim ? (size_t)(delim-part) : inlen;
|
|
|
|
|
|
|
|
if( part_len )
|
|
|
|
{
|
|
|
|
char * text = tr_strndup( part, part_len );
|
|
|
|
if( strstr( text, "filename=\"" ) )
|
|
|
|
{
|
|
|
|
const char * body = strstr( text, "\r\n\r\n" );
|
|
|
|
if( body )
|
|
|
|
{
|
2008-07-15 19:25:46 +00:00
|
|
|
char * b64, *json, *freeme;
|
|
|
|
int json_len;
|
2008-06-30 21:11:53 +00:00
|
|
|
size_t body_len;
|
2008-07-15 19:25:46 +00:00
|
|
|
tr_benc top, *args;
|
|
|
|
|
2008-06-30 21:11:53 +00:00
|
|
|
body += 4;
|
|
|
|
body_len = part_len - ( body - text );
|
|
|
|
if( body_len >= 2 && !memcmp(&body[body_len-2],"\r\n",2) )
|
|
|
|
body_len -= 2;
|
2008-07-15 19:25:46 +00:00
|
|
|
|
|
|
|
tr_bencInitDict( &top, 2 );
|
|
|
|
args = tr_bencDictAddDict( &top, "arguments", 2 );
|
|
|
|
tr_bencDictAddStr( &top, "method", "torrent-add" );
|
|
|
|
b64 = tr_base64_encode( body, body_len, NULL );
|
|
|
|
tr_bencDictAddStr( args, "metainfo", b64 );
|
|
|
|
tr_bencDictAddInt( args, "paused", paused );
|
|
|
|
json = tr_bencSaveAsJSON( &top, &json_len );
|
|
|
|
freeme = tr_rpc_request_exec_json( s->session, json, json_len, NULL );
|
|
|
|
|
|
|
|
tr_free( freeme );
|
|
|
|
tr_free( json );
|
|
|
|
tr_free( b64 );
|
|
|
|
tr_bencFree( &top );
|
2008-06-30 21:11:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
tr_free( text );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while( delim );
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_drain( cbuf->in, EVBUFFER_LENGTH( cbuf->in ) );
|
2008-06-30 21:11:53 +00:00
|
|
|
tr_free( boundary );
|
|
|
|
|
|
|
|
{
|
2008-07-01 02:33:31 +00:00
|
|
|
/* use xml here because json responses to file uploads is trouble.
|
|
|
|
* see http://www.malsup.com/jquery/form/#sample7 for details */
|
|
|
|
const char * response = "<result>success</result>";
|
|
|
|
const int len = strlen( response );
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_add_printf( cbuf->out, "HTTP/1.1 200 OK\r\n"
|
|
|
|
"Content-Type: text/xml\r\n"
|
|
|
|
"Content-Length: %d\r\n"
|
|
|
|
"\r\n"
|
|
|
|
"%s\r\n", len, response );
|
2008-06-30 21:11:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
if( EVBUFFER_LENGTH( cbuf->out ) )
|
2008-06-30 21:11:53 +00:00
|
|
|
{
|
2008-07-16 17:47:20 +00:00
|
|
|
const int n = MIN( ( int )EVBUFFER_LENGTH( cbuf->out ), arg->out.len );
|
|
|
|
memcpy( arg->out.buf, EVBUFFER_DATA( cbuf->out ), n );
|
|
|
|
evbuffer_drain( cbuf->out, n );
|
2008-06-30 21:11:53 +00:00
|
|
|
arg->out.num_bytes = n;
|
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
if( !EVBUFFER_LENGTH( cbuf->out ) )
|
|
|
|
{
|
2008-06-30 21:11:53 +00:00
|
|
|
arg->flags |= SHTTPD_END_OF_OUTPUT;
|
2008-07-16 17:47:20 +00:00
|
|
|
pruneBuf( s, cbuf );
|
|
|
|
}
|
2008-06-30 21:11:53 +00:00
|
|
|
}
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
static void
|
|
|
|
handle_rpc( struct shttpd_arg * arg )
|
|
|
|
{
|
|
|
|
struct tr_rpc_server * s = arg->user_data;
|
2008-06-10 17:13:56 +00:00
|
|
|
s->lastRequestTime = time( NULL );
|
2008-07-16 17:47:20 +00:00
|
|
|
struct ConnBuf * cbuf = getBuffer( s, arg );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
if( !EVBUFFER_LENGTH( cbuf->out ) )
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
|
|
|
int len = 0;
|
|
|
|
char * response = NULL;
|
|
|
|
const char * request_method = shttpd_get_env( arg, "REQUEST_METHOD" );
|
|
|
|
const char * query_string = shttpd_get_env( arg, "QUERY_STRING" );
|
|
|
|
|
|
|
|
if( query_string && *query_string )
|
|
|
|
response = tr_rpc_request_exec_uri( s->session,
|
|
|
|
query_string,
|
|
|
|
strlen( query_string ),
|
|
|
|
&len );
|
|
|
|
else if( !strcmp( request_method, "POST" ) )
|
|
|
|
{
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_add( cbuf->in, arg->in.buf, arg->in.len );
|
2008-05-18 16:44:30 +00:00
|
|
|
arg->in.num_bytes = arg->in.len;
|
2008-05-19 18:16:58 +00:00
|
|
|
if( arg->flags & SHTTPD_MORE_POST_DATA )
|
2008-05-18 16:44:30 +00:00
|
|
|
return;
|
2008-05-19 18:16:58 +00:00
|
|
|
response = tr_rpc_request_exec_json( s->session,
|
2008-07-16 17:47:20 +00:00
|
|
|
EVBUFFER_DATA( cbuf->in ),
|
|
|
|
EVBUFFER_LENGTH( cbuf->in ),
|
2008-05-19 18:16:58 +00:00
|
|
|
&len );
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_drain( cbuf->in, EVBUFFER_LENGTH( cbuf->in ) );
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
evbuffer_add_printf( cbuf->out, "HTTP/1.1 200 OK\r\n"
|
|
|
|
"Content-Type: application/json\r\n"
|
|
|
|
"Content-Length: %d\r\n"
|
|
|
|
"\r\n"
|
|
|
|
"%*.*s", len, len, len, response );
|
2008-05-18 16:44:30 +00:00
|
|
|
tr_free( response );
|
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
if( EVBUFFER_LENGTH( cbuf->out ) )
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2008-07-16 17:47:20 +00:00
|
|
|
const int n = MIN( ( int )EVBUFFER_LENGTH( cbuf->out ), arg->out.len );
|
|
|
|
memcpy( arg->out.buf, EVBUFFER_DATA( cbuf->out ), n );
|
|
|
|
evbuffer_drain( cbuf->out, n );
|
2008-05-18 16:44:30 +00:00
|
|
|
arg->out.num_bytes = n;
|
|
|
|
}
|
|
|
|
|
2008-07-16 17:47:20 +00:00
|
|
|
if( !EVBUFFER_LENGTH( cbuf->out ) )
|
|
|
|
{
|
2008-05-18 16:44:30 +00:00
|
|
|
arg->flags |= SHTTPD_END_OF_OUTPUT;
|
2008-07-16 17:47:20 +00:00
|
|
|
pruneBuf( s, cbuf );
|
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
rpcPulse( int socket UNUSED, short action UNUSED, void * vserver )
|
|
|
|
{
|
|
|
|
int interval;
|
|
|
|
struct timeval tv;
|
|
|
|
tr_rpc_server * server = vserver;
|
2008-06-05 02:07:17 +00:00
|
|
|
const time_t now = time( NULL );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
assert( server );
|
|
|
|
|
2008-06-25 11:34:35 +00:00
|
|
|
if( server->ctx )
|
|
|
|
shttpd_poll( server->ctx, 1 );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
/* set a timer for the next pulse */
|
2008-07-16 17:47:20 +00:00
|
|
|
if( now - server->lastRequestTime < 300 )
|
|
|
|
interval = ACTIVE_INTERVAL_MSEC;
|
2008-06-10 19:25:18 +00:00
|
|
|
else
|
2008-07-16 17:47:20 +00:00
|
|
|
interval = INACTIVE_INTERVAL_MSEC;
|
2008-05-18 16:44:30 +00:00
|
|
|
tv = tr_timevalMsec( interval );
|
|
|
|
evtimer_add( &server->timer, &tv );
|
|
|
|
}
|
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
static void
|
|
|
|
getPasswordFile( tr_rpc_server * server, char * buf, int buflen )
|
|
|
|
{
|
|
|
|
tr_buildPath( buf, buflen, tr_sessionGetConfigDir( server->session ),
|
|
|
|
"htpasswd",
|
|
|
|
NULL );
|
|
|
|
}
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
static void
|
|
|
|
startServer( tr_rpc_server * server )
|
|
|
|
{
|
2008-06-05 04:02:46 +00:00
|
|
|
dbgmsg( "in startServer; current context is %p", server->ctx );
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
if( !server->ctx )
|
|
|
|
{
|
|
|
|
char ports[128];
|
2008-06-05 16:23:03 +00:00
|
|
|
char passwd[MAX_PATH_LENGTH];
|
2008-07-11 04:07:14 +00:00
|
|
|
const char * clutchDir = tr_getClutchDir( server->session );
|
2008-07-16 17:47:20 +00:00
|
|
|
struct timeval tv = tr_timevalMsec( INACTIVE_INTERVAL_MSEC );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
getPasswordFile( server, passwd, sizeof( passwd ) );
|
|
|
|
if( !server->isPasswordEnabled )
|
|
|
|
unlink( passwd );
|
|
|
|
else
|
2008-06-05 17:32:36 +00:00
|
|
|
edit_passwords( passwd, MY_REALM, server->username, server->password );
|
2008-06-05 16:23:03 +00:00
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
server->ctx = shttpd_init( );
|
2008-07-15 17:16:57 +00:00
|
|
|
tr_snprintf( ports, sizeof( ports ), "%d", server->port );
|
2008-06-18 22:01:15 +00:00
|
|
|
shttpd_register_uri( server->ctx, "/transmission/rpc", handle_rpc, server );
|
2008-06-30 21:11:53 +00:00
|
|
|
shttpd_register_uri( server->ctx, "/transmission/upload", handle_upload, server );
|
2008-07-11 17:09:53 +00:00
|
|
|
|
|
|
|
if( clutchDir && *clutchDir ) {
|
2008-07-14 16:00:20 +00:00
|
|
|
char * clutchAlias = tr_strdup_printf( "%s=%s,%s=%s",
|
|
|
|
"/transmission/clutch", clutchDir,
|
|
|
|
"/transmission/web", clutchDir );
|
2008-07-11 17:09:53 +00:00
|
|
|
tr_inf( _( "Serving the web interface files from \"%s\"" ), clutchDir );
|
|
|
|
shttpd_set_option( server->ctx, "aliases", clutchAlias );
|
|
|
|
tr_free( clutchAlias );
|
|
|
|
}
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
shttpd_set_option( server->ctx, "ports", ports );
|
|
|
|
shttpd_set_option( server->ctx, "dir_list", "0" );
|
2008-06-24 21:39:07 +00:00
|
|
|
//shttpd_set_option( server->ctx, "root", "/dev/null" );
|
2008-06-05 16:23:03 +00:00
|
|
|
shttpd_set_option( server->ctx, "auth_realm", MY_REALM );
|
2008-06-05 04:02:46 +00:00
|
|
|
if( server->acl ) {
|
|
|
|
dbgmsg( "setting acl [%s]", server->acl );
|
2008-05-18 16:44:30 +00:00
|
|
|
shttpd_set_option( server->ctx, "acl", server->acl );
|
2008-06-05 04:02:46 +00:00
|
|
|
}
|
2008-06-05 16:23:03 +00:00
|
|
|
if( server->isPasswordEnabled ) {
|
2008-07-15 20:39:50 +00:00
|
|
|
char * buf = tr_strdup_printf( "/transmission=%s", passwd );
|
2008-06-05 16:23:03 +00:00
|
|
|
shttpd_set_option( server->ctx, "protect", buf );
|
|
|
|
tr_free( buf );
|
|
|
|
}
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
evtimer_set( &server->timer, rpcPulse, server );
|
|
|
|
evtimer_add( &server->timer, &tv );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
stopServer( tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
if( server->ctx )
|
|
|
|
{
|
2008-06-05 16:23:03 +00:00
|
|
|
char passwd[MAX_PATH_LENGTH];
|
|
|
|
getPasswordFile( server, passwd, sizeof( passwd ) );
|
|
|
|
unlink( passwd );
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
evtimer_del( &server->timer );
|
|
|
|
shttpd_fini( server->ctx );
|
|
|
|
server->ctx = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tr_rpcSetEnabled( tr_rpc_server * server, int isEnabled )
|
|
|
|
{
|
|
|
|
if( !isEnabled && server->ctx )
|
|
|
|
stopServer( server );
|
|
|
|
|
|
|
|
if( isEnabled && !server->ctx )
|
|
|
|
startServer( server );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
tr_rpcIsEnabled( const tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
return server->ctx != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tr_rpcSetPort( tr_rpc_server * server, int port )
|
|
|
|
{
|
|
|
|
if( server->port != port )
|
|
|
|
{
|
|
|
|
server->port = port;
|
|
|
|
|
|
|
|
if( server->ctx )
|
|
|
|
{
|
|
|
|
stopServer( server );
|
|
|
|
startServer( server );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
tr_rpcGetPort( const tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
return server->port;
|
|
|
|
}
|
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
/****
|
|
|
|
***** ACL
|
|
|
|
****/
|
|
|
|
|
2008-06-02 19:44:19 +00:00
|
|
|
/*
|
|
|
|
* DELIM_CHARS, FOR_EACH_WORD_IN_LIST, isbyte, and testACL are from, or modified from,
|
|
|
|
* shttpd, written by Sergey Lyubka under this license:
|
|
|
|
* "THE BEER-WARE LICENSE" (Revision 42):
|
|
|
|
* Sergey Lyubka wrote this file. As long as you retain this notice you
|
|
|
|
* can do whatever you want with this stuff. If we meet some day, and you think
|
|
|
|
* this stuff is worth it, you can buy me a beer in return.
|
|
|
|
*/
|
|
|
|
|
2008-06-09 23:58:31 +00:00
|
|
|
#define DELIM_CHARS "," /* Separators for lists */
|
2008-06-02 19:44:19 +00:00
|
|
|
|
|
|
|
#define FOR_EACH_WORD_IN_LIST(s,len) \
|
|
|
|
for (; s != NULL && (len = strcspn(s, DELIM_CHARS)) != 0; \
|
|
|
|
s += len, s+= strspn(s, DELIM_CHARS))
|
|
|
|
|
|
|
|
static int isbyte(int n) { return (n >= 0 && n <= 255); }
|
|
|
|
|
|
|
|
static char*
|
|
|
|
testACL( const char * s )
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
|
|
|
|
FOR_EACH_WORD_IN_LIST(s, len)
|
|
|
|
{
|
|
|
|
|
|
|
|
char flag;
|
|
|
|
int a, b, c, d, n, mask;
|
|
|
|
|
|
|
|
if( sscanf(s, "%c%d.%d.%d.%d%n",&flag,&a,&b,&c,&d,&n) != 5 )
|
|
|
|
return tr_strdup_printf( _( "[%s]: subnet must be [+|-]x.x.x.x[/x]" ), s );
|
|
|
|
if( flag != '+' && flag != '-')
|
|
|
|
return tr_strdup_printf( _( "[%s]: flag must be + or -" ), s );
|
|
|
|
if( !isbyte(a) || !isbyte(b) || !isbyte(c) || !isbyte(d) )
|
|
|
|
return tr_strdup_printf( _( "[%s]: bad ip address" ), s );
|
|
|
|
if( sscanf(s + n, "/%d", &mask) == 1 && ( mask<0 || mask>32 ) )
|
|
|
|
return tr_strdup_printf( _( "[%s]: bad subnet mask %d" ), s, n );
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-04 17:14:58 +00:00
|
|
|
/* 192.*.*.* --> 192.0.0.0/8
|
|
|
|
192.64.*.* --> 192.64.0.0/16
|
|
|
|
192.64.1.* --> 192.64.1.0/24
|
|
|
|
192.64.1.2 --> 192.64.1.2/32 */
|
|
|
|
static void
|
|
|
|
cidrizeOne( const char * in, int len, struct evbuffer * out )
|
|
|
|
{
|
|
|
|
int stars = 0;
|
|
|
|
const char * pch;
|
|
|
|
const char * end;
|
|
|
|
char zero = '0';
|
|
|
|
char huh = '?';
|
|
|
|
|
|
|
|
for( pch=in, end=pch+len; pch!=end; ++pch ) {
|
|
|
|
if( stars && isdigit(*pch) )
|
|
|
|
evbuffer_add( out, &huh, 1 );
|
|
|
|
else if( *pch!='*' )
|
|
|
|
evbuffer_add( out, pch, 1 );
|
|
|
|
else {
|
|
|
|
evbuffer_add( out, &zero, 1 );
|
|
|
|
++stars;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
evbuffer_add_printf( out, "/%d", (32-(stars*8)));
|
|
|
|
}
|
|
|
|
|
|
|
|
char*
|
|
|
|
cidrize( const char * acl )
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
const char * walk = acl;
|
|
|
|
char * ret;
|
|
|
|
struct evbuffer * out = evbuffer_new( );
|
|
|
|
|
|
|
|
FOR_EACH_WORD_IN_LIST( walk, len )
|
|
|
|
{
|
|
|
|
cidrizeOne( walk, len, out );
|
2008-06-09 23:28:14 +00:00
|
|
|
evbuffer_add_printf( out, "," );
|
2008-06-04 17:14:58 +00:00
|
|
|
}
|
|
|
|
|
2008-06-11 15:17:59 +00:00
|
|
|
/* the -1 is to eat the final ", " */
|
|
|
|
ret = tr_strndup( (char*) EVBUFFER_DATA(out), EVBUFFER_LENGTH(out)-1 );
|
2008-06-04 17:14:58 +00:00
|
|
|
evbuffer_free( out );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-02 19:44:19 +00:00
|
|
|
int
|
2008-06-04 17:14:58 +00:00
|
|
|
tr_rpcTestACL( const tr_rpc_server * server UNUSED,
|
|
|
|
const char * acl,
|
|
|
|
char ** setme_errmsg )
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2008-06-04 19:46:37 +00:00
|
|
|
int err = 0;
|
2008-06-04 17:14:58 +00:00
|
|
|
char * cidr = cidrize( acl );
|
|
|
|
char * errmsg = testACL( cidr );
|
2008-06-02 19:44:19 +00:00
|
|
|
if( errmsg )
|
|
|
|
{
|
2008-06-04 04:49:45 +00:00
|
|
|
if( setme_errmsg )
|
|
|
|
*setme_errmsg = errmsg;
|
2008-06-04 06:36:50 +00:00
|
|
|
else
|
|
|
|
tr_free( errmsg );
|
2008-06-04 19:46:37 +00:00
|
|
|
err = -1;
|
2008-06-02 19:44:19 +00:00
|
|
|
}
|
2008-06-04 17:14:58 +00:00
|
|
|
tr_free( cidr );
|
2008-06-04 19:46:37 +00:00
|
|
|
return err;
|
2008-06-04 17:14:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
tr_rpcSetACL( tr_rpc_server * server,
|
|
|
|
const char * acl,
|
|
|
|
char ** setme_errmsg )
|
|
|
|
{
|
|
|
|
char * cidr = cidrize( acl );
|
2008-06-04 19:46:37 +00:00
|
|
|
const int err = tr_rpcTestACL( server, cidr, setme_errmsg );
|
2008-06-04 17:14:58 +00:00
|
|
|
|
2008-06-05 04:02:46 +00:00
|
|
|
if( !err )
|
2008-06-02 19:44:19 +00:00
|
|
|
{
|
2008-06-04 17:14:58 +00:00
|
|
|
const int isRunning = server->ctx != NULL;
|
|
|
|
|
2008-06-02 19:44:19 +00:00
|
|
|
if( isRunning )
|
|
|
|
stopServer( server );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-06-02 19:44:19 +00:00
|
|
|
tr_free( server->acl );
|
2008-06-04 17:14:58 +00:00
|
|
|
server->acl = tr_strdup( cidr );
|
2008-06-05 04:02:46 +00:00
|
|
|
dbgmsg( "setting our ACL to [%s]", server->acl );
|
2008-05-18 16:44:30 +00:00
|
|
|
|
2008-06-02 19:44:19 +00:00
|
|
|
if( isRunning )
|
|
|
|
startServer( server );
|
|
|
|
}
|
2008-06-08 04:23:56 +00:00
|
|
|
tr_free( cidr );
|
2008-06-02 19:44:19 +00:00
|
|
|
|
2008-06-04 19:46:37 +00:00
|
|
|
return err;
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
char*
|
2008-05-18 16:44:30 +00:00
|
|
|
tr_rpcGetACL( const tr_rpc_server * server )
|
|
|
|
{
|
2008-06-05 16:23:03 +00:00
|
|
|
return tr_strdup( server->acl ? server->acl : "" );
|
|
|
|
}
|
|
|
|
|
|
|
|
/****
|
|
|
|
***** PASSWORD
|
|
|
|
****/
|
|
|
|
|
|
|
|
void
|
|
|
|
tr_rpcSetUsername( tr_rpc_server * server,
|
|
|
|
const char * username )
|
|
|
|
{
|
|
|
|
const int isRunning = server->ctx != NULL;
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
stopServer( server );
|
|
|
|
|
|
|
|
tr_free( server->username );
|
|
|
|
server->username = tr_strdup( username );
|
|
|
|
dbgmsg( "setting our Username to [%s]", server->username );
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
startServer( server );
|
|
|
|
}
|
|
|
|
|
|
|
|
char*
|
|
|
|
tr_rpcGetUsername( const tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
return tr_strdup( server->username ? server->username : "" );
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tr_rpcSetPassword( tr_rpc_server * server,
|
|
|
|
const char * password )
|
|
|
|
{
|
|
|
|
const int isRunning = server->ctx != NULL;
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
stopServer( server );
|
|
|
|
|
|
|
|
tr_free( server->password );
|
|
|
|
server->password = tr_strdup( password );
|
|
|
|
dbgmsg( "setting our Password to [%s]", server->password );
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
startServer( server );
|
|
|
|
}
|
|
|
|
|
|
|
|
char*
|
|
|
|
tr_rpcGetPassword( const tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
return tr_strdup( server->password ? server->password : "" );
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
tr_rpcSetPasswordEnabled( tr_rpc_server * server,
|
|
|
|
int isEnabled )
|
|
|
|
{
|
|
|
|
const int isRunning = server->ctx != NULL;
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
stopServer( server );
|
|
|
|
|
|
|
|
server->isPasswordEnabled = isEnabled;
|
|
|
|
dbgmsg( "setting 'password enabled' to %d", isEnabled );
|
|
|
|
|
|
|
|
if( isRunning )
|
|
|
|
startServer( server );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
tr_rpcIsPasswordEnabled( const tr_rpc_server * server )
|
|
|
|
{
|
|
|
|
return server->isPasswordEnabled;
|
2008-05-18 16:44:30 +00:00
|
|
|
}
|
|
|
|
|
2008-06-05 16:23:03 +00:00
|
|
|
/****
|
|
|
|
***** LIFE CYCLE
|
|
|
|
****/
|
|
|
|
|
2008-05-18 16:44:30 +00:00
|
|
|
void
|
|
|
|
tr_rpcClose( tr_rpc_server ** ps )
|
|
|
|
{
|
|
|
|
tr_rpc_server * s = *ps;
|
|
|
|
*ps = NULL;
|
|
|
|
|
|
|
|
stopServer( s );
|
2008-07-16 19:36:46 +00:00
|
|
|
tr_free( s->username );
|
|
|
|
tr_free( s->password );
|
2008-05-19 18:16:58 +00:00
|
|
|
tr_free( s->acl );
|
2008-05-18 16:44:30 +00:00
|
|
|
tr_free( s );
|
|
|
|
}
|
|
|
|
|
|
|
|
tr_rpc_server *
|
|
|
|
tr_rpcInit( tr_handle * session,
|
|
|
|
int isEnabled,
|
|
|
|
int port,
|
2008-06-05 16:23:03 +00:00
|
|
|
const char * acl,
|
|
|
|
int isPasswordEnabled,
|
|
|
|
const char * username,
|
|
|
|
const char * password )
|
2008-05-18 16:44:30 +00:00
|
|
|
{
|
2008-06-02 19:57:16 +00:00
|
|
|
char * errmsg;
|
|
|
|
tr_rpc_server * s;
|
|
|
|
|
|
|
|
if(( errmsg = testACL ( acl )))
|
|
|
|
{
|
|
|
|
tr_nerr( MY_NAME, errmsg );
|
|
|
|
tr_free( errmsg );
|
|
|
|
acl = TR_DEFAULT_RPC_ACL;
|
|
|
|
tr_nerr( MY_NAME, "using fallback ACL \"%s\"", acl );
|
|
|
|
}
|
|
|
|
|
|
|
|
s = tr_new0( tr_rpc_server, 1 );
|
2008-05-18 16:44:30 +00:00
|
|
|
s->session = session;
|
|
|
|
s->port = port;
|
|
|
|
s->acl = tr_strdup( acl );
|
2008-06-05 16:23:03 +00:00
|
|
|
s->username = tr_strdup( username );
|
|
|
|
s->password = tr_strdup( password );
|
|
|
|
s->isPasswordEnabled = isPasswordEnabled;
|
2008-05-18 16:44:30 +00:00
|
|
|
|
|
|
|
if( isEnabled )
|
|
|
|
startServer( s );
|
|
|
|
return s;
|
|
|
|
}
|