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