transmission/libtransmission/tr-lpd.c

/*
Copyright (c) 2010 by Johannes Lieder

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.
*/

/* ansi */
#include <errno.h>
#include <stdio.h>

/* posix */
#include <netinet/in.h> /* sockaddr_in */
#include <signal.h> /* sig_atomic_t */
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h> /* socket(), bind() */
#include <unistd.h> /* close() */
#include <fcntl.h> /* fcntl(), O_NONBLOCK */
#include <ctype.h> /* toupper() */

/* third party */
#include <event.h>

/* libT */
#include "transmission.h"
#include "crypto.h"
#include "net.h"
#include "peer-mgr.h" /* tr_peerMgrAddPex() */
#include "session.h"
#include "torrent.h" /* tr_torrentFindFromHash() */
#include "tr-lpd.h"
#include "utils.h"
#include "version.h"

/**
* @brief Local Peer Discovery
* @file tr-lpd.c
*
* This module implements the Local Peer Discovery (LPD) protocol as supported by the
* uTorrent client application.  A typical LPD datagram is 119 bytes long.
*
* $Id$
*/

static void event_callback( int, short, void* );

static int lpd_socket; /**<separate multicast receive socket */
static int lpd_socket2; /**<and multicast send socket */
static struct event lpd_event;
static tr_port lpd_port;

static tr_torrent* lpd_torStaticType UNUSED; /* just a helper for static type analysis */
static tr_session* session;

enum { lpd_maxDatagramLength = 200 }; /**<the size an LPD datagram must not exceed */
const char lpd_mcastGroup[] = "239.192.152.143"; /**<LPD multicast group */
const int lpd_mcastPort = 6771; /**<LPD source and destination UPD port */
static struct sockaddr_in lpd_mcastAddr; /**<initialized from the above constants in tr_lpdInit */

/**
* @brief Protocol-related information carried by a Local Peer Discovery packet */
struct lpd_protocolVersion
{
    int major, minor;
};

enum lpd_enumTimeToLive {
    lpd_ttlSameSubnet = 1,
    lpd_ttlSameSite = 32,
    lpd_ttlSameRegion = 64,
    lpd_ttlSameContinent = 128,
    lpd_ttlUnrestricted = 255
};

enum {
    lpd_announceInterval = 4 * 60, /**<4 min announce interval per torrent */
    lpd_announceScope = lpd_ttlSameSubnet /**<the maximum scope for LPD datagrams */
};


/**
* @defgroup DoS Message Flood Protection
* @{
* We want to have a means to protect the libtransmission backend against message
* flooding: the strategy is to cap event processing once more than ten messages
* per second (that is, taking the average over one of our housekeeping intervals)
* got into our processing handler.
* If we'd really hit the limit and start discarding events, we either joined an
* extremely crowded multicast group or a malevolent host is sending bogus data to
* our socket. In this situation, we rather miss some announcements than blocking
* the actual task.
* @}
*/

/**
* @ingroup DoS
* @brief allow at most ten messages per second (interval average)
* @note this constraint is only enforced once per housekeeping interval */
enum { lpd_announceCapFactor = 10 };

/**
* @ingroup DoS
* @brief number of unsolicited messages during the last HK interval
* @remark counts downwards */
static int lpd_unsolicitedMsgCounter;

/**
* @def CRLF
* @brief a line-feed, as understood by the LPD protocol */
#define CRLF "\r\n"


/**
* @defgroup HttpReqProc HTTP-style request handling
* @{
*/

/**
* @brief Checks for BT-SEARCH method and separates the parameter section
* @param[in] s The request string
* @param[out] ver If non-NULL, gets filled with protocol info from the request
* @return Returns a relative pointer to the beginning of the parameter section;
*         if result is NULL, s was invalid and no information will be returned
* @remark Note that the returned pointer is only usable as long as the given
*         pointer s is valid; that is, return storage is temporary.
*
* Determines whether the given string checks out to be a valid BT-SEARCH message.
* If so, the return value points to the beginning of the parameter section (note:
* in this case the function returns a character sequence beginning with CRLF).
* If parameter is not NULL, the declared protocol version is returned as part of
* the lpd_protocolVersion structure.
*/
static const char* lpd_extractHeader( const char* s, struct lpd_protocolVersion* const ver )
{
    int major = -1, minor = -1;
    size_t len;

    assert( s != NULL );
    len = strlen( s );

    /* something might be rotten with this chunk of data */
    if( len == 0 || len > lpd_maxDatagramLength )
        return NULL;

    /* now we can attempt to look up the BT-SEARCH header */
    if( sscanf( s, "BT-SEARCH * HTTP/%d.%d" CRLF, &major, &minor ) != 2 )
        return NULL;

    if( major < 0 || minor < 0 )
        return NULL;

    {
        /* a pair of blank lines at the end of the string, no place else */
        const char* const two_blank = CRLF CRLF CRLF;
        const char* const end = strstr( s, two_blank );

        if( end == NULL || strlen( end ) > strlen( two_blank ) )
            return NULL;
    }

    if( ver != NULL )
    {
        ver->major = major;
        ver->minor = minor;
    }

    /* separate the header, begins with CRLF */
    return strstr( s, CRLF );
}

/**
* @brief Return the value of a named parameter
*
* @param[in] str Input string of "\r\nName: Value" pairs without HTTP-style method part
* @param[in] name Name of parameter to extract
* @param[in] n Maximum available storage for value to return
* @param[out] val Output parameter for the actual value
* @return Returns 1 if value could be copied successfully
*
* Extracts the associated value of a named parameter from a HTTP-style header by
* performing the following steps:
*   - assemble search string "\r\nName: " and locate position
*   - copy back value from end to next "\r\n"
*/
static int lpd_extractParam( const char* const str, const char* const name, int n, char* const val )
{
    /* configure maximum length of search string here */
    enum { maxLength = 30 };
    char sstr[maxLength] = { };
    const char* pos;

    assert( str != NULL && name != NULL );
    assert( val != NULL );

    if( strlen( name ) > maxLength - strlen( CRLF ": " ) )
        return 0;

    /* compose the string token to search for */
    snprintf( sstr, maxLength, CRLF "%s: ", name );

    pos = strstr( str, sstr );
    if( pos == NULL )
        return 0; /* search was not successful */

    {
        const char* const beg = pos + strlen( sstr );
        const char* const new_line = strstr( beg, CRLF );

        /* the value is delimited by the next CRLF */
        int len = new_line - beg;

        /* if value string hits the length limit n,
         * leave space for a trailing '\0' character */
        if( len < n-- )
            n = len;

        strncpy( val, beg, n );
        val[n] = 0;
    }

    /* we successfully returned the value string */
    return 1;
}

/**
* @} */


/**
* @brief Configures additional capabilities for a socket */
static inline int lpd_configureSocket( int sock, int add )
{
    /* read-modify-write socket flags */
    int flags = fcntl( sock, F_GETFL );

    if( flags < 0 )
        return -1;

    if( fcntl( sock, F_SETFL, add | flags ) == -1 )
        return -1;

    return add;
}

/**
* @brief Initializes Local Peer Discovery for this node
*
* For the most part, this means setting up an appropriately configured multicast socket
* and event-based message handling.
*
* @remark Since the LPD service does not use another protocol family yet, this code is
* IPv4 only for the time being.
*/
int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
{
    struct ip_mreq mcastReq;
    const int opt_on = 1, opt_off = 0;

    if( session ) /* already initialized */
        return -1;

    assert( lpd_announceInterval > 0 );
    assert( lpd_announceScope > 0 );

    lpd_port = tr_sessionGetPeerPort( ss );
    if( lpd_port <= 0 )
        return -1;

    tr_ndbg( "LPD", "Initialising Local Peer Discovery" );

    /* setup datagram socket (receive) */
    {
        lpd_socket = socket( PF_INET, SOCK_DGRAM, 0 );
        if( lpd_socket < 0 )
            goto fail;

        /* enable non-blocking operation */
        if( lpd_configureSocket( lpd_socket, O_NONBLOCK ) < 0 )
            goto fail;

        if( setsockopt( lpd_socket, SOL_SOCKET, SO_REUSEADDR,
                &opt_on, sizeof opt_on ) < 0 )
            goto fail;

        memset( &lpd_mcastAddr, 0, sizeof lpd_mcastAddr );
        lpd_mcastAddr.sin_family = AF_INET;
        lpd_mcastAddr.sin_port = htons( lpd_mcastPort );
        if( inet_pton( lpd_mcastAddr.sin_family, lpd_mcastGroup,
                &lpd_mcastAddr.sin_addr ) < 0 )
            goto fail;

        if( bind( lpd_socket, (struct sockaddr*) &lpd_mcastAddr,
                sizeof lpd_mcastAddr ) < 0 )
            goto fail;

        /* we want to join that LPD multicast group */
        memset( &mcastReq, 0, sizeof mcastReq );
        mcastReq.imr_multiaddr = lpd_mcastAddr.sin_addr;
        mcastReq.imr_interface.s_addr = htonl( INADDR_ANY );
        if( setsockopt( lpd_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                &mcastReq, sizeof mcastReq ) < 0 )
            goto fail;

        if( setsockopt( lpd_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
                &opt_off, sizeof opt_off ) < 0 )
            goto fail;
    }

    /* setup datagram socket (send) */
    {
        const unsigned char scope = lpd_announceScope;

        lpd_socket2 = socket( PF_INET, SOCK_DGRAM, 0 );
        if( lpd_socket2 < 0 )
            goto fail;

        /* enable non-blocking operation */
        if( lpd_configureSocket( lpd_socket2, O_NONBLOCK ) < 0 )
            goto fail;

        /* configure outbound multicast TTL */
        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_TTL,
                &scope, sizeof scope ) < 0 )
            goto fail;

        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_LOOP,
                &opt_off, sizeof opt_off ) < 0 )
            goto fail;
    }

    session = ss;

    /* Note: lpd_unsolicitedMsgCounter remains 0 until the first timeout event, thus
     * any announcement received during the initial interval will be discarded. */

    event_set( &lpd_event, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL );
    event_add( &lpd_event, NULL );

    tr_ndbg( "LPD", "Local Peer Discovery initialised" );

    return 1;

    fail:
    {
        const int save = errno;
        close( lpd_socket );
        close( lpd_socket2 );
        lpd_socket = lpd_socket2 = -1;
        session = NULL;
        tr_ndbg( "LPD", "LPD initialisation failed (errno = %d)", save );
        errno = save;
    }


    return -1;
}

void tr_lpdUninit( tr_session* ss )
{
    if( session != ss )
        return;

    tr_ndbg( "LPD", "Uninitialising Local Peer Discovery" );

    event_del( &lpd_event );

    /* just shut down, we won't remember any former nodes */
    EVUTIL_CLOSESOCKET( lpd_socket );
    EVUTIL_CLOSESOCKET( lpd_socket2 );
    tr_ndbg( "LPD", "Done uninitialising Local Peer Discovery" );

    session = NULL;
}

tr_bool tr_lpdEnabled( const tr_session* ss )
{
    return ss && ( ss == session );
}


/**
* @cond
* @brief Performs some (internal) software consistency checks at compile time.
* @remark Declared inline for the compiler not to allege us of feeding unused
* functions. In any other respect, lpd_consistencyCheck is an orphaned function.
*/
static inline void lpd_consistencyCheck( void )
{
    /* if the following check fails, the definition of a hash string has changed
     * without our knowledge; revise string handling in functions tr_lpdSendAnnounce
     * and tr_lpdConsiderAnnounce. However, the code is designed to function as long
     * as interfaces to the rest of the lib remain compatible with char* strings. */
    STATIC_ASSERT( sizeof(lpd_torStaticType->info.hashString[0]) == sizeof(char) );
}
/**
* @endcond */


/**
* @defgroup LdsProto LPD announcement processing
* @{
*/

/**
* @brief Announce the given torrent on the local network
*
* @param[in] t Torrent to announce
* @return Returns TRUE on success
*
* Send a query for torrent t out to the LPD multicast group (or the LAN, for that
* matter).  A listening client on the same network might react by adding us to his
* peer pool for torrent t.
*/
tr_bool tr_lpdSendAnnounce( const tr_torrent* t )
{
    size_t i;
    const char fmt[] =
        "BT-SEARCH * HTTP/%u.%u" CRLF
        "Host: %s:%u" CRLF
        "Port: %u" CRLF
        "Infohash: %s" CRLF
        CRLF
        CRLF;

    char hashString[lengthof( t->info.hashString )];
    char query[lpd_maxDatagramLength + 1] = { };

    if( t == NULL )
        return FALSE;

    /* make sure the hash string is normalized, just in case */
    for( i = 0; i < sizeof hashString; i++ )
        hashString[i] = toupper( t->info.hashString[i] );

    /* prepare a zero-terminated announce message */
    snprintf( query, lpd_maxDatagramLength + 1, fmt, 1, 1,
        lpd_mcastGroup, lpd_mcastPort, lpd_port, hashString );

    /* actually send the query out using [lpd_socket2] */
    {
        const int len = strlen( query );

        /* destination address info has already been set up in tr_lpdInit(),
         * so we refrain from preparing another sockaddr_in here */
        int res = sendto( lpd_socket2, query, len, 0,
            (const struct sockaddr*) &lpd_mcastAddr, sizeof lpd_mcastAddr );

        if( res != len )
            return FALSE;
    }

    tr_tordbg( t, "LPD announce message away" );

    return TRUE;
}

/**
* @brief Process incoming unsolicited messages and add the peer to the announced
* torrent if all checks are passed.
*
* @param[in,out] peer Adress information of the peer to add
* @param[in] msg The announcement message to consider
* @return Returns 0 if any input parameter or the announce was invalid, 1 if the peer
* was successfully added, -1 if not; a non-null return value indicates a side-effect to
* the peer in/out parameter.
*
* @note The port information gets added to the peer structure if tr_lpdConsiderAnnounce
* is able to extract the necessary information from the announce message.  That is, if
* return != 0, the caller may retrieve the value from the passed structure.
*/
static int tr_lpdConsiderAnnounce( tr_pex* peer, const char* const msg )
{
    enum
    {
        maxValueLen = 25,
        maxHashLen = lengthof(lpd_torStaticType->info.hashString)
    };

    struct lpd_protocolVersion ver = { -1, -1 };
    char value[maxValueLen] = { };
    char hashString[maxHashLen] = { };
    int res = 0, peerPort = 0;

    if( peer != NULL && msg != NULL )
    {
        tr_torrent* tor = NULL;

        const char* params = lpd_extractHeader( msg, &ver );
        if( params == NULL || ver.major != 1 ) /* allow messages of protocol v1 */
            return 0;

        /* save the effort to check Host, which seems to be optional anyway */

        if( lpd_extractParam( params, "Port", maxValueLen, value ) == 0 )
            return 0;

        /* determine announced peer port, refuse if value too large */
        if( sscanf( value, "%u", &peerPort ) != 1 || peerPort > (in_port_t)-1 )
            return 0;

        peer->port = htons( peerPort );
        res = -1; /* signal caller side-effect to peer->port via return != 0 */

        if( lpd_extractParam( params, "Infohash", maxHashLen, hashString ) == 0 )
            return res;

        tor = tr_torrentFindFromHashString( session, hashString );

        if( tr_isTorrent( tor ) && tr_torrentAllowsLPD( tor ) )
        {
            /* we found a suitable peer, add it to the torrent */
            tr_peerMgrAddPex( tor, TR_PEER_FROM_LPD, peer, -1 );
            tr_tordbg( tor, "Learned %d local peer from LPD (%s:%u)",
                1, inet_ntoa( peer->addr.addr.addr4 ), peerPort );

            /* periodic reconnectPulse() deals with the rest... */

            return 1;
        }
        else
            tr_ndbg( "LPD", "Cannot serve torrent #%s", hashString );
    }

    return res;
}

/**
* @} */

/**
* @note Since it possible for tr_lpdAnnounceMore to get called from outside the LPD module,
* the function needs to be informed of the externally employed housekeeping interval.
* Further, by setting interval to zero (or negative) the caller may actually disable LPD
* announces on a per-interval basis.
*/
int tr_lpdAnnounceMore( const time_t now, const int interval )
{
    tr_torrent* tor = NULL;
    int announcesSent = 0;

    if( !tr_isSession( session ) )
        return -1;

    while(( tor = tr_torrentNext( session, tor ) )
          && tr_sessionAllowsLPD( session ) )
    {
        if( tr_isTorrent( tor ) )
        {
            if( !tr_torrentAllowsLPD( tor ) || (
                    ( tr_torrentGetActivity( tor ) != TR_STATUS_DOWNLOAD ) &&
                    ( tr_torrentGetActivity( tor ) != TR_STATUS_SEED ) ) )
                continue;

            if( tor->lpdAnnounceAt <= now )
            {
                if( tr_lpdSendAnnounce( tor ) )
                    announcesSent++;

                tor->lpdAnnounceAt = now + lpd_announceInterval;
                break; /* that's enough; for this interval */
            }
        }
    }

    /* perform housekeeping for the flood protection mechanism */
    {
        const int maxAnnounceCap = interval * lpd_announceCapFactor;

        if( lpd_unsolicitedMsgCounter < 0 )
            tr_ninf( "LPD", "Dropped %d announces in the last interval (max. %d "
                     "allowed)", -lpd_unsolicitedMsgCounter, maxAnnounceCap );

        lpd_unsolicitedMsgCounter = maxAnnounceCap;
    }

    return announcesSent;
}

/**
* @brief Processing of timeout notifications and incoming data on the socket
* @note maximum rate of read events is limited according to @a lpd_maxAnnounceCap
* @see DoS */
static void event_callback( int s UNUSED, short type, void* ignore UNUSED )
{
    assert( tr_isSession( session ) );

    /* do not allow announces to be processed if LPD is disabled */
    if( !tr_sessionAllowsLPD( session ) )
        return;

    if( ( type & EV_READ ) != 0 )
    {
        struct sockaddr_in foreignAddr;
        int addrLen = sizeof foreignAddr;

        /* be paranoid enough about zero terminating the foreign string */
        char foreignMsg[lpd_maxDatagramLength + 1] = { };

        /* process local announcement from foreign peer */
        int res = recvfrom( lpd_socket, foreignMsg, lpd_maxDatagramLength,
            0, (struct sockaddr*) &foreignAddr, (socklen_t*) &addrLen );

        /* besides, do we get flooded? then bail out! */
        if( --lpd_unsolicitedMsgCounter < 0 )
            return;

        if( res > 0 && res <= lpd_maxDatagramLength )
        {
            struct tr_pex foreignPeer =
                {
                    .port = 0, /* the peer-to-peer port is yet unknown */
                    .flags = 0
                };

            foreignPeer.addr.addr.addr4 = foreignAddr.sin_addr;
            if( tr_lpdConsiderAnnounce( &foreignPeer, foreignMsg ) != 0 )
                return; /* OK so far, no log message */
        }

        tr_ndbg( "LPD", "Discarded invalid multicast message" );
    }
}