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

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

WEB邮件程序

开发平台：

C/C++

attachments.c：源码内容
  1. /*
  2. ** Copyright 1998 - 2000 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  7. /*
  8. ** $Id: attachments.c,v 1.22 2000/06/18 01:26:21 mrsam Exp $
  9. */
  10. #include "config.h"
  11. #include "sqwebmail.h"
  12. #include "cgi/cgi.h"
  13. #include "sqconfig.h"
  14. #include "maildir.h"
  15. #include "folder.h"
  16. #include "rfc822/rfc822.h"
  17. #include "rfc822/rfc2047.h"
  18. #include "rfc2045/rfc2045.h"
  19. #include "token.h"
  20. #include "newmsg.h"
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <ctype.h>
  24. #include <fcntl.h>
  25. #if HAVE_UNISTD_H
  26. #include        <unistd.h>
  27. #endif
  28. #include <sys/types.h>
  29. #include <sys/stat.h>
  31. #include "maildir/maildirmisc.h"
  33. #include "htmllibdir.h"
  35. extern char *alloc_filename(const char *, const char *, const char *);
  36. extern const char *showsize(unsigned long);
  37. extern void output_attrencoded(const char *);
  38. extern char form_args[];
  39. extern int newdraftfd;
  40. extern void newmsg_hiddenheader(const char *, const char *);
  41. extern void output_scriptptrget();
  42. extern void output_urlencoded(const char *);
  43. extern void sendmsg_done();
  45. extern char *multipart_boundary_create();
  46. extern int multipart_boundary_checkf(const char *, FILE *);
  48. extern void newmsg_create_multipart(int, const char *, const char *);
  49. extern void newmsg_copy_nonmime_headers(FILE *);
  51. extern const char *sqwebmail_content_charset;
  53. static void attachment_showname(const char *);
  55. static off_t max_attach = MAXMSGSIZE;
  57. void attachments_head(const char *folder, const char *pos, const char *draft)
  58. {
  59. char *filename;
  60. FILE *fp;
  61. struct rfc2045 *rfcp;
  62. int cnt=0;
  63. struct rfc2045 *q;
  64. int foundtextplain=0;
  65. char *noattach_lab=strtok(form_args, "|");
  66. char *quotaerr=strtok(0, "|");
  67. char *limiterr=strtok(0, "|");
  68. off_t dummy;
  69. int fd2;
  71. CHECKFILENAME(draft);
  72. filename=maildir_find(DRAFTS, draft);
  73. if (!filename) return;
  75. fd2=maildir_safeopen(filename, O_RDONLY, 0);
  77. fp=0;
  78. if (fd2 >= 0)
  79. {
  80. fp=fdopen(fd2, "r");
  81. if (fp == NULL)
  82. close(fd2);
  83. }
  85. if (fp == NULL)
  86. {
  87. free(filename);
  88. return;
  89. }
  91. rfcp=rfc2045_fromfp(fp);
  92. fclose(fp);
  93. free(filename);
  95. if (strcmp(cgi("error"), "quota") == 0)
  96. {
  97. printf("%s", quotaerr);
  98. }
  100. if (strcmp(cgi("error"), "limits") == 0)
  101. {
  102. printf(limiterr, (unsigned long)(max_attach / 1024));
  103. }
  105. newmsg_hiddenheader("pos", pos);
  106. newmsg_hiddenheader("draft", draft);
  107. tokennew();
  108. printf("<table width="100%%" border=0>");
  110. for (q=rfcp ? rfcp->firstpart:0; q; q=q->next)
  111. {
  112. const char *content_type;
  113. const char *content_transfer_encoding;
  114. const char *charset;
  115. const char *name;
  116. off_t start_pos, end_pos, start_body;
  118. if (q->isdummy) continue;
  120. rfc2045_mimeinfo(q, &content_type,
  121. &content_transfer_encoding, &charset);
  122. if (!foundtextplain && strcmp(content_type,
  123. "text/plain") == 0)
  124. {
  125. foundtextplain=1;
  126. continue;
  127. }
  128. rfc2045_mimepos(q, &start_pos, &end_pos, &start_body,
  129. &dummy, &dummy);
  131. printf("<TR><TD ALIGN=LEFT><INPUT TYPE=CHECKBOX NAME="del%d">&nbsp;",
  132. ++cnt);
  133. name=rfc2045_contentname(q);
  134. attachment_showname(name);
  135. printf("</TD><TD ALIGN=LEFT>&nbsp;&nbsp;");
  136. output_attrencoded( content_type );
  137. printf("</TD><TD ALIGN=RIGHT>%s<BR></TD></TR>",
  138. showsize(end_pos - start_body));
  139. }
  141. if (cnt == 0)
  142. printf("<TR><TD ALIGN=CENTER>%s<BR></TD></TR>n",
  143. noattach_lab);
  144. printf("</table>n");
  145. }
  147. static void attachment_showname(const char *name)
  148. {
  149. char *s;
  151. if (!name || !*name) name="[attachment]"; /* Eh??? */
  152. s=rfc2047_decode_simple(name);
  153. output_attrencoded(s ? s:name);
  154. if (s) free(s);
  155. }
  157. static void attachment_open(const char *draft,
  158. FILE **fp,
  159. int *fd2,
  160. struct rfc2045 **rfcp)
  161. {
  162. char *oldname=maildir_find(DRAFTS, draft);
  164. if (!oldname) enomem();
  166. *fd2=maildir_safeopen(oldname, O_RDONLY, 0);
  168. *fp=0;
  169. if (*fd2 >= 0)
  170. {
  171. *fp=fdopen(*fd2, "r");
  172. if (*fp == NULL)
  173. close(*fd2);
  174. }
  176. if (*fp == NULL) enomem();
  177. *rfcp=rfc2045_fromfp( *fp );
  178. if (!*rfcp) enomem();
  179. }
  181. static int messagecopy(FILE *fp, off_t start, off_t end)
  182. {
  183. char buf[512];
  184. int n;
  186. if (fseek(fp, start, SEEK_SET) == -1) return (-1);
  187. while (start < end)
  188. {
  189. n=sizeof(buf);
  190. if (n > end - start)
  191. n=end - start;
  192. n=fread(buf, 1, n, fp);
  193. if (n <= 0) enomem();
  194. maildir_writemsg(newdraftfd, buf, n);
  195. start += n;
  196. }
  197. return (0);
  198. }
  200. /* Return non-zero if user selected all attachments for deletion */
  202. static int deleting_all_attachments(struct rfc2045 *p)
  203. {
  204. struct rfc2045 *q;
  205. const char *content_type;
  206. const char *content_transfer_encoding;
  207. const char *charset;
  208. int foundtextplain, cnt;
  209. char buf[MAXLONGSIZE+4];
  211. foundtextplain=0;
  212. cnt=0;
  213. for (q=p->firstpart; q; q=q->next)
  214. {
  215. rfc2045_mimeinfo(q, &content_type,
  216. &content_transfer_encoding, &charset);
  217. if (q->isdummy) continue;
  219. if (strcmp(content_type, "text/plain") == 0 &&
  220. !foundtextplain)
  221. {
  222. foundtextplain=1;
  223. continue;
  224. }
  226. sprintf(buf, "del%d", ++cnt);
  227. if (*cgi(buf) == '') return (0);
  228. }
  229. return (1);
  230. }
  232. static int del_final_attachment(FILE *fp, struct rfc2045 *rfcp)
  233. {
  234. struct rfc2045 *q;
  235. const char *content_type;
  236. const char *content_transfer_encoding;
  237. const char *charset;
  238. off_t start_pos, end_pos, start_body;
  239. off_t dummy;
  241. for (q=rfcp->firstpart; q; q=q->next)
  242. {
  243. if (q->isdummy) continue;
  244. rfc2045_mimeinfo(q, &content_type,
  245. &content_transfer_encoding, &charset);
  246. if (strcmp(content_type, "text/plain") == 0)
  247. break;
  248. }
  249. if (!q) return (-1);
  251. if (fseek(fp, 0L, SEEK_SET) == -1) return (-1);
  252. newmsg_copy_nonmime_headers(fp);
  253. maildir_writemsgstr(newdraftfd, "mime-version: 1.0ncontent-type: text/plain; charset="");
  254. maildir_writemsgstr(newdraftfd, sqwebmail_content_charset);
  255. maildir_writemsgstr(newdraftfd, ""ncontent-transfer-encoding: ");
  256. maildir_writemsgstr(newdraftfd, content_transfer_encoding);
  257. maildir_writemsgstr(newdraftfd, "nn");
  259. rfc2045_mimepos(q, &start_pos, &end_pos, &start_body, &dummy, &dummy);
  260. return (messagecopy(fp, start_body, end_pos));
  261. }
  263. static int del_some_attachments(FILE *fp, struct rfc2045 *rfcp)
  264. {
  265. struct rfc2045 *q;
  266. const char *content_type;
  267. const char *content_transfer_encoding;
  268. const char *charset;
  269. int foundtextplain;
  270. int cnt;
  271. const char *boundary=rfc2045_boundary(rfcp);
  272. off_t start_pos, end_pos, start_body;
  273. off_t dummy;
  275. rfc2045_mimepos(rfcp, &start_pos, &end_pos, &start_body, &dummy,
  276. &dummy);
  277. if (messagecopy(fp, 0, start_body)) return (-1);
  279. foundtextplain=0;
  280. cnt=0;
  281. for (q=rfcp->firstpart; q; q=q->next)
  282. {
  283. rfc2045_mimeinfo(q, &content_type,
  284. &content_transfer_encoding, &charset);
  285. if (q->isdummy)
  286. ;
  287. else if (strcmp(content_type, "text/plain") == 0 &&
  288. !foundtextplain)
  289. foundtextplain=1;
  290. else
  291. {
  292. char buf[MAXLONGSIZE+4];
  294. sprintf(buf, "del%d", ++cnt);
  295. if (*cgi(buf)) continue; /* This one's gone */
  296. }
  298. if (!q->isdummy)
  299. {
  300. maildir_writemsgstr(newdraftfd, "n--");
  301. maildir_writemsgstr(newdraftfd, boundary);
  302. maildir_writemsgstr(newdraftfd, "n");
  303. }
  304. rfc2045_mimepos(q, &start_pos, &end_pos, &start_body, &dummy,
  305. &dummy);
  306. if (messagecopy(fp, start_pos, end_pos))
  307. return (-1);
  308. }
  309. maildir_writemsgstr(newdraftfd, "n--");
  310. maildir_writemsgstr(newdraftfd, boundary);
  311. maildir_writemsgstr(newdraftfd, "--n");
  312. return (0);
  313. }
  315. static void deleteattach(const char *folder, const char *draft)
  316. {
  317. FILE *fp;
  318. int fd2;
  319. struct rfc2045 *rfcp;
  320. char *draftfilename;
  321. int isok=1;
  322. struct stat stat_buf;
  324. attachment_open(draft, &fp, &fd2, &rfcp);
  325. if (!rfcp->firstpart)
  326. {
  327. rfc2045_free(rfcp);
  328. fclose(fp);
  329. return; /* No attachments to delete */
  330. }
  332. if (fstat(fileno(fp), &stat_buf))
  333. {
  334. fclose(fp);
  335. enomem();
  336. }
  338. newdraftfd=maildir_recreatemsg(DRAFTS, draft, &draftfilename);
  339. if (newdraftfd < 0)
  340. {
  341. fclose(fp);
  342. enomem();
  343. }
  345. if (deleting_all_attachments(rfcp))
  346. {
  347. /* Deleting all attachments */
  349. if (del_final_attachment(fp, rfcp)) isok=0;
  350. }
  351. else
  352. {
  353. if (del_some_attachments(fp, rfcp)) isok=0;
  354. }
  355. fclose(fp);
  356. rfc2045_free(rfcp);
  358. if ( maildir_closemsg(newdraftfd, DRAFTS, draftfilename, isok,
  359. stat_buf.st_size))
  360. {
  361. free(draftfilename);
  362. enomem();
  363. }
  364. free(draftfilename);
  365. maildir_remcache(DRAFTS); /* Cache file invalid now */
  366. }
  368. /* ---------------------------------------------------------------------- */
  369. /* Upload an attachment */
  371. static int isbinary;
  372. static int attachfd;
  373. static const char *cgi_attachname, *cgi_attachfilename;
  375. static int upload_start(const char *name, const char *filename)
  376. {
  377. const char *p;
  379. p=strrchr(filename, '/');
  380. if (p) filename=p+1;
  382. p=strrchr(filename, '\');
  383. if (p) filename=p+1;
  385. cgi_attachname=name;
  386. cgi_attachfilename=filename;
  387. isbinary=0;
  388. return (0);
  389. }
  391. static int upload_file(const char *ptr, size_t cnt, void *voidptr)
  392. {
  393. size_t i;
  395. for (i=0; i<cnt; i++)
  396. if ( (ptr[i] < ' ' || ptr[i] >= 127) && ptr[i] != 'n' &&
  397. ptr[i] != 'r')
  398. isbinary=1;
  399. maildir_writemsg(attachfd, ptr, cnt);
  400. return (0);
  401. }
  403. static void upload_end()
  404. {
  405. }
  407. static void writebase64encode(const char *p, size_t n)
  408. {
  409. maildir_writemsg(newdraftfd, p, n);
  410. }
  412. static const char *search_mime_type(const char *mimetype, const char *filename)
  413. {
  414. FILE *fp;
  415. char *p, *q;
  417. if (!filename || !(filename=strrchr(filename, '.'))) return (0);
  418. ++filename;
  420. if ((fp=fopen(mimetype, "r")) == NULL) return(0);
  421. while ((p=maildir_readline(fp)) != NULL)
  422. {
  423. if ((q=strchr(p, '#')) != NULL) *q='';
  424. if ((p=strtok(p, " t")) == NULL) continue;
  425. while ((q=strtok(NULL, " t")) != NULL)
  426. if (strcasecmp(q, filename) == 0)
  427. {
  428. fclose(fp);
  429. return (p);
  430. }
  431. }
  432. fclose(fp);
  433. return (NULL);
  434. }
  436. static const char *calc_mime_type(const char *filename)
  437. {
  438. static const char mimetypes[]=MIMETYPES;
  439. const char *p;
  440. char *q;
  441. const char *r;
  442. char *s;
  444. p=mimetypes;
  445. if (!p) enomem();
  446. while (*p)
  447. {
  448. if (*p == ':')
  449. {
  450. ++p;
  451. continue;
  452. }
  453. q=strdup(p);
  454. if (!q) enomem();
  455. if ((s=strchr(q, ':')) != NULL) *s='';
  456. if ((r=search_mime_type(q, filename)) != 0)
  457. {
  458. free(q);
  459. return (r);
  460. }
  461. free(q);
  462. while (*p && *p != ':')
  463. p++;
  464. }
  465. return ("application/octet-stream");
  466. }
  468. static void write_disposition_param(const char *label, const char *value)
  469. {
  470. char *p, *q;
  471. const char *r;
  473.         while (value && ((r=strchr(value, ':')) || (r=strchr(value, '/'))
  474.                 || (r=strchr(value, '\'))))
  475.                 value=r+1;
  477. if (!value || !*value) return;
  478. maildir_writemsgstr(newdraftfd, "; ");
  479. maildir_writemsgstr(newdraftfd, label);
  480. maildir_writemsgstr(newdraftfd, "="");
  481. p=strdup(value);
  482. if (!p) enomem();
  483. while ((q=strchr(p, '\')) || (q=strchr(p, '"')))
  484. *q='_';
  485. maildir_writemsgstr(newdraftfd, p);
  486. maildir_writemsgstr(newdraftfd, """);
  487. free(p);
  488. }
  490. static int uploadattach(const char *draft)
  491. {
  492. char *attachfilename;
  493. char *draftfilename;
  494. FILE *draftfp;
  495. char *boundary;
  496. FILE *tempfp;
  497. struct rfc2045 *rfcp;
  498. const char *content_type;
  499. const char *content_transfer_encoding;
  500. const char *charset;
  501. off_t start_pos, end_pos, start_body;
  502. char buf[BUFSIZ];
  503. int n;
  504. struct stat stat_buf, attach_stat_buf;
  505. off_t dummy;
  506. int fd2;
  507. char *filenamemime;
  509. /* Open the file containing the draft message */
  511. draftfilename=maildir_find(DRAFTS, draft);
  512. if (!draftfilename) return (0);
  514. fd2=maildir_safeopen(draftfilename, O_RDONLY, 0);
  516. draftfp=0;
  517. if (fd2 >= 0)
  518. {
  519. draftfp=fdopen(fd2, "r");
  520. if (draftfp == NULL)
  521. close(fd2);
  522. }
  524. if (draftfp == 0)
  525. enomem();
  527. free(draftfilename);
  528. if (fstat(fileno(draftfp), &stat_buf))
  529. {
  530. fclose(draftfp);
  531. enomem();
  532. }
  534. /* Create a temporary file in tmp where we'll temporarily store the
  535. ** attachment
  536. */
  538. attachfd=maildir_createmsg(DRAFTS, "temp", &attachfilename);
  539. if (attachfd < 0)
  540. {
  541. fclose(draftfp);
  542. enomem();
  543. }
  545. if (cgi_getfiles( &upload_start, &upload_file, &upload_end, 1)
  546. || maildir_writemsg_flush(attachfd))
  547. {
  548. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  549. free(attachfilename);
  550. fclose(draftfp);
  551. close(attachfd);
  552. return (0);
  553. }
  555. if (fstat(attachfd, &attach_stat_buf) ||
  556. attach_stat_buf.st_size + stat_buf.st_size > max_attach)
  557. {
  558. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  559. maildir_deletenewmsg(attachfd, DRAFTS, attachfilename);
  560. free(attachfilename);
  561. fclose(draftfp);
  562. close(attachfd);
  563. return (-2);
  564. }
  567. /* Calculate new MIME content boundary */
  569. /* If the attachment will be encoded in base64, there's no need
  570. ** to scan it for the embedded boundary tag, since we create a
  571. ** boundary that will never occur in base64-encoded text.
  572. */
  574. boundary=0;
  575. tempfp=0;
  576. if (!isbinary)
  577. {
  578. int n=dup(attachfd);
  580. if (n < 0)
  581. {
  582. fclose(draftfp);
  583. enomem();
  584. }
  585. tempfp=fdopen(n, "r");
  586. if (tempfp == 0)
  587. {
  588. fclose(draftfp);
  589. enomem();
  590. }
  591. }
  593. do
  594. {
  595. if (boundary) free(boundary);
  596. boundary=multipart_boundary_create();
  597. } while ( multipart_boundary_checkf(boundary, draftfp) ||
  598. (tempfp && multipart_boundary_checkf(boundary,
  599. tempfp)));
  600. if (tempfp) fclose(tempfp);
  602. /* Parse existing draft for its MIME structure */
  604. rfcp=rfc2045_fromfp(draftfp);
  606. rfc2045_mimeinfo(rfcp, &content_type,
  607. &content_transfer_encoding, &charset);
  609. /* Create a new version of the draft message */
  611. newdraftfd=maildir_recreatemsg(DRAFTS, draft, &draftfilename);
  612. if (newdraftfd < 0)
  613. {
  614. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  615. fclose(draftfp);
  616. close(attachfd);
  617. enomem();
  618. }
  620. if (fseek(draftfp, 0L, SEEK_SET) < 0)
  621. {
  622. maildir_closemsg(newdraftfd, DRAFTS, draftfilename, 0, 0);
  623. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  624. fclose(draftfp);
  625. close(attachfd);
  626. enomem();
  627. }
  629. newmsg_copy_nonmime_headers(draftfp);
  631. /* Create a multipart message, 1st attachment is the existing
  632. ** contents.
  633. */
  635. newmsg_create_multipart(newdraftfd, charset, boundary);
  636. maildir_writemsgstr(newdraftfd, "--");
  637. maildir_writemsgstr(newdraftfd, boundary);
  638. maildir_writemsgstr(newdraftfd, "n");
  640. if (!rfcp->firstpart)
  641. {
  642. /* The current draft does not have attachments.  Take its
  643. ** sole contents, and write it as a text/plain attachment.
  644. */
  646. maildir_writemsgstr(newdraftfd, "Content-Type: ");
  647. maildir_writemsgstr(newdraftfd, content_type);
  648. maildir_writemsgstr(newdraftfd, "; charset="");
  649. maildir_writemsgstr(newdraftfd, sqwebmail_content_charset);
  650. maildir_writemsgstr(newdraftfd, ""nContent-Transfer-Encoding: ");
  651. maildir_writemsgstr(newdraftfd, content_transfer_encoding);
  652. maildir_writemsgstr(newdraftfd, "nn");
  653. rfc2045_mimepos(rfcp, &start_pos, &end_pos, &start_body,
  654. &dummy, &dummy);
  655. if (messagecopy(draftfp, start_body, end_pos))
  656. {
  657. maildir_closemsg(newdraftfd, DRAFTS, draftfilename,
  658. 0, 0);
  659. maildir_closemsg(attachfd, DRAFTS, attachfilename,
  660. 0, 0);
  661. fclose(draftfp);
  662. close(newdraftfd);
  663. close(attachfd);
  664. enomem();
  665. }
  667. maildir_writemsgstr(newdraftfd, "n--");
  668. maildir_writemsgstr(newdraftfd, boundary);
  669. maildir_writemsgstr(newdraftfd, "n");
  670. }
  671. else
  672. {
  673. struct rfc2045 *q;
  675. /* If the current draft already has MIME attachments,
  676. ** just copy them over to the new draft message.
  677. */
  679. for (q=rfcp->firstpart; q; q=q->next)
  680. {
  681. if (q->isdummy) continue;
  682. rfc2045_mimepos(q, &start_pos, &end_pos, &start_body,
  683. &dummy, &dummy);
  684. if (messagecopy(draftfp, start_pos, end_pos))
  685. {
  686. maildir_closemsg(newdraftfd, DRAFTS,
  687. draftfilename, 0, 0);
  688. maildir_closemsg(attachfd, DRAFTS,
  689. attachfilename, 0, 0);
  690. fclose(draftfp);
  691. close(newdraftfd);
  692. close(attachfd);
  693. enomem();
  694. }
  695. maildir_writemsgstr(newdraftfd, "n--");
  696. maildir_writemsgstr(newdraftfd, boundary);
  697. maildir_writemsgstr(newdraftfd, "n");
  698. }
  699. }
  701. filenamemime=rfc2047_encode_str(cgi_attachfilename,
  702. sqwebmail_content_charset);
  703. maildir_writemsgstr(newdraftfd, "Content-Type: ");
  704. maildir_writemsgstr(newdraftfd, calc_mime_type(cgi_attachfilename));
  705. write_disposition_param("name",
  706. filenamemime ? filenamemime:"filename.dat");
  707. maildir_writemsgstr(newdraftfd,
  708. *cgi("attach_inline") ?
  709. "nContent-Disposition: inline":
  710. "nContent-Disposition: attachment");
  711. write_disposition_param("filename",
  712. filenamemime ? filenamemime:"filename.dat");
  713. if (filenamemime)
  714. free(filenamemime);
  715. maildir_writemsgstr(newdraftfd, "n");
  717. if (lseek(attachfd, 0L, SEEK_SET) < 0)
  718. {
  719. maildir_closemsg(newdraftfd, DRAFTS, draftfilename, 0, 0);
  720. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  721. fclose(draftfp);
  722. close(newdraftfd);
  723. close(attachfd);
  724. enomem();
  725. }
  727. /* Save our new attachment */
  729. if (isbinary)
  730. {
  731. maildir_writemsgstr(newdraftfd, "Content-Transfer-Encoding: base64nn");
  732. rfc2045_base64encode_start(&writebase64encode);
  733. }
  734. else
  735. {
  736. maildir_writemsgstr(newdraftfd, "Content-Transfer-Encoding: 7bitnn");
  737. }
  739. while ((n=read(attachfd, buf, sizeof(buf))) > 0)
  740. {
  741. if (isbinary)
  742. rfc2045_base64encode(buf, n);
  743. else
  744. maildir_writemsg(newdraftfd, buf, n);
  745. }
  746. if (n < 0)
  747. {
  748. maildir_closemsg(newdraftfd, DRAFTS, draftfilename, 0, 0);
  749. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  750. fclose(draftfp);
  751. close(newdraftfd);
  752. close(attachfd);
  753. enomem();
  754. }
  755. if (isbinary)
  756. rfc2045_base64encode_end();
  757. maildir_writemsgstr(newdraftfd, "n--");
  758. maildir_writemsgstr(newdraftfd, boundary);
  759. maildir_writemsgstr(newdraftfd, "--n");
  761. /* Finish new draft message, let it replace the current one */
  763. if (maildir_closemsg(newdraftfd, DRAFTS, draftfilename, 1,
  764. stat_buf.st_size))
  765. {
  766. maildir_closemsg(attachfd, DRAFTS, attachfilename, 0, 0);
  767. free(draftfilename);
  768. maildir_deletenewmsg(attachfd, DRAFTS, attachfilename);
  769. free(attachfilename);
  770. rfc2045_free(rfcp);
  771. fclose(draftfp);
  772. close(attachfd);
  773. return (-1);
  774. }
  775. free(draftfilename);
  777. fclose(draftfp);
  779. /* Remove and delete temp attachment file */
  781. maildir_deletenewmsg(attachfd, DRAFTS, attachfilename);
  782. free(attachfilename);
  783. rfc2045_free(rfcp);
  784. return (0);
  785. }
  787. void doattach(const char *folder, const char *draft)
  788. {
  789. int quotaflag=0;
  791. CHECKFILENAME(draft);
  792. if (*cgi("dodelete"))
  793. {
  794. if (!tokencheck())
  795. {
  796. deleteattach(folder, draft);
  797. tokensave();
  798. }
  799. }
  800. else if (*cgi("upload"))
  801. {
  802. if (!tokencheck())
  803. {
  804. quotaflag=uploadattach(draft);
  805. tokensave();
  806. }
  807. }
  808. else if (*cgi("previewmsg"))
  809. {
  810. cgi_put("draft", draft);
  811. newmsg_do(folder);
  812. return;
  813. }
  814. else if (*cgi("sendmsg"))
  815. {
  816. cgi_put("draftmessage", draft);
  817. newmsg_do(folder);
  818. return;
  819. }
  820. else if (*cgi("savedraft"))
  821. {
  822. sendmsg_done();
  823. return;
  824. }
  826. if (quotaflag == -2)
  827.         {
  828.                 http_redirect_argss(
  829.                   "&form=attachments&pos=%s&draft=%s&error=limits",
  830.                   cgi("pos"), draft);
  831.         }
  832.         else
  833.         {
  834.                 http_redirect_argss(
  835.                   (quotaflag ? "&form=attachments&pos=%s&draft=%s&error=quota":
  836.                   "&form=attachments&pos=%s&draft=%s"), cgi("pos"),
  837.                   draft);
  838.         }
  839. }