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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
html.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：15k
源码类别：

WEB邮件程序

开发平台：

C/C++

html.c：源码内容
  1. /*
  2. ** Copyright 1998 - 1999 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  7. /*
  8. ** $Id: html.c,v 1.12 2000/05/11 03:55:49 mrsam Exp $
  9. */
  10. #include <stdio.h>
  11. #include <ctype.h>
  12. #include <string.h>
  13. #include <stdlib.h>
  14. #include "config.h"
  15. #include "cgi/cgi.h"
  16. #include "sqwebmail.h"
  17. #include "rfc2045/rfc2045.h"
  19. void decodehtmlchar(char *p)
  20. {
  21. char *q;
  23. for (q=p; *p; )
  24. {
  25. int i;
  27. if (*p != '&')
  28. {
  29. *q++=*p++;
  30. continue;
  31. }
  33. if ( p[1] == '#')
  34. {
  35. unsigned c=0;
  37. for (p += 2; isdigit((int)(unsigned char)*p); p++)
  38. c=c * 10 + (*p++ - '0');
  39. c=(unsigned char)c;
  40. if (c) *q++=c;
  41. if (*p == ';') p++;
  42. }
  44. for (i=1; p[i]; i++)
  45. if (!isalpha((int)(unsigned char)p[i])) break;
  47. if (p[i] != ';')
  48. {
  49. *q++=*p++;
  50. continue;
  51. }
  53. for (i=0; p[i] != ';'; i++)
  54. p[i]=tolower(p[i]);
  55. ++i;
  56. if (strncmp(p, "&lt;", 4) == 0)
  57. {
  58. *q++ = '<';
  59. }
  60. else if ( strncmp(p, "&gt;",4) == 0)
  61. {
  62. *q++ = '>';
  63. }
  64. else if ( strncmp(p, "&amp;", 5) == 0)
  65. {
  66. *q++ = '&';
  67. }
  68. else if ( strncmp(p, "&quot;", 6) == 0)
  69. {
  70. *q++ = '"';
  71. }
  72. p += i;
  73. }
  74. *q=0;
  75. }
  77. /*
  78. HTML sanitization filter.  Transforms HTML as follows:
  80. The following tags are dropped:
  82. <SCRIPT>, </SCRIPT>, <APP>, </APP>, <APPLET>, </APPLET>, 
  83. <SERVER>, </SERVER>, <OBJECT>, </OBJECT>, <HTML>, </HTML>, 
  84. <HEAD>, </HEAD>, <BODY>, </BODY>, <META>, <TITLE>, </TITLE>,
  85. <FRAME>, </FRAME>, <LINK> <IFRAME> and </IFRAME>.
  87. The ONLOAD, ONMOUSEOVER, and all other ON* attributes are removed.
  89. Attributes TARGET, CODE, ACTION, CODETYPE and LANGUAGE are removed.
  90. TARGET=_blank is added to all <A> tags.
  92. HREF, SRC, or LOWSRC attributes that do not specify a URL of http:,
  93. https:, ftp:, gopher:, wais:, or telnet:, are removed.
  95. */
  97. char *tagbuf=0;
  98. size_t tagbufsize=0, tagbuflen;
  100. struct tagattrinfo {
  101. char *tagname;
  102. size_t tagnamelen;
  103. char *tagvalue;
  104. size_t tagvaluelen;
  106. char *atagstart; /* Entire tag=value location */
  107. size_t ataglen;
  108. } ;
  110. struct tagattrinfo *tagattr=0;
  111. size_t tagattrsize=0, tagattrlen;
  113. static void addtagbuf(int c)
  114. {
  115. if (tagbufsize >= 1024) return; /* DOS attack - get rid of the tag */
  117. if (tagbuflen >= tagbufsize)
  118. {
  119. char *newtagbuf= tagbuf ? (char *)realloc(tagbuf, tagbufsize+256)
  120. :(char *)malloc(tagbufsize+256);
  122. if (!newtagbuf) enomem();
  123. tagbuf=newtagbuf;
  124. tagbufsize += 256;
  125. }
  126. tagbuf[tagbuflen++]=c;
  127. }
  129. /* Parse the contents of tagbuf into individual attributes.  If argument is
  130. ** NULL, just the count of attributes is returned.  That's the first pass.
  131. ** On the second pass the argument points to a struct tagattrinfo array which
  132. ** we initialize.
  133. **
  134. ** The first attribute is -- obviously -- the actual tag.
  135. */
  137. static size_t parseattr(struct tagattrinfo *tai)
  138. {
  139. size_t c=0;
  140. char *p;
  142. for (p=tagbuf; *p; )
  143. {
  144. while (*p && isspace((int)(unsigned char)*p)) p++;
  145. if (!*p) break;
  147. ++c;
  148. if (tai)
  149. {
  150. tai->tagname=p;
  151. tai->tagnamelen=0;
  152. tai->atagstart=p;
  153. }
  154. while (*p && !isspace((int)(unsigned char)*p) && *p != '=')
  155. {
  156. ++p;
  157. if (tai) ++tai->tagnamelen;
  158. }
  159. if (*p != '=') /* No attribute value */
  160. {
  161. if (tai)
  162. {
  163. tai->tagvalue=0;
  164. tai->tagvaluelen=0;
  165. }
  166. }
  167. else
  168. {
  169. ++p;
  170. if (*p == '"') /* Attr value in quotes */
  171. {
  172. ++p;
  173. if (tai)
  174. {
  175. tai->tagvalue=p;
  176. tai->tagvaluelen=0;
  177. }
  178. while (*p && *p != '"')
  179. {
  180. ++p;
  181. if (tai) ++tai->tagvaluelen;
  182. }
  183. if (*p) p++;
  184. }
  185. else
  186. {
  187. if (tai)
  188. {
  189. tai->tagvalue=p;
  190. tai->tagvaluelen=0;
  191. }
  192. while (*p && !isspace((int)(unsigned char)*p))
  193. {
  194. p++;
  195. if (tai)
  196. {
  197. tai->tagvalue=p;
  198. tai->tagvaluelen=0;
  199. }
  200. }
  201. }
  202. }
  203. if (tai)
  204. {
  205. tai->ataglen=p-tai->atagstart;
  206. ++tai;
  207. }
  208. }
  209. return (c);
  210. }
  212. static void parsetagbuf()
  213. {
  214.         tagattrlen=parseattr(0);
  215.         if ( tagattrlen > tagattrsize)
  216.         {
  217.         struct tagattrinfo *newta= tagattr ? (struct tagattrinfo *)
  218.                 realloc(tagattr, (tagattrlen+16)*sizeof(*tagattr))
  219.                 :(struct tagattrinfo *)
  220. malloc((tagattrlen+16)*sizeof(*tagattr));
  222.                 if (!newta)     enomem();
  223. tagattrsize=tagattrlen+16;
  224. tagattr=newta;
  225.         }
  226.         parseattr(tagattr);
  227. }
  229. /* See if this attribute is the one we're looking for */
  231. static int is_attr(struct tagattrinfo *i, const char *l)
  232. {
  233. size_t ll=strlen(l);
  235. return (i->tagnamelen == ll && strncasecmp(i->tagname, l, ll) == 0);
  236. }
  238. /* If this is the tag we're looking for */
  240. static int is_htmltag(const char *l)
  241. {
  242. return (tagattrlen ? is_attr(tagattr, l):0);
  243. }
  245. /* See if the attribute value starts with what we're looking for */
  247. static int is_valuestart(const char *v, const char *l)
  248. {
  249. while (v && isspace((int)(unsigned char)*v))
  250. ++v;
  252. return (v && strncasecmp(v, l, strlen(l)) == 0);
  253. }
  255. /*
  256. htmlfilter() is repeatedly called to filter the HTML text.  htmlfilter()
  257. will call htmlfiltered() with the filtered text, more or less on a
  258. one to one basis.
  260. htmlfilter_init() must be called before the first invocation of
  261. htmlfilter().  Because the HTML can be fed in arbitrary quantities,
  262. htmlfilter() implements a state machine which htmlfilter_init()
  263. initializes.
  264. */
  266. enum htmlstate {
  267. intext, /* Initial value.  In plain text */
  268. seenlt, /* Seen < */
  269. seenltbang, /* Seen <! */
  270. seenltbangdash, /* Seen <!- */
  271. intag, /* Seen < but not <!, we're collecting the
  272. tag */
  274. incomment, /* <!--, in a comment, have not seen any
  275. dashes */
  276. incommentseendash, /* In a comment, seen - */
  277. incommentseendashdash /* In a comment, seen -- */
  278. } ;
  280. static enum htmlstate cur_state;
  281. static unsigned instyletag;
  282. static void filtered_tag();
  283. static void (*htmlfiltered_func)(const char *, size_t);
  284. static char *(*htmlconvertcid_func)(const char *, void *);
  285. static void *convertcid_arg;
  287. const char *washlink=0;
  288. const char *washlinkmailto=0;
  289. const char *contentbase=0;
  291. void htmlfilter_init( void (*func)(const char *, size_t))
  292. {
  293. cur_state=intext;
  294. htmlfiltered_func=func;
  295. instyletag=0;
  296. }
  298. /* Set prefix to wash HTML links */
  300. void htmlfilter_washlink( const char *p)
  301. {
  302. washlink=p;
  303. }
  305. void htmlfilter_contentbase( const char *p)
  306. {
  307. contentbase=p;
  308. }
  310. void htmlfilter_washlinkmailto( const char *p)
  311. {
  312. washlinkmailto=p;
  313. }
  315. void htmlfilter_convertcid( char *(*cidfunc)(const char *, void *), void *arg)
  316. {
  317. htmlconvertcid_func=cidfunc;
  318. convertcid_arg=arg;
  319. }
  321. void htmlfilter(const char *p, size_t s)
  322. {
  323. size_t l;
  324. size_t start=0;
  326. for (l=0; l<s; l++)
  327. {
  328. switch (cur_state) {
  329. case intext:
  330. if (p[l] != '<') continue;
  331. if (!instyletag)
  332. (*htmlfiltered_func)(p+start, l-start);
  333. /* Output everything up until the tag */
  334. cur_state=seenlt;
  335. tagbuflen=0;
  336. break;
  337. case seenlt:
  338. if (p[l] == '>')
  339. {
  340. cur_state=intext;
  341. start=l+1;
  342. if (!instyletag)
  343. (*htmlfiltered_func)("<>", 2);
  344. /* Eh? */
  345. continue;
  346. }
  347. addtagbuf(p[l]);
  348. if (p[l] == '!')
  349. cur_state=seenltbang;
  350. else
  351. cur_state=intag;
  352. break;
  353. case intag:
  354. /* We're in a tag (not a <!-- comment)
  355. collect the contents in tagbuf, until > is seen */
  356. do_intag:
  357. cur_state=intag;
  358. if (p[l] == '>')
  359. {
  360. start=l+1;
  361. cur_state=intext;
  362. filtered_tag(); /* Filter this tag */
  363. continue;
  364. }
  365. addtagbuf(p[l]);
  366. continue;
  368. case seenltbang:
  369. /* We have <!.  If - is not here, this is a SGML tag */
  370. if (p[l] != '-') goto do_intag;
  371. addtagbuf(p[l]);
  372. cur_state=seenltbangdash;
  373. continue;
  375. case seenltbangdash:
  377. /* We have <!-. If - is not here, this is a SGML tag,
  378. otherweise we're in a comment, which we can pass
  379. along */
  381. if (p[l] != '-') goto do_intag;
  382. if (!instyletag)
  383. (*htmlfiltered_func)("<!--", 4);
  384. start=l+1;
  385. cur_state=incomment;
  386. continue;
  388. /* Look for end of comment */
  390. case incomment:
  391. if (p[l] == '-') cur_state=incommentseendash;
  392. continue;
  393. case incommentseendash:
  394. cur_state= p[l] == '-' ? incommentseendashdash
  395. :incomment;
  396. continue;
  397. case incommentseendashdash:
  398. if (p[l] == '-') continue;
  399. if (p[l] != '>')
  400. {
  401. cur_state=incomment;
  402. continue;
  403. }
  404. if (!instyletag)
  405. (*htmlfiltered_func)(p+start, l+1-start);
  406. cur_state=intext;
  407. start=l+1;
  408. continue;
  409. }
  410. }
  412. /* When we're done with this chunk, if we're doing plain text, or if
  413. ** we're in a comment, just pass it along */
  415. switch (cur_state) {
  416. case intext:
  417. case incomment:
  418. case incommentseendash:
  419. case incommentseendashdash:
  420. if (!instyletag)
  421. (*htmlfiltered_func)(p+start, l-start);
  422. default:
  423. break;
  424. }
  425. }
  427. /* Ok, wash an HREF link.  The entire A (or whatever) element is in tagbuf.
  428. ** tag=value pairs have been parsed into tagattr array.
  429. **
  430. ** Our argument is the index of the HREF (or SRC) link, which points back
  431. ** into tagbuf.
  432. **
  433. ** We build a new element, and then rebuild the tagbuf structure.
  434. */
  436. static char *redirectencode(const char *, size_t );
  438. /* replacelink takes care of replacing the contents of one tag's value. */
  440. static void replacelink(size_t l, const char *p)
  441. {
  442. struct tagattrinfo *tagattrp=tagattr+l;
  443. char *newbuf;
  444. size_t plen=tagattrp->tagvalue - tagbuf;
  445. size_t i;
  447. newbuf=malloc(strlen(tagbuf)+strlen(p)+1);
  448. /* Yes, that's a bit too much.  That's OK */
  450. if (!newbuf) enomem();
  451. memcpy(newbuf, tagbuf, plen);
  452. strcpy(newbuf+plen, p);
  453. strcat(newbuf, tagattrp->tagvalue+tagattrp->tagvaluelen);
  455. tagbuflen=0;
  456. for (i=0; newbuf[i]; i++)
  457. addtagbuf(newbuf[i]);
  458. addtagbuf(0);
  459. parsetagbuf();
  460. free(newbuf);
  461. }
  463. static void dowashlink(size_t l, const char *value)
  464. {
  465. char *url, *p;
  467. url=redirectencode(value, strlen(value));
  469. p=malloc(strlen(url)+strlen(washlink)+1);
  470. if (!p) enomem();
  471. strcat(strcpy(p, washlink), url);
  472. replacelink(l, p);
  473. free(p);
  474. free(url);
  475. }
  477. static void dowashlinkmailto(size_t l, const char *mailtolink)
  478. {
  479. size_t mailtolinklen=strlen(mailtolink);
  480. char *newlink=malloc(strlen(washlinkmailto)+1+mailtolinklen);
  481. char *p;
  483. if (!newlink) enomem();
  484. strcpy(newlink, washlinkmailto);
  485. strncat(newlink, mailtolink, mailtolinklen);
  486. if ((p=strchr(newlink+strlen(washlinkmailto), '?')) != 0)
  487. *p='&';
  488. replacelink(l, newlink);
  489. free(newlink);
  490. }
  492. static void dowashcid(size_t l, const char *link)
  493. {
  494. size_t linklen=strlen(link);
  495. char *p;
  497. p=malloc(linklen+1);
  498. if (!p) enomem();
  500. memcpy(p, link, linklen);
  501. p[linklen]=0;
  503. if (!htmlconvertcid_func)
  504. *p=0;
  505. else
  506. {
  507. char *q=(*htmlconvertcid_func)(p+4, convertcid_arg);
  509. free(p);
  510. p=q;
  511. }
  512. replacelink(l, p);
  513. free(p);
  514. }
  516. static char *redirectencode(const char *p, size_t l)
  517. {
  518. char *q=malloc(l+1);
  519. char *r;
  521. if (!q) enomem();
  522. memcpy(q, p, l);
  523. q[l]=0;
  524. decodehtmlchar(q);
  525. r=cgiurlencode(q);
  526. free(q);
  527. return (r);
  528. }
  531. size_t find_tag(const char *tagname)
  532. {
  533. size_t l;
  535. for (l=1; l<tagattrlen; l++)
  536. if (is_attr(tagattr+l, tagname)) return (l);
  537. return (0);
  538. }
  540. /*
  541. Decide what to do with this tag
  542. */
  544. static void filtered_tag()
  545. {
  546. size_t l;
  547. int open_window=0;
  548.  
  549. addtagbuf(0);
  550. parsetagbuf();
  551. if ( is_htmltag("TITLE") || is_htmltag("/TITLE") ||
  552. is_htmltag("SCRIPT") || is_htmltag("/SCRIPT") ||
  553. is_htmltag("FRAME") || is_htmltag("/FRAME") ||
  554. is_htmltag("IFRAME") || is_htmltag("/IFRAME") ||
  555. is_htmltag("APP") || is_htmltag("/APP") ||
  556. is_htmltag("APPLET") || is_htmltag("/APPLET") ||
  557. is_htmltag("SERVER") || is_htmltag("/SERVER") ||
  558. is_htmltag("OBJECT") || is_htmltag("/OBJECT") ||
  559. is_htmltag("HTML") || is_htmltag("/HTML") ||
  560. is_htmltag("HEAD") || is_htmltag("/HEAD") ||
  561. is_htmltag("BODY") || is_htmltag("/BODY") ||
  562. is_htmltag("LINK") || is_htmltag("META"))
  563. {
  564. return;
  565. }
  567. if ( is_htmltag("STYLE"))
  568. {
  569. ++instyletag;
  570. return;
  571. }
  573. if ( is_htmltag("/STYLE"))
  574. {
  575. --instyletag;
  576. return;
  577. }
  579. if (instyletag) return;
  582. for (l=1; l<tagattrlen; l++)
  583. {
  584. if (tagattr[l].tagnamelen > 2 &&
  585. strncasecmp(tagattr[l].tagname, "ON", 2) == 0)
  586. {
  587. memset(tagattr[l].atagstart, ' ',
  588. tagattr[l].ataglen);
  589. }
  590. }
  592. if (is_htmltag("IMG"))
  593. {
  594. size_t nsrc=find_tag("src");
  595. size_t nalt=find_tag("alt");
  596. int ignore_img=0;
  598. /*
  599. ** An IMG with a cid: URL is passed along, untouched, with
  600. ** the URL being processed.  This is handled later.
  601. */
  603. if (nsrc && htmlconvertcid_func)
  604. {
  605. const char *p=tagattr[nsrc].tagvalue;
  606. size_t s=tagattr[nsrc].tagvaluelen;
  608. while (s)
  609. {
  610. if ( !isspace((int)(unsigned char)*p)) break;
  612. ++p;
  613. --s;
  614. }
  615. if (s >= 4 && strncasecmp(p, "cid:", 4) == 0)
  616. {
  617. nsrc=0;
  618. ignore_img=1;
  619. /* Handle tags below */
  620. }
  621. }
  623. if (nsrc)
  624. {
  625. char *r;
  626. char *q;
  627. char *alt=0;
  629. r=malloc(tagattr[nsrc].tagvaluelen+1);
  630. if (!r) enomem();
  631. memcpy(r, tagattr[nsrc].tagvalue,
  632. tagattr[nsrc].tagvaluelen);
  633. r[tagattr[nsrc].tagvaluelen]=0;
  634. q=rfc2045_append_url(contentbase, r);
  635. free(r);
  637. for (r=q; *r; r++)
  638. if (*r == '"' ||
  639. *r == '<' || *r == '>') *r=0;
  640. /* Someone's playing games with us */
  642. if (nalt)
  643. {
  644. alt=malloc(tagattr[nalt].tagvaluelen+1);
  645. if (!alt) enomem();
  646. memcpy(alt, tagattr[nalt].tagvalue,
  647. tagattr[nalt].tagvaluelen);
  648. alt[tagattr[nalt].tagvaluelen]=0;
  649. }
  651. (*htmlfiltered_func)("<A TARGET="_blank" HREF="", 25);
  653. if (washlink) dowashlink(nsrc, q);
  654. else replacelink(nsrc, q);
  656. (*htmlfiltered_func)(tagattr[nsrc].tagvalue,
  657. tagattr[nsrc].tagvaluelen);
  658. (*htmlfiltered_func)("">", 2);
  659. if (alt)
  660. (*htmlfiltered_func)(alt, strlen(alt));
  661. else
  662. {
  663. (*htmlfiltered_func)("[", 1);
  664. (*htmlfiltered_func)(q, strlen(q));
  665. (*htmlfiltered_func)("]", 1);
  666. }
  667. (*htmlfiltered_func)("</A>", 4);
  668. free(q);
  669. if (alt) free(alt);
  670. }
  672. if (!ignore_img)
  673. return;
  674. }
  676. /* Attempt to automatically plug in any holes */
  678. for (l=1; l<tagattrlen; l++)
  679. {
  680. if (is_attr(tagattr+l, "target") ||
  681. is_attr(tagattr+l, "code") ||
  682. is_attr(tagattr+l, "language") ||
  683. is_attr(tagattr+l, "action") ||
  684. is_attr(tagattr+l, "codetype"))
  685. memset(tagattr[l].atagstart, ' ',
  686. tagattr[l].ataglen);
  688. if (is_attr(tagattr+l, "href")
  689. || is_attr(tagattr+l, "src")
  690. || is_attr(tagattr+l, "lowsrc"))
  691. {
  692. char *p=malloc(tagattr[l].tagvaluelen+1), *q;
  693. size_t n;
  694. int goodhref=0;
  696. if (!p) enomem();
  698. memcpy(p, tagattr[l].tagvalue, tagattr[l].tagvaluelen);
  699. p[tagattr[l].tagvaluelen]=0;
  701. q=rfc2045_append_url(contentbase, p);
  702. free(p);
  704. for (p=q; *p; p++)
  705. if (*p == '"' ||
  706. *p == '<' || *p == '>') *p=0;
  707. /* Someone's playing games with us */
  709. for (n=0; q[n]; n++)
  710. if (q[n] == ':')
  711. {
  712. if (is_valuestart(q, "cid:"))
  713. {
  714. goodhref=1;
  715. dowashcid(l, q);
  716. }
  717. else if ((is_valuestart(q, "http:") ||
  718. is_valuestart(q, "https:")) &&
  719. is_attr(tagattr+l, "href"))
  720. /* block src/lowsrc tags in anything but IMG.
  721. Ex: <input type="image" src="http://"> -- don't render as a redirect
  722. URL
  723. */
  724. {
  725. goodhref=1;
  726. if (washlink)
  727. dowashlink(l, q);
  728. else
  729. replacelink(l, q);
  730. if (is_htmltag("A"))
  731. open_window=1;
  732. break;
  733. }
  734. else if ( is_valuestart(q, "mailto:"))
  735. {
  736. goodhref=1;
  737. dowashlinkmailto(l, strchr(q,
  738. ':')+1);
  739. }
  740. else if ( is_valuestart(q, "ftp:") ||
  741. is_valuestart(q, "gopher:") ||
  742. is_valuestart(q, "wais:") ||
  743. is_valuestart(q, "telnet:"))
  744. {
  745. goodhref=1;
  746. if (is_htmltag("A"))
  747. open_window=1;
  748. }
  749. break;
  750. }
  751. if (!goodhref)
  752. {
  753. memset(tagattr[l].atagstart, ' ',
  754. tagattr[l].ataglen);
  755. }
  756. free(q);
  757. }
  758. }
  760. (*htmlfiltered_func)("<", 1);
  761. (*htmlfiltered_func)(tagbuf, strlen(tagbuf));
  762. if (open_window)
  763. (*htmlfiltered_func)(" target="_blank"", 16);
  764. (*htmlfiltered_func)(">", 1);
  766. }