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

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

WEB邮件程序

开发平台：

C/C++

newmsg_newdraft.c：源码内容
  1. /*
  2. ** Copyright 1998 - 2000 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  7. /*
  8. ** $Id: newmsg_newdraft.c,v 1.25 2000/07/01 22:36:34 mrsam Exp $
  9. */
  10. #include "config.h"
  11. #include "cgi/cgi.h"
  12. #include "sqconfig.h"
  13. #include "sqwebmail.h"
  14. #include "auth.h"
  15. #include "pref.h"
  16. #include "maildir.h"
  17. #include "folder.h"
  18. #include "maildir/maildirmisc.h"
  19. #include "rfc822/rfc822.h"
  20. #include "rfc822/rfc2047.h"
  21. #include "rfc2045/rfc2045.h"
  23. #include <stdlib.h>
  24. #include <fcntl.h>
  25. #if HAVE_UNISTD_H
  26. #include <unistd.h>
  27. #endif
  29. extern const char *sqwebmail_mailboxid;
  30. extern const char *sqwebmail_content_charset;
  32. static int start_line;
  33. static int draftfd;
  35. extern const char mimemsg[];
  37. const char *dropre(const char *p, int *flag)
  38. {
  39. *flag=0;
  40. if (strncasecmp(p, "re", 2) == 0 && p[2] == ':')
  41. {
  42. p += 2;
  43. while (*p && strchr(": ", *p))
  44. ++p;
  45. *flag=1;
  46. }
  47. return(p);
  48. }
  50. static void forwardbody(FILE *fp, long nbytes)
  51. {
  52. char buf[512];
  53. int i;
  55. while ((i=nbytes > sizeof(buf) ? sizeof(buf):nbytes) > 0 &&
  56. (i=fread(buf, 1, i, fp)) > 0)
  57. {
  58. nbytes -= i;
  59. maildir_writemsg(draftfd, buf, i);
  60. }
  61. }
  63. static int quotereply(const char *p, size_t l, void *voidptr)
  64. {
  65. size_t i, j;
  67. for (i=j=0; i<l; i++)
  68. {
  69. if (p[i] == 'n')
  70. {
  71. if (start_line)
  72. maildir_writemsgstr(draftfd, "> ");
  73. start_line=0;
  74. maildir_writemsg(draftfd, p+j, i-j);
  75. maildir_writemsgstr(draftfd, "n");
  76. start_line=1;
  77. j=i+1;
  78. }
  79. }
  81. if (j < i)
  82. {
  83. if (start_line)
  84. maildir_writemsgstr(draftfd, "> ");
  85. start_line=0;
  86. maildir_writemsg(draftfd, p+j, i-j);
  87. }
  88. return (0);
  89. }
  91. /* We have to do something with the first text/plain MIME section we have
  92. ** in themessage */
  94. static void decode_textplain(FILE *fp, struct rfc2045 *rfc,
  95. int (*handler)(const char *, size_t, void *))
  96. {
  97. off_t start_pos, end_pos, start_body;
  98. char buf[512];
  99. int cnt;
  100. off_t dummy;
  102. rfc2045_mimepos(rfc, &start_pos, &end_pos, &start_body,
  103. &dummy, &dummy);
  104. if (fseek(fp, start_body, SEEK_SET) == -1) return;
  106.         rfc2045_cdecode_start(rfc, handler, 0);
  108. start_line=1;
  109.         while (start_body < end_pos)
  110.         {
  111.                 cnt=sizeof(buf);
  112.                 if (cnt > end_pos-start_body)
  113.                         cnt=end_pos-start_body;
  114.                 cnt=fread(buf, 1, cnt, fp);
  115.                 if (cnt <= 0)   break;
  116.                 rfc2045_cdecode(rfc, buf, cnt);
  117. start_body += cnt;
  118.         }
  119.         rfc2045_cdecode_end(rfc);
  120. }
  122. void newmsg_handletextplain(FILE *fp, struct rfc2045 *rfc,
  123. int (*handler)(const char *, size_t, void *))
  124. {
  125. const char *content_type, *dummy;
  127.         rfc2045_mimeinfo(rfc, &content_type, &dummy, &dummy);
  128. if (strcmp(content_type, "text/plain") == 0)
  129. decode_textplain(fp, rfc, handler);
  130. else
  131. {
  132. struct rfc2045 *p;
  134. for (p=rfc->firstpart; p; p=p->next)
  135. {
  136. if (p->isdummy) continue;
  137. rfc2045_mimeinfo(p, &content_type, &dummy, &dummy);
  138. if (strcmp(content_type, "text/plain") == 0)
  139. break;
  140. if (strcmp(content_type, "multipart/alternative") == 0)
  141. return(newmsg_handletextplain(fp,p,handler));
  142. }
  143. if (p) decode_textplain(fp, p, handler);
  144. }
  145. }
  147. static void replybody(FILE *fp, struct rfc2045 *rfc)
  148. {
  149. newmsg_handletextplain(fp, rfc, &quotereply);
  150. }
  152. static void newmsg_writesig(int d)
  153. {
  154. FILE *fp=fopen(SIGNATURE, "r");
  155. char buf[256];
  156. int n;
  158. if (!fp) return;
  159. maildir_writemsg(d, "nn", 2);
  160. while ((n=fread(buf, 1, sizeof(buf), fp)) > 0)
  161. maildir_writemsg(d, buf, n);
  162. fclose(fp);
  163. maildir_writemsg(d, "n", 1);
  164. }
  166. static void writereferences(int fd, const char *oldref, const char *oldmsgid)
  167. {
  168. char *buf=malloc((oldref ? strlen(oldref):0)
  169. + (oldmsgid ? strlen(oldmsgid):0)+2);
  170. char *p, *q;
  171. struct rfc822t *tp;
  172. struct rfc822a *ap;
  173. int i;
  175. if (!buf) enomem();
  177. /* Create new references header */
  178. *buf=0;
  179. if (oldref) strcat(buf, oldref);
  180. if (oldref && oldmsgid) strcat(buf, " ");
  181. if (oldmsgid) strcat(buf, oldmsgid);
  183. /* Do wrapping the RIGHT way, by
  184. ** RFC822 parsing the References: header
  185. */
  187. if ((tp=rfc822t_alloc(buf, NULL)) == 0 ||
  188. (ap=rfc822a_alloc(tp)) == 0)
  189. {
  190. enomem();
  191. return;
  192. }
  194. /* Keep only the last 20 message IDs */
  196. i=0;
  197. if (ap->naddrs > 20) i=ap->naddrs-20;
  198. p="";
  199. while (i < ap->naddrs)
  200. {
  201. q=rfc822_gettok(ap->addrs[i].tokens);
  202. if (!q) enomem();
  203. maildir_writemsgstr(fd, p);
  204. maildir_writemsgstr(fd, "<");
  205. maildir_writemsgstr(fd, q);
  206. maildir_writemsgstr(fd, ">n");
  207. p="            ";
  208. free(q);
  209. i++;
  210. }
  211. rfc822a_free(ap);
  212. rfc822t_free(tp);
  213. free(buf);
  214. }
  216. /*
  217. ** This functions creates a new draft message, which may be a reply or a
  218. ** forward of an existing message.
  219. */
  221. static struct rfc2045 *do_mixed_fwd(struct rfc2045 *, off_t *);
  223. char *newmsg_newdraft(const char *folder, const char *pos,
  224. const char *forwardsep, const char *replysalut)
  225. {
  226. char *filename=0;
  227. char *replymode;
  228. size_t pos_n;
  229. FILE *fp;
  231. char *header, *value;
  232. char *oldtocc, *oldfrom, *oldreplyto;
  233. char *subject;
  234. char *oldmsgid;
  235. char *draftfilename;
  236. char *whowrote;
  237. char *oldreferences;
  238. struct rfc2045 *rfc2045p, *rfc2045partp;
  239. const char *mimeidptr;
  240. off_t start_pos, end_pos, start_body, posptr;
  241. off_t dummy;
  242. int x;
  244. if (*cgi(replymode="reply") ||
  245. *cgi(replymode="replyall") ||
  246. *cgi(replymode="forward") ||
  247. *cgi(replymode="forwardatt"))
  248. {
  249. filename=maildir_posfind(folder, (pos_n=atol(pos), &pos_n));
  250. }
  252. if (!filename) return (0);
  254. fp=0;
  255. x=maildir_safeopen(filename, O_RDONLY, 0);
  257. if (x >= 0)
  258. if ((fp=fdopen(x, "r")) == 0)
  259. close(x);
  261. if (fp == 0)
  262. {
  263. free(filename);
  264. return (0);
  265. }
  267. rfc2045p=rfc2045_fromfp(fp);
  269. if (!rfc2045p) enomem();
  271. mimeidptr=cgi("mimeid");
  273. rfc2045partp=0;
  275. if (*mimeidptr)
  276. {
  277. rfc2045partp=rfc2045_find(rfc2045p, mimeidptr);
  278. if (rfc2045partp)
  279. {
  280. const char      *content_type, *dummy;
  282. rfc2045_mimeinfo(rfc2045partp, &content_type,
  283. &dummy, &dummy);
  285. if (!content_type || strcmp(content_type, "message/rfc822"))
  286. rfc2045partp=0;
  287. else
  288. rfc2045partp=rfc2045partp->firstpart;
  289. }
  290. }
  292. if (!rfc2045partp)
  293. rfc2045partp=rfc2045p;
  295. oldtocc=0;
  296. oldfrom=0;
  297. oldreplyto=0;
  298. subject=0;
  299. oldmsgid=0;
  300. oldreferences=0;
  302. rfc2045_mimepos(rfc2045partp, &start_pos, &end_pos, &start_body,
  303. &dummy, &dummy);
  304.         if (fseek(fp, start_pos, SEEK_SET) == -1)
  305.                 enomem();
  307. draftfd=maildir_createmsg(DRAFTS, 0, &draftfilename);
  308. if (draftfd < 0) enomem();
  309. whowrote=0;
  311. maildir_writemsgstr(draftfd, "From: ");
  312. {
  313. const char *f=pref_from;
  315. if (!f || !*f) f=login_fromhdr();
  316. if (!f) f="";
  317. maildir_writemsgstr(draftfd, f);
  318. maildir_writemsgstr(draftfd, "n");
  319. }
  321. if (strcmp(replymode, "forward") == 0 || strcmp(replymode, "forwardatt") == 0)
  322. {
  323. char *boundary=0;
  324. struct rfc2045 *mixed_fwd;
  325. off_t orig_startpos=start_pos;
  327. posptr=start_pos;
  328. while (posptr < end_pos &&
  329. (header=maildir_readheader(fp, &value, 0)) != 0)
  330. {
  331. posptr += strlen(header)+1;
  332. if (strcmp(header, "subject") == 0)
  333. {
  334. if (subject) free(subject);
  335. subject=malloc(strlen(value)+10);
  336. if (!subject) enomem();
  337. strcpy(subject, value);
  338. if (strlen(subject) > 255)
  339. subject[255]='';
  340. }
  341. }
  343. maildir_writemsgstr(draftfd, "Subject: ");
  344. if (subject)
  345. {
  346. int dummy;
  348. maildir_writemsgstr(draftfd, dropre(subject, &dummy));
  349. }
  350. maildir_writemsgstr(draftfd, " (fwd)nMime-Version: 1.0n");
  352. if ((mixed_fwd=strcmp(replymode, "forwardatt") == 0 ? 0:
  353. do_mixed_fwd(rfc2045p, &start_pos)) != 0)
  354. {
  355. /* Borrow boundary from the message */
  357. boundary=strdup(rfc2045_boundary(rfc2045p));
  358. if (!boundary) enomem();
  360. maildir_writemsgstr(draftfd,
  361. "Content-Type: multipart/mixed; boundary="");
  362. maildir_writemsgstr(draftfd, boundary);
  363. maildir_writemsgstr(draftfd,
  364. ""nContent-Transfer-Encoding: 8bitnn");
  365. maildir_writemsgstr(draftfd, mimemsg);
  366. maildir_writemsgstr(draftfd, "--");
  367. maildir_writemsgstr(draftfd, boundary);
  368. maildir_writemsgstr(draftfd, "n");
  369. }
  370. else
  371. if (strcmp(replymode, "forwardatt") == 0)
  372. {
  373. const char *content_type, *content_transfer_encoding, *charset;
  375. boundary=rfc2045_mk_boundary(rfc2045p, fileno(fp));
  376. if (!boundary) enomem();
  378. rfc2045_mimeinfo(rfc2045partp, &content_type,
  379. &content_transfer_encoding, &charset);
  380. maildir_writemsgstr(draftfd,
  381. "Content-Type: multipart/mixed; boundary="");
  382. maildir_writemsgstr(draftfd, boundary);
  383. maildir_writemsgstr(draftfd,
  384. ""nContent-Transfer-Encoding: ");
  385. maildir_writemsgstr(draftfd, content_transfer_encoding);
  386. maildir_writemsgstr(draftfd,
  387. "nn");
  388. maildir_writemsgstr(draftfd, mimemsg);
  389. maildir_writemsgstr(draftfd, "--");
  390. maildir_writemsgstr(draftfd, boundary);
  391. maildir_writemsgstr(draftfd, "n");
  392. }
  393. maildir_writemsgstr(draftfd,
  394. "Content-Type: text/plain; charset="");
  395. maildir_writemsgstr(draftfd, sqwebmail_content_charset);
  396. maildir_writemsgstr(draftfd, ""nn");
  398. newmsg_writesig(draftfd);
  400. maildir_writemsgstr(draftfd, "n");
  402. if (!boundary)
  403. {
  404. if (forwardsep)
  405. {
  406. maildir_writemsgstr(draftfd, forwardsep);
  407. maildir_writemsgstr(draftfd, "n");
  408. }
  409. }
  410. else if (mixed_fwd)
  411. {
  412. off_t txtbody, txtend, dummy;
  414. if (forwardsep)
  415. {
  416. maildir_writemsgstr(draftfd, forwardsep);
  417. maildir_writemsgstr(draftfd, "n");
  418. }
  420. /* Copy original headers. */
  422. if (fseek(fp, orig_startpos, SEEK_SET) == -1)
  423. enomem();
  424. forwardbody(fp, start_body - orig_startpos);
  426. rfc2045_mimepos(mixed_fwd, &dummy, &txtend, &txtbody,
  427. &dummy, &dummy);
  428. if (fseek(fp, txtbody, SEEK_SET) == -1)
  429. enomem();
  430. forwardbody(fp, txtend - txtbody);
  432. maildir_writemsgstr(draftfd, "n--");
  433. maildir_writemsgstr(draftfd, boundary);
  434. maildir_writemsgstr(draftfd, "n");
  435. }
  436. else
  437. {
  438. maildir_writemsgstr(draftfd, "n--");
  439. maildir_writemsgstr(draftfd, boundary);
  440. maildir_writemsgstr(draftfd,
  441. "nContent-Type: message/rfc822nn");
  442. }
  443. if (fseek(fp, start_pos, SEEK_SET) == -1)
  444. enomem();
  445. forwardbody(fp, end_pos - start_pos);
  446. if (boundary)
  447. {
  448. if (!mixed_fwd) /* Already copied */
  449. {
  450. maildir_writemsgstr(draftfd, "n--");
  451. maildir_writemsgstr(draftfd, boundary);
  452. maildir_writemsgstr(draftfd, "--n");
  453. }
  454. free(boundary);
  455. }
  456. }
  457. else
  458. {
  459. maildir_writemsgstr(draftfd, "X-Reply-To-Folder: ");
  460. maildir_writemsgstr(draftfd, folder);
  461. maildir_writemsgstr(draftfd, "nX-Reply-To-Msg: ");
  462. {
  463. char *basename=maildir_basename(filename);
  465. maildir_writemsgstr(draftfd, basename);
  466. free(basename);
  467. }
  468. maildir_writemsgstr(draftfd, "n");
  470. posptr=start_pos;
  471. while (posptr < end_pos &&
  472. (header=maildir_readheader(fp, &value, 0)) != 0)
  473. {
  474. posptr += strlen(header)+1;
  475. if (strcmp(header, "subject") == 0)
  476. {
  477. if (subject) free(subject);
  478. subject=strdup(value);
  479. if (!subject) enomem();
  480. }
  481. else if (strcmp(header, "reply-to") == 0)
  482. {
  483. if (oldreplyto) free(oldreplyto);
  484. oldreplyto=strdup(value);
  485. if (!oldreplyto) enomem();
  486. }
  487. else if (strcmp(header, "from") == 0)
  488. {
  489. if (oldfrom) free(oldfrom);
  490. oldfrom=strdup(value);
  491. if (!oldfrom) enomem();
  492. }
  493. else if (strcmp(header, "message-id") == 0)
  494. {
  495. if (oldmsgid) free(oldmsgid);
  496. oldmsgid=strdup(value);
  497. if (!oldmsgid) enomem();
  498. }
  499. else if (strcmp(header, "references") == 0)
  500. {
  501. if (oldreferences) free(oldreferences);
  502. oldreferences=strdup(value);
  503. if (!oldreferences) enomem();
  504. }
  505. else if (strcmp(replymode, "replyall") == 0 &&
  506. (
  507. strcmp(header, "to") == 0 ||
  508. strcmp(header, "cc") == 0
  509. )
  510. )
  511. {
  512. char *newh=malloc( (oldtocc ?
  513. strlen(oldtocc):0)
  514. + strlen(value)+2);
  516. if (!newh) enomem();
  517. *newh=0;
  518. if (oldtocc)
  519. strcat(strcpy(newh, oldtocc),
  520. ",");
  521. strcat(newh, value);
  522. if (oldtocc) free(oldtocc);
  523. oldtocc=newh;
  524. }
  525. }
  527. /* Write:  "%s writes:" */
  529. if (oldfrom)
  530. {
  531. struct rfc822t *rfcp=rfc822t_alloc(oldfrom, NULL);
  532. struct rfc822a *rfcpa;
  533. char *p, *q;
  535. if (!rfcp) enomem();
  536. rfcpa=rfc822a_alloc(rfcp);
  537. if (!rfcpa) enomem();
  538. p= rfcpa->naddrs > 0 ?
  539. rfc822_getname(rfcpa, 0):0;
  540. rfc822a_free(rfcpa);
  541. rfc822t_free(rfcp);
  542. if (!p) p=strdup(oldfrom);
  543. if (!p) enomem();
  544. q=rfc2047_decode_enhanced(p, sqwebmail_content_charset);
  545. if (!q) enomem();
  546. free(p);
  547. p=q;
  548. whowrote=malloc(strlen(p)+strlen(replysalut)+1);
  549. if (!whowrote) enomem();
  550. sprintf(whowrote, replysalut, p);
  551. free(p);
  552. }
  553. if (oldreplyto)
  554. {
  555. if (oldfrom) free(oldfrom);
  556. oldfrom=oldreplyto;
  557. oldreplyto=0;
  558. }
  560. /* Remove duplicate entries from new Cc header */
  562. if (oldtocc)
  563. {
  564. struct rfc822t *rfccc, *rfcto;
  565. struct rfc822a *arfccc, *arfcto;
  566. int i, j;
  567. const char *returnaddr= login_returnaddr();
  568. char *new_addresses;
  570. rfccc=rfc822t_alloc(oldtocc, NULL);
  571. rfcto= oldfrom ? rfc822t_alloc(oldfrom, NULL):NULL;
  572. arfccc=rfccc ? rfc822a_alloc(rfccc):NULL;
  573. arfcto=rfcto ? rfc822a_alloc(rfcto):NULL;
  575. for (i=0; arfccc && i <arfccc->naddrs; i++)
  576. {
  577. char *addr=rfc822_getaddr(arfccc, i);
  579. if (!addr) continue;
  581. /* Remove address from Cc if it is my address */
  583. if (strcmp(addr, returnaddr) == 0)
  584. {
  585. rfc822_deladdr(arfccc, i); --i;
  586. free(addr);
  587. continue;
  588. }
  590. /* Remove address from Cc if it appears in To: */
  592. for (j=0; arfcto && j < arfcto->naddrs; j++)
  593. {
  594. char *addr2=rfc822_getaddr(arfcto, j);
  596. if (!addr2) continue;
  597. if (strcmp(addr, addr2) == 0)
  598. {
  599. free(addr2);
  600. break;
  601. }
  602. free(addr2);
  603. }
  604. if (arfcto && j < arfcto->naddrs)
  605. {
  606. rfc822_deladdr(arfccc, i); --i;
  607. free(addr);
  608. continue;
  609. }
  611. /* Remove outright duplicates in Cc */
  613. for (j=i+1; j<arfccc->naddrs; j++)
  614. {
  615. char *addr2=rfc822_getaddr(arfccc, j);
  617. if (!addr2) continue;
  618. if (strcmp(addr, addr2) == 0)
  619. {
  620. rfc822_deladdr(arfccc, j);
  621. --j;
  622. }
  623. free(addr2);
  624. }
  625. free(addr);
  626. }
  627. new_addresses=rfc822_getaddrs(arfccc);
  628. free(oldtocc);
  629. oldtocc=new_addresses;
  630. if (arfccc) rfc822a_free(arfccc);
  631. if (arfcto) rfc822a_free(arfcto);
  632. rfc822t_free(rfccc);
  633. if (rfcto) rfc822t_free(rfcto);
  634. }
  636. if (oldfrom)
  637. {
  638. maildir_writemsgstr(draftfd, "To: ");
  639. maildir_writemsgstr(draftfd, oldfrom);
  640. maildir_writemsgstr(draftfd, "n");
  641. free(oldfrom);
  642. }
  644. if (oldtocc)
  645. {
  646. maildir_writemsgstr(draftfd, "Cc: ");
  647. maildir_writemsgstr(draftfd, oldtocc);
  648. maildir_writemsgstr(draftfd, "n");
  649. free(oldtocc);
  650. }
  651. if (oldmsgid || oldreferences)
  652. {
  653. maildir_writemsgstr(draftfd, "References: ");
  654. writereferences(draftfd, oldreferences, oldmsgid);
  655. if (oldreferences) free(oldreferences);
  656. }
  657. if (oldmsgid)
  658. {
  659. maildir_writemsgstr(draftfd, "In-Reply-To: ");
  660. maildir_writemsgstr(draftfd, oldmsgid);
  661. maildir_writemsgstr(draftfd, "n");
  662. free(oldmsgid);
  663. }
  664. maildir_writemsgstr(draftfd, "Subject: Re: ");
  665. if (subject)
  666. {
  667. int dummy;
  669. maildir_writemsgstr(draftfd, dropre(subject, &dummy));
  670. free(subject);
  671. }
  672. maildir_writemsgstr(draftfd, "nn");
  673. if (whowrote)
  674. {
  675. maildir_writemsgstr(draftfd, whowrote);
  676. free(whowrote);
  677. maildir_writemsgstr(draftfd, "nn");
  678. }
  679. if (fseek(fp, start_body, SEEK_SET) == -1)
  680. enomem();
  681. replybody(fp, rfc2045partp);
  682. newmsg_writesig(draftfd);
  683. }
  684. fclose(fp);
  685. if (maildir_closemsg(draftfd, DRAFTS, draftfilename, 1, 0))
  686. {
  687. free(draftfilename);
  688. draftfilename=0;
  689. cgi_put("error", "quota");
  690. }
  691. free(filename);
  692. rfc2045_free(rfc2045p);
  693. return(draftfilename);
  694. }
  696. /*****************************************************************************
  697. **
  698. ** do_mixed_fwd determines if what we should create for forwarding should be
  699. ** a mixture of a portion of the original message, plus attachments.  This
  700. ** should happen when the original message has attachments.  Normally, we
  701. ** either forward the entire message as text/plain, or as a message/rfc822
  702. ** attachment.  When the original message has attachments, it's preferrable
  703. ** to keep the original attachments as attachments of the forward message,
  704. ** while putting the text portion of the original message in the forwarded
  705. ** body.
  706. **
  707. ** So, what we check here is this:
  708. **
  709. ** A) This is a multipart message with at least two parts.
  710. ** B) The first part is text/plain (if it's text/html we'll just quote the
  711. **    whole mess too).  If the first part is multipart/alternative, look
  712. **    inside the multipart/alternative for the text/plain section.
  713. **
  714. ** If this is not the case, we return NULL.  Otherwise we return the
  715. ** rfc2045 pointer to the text/plain section, and the starting position
  716. ** of the first attachment (it's used to reset the starting position of
  717. ** the portion of the original message that's copied into the forwarding
  718. ** message).
  719. */
  721. static struct rfc2045 *do_mixed_fwd(struct rfc2045 *p, off_t *f)
  722. {
  723. const char *content_type, *dummy;
  724. off_t dummyp;
  726. if (!p->firstpart || !p->firstpart->isdummy ||
  727. !p->firstpart->next || !p->firstpart->next->next)
  728. return (0);
  730. rfc2045_mimepos(p->firstpart->next->next, f, &dummyp, &dummyp,
  731. &dummyp, &dummyp);
  733. p=p->firstpart->next;
  735. rfc2045_mimeinfo(p, &content_type, &dummy, &dummy);
  737. if (strcmp(content_type, "text/plain") &&
  738. strcmp(content_type, "text/html") /* GRUMBLE */)
  739. {
  740. if (strcmp(content_type, "multipart/alternative"))
  741. return (0);
  743. for (p=p->firstpart; p; p=p->next)
  744. {
  745. if (p->isdummy) continue;
  747. rfc2045_mimeinfo(p, &content_type, &dummy, &dummy);
  748. if (strcmp(content_type, "text/plain") == 0)
  749. break;
  750. }
  751. if (!p) return (0);
  752. }
  753. return (p);
  754. }