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

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

WEB邮件程序

开发平台：

C/C++

newmsg_create.c：源码内容
  1. /*
  2. ** Copyright 1998 - 1999 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  7. /*
  8. ** $Id: newmsg_create.c,v 1.29 2000/06/18 01:26:21 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 "maildir.h"
  16. #include "folder.h"
  17. #include "filter.h"
  18. #include "pref.h"
  19. #include "addressbook.h"
  20. #include "maildir/maildirmisc.h"
  21. #include "rfc822/rfc822.h"
  22. #include "rfc2045/rfc2045.h"
  23. #include "rfc822/rfc2047.h"
  24. #include "http11/http11.h"
  25. #include "htmllibdir.h"
  27. #include <stdlib.h>
  28. #if HAVE_UNISTD_H
  29. #include <unistd.h>
  30. #endif
  31. #include <ctype.h>
  32. #include <fcntl.h>
  34. extern const char *rfc822_mkdt(time_t);
  36. extern const char *sqwebmail_content_charset;
  37. extern const char *sqwebmail_content_language;
  39. int newdraftfd;
  40. extern const char *sqwebmail_mailboxid;
  42. const char mimemsg[]="This is a MIME-formatted message.  If you see this text it means that yournmail software cannot handle MIME-formatted messages.nn";
  44. char *newmsg_createdraft_do(const char *, const char *, int);
  46. /* Save message in a draft file */
  48. char *newmsg_createdraft(const char *curdraft)
  49. {
  50. if (curdraft && *curdraft)
  51. {
  52. char *base=maildir_basename(curdraft);
  53. char *filename=maildir_find(DRAFTS, base);
  55. if (filename)
  56. {
  57. char *p=newmsg_createdraft_do(filename, cgi("message"), 0);
  59. free(filename);
  60. free(base);
  61. return (p);
  62. }
  63. free(base);
  64. }
  65. return (newmsg_createdraft_do(0, cgi("message"), 0));
  66. }
  68. static void create_draftheader_do(const char *hdrname, const char *p,
  69. int isrfc822addr);
  71. static void create_draftheader(const char *hdrname, const char *p,
  72. const char *q, int isrfc822addr)
  73. {
  74. if (q && *q) /* Add from address book */
  75. {
  76. char *nick=cgi_multiple("nick", ",");
  77. char *s;
  79. if (nick)
  80. {
  81. s=malloc(strlen(p)+strlen(nick)+2);
  83. if (s)
  84. {
  85. strcpy(s, p);
  86. if (*s && *nick) strcat(s, ",");
  87. strcat(s, nick);
  88. create_draftheader_do(hdrname, s, isrfc822addr);
  89. free(s);
  90. free(nick);
  91. return;
  92. }
  93. free(nick);
  94. }
  96. }
  97. create_draftheader_do(hdrname, p, isrfc822addr);
  98. }
  100. static void create_draftheader_do(const char *hdrname, const char *p,
  101. int isrfc822addr)
  102. {
  103. char *s;
  105. if (!*p) return;
  107. if (!isrfc822addr)
  108. {
  109. s=rfc2047_encode_str(p, sqwebmail_content_charset);
  110. }
  111. else
  112. {
  113. struct rfc822t *t;
  114. struct rfc822a *a;
  116. /*
  117. ** For proper RFC 2047 encoding, we must RFC822-parse
  118. ** this header.
  119. */
  121. s=0;
  122. if ((t=rfc822t_alloc(p, 0)) != 0)
  123. {
  124. if ((a=rfc822a_alloc(t)) != 0)
  125. {
  126. s=rfc2047_encode_header(a,
  127. sqwebmail_content_charset);
  128. rfc822a_free(a);
  129. }
  130. rfc822t_free(t);
  131. }
  132. }
  134. if (!s)
  135. {
  136. close(newdraftfd);
  137. enomem();
  138. }
  139. maildir_writemsgstr(newdraftfd, hdrname);
  140. maildir_writemsgstr(newdraftfd, s);
  141. maildir_writemsgstr(newdraftfd, "n");
  142. free(s);
  143. }
  145. void newmsg_create_multipart(int newdraftfd, const char *charset,
  146. const char *multipart_boundary)
  147. {
  148. maildir_writemsgstr(newdraftfd,
  149. "Mime-version: 1.0n"
  150. "Content-Type: multipart/mixed; boundary="");
  151. maildir_writemsgstr(newdraftfd, multipart_boundary);
  152. maildir_writemsgstr(newdraftfd, ""; charset="");
  153. maildir_writemsgstr(newdraftfd, charset);
  154. maildir_writemsgstr(newdraftfd, 
  155. ""nn");
  157. maildir_writemsgstr(newdraftfd, mimemsg);
  158. }
  161. static char *newmsg_multipart_boundary(FILE *, const char *);
  162. static void newmsg_copy_attachments(FILE *, const char *);
  164. void newmsg_copy_nonmime_headers(FILE *fp)
  165. {
  166. char *header, *value;
  167. char *q;
  169. while ((header=maildir_readheader(fp, &value, 1)) != NULL)
  170. {
  171. if (strcmp(header, "mime-version") == 0 ||
  172. strncmp(header, "content-", 8) == 0) continue;
  174. /* Fluff - capitalize header names */
  176. for (q=header; *q; q++)
  177. {
  178. for (*q=toupper(*q); *q; q++)
  179. if (*q == '-') break;
  180. }
  182. maildir_writemsgstr(newdraftfd, header);
  183. maildir_writemsgstr(newdraftfd, ": ");
  184. maildir_writemsgstr(newdraftfd, value);
  185. maildir_writemsgstr(newdraftfd, "n");
  186. }
  187. }
  189. static void do_save(const char *, size_t);
  191. char *newmsg_createdraft_do(const char *curdraft, const char *newmsg,
  192. int keepheader)
  193. {
  194. char *draftfilename;
  195. FILE *fp=0;
  196. char *multipart_boundary;
  197. const char *content_type;
  198. const char *content_transfer_encoding;
  199. const char *charset;
  200. unsigned long prev_size=0;
  201. off_t transferencodingpos;
  203. if (curdraft) /* Reuse a draft filename */
  204. newdraftfd=maildir_recreatemsg(DRAFTS, curdraft, &draftfilename);
  205. else
  206. newdraftfd=maildir_createmsg(DRAFTS, 0, &draftfilename);
  207. if (newdraftfd < 0) enomem();
  209. fp=NULL;
  210. if (curdraft)
  211. {
  212. int x=maildir_safeopen(curdraft, O_RDONLY, 0);
  214. if (x >= 0)
  215. if ((fp=fdopen(x, "r")) == 0)
  216. close(x);
  217. }
  219. if (fp)
  220. {
  221. char *header, *value;
  222. struct stat stat_buf;
  224. if (fstat(fileno(fp), &stat_buf))
  225. {
  226. fclose(fp);
  227. enomem();
  228. }
  229. prev_size=stat_buf.st_size;
  231. while ((header=maildir_readheader(fp, &value, 1)) != NULL)
  232. {
  233. if (!keepheader)
  234. {
  235. if (strcmp(header, "in-reply-to") &&
  236. strcmp(header, "references") &&
  237. strncmp(header, "x-", 2)) continue;
  238. /* Do not discard these headers */
  239. }
  240. else /* Called from spell */
  241. {
  242. if (strcasecmp(header, "mime-version") == 0 ||
  243. strncasecmp(header, "content-", 8) == 0)
  244. continue;
  245. }
  247. maildir_writemsgstr(newdraftfd, header);
  248. maildir_writemsgstr(newdraftfd, ": ");
  249. maildir_writemsgstr(newdraftfd, value);
  250. maildir_writemsgstr(newdraftfd, "n");
  251. }
  252. }
  254. if (!keepheader) /* Coming back from msg edit, set headers */
  255. {
  256. time_t t;
  257. const char *p=cgi("headerfrom");
  259. if (!*p) p=pref_from;
  260. if (!p || !*p || access(NOCHANGINGFROM, 0) == 0)
  261. p=login_fromhdr();
  263. create_draftheader("From: ", p, 0, 1);
  265. if (!pref_from || strcmp(p, pref_from))
  266. pref_setfrom(p);
  268. /* sam ????
  269. create_draftheader("In-Reply-To: ", cgi("headerin-reply-to"));
  270. */
  272. create_draftheader("To: ", cgi("headerto"),
  273. cgi("addressbook_to"), 1);
  274. create_draftheader("Cc: ", cgi("headercc"),
  275. cgi("addressbook_cc"), 1);
  276. create_draftheader("Bcc: ", cgi("headerbcc"),
  277. cgi("addressbook_bcc"), 1);
  278. create_draftheader("Reply-To: ", cgi("headerreply-to"), 0, 1);
  279. create_draftheader("Subject: ", cgi("headersubject"), 0, 0);
  281. maildir_writemsgstr(newdraftfd, "Date: ");
  283. time (&t);
  284. maildir_writemsgstr(newdraftfd, rfc822_mkdt(t));
  285. maildir_writemsgstr(newdraftfd, "n");
  286. }
  288. /* If the message has attachments, calculate multipart boundary */
  290. multipart_boundary=fp ? newmsg_multipart_boundary(fp, newmsg) : NULL;
  292. if (multipart_boundary)
  293. {
  294. struct rfc2045 *rfcp=rfc2045_fromfp(fp), *q;
  295. /* Copy over existing charset */
  297. if (!rfcp)
  298. {
  299. close(newdraftfd);
  300. fclose(fp);
  301. enomem();
  302. }
  304. rfc2045_mimeinfo(rfcp, &content_type,
  305. &content_transfer_encoding, &charset);
  307. newmsg_create_multipart(newdraftfd,
  308. sqwebmail_content_charset, multipart_boundary);
  310. maildir_writemsgstr(newdraftfd, "--");
  311. maildir_writemsgstr(newdraftfd, multipart_boundary);
  313. for (q=rfcp->firstpart; q; q=q->next)
  314. {
  315. if (q->isdummy) continue;
  316. rfc2045_mimeinfo(q, &content_type,
  317. &content_transfer_encoding, &charset);
  318. if (strcmp(content_type, "text/plain") == 0) break;
  319. }
  321. maildir_writemsgstr(newdraftfd, "nContent-Type: text/plain");
  323. if (q)
  324. {
  325. maildir_writemsgstr(newdraftfd, "; charset="");
  326. maildir_writemsgstr(newdraftfd,
  327. sqwebmail_content_charset);
  328. maildir_writemsgstr(newdraftfd, """);
  329. }
  330. rfc2045_free(rfcp);
  331. maildir_writemsgstr(newdraftfd, "n");
  332. }
  333. else
  334. {
  335. struct rfc2045 *rfcp;
  337. if (fp)
  338. {
  339. rfcp=rfc2045_fromfp(fp);
  340. if (!rfcp)
  341. {
  342. close(newdraftfd);
  343. fclose(fp);
  344. enomem();
  345. }
  347. rfc2045_mimeinfo(rfcp, &content_type,
  348. &content_transfer_encoding, &charset);
  349. }
  350. else
  351. {
  352. rfcp=0;
  353. charset=sqwebmail_content_charset;
  354. }
  356. maildir_writemsgstr(newdraftfd, "Mime-Version: 1.0nContent-Type: text/plain; charset="");
  357. maildir_writemsgstr(newdraftfd, charset);
  358. maildir_writemsgstr(newdraftfd, ""n");
  360. if (rfcp)
  361. rfc2045_free(rfcp);
  362. }
  364. maildir_writemsgstr(newdraftfd, "Content-Transfer-Encoding: ");
  365. transferencodingpos=writebufpos;
  366. maildir_writemsgstr(newdraftfd, "7bitnn");
  368. maildir_writemsgstr(newdraftfd, "n");
  371. {
  372. char *buf=strdup(newmsg);
  373. size_t i,j;
  375. for (i=j=0; buf[i]; i++)
  376. if (buf[i] != 'r') buf[j++]=buf[i];
  377. filter_start(FILTER_FOR_SAVING, &do_save);
  378. filter(buf, j);
  379. if (j && buf[j-1] != 'n')
  380. filter("n", 1);
  381. filter_end();
  382. free(buf);
  383. }
  385. if ( multipart_boundary)
  386. {
  387. newmsg_copy_attachments(fp, multipart_boundary);
  388. maildir_writemsgstr(newdraftfd, "n--");
  389. maildir_writemsgstr(newdraftfd, multipart_boundary);
  390. maildir_writemsgstr(newdraftfd, "--n");
  391. free(multipart_boundary);
  392. }
  393. if (fp) fclose(fp);
  395. if ( maildir_writemsg_flush(newdraftfd) == 0 && writebuf8bit)
  396. {
  397. if (lseek(newdraftfd, transferencodingpos, SEEK_SET) < 0 ||
  398. write(newdraftfd, "8", 1) != 1)
  399. {
  400. close(newdraftfd);
  401. enomem();
  402. }
  403. }
  405. if ( maildir_closemsg(newdraftfd, DRAFTS, draftfilename, -1, prev_size))
  406. cgi_put("error", "quota");
  408. return(draftfilename);
  409. }
  411. static void do_save(const char *p, size_t l)
  412. {
  413. maildir_writemsg(newdraftfd, p, l);
  414. }
  416. /* Create message in the sent folder */
  418. static void sentmsg_copy(FILE *, struct rfc2045 *);
  419. static void sentmsg_reformat(FILE *, struct rfc2045 *);
  421. extern void header_uc(char *h);
  423. struct lookup_buffers {
  424. struct lookup_buffers *next;
  425. char *buf;
  426. char *buf2;
  427. } ;
  429. static int lookup_addressbook_do(const char *header, const char *value,
  430. struct lookup_buffers **lookup_buffer_list)
  431. {
  432. struct rfc822t *t;
  433. struct rfc822a *a;
  434. int i;
  435. char *newbuf;
  436. struct lookup_buffers *ptr;
  437. int expanded=0;
  439. t=rfc822t_alloc(value, 0);
  440. if (!t) enomem();
  441. a=rfc822a_alloc(t);
  442. if (!a)
  443. {
  444. rfc822t_free(t);
  445. enomem();
  446. }
  448. for (i=0; i<a->naddrs; i++)
  449. {
  450. char *p;
  451. const char *q;
  452. struct lookup_buffers *r;
  454. if (a->addrs[i].tokens == 0)
  455. continue;
  456. if (a->addrs[i].name)
  457. continue; /* Can't be a nickname */
  459. p=rfc822_getaddr(a, i);
  460. if (!p)
  461. {
  462. rfc822a_free(a);
  463. rfc822t_free(t);
  464. free(p);
  465. return (-1);
  466. }
  468. for (ptr= *lookup_buffer_list; ptr; ptr=ptr->next)
  469. if (strcmp(ptr->buf2, p) == 0)
  470. break;
  472. if (ptr) /* Address book loop */
  473. {
  474. int j;
  476. for (j=i+1; j<a->naddrs; j++)
  477. a->addrs[j-1]=a->addrs[j];
  478. --a->naddrs;
  479. --i;
  480. free(p);
  481. continue;
  482. }
  484. if ((q=ab_find(p)) == 0)
  485. {
  486. free(p);
  487. continue;
  488. }
  490. r=malloc(sizeof(struct lookup_buffers));
  491. if (r) r->buf=r->buf2=0;
  493. if (!r || !(r->buf=strdup(q)) || !(r->buf2=strdup(p)))
  494. {
  495. free(p);
  496. if (r && r->buf) free(r->buf);
  497. if (r) free(r);
  498. rfc822a_free(a);
  499. rfc822t_free(t);
  500. return (-1);
  501. }
  502. free(p);
  503. r->next= *lookup_buffer_list;
  504. *lookup_buffer_list=r;
  505. a->addrs[i].tokens->next=0;
  506. a->addrs[i].tokens->token=0;
  507. a->addrs[i].tokens->ptr=r->buf;
  508. a->addrs[i].tokens->len=strlen(r->buf);
  509. expanded=1;
  510. }
  512. newbuf=rfc822_getaddrs_wrap(a, 70);
  513. rfc822a_free(a);
  514. rfc822t_free(t);
  515. if (!newbuf) return (-1);
  517. if (expanded) /* Look through the address book again */
  518. {
  519. int rc=lookup_addressbook_do(header, newbuf, lookup_buffer_list);
  521. free(newbuf);
  522. return (rc);
  523. }
  525. create_draftheader_do(header, newbuf, 1);
  526. free(newbuf);
  527. return (0);
  528. }
  530. static void lookup_addressbook(const char *header, const char *value)
  531. {
  532. struct lookup_buffers *lookup_buffer_list=0;
  533. int rc;
  534. char *s=strdup(value);
  536. if (!s) enomem();
  537. rc=lookup_addressbook_do(header, s, &lookup_buffer_list);
  538. free(s);
  540. while (lookup_buffer_list)
  541. {
  542. struct lookup_buffers *p=lookup_buffer_list;
  544. lookup_buffer_list=p->next;
  545. free(p->buf);
  546. free(p->buf2);
  547. free(p);
  548. }
  549. if (rc) enomem();
  550. }
  552. char *newmsg_createsentmsg(const char *draftname)
  553. {
  554. char *filename=maildir_find(DRAFTS, draftname);
  555. FILE *fp;
  556. char *sentname;
  557. char *header, *value;
  558. struct rfc2045 *rfcp;
  559. int x;
  561. #if 0
  562. off_t transferencodingpos;
  563. #endif
  565. if (!filename) return (0);
  567. fp=0;
  569. x=maildir_safeopen(filename, O_RDONLY, 0);
  570. if (x >= 0)
  571. if ((fp=fdopen(x, "r")) == 0)
  572. close(x);
  574. if (fp == 0)
  575. {
  576. free(filename);
  577. enomem();
  578. }
  580. newdraftfd=maildir_createmsg(SENT, 0, &sentname);
  581. if (newdraftfd < 0)
  582. {
  583. free(filename);
  584. fclose(fp);
  585. enomem();
  586. }
  587. /* First, copy all headers except X- headers */
  589. while ((header=maildir_readheader(fp, &value, 1)) != 0)
  590. {
  591. if (strncmp(header, "x-", 2) == 0) continue;
  592. header_uc(header);
  593. if (strcasecmp(header, "To") == 0)
  594. {
  595. lookup_addressbook("To: ", value);
  596. continue;
  597. }
  599. if (strcasecmp(header, "Cc") == 0)
  600. {
  601. lookup_addressbook("Cc: ", value);
  602. continue;
  603. }
  605. if (strcasecmp(header, "Bcc") == 0)
  606. {
  607. lookup_addressbook("Bcc: ", value);
  608. continue;
  609. }
  610. maildir_writemsgstr(newdraftfd, header);
  611. maildir_writemsgstr(newdraftfd, ": ");
  612. maildir_writemsgstr(newdraftfd, value);
  613. maildir_writemsgstr(newdraftfd, "n");
  614. }
  615. if (access(USEXSENDER, 0) == 0)
  616. {
  617. maildir_writemsgstr(newdraftfd, "X-Sender: ");
  618. maildir_writemsgstr(newdraftfd, login_returnaddr());
  619. maildir_writemsgstr(newdraftfd, "n");
  620. }
  622. #if 0
  623. maildir_writemsgstr(newdraftfd, "Content-Transfer-Encoding: ");
  624. transferencodingpos=writebufpos;
  625. maildir_writemsgstr(newdraftfd, "7bitn");
  627. #endif
  628. maildir_writemsgstr(newdraftfd, "n");
  630. rfcp=rfc2045_fromfp(fp);
  631. if (!rfcp)
  632. {
  633. fclose(fp);
  634. close(newdraftfd);
  635. enomem();
  636. }
  638. if (!rfcp->firstpart)
  639. sentmsg_reformat(fp, rfcp);
  640. else
  641. {
  642. int found_textplain=0;
  643. struct rfc2045 *p;
  645. for (p=rfcp->firstpart; p; p=p->next)
  646. {
  647. const char *content_type;
  648. const char *content_transfer_encoding;
  649. const char *charset;
  651. rfc2045_mimeinfo(p, &content_type,
  652. &content_transfer_encoding, &charset);
  654. if (strcmp(content_type, "text/plain") == 0 &&
  655. !p->isdummy && !found_textplain)
  656. {
  657. maildir_writemsgstr(newdraftfd,
  658. "Content-Type: text/plain; charset=");
  659. maildir_writemsgstr(newdraftfd, charset);
  660. maildir_writemsgstr(newdraftfd,
  661. "nContent-Transfer-Encoding: ");
  662. maildir_writemsgstr(newdraftfd,
  663. content_transfer_encoding);
  664. maildir_writemsgstr(newdraftfd, "nn");
  665. sentmsg_reformat(fp, p);
  666. found_textplain=1;
  667. }
  668. else sentmsg_copy(fp, p);
  669. maildir_writemsgstr(newdraftfd, "n--");
  670. maildir_writemsgstr(newdraftfd, rfc2045_boundary(rfcp));
  671. if (!p->next)
  672. maildir_writemsgstr(newdraftfd, "--");
  673. maildir_writemsgstr(newdraftfd, "n");
  674. }
  675. }
  676. if ( maildir_writemsg_flush(newdraftfd))
  677. {
  678. free(sentname);
  679. return (0);
  680. }
  682. #if 0
  683. if (writebuf8bit)
  684. {
  685. if (lseek(newdraftfd, transferencodingpos, SEEK_SET) < 0 ||
  686. write(newdraftfd, "8", 1) != 1)
  687. {
  688. free(sentname);
  689. return (0);
  690. }
  691. }
  692. #endif
  694. if ( maildir_closemsg(newdraftfd, SENT, sentname, 1, 0))
  695. {
  696. free(sentname);
  697. return (0);
  698. }
  699. return (sentname);
  700. }
  702. /* Note - sentmsg_copy is also reused in newmsg_copy_attachments */
  704. static void sentmsg_copy(FILE *f, struct rfc2045 *p)
  705. {
  706. off_t start_pos, end_pos, start_body;
  707. char buf[512];
  708. int n;
  709. off_t dummy;
  711. rfc2045_mimepos(p, &start_pos, &end_pos, &start_body, &dummy, &dummy);
  712. if (fseek(f, start_pos, SEEK_SET) == -1)
  713. {
  714. fclose(f);
  715. close(newdraftfd);
  716. enomem();
  717. }
  719. while (start_pos < end_pos)
  720. {
  721. int cnt=sizeof(buf);
  723. if (cnt > end_pos - start_pos)
  724. cnt=end_pos - start_pos;
  726. if ((n=fread(buf, 1, cnt, f)) <= 0)
  727. {
  728. fclose(f);
  729. close(newdraftfd);
  730. enomem();
  731. }
  733. maildir_writemsg(newdraftfd, buf, n);
  734. start_pos += n;
  735. }
  736. }
  738. static void write_to_draft(const char *p, size_t l)
  739. {
  740. maildir_writemsg(newdraftfd, p, l);
  741. }
  743. static void sentmsg_reformat(FILE *f, struct rfc2045 *p)
  744. {
  745. off_t start_pos, end_pos, start_body;
  746. char buf[BUFSIZ];
  747. int n;
  748. off_t dummy;
  749. FILE *fp;
  751. rfc2045_mimepos(p, &start_pos, &end_pos, &start_body,
  752. &dummy, &dummy);
  753. if (fseek(f, start_body, SEEK_SET) == -1)
  754. {
  755. fclose(f);
  756. close(newdraftfd);
  757. enomem();
  758. }
  760. filter_start(FILTER_FOR_SENDING, &write_to_draft);
  762. while (start_body < end_pos)
  763. {
  764. int cnt=sizeof(buf);
  766. if (cnt > end_pos - start_body)
  767. cnt=end_pos - start_body;
  769. if ((n=fread(buf, 1, cnt, f)) <= 0)
  770. {
  771. fclose(f);
  772. close(newdraftfd);
  773. enomem();
  774. }
  775. filter(buf, n);
  776. start_body += n;
  777. }
  779. fp=http11_open_langfile(HTMLLIBDIR, sqwebmail_content_language,
  780. "footer");
  781. if (fp != 0)
  782. {
  783. while ((n=fread(buf, 1, sizeof(buf), fp)) > 0)
  784. filter(buf, n);
  785. fclose(fp);
  786. }
  787. filter_end();
  788. }
  790. /* ---------------------------------------------------------------------- */
  792. /* Create a potential multipart boundary separator tag */
  794. char *multipart_boundary_create()
  795. {
  796. char pidbuf[MAXLONGSIZE];
  797. char timebuf[MAXLONGSIZE];
  798. time_t t;
  799. char cntbuf[MAXLONGSIZE];
  800. unsigned long cnt=0;
  801. char *p;
  803. sprintf(pidbuf, "%lu", (unsigned long)getpid());
  804. time(&t);
  805. sprintf(timebuf, "%lu", (unsigned long)t);
  806. sprintf(cntbuf, "%lu", cnt++);
  807. p=malloc(strlen(pidbuf)+strlen(timebuf) +strlen(cntbuf)+10);
  808. sprintf(p, "=_%s_%s_%s", cntbuf, pidbuf, timebuf);
  809. return (p);
  810. }
  812. /* Search for the boundary tag in a string buffer - this is the new message
  813. ** we're creating.  We should really look for the tag at the beginning of the
  814. ** line, however, the text is not yet linewrapped, besides, why make your
  815. ** life hard?
  816. */
  818. int multipart_boundary_checks(const char *boundary, const char *msg)
  819. {
  820. size_t boundarylen=strlen(boundary);
  822. while (*msg)
  823. {
  824. if (msg[0] == '-' && msg[1] == '-' && msg[2] != '-' &&
  825. strncasecmp(msg+2, boundary, boundarylen) == 0)
  826. return (-1);
  827. ++msg;
  828. }
  829. return (0);
  830. }
  832. /* Again, just look for it at the beginning of the line -- why make your
  833. ** life hard? */
  835. int multipart_boundary_checkf(const char *boundary, FILE *f)
  836. {
  837. size_t boundarylen=strlen(boundary);
  838. const char *line;
  840. if (fseek(f, 0L, SEEK_SET) == -1)
  841. {
  842. fclose(f);
  843. close(newdraftfd);
  844. enomem();
  845. }
  847. while ((line=maildir_readline(f)) != 0)
  848. if (line[0] == '-' && line[1] == '-' &&
  849. strncasecmp(line+2, boundary, boundarylen) == 0)
  850. return (-1);
  851. return (0);
  852. }
  854. /* ---------------------------------------------------------------------- */
  856. /* Copy existing attachments into the new draft message */
  858. /* multipart_boundary - determine if current draft has attachments */
  860. static struct rfc2045 *copyrfc2045;
  862. static char *newmsg_multipart_boundary(FILE *f, const char *msg)
  863. {
  864. char *p=0;
  866. copyrfc2045=rfc2045_fromfp(f);
  867. if (!copyrfc2045)
  868. {
  869. fclose(f);
  870. close(newdraftfd);
  871. enomem();
  872. }
  873. if ( copyrfc2045->firstpart == 0)
  874. {
  875. rfc2045_free(copyrfc2045);
  876. return (0);
  877. }
  879. do
  880. {
  881. if (p) free(p);
  882. p=multipart_boundary_create();
  883. } while (multipart_boundary_checks(p, msg)
  884. || multipart_boundary_checkf(p, f));
  885. return (p);
  886. }
  888. static void newmsg_copy_attachments(FILE *f, const char *boundary)
  889. {
  890. struct rfc2045 *p;
  891. int foundtextplain=0;
  892. const char *content_type;
  893. const char *content_transfer_encoding;
  894. const char *charset;
  896. for (p=copyrfc2045->firstpart; p; p=p->next)
  897. {
  898. if (p->isdummy) continue;
  899. rfc2045_mimeinfo(p, &content_type,
  900. &content_transfer_encoding, &charset);
  901. if (!foundtextplain && strcmp(content_type,
  902. "text/plain") == 0)
  903. { /* Previous version of this message */
  905. foundtextplain=1;
  906. continue;
  907. }
  908. maildir_writemsgstr(newdraftfd, "n--");
  909. maildir_writemsgstr(newdraftfd, boundary);
  910. maildir_writemsgstr(newdraftfd, "n");
  911. sentmsg_copy(f, p); /* Reuse some code */
  912. }
  913. rfc2045_free(copyrfc2045);
  914. }