EmuProxyZA / emuProxyZA.c

From TivoZA

Back to emuProxyZA.
Download source (You will need to rename it to: emuProxyZA.c)

To update the below source file, select Upload file and upload your new emuProxyZA.c file (there is no need to upload it as a .txt). If you do upload a new version, please add a brief description to the change log at the bottom of this page indicating what changes you made and why.

[edit]

Source

  1. /*
  3. emuProxyZA is based on emuProxy2 (by Tim Kleingeld) and the tivodns
  4. library (by Christopher R. Wingert). The reason for the name change is
  5. I have made significant changes to emuProxy2. emuProxy2 (and emuProxy3)
  6. does not correctly send through the requests as it relies on their being
  7. a Content-length field which is only present in the mlog.cgi request,
  8. this has now been fixed as well as a couple of major features added as
  9. listed below.
  11. Features:
  12.  * Use DNS addresses as well as static IP addresses
  13.  * Allows limiting the number of guide days to download, nice for those
  14.    on dial-up (only possible if your provider/emulator supports it). The
  15.    TivoZA emulator supplies 30 days of guide data by default which even
  16.    gzipped can be 2MB for the full download.
  17.  * Fix mlog.cgi request, mlog.cgi requests previously failed when the
  18.    svclog was too large (this also prevented guide downloads being available
  19.    for long periods, such as a month)
  20.  * Fix Series 1 LocationID problem (i.e. how to use shorter LocationID's)
  21.  * Accessing the server/emulator through transparent proxies (part of emuProxy2)
  22.  * HTTP header fix (added in emuProxy3 by Warren Toomey)
  23.  * Allow full traces of the requests sent and the responses received, great
  24.    for debugging
  26. This program is distributed in the hope that it will be useful,
  27. but WITHOUT ANY WARRANTY; without even the implied warranty of
  28. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  30. For the latest version and more information please see:
  31.   http://tivoza.nanfo.com
  33. Enjoy, regards
  34. TivoZA
  36. */
  37.  
  38. #include <stdio.h>
  39. #include <time.h>
  40. #include <sys/types.h>
  41. #include <sys/socket.h>
  42. #include <netinet/in.h>
  43. #include <sys/signal.h>
  44. #include <sys/errno.h>
  45. #include <string.h>
  46. #include "tivodns.h"
  47. #include "base64.c"
  48. #include <fcntl.h>
  49.  
  50. #ifdef TIVO
  51. # include "bootpage.c"
  52. # include "mfs-utils/mfs.h"
  53. #endif
  54.  
  55.  
  56. #define VERSION 		"4.1.40"
  57.  
  58. #define BUFFER_SIZE 	1024
  59. #define RESOLVCONF_FILE	"/etc/resolv.conf"
  60. #define PORT 			8000
  61. #define SERVERIP 		"204.176.49.2"
  62. #define SERVERPORT 		80
  63. #define NTPIP	 		"132.163.4.102" //"204.176.49.2"
  64. #define NTPPORT 		37
  65. #define LISTENTO 		"0.0.0.0"   // Useful for testing
  66. //#define LISTENTO 		"127.0.0.1" // Potentially more secure
  67. #define DEBUGPATH 		"/tmp/"
  68. #define CONFIG_FILE 	"/hack/etc/emuProxyZA.conf"
  69.  
  70. static char * argv_init[8+2];// = { NULL, };
  71. static char * envp_init[8+2];// = { NULL, };
  72.  
  73. char *emuconf 	 = CONFIG_FILE;
  74. char *resolvconf = RESOLVCONF_FILE;
  75. int localport 	 = PORT;
  76. char *serverip 	 = SERVERIP;
  77. int serverport 	 = SERVERPORT;
  78. char *ntpip;
  79. char *listento	 = LISTENTO;
  80. char *proxyip;
  81. char *proxyport;
  82. char *proxyAuth = NULL;
  83. char myHeaders[BUFFER_SIZE];
  84. char outBuffer[BUFFER_SIZE] = "";
  85. char debugClientPath[100] = DEBUGPATH;
  86. char debugServerPath[100] = DEBUGPATH;
  87. int debugClient;
  88. int debugServer;
  89. int debug;
  90. int outBufferLength = 0;
  91. int inited = 0;
  92. int gotAlarm;
  93. int count = 0;
  94. int rawSend = 0;
  95. int onScreenDisplay = 0;
  96. int tcInfo = 0;
  97. int timeOffset = 0;
  98. int forceUpdate = 2;
  99. int guideDays = 0;
  100. char *weekDays	 = "";
  101. int urlbase = 0;
  102. char locationID[50] = "";
  103. time_t timeWeekdayOverride = 0;
  104. int bGuidedSetup = -1;
  105. int altNTP = 0;
  106.  
  107. //Having flags to check if the following has been completed will save string comparison time
  108. int fixMlog;
  109. int fixHServer;
  110. int bodylength;
  111. int post;
  112. int addedHeaders;
  113. int headerComplete;
  114. int contentStarted;
  115. int totalRead;
  116.  
  117. /****************************************************************************************/
  118. void alarmHandler() {
  119. 	gotAlarm = 1;
  120. }
  121.  
  122. /****************************************************************************************/
  123. char *ltrim(char *buffer)
  124. {
  125. 	char *cp = buffer;
  126.  
  127. 	if (cp && *cp)
  128. 	{
  129. 		// find first non-whitespace character
  130. 		//while (_istspace(*cp))
  131. 		while (cp[0] == ' ')
  132. 			cp++;
  133.  
  134. 		if (cp != buffer)
  135. 			memcpy(buffer, cp, (strlen(cp)+1)*sizeof(char));
  136. 	}
  137.  
  138. 	return buffer;
  139. }
  140.  
  141. /****************************************************************************************/
  142. char *rtrim(char *buffer)
  143. {
  144. 	char *cp = buffer;
  145.  
  146. 	if (cp && *cp)
  147. 	{
  148. 		int bNonSpaceSeen = 0;
  149.  
  150. 		// check if string is blank
  151. 		while (*cp)
  152. 		{
  153. 			if (!(cp[0] == ' '))
  154. 				bNonSpaceSeen = 1;
  155. 			cp++;
  156. 		}
  157.  
  158. 		if (bNonSpaceSeen)
  159. 		{
  160. 			cp--;
  161.  
  162. 			// find last non-whitespace character
  163. 			while ( (cp >= buffer) && (cp[0] == ' ') )
  164. 				*cp-- = 0; //_T('\0');
  165. 		}
  166. 		else
  167. 		{
  168. 			// string contains only whitespace characters
  169. 			*buffer = 0; //_T('\0');
  170. 		}
  171. 	}
  172.  
  173. 	return buffer;
  174. }
  175.  
  176. /****************************************************************************************/
  177. char *trim(char *buffer)
  178. {
  179. 	return ltrim(rtrim(buffer));
  180. }
  181.  
  182. /****************************************************************************************/
  183. char *substr(const char* buffer, int count) {
  184. 	char *outS = strdup(buffer);
  185. 	outS[count] = 0;
  186. 	return outS;
  187. }
  188.  
  189. /****************************************************************************************/
  190. int chrpos(const char* buffer, const char find) {
  191. 	char *pos = strchr(buffer, find);
  192. 	if (pos == NULL)
  193. 		return -1;
  194. 	else
  195. 		return pos  - buffer;
  196. }
  197.  
  198. /****************************************************************************************/
  199. int strpos(const char* buffer, const char* find) {
  200. 	char *pos = strstr(buffer, find);
  201. 	if (pos == NULL)
  202. 		return -1;
  203. 	else
  204. 		return pos  - buffer;
  205. }
  206.  
  207. /****************************************************************************************/
  208. unsigned long getIPAddress(const char* serverAddr) {
  209. 	struct in4_addr *ipAddr;
  210. 	int fd;
  211. 	int b;
  212.  
  213. 	/* Convert a DNS address to an IP address */
  214. 	if ( sscanf( serverAddr , "%d.%d.%d.%d", &b, &b, &b, &b ) != 4 ) {
  215. 		 if (debug == 2) fprintf(stderr, "DNS address detected (%s), attempting to resolve to an IP address\n", serverAddr);
  216.  
  217. 		/* Load resolv.conf to enable DNS lookups*/
  218. 		if (inited == 0) {
  219.       		fd = open( resolvconf, O_RDONLY );
  220. 	      	if ( fd < 0 ) {
  221. 				perror( "Failed to open resolv.conf" );
  222. 				return INADDR_NONE;
  223. 			}
  224. 	      	close(fd);
  225.       		tivodns_init(resolvconf);
  226. 			inited = 1;
  227. 		}
  228.  
  229. 		/* Convert the DNS address to an IP address */
  230. 	 	ipAddr = tivodns_resolveip4(serverAddr);
  231. 	 	if (!ipAddr) {
  232. 			perror("Failed to find server IP for given DNS!\n");
  233. 			return INADDR_NONE;
  234. 		}
  235.   		serverAddr = tivodns_ntoa4(ipAddr);
  236. 	} else if (debug == 2) fprintf(stderr, "IP address detected (%s), no DNS resolution required\n", serverAddr);
  237.  
  238. 	return inet_addr(serverAddr); /* Fill in the server address */
  239. }
  240.  
  241. /****************************************************************************************/
  242. void outSocket(int socket, char buffer[BUFFER_SIZE], int length, FILE *ofile) {
  243. 	//A similar function should be created for client out as this function relies on the specific
  244. 	//debugServer, outBufferLength & outBuffer variables
  245. 	if ((outBufferLength > 0) && ((length == -1) || (outBufferLength + length > BUFFER_SIZE)) ) {
  246. 		write(socket, outBuffer, outBufferLength);
  247. 		if (ofile)
  248. 			fwrite(outBuffer, outBufferLength, 1, ofile);
  249.  
  250. 		outBufferLength = 0;
  251. 	}
  252.  
  253. 	if (length > 0) {
  254. 		memcpy(outBuffer + outBufferLength, buffer, length);
  255. 		outBufferLength += length;
  256. 	}
  257.  
  258. 	/*if (length != -1) {
  259. 		write(socket, buffer, length);
  260. 		if (debugServer)
  261. 			fwrite(buffer, length, 1, ofile);
  262. 	} */
  263. }
  264.  
  265. /****************************************************************************************/
  266. void fixLocationID(int server, char buffer[BUFFER_SIZE], int length, FILE *ofile) {
  267. 	char newLocationID[100] = "IDB_LOCATIONID: ";
  268. 	char locID[50] = "";
  269. 	char *pos;
  270. 	char *posEnd;
  271. 	int onlySatellite = 0;
  272.  
  273. 	#ifdef TIVO
  274. 	//Load the current value stored in the MFS and replace it if necessary
  275. 	strcpy(locID, mfs_attr_get_str("/State/LocationConfig", "PostalCode"));
  276. 	if ( (strcmp(locationID, "0")) && (strcmp(locationID, locID)) ) {
  277. 		if (debug == 2) fprintf(stderr, "Update PostalCode to: %s\n", locationID);
  278. 		mfs_attr_set("/State/LocationConfig", "PostalCode", locationID);
  279. 	}
  280. 	#endif
  281.  
  282. 	pos = strchr(buffer, ':') + 2;
  283. 	onlySatellite = !strncmp(pos, "DBS", 3);
  284. 	if (!strcmp(locationID, "0")) { //Only determine the locationID if a fixed one was not specified
  285. 		if (onlySatellite) {
  286. 			fprintf(stderr,"EmuProxyZA Error: When only receiving satellite data you need to supply a LocationID, run emuProxyZA -h for more help!\n");
  287. 			exit(1);
  288. 		}
  289. 		strncpy(locID, pos, strchr(buffer, '-') - pos);
  290. 	} else
  291. 		strcpy(locID, locationID);
  292.  
  293. 	if (debug == 2) fprintf(stderr, "LocationID: %s\n", locID);
  294.  
  295. 	posEnd = strchr(pos, '~');
  296. 	if (onlySatellite) {
  297. 		//Handle just Satellite postal codes
  298. 		if (posEnd != NULL) {
  299. 			strncat(newLocationID, pos, posEnd - pos + 1);
  300. 			strncat(newLocationID, locID, 3);
  301. 			pos = strchr(pos, '-');
  302. 		}
  303. 	} else {
  304. 		//Handle Cable & Satellite postal codes
  305. 		strncat(newLocationID, locID, 4);
  306.  
  307. 		pos = strchr(pos, '-');
  308. 		if (posEnd != NULL) {
  309. 			//Handle Satellite part of request
  310. 			strncat(newLocationID, pos, posEnd - pos + 1);
  311. 			strncat(newLocationID, locID, 3);
  312. 			pos = strchr(pos + 1, '-');
  313. 		}
  314. 	}
  315.  
  316. 	posEnd = strchr(pos, '\n');
  317. 	strncat(newLocationID, pos, posEnd - pos);
  318. 	strcat(newLocationID, "\n");
  319.  
  320. 	outSocket(server, newLocationID, strlen(newLocationID), ofile);
  321. 	if (debug == 2) fprintf(stderr, "Location ID changed to: %s", newLocationID);
  322. }
  323.  
  324. /****************************************************************************************/
  325. void fixTcInfo(int server, char buffer[BUFFER_SIZE], int length, FILE *ofile) {
  326. //Only the ip address and port numbers will be changed the rest will remain as is
  327.  
  328. 	char newTcInfo[100];
  329. 	char *pos;
  330. 	char *posEnd;
  331.  
  332. 	sprintf(newTcInfo, "%s:%d", serverip, serverport);
  333. 	pos = strchr(buffer, ':') + 1; //Find the end of the IDB_TCINFO field
  334.  
  335. 	pos = strchr(pos, ':') + 1; //Find the second colon just before the ip address is passed
  336. 	outSocket(server, buffer, pos - buffer, ofile);
  337.  
  338. 	outSocket(server, newTcInfo, strlen(newTcInfo), ofile);
  339.  
  340. 	pos = strchr(pos, ':'); //Find the colon between the ip adrress and port number
  341. 	pos = strchr(pos + 1, ':'); //Find the colon after port number
  342. 	posEnd = strchr(pos, '\n'); //Find the end of the line
  343.  
  344. 	//Output the remiander of the IDB_TCINFO field
  345. 	outSocket(server, pos, posEnd - pos + 1, ofile);
  346.  
  347. 	if (debug == 2) fprintf(stderr, "IDB_TCINFO has been corrected");
  348. }
  349.  
  350. /****************************************************************************************/
  351. char *extractFileName(const char* buffer) {
  352. 	char *fileName = NULL;
  353.  
  354. 	fileName = strchr(buffer, ' ') + 1;
  355. 	fileName = substr(fileName, strpos(fileName, " "));
  356. 	fileName = strrchr(fileName, '/') + 1;
  357.  
  358. 	if (debug == 2) fprintf(stderr, "\nFileName: %s\n", fileName);
  359.  
  360. 	return fileName;
  361. }
  362.  
  363. /****************************************************************************************/
  364. int GuidedSetup() {
  365. 	if (bGuidedSetup < 0) {
  366.  
  367. 		//Check if TiVo is in Guided Setup mode
  368. 		#ifdef TIVO
  369. 		char *bootpg = bootpage("/dev/hda");
  370. 		bGuidedSetup = (bootpg != NULL) && (strstr(bootpg, "GS=1") != NULL); //Check if in Maintenance Mode
  371.  
  372. 		if (!bGuidedSetup)
  373. 			bGuidedSetup = mfs_attr_get_int("/State/GeneralConfig", "Complete") != 7; //Check if Guided Setup has been completed
  374. 		#endif
  375.  
  376. 		if (debug) fprintf(stderr, "Guided Setup: %d\n", bGuidedSetup);
  377. 	}
  378.  
  379. 	return bGuidedSetup;
  380. }
  381.  
  382. /****************************************************************************************/
  383. int GuideDataTo() {
  384. 	u32 fsid, count, i, ver, idx, sliceID;
  385. 	u32 maxVer = 0;
  386. 	char name[20];
  387. 	int arrOffset = time(NULL)  / 86400 - 10; //Allows days in array to be populated from today - 10, no find required
  388. 	int days[100];
  389.  
  390. 	for(i=0; i < 100; i++)
  391. 		days[i] = 0;
  392.  
  393. 	fsid = mfs_fsid( "/Schedule" );
  394. 	if (fsid > 0) {
  395. 		struct mfs_dirent *dir = mfs_dir(fsid,&count);
  396. 		for(i=0; i < count; i++) {
  397. 			strcpy(name, strrchr(dir[i].name, ':') + 1);
  398. 			sliceID = atoi(name);
  399.  
  400. 			//Get date
  401. 			strcpy(name, strchr(dir[i].name, ':') + 1);
  402. 			strchr(name, ':')[0] = 0;
  403. 			idx = atoi(name) - arrOffset;
  404.  
  405. 			if (days[idx] != 1) {
  406. 				days[idx] = 1;
  407.  
  408. 				ver = query_int(sliceID, "ServerVersion");
  409. 				if (ver > maxVer)
  410. 					maxVer = ver;
  411.  
  412. 				//printf("%s: %d\n", name, ver);
  413. 			}
  414. 		}
  415. 		if (dir) mfs_dir_free(dir);
  416. 	}
  417.  
  418. 	return maxVer;
  419. }
  420.  
  421. /****************************************************************************************/
  422. void requestNTP(int server) {
  423. 	if (proxyip) {
  424. 		char strReq[100];
  425. 		FILE *ofile = NULL;
  426.  
  427. 		if (debug == 2) fprintf(stderr, "Performing NTP request via proxy.\n");
  428.  
  429. 		if (debugServer) {
  430. 			char filename[100];
  431. 			sprintf(filename, "%sep%dRequest.log", debugServerPath, count);
  432. 			ofile = fopen(filename, "w");
  433. 		}
  434.  
  435. 		sprintf(strReq, "GET http://%s:%d HTTP/1.0\r\n", ntpip, NTPPORT);
  436. 		outSocket(server, strReq, strlen(strReq), ofile);
  437.  
  438. 		if (proxyAuth) {
  439. 			char extraInfo[BUFFER_SIZE];
  440. 			sprintf(extraInfo, "Proxy-authorization: Basic %s\r\n", proxyAuth);
  441. 			outSocket(server, extraInfo, strlen(extraInfo), ofile);
  442. 		}
  443.  
  444. 		//Send end of request
  445. 		outSocket(server, "\r\n\r\n", 4, ofile);
  446.  
  447. 		outSocket(server, "", -1, ofile);
  448.  
  449.  
  450. 		if (debugServer)
  451. 			fclose(ofile);
  452. 	}
  453. }
  454.  
  455. /****************************************************************************************/
  456. void fixEpoch(int socket, char buffer[BUFFER_SIZE], int length, FILE *ofile) {
  457. 	int i;
  458. 	unsigned char val;
  459. 	unsigned long long int epoch = 0;
  460. 	unsigned long long int oldepoch = 0;
  461. 	char epochStr[10] = "";
  462. 	char currentStr[10];
  463.  
  464. 	if (debug == 2) fprintf(stderr, "\nNTP epoch time: %s\n", buffer);
  465.  
  466. 	for (i=0; i < length; i++) {
  467. 		val = buffer[i];
  468. 		epoch = epoch + val;
  469. 		if (i + 1 < length)
  470. 		  epoch = epoch << 8;
  471. 		fprintf(stderr, "loop %d: %c = %d\n", i, val, val);
  472. 	}
  473.  
  474. 	epoch = epoch + (timeOffset * 60); //timeOffset need to be in minutes
  475.  
  476. 	while (epoch > 0) {
  477. 		oldepoch = epoch;
  478. 		epoch = epoch >> 8;
  479. 		val = oldepoch - (epoch << 8);
  480.  
  481. 		strcpy(currentStr, epochStr);
  482. 		sprintf(epochStr, "%c%s", val, currentStr);
  483. 		fprintf(stderr, "loop time: %c = %d, %s\n", val, val, epochStr);
  484. 	}
  485.  
  486. 	fprintf(stderr, "\nnew time: %s\n", epochStr);
  487.  
  488. 	outSocket(socket, epochStr, strlen(epochStr), ofile);
  489. }
  490.  
  491. /****************************************************************************************/
  492. void checkRequest(int socket, char buf[BUFFER_SIZE], int length, FILE *ofile) {
  493. 	char buffer[BUFFER_SIZE];
  494. 	char *http10; /* Pointer to occurrence of "HTTP/1.0 CR" */
  495.  
  496. 	strncpy(buffer, buf, length);
  497. 	buffer[length] = 0;
  498.  
  499. 	if ( (bodylength < 0) && strncasecmp(buffer, "Content-length:", 15) == 0) {
  500. 		if (!fixMlog) {
  501. 			bodylength = atoi(buffer+15);
  502. 			outSocket(socket, buffer, length, ofile);
  503. 		}
  504. 	} else if (fixMlog && headerComplete && !rawSend) {
  505. 		//No mlog content will be sent to the socket
  506. 	} else if (fixHServer && !rawSend && (strncasecmp(buffer, "IDB_SWDESC:", 11) == 0)) {
  507. 		if (debug == 2) fprintf(stderr, "Line removed: IDB_SWDESC\n");
  508. 	} else if (fixHServer && strcmp(locationID, "") && (strncasecmp(buffer, "IDB_LOCATIONID:", 15) == 0)) {
  509. 		fixLocationID(socket, buffer, length, ofile);
  510. 	} else if (fixHServer && forceUpdate && (strncasecmp(buffer, "IDB_ST_HIST:", 12) == 0)) {
  511. 		char strHist[BUFFER_SIZE] = "IDB_ST_HIST:\n";
  512. 		//Write the histry field
  513. 		#ifdef TIVO
  514. 		if ( (forceUpdate == 2) && (!GuidedSetup()) ) {
  515. 			if (debug == 2) fprintf(stderr, "Replacing IDB_ST_HIST with correct GuideDataTo\n");
  516. 			strncpy(strHist, buffer, strrchr(buffer, ':') - buffer + 1);
  517. 			sprintf(strHist, "%s%d-1\n", strHist, GuideDataTo() );
  518. 		} else
  519. 		#endif
  520. 		if (debug == 2) fprintf(stderr, "Removing known slices from IDB_ST_HIST\n");
  521. 		outSocket(socket, strHist, strlen(strHist), ofile);
  522. 	} else if (fixHServer && tcInfo && (strncasecmp(buffer, "IDB_TCINFO:", 11) == 0)) {
  523. 		fixTcInfo(socket, buffer, length, ofile);
  524. 	} else if (!addedHeaders && strstr(buffer, "HTTP/1") != NULL) {
  525.  
  526.  
  527. 		if (onScreenDisplay) osd_write( extractFileName(buffer) );
  528.  
  529. 		post 		=  (!strncasecmp("POST", buffer, 4));
  530.  
  531. 		fixMlog		= ((strstr(buffer, "mlog.cgi") != NULL) && !rawSend);
  532. 		fixHServer 	= (strstr(buffer, "HServer.cgi") != NULL);
  533.  
  534. 		/*None of this first condition should be here, the problem is the mlog.cgi has param gzip
  535. 		which causes it to fail. When using a proxy to proxy the line get duplicated due to the
  536. 		way in which each line is sent one by one, so this should be fixed!!!! Should probably
  537. 		buffer the data and only send it when the TiVo normally would send it, i.e. after the full
  538. 		read has completed???
  539. 		Add a param -S2 for series 2 mode, this would seperate each instruction by the & symbol rather
  540. 		than by a new line!*/
  541.  
  542. 		//Below test is needed for Series 2 units
  543. 		/*
  544. 		if (forceUpdate && fixMlog) {
  545. 			outSocket(socket, "POST /tivo-service/mlog.cgi HTTP/1.0\n", 37, ofile);
  546. 			fixMlog = 0;
  547. 			addedHeaders = 1;
  548. 		} else*/ if (rawSend == 2) {
  549. 			outSocket(socket, buffer, length, ofile);
  550. 		} else {
  551. 			//Write the corrected http request to the socket, Replace any "HTTP/1.0 CR" with " HTTP/1.0CR
  552. 			if ((http10 = strstr(buffer, "HTTP/1.0 \015")) != NULL)
  553. 				memcpy(http10, " HTTP/1.0\015", 10);
  554.  
  555. 			if (proxyip) {
  556. 				char *strReq;
  557. 				int idx = strchr(buffer, '/') - buffer;
  558. 				strncpy(strReq, buffer, idx);
  559. 				strReq[idx] = 0;
  560. 				sprintf(strReq, "%shttp://%s:%d%s", strReq, serverip, serverport, buffer + idx);
  561.  
  562. 				outSocket(socket, strReq, strlen(strReq), ofile);
  563.  
  564. 				if (proxyAuth) {
  565. 					char extraInfo[BUFFER_SIZE];
  566. 					sprintf(extraInfo, "Proxy-authorization: Basic %s\r\n", proxyAuth);
  567. 					outSocket(socket, extraInfo, strlen(extraInfo), ofile);
  568. 				}
  569. 			} else
  570. 				outSocket(socket, buffer, length, ofile);
  571.  
  572. 			//Add guide days, if set to the HServer.cgi request
  573. 			if (fixHServer && guideDays)
  574. 				sprintf(myHeaders, strcat(myHeaders, "GuideDays: %d\n"), guideDays);
  575.  
  576. 			// Append our headers after the HTTP/1.x line
  577. 			outSocket(socket, myHeaders, strlen(myHeaders), ofile);
  578.  
  579. 			if (fixHServer && !rawSend) {
  580. 				char extraInfo[BUFFER_SIZE];
  581. 				sprintf(extraInfo, "emuProxyZA: %s\n", VERSION);
  582. 				outSocket(socket, extraInfo, strlen(extraInfo), ofile);
  583. 			}
  584.  
  585. 			addedHeaders = 1;
  586. 			if (debug == 2) fprintf(stderr, "Send my headers\n");
  587. 		}
  588. 	} else {
  589. 		//Check if we are finished reading the header
  590. 		if (!headerComplete && (
  591. 		(buffer[0] == '\n') ||
  592. 		(buffer[0] == '\r') )) {
  593.  
  594. 			headerComplete = 1;
  595.  
  596. 			if (debug == 2) {
  597. 				fprintf(stderr, ", header complete: ");
  598. 				if (buffer[0] == '\r')
  599. 					fprintf(stderr, "Blank line found");
  600. 				else if (buffer[0] == '\n')
  601. 					fprintf(stderr, "Blank DOS line found");
  602. 				fprintf(stderr, "\n");
  603. 			}
  604.  
  605. 			contentStarted = 1;
  606.  
  607. 			//Add Content-length to the HServer.cgi request
  608. 			if (post && (bodylength < 0) )
  609. 			{
  610. 				bodylength = 0;
  611. 				outSocket(socket, "Content-length: 0\r\n\r\n", 21, ofile);
  612. 			} else
  613. 				outSocket(socket, buffer, length, ofile);
  614.  
  615. 		} else {
  616. 		//Write the buffer content to the socket
  617. 		outSocket(socket, buffer, length, ofile);
  618. 		}
  619. 	}
  620. }
  621.  
  622. /****************************************************************************************/
  623. void checkResponse(int socket, char buf[BUFFER_SIZE], int length, FILE *ofile) {
  624. 	char buffer[BUFFER_SIZE];
  625.  
  626. 	strncpy(buffer, buf, length);
  627. 	buffer[length] = 0;
  628.  
  629. 	if (fixHServer && altNTP && (strncasecmp(buffer, "TIME_SVC=", 9) == 0)) {
  630. 		char ntpInfo[BUFFER_SIZE];
  631.  
  632. 		//Get NTP server address
  633. 		if (!ntpip) {
  634. 			char strPad[100];
  635. 			char strNTP[100];
  636.  
  637. 			if ( sscanf( buffer , "%s -b %s ", &strPad, &strNTP) == 2)
  638. 				ntpip = strdup(strNTP);
  639. 		}
  640.  
  641. 		if (debug == 2) fprintf(stderr, "NTP server: %s", ntpip);
  642.  
  643. 		//If no ntpip is found, set it to the default
  644. 		if ((!ntpip) || (ntpip == ""))
  645. 			ntpip = NTPIP;
  646.  
  647. 		//Update sent NTP address
  648. 		sprintf(ntpInfo, "TIME_SVC=/bin/ntpdate -b %s\n", listento);
  649. 		outSocket(socket, ntpInfo, strlen(ntpInfo), ofile);
  650. 	} else {
  651. 		//Write the buffer content to the socket
  652. 		outSocket(socket, buffer, length, ofile);
  653. 	}
  654. }
  655.  
  656. /****************************************************************************************/
  657. int ProcessBuffer(int socket, char buffer[BUFFER_SIZE], int length, int readComplete, object_fn fnCheck, FILE *ofile) {
  658.    	int end = 0;
  659.    	int start = 0;
  660.  
  661. 	do {
  662. 		int newline = chrpos(buffer+start, '\n');
  663. 		if (newline < 0) {
  664. 			end = length - start;
  665. 			if (debug == 2) fprintf(stderr,"New line is NULL, Read: %d, Start: %d, End: %d\n", length, start, end);
  666.  
  667. 			if (readComplete || (end + 1 >= BUFFER_SIZE)) {
  668. 				fnCheck(socket, buffer+start, end, ofile);
  669. 				return 0;
  670. 			} else {
  671. 				memcpy(buffer, buffer+start, end);
  672. 				return end;
  673. 			}
  674. 		} else {
  675. 			end = newline + 1;
  676. 			if (debug == 2) fprintf(stderr,"Start: %d, End: %d", start, end);
  677.  
  678. 			fnCheck(socket, buffer+start, end, ofile);
  679. 			if (debug == 2) fprintf(stderr,", written\n");
  680. 			start += end;
  681. 		}
  682.  
  683. 	} while (start < length);
  684. 	return 0;
  685. }
  686.  
  687. /****************************************************************************************/
  688. void request(int server, int client) {
  689. 	char buffer[BUFFER_SIZE];
  690. 	int r = 0;
  691. 	int end = 0;
  692. 	int readComplete = 0;
  693. 	FILE *ofile = NULL;
  694. 	char filename[100];
  695.  
  696. 	if (debugServer) {
  697. 		sprintf(filename, "%sep%dRequest.log", debugServerPath, count);
  698. 		ofile = fopen(filename, "w");
  699. 	}
  700.  
  701. 	//Reset the flags
  702. 	addedHeaders 		= 0;
  703. 	headerComplete		= 0;
  704. 	contentStarted		= 0;
  705. 	bodylength			= -1;
  706. 	post				= 0;
  707. 	totalRead			= 0;
  708.  
  709.     // Pass out post data
  710.     do {
  711. 		if (!readComplete) {
  712. 			//alarm(15); // Just in case
  713.    			r = read(client, buffer+end, (sizeof buffer) - end - 1);
  714.    			totalRead += r;
  715.    			readComplete = (r < (sizeof buffer) - end - 1);
  716.  			r += end;
  717. 			if (gotAlarm) {
  718. 				break;
  719. 				if (debug) fprintf(stderr,"Client read failed, got alarm!\n");
  720. 			}
  721. 		}
  722.  
  723. 		if (debug == 2) fprintf(stderr,"Request read count: %d, read complete: %d\n", r, readComplete);
  724.  
  725. 	   	if (r > 0) {
  726. 	    	buffer[r] = 0;
  727. 	    	end = 0;
  728.  
  729. 			if (contentStarted && !fixMlog && !fixHServer) {
  730. 				if (debug == 2) fprintf(stderr,"Direct stream output\n");
  731. 				outSocket(server, buffer, r, ofile);
  732. 			} else
  733. 				end = ProcessBuffer(server, buffer, r, readComplete, checkRequest, ofile);
  734.  
  735.     	}
  736. 		if (debug == 2) fprintf(stderr,"ReadComplete %d, HeaderComplete: %d, ContentStarted: %d\n", readComplete, headerComplete, contentStarted);
  737. 		readComplete = readComplete && headerComplete && contentStarted;
  738. 		readComplete = readComplete && (bodylength < 0 || totalRead >= (bodylength));
  739.  
  740. 		if (debug == 2) fprintf(stderr, "Bodylength: %d, TotalRead: %d\n", bodylength, totalRead);
  741.  
  742. 		if (!readComplete) {
  743. 			if (debug == 2) fprintf(stderr, "ReadComplete not true so not cheking for file end!\n");
  744. 		} else if (bodylength < 0 || totalRead >= bodylength) {
  745. 			if (debug == 2) fprintf(stderr, "Bodylength read complete!\n");
  746. 		} else if (strncasecmp(buffer + r - 2, "\n\n", 2) == 0) {
  747. 			if (debug == 2) fprintf(stderr, "End of transmission, double blank unix line found!\n");
  748. 		} else if (strncasecmp(buffer + r - 4, "\r\n\r\n", 4) == 0) {
  749. 			if (debug == 2) fprintf(stderr, "End of transmission, double blank dos line found!\n");
  750. 		} else
  751. 			readComplete = 0;
  752.  
  753. 	} while (!readComplete || !headerComplete || !contentStarted);
  754.  
  755.  	if (fixMlog && !rawSend)
  756. 		outSocket(server, "\nemuProxyZA\n", 12, ofile);
  757.  
  758. 	outSocket(server, "", -1, ofile);
  759.  
  760.  
  761. 	if (debugServer)
  762. 		fclose(ofile);
  763.  
  764. 	if (debug) fprintf(stderr,"Request finished!\n");
  765. }
  766.  
  767. /****************************************************************************************/
  768. void response(int server, int client, int port) {
  769. 	char buffer[BUFFER_SIZE];
  770. 	int r;
  771. 	FILE *ofile = NULL;
  772. 	char filename[100];
  773. 	int readComplete = 0;
  774. 	int end = 0;
  775.  
  776. 	//Reset the flags
  777. 	totalRead			= 0;
  778.  
  779. 	if (debug) fprintf(stderr,"Response started:\n");
  780.  
  781. 	if (debugClient) {
  782. 		sprintf(filename, "%sep%dResponse.log", debugClientPath, count);
  783. 		ofile = fopen(filename, "w");
  784. 	}
  785.  
  786. 	if (debug) fprintf(stderr,"Response file created.\n");
  787.  
  788. 	// Pass back the reply
  789.     do {
  790. 		if (!readComplete) {
  791. 			alarm(15); // Just in case
  792.    			r = read(server, buffer+end, (sizeof buffer) - end - 1);
  793.  
  794.    			totalRead += r;
  795.    			readComplete = (r <= 0); //(r < (sizeof buffer) - end - 1);
  796.  			r += end;
  797. 			if (gotAlarm) {
  798. 				break;
  799. 				if (debug) fprintf(stderr,"Server read failed, got alarm!\n");
  800. 			}
  801. 		}
  802.  
  803. 		if (debug == 2) fprintf(stderr,"Request read count: %d, read complete: %d\n", r, readComplete);
  804.  
  805. 	   	if (r > 0) {
  806. 			buffer[r] = 0;
  807. 			end = 0;
  808.  
  809. 			if ((timeOffset != 0) && (port == NTPPORT))
  810. 				fixEpoch(client, buffer, r, ofile);
  811. 			else if (fixHServer && altNTP)
  812. 				end = ProcessBuffer(client, buffer, r, readComplete, checkResponse, ofile);
  813. 			else
  814. 				outSocket(client, buffer, r, ofile);
  815. 			if (debug == 2) fprintf(stderr,", written");
  816.     	}
  817. 		if (debug == 2) fprintf(stderr,", done\n");
  818.  
  819. 	} while (!readComplete);
  820.  
  821. 	outSocket(client, "", -1, ofile);
  822.  
  823. 	if (debugClient)
  824. 		fclose(ofile);
  825.  
  826. 	if (debug) fprintf(stderr,"Response finished!\n");
  827. }
  828.  
  829. /****************************************************************************************/
  830. int handleConnection(int listener, const char* serverAddr, int port) {
  831.  
  832. 	int server = -1;
  833. 	int client;
  834.  
  835. 	struct sockaddr_in addr;
  836. 	time_t t0 = time(NULL);
  837. 	struct tm *tTm = localtime ( &t0 );
  838. 	char dayOfWeek[1];
  839. 	char *pos;
  840.  
  841. 	client = accept(listener, 0, 0);
  842. 	if (client < 0)
  843. 		return 1;
  844.  
  845. 	if (debug) fprintf(stderr, "\nAccepted connection on port: %d\nDate/Time: %s", port, asctime(tTm));
  846.  
  847. 	count++;
  848.  
  849. 	if (serverAddr == "") { //Need to be done before weekday check so weekday can be overriden
  850. 		close(client);
  851. 		return 0;
  852. 	}
  853.  
  854. 	if (debug) fprintf(stderr, "timeWeekdayOverride: %d, Difference: %d\n", timeWeekdayOverride, t0 - timeWeekdayOverride);
  855. 	if ((timeWeekdayOverride > 0) && (t0 - timeWeekdayOverride > 3600)) // 3600 = 60minutes x 60seconds
  856. 		timeWeekdayOverride = 0;
  857.  
  858. 	if ( (!timeWeekdayOverride) && (weekDays != "") && (!GuidedSetup()) ) { //Check to see if a call is allowed to be made today
  859. 		sprintf(dayOfWeek, "%ld", tTm->tm_wday);
  860.  
  861. 		pos = strstr(weekDays, dayOfWeek);
  862.  
  863. 		if (debug) fprintf(stderr, "Weekdays: %s, DayOfWeek: %s, pos: %d\n", weekDays, dayOfWeek, pos);
  864. 		if (pos == NULL) {
  865. 			if (debug) fprintf(stderr, "You have specified not to allow guide downloads on this day of the week.\n");
  866. 			close(client);
  867. 			return 0;
  868. 		}
  869. 	}
  870.  
  871. 	//Process request--------------------------------------------
  872. 	if (onScreenDisplay) osd_init();
  873.  
  874. 	server = socket(PF_INET, SOCK_STREAM, 0);
  875. 	if (server < 0) {
  876. 		perror("Could not create socket");
  877. 		close(client);
  878. 		return 0;
  879. 	} else if (debug == 2) fprintf(stderr, "Server socket created\n");
  880.  
  881. 	//Fill in the server address
  882. 	/* Moved the ip address assignment down here as this now allows for
  883. 	DNS addresses as well as dynamic DNS addresses which could have changed
  884. 	IP address between calls to the emulator */
  885. 	addr.sin_family = AF_INET;
  886. 	if (proxyip) {
  887. 		addr.sin_addr.s_addr = getIPAddress(proxyip);
  888. 		addr.sin_port = htons(proxyport);
  889. 	} else {
  890. 		addr.sin_addr.s_addr = getIPAddress(serverAddr); //serverip);
  891. 		addr.sin_port = htons(serverport);
  892. 	}
  893.  
  894.  
  895. 	if (addr.sin_addr.s_addr == INADDR_NONE)