![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mime.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 mime.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.2.2.1 ! misho 6: * $Id: mime.c,v 1.2 2012/03/10 00:26:49 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: #include "tools.h"
49:
50:
51: static int decode_quoted(char *, int, char *);
52: static int decode_base64(char *, int, char *);
53:
54: static const char *n_encode[] = { "7bit", "8bit", "binary" };
55: static struct _tagEncode {
56: char *name;
57: float mul;
58:
59: int (*decode)(char *, int, char *);
60: } encode[] = {
61: { "quoted-printable", 1, decode_quoted },
62: { "base64", (float) 3 / 4, decode_base64 }
63: };
64:
65:
66: static inline char *
67: bd_begin(const char *str)
68: {
69: char *s;
70: int len = strlen(str) + 6;
71:
72: s = malloc(len + 1);
73: if (!s) {
74: LOGERR;
75: return NULL;
76: } else {
77: snprintf(s, len + 1, "\r\n--%s\r\n", str);
78: s[len] = 0;
79: }
80:
81: return s;
82: }
83:
84: static inline char *
85: bd_end(const char *str)
86: {
87: char *s;
88: int len = strlen(str) + 8;
89:
90: s = malloc(len + 1);
91: if (!s) {
92: LOGERR;
93: return NULL;
94: } else {
95: snprintf(s, len + 1, "\r\n--%s--\r\n", str);
96: s[len] = 0;
97: }
98:
99: return s;
100: }
101:
102: static u_int
103: powmod(int x, int y, int q)
104: {
105: u_int ret = 1;
106:
107: while (y) {
108: if (y & 1)
109: ret = ((unsigned long long)ret * x) % q;
110: x = (unsigned long long) x * x % q;
111: y = y / 2;
112: }
113: return ret;
114: }
115:
116: static const char *
117: findtextpos(const char *T, size_t tlen, const char *P, size_t plen)
118: {
119: const u_int q = 4294967291u;
120: const u_int d = 256;
121: u_int hash, p = 0, t = 0;
122: register int i;
123:
124: hash = powmod(d, plen - 1, q);
125:
126: /* calculate initial hash tags */
127: for (i = 0; i < plen; i++) {
128: p = (d * p + P[i]) % q;
129: t = (d * t + T[i]) % q;
130: }
131:
132: tlen -= plen;
133: for (i = 0; i <= tlen; i++) {
134: if (p == t) {
135: /* match pattern */
136: if (!memcmp(P, T + i, plen))
137: return T + i;
138: }
139:
140: /* rehashing */
141: if (i < tlen)
142: t = (d * (t - T[i] * hash) + T[i + plen]) % q;
143: }
144:
145: return NULL;
146: }
147:
148: static inline void
149: freeHeader(struct tagMIME * __restrict m)
150: {
151: struct tagCGI *c;
152:
153: while ((c = SLIST_FIRST(&m->mime_header))) {
154: if (c->cgi_name)
155: free(c->cgi_name);
156: if (c->cgi_value)
157: free(c->cgi_value);
158: SLIST_REMOVE_HEAD(&m->mime_header, cgi_node);
159: free(c);
160: }
161: }
162:
163: static char *
164: hdrValue(const char *str, size_t len, const char **end)
165: {
166: const char *e, *crlf = NULL;
167: char *tmp, *s = NULL;
168: int off = 0;
169:
170: e = str + len;
171: while (str < e) {
1.2 misho 172: if (!(crlf = findtextpos(str, e - str, CRLF, strlen(CRLF)))) {
1.2.2.1 ! misho 173: www_SetErr(EFAULT, "Bad header format of MIME part");
1.1 misho 174: return NULL;
175: }
176:
177: tmp = realloc(s, crlf - str + off + 1);
178: if (!tmp) {
179: LOGERR;
180: free(s);
181: return NULL;
182: } else
183: s = tmp;
184:
185: memcpy(s + off, str, crlf - str);
186: s[crlf - str + off] = 0;
187: off += crlf - str;
188:
189: /* if is multi part header value */
190: tmp = (char*) crlf + strlen(CRLF);
191: if (*tmp == ' ' || *tmp == '\t')
192: str = ++tmp;
193: else
194: break;
195: }
196:
197: *end = crlf + strlen(CRLF);
198: return s;
199: }
200:
201: static inline int
202: hexdigit(char a)
203: {
204: if (a >= '0' && a <= '9')
205: return a - '0';
206: if (a >= 'a' && a <= 'f')
207: return a - 'a' + 10;
208: if (a >= 'A' && a <= 'F')
209: return a - 'A' + 10;
210: /* error!!! */
211: return -1;
212: }
213:
214: static int
215: decode_quoted(char *in, int len, char *out)
216: {
217: register int i, cx;
218:
219: for (i = cx = 0; i < len; i++)
220: if (in[i] == '=') {
221: /* special handling */
222: i++;
223: if ((in[i] >= '0' && in[i] <= '9') ||
224: (in[i] >= 'A' && in[i] <= 'F') ||
225: (in[i] >= 'a' && in[i] <= 'f')) {
226: /* encoding a special char */
227: *out++ = hexdigit(in[i]) << 4 | hexdigit(in[i+ 1]);
228: cx++;
229: } else
230: i += strlen(CRLF);
231: } else {
232: *out++ = in[i++];
233: cx++;
234: }
235:
236: return cx;
237: }
238:
239: static int
240: decode_base64(char *in, int len, char *out)
241: {
242: register int cx, i, j;
243: int bits, eqc;
244:
245: for (cx = i = eqc = bits = 0; i < len && !eqc; bits = 0) {
246: for (j = 0; i < len && j < 4; i++) {
247: switch (in[i]) {
248: case 'A': case 'B': case 'C': case 'D': case 'E':
249: case 'F': case 'G': case 'H': case 'I': case 'J':
250: case 'K': case 'L': case 'M': case 'N': case 'O':
251: case 'P': case 'Q': case 'R': case 'S': case 'T':
252: case 'U': case 'V': case 'W': case 'X': case 'Y':
253: case 'Z':
254: bits = (bits << 6) | (in[i] - 'A');
255: j++;
256: break;
257: case 'a': case 'b': case 'c': case 'd': case 'e':
258: case 'f': case 'g': case 'h': case 'i': case 'j':
259: case 'k': case 'l': case 'm': case 'n': case 'o':
260: case 'p': case 'q': case 'r': case 's': case 't':
261: case 'u': case 'v': case 'w': case 'x': case 'y':
262: case 'z':
263: bits = (bits << 6) | (in[i] - 'a' + 26);
264: j++;
265: break;
266: case '0': case '1': case '2': case '3': case '4':
267: case '5': case '6': case '7': case '8': case '9':
268: bits = (bits << 6) | (in[i] - '0' + 52);
269: j++;
270: break;
271: case '+':
272: bits = (bits << 6) | 62;
273: j++;
274: break;
275: case '/':
276: bits = (bits << 6) | 63;
277: j++;
278: break;
279: case '=':
280: bits <<= 6;
281: j++;
282: eqc++;
283: break;
284: default:
285: break;
286: }
287: }
288:
289: if (!j && i >= len)
290: continue;
291:
292: switch (eqc) {
293: case 0:
294: *out++ = (bits >> 16) & 0xff;
295: *out++ = (bits >> 8) & 0xff;
296: *out++ = bits & 0xff;
297: cx += 3;
298: break;
299: case 1:
300: *out++ = (bits >> 16) & 0xff;
301: *out++ = (bits >> 8) & 0xff;
302: cx += 2;
303: break;
304: case 2:
305: *out++ = (bits >> 16) & 0xff;
306: cx += 1;
307: break;
308: }
309: }
310:
311: return cx;
312: }
313:
314: /* ------------------------------------------------------------------ */
315:
316: /*
317: * mime_parseMultiPart() - Parse multi part MIME message
318: *
319: * @str = String
320: * @len = String length
321: * @bd = Boundary tag
322: * @end = End of parsed part
323: * return: NULL error or !=NULL allocated MIME session
324: */
325: mime_t *
326: mime_parseMultiPart(const char *str, size_t len, const char *bdtag, const char **end)
327: {
328: mime_t *mime = NULL;
329: struct iovec bd[2];
330: struct tagMIME *m, *old = NULL;
1.2 misho 331: const char *next = NULL;
1.1 misho 332:
333: if (!str | !bdtag) {
334: www_SetErr(EINVAL, "String or boundary tag is NULL");
335: return NULL;
336: }
337:
338: /* init MIME */
339: mime = malloc(sizeof(mime_t));
340: if (!mime) {
341: LOGERR;
342: return NULL;
343: } else {
344: memset(mime, 0, sizeof(mime_t));
345: SLIST_INIT(mime);
346: }
347:
348: /* prepare boundary format */
349: bd[0].iov_base = bd_begin(bdtag);
350: if (!bd[0].iov_base) {
351: free(mime);
352: return NULL;
353: } else
354: bd[0].iov_len = strlen(bd[0].iov_base);
355: bd[1].iov_base = bd_end(bdtag);
356: if (!bd[1].iov_base) {
357: free(bd[0].iov_base);
358: free(mime);
359: return NULL;
360: } else
361: bd[1].iov_len = strlen(bd[1].iov_base);
1.2 misho 362:
363: /* check boundary tag */
1.1 misho 364: if (memcmp(str, strstr(bd[0].iov_base, "--"), strlen(strstr(bd[0].iov_base, "--")))) {
1.2.2.1 ! misho 365: www_SetErr(EFAULT, "Bad content data, not found boundary tag");
1.1 misho 366: free(bd[1].iov_base);
367: free(bd[0].iov_base);
368: free(mime);
369: return NULL;
370: } else {
371: str += strlen(strstr(bd[0].iov_base, "--"));
372: len -= strlen(strstr(bd[0].iov_base, "--"));
373: }
374:
1.2 misho 375: while (len > 0) {
1.1 misho 376: m = malloc(sizeof(struct tagMIME));
377: if (!m) {
378: LOGERR;
379: mime_close(&mime);
380: free(bd[1].iov_base);
381: free(bd[0].iov_base);
382: return NULL;
383: } else {
384: memset(m, 0, sizeof(struct tagMIME));
385: SLIST_INIT(&m->mime_header);
386: }
387:
388: if (!(next = findtextpos(str, len, bd[0].iov_base, bd[0].iov_len)))
389: next = findtextpos(str, len, bd[1].iov_base, bd[1].iov_len);
390:
391: /* parse message between tags */
392: if (mime_readPart(m, str, next - str)) {
393: mime_close(&mime);
394: free(bd[1].iov_base);
395: free(bd[0].iov_base);
396: return NULL;
397: }
398:
399: str += next - str;
400: len -= next - str;
401:
402: /* add to mime session */
403: if (!old)
404: SLIST_INSERT_HEAD(mime, m, mime_node);
405: else
406: SLIST_INSERT_AFTER(old, m, mime_node);
407: old = m;
408:
409: /* match part termination tag */
410: if (!memcmp(str, bd[1].iov_base, bd[1].iov_len))
411: break;
412:
413: str += bd[0].iov_len;
414: len -= bd[0].iov_len;
415: }
416:
417: str += bd[0].iov_len;
1.2 misho 418: /* LLVM static code analyzer said for this - unusable
419: *
1.1 misho 420: len -= bd[0].iov_len;
1.2 misho 421: */
422:
423: free(bd[1].iov_base);
424: free(bd[0].iov_base);
1.1 misho 425:
426: if (end)
427: *end = str;
428: return mime;
429: }
430:
431: static inline void
432: freeMIME(struct tagMIME * __restrict m)
433: {
434: if (m->mime_body.iov_base)
435: free(m->mime_body.iov_base);
436: if (m->mime_prolog.iov_base)
437: free(m->mime_prolog.iov_base);
438: if (m->mime_epilog.iov_base)
439: free(m->mime_epilog.iov_base);
440:
441: freeHeader(m);
442: mime_close(&m->mime_attach);
443: }
444:
445: /*
446: * mime_close() - Close MIME session and free all resources
447: *
448: * @mime = Inited mime session
449: * return: none
450: */
451: void
452: mime_close(mime_t ** __restrict mime)
453: {
454: struct tagMIME *m;
455:
456: if (!mime || !*mime)
457: return;
458:
459: while ((m = SLIST_FIRST(*mime))) {
460: SLIST_REMOVE_HEAD(*mime, mime_node);
461: freeMIME(m);
462: free(m);
463: }
464:
465: free(*mime);
466: *mime = NULL;
467: }
468:
469: /*
470: * mime_parseHeader() - Parse MIME header pairs
471: *
472: * @m = Mime part
473: * @str = String
474: * @len = String length
475: * @end = End of parsed part
476: * return: -1 error or 0 ok
477: */
478: int
479: mime_parseHeader(struct tagMIME * __restrict m, const char *str, size_t len, const char **end)
480: {
481: const char *e, *colon, *eoh;
482: struct tagCGI *c, *old = NULL;
483:
484: if (!m || !str) {
485: www_SetErr(EINVAL, "Mime part or string is NULL");
486: return -1;
487: } else
488: e = str + len;
489:
490: while (str < e) {
491: if (!memcmp(str, CRLF, strlen(CRLF))) {
492: str += 2;
493: break;
494: }
495:
496: colon = memchr(str, ':', e - str);
497: eoh = findtextpos(str, e - str, CRLF, strlen(CRLF));
498: if (!colon || !eoh || colon > eoh) {
1.2.2.1 ! misho 499: www_SetErr(EFAULT, "Bad MIME format message");
1.1 misho 500: freeHeader(m);
501: return -1;
502: }
503:
504: c = malloc(sizeof(struct tagCGI));
505: if (!c) {
506: LOGERR;
507: freeHeader(m);
508: return -1;
509: }
510: /* get name */
511: c->cgi_name = malloc(colon - str + 1);
512: if (!c->cgi_name) {
513: LOGERR;
514: free(c);
515: freeHeader(m);
516: return -1;
517: } else {
518: memcpy(c->cgi_name, str, colon - str);
519: c->cgi_name[colon - str] = 0;
520: }
521: /* get value */
522: c->cgi_value = hdrValue(colon + 1, e - colon - 1, &str);
1.2 misho 523: if (!c->cgi_value) {
524: free(c->cgi_name);
525: free(c);
526: freeHeader(m);
527: return -1;
528: }
1.1 misho 529:
530: if (!old)
531: SLIST_INSERT_HEAD(&m->mime_header, c, cgi_node);
532: else
533: SLIST_INSERT_AFTER(old, c, cgi_node);
534: old = c;
535: }
536:
537: if (end)
538: *end = str;
539: return 0;
540: }
541:
542: /*
543: * mime_getValue() - Get value from MIME header
544: *
545: * @m = Mime part
546: * @name = Header name
547: * return: NULL not found or !=NULL value
548: */
549: inline const char *
550: mime_getValue(struct tagMIME * __restrict m, const char *name)
551: {
552: struct tagCGI *c;
553: const char *v = NULL;
554:
555: SLIST_FOREACH(c, &m->mime_header, cgi_node)
1.2 misho 556: if (!strcasecmp(c->cgi_name, name)) {
1.1 misho 557: v = c->cgi_value;
558: break;
559: }
560: return v;
561: }
562:
563: /*
564: * mime_readPart() Read and parse MIME part
565: *
566: * @m = Mime part
567: * @str = String
568: * @len = String length
569: * return: -1 error or 0 ok
570: */
571: int
572: mime_readPart(struct tagMIME * __restrict m, const char *str, size_t len)
573: {
574: const char *eoh, *ct, *eb;
575: cgi_t *attr;
576: struct iovec bd;
577:
1.2 misho 578: if (!m || !str || (ssize_t) len < 0) {
579: www_SetErr(EINVAL, "Mime part, string is NULL or length is less 0");
1.1 misho 580: return -1;
581: }
582:
583: if (mime_parseHeader(m, str, len, &eoh))
584: return -1;
585:
586: ct = mime_getValue(m, "content-type");
587: if (!ct || www_cmptype(ct, "multipart")) {
588: /* not multi part, assign like body element */
589: m->mime_body.iov_base = malloc(len - (eoh - str) + 1);
1.2 misho 590: if (!m->mime_body.iov_base) {
591: LOGERR;
592: freeHeader(m);
593: return -1;
594: }
1.1 misho 595: memcpy(m->mime_body.iov_base, eoh, len - (eoh - str));
596: ((char*) m->mime_body.iov_base)[len - (eoh - str)] = 0;
597: m->mime_body.iov_len = len - (eoh - str) + 1;
598: } else {
599: /* multi part */
600: attr = www_parseAttributes(&ct);
1.2 misho 601: if (!attr) {
602: freeHeader(m);
1.1 misho 603: return -1;
1.2 misho 604: }
1.1 misho 605: bd.iov_base = bd_begin(www_getAttribute(attr, "boundary"));
606: bd.iov_len = strlen(bd.iov_base);
607: eb = findtextpos(eoh, len - (eoh - str), bd.iov_base, bd.iov_len);
608: free(bd.iov_base);
609:
610: /* set prolog if exists */
611: if (eb != eoh) {
612: m->mime_prolog.iov_base = malloc(eb - eoh + 1);
613: if (!m->mime_prolog.iov_base) {
614: LOGERR;
615: www_freeAttributes(&attr);
1.2 misho 616: freeHeader(m);
1.1 misho 617: return -1;
618: }
619: memcpy(m->mime_prolog.iov_base, eoh, eb - eoh);
620: ((char*) m->mime_prolog.iov_base)[eb - eoh] = 0;
621: m->mime_prolog.iov_len = eb - eoh + 1;
622: }
623:
624: m->mime_attach = mime_parseMultiPart(eb + 1, len - (eb + 1 - str),
625: www_getAttribute(attr, "boundary"), &eoh);
626:
627: /* set epilog if exists */
628: if (eoh - str < len) {
629: m->mime_epilog.iov_base = malloc(len - (eoh - str) + 1);
630: if (!m->mime_epilog.iov_base) {
631: LOGERR;
632: www_freeAttributes(&attr);
1.2 misho 633: freeHeader(m);
1.1 misho 634: return -1;
635: }
636: memcpy(m->mime_epilog.iov_base, str, len - (eoh - str));
637: ((char*) m->mime_epilog.iov_base)[len - (eoh - str)] = 0;
638: m->mime_epilog.iov_len = len - (eoh - str) + 1;
639:
640: }
1.2 misho 641:
642: www_freeAttributes(&attr);
1.1 misho 643: }
644:
645: return 0;
646: }
647:
648: /*
649: * mime_calcRawSize() - Calculate estimated memory for data from parsed MIME part
650: *
651: * @m = Mime part
652: * return: -1 error or >-1 data size in mime part
653: */
654: int
655: mime_calcRawSize(struct tagMIME * __restrict m)
656: {
657: const char *s;
658: char *t;
659: int len;
660: register int i;
661:
662: if (!m) {
663: www_SetErr(EINVAL, "Mime part is NULL");
664: return -1;
665: }
666:
667: /* no body */
668: if (m->mime_body.iov_len < 1)
669: return 0;
670:
671: s = mime_getValue(m, "content-transfer-encoding");
672: if (!s)
673: return m->mime_body.iov_len;
674: /* strip whitespaces */
675: while (isspace(*s))
676: s++;
677: t = strchr(s, ';');
678: len = t ? strlen(s) : t - s;
679:
680: /* find proper encoding */
681: for (i = 0; i < sizeof n_encode / sizeof *n_encode; i++)
682: if (len == strlen(n_encode[i]) && !strncasecmp(s, n_encode[i], len))
683: return m->mime_body.iov_len;
684:
685: for (i = 0; i < sizeof encode / sizeof *encode; i++)
686: if (len == strlen(encode[i].name) && !strncasecmp(s, encode[i].name, len))
687: return m->mime_body.iov_len * encode[i].mul;
688:
689: /* fail */
690: return -1;
691: }
692:
693: /*
694: * mime_getRawData() - Get ready parsed data from MIME part body
695: *
696: * @m = Mime part
697: * @str = output data buffer
698: * @len = output data buffer length
699: * return: -1 error or >-1 data length in output buffer
700: */
701: int
702: mime_getRawData(struct tagMIME * __restrict m, char * __restrict str, int slen)
703: {
704: const char *s;
705: char *t;
706: int len;
707: register int i;
708:
709: if (!m || !str) {
710: www_SetErr(EINVAL, "Mime part or string is NULL");
711: return -1;
712: }
713:
714: /* no body */
715: if (m->mime_body.iov_len < 1)
716: return 0;
717:
718: s = mime_getValue(m, "content-transfer-encoding");
719: if (!s) {
720: memcpy(str, m->mime_body.iov_base, m->mime_body.iov_len > (slen - 1) ?
721: slen - 1 : m->mime_body.iov_len);
722: return m->mime_body.iov_len;
723: }
724:
725: /* strip whitespaces */
726: while (isspace(*s))
727: s++;
728: t = strchr(s, ';');
729: len = t ? strlen(s) : t - s;
730:
731: /* decoding body */
732: for (i = 0; i < sizeof encode / sizeof *encode; i++)
733: if (len == strlen(encode[i].name) && !strncasecmp(s, encode[i].name, len))
734: return encode[i].decode(m->mime_body.iov_base,
735: m->mime_body.iov_len, str);
736:
737: /* fail */
738: return -1;
739: }