Annotation of embedaddon/libpdel/http/http_mime.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/queue.h>
! 43:
! 44: #include <netinet/in.h>
! 45:
! 46: #include <stdio.h>
! 47: #include <stdlib.h>
! 48: #include <stdarg.h>
! 49: #include <string.h>
! 50: #include <syslog.h>
! 51: #include <pthread.h>
! 52: #include <errno.h>
! 53: #include <limits.h>
! 54: #include <ctype.h>
! 55:
! 56: #include <openssl/ssl.h>
! 57:
! 58: #include "structs/structs.h"
! 59: #include "structs/type/array.h"
! 60:
! 61: #include "io/boundary_fp.h"
! 62: #include "io/string_fp.h"
! 63: #include "util/typed_mem.h"
! 64: #include "http/http_defs.h"
! 65: #include "http/http_server.h"
! 66: #include "http/http_internal.h"
! 67:
! 68: #define CR '\r'
! 69: #define LF '\n'
! 70:
! 71: #define MIME_MEM_TYPE "mime_multipart"
! 72:
! 73: struct mime_multipart {
! 74: u_int nparts;
! 75: u_int nalloc;
! 76: struct mime_part *parts;
! 77: };
! 78:
! 79: struct mime_part {
! 80: struct http_head *head; /* mime headers */
! 81: u_char *data; /* part's data */
! 82: u_int dlen; /* length of data */
! 83: };
! 84:
! 85: /* Internal functions */
! 86: static http_mime_handler_t _http_request_read_mime_handler;
! 87:
! 88: /*
! 89: * Read in multi-part MIME data all at once into memory.
! 90: */
! 91: struct mime_multipart *
! 92: http_request_read_mime_multipart(struct http_request *req)
! 93: {
! 94: struct mime_multipart *mp;
! 95:
! 96: /* Allocate multipart structure */
! 97: if ((mp = MALLOC(MIME_MEM_TYPE, sizeof(*mp))) == NULL)
! 98: return (NULL);
! 99: memset(mp, 0, sizeof(*mp));
! 100:
! 101: /* Read in parts */
! 102: if (http_request_get_mime_multiparts(req,
! 103: _http_request_read_mime_handler, mp) < 0) {
! 104: http_mime_multipart_free(&mp);
! 105: return (NULL);
! 106: }
! 107:
! 108: /* Done */
! 109: return (mp);
! 110: }
! 111:
! 112: /*
! 113: * Handler used by http_request_read_mime_multipart().
! 114: */
! 115: static int
! 116: _http_request_read_mime_handler(void *arg, struct mime_part *part0, FILE *fp)
! 117: {
! 118: struct mime_multipart *const mp = arg;
! 119: struct mime_part *part;
! 120: FILE *sb = NULL;
! 121: char buf[256];
! 122: int nr;
! 123:
! 124: /* Allocate new part structure */
! 125: if (mp->nalloc < mp->nparts + 1) {
! 126: const u_int new_alloc = (mp->nalloc + 1) * 2;
! 127: struct mime_part *new_parts;
! 128:
! 129: if ((new_parts = REALLOC(MIME_MEM_TYPE,
! 130: mp->parts, new_alloc * sizeof(*mp->parts))) == NULL)
! 131: return (-1);
! 132: mp->parts = new_parts;
! 133: mp->nalloc = new_alloc;
! 134: }
! 135: part = &mp->parts[mp->nparts++];
! 136: memset(part, 0, sizeof(*part));
! 137:
! 138: /* Copy headers for this part */
! 139: if ((part->head = _http_head_copy(part0->head)) == NULL)
! 140: return (-1);
! 141:
! 142: /* Slurp part's data into memory buffer */
! 143: if ((sb = string_buf_output(MIME_MEM_TYPE)) == NULL)
! 144: return (-1);
! 145: while ((nr = fread(buf, 1, sizeof(buf), fp)) != 0) {
! 146: if (fwrite(buf, 1, nr, sb) != nr) {
! 147: fclose(sb);
! 148: return (-1);
! 149: }
! 150: }
! 151: if (ferror(fp)) {
! 152: fclose(sb);
! 153: return (-1);
! 154: }
! 155:
! 156: /* Extract data from string buffer stream */
! 157: part->dlen = string_buf_length(sb);
! 158: if ((part->data = (u_char *)string_buf_content(sb, 1)) == NULL) {
! 159: part->dlen = 0;
! 160: fclose(sb);
! 161: return (-1);
! 162: }
! 163: fclose(sb);
! 164:
! 165: /* Done */
! 166: return (0);
! 167: }
! 168:
! 169: /*
! 170: * Read in multi-part MIME data, and call the handler for each part.
! 171: *
! 172: * Returns the number of parts successfully read, or the ones
! 173: * complement of that number if the handler aborted.
! 174: */
! 175: int
! 176: http_request_get_mime_multiparts(struct http_request *req,
! 177: http_mime_handler_t *handler, void *arg)
! 178: {
! 179: const char *hval;
! 180: FILE *fp = NULL;
! 181: char boundary[256];
! 182: char buf[256];
! 183: char *tokctx;
! 184: FILE *input;
! 185: int nparts;
! 186: char *s;
! 187:
! 188: /* Get POST input stream */
! 189: if ((input = http_request_get_input(req)) == NULL)
! 190: return (~0);
! 191:
! 192: /* Get boundary string */
! 193: if ((hval = http_request_get_header(req,
! 194: HTTP_HEADER_CONTENT_TYPE)) == NULL
! 195: || strlen(hval) > sizeof(buf) - 1)
! 196: goto bogus;
! 197: strlcpy(buf, hval, sizeof(buf));
! 198: if ((s = strchr(buf, ';')) == NULL)
! 199: goto bogus;
! 200: *s++ = '\0';
! 201: if (strcasecmp(buf, HTTP_CTYPE_MULTIPART_FORMDATA) != 0)
! 202: goto bogus;
! 203: if ((s = strtok_r(s, " \t;=", &tokctx)) == NULL
! 204: || strcasecmp(s, "boundary") != 0
! 205: || (s = strtok_r(NULL, " \t;=", &tokctx)) == NULL) {
! 206: bogus: errno = EINVAL;
! 207: return (~0);
! 208: }
! 209: snprintf(boundary, sizeof(boundary), "\r\n--%s", s);
! 210:
! 211: /* Read up through the initial boundary string */
! 212: if ((fp = boundary_fopen(input, boundary + 2, 0)) == NULL)
! 213: return (~0);
! 214: while (fgets(buf, sizeof(buf), fp) != NULL)
! 215: ;
! 216: if (ferror(fp)) {
! 217: fclose(fp);
! 218: return (~0);
! 219: }
! 220: fclose(fp);
! 221:
! 222: /* Read in each part */
! 223: for (nparts = 0; 1; nparts++) {
! 224: struct mime_part part;
! 225: int ch;
! 226: int r;
! 227:
! 228: /* We just saw a boundary; see if it was the last one */
! 229: if ((ch = getc(input)) == '-')
! 230: return (nparts);
! 231: if (ch != '\r' || getc(input) != '\n') {
! 232: errno = EFTYPE;
! 233: break;
! 234: }
! 235:
! 236: /* Get stream for the next part only */
! 237: if ((fp = boundary_fopen(input, boundary, 0)) == NULL)
! 238: break;
! 239:
! 240: /* Read in the next part's headers */
! 241: memset(&part, 0, sizeof(part));
! 242: if ((part.head = _http_head_new()) == NULL) {
! 243: fclose(fp);
! 244: break;
! 245: }
! 246: if (_http_head_read_headers(part.head, fp) == -1) {
! 247: _http_head_free(&part.head);
! 248: fclose(fp);
! 249: break;
! 250: }
! 251:
! 252: /* Invoke the handler */
! 253: r = (*handler)(arg, &part, fp);
! 254:
! 255: /* Read any data not read by handler */
! 256: while (fgets(buf, sizeof(buf), fp) != NULL)
! 257: ;
! 258:
! 259: /* Clean up */
! 260: _http_head_free(&part.head);
! 261: fclose(fp);
! 262:
! 263: /* If handler aborted, stop */
! 264: if (r != 0)
! 265: break;
! 266: }
! 267:
! 268: /* There was an error */
! 269: return (~nparts);
! 270: }
! 271:
! 272: u_int
! 273: http_mime_multipart_get_count(struct mime_multipart *mp)
! 274: {
! 275: return (mp->nparts);
! 276: }
! 277:
! 278: struct mime_part *
! 279: http_mime_multipart_get_part(struct mime_multipart *mp, u_int index)
! 280: {
! 281: if (index >= mp->nparts) {
! 282: errno = EINVAL;
! 283: return (NULL);
! 284: }
! 285: return (&mp->parts[index]);
! 286: }
! 287:
! 288: void
! 289: http_mime_multipart_free(struct mime_multipart **mpp)
! 290: {
! 291: struct mime_multipart *const mp = *mpp;
! 292: int i;
! 293:
! 294: if (mp == NULL)
! 295: return;
! 296: for (i = 0; i < mp->nparts; i++) {
! 297: struct mime_part *const part = &mp->parts[i];
! 298:
! 299: _http_head_free(&part->head);
! 300: FREE(MIME_MEM_TYPE, part->data);
! 301: }
! 302: FREE(MIME_MEM_TYPE, mp->parts);
! 303: FREE(MIME_MEM_TYPE, mp);
! 304: *mpp = NULL;
! 305: }
! 306:
! 307: const char *
! 308: http_mime_part_get_header(struct mime_part *part, const char *name)
! 309: {
! 310: return (_http_head_get(part->head, name));
! 311: }
! 312:
! 313: u_int
! 314: http_mime_part_get_length(struct mime_part *part)
! 315: {
! 316: return (part->dlen);
! 317: }
! 318:
! 319: u_char *
! 320: http_mime_part_get_data(struct mime_part *part)
! 321: {
! 322: return (part->data);
! 323: }
! 324:
! 325:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_mime.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / http