0221722e6ce2499c0112504221928ad29e53ef7f
[infodrom/cgilib] / cgi.c
1 /*
2     cgi.c - Some simple routines for CGI programming
3     Copyright (c) 1996-9,2007,8  Martin Schulze <joey@infodrom.org>
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
18  */
19
20 #define _GNU_SOURCE 1
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <string.h>
26 #include <strings.h>
27 #include <ctype.h>
28 #include <syslog.h>
29 #include <cgi.h>
30 #include "aux.h"
31
32 char *cgiHeaderString = NULL;
33 char *cgiType = NULL;
34
35 extern s_cookie **cgiReadCookies();
36
37 int cgiSetHeader (const char *name, const char *value)
38 {
39     const char *cp, *vp;
40     char *pivot;
41     int len;
42
43     if (!name || !strlen (name) || !value || !strlen (value))
44         return 0;
45     
46     for (cp=name;*cp && *cp!=' ' && *cp!='\r' && *cp!='\n' && *cp!=':';cp++);
47     for (vp=value;*vp && *vp!='\r' && *vp!='\n';vp++);
48
49     if (cgiHeaderString) {
50         len = (strlen (cgiHeaderString) + cp-name + vp-value + 5) * sizeof (char);
51         if ((pivot = (char *)realloc (cgiHeaderString,len)) == NULL)
52             return 0;
53         cgiHeaderString = pivot;
54         pivot += strlen (cgiHeaderString);
55     } else {
56         len = (cp-name + vp-value + 5) * sizeof (char);
57         if ((cgiHeaderString = (char *)malloc (len)) == NULL)
58             return 0;
59         pivot = cgiHeaderString;
60     }
61     strncpy (pivot, name, cp-name);
62     strncat (pivot, ": ", 2);
63     strncat (pivot, value, vp-value);
64     strncat (pivot, "\r\n", 2);
65
66     return 1;
67 }
68
69 int cgiSetType (const char *type)
70 {
71     int len;
72     const char *cp;
73
74     if (!type || !strlen (type))
75         return 0;
76     if (cgiType)
77         free (cgiType);
78
79     for (cp=type;*cp && *cp!='\r' && *cp!='\n';cp++);
80
81     len = (cp-type+1) * sizeof (char);
82     if ((cgiType = (char *)malloc (len+20)) == NULL)
83         return 0;
84     memset (cgiType, 0, len);
85     strncpy (cgiType, type, cp-type);
86     
87     return 1;
88 }
89
90 void cgiHeader ()
91 {
92     if (cgiType)
93         printf ("Content-type: %s\r\n", cgiType);
94     else
95         printf ("Content-type: text/html\r\n");
96     if (cgiHeaderString)
97         printf ("%s", cgiHeaderString);
98     printf ("\r\n");
99 }
100
101 void cgiDebug (int level, int where)
102 {
103     if (level > 0)
104         cgiDebugLevel = level;
105     else
106         cgiDebugLevel = 0;
107     if (where > 0) {
108         if (where < 3) {
109             cgiDebugType = where;
110             if (where == 2)
111                 openlog("cgilib", LOG_PID, LOG_USER);
112         } else
113             cgiDebugType = 0;
114     }
115 }
116
117 char *cgiDecodeString (char *text)
118 {
119     char *cp, *xp;
120
121     for (cp=text,xp=text; *cp; cp++) {
122         if (*cp == '%') {
123             if (strchr("0123456789ABCDEFabcdef", *(cp+1))
124                 && strchr("0123456789ABCDEFabcdef", *(cp+2))) {
125                 if (islower(*(cp+1)))
126                     *(cp+1) = toupper(*(cp+1));
127                 if (islower(*(cp+2)))
128                     *(cp+2) = toupper(*(cp+2));
129                 *(xp) = (*(cp+1) >= 'A' ? *(cp+1) - 'A' + 10 : *(cp+1) - '0' ) * 16
130                     + (*(cp+2) >= 'A' ? *(cp+2) - 'A' + 10 : *(cp+2) - '0');
131                 xp++;cp+=2;
132             }
133         } else {
134             *(xp++) = *cp;
135         }
136     }
137     memset(xp, 0, cp-xp);
138     return text;
139 }
140
141 /* cgiReadFile()
142  *
143  * Read and save a file fro a multipart request
144  */
145 #include <errno.h>
146 char *cgiReadFile (FILE *stream, char *boundary)
147 {
148     char *crlfboundary, *buf;
149     size_t boundarylen;
150     int c;
151     unsigned int pivot;
152     char *cp;
153     char template[]= "/tmp/cgilibXXXXXX";
154     FILE *tmpfile;
155     int fd;
156
157     boundarylen = strlen(boundary)+3;
158     if ((crlfboundary = (char *)malloc (boundarylen)) == NULL)
159         return NULL;
160     sprintf (crlfboundary, "\r\n%s", boundary);
161
162     if ((buf = (char *)malloc (boundarylen)) == NULL) {
163         free (crlfboundary);
164         return NULL;
165     }
166     memset (buf, 0, boundarylen);
167     pivot = 0;
168
169     if ((fd = mkstemp (template)) == -1) {
170         free (crlfboundary);
171         free (buf);
172         return NULL;
173     }
174
175     if ((tmpfile = fdopen (fd, "w")) == NULL) {
176         free (crlfboundary);
177         free (buf);
178         unlink (template);
179         return NULL;
180     }
181     
182     while (!feof (stream)) {
183         c = fgetc (stream);
184
185         if (c == 0) {
186             if (strlen (buf)) {
187                 for (cp=buf; *cp; cp++)
188                     putc (*cp, tmpfile);
189                 memset (buf, 0, boundarylen);
190                 pivot = 0;
191             }
192             putc (c, tmpfile);
193             continue;
194         }
195
196         if (strlen (buf)) {
197             if (crlfboundary[pivot+1] == c) {
198                 buf[++pivot] = c;
199
200                 if (strlen (buf) == strlen (crlfboundary))
201                     break;
202                 else
203                     continue;
204             } else {
205                 for (cp=buf; *cp; cp++)
206                     putc (*cp, tmpfile);
207                 memset (buf, 0, boundarylen);
208                 pivot = 0;
209             }
210         }
211
212         if (crlfboundary[0] == c) {
213             buf[0] = c;
214         } else {
215             fputc (c, tmpfile);
216         }
217     }
218
219     if (!feof (stream))
220         fgets (buf, boundarylen, stream);
221
222     fclose (tmpfile);
223
224     free (crlfboundary);
225     free (buf);
226
227     return strdup (template);
228 }
229
230 /* cgiReadMultipart()
231  *
232  * Decode multipart/form-data
233  */
234 #define MULTIPART_DELTA 5
235 s_cgi *cgiReadMultipart (char *boundary)
236 {
237     char *line;
238     char *cp, *xp;
239     char *name = NULL, *type = NULL;
240     char *fname = NULL;
241     char *tmpfile;
242     int header = 1;
243     s_var **result = NULL;
244     s_var **tmp;
245     int numresults = 0, current = 0;
246     s_file **files = NULL;
247     s_file **tmpf;
248     s_file *file;
249     int index = 0;
250     size_t len;
251     s_cgi *res;
252     
253     while ((line = cgiGetLine (stdin)) != NULL) {
254
255         if (!strncmp (line, boundary, strlen(boundary))) {
256             header = 1;
257         } else if (!strncasecmp (line, "Content-Disposition: form-data; ", 32)) {
258             if (!name) {
259                 if ((cp = strstr (line, "name=\"")) == NULL)
260                     continue;
261                 cp += 6;
262                 if ((xp = strchr (cp, '\"')) == NULL)
263                     continue;
264                 name = strndup (cp, xp-cp);
265                 cgiDecodeString (name);
266                 cgiDebugOutput (2, "Found field name %s", name);
267
268                 if ((cp = strstr (line, "filename=\"")) == NULL)
269                     continue;
270                 cp += 10;
271                 if ((xp = strchr (cp, '\"')) == NULL)
272                     continue;
273                 fname = strndup (cp, xp-cp);
274                 cgiDecodeString (fname);
275                 cgiDebugOutput (2, "Found filename %s", fname);
276             }
277         } else if (!strncasecmp (line, "Content-Type: ", 14)) {
278             if (!type) {
279                 cp = line + 14;
280                 type = strdup (cp);
281                 cgiDebugOutput (2, "Found mime type %s", type);
282             }
283         } else if (header) {
284             if (!strlen(line)) {
285                 header = 0;
286
287                 if (fname) {
288                     header = 1;
289                     tmpfile = cgiReadFile (stdin, boundary);
290
291                     if (!tmpfile) {
292                         free (name);
293                         free (fname);
294                         if (type)
295                             free (type);
296                         name = fname = type = NULL;
297                     }
298
299                     cgiDebugOutput (2, "Wrote %s (%s) to file: %s", name, fname, tmpfile);
300
301                     if (!strlen (fname)) {
302                         cgiDebugOutput (3, "Found empty filename, removing");
303                         unlink (tmpfile);
304                         free (tmpfile);
305                         free (name);
306                         free (fname);
307                         if (type)
308                             free (type);
309                         name = fname = type = NULL;
310                     } else {
311                         if ((file = (s_file *)malloc (sizeof (s_file))) == NULL) {
312                             cgiDebugOutput (3, "malloc failed, ignoring %s=%s", name, fname);
313                             unlink (tmpfile);
314                             free (tmpfile);
315                             free (name);
316                             free (fname);
317                             if (type)
318                                 free (type);
319                             name = fname = type = NULL;
320                             continue;
321                         }
322
323                         file->name = name;
324                         file->type = type;
325                         file->tmpfile = tmpfile;
326                         if ((cp = rindex (fname, '/')) == NULL)
327                             file->filename = fname;
328                         else {
329                             file->filename = strdup (++cp);
330                             free (fname);
331                         }
332                         name = type = fname = NULL;
333
334                         if (!files) {
335                             if ((files = (s_file **)malloc(2*sizeof (s_file *))) == NULL) {
336                                 cgiDebugOutput (3, "malloc failed, ignoring %s=%s", name, fname);
337                                 unlink (tmpfile);
338                                 free (tmpfile);
339                                 free (name);
340                                 name = NULL;
341                                 if (type) {
342                                     free (type);
343                                     type = NULL;
344                                 }
345                                 free (file->filename);
346                                 free (file);
347                                 continue;
348                             }
349                             memset (files, 0, 2*sizeof (s_file *));
350                             index = 0;
351                         } else {
352                             for (index=0; files[index]; index++);
353                             if ((tmpf = (s_file **)realloc(files, (index+2)*sizeof (s_file *))) == NULL) {
354                                 cgiDebugOutput (3, "realloc failed, ignoring %s=%s", name, fname);
355                                 unlink (tmpfile);
356                                 free (tmpfile);
357                                 free (name);
358                                 if (type)
359                                     free (type);
360                                 free (file->filename);
361                                 free (file);
362                                 name = type = fname = NULL;
363                                 continue;
364                             }
365                             files = tmpf;
366                             memset (files + index, 0, 2*sizeof (s_file *));
367                         }
368                         files[index] = file;
369                     }
370                 }
371             }
372         } else {
373             if (name) {
374
375                 /* try to find out if there's already such a variable */
376                 for (index=0; index<current && strcmp (result[index]->name,name); index++);
377
378                 if (index == current) {
379                     if (!result) {
380                         len = MULTIPART_DELTA * sizeof (s_var *);
381                         if ((result = (s_var **)malloc (len)) == NULL) {
382                             free (name);
383                             if (type)
384                                 free (type);
385                             return NULL;
386                         }
387                         numresults = MULTIPART_DELTA;
388                         memset (result, 0, len);
389                         current = 0;
390                     } else {
391                         if (current+2 > numresults) {
392                             len = (numresults + MULTIPART_DELTA) * sizeof(s_var *);
393                             if ((tmp = (s_var **)realloc (result, len)) == NULL) {
394                                 for (index=0; result[index]; index++)
395                                     free (result[index]);
396                                 free (result);
397                                 free (name);
398                                 if (type)
399                                     free (type);
400                                 return NULL;
401                             }
402                             result = tmp;
403                             memset (result + numresults, 0, len - numresults*sizeof(s_var *));
404                             numresults += MULTIPART_DELTA;
405                         }
406                     }
407                     if ((result[current] = (s_var *)malloc(sizeof(s_var))) == NULL) {
408                         for (index=0; result[index]; index++)
409                             free (result[index]);
410                         free (result);
411                         free (name);
412                         if (type)
413                             free (type);
414                         return NULL;
415                     }
416                     current++;
417                     cgiDebugOutput (3, "Set #%d to %s=%s", index, name, line);
418                     result[index]->name = name; name = NULL;
419                     result[index]->value = strdup (line);
420                     cgiDecodeString (result[index]->value);
421                     if (type) {
422                         free (type);
423                         type = NULL;
424                     }
425                 } else {
426                     cgiDebugOutput (3, "Set #%d to %s=%s", index, name, line);
427                     free (name);
428                     name = NULL;
429                     if ((cp = (char *)realloc (result[index]->value, strlen(result[index]->value)+strlen(line)+2)) != NULL) {
430                         strcat(cp, "\n");
431                         strcat(cp, line);
432                         result[index]->value = cp;
433                         if (type) {
434                             free (type);
435                             type = NULL;
436                         }
437                     }
438                 }
439             } else {
440                 if (index > 0) {
441                     xp = strdup (line);
442                     cgiDecodeString (xp);
443
444                     if ((name = (char *)malloc (strlen(result[index]->value)+strlen(xp)+3)) == NULL) {
445                         for (index=0; result[index]; index++)
446                             free (result[index]);
447                         free (result);
448                         free (xp);
449                         return NULL;
450                     }
451                     sprintf (name, "%s\r\n%s", result[index]->value, xp);
452                     free (result[index]->value);
453                     result[index]->value = name;
454                     name = NULL;
455                     free (xp);
456                 }
457             }
458         }
459     }
460
461     if ((res = (s_cgi *)malloc (sizeof (s_cgi))) == NULL)
462         return NULL;
463
464     res->vars = result;
465     res->cookies = NULL;
466     res->files = files;
467
468     return res;
469 }
470
471 /*  cgiReadVariables()
472  *
473  *  Read from stdin if no string is provided via CGI.  Variables that
474  *  doesn't have a value associated with it doesn't get stored.
475  */
476 s_cgi *cgiReadVariables ()
477 {
478     int length;
479     char *line = NULL;
480     int numargs;
481     char *cp, *ip, *esp, *sptr;
482     s_var **result;
483     int i, k, len;
484     char tmp[101];
485     s_cgi *res;
486
487     cp = getenv("CONTENT_TYPE");
488     if (cp)
489         cgiDebugOutput (2, "Content-Type: %s", cp);
490     if (cp && strstr(cp, "multipart/form-data") && strstr(cp, "boundary=")) {
491         cp = strstr(cp, "boundary=") + strlen ("boundary=") - 2;
492         *cp = *(cp+1) = '-';
493         return cgiReadMultipart (cp);
494     }
495
496     if ((res = (s_cgi *)malloc (sizeof (s_cgi))) == NULL)
497         return NULL;
498
499     cp = getenv("REQUEST_METHOD");
500     if (cp)
501         cgiDebugOutput (2, "REQUEST_METHOD: %s", cp);
502     ip = getenv("CONTENT_LENGTH");
503     if (ip)
504         cgiDebugOutput (2, "CONTENT_LENGTH: %s", ip);
505
506     if (cp && !strcmp(cp, "POST")) {
507         if (ip) {
508             length = atoi(ip);
509             if (length <= 0)
510                 return NULL;
511             if ((line = (char *)malloc (length+2)) == NULL)
512                 return NULL;
513             fgets(line, length+1, stdin);
514         } else
515             return NULL;
516     } else if (cp && !strcmp(cp, "GET")) {
517         esp = getenv("QUERY_STRING");
518         if (esp && strlen(esp)) {
519             if ((line = (char *)malloc (strlen(esp)+2)) == NULL)
520                 return NULL;
521             sprintf (line, "%s", esp);
522         } else
523             return NULL;
524     } else {
525         length = 0;
526         printf ("(offline mode: enter name=value pairs on standard input)\n");
527         memset (tmp, 0, sizeof(tmp));
528         while((cp = fgets (tmp, 100, stdin)) != NULL) {
529             if (strlen(tmp)) {
530                 if (tmp[strlen(tmp)-1] == '\n')
531                     tmp[strlen(tmp)-1] = '&';
532                 if (length) {
533                     length += strlen(tmp);
534                     len = (length+1) * sizeof(char);
535                     if ((line = (char *)realloc (line, len)) == NULL)
536                         return NULL;
537                     strcat (line, tmp);
538                 } else {
539                     length = strlen(tmp);
540                     len = (length+1) * sizeof(char);
541                     if ((line = (char *)malloc (len)) == NULL)
542                         return NULL;
543                     memset (line, 0, len);
544                     strcpy (line, tmp);
545                 }
546             }
547             memset (tmp, 0, sizeof(tmp));
548         }
549         if (!line)
550             return NULL;
551         if (line[strlen(line)-1] == '&')
552             line[strlen(line)-1] = '\0';
553     }
554
555     /*
556      *  From now on all cgi variables are stored in the variable line
557      *  and look like  foo=bar&foobar=barfoo&foofoo=
558      */
559
560     cgiDebugOutput (1, "Received CGI input: %s", line);
561
562     for (cp=line; *cp; cp++)
563         if (*cp == '+')
564             *cp = ' ';
565
566     if (strlen(line)) {
567         for (numargs=1,cp=line; *cp; cp++)
568             if (*cp == '&' || *cp == ';' ) numargs++;
569     } else
570         numargs = 0;
571     cgiDebugOutput (1, "%d cgi variables found.", numargs);
572
573     len = (numargs+1) * sizeof(s_var *);
574     if ((result = (s_var **)malloc (len)) == NULL)
575         return NULL;
576     memset (result, 0, len);
577
578     cp = line;
579     i=0;
580     while (*cp) {
581         if ((ip = (char *)strchr(cp, '&')) != NULL) {
582             *ip = '\0';
583         } else if ((ip = (char *)strchr(cp, ';')) != NULL) {
584             *ip = '\0';
585         } else
586             ip = cp + strlen(cp);
587
588         if ((esp=(char *)strchr(cp, '=')) == NULL) {
589             cp = ++ip;
590             continue;
591         }
592
593         if (!strlen(esp)) {
594             cp = ++ip;
595             continue;
596         }
597
598         if (i<numargs) {
599             char *name;
600             char *value;
601
602             if ((name = (char *)malloc((esp-cp+1) * sizeof (char))) == NULL)
603                 return NULL;
604             strncpy(name, cp, esp-cp);
605             name[esp-cp] = '\0';
606             cgiDecodeString (name);
607
608             cp = ++esp;
609
610             if ((value = (char *)malloc((ip-esp+1) * sizeof (char))) == NULL) {
611                 free (name);
612                 return NULL;
613             }
614             strncpy(value, cp, ip-esp);
615             value[ip-esp] = '\0';
616             cgiDecodeString (value);
617
618             /* try to find out if there's already such a variable */
619             for (k=0; k<i && strcmp (result[k]->name, name); k++);
620
621             if (k == i) {       /* No such variable yet */
622                 if ((result[i] = (s_var *)malloc(sizeof(s_var))) == NULL)
623                     return NULL;
624                 result[i]->name = name;
625                 result[i]->value = value;
626                 cgiDebugOutput (1, "%s: %s", result[i]->name, result[i]->value);
627                 i++;
628             } else {    /* There is already such a name, suppose a mutiple field */
629                 free (name);
630                 len = (strlen(result[k]->value)+strlen(value)+2) * sizeof (char);
631                 if ((sptr = (char *)malloc(len)) == NULL) {
632                     free (value);
633                     return NULL;
634                 }
635                 memset (sptr, 0, len);
636                 sprintf (sptr, "%s\n%s", result[k]->value, value);
637                 free (result[k]->value);
638                 free (value);
639                 result[k]->value = sptr;
640                 cgiDebugOutput (1, "%s: %s", result[i]->name, result[i]->value);
641             }
642         }
643         cp = ++ip;
644     }
645
646     res->vars = result;
647     res->cookies = NULL;
648     res->files = NULL;
649
650     return res;
651 }
652
653 /*  cgiInit()
654  *
655  *  Read from stdin if no string is provided via CGI.  Variables that
656  *  doesn't have a value associated with it doesn't get stored.
657  */
658 s_cgi *cgiInit()
659 {
660     s_cgi *res;
661
662     res = cgiReadVariables ();
663     if (res)
664         res->cookies = cgiReadCookies ();
665     else
666         return NULL;
667
668     if (!res->vars && !res->cookies && !res->files) {
669         free (res);
670         return NULL;
671     }
672
673     return res;
674 }
675
676 char *cgiGetValue (s_cgi *parms, const char *name)
677 {
678     int i;
679
680     if (!parms || !parms->vars)
681         return NULL;
682     for (i=0;parms->vars[i]; i++)
683         if (!strcmp(name,parms->vars[i]->name)) {
684             cgiDebugOutput (1, "%s found as %s", name, parms->vars[i]->value);
685             if (strlen(parms->vars[i]->value) > 0)
686                 return parms->vars[i]->value;
687             else
688                 return NULL;
689         }
690     cgiDebugOutput (1, "%s not found", name);
691     return NULL;
692 }
693
694 char **cgiGetVariables (s_cgi *parms)
695 {
696     int i;
697     char **res = NULL;
698     int len;
699
700     if (!parms || !parms->vars)
701         return NULL;
702     for (i=0;parms->vars[i]; i++);
703     len = sizeof (char *) * ++i;
704     if ((res = (char **)malloc (len)) == NULL)
705         return NULL;
706     memset (res, 0, len);
707     for (i=0;parms->vars[i]; i++) {
708         len = strlen (parms->vars[i]->name) +1;
709         if ((res[i] = (char *)malloc (len)) == NULL)
710             return NULL;
711         memset (res[i], 0, len);
712         strcpy (res[i], parms->vars[i]->name);
713     }
714     return res;
715 }
716
717 /* cgiGetFiles
718  *
719  * Returns a list of names of all files.
720  */
721 char **cgiGetFiles (s_cgi *parms)
722 {
723     int i;
724     char **res = NULL;
725     int len;
726
727     if (!parms || !parms->files)
728         return NULL;
729
730     for (i=0;parms->files[i]; i++);
731     len = sizeof (char *) * ++i;
732     if ((res = (char **)malloc (len)) == NULL)
733         return NULL;
734     memset (res, 0, len);
735     for (i=0;parms->files[i]; i++) {
736         len = strlen (parms->files[i]->name) +1;
737         if ((res[i] = (char *)malloc (len)) == NULL)
738             return NULL;
739         memset (res[i], 0, len);
740         strcpy (res[i], parms->files[i]->name);
741     }
742     return res;
743 }
744
745 /* cgiGetFile
746  *
747  * Return data structure for CGI file variable
748  */
749 s_file *cgiGetFile (s_cgi *parms, const char *name)
750 {
751     int i;
752
753     if (!parms || !parms->files)
754         return NULL;
755
756     for (i=0;parms->files[i]; i++)
757         if (!strcmp(name,parms->files[i]->name)) {
758             cgiDebugOutput (1, "%s found as %s", name, parms->files[i]->filename);
759             return parms->files[i];
760         }
761     cgiDebugOutput (1, "%s not found", name);
762     return NULL;
763 }
764
765 void cgiRedirect (const char *url)
766 {
767     if (url && strlen(url)) {
768         printf ("Content-type: text/html\r\nContent-length: %d\r\n", 77+(strlen(url)*2));
769         printf ("Status: 302 Temporal Relocation\r\n");
770         printf ("Location: %s\r\n\r\n", url);
771         printf ("<html>\n<body>\nThe page has been moved to <a href=\"%s\">%s</a>\n</body>\n</html>\n", url, url);
772     }
773 }
774
775 void cgiFreeList (char **list)
776 {
777     int i;
778
779     for (i=0; list[i] != NULL; i++)
780         free (list[i]);
781     free (list);
782 }
783
784 void cgiFree (s_cgi *parms)
785 {
786     int i;
787
788     if (!parms)
789         return;
790     if (parms->vars) {
791         for (i=0;parms->vars[i]; i++) {
792             if (parms->vars[i]->name)
793                 free (parms->vars[i]->name);
794             if (parms->vars[i]->value)
795                 free (parms->vars[i]->value);
796             free (parms->vars[i]);
797         }
798         free (parms->vars);
799     }
800     if (parms->cookies) {
801         if (parms->cookies[0]->version)
802             free (parms->cookies[0]->version);
803         for (i=0;parms->cookies[i]; i++) {
804             if (parms->cookies[i]->name)
805                 free (parms->cookies[i]->name);
806             if (parms->cookies[i]->value)
807                 free (parms->cookies[i]->value);
808             if (parms->cookies[i]->path)
809                 free (parms->cookies[i]->path);
810             if (parms->cookies[i]->domain)
811                 free (parms->cookies[i]->domain);
812             free (parms->cookies[i]);
813         }
814         free (parms->cookies);
815     }
816     if (parms->files) {
817         for (i=0;parms->files[i]; i++) {
818             if (parms->files[i]->name)
819                 free (parms->files[i]->name);
820             if (parms->files[i]->type)
821                 free (parms->files[i]->type);
822             if (parms->files[i]->filename)
823                 free (parms->files[i]->filename);
824             if (parms->files[i]->tmpfile) {
825                 unlink (parms->files[i]->tmpfile);
826                 free (parms->files[i]->tmpfile);
827             }
828             free (parms->files[i]);
829         }
830         free (parms->files);
831     }
832     free (parms);
833
834     if (cgiHeaderString) {
835         free (cgiHeaderString);
836         cgiHeaderString = NULL;
837     }
838     if (cgiType) {
839         free (cgiType);
840         cgiType = NULL;
841     }
842 }
843
844 /*
845  * Local variables:
846  *  c-indent-level: 4
847  *  c-basic-offset: 4
848  *  tab-width: 8
849  * End:
850  */