![[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.1.1.1.2.1! misho 6: * $Id: aitwww.c,v 1.1.1.1 2012/03/08 23:40:21 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 "tools.h"
48: #include "mime.h"
49:
50:
51: #pragma GCC visibility push(hidden)
52:
53: int www_Errno;
54: char www_Error[STRSIZ];
55:
56: #pragma GCC visibility pop
57:
58: // www_GetErrno() Get error code of last operation
59: inline int
60: www_GetErrno()
61: {
62: return www_Errno;
63: }
64:
65: // www_GetError() Get error text of last operation
66: inline const char *
67: www_GetError()
68: {
69: return www_Error;
70: }
71:
72: // www_SetErr() Set error to variables for internal use!!!
73: inline void
74: www_SetErr(int eno, char *estr, ...)
75: {
76: va_list lst;
77:
78: www_Errno = eno;
79: memset(www_Error, 0, STRSIZ);
80: va_start(lst, estr);
81: vsnprintf(www_Error, STRSIZ, estr, lst);
82: va_end(lst);
83: }
84:
85: /* -------------------------------------------------------------- */
86:
87: /*
88: * www_initCGI() - Init CGI program
89: *
90: * return: NULL error or allocated cgi session
91: */
92: cgi_t *
93: www_initCGI(void)
94: {
95: char *s, *str;
96: int ctlen, rlen;
97: register int i;
98: cgi_t *cgi = NULL;
99:
100: str = getenv("REQUEST_METHOD");
101: if (!str) {
102: www_SetErr(EBADMSG, "Request method not found");
103: return NULL;
104: }
105: if (!strcmp(str, "GET") || !strcmp(str, "HEAD")) {
106: /* GET | HEAD */
107: str = getenv("QUERY_STRING");
108: if (!str) {
109: www_SetErr(EBADMSG, "Query string not found");
110: return NULL;
111: }
112: cgi = www_parseQuery(str);
113: } else if (!strcmp(str, "POST")) {
114: /* POST */
115: str = getenv("CONTENT_LENGTH");
116: if (!str) {
117: www_SetErr(EBADMSG, "Content length not found");
118: return NULL;
119: } else
120: ctlen = strtol(str, NULL, 0);
121:
122: s = getenv("CONTENT_TYPE");
123: if (!s) {
124: www_SetErr(EBADMSG, "Content type not found");
125: return NULL;
126: }
127: if (www_cmp(s, "multipart/form-data") &&
128: www_cmp(s, "application/x-www-form-urlencoded")) {
129: www_SetErr(EBADMSG, "MIME parts are broken");
130: return NULL;
131: }
132:
133: /* allocated space for post data */
134: str = malloc(ctlen + 1);
135: if (!str) {
136: LOGERR;
137: return NULL;
138: }
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 */
151: www_SetErr(EBADMSG, "Unknown request method");
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.1.1.1.2.1! 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.1.1.1.2.1! misho 260: return t->cgi_value;
1.1 misho 261:
1.1.1.1.2.1! 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.1.1.1.2.1! 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: {
327: struct tagCGI *t;
328:
329: if (!cgi || !name) {
330: www_SetErr(EINVAL, "Invalid argument(s)");
331: return -1;
332: }
333:
334: /* search for delete */
335: SLIST_FOREACH(t, cgi, cgi_node)
336: if (t->cgi_name && !strcmp(name, t->cgi_name)) {
337: SLIST_REMOVE(cgi, t, tagCGI, cgi_node);
338: return 1;
339: }
340:
341: return 0;
342: }
343:
344: /*
345: * www_header() - Output initial html header
346: *
347: * @output = file handle
348: * return: <1 error or >0 writed bytes
349: */
350: inline int
351: www_header(FILE *output)
352: {
353: FILE *f = output ? output : stdout;
354:
355: return fputs("Content-type: text/html\n\n", f);
356: }
357:
358: static char *
359: quotStr(const char *str, const char **end)
360: {
361: char *s, *e;
362: int n, len = 0;
363: register int i;
364:
365: /* get str w/o " */
366: if (*str != '"') {
367: n = strspn(str, "!#$%&'*+-.0123456789?ABCDEFGHIJKLMNOPQRSTUVWXYZ"
368: "^_`abcdefghijklmnopqrstuvwxyz{|}~");
369: s = malloc(n + 1);
370: if (!s) {
371: LOGERR;
372: return NULL;
373: } else {
374: strncpy(s, str, n);
375: s[n] = 0;
376: *end = str + n;
377: return s;
378: }
379: } else
380: str++;
381: /* get quoted string */
382: if (!(e = strchr(str, '"')))
383: return NULL;
384: else
385: len = e - str;
386: s = malloc(len + 1);
387: if (!s) {
388: LOGERR;
389: return NULL;
390: }
391:
392: for (i = 0; i < len; i++, str++) {
393: if (*str == '\\' || *str == '\n')
394: s[i] = *++str;
395: else if (*str == '"')
396: break;
397: else
398: s[i] = *str;
399: }
400: s[i] = 0;
401:
402: *end = ++str;
403: return s;
404: }
405:
406: static struct tagCGI *
407: addAttr(const char **ct)
408: {
409: struct tagCGI *a;
410: const char *c, *eq;
411: char *name, *value;
412:
413: if (!*ct || !(c = strchr(*ct, ';')))
414: return NULL;
415: else
416: c++;
417: while (isspace(*c))
418: c++;
419:
420: if (!(eq = strchr(c, '=')))
421: return NULL;
422:
423: /* parse name */
424: name = malloc(eq - c + 1);
425: if (!name) {
426: LOGERR;
427: return NULL;
428: } else {
429: strncpy(name, c, eq - c);
430: name[eq - c] = 0;
431: }
432: /* parse value */
433: value = quotStr(++eq, &c);
434: if (!value) {
435: free(name);
436: return NULL;
437: }
438:
439: /* fill tagCGI */
440: a = malloc(sizeof(struct tagCGI));
441: if (!a) {
442: LOGERR;
443: return NULL;
444: } else {
445: a->cgi_name = name;
446: a->cgi_value = value;
447: *ct = c;
448: }
449: return a;
450: }
451:
452: /*
453: * www_parseMultiPart() - Parse Multi part POST CGI query string
454: *
455: * @str = String
456: * @ctlen = Content length
457: * @ct = Content type
458: * return: NULL error or allocated cgi session
459: */
460: cgi_t *
461: www_parseMultiPart(const char *str, int ctlen, const char *ct)
462: {
463: cgi_t *cgi, *attr;
464: mime_t *mime = NULL;
465: struct tagMIME *m;
466: struct tagCGI *t, *old = NULL;
467: const char *s;
468: int len;
469:
470: if (!str) {
471: www_SetErr(EINVAL, "String is NULL");
472: return NULL;
473: }
474:
475: cgi = malloc(sizeof(cgi_t));
476: if (!cgi) {
477: LOGERR;
478: return NULL;
479: } else {
480: memset(cgi, 0, sizeof(cgi_t));
481: SLIST_INIT(cgi);
482: }
483:
484: /* parse MIME messages */
485: attr = www_parseAttributes(&ct);
486: if (!attr) {
487: www_closeCGI(&cgi);
488: return NULL;
489: }
490: mime = mime_parseMultiPart(str, ctlen, www_getAttribute(attr, "boundary"), NULL);
491: www_freeAttributes(&attr);
492:
493: SLIST_FOREACH(m, mime, mime_node) {
494: s = mime_getValue(m, "content-disposition");
495: attr = www_parseAttributes(&s);
496:
497: t = malloc(sizeof(struct tagCGI));
498: if (!t) {
499: LOGERR;
500: mime_close(&mime);
501: www_closeCGI(&cgi);
502: return NULL;
503: } else
504: memset(t, 0, sizeof(struct tagCGI));
505:
506: t->cgi_name = strdup(www_getAttribute(attr, "name"));
507: len = mime_calcRawSize(m);
508: t->cgi_value = malloc(len + 1);
509: if (t->cgi_value) {
510: len = mime_getRawData(m, t->cgi_value, len + 1);
511: t->cgi_value[len] = 0;
512: }
513:
514: www_freeAttributes(&attr);
515:
516: if (!old)
517: SLIST_INSERT_HEAD(cgi, t, cgi_node);
518: else
519: SLIST_INSERT_AFTER(old, t, cgi_node);
520: old = t;
521: }
522:
523: mime_close(&mime);
524: return cgi;
525: }
526:
527: /*
528: * www_parseAttributes() - Parse attributes
529: *
530: * @ct = Content type
531: * return: NULL error or !=NULL attributes
532: */
533: inline cgi_t *
534: www_parseAttributes(const char **ct)
535: {
536: struct tagCGI *t, *old = NULL;
537: cgi_t *attr = NULL;
538:
539: if (!ct) {
540: www_SetErr(EINVAL, "String is NULL");
541: return NULL;
542: }
543:
544: attr = malloc(sizeof(cgi_t));
545: if (!attr) {
546: LOGERR;
547: return NULL;
548: } else {
549: memset(attr, 0, sizeof(cgi_t));
550: SLIST_INIT(attr);
551: }
552:
553: /* get mime attributes */
554: while ((t = addAttr(ct))) {
555: if (!old)
556: SLIST_INSERT_HEAD(attr, t, cgi_node);
557: else
558: SLIST_INSERT_AFTER(old, t, cgi_node);
559: old = t;
560: }
561:
562: return attr;
563: }
564:
565: /*
566: * www_freeAttributes() - Free attributes
567: *
568: * @attr = Attributes
569: * return: none
570: */
571: inline void
572: www_freeAttributes(cgi_t ** __restrict attr)
573: {
574: struct tagCGI *t;
575:
576: if (!attr || !*attr)
577: return;
578:
579: /* free mime attributes */
580: while ((t = SLIST_FIRST(*attr))) {
581: if (t->cgi_name)
582: free(t->cgi_name);
583: if (t->cgi_value)
584: free(t->cgi_value);
585: SLIST_REMOVE_HEAD(*attr, cgi_node);
586: free(t);
587: }
588:
589: free(*attr);
590: *attr = NULL;
591: }
592:
593: /*
594: * www_getAttribute() - Get attribute by name
595: *
596: * @attr = Attributes
597: * @name = Name of attribute
598: * return: NULL not found or !=NULL attribute value
599: */
600: inline const char *
601: www_getAttribute(cgi_t * __restrict attr, const char *name)
602: {
603: struct tagCGI *t;
604:
605: SLIST_FOREACH(t, attr, cgi_node)
606: if (!strcasecmp(t->cgi_name, name))
607: return t->cgi_value;
608:
609: return NULL;
610: }