home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / PPPBCKP / SRC15B44.ZIP / POP.C < prev    next >
Text File  |  1997-10-02  |  36KB  |  1,158 lines
  1. #include <stdio.h>
  2. #include <stdarg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <dos.h>
  6. #include <fcntl.h>
  7. #include <sys/stat.h>
  8. #include <ctype.h>
  9. #include <mem.h>
  10. #include <conio.h>
  11. #include <io.h>
  12. #include <share.h>
  13. #include <errno.h>
  14. #include <malloc.h>
  15. #include <dir.h>
  16. #include "tcp.h"
  17. #include "pop.h"
  18. #include "version.h"
  19. #include "retcode.h"
  20.  
  21. #define POP_PORT 110
  22.  
  23. #define SMTP_PORT 25
  24.  
  25. #define _TEMP_BUFFER_LEN 1024
  26.  
  27. #define SHARE_LEVEL 10
  28. #define WAIT_TIME 10
  29. #define TRIES 100
  30.  
  31. #define MT_DESQVIEW 0x01
  32. #define MT_WINDOWS  0x02
  33. #define MT_OS2      0x04
  34. #define MT_NB       0x40
  35.  
  36.  
  37. #define blankline(LINE) (strspn(LINE, " \n\t\r")==strlen(LINE))
  38.  
  39. #define free_Mail_Socket(SOCK) if (SOCK!=NULL) {     \
  40.   free(SOCK->sock); free(SOCK); SOCK=NULL; }
  41.  
  42. int POP_Err_Cond;
  43. static char *POP_Err_Msg = NULL;
  44. static char _POP_err_msg_buf[100] = "";
  45. static int SMTP_Err_Cond;
  46. static char *SMTP_Err_Msg = NULL;
  47. static char _SMTP_err_msg_buf[100] = "";
  48. static int POPLIB_Err_Cond;
  49. static char *POPLIB_Err_Msg = NULL;
  50. char from_user[41], POPHOST[81];
  51. int WatTCP_initialized = 0;
  52. static char _temp_buffer[_TEMP_BUFFER_LEN];
  53. int POP_stat;
  54. int SMTP_stat;
  55. int SOCK_DELAY = 60;
  56. int multitasker = 0;
  57. int DEBUG = 1;
  58. int ALLMAIL;
  59.  
  60. char pktowner[26];
  61.  
  62. #define SOCK_READ_ERR(PROTOCOL)                                                 \
  63.   sock_err:                                                                     \
  64.     switch (PROTOCOL##_stat) {                                                  \
  65.       case 1 :                                                                  \
  66.         sprintf(PROTOCOL##_Err_Msg, #PROTOCOL " Ok");                           \
  67.         PROTOCOL##_Err_Cond = PROTOCOL##_OK;                                    \
  68.         sprintf(POPLIB_Err_Msg, "Session error : %s.",                          \
  69.             sockerr(PROTOCOL##_sock->sock));                                    \
  70.         POPLIB_Err_Cond = POPLIB_S_CLOSED;                                      \
  71.         if (DEBUG) output(#PROTOCOL " > %s\n", POPLIB_Err_Msg);                 \
  72.         break;                                                                  \
  73.       case -1:                                                                  \
  74.         sprintf(PROTOCOL##_Err_Msg, #PROTOCOL " Ok");                           \
  75.         PROTOCOL##_Err_Cond = PROTOCOL##_OK;                                    \
  76.         sprintf(POPLIB_Err_Msg, "Session error : %s.", sockerr(PROTOCOL##_sock->sock));\
  77.         POPLIB_Err_Cond = POPLIB_S_CLOSED;                                      \
  78.         if (DEBUG) output(#PROTOCOL " > %s\n", POPLIB_Err_Msg);                 \
  79.         break;                                                                  \
  80.     }
  81.  
  82. #define SOCK_GETS(PROTOCOL)                                                     \
  83.   sock_wait_input( PROTOCOL##_sock->sock, SOCK_DELAY, NULL,                     \
  84.        &PROTOCOL##_stat );                                                      \
  85.   sock_gets( PROTOCOL##_sock->sock, _temp_buffer, sizeof( _temp_buffer ));      \
  86.   if (DEBUG) output(#PROTOCOL"> %s\n", _temp_buffer);                           \
  87.   PROTOCOL##_Err_Cond = atoi(_temp_buffer);                                     \
  88.   strncpy(PROTOCOL##_Err_Msg, &_temp_buffer[5], 100);
  89.  
  90. #define SMTP_FAIL_ON(NUM, SHUTDOWN)                                             \
  91.   if ( SMTP_Err_Cond == NUM ) {                                                 \
  92.     if (DEBUG) output("\nSMTP Failure > '" #NUM "'\n");                           \
  93.     sock_puts( SMTP_sock->sock, "QUIT" );                                       \
  94.     sock_close( SMTP_sock->sock );                                              \
  95.     free_Mail_Socket(SMTP_sock);                                                \
  96.     strncpy(POPLIB_Err_Msg, "SMTP Error -- SMTP Reply '" #NUM "'", 100);        \
  97.     POPLIB_Err_Cond = POPLIB_SMTP_ERR;                                          \
  98.     output("\n ■ %s", POPLIB_Err_Msg);                                          \
  99.     SHUTDOWN;                                                                   \
  100.     return(0);                                                                  \
  101.   }
  102.  
  103. #define SMTP_FAIL_IF(COND, SHUTDOWN)                                            \
  104.   if ( COND ) {                                                                 \
  105.     if (DEBUG) output("\nSMTP Failure > (" #COND ")\n");                          \
  106.     sock_puts( SMTP_sock->sock, "QUIT" );                                       \
  107.     sock_close( SMTP_sock->sock );                                              \
  108.     free_Mail_Socket(SMTP_sock);                                                \
  109.     strncpy(POPLIB_Err_Msg, "SMTP Error -- Condition (" #COND ")", 100);        \
  110.     POPLIB_Err_Cond = POPLIB_SMTP_ERR;                                          \
  111.     output("\n ■ %s", POPLIB_Err_Msg);                                          \
  112.     SHUTDOWN;                                                                   \
  113.     return(0);                                                                  \
  114.   }
  115.  
  116. #define SMTP_RESET_ON(NUM, SHUTDOWN)                                            \
  117.   if ( SMTP_Err_Cond == NUM ) {                                                 \
  118.     if (DEBUG) output("SMTP Problem > '" #NUM "'\n");                           \
  119.     sock_puts( SMTP_sock->sock, "RSET" );                                       \
  120.     sock_wait_input( SMTP_sock->sock, SOCK_DELAY, NULL, &SMTP_stat );           \
  121.     sock_gets( SMTP_sock->sock, _temp_buffer, sizeof( _temp_buffer ));          \
  122.     POPLIB_Err_Cond = POPLIB_SMTP_PROB;                                         \
  123.     strncpy(POPLIB_Err_Msg, "SMTP Problem -- SMTP Reply '" #NUM "'", 100);      \
  124.     output("\n ■ %s", POPLIB_Err_Msg);                                          \
  125.     SHUTDOWN;                                                                   \
  126.     return(0);                                                                  \
  127.   }
  128.  
  129. void output(char *fmt,...)
  130. {
  131.   va_list v;
  132.   char s[255];
  133.  
  134.   va_start(v, fmt);
  135.   vsprintf(s, fmt, v);
  136.   va_end(v);
  137.   fputs(s, stderr);
  138. }
  139.  
  140. void backline(void)
  141. {
  142.   int i;
  143.  
  144.   i = wherex();
  145.   if (i < 80)
  146.     output(" ");
  147.   else
  148.     i--;
  149.   while (i-- > 0)
  150.     output("\b \b");
  151. }
  152.  
  153.  
  154. int get_dos_version(void)
  155. {
  156.   _AX = 0x3000;
  157.   geninterrupt(0x21);
  158.   if (_AX % 256 >= 10) {
  159.     multitasker |= MT_OS2;
  160.   }
  161.   return (_AX);
  162. }
  163.  
  164. int get_dv_version(void)
  165. {
  166.   int v;
  167.  
  168.   if (multitasker & MT_OS2)
  169.     return 0;
  170.   _AX = 0x2b01;
  171.   _CX = 0x4445;
  172.   _DX = 0x5351;
  173.   geninterrupt(0x21);
  174.   if (_AL == 0xff) {
  175.     return 0;
  176.   } else {
  177.     v = _BX;
  178.     multitasker |= MT_DESQVIEW;
  179.     return v;
  180.   }
  181. }
  182.  
  183. int get_win_version(void)
  184. {
  185.   int v = 0;
  186.  
  187.   __emit__(0x55, 0x06, 0x53);
  188.   _AX = 0x352f;
  189.   geninterrupt(0x21);
  190.   _AX = _ES;
  191.   if (_AX | _BX) {
  192.     _AX = 0x1600;
  193.     geninterrupt(0x2f);
  194.     v = _AX;
  195.     if (v % 256 <= 1)
  196.       v = 0;
  197.   }
  198.   __emit__(0x5b, 0x07, 0x5d);
  199.   if (v != 0)
  200.     multitasker |= MT_WINDOWS;
  201.   return (v);
  202. }
  203.  
  204. int get_nb_version(void)
  205. {
  206.   _AX = 0;
  207.   geninterrupt(0x2A);
  208.   return (_AH);
  209. }
  210.  
  211. void detect_multitask(void)
  212. {
  213.   get_dos_version();
  214.   get_win_version();
  215.   get_dv_version();
  216.   if (multitasker < 2)
  217.     if (get_nb_version())
  218.       multitasker = MT_NB;
  219. }
  220.  
  221. unsigned char *trim(char *str)
  222. {
  223.   int i;
  224.  
  225.   if (str == NULL)
  226.     return (str);
  227.   for (i = strlen(str) - 1; (i >= 0) && isspace(str[i]); str[i--] = '\0');
  228.   while (isspace(str[0]))
  229.     strcpy(str, str + 1);
  230.   return (str);
  231. }
  232.  
  233. unsigned char *strrep(char *str, char old, char New)
  234. {
  235.   int i;
  236.  
  237.   for (i = 0; str[i]; i++)
  238.     if (str[i] == old)
  239.       str[i] = New;
  240.   return (str);
  241. }
  242.  
  243. int getnumbers(unsigned char *ascii, unsigned int *d1, unsigned long *d2)
  244. {
  245.   char *p;
  246.  
  247.   /* it must return a number after the white space */
  248.   if ((p = (char *) _fstrchr((char *) ascii, ' ')) == NULL)
  249.     return 0;
  250.   /* skip space */
  251.   while (*p == ' ')
  252.     p++;
  253.   *d1 = atoi(p);
  254.   if ((p = (char *) _fstrchr(p, ' ')) == NULL)
  255.     return 1;
  256.   /* skip space */
  257.   while (*p == ' ')
  258.     p++;
  259.   *d2 = atol(p);
  260.   return 2;
  261. }
  262.  
  263. char *fix_quoted_commas(char *string)
  264. {
  265.   char *ptr;
  266.   int quoted = 0;
  267.  
  268.   ptr = string;
  269.   if (ptr) {
  270.     while (*ptr != 0) {
  271.       if (*ptr == '\"')
  272.         quoted = (!quoted);
  273.       if (*ptr == ',' && quoted)
  274.         *ptr = '│';
  275.       ptr = &ptr[1];
  276.     }
  277.   }
  278.   return (string);
  279. }
  280.  
  281. long sh_lseek(int handle, long offset, int fromwhere)
  282. {
  283.   if (handle == -1) {
  284.     return (-1L);
  285.   }
  286.   return (lseek(handle, offset, fromwhere));
  287. }
  288.  
  289. FILE *fsh_open(char *path, char *fmode)
  290. {
  291.   FILE *f;
  292.   int count, share, md, fd;
  293.   char drive[MAXDRIVE], dir[MAXDIR], file[MAXFILE], ext[MAXEXT];
  294.  
  295.   share = SH_DENYWR;
  296.   md = 0;
  297.   if (((char *) _fstrchr(fmode, 'w')) != NULL) {
  298.     share = SH_DENYRD;
  299.     md = O_RDWR | O_CREAT | O_TRUNC;
  300.   } else
  301.     if (((char *) _fstrchr(fmode, 'a')) != NULL) {
  302.     share = SH_DENYRD;
  303.     md = O_RDWR | O_CREAT;
  304.   } else {
  305.     md = O_RDONLY;
  306.   }
  307.   if (((char *) _fstrchr(fmode, 'b')) != NULL) {
  308.     md |= O_BINARY;
  309.   }
  310.   if (((char *) _fstrchr(fmode, '+')) != NULL) {
  311.     md &= ~O_RDONLY;
  312.     md |= O_RDWR;
  313.     share = SH_DENYRD;
  314.   }
  315.   fd = open(path, md | share, S_IREAD | S_IWRITE);
  316.   if (fd < 0) {
  317.     count = 1;
  318.     fnsplit(path, drive, dir, file, ext);
  319.     if ((access(path, 0)) != -1) {
  320.       delay(WAIT_TIME);
  321.       fd = open(path, md | share, S_IREAD | S_IWRITE);
  322.       while (((fd < 0) && (errno == EACCES)) && (count < TRIES)) {
  323.         delay(WAIT_TIME);
  324.         count++;
  325.         fd = open(path, md | share, S_IREAD | S_IWRITE);
  326.       }
  327.     }
  328.   }
  329.   if (fd > 0) {
  330.     if (((char *) _fstrchr(fmode, 'a')) != NULL)
  331.       sh_lseek(fd, 0L, SEEK_END);
  332.     f = fdopen(fd, fmode);
  333.     if (!f) {
  334.       close(fd);
  335.     }
  336.   } else
  337.     f = 0;
  338.   return (f);
  339. }
  340.  
  341. Mail_Socket *smtp_start(char *host, char *dom)
  342. {
  343.   longword h;
  344.   Mail_Socket *SMTP_sock = NULL;
  345.  
  346.   if (!SMTP_Err_Msg)
  347.     SMTP_Err_Msg = _SMTP_err_msg_buf;
  348.   if (!WatTCP_initialized) {
  349.     sock_init();
  350.     WatTCP_initialized = 1;
  351.   }
  352.   if (!(h = resolve(host))) {
  353.     SMTP_Err_Cond = SMTP_FAILED;
  354.     sprintf(SMTP_Err_Msg, "Cannot resolve host %s", host);
  355.     output("\n ■ Error : %s", SMTP_Err_Msg);
  356.     return NULL;
  357.   }
  358.   if ((SMTP_sock = (Mail_Socket *) malloc(sizeof(Mail_Socket))) == NULL) {
  359.     output("\n ■ Insufficient memory to create socket... aborting");
  360.     exit(EXIT_FAILURE);
  361.   }
  362.   if ((SMTP_sock->sock = (tcp_Socket *) malloc(sizeof(tcp_Socket))) == NULL) {
  363.     output("\n ■ Insufficient memory to create socket... aborting");
  364.     free(SMTP_sock);
  365.     exit(EXIT_FAILURE);
  366.   }
  367.   if (!tcp_open(SMTP_sock->sock, 0, h, SMTP_PORT, NULL)) {
  368.     SMTP_Err_Cond = SMTP_FAILED;
  369.     sprintf(SMTP_Err_Msg, "Unable to connect to %s.", host);
  370.     output("\n ■ Error : %s", SMTP_Err_Msg);
  371.     free(SMTP_sock);
  372.     return NULL;
  373.   }
  374.   sock_mode(SMTP_sock->sock, TCP_MODE_ASCII);
  375.   sock_wait_established(SMTP_sock->sock, SOCK_DELAY, NULL, &SMTP_stat);
  376.   while (sock_tbused(SMTP_sock->sock) > 0) {
  377.     SOCK_GETS(SMTP);
  378.     SMTP_FAIL_ON(SMTP_OOPS,);
  379.   }
  380.   sock_printf(SMTP_sock->sock, "HELO %s", dom);
  381.   sock_wait_input(SMTP_sock->sock, SOCK_DELAY, NULL, &SMTP_stat);
  382.   while (sock_tbused(SMTP_sock->sock) > 0) {
  383.     SOCK_GETS(SMTP);
  384.     SMTP_FAIL_ON(SMTP_OOPS,);
  385.     SMTP_FAIL_ON(SMTP_SYNTAX,);
  386.     SMTP_FAIL_ON(SMTP_PARAM,);
  387.     SMTP_FAIL_ON(SMTP_BAD_PARM,);
  388.   }
  389.   return (SMTP_sock);
  390.   SOCK_READ_ERR(SMTP);
  391.   return NULL;
  392. }
  393.  
  394. char *smtp_parse_from_line(FILE * f)
  395. {
  396.   int found = 0, done = 0;
  397.  
  398.   rewind(f);
  399.   while (!feof(f) && !done) {
  400.     fgets(_temp_buffer, sizeof(_temp_buffer), f);
  401.     if (*_temp_buffer == '\n')
  402.       done = 1;
  403.     else
  404.       if (strncmpi(_temp_buffer, "from:", 5) == 0 &&
  405.           _fstrchr(_temp_buffer, '@') != 0)
  406.       found = 1, done = 1;
  407.   }
  408.   if (found)
  409.     return (trim(strdup(&_temp_buffer[5])));
  410.   return 0;
  411. }
  412.  
  413. char **smtp_parse_to_line(FILE * f)
  414. {
  415.   int done = 0, current = 0;
  416.   char **list = NULL;
  417.   char *addr;
  418.  
  419.   rewind(f);
  420.   while (!feof(f) && !done) {
  421.     fgets(_temp_buffer, sizeof(_temp_buffer), f);
  422.     if (*_temp_buffer == '\n')
  423.       done = 1;
  424.     else
  425.       if ((strncmpi(_temp_buffer, "to:", 3) == 0) ||
  426.           (strncmpi(_temp_buffer, "cc:", 3) == 0) ||
  427.           (strncmpi(_temp_buffer, "bcc:", 4) == 0)) {
  428.       fix_quoted_commas(_temp_buffer);
  429.       addr = strtok(_temp_buffer, ":");
  430.       while ((addr = strtok(NULL, ",\n")) != NULL) {
  431.         strrep(addr, '│', ',');
  432.         list = (char **) realloc(list, sizeof(char *) * ((current) + 2));
  433.         list[current] = strdup(addr);
  434.         list[current + 1] = NULL;
  435.         current++;
  436.       }
  437.       }
  438.   }
  439.   return (list);
  440. }
  441.  
  442. int smtp_send_MAIL_FROM_line(Mail_Socket * SMTP_sock, FILE * f)
  443. {
  444.   char *from;
  445.  
  446.   from = smtp_parse_from_line(f);
  447.   if (from) {
  448.     if (DEBUG)
  449.       output("\nSMTP> Mail From:<%s>\n", from);
  450.     sock_printf(SMTP_sock->sock, "MAIL FROM:<%s>", from);
  451.     free(from);
  452.     while (sock_tbused(SMTP_sock->sock) > 0) {
  453.       SOCK_GETS(SMTP);
  454.       SMTP_FAIL_ON(SMTP_OOPS,);
  455.     }
  456.   }
  457.   return 1;
  458.   SOCK_READ_ERR(SMTP);
  459.   return 0;
  460. }
  461.  
  462. #define FREE_ALL for (i=0; to_list[i]!=NULL; i++) if (to_list[i]) free(to_list[i]); if (to_list) free(to_list);
  463.  
  464. int smtp_send_RCPT_TO_line(Mail_Socket * SMTP_sock, FILE * f)
  465. {
  466.   char **to_list;
  467.   int i;
  468.  
  469.   to_list = smtp_parse_to_line(f);
  470.   for (i = 0; to_list[i] != NULL; i++) {
  471.     if (DEBUG)
  472.       output("SMTP> Rcpt To:<%s>\n", to_list[i]);
  473.     sock_printf(SMTP_sock->sock, "RCPT TO:<%s>", to_list[i]);
  474.     while (sock_tbused(SMTP_sock->sock) > 0) {
  475.       SOCK_GETS(SMTP);
  476.       SMTP_FAIL_ON(SMTP_OOPS, FREE_ALL);
  477.       SMTP_RESET_ON(SMTP_SYNTAX, FREE_ALL);
  478.       SMTP_RESET_ON(SMTP_PARAM, FREE_ALL);
  479.       SMTP_RESET_ON(SMTP_BAD_SEQ, FREE_ALL);
  480.     }
  481.   }
  482.   FREE_ALL;
  483.   return 1;
  484.   SOCK_READ_ERR(SMTP);
  485.   return 0;
  486. }
  487.  
  488. void go_back(int from, int to)
  489. {
  490.   int i;
  491.  
  492.   for (i = from; i > to; i--)
  493.     output("\b \b");
  494. }
  495.  
  496.  
  497. #undef FREE_ALL
  498.  
  499. int smtp_sendf(Mail_Socket * SMTP_sock, FILE * f)
  500. {
  501.   int in_header = 1, in_bcc = 0, i, pos;
  502.   long nbytes, obytes, rbytes;
  503.   char *temp, ch;
  504.  
  505.   if (smtp_send_MAIL_FROM_line(SMTP_sock, f) == 0)
  506.     return 0;
  507.   if (smtp_send_RCPT_TO_line(SMTP_sock, f) == 0)
  508.     return 0;
  509.   fseek(f, 0L, SEEK_END);
  510.   obytes = ftell(f);
  511.   rewind(f);
  512.   sock_puts(SMTP_sock->sock, "DATA");
  513.   sock_wait_input(SMTP_sock->sock, SOCK_DELAY, NULL, &SMTP_stat);
  514.   while (sock_tbused(SMTP_sock->sock) > 0) {
  515.     SOCK_GETS(SMTP);
  516.     if (DEBUG)
  517.       output("\nSMTP> %s", _temp_buffer);
  518.     SMTP_FAIL_ON(SMTP_OOPS,);
  519. //    SMTP_RESET_ON(SMTP_BAD_SEQ,);
  520.     SMTP_RESET_ON(SMTP_SYNTAX,);
  521.     SMTP_RESET_ON(SMTP_PARAM,);
  522.     SMTP_RESET_ON(SMTP_COM_NI,);
  523.     SMTP_RESET_ON(SMTP_FAILED,);
  524.     SMTP_RESET_ON(SMTP_ERROR,);
  525.   }
  526.   nbytes = 0L;
  527.   rbytes = 1024L;
  528.   output(" - ");
  529.   pos = wherex();
  530.   while (!feof(f)) {
  531.     fgets(_temp_buffer, sizeof(_temp_buffer), f);
  532.     strrep(_temp_buffer, '\n', '\0');
  533.     strrep(_temp_buffer, '\r', '\0');
  534.     temp = trim(strdup(_temp_buffer));
  535.     if (strlen(temp) == 0)
  536.       in_header = 0;
  537.     if (temp)
  538.       free(temp);
  539.     if (in_header && !in_bcc && strncmpi(_temp_buffer, "bcc:", 4) == 0) {
  540.       in_bcc = 1;
  541.       continue;
  542.     }
  543.     if (in_bcc)
  544.       in_bcc = isspace(*_temp_buffer);
  545.     if (in_bcc)
  546.       continue;
  547.     if (*_temp_buffer == '.') {
  548.       movmem(_temp_buffer, _temp_buffer + 1, sizeof(_temp_buffer) - 1);
  549.       *_temp_buffer = '.';
  550.       if (DEBUG)
  551.         output("\nSMTP> %s", _temp_buffer);
  552.     }
  553.     nbytes += sock_puts(SMTP_sock->sock, _temp_buffer);
  554.     nbytes += 2;
  555.     if (nbytes > rbytes) {
  556.       go_back(wherex(), pos);
  557.       output("%ld/%ld", nbytes, obytes);
  558.       rbytes += 512L;
  559.     }
  560.     while (kbhit()) {
  561.       ch = (getch());
  562.       switch (ch) {
  563.         case 27:
  564.         case 32:
  565.           go_back(wherex(), pos);
  566.           return -1;
  567.         default:
  568.           break;
  569.       }
  570.     }
  571.   }
  572.   sock_puts(SMTP_sock->sock, ".");
  573.   sock_wait_input(SMTP_sock->sock, SOCK_DELAY, NULL, &SMTP_stat);
  574.   while (sock_tbused(SMTP_sock->sock) > 0) {
  575.     SOCK_GETS(SMTP);
  576.     SMTP_FAIL_ON(SMTP_OOPS,);
  577.     SMTP_RESET_ON(SMTP_ERROR,);
  578.     SMTP_RESET_ON(SMTP_SQUEEZED,);
  579.     SMTP_RESET_ON(SMTP_FULL,);
  580.     SMTP_RESET_ON(SMTP_FAILED,);
  581.   }
  582.   go_back(wherex(), pos);
  583.   return 1;
  584.   SOCK_READ_ERR(SMTP);
  585.   return 0;
  586. }
  587.  
  588. int smtp_shutdown(Mail_Socket * SMTP_sock)
  589. {
  590.   if (SMTP_sock->sock) {
  591.     sock_puts(SMTP_sock->sock, "QUIT");
  592.     sock_close(SMTP_sock->sock);
  593.     fcloseall();
  594.     return 1;
  595.   }
  596. sock_err:
  597.   free_Mail_Socket(SMTP_sock);
  598.   return 0;
  599. }
  600.  
  601.  
  602. Mail_Socket *pop_init(char *host)
  603. {
  604.   longword h;
  605.   Mail_Socket *POP_sock = NULL;
  606.  
  607.   if (!POP_Err_Msg)
  608.     POP_Err_Msg = _POP_err_msg_buf;
  609.  
  610.   if (!WatTCP_initialized) {
  611.     sock_init();
  612.     WatTCP_initialized = 1;
  613.   }
  614.   if (!(h = resolve(host))) {
  615.     POP_Err_Cond = POP_BAD_HOST;
  616.     sprintf(POP_Err_Msg, "Cannot resolve host %s", host);
  617.     output("\n ■ Error : %s", POP_Err_Msg);
  618.     return NULL;
  619.   }
  620.   if ((POP_sock = (Mail_Socket *) malloc(sizeof(Mail_Socket))) == NULL) {
  621.     output("\n ■ Insufficient memory to create socket... aborting.");
  622.     exit(EXIT_FAILURE);
  623.   }
  624.   if ((POP_sock->sock = (tcp_Socket *) malloc(sizeof(tcp_Socket))) == NULL) {
  625.     output("\n ■ Insufficient memory to create socket... aborting.");
  626.     free(POP_sock);
  627.     exit(EXIT_FAILURE);
  628.   }
  629.   if (!tcp_open(POP_sock->sock, 0, h, POP_PORT, NULL)) {
  630.     sprintf(POP_Err_Msg, "\n ■ Unable to connect to host %s.", host);
  631.     POP_Err_Cond = POP_BAD_HOST;
  632.     output("\n ■ Error : %s", POP_Err_Msg);
  633.     return NULL;
  634.   }
  635.   sock_mode(POP_sock->sock, TCP_MODE_ASCII);
  636.   sock_wait_established(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  637.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  638.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  639.   if (DEBUG)
  640.     output("\nPOP> %s", _temp_buffer);
  641.   if (*_temp_buffer != '+') {
  642.     sprintf(POP_Err_Msg, "Host %s is unavailable.", host);
  643.     POP_Err_Cond = POP_HOST_UNAVAILABLE;
  644.     output("\n ■ Error : %s", POP_Err_Msg);
  645.     if (POP_sock->sock) {
  646.       sock_puts(POP_sock->sock, "QUIT");
  647.       sock_close(POP_sock->sock);
  648.     }
  649.     return NULL;
  650.   }
  651.   return (POP_sock);
  652.   SOCK_READ_ERR(POP);
  653.   return NULL;
  654. }
  655.  
  656. int pop_login(Mail_Socket * POP_sock, char *userid, char *password)
  657. {
  658.   sprintf(_temp_buffer, "USER %s", userid);
  659.   sock_puts(POP_sock->sock, _temp_buffer);
  660.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  661.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  662.   if (DEBUG)
  663.     output("\nPOP> %s", _temp_buffer);
  664.   if (*_temp_buffer != '+') {
  665.     sprintf(POP_Err_Msg, "Host reports mailbox \"%s\" does not exist!", userid);
  666.     POP_Err_Cond = POP_BAD_MBOX;
  667.     output("\n ■ %s", POP_Err_Msg);
  668.     return 0;
  669.   }
  670.   sprintf(_temp_buffer, "PASS %s", password);
  671.   sock_puts(POP_sock->sock, _temp_buffer);
  672.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  673.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  674.   if (DEBUG)
  675.     output("\nPOP> %s", _temp_buffer);
  676.   if (*_temp_buffer != '+') {
  677.     sprintf(POP_Err_Msg, "Host reports password incorrect or account is locked.");
  678.     POP_Err_Cond = POP_BAD_PASS;
  679.     output("\n ■ %s", POP_Err_Msg);
  680.     return 0;
  681.   }
  682.   return 1;
  683.   SOCK_READ_ERR(POP);
  684.   return 0;
  685. }
  686.  
  687. int pop_status(Mail_Socket * POP_sock, unsigned int *count, unsigned long *totallength)
  688. {
  689.   sock_puts(POP_sock->sock, "STAT");
  690.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  691.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  692.   if (DEBUG)
  693.     output("\nPOP> %s", _temp_buffer);
  694.   if ((*_temp_buffer != '+') ||
  695.       (getnumbers(_temp_buffer, count, totallength) < 2)) {
  696.     POP_Err_Cond = POP_UNKNOWN;
  697.     if (DEBUG) {
  698.       sprintf(POP_Err_Msg, "Unknown POP error");
  699.       output("\n%s", POP_Err_Msg);
  700.     }
  701.     return 0;
  702.   }
  703.   return 1;
  704.   SOCK_READ_ERR(POP);
  705.   return 0;
  706. }
  707.  
  708. long pop_length(Mail_Socket * POP_sock, unsigned int msg_num, unsigned long *size)
  709. {
  710.   unsigned int dummy;
  711.  
  712.   sprintf(_temp_buffer, "LIST %u", msg_num);
  713.   sock_puts(POP_sock->sock, _temp_buffer);
  714.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  715.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  716.   if (DEBUG)
  717.     output("\nPOP> %s", _temp_buffer);
  718.   if ((*_temp_buffer != '+') ||
  719.       (getnumbers(_temp_buffer, &dummy, size) < 2)) {
  720.     POP_Err_Cond = POP_NOT_MSG;
  721.     if (DEBUG) {
  722.       sprintf(POP_Err_Msg, "No message #%u", msg_num);
  723.       output("\n%s", POP_Err_Msg);
  724.     }
  725.     return 0;
  726.   }
  727.   return (*size);
  728.   SOCK_READ_ERR(POP);
  729.   return 0;
  730. }
  731.  
  732. char *stristr(char *String, char *Pattern)
  733. {
  734.   char *pptr, *sptr, *start;
  735.   unsigned int slen, plen;
  736.  
  737.   for (start = String, pptr = Pattern, slen = strlen(String),
  738.        plen = strlen(Pattern); slen >= plen; start++, slen--) {
  739.     while (toupper(*start) != toupper(*Pattern)) {
  740.       start++;
  741.       slen--;
  742.       if (slen < plen)
  743.         return (NULL);
  744.     }
  745.     sptr = start;
  746.     pptr = Pattern;
  747.     while (toupper(*sptr) == toupper(*pptr)) {
  748.       sptr++;
  749.       pptr++;
  750.       if ('\0' == *pptr)
  751.         return (start);
  752.     }
  753.   }
  754.   return (NULL);
  755. }
  756.  
  757. int pop_top(Mail_Socket * POP_sock, unsigned int msg_num)
  758. {
  759.   int okpkt, in_header;
  760.   char *temp;
  761.  
  762.   in_header = 1;
  763.   sprintf(_temp_buffer, "TOP %u 50", msg_num);
  764.   sock_puts(POP_sock->sock, _temp_buffer);
  765.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  766.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  767.   if (DEBUG)
  768.     output("\nPOP> %s", _temp_buffer);
  769.   if (*_temp_buffer != '+') {
  770.     POP_Err_Cond = POP_NOT_MSG;
  771.     sprintf(POP_Err_Msg, "No message #%ld.", msg_num);
  772.     output("\n ■ %s", POP_Err_Msg);
  773.     return -1;
  774.   }
  775.   okpkt = -1;
  776.   while (1) {
  777.     sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  778.     sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  779.     if (_temp_buffer[0] == '.' && _temp_buffer[1] == 0)
  780.       break;
  781.     temp = trim(strdup(_temp_buffer));
  782.     if (strlen(temp) == 0)
  783.       in_header = 0;
  784.     free(temp);
  785.     if ((strnicmp(_temp_buffer, "begin ", 6) == 0) &&
  786.         (stristr(_temp_buffer, "WINMAIL") == NULL)) {
  787.       if (okpkt != 4)
  788.         okpkt = 1;
  789.       if ((stristr(_temp_buffer, ".ZIP") != NULL) ||
  790.           (stristr(_temp_buffer, ".ARJ") != NULL) ||
  791.           (stristr(_temp_buffer, ".LZH") != NULL))
  792.         okpkt = 2;
  793.       if ((stristr(_temp_buffer, ".GIF") != NULL) ||
  794.           (stristr(_temp_buffer, ".JPG") != NULL))
  795.         okpkt = 3;
  796.     }
  797.     if ((strnicmp(_temp_buffer, "from:", 5) == 0) && (in_header)) {
  798.       if ((stristr(_temp_buffer, "mailer-daemon") != NULL) ||
  799.           (stristr(_temp_buffer, "mail delivery") != NULL) ||
  800.           (stristr(_temp_buffer, "administrator") != NULL) ||
  801.           (stristr(_temp_buffer, from_user) != NULL))
  802.         okpkt = 4;
  803.       else
  804.         strncpy(pktowner, &_temp_buffer[6], 25);
  805.     }
  806.   }
  807.   return okpkt;
  808.   SOCK_READ_ERR(POP);
  809.   return 0;
  810. }
  811.  
  812. int pop_getf(Mail_Socket * POP_sock, char *fn, unsigned int msg_num)
  813. {
  814.   unsigned long size;
  815.   long nbytes, rbytes;
  816.   int i, pos, ctld, len;
  817.   FILE *fp;
  818.  
  819.   if (!pop_length(POP_sock, msg_num, &size)) {
  820.     output("\n ■ Unable to retrieve message number %d", msg_num);
  821.     return 0;
  822.   }
  823.   sprintf(_temp_buffer, "RETR %u", msg_num);
  824.   sock_puts(POP_sock->sock, _temp_buffer);
  825.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  826.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  827.   if (DEBUG)
  828.     output("\nPOP> %s", _temp_buffer);
  829.   if (*_temp_buffer != '+') {
  830.     POP_Err_Cond = POP_NOT_MSG;
  831.     sprintf(POP_Err_Msg, "No message #%u", msg_num);
  832.     output("\n ■ %s", POP_Err_Msg);
  833.     return 0;
  834.   }
  835.   nbytes = 0L;
  836.   rbytes = 1024L;
  837.   output(" - ");
  838.   pos = wherex();
  839.   if ((fp = fsh_open(fn, "w")) == NULL) {
  840.     output("\n ■ Unable to create %s... aborting!", fn);
  841.     return 0;
  842.   }
  843.   ctld = 1;
  844.   while (1) {
  845.     sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  846.     len = (sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer)));
  847.     if ((ctld == 1) && (len == 0))
  848.       ctld = 0;
  849.     if ((strnicmp(_temp_buffer, "begin ", 6) == 0) &&
  850.         (stristr(_temp_buffer, "WINMAIL") != NULL))
  851.       ctld = 2;
  852.     if ((ctld == 2) && (strnicmp(_temp_buffer, "end", 3) == 0))
  853.       ctld = 0;
  854.     if (_temp_buffer[0] == '.' && _temp_buffer[1] == 0)
  855.       break;
  856.     if (EOF == (nbytes += fprintf(fp, "%s%s\n", ctld ? "0R" : "", _temp_buffer))) {
  857.       if (fp != NULL)
  858.         fclose(fp);
  859.       return 0;
  860.     }
  861.     if (nbytes > rbytes) {
  862.       go_back(wherex(), pos);
  863.       output("%ld/%ld", nbytes, size);
  864.       rbytes += 512L;
  865.     }
  866.   }
  867.   if (fp != NULL)
  868.     fclose(fp);
  869.   go_back(wherex(), pos);
  870.   output("message received!");
  871.   return 1;
  872.   SOCK_READ_ERR(POP);
  873.   return 0;
  874. }
  875.  
  876. int pop_delete(Mail_Socket * POP_sock, unsigned int msg_num)
  877. {
  878.   sprintf(_temp_buffer, "DELE %u", msg_num);
  879.   sock_puts(POP_sock->sock, _temp_buffer);
  880.   sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  881.   sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  882.   if (DEBUG)
  883.     output("\nPOP> %s", _temp_buffer);
  884.   if (*_temp_buffer != '+') {
  885.     POP_Err_Cond = POP_NOT_MSG;
  886.     if (DEBUG) {
  887.       sprintf(POP_Err_Msg, "No message #%u", msg_num);
  888.       output("\n%s", POP_Err_Msg);
  889.     }
  890.     return 2;
  891.   }
  892.   return 1;
  893.   SOCK_READ_ERR(POP);
  894.   return 0;
  895. }
  896.  
  897.  
  898. int pop_shutdown(Mail_Socket * POP_sock)
  899. {
  900.   if (POP_sock->sock) {
  901.     sock_puts(POP_sock->sock, "QUIT");
  902.     sock_wait_input(POP_sock->sock, SOCK_DELAY, NULL, &POP_stat);
  903.     sock_gets(POP_sock->sock, _temp_buffer, sizeof(_temp_buffer));
  904.     if (*_temp_buffer != '+') {
  905.       POP_Err_Cond = POP_UNKNOWN;
  906.       if (DEBUG) {
  907.         sprintf(POP_Err_Msg, "Unable to update mailbox!");
  908.         output("\n%s", POP_Err_Msg);
  909.     }
  910.       return 0;
  911.     } else
  912.       output("\n ■ Closed and updated mailbox on %s.", POPHOST);
  913.     sock_close(POP_sock->sock);
  914.     return 1;
  915.   }
  916. sock_err:
  917.   free_Mail_Socket(POP_sock);
  918.   return 0;
  919. }
  920.  
  921. int pop_get_nextf(Mail_Socket * POP_sock, char *fn, int msgnum)
  922. {
  923.   if (!pop_getf(POP_sock, fn, msgnum))
  924.     return 0;
  925.   return (pop_delete(POP_sock, msgnum));
  926. }
  927.  
  928. int exist(char *s)
  929. {
  930.   int i;
  931.   struct ffblk ff;
  932.  
  933.   i = findfirst(s, &ff, FA_HIDDEN);
  934.   if (i)
  935.     return 0;
  936.   else
  937.     return 1;
  938. }
  939.  
  940. void main(int argc, char *argv[])
  941. {
  942.   unsigned int count;
  943.   unsigned long size;
  944.   int i, i1, okpkt, result;
  945.   char temp[181], s[21], s1[21];
  946.   FILE *fp;
  947.   Mail_Socket *pop_sock = NULL;
  948.   Mail_Socket *smtp_sock = NULL;
  949.  
  950.   detect_multitask();
  951.  
  952.   if (strncmpi(argv[1], "-send", strlen(argv[1])) == 0) {
  953.     if (argc < 5)
  954.       exit(EXIT_FAILURE);
  955.     output("- %s - [Space] skips", argv[2]);
  956.     if (argc == 6)
  957.       DEBUG = atoi(argv[5]);
  958.     if ((smtp_sock = smtp_start(argv[2], argv[3])) != NULL) {
  959.       if ((fp = fsh_open(argv[4], "r")) != NULL) {
  960.         result = (smtp_sendf(smtp_sock, fp));
  961.         switch (result) {
  962.           case 1:
  963.             output("message sent.");
  964.             if (fp != NULL)
  965.               fclose(fp);
  966.             smtp_shutdown(smtp_sock);
  967.             exit(EXIT_SUCCESS);
  968.           case 0:
  969.             output("SMTP failed!");
  970.             if (fp != NULL)
  971.               fclose(fp);
  972.               exit(EXIT_FAILURE);
  973.           case -1:
  974.             output("SMTP abort.");
  975.             if (fp != NULL)
  976.               fclose(fp);
  977.             smtp_shutdown(smtp_sock);
  978.             exit(EXIT_FAILURE);
  979.         }
  980.       } else {
  981.         output("\n ■ Error accessing file %s.", argv[4]);
  982.         smtp_shutdown(smtp_sock);
  983.         exit(EXIT_FAILURE);
  984.       }
  985.     } else
  986.       output(" - socket connect failed.");
  987.   } else if (strncmpi(argv[1], "-receive", strlen(argv[1])) == 0) {
  988.     if (argc < 8) {
  989.       output("Received: ");
  990.       for (i = 0; i < argc; i++)
  991.         output("%s ", argv[i]);
  992.       exit(EXIT_FAILURE);
  993.     }
  994.     strcpy(POPHOST, argv[2]);
  995.     sprintf(from_user, "%s@%s", argv[3], argv[7]);
  996.     if (argc == 9)
  997.       DEBUG = atoi(argv[8]);
  998.     if ((pop_sock = pop_init(argv[2])) != NULL) {
  999.       if (pop_login(pop_sock, argv[3], argv[4])) {
  1000.         if (pop_status(pop_sock, &count, &size)) {
  1001.           okpkt = 0;
  1002.           output("%u message%s (%lu bytes).",
  1003.                  count, count == 1 ? "" : "s", size);
  1004.           i1 = 1;
  1005.           ALLMAIL = atoi(argv[6]);
  1006.           while (i1 <= count) {
  1007.             okpkt = 0;
  1008.             okpkt = pop_top(pop_sock, i1);
  1009.             switch (okpkt) {
  1010.               case -1:
  1011.                 if (!ALLMAIL)
  1012.                   output("\n ■ Non-network message %d left on server.", i1);
  1013.                 else {
  1014.                   i = 0;
  1015.                   sprintf(temp, "%sUNK-%03d.MSG", argv[5], i);
  1016.                   while (exist(temp))
  1017.                     sprintf(temp, "%sUNK-%03d.MSG", argv[5], ++i);
  1018.                   fnsplit(temp, NULL, NULL, s, s1);
  1019.                   output("\n ■ RCV : %3.3d - %-25s - %s%s", i1, "non-network packet", s, s1);
  1020.                   result = (pop_get_nextf(pop_sock, temp, i1));
  1021.                   switch (result) {
  1022.                     case 0:
  1023.                       output("\n ■ Unable to retrieve message %d.", i1);
  1024.                       result = fcloseall();
  1025.                       if (DEBUG)
  1026.                         output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1027.                       exit(EXIT_FAILURE);
  1028.                     case 1:
  1029.                       break;
  1030.                     case 2:
  1031.                       output("\n ■ Unable to delete message %d from host!", i1);
  1032.                       exit(EXIT_FAILURE);
  1033.                   }
  1034.                 }
  1035.                 break;
  1036.               case 0:
  1037.                 output("\n ■ Error accessing message %d", i1);
  1038.                 result = fcloseall();
  1039.                 if (DEBUG)
  1040.                   output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1041.                 exit(EXIT_FAILURE);
  1042.               case 1:
  1043.                 i = 0;
  1044.                 sprintf(temp, "%sPKT-%03d.UUE", argv[5], i);
  1045.                 while (exist(temp))
  1046.                   sprintf(temp, "%sPKT-%03d.UUE", argv[5], ++i);
  1047.                 fnsplit(temp, NULL, NULL, s, s1);
  1048.                 output("\n ■ RCV : %3.3d - %-25s - %s%s", i1, pktowner, s, s1);
  1049.                 result = (pop_get_nextf(pop_sock, temp, i1));
  1050.                 switch (result) {
  1051.                   case 0:
  1052.                     output("\n ■ Unable to retrieve message %d.", i1);
  1053.                     result = fcloseall();
  1054.                     if (DEBUG)
  1055.                       output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1056.                     exit(EXIT_FAILURE);
  1057.                   case 1:
  1058.                     break;
  1059.                   case 2:
  1060.                     output("\n ■ Unable to delete message %d on host!", i1);
  1061.                     exit(EXIT_FAILURE);
  1062.                 }
  1063.                 break;
  1064.               case 2:
  1065.                 if (!ALLMAIL)
  1066.                   output("\n ■ Non-network message %d left on server.", i1);
  1067.                 else {
  1068.                   i = 0;
  1069.                   sprintf(temp, "%sARC-%03d.UUE", argv[5], i);
  1070.                   while (exist(temp))
  1071.                     sprintf(temp, "%sARC-%03d.UUE", argv[5], ++i);
  1072.                   fnsplit(temp, NULL, NULL, s, s1);
  1073.                   output("\n ■ RCV : %3.3d - %-25s - %s%s", i1, "archived file", s, s1);
  1074.                   result = (pop_get_nextf(pop_sock, temp, i1));
  1075.                   switch (result) {
  1076.                     case 0:
  1077.                       output("\n ■ Unable to retrieve message %d.", i1);
  1078.                       result = fcloseall();
  1079.                       if (DEBUG)
  1080.                         output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1081.                       exit(EXIT_FAILURE);
  1082.                     case 1:
  1083.                       break;
  1084.                     case 2:
  1085.                       output("\n ■ Unable to delete message %d on host!", i1);
  1086.                       exit(EXIT_FAILURE);
  1087.                   }
  1088.                 }
  1089.                 break;
  1090.               case 3:
  1091.                 if (!ALLMAIL)
  1092.                   output("\n ■ Non-network message %d left on server.", i1);
  1093.                 else {
  1094.                   i = 0;
  1095.                   sprintf(temp, "%sGIF-%03d.UUE", argv[5], i);
  1096.                   while (exist(temp))
  1097.                     sprintf(temp, "%sGIF-%03d.UUE", argv[5], ++i);
  1098.                   fnsplit(temp, NULL, NULL, s, s1);
  1099.                   output("\n ■ RCV : %3.3d - %-25s - %s%s", i1, "graphic/image file", s, s1);
  1100.                   result = (pop_get_nextf(pop_sock, temp, i1));
  1101.                   switch (result) {
  1102.                     case 0:
  1103.                       output("\n ■ Unable to retrieve message %d.", i1);
  1104.                       result = fcloseall();
  1105.                       if (DEBUG)
  1106.                         output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1107.                       exit(EXIT_FAILURE);
  1108.                     case 1:
  1109.                       break;
  1110.                     case 2:
  1111.                       output("\n ■ Unable to delete message %d from host!", i1);
  1112.                       exit(EXIT_FAILURE);
  1113.                   }
  1114.                 }
  1115.                 break;
  1116.               case 4:
  1117.                 i = 0;
  1118.                 sprintf(temp, "%sBAD-%03d.UUE", argv[5], i);
  1119.                 while (exist(temp))
  1120.                   sprintf(temp, "%sBAD-%03d.UUE", argv[5], ++i);
  1121.                 fnsplit(temp, NULL, NULL, s, s1);
  1122.                 output("\n ■ RCV : %3.3d - %-25s - %s%s", i1, "mailer-daemon/bounced", s, s1);
  1123.                 result = (pop_get_nextf(pop_sock, temp, i1));
  1124.                 switch (result) {
  1125.                   case 0:
  1126.                     output("\n ■ Unable to retrieve message %d.", i1);
  1127.                     result = fcloseall();
  1128.                     if (DEBUG)
  1129.                       output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1130.                     exit(EXIT_FAILURE);
  1131.                   case 1:
  1132.                     break;
  1133.                   case 2:
  1134.                     output("\n ■ Unable to delete message %d from host!", i1);
  1135.                     exit(EXIT_FAILURE);
  1136.                 }
  1137.                 break;
  1138.             }
  1139.             i1++;
  1140.             result = fcloseall();
  1141.             if (DEBUG)
  1142.               output("\n ■ Closed %d open file%s", result, result == 1 ? "" : "s");
  1143.           }
  1144.           output("\n ■ Mailbox scan of %d messages completed.", count);
  1145.         } else
  1146.           output("\n ■ Unknown POP access error - try again later.");
  1147.         pop_shutdown(pop_sock);
  1148.         exit(EXIT_SUCCESS);
  1149.       } else {
  1150.         output("\n ■ Unable to log into POP server!");
  1151.         pop_shutdown(pop_sock);
  1152.       }
  1153.     } else
  1154.       output("\n ■ POP socket connect failed.");
  1155.   }
  1156.   exit(EXIT_FAILURE);
  1157. }
  1158.