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