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