开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
MIMEState.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：13k
源码类别：

传真(Fax)编程

开发平台：

C/C++

MIMEState.c++：源码内容
  1. /* $Id: MIMEState.c++,v 1.6 2008/02/11 04:12:22 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. /*
  27.  * MIME Decoder Support.
  28.  */
  29. #include "MIMEState.h"
  30. #include "MsgFmt.h"
  31. #include "StackBuffer.h"
  33. #include <string.h>
  34. #include <ctype.h>
  36. MIMEState::MIMEState(const char* t, const char* st) : type(t), subtype(st)
  37. {
  38.     parent = NULL;
  39.     lastPart = false;
  40.     encode = ENC_7BIT;
  41.     charset = CS_USASCII;
  42.     blen = (u_int) -1; // NB: should insure no matches
  43.     lineno = 1;
  44.     external = false;
  45. }
  46. MIMEState::MIMEState(MIMEState& other)
  47.     : parent(&other)
  48.     , boundary(other.boundary)
  49. {
  50.     if (other.type == "multipart" && other.subtype == "digest") 
  51. type = "message", subtype = "rfc822";
  52.     else
  53. type = "text", subtype = "plain";
  54.     lastPart = false;
  55.     encode = other.encode;
  56.     charset = other.charset;
  57.     blen = other.blen;
  58.     lineno = other.lineno;
  59.     external = other.external;
  60. }
  61. MIMEState::MIMEState(MIMEState& other, const char* t, const char* st)
  62.     : parent(&other)
  63.     , type(t)
  64.     , subtype(st)
  65.     , boundary(other.boundary)
  66. {
  67.     lastPart = false;
  68.     encode = other.encode;
  69.     charset = other.charset;
  70.     blen = other.blen;
  71.     lineno = other.lineno;
  72.     external = other.external;
  73. }
  74. MIMEState::~MIMEState()
  75. {
  76.     if (parent) {
  77. parent->lineno = lineno;
  78.     }
  79. }
  81. void
  82. MIMEState::trace(FILE* fd)
  83. {
  84.     static const char* enames[] = {
  85. "7bit",
  86. "quoted-printable",
  87. "base64",
  88. "8bit",
  89. "binary",
  90. "x-uuencode"
  91.     };
  92.     static const char* cnames[] = {
  93. "us-ascii",
  94. "iso-8859-1",
  95. "iso-8859-2",
  96. "iso-8859-3",
  97. "iso-8859-4",
  98. "iso-8859-5",
  99. "iso-8859-6",
  100. "iso-8859-7",
  101. "iso-8859-8",
  102. "iso-8859-9",
  103.     };
  104.     fprintf(fd, "MIME part (line %u): %s/%s charset=%s encoding=%sn"
  105. , lineno
  106. , (const char*) type
  107. , (const char*) subtype
  108. , cnames[charset]
  109. , enames[encode]
  110.     );
  111. }
  113. bool
  114. MIMEState::parseToken(const char*& cp, const char delimeter, fxStr& result)
  115. {
  116.     while (*cp && isspace(*cp))
  117. cp++;
  118.     const char* bp = cp;
  119.     while (*cp && !isspace(*cp) && *cp != delimeter)
  120. cp++;
  121.     if (cp - bp > 0) {
  122. result = fxStr(bp, cp-bp);
  123. while (isspace(*cp)) // remove trailing ws
  124.     cp++;
  125. return (true);
  126.     } else
  127. return (false);
  128. }
  130. /*
  131.  * Extract MIME-related information from a set of
  132.  * message headers and fillin the MIME state block.
  133.  */
  134. bool
  135. MIMEState::parse(const MsgFmt& msg, fxStr& emsg)
  136. {
  137.     const fxStr* s = msg.findHeader("Content-Type");
  138.     if (s) { // type/subtype [; parameter]*
  139. const char* cp = &(*s)[0];
  140. if (parseToken(cp, '/', type)
  141.   && *cp++ == '/'
  142.   && parseToken(cp, ';', subtype)) {
  143.     if (*cp == ';') // parse optional parameters
  144. parseParameters(cp+1);
  145.     type.lowercase();
  146.     subtype.lowercase();
  147. } else {
  148.     emsg = "Syntax error parsing MIME Content-Type: " | *s;
  149.     type = "text"; // reset on parsing error
  150.     return (false);
  151. }
  152.     }
  153.     s = msg.findHeader("Content-Transfer-Encoding");
  154.     if (s)
  155. setEncoding(&(*s)[0]);
  156.     s = msg.findHeader("Content-Description");
  157.     if (s)
  158. desc = *s;
  159.     s = msg.findHeader("Content-ID");
  160.     if (s)
  161. cid = *s;
  162.     s = msg.findHeader("Content-Disposition");
  163.     if (s)
  164. disp = *s;
  165.     return (true);
  166. }
  168. /*
  169.  * Parse optional MIME parameters used by the decoder.
  170.  */
  171. void
  172. MIMEState::parseParameters(const char* cp)
  173. {
  174.     for (;;) {
  175. while (*cp && isspace(*cp))
  176.     cp++;
  177. const char* bp = cp;
  178. while (*cp && !isspace(*cp) && *cp != '=')
  179.     cp++;
  180. if (*cp == '') // end of string
  181.     break;
  182. fxStr param(bp, cp-bp);
  183. if (*cp != '=') { // param<ws>=
  184.     while (isspace(*cp++))
  185. ;
  186.     if (*cp != '=') // syntax error
  187. break;
  188. }
  189. for (cp++; isspace(*cp); cp++) // skip ws after =
  190.     ;
  191. const char* ev;
  192. if (*cp == '"') { // quoted value
  193.     for (ev = ++cp; *ev && *ev != '"'; ev++)
  194. ;
  195.     if (*ev != '"') // missing close quote
  196. break;
  197. } else {
  198.     for (ev = cp; *ev && !isspace(*ev) && *ev != ';'; ev++)
  199. ;
  200. }
  202. (void) setParameter(param, fxStr(cp, ev-cp));
  204. if (*ev != '' && *ev != ';') { // scan to trailing ;
  205.     do {
  206. ev++;
  207.     } while (*ev && *ev != ';');
  208. }
  209. if (*ev != ';')
  210.     break;
  211. cp = ++ev;
  212.     }
  213. }
  215. /*
  216.  * Set a MIME parameter used by the decoder.
  217.  */
  218. bool
  219. MIMEState::setParameter(const fxStr& p, const fxStr& value)
  220. {
  221.     fxStr param(p);
  222.     param.lowercase();
  223.     if (param.length() == 7 && param == "charset") {
  224. setCharset(value); // character set
  225.     } else if (param.length() == 8 && param == "boundary") {
  226. setBoundary(value); // part boundary marker
  227.     } else
  228. return (false);
  229.     return (true);
  230. }
  232. /*
  233.  * Set the content-transfer-encoding.
  234.  */
  235. void
  236. MIMEState::setEncoding(const char* cp)
  237. {
  238.     if (strcasecmp(cp, "7bit") == 0)
  239. encode = ENC_7BIT;
  240.     else if (strcasecmp(cp, "quoted-printable") == 0)
  241. encode = ENC_QPRINT;
  242.     else if (strcasecmp(cp, "base64") == 0)
  243. encode = ENC_BASE64;
  244.     else if (strcasecmp(cp, "8bit") == 0)
  245. encode = ENC_8BIT;
  246.     else if (strcasecmp(cp, "binary") == 0)
  247. encode = ENC_BINARY;
  248.     else if (strcasecmp(cp, "x-uuencode") == 0)
  249. encode = ENC_UUENCODE;
  250. }
  252. /*
  253.  * Set the body part boundary.
  254.  */
  255. void
  256. MIMEState::setBoundary(const char* s)
  257. {
  258.     boundary = s;
  259.     boundary.insert("--"); // NB: insert "--" to simplify parsing
  260.     boundary.append("--"); // NB: append "--" to simplify parsing
  261.     blen = boundary.length()-2; // optimized for checking
  262. }
  264. /*
  265.  * Set the text character set.
  266.  */
  267. void
  268. MIMEState::setCharset(const char* cp)
  269. {
  270.     if (strcasecmp(cp, "us-ascii") == 0)
  271. charset = CS_USASCII;
  272.     else if (strcasecmp(cp, "iso-8859-1") == 0)
  273. charset = CS_ISO8859_1;
  274.     else if (strcasecmp(cp, "iso-8859-2") == 0)
  275. charset = CS_ISO8859_2;
  276.     else if (strcasecmp(cp, "iso-8859-3") == 0)
  277. charset = CS_ISO8859_3;
  278.     else if (strcasecmp(cp, "iso-8859-4") == 0)
  279. charset = CS_ISO8859_4;
  280.     else if (strcasecmp(cp, "iso-8859-5") == 0)
  281. charset = CS_ISO8859_5;
  282.     else if (strcasecmp(cp, "iso-8859-6") == 0)
  283. charset = CS_ISO8859_6;
  284.     else if (strcasecmp(cp, "iso-8859-7") == 0)
  285. charset = CS_ISO8859_7;
  286.     else if (strcasecmp(cp, "iso-8859-8") == 0)
  287. charset = CS_ISO8859_8;
  288.     else if (strcasecmp(cp, "iso-8859-9") == 0)
  289. charset = CS_ISO8859_9;
  290. }
  292. extern void fxFatal(const char* fmt ...);
  294. /*
  295.  * Return a line of data according to the current
  296.  * setting of the content-transfer-encoding and
  297.  * the body part boundary.  If the boundary marker
  298.  * or EOF is reached false is returned, otherwise
  299.  * this method returns true and the decoded line.
  300.  * If the data is encoded with a text-oriented
  301.  * scheme (7bit, 8bit, binary, or quoted-printable)
  302.  * then the trailing newline character is returned
  303.  * in the buffer.  Otherwise any trailing newline
  304.  * is discarded and only the decoded data is returned.
  305.  */
  306. bool
  307. MIMEState::getLine(FILE* fd, fxStackBuffer& buf)
  308. {
  309.     buf.reset();
  310.     switch (encode) {
  311.     case ENC_7BIT:
  312.         for (;;) {
  313.             int c = getc(fd);
  314.             if (c == EOF) {
  315.                 return (buf.getLength() > 0);
  316.             }
  317.             c &= 0xff;
  318.     if (c == 'r') {
  319. c = getc(fd);
  320. if (c == EOF) {
  321.     return (buf.getLength() > 0);
  322. }
  323. c &= 0xff;
  324. if (c != 'n') {
  325.     ungetc(c, fd);
  326.     c = 'r';
  327. }
  328.     }
  329.             if (c == 'n') { // check for boundary marker
  330.             lineno++;
  331.             u_int cc = buf.getLength();
  332.             if (cc >= blen && buf[0] == '-') {
  333.                 if (cc == blen && strneq(buf, boundary, blen)) {
  334.                 return (false);
  335.                     }
  336.                 if (cc == blen+2 && strneq(buf, boundary, blen+2)) {
  337.                 lastPart = true;
  338.                 return (false);
  339.                 }
  340.              }
  341.                 buf.put('n');
  342.                 return (true);
  343.             }
  344.             buf.put(c);
  345.         }
  346.     /*NOTREACHED*/
  347.     case ENC_8BIT:
  348.     case ENC_BINARY:
  349.         for (;;) {
  350.             int c = getc(fd);
  351.             if (c == EOF) {
  352.             return (buf.getLength() > 0);
  353.             }
  354.             c &= 0xff;
  355.     if (c == 'r') {
  356. c = getc(fd);
  357. if (c == EOF) {
  358.     return (buf.getLength() > 0);
  359. }
  360. c &= 0xff;
  361. if (c != 'n') {
  362.     ungetc(c, fd);
  363.     c = 'r';
  364. }
  365.     }
  366.             if (c == 'n') { // check for boundary marker
  367.             lineno++;
  368.                 u_int cc = buf.getLength();
  369.                 if (cc >= blen && buf[0] == '-') {
  370.                     if (cc == blen && strneq(buf, boundary, blen)) {
  371.                         return (false);
  372.                     }
  373.                 if (cc == blen+2 && strneq(buf, boundary, blen+2)) {
  374.                      lastPart = true;
  375.                      return (false);
  376.                     }
  377.             }
  378.                 buf.put('n');
  379.                 return (true);
  380.             }
  381.             buf.put(c);
  382.         }
  383.     /*NOTREACHED*/
  384.     case ENC_QPRINT: return getQuotedPrintableLine(fd, buf);
  385.     case ENC_BASE64: return getBase64Line(fd, buf);
  386.     case ENC_UUENCODE: return getUUDecodeLine(fd, buf);
  387.     }
  388.     fxFatal("Internal error, unsupported Content-Transfer-Encoding %u", encode);
  389.     /*NOTREACHED*/
  390.     return (false);
  391. }
  393. /*
  394.  * Return a decoded line of quoted-printable text.
  395.  */
  396. bool
  397. MIMEState::getQuotedPrintableLine(FILE* fd, fxStackBuffer& buf)
  398. {
  399.     MsgFmt msg;
  400.     char line[80]; // spec says never more than 76
  401.     u_int cc = 0; // chars in current line
  402.     for (;;) {
  403. int c = getc(fd);
  404. if (c == EOF) {
  405.     msg.copyQP(buf, line, cc);
  406.     return (buf.getLength() > 0);
  407. }
  408. c &= 0xff;
  409. if (c == 'r') {
  410.     c = getc(fd);
  411.     if (c == EOF) {
  412. msg.copyQP(buf, line, cc);
  413. return (buf.getLength() > 0);
  414.     }
  415.     c &= 0xff;
  416.     if (c != 'n') {
  417. ungetc(c, fd);
  418. c = 'r';
  419.     }
  420. }
  421. if (c == 'n') { // check for boundary marker
  422.     lineno++;
  423.     if (cc > 0 && line[cc-1] == '=') { // soft line break
  424. msg.copyQP (buf, line, cc-1);       // everything up to ``="''
  425. cc = 0;
  426. continue;
  427.     }
  428.     if (cc >= blen && line[0] == '-') {
  429. if (cc == blen && strneq(line, boundary, blen))
  430.     return (false);
  431. if (cc == blen+2 && strneq(line, boundary, blen+2)) {
  432.     lastPart = true;
  433.     return (false);
  434. }
  435.     }
  436.     msg.copyQP(buf, line, cc);
  437.     buf.put('n');
  438.     return (true);
  439. }
  440. if (cc < sizeof (line)-1)
  441.     line[cc++] = c;
  442.     }
  443.     /*NOTREACHED*/
  444. }
  446. /*
  447.  * Return a decoded line of base64 data.
  448.  */
  449. bool
  450. MIMEState::getBase64Line(FILE* fd, fxStackBuffer& buf)
  451. {
  452.     MsgFmt msg;
  453.     char line[80]; // spec says never more than 76
  454.     u_int cc = 0; // chars in current line
  455.     for (;;) {
  456. int c = getc(fd);
  457. if (c == EOF) {
  458.     msg.copyBase64(buf, line, cc);
  459.     return (buf.getLength() > 0);
  460. }
  461. c &= 0x7f;
  462. if (c == 'r') {
  463.     c = getc(fd);
  464.     if (c == EOF) {
  465. msg.copyBase64(buf, line, cc);
  466. return (buf.getLength() > 0);
  467.     }
  468.     c &= 0x7f;
  469.     if (c != 'n') {
  470. ungetc(c, fd);
  471. c = 'r';
  472.     }
  473. }
  474. if (c == 'n') { // check for boundary marker
  475.     lineno++;
  476.     if (cc >= blen && line[0] == '-') {
  477. if (cc == blen && strneq(line, boundary, blen))
  478.     return (false);
  479. if (cc == blen+2 && strneq(line, boundary, blen+2)) {
  480.     lastPart = true;
  481.     return (false);
  482. }
  483.     }
  484.     msg.copyBase64(buf, line, cc);
  485.     return (true);
  486. }
  487. if (cc < sizeof (line)-1)
  488.     line[cc++] = c;
  489.     }
  490.     /*NOTREACHED*/
  491. }
  493. /*
  494.  * Return a decoded line of uuencode'd data.
  495.  */
  496. bool
  497. MIMEState::getUUDecodeLine(FILE* fd, fxStackBuffer& buf)
  498. {
  499.     MsgFmt msg;
  500.     char line[80]; // spec says never more than 62
  501.     u_int cc = 0; // chars in current line
  502.     for (;;) {
  503. int c = getc(fd);
  504. if (c == EOF) {
  505.     msg.copyUUDecode(buf, line, cc);
  506.     return (buf.getLength() > 0);
  507. }
  508. c &= 0x7f;
  509. if (c == 'r') {
  510.     c = getc(fd);
  511.     if (c == EOF) {
  512. msg.copyUUDecode(buf, line, cc);
  513. return (buf.getLength() > 0);
  514.     }
  515.     c &= 0x7f;
  516.     if (c != 'n') {
  517. ungetc(c, fd);
  518. c = 'r';
  519.     }
  520. }
  521. if (c == 'n') {
  522.     lineno++;
  523.     if (cc >= blen && line[0] == '-') { // check for boundary marker
  524. if (cc == blen && strneq(line, boundary, blen))
  525.     return (false);
  526. if (cc == blen+2 && strneq(line, boundary, blen+2)) {
  527.     lastPart = true;
  528.     return (false);
  529. }
  530.     } else if (cc >= 6 && strneq(line, "begin ", 6)) {
  531. return (getUUDecodeLine(fd, buf));
  532.     } else if (cc == 3 && streq(line, "end")) {
  533. // consume to boundary marker
  534. while (getUUDecodeLine(fd, buf))
  535.     ;
  536. return (false);
  537.     }
  538.     msg.copyUUDecode(buf, line, cc);
  539.     return (true);
  540. }
  541. if (cc < sizeof (line)-1)
  542.     line[cc++] = c;
  543.     }
  544.     /*NOTREACHED*/
  545. }