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

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

WEB邮件程序

开发平台：

C/C++

reformime.c：源码内容
  1. /*
  2. ** Copyright 1998 - 2000 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  6. #if HAVE_CONFIG_H
  7. #include "config.h"
  8. #endif
  9. #include <sys/types.h>
  10. #include <sys/stat.h>
  11. #include <time.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #if HAVE_STRINGS_H
  15. #include <strings.h>
  16. #endif
  17. #include <stdlib.h>
  18. #include <ctype.h>
  19. #include <pwd.h>
  20. #include <fcntl.h>
  21. #include <signal.h>
  22. #include "rfc2045.h"
  23. #include "rfc2045charset.h"
  24. #if HAVE_UNISTD_H
  25. #include <unistd.h>
  26. #endif
  27. #if HAVE_SYS_WAIT_H
  28. #include <sys/wait.h>
  29. #endif
  30. #include "numlib/numlib.h"
  32. #if     HAS_GETHOSTNAME
  33. #else
  34. int gethostname(const char *, size_t);
  35. #endif
  38. static const char rcsid[]="$Id: reformime.c,v 1.23 2000/05/23 17:55:02 mrsam Exp $";
  40. void rfc2045_error(const char *errmsg)
  41. {
  42. fprintf(stderr, "reformime: %sn", errmsg);
  43. exit(1);
  44. }
  46. static void do_print_structure(struct rfc2045 *p, struct rfc2045id *id, void *ptr)
  47. {
  48. p=p;
  49. ptr=p;
  51. while (id)
  52. {
  53. printf("%d%c", id->idnum, id->next ? '.':'n');
  54. id=id->next;
  55. }
  56. }
  58. static int decode_to_file(const char *p, size_t n, void *ptr)
  59. {
  60. FILE *fp=(FILE *)ptr;
  62. while (n)
  63. {
  64. --n;
  65. if (putc(*p++, fp) == -1)
  66. {
  67. perror("write");
  68. exit(1);
  69. }
  70. }
  71. return (0);
  72. }
  74. void usage()
  75. {
  76. fprintf(stderr, "Usage: reformime [options]n");
  77. fprintf(stderr, "    -d - parse a delivery status notification.n");
  78. fprintf(stderr, "    -e - extract contents of MIME section.n");
  79. fprintf(stderr, "    -x - extract MIME section to a file.n");
  80. fprintf(stderr, "    -X - pipe MIME section to a program.n");
  81. fprintf(stderr, "    -i - show MIME info.n");
  82. fprintf(stderr, "    -s n.n.n.n - specify MIME section.n");
  83. fprintf(stderr, "    -r - rewrite message, filling in missing MIME header.n");
  84. fprintf(stderr, "    -r7 - also convert 8bit/raw encoding to quoted-printable, if possible.n");
  85. fprintf(stderr, "    -r8 - also convert quoted-printable encoding to 8bit, if possible.n");
  86. fprintf(stderr, "    -c charset - when rewriting, specify default charset.n");
  87. fprintf(stderr, "    -m [file] [file]... - create a MIME message digest.n");
  88. exit(1);
  89. }
  91. static char *tempname(const char *tempdir)
  92. {
  93. char pidbuf[NUMBUFSIZE], timebuf[NUMBUFSIZE], hostnamebuf[256];
  94. time_t t;
  95. char *p;
  97. str_pid_t(getpid(), pidbuf);
  98. time(&t);
  99. str_time_t(t, timebuf);
  100. hostnamebuf[sizeof(hostnamebuf)-1]=0;
  101. if (gethostname(hostnamebuf, sizeof(hostnamebuf)))
  102. hostnamebuf[0]=0;
  103. p=malloc(strlen(tempdir)+strlen(pidbuf)+strlen(timebuf)+
  104. strlen(hostnamebuf)+4);
  105. if (!p) return (0);
  106. sprintf(p, "%s/%s.%s.%s", tempdir, timebuf, pidbuf, hostnamebuf);
  107. return (p);
  108. }
  110. struct rfc2045 *read_message()
  111. {
  112. char buf[BUFSIZ];
  113. struct rfc2045 *p=rfc2045_alloc_ac();
  114. int tempfd= -1;
  116. if (fseek(stdin, 0L, SEEK_END) < 0 ||
  117. fseek(stdin, 0L, SEEK_SET) < 0) /* Pipe, save to temp file */
  118. {
  119. struct passwd *p;
  120. char *tmpdir, *tmpfilename;
  122. /* Create temp file in $HOME/.tmp */
  124. p=getpwuid(getuid());
  125. if (!p)
  126. {
  127. fprintf(stderr, "reformime: unable to read your home directory.n");
  128. exit(1);
  129. }
  130. tmpdir=malloc(strlen(p->pw_dir)+6);
  131. if (!tmpdir ||
  132. !(tmpfilename=tempname(strcat(strcpy(tmpdir,
  133. p->pw_dir), "/.tmp"))))
  134. {
  135. perror("malloc");
  136. exit(1);
  137. }
  138. mkdir(tmpdir, 0700);
  139. if ((tempfd=open(tmpfilename, O_RDWR|O_CREAT, 0600)) < 0)
  140. {
  141. perror("open");
  142. }
  143. unlink(tmpfilename);
  144. free(tmpdir);
  145. free(tmpfilename);
  146. }
  148. while (fgets(buf, sizeof(buf), stdin))
  149. {
  150. rfc2045_parse(p, buf, strlen(buf));
  151. if (tempfd >= 0)
  152. {
  153. const char *p=buf;
  154. size_t l=strlen(p);
  156. while (l)
  157. {
  158. int n=write(tempfd, p, l);
  160. if (n <= 0)
  161. {
  162. perror("write");
  163. exit(1);
  164. }
  165. p += n;
  166. l -= n;
  167. }
  168. }
  169. }
  170. if (tempfd >= 0)
  171. {
  172. close(0);
  173. dup(tempfd);
  174. close(tempfd);
  175. }
  176. return (p);
  177. }
  179. void print_structure(struct rfc2045 *p)
  180. {
  181. rfc2045_decode(p, &do_print_structure, 0);
  182. }
  184. static void notfound(const char *p)
  185. {
  186. fprintf(stderr, "reformime: MIME section %s not found.n", p);
  187. exit(1);
  188. }
  190. static void do_print_info(struct rfc2045 *s)
  191. {
  192. const char *content_type, *transfer_encoding, *charset;
  193. off_t start, end, body;
  194. const char *disposition;
  195. const char *disposition_name;
  196. const char *disposition_filename;
  197. const char *content_name;
  198. off_t nlines, nbodylines;
  199. const char *p;
  201. rfc2045_mimeinfo(s, &content_type, &transfer_encoding, &charset);
  202. rfc2045_mimepos(s, &start, &end, &body, &nlines, &nbodylines);
  203. rfc2045_dispositioninfo(s, &disposition, &disposition_name,
  204. &disposition_filename);
  205. content_name=rfc2045_contentname(s);
  206. printf("content-type: %sn", content_type);
  207. if (content_name)
  208. printf("content-name: %sn", content_name);
  209. printf("content-transfer-encoding: %sn", transfer_encoding);
  210. printf("charset: %sn", charset);
  211. if (disposition && *disposition)
  212. printf("content-disposition: %sn", disposition);
  213. if (disposition_name && *disposition_name)
  214. printf("content-disposition-name: %sn", disposition_name);
  215. if (disposition_filename && *disposition_filename)
  216. printf("content-disposition-filename: %sn",
  217. disposition_filename);
  218. if (*(p=rfc2045_content_id(s)))
  219. printf("content-id: <%s>n", p);
  220. if (*(p=rfc2045_content_description(s)))
  221. printf("content-description: %sn", p);
  222. if (*(p=rfc2045_content_language(s)))
  223. printf("content-language: %sn", p);
  224. if (*(p=rfc2045_content_md5(s)))
  225. printf("content-md5: %sn", p);
  227. printf("starting-pos: %lun", (unsigned long)start);
  228. printf("starting-pos-body: %lun", (unsigned long)body);
  229. printf("ending-pos: %lun", (unsigned long)end);
  230. printf("line-count: %lun", (unsigned long)nlines);
  231. printf("body-line-count: %lun", (unsigned long)nbodylines);
  232. }
  234. static void do_print_info_multiple(struct rfc2045 *p, struct rfc2045id *id,
  235. void *ptr)
  236. {
  237. printf("section: ");
  238. do_print_structure(p, id, ptr);
  239. do_print_info(p);
  240. printf("n");
  241. }
  243. void print_info(struct rfc2045 *p, const char *mimesection)
  244. {
  245. struct rfc2045 *s;
  247. if (mimesection)
  248. {
  249. s=rfc2045_find(p, mimesection);
  250. if (!s)
  251. notfound(mimesection);
  252. printf("section: %sn", mimesection);
  253. do_print_info(s);
  254. return;
  255. }
  256. rfc2045_decode(p, &do_print_info_multiple, 0);
  257. }
  259. static void do_print_section(struct rfc2045 *s, FILE *fp)
  260. {
  261. off_t start, end, body;
  262. off_t nlines;
  263. off_t nbodylines;
  265. rfc2045_mimepos(s, &start, &end, &body, &nlines, &nbodylines);
  267. if (fseek(stdin, body, SEEK_SET) == -1)
  268. {
  269. perror("fseek");
  270. exit(1);
  271. }
  273. rfc2045_cdecode_start(s, &decode_to_file, fp);
  274. while (body < end)
  275. {
  276. char buf[BUFSIZ];
  277. size_t n=sizeof(buf);
  279. if ((off_t)n > end-body) n=end-body;
  280. n=fread(buf, 1, n, stdin);
  281. if (n == 0)
  282. {
  283. perror("fread");
  284. exit(1);
  285. }
  286. rfc2045_cdecode(s, buf, n);
  287. body += n;
  288. }
  289. rfc2045_cdecode_end(s);
  290. }
  292. void print_decode(struct rfc2045 *p, const char *mimesection)
  293. {
  294. struct rfc2045 *s;
  296. if (!mimesection)
  297. usage();
  299. s=rfc2045_find(p, mimesection);
  300. if (!s)
  301. notfound(mimesection);
  303. do_print_section(s, stdout);
  304. }
  306. void rewrite(struct rfc2045 *p, int rwmode)
  307. {
  308. rfc2045_ac_check(p, rwmode);
  309. if (rfc2045_rewrite(p, fileno(stdin), fileno(stdout),
  310. "reformime (" RFC2045PKG " " RFC2045VER ")"))
  311. {
  312. perror("reformime");
  313. exit(1);
  314. }
  315. }
  317. static char *get_suitable_filename(struct rfc2045 *r, const char *pfix)
  318. {
  319. const char *disposition_s;
  320. const char *disposition_name_s;
  321. const char *disposition_filename_s;
  322. const char *content_name_s;
  323. char *p, *q;
  324. char *dyn_disp_name=0;
  326. rfc2045_dispositioninfo(r, &disposition_s, &disposition_name_s,
  327. &disposition_filename_s);
  329. content_name_s=rfc2045_contentname(r);
  331. if (!disposition_filename_s || !*disposition_filename_s)
  332. disposition_filename_s=disposition_name_s;
  333. if (!disposition_filename_s || !*disposition_filename_s)
  334. disposition_filename_s=content_name_s;
  336. if (!disposition_filename_s || !*disposition_filename_s)
  337. {
  338. dyn_disp_name=tempname(".");
  339. disposition_filename_s=dyn_disp_name+2; /* Skip over ./ */
  340. }
  342. p=malloc((pfix ? strlen(pfix):0)+strlen(disposition_filename_s)+1);
  343. if (!p)
  344. {
  345. perror("malloc");
  346. exit(1);
  347. }
  348. *p=0;
  349. if (pfix) strcpy(p, pfix);
  350. q=p+strlen(p);
  351. for (strcpy(q, disposition_filename_s); *q; q++)
  352. if (!isalnum(*q) && *q != '.' && *q != '-')
  353. *q='_';
  355. if (dyn_disp_name) free(dyn_disp_name);
  357. if (!pfix)
  358. {
  359.         const char *content_type_s;
  360.         const char *content_transfer_encoding_s;
  361.         const char *charset_s;
  362. int c;
  363. static char filenamebuf[256];
  364. char *t;
  365. FILE *tty;
  367. if ((tty=fopen("/dev/tty", "r+")) == 0)
  368. {
  369. perror("/dev/tty");
  370. exit(1);
  371. }
  373. rfc2045_mimeinfo(r, &content_type_s,
  374. &content_transfer_encoding_s, &charset_s);
  376. fprintf (tty, "Extract %s? ", content_type_s);
  377. fflush(tty);
  378. c=getc(tty);
  379. if (c != 'n' && c != EOF)
  380. {
  381. int cc;
  383. while ((cc=getc(tty)) != 'n' && cc != EOF)
  384. ;
  385. }
  386. if (c != 'y' && c != 'Y')
  387. {
  388. free(p);
  389. fclose(tty);
  390. return (0);
  391. }
  392. fprintf (tty, "Filename [%s]: ", p);
  393. fgets(filenamebuf, sizeof(filenamebuf)-1, tty);
  394. fclose(tty);
  395. t=strchr(filenamebuf, 'n');
  396. if (t) *t=0;
  397. else
  398. {
  399. fprintf(stderr, "Filename too long.n");
  400. exit(1);
  401. }
  402. if (filenamebuf[0])
  403. {
  404. free(p);
  405. p=strdup(filenamebuf);
  406. if (!p)
  407. {
  408. perror("malloc");
  409. exit(1);
  410. }
  411. }
  412. }
  413. return (p);
  414. }
  416. static void extract_file(struct rfc2045 *p,
  417. const char *filename, int argc, char **argv)
  418. {
  419. char *f=get_suitable_filename(p, filename);
  420. FILE *fp;
  422. if (!f) return;
  424. if ((fp=fopen(f, "w")) == 0)
  425. {
  426. perror(f);
  427. exit(1);
  428. }
  430. do_print_section(p, fp);
  431. if (fflush(fp) || ferror(fp))
  432. {
  433. perror("write");
  434. exit(1);
  435. }
  436. fclose(fp);
  437. free(f);
  438. }
  440. static void extract_pipe(struct rfc2045 *p,
  441. const char *filename,
  442. int argc, char **argv)
  443. {
  444. char *f=get_suitable_filename(p, "FILENAME=");
  445. int pipefd[2];
  446. pid_t pid, p2;
  447. FILE *fp;
  448. int waitstat;
  450. if (argc == 0)
  451. {
  452. fprintf(stderr, "reformime: Invalid -X option.n");
  453. exit(1);
  454. }
  456. if (pipe(pipefd))
  457. {
  458. perror("pipe");
  459. exit(1);
  460. }
  462. if ((fp=fdopen(pipefd[1], "w")) == 0)
  463. {
  464. perror("fdopen");
  465. exit(1);
  466. }
  468. while ((pid=fork()) == -1)
  469. {
  470. sleep(2);
  471. }
  473. if (pid == 0)
  474. {
  475.         const char *content_type_s;
  476.         const char *content_transfer_encoding_s;
  477.         const char *charset_s;
  479. if (!f) f="FILENAME=attachment.dat";
  480. putenv(f);
  481. rfc2045_mimeinfo(p, &content_type_s,
  482. &content_transfer_encoding_s, &charset_s);
  483. f=malloc(strlen(content_type_s)
  484. +sizeof("CONTENT_TYPE="));
  485. if (!f)
  486. {
  487. perror("malloc");
  488. exit(1);
  489. }
  490. strcat(strcpy(f, "CONTENT_TYPE="), content_type_s);
  491. putenv(f);
  492. close(0);
  493. dup(pipefd[0]);
  494. close(pipefd[0]);
  495. close(pipefd[1]);
  496. execv(argv[0], argv);
  497. perror("exec");
  498. _exit(1);
  499. }
  500. close(pipefd[0]);
  501. signal(SIGPIPE, SIG_IGN);
  502. do_print_section(p, fp);
  503. signal(SIGPIPE, SIG_DFL);
  504. fclose(fp);
  505. close(pipefd[1]);
  507. while ((p2=wait(&waitstat)) != pid && p2 != -1)
  508. ;
  509. free(f);
  510. }
  512. static void extract_section(struct rfc2045 *top_rfcp, const char *mimesection,
  513. const char *extract_filename, int argc, char **argv,
  514. void (*extract_func)(struct rfc2045 *, const char *,
  515. int, char **))
  516. {
  517. if (mimesection)
  518. {
  519. top_rfcp=rfc2045_find(top_rfcp, mimesection);
  520. if (!mimesection)
  521. notfound(mimesection);
  522. if (top_rfcp->firstpart)
  523. {
  524. fprintf(stderr, "reformime: MIME section %s is a compound section.n", mimesection);
  525. exit(1);
  526. }
  527. (*extract_func)(top_rfcp, extract_filename, argc, argv);
  528. return;
  529. }
  531. /* Recursive */
  533. if (top_rfcp->firstpart)
  534. {
  535. for (top_rfcp=top_rfcp->firstpart; top_rfcp;
  536. top_rfcp=top_rfcp->next)
  537. extract_section(top_rfcp, mimesection,
  538. extract_filename, argc, argv, extract_func);
  539. return;
  540. }
  542. if (!top_rfcp->isdummy)
  543. (*extract_func)(top_rfcp, extract_filename, argc, argv);
  544. }
  546. static void print_dsn_recip(char *addr, char *action)
  547. {
  548. char *p, *q;
  550. if (!action || !addr)
  551. {
  552. if (action) free(action);
  553. if (addr) free(addr);
  554. return;
  555. }
  557. for (p=action; *p; ++p)
  558. *p=tolower((int)(unsigned char)*p);
  560. for (p=addr; *p && isspace((int)(unsigned char)*p); ++p)
  561. ;
  563. if (strncasecmp(p, "rfc822;", 7))
  564. {
  565. free(action);
  566. free(addr);
  567. return;
  568. }
  569. for (q=action; *q && isspace((int)(unsigned char)*q); ++q)
  570. ;
  571. p += 7;
  572. while (*p && isspace((int)(unsigned char)*p))
  573. ++p;
  574. printf("%s %sn", q, p);
  575. free(action);
  576. free(addr);
  577. }
  579. static void dsn(struct rfc2045 *p, int do_orig)
  580. {
  581. const char *content_type_s;
  582. const char *content_transfer_encoding_s;
  583. const char *charset_s;
  584. off_t start_pos, end_pos, start_body;
  585. off_t dummy;
  586. const char *q;
  587. char buf[BUFSIZ];
  588. unsigned i;
  589. int ch;
  590. char *recip;
  591. char *action;
  592. char *orecip;
  594. rfc2045_mimeinfo(p, &content_type_s, &content_transfer_encoding_s,
  595. &charset_s);
  596. if (strcasecmp(content_type_s, "multipart/report") ||
  597. (q=rfc2045_getattr(p->content_type_attr, "report-type")) == 0 ||
  598. strcasecmp(q, "delivery-status") ||
  599. !p->firstpart || !p->firstpart->next ||
  600. !p->firstpart->next->next)
  601. _exit(1);
  602. p=p->firstpart->next->next;
  603. rfc2045_mimeinfo(p, &content_type_s, &content_transfer_encoding_s,
  604. &charset_s);
  605. rfc2045_mimepos(p, &start_pos, &end_pos, &start_body, &dummy, &dummy);
  606. if (strcasecmp(content_type_s, "message/delivery-status") ||
  607. fseek(stdin, start_body, SEEK_SET) == -1)
  608. _exit(1);
  610. i=0;
  611. recip=0;
  612. orecip=0;
  613. action=0;
  614. while (start_body < end_pos)
  615. {
  616. if ((ch=getchar()) == EOF) break;
  617. ++start_body;
  618. if (i < sizeof(buf)-1)
  619. buf[i++]= ch;
  620. if (ch != 'n') continue;
  621. ch=getchar();
  622. if (ch != EOF) ungetc(ch, stdin);
  623. if (ch != 'n' && isspace((int)(unsigned char)ch))
  624. continue;
  625. buf[i-1]=0;
  626. if (buf[0] == 0)
  627. {
  628. if (orecip)
  629. {
  630. if (recip) free(recip);
  631. recip=orecip;
  632. orecip=0;
  633. }
  634. print_dsn_recip(recip, action);
  635. recip=0;
  636. action=0;
  637. }
  638. if (strncasecmp(buf, "Final-Recipient:", 16) == 0 &&
  639. recip == 0)
  640. {
  641. recip=strdup(buf+16);
  642. if (!recip)
  643. {
  644. perror("strdup");
  645. exit(2);
  646. }
  647. }
  648. if (strncasecmp(buf, "Original-Recipient:", 19) == 0 &&
  649. orecip == 0 && do_orig)
  650. {
  651. orecip=strdup(buf+19);
  652. if (!orecip)
  653. {
  654. perror("strdup");
  655. exit(2);
  656. }
  657. }
  658. if (strncasecmp(buf, "Action:", 7) == 0 && action == 0)
  659. {
  660. action=strdup(buf+7);
  661. if (!action)
  662. {
  663. perror("strdup");
  664. exit(2);
  665. }
  666. }
  667. i=0;
  668. }
  669. if (orecip)
  670. {
  671. if (recip) free(recip);
  672. recip=orecip;
  673. orecip=0;
  674. }
  675. print_dsn_recip(recip, action);
  676. }
  678. static void mimedigest1(int, char **);
  679. static char mimebuf[BUFSIZ];
  681. static void mimedigest(int argc, char **argv)
  682. {
  683. char *p;
  684. struct filelist { struct filelist *next; char *fn; } *first=0, *last=0;
  685. unsigned pcnt=0;
  686. char **l;
  688. if (argc > 0)
  689. {
  690. mimedigest1(argc, argv);
  691. return;
  692. }
  694. while (fgets(mimebuf, sizeof(mimebuf), stdin))
  695. {
  696. struct filelist *q;
  698. if ((p=strchr(mimebuf, 'n')) != 0) *p=0;
  699. q=malloc(sizeof(struct filelist));
  700. if (!q || !(q->fn=strdup(mimebuf)))
  701. {
  702. perror("malloc");
  703. exit(1);
  704. }
  706. if (last) last->next=q;
  707. else first=q;
  708. last=q;
  709. q->next=0;
  710. ++pcnt;
  711. }
  712. if (pcnt == 0) return;
  714. if ( (l=malloc(sizeof (char *) * pcnt)) == 0)
  715. {
  716. perror("malloc");
  717. }
  718. pcnt=0;
  720. for (last=first; last; last=last->next)
  721. l[pcnt++]=last->fn;
  723. mimedigest1(pcnt, l);
  724. }
  726. static void mimedigest1(int argc, char **argv)
  727. {
  728. time_t t;
  729. char boundarybuf[200];
  730. unsigned boundarycnt=0;
  731. int i;
  732. FILE *fp;
  734. time (&t);
  736. /* Search for a suitable boundary */
  738. do
  739. {
  740. int l;
  742. sprintf(boundarybuf, "reformime_%lu_%u",
  743. (unsigned long)t, ++boundarycnt);
  745. l=strlen(boundarybuf);
  747. for (i=0; i<argc; i++)
  748. {
  749. int err=0;
  751. if ((fp=fopen(argv[i], "r")) == 0)
  752. {
  753. perror(argv[i]);
  754. exit(1);
  755. }
  757. while (fgets(mimebuf, sizeof(mimebuf), fp))
  758. {
  759. if (mimebuf[0] != '-' || mimebuf[1] != '-')
  760. continue;
  762. if (strncasecmp(mimebuf+2, boundarybuf, l) == 0)
  763. {
  764. err=1;
  765. break;
  766. }
  767. }
  768. fclose(fp);
  769. if (err) break;
  770. }
  771. } while (i < argc);
  773. printf("Mime-Version:1.0n"
  774. "Content-Type: multipart/digest; boundary="%s"nn%s",
  775. boundarybuf, RFC2045MIMEMSG);
  777. for (i=0; i<argc; i++)
  778. {
  779. if ((fp=fopen(argv[i], "r")) == 0)
  780. {
  781. perror(argv[i]);
  782. exit(1);
  783. }
  785. printf("n--%snContent-Type: message/rfc822nn",
  786. boundarybuf);
  788. while (fgets(mimebuf, sizeof(mimebuf), fp))
  789. printf("%s", mimebuf);
  790. fclose(fp);
  791. }
  793. printf("n--%s--n", boundarybuf);
  794. }
  796. int main(int argc, char **argv)
  797. {
  798. int argn;
  799. char optc;
  800. char *optarg;
  801. char *mimesection=0;
  802. int doinfo=0, dodecode=0, dorewrite=0, dodsn=0, domimedigest=0;
  803. struct rfc2045 *p;
  804. int rwmode=0;
  805. void (*do_extract)(struct rfc2045 *, const char *, int, char **)=0;
  806. const char *extract_filename=0;
  808. for (argn=1; argn<argc; )
  809. {
  810. if (argv[argn][0] != '-') break;
  811. optarg=0;
  812. optc=argv[argn][1];
  813. if (optc && argv[argn][2]) optarg=argv[argn]+2;
  814. ++argn;
  815. switch (optc) {
  816. case 'c':
  817. if (!optarg && argn < argc)
  818. optarg=argv[argn++];
  819. if (optarg && *optarg)
  820. rfc2045_setdefaultcharset(optarg);
  821. break;
  823. case 's':
  824. if (!optarg && argn < argc)
  825. optarg=argv[argn++];
  826. if (optarg && *optarg) mimesection=optarg;
  827. break;
  828. case 'i':
  829. doinfo=1;
  830. break;
  831. case 'e':
  832. dodecode=1;
  833. break;
  834. case 'r':
  835. dorewrite=1;
  836. if (optarg && *optarg == '7')
  837. rwmode=RFC2045_RW_7BIT;
  838. if (optarg && *optarg == '8')
  839. rwmode=RFC2045_RW_8BIT;
  840. break;
  841. case 'm':
  842. domimedigest=1;
  843. break;
  844. case 'd':
  845. dodsn=1;
  846. break;
  847. case 'D':
  848. dodsn=2;
  849. break;
  850. case 'x':
  851. do_extract=extract_file;
  852. if (optarg)
  853. extract_filename=optarg;
  854. break;
  855. case 'X':
  856. do_extract=extract_pipe;
  857. break;
  858. default:
  859. usage();
  860. }
  861. }
  863. if (domimedigest)
  864. {
  865. mimedigest(argc-argn, argv+argn);
  866. return (0);
  867. }
  869. p=read_message();
  871. if (doinfo)
  872. print_info(p, mimesection);
  873. else if (dodecode)
  874. print_decode(p, mimesection);
  875. else if (dorewrite)
  876. rewrite(p, rwmode);
  877. else if (dodsn)
  878. dsn(p, dodsn == 2);
  879. else if (do_extract)
  880. extract_section(p, mimesection, extract_filename,
  881. argc-argn, argv+argn, do_extract);
  882. else
  883. print_structure(p);
  884. rfc2045_free(p);
  885. exit(0);
  886. return (0);
  887. }