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

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

网络编程

开发平台：

Unix_Linux

pop_updt.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.  */
  11. #include <config.h>
  12. #include <errno.h>
  13. #include <stdio.h>
  14. #include <sys/types.h>
  15. # include <string.h>
  16. #if HAVE_UNISTD_H
  17. # include <unistd.h>
  18. #endif
  19. #include <flock.h>
  20. #if HAVE_STRINGS_H
  21. # include <strings.h>
  22. #endif
  23. #include <sys/stat.h>
  24. #include <sys/file.h>
  25. #include <popper.h>
  27. #ifdef MAILOCK
  28. # include <maillock.h>
  29. #endif
  31. #if !defined(L_XTND)
  32. #define L_XTND SEEK_END
  33. #endif
  34. #ifndef L_SET
  35. #define L_SET SEEK_SET
  36. #endif
  38. #if defined(HAVE_UNISTD_H)
  39. #include <unistd.h>
  40. #endif
  42. extern int      errno;
  44. #define BBSIZE 4096
  46. static char standard_error[] =
  47.     "Error updating primary drop. Mail left in temporary maildrop (%d)";
  49. /* 
  50.  *  updt:   Apply changes to a user's POP maildrop
  51.  */
  53. int pop_updt (p)
  54. POP     *   p;
  55. {
  56.     FILE                *   md;                     /*  Stream pointer for 
  57.                                                         the user's maildrop */
  58.     int                     mfd;                    /*  File descriptor for
  59.                                                         above */
  60.     char                    buffer[BBSIZE];         /*  Read buffer */
  62.     char     uidl_buf[128];     /*  UIDL header */
  63.     MsgInfoList         *   mp;                     /*  Pointer to message 
  64.                                                         info list */
  65.     register int            msg_num;                /*  Current message 
  66.                                                         counter */
  67.     register int            status_written;         /*  Status header field 
  68.                                                         written */
  69.     int                     nchar;                  /* Bytes read/written */
  71.     long                    offset;                 /* New mail offset */
  73.     char *   result;     /* fget and fputs status */
  75.     int     save_errno;     /* Save the error value we
  76.        are trying to print. */
  77.     struct stat             mybuf;                  /*  For fstat() */
  79. #ifdef DEBUG
  80.     if (p->debug) {
  81.         pop_log(p,POP_DEBUG,"Performing maildrop update...");
  82.         pop_log(p,POP_DEBUG,"Checking to see if all messages were deleted");
  83.     }
  84. #endif
  86.     if (p->stats) {
  87.         pop_log(p,POP_PRIORITY,"Stats: %s %d %d %d %d",
  88.            p->user, p->msgs_deleted, p->bytes_deleted,
  89.            p->msg_count - p->msgs_deleted,
  90.            p->drop_size - p->bytes_deleted);
  91.     }
  93.     if (p->server_mode) {
  94. if (!p->dirty) {
  95. #ifndef KEEP_TEMP_DROP
  96.     /* Added code in pop_dropcopy.c makes unlink ok now. */
  97.     /* s-dorner@uiuc.edu, 12/91 */
  98.     (void)unlink(p->temp_drop);
  99. #endif
  100.     return(POP_SUCCESS);
  101. }
  103. #ifdef MAILOCK
  104. /* Use SVR4 mail locking */
  105. if (maillock(p->user, 1) != 0)
  106.     return(pop_msg(p,POP_FAILURE,"maillock: '%s' (%d)",p->temp_drop,errno));
  107. #endif
  108.     }
  110.     if (p->server_mode)
  111. fstat(fileno(p->drop), &mybuf);
  113.     if ((p->msgs_deleted == p->msg_count) &&
  114. (!p->server_mode || (mybuf.st_size == p->spool_end))) {
  115. /* Truncate before close, to avoid race condition.  */
  116. (void)ftruncate (fileno(p->drop), (OFF_T)0);
  117. #ifndef KEEP_TEMP_DROP
  118. /* Added code in pop_dropcopy.c makes unlink ok now. */
  119. /* s-dorner@uiuc.edu, 12/91 */
  120. (void)unlink(p->temp_drop);
  121. #endif
  122. (void)fclose(p->drop);
  123. if (p->server_mode) {
  124.     (void)fclose(p->hold);
  125. #ifdef MAILOCK
  126.     mailunlock();
  127. #endif
  128. }
  129.         return (POP_SUCCESS);
  130.     }
  132.     if (!p->server_mode) {
  134. #ifdef DEBUG
  135. if (p->debug) 
  136.     pop_log(p,POP_DEBUG,"Opening mail drop "%s"", p->drop_name);
  137. #endif
  139. #ifdef MAILOCK
  140. /* Use SVR4 mail locking */
  141. if (maillock(p->user, 1) != 0)
  142.     return(pop_msg(p,POP_FAILURE,"maillock: '%s' (%d)",
  143. p->drop_name, errno));
  144. #endif
  146. /*  Open the user's real maildrop */
  147. if ((mfd = open(p->drop_name,O_RDWR|O_CREAT,0660)) == -1 ||
  148.     (md = fdopen(mfd,"r+")) == NULL) {
  149. #ifdef MAILOCK
  150.     mailunlock();
  151. #endif
  152.     return pop_msg(p,POP_FAILURE, standard_error, errno);
  153. }
  154.     } else {
  155. #ifdef MAILOCK
  156. /* Use SVR4 mail locking */
  157. if (maillock(p->user, 1) != 0)
  158.     return(pop_msg(p,POP_FAILURE,"maillock: '%s' (%d)",
  159. p->drop_name, errno));
  160. #endif
  161. mfd = fileno(p->drop);
  162.     }
  164.     /*  Lock the user's real mail drop */
  165.     if ( flock(mfd,LOCK_EX) == -1 )
  166.     {
  167.         (void)fclose(md) ;
  168. #ifdef MAILOCK
  169. mailunlock();
  170. #endif
  171.         return pop_msg(p,POP_FAILURE, "flock: '%s': %s (%d)", p->drop_name,
  172.             (errno < sys_nerr) ? sys_errlist[errno] : "", errno);
  173.     }
  175.     if (!p->server_mode) {
  176. /* Go to the right places */
  177. (void)fseek(p->drop, 0, SEEK_END); 
  178. offset = ftell(p->drop); 
  180. /*  Append any messages that may have arrived during the session 
  181.     to the temporary maildrop */
  182. while ((nchar = read(mfd, buffer, BBSIZE)) > 0)
  183.     if ( nchar != write(fileno(p->drop), buffer, nchar) ) {
  184. nchar = -1;
  185. break ;
  186.     }
  187. if ( nchar != 0 ) {
  188.     save_errno = errno;
  189.     (void)fclose(md) ;
  190. #ifdef MAILOCK
  191.     mailunlock();
  192. #endif
  193.     (void)ftruncate(fileno(p->drop), (OFF_T)offset);
  194.     (void)fclose(p->drop) ;
  195. #ifdef EDQUOT
  196.     if (save_errno == EDQUOT) {
  197. pop_msg(p, POP_FAILURE,
  198. "Overquota: appending messages from mailspool to temporary drop (%d)",
  199. errno);
  200.     } else
  201. #endif
  202. pop_msg(p, POP_FAILURE,
  203.       "Error appending messages from mailspool to temporary drop (%d)",
  204.     errno);
  205. }
  207. fflush(md);
  208. rewind(md);
  209. (void)ftruncate(mfd, (OFF_T)0) ;
  210. (void)lseek(mfd, (OFF_T)0, L_SET);
  212. /* Synch stdio and the kernel for the POP drop */
  213. rewind(p->drop);
  214. (void)lseek(fileno(p->drop), (OFF_T)0, L_SET);
  216. /*  Transfer messages not flagged for deletion from the temporary 
  217.     maildrop to the new maildrop */
  218. #ifdef DEBUG
  219. if (p->debug) 
  220.     pop_log(p,POP_DEBUG,"Creating new maildrop "%s" from "%s"",
  221.     p->drop_name,p->temp_drop);
  222. #endif
  224.     } else {
  225. /* Move this stuff later */
  226. fstat(fileno(p->drop), &mybuf);
  228. md = p->hold; /* Really the temp drop */
  229. mfd = fileno(md);
  230.     }
  232.     if (!p->server_mode || (p->msgs_deleted != p->msg_count)) {
  234. for (msg_num = 0; msg_num < p->msg_count; ++msg_num) {
  236.     int inheader;
  237.     int body_lines;
  239.     /*  Get a pointer to the message information list */
  240.     mp = &p->mlp[msg_num];
  242.     if (mp->del_flag) {
  243. #ifdef DEBUG
  244. if(p->debug)
  245.     pop_log(p,POP_DEBUG,
  246. "Message %d flagged for deletion.",mp->number);
  247. #endif
  248. continue;
  249.     }
  251.     (void)fseek(p->drop, mp->offset, SEEK_SET);
  253. #ifdef DEBUG
  254.     if(p->debug)
  255. pop_log(p,POP_DEBUG,"Copying message %d.",mp->number);
  256. #endif
  258.     /* Put the From line separator */
  259.     fgets(buffer, MAXMSGLINELEN, p->drop);
  260.     if (fputs(buffer, md) == EOF)
  261. break;
  263.     sprintf(buffer, "%s %s", "X-UIDL:", mp->uidl_str);
  264.     if (fputs(buffer, md) == EOF)
  265. break;
  267.     for(status_written=0,inheader=1;
  268.     fgets(buffer,MAXMSGLINELEN,p->drop);) {
  270. if (inheader) { /* Header */
  272.     /*  A blank line signals the end of the header. */
  273.     if (*buffer == 'n') {
  274. #ifndef NO_STATUS
  275. if (status_written == 0) {
  276.     if (mp->retr_flag) {
  277. (void)sprintf(buffer, "Status: ROnn");
  278.     } else {
  279. (void)sprintf(buffer, "Status: Unn");
  280.     }
  281. }
  282. #endif
  284. inheader = 0;
  285. body_lines = 1;
  286. status_written = 0;
  288.     } else if (!strncasecmp(buffer, "X-UIDL:", 7)) {
  289. continue; /* Skip all existing UIDL lines */
  291.     } else if (!strncasecmp(buffer,"Status:", 7)) {
  293. /*  Update the message status */
  294. if (mp->retr_flag)
  295.     sprintf(buffer, "Status: ROn");
  296. status_written++;
  297.     }
  298.     /*  Save another header line */
  299.     if (fputs(buffer, md) == EOF)
  300. break;
  302.     } else { /* Body */ 
  303. if (++body_lines > mp->body_lines)
  304.     break;
  305. if (fputs(buffer, md) == EOF)
  306.     break;
  307.     }
  308.     }
  310.     if (ferror(md)) {
  311. break;
  312.     }
  314.     if (p->mmdf_separator) {
  315. fputs(p->mmdf_separator, md);
  316.     }
  317. }
  319.     /* flush and check for errors now!  The new mail will writen
  320.        without stdio,  since we need not separate messages */
  322. if (ferror(md)) {
  323.     save_errno = errno;
  325.     (void)ftruncate(mfd, (OFF_T)0) ;
  326.     (void)fclose(md) ;
  327. #ifdef MAILOCK
  328.     mailunlock();
  329. #endif
  330.     (void)fclose(p->drop) ;
  331. #ifdef EDQUOT
  332.     if (save_errno == EDQUOT)
  333. return pop_msg(p, POP_FAILURE,
  334.     "Overquota copying messages to Mailspool. Temp drop unchanged (%d)",
  335.     save_errno);
  336.     else
  337. #endif
  338. return pop_msg(p,POP_FAILURE, standard_error, errno);
  339. }
  341. (void)fflush(md) ;
  342. if (ferror(md)) {
  343.     int save_error = errno;
  345.     (void)ftruncate(mfd, (OFF_T)0) ;
  346.     (void)close(mfd) ;
  347. #ifdef MAILOCK
  348.     mailunlock();
  349. #endif
  350.     (void)fclose(p->drop);
  351. #ifdef EDQUOT
  352.     if (save_errno == EDQUOT)
  353. return pop_msg(p, POP_FAILURE,
  354.     "Overquota copying messages to Mailspool. Temp drop unchanged (%d)",
  355.     save_errno);
  356.     else
  357. #endif
  358. return pop_msg(p,POP_FAILURE, standard_error, errno);
  359. }
  361.     } /* p->msgs_deleted != p->msg_count */
  363.     if (p->server_mode) {
  364. if (mybuf.st_size > p->spool_end) {
  365.     /* Go to the right places */
  366.     (void)lseek(fileno(p->drop), (OFF_T)p->spool_end, L_SET); 
  368.     /*  Append any messages that may have arrived during the session 
  369. to the temporary maildrop */
  370.     while ((nchar = read(fileno(p->drop), buffer, BBSIZE)) > 0)
  371. if ( nchar != write(mfd, buffer, nchar) ) {
  372.     nchar = -1;
  373.     break ;
  374. }
  376.     if ( nchar != 0 ) {
  377. #ifdef MAILOCK
  378. mailunlock();
  379. #endif
  380. (void)ftruncate(mfd, (OFF_T)0) ;
  381. (void)close(mfd) ;
  382. #ifdef EDQUOT
  383. if (errno == EDQUOT) {
  384.     pop_msg(p, POP_FAILURE,
  385. "Overquota: appending messages from mailspool to temporary drop (%d)",
  386.     errno);
  387. } else
  388. #endif
  389.     pop_msg(p, POP_FAILURE,
  390.     "Error appending messages from mailspool to temporary drop (%d)",
  391. errno);
  392.     }
  393. }
  395. rewind(p->drop);
  396. (void)ftruncate(fileno(p->drop), (OFF_T)0);
  397. (void)lseek(fileno(p->drop), (OFF_T)0, L_SET);
  399. (void)lseek(mfd, (OFF_T)0, L_SET);
  401. while ((nchar = read(mfd, buffer, BBSIZE)) > 0)
  402.     if (nchar != write(fileno(p->drop), buffer, nchar)) {
  403. nchar = -1;
  404. break ;
  405.     }
  407. if ( nchar != 0 ) {
  408.     (void)ftruncate(fileno(p->drop), (OFF_T)0);
  409.     (void)fclose(p->drop);
  410. #ifdef MAILOCK
  411.     mailunlock();
  412. #endif
  413.     (void)fclose(md);
  414. #ifdef EDQUOT
  415.     if (errno == EDQUOT) {
  416. pop_msg(p, POP_FAILURE,
  417. "Overquota: copying messages back to mailspool (%d)", errno);
  418.     } else
  419. #endif
  420. pop_msg(p, POP_FAILURE,
  421.     "Error appending messages from temporary drop to mailspool (%d)",
  422. errno);
  423. }
  425. (void)fclose(md);
  426. #ifdef MAILOCK
  427. mailunlock();
  428. #endif
  429. (void)ftruncate(mfd, (OFF_T)0);
  430. #ifndef KEEP_TEMP_DROP
  431. /* Added code in pop_dropcopy.c makes unlink ok now. */
  432. /* s-dorner@uiuc.edu, 12/91 */
  433. (void)fclose(p->drop);
  434. #endif
  435. (void)unlink(p->temp_drop);
  436.     } else {
  437. /* Go to start of new mail if any */
  438. (void)lseek(fileno(p->drop), (OFF_T)offset, L_SET);
  440. /* Copy over any new mail that arrived while processing the pop drop */
  441. while((nchar = read(fileno(p->drop), buffer, BBSIZE)) > 0)
  442.     if ( nchar != write(mfd, buffer, nchar) ) {
  443. nchar = -1;
  444. break ;
  445.     }
  446. if ( nchar != 0 ) {
  447.     int save_error = errno;
  449.     (void)ftruncate(mfd, (OFF_T)0) ;
  450.     (void)fclose(md) ;
  451. #ifdef MAILOCK
  452.     mailunlock();
  453. #endif
  454.     (void)fclose(p->drop) ;
  455. #ifdef EDQUOT
  456.     if (save_errno == EDQUOT)
  457. return pop_msg(p, POP_FAILURE,
  458.     "Overquota copying messages to Mailspool. Temp drop unchanged (%d)",
  459. save_errno);
  460.     else
  461. #endif
  462. return pop_msg(p,POP_FAILURE, standard_error, errno);
  463. }
  465. /*  Close the maildrop and empty temporary maildrop */
  466. (void)fclose(md);
  467. #ifdef MAILOCK
  468. mailunlock();
  469. #endif
  470. (void)ftruncate(fileno(p->drop), (OFF_T)0);
  471. #ifndef KEEP_TEMP_DROP
  472. /* Added code in pop_dropcopy.c makes unlink ok now. */
  473. /* s-dorner@uiuc.edu, 12/91 */
  474. (void)unlink(p->temp_drop);
  475. #endif
  476. (void)fclose(p->drop);
  477.     }
  479.     return(pop_quit(p));
  480. }
  484. int pop_restore (p)
  485. POP *p;
  486. {
  487.   FILE    *md;
  488.   int     mfd;
  489.   char    buffer[BBSIZE];
  490.   int     nchar;
  491.   long    offset;
  492.   int     save_errno;
  494. #ifdef DEBUG
  495.     if (p->debug)
  496.         pop_log(p,POP_DEBUG,"Performing maildrop restoration...");
  497. #endif
  499.     if (p->server_mode)
  500.     {
  501. #ifndef KEEP_TEMP_DROP        
  502.         (void) unlink(p->temp_drop);
  503. #endif        
  504.         return(POP_SUCCESS);
  505.     }
  507. #ifdef DEBUG
  508.     if (p->debug)
  509.         pop_log(p,POP_DEBUG,"Opening mail drop "%s"", p->drop_name);
  510. #endif
  512. #ifdef MAILOCK
  513.     if (maillock(p->user, 1))
  514.         return pop_msg(p,POP_FAILURE,"maillock: '%s' (%d)",p->drop_name, errno);
  515. #endif
  517.     if ((mfd = open(p->drop_name,O_RDWR | O_CREAT,0660)) == -1 ||
  518.         (md = fdopen(mfd, "r+")) == NULL)
  519.     {
  520. #ifdef MAILOCK
  521.         mailunlock();
  522. #endif
  523.         return pop_msg(p,POP_FAILURE, standard_error, errno);
  524.     }
  526.     if (flock(mfd, LOCK_EX) == -1)
  527.     {
  528.         (void) fclose(md);
  529. #ifdef MAILOCK
  530.         mailunlock();
  531. #endif
  532.         return pop_msg(p,POP_FAILURE, "flock: '%s': %s (%d)", p->drop_name,
  533.             (errno < sys_nerr) ? sys_errlist[errno]: "", errno);
  534.     }
  536.     (void)fseek(p->drop, 0, SEEK_END);
  537.     offset = ftell(p->drop);
  539.     /* Append any messages that may have arrived during the session 
  540.          to the temporary mail drop */
  541.     while ((nchar = read(mfd,buffer, BBSIZE)) > 0)
  542.         if ( nchar != write(fileno(p->drop), buffer, nchar))
  543.         {
  544.             nchar = -1;
  545.             break;
  546.         }
  547.         if ( nchar != 0)
  548.         {
  549.     save_errno = errno;
  550.             (void) fclose(md);
  551. #ifdef MAILOCK
  552.             mailunlock();
  553. #endif
  554.             (void)ftruncate(fileno(p->drop), (OFF_T)offset);
  555.             (void)fclose(p->drop);
  556. #ifdef EDQUOT
  557.             if (save_errno == EDQUOT)
  558.             {
  559.                 pop_msg(p, POP_FAILURE, 
  560.                   "Overquota: appending messages to temporary drop (%d)",
  561.                   errno);
  562.             }
  563.             else
  564. #endif
  565.             pop_msg(p, POP_FAILURE,
  566.                 "Error appending messages from mailspool to temporary drop (%d)",
  567.                  errno);
  568.        }
  570.        fflush(md);
  571.        rewind(md);
  572.        (void)ftruncate(mfd, (OFF_T)0);
  573.        (void)lseek(mfd, (OFF_T)0, L_SET);
  575.        rewind(p->drop);
  576.        (void)lseek(fileno(p->drop), (OFF_T)0, L_SET);
  577.        
  578.        while((nchar = read(fileno(p->drop), buffer, BBSIZE)) > 0)
  579.             if (nchar != write(mfd, buffer, nchar))
  580.             {
  581.                 nchar = -1;
  582.                 break;
  583.             }
  584.        if (nchar != 0)
  585.        {
  586.            save_errno = errno;
  587.            (void) ftruncate(mfd, (OFF_T)0);
  588.            (void) fclose(md);
  589. #ifdef MAILOCK
  590.            mailunlock();
  591. #endif
  592.            (void)fclose(p->drop);
  593. #ifdef EDQUOT
  594.            if (save_errno == EDQUOT)
  595.                return pop_msg(p, POP_FAILURE,
  596.                   "Overquota copying messages to Mailspool. Temp drop unchanged (%d)",
  597.                    save_errno);
  598.            else
  599. #endif
  600.            return pop_msg(p,POP_FAILURE, standard_error, errno);
  601.        }
  603.        (void) fclose(md);
  604. #ifdef MAILOCK
  605.        mailunlock();
  606. #endif
  607.        (void) ftruncate(fileno(p->drop), (OFF_T)0);
  608. #ifndef KEEP_TEMP_DROP
  609.        (void) unlink(p->temp_drop);
  610. #endif
  611.        (void) fclose(p->drop);
  613.        return pop_quit(p);
  614. }