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