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