[BACK]Return to mime.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitwww / src

Diff for /libaitwww/src/mime.c between versions 1.4 and 1.5

version 1.4, 2012/08/01 00:40:41 version 1.5, 2013/05/30 09:25:35
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 68  bd_begin(const char *str) Line 68  bd_begin(const char *str)
         char *s;          char *s;
         int len = strlen(str) + 6;          int len = strlen(str) + 6;
   
        s = io_malloc(len + 1);        s = e_malloc(len + 1);
         if (!s) {          if (!s) {
                www_SetErr(io_GetErrno(), "%s", io_GetError());                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 return NULL;                  return NULL;
         } else {          } else {
                 snprintf(s, len + 1, "\r\n--%s\r\n", str);                  snprintf(s, len + 1, "\r\n--%s\r\n", str);
Line 86  bd_end(const char *str) Line 86  bd_end(const char *str)
         char *s;          char *s;
         int len = strlen(str) + 8;          int len = strlen(str) + 8;
   
        s = io_malloc(len + 1);        s = e_malloc(len + 1);
         if (!s) {          if (!s) {
                www_SetErr(io_GetErrno(), "%s", io_GetError());                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 return NULL;                  return NULL;
         } else {          } else {
                 snprintf(s, len + 1, "\r\n--%s--\r\n", str);                  snprintf(s, len + 1, "\r\n--%s--\r\n", str);
Line 150  freeHeader(struct tagMIME * __restrict m) Line 150  freeHeader(struct tagMIME * __restrict m)
         struct tagCGI *c;          struct tagCGI *c;
   
         while ((c = SLIST_FIRST(&m->mime_header))) {          while ((c = SLIST_FIRST(&m->mime_header))) {
                io_freeVar(&c->cgi_name);                ait_freeVar(&c->cgi_name);
                io_freeVar(&c->cgi_value);                ait_freeVar(&c->cgi_value);
   
                 SLIST_REMOVE_HEAD(&m->mime_header, cgi_node);                  SLIST_REMOVE_HEAD(&m->mime_header, cgi_node);
                io_free(c);                e_free(c);
         }          }
 }  }
   
Line 173  hdrValue(const char *str, size_t len, const char **end Line 173  hdrValue(const char *str, size_t len, const char **end
                         return NULL;                          return NULL;
                 }                  }
   
                tmp = io_realloc(s, crlf - str + off + 1);                tmp = e_realloc(s, crlf - str + off + 1);
                 if (!tmp) {                  if (!tmp) {
                        LOGERR;                        www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                        io_free(s);                        e_free(s);
                         return NULL;                          return NULL;
                 } else                  } else
                         s = tmp;                          s = tmp;
Line 194  hdrValue(const char *str, size_t len, const char **end Line 194  hdrValue(const char *str, size_t len, const char **end
         }          }
   
         *end = crlf + strlen(CRLF);          *end = crlf + strlen(CRLF);
        ret = io_makeVar(string, s);        ret = ait_makeVar(string, s);
         if (!ret)          if (!ret)
                www_SetErr(io_GetErrno(), "%s", io_GetError());                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
        io_free(s);        e_free(s);
   
         return ret;          return ret;
 }  }
Line 340  mime_parseMultiPart(const char *str, size_t len, const Line 340  mime_parseMultiPart(const char *str, size_t len, const
         }          }
   
         /* init MIME */          /* init MIME */
        mime = io_malloc(sizeof(mime_t));        mime = e_malloc(sizeof(mime_t));
         if (!mime) {          if (!mime) {
                www_SetErr(io_GetErrno(), "%s", io_GetError());                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 return NULL;                  return NULL;
         } else {          } else {
                 memset(mime, 0, sizeof(mime_t));                  memset(mime, 0, sizeof(mime_t));
Line 352  mime_parseMultiPart(const char *str, size_t len, const Line 352  mime_parseMultiPart(const char *str, size_t len, const
         /* prepare boundary format */          /* prepare boundary format */
         bd[0].iov_base = bd_begin(bdtag);          bd[0].iov_base = bd_begin(bdtag);
         if (!bd[0].iov_base) {          if (!bd[0].iov_base) {
                io_free(mime);                e_free(mime);
                 return NULL;                  return NULL;
         } else          } else
                 bd[0].iov_len = strlen(bd[0].iov_base);                  bd[0].iov_len = strlen(bd[0].iov_base);
         bd[1].iov_base = bd_end(bdtag);          bd[1].iov_base = bd_end(bdtag);
         if (!bd[1].iov_base) {          if (!bd[1].iov_base) {
                io_free(bd[0].iov_base);                e_free(bd[0].iov_base);
                io_free(mime);                e_free(mime);
                 return NULL;                  return NULL;
         } else          } else
                 bd[1].iov_len = strlen(bd[1].iov_base);                  bd[1].iov_len = strlen(bd[1].iov_base);
Line 367  mime_parseMultiPart(const char *str, size_t len, const Line 367  mime_parseMultiPart(const char *str, size_t len, const
         /* check boundary tag */          /* check boundary tag */
         if (memcmp(str, strstr(bd[0].iov_base, "--"), strlen(strstr(bd[0].iov_base, "--")))) {          if (memcmp(str, strstr(bd[0].iov_base, "--"), strlen(strstr(bd[0].iov_base, "--")))) {
                 www_SetErr(EFAULT, "Bad content data, not found boundary tag");                  www_SetErr(EFAULT, "Bad content data, not found boundary tag");
                io_free(bd[1].iov_base);                e_free(bd[1].iov_base);
                io_free(bd[0].iov_base);                e_free(bd[0].iov_base);
                io_free(mime);                e_free(mime);
                 return NULL;                  return NULL;
         } else {          } else {
                 str += strlen(strstr(bd[0].iov_base, "--"));                  str += strlen(strstr(bd[0].iov_base, "--"));
Line 377  mime_parseMultiPart(const char *str, size_t len, const Line 377  mime_parseMultiPart(const char *str, size_t len, const
         }          }
   
         while (len > 0) {          while (len > 0) {
                m = io_malloc(sizeof(struct tagMIME));                m = e_malloc(sizeof(struct tagMIME));
                 if (!m) {                  if (!m) {
                        www_SetErr(io_GetErrno(), "%s", io_GetError());                        www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                         mime_close(&mime);                          mime_close(&mime);
                        io_free(bd[1].iov_base);                        e_free(bd[1].iov_base);
                        io_free(bd[0].iov_base);                        e_free(bd[0].iov_base);
                         return NULL;                          return NULL;
                 } else {                  } else {
                         memset(m, 0, sizeof(struct tagMIME));                          memset(m, 0, sizeof(struct tagMIME));
Line 395  mime_parseMultiPart(const char *str, size_t len, const Line 395  mime_parseMultiPart(const char *str, size_t len, const
                 /* parse message between tags */                  /* parse message between tags */
                 if (mime_readPart(m, str, next - str)) {                  if (mime_readPart(m, str, next - str)) {
                         mime_close(&mime);                          mime_close(&mime);
                        io_free(bd[1].iov_base);                        e_free(bd[1].iov_base);
                        io_free(bd[0].iov_base);                        e_free(bd[0].iov_base);
                         return NULL;                          return NULL;
                 }                  }
   
Line 424  mime_parseMultiPart(const char *str, size_t len, const Line 424  mime_parseMultiPart(const char *str, size_t len, const
         len -= bd[0].iov_len;          len -= bd[0].iov_len;
         */          */
   
        io_free(bd[1].iov_base);        e_free(bd[1].iov_base);
        io_free(bd[0].iov_base);        e_free(bd[0].iov_base);
   
         if (end)          if (end)
                 *end = str;                  *end = str;
Line 436  static inline void Line 436  static inline void
 freeMIME(struct tagMIME * __restrict m)  freeMIME(struct tagMIME * __restrict m)
 {  {
         if (m->mime_body.iov_base)          if (m->mime_body.iov_base)
                io_free(m->mime_body.iov_base);                e_free(m->mime_body.iov_base);
         if (m->mime_prolog.iov_base)          if (m->mime_prolog.iov_base)
                io_free(m->mime_prolog.iov_base);                e_free(m->mime_prolog.iov_base);
         if (m->mime_epilog.iov_base)          if (m->mime_epilog.iov_base)
                io_free(m->mime_epilog.iov_base);                e_free(m->mime_epilog.iov_base);
   
         freeHeader(m);          freeHeader(m);
         mime_close(&m->mime_attach);          mime_close(&m->mime_attach);
Line 463  mime_close(mime_t ** __restrict mime) Line 463  mime_close(mime_t ** __restrict mime)
         while ((m = SLIST_FIRST(*mime))) {          while ((m = SLIST_FIRST(*mime))) {
                 SLIST_REMOVE_HEAD(*mime, mime_node);                  SLIST_REMOVE_HEAD(*mime, mime_node);
                 freeMIME(m);                  freeMIME(m);
                io_free(m);                e_free(m);
         }          }
   
        io_free(*mime);        e_free(*mime);
         *mime = NULL;          *mime = NULL;
 }  }
   
Line 505  mime_parseHeader(struct tagMIME * __restrict m, const  Line 505  mime_parseHeader(struct tagMIME * __restrict m, const 
                         return -1;                          return -1;
                 }                  }
   
                c = io_malloc(sizeof(struct tagCGI));                c = e_malloc(sizeof(struct tagCGI));
                 if (!c) {                  if (!c) {
                        www_SetErr(io_GetErrno(), "%s", io_GetError());                        www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                         freeHeader(m);                          freeHeader(m);
                         return -1;                          return -1;
                 }                  }
                 /* get name */                  /* get name */
                c->cgi_name = io_allocVar();                c->cgi_name = ait_allocVar();
                 if (!c->cgi_name) {                  if (!c->cgi_name) {
                        www_SetErr(io_GetErrno(), "%s", io_GetError());                        www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                        io_free(c);                        e_free(c);
                         freeHeader(m);                          freeHeader(m);
                         return -1;                          return -1;
                 } else                  } else
Line 548  mime_parseHeader(struct tagMIME * __restrict m, const  Line 548  mime_parseHeader(struct tagMIME * __restrict m, const 
  * @name = Header name   * @name = Header name
  * return: NULL not found or !=NULL value   * return: NULL not found or !=NULL value
  */   */
inline const char *const char *
 mime_getValue(struct tagMIME * __restrict m, const char *name)  mime_getValue(struct tagMIME * __restrict m, const char *name)
 {  {
         struct tagCGI *c;          struct tagCGI *c;
Line 587  mime_readPart(struct tagMIME * __restrict m, const cha Line 587  mime_readPart(struct tagMIME * __restrict m, const cha
         ct = mime_getValue(m, "content-type");          ct = mime_getValue(m, "content-type");
         if (!ct || www_cmptype(ct, "multipart")) {          if (!ct || www_cmptype(ct, "multipart")) {
                 /* not multi part, assign like body element */                  /* not multi part, assign like body element */
                m->mime_body.iov_base = io_malloc(len - (eoh - str) + 1);                m->mime_body.iov_base = e_malloc(len - (eoh - str) + 1);
                 if (!m->mime_body.iov_base) {                  if (!m->mime_body.iov_base) {
                        www_SetErr(io_GetErrno(), "%s", io_GetError());                        www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                         freeHeader(m);                          freeHeader(m);
                         return -1;                          return -1;
                 }                  }
Line 607  mime_readPart(struct tagMIME * __restrict m, const cha Line 607  mime_readPart(struct tagMIME * __restrict m, const cha
                 bd.iov_base = bd_begin(AIT_GET_STR(v));                  bd.iov_base = bd_begin(AIT_GET_STR(v));
                 bd.iov_len = strlen(bd.iov_base);                  bd.iov_len = strlen(bd.iov_base);
                 eb = findtextpos(eoh, len - (eoh - str), bd.iov_base, bd.iov_len);                  eb = findtextpos(eoh, len - (eoh - str), bd.iov_base, bd.iov_len);
                io_free(bd.iov_base);                e_free(bd.iov_base);
   
                 /* set prolog if exists */                  /* set prolog if exists */
                 if (eb != eoh) {                  if (eb != eoh) {
                        m->mime_prolog.iov_base = io_malloc(eb - eoh + 1);                        m->mime_prolog.iov_base = e_malloc(eb - eoh + 1);
                         if (!m->mime_prolog.iov_base) {                          if (!m->mime_prolog.iov_base) {
                                www_SetErr(io_GetErrno(), "%s", io_GetError());                                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                                 www_freeAttributes(&attr);                                  www_freeAttributes(&attr);
                                 freeHeader(m);                                  freeHeader(m);
                                 return -1;                                  return -1;
Line 629  mime_readPart(struct tagMIME * __restrict m, const cha Line 629  mime_readPart(struct tagMIME * __restrict m, const cha
   
                 /* set epilog if exists */                  /* set epilog if exists */
                 if (eoh - str < len) {                  if (eoh - str < len) {
                        m->mime_epilog.iov_base = io_malloc(len - (eoh - str) + 1);                        m->mime_epilog.iov_base = e_malloc(len - (eoh - str) + 1);
                         if (!m->mime_epilog.iov_base) {                          if (!m->mime_epilog.iov_base) {
                                www_SetErr(io_GetErrno(), "%s", io_GetError());                                www_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                                 www_freeAttributes(&attr);                                  www_freeAttributes(&attr);
                                 freeHeader(m);                                  freeHeader(m);
                                 return -1;                                  return -1;
Removed from v.1.4  
changed lines
  Added in v.1.5

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>