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