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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
pop_dropcopy.c
资源名称：qpopper2.53.tar.Z　[点击查看]
上传用户：dayuan858
上传日期：2007-01-04
资源大小：194k
文件大小：27k
源码类别：

网络编程

开发平台：

Unix_Linux

pop_dropcopy.c：源码内容
  1. /*
  2.  * Copyright (c) 1989 Regents of the University of California.
  3.  * All rights reserved.  The Berkeley software License Agreement
  4.  * specifies the terms and conditions for redistribution.
  5.  */
  7. /*
  8.  * Copyright (c) 1997 by Qualcomm Incorporated.
  9.  */
  12. /*
  13.  * When adding each line length into the size of the message and the maildrop,
  14.  * increase the character count by one for the <cr> added when sending the
  15.  * message to the mail client.  All lines sent to the client are terminated
  16.  * with a <cr><lf>.
  17.  */
  19. #include <config.h>
  21. #include <errno.h>
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include <ctype.h>
  25. #include <string.h>
  26. #include <flock.h>
  28. #if HAVE_UNISTD_H
  29. # include <unistd.h>
  30. #endif
  32. #if HAVE_SYS_UNISTD_H
  33. # include <sys/unistd.h>
  34. #endif
  36. #ifndef HAVE_INDEX
  37. #  define index(s,c) strchr(s,c)
  38. #  define rindex(s,c) strrchr(s,c)
  39. # endif
  40. #if HAVE_STRINGS_H
  41. # include <strings.h>
  42. #endif
  43. #include <sys/stat.h>
  44. #include <sys/file.h>
  45. #include <pwd.h>
  46. #include <popper.h>
  48. #include <md5.h>
  50. #ifdef MAILOCK
  51. # ifdef HAVE_MAILLOCK
  52. #  include <maillock.h>
  53. # endif
  54. # define MAILUNLOCK() mailunlock()
  55. #else 
  56. # define MAILUNLOCK()
  57. #endif
  59. #define MIN_UIDL_LENGTH 5     /* For no reason */
  60. #define MAX_UIDL_LENGTH 72    /* Including NL, Imposed by rfc1939 */
  62. /* This macro comes from Mark Crispin's c-client code */
  64. /* Validate line
  65.  * Accepts: pointer to candidate string to validate as a From header
  66.  *     return pointer to end of date/time field
  67.  *     return pointer to offset from t of time (hours of ``mmm dd hh:mm'')
  68.  *     return pointer to offset from t of time zone (if non-zero)
  69.  * Returns: t,ti,zn set if valid From string, else ti is NIL
  70.  */
  72. #define VALID(s,x,ti,zn) {
  73.   ti = 0;
  74.   if ((*s == 'F') && (s[1] == 'r') && (s[2] == 'o') && (s[3] == 'm') &&
  75.       (s[4] == ' ')) {
  76.     for (x = s + 5; *x && *x != 'n'; x++);
  77.     if (x) {
  78.       if (x - s >= 41) {
  79. for (zn = -1; x[zn] != ' '; zn--);
  80. if ((x[zn-1] == 'm') && (x[zn-2] == 'o') && (x[zn-3] == 'r') &&
  81.     (x[zn-4] == 'f') && (x[zn-5] == ' ') && (x[zn-6] == 'e') &&
  82.     (x[zn-7] == 't') && (x[zn-8] == 'o') && (x[zn-9] == 'm') &&
  83.     (x[zn-10] == 'e') && (x[zn-11] == 'r') && (x[zn-12] == ' '))
  84.   x += zn - 12;
  85.       }
  86.       if (x - s >= 27) {
  87. if (x[-5] == ' ') {
  88.   if (x[-8] == ':') zn = 0,ti = -5;
  89.   else if (x[-9] == ' ') ti = zn = -9;
  90.   else if ((x[-11] == ' ') && ((x[-10]=='+') || (x[-10]=='-')))
  91.     ti = zn = -11;
  92. }
  93. else if (x[-4] == ' ') {
  94.   if (x[-9] == ' ') zn = -4,ti = -9;
  95. }
  96. else if (x[-6] == ' ') {
  97.   if ((x[-11] == ' ') && ((x[-5] == '+') || (x[-5] == '-')))
  98.     zn = -6,ti = -11;
  99. }
  100. if (ti && !((x[ti - 3] == ':') &&
  101.     (x[ti -= ((x[ti - 6] == ':') ? 9 : 6)] == ' ') &&
  102.     (x[ti - 3] == ' ') && (x[ti - 7] == ' ') &&
  103.     (x[ti - 11] == ' '))) ti = 0;
  104.       }
  105.     }
  106.   }
  107. }
  109. /* You are not expected to understand this macro, but read the next page if
  110.  * you are not faint of heart.
  111.  *
  112.  * Known formats to the VALID macro are:
  113.  *  From user Wed Dec  2 05:53 1992
  114.  * BSD From user Wed Dec  2 05:53:22 1992
  115.  * SysV From user Wed Dec  2 05:53 PST 1992
  116.  * rn From user Wed Dec  2 05:53:22 PST 1992
  117.  * From user Wed Dec  2 05:53 -0700 1992
  118.  * From user Wed Dec  2 05:53:22 -0700 1992
  119.  * From user Wed Dec  2 05:53 1992 PST
  120.  * From user Wed Dec  2 05:53:22 1992 PST
  121.  * From user Wed Dec  2 05:53 1992 -0700
  122.  * Solaris From user Wed Dec  2 05:53:22 1992 -0700
  123.  *
  124.  * Plus all of the above with `` remote from xxx'' after it. Thank you very
  125.  * much, smail and Solaris, for making my life considerably more complicated.
  126.  */
  129. int newline = 1;
  131. /*
  132.  *  0 for not a from line
  133.  *  1 for is a from line
  134.  */
  136. /* Valid UUCP From lines:
  137.  *
  138.  * From Address [tty] date
  139.  * From [tty] date
  140.  *
  141.  * "From [tty] date" is probably valid but I'm too lazy at this
  142.  * time to add the code.
  143.  *
  144.  */
  145. int
  146. isfromline(cp)
  147. char *cp;
  148. {
  149.     int ti, zn;
  150.     char *x;
  152.     /* If the previous line was not a newline then just return */
  153.     /* From message separators are preceeded by a newline */ 
  154.     if (*cp == 'n') {
  155. newline = 1;
  156. return(0);
  157.     } else if (!newline) {
  158. return(0);
  159.     } else
  160. newline = 0;
  162.     VALID(cp, x, ti, zn);
  163.     return(ti != 0);
  164. }
  166. /* Hashing to a spool directory helps reduce the lookup time for sites
  167.  * with thousands of mail spool files.  Unix uses a linear list to
  168.  * save directory information and the following methods attempt to
  169.  * improve the performance.
  170.  *
  171.  * Method 1 - add the value of the first 4 chars mod 26 and open the
  172.  *       spool file in the directory 'a' - 'z'/user.
  173.  *       Brian Buhrow <buhrow@cats.ucsc.edu>
  174.  *
  175.  * Method 2 - Use the first 2 characters to determine which mail spool
  176.  *       to open.  Eg: /usr/spool/u/s/user.
  177.  *       Larry Schwimmer <rosebud@cyclone.stanford.edu>
  178.  *
  179.  * All these methods require that local mail delivery and client programs
  180.  * use the same algorithm.  Only one method to a customer :-)
  181.  */
  183. #if (HASH_SPOOL == 1)
  185. int
  186. genpath(p)
  187. POP *p;
  188. {
  189.     int seed = 0;
  190.     char dirchar[4];
  192.     if (!p->user || *p->user == '')
  193. return(NULL); /*bogus login name*/
  195.     /*Now, perform the hash*/
  197.     switch(strlen(p->user)) {
  198.    case 1:
  199.    seed = (p->user[0]);
  200.    break;
  201.    case 2:
  202.    seed = (p->user[0] + p->user[1]);
  203.    break;
  204.    case 3:
  205.    seed = (p->user[0] + p->user[1] + p->user[2]);
  206.    break;
  207.    case 4:
  208.    seed = (p->user[0] + p->user[1] + p->user[2]+p->user[3]);
  209.    break;
  210.    default:
  211.    seed = (p->user[0] + p->user[1] + p->user[2]+p->user[3]+p->user[4]);
  212.    break;
  213.     }
  214.     dirchar[0] = '/';
  215.     dirchar[1] = (char)((seed % 26) + 'a');
  216.     dirchar[2] = '/';
  217.     dirchar[3] = '';
  218.     strncpy(p->drop_name, POP_MAILDIR, sizeof(p->drop_name));
  219.     strncat(p->drop_name, dirchar, sizeof(p->drop_name) - strlen(p->drop_name));
  220.     strncat(p->drop_name, p->user, sizeof(p->drop_name) - strlen(p->drop_name));
  222.     return(1);
  223. }
  225. #endif
  226. #if (HASH_SPOOL == 2)
  228. int
  229. genpath(p)
  230. POP *p;
  231. {
  232.     static char pathstr[256];
  234.     if (!p->user || *p->user == '')
  235. return(NULL);
  236.     
  237.     sprintf(pathstr, "/%c/%c/%s",
  238.     *p->user, *(p->user+1) ? *(p->user+1) : *p->user, p->user);
  240.     strncpy(p->drop_name, POP_MAILDIR, sizeof(p->drop_name));
  241.     strncat(p->drop_name, pathstr, sizeof(p->drop_name) - strlen(p->drop_name));
  243.     return(1);
  244. }
  246. #endif
  247. #if (HASH_SPOOL != 1 && HASH_SPOOL != 2)
  249. int
  250. genpath(p)
  251. POP *p;
  252. {
  253.     struct passwd *pwp;
  255. #ifdef HOMEDIRMAIL
  256.     if ((pwp = getpwnam(p->user)) == NULL) {
  257. pop_log(p, POP_FAILURE, "unable to retrieve users password entry");
  258. return(-1);
  259.     }
  260.     strncpy(p->drop_name, pwp->pw_dir, sizeof(p->drop_name));
  261.     strncat(p->drop_name, "/.mail",sizeof(p->drop_name) - strlen(p->drop_name));
  262. #else
  263.     strncpy(p->drop_name, POP_MAILDIR, sizeof(p->drop_name));
  264.     strncat(p->drop_name, "/", sizeof(p->drop_name) - strlen(p->drop_name));
  265.     strncat(p->drop_name, p->user, sizeof(p->drop_name) - strlen(p->drop_name));
  266. #endif
  268.     return(1);
  269. }
  271. #endif /* HASH_SPOOL */
  274. /* Open and check the .user.pop file and gather info before copying over
  275.  * the users mailbox.
  276.  */
  277. int init_dropinfo(p)
  278. POP *p;
  279. {
  280.     MsgInfoList         *   mp;         /* Pointer to message info list */
  281.     int     msg_num; /* Current message number */
  282.     int     nchar;
  283.     int     inheader;
  284.     int     uidl_found;
  285.     int     expecting_trailer;
  286.     int     content_length, content_nchar, cont_len;
  287.     char                    buffer[MAXLINELEN]; /*  Read buffer */
  288.     MD5_CTX     mdContext;
  289.     unsigned char     digest[16];
  291. #ifdef DEBUG
  292.     if(p->debug)
  293. pop_log(p,POP_DEBUG, "Checking for old .%s.pop file", p->user);
  294. #endif
  296.     /*  Allocate memory for message information structures */
  297.     p->mlp = (MsgInfoList *)calloc((unsigned)ALLOC_MSGS,sizeof(MsgInfoList));
  298.     if (p->mlp == NULL){
  299.         return pop_msg (p,POP_FAILURE,
  300.             "Can't build message list for '%s': Out of memory", p->user);
  301.     }
  303.     p->msg_count = 0;
  304.     p->drop_size = 0;
  306. #ifdef NULLKLUDGE
  307.   /* Kludge to get around NULLs at the beginning of the mailspool */
  308.   while ((tempchar = getc(p->drop)) == 0);
  309.   ungetc(tempchar, p->drop);
  310. #endif
  312.     if (fgets(buffer, MAXMSGLINELEN, p->drop) == NULL) {
  313. #ifdef DEBUG
  314. if(p->debug)
  315.     pop_log(p,POP_DEBUG, "Old .%s.pop file not found, errno (%d)",
  316. p->user, errno);
  317. #endif
  318. return(POP_SUCCESS);
  319.     }
  321.     /* Is this an MMDF file? */
  322.     if (*buffer == MMDF_SEP_CHAR) {
  323. p->mmdf_separator = (char *)strdup(buffer);
  324.     } else if (!isfromline(buffer)) {
  325. return pop_msg (p,POP_FAILURE,
  326.   "Unable to process From lines (envelopes), change recognition modes.");
  327.     }
  329.     newline = 1;
  330.     rewind(p->drop);
  332.     inheader = 0;
  333.     msg_num = 0;
  334.     uidl_found = 0;
  335.     expecting_trailer = 0;
  336.     content_length = 0;
  337.     content_nchar = 0;
  338.     cont_len = 0;
  339.     p->msg_count = ALLOC_MSGS;
  341. #ifdef NULLKLUDGE
  342.   /* Kludge to get around NULLs at the beginning of the mailspool */
  343.   while ((tempchar = getc(p->drop)) == 0);
  344.   ungetc(tempchar, p->drop);
  345. #endif
  347.     for (mp=p->mlp - 1; fgets(buffer, MAXMSGLINELEN, p->drop);) {
  348. nchar = strlen(buffer);
  350. if ((content_nchar >= content_length) &&
  351.     (p->mmdf_separator ? !strcmp(p->mmdf_separator, buffer) :
  352.     isfromline(buffer))) {
  354.     if (expecting_trailer) {
  355. /* skip over the MMDF trailer */
  356. expecting_trailer = 0;
  357. continue;
  358.     }
  360.     MD5Init (&mdContext);
  361.     MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  363.     if (!inheader) {
  364. if (++msg_num > p->msg_count) {
  365.     p->mlp = (MsgInfoList *) realloc(p->mlp,
  366. (p->msg_count += ALLOC_MSGS) * sizeof(MsgInfoList));
  367.     if (p->mlp == NULL){
  368. p->msg_count = 0;
  369. return pop_msg (p, POP_FAILURE,
  370.     "Can't build message list for '%s': Out of memory",
  371.     p->user);
  372.     }
  373.     mp = p->mlp + msg_num - 2;
  374. }
  375. #ifdef DEBUG
  376. if(p->debug && msg_num != 1)
  377.     pop_log(p, POP_DEBUG,
  378.     "Msg %d uidl %s at offset %d is %d octets long and has %u lines.",
  379.     mp->number, mp->uidl_str, mp->offset, mp->length, mp->lines);
  380. else
  381.     pop_log(p,POP_DEBUG, "Found top of first message");
  382. #endif
  383. ++mp;
  385.     } else {
  386. pop_log(p,POP_DEBUG,
  387.     "Msg %d corrupted, ignoring previous header information.",
  388.      mp->number);
  389.     }
  390.     mp->number = msg_num;
  391.     mp->length = 0;
  392.     mp->lines = 0;
  393.     mp->body_lines = 0;
  394.     mp->offset = ftell(p->drop) - nchar;
  395.     mp->del_flag = FALSE;
  396.     mp->retr_flag = FALSE;
  397.     mp->orig_retr_state = FALSE;
  398.     mp->uidl_str = "n";
  399. #ifdef DEBUG
  400.     if(p->debug)
  401. pop_log(p,POP_DEBUG, "Msg %d being added to list", mp->number);
  402. #endif
  403.     inheader = 1;
  404.     uidl_found = 0;
  405.     content_nchar = 0;
  406.     content_length = 0;
  407.     cont_len = 0;
  408.     if (p->mmdf_separator)
  409. expecting_trailer = 1;
  410.     
  411.     continue; /* Don't count message separator in total size */
  412. }
  414. if (inheader) {
  415.     if (*buffer == 'n') {
  416. inheader = 0;
  417. content_length = cont_len;
  418. mp->body_lines = 1;  /* Count newline as the first body line */
  419. if (!uidl_found) {
  420.     char *cp;
  421.     int i;
  423.     MD5Final (digest, &mdContext);
  424.     cp = mp->uidl_str = (char *)malloc((DIG_SIZE * 2) + 2);
  426.     for (i = 0; i < DIG_SIZE; i++, cp+=2) {
  427. sprintf(cp, "%02x", digest[i]);
  428.     }
  429.     *cp++ = 'n';
  430.     *cp   = '';
  432.     mp->length += strlen("X-UIDL: ") + strlen(mp->uidl_str) + 1;
  433.     p->drop_size += strlen("X-UIDL: ") + strlen(mp->uidl_str)+1;
  435. /* New UIDs do not dirty the mailspool if NO_STATUS is set.  They
  436.    are just recalculated each time the popper is run or LMOS is
  437.    set and the mail spool is updated.
  438.  */
  439. #ifndef NO_STATUS
  440.     p->dirty = 1;
  441. #endif
  442. }
  444.     } else if (CONTENT_LENGTH && !strncmp(buffer, "Content-Length:", 15)) {
  445. cont_len = atoi(buffer + 15);
  446. MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  447. continue; /* not part of the message size */
  448.     } else if (!uidl_found && (!strncasecmp("Received:", buffer, 9) ||
  449.        !strncasecmp("Date:", buffer, 5) ||
  450.        !strncasecmp("Message-Id:",buffer, 11) ||
  451.        !strncasecmp("Subject:",buffer, 8)
  452.        )) {
  453. MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  454.     } else if (!strncasecmp("X-UIDL:", buffer, 7)) {
  455. if (!uidl_found) {
  456.     char *cp;
  457.     int len;
  459.     /* Skip over header string */
  460.     cp = &buffer[7];
  461.                     while (*cp && (*cp == ' ' || *cp == 't')) cp++;
  462.     if( (len = strlen(cp)) > MIN_UIDL_LENGTH && len < MAX_UIDL_LENGTH ) {
  463. uidl_found++;
  464. mp->uidl_str = (char *)strdup(cp);
  465. mp->length += nchar + 1;
  466. p->drop_size += nchar + 1;
  467.     }
  468. }
  469. continue;  /* Do not include this value in the message size */
  470.     } else if ((strncasecmp(buffer,"Status:",7) == 0)) {
  471. if (index(buffer, 'R') != NULL) {
  472.     mp->retr_flag = TRUE;
  473.     mp->orig_retr_state = TRUE;
  474. }
  475.     }
  476. } else {
  477.     content_nchar += nchar;
  478.     mp->body_lines++;
  479. }
  481. mp->length += nchar + 1;
  482. p->drop_size += nchar + 1;
  483. mp->lines++;
  484.     }
  486.     p->msg_count = msg_num;
  488.     return(POP_SUCCESS);
  489. }
  492. /* 
  493.  *  use to be dropinfo:   Extract information about the POP maildrop and store 
  494.  *  it for use by the other POP routines.
  495.  *
  496.  *  Now, the copy and info collection are done at the same time.
  497.  */
  499. do_drop_copy(p, mfd, dfd)
  500. int mfd, dfd;
  501. POP *p;
  502. {
  503.     char                    buffer[MAXLINELEN];     /*  Read buffer */
  504.     MsgInfoList         *   mp;                     /*  Pointer to message 
  505.                                                         info list */
  506.     int                     nchar;                  /*  Bytes written/read */
  507.     int     inheader;     /*  Header section flag */
  508.     int     uidl_found;     /*  UIDL header flag */
  509.     int     msg_num;
  510.     int     expecting_trailer;
  511.     int     content_length, content_nchar, cont_len;
  512.     MD5_CTX     mdContext;
  513.     unsigned char     digest[16];
  515.     FILE     *mail_drop;     /*  Streams for fids */
  517.     /*  Acquire a stream pointer for the maildrop */
  518.     if ( (mail_drop = fdopen(mfd,"r")) == NULL ) {
  519.         (void)close(mfd) ;
  520.         return pop_msg(p,POP_FAILURE,"Cannot assign stream for %s (%d)",
  521.             p->drop_name, errno);
  522.     }
  524.     rewind (mail_drop);
  526. #ifdef NULLKLUDGE
  527.   /* Kludge to get around NULLs at the beginning of the mailspool */
  528.   while ((tempchar = getc(p->drop)) == 0);
  529.   ungetc(tempchar, p->drop);
  530. #endif
  532.     if (fgets(buffer, MAXMSGLINELEN, mail_drop) == NULL) {
  533. return(POP_SUCCESS);
  534.     }
  536.     /* Is this an MMDF file? */
  537.     if (*buffer == MMDF_SEP_CHAR) {
  538. if (!p->mmdf_separator)
  539.     p->mmdf_separator = (char *)strdup(buffer);
  540.     } else if (!isfromline(buffer)) {
  541. return pop_msg (p,POP_FAILURE,
  542.  "Unable to process From lines (envelopes), change recognition modes.");
  543.     }
  545.     newline = 1;
  546.     rewind (mail_drop);
  548.     /*  Scan the file, loading the message information list with 
  549.         information about each message */
  551.     inheader = 0;
  552.     uidl_found = 0;
  553.     expecting_trailer = 0;
  554.     msg_num = p->msg_count;
  555.     content_length = 0;
  556.     content_nchar = 0;
  557.     cont_len = 0;
  558.     p->msg_count = (((p->msg_count - 1) / ALLOC_MSGS) + 1) * ALLOC_MSGS;
  560. #ifdef NULLKLUDGE
  561.   /* Kludge to get around NULLs at the beginning of the mailspool */
  562.   while ((tempchar = getc(p->drop)) == 0);
  563.   ungetc(tempchar, p->drop);
  564. #endif
  566.     for (mp = p->mlp + msg_num - 1; fgets(buffer,MAXMSGLINELEN,mail_drop);) {
  568. nchar = strlen(buffer);
  570. if (fputs(buffer, p->drop) == EOF) {
  571. #ifdef EDQUOT
  572.     if (errno == EDQUOT)
  573. return pop_msg (p,POP_FAILURE,
  574.     "Unable to copy mail spool file, quota exceeded (%d)",
  575. errno);
  576. #endif
  577.     return pop_msg (p,POP_FAILURE,
  578. "Unable to copy mail spool file to temp pop dropbox %s (%d)",
  579.     p->temp_drop, errno);
  580. }
  582. if ((content_nchar >= content_length) &&
  583.     (p->mmdf_separator ? !strcmp(p->mmdf_separator, buffer) :
  584.     isfromline(buffer))) {
  586.     if (expecting_trailer) {
  587. expecting_trailer = 0;
  588. continue;
  589.     }
  591.     MD5Init (&mdContext);
  592.     MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  594.     if (!inheader) {
  595. if (++msg_num > p->msg_count) {
  596.     p->mlp=(MsgInfoList *) realloc(p->mlp,
  597. (p->msg_count+=ALLOC_MSGS)*sizeof(MsgInfoList));
  598.     if (p->mlp == NULL) {
  599. (void)close (mfd);
  600. (void)close (dfd);
  601. p->msg_count = 0;
  602. return pop_msg (p,POP_FAILURE,
  603.     "Can't build message list for '%s': Out of memory",
  604. p->user);
  605.     }
  606.     mp = p->mlp + msg_num - 2;
  607. }
  608. #ifdef DEBUG
  609. if(p->debug && msg_num != 1)
  610.     pop_log(p,POP_DEBUG,
  611.     "Msg %d uidl %s at offset %d is %d octets long and has %u lines.",
  612.     mp->number,mp->uidl_str,mp->offset,mp->length,mp->lines);
  613. #endif
  614. ++mp;
  616.     } else {
  617. pop_log(p,POP_DEBUG,
  618.     "Msg %d corrupted, ignoring previous header information.",
  619.      mp->number);
  620.     }
  622.             mp->number = msg_num;
  623.             mp->length = 0;
  624.             mp->lines = 0;
  625.             mp->body_lines = 0;
  626.             mp->offset = ftell(p->drop) - nchar;
  627.             mp->del_flag = FALSE;
  628.             mp->retr_flag = FALSE;
  629.             mp->orig_retr_state = FALSE;
  630.     mp->uidl_str = "n";
  632. #ifdef DEBUG
  633.             if(p->debug)
  634.                 pop_log(p,POP_DEBUG, "Msg %d being added to list", mp->number);
  635. #endif
  636.     inheader = 1;
  637.     content_length = 0;
  638.     content_nchar = 0;
  639.     cont_len = 0;
  640.     uidl_found = 0;
  641.     if (p->mmdf_separator)
  642. expecting_trailer = 1;
  644.     continue; /* Do not include From separator in message size */
  645.         } 
  647. if (inheader) {
  648.     if (*buffer == 'n') {
  649. inheader = 0;
  650. mp->body_lines = 1;
  651. content_length = cont_len;
  653. if (!uidl_found) {
  654.     char *cp;
  655.     int  i;
  657.     MD5Final (digest, &mdContext);
  658.     cp = mp->uidl_str = (char *)malloc((DIG_SIZE * 2) + 2);
  660.     for (i = 0; i < DIG_SIZE; i++, cp+=2) {
  661. sprintf(cp, "%02x", digest[i]);
  662.     }
  663.     *cp++ = 'n';
  664.     *cp   = '';
  666.     mp->length += strlen("X-UIDL: ") + strlen(mp->uidl_str) + 1;
  667.     p->drop_size += strlen("X-UIDL: ") + strlen(mp->uidl_str)+1;
  669. /* New UIDs do not dirty the mailspool if NO_STATUS is set.  They
  670.    are just recalculated each time the popper is run or LMOS is
  671.    set and the mail spool is updated.
  672.  */
  673. #ifndef NO_STATUS
  674.     p->dirty = 1;
  675. #endif
  676. }
  678.     } else if (CONTENT_LENGTH && !strncmp(buffer, "Content-Length:", 15)) {
  679. cont_len = atoi(buffer + 15);
  680. MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  681. continue;  /* Not included in message size */
  683.     } else if (!uidl_found && (!strncasecmp("Received:", buffer, 9) ||
  684.        !strncasecmp("Date:", buffer, 5) ||
  685.        !strncasecmp("Message-Id:",buffer, 11) ||
  686.        !strncasecmp("Subject:",buffer, 8)
  687.        )) {
  688. MD5Update(&mdContext,(unsigned char *)buffer,strlen(buffer));
  689.     } else if (!strncasecmp("X-UIDL:", buffer, 7)) {
  690. if (!uidl_found) {
  691.     int len;
  692.     char *cp;
  694.     uidl_found++;
  696.     /* Skip over header */
  697.     cp = &buffer[7];
  698.                     while (*cp && (*cp == ' ' || *cp == 't')) cp++;
  699.     if( (len = strlen(cp)) > MIN_UIDL_LENGTH && len < MAX_UIDL_LENGTH ) {
  700. uidl_found++;
  701. mp->uidl_str = (char *)strdup(cp);
  702. mp->length += nchar + 1;
  703. p->drop_size += nchar + 1;
  704.     }
  705. }
  706. continue;  /* Do not include this value in the message size */
  707.     } else if (!strncasecmp(buffer,"Status:",7)) {
  708. if (index(buffer, 'R') != NULL) {
  709.     mp->retr_flag = TRUE;
  710.     mp->orig_retr_state = TRUE;
  711. }
  712.     }
  713. } else {
  714.     content_nchar += nchar;
  715.     mp->body_lines++;
  716. }
  718.         mp->length += nchar + 1;
  719.         p->drop_size += nchar + 1;
  720.         mp->lines++;
  721.     }
  723.     p->msg_count = msg_num;
  725. #ifdef DEBUG
  726.     if(p->debug && msg_num > 0) {
  727.         register    i;
  728.         for (i = 0, mp = p->mlp; i < p->msg_count; i++, mp++)
  729.             pop_log(p,POP_DEBUG,
  730.     "Msg %d uidl %s at offset %d is %d octets long and has %u lines.",
  731.     mp->number,mp->uidl_str,mp->offset,mp->length,mp->lines);
  732.     }
  733. #endif
  735.     if (fflush(p->drop) == EOF)
  736.         return pop_msg(p,POP_FAILURE,"Flush of temp pop dropbox %s failed (%d)",
  737.     p->temp_drop, errno);
  739.     return(POP_SUCCESS);
  740. }
  742. /* 
  743.  *  dropcopy:   Make a temporary copy of the user's mail drop and 
  744.  *  save a stream pointer for it.
  745.  */
  747. pop_dropcopy(p, pwp)
  748. POP     *   p;
  749. struct passwd * pwp;
  750. {
  751.     int                     mfd;                    /*  File descriptor for 
  752.                                                         the user's maildrop */
  753.     int                     dfd;                    /*  File descriptor for 
  754.                                                         the SERVER maildrop */
  755.     FILE     *tf;     /*  The temp file */
  756.     int     tfn;     
  757.     char                    buffer[MAXLINELEN];     /*  Read buffer */
  758.     long                    offset;                 /*  Old/New boundary */
  759.     int                     nchar;                  /*  Bytes written/read */
  760.     struct stat             mybuf;                  /*  For fstat() */
  762.     if (genpath(p) < 0)
  763. return(pop_msg(p, POP_FAILURE, "Unable to create temporary drop name"));
  765.     /*  Create a temporary maildrop into which to copy the updated maildrop */
  766.     (void)sprintf(p->temp_drop, POP_DROP, p->user);
  768. #ifdef DEBUG
  769.     if(p->debug)
  770.         pop_log(p,POP_DEBUG,"Creating temporary maildrop '%s'",
  771.             p->temp_drop);
  772. #endif
  774. #ifdef BULLDB
  775.     if (p->bulldir) {
  776. char bull_db[MAXLINELEN];
  778. #ifdef BULLDBDIR
  779. sprintf(bull_db, "%s/bulldb", BULLDBDIR);
  780. #else
  781. sprintf(bull_db, "%s/bulldb", p->bulldir);
  782. #endif
  783. #ifdef GDBM
  784. if ((p->bull_db = gdbm_open (bull_db, 512, GDBM_WRCREAT, 0600, 0)) == NULL)
  785. #else
  786.         if ((p->bull_db = dbm_open (bull_db, O_RDWR | O_CREAT, 0600)) == NULL) 
  787. #endif
  788. {
  789. pop_log(p,POP_PRIORITY,"[g]dbm_open failed : %s (%d)",sys_errlist[errno],errno);
  790.     return(pop_msg(p, POP_FAILURE,
  791.        "Unable to open Bulletin database, contact your administrator"));
  792. }
  793.     }
  794. #endif
  796.     /* Here we work to make sure the user doesn't cause us to remove or
  797.      * write over existing files by limiting how much work we do while
  798.      * running as root.
  799.      */
  801. #ifdef BINMAIL_IS_SETGID
  802. # if BINMAIL_IS_SETGID > 1
  803.     pwp->pw_gid = (gid_t)BINMAIL_IS_SETGID;
  804. # else
  805.     if (!stat(POP_MAILDIR, &mybuf))
  806. pwp->pw_gid = mybuf.st_gid;
  807. # endif
  808. #endif
  810.     /* Now we run as the user. */
  811.     (void) setgid((GID_T)pwp->pw_gid);
  812.     (void) setgroups(1,(GID_T *)&pwp->pw_gid); /* Set the supplementary groups list */
  813.     (void) setuid((UID_T)pwp->pw_uid);
  815. #ifdef DEBUG
  816.     if(p->debug)pop_log(p,POP_DEBUG,"uid = %d, gid = %d",getuid(),getgid());
  817. #endif
  819.     if ((dfd = open(p->temp_drop, O_RDWR | O_CREAT, 0600)) == -1) {
  820.         pop_log(p, POP_PRIORITY,
  821.             "Unable to open temporary maildrop '%s': %s (%d)",p->temp_drop,
  822.                 (errno < sys_nerr) ? sys_errlist[errno] : "", errno) ;
  823.         return pop_msg(p,POP_FAILURE,
  824. "System error, can't open temporary file, do you own it?");
  825.     }
  827.     fstat(dfd, &mybuf);
  828.     if (mybuf.st_uid != pwp->pw_uid) {
  829. close(dfd);
  830. return(pop_msg(p, POP_FAILURE, "Temporary drop file not owned by %s.",
  831.     p->user));
  832.     }
  833. #ifdef NeXT
  834.     if (mybuf.st_mode & (0x7)) {
  835. #else
  836.     if (mybuf.st_mode & (S_IWOTH | S_IROTH)) {
  837. #endif
  838. close(dfd);
  839. return(pop_msg(p, POP_FAILURE,
  840.   "Your temporary file %s is accessable by others.  This must be fixed",
  841.     p->temp_drop));
  842.     }
  843.     /* Make sure the mailspool is not a hard link */
  844.     if (mybuf.st_nlink != 1) {
  845. close(dfd);
  846. return(pop_msg(p, POP_FAILURE,
  847.     "Your temporary file appears to have more than one link."));
  848.     }
  850.     /* If the temporary popdrop is not empty, revert to regular mode. */
  851.     if (mybuf.st_size != 0)
  852. p->server_mode = 0;
  854. #if defined(S_ISREG)
  855.     /* Make sure the file is not a symbolic link reference */
  856.     lstat(p->temp_drop, &mybuf);
  857.     if (!S_ISREG(mybuf.st_mode)) {
  858. close(dfd);
  859. return pop_msg(p, POP_FAILURE,
  860. "Your temporary drop file %s is not type 'regular file'", p->temp_drop);
  861.     }
  862. #endif
  864.     /*  Lock the temporary maildrop */
  865.     if ( flock (dfd, LOCK_EX|LOCK_NB) == -1 ) {
  866. switch(errno) {
  867.     case EWOULDBLOCK:
  868. return pop_msg(p,POP_FAILURE,
  869.      "%s lock busy!  Is another session active? (%d)",
  870. p->temp_drop, errno);
  871. /* NOTREACHED */
  872.     default:
  873. return pop_msg(p,POP_FAILURE,"flock: '%s': %s (%d)",
  874.     p->temp_drop, (errno < sys_nerr) ? sys_errlist[errno] : "", errno);
  875. /* NOTREACHED */
  876. }
  877.     }
  878.     
  879. #ifndef KEEP_TEMP_DROP
  880.     /* check for race conditions involving unlink.  See pop_updt.c */
  881.     /* s-dorner@uiuc.edu, 12/91 */
  882.     {
  883.       struct stat byName, byFd;
  884.       if (stat(p->temp_drop, &byName) || fstat(dfd, &byFd) ||
  885.   byName.st_ino != byFd.st_ino)
  886.       {
  887.         return pop_msg(p,POP_FAILURE,
  888. "Maildrop being unlocked; try again.");
  889.       }
  890.     }
  891. #endif
  892.     
  893.     /* If in server mode and the temporary popdrop has any data in it
  894.        then revert back to the original way of dealing with pop drops.
  895.      */
  897.     /*  Acquire a stream pointer for the temporary maildrop */
  898.     if ( (p->drop = fdopen(dfd,"r+")) == NULL ) {
  899.         (void)close(dfd) ;
  900.         return pop_msg(p,POP_FAILURE,"Cannot assign stream for %s (%d)",
  901.             p->temp_drop, errno);
  902.     }
  904.     if (!p->server_mode) {
  905. /* In server mode this file is used as a process lock and a temporary
  906.    copy file later on */
  908. if (init_dropinfo(p) != POP_SUCCESS)
  909.     return(POP_FAILURE);
  911. /* Sync with stdio */
  912. (void)fseek(p->drop, 0L, SEEK_END);
  913. offset = ftell(p->drop);
  914.     }
  916. #ifdef MAILOCK
  917.     /*  Lock the maildrop */
  918.     if (maillock(p->user,1) != 0)
  919.             return pop_msg(p,POP_FAILURE, "maillock: '%s'", p->temp_drop);
  920. #endif
  922.     /*  Open the user's maildrop, If this fails,  no harm in assuming empty */
  923.     if ((mfd = open(p->drop_name, O_RDWR)) > 0) {
  924.         /* Lock the maildrop */
  925.         if (flock (mfd,LOCK_EX) == -1)
  926. {
  927.             (void)close(mfd) ;
  928.     MAILUNLOCK();
  929.             return pop_msg(p,POP_FAILURE, "flock: '%s': %s (%d)", p->temp_drop,
  930.                 (errno < sys_nerr) ? sys_errlist[errno] : "", errno);
  931.         }
  933. if (!p->server_mode) {
  934.     /* New routine to copy and get dropbox info all at the same time */
  935.     nchar = do_drop_copy(p, mfd, dfd);
  937.     if ( nchar != POP_SUCCESS ) {
  938. /* pop_dropcopy has integrated the info gathering pass into
  939.    the copy pass so now the information of the dropfile is
  940.    inconsistant if there is an error.  Now we exit instead
  941.    of trying to continue with what is available.
  942. */
  943. (void)ftruncate(dfd, (OFF_T)offset) ;
  944. return(nchar);
  945.     } else {
  946. /* Mail transferred!  Zero the mail drop NOW,  that we
  947.    do not have to do gymnastics to figure out what's new
  948.    and what is old later */
  949. (void)ftruncate(mfd, (OFF_T)0) ;
  950.     }
  952.     /*  Close the actual mail drop */
  953.     (void)close (mfd);
  954. } else {
  955.     /* Save the temporary drop FILE and fid values */
  956.     p->hold = p->drop;
  957.     if ((p->drop = fdopen(mfd,"r+")) == NULL) {
  958. pop_msg(p,POP_FAILURE,"Cannot assign stream for %s (%d)",
  959.     p->drop_name, errno);
  960. goto bailout;
  961.     }
  963.     if (init_dropinfo(p) != POP_SUCCESS)
  964. goto bailout;
  966.     dfd = mfd;
  967. }
  968.     } 
  970.     /* Recalculate offset */
  971.     (void)fseek(p->drop, 0L, SEEK_END);
  972.     offset = ftell(p->drop);
  973.     if ((p->bulldir != NULL) && (pop_bull(p, pwp) != POP_SUCCESS)) {
  974. /* Return pop drop back to what it was before the bulletins */
  975. (void)ftruncate(dfd, (OFF_T)offset);
  976.     }
  977. #ifdef BULLDB
  978.     if(p->bulldir != NULL && p->bull_db != NULL) {
  979. #ifdef GDBM
  980.         gdbm_close(p->bull_db);
  981. #else
  982.         dbm_close(p->bull_db);
  983. #endif
  984. p->bull_db = NULL;
  985.     }
  986. #endif
  987.     (void)fseek(p->drop, 0L, SEEK_END);
  988.     p->spool_end = ftell(p->drop);
  990.     MAILUNLOCK();
  991.     if (p->server_mode)
  992.         flock(mfd, LOCK_UN);
  994.     return(POP_SUCCESS);
  995.  bailout:
  996.     MAILUNLOCK();
  997.     flock(mfd, LOCK_UN);
  998.     flock(dfd, LOCK_UN);
  999.     close(mfd);
  1000.     close(dfd);
  1001.     return( POP_FAILURE );
  1002. }