/Src/Symphony/slurpie_client/context.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <time.h>

#include "utils.h"
#include "connection.h"
#include "rem_slurpied.h"
#include "protocol.h"
#include "context.h"
#include "downloads.h"
#include "version.h"

// Local prototypes. aka helper functions
static int parseSlurpieServer(context* c, const char* server_port);
static int contextParseURL(context* c, const char* url);
static int parseURLMD5SUM(context* c, const char* urlmd5sum);
static int generateDestination(context* c);

context* contextCreate()
{

	context* c;

	// Allocate the structure
	c = (context*) malloc(sizeof(context));
	if (c == NULL)
		return NULL;
	memset(c, 0, sizeof(context));

	// Set some default values
	c->maxNumOfDownloads = 10;
	c->maxUpdateTreeLeaves = 100;
	c->maxNumOfNeighbors = MAXNUMNEIGHBORS;
	c->desiredNumOfNeighbors = DEFAULTNUMNEIGHBORS;
	c->desiredNumOfUpdates=DEFAULT_UPDATES_PER_ROUND;
	c->neighborChoice=0;

	c->URL= NULL;

	// leech server stuff
	c->maxNumOfLeeches = 10;
	c->numOfLeechThreads = 10;
	c->useMTLeechServ = 0;

	// Initialize the Block break rule
	c->blockRule = 0;
	c->blockSize = 256*1024;			// by default, bs=256k
	c->blockingPriority = BLOCKSIZEPRIORITY;	// by default, we fix
	// the blocksize, and then calculate the number of blocks
	// as a function of the size, by default
	c->fileSize = -1;	// set later in init
	c->numberOfBlocks = -1;
	c->fd = 0;
	c->dlBitMap = NULL;
	c->dlq = NULL;
	c->ac = NULL;
	c->quiet = 0;		// not quiet by default
	c->downloadType=DOWNLOADTYPE_ADAPTIVE;	// download style
	c->phase2=0;
	c->magicTime=DEFAULT_MAGIC_TIME;
	c->pickTwo=0;
	c->randomSeed=-1;

	// Neighbor Manager: creation moved to contextJoin
	c->neighborMgr = NULL;

	// Hash stuff
	c->hashChecker = NULL;
	c->hash_enabled = 0;
	c->hash_maxRequestSize = DEFAULT_HASH_MAX_REQ_SIZE;

	c->backoffRule=BACKOFFRULE_GOOD;
	c->backoffBias=BACKOFFBIASDEFAULT;
	c->backOffCommitTime=DEFAULT_BACKOFF_TIME;
	c->backoffDidBackOff=0;

	c->peerBlocksDld=c-> sourceBlocksDld=0;

	// Update Tree
	// If you create something thing, don't forget to destroy
	// it at contextDestroy
	c->updateTree = updateTreeNew(c->maxUpdateTreeLeaves);
	c->updateThreadP=NULL;

	// Slurpie Server stuff
	c->slurpieServerAddress = (char*)(malloc(strlen(SLURPIED_DEFAULT_HOST)+1));
	strcpy(c->slurpieServerAddress, SLURPIED_DEFAULT_HOST);
	c->slurpieServerPort=SLURPIED_DEFAULT_PORT;

	c->localIp = getLocalHostIP();

	// Initialize the Synchronization Primitives
	c->lock = (boost::mutex*)malloc(sizeof(boost::mutex));
	c->flock = (boost::mutex*)malloc(sizeof(boost::mutex));

	// Default adaptive downloading parameters
	c->adl_maxBandwidth = DEFAULT_ADL_MAX_BANDWIDTH;;
	c->adl_timer =	DEFAULT_ADL_TIMER;
	c->adl_timer_inc =	DEFAULT_ADL_TIMER_INC;
	c->adl_maxConnections =	DEFAULT_ADL_MAX_CONNECTIONS;
	c->adl_bandwidth_inc =	DEFAULT_ADL_BANDWIDTH_INC;

	return c;
}

int contextParseParameters(context* c, int argc, char** argv)
{
	int i;
	// Lock the mutex

	c->lock->lock();
	for(i=1;i<argc;i++)
	{
		if(!strcmp(argv[i],"-q"))
		{
			c->quiet=1;
			continue;
		}
		if(!strcmp(argv[i],"-p"))
		{
			c->phase2=1;
			continue;
		}
		if((!strcmp(argv[i],"-s"))&&(i+1<argc))
		{
			i++;
			if(parseSlurpieServer(c,argv[i]))
				usage(argv[i],": bad server:port");
			continue;
		}
		if((!strcmp(argv[i],"-o"))&&(i+1<argc))
		{
			i++;
			c->destFileName = strdup(argv[i]);
			assert(c->destFileName!=NULL);
			continue;
		}
		if((!strcmp(argv[i],"-N"))&&(i+1<argc))
		{
			i++;
			c->maxNumOfNeighbors = atoi(argv[i]);
			assert(c->maxNumOfNeighbors>=0);
			continue;
		}
		if((!strcmp(argv[i],"-m"))&&(i+1<argc))
		{
			i++;
			c->magicTime = atoi(argv[i]);
			assert(c->magicTime>=0);
			continue;
		}
		if((!strcmp(argv[i],"-n"))&&(i+1<argc))
		{
			i++;
			c->numberOfBlocks = atoi(argv[i]);
			c->blockingPriority=NUMBLOCKSPRIORITY;
			assert(c->numberOfBlocks>=0);
			continue;
		}
		if((!strcmp(argv[i],"-b"))&&(i+1<argc))
		{
			i++;
			c->blockSize = atoi(argv[i]);
			c->blockingPriority=BLOCKSIZEPRIORITY;
			assert(c->blockSize>=0);
			continue;
		}
		if((!strcmp(argv[i],"-B"))&&(i+1<argc))
		{
			i++;
			c->backoffRule = atoi(argv[i]);
			continue;
		}
		if((!strcmp(argv[i],"-bt"))&&(i+1<argc))
		{
			i++;
			c->backoffTime = atoi(argv[i]);
			continue;
		}
		if((!strcmp(argv[i],"-bb"))&&(i+1<argc))
		{
			i++;
			c->backoffBias = atoi(argv[i]);
			continue;
		}
		if((!strcmp(argv[i],"-d"))&&(i+1<argc))
		{
			i++;
			DEBUGLEVEL = atoi(argv[i]);
			assert(DEBUGLEVEL>=0);
			continue;
		}
		if((!strcmp(argv[i],"-R"))&&(i+1<argc))
		{
			i++;
			c->randomSeed = atoi(argv[i]);
			continue;
		}
		if((!strcmp(argv[i],"-t"))&&(i+1<argc))
		{
			i++;
			c->maxNumOfDownloads = atoi(argv[i]);
			assert(c->maxNumOfDownloads>=0);
			continue;
		}
		if(!strncmp(argv[i],"ftp://",strlen("ftp://")))
		{
			if(contextParseURL(c,argv[i]))
				usage(argv[i],": bad URL");
			continue;
		}
		if(!strncmp(argv[i],"http://",strlen("http://")))
		{
			if(contextParseURL(c,argv[i]))
				usage(argv[i],": bad URL");
			continue;
		}
		if(!strcmp(argv[i],"-a"))
		{
			c->downloadType=DOWNLOADTYPE_ADAPTIVE;
			continue;
		}
		if(!strcmp(argv[i],"-at"))
		{
			i++;
			c->adl_timer=atoi(argv[i]);
			assert(c->adl_timer>=0);
			continue;
		}
		if(!strcmp(argv[i], "-P")) 
		{
			c->pickTwo = 0;
			continue;
		}
		if(!strcmp(argv[i], "-L"))
		{
			c->neighborChoice = 1;
			continue;
		}
		if(!strcmp(argv[i], "-l"))
		{
			c->useMTLeechServ = 1;
			continue;
		}
		if(!strcmp(argv[i], "-S"))
		{
			c->hash_enabled = 1;
			continue;
		}
		if(!strcmp(argv[i], "-Ssize")) 
		{
			// The value specified is in kilobytes, but store it in bytes for
			// easy comparison later
			i++;
			c->hash_maxRequestSize = 1024 * atoi(argv[i]);
			assert(c->hash_maxRequestSize > 0);
			continue;
		}
		usage(argv[i],": unknown argument");
	}

	c->lock->unlock();
	return 0;
}

void usage(char *s1, char *s2)
{
	if(s1)
		fprintf(stderr,"%s ",s1);
	if(s2)
		fprintf(stderr,"%s ",s2);
	if(s1||s2)
		fprintf(stderr,"\n");


	fprintf(stderr,"Slurpie Client v%d.%d\n"
		"Usage:\n"
		"slurpie [options] <http://...|ftp://...>\n"
		"Options:\n"
		"\t-a                 - turns on adaptive downloads\n"
		"\t-s host[:port]     - set slurpie server\n"
		"\t-t nThreads        - number of concurrent downloads\n"
		"\t-o outfile         - alternative name for outfile\n"
		"\t-b blocksize       - sets the size of the blocks\n"
		"\t-B rule       	- sets the backoff rule [off]\n"
		"\t-bt secs		- time in secs to backoff [%d]\n"
		"\t-bb k		- goto the source with P(k/n) [%d]\n"
		"\t-m secs		- the time to wait after downloads[%d]\n"
		"\t-n numberofblocks  - sets the number of blocks (overrides blocksize)\n"
		"\t-N numofneighbors  - sets the number of neighbors[%d]\n"
		"\t-l                 - use old (multithreaded) threaded leech sever\n"
		"\t-L                 - sets neighbors to O(ln(n))\n"
		"\t-p			- disable phase1 of downloads\n"
		"\t-P			- pick best block of 2\n"
		"\t-q                 - turns off all screen output\n"
		"\t-R seed		- seed the PRNG with 'seed' \n"
		"\t-d level           - sets the debug level[%d]\n"
		"\t-S                 - turns on secure mode (blocks verified)\n"
		"\t-------------- Adaptive Download Options -------------\n"
		"\t-at secs           - initial timer value [%d] \n"
		"\t----------------- Secure Mode Options ----------------\n"
		"\t-Ssize kbytes      - sets the maximum size of a hash request [1024]\n",
		SLURPIE_VERSION.major,
		SLURPIE_VERSION.minor,
		DEFAULT_BACKOFF_TIME,
		BACKOFFBIASDEFAULT,
		DEFAULT_MAGIC_TIME,
		DEFAULTNUMNEIGHBORS,
		DEFAULTDEBUGLEVEL,
		DEFAULT_ADL_TIMER
		);
	exit(1);
}

void contextDestroy(context* c) 
{
	Dprintf("contextDestroy ENTERED\n");
	// Free The user parameters
	if (c->slurpieServerAddress) free(c->slurpieServerAddress);
	if (c->URL) free(c->URL);
	if (c->URLMD5SUM) free(c->URLMD5SUM);
	if (c->destFileName) free(c->destFileName);

	// Destroy the NeighborManager
	if(c->neighborMgr)
		neighborManagerDestroy(c->neighborMgr);

	// Destroy the Sync Primitives
	delete c->lock;
	c->lock = NULL;

	// take out the updateTree
	c->updateThreadP->detach();

	if(c->updateTree)
		updateTreeFree(c->updateTree);

	close(c->fd);

	Dprintf("contextDestroy EXIT\n");
}

int contextJoin(context* c)
{
	int rv = 0;
	char addr[30];
	connection_t* server;
	order_cmd* order;
	get_drinkers_cmd* get_drinkers;

	c->lock->lock();

	// moved from contextCreate: Rob
	c->neighborMgr= neighborManagerCreate((struct context *)c);

	server = connection_create(PROTO_SLURPIED, SLURPIE_VERSION);
	order = order_create(c->URL, neighborManagerGetAddr(c->neighborMgr, addr, 30), neighborManagerGetPort(c->neighborMgr));
	get_drinkers = get_drinkers_create(c->URL, c->neighborMgr->maxNumOfNeighbors);

	rv = server == NULL;
	rv = (rv) ? rv : connection_connect(server, c->slurpieServerAddress, c->slurpieServerPort);
	rv = (rv) ? rv : rem_slurpied_get_drinkers(server, &get_drinkers);
	rv = (rv) ? rv : rem_slurpied_order(server, order);

	if (server)
		connection_destroy(server);

	if (order) 
		order_destroy(&order);

	if (get_drinkers) 
	{
		int i;
		if (rv == 0)
		{
			if((get_drinkers->num_ip_ports)&&(!c->quiet))
				printf("Neighbors:");

			for (i = 0; i < get_drinkers->num_ip_ports; i++) 
			{
				char ipPortBuf[IP_PORT_BUF_LEN];
				if(!c->quiet) printf(" %s", ip_port_to_string(get_drinkers->ip_ports[i], ipPortBuf, IP_PORT_BUF_LEN));
				neighborManagerConnectToPeer(c->neighborMgr, get_drinkers->ip_ports[i]->ip, get_drinkers->ip_ports[i]->port);
			}

			if ((get_drinkers->num_ip_ports)&&(!c->quiet))
				printf("\n");
		}

		get_drinkers_destroy(&get_drinkers);
	}
	c->lock->unlock();
	return rv;
}


/* int contextFileOpen(context *c);
* 	opens the dst file in the dst dir
*/

int contextFileOpen(context *c)
{
	char buf[BUFLEN];
	int fd;

	sprintf_s(buf,BUFLEN,"%s",c->destFileName);
	fd= open(buf,O_RDWR|O_CREAT|O_TRUNC,0644);
	c->fd=fd;
	if(fd == -1){
		perror("contextFileOpen:open");
		abort();
	}
	return fd;
}

/* char *contextParseFileName(context *c)
* 	sldkfslk
*/

char * contextParseFileName(context *c)
{
	char * tmp;
	if(c->destFileName)	// already set on command line
		return c->destFileName;	
	tmp = rindex(c->URL,'/');
	tmp++;
	c->destFileName = strdup(tmp);
	return c->destFileName;
}


void do_context_tests()
{
	context* c = contextCreate();

	// parseSlurpieServer test
	{
		const char* serverPort[] =
		{ 
			"envy.sodre.cx", 
			"lust.sodre.cx:", 
			"sloth.sodre.cx:33456",
			":33457", 
			":", 
			NULL
		};
		const char* expectedAddress[] = 
		{
			"envy.sodre.cx",
			"lust.sodre.cx",
			"sloth.sodre.cx",
			SLURPIED_DEFAULT_HOST,
			SLURPIED_DEFAULT_HOST,
			NULL
		};
		const int expectedPort[] = 
		{
			SLURPIED_DEFAULT_PORT,
			SLURPIED_DEFAULT_PORT,
			33456,
			33457,
			SLURPIED_DEFAULT_PORT,
			-1
		};
		const char** sp = serverPort;
		const char** ea = expectedAddress;
		const int* ep = expectedPort;
		for(; *sp != NULL; sp++, ea++, ep++) 
		{
			assert(parseSlurpieServer(c, *sp) == 0);
			assert(strcmp(c->slurpieServerAddress, *ea) == 0);
			assert(c->slurpieServerPort == *ep);
			printf("%s -> %s:%d OK\n", *sp, *ea, *ep);
			free(c->slurpieServerAddress);
		}

		assert(parseSlurpieServer(c, *(--sp)) == 0);
	}

	// Test the contextParseURL
	{
		const char* url = "ftp://ftp2.it.debian.org/debian-cd/3.0_r0/i386/debian-30r0-i386-1_NONUS.iso";
		assert(contextParseURL(c, url) == 0);
		assert(strcmp(c->URL, url) == 0);
		printf("%s == %s OK\n", url, c->URL);
	}

	// Test the parseURLMD5SUM
	{
		const char* url = "ftp://ftp2.it.debian.org/debian-cd/3.0_r0/i386/MD5SUMS";
		assert(parseURLMD5SUM(c, url) == 0);
		assert(strcmp(c->URLMD5SUM, url) == 0);
		printf("%s == %s OK\n", url, c->URLMD5SUM);
	}

	// Test the generateDestinationFilename
	{
		const char* destFN = "debian-30r0-i386-1_NONUS.iso";
		assert(generateDestination(c) == 0);
		assert(strcmp(c->destFileName, destFN) == 0);
		printf("%s == %s OK\n", c->destFileName, destFN);
	}

	contextDestroy(c);
	return;
}

// Local Prototypes. aka helper functions {{{2
static int parseSlurpieServer(context* c, const char* server_port)
{
	int rv=0;
	int i=0;
	// Find a ':'
	while(i < strlen(server_port) && server_port[i] != ':')
		i++;

	// Copy the serverName
	if (i == 0) {
		const char* defaultServer = SLURPIED_DEFAULT_HOST;
		free(c->slurpieServerAddress);
		c->slurpieServerAddress = (char*)(malloc(strlen(defaultServer)+1));
		strcpy(c->slurpieServerAddress, defaultServer);
	}
	else {
		c->slurpieServerAddress = (char*)(malloc(i+1));
		strncpy(c->slurpieServerAddress, server_port, i);
		c->slurpieServerAddress[i] = '\0';
	}
	// Get the Port
	if ((i+1) >= strlen(server_port)) 
		c->slurpieServerPort = SLURPIED_DEFAULT_PORT;
	else {
		char* endPtr;
		c->slurpieServerPort = strtoul(&server_port[i+1], &endPtr, 10);
		if (*endPtr != '\0') {
			printf("contextParseSlurpieServer error: Invalid <[server]:[port]> %s\n", server_port);
			rv = -1;
		}
	}

	return rv;
}

static int contextParseURL(context* c, const char* url) 
{
	int rv = 0;
	// ftp://ftp2.it.debian.org/debian-cd/3.0_r0/i386/debian-30r0-i386-1_NONUS.iso;
	c->URL = (char*)malloc(strlen(url)+1);
	if (c->URL) 
		strcpy(c->URL, url);
	else 
		rv = -1;
	return rv;
}

static int parseURLMD5SUM(context* c, const char* url)
{
	// ftp://ftp2.it.debian.org/debian-cd/3.0_r0/i386/MD5SUMS;
	int rv = 0;
	c->URLMD5SUM = (char*)malloc(strlen(url)+1);
	if (c->URLMD5SUM)
		strcpy(c->URLMD5SUM, url);
	else
		rv = -1;
	return rv;
}

static int generateDestination(context* c)
{
	int rv = 0;
	// Default value was 
	// debian-30r0-i386-1_NONUS.iso;
	int i = strlen(c->URL);

	// Look for the url separator '/'
	do
	{
		i--;
	} while(i > 0 && c->URL[i] != '/');

	// copy the filename
	if (i > 0) 
	{
		const char* destFN = &c->URL[i+1];
		c->destFileName = (char*)malloc(strlen(destFN)+1);
		if (c->destFileName) 
			strcpy(c->destFileName, destFN);
		else 
			rv = -1;
	}
	else 
		rv = -1;
	return rv;
}

// 2}}}