1 /*
2  * ======================================================================= *
3  * File: stress .c                                                         *
4  * stress tester for isapi dll's                                           *
5  * based on cgiwrap                                                        *
6  * ======================================================================= *
7  *
8 */
9 #define WIN32_LEAN_AND_MEAN
10 #include <afx.h>
11 #include <afxtempl.h>
12 #include <winbase.h>
13 #include <winerror.h>
14 #include <httpext.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include "getopt.h"
18 
19 // These are things that go out in the Response Header
20 //
21 #define HTTP_VER     "HTTP/1.0"
22 #define SERVER_VERSION "Http-Srv-Beta2/1.0"
23 
24 //
25 // Simple wrappers for the heap APIS
26 //
27 #define xmalloc(s) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (s))
28 #define xfree(s)   HeapFree(GetProcessHeap(), 0, (s))
29 
30 //
31 // The mandatory exports from the ISAPI DLL
32 //
33 DWORD numThreads = 1;
34 DWORD iterations = 1;
35 
36 HANDLE StartNow;
37 // quick and dirty environment
38 typedef CMapStringToString TEnvironment;
39 TEnvironment IsapiEnvironment;
40 
41 typedef struct _TResults {
42 	LONG ok;
43 	LONG bad;
44 } TResults;
45 
46 CStringArray IsapiFileList;  // list of filenames
47 CStringArray TestNames;      // --TEST--
48 CStringArray IsapiGetData;   // --GET--
49 CStringArray IsapiPostData;  // --POST--
50 CStringArray IsapiMatchData; // --EXPECT--
51 CArray<TResults, TResults> Results;
52 
53 typedef struct _TIsapiContext {
54 	HANDLE in;
55 	HANDLE out;
56 	DWORD tid;
57 	TEnvironment env;
58 	HANDLE waitEvent;
59 } TIsapiContext;
60 
61 //
62 // Prototypes of the functions this sample implements
63 //
64 extern "C" {
65 HINSTANCE hDll;
66 typedef BOOL (WINAPI *VersionProc)(HSE_VERSION_INFO *) ;
67 typedef DWORD (WINAPI *HttpExtProc)(EXTENSION_CONTROL_BLOCK *);
68 typedef BOOL (WINAPI *TerminateProc) (DWORD);
69 BOOL WINAPI FillExtensionControlBlock(EXTENSION_CONTROL_BLOCK *, TIsapiContext *) ;
70 BOOL WINAPI GetServerVariable(HCONN, LPSTR, LPVOID, LPDWORD );
71 BOOL WINAPI ReadClient(HCONN, LPVOID, LPDWORD);
72 BOOL WINAPI WriteClient(HCONN, LPVOID, LPDWORD, DWORD);
73 BOOL WINAPI ServerSupportFunction(HCONN, DWORD, LPVOID, LPDWORD, LPDWORD);
74 VersionProc IsapiGetExtensionVersion;
75 HttpExtProc IsapiHttpExtensionProc;
76 TerminateProc TerminateExtensionProc;
77 HSE_VERSION_INFO version_info;
78 }
79 
80 char * MakeDateStr(VOID);
81 char * GetEnv(char *);
82 
83 
84 
85 
86 DWORD CALLBACK IsapiThread(void *);
87 int stress_main(const char *filename,
88 				const char *arg,
89 				const char *postfile,
90 				const char *matchdata);
91 
92 
93 
94 BOOL bUseTestFiles = FALSE;
95 char temppath[MAX_PATH];
96 
stripcrlf(char * line)97 void stripcrlf(char *line)
98 {
99 	DWORD l = strlen(line)-1;
100 	if (line[l]==10 || line[l]==13) line[l]=0;
101 	l = strlen(line)-1;
102 	if (line[l]==10 || line[l]==13) line[l]=0;
103 }
104 
105 #define COMPARE_BUF_SIZE	1024
106 
CompareFiles(const char * f1,const char * f2)107 BOOL CompareFiles(const char*f1, const char*f2)
108 {
109 	FILE *fp1, *fp2;
110 	bool retval;
111 	char buf1[COMPARE_BUF_SIZE], buf2[COMPARE_BUF_SIZE];
112 	int length1, length2;
113 
114 	if ((fp1=fopen(f1, "r"))==NULL) {
115 		return FALSE;
116 	}
117 
118 	if ((fp2=fopen(f2, "r"))==NULL) {
119 		fclose(fp1);
120 		return FALSE;
121 	}
122 
123 	retval = TRUE; // success oriented
124 	while (true) {
125 		length1 = fread(buf1, 1, sizeof(buf1), fp1);
126 		length2 = fread(buf2, 1, sizeof(buf2), fp2);
127 
128 		// check for end of file
129 		if (feof(fp1)) {
130 			if (!feof(fp2)) {
131 				retval = FALSE;
132 			}
133 			break;
134 		} else if (feof(fp2)) {
135 			if (!feof(fp1)) {
136 				retval = FALSE;
137 			}
138 			break;
139 		}
140 
141 		// compare data
142 		if (length1!=length2
143 			|| memcmp(buf1, buf2, length1)!=0) {
144 			retval = FALSE;
145 			break;
146 		}
147 	}
148 	fclose(fp1);
149 	fclose(fp2);
150 
151 	return retval;
152 }
153 
154 
CompareStringWithFile(const char * filename,const char * str,unsigned int str_length)155 BOOL CompareStringWithFile(const char *filename, const char *str, unsigned int str_length)
156 {
157 	FILE *fp;
158 	bool retval;
159 	char buf[COMPARE_BUF_SIZE];
160 	unsigned int offset=0, readbytes;
161 	fprintf(stderr, "test %s\n",filename);
162 	if ((fp=fopen(filename, "rb"))==NULL) {
163 		fprintf(stderr, "Error opening %s\n",filename);
164 		return FALSE;
165 	}
166 
167 	retval = TRUE; // success oriented
168 	while (true) {
169 		readbytes = fread(buf, 1, sizeof(buf), fp);
170 
171 		// check for end of file
172 
173 		if (offset+readbytes > str_length
174 			|| memcmp(buf, str+offset, readbytes)!=NULL) {
175 			fprintf(stderr, "File missmatch %s\n",filename);
176 			retval = FALSE;
177 			break;
178 		}
179 		if (feof(fp)) {
180 			if (!retval) fprintf(stderr, "File zero length %s\n",filename);
181 			break;
182 		}
183 	}
184 	fclose(fp);
185 
186 	return retval;
187 }
188 
189 
ReadGlobalEnvironment(const char * environment)190 BOOL ReadGlobalEnvironment(const char *environment)
191 {
192 	if (environment) {
193 	FILE *fp = fopen(environment, "r");
194 	DWORD i=0;
195 	if (fp) {
196 		char line[2048];
197 		while (fgets(line, sizeof(line)-1, fp)) {
198 			// file.php arg1 arg2 etc.
199 			char *p = strchr(line, '=');
200 			if (p) {
201 				*p=0;
202 				IsapiEnvironment[line]=p+1;
203 			}
204 		}
205 		fclose(fp);
206 		return IsapiEnvironment.GetCount() > 0;
207 	}
208 	}
209 	return FALSE;
210 }
211 
ReadFileList(const char * filelist)212 BOOL ReadFileList(const char *filelist)
213 {
214 	FILE *fp = fopen(filelist, "r");
215 	if (!fp) {
216 		printf("Unable to open %s\r\n", filelist);
217 	}
218 	char line[2048];
219 	int i=0;
220 	while (fgets(line, sizeof(line)-1, fp)) {
221 		// file.php arg1 arg2 etc.
222 		stripcrlf(line);
223 		if (strlen(line)>3) {
224 			char *p = strchr(line, ' ');
225 			if (p) {
226 				*p = 0;
227 				// get file
228 
229 				IsapiFileList.Add(line);
230 				IsapiGetData.Add(p+1);
231 			} else {
232 				// just a filename is all
233 				IsapiFileList.Add(line);
234 				IsapiGetData.Add("");
235 			}
236 		}
237 
238 		// future use
239 		IsapiPostData.Add("");
240 		IsapiMatchData.Add("");
241 		TestNames.Add("");
242 
243 		i++;
244 	}
245 	Results.SetSize(TestNames.GetSize());
246 
247 	fclose(fp);
248 	return IsapiFileList.GetSize() > 0;
249 }
250 
DoThreads()251 void DoThreads() {
252 
253 	if (IsapiFileList.GetSize() == 0) {
254 		printf("No Files to test\n");
255 		return;
256 	}
257 
258 	printf("Starting Threads...\n");
259 	// loop creating threads
260 	DWORD tid;
261 	HANDLE *threads = new HANDLE[numThreads];
262 	DWORD i;
263 	for (i=0; i< numThreads; i++) {
264 		threads[i]=CreateThread(NULL, 0, IsapiThread, NULL, CREATE_SUSPENDED, &tid);
265 	}
266 	for (i=0; i< numThreads; i++) {
267 		if (threads[i]) ResumeThread(threads[i]);
268 	}
269 	// wait for threads to finish
270 	WaitForMultipleObjects(numThreads, threads, TRUE, INFINITE);
271 	for (i=0; i< numThreads; i++) {
272 		CloseHandle(threads[i]);
273 	}
274 	delete [] threads;
275 }
276 
DoFileList(const char * filelist,const char * environment)277 void DoFileList(const char *filelist, const char *environment)
278 {
279 	// read config files
280 
281 	if (!ReadFileList(filelist)) {
282 		printf("No Files to test!\r\n");
283 		return;
284 	}
285 
286 	ReadGlobalEnvironment(environment);
287 
288 	DoThreads();
289 }
290 
291 
292 /**
293  * ParseTestFile
294  * parse a single phpt file and add it to the arrays
295  */
ParseTestFile(const char * path,const char * fn)296 BOOL ParseTestFile(const char *path, const char *fn)
297 {
298 	// parse the test file
299 	char filename[MAX_PATH];
300 	_snprintf(filename, sizeof(filename)-1, "%s\\%s", path, fn);
301 	char line[1024];
302 	memset(line, 0, sizeof(line));
303 	CString cTest, cSkipIf, cPost, cGet, cFile, cExpect;
304 	printf("Reading %s\r\n", filename);
305 
306 	enum state {none, test, skipif, post, get, file, expect} parsestate = none;
307 
308 	FILE *fp = fopen(filename, "rb");
309 	char *tn = _tempnam(temppath,"pht.");
310 	char *en = _tempnam(temppath,"exp.");
311 	FILE *ft = fopen(tn, "wb+");
312 	FILE *fe = fopen(en, "wb+");
313 	if (fp && ft && fe) {
314 		while (fgets(line, sizeof(line)-1, fp)) {
315 			if (line[0]=='-') {
316 				if (_strnicmp(line, "--TEST--", 8)==0) {
317 					parsestate = test;
318 					continue;
319 				} else if (_strnicmp(line, "--SKIPIF--", 10)==0) {
320 					parsestate = skipif;
321 					continue;
322 				} else if (_strnicmp(line, "--POST--", 8)==0) {
323 					parsestate = post;
324 					continue;
325 				} else if (_strnicmp(line, "--GET--", 7)==0) {
326 					parsestate = get;
327 					continue;
328 				} else if (_strnicmp(line, "--FILE--", 8)==0) {
329 					parsestate = file;
330 					continue;
331 				} else if (_strnicmp(line, "--EXPECT--", 10)==0) {
332 					parsestate = expect;
333 					continue;
334 				}
335 			}
336 			switch (parsestate) {
337 			case test:
338 				stripcrlf(line);
339 				cTest = line;
340 				break;
341 			case skipif:
342 				cSkipIf += line;
343 				break;
344 			case post:
345 				cPost += line;
346 				break;
347 			case get:
348 				cGet += line;
349 				break;
350 			case file:
351 				fputs(line, ft);
352 				break;
353 			case expect:
354 				fputs(line, fe);
355 				break;
356 			}
357 		}
358 
359 		fclose(fp);
360 		fclose(ft);
361 		fclose(fe);
362 
363 		if (!cTest.IsEmpty()) {
364 			IsapiFileList.Add(tn);
365 			TestNames.Add(cTest);
366 			IsapiGetData.Add(cGet);
367 			IsapiPostData.Add(cPost);
368 			IsapiMatchData.Add(en);
369 			free(tn);
370 			free(en);
371 			return TRUE;
372 		}
373 	}
374 	free(tn);
375 	free(en);
376 	return FALSE;
377 }
378 
379 
380 /**
381  * GetTestFiles
382  * Recurse through the path and subdirectories, parse each phpt file
383  */
GetTestFiles(const char * path)384 BOOL GetTestFiles(const char *path)
385 {
386 	// find all files .phpt under testpath\tests
387 	char FindPath[MAX_PATH];
388 	WIN32_FIND_DATA fd;
389 	memset(&fd, 0, sizeof(WIN32_FIND_DATA));
390 
391 	_snprintf(FindPath, sizeof(FindPath)-1, "%s\\*.*", path);
392 	HANDLE fh = FindFirstFile(FindPath, &fd);
393 	if (fh != INVALID_HANDLE_VALUE) {
394 		do {
395 			if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
396 				!strchr(fd.cFileName, '.')) {
397 				// subdirectory, recurse into it
398 				char NewFindPath[MAX_PATH];
399 				_snprintf(NewFindPath, sizeof(NewFindPath)-1, "%s\\%s", path, fd.cFileName);
400 				GetTestFiles(NewFindPath);
401 			} else if (strstr(fd.cFileName, ".phpt")) {
402 				// got test file, parse it now
403 				if (ParseTestFile(path, fd.cFileName)) {
404 					printf("Test File Added: %s\\%s\r\n", path, fd.cFileName);
405 				}
406 			}
407 			memset(&fd, 0, sizeof(WIN32_FIND_DATA));
408 		} while (FindNextFile(fh, &fd) != 0);
409 		FindClose(fh);
410 	}
411 	return IsapiFileList.GetSize() > 0;
412 }
413 
DeleteTempFiles(const char * mask)414 void DeleteTempFiles(const char *mask)
415 {
416 	char FindPath[MAX_PATH];
417 	WIN32_FIND_DATA fd;
418 	memset(&fd, 0, sizeof(WIN32_FIND_DATA));
419 
420 	_snprintf(FindPath, sizeof(FindPath)-1, "%s\\%s", temppath, mask);
421 	HANDLE fh = FindFirstFile(FindPath, &fd);
422 	if (fh != INVALID_HANDLE_VALUE) {
423 		do {
424 			char NewFindPath[MAX_PATH];
425 			_snprintf(NewFindPath, sizeof(NewFindPath)-1, "%s\\%s", temppath, fd.cFileName);
426 			DeleteFile(NewFindPath);
427 			memset(&fd, 0, sizeof(WIN32_FIND_DATA));
428 		} while (FindNextFile(fh, &fd) != 0);
429 		FindClose(fh);
430 	}
431 }
432 
DoTestFiles(const char * filelist,const char * environment)433 void DoTestFiles(const char *filelist, const char *environment)
434 {
435 	if (!GetTestFiles(filelist)) {
436 		printf("No Files to test!\r\n");
437 		return;
438 	}
439 
440 	Results.SetSize(IsapiFileList.GetSize());
441 
442 	ReadGlobalEnvironment(environment);
443 
444 	DoThreads();
445 
446 	printf("\r\nRESULTS:\r\n");
447 	// show results:
448 	DWORD r = Results.GetSize();
449 	for (DWORD i=0; i< r; i++) {
450 		TResults result = Results.GetAt(i);
451 		printf("%s\r\nOK: %d FAILED: %d\r\n", TestNames.GetAt(i), result.ok, result.bad);
452 	}
453 
454 	// delete temp files
455 	printf("Deleting Temp Files\r\n");
456 	DeleteTempFiles("exp.*");
457 	DeleteTempFiles("pht.*");
458 	printf("Done\r\n");
459 }
460 
461 #define OPTSTRING "m:f:d:h:t:i:"
_usage(char * argv0)462 static void _usage(char *argv0)
463 {
464 	char *prog;
465 
466 	prog = strrchr(argv0, '/');
467 	if (prog) {
468 		prog++;
469 	} else {
470 		prog = "stresstest";
471 	}
472 
473 	printf("Usage: %s -m <isapi.dll> -d|-l <file> [-t <numthreads>] [-i <numiterations>]\n"
474 				"  -m             path to isapi dll\n"
475 				"  -d <directory> php directory (to run php test files).\n"
476 				"  -f <file>      file containing list of files to run\n"
477 				"  -t             number of threads to use (default=1)\n"
478                 "  -i             number of iterations per thread (default=1)\n"
479 				"  -h             This help\n", prog);
480 }
main(int argc,char * argv[])481 int main(int argc, char* argv[])
482 {
483 	LPVOID lpMsgBuf;
484 	char *filelist=NULL, *environment=NULL, *module=NULL;
485 	int c = NULL;
486 	while ((c=ap_getopt(argc, argv, OPTSTRING))!=-1) {
487 		switch (c) {
488 			case 'd':
489 				bUseTestFiles = TRUE;
490 				filelist = strdup(ap_optarg);
491 				break;
492 			case 'f':
493 				bUseTestFiles = FALSE;
494 				filelist = strdup(ap_optarg);
495 				break;
496 			case 'e':
497 				environment = strdup(ap_optarg);
498 				break;
499 			case 't':
500 				numThreads = atoi(ap_optarg);
501 				break;
502 			case 'i':
503 				iterations = atoi(ap_optarg);
504 				break;
505 			case 'm':
506 				module = strdup(ap_optarg);
507 				break;
508 			case 'h':
509 				_usage(argv[0]);
510 				exit(0);
511 				break;
512 		}
513 	}
514 	if (!module || !filelist) {
515 		_usage(argv[0]);
516 		exit(0);
517 	}
518 
519 	GetTempPath(sizeof(temppath), temppath);
520 	hDll = LoadLibrary(module); // Load our DLL
521 
522 	if (!hDll) {
523 		FormatMessage(
524 		   FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
525 		    NULL,
526 		    GetLastError(),
527 		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
528 		    (LPTSTR) &lpMsgBuf,
529 		    0,
530 		    NULL
531 		);
532 		fprintf(stderr,"Error: Dll 'php5isapi.dll' not found -%d\n%s\n", GetLastError(), lpMsgBuf);
533 		free (module);
534 		free(filelist);
535 		LocalFree( lpMsgBuf );
536 		return -1;
537 	}
538 
539 	//
540 	// Find the exported functions
541 
542 	IsapiGetExtensionVersion = (VersionProc)GetProcAddress(hDll,"GetExtensionVersion");
543 	if (!IsapiGetExtensionVersion) {
544 		fprintf(stderr,"Can't Get Extension Version %d\n", GetLastError());
545 		free (module);
546 		free(filelist);
547 		return -1;
548 	}
549 	IsapiHttpExtensionProc = (HttpExtProc)GetProcAddress(hDll,"HttpExtensionProc");
550 	if (!IsapiHttpExtensionProc) {
551 		fprintf(stderr,"Can't Get Extension proc %d\n", GetLastError());
552 		free (module);
553 		free(filelist);
554 		return -1;
555 	}
556 	TerminateExtensionProc = (TerminateProc) GetProcAddress(hDll,
557                                           "TerminateExtension");
558 
559 	// This should really check if the version information matches what we
560 	// expect.
561 	//
562 	if (!IsapiGetExtensionVersion(&version_info) ) {
563 		fprintf(stderr,"Fatal: GetExtensionVersion failed\n");
564 		free (module);
565 		free(filelist);
566 		return -1;
567 	}
568 
569 	if (bUseTestFiles) {
570 		char TestPath[MAX_PATH];
571 		if (filelist != NULL)
572 			_snprintf(TestPath, sizeof(TestPath)-1, "%s\\tests", filelist);
573 		else strcpy(TestPath, "tests");
574 		DoTestFiles(TestPath, environment);
575 	} else {
576 		DoFileList(filelist, environment);
577 	}
578 
579 	// cleanup
580 	if (TerminateExtensionProc) TerminateExtensionProc(0);
581 
582 	// We should really free memory (e.g., from GetEnv), but we'll be dead
583 	// soon enough
584 
585 	FreeLibrary(hDll);
586 	free (module);
587 	free(filelist);
588 	return 0;
589 }
590 
591 
IsapiThread(void * p)592 DWORD CALLBACK IsapiThread(void *p)
593 {
594 	DWORD filecount = IsapiFileList.GetSize();
595 
596 	for (DWORD j=0; j<iterations; j++) {
597 		for (DWORD i=0; i<filecount; i++) {
598 			// execute each file
599 			CString testname = TestNames.GetAt(i);
600 			BOOL ok = FALSE;
601 			if (stress_main(IsapiFileList.GetAt(i),
602 						IsapiGetData.GetAt(i),
603 						IsapiPostData.GetAt(i),
604 						IsapiMatchData.GetAt(i))) {
605 				InterlockedIncrement(&Results[i].ok);
606 				ok = TRUE;
607 			} else {
608 				InterlockedIncrement(&Results[i].bad);
609 				ok = FALSE;
610 			}
611 
612 			if (testname.IsEmpty()) {
613 				printf("Thread %d File %s\n", GetCurrentThreadId(), IsapiFileList.GetAt(i));
614 			} else {
615 				printf("tid %d: %s %s\n", GetCurrentThreadId(), testname, ok?"OK":"FAIL");
616 			}
617 			Sleep(10);
618 		}
619 	}
620 	printf("Thread ending...\n");
621 	return 0;
622 }
623 
624 /*
625  * ======================================================================= *
626  * In the startup of this program, we look at our executable name and      *
627  * replace the ".EXE" with ".DLL" to find the ISAPI DLL we need to load.   *
628  * This means that the executable need only be given the same "name" as    *
629  * the DLL to load. There is no recompilation required.                    *
630  * ======================================================================= *
631 */
stress_main(const char * filename,const char * arg,const char * postdata,const char * matchdata)632 BOOL stress_main(const char *filename,
633 				const char *arg,
634 				const char *postdata,
635 				const char *matchdata)
636 {
637 
638 	EXTENSION_CONTROL_BLOCK ECB;
639 	DWORD rc;
640 	TIsapiContext context;
641 
642 	// open output and input files
643 	context.tid = GetCurrentThreadId();
644 	CString fname;
645 	fname.Format("%08X.out", context.tid);
646 
647 	context.out = CreateFile(fname, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);
648 	if (context.out==INVALID_HANDLE_VALUE) {
649 		printf("failed to open output file %s\n", fname);
650 		return 0;
651 	}
652 
653 	// not using post files
654 	context.in = INVALID_HANDLE_VALUE;
655 
656 	//
657 	// Fill the ECB with the necessary information
658 	//
659 	if (!FillExtensionControlBlock(&ECB, &context) ) {
660 		fprintf(stderr,"Fill Ext Block Failed\n");
661 		return -1;
662 	}
663 
664 	// check for command line argument,
665 	// first arg = filename
666 	// this is added for testing php from command line
667 
668 	context.env.RemoveAll();
669 	context.env["PATH_TRANSLATED"]= filename;
670 	context.env["SCRIPT_MAP"]= filename;
671 	context.env["CONTENT_TYPE"]= "";
672 	context.env["CONTENT_LENGTH"]= "";
673 	context.env["QUERY_STRING"]= arg;
674 	context.env["METHOD"]="GET";
675 	context.env["PATH_INFO"] = "";
676 	context.waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
677 	char buf[MAX_PATH];
678 	if (postdata && *postdata !=0) {
679 		ECB.cbAvailable = strlen(postdata);
680 		ECB.cbTotalBytes = ECB.cbAvailable;
681 		ECB.lpbData = (unsigned char *)postdata;
682 		context.env["METHOD"]="POST";
683 
684 		_snprintf(buf, sizeof(buf)-1, "%d", ECB.cbTotalBytes);
685 		context.env["CONTENT_LENGTH"]=buf;
686 
687 		context.env["CONTENT_TYPE"]="application/x-www-form-urlencoded";
688 	}
689 	ECB.lpszMethod = strdup(context.env["METHOD"]);
690     ECB.lpszPathTranslated = strdup(filename);
691 	ECB.lpszQueryString = strdup(arg);
692 	ECB.lpszPathInfo = strdup(context.env["PATH_INFO"]);
693 
694 
695 	// Call the DLL
696 	//
697 	rc = IsapiHttpExtensionProc(&ECB);
698 	if (rc == HSE_STATUS_PENDING) {
699 		// We will exit in ServerSupportFunction
700 		WaitForSingleObject(context.waitEvent, INFINITE);
701 	}
702 	CloseHandle(context.waitEvent);
703 	//Sleep(75);
704 	free(ECB.lpszPathTranslated);
705 	free(ECB.lpszQueryString);
706 	free(ECB.lpszMethod);
707 	free(ECB.lpszPathInfo);
708 
709 	BOOL ok = TRUE;
710 
711 	if (context.out != INVALID_HANDLE_VALUE) CloseHandle(context.out);
712 
713 	// compare the output with the EXPECT section
714 	if (matchdata && *matchdata != 0) {
715 		ok = CompareFiles(fname, matchdata);
716 	}
717 
718 	DeleteFile(fname);
719 
720 	return ok;
721 
722 }
723 //
724 // GetServerVariable() is how the DLL calls the main program to figure out
725 // the environment variables it needs. This is a required function.
726 //
GetServerVariable(HCONN hConn,LPSTR lpszVariableName,LPVOID lpBuffer,LPDWORD lpdwSize)727 BOOL WINAPI GetServerVariable(HCONN hConn, LPSTR lpszVariableName,
728 								LPVOID lpBuffer, LPDWORD lpdwSize){
729 
730 	DWORD rc;
731 	CString value;
732 	TIsapiContext *c = (TIsapiContext *)hConn;
733 	if (!c) return FALSE;
734 
735 	if (IsapiEnvironment.Lookup(lpszVariableName, value)) {
736 		rc = value.GetLength();
737 		strncpy((char *)lpBuffer, value, *lpdwSize-1);
738 	} else if (c->env.Lookup(lpszVariableName, value)) {
739 		rc = value.GetLength();
740 		strncpy((char *)lpBuffer, value, *lpdwSize-1);
741 	} else
742 		rc = GetEnvironmentVariable(lpszVariableName, (char *)lpBuffer, *lpdwSize) ;
743 
744 	if (!rc) { // return of 0 indicates the variable was not found
745 		SetLastError(ERROR_NO_DATA);
746 		return FALSE;
747 	}
748 
749 	if (rc > *lpdwSize) {
750 		SetLastError(ERROR_INSUFFICIENT_BUFFER);
751 		return FALSE;
752 	}
753 
754 	*lpdwSize =rc + 1 ; // GetEnvironmentVariable does not count the NULL
755 
756 	return TRUE;
757 
758 }
759 //
760 // Again, we don't have an HCONN, so we simply wrap ReadClient() to
761 // ReadFile on stdin. The semantics of the two functions are the same
762 //
ReadClient(HCONN hConn,LPVOID lpBuffer,LPDWORD lpdwSize)763 BOOL WINAPI ReadClient(HCONN hConn, LPVOID lpBuffer, LPDWORD lpdwSize) {
764 	TIsapiContext *c = (TIsapiContext *)hConn;
765 	if (!c) return FALSE;
766 
767 	if (c->in != INVALID_HANDLE_VALUE)
768 		return ReadFile(c->in, lpBuffer, (*lpdwSize), lpdwSize, NULL);
769 
770 	return FALSE;
771 }
772 //
773 // ditto for WriteClient()
774 //
WriteClient(HCONN hConn,LPVOID lpBuffer,LPDWORD lpdwSize,DWORD dwReserved)775 BOOL WINAPI WriteClient(HCONN hConn, LPVOID lpBuffer, LPDWORD lpdwSize,
776 			DWORD dwReserved) {
777 	TIsapiContext *c = (TIsapiContext *)hConn;
778 	if (!c) return FALSE;
779 
780 	if (c->out != INVALID_HANDLE_VALUE)
781 		return WriteFile(c->out, lpBuffer, *lpdwSize, lpdwSize, NULL);
782 	return FALSE;
783 }
784 //
785 // This is a special callback function used by the DLL for certain extra
786 // functionality. Look at the API help for details.
787 //
ServerSupportFunction(HCONN hConn,DWORD dwHSERequest,LPVOID lpvBuffer,LPDWORD lpdwSize,LPDWORD lpdwDataType)788 BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest,
789 				LPVOID lpvBuffer, LPDWORD lpdwSize, LPDWORD lpdwDataType){
790 
791 	TIsapiContext *c = (TIsapiContext *)hConn;
792 	char *lpszRespBuf;
793 	char * temp = NULL;
794 	DWORD dwBytes;
795 	BOOL bRet = TRUE;
796 
797 	switch(dwHSERequest) {
798 		case (HSE_REQ_SEND_RESPONSE_HEADER) :
799 			lpszRespBuf = (char *)xmalloc(*lpdwSize);//+ 80);//accomodate our header
800 			if (!lpszRespBuf)
801 				return FALSE;
802 			wsprintf(lpszRespBuf,"%s",
803 				//HTTP_VER,
804 
805 				/* Default response is 200 Ok */
806 
807 				//lpvBuffer?lpvBuffer:"200 Ok",
808 
809 				/* Create a string for the time. */
810 				//temp=MakeDateStr(),
811 
812 				//SERVER_VERSION,
813 
814 				/* If this exists, it is a pointer to a data buffer to
815 				   be sent. */
816 				lpdwDataType?(char *)lpdwDataType:NULL);
817 
818 			if (temp) xfree(temp);
819 
820 			dwBytes = strlen(lpszRespBuf);
821 			bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
822 			xfree(lpszRespBuf);
823 
824 			break;
825 			//
826 			// A real server would do cleanup here
827 		case (HSE_REQ_DONE_WITH_SESSION):
828 			SetEvent(c->waitEvent);
829 			//ExitThread(0);
830 			break;
831 
832 		//
833 		// This sends a redirect (temporary) to the client.
834 		// The header construction is similar to RESPONSE_HEADER above.
835 		//
836 		case (HSE_REQ_SEND_URL_REDIRECT_RESP):
837 			lpszRespBuf = (char *)xmalloc(*lpdwSize +80) ;
838 			if (!lpszRespBuf)
839 				return FALSE;
840 			wsprintf(lpszRespBuf,"%s %s %s\r\n",
841 					HTTP_VER,
842 					"302 Moved Temporarily",
843 					(lpdwSize > 0)?lpvBuffer:0);
844 			xfree(temp);
845 			dwBytes = strlen(lpszRespBuf);
846 			bRet = WriteClient(0, lpszRespBuf, &dwBytes, 0);
847 			xfree(lpszRespBuf);
848 			break;
849 		default:
850 			return FALSE;
851 		break;
852 	}
853 	return bRet;
854 
855 }
856 //
857 // Makes a string of the date and time from GetSystemTime().
858 // This is in UTC, as required by the HTTP spec.`
859 //
MakeDateStr(void)860 char * MakeDateStr(void){
861 	SYSTEMTIME systime;
862 	char *szDate= (char *)xmalloc(64);
863 
864 	char * DaysofWeek[] = {"Sun","Mon","Tue","Wed","Thurs","Fri","Sat"};
865 	char * Months[] = {"NULL","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug",
866 						"Sep","Oct","Nov","Dec"};
867 
868 	GetSystemTime(&systime);
869 
870 	wsprintf(szDate,"%s, %d %s %d %d:%d.%d", DaysofWeek[systime.wDayOfWeek],
871 									  systime.wDay,
872 									  Months[systime.wMonth],
873 									  systime.wYear,
874 									  systime.wHour, systime.wMinute,
875 									  systime.wSecond );
876 
877 	return szDate;
878 }
879 //
880 // Fill the ECB up
881 //
FillExtensionControlBlock(EXTENSION_CONTROL_BLOCK * ECB,TIsapiContext * context)882 BOOL WINAPI FillExtensionControlBlock(EXTENSION_CONTROL_BLOCK *ECB, TIsapiContext *context) {
883 
884 	char * temp;
885 	ECB->cbSize = sizeof(EXTENSION_CONTROL_BLOCK);
886 	ECB->dwVersion = MAKELONG(HSE_VERSION_MINOR, HSE_VERSION_MAJOR);
887 	ECB->ConnID = (void *)context;
888 	//
889 	// Pointers to the functions the DLL will call.
890 	//
891 	ECB->GetServerVariable = GetServerVariable;
892 	ECB->ReadClient  = ReadClient;
893 	ECB->WriteClient = WriteClient;
894 	ECB->ServerSupportFunction = ServerSupportFunction;
895 
896 	//
897 	// Fill in the standard CGI environment variables
898 	//
899 	ECB->lpszMethod = GetEnv("REQUEST_METHOD");
900 	if (!ECB->lpszMethod) ECB->lpszMethod = "GET";
901 
902 	ECB->lpszQueryString = GetEnv("QUERY_STRING");
903 	ECB->lpszPathInfo = GetEnv("PATH_INFO");
904 	ECB->lpszPathTranslated = GetEnv("PATH_TRANSLATED");
905 	ECB->cbTotalBytes=( (temp=GetEnv("CONTENT_LENGTH")) ? (atoi(temp)): 0);
906 	ECB->cbAvailable = 0;
907 	ECB->lpbData = (unsigned char *)"";
908 	ECB->lpszContentType = GetEnv("CONTENT_TYPE");
909 	return TRUE;
910 
911 }
912 
913 //
914 // Works like _getenv(), but uses win32 functions instead.
915 //
GetEnv(LPSTR lpszEnvVar)916 char *GetEnv(LPSTR lpszEnvVar)
917 {
918 
919 	char *var, dummy;
920 	DWORD dwLen;
921 
922 	if (!lpszEnvVar)
923 		return "";
924 
925 	dwLen =GetEnvironmentVariable(lpszEnvVar, &dummy, 1);
926 
927 	if (dwLen == 0)
928 		return "";
929 
930 	var = (char *)xmalloc(dwLen);
931 	if (!var)
932 		return "";
933 	(void)GetEnvironmentVariable(lpszEnvVar, var, dwLen);
934 
935 	return var;
936 }
937