exttrack.cpp

/*
 *  exttrack.cpp
 *
 *  Implements an external tracker client. Currently uses BT tracker protocol.
 *  If SwarmIDs are not SHA1 hashes they are hashed with a SHA1 MDC to turn
 *  them into an infohash. Only HTTP trackers supported at the moment.
 *
 *  TODO:
 *  - SwarmManager reregistrations
 *  - IETF PPSP tracker protocol
 *
 *  Created by Arno Bakker
 *  Copyright 2013-2016 Vrije Universiteit Amsterdam. All rights reserved.
 */
#include "swift.h"
#include <event2/http.h>
#include <event2/http_struct.h>
#include <sstream>

#define exttrack_debug	true


using namespace swift;


// https://wiki.theory.org/BitTorrentSpecification#peer_id
#define BT_PEER_ID_LENGTH	20 // bytes
#define BT_PEER_ID_PREFIX	"-SW1000-"

#define BT_BENCODE_STRING_SEP		":"
#define BT_BENCODE_INT_SEP		"e"

#define BT_FAILURE_REASON_DICT_KEY	"failure reason"
#define BT_PEERS_IPv4_DICT_KEY	"5:peers"	// 5: to avoid confusion with a 'peers' list with one 6-byte entry
#define BT_INTERVAL_DICT_KEY	"interval"
#define BT_PEERS_IPv6_DICT_KEY	"6:peers6"

#define BT_INITIAL_REPORT_INTERVAL	30 // seconds


typedef enum
{
    BENCODED_INT,
    BENCODED_STRING
} bencoded_type_t;


static int ParseBencodedPeers(struct evbuffer *evb, std::string key, peeraddrs_t *peerlist);
static int ParseBencodedValue(struct evbuffer *evb, struct evbuffer_ptr &startevbp, std::string key, bencoded_type_t valuetype, char **valueptr);

ExternalTrackerClient::ExternalTrackerClient(std::string url) : url_(url), report_last_time_(0), report_interval_(BT_INITIAL_REPORT_INTERVAL), reported_complete_(false)
{
    // Create PeerID
    peerid_ = new uint8_t[BT_PEER_ID_LENGTH];

    int ret = 0;
#ifdef OPENSSL
    strcpy((char *)peerid_,BT_PEER_ID_PREFIX);
    ret = RAND_bytes(&peerid_[strlen(BT_PEER_ID_PREFIX)], BT_PEER_ID_LENGTH-strlen(BT_PEER_ID_PREFIX));
#endif
    if (ret != 1)
    {
	// Fallback and no OPENSSL option
	char buf[32];
	std::ostringstream oss;
	oss << BT_PEER_ID_PREFIX;
	sprintf(buf,"%05d", rand() );
	oss << buf;
	sprintf(buf,"%05d", rand() );
	oss << buf;
	sprintf(buf,"%05d", rand() );
	oss << buf;
	std::string randstr = oss.str().substr(0,BT_PEER_ID_LENGTH);
	strcpy((char *)peerid_,randstr.c_str());
    }
}

ExternalTrackerClient::~ExternalTrackerClient()
{
    if (peerid_ != NULL)
	delete peerid_;
}


int ExternalTrackerClient::Contact(ContentTransfer *transfer, std::string event, exttrack_peerlist_callback_t callback)
{
    Address myaddr = Channel::BoundAddress(Channel::default_socket());
    std::string q = CreateQuery(transfer,myaddr,event);
    if (q.length() == 0)
	return -1;
    else
    {
	if (event == EXTTRACK_EVENT_COMPLETED)
	    reported_complete_ = true;

	report_last_time_ = NOW;

	ExtTrackCallbackRecord *callbackrec = new ExtTrackCallbackRecord(transfer->td(),callback);
	return HTTPConnect(q,callbackrec);
    }
}

/** IP in myaddr currently unused */
std::string ExternalTrackerClient::CreateQuery(ContentTransfer *transfer, Address myaddr, std::string event)
{
    Sha1Hash infohash;

    // Should be per swarm, now using global upload, just to monitor sharing activity
    uint64_t uploaded = Channel::global_bytes_up;
    uint64_t downloaded = swift::SeqComplete(transfer->td());
    uint64_t left = 0;
    if (transfer->ttype() == FILE_TRANSFER)
    {
	infohash = transfer->swarm_id().roothash();
	if (downloaded > swift::Size(transfer->td()))
	    left = 0;
	else
	    left = swift::Size(transfer->td()) - downloaded;

	// "No completed is sent if the file was complete when started. "
	// http://www.bittorrent.org/beps/bep_0003.html
	if (event == EXTTRACK_EVENT_STARTED && left == 0)
	    reported_complete_ = true;
    }
    else
    {
	SwarmPubKey spubkey = transfer->swarm_id().spubkey();
	infohash = Sha1Hash(spubkey.bits(),spubkey.length());
	left = 0x7fffffffffffffffULL;
    }

    // See
    // http://www.bittorrent.org/beps/bep_0003.html
    // https://wiki.theory.org/BitTorrent_Tracker_Protocol

    char *esc = NULL;
    std::ostringstream oss;

    oss << "info_hash=";
    esc = evhttp_uriencode((const char *)infohash.bytes(),Sha1Hash::SIZE,false);
    if (esc == NULL)
	return "";
    oss << esc;
    free(esc);
    oss << "&";

    oss << "peer_id=";
    esc = evhttp_uriencode((const char *)peerid_,BT_PEER_ID_LENGTH,false);
    if (esc == NULL)
	return "";
    oss << esc;
    free(esc);
    oss << "&";

    // ip= currently unused

    oss << "port=";
    oss << myaddr.port();
    oss << "&";

    oss << "uploaded=";
    oss << uploaded;
    oss << "&";

    oss << "downloaded=";
    oss << downloaded;
    oss << "&";

    oss << "left=";
    oss << left;
    oss << "&";

    // Request compacted peerlist, is most common http://www.bittorrent.org/beps/bep_0023.html
    oss << "compact=1";

    if (event.length() > 0)
    {
	oss << "&";
	oss << "event=";
	oss << event;
    }

    return oss.str();
}


static void ExternalTrackerClientHTTPResponseCallback(struct evhttp_request *req, void *callbackrecvoid)
{
    if (exttrack_debug)
	fprintf(stderr,"exttrack: Callback: ENTER %p\n", callbackrecvoid );

    ExtTrackCallbackRecord *callbackrec = (ExtTrackCallbackRecord *)callbackrecvoid;
    if (callbackrec == NULL)
	return;
    if (callbackrec->callback_ == NULL)
	return;


    if (req->response_code != HTTP_OK)
    {
	callbackrec->callback_(callbackrec->td_,"Unexpected HTTP Response Code",0,peeraddrs_t());
	delete callbackrec;
	return;
    }

    // Create a copy of the response, as we do destructive parsing
    struct evbuffer *evb = evhttp_request_get_input_buffer(req);
    size_t copybuflen = evbuffer_get_length(evb);
    char *copybuf = new char[copybuflen];
    int ret = evbuffer_remove(evb,copybuf,copybuflen);
    if (ret < 0)
    {
	delete copybuf;

	callbackrec->callback_(callbackrec->td_,"Could not read HTTP body",0,peeraddrs_t());
	delete callbackrec;
	return;
    }

    //fprintf(stderr,"exttrack: Raw response <%s>\n", copybuf );


    evb = evbuffer_new();
    evbuffer_add(evb,copybuf,copybuflen);

    // Find "failure reason" string following BT spec
    struct evbuffer_ptr startevbp = evbuffer_search(evb,BT_FAILURE_REASON_DICT_KEY,strlen(BT_FAILURE_REASON_DICT_KEY),NULL);
    if (startevbp.pos != -1)
    {
	char *valuebytes = NULL;
	std::string errorstr;
	int ret = ParseBencodedValue(evb,startevbp,BT_FAILURE_REASON_DICT_KEY,BENCODED_STRING,&valuebytes);
	if (ret < 0)
	{
	    errorstr = "Error parsing tracker response: failure reason";
	}
	else
	{
	    errorstr = "Tracker responded: "+std::string(valuebytes);
	}
	callbackrec->callback_(callbackrec->td_,errorstr,0,peeraddrs_t());
	delete callbackrec;

	evbuffer_free(evb);
	delete copybuf;
	free(valuebytes);
	return; // failure case done
    }
    evbuffer_free(evb);

    // If not failure, find tracker report interval
    uint32_t interval=0;

    evb = evbuffer_new();
    evbuffer_add(evb,copybuf,copybuflen);
    startevbp = evbuffer_search(evb,BT_INTERVAL_DICT_KEY,strlen(BT_INTERVAL_DICT_KEY),NULL);
    if (startevbp.pos != -1)
    {
	char *valuebytes = NULL;
	std::string errorstr="";
	int ret = ParseBencodedValue(evb,startevbp,BT_INTERVAL_DICT_KEY,BENCODED_INT,&valuebytes);
	if (ret < 0)
	{
	    delete copybuf;
	    evbuffer_free(evb);

	    callbackrec->callback_(callbackrec->td_,"Error parsing tracker response: interval",0,peeraddrs_t());
	    delete callbackrec;
	    return;
	}
	else
	{
	    ret = sscanf(valuebytes,"%" PRIu32 "",&interval);
	    if (ret != 1)
	    {
		free(valuebytes);
		delete copybuf;
		evbuffer_free(evb);

		callbackrec->callback_(callbackrec->td_,"Error parsing tracker response: interval",0,peeraddrs_t());
		delete callbackrec;
		return;
	    }

	    free(valuebytes);
	    if (exttrack_debug)
		fprintf(stderr,"exttrack: Got interval %" PRIu32 "\n", interval);
	}
    }
    evbuffer_free(evb);


    // If not failure, find peers key whose value is compact IPv4 addresses
    // http://www.bittorrent.org/beps/bep_0023.html
    peeraddrs_t	peerlist;

    evb = evbuffer_new();
    evbuffer_add(evb,copybuf,copybuflen);
    ret = ParseBencodedPeers(evb, BT_PEERS_IPv4_DICT_KEY,&peerlist);
    if (ret < 0)
    {
	delete copybuf;
	evbuffer_free(evb);

	callbackrec->callback_(callbackrec->td_,"Error parsing tracker response: peerlist",interval,peeraddrs_t());
	delete callbackrec;
	return;
    }
    evbuffer_free(evb);

    if (exttrack_debug)
	fprintf(stderr,"btrack: Got " PRISIZET " IPv4 peers\n", peerlist.size() );

    // If not failure, find peers key whose value is compact IPv6 addresses
    // http://www.bittorrent.org/beps/bep_0007.html
    evb = evbuffer_new();
    evbuffer_add(evb,copybuf,copybuflen);
    ret = ParseBencodedPeers(evb, BT_PEERS_IPv6_DICT_KEY,&peerlist);
    if (ret < 0)
    {
	delete copybuf;
	evbuffer_free(evb);

	callbackrec->callback_(callbackrec->td_,"Error parsing tracker response: peerlist",interval,peeraddrs_t());
	delete callbackrec;
	return;
    }
    evbuffer_free(evb);

    if (exttrack_debug)
	fprintf(stderr,"btrack: Got " PRISIZET " peers total\n", peerlist.size() );

    // Report success
    callbackrec->callback_(callbackrec->td_,"",interval,peerlist);

    delete copybuf;
    delete callbackrec;
}


int ExternalTrackerClient::HTTPConnect(std::string query,ExtTrackCallbackRecord *callbackrec)
{
    std::string fullurl = url_+"?"+query;

    if (exttrack_debug)
	fprintf(stderr,"exttrack: HTTPConnect: %s\n", fullurl.c_str() );

    struct evhttp_uri *evu = evhttp_uri_parse(fullurl.c_str());
    if (evu == NULL)
	return -1;

    int fullpathlen = strlen(evhttp_uri_get_path(evu))+strlen("?")+strlen(evhttp_uri_get_query(evu));
    char *fullpath = new char[fullpathlen+1];
    strcpy(fullpath,evhttp_uri_get_path(evu));
    strcat(fullpath,"?");
    strcat(fullpath,evhttp_uri_get_query(evu));

    //fprintf(stderr,"exttrack: HTTPConnect: Composed fullpath %s\n", fullpath );

    // Create HTTP client
    struct evhttp_connection *cn = evhttp_connection_base_new(Channel::evbase, NULL, evhttp_uri_get_host(evu), evhttp_uri_get_port(evu) );
    struct evhttp_request *req = evhttp_request_new(ExternalTrackerClientHTTPResponseCallback, (void *)callbackrec);

    // Make request to server
    evhttp_make_request(cn, req, EVHTTP_REQ_GET, fullpath);
    evhttp_add_header(req->output_headers, "Host", evhttp_uri_get_host(evu));

    delete fullpath;
    evhttp_uri_free(evu);

    return 0;
}


static int ParseBencodedPeers(struct evbuffer *evb, std::string key, peeraddrs_t *peerlist)
{
    struct evbuffer_ptr startevbp = evbuffer_search(evb,key.c_str(),key.length(),NULL);
    if (startevbp.pos != -1)
    {
	char *valuebytes = NULL;
	std::string errorstr;
	int ret = ParseBencodedValue(evb,startevbp,key,BENCODED_STRING,&valuebytes);
	if (ret < 0)
	    return -1;

	int peerlistenclen = ret;
	//fprintf(stderr,"exttrack: Peerlist encoded len %d\n", peerlistenclen );

	// Decompact addresses
	struct evbuffer *evb2 = evbuffer_new();
	evbuffer_add(evb2,valuebytes,peerlistenclen);


	int family=AF_INET;
	int enclen=6;
	if (key == BT_PEERS_IPv6_DICT_KEY)
	{
	    family = AF_INET6;
	    enclen = 18;
	}
	for (int i=0; i<peerlistenclen/enclen; i++)
	{
	    // Careful: if PPSPP on the wire encoding changes, we can't use
	    // this one anymore.
	    Address addr = evbuffer_remove_pexaddr(evb2,family);
	    peerlist->push_back(addr);

	    if (exttrack_debug)
		fprintf(stderr,"exttrack: Peerlist parsed %d %s\n", i, addr.str().c_str() );
	}
	evbuffer_free(evb2);

	return 0;
    }
    else
	return 0; // Could be attempt to look for IPv6 peers in IPv4 only dict.
}


/** Failure reported, extract string from bencoded dictionary */
static int ParseBencodedValue(struct evbuffer *evb, struct evbuffer_ptr &startevbp, std::string key, bencoded_type_t valuetype, char **valueptr)
{
    //fprintf(stderr,"exttrack: Callback: key %s starts at " PRISIZET "\n", key.c_str(), startevbp.pos );

    size_t pastkeypos = startevbp.pos+key.length();
    if (valuetype == BENCODED_INT)
	pastkeypos++; // skip 'i'

    //fprintf(stderr,"exttrack: Callback: key ends at " PRISIZET "\n", pastkeypos );

    int ret = evbuffer_ptr_set(evb, &startevbp, pastkeypos, EVBUFFER_PTR_SET);
    if (ret < 0)
	return -1;

    std::string separator = BT_BENCODE_STRING_SEP;
    if (valuetype == BENCODED_INT)
	separator = BT_BENCODE_INT_SEP;

    // Find separator to determine string len
    struct evbuffer_ptr endevbp = evbuffer_search(evb,separator.c_str(),strlen(separator.c_str()),&startevbp);
    if (endevbp.pos == -1)
	return -1;

    //fprintf(stderr,"exttrack: Callback: separator at " PRISIZET " key len %d\n", endevbp.pos, key.length() );

    size_t intcstrlen = endevbp.pos - startevbp.pos;

    //fprintf(stderr,"exttrack: Callback: value length " PRISIZET "\n", intcstrlen );

    size_t strpos = endevbp.pos+1;

    //fprintf(stderr,"exttrack: Callback: value starts at " PRISIZET "\n", strpos );

    ret = evbuffer_ptr_set(evb, &startevbp, strpos, EVBUFFER_PTR_SET);
    if (ret < 0)
	return -1;

    // Remove all before
    ret = evbuffer_drain(evb,strpos-1-intcstrlen);
    if (ret < 0)
	return -1;

    char *intcstr = new char[intcstrlen+1];
    intcstr[intcstrlen] = '\0';
    ret = evbuffer_remove(evb,intcstr,intcstrlen);
    if (ret < 0)
    {
	delete intcstr;
	return -1;
    }


    //fprintf(stderr,"exttrack: Callback: Length value string %s\n", intcstr );

    if (valuetype == BENCODED_INT)
    {
	*valueptr = intcstr;
	return intcstrlen;
    }
    // For strings carry on

    int slen=0;
    ret = sscanf(intcstr,"%d", &slen);
    delete intcstr;
    if (ret != 1)
	return -1;

    //fprintf(stderr,"exttrack: Callback: Length value int %d\n", slen );

    // Drain colon
    ret = evbuffer_drain(evb,1);
    if (ret < 0)
	return -1;

    // NOTE: actual bytes may also contain '\0', C string is for convenience when it isn't pure binary.
    char *valuecstr = new char[slen+1];
    valuecstr[slen] = '\0';
    ret = evbuffer_remove(evb,valuecstr,slen);
    if (ret < 0)
    {
	delete valuecstr;
	return -1;
    }
    else
    {
	//fprintf(stderr,"exttrack: Callback: Value string <%s>\n", valuecstr );

	*valueptr = valuecstr;
	// do not delete valuecstr;
	return slen;
    }
}