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