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

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

WEB邮件程序

开发平台：

C/C++

rfc822.c：源码内容
  1. /*
  2. ** Copyright 1998 - 1999 Double Precision, Inc.
  3. ** See COPYING for distribution information.
  4. */
  6. /*
  7. ** $Id: rfc822.c,v 1.12 2000/02/23 02:41:19 mrsam Exp $
  8. */
  9. #include <stdio.h>
  10. #include <ctype.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include "rfc822.h"
  15. static void tokenize(const char *p, struct rfc822token *tokp, int *toklen,
  16. void (*err_func)(const char *, int))
  17. {
  18. const char *addr=p;
  19. int i=0;
  20. int inbracket=0;
  22. *toklen=0;
  23. while (*p)
  24. {
  25. if (isspace((int)(unsigned char)*p))
  26. {
  27. p++;
  28. i++;
  29. continue;
  30. }
  32. switch (*p) {
  33. int level;
  35. case '(':
  36. if (tokp)
  37. {
  38. tokp->token='(';
  39. tokp->ptr=p;
  40. tokp->len=0;
  41. }
  42. level=0;
  43. for (;;)
  44. {
  45. if (!*p)
  46. {
  47. if (err_func) (*err_func)(addr, i);
  48. if (tokp) tokp->token='"';
  49. ++*toklen;
  50. return;
  51. }
  52. if (*p == '(')
  53. ++level;
  54. if (*p == ')' && --level == 0)
  55. {
  56. p++;
  57. i++;
  58. if (tokp) tokp->len++;
  59. break;
  60. }
  61. if (*p == '\' && p[1])
  62. {
  63. p++;
  64. i++;
  65. if (tokp) tokp->len++;
  66. }
  68. i++;
  69. if (tokp) tokp->len++;
  70. p++;
  71. }
  72. if (tokp) ++tokp;
  73. ++*toklen;
  74. continue;
  76. case '"':
  77. p++;
  78. i++;
  80. if (tokp)
  81. {
  82. tokp->token='"';
  83. tokp->ptr=p;
  84. }
  85. while (*p != '"')
  86. {
  87. if (!*p)
  88. {
  89. if (err_func) (*err_func)(addr, i);
  90. ++*toklen;
  91. return;
  92. }
  93. if (*p == '\' && p[1])
  94. {
  95. if (tokp) tokp->len++;
  96. p++;
  97. i++;
  98. }
  99. if (tokp) tokp->len++;
  100. p++;
  101. i++;
  102. }
  103. ++*toklen;
  104. if (tokp) ++tokp;
  105. p++;
  106. i++;
  107. continue;
  108. case '\':
  109. case ')':
  110. if (err_func) (*err_func)(addr, i);
  111. ++p;
  112. ++i;
  113. continue;
  114. case '<':
  115. case '>':
  116. case '@':
  117. case ',':
  118. case ';':
  119. case ':':
  120. case '.':
  121. case '[':
  122. case ']':
  123. case '%':
  124. case '!':
  125. case '?':
  126. case '=':
  127. case '/':
  129. if ( (*p == '<' && inbracket) ||
  130. (*p == '>' && !inbracket))
  131. {
  132. if (err_func) (*err_func)(addr, i);
  133. ++p;
  134. ++i;
  135. continue;
  136. }
  138. if (*p == '<')
  139. inbracket=1;
  141. if (*p == '>')
  142. inbracket=0;
  144. if (tokp)
  145. {
  146. tokp->token= *p;
  147. tokp->ptr=p;
  148. tokp->len=1;
  149. ++tokp;
  150. }
  151. ++*toklen;
  153. if (*p == '<' && p[1] == '>')
  154. /* Fake a null address */
  155. {
  156. if (tokp)
  157. {
  158. tokp->token=0;
  159. tokp->ptr="";
  160. tokp->len=0;
  161. ++tokp;
  162. }
  163. ++*toklen;
  164. }
  165. ++p;
  166. ++i;
  167. continue;
  168. default:
  170. if (tokp)
  171. {
  172. tokp->token=0;
  173. tokp->ptr=p;
  174. tokp->len=0;
  175. }
  176. while (*p && !isspace((int)(unsigned char)*p) && strchr(
  177. "<>@,;:.[]()%!"\?=/", *p) == 0)
  178. {
  179. if (tokp) ++tokp->len;
  180. ++p;
  181. ++i;
  182. }
  183. if (i == 0) /* Idiot check */
  184. {
  185. if (err_func) (*err_func)(addr, i);
  186. if (tokp)
  187. {
  188. tokp->token='"';
  189. tokp->ptr=p;
  190. tokp->len=1;
  191. ++tokp;
  192. }
  193. ++*toklen;
  194. ++p;
  195. ++i;
  196. continue;
  197. }
  198. if (tokp) ++tokp;
  199. ++*toklen;
  200. }
  201. }
  202. }
  204. static void parseaddr(struct rfc822token *tokens, int ntokens,
  205. struct rfc822addr *addrs, int *naddrs)
  206. {
  207. int flag, j, k;
  208. struct rfc822token save_token;
  210. *naddrs=0;
  212. while (ntokens)
  213. {
  214. int i;
  216. /* atoms (token=0) or quoted strings, followed by a : token
  217. is a list name. */
  219. for (i=0; i<ntokens; i++)
  220. if (tokens[i].token && tokens[i].token != '"')
  221. break;
  222. if (i < ntokens && tokens[i].token == ':')
  223. {
  224. ++i;
  225. if (addrs)
  226. {
  227. addrs->tokens=0;
  228. addrs->name=i ? tokens:0;
  229. for (j=1; j<i; j++)
  230. addrs->name[j-1].next=addrs->name+j;
  231. if (i)
  232. addrs->name[i-1].next=0;
  233. addrs++;
  234. }
  235. ++*naddrs;
  236. tokens += i;
  237. ntokens -= i;
  238. continue;  /* Group=phrase ":" */
  239. }
  241. /* Spurious commas are skipped, ;s are recorded */
  243. if (tokens->token == ',' || tokens->token == ';')
  244. {
  245. if (tokens->token == ';')
  246. {
  247. if (addrs)
  248. {
  249. addrs->tokens=0;
  250. addrs->name=tokens;
  251. addrs->name->next=0;
  252. addrs++;
  253. }
  254. ++*naddrs;
  255. }
  256. ++tokens;
  257. --ntokens;
  258. continue;
  259. }
  261. /* If we can find a '<' before the next comma or semicolon,
  262. we have new style RFC path address */
  264. for (i=0; i<ntokens && tokens[i].token != ';' &&
  265. tokens[i].token != ',' &&
  266. tokens[i].token != '<'; i++)
  267. ;
  269. if (i < ntokens && tokens[i].token == '<')
  270. {
  271. int j;
  273. /* Ok -- what to do with the stuff before '>'???
  274. If it consists exclusively of atoms, leave them alone.
  275. Else, make them all a quoted string. */
  277. for (j=0; j<i && (tokens[j].token == 0 ||
  278. tokens[j].token == '('); j++)
  279. ;
  281. if (j == i)
  282. {
  283. if (addrs)
  284. {
  285. addrs->name= i ? tokens:0;
  286. for (k=1; k<i; k++)
  287. addrs->name[k-1].next=addrs->name+k;
  288. if (i)
  289. addrs->name[i-1].next=0;
  290. }
  291. }
  292. else /* Intentionally corrupt the original toks */
  293. {
  294. if (addrs)
  295. {
  296. tokens->len= tokens[i-1].ptr
  297. + tokens[i-1].len
  298. - tokens->ptr;
  299. /* We know that all the ptrs point
  300. to parts of the same string. */
  301. tokens->token='"';
  302. /* Quoted string. */
  303. addrs->name=tokens;
  304. addrs->name->next=0;
  305. }
  306. }
  308. /* Any comments in the name part are changed to quotes */
  310. if (addrs)
  311. {
  312. struct rfc822token *t;
  314. for (t=addrs->name; t; t=t->next)
  315. if (t->token == '(')
  316. t->token='"';
  317. }
  319. /* Now that's done and over with, see what can
  320. be done with the <...> part. */
  322. ++i;
  323. tokens += i;
  324. ntokens -= i;
  325. for (i=0; i<ntokens && tokens[i].token != '>'; i++)
  326. ;
  327. if (addrs)
  328. {
  329. addrs->tokens=i ? tokens:0;
  330. for (k=1; k<i; k++)
  331. addrs->tokens[k-1].next=addrs->tokens+k;
  332. if (i)
  333. addrs->tokens[i-1].next=0;
  334. ++addrs;
  335. }
  336. ++*naddrs;
  337. tokens += i;
  338. ntokens -= i;
  339. if (ntokens) /* Skip the '>' token */
  340. {
  341. --ntokens;
  342. ++tokens;
  343. }
  344. continue;
  345. }
  347. /* Ok - old style address.  Assume the worst */
  349. /* Try to figure out where the address ends.  It ends upon:
  350. a comma, semicolon, or two consecutive atoms. */
  352. flag=0;
  353. for (i=0; i<ntokens && tokens[i].token != ',' &&
  354. tokens[i].token != ';'; i++)
  355. {
  356. if (tokens[i].token == '(') continue;
  357. /* Ignore comments */
  358. if (tokens[i].token == 0 || tokens[i].token == '"')
  359. /* Atom */
  360. {
  361. if (flag) break;
  362. flag=1;
  363. }
  364. else flag=0;
  365. }
  366. if (i == 0) /* Must be spurious comma, or something */
  367. {
  368. ++tokens;
  369. --ntokens;
  370. continue;
  371. }
  373. if (addrs)
  374. {
  375. addrs->name=0;
  376. }
  378. /* Ok, now get rid of embedded comments in the address.
  379. Consider the last comment to be the real name */
  381. if (addrs)
  382. {
  384. save_token.ptr=0;
  385. save_token.len=0;
  387. for (j=k=0; j<i; j++)
  388. {
  389. if (tokens[j].token == '(')
  390. {
  391. save_token=tokens[j];
  392. continue;
  393. }
  394. tokens[k]=tokens[j];
  395. k++;
  396. }
  398. if (save_token.ptr)
  399. {
  400. tokens[i-1]=save_token;
  401. addrs->name=tokens+i-1;
  402. addrs->name->next=0;
  403. }
  404. addrs->tokens=k ? tokens:NULL;
  405. for (j=1; j<k; j++)
  406. addrs->tokens[j-1].next=addrs->tokens+j;
  407. if (k)
  408. addrs->tokens[k-1].next=0;
  409. ++addrs;
  410. }
  411. ++*naddrs;
  412. tokens += i;
  413. ntokens -= i;
  414. }
  415. }
  417. static void print_token(const struct rfc822token *token,
  418. void (*print_func)(char, void *), void *ptr)
  419. {
  420. const char *p;
  421. int n;
  423. if (token->token == 0 || token->token == '(')
  424. {
  425. for (n=token->len, p=token->ptr; n; --n, ++p)
  426. (*print_func)(*p, ptr);
  427. return;
  428. }
  430. if (token->token != '"')
  431. {
  432. (*print_func)(token->token, ptr);
  433. return;
  434. }
  436. (*print_func)('"', ptr);
  437. n=token->len;
  438. p=token->ptr;
  439. while (n)
  440. {
  441. if (*p == '"' || (*p == '\' && n == 1)) (*print_func)('\', ptr);
  442. if (*p == '\' && n > 1)
  443. {
  444. (*print_func)('\', ptr);
  445. ++p;
  446. --n;
  447. }
  448. (*print_func)(*p++, ptr);
  449. --n;
  450. }
  451. (*print_func)('"', ptr);
  452. }
  454. void rfc822tok_print(const struct rfc822token *token,
  455. void (*print_func)(char, void *), void *ptr)
  456. {
  457. int prev_isatom=0;
  458. int isatom;
  460. while (token)
  461. {
  462. isatom=rfc822_is_atom(token->token);
  463. if (prev_isatom && isatom)
  464. (*print_func)(' ', ptr);
  465. print_token(token, print_func, ptr);
  466. prev_isatom=isatom;
  467. token=token->next;
  468. }
  469. }
  471. void rfc822_print(const struct rfc822a *rfcp, void (*print_func)(char, void *),
  472. void (*print_separator)(const char *s, void *), void *ptr)
  473. {
  474. rfc822_print_common(rfcp, 0, 0, print_func, print_separator, ptr);
  475. }
  477. void rfc822_print_common(const struct rfc822a *rfcp,
  478. char *(*decode_func)(const char *, const char *), const char *chset,
  479. void (*print_func)(char, void *),
  480. void (*print_separator)(const char *, void *), void *ptr)
  481. {
  482. const struct rfc822addr *addrs=rfcp->addrs;
  483. int naddrs=rfcp->naddrs;
  485. while (naddrs)
  486. {
  487. if (addrs->tokens == 0)
  488. {
  489. rfc822tok_print(addrs->name, print_func, ptr);
  490. ++addrs;
  491. --naddrs;
  492. if (addrs[-1].name && naddrs)
  493. {
  494. struct rfc822token *t;
  496. for (t=addrs[-1].name; t && t->next; t=t->next)
  497. ;
  499. if (t && (t->token == ':' || t->token == ';'))
  500. (*print_separator)(" ", ptr);
  501. }
  502. continue;
  503. }
  504. else if (addrs->name && addrs->name->token == '(')
  505. { /* old style */
  506. char *p;
  508. rfc822tok_print(addrs->tokens, print_func, ptr);
  509. (*print_func)(' ', ptr);
  511. if (decode_func && (p=rfc822_gettok(addrs->name))!=0)
  512. {
  513. char *q= (*decode_func)(p, chset);
  514. char *r;
  516. for (r=q; r && *r; r++)
  517. (*print_func)( (int)(unsigned char)*r,
  518. ptr);
  519. if (q) free(q);
  520. free(p);
  521. }
  522. else rfc822tok_print(addrs->name, print_func, ptr);
  523. }
  524. else
  525. {
  526. int print_braces=0;
  527. char *p;
  529. if (addrs->name)
  530. {
  531. if (decode_func &&
  532. (p=rfc822_gettok(addrs->name)) != 0)
  533. {
  534. char *q= (*decode_func)(p, chset);
  535. char *r;
  537. for (r=q; r && *r; r++)
  538. (*print_func)(
  539. (int)(unsigned char)*r,
  540. ptr);
  541. if (q) free(q);
  542. free(p);
  543. }
  544. else rfc822tok_print(addrs->name,
  545. print_func, ptr);
  546. (*print_func)(' ', ptr);
  547. print_braces=1;
  548. }
  549. else
  550. {
  551. struct rfc822token *p;
  553. for (p=addrs->tokens; p && p->next; p=p->next)
  554. if (rfc822_is_atom(p->token) &&
  555. rfc822_is_atom(p->next->token))
  556. print_braces=1;
  557. }
  558. if (print_braces)
  559. (*print_func)('<', ptr);
  560. rfc822tok_print(addrs->tokens, print_func, ptr);
  561. if (print_braces)
  562. {
  563. (*print_func)('>', ptr);
  564. }
  565. }
  566. ++addrs;
  567. --naddrs;
  568. if (naddrs)
  569. if (addrs->tokens || (addrs->name &&
  570. rfc822_is_atom(addrs->name->token)))
  571. (*print_separator)(", ", ptr);
  572. }
  573. }
  575. void rfc822t_free(struct rfc822t *p)
  576. {
  577. if (p->tokens) free(p->tokens);
  578. free(p);
  579. }
  581. void rfc822a_free(struct rfc822a *p)
  582. {
  583. if (p->addrs) free(p->addrs);
  584. free(p);
  585. }
  587. void rfc822_deladdr(struct rfc822a *rfcp, int index)
  588. {
  589. int i;
  591. if (index < 0 || index >= rfcp->naddrs) return;
  593. for (i=index+1; i<rfcp->naddrs; i++)
  594. rfcp->addrs[i-1]=rfcp->addrs[i];
  595. if (--rfcp->naddrs == 0)
  596. {
  597. free(rfcp->addrs);
  598. rfcp->addrs=0;
  599. }
  600. }
  602. struct rfc822t *rfc822t_alloc(const char *addr,
  603. void (*err_func)(const char *, int))
  604. {
  605. struct rfc822t *p=(struct rfc822t *)malloc(sizeof(struct rfc822t));
  607. if (!p) return (NULL);
  608. memset(p, 0, sizeof(*p));
  610. tokenize(addr, NULL, &p->ntokens, err_func);
  611. p->tokens=p->ntokens ? (struct rfc822token *)
  612. calloc(p->ntokens, sizeof(struct rfc822token)):0;
  613. if (p->ntokens && !p->tokens)
  614. {
  615. rfc822t_free(p);
  616. return (NULL);
  617. }
  618. tokenize(addr, p->tokens, &p->ntokens, NULL);
  619. return (p);
  620. }
  622. struct rfc822a *rfc822a_alloc(struct rfc822t *t)
  623. {
  624. struct rfc822a *p=(struct rfc822a *)malloc(sizeof(struct rfc822a));
  626. if (!p) return (NULL);
  627. memset(p, 0, sizeof(*p));
  629. parseaddr(t->tokens, t->ntokens, NULL, &p->naddrs);
  630. p->addrs=p->naddrs ? (struct rfc822addr *)
  631. calloc(p->naddrs, sizeof(struct rfc822addr)):0;
  632. if (p->naddrs && !p->addrs)
  633. {
  634. rfc822a_free(p);
  635. return (NULL);
  636. }
  637. parseaddr(t->tokens, t->ntokens, p->addrs, &p->naddrs);
  638. return (p);
  639. }
  641. void rfc822_praddr(const struct rfc822a *rfcp, int index,
  642. void (*print_func)(char, void *), void *ptr)
  643. {
  644. const struct rfc822addr *addrs;
  646. if (index < 0 || index >= rfcp->naddrs) return;
  648. addrs=rfcp->addrs+index;
  649. if (addrs->tokens)
  650. {
  651. rfc822tok_print(addrs->tokens, print_func, ptr);
  652. (*print_func)('n', ptr);
  653. }
  654. }
  656. void rfc822_addrlist(const struct rfc822a *rfcp,
  657. void (*print_func)(char, void *), void *ptr)
  658. {
  659. int i;
  661. for (i=0; i<rfcp->naddrs; i++)
  662. rfc822_praddr(rfcp, i, print_func, ptr);
  663. }
  665. void rfc822_prname(const struct rfc822a *rfcp, int index,
  666. void (*print_func)(char, void *), void *ptr)
  667. {
  668. const struct rfc822addr *addrs;
  670. if (index < 0 || index >= rfcp->naddrs) return;
  672. addrs=rfcp->addrs+index;
  674. if (!addrs->tokens) return;
  676. if (addrs->name)
  677. {
  678. struct rfc822token *i;
  679. int n;
  680. int prev_isatom=0;
  681. int isatom=0;
  683. for (i=addrs->name; i; i=i->next, prev_isatom=isatom)
  684. {
  685. isatom=rfc822_is_atom(i->token);
  686. if (isatom && prev_isatom)
  687. (*print_func)(' ', ptr);
  689. if (i->token != '(')
  690. {
  691. print_token(i, print_func, ptr);
  692. continue;
  693. }
  695. for (n=2; n<i->len; n++)
  696. (*print_func)(i->ptr[n-1], ptr);
  697. }
  698. } else
  699. rfc822tok_print(addrs->tokens, print_func, ptr);
  700. (*print_func)('n', ptr);
  701. }
  703. void rfc822_namelist(const struct rfc822a *rfcp,
  704. void (*print_func)(char, void *), void *ptr)
  705. {
  706. int i;
  708. for (i=0; i<rfcp->naddrs; i++)
  709. rfc822_prname(rfcp, i, print_func, ptr);
  710. }