![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aitwww.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitwww / src|
Return to aitwww.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / libaitwww / src |
1.1 misho 1: /*************************************************************************
2: * (C) 2012 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
1.3.4.1 ! misho 6: * $Id: aitwww.c,v 1.3 2012/03/15 01:59:37 misho Exp $
1.1 misho 7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47: #include "mime.h"
48:
49:
50: #pragma GCC visibility push(hidden)
51:
52: int www_Errno;
53: char www_Error[STRSIZ];
54:
55: #pragma GCC visibility pop
56:
57: // www_GetErrno() Get error code of last operation
58: inline int
59: www_GetErrno()
60: {
61: return www_Errno;
62: }
63:
64: // www_GetError() Get error text of last operation
65: inline const char *
66: www_GetError()
67: {
68: return www_Error;
69: }
70:
71: // www_SetErr() Set error to variables for internal use!!!
72: inline void
73: www_SetErr(int eno, char *estr, ...)
74: {
75: va_list lst;
76:
77: www_Errno = eno;
1.3.4.1 ! misho 78: memset(www_Error, 0, sizeof www_Errno);
1.1 misho 79: va_start(lst, estr);
1.3.4.1 ! misho 80: vsnprintf(www_Error, sizeof www_Errno, estr, lst);
1.1 misho 81: va_end(lst);
82: }
83:
84: /* -------------------------------------------------------------- */
85:
86: /*
87: * www_initCGI() - Init CGI program
88: *
89: * return: NULL error or allocated cgi session
90: */
91: cgi_t *
92: www_initCGI(void)
93: {
94: char *s, *str;
95: int ctlen, rlen;
96: register int i;
97: cgi_t *cgi = NULL;
98:
99: str = getenv("REQUEST_METHOD");
100: if (!str) {
1.3 misho 101: www_SetErr(EFAULT, "Request method not found");
1.1 misho 102: return NULL;
103: }
104: if (!strcmp(str, "GET") || !strcmp(str, "HEAD")) {
105: /* GET | HEAD */
106: str = getenv("QUERY_STRING");
107: if (!str) {
1.3 misho 108: www_SetErr(EFAULT, "Query string not found");
1.1 misho 109: return NULL;
110: }
111: cgi = www_parseQuery(str);
112: } else if (!strcmp(str, "POST")) {
113: /* POST */
114: str = getenv("CONTENT_LENGTH");
115: if (!str) {
1.3 misho 116: www_SetErr(EFAULT, "Content length not found");
1.1 misho 117: return NULL;
118: } else
119: ctlen = strtol(str, NULL, 0);
120:
121: s = getenv("CONTENT_TYPE");
122: if (!s) {
1.3 misho 123: www_SetErr(EFAULT, "Content type not found");
1.1 misho 124: return NULL;
125: }
126: if (www_cmp(s, "multipart/form-data") &&
127: www_cmp(s, "application/x-www-form-urlencoded")) {
1.3 misho 128: www_SetErr(EFAULT, "MIME parts are broken");
1.1 misho 129: return NULL;
130: }
131:
132: /* allocated space for post data */
133: str = malloc(ctlen + 1);
134: if (!str) {
135: LOGERR;
136: return NULL;
1.2 misho 137: } else
138: memset(str, 0, ctlen + 1);
1.1 misho 139: for (i = 0; i < ctlen && (rlen =
140: read(STDIN_FILENO, (void*) str + i, ctlen - i)) > 0; i += rlen);
141: str[ctlen] = 0;
142:
143: if (!www_cmp(s, "application/x-www-form-urlencoded"))
144: cgi = www_parseQuery(str);
145: else if (!www_cmp(s, "multipart/form-data"))
146: cgi = www_parseMultiPart(str, ctlen, s);
147:
148: free(str);
149: } else {
150: /* Unknown method */
1.3 misho 151: www_SetErr(EFAULT, "Unknown request method");
1.1 misho 152: return NULL;
153: }
154:
155: return cgi;
156: }
157:
158: /*
159: * www_closeCGI() - Close and free all CGI resources
160: *
161: * @cgi = Inited cgi session
162: * return: none
163: */
164: void
165: www_closeCGI(cgi_t ** __restrict cgi)
166: {
167: struct tagCGI *t;
168:
169: if (!cgi || !*cgi)
170: return;
171:
172: while ((t = SLIST_FIRST(*cgi))) {
173: if (t->cgi_name)
174: free(t->cgi_name);
175: if (t->cgi_value)
176: free(t->cgi_value);
177:
178: SLIST_REMOVE_HEAD(*cgi, cgi_node);
179: free(t);
180: }
181:
182: free(*cgi);
183: *cgi = NULL;
184: }
185:
186: /*
187: * www_parseQuery() - Parse CGI query string
188: *
189: * @str = String
190: * return: NULL error or allocated cgi session
191: */
192: cgi_t *
193: www_parseQuery(const char *str)
194: {
195: char *base, *wrk;
196: cgi_t *cgi;
197: struct tagCGI *t, *old = NULL;
198:
199: if (!str) {
200: www_SetErr(EINVAL, "String is NULL");
201: return NULL;
202: }
203:
204: cgi = malloc(sizeof(cgi_t));
205: if (!cgi) {
206: LOGERR;
207: return NULL;
208: } else {
209: memset(cgi, 0, sizeof(cgi_t));
210: SLIST_INIT(cgi);
211: }
212:
213: base = wrk = strdup(str);
214:
215: while (*wrk) {
216: t = malloc(sizeof(struct tagCGI));
217: if (!t) {
218: LOGERR;
219: www_closeCGI(&cgi);
220: return NULL;
221: } else
222: memset(t, 0, sizeof(struct tagCGI));
223:
224: t->cgi_name = www_getpair(&wrk, "=");
225: www_unescape(t->cgi_name);
226:
227: t->cgi_value = www_getpair(&wrk, "&;");
228: www_unescape(t->cgi_value);
229:
230: if (!old)
231: SLIST_INSERT_HEAD(cgi, t, cgi_node);
232: else
233: SLIST_INSERT_AFTER(old, t, cgi_node);
234: old = t;
235: }
236:
237: free(base);
1.2 misho 238: return cgi;
1.1 misho 239: }
240:
241: /*
242: * www_getValue() - Get Value from CGI session
243: *
244: * @cgi = Inited cgi session
245: * @name = Name of cgi variable
246: * return: NULL not found or !=NULL value
247: */
248: inline const char *
249: www_getValue(cgi_t * __restrict cgi, const char *name)
250: {
251: struct tagCGI *t;
252:
253: if (!cgi || !name) {
254: www_SetErr(EINVAL, "Invalid argument(s)");
255: return NULL;
256: }
257:
258: SLIST_FOREACH(t, cgi, cgi_node)
259: if (t->cgi_name && !strcmp(name, t->cgi_name))
1.2 misho 260: return t->cgi_value;
1.1 misho 261:
1.2 misho 262: return NULL;
1.1 misho 263: }
264:
265: /*
266: * www_addValue() - Add new or update if exists CGI variable
267: *
268: * @cgi = Inited cgi session
269: * @name = Name of cgi variable
270: * @value = Value of cgi variable
271: * return: -1 error, 0 add new one or 1 updated variable
272: */
273: int
274: www_addValue(cgi_t * __restrict cgi, const char *name, const char *value)
275: {
276: struct tagCGI *t, *tmp;
277:
278: if (!cgi || !name) {
279: www_SetErr(EINVAL, "Invalid argument(s)");
280: return -1;
281: }
282:
283: /* search for update */
284: SLIST_FOREACH_SAFE(t, cgi, cgi_node, tmp) {
285: if (t->cgi_name && !strcmp(name, t->cgi_name)) {
286: if (t->cgi_value)
287: free(t->cgi_value);
288: if (value)
289: t->cgi_value = strdup(value);
290: /* update */
291: return 1;
292: }
293: /* save last cgi pair */
294: if (!tmp)
295: break;
296: }
297:
298: /* add new one */
299: tmp = malloc(sizeof(struct tagCGI));
300: if (!tmp) {
301: LOGERR;
302: return -1;
303: } else
304: memset(tmp, 0, sizeof(struct tagCGI));
305:
306: tmp->cgi_name = strdup(name);
307: if (value)
308: tmp->cgi_value = strdup(value);
309:
1.2 misho 310: if (!t)
311: SLIST_INSERT_HEAD(cgi, tmp, cgi_node);
312: else
313: SLIST_INSERT_AFTER(t, tmp, cgi_node);
1.1 misho 314: return 0;
315: }
316:
317: /*
318: * www_delPair() - Delete CGI variable from session
319: *
320: * @cgi = Inited cgi session
321: * @name = Name of cgi variable
322: * return: -1 error, 0 not found or 1 deleted ok
323: */
324: int
325: www_delPair(cgi_t * __restrict cgi, const char *name)
326: {
1.2 misho 327: struct tagCGI *t, *tmp;
1.1 misho 328:
329: if (!cgi || !name) {
330: www_SetErr(EINVAL, "Invalid argument(s)");
331: return -1;
332: }
333:
334: /* search for delete */
1.2 misho 335: SLIST_FOREACH_SAFE(t, cgi, cgi_node, tmp)
1.1 misho 336: if (t->cgi_name && !strcmp(name, t->cgi_name)) {
337: SLIST_REMOVE(cgi, t, tagCGI, cgi_node);
1.2 misho 338:
339: if (t->cgi_name)
340: free(t->cgi_name);
341: if (t->cgi_value)
342: free(t->cgi_value);
343: free(t);
1.1 misho 344: return 1;
345: }
346:
347: return 0;
348: }
349:
350: /*
1.2 misho 351: * www_listPairs() - Walk over CGI session variables
352: *
353: * @cgi = Cgi session
354: * @func = If !=NULL call function for each element
355: * @arg = Optional argument pass through callback
356: * return: -1 error or >-1 number of elements
357: */
358: inline int
359: www_listPairs(cgi_t * __restrict cgi, list_cb_t func, void *arg)
360: {
361: register int ret = 0;
362: struct tagCGI *t;
363:
364: if (!cgi) {
365: www_SetErr(EINVAL, "Invalid CGI session argument");
366: return -1;
367: }
368:
369: SLIST_FOREACH(t, cgi, cgi_node) {
370: ret++;
371:
372: if (func)
373: func(t, arg);
374: }
375:
376: return ret;
377: }
378:
379: /*
1.1 misho 380: * www_header() - Output initial html header
381: *
382: * @output = file handle
383: * return: <1 error or >0 writed bytes
384: */
385: inline int
386: www_header(FILE *output)
387: {
388: FILE *f = output ? output : stdout;
389:
390: return fputs("Content-type: text/html\n\n", f);
391: }
392:
393: static char *
394: quotStr(const char *str, const char **end)
395: {
396: char *s, *e;
397: int n, len = 0;
398: register int i;
399:
400: /* get str w/o " */
401: if (*str != '"') {
402: n = strspn(str, "!#$%&'*+-.0123456789?ABCDEFGHIJKLMNOPQRSTUVWXYZ"
403: "^_`abcdefghijklmnopqrstuvwxyz{|}~");
404: s = malloc(n + 1);
405: if (!s) {
406: LOGERR;
407: return NULL;
408: } else {
409: strncpy(s, str, n);
410: s[n] = 0;
411: *end = str + n;
412: return s;
413: }
414: } else
415: str++;
416: /* get quoted string */
417: if (!(e = strchr(str, '"')))
418: return NULL;
419: else
420: len = e - str;
421: s = malloc(len + 1);
422: if (!s) {
423: LOGERR;
424: return NULL;
425: }
426:
427: for (i = 0; i < len; i++, str++) {
428: if (*str == '\\' || *str == '\n')
429: s[i] = *++str;
430: else if (*str == '"')
431: break;
432: else
433: s[i] = *str;
434: }
435: s[i] = 0;
436:
437: *end = ++str;
438: return s;
439: }
440:
441: static struct tagCGI *
442: addAttr(const char **ct)
443: {
444: struct tagCGI *a;
445: const char *c, *eq;
446: char *name, *value;
447:
448: if (!*ct || !(c = strchr(*ct, ';')))
449: return NULL;
450: else
451: c++;
452: while (isspace(*c))
453: c++;
454:
455: if (!(eq = strchr(c, '=')))
456: return NULL;
457:
458: /* parse name */
459: name = malloc(eq - c + 1);
460: if (!name) {
461: LOGERR;
462: return NULL;
463: } else {
464: strncpy(name, c, eq - c);
465: name[eq - c] = 0;
466: }
467: /* parse value */
468: value = quotStr(++eq, &c);
469: if (!value) {
470: free(name);
471: return NULL;
472: }
473:
474: /* fill tagCGI */
475: a = malloc(sizeof(struct tagCGI));
476: if (!a) {
477: LOGERR;
478: return NULL;
479: } else {
480: a->cgi_name = name;
481: a->cgi_value = value;
482: *ct = c;
483: }
484: return a;
485: }
486:
487: /*
488: * www_parseMultiPart() - Parse Multi part POST CGI query string
489: *
490: * @str = String
491: * @ctlen = Content length
492: * @ct = Content type
493: * return: NULL error or allocated cgi session
494: */
495: cgi_t *
496: www_parseMultiPart(const char *str, int ctlen, const char *ct)
497: {
498: cgi_t *cgi, *attr;
499: mime_t *mime = NULL;
500: struct tagMIME *m;
501: struct tagCGI *t, *old = NULL;
502: const char *s;
503: int len;
504:
505: if (!str) {
506: www_SetErr(EINVAL, "String is NULL");
507: return NULL;
508: }
509:
510: cgi = malloc(sizeof(cgi_t));
511: if (!cgi) {
512: LOGERR;
513: return NULL;
514: } else {
515: memset(cgi, 0, sizeof(cgi_t));
516: SLIST_INIT(cgi);
517: }
518:
519: /* parse MIME messages */
520: attr = www_parseAttributes(&ct);
521: if (!attr) {
522: www_closeCGI(&cgi);
523: return NULL;
524: }
525: mime = mime_parseMultiPart(str, ctlen, www_getAttribute(attr, "boundary"), NULL);
526: www_freeAttributes(&attr);
1.2 misho 527: if (!mime) {
528: www_closeCGI(&cgi);
529: return NULL;
530: }
1.1 misho 531:
532: SLIST_FOREACH(m, mime, mime_node) {
533: s = mime_getValue(m, "content-disposition");
534: attr = www_parseAttributes(&s);
1.2 misho 535: if (!www_getAttribute(attr, "name")) {
536: www_freeAttributes(&attr);
537: continue;
538: }
1.1 misho 539:
540: t = malloc(sizeof(struct tagCGI));
541: if (!t) {
542: LOGERR;
543: mime_close(&mime);
544: www_closeCGI(&cgi);
545: return NULL;
546: } else
547: memset(t, 0, sizeof(struct tagCGI));
548:
549: t->cgi_name = strdup(www_getAttribute(attr, "name"));
550: len = mime_calcRawSize(m);
551: t->cgi_value = malloc(len + 1);
552: if (t->cgi_value) {
553: len = mime_getRawData(m, t->cgi_value, len + 1);
554: t->cgi_value[len] = 0;
555: }
556:
557: www_freeAttributes(&attr);
558:
559: if (!old)
560: SLIST_INSERT_HEAD(cgi, t, cgi_node);
561: else
562: SLIST_INSERT_AFTER(old, t, cgi_node);
563: old = t;
564: }
565:
566: mime_close(&mime);
567: return cgi;
568: }
569:
570: /*
571: * www_parseAttributes() - Parse attributes
572: *
573: * @ct = Content type
574: * return: NULL error or !=NULL attributes
575: */
576: inline cgi_t *
577: www_parseAttributes(const char **ct)
578: {
579: struct tagCGI *t, *old = NULL;
580: cgi_t *attr = NULL;
581:
582: if (!ct) {
583: www_SetErr(EINVAL, "String is NULL");
584: return NULL;
585: }
586:
587: attr = malloc(sizeof(cgi_t));
588: if (!attr) {
589: LOGERR;
590: return NULL;
591: } else {
592: memset(attr, 0, sizeof(cgi_t));
593: SLIST_INIT(attr);
594: }
595:
596: /* get mime attributes */
597: while ((t = addAttr(ct))) {
598: if (!old)
599: SLIST_INSERT_HEAD(attr, t, cgi_node);
600: else
601: SLIST_INSERT_AFTER(old, t, cgi_node);
602: old = t;
603: }
604:
605: return attr;
606: }
607:
608: /*
609: * www_freeAttributes() - Free attributes
610: *
611: * @attr = Attributes
612: * return: none
613: */
614: inline void
615: www_freeAttributes(cgi_t ** __restrict attr)
616: {
617: struct tagCGI *t;
618:
619: if (!attr || !*attr)
620: return;
621:
622: /* free mime attributes */
623: while ((t = SLIST_FIRST(*attr))) {
624: if (t->cgi_name)
625: free(t->cgi_name);
626: if (t->cgi_value)
627: free(t->cgi_value);
628: SLIST_REMOVE_HEAD(*attr, cgi_node);
629: free(t);
630: }
631:
632: free(*attr);
633: *attr = NULL;
634: }
635:
636: /*
637: * www_getAttribute() - Get attribute by name
638: *
639: * @attr = Attributes
640: * @name = Name of attribute
641: * return: NULL not found or !=NULL attribute value
642: */
643: inline const char *
644: www_getAttribute(cgi_t * __restrict attr, const char *name)
645: {
646: struct tagCGI *t;
647:
648: SLIST_FOREACH(t, attr, cgi_node)
649: if (!strcasecmp(t->cgi_name, name))
650: return t->cgi_value;
651:
652: return NULL;
653: }