cgic.c @ 244

Last change on this file since 244 was 216, checked in by djay, 14 years ago
Add WIN32 platform support. Fix for values containing @ passed as KVP.
File size: 54.5 KB

Line
1	/* cgicTempDir is the only setting you are likely to need
2	to change in this file. */
3
4	/* Used only in Unix environments, in conjunction with mkstemp().
5	Elsewhere (Windows), temporary files go where the tmpnam()
6	function suggests. If this behavior does not work for you,
7	modify the getTempFileName() function to suit your needs. */
8
9	#define cgicTempDir "/tmp"
10
11	#include <fcgi_stdio.h>
12	#if CGICDEBUG
13	#define CGICDEBUGSTART \
14	{ \
15	FILE *dout; \
16	dout = fopen("/home/boutell/public_html/debug", "a"); \
17
18	#define CGICDEBUGEND \
19	fclose(dout); \
20	}
21	#else /* CGICDEBUG */
22	#define CGICDEBUGSTART
23	#define CGICDEBUGEND
24	#endif /* CGICDEBUG */
25
26	#include <stdio.h>
27	#include <string.h>
28	#include <ctype.h>
29	#include <stdlib.h>
30	#include <time.h>
31	#include <sys/types.h>
32	#include <sys/stat.h>
33
34	#ifdef WIN32
35	#include <io.h>
36
37	/* cgic 2.01 */
38	#include <fcntl.h>
39
40	#else
41	#include <unistd.h>
42	#endif /* WIN32 */
43	#include "cgic.h"
44
45	#define cgiStrEq(a, b) (!strcmp((a), (b)))
46
47	char *cgiServerSoftware;
48	char *cgiServerName;
49	char *cgiGatewayInterface;
50	char *cgiServerProtocol;
51	char *cgiServerPort;
52	char *cgiRequestMethod;
53	char *cgiPathInfo;
54	char *cgiPathTranslated;
55	char *cgiScriptName;
56	char *cgiQueryString;
57	char *cgiRemoteHost;
58	char *cgiRemoteAddr;
59	char *cgiAuthType;
60	char *cgiRemoteUser;
61	char *cgiRemoteIdent;
62	char cgiContentTypeData[1024];
63	char *cgiContentType = cgiContentTypeData;
64	char *cgiMultipartBoundary;
65	char *cgiCookie;
66	int cgiContentLength;
67	char *cgiAccept;
68	char *cgiUserAgent;
69	char *cgiReferrer;
70	char *cgiSid;
71
72	FILE *cgiIn;
73	FILE *cgiOut;
74
75	/* True if CGI environment was restored from a file. */
76	static int cgiRestored = 0;
77	static int cgiTreatUrlEncoding;
78
79	static void cgiGetenv(char *s, char var);
80
81	typedef enum {
82	cgiParseSuccess,
83	cgiParseMemory,
84	cgiParseIO
85	} cgiParseResultType;
86
87	/* One form entry, consisting of an attribute-value pair,
88	and an optional filename and content type. All of
89	these are guaranteed to be valid null-terminated strings,
90	which will be of length zero in the event that the
91	field is not present, with the exception of tfileName
92	which will be null when 'in' is null. DO NOT MODIFY THESE
93	VALUES. Make local copies if modifications are desired. */
94
95	typedef struct cgiFormEntryStruct {
96	char *attr;
97	/* value is populated for regular form fields only.
98	For file uploads, it points to an empty string, and file
99	upload data should be read from the file tfileName. */
100	char *value;
101	/* When fileName is not an empty string, tfileName is not null,
102	and 'value' points to an empty string. */
103	/* Valid for both files and regular fields; does not include
104	terminating null of regular fields. */
105	int valueLength;
106	char *fileName;
107	char *contentType;
108	/* Temporary file name for working storage of file uploads. */
109	char *tfileName;
110	struct cgiFormEntryStruct *next;
111	} cgiFormEntry;
112
113	/* The first form entry. */
114	static cgiFormEntry *cgiFormEntryFirst;
115
116	static cgiParseResultType cgiParseGetFormInput();
117	static cgiParseResultType cgiParsePostFormInput();
118	static cgiParseResultType cgiParsePostMultipartInput();
119	static cgiParseResultType cgiParseFormInput(char *data, int length);
120	static void cgiSetupConstants();
121	static void cgiFreeResources();
122	static int cgiStrEqNc(char s1, char s2);
123	static int cgiStrBeginsNc(char s1, char s2);
124
125	//int cgiMain_init() {}
126
127
128	int main(int argc, char *argv[]) {
129	int result;
130	char *cgiContentLengthString;
131	char *e;
132	while (FCGI_Accept() >= 0) {
133	cgiSetupConstants();
134	cgiGetenv(&cgiServerSoftware, "SERVER_SOFTWARE");
135	cgiGetenv(&cgiServerName, "SERVER_NAME");
136	cgiGetenv(&cgiGatewayInterface, "GATEWAY_INTERFACE");
137	cgiGetenv(&cgiServerProtocol, "SERVER_PROTOCOL");
138	cgiGetenv(&cgiServerPort, "SERVER_PORT");
139	cgiGetenv(&cgiRequestMethod, "REQUEST_METHOD");
140	if(strcmp(cgiRequestMethod,"")==0 && argc>=1)
141	cgiRequestMethod="GET";
142	cgiGetenv(&cgiPathInfo, "PATH_INFO");
143	cgiGetenv(&cgiPathTranslated, "PATH_TRANSLATED");
144	cgiGetenv(&cgiScriptName, "SCRIPT_NAME");
145	cgiGetenv(&cgiQueryString, "QUERY_STRING");
146	cgiSid=NULL;
147	if(strcmp(cgiQueryString,"")==0 && argc>=2){
148	cgiQueryString=argv[1];
149	if(argc>2){
150	cgiSid=argv[2];
151	}
152	}
153	cgiGetenv(&cgiRemoteHost, "REMOTE_HOST");
154	cgiGetenv(&cgiRemoteAddr, "REMOTE_ADDR");
155	cgiGetenv(&cgiAuthType, "AUTH_TYPE");
156	cgiGetenv(&cgiRemoteUser, "REMOTE_USER");
157	cgiGetenv(&cgiRemoteIdent, "REMOTE_IDENT");
158	/* 2.0: the content type string needs to be parsed and modified, so
159	copy it to a buffer. */
160	e = getenv("CONTENT_TYPE");
161	if (e) {
162	if (strlen(e) < sizeof(cgiContentTypeData)) {
163	strcpy(cgiContentType, e);
164	} else {
165	/* Truncate safely in the event of what is almost certainly
166	a hack attempt */
167	strncpy(cgiContentType, e, sizeof(cgiContentTypeData));
168	cgiContentType[sizeof(cgiContentTypeData) - 1] = '\0';
169	}
170	} else {
171	cgiContentType[0] = '\0';
172	}
173	/* Never null */
174	cgiMultipartBoundary = "";
175	/* 2.0: parse semicolon-separated additional parameters of the
176	content type. The one we're interested in is 'boundary'.
177	We discard the rest to make cgiContentType more useful
178	to the typical programmer. */
179	if (strchr(cgiContentType, ';')) {
180	char *sat = strchr(cgiContentType, ';');
181	while (sat) {
182	*sat = '\0';
183	sat++;
184	while (isspace(*sat)) {
185	sat++;
186	}
187	if (cgiStrBeginsNc(sat, "boundary=")) {
188	char *s;
189	cgiMultipartBoundary = sat + strlen("boundary=");
190	s = cgiMultipartBoundary;
191	while ((s) && (!isspace(s))) {
192	s++;
193	}
194	*s = '\0';
195	break;
196	} else {
197	sat = strchr(sat, ';');
198	}
199	}
200	}
201	cgiGetenv(&cgiContentLengthString, "CONTENT_LENGTH");
202	cgiContentLength = atoi(cgiContentLengthString);
203	if(cgiContentLength==0 && argc>=2){
204	cgiContentLength=strlen(argv[1]);
205	}
206	cgiGetenv(&cgiAccept, "HTTP_ACCEPT");
207	cgiGetenv(&cgiUserAgent, "HTTP_USER_AGENT");
208	cgiGetenv(&cgiReferrer, "HTTP_REFERER");
209	cgiGetenv(&cgiCookie, "HTTP_COOKIE");
210	#ifdef CGICDEBUG
211	CGICDEBUGSTART
212	fprintf(dout, "%d\n", cgiContentLength);
213	fprintf(dout, "%s\n", cgiRequestMethod);
214	fprintf(dout, "%s\n", cgiContentType);
215	CGICDEBUGEND
216	#endif /* CGICDEBUG */
217	#ifdef WIN32
218	/* 1.07: Must set stdin and stdout to binary mode */
219	/* 2.0: this is particularly crucial now and must not be removed */
220	_setmode( FCGI_fileno( stdin ), _O_BINARY );
221	_setmode( FCGI_fileno( stdout ), _O_BINARY );
222	#endif /* WIN32 */
223	cgiFormEntryFirst = 0;
224	cgiIn = FCGI_stdin;
225	cgiOut = FCGI_stdout;
226	cgiRestored = 0;
227
228
229	/* These five lines keep compilers from
230	producing warnings that argc and argv
231	are unused. They have no actual function. */
232	if (argc) {
233	if (argv[0]) {
234	cgiRestored = 0;
235	}
236	}
237
238
239	cgiTreatUrlEncoding=1;
240	if (cgiStrEqNc(cgiRequestMethod, "post")) {
241	cgiTreatUrlEncoding=0;
242	#ifdef CGICDEBUG
243	CGICDEBUGSTART
244	fprintf(dout, "POST recognized\n");
245	CGICDEBUGEND
246	#endif /* CGICDEBUG */
247	if (cgiStrEqNc(cgiContentType, "application/x-www-form-urlencoded")) {
248	#ifdef CGICDEBUG
249	CGICDEBUGSTART
250	fprintf(dout, "Calling PostFormInput\n");
251	CGICDEBUGEND
252	#endif /* CGICDEBUG */
253	if (cgiParsePostFormInput() != cgiParseSuccess) {
254	#ifdef CGICDEBUG
255	CGICDEBUGSTART
256	fprintf(dout, "PostFormInput failed\n");
257	CGICDEBUGEND
258	#endif /* CGICDEBUG */
259	cgiFreeResources();
260	return -1;
261	}
262	#ifdef CGICDEBUG
263	CGICDEBUGSTART
264	fprintf(dout, "PostFormInput succeeded\n");
265	CGICDEBUGEND
266	#endif /* CGICDEBUG */
267	} else if (cgiStrEqNc(cgiContentType, "multipart/form-data")) {
268	#ifdef CGICDEBUG
269	CGICDEBUGSTART
270	fprintf(dout, "Calling PostMultipartInput\n");
271	CGICDEBUGEND
272	#endif /* CGICDEBUG */
273	if (cgiParsePostMultipartInput() != cgiParseSuccess) {
274	#ifdef CGICDEBUG
275	CGICDEBUGSTART
276	fprintf(dout, "PostMultipartInput failed\n");
277	CGICDEBUGEND
278	#endif /* CGICDEBUG */
279	cgiFreeResources();
280	return -1;
281	}
282	#ifdef CGICDEBUG
283	CGICDEBUGSTART
284	fprintf(dout, "PostMultipartInput succeeded\n");
285	CGICDEBUGEND
286	#endif /* CGICDEBUG */
287	}
288	} else if (cgiStrEqNc(cgiRequestMethod, "get")) {
289	/* The spec says this should be taken care of by
290	the server, but... it isn't */
291	cgiContentLength = strlen(cgiQueryString);
292	if (cgiParseGetFormInput() != cgiParseSuccess) {
293	#ifdef CGICDEBUG
294	CGICDEBUGSTART
295	fprintf(dout, "GetFormInput failed\n");
296	CGICDEBUGEND
297	#endif /* CGICDEBUG */
298	cgiFreeResources();
299	return -1;
300	} else {
301	#ifdef CGICDEBUG
302	CGICDEBUGSTART
303	fprintf(dout, "GetFormInput succeeded\n");
304	CGICDEBUGEND
305	#endif /* CGICDEBUG */
306	}
307	}
308	result = cgiMain();
309	cgiFreeResources();
310	}
311	FCGI_Finish();
312	return result;
313	}
314
315	static void cgiGetenv(char *s, char var){
316	*s = getenv(var);
317	if (!(*s)) {
318	*s = "";
319	}
320	}
321
322	static cgiParseResultType cgiParsePostFormInput() {
323	char *input;
324	cgiParseResultType result;
325	if (!cgiContentLength) {
326	return cgiParseSuccess;
327	}
328	input = (char *) malloc(cgiContentLength);
329	if (!input) {
330	return cgiParseMemory;
331	}
332	if (((int) fread(input, 1, cgiContentLength, cgiIn))
333	!= cgiContentLength)
334	{
335	return cgiParseIO;
336	}
337	result = cgiParseFormInput(input, cgiContentLength);
338	free(input);
339	return result;
340	}
341
342	/* 2.0: A virtual datastream supporting putback of
343	enough characters to handle multipart boundaries easily.
344	A simple memset(&mp, 0, sizeof(mp)) is suitable initialization. */
345
346	typedef struct {
347	/* Buffer for putting characters back */
348	char putback[1024];
349	/* Position in putback from which next character will be read.
350	If readPos == writePos, then next character should
351	come from cgiIn. */
352	int readPos;
353	/* Position in putback to which next character will be put back.
354	If writePos catches up to readPos, as opposed to the other
355	way around, the stream no longer functions properly.
356	Calling code must guarantee that no more than
357	sizeof(putback) bytes are put back at any given time. */
358	int writePos;
359	/* Offset in the virtual datastream; can be compared
360	to cgiContentLength */
361	int offset;
362	} mpStream, *mpStreamPtr;
363
364	int mpRead(mpStreamPtr mpp, char *buffer, int len)
365	{
366	int ilen = len;
367	int got = 0;
368	while (len) {
369	if (mpp->readPos != mpp->writePos) {
370	*buffer++ = mpp->putback[mpp->readPos++];
371	mpp->readPos %= sizeof(mpp->putback);
372	got++;
373	len--;
374	} else {
375	break;
376	}
377	}
378	/* Refuse to read past the declared length in order to
379	avoid deadlock */
380	if (len > (cgiContentLength - mpp->offset)) {
381	len = cgiContentLength - mpp->offset;
382	}
383	if (len) {
384	int fgot = fread(buffer, 1, len, cgiIn);
385	if (fgot >= 0) {
386	mpp->offset += (got + fgot);
387	return got + fgot;
388	} else if (got > 0) {
389	mpp->offset += got;
390	return got;
391	} else {
392	/* EOF or error */
393	return fgot;
394	}
395	} else if (got) {
396	return got;
397	} else if (ilen) {
398	return EOF;
399	} else {
400	/* 2.01 */
401	return 0;
402	}
403	}
404
405	void mpPutBack(mpStreamPtr mpp, char *data, int len)
406	{
407	mpp->offset -= len;
408	while (len) {
409	mpp->putback[mpp->writePos++] = *data++;
410	mpp->writePos %= sizeof(mpp->putback);
411	len--;
412	}
413	}
414
415	/* This function copies the body to outf if it is not null, otherwise to
416	a newly allocated character buffer at *outP, which will be null
417	terminated; if both outf and outP are null the body is not stored.
418	If bodyLengthP is not null, the size of the body in bytes is stored
419	to bodyLengthP, not including any terminating null added to outP.
420	If 'first' is nonzero, a preceding newline is not expected before
421	the boundary. If 'first' is zero, a preceding newline is expected.
422	Upon return mpp is positioned after the boundary and its trailing
423	newline, if any; if the boundary is followed by -- the next two
424	characters read after this function returns will be --. Upon error,
425	if outP is not null, outP is a null pointer; bodyLengthP
426	is set to zero. Returns cgiParseSuccess, cgiParseMemory
427	or cgiParseIO. */
428
429	static cgiParseResultType afterNextBoundary(mpStreamPtr mpp,
430	FILE *outf,
431	char **outP,
432	int *bodyLengthP,
433	int first
434	);
435
436	static int readHeaderLine(
437	mpStreamPtr mpp,
438	char *attr,
439	int attrSpace,
440	char *value,
441	int valueSpace);
442
443	static void decomposeValue(char *value,
444	char *mvalue, int mvalueSpace,
445	char **argNames,
446	char **argValues,
447	int argValueSpace);
448
449	/* tfileName must be 1024 bytes to ensure adequacy on
450	win32 (1024 exceeds the maximum path length and
451	certainly exceeds observed behavior of _tmpnam).
452	May as well also be 1024 bytes on Unix, although actual
453	length is strlen(cgiTempDir) + a short unique pattern. */
454
455	static cgiParseResultType getTempFileName(char *tfileName);
456
457	static cgiParseResultType cgiParsePostMultipartInput() {
458	cgiParseResultType result;
459	cgiFormEntry n = 0, l = 0;
460	int got;
461	FILE *outf = 0;
462	char *out = 0;
463	char tfileName[1024];
464	mpStream mp;
465	mpStreamPtr mpp = &mp;
466	memset(&mp, 0, sizeof(mp));
467	if (!cgiContentLength) {
468	return cgiParseSuccess;
469	}
470	/* Read first boundary, including trailing newline */
471	result = afterNextBoundary(mpp, 0, 0, 0, 1);
472	if (result == cgiParseIO) {
473	/* An empty submission is not necessarily an error */
474	return cgiParseSuccess;
475	} else if (result != cgiParseSuccess) {
476	return result;
477	}
478	while (1) {
479	char d[1024];
480	char fvalue[1024];
481	char fname[1024];
482	int bodyLength = 0;
483	char ffileName[1024];
484	char fcontentType[1024];
485	char attr[1024];
486	char value[1024];
487	fvalue[0] = 0;
488	fname[0] = 0;
489	ffileName[0] = 0;
490	fcontentType[0] = 0;
491	out = 0;
492	outf = 0;
493	/* Check for EOF */
494	got = mpRead(mpp, d, 2);
495	if (got < 2) {
496	/* Crude EOF */
497	break;
498	}
499	if ((d[0] == '-') && (d[1] == '-')) {
500	/* Graceful EOF */
501	break;
502	}
503	mpPutBack(mpp, d, 2);
504	/* Read header lines until end of header */
505	while (readHeaderLine(
506	mpp, attr, sizeof(attr), value, sizeof(value)))
507	{
508	char *argNames[3];
509	char *argValues[2];
510	/* Content-Disposition: form-data;
511	name="test"; filename="googley.gif" */
512	if (cgiStrEqNc(attr, "Content-Disposition")) {
513	argNames[0] = "name";
514	argNames[1] = "filename";
515	argNames[2] = 0;
516	argValues[0] = fname;
517	argValues[1] = ffileName;
518	decomposeValue(value,
519	fvalue, sizeof(fvalue),
520	argNames,
521	argValues,
522	1024);
523	} else if (cgiStrEqNc(attr, "Content-Type")) {
524	argNames[0] = 0;
525	decomposeValue(value,
526	fcontentType, sizeof(fcontentType),
527	argNames,
528	0,
529	0);
530	}
531	}
532	if (!cgiStrEqNc(fvalue, "form-data")) {
533	/* Not form data */
534	continue;
535	}
536	/* Body is everything from here until the next
537	boundary. So, set it aside and move past boundary.
538	If a filename was submitted as part of the
539	disposition header, store to a temporary file.
540	Otherwise, store to a memory buffer (it is
541	presumably a regular form field). */
542	if (strlen(ffileName)) {
543	if (getTempFileName(tfileName) != cgiParseSuccess) {
544	return cgiParseIO;
545	}
546	outf = fopen(tfileName, "w+b");
547	} else {
548	outf = 0;
549	tfileName[0] = '\0';
550	}
551	result = afterNextBoundary(mpp, outf, &out, &bodyLength, 0);
552	if (result != cgiParseSuccess) {
553	/* Lack of a boundary here is an error. */
554	if (outf) {
555	fclose(outf);
556	unlink(tfileName);
557	}
558	if (out) {
559	free(out);
560	}
561	return result;
562	}
563	/* OK, we have a new pair, add it to the list. */
564	n = (cgiFormEntry *) malloc(sizeof(cgiFormEntry));
565	if (!n) {
566	goto outOfMemory;
567	}
568	memset(n, 0, sizeof(cgiFormEntry));
569	/* 2.01: one of numerous new casts required
570	to please C++ compilers */
571	n->attr = (char *) malloc(strlen(fname) + 1);
572	if (!n->attr) {
573	goto outOfMemory;
574	}
575	strcpy(n->attr, fname);
576	if (out) {
577	n->value = out;
578	out = 0;
579	} else if (outf) {
580	n->value = (char *) malloc(1);
581	if (!n->value) {
582	goto outOfMemory;
583	}
584	n->value[0] = '\0';
585	fclose(outf);
586	}
587	n->valueLength = bodyLength;
588	n->next = 0;
589	if (!l) {
590	cgiFormEntryFirst = n;
591	} else {
592	l->next = n;
593	}
594	n->fileName = (char *) malloc(strlen(ffileName) + 1);
595	if (!n->fileName) {
596	goto outOfMemory;
597	}
598	strcpy(n->fileName, ffileName);
599	n->contentType = (char *) malloc(strlen(fcontentType) + 1);
600	if (!n->contentType) {
601	goto outOfMemory;
602	}
603	strcpy(n->contentType, fcontentType);
604	n->tfileName = (char *) malloc(strlen(tfileName) + 1);
605	if (!n->tfileName) {
606	goto outOfMemory;
607	}
608	strcpy(n->tfileName, tfileName);
609
610	l = n;
611	}
612	return cgiParseSuccess;
613	outOfMemory:
614	if (n) {
615	if (n->attr) {
616	free(n->attr);
617	}
618	if (n->value) {
619	free(n->value);
620	}
621	if (n->fileName) {
622	free(n->fileName);
623	}
624	if (n->tfileName) {
625	free(n->tfileName);
626	}
627	if (n->contentType) {
628	free(n->contentType);
629	}
630	free(n);
631	}
632	if (out) {
633	free(out);
634	}
635	if (outf) {
636	fclose(outf);
637	unlink(tfileName);
638	}
639	return cgiParseMemory;
640	}
641
642	static cgiParseResultType getTempFileName(char *tfileName)
643	{
644	#ifndef WIN32
645	/* Unix. Use the robust 'mkstemp' function to create
646	a temporary file that is truly unique, with
647	permissions that are truly safe. The
648	fopen-for-write destroys any bogus information
649	written by potential hackers during the brief
650	window between the file's creation and the
651	chmod call (glibc 2.0.6 and lower might
652	otherwise have allowed this). */
653	int outfd;
654	strcpy(tfileName, cgicTempDir "/cgicXXXXXX");
655	outfd = mkstemp(tfileName);
656	if (outfd == -1) {
657	return cgiParseIO;
658	}
659	close(outfd);
660	/* Fix the permissions */
661	if (chmod(tfileName, 0600) != 0) {
662	unlink(tfileName);
663	return cgiParseIO;
664	}
665	#else
666	/* Non-Unix. Do what we can. */
667	if (!tmpnam(tfileName)) {
668	return cgiParseIO;
669	}
670	#endif
671	return cgiParseSuccess;
672	}
673
674
675	#define APPEND(string, char) \
676	{ \
677	if ((string##Len + 1) < string##Space) { \
678	string[string##Len++] = (char); \
679	} \
680	}
681
682	#define RAPPEND(string, ch) \
683	{ \
684	if ((string##Len + 1) == string##Space) { \
685	char *sold = string; \
686	string##Space *= 2; \
687	string = (char *) realloc(string, string##Space); \
688	if (!string) { \
689	string = sold; \
690	goto outOfMemory; \
691	} \
692	} \
693	string[string##Len++] = (ch); \
694	}
695
696	#define BAPPEND(ch) \
697	{ \
698	if (outf) { \
699	putc(ch, outf); \
700	outLen++; \
701	} else if (out) { \
702	RAPPEND(out, ch); \
703	} \
704	}
705
706	cgiParseResultType afterNextBoundary(mpStreamPtr mpp, FILE outf, char *outP,
707	int *bodyLengthP, int first)
708	{
709	int outLen = 0;
710	int outSpace = 256;
711	char *out = 0;
712	cgiParseResultType result;
713	int boffset;
714	int got;
715	char d[2];
716	/* This is large enough, because the buffer into which the
717	original boundary string is fetched is shorter by more
718	than four characters due to the space required for
719	the attribute name */
720	char workingBoundaryData[1024];
721	char *workingBoundary = workingBoundaryData;
722	int workingBoundaryLength;
723	if ((!outf) && (outP)) {
724	out = (char *) malloc(outSpace);
725	if (!out) {
726	goto outOfMemory;
727	}
728	}
729	boffset = 0;
730	sprintf(workingBoundaryData, "\r\n--%s", cgiMultipartBoundary);
731	if (first) {
732	workingBoundary = workingBoundaryData + 2;
733	}
734	workingBoundaryLength = strlen(workingBoundary);
735	while (1) {
736	got = mpRead(mpp, d, 1);
737	if (got != 1) {
738	/* 2.01: cgiParseIO, not cgiFormIO */
739	result = cgiParseIO;
740	goto error;
741	}
742	if (d[0] == workingBoundary[boffset]) {
743	/* We matched the next byte of the boundary.
744	Keep track of our progress into the
745	boundary and don't emit anything. */
746	boffset++;
747	if (boffset == workingBoundaryLength) {
748	break;
749	}
750	} else if (boffset > 0) {
751	/* We matched part, but not all, of the
752	boundary. Now we have to be careful:
753	put back all except the first
754	character and try again. The
755	real boundary could begin in the
756	middle of a false match. We can
757	emit the first character only so far. */
758	BAPPEND(workingBoundary[0]);
759	mpPutBack(mpp,
760	workingBoundary + 1, boffset - 1);
761	mpPutBack(mpp, d, 1);
762	boffset = 0;
763	} else {
764	/* Not presently in the middle of a boundary
765	match; just emit the character. */
766	BAPPEND(d[0]);
767	}
768	}
769	/* Read trailing newline or -- EOF marker. A literal EOF here
770	would be an error in the input stream. */
771	got = mpRead(mpp, d, 2);
772	if (got != 2) {
773	result = cgiParseIO;
774	goto error;
775	}
776	if ((d[0] == '\r') && (d[1] == '\n')) {
777	/* OK, EOL */
778	} else if (d[0] == '-') {
779	/* Probably EOF, but we check for
780	that later */
781	mpPutBack(mpp, d, 2);
782	}
783	if (out && outSpace) {
784	char *oout = out;
785	out[outLen] = '\0';
786	out = (char *) realloc(out, outLen + 1);
787	if (!out) {
788	/* Surprising if it happens; and not fatal! We were
789	just trying to give some space back. We can
790	keep it if we have to. */
791	out = oout;
792	}
793	*outP = out;
794	}
795	if (bodyLengthP) {
796	*bodyLengthP = outLen;
797	}
798	return cgiParseSuccess;
799	outOfMemory:
800	result = cgiParseMemory;
801	if (outP) {
802	if (out) {
803	free(out);
804	}
805	*outP = '\0';
806	}
807	error:
808	if (bodyLengthP) {
809	*bodyLengthP = 0;
810	}
811	if (out) {
812	free(out);
813	}
814	if (outP) {
815	*outP = 0;
816	}
817	return result;
818	}
819
820	static void decomposeValue(char *value,
821	char *mvalue, int mvalueSpace,
822	char **argNames,
823	char **argValues,
824	int argValueSpace)
825	{
826	char argName[1024];
827	int argNameSpace = sizeof(argName);
828	int argNameLen = 0;
829	int mvalueLen = 0;
830	char *argValue;
831	int argNum = 0;
832	while (argNames[argNum]) {
833	if (argValueSpace) {
834	argValues[argNum][0] = '\0';
835	}
836	argNum++;
837	}
838	while (isspace(*value)) {
839	value++;
840	}
841	/* Quoted mvalue */
842	if (*value == '\"') {
843	value++;
844	while ((value) && (value != '\"')) {
845	APPEND(mvalue, *value);
846	value++;
847	}
848	while ((value) && (value != ';')) {
849	value++;
850	}
851	} else {
852	/* Unquoted mvalue */
853	while ((value) && (value != ';')) {
854	APPEND(mvalue, *value);
855	value++;
856	}
857	}
858	if (mvalueSpace) {
859	mvalue[mvalueLen] = '\0';
860	}
861	while (*value == ';') {
862	int argNum;
863	int argValueLen = 0;
864	/* Skip the ; between parameters */
865	value++;
866	/* Now skip leading whitespace */
867	while ((value) && (isspace(value))) {
868	value++;
869	}
870	/* Now read the parameter name */
871	argNameLen = 0;
872	while ((value) && (isalnum(value))) {
873	APPEND(argName, *value);
874	value++;
875	}
876	if (argNameSpace) {
877	argName[argNameLen] = '\0';
878	}
879	while ((value) && isspace(value)) {
880	value++;
881	}
882	if (*value != '=') {
883	/* Malformed line */
884	return;
885	}
886	value++;
887	while ((value) && isspace(value)) {
888	value++;
889	}
890	/* Find the parameter in the argument list, if present */
891	argNum = 0;
892	argValue = 0;
893	while (argNames[argNum]) {
894	if (cgiStrEqNc(argName, argNames[argNum])) {
895	argValue = argValues[argNum];
896	break;
897	}
898	argNum++;
899	}
900	/* Finally, read the parameter value */
901	if (*value == '\"') {
902	value++;
903	while ((value) && (value != '\"')) {
904	if (argValue) {
905	APPEND(argValue, *value);
906	}
907	value++;
908	}
909	while ((value) && (value != ';')) {
910	value++;
911	}
912	} else {
913	/* Unquoted value */
914	while ((value) && (value != ';')) {
915	if (argNames[argNum]) {
916	APPEND(argValue, *value);
917	}
918	value++;
919	}
920	}
921	if (argValueSpace) {
922	argValue[argValueLen] = '\0';
923	}
924	}
925	}
926
927	static int readHeaderLine(
928	mpStreamPtr mpp,
929	char *attr,
930	int attrSpace,
931	char *value,
932	int valueSpace)
933	{
934	int attrLen = 0;
935	int valueLen = 0;
936	int valueFound = 0;
937	while (1) {
938	char d[1];
939	int got = mpRead(mpp, d, 1);
940	if (got != 1) {
941	return 0;
942	}
943	if (d[0] == '\r') {
944	got = mpRead(mpp, d, 1);
945	if (got == 1) {
946	if (d[0] == '\n') {
947	/* OK */
948	} else {
949	mpPutBack(mpp, d, 1);
950	}
951	}
952	break;
953	} else if (d[0] == '\n') {
954	break;
955	} else if ((d[0] == ':') && attrLen) {
956	valueFound = 1;
957	while (mpRead(mpp, d, 1) == 1) {
958	if (!isspace(d[0])) {
959	mpPutBack(mpp, d, 1);
960	break;
961	}
962	}
963	} else if (!valueFound) {
964	if (!isspace(*d)) {
965	if (attrLen < (attrSpace - 1)) {
966	attr[attrLen++] = *d;
967	}
968	}
969	} else if (valueFound) {
970	if (valueLen < (valueSpace - 1)) {
971	value[valueLen++] = *d;
972	}
973	}
974	}
975	if (attrSpace) {
976	attr[attrLen] = '\0';
977	}
978	if (valueSpace) {
979	value[valueLen] = '\0';
980	}
981	if (attrLen && valueLen) {
982	return 1;
983	} else {
984	return 0;
985	}
986	}
987
988	static cgiParseResultType cgiParseGetFormInput() {
989	return cgiParseFormInput(cgiQueryString, cgiContentLength);
990	}
991
992	typedef enum {
993	cgiEscapeRest,
994	cgiEscapeFirst,
995	cgiEscapeSecond
996	} cgiEscapeState;
997
998	typedef enum {
999	cgiUnescapeSuccess,
1000	cgiUnescapeMemory
1001	} cgiUnescapeResultType;
1002
1003	static cgiUnescapeResultType cgiUnescapeChars(char *sp, char cp, int len);
1004
1005	static cgiParseResultType cgiParseFormInput(char *data, int length) {
1006	/* Scan for pairs, unescaping and storing them as they are found. */
1007	int pos = 0;
1008	cgiFormEntry *n;
1009	cgiFormEntry *l = 0;
1010	while (pos != length) {
1011	int foundEq = 0;
1012	int foundAmp = 0;
1013	int start = pos;
1014	int len = 0;
1015	char *attr;
1016	char *value;
1017	while (pos != length) {
1018	if (data[pos] == '=') {
1019	foundEq = 1;
1020	pos++;
1021	break;
1022	}
1023	pos++;
1024	len++;
1025	}
1026	if (!foundEq) {
1027	break;
1028	}
1029	if (cgiUnescapeChars(&attr, data+start, len)
1030	!= cgiUnescapeSuccess) {
1031	return cgiParseMemory;
1032	}
1033	start = pos;
1034	len = 0;
1035	while (pos != length) {
1036	if (data[pos] == '&') {
1037	foundAmp = 1;
1038	pos++;
1039	break;
1040	}
1041	pos++;
1042	len++;
1043	}
1044	/* The last pair probably won't be followed by a &, but
1045	that's fine, so check for that after accepting it */
1046	if (cgiUnescapeChars(&value, data+start, len)
1047	!= cgiUnescapeSuccess) {
1048	free(attr);
1049	return cgiParseMemory;
1050	}
1051	/* OK, we have a new pair, add it to the list. */
1052	n = (cgiFormEntry *) malloc(sizeof(cgiFormEntry));
1053	if (!n) {
1054	free(attr);
1055	free(value);
1056	return cgiParseMemory;
1057	}
1058	n->attr = attr;
1059	n->value = value;
1060	n->valueLength = strlen(n->value);
1061	n->fileName = (char *) malloc(1);
1062	if (!n->fileName) {
1063	free(attr);
1064	free(value);
1065	free(n);
1066	return cgiParseMemory;
1067	}
1068	n->fileName[0] = '\0';
1069	n->contentType = (char *) malloc(1);
1070	if (!n->contentType) {
1071	free(attr);
1072	free(value);
1073	free(n->fileName);
1074	free(n);
1075	return cgiParseMemory;
1076	}
1077	n->contentType[0] = '\0';
1078	n->tfileName = (char *) malloc(1);
1079	if (!n->tfileName) {
1080	free(attr);
1081	free(value);
1082	free(n->fileName);
1083	free(n->contentType);
1084	free(n);
1085	return cgiParseMemory;
1086	}
1087	n->tfileName[0] = '\0';
1088	n->next = 0;
1089	if (!l) {
1090	cgiFormEntryFirst = n;
1091	} else {
1092	l->next = n;
1093	}
1094	l = n;
1095	if (!foundAmp) {
1096	break;
1097	}
1098	}
1099	return cgiParseSuccess;
1100	}
1101
1102	static int cgiHexValue[256];
1103
1104	cgiUnescapeResultType cgiUnescapeChars(char *sp, char cp, int len) {
1105	char *s;
1106	cgiEscapeState escapeState = cgiEscapeRest;
1107	int escapedValue = 0;
1108	int srcPos = 0;
1109	int dstPos = 0;
1110	s = (char *) malloc(len + 1);
1111	if (!s) {
1112	return cgiUnescapeMemory;
1113	}
1114	while (srcPos < len) {
1115	int ch = cp[srcPos];
1116	if(cgiTreatUrlEncoding==1)
1117	switch (escapeState) {
1118	case cgiEscapeRest:
1119	if (ch == '%') {
1120	escapeState = cgiEscapeFirst;
1121	} else if (ch == '+') {
1122	s[dstPos++] = ' ';
1123	} else {
1124	s[dstPos++] = ch;
1125	}
1126	break;
1127	case cgiEscapeFirst:
1128	escapedValue = cgiHexValue[ch] << 4;
1129	escapeState = cgiEscapeSecond;
1130	break;
1131	case cgiEscapeSecond:
1132	escapedValue += cgiHexValue[ch];
1133	s[dstPos++] = escapedValue;
1134	escapeState = cgiEscapeRest;
1135	break;
1136	}
1137	else
1138	s[dstPos++] = ch;
1139	srcPos++;
1140	}
1141	s[dstPos] = '\0';
1142	*sp = s;
1143	return cgiUnescapeSuccess;
1144	}
1145
1146	static void cgiSetupConstants() {
1147	int i;
1148	for (i=0; (i < 256); i++) {
1149	cgiHexValue[i] = 0;
1150	}
1151	cgiHexValue['0'] = 0;
1152	cgiHexValue['1'] = 1;
1153	cgiHexValue['2'] = 2;
1154	cgiHexValue['3'] = 3;
1155	cgiHexValue['4'] = 4;
1156	cgiHexValue['5'] = 5;
1157	cgiHexValue['6'] = 6;
1158	cgiHexValue['7'] = 7;
1159	cgiHexValue['8'] = 8;
1160	cgiHexValue['9'] = 9;
1161	cgiHexValue['A'] = 10;
1162	cgiHexValue['B'] = 11;
1163	cgiHexValue['C'] = 12;
1164	cgiHexValue['D'] = 13;
1165	cgiHexValue['E'] = 14;
1166	cgiHexValue['F'] = 15;
1167	cgiHexValue['a'] = 10;
1168	cgiHexValue['b'] = 11;
1169	cgiHexValue['c'] = 12;
1170	cgiHexValue['d'] = 13;
1171	cgiHexValue['e'] = 14;
1172	cgiHexValue['f'] = 15;
1173	}
1174
1175	static void cgiFreeResources() {
1176	cgiFormEntry *c = cgiFormEntryFirst;
1177	cgiFormEntry *n;
1178	while (c) {
1179	n = c->next;
1180	free(c->attr);
1181	free(c->value);
1182	free(c->fileName);
1183	free(c->contentType);
1184	if (strlen(c->tfileName)) {
1185	unlink(c->tfileName);
1186	}
1187	free(c->tfileName);
1188	free(c);
1189	c = n;
1190	}
1191	/* If the cgi environment was restored from a saved environment,
1192	then these are in allocated space and must also be freed */
1193	if (cgiRestored) {
1194	free(cgiServerSoftware);
1195	free(cgiServerName);
1196	free(cgiGatewayInterface);
1197	free(cgiServerProtocol);
1198	free(cgiServerPort);
1199	free(cgiRequestMethod);
1200	free(cgiPathInfo);
1201	free(cgiPathTranslated);
1202	free(cgiScriptName);
1203	free(cgiQueryString);
1204	free(cgiRemoteHost);
1205	free(cgiRemoteAddr);
1206	free(cgiAuthType);
1207	free(cgiRemoteUser);
1208	free(cgiRemoteIdent);
1209	free(cgiContentType);
1210	free(cgiAccept);
1211	free(cgiUserAgent);
1212	free(cgiReferrer);
1213	}
1214	/* 2.0: to clean up the environment for cgiReadEnvironment,
1215	we must set these correctly */
1216	cgiFormEntryFirst = 0;
1217	cgiRestored = 0;
1218	}
1219
1220	static cgiFormResultType cgiFormEntryString(
1221	cgiFormEntry e, char result, int max, int newlines);
1222
1223	static cgiFormEntry cgiFormEntryFindFirst(char name);
1224	static cgiFormEntry *cgiFormEntryFindNext();
1225
1226	cgiFormResultType cgiFormString(
1227	char name, char result, int max) {
1228	cgiFormEntry *e;
1229	e = cgiFormEntryFindFirst(name);
1230	if (!e) {
1231	strcpy(result, "");
1232	return cgiFormNotFound;
1233	}
1234	return cgiFormEntryString(e, result, max, 1);
1235	}
1236
1237	cgiFormResultType cgiFormFileName(
1238	char name, char result, int resultSpace)
1239	{
1240	cgiFormEntry *e;
1241	int resultLen = 0;
1242	char *s;
1243	e = cgiFormEntryFindFirst(name);
1244	if (!e) {
1245	strcpy(result, "");
1246	return cgiFormNotFound;
1247	}
1248	s = e->fileName;
1249	while (*s) {
1250	APPEND(result, *s);
1251	s++;
1252	}
1253	if (resultSpace) {
1254	result[resultLen] = '\0';
1255	}
1256	if (!strlen(e->fileName)) {
1257	return cgiFormNoFileName;
1258	} else if (((int) strlen(e->fileName)) > (resultSpace - 1)) {
1259	return cgiFormTruncated;
1260	} else {
1261	return cgiFormSuccess;
1262	}
1263	}
1264
1265	cgiFormResultType cgiFormFileContentType(
1266	char name, char result, int resultSpace)
1267	{
1268	cgiFormEntry *e;
1269	int resultLen = 0;
1270	char *s;
1271	e = cgiFormEntryFindFirst(name);
1272	if (!e) {
1273	if (resultSpace) {
1274	result[0] = '\0';
1275	}
1276	return cgiFormNotFound;
1277	}
1278	s = e->contentType;
1279	while (*s) {
1280	APPEND(result, *s);
1281	s++;
1282	}
1283	if (resultSpace) {
1284	result[resultLen] = '\0';
1285	}
1286	if (!strlen(e->contentType)) {
1287	return cgiFormNoContentType;
1288	} else if (((int) strlen(e->contentType)) > (resultSpace - 1)) {
1289	return cgiFormTruncated;
1290	} else {
1291	return cgiFormSuccess;
1292	}
1293	}
1294
1295	cgiFormResultType cgiFormFileSize(
1296	char name, int sizeP)
1297	{
1298	cgiFormEntry *e;
1299	e = cgiFormEntryFindFirst(name);
1300	if (!e) {
1301	if (sizeP) {
1302	*sizeP = 0;
1303	}
1304	return cgiFormNotFound;
1305	} else if (!strlen(e->tfileName)) {
1306	if (sizeP) {
1307	*sizeP = 0;
1308	}
1309	return cgiFormNotAFile;
1310	} else {
1311	if (sizeP) {
1312	*sizeP = e->valueLength;
1313	}
1314	return cgiFormSuccess;
1315	}
1316	}
1317
1318	typedef struct cgiFileStruct {
1319	FILE *in;
1320	} cgiFile;
1321
1322	cgiFormResultType cgiFormFileOpen(
1323	char name, cgiFilePtr cfpp)
1324	{
1325	cgiFormEntry *e;
1326	cgiFilePtr cfp;
1327	e = cgiFormEntryFindFirst(name);
1328	if (!e) {
1329	*cfpp = 0;
1330	return cgiFormNotFound;
1331	}
1332	if (!strlen(e->tfileName)) {
1333	*cfpp = 0;
1334	return cgiFormNotAFile;
1335	}
1336	cfp = (cgiFilePtr) malloc(sizeof(cgiFile));
1337	if (!cfp) {
1338	*cfpp = 0;
1339	return cgiFormMemory;
1340	}
1341	cfp->in = fopen(e->tfileName, "rb");
1342	if (!cfp->in) {
1343	free(cfp);
1344	return cgiFormIO;
1345	}
1346	*cfpp = cfp;
1347	return cgiFormSuccess;
1348	}
1349
1350	cgiFormResultType cgiFormFileRead(
1351	cgiFilePtr cfp, char *buffer,
1352	int bufferSize, int *gotP)
1353	{
1354	int got = 0;
1355	if (!cfp) {
1356	return cgiFormOpenFailed;
1357	}
1358	got = fread(buffer, 1, bufferSize, cfp->in);
1359	if (got <= 0) {
1360	return cgiFormEOF;
1361	}
1362	*gotP = got;
1363	return cgiFormSuccess;
1364	}
1365
1366	cgiFormResultType cgiFormFileClose(cgiFilePtr cfp)
1367	{
1368	if (!cfp) {
1369	return cgiFormOpenFailed;
1370	}
1371	fclose(cfp->in);
1372	free(cfp);
1373	return cgiFormSuccess;
1374	}
1375
1376	cgiFormResultType cgiFormStringNoNewlines(
1377	char name, char result, int max) {
1378	cgiFormEntry *e;
1379	e = cgiFormEntryFindFirst(name);
1380	if (!e) {
1381	strcpy(result, "");
1382	return cgiFormNotFound;
1383	}
1384	return cgiFormEntryString(e, result, max, 0);
1385	}
1386
1387	cgiFormResultType cgiFormStringMultiple(
1388	char name, char **result) {
1389	char **stringArray;
1390	cgiFormEntry *e;
1391	int i;
1392	int total = 0;
1393	/* Make two passes. One would be more efficient, but this
1394	function is not commonly used. The select menu and
1395	radio box functions are faster. */
1396	e = cgiFormEntryFindFirst(name);
1397	if (e != 0) {
1398	do {
1399	total++;
1400	} while ((e = cgiFormEntryFindNext()) != 0);
1401	}
1402	stringArray = (char *) malloc(sizeof(char ) * (total + 1));
1403	if (!stringArray) {
1404	*result = 0;
1405	return cgiFormMemory;
1406	}
1407	/* initialize all entries to null; the last will stay that way */
1408	for (i=0; (i <= total); i++) {
1409	stringArray[i] = 0;
1410	}
1411	/* Now go get the entries */
1412	e = cgiFormEntryFindFirst(name);
1413	#ifdef CGICDEBUG
1414	CGICDEBUGSTART
1415	fprintf(dout, "StringMultiple Beginning\n");
1416	CGICDEBUGEND
1417	#endif /* CGICDEBUG */
1418	if (e) {
1419	i = 0;
1420	do {
1421	int max = (int) (strlen(e->value) + 1);
1422	stringArray[i] = (char *) malloc(max);
1423	if (stringArray[i] == 0) {
1424	/* Memory problems */
1425	cgiStringArrayFree(stringArray);
1426	*result = 0;
1427	return cgiFormMemory;
1428	}
1429	strcpy(stringArray[i], e->value);
1430	cgiFormEntryString(e, stringArray[i], max, 1);
1431	i++;
1432	} while ((e = cgiFormEntryFindNext()) != 0);
1433	*result = stringArray;
1434	#ifdef CGICDEBUG
1435	CGICDEBUGSTART
1436	fprintf(dout, "StringMultiple Succeeding\n");
1437	CGICDEBUGEND
1438	#endif /* CGICDEBUG */
1439	return cgiFormSuccess;
1440	} else {
1441	*result = stringArray;
1442	#ifdef CGICDEBUG
1443	CGICDEBUGSTART
1444	fprintf(dout, "StringMultiple found nothing\n");
1445	CGICDEBUGEND
1446	#endif /* CGICDEBUG */
1447	return cgiFormNotFound;
1448	}
1449	}
1450
1451	cgiFormResultType cgiFormStringSpaceNeeded(
1452	char name, int result) {
1453	cgiFormEntry *e;
1454	e = cgiFormEntryFindFirst(name);
1455	if (!e) {
1456	*result = 1;
1457	return cgiFormNotFound;
1458	}
1459	*result = ((int) strlen(e->value)) + 1;
1460	return cgiFormSuccess;
1461	}
1462
1463	static cgiFormResultType cgiFormEntryString(
1464	cgiFormEntry e, char result, int max, int newlines) {
1465	char dp, sp;
1466	int truncated = 0;
1467	int len = 0;
1468	int avail = max-1;
1469	int crCount = 0;
1470	int lfCount = 0;
1471	dp = result;
1472	sp = e->value;
1473	while (1) {
1474	int ch;
1475	/* 1.07: don't check for available space now.
1476	We check for it immediately before adding
1477	an actual character. 1.06 handled the
1478	trailing null of the source string improperly,
1479	resulting in a cgiFormTruncated error. */
1480	ch = *sp;
1481	/* Fix the CR/LF, LF, CR nightmare: watch for
1482	consecutive bursts of CRs and LFs in whatever
1483	pattern, then actually output the larger number
1484	of LFs. Consistently sane, yet it still allows
1485	consecutive blank lines when the user
1486	actually intends them. */
1487	if ((ch == 13) \|\| (ch == 10)) {
1488	if (ch == 13) {
1489	crCount++;
1490	} else {
1491	lfCount++;
1492	}
1493	} else {
1494	if (crCount \|\| lfCount) {
1495	int lfsAdd = crCount;
1496	if (lfCount > crCount) {
1497	lfsAdd = lfCount;
1498	}
1499	/* Stomp all newlines if desired */
1500	if (!newlines) {
1501	lfsAdd = 0;
1502	}
1503	while (lfsAdd) {
1504	if (len >= avail) {
1505	truncated = 1;
1506	break;
1507	}
1508	*dp = 10;
1509	dp++;
1510	lfsAdd--;
1511	len++;
1512	}
1513	crCount = 0;
1514	lfCount = 0;
1515	}
1516	if (ch == '\0') {
1517	/* The end of the source string */
1518	break;
1519	}
1520	/* 1.06: check available space before adding
1521	the character, because a previously added
1522	LF may have brought us to the limit */
1523	if (len >= avail) {
1524	truncated = 1;
1525	break;
1526	}
1527	*dp = ch;
1528	dp++;
1529	len++;
1530	}
1531	sp++;
1532	}
1533	*dp = '\0';
1534	if (truncated) {
1535	return cgiFormTruncated;
1536	} else if (!len) {
1537	return cgiFormEmpty;
1538	} else {
1539	return cgiFormSuccess;
1540	}
1541	}
1542
1543	static int cgiFirstNonspaceChar(char *s);
1544
1545	cgiFormResultType cgiFormInteger(
1546	char name, int result, int defaultV) {
1547	cgiFormEntry *e;
1548	int ch;
1549	e = cgiFormEntryFindFirst(name);
1550	if (!e) {
1551	*result = defaultV;
1552	return cgiFormNotFound;
1553	}
1554	if (!strlen(e->value)) {
1555	*result = defaultV;
1556	return cgiFormEmpty;
1557	}
1558	ch = cgiFirstNonspaceChar(e->value);
1559	if (!(isdigit(ch)) && (ch != '-') && (ch != '+')) {
1560	*result = defaultV;
1561	return cgiFormBadType;
1562	} else {
1563	*result = atoi(e->value);
1564	return cgiFormSuccess;
1565	}
1566	}
1567
1568	cgiFormResultType cgiFormIntegerBounded(
1569	char name, int result, int min, int max, int defaultV) {
1570	cgiFormResultType error = cgiFormInteger(name, result, defaultV);
1571	if (error != cgiFormSuccess) {
1572	return error;
1573	}
1574	if (*result < min) {
1575	*result = min;
1576	return cgiFormConstrained;
1577	}
1578	if (*result > max) {
1579	*result = max;
1580	return cgiFormConstrained;
1581	}
1582	return cgiFormSuccess;
1583	}
1584
1585	cgiFormResultType cgiFormDouble(
1586	char name, double result, double defaultV) {
1587	cgiFormEntry *e;
1588	int ch;
1589	e = cgiFormEntryFindFirst(name);
1590	if (!e) {
1591	*result = defaultV;
1592	return cgiFormNotFound;
1593	}
1594	if (!strlen(e->value)) {
1595	*result = defaultV;
1596	return cgiFormEmpty;
1597	}
1598	ch = cgiFirstNonspaceChar(e->value);
1599	if (!(isdigit(ch)) && (ch != '.') && (ch != '-') && (ch != '+')) {
1600	*result = defaultV;
1601	return cgiFormBadType;
1602	} else {
1603	*result = atof(e->value);
1604	return cgiFormSuccess;
1605	}
1606	}
1607
1608	cgiFormResultType cgiFormDoubleBounded(
1609	char name, double result, double min, double max, double defaultV) {
1610	cgiFormResultType error = cgiFormDouble(name, result, defaultV);
1611	if (error != cgiFormSuccess) {
1612	return error;
1613	}
1614	if (*result < min) {
1615	*result = min;
1616	return cgiFormConstrained;
1617	}
1618	if (*result > max) {
1619	*result = max;
1620	return cgiFormConstrained;
1621	}
1622	return cgiFormSuccess;
1623	}
1624
1625	cgiFormResultType cgiFormSelectSingle(
1626	char name, char *choicesText, int choicesTotal,
1627	int *result, int defaultV)
1628	{
1629	cgiFormEntry *e;
1630	int i;
1631	e = cgiFormEntryFindFirst(name);
1632	#ifdef CGICDEBUG
1633	CGICDEBUGSTART
1634	fprintf(dout, "%d\n", (int) e);
1635	CGICDEBUGEND
1636	#endif /* CGICDEBUG */
1637	if (!e) {
1638	*result = defaultV;
1639	return cgiFormNotFound;
1640	}
1641	for (i=0; (i < choicesTotal); i++) {
1642	#ifdef CGICDEBUG
1643	CGICDEBUGSTART
1644	fprintf(dout, "%s %s\n", choicesText[i], e->value);
1645	CGICDEBUGEND
1646	#endif /* CGICDEBUG */
1647	if (cgiStrEq(choicesText[i], e->value)) {
1648	#ifdef CGICDEBUG
1649	CGICDEBUGSTART
1650	fprintf(dout, "MATCH\n");
1651	CGICDEBUGEND
1652	#endif /* CGICDEBUG */
1653	*result = i;
1654	return cgiFormSuccess;
1655	}
1656	}
1657	*result = defaultV;
1658	return cgiFormNoSuchChoice;
1659	}
1660
1661	cgiFormResultType cgiFormSelectMultiple(
1662	char name, char *choicesText, int choicesTotal,
1663	int result, int invalid)
1664	{
1665	cgiFormEntry *e;
1666	int i;
1667	int hits = 0;
1668	int invalidE = 0;
1669	for (i=0; (i < choicesTotal); i++) {
1670	result[i] = 0;
1671	}
1672	e = cgiFormEntryFindFirst(name);
1673	if (!e) {
1674	*invalid = invalidE;
1675	return cgiFormNotFound;
1676	}
1677	do {
1678	int hit = 0;
1679	for (i=0; (i < choicesTotal); i++) {
1680	if (cgiStrEq(choicesText[i], e->value)) {
1681	result[i] = 1;
1682	hits++;
1683	hit = 1;
1684	break;
1685	}
1686	}
1687	if (!(hit)) {
1688	invalidE++;
1689	}
1690	} while ((e = cgiFormEntryFindNext()) != 0);
1691
1692	*invalid = invalidE;
1693
1694	if (hits) {
1695	return cgiFormSuccess;
1696	} else {
1697	return cgiFormNotFound;
1698	}
1699	}
1700
1701	cgiFormResultType cgiFormCheckboxSingle(
1702	char *name)
1703	{
1704	cgiFormEntry *e;
1705	e = cgiFormEntryFindFirst(name);
1706	if (!e) {
1707	return cgiFormNotFound;
1708	}
1709	return cgiFormSuccess;
1710	}
1711
1712	extern cgiFormResultType cgiFormCheckboxMultiple(
1713	char name, char *valuesText, int valuesTotal,
1714	int result, int invalid)
1715	{
1716	/* Implementation is identical to cgiFormSelectMultiple. */
1717	return cgiFormSelectMultiple(name, valuesText,
1718	valuesTotal, result, invalid);
1719	}
1720
1721	cgiFormResultType cgiFormRadio(
1722	char *name,
1723	char *valuesText, int valuesTotal, int result, int defaultV)
1724	{
1725	/* Implementation is identical to cgiFormSelectSingle. */
1726	return cgiFormSelectSingle(name, valuesText, valuesTotal,
1727	result, defaultV);
1728	}
1729
1730	cgiFormResultType cgiCookieString(
1731	char *name,
1732	char *value,
1733	int space)
1734	{
1735	char *p = cgiCookie;
1736	while (*p) {
1737	char *n = name;
1738	/* 2.02: if cgiCookie is exactly equal to name, this
1739	can cause an overrun. The server probably wouldn't
1740	allow it, since a name without values makes no sense
1741	-- but then again it might not check, so this is a
1742	genuine security concern. Thanks to Nicolas
1743	Tomadakis. */
1744	while (p == n) {
1745	if ((p == '\0') && (n == '\0')) {
1746	/* Malformed cookie header from client */
1747	return cgiFormNotFound;
1748	}
1749	p++;
1750	n++;
1751	}
1752	if ((!n) && (p == '=')) {
1753	p++;
1754	while ((p != ';') && (p != '\0') &&
1755	(space > 1))
1756	{
1757	value = p;
1758	value++;
1759	p++;
1760	space--;
1761	}
1762	if (space > 0) {
1763	*value = '\0';
1764	}
1765	/* Correct parens: 2.02. Thanks to
1766	Mathieu Villeneuve-Belair. */
1767	if (!(((p) == ';') \|\| ((p) == '\0')))
1768	{
1769	return cgiFormTruncated;
1770	} else {
1771	return cgiFormSuccess;
1772	}
1773	} else {
1774	/* Skip to next cookie */
1775	while (*p) {
1776	if (*p == ';') {
1777	break;
1778	}
1779	p++;
1780	}
1781	if (!*p) {
1782	/* 2.01: default to empty */
1783	if (space) {
1784	*value = '\0';
1785	}
1786	return cgiFormNotFound;
1787	}
1788	p++;
1789	/* Allow whitespace after semicolon */
1790	while ((p) && isspace(p)) {
1791	p++;
1792	}
1793	}
1794	}
1795	/* 2.01: actually the above loop never terminates except
1796	with a return, but do this to placate gcc */
1797	if (space) {
1798	*value = '\0';
1799	}
1800	return cgiFormNotFound;
1801	}
1802
1803	cgiFormResultType cgiCookieInteger(
1804	char *name,
1805	int *result,
1806	int defaultV)
1807	{
1808	char buffer[256];
1809	cgiFormResultType r =
1810	cgiCookieString(name, buffer, sizeof(buffer));
1811	if (r != cgiFormSuccess) {
1812	*result = defaultV;
1813	} else {
1814	*result = atoi(buffer);
1815	}
1816	return r;
1817	}
1818
1819	void cgiHeaderCookieSetInteger(char *name, int value, int secondsToLive,
1820	char path, char domain)
1821	{
1822	char svalue[256];
1823	sprintf(svalue, "%d", value);
1824	cgiHeaderCookieSetString(name, svalue, secondsToLive, path, domain);
1825	}
1826
1827	char *days[] = {
1828	"Sun",
1829	"Mon",
1830	"Tue",
1831	"Wed",
1832	"Thu",
1833	"Fri",
1834	"Sat"
1835	};
1836
1837	char *months[] = {
1838	"Jan",
1839	"Feb",
1840	"Mar",
1841	"Apr",
1842	"May",
1843	"Jun",
1844	"Jul",
1845	"Aug",
1846	"Sep",
1847	"Oct",
1848	"Nov",
1849	"Dec"
1850	};
1851
1852	void cgiHeaderCookieSetString(char name, char value, int secondsToLive,
1853	char path, char domain)
1854	{
1855	/* cgic 2.02: simpler and more widely compatible implementation.
1856	Thanks to Chunfu Lai.
1857	cgic 2.03: yes, but it didn't work. Reimplemented by
1858	Thomas Boutell. ; after last element was a bug.
1859	Examples of real world cookies that really work:
1860	Set-Cookie: MSNADS=UM=; domain=.slate.com;
1861	expires=Tue, 26-Apr-2022 19:00:00 GMT; path=/
1862	Set-Cookie: MC1=V=3&ID=b5bc08af2b8a43ff85fcb5efd8b238f0;
1863	domain=.slate.com; expires=Mon, 04-Oct-2021 19:00:00 GMT; path=/
1864	*/
1865	time_t now;
1866	time_t then;
1867	struct tm *gt;
1868	time(&now);
1869	then = now + secondsToLive;
1870	gt = gmtime(&then);
1871	fprintf(cgiOut,
1872	"Set-Cookie: %s=%s; domain=%s; expires=%s, %02d-%s-%04d %02d:%02d:%02d GMT; path=%s\r\n",
1873	name, value, domain,
1874	days[gt->tm_wday],
1875	gt->tm_mday,
1876	months[gt->tm_mon],
1877	gt->tm_year + 1900,
1878	gt->tm_hour,
1879	gt->tm_min,
1880	gt->tm_sec,
1881	path);
1882	}
1883
1884	void cgiHeaderLocation(char *redirectUrl) {
1885	fprintf(cgiOut, "Location: %s\r\n\r\n", redirectUrl);
1886	}
1887
1888	void cgiHeaderStatus(int status, char *statusMessage) {
1889	fprintf(cgiOut, "Status: %d %s\r\n\r\n", status, statusMessage);
1890	}
1891
1892	void cgiHeaderContentType(char *mimeType) {
1893	fprintf(cgiOut, "Content-type: %s\r\n\r\n", mimeType);
1894	}
1895
1896	static int cgiWriteString(FILE out, char s);
1897
1898	static int cgiWriteInt(FILE *out, int i);
1899
1900	#define CGIC_VERSION "2.0"
1901
1902	cgiEnvironmentResultType cgiWriteEnvironment(char *filename) {
1903	FILE *out;
1904	cgiFormEntry *e;
1905	/* Be sure to open in binary mode */
1906	out = fopen(filename, "wb");
1907	if (!out) {
1908	/* Can't create file */
1909	return cgiEnvironmentIO;
1910	}
1911	if (!cgiWriteString(out, "CGIC2.0")) {
1912	goto error;
1913	}
1914	if (!cgiWriteString(out, cgiServerSoftware)) {
1915	goto error;
1916	}
1917	if (!cgiWriteString(out, cgiServerName)) {
1918	goto error;
1919	}
1920	if (!cgiWriteString(out, cgiGatewayInterface)) {
1921	goto error;
1922	}
1923	if (!cgiWriteString(out, cgiServerProtocol)) {
1924	goto error;
1925	}
1926	if (!cgiWriteString(out, cgiServerPort)) {
1927	goto error;
1928	}
1929	if (!cgiWriteString(out, cgiRequestMethod)) {
1930	goto error;
1931	}
1932	if (!cgiWriteString(out, cgiPathInfo)) {
1933	goto error;
1934	}
1935	if (!cgiWriteString(out, cgiPathTranslated)) {
1936	goto error;
1937	}
1938	if (!cgiWriteString(out, cgiScriptName)) {
1939	goto error;
1940	}
1941	if (!cgiWriteString(out, cgiQueryString)) {
1942	goto error;
1943	}
1944	if (!cgiWriteString(out, cgiRemoteHost)) {
1945	goto error;
1946	}
1947	if (!cgiWriteString(out, cgiRemoteAddr)) {
1948	goto error;
1949	}
1950	if (!cgiWriteString(out, cgiAuthType)) {
1951	goto error;
1952	}
1953	if (!cgiWriteString(out, cgiRemoteUser)) {
1954	goto error;
1955	}
1956	if (!cgiWriteString(out, cgiRemoteIdent)) {
1957	goto error;
1958	}
1959	if (!cgiWriteString(out, cgiContentType)) {
1960	goto error;
1961	}
1962	if (!cgiWriteString(out, cgiAccept)) {
1963	goto error;
1964	}
1965	if (!cgiWriteString(out, cgiUserAgent)) {
1966	goto error;
1967	}
1968	if (!cgiWriteString(out, cgiReferrer)) {
1969	goto error;
1970	}
1971	if (!cgiWriteString(out, cgiCookie)) {
1972	goto error;
1973	}
1974	if (!cgiWriteInt(out, cgiContentLength)) {
1975	goto error;
1976	}
1977	e = cgiFormEntryFirst;
1978	while (e) {
1979	cgiFilePtr fp;
1980	if (!cgiWriteString(out, e->attr)) {
1981	goto error;
1982	}
1983	if (!cgiWriteString(out, e->value)) {
1984	goto error;
1985	}
1986	/* New 2.0 fields and file uploads */
1987	if (!cgiWriteString(out, e->fileName)) {
1988	goto error;
1989	}
1990	if (!cgiWriteString(out, e->contentType)) {
1991	goto error;
1992	}
1993	if (!cgiWriteInt(out, e->valueLength)) {
1994	goto error;
1995	}
1996	if (cgiFormFileOpen(e->attr, &fp) == cgiFormSuccess) {
1997	char buffer[1024];
1998	int got;
1999	if (!cgiWriteInt(out, 1)) {
2000	cgiFormFileClose(fp);
2001	goto error;
2002	}
2003	while (cgiFormFileRead(fp, buffer,
2004	sizeof(buffer), &got) == cgiFormSuccess)
2005	{
2006	if (((int) fwrite(buffer, 1, got, out)) != got) {
2007	cgiFormFileClose(fp);
2008	goto error;
2009	}
2010	}
2011	if (cgiFormFileClose(fp) != cgiFormSuccess) {
2012	goto error;
2013	}
2014	} else {
2015	if (!cgiWriteInt(out, 0)) {
2016	goto error;
2017	}
2018	}
2019	e = e->next;
2020	}
2021	fclose(out);
2022	return cgiEnvironmentSuccess;
2023	error:
2024	fclose(out);
2025	/* If this function is not defined in your system,
2026	you must substitute the appropriate
2027	file-deletion function. */
2028	unlink(filename);
2029	return cgiEnvironmentIO;
2030	}
2031
2032	static int cgiWriteString(FILE out, char s) {
2033	int len = (int) strlen(s);
2034	cgiWriteInt(out, len);
2035	if (((int) fwrite(s, 1, len, out)) != len) {
2036	return 0;
2037	}
2038	return 1;
2039	}
2040
2041	static int cgiWriteInt(FILE *out, int i) {
2042	if (!fwrite(&i, sizeof(int), 1, out)) {
2043	return 0;
2044	}
2045	return 1;
2046	}
2047
2048	static int cgiReadString(FILE out, char *s);
2049
2050	static int cgiReadInt(FILE out, int i);
2051
2052	cgiEnvironmentResultType cgiReadEnvironment(char *filename) {
2053	FILE *in;
2054	cgiFormEntry e = 0, p;
2055	char *version;
2056	/* Prevent compiler warnings */
2057	cgiEnvironmentResultType result = cgiEnvironmentIO;
2058	/* Free any existing data first */
2059	cgiFreeResources();
2060	/* Be sure to open in binary mode */
2061	in = fopen(filename, "rb");
2062	if (!in) {
2063	/* Can't access file */
2064	return cgiEnvironmentIO;
2065	}
2066	if (!cgiReadString(in, &version)) {
2067	goto error;
2068	}
2069	if (strcmp(version, "CGIC" CGIC_VERSION)) {
2070	/* 2.02: Merezko Oleg */
2071	free(version);
2072	return cgiEnvironmentWrongVersion;
2073	}
2074	/* 2.02: Merezko Oleg */
2075	free(version);
2076	if (!cgiReadString(in, &cgiServerSoftware)) {
2077	goto error;
2078	}
2079	if (!cgiReadString(in, &cgiServerName)) {
2080	goto error;
2081	}
2082	if (!cgiReadString(in, &cgiGatewayInterface)) {
2083	goto error;
2084	}
2085	if (!cgiReadString(in, &cgiServerProtocol)) {
2086	goto error;
2087	}
2088	if (!cgiReadString(in, &cgiServerPort)) {
2089	goto error;
2090	}
2091	if (!cgiReadString(in, &cgiRequestMethod)) {
2092	goto error;
2093	}
2094	if (!cgiReadString(in, &cgiPathInfo)) {
2095	goto error;
2096	}
2097	if (!cgiReadString(in, &cgiPathTranslated)) {
2098	goto error;
2099	}
2100	if (!cgiReadString(in, &cgiScriptName)) {
2101	goto error;
2102	}
2103	if (!cgiReadString(in, &cgiQueryString)) {
2104	goto error;
2105	}
2106	if (!cgiReadString(in, &cgiRemoteHost)) {
2107	goto error;
2108	}
2109	if (!cgiReadString(in, &cgiRemoteAddr)) {
2110	goto error;
2111	}
2112	if (!cgiReadString(in, &cgiAuthType)) {
2113	goto error;
2114	}
2115	if (!cgiReadString(in, &cgiRemoteUser)) {
2116	goto error;
2117	}
2118	if (!cgiReadString(in, &cgiRemoteIdent)) {
2119	goto error;
2120	}
2121	if (!cgiReadString(in, &cgiContentType)) {
2122	goto error;
2123	}
2124	if (!cgiReadString(in, &cgiAccept)) {
2125	goto error;
2126	}
2127	if (!cgiReadString(in, &cgiUserAgent)) {
2128	goto error;
2129	}
2130	if (!cgiReadString(in, &cgiReferrer)) {
2131	goto error;
2132	}
2133	/* 2.0 */
2134	if (!cgiReadString(in, &cgiCookie)) {
2135	goto error;
2136	}
2137	if (!cgiReadInt(in, &cgiContentLength)) {
2138	goto error;
2139	}
2140	p = 0;
2141	while (1) {
2142	int fileFlag;
2143	e = (cgiFormEntry *) calloc(1, sizeof(cgiFormEntry));
2144	if (!e) {
2145	cgiFreeResources();
2146	fclose(in);
2147	return cgiEnvironmentMemory;
2148	}
2149	memset(e, 0, sizeof(cgiFormEntry));
2150	if (!cgiReadString(in, &e->attr)) {
2151	/* This means we've reached the end of the list. */
2152	/* 2.02: thanks to Merezko Oleg */
2153	free(e);
2154	break;
2155	}
2156	if (!cgiReadString(in, &e->value)) {
2157	goto outOfMemory;
2158	}
2159	if (!cgiReadString(in, &e->fileName)) {
2160	goto outOfMemory;
2161	}
2162	if (!cgiReadString(in, &e->contentType)) {
2163	goto outOfMemory;
2164	}
2165	if (!cgiReadInt(in, &e->valueLength)) {
2166	goto outOfMemory;
2167	}
2168	if (!cgiReadInt(in, &fileFlag)) {
2169	goto outOfMemory;
2170	}
2171	if (fileFlag) {
2172	char buffer[1024];
2173	FILE *out;
2174	char tfileName[1024];
2175	int got;
2176	int len = e->valueLength;
2177	if (getTempFileName(tfileName)
2178	!= cgiParseSuccess)
2179	{
2180	result = cgiEnvironmentIO;
2181	goto error;
2182	}
2183	out = fopen(tfileName, "w+b");
2184	if (!out) {
2185	result = cgiEnvironmentIO;
2186	goto error;
2187	}
2188	while (len > 0) {
2189	/* 2.01: try is a bad variable name in
2190	C++, and it wasn't being used
2191	properly either */
2192	int tryr = len;
2193	if (tryr > ((int) sizeof(buffer))) {
2194	tryr = sizeof(buffer);
2195	}
2196	got = fread(buffer, 1, tryr, in);
2197	if (got <= 0) {
2198	result = cgiEnvironmentIO;
2199	fclose(out);
2200	unlink(tfileName);
2201	goto error;
2202	}
2203	if (((int) fwrite(buffer, 1, got, out)) != got) {
2204	result = cgiEnvironmentIO;
2205	fclose(out);
2206	unlink(tfileName);
2207	goto error;
2208	}
2209	len -= got;
2210	}
2211	/* cgic 2.05: should be fclose not rewind */
2212	fclose(out);
2213	e->tfileName = (char *) malloc((int) strlen(tfileName) + 1);
2214	if (!e->tfileName) {
2215	result = cgiEnvironmentMemory;
2216	unlink(tfileName);
2217	goto error;
2218	}
2219	strcpy(e->tfileName, tfileName);
2220	} else {
2221	e->tfileName = (char *) malloc(1);
2222	if (!e->tfileName) {
2223	result = cgiEnvironmentMemory;
2224	goto error;
2225	}
2226	}
2227	e->next = 0;
2228	if (p) {
2229	p->next = e;
2230	} else {
2231	cgiFormEntryFirst = e;
2232	}
2233	p = e;
2234	}
2235	fclose(in);
2236	cgiRestored = 1;
2237	return cgiEnvironmentSuccess;
2238	outOfMemory:
2239	result = cgiEnvironmentMemory;
2240	error:
2241	cgiFreeResources();
2242	fclose(in);
2243	if (e) {
2244	if (e->attr) {
2245	free(e->attr);
2246	}
2247	if (e->value) {
2248	free(e->value);
2249	}
2250	if (e->fileName) {
2251	free(e->fileName);
2252	}
2253	if (e->contentType) {
2254	free(e->contentType);
2255	}
2256	if (e->tfileName) {
2257	free(e->tfileName);
2258	}
2259	free(e);
2260	}
2261	return result;
2262	}
2263
2264	static int cgiReadString(FILE in, char *s) {
2265	int len;
2266	/* 2.0 fix: test cgiReadInt for failure! */
2267	if (!cgiReadInt(in, &len)) {
2268	return 0;
2269	}
2270	s = (char ) malloc(len + 1);
2271	if (!(*s)) {
2272	return 0;
2273	}
2274	if (((int) fread(*s, 1, len, in)) != len) {
2275	return 0;
2276	}
2277	(*s)[len] = '\0';
2278	return 1;
2279	}
2280
2281	static int cgiReadInt(FILE out, int i) {
2282	if (!fread(i, sizeof(int), 1, out)) {
2283	return 0;
2284	}
2285	return 1;
2286	}
2287
2288	static int cgiStrEqNc(char s1, char s2) {
2289	while(1) {
2290	if (!(*s1)) {
2291	if (!(*s2)) {
2292	return 1;
2293	} else {
2294	return 0;
2295	}
2296	} else if (!(*s2)) {
2297	return 0;
2298	}
2299	if (isalpha(*s1)) {
2300	if (tolower(s1) != tolower(s2)) {
2301	return 0;
2302	}
2303	} else if ((s1) != (s2)) {
2304	return 0;
2305	}
2306	s1++;
2307	s2++;
2308	}
2309	}
2310
2311	static int cgiStrBeginsNc(char s1, char s2) {
2312	while(1) {
2313	if (!(*s2)) {
2314	return 1;
2315	} else if (!(*s1)) {
2316	return 0;
2317	}
2318	if (isalpha(*s1)) {
2319	if (tolower(s1) != tolower(s2)) {
2320	return 0;
2321	}
2322	} else if ((s1) != (s2)) {
2323	return 0;
2324	}
2325	s1++;
2326	s2++;
2327	}
2328	}
2329
2330	static char *cgiFindTarget = 0;
2331	static cgiFormEntry *cgiFindPos = 0;
2332
2333	static cgiFormEntry cgiFormEntryFindFirst(char name) {
2334	cgiFindTarget = name;
2335	cgiFindPos = cgiFormEntryFirst;
2336	return cgiFormEntryFindNext();
2337	}
2338
2339	static cgiFormEntry *cgiFormEntryFindNext() {
2340	while (cgiFindPos) {
2341	cgiFormEntry *c = cgiFindPos;
2342	cgiFindPos = c->next;
2343	if (!strcmp(c -> attr, cgiFindTarget)) {
2344	return c;
2345	}
2346	}
2347	return 0;
2348	}
2349
2350	static int cgiFirstNonspaceChar(char *s) {
2351	int len = strspn(s, " \n\r\t");
2352	return s[len];
2353	}
2354
2355	void cgiStringArrayFree(char **stringArray) {
2356	char *p;
2357	char **arrayItself = stringArray;
2358	p = *stringArray;
2359	while (p) {
2360	free(p);
2361	stringArray++;
2362	p = *stringArray;
2363	}
2364	/* 2.0: free the array itself! */
2365	free(arrayItself);
2366	}
2367
2368	cgiFormResultType cgiCookies(char ***result) {
2369	char **stringArray;
2370	int i;
2371	int total = 0;
2372	char *p;
2373	char *n;
2374	p = cgiCookie;
2375	while (*p) {
2376	if (*p == '=') {
2377	total++;
2378	}
2379	p++;
2380	}
2381	stringArray = (char *) malloc(sizeof(char ) * (total + 1));
2382	if (!stringArray) {
2383	*result = 0;
2384	return cgiFormMemory;
2385	}
2386	/* initialize all entries to null; the last will stay that way */
2387	for (i=0; (i <= total); i++) {
2388	stringArray[i] = 0;
2389	}
2390	i = 0;
2391	p = cgiCookie;
2392	while (*p) {
2393	while (p && isspace(p)) {
2394	p++;
2395	}
2396	n = p;
2397	while (p && (p != '=')) {
2398	p++;
2399	}
2400	if (p != n) {
2401	stringArray[i] = (char *) malloc((p - n) + 1);
2402	if (!stringArray[i]) {
2403	cgiStringArrayFree(stringArray);
2404	*result = 0;
2405	return cgiFormMemory;
2406	}
2407	memcpy(stringArray[i], n, p - n);
2408	stringArray[i][p - n] = '\0';
2409	i++;
2410	}
2411	while (p && (p != ';')) {
2412	p++;
2413	}
2414	if (!*p) {
2415	break;
2416	}
2417	if (*p == ';') {
2418	p++;
2419	}
2420	}
2421	*result = stringArray;
2422	return cgiFormSuccess;
2423	}
2424
2425	cgiFormResultType cgiFormEntries(char ***result) {
2426	char **stringArray;
2427	cgiFormEntry e, pe;
2428	int i;
2429	int total = 0;
2430	e = cgiFormEntryFirst;
2431	while (e) {
2432	/* Don't count a field name more than once if
2433	multiple values happen to be present for it */
2434	pe = cgiFormEntryFirst;
2435	while (pe != e) {
2436	if (!strcmp(e->attr, pe->attr)) {
2437	goto skipSecondValue;
2438	}
2439	pe = pe->next;
2440	}
2441	total++;
2442	skipSecondValue:
2443	e = e->next;
2444	}
2445	stringArray = (char *) malloc(sizeof(char ) * (total + 1));
2446	if (!stringArray) {
2447	*result = 0;
2448	return cgiFormMemory;
2449	}
2450	/* initialize all entries to null; the last will stay that way */
2451	for (i=0; (i <= total); i++) {
2452	stringArray[i] = 0;
2453	}
2454	/* Now go get the entries */
2455	e = cgiFormEntryFirst;
2456	i = 0;
2457	while (e) {
2458	int space;
2459	/* Don't return a field name more than once if
2460	multiple values happen to be present for it */
2461	pe = cgiFormEntryFirst;
2462	while (pe != e) {
2463	if (!strcmp(e->attr, pe->attr)) {
2464	goto skipSecondValue2;
2465	}
2466	pe = pe->next;
2467	}
2468	space = (int) strlen(e->attr) + 1;
2469	stringArray[i] = (char *) malloc(space);
2470	if (stringArray[i] == 0) {
2471	/* Memory problems */
2472	cgiStringArrayFree(stringArray);
2473	*result = 0;
2474	return cgiFormMemory;
2475	}
2476	strcpy(stringArray[i], e->attr);
2477	i++;
2478	skipSecondValue2:
2479	e = e->next;
2480	}
2481	*result = stringArray;
2482	return cgiFormSuccess;
2483	}
2484
2485	#define TRYPUTC(ch) \
2486	{ \
2487	if (putc((ch), cgiOut) == EOF) { \
2488	return cgiFormIO; \
2489	} \
2490	}
2491
2492	cgiFormResultType cgiHtmlEscapeData(char *data, int len)
2493	{
2494	while (len--) {
2495	if (*data == '<') {
2496	TRYPUTC('&');
2497	TRYPUTC('l');
2498	TRYPUTC('t');
2499	TRYPUTC(';');
2500	} else if (*data == '&') {
2501	TRYPUTC('&');
2502	TRYPUTC('a');
2503	TRYPUTC('m');
2504	TRYPUTC('p');
2505	TRYPUTC(';');
2506	} else if (*data == '>') {
2507	TRYPUTC('&');
2508	TRYPUTC('g');
2509	TRYPUTC('t');
2510	TRYPUTC(';');
2511	} else {
2512	TRYPUTC(*data);
2513	}
2514	data++;
2515	}
2516	return cgiFormSuccess;
2517	}
2518
2519	cgiFormResultType cgiHtmlEscape(char *s)
2520	{
2521	return cgiHtmlEscapeData(s, (int) strlen(s));
2522	}
2523
2524	/* Output data with the " character HTML-escaped, and no
2525	other characters escaped. This is useful when outputting
2526	the contents of a tag attribute such as 'href' or 'src'.
2527	'data' is not null-terminated; 'len' is the number of
2528	bytes in 'data'. Returns cgiFormIO in the event
2529	of error, cgiFormSuccess otherwise. */
2530	cgiFormResultType cgiValueEscapeData(char *data, int len)
2531	{
2532	while (len--) {
2533	if (*data == '\"') {
2534	TRYPUTC('&');
2535	TRYPUTC('#');
2536	TRYPUTC('3');
2537	TRYPUTC('4');
2538	TRYPUTC(';');
2539	} else {
2540	TRYPUTC(*data);
2541	}
2542	data++;
2543	}
2544	return cgiFormSuccess;
2545	}
2546
2547	cgiFormResultType cgiValueEscape(char *s)
2548	{
2549	return cgiValueEscapeData(s, (int) strlen(s));
2550	}
2551
2552

Note: See TracBrowser for help on using the repository browser.

Open WPS platform

source: trunk/thirds/cgic206/cgic.c @ 244

Download in other formats:

Download now !

Support ZOO-Project

Search

Context Navigation

Main Navigation

ZOO Sponsors

Knowledge partners

Related links