home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / PPPBCKP / SRC15B48.ZIP / UUMAIN.C < prev    next >
C/C++ Source or Header  |  1997-10-07  |  30KB  |  1,269 lines
  1. #include <stdio.h>
  2. #include <stdarg.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <dir.h>
  6. #include <dos.h>
  7. #include <share.h>
  8. #include <sys\stat.h>
  9. #include <alloc.h>
  10. #include <io.h>
  11. #include <fcntl.h>
  12. #include <time.h>
  13. #include <errno.h>
  14. #include <process.h>
  15. #include "uu.h"
  16. #include "net.h"
  17. #include "vardec.h"
  18. #include "version.h"
  19. #include "retcode.h"
  20.  
  21. #define MAX_BUF 1024
  22. #define MAX_DIZ_LINES 10
  23.  
  24. #define SHARE_LEVEL 10
  25. #define WAIT_TIME 10
  26. #define TRIES 100
  27. #define MT_DESQVIEW 0x01
  28. #define MT_WINDOWS  0x02
  29. #define MT_OS2      0x04
  30. #define MT_NB       0x40
  31.  
  32. #define SETREC(f,i)  sh_lseek(f,((long) (i)) * \
  33.     ((long)sizeof(uploadsrec)), SEEK_SET);
  34.  
  35. #define LAST(s) s[strlen(s)-1]
  36.  
  37. extern unsigned _stklen = 10240;
  38.  
  39. char net_name[21], net_data[MAXPATH], fdldesc[81], fdlfn[40], fdlupby[40], edlfn[MAXPATH];
  40. char temp_dir[MAXPATH], maindir[MAXPATH], dlfn[MAXPATH];
  41. char *xenviron[50];
  42. unsigned short fdltype;
  43. int num_dirs, numf, multitasker = 0;
  44. char *version = "Freeware PPP Project UU Encode/Decode " VERSION;
  45.  
  46. directoryrec huge *directories;
  47. configrec syscfg;
  48. void dv_pause(void)
  49. {
  50.   __emit__(0xb8, 0x1a, 0x10, 0xcd, 0x15);
  51.   __emit__(0xb8, 0x00, 0x10, 0xcd, 0x15);
  52.   __emit__(0xb8, 0x25, 0x10, 0xcd, 0x15);
  53. }
  54.  
  55. void win_pause(void)
  56. {
  57.   __emit__(0x55, 0xb8, 0x80, 0x16, 0xcd, 0x2f, 0x5d);
  58. }
  59.  
  60. int get_dos_version(void)
  61. {
  62.   _AX = 0x3000;
  63.   geninterrupt(0x21);
  64.   if (_AX % 256 >= 10) {
  65.     multitasker |= MT_OS2;
  66.   }
  67.   return (_AX);
  68. }
  69.  
  70. int get_dv_version(void)
  71. {
  72.   int v;
  73.  
  74.   if (multitasker & MT_OS2)
  75.     return 0;
  76.   _AX = 0x2b01;
  77.   _CX = 0x4445;
  78.   _DX = 0x5351;
  79.   geninterrupt(0x21);
  80.   if (_AL == 0xff) {
  81.     return 0;
  82.   } else {
  83.     v = _BX;
  84.     multitasker |= MT_DESQVIEW;
  85.     return v;
  86.   }
  87. }
  88.  
  89. int get_win_version(void)
  90. {
  91.   int v = 0;
  92.  
  93.   __emit__(0x55, 0x06, 0x53);
  94.   _AX = 0x352f;
  95.   geninterrupt(0x21);
  96.   _AX = _ES;
  97.   if (_AX | _BX) {
  98.     _AX = 0x1600;
  99.     geninterrupt(0x2f);
  100.     v = _AX;
  101.     if (v % 256 <= 1)
  102.       v = 0;
  103.   }
  104.   __emit__(0x5b, 0x07, 0x5d);
  105.   if (v != 0)
  106.     multitasker |= MT_WINDOWS;
  107.   return (v);
  108. }
  109.  
  110. int get_nb_version(void)
  111. {
  112.   _AX = 0;
  113.   geninterrupt(0x2A);
  114.   return (_AH);
  115. }
  116.  
  117. void detect_multitask(void)
  118. {
  119.   get_dos_version();
  120.   get_win_version();
  121.   get_dv_version();
  122.   if (multitasker < 2)
  123.     if (get_nb_version())
  124.       multitasker = MT_NB;
  125. }
  126.  
  127. void giveup_timeslice(void)
  128. {
  129.   if (multitasker) {
  130.     switch (multitasker) {
  131.  case 1: 
  132.  case 3: 
  133.         dv_pause();
  134.         break;
  135.       case 2:
  136.       case 4:
  137.       case 5:
  138.       case 6:
  139.       case 7:
  140.         win_pause();
  141.         break;
  142.       default:
  143.         break;
  144.     }
  145.   }
  146. }
  147.  
  148. int sh_read(int handle, void *buf, unsigned len)
  149. {
  150.   if (handle == -1) {
  151.     return (-1);
  152.   }
  153.   return (read(handle, buf, len));
  154. }
  155.  
  156. long sh_lseek(int handle, long offset, int fromwhere)
  157. {
  158.   if (handle == -1) {
  159.     return (-1L);
  160.   }
  161.   return (lseek(handle, offset, fromwhere));
  162. }
  163.  
  164. int sh_write(int handle, void *buffer, unsigned long len)
  165. {
  166.   if (handle == -1) {
  167.     return (-1);
  168.   }
  169.   return (write(handle, buffer, (unsigned) len));
  170. }
  171.  
  172. int sh_close(int f)
  173. {
  174.   if (f != -1)
  175.     close(f);
  176.   return (-1);
  177. }
  178.  
  179. int sh_open(char *path, int file_access, unsigned fmode)
  180. {
  181.   int handle, count, share;
  182.   char drive[MAXDRIVE], dir[MAXDIR], file[MAXFILE], ext[MAXEXT];
  183.  
  184.   if ((file_access & O_RDWR) || (file_access & O_WRONLY) || (fmode & S_IWRITE)) {
  185.     share = SH_DENYRW;
  186.   } else {
  187.     share = SH_DENYWR;
  188.   }
  189.   handle = open(path, file_access | share, fmode);
  190.   if (handle < 0) {
  191.     count = 1;
  192.     fnsplit(path, drive, dir, file, ext);
  193.     if (access(path, 0) != -1) {
  194.       delay(WAIT_TIME);
  195.       handle = open(path, file_access | share, fmode);
  196.       while (((handle < 0) && (errno == EACCES)) && (count < TRIES)) {
  197.         if (count % 2)
  198.           delay(WAIT_TIME);
  199.         else
  200.           giveup_timeslice();
  201.         count++;
  202.         handle = open(path, file_access | share, fmode);
  203.       }
  204.     }
  205.   }
  206.   return (handle);
  207. }
  208.  
  209. int sh_open1(char *path, int access)
  210. {
  211.   unsigned fmode;
  212.  
  213.   fmode = 0;
  214.   if ((access & O_RDWR) || (access & O_WRONLY))
  215.     fmode |= S_IWRITE;
  216.   if ((access & O_RDWR) || (access & O_RDONLY))
  217.     fmode |= S_IREAD;
  218.   return (sh_open(path, access, fmode));
  219. }
  220.  
  221. #define MAX_XFER 61440L
  222.  
  223. long huge_xfer(int fd, void huge * buf, unsigned sz, unsigned nel, int wr)
  224. {
  225.   long nxfr = 0, len = ((long) sz) * ((long) nel);
  226.   char huge *xbuf = (char huge *) buf;
  227.   unsigned cur, cur1;
  228.  
  229.   while (len > 0) {
  230.  
  231.     if (len > MAX_XFER)
  232.       cur = (unsigned int) MAX_XFER;
  233.     else
  234.       cur = (unsigned int) len;
  235.  
  236.     if (wr)
  237.       cur1 = sh_write(fd, (char *) xbuf, cur);
  238.     else
  239.       cur1 = sh_read(fd, (char *) xbuf, cur);
  240.  
  241.     if (cur1 != 65535L) {
  242.       len -= cur1;
  243.       nxfr += cur1;
  244.       xbuf = ((char huge *) buf) + nxfr;
  245.     }
  246.     if (cur1 != cur)
  247.       break;
  248.   }
  249.  
  250.   return (nxfr);
  251. }
  252.  
  253. void output(char *fmt,...)
  254. {
  255.   va_list v;
  256.   char s[255];
  257.  
  258.   va_start(v, fmt);
  259.   vsprintf(s, fmt, v);
  260.   va_end(v);
  261.   fputs(s, stderr);
  262. }
  263.  
  264.  
  265.  
  266. void far *mallocx(unsigned long l)
  267. {
  268.   void *x;
  269.   char huge *xx;
  270.  
  271.   if (!l)
  272.     l = 1;
  273.   x = farmalloc(l);
  274.   if (!x) {
  275.     output("\n ■ Insufficient memory (%ld bytes) to read all directories.", l);
  276.     return NULL;
  277.   }
  278.   xx = (char huge *) x;
  279.   while (l >= 1) {
  280.     if (l > 32768L) {
  281.       memset((void *) xx, 0, 32768L);
  282.       l -= 32768L;
  283.       xx += 32768L;
  284.     } else {
  285.       memset((void *) xx, 0, l);
  286.       break;
  287.     }
  288.   }
  289.   return (x);
  290. }
  291.  
  292. int scanfor(char *token, FILE * in)
  293. {
  294.   char buf[MAX_BUF];
  295.   long pos;
  296.  
  297.   pos = ftell(in);
  298.   while (fgets(buf, MAX_BUF, in) && strncmpi(buf, token, strlen(token))) {
  299.     pos = ftell(in);
  300.   }
  301.   rewind(in);
  302.   fseek(in, pos, 0);
  303.   pos = ftell(in);
  304.   return (!strncmpi(buf, "begin 6", 7));
  305. }
  306.  
  307. unsigned char *trimstr1(unsigned char *s)
  308. {
  309.   int i;
  310.   static char *whitespace = " \r\n\t";
  311.  
  312.   i = strlen(s);
  313.   while ((i > 0) && (_fstrchr(whitespace, s[i - 1])))
  314.     --i;
  315.   while ((i > 0) && (_fstrchr(whitespace, *s))) {
  316.     memmove(s, s + 1, --i);
  317.   }
  318.   s[i] = 0;
  319.   return (s);
  320. }
  321.  
  322.  
  323. void scanfdl(FILE * in)
  324. {
  325.   char *ss, buf[MAX_BUF];
  326.   int done = 0;
  327.  
  328.   while ((fgets(buf, MAX_BUF, in)) && !done) {
  329.     ss = NULL;
  330.     if (strncmpi(buf, "subject:", 8) == 0) {
  331.       if (strstr(buf, "FILE TRANSFER")) {
  332.         ss = strtok(buf, "@");
  333.         if (ss) {
  334.           ss = strtok(NULL, " ");
  335.           strcpy(net_name, ss);
  336.           ss = strtok(NULL, ":");
  337.           if (ss) {
  338.             ss = strtok(NULL, "\r\n");
  339.             if (ss) {
  340.               strcpy(fdlfn, ss);
  341.               trimstr1(fdlfn);
  342.             }
  343.           }
  344.         }
  345.       }
  346.     } else
  347.       if (strncmpi(buf, "Description:", 12) == 0) {
  348.       ss = strtok(buf, " ");
  349.       if (ss) {
  350.         ss = strtok(NULL, "\r\n");
  351.         strcpy(fdldesc, ss);
  352.       }
  353.     } else
  354.       if (strncmpi(buf, "FDL Type:", 9) == 0) {
  355.       ss = strtok(buf, ":");
  356.       if (ss) {
  357.         ss = strtok(NULL, "\r\n");
  358.         trimstr1(ss);
  359.         fdltype = atoi(ss);
  360.       }
  361.     } else
  362.       if (strncmpi(buf, "Originating System:", 19) == 0) {
  363.       ss = strtok(buf, ":");
  364.       if (ss) {
  365.         ss = strtok(NULL, "\r\n");
  366.         trimstr1(ss);
  367.         strcpy(fdlupby, ss);
  368.       }
  369.     } else
  370.       if (strncmpi(buf, "begin 600", 9) == 0)
  371.       done = 1;
  372.   }
  373.   return;
  374. }
  375.  
  376. void cd_to(char *s)
  377. {
  378.   char s1[81];
  379.   int i, db;
  380.  
  381.   strcpy(s1, s);
  382.   i = strlen(s1) - 1;
  383.   db = (s1[i] == '\\');
  384.   if (i == 0)
  385.     db = 0;
  386.   if ((i == 2) && (s1[1] == ':'))
  387.     db = 0;
  388.   if (db)
  389.     s1[i] = 0;
  390.   chdir(s1);
  391.   if (s[1] == ':') {
  392.     setdisk(s[0] - 'A');
  393.     if (s[2] == 0)
  394.       chdir("\\");
  395.   }
  396. }
  397.  
  398. void get_dir(char *s, int be)
  399. {
  400.   strcpy(s, "X:\\");
  401.   s[0] = 'A' + getdisk();
  402.   getcurdir(0, &(s[3]));
  403.   if (be) {
  404.     if (s[strlen(s) - 1] != '\\')
  405.       strcat(s, "\\");
  406.   }
  407. }
  408.  
  409. int exist(char *s)
  410. {
  411.   int i;
  412.   struct ffblk ff;
  413.  
  414.   i = findfirst(s, &ff, FA_HIDDEN);
  415.   if (i)
  416.     return (0);
  417.   else
  418.     return (1);
  419. }
  420.  
  421. int copyfile(int display, char *infile, char *outfile)
  422. {
  423.   int f1, f2, i;
  424.   char *b, s[181], s1[21], s2[81], s3[81];
  425.   struct ftime ft;
  426.  
  427.   if ((strcmp(infile, outfile) != 0) && (exist(infile))) {
  428.     if (exist(outfile)) {
  429.       fnsplit(outfile, s3, s2, s1, NULL);
  430.       i = 0;
  431.       sprintf(s, "%s%s%s.%03d", s3, s2, s1, i);
  432.       while (exist(s))
  433.         sprintf(s, "%s%s%s.%03d", s3, s2, s1, ++i);
  434.       strcpy(outfile, s);
  435.     }
  436.     fnsplit(outfile, NULL, NULL, s3, s2);
  437.     if (display)
  438.       output(" as %s%s", s3, s2);
  439.     if ((b = (char *) farmalloc(16400)) == NULL)
  440.       return 1;
  441.     f1 = open(infile, O_RDONLY | O_BINARY, S_IREAD | S_IWRITE);
  442.     if (!f1) {
  443.       farfree(b);
  444.       return 1;
  445.     }
  446.     getftime(f1, &ft);
  447.     f2 = open(outfile, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
  448.     if (!f2) {
  449.       farfree(b);
  450.       close(f1);
  451.       return 1;
  452.     }
  453.     i = read(f1, (void *) b, 16384);
  454.     while (i > 0) {
  455.       write(f2, (void *) b, i);
  456.       i = read(f1, (void *) b, 16384);
  457.     }
  458.     f1 = close(f1);
  459.     setftime(f2, &ft);
  460.     f2 = close(f2);
  461.     farfree(b);
  462.   }
  463.   return 0;
  464. }
  465.  
  466. char *stripfn(char *fn)
  467. {
  468.   static char ofn[15];
  469.   int i, i1;
  470.   char s[81];
  471.  
  472.   i1 = -1;
  473.   for (i = 0; i < strlen(fn); i++)
  474.     if ((fn[i] == '\\') || (fn[i] == ':') || (fn[i] == '/'))
  475.       i1 = i;
  476.   if (i1 != -1)
  477.     strcpy(s, &(fn[i1 + 1]));
  478.   else
  479.     strcpy(s, fn);
  480.   for (i = 0; i < strlen(s); i++)
  481.     if ((s[i] >= 'A') && (s[i] <= 'Z'))
  482.       s[i] = s[i] - 'A' + 'a';
  483.   i = 0;
  484.   while (s[i] != 0) {
  485.     if (s[i] == 32)
  486.       strcpy(&s[i], &s[i + 1]);
  487.     else
  488.       ++i;
  489.   }
  490.   strcpy(ofn, s);
  491.  
  492.   return (ofn);
  493. }
  494.  
  495. void ssm(char *s)
  496. {
  497.   int f, i, i1;
  498.   char s1[161];
  499.   shortmsgrec sm;
  500.  
  501.   sprintf(s1, "%sSMW.DAT", syscfg.datadir);
  502.   f = sh_open(s1, O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  503.   if (f < 0)
  504.     return;
  505.   i = (int) (filelength(f) / sizeof(shortmsgrec));
  506.   i1 = i - 1;
  507.   if (i1 >= 0) {
  508.     sh_lseek(f, ((long) (i1)) * sizeof(shortmsgrec), SEEK_SET);
  509.     sh_read(f, (void *) &sm, sizeof(shortmsgrec));
  510.     while ((sm.tosys == 0) && (sm.touser == 0) && (i1 > 0)) {
  511.       --i1;
  512.       sh_lseek(f, ((long) (i1)) * sizeof(shortmsgrec), SEEK_SET);
  513.       sh_read(f, (void *) &sm, sizeof(shortmsgrec));
  514.     }
  515.     if ((sm.tosys) || (sm.touser))
  516.       ++i1;
  517.   } else
  518.     i1 = 0;
  519.   sm.tosys = 0;
  520.   sm.touser = 1;
  521.   strncpy(sm.message, s, 80);
  522.   sm.message[80] = 0;
  523.   sh_lseek(f, ((long) (i1)) * sizeof(shortmsgrec), SEEK_SET);
  524.   sh_write(f, (void *) &sm, sizeof(shortmsgrec));
  525.   sh_close(f);
  526. }
  527.  
  528. int do_it(char *cl)
  529. {
  530.   int i, i1, l, result;
  531.   char s[101], *ss[50];
  532.  
  533.   strcpy(s, cl);
  534.   ss[0] = s;
  535.   i = 1;
  536.   l = strlen(s);
  537.   for (i1 = 1; i1 < l; i1++)
  538.     if (s[i1] == 32) {
  539.       s[i1] = 0;
  540.       ss[i++] = &(s[i1 + 1]);
  541.     }
  542.   ss[i] = NULL;
  543.   result = spawnvpe(P_WAIT, ss[0], ss, xenviron);
  544.   return result;
  545. }
  546.  
  547. void align(char *s)
  548. {
  549.   char f[40], e[40], s1[20], *s2;
  550.   int i, i1, i2;
  551.  
  552.   i1 = 0;
  553.   if (s[0] == '.')
  554.     i1 = 1;
  555.   for (i = 0; i < strlen(s); i++)
  556.     if ((s[i] == '\\') || (s[i] == '/') || (s[i] == ':') || (s[i] == '<') ||
  557.         (s[i] == '>') || (s[i] == '|'))
  558.       i1 = 1;
  559.   if (i1) {
  560.     strcpy(s, "!");
  561.     return;
  562.   }
  563.   s2 = strchr(s, '.');
  564.   if (s2 == NULL) {
  565.     e[0] = 0;
  566.   } else {
  567.     strcpy(e, &(s2[1]));
  568.     e[3] = 0;
  569.     s2[0] = 0;
  570.   }
  571.   strcpy(f, s);
  572.  
  573.   for (i = strlen(f); i < 8; i++)
  574.     f[i] = 32;
  575.   f[8] = 0;
  576.   i1 = 0;
  577.   i2 = 0;
  578.   for (i = 0; i < 8; i++) {
  579.     if (f[i] == '*')
  580.       i1 = 1;
  581.     if (f[i] == ' ')
  582.       i2 = 1;
  583.     if (i2)
  584.       f[i] = ' ';
  585.     if (i1)
  586.       f[i] = '?';
  587.   }
  588.  
  589.   for (i = strlen(e); i < 3; i++)
  590.     e[i] = 32;
  591.   e[3] = 0;
  592.   i1 = 0;
  593.   for (i = 0; i < 3; i++) {
  594.     if (e[i] == '*')
  595.       i1 = 1;
  596.     if (i1)
  597.       e[i] = '?';
  598.   }
  599.  
  600.   for (i = 0; i < 12; i++)
  601.     s1[i] = 32;
  602.   strcpy(s1, f);
  603.   s1[8] = '.';
  604.   strcpy(&(s1[9]), e);
  605.   strcpy(s, s1);
  606.   strupr(s);
  607. }
  608.  
  609.  
  610. void stuff_in(char *s, char *s1, char *f1, char *f2, char *f3, char *f4, char *f5)
  611. {
  612.   int r = 0, w = 0;
  613.  
  614.   while (s1[r] != 0) {
  615.     if (s1[r] == '%') {
  616.       ++r;
  617.       s[w] = 0;
  618.       switch (s1[r]) {
  619.         case '1':
  620.           strcat(s, f1);
  621.           break;
  622.         case '2':
  623.           strcat(s, f2);
  624.           break;
  625.         case '3':
  626.           strcat(s, f3);
  627.           break;
  628.         case '4':
  629.           strcat(s, f4);
  630.           break;
  631.         case '5':
  632.           strcat(s, f5);
  633.           break;
  634.       }
  635.       w = strlen(s);
  636.       r++;
  637.     } else
  638.       s[w++] = s1[r++];
  639.   }
  640.   s[w] = 0;
  641. }
  642.  
  643. char upcase(char ch)
  644. {
  645.   if ((ch > '`') && (ch < '{'))
  646.     ch = ch - 32;
  647.   return (ch);
  648. }
  649.  
  650.  
  651. char *make_abs_cmd(char *out)
  652. {
  653.   char s[161], s1[161], s2[161], *ss, *ss1;
  654.   char *exts[] = {"", ".COM", ".EXE", ".BAT", 0};
  655.   int i;
  656.  
  657.   strcpy(s1, out);
  658.  
  659.   if (s1[1] == ':') {
  660.     if (s1[2] != '\\') {
  661.       getcurdir(upcase(s1[0]) - 'A' + 1, s);
  662.       sprintf(out, "%c:\\%s\\%s", s1[0], s, s1 + 2);
  663.     }
  664.     goto got_cmd;
  665.   }
  666.   if (out[0] == '\\') {
  667.     sprintf(out, "%c:%s", maindir[0], s1);
  668.     goto got_cmd;
  669.   }
  670.   ss = strchr(s1, ' ');
  671.   if (ss) {
  672.     *ss = 0;
  673.     sprintf(s2, " %s", ss + 1);
  674.   } else {
  675.     s2[0] = 0;
  676.   }
  677.   for (i = 0; exts[i]; i++) {
  678.     if (i == 0) {
  679.       ss1 = strrchr(s1, '\\');
  680.       if (!ss1)
  681.         ss1 = s1;
  682.       if (strchr(ss1, '.') == 0)
  683.         continue;
  684.     }
  685.     sprintf(s, "%s%s", s1, exts[i]);
  686.     if (exist(s)) {
  687.       sprintf(out, "%s%s%s", maindir, s, s2);
  688.       goto got_cmd;
  689.     } else {
  690.       ss1 = searchpath(s);
  691.       if (ss1) {
  692.         sprintf(out, "%s%s", ss1, s2);
  693.         goto got_cmd;
  694.       }
  695.     }
  696.   }
  697.  
  698.   sprintf(out, "%s%s%s", maindir, s1, s2);
  699.  
  700. got_cmd:
  701.   return (out);
  702. }
  703.  
  704.  
  705. void get_arc_cmd(char *out, char *arcfn, int cmd, char *ofn)
  706. {
  707.   char *ss, s[161];
  708.   int i;
  709.  
  710.   out[0] = 0;
  711.   ss = strchr(arcfn, '.');
  712.   if (ss == NULL)
  713.     return;
  714.   ++ss;
  715.   for (i = 0; i < 4; i++)
  716.     if (stricmp(ss, syscfg.arcs[i].extension) == 0) {
  717.       switch (cmd) {
  718.         case 0:
  719.           strcpy(s, syscfg.arcs[i].arcl);
  720.           break;
  721.         case 1:
  722.           strcpy(s, syscfg.arcs[i].arce);
  723.           break;
  724.         case 2:
  725.           strcpy(s, syscfg.arcs[i].arca);
  726.           break;
  727.       }
  728.       if (s[0] == 0)
  729.         return;
  730.       stuff_in(out, s, arcfn, ofn, "", "", "");
  731.       make_abs_cmd(out);
  732.       return;
  733.     }
  734. }
  735.  
  736. void add_extended_description(char *fn, char *desc)
  737. {
  738.   ext_desc_type ed;
  739.   int f;
  740.  
  741.   strcpy(ed.name, fn);
  742.   ed.len = strlen(desc);
  743.   f = sh_open(edlfn, O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  744.   sh_lseek(f, 0L, SEEK_END);
  745.   sh_write(f, &ed, sizeof(ext_desc_type));
  746.   sh_write(f, desc, ed.len);
  747.   f = sh_close(f);
  748. }
  749.  
  750.  
  751.  
  752. int get_file_idz(uploadsrec * u, directoryrec * d)
  753. {
  754.   char *b, *ss, cmd[255], cmdline[255], s3[121], s4[121];
  755.   int f, i, ok = 0;
  756.  
  757.   ss = strchr(stripfn(u->filename), '.');
  758.   if (ss == NULL)
  759.     return 1;
  760.   ++ss;
  761.   for (i = 0; i < 4 && !ok; i++)
  762.     if (!ok)
  763.       ok = (stricmp(ss, syscfg.arcs[i].extension) == 0);
  764.   if (!ok)
  765.     return 1;
  766.   sprintf(s4, "%sFILE_ID.DIZ", temp_dir);
  767.   unlink(s4);
  768.   sprintf(s4, "%sDESC.SDI", temp_dir);
  769.   unlink(s4);
  770.   strcpy(s3, d->path);
  771.   cd_to(s3);
  772.   get_dir(s4, 1);
  773.   strcat(s4, stripfn(u->filename));
  774.   cd_to(maindir);
  775.   get_arc_cmd(cmd, s4, 1, "FILE_ID.DIZ DESC.SDI");
  776.   sprintf(cmdline, "%s", cmd);
  777.   cd_to(temp_dir);
  778.   do_it(cmdline);
  779.   cd_to(maindir);
  780.   sprintf(s4, "%sFILE_ID.DIZ", temp_dir);
  781.   if (!exist(s4))
  782.     sprintf(s4, "%sDESC.SDI", temp_dir);
  783.   if (exist(s4)) {
  784.     stripfn(s4);
  785.     if ((b = (char *) farmalloc((long) MAX_DIZ_LINES * 256 + 1)) == NULL)
  786.       return 1;
  787.     f = sh_open1(s4, O_RDONLY | O_BINARY);
  788.     if (filelength(f) < (MAX_DIZ_LINES * 256)) {
  789.       sh_read(f, b, (int) filelength(f));
  790.       b[filelength(f)] = 0;
  791.     } else {
  792.       sh_read(f, b, (int) MAX_DIZ_LINES * 256);
  793.       b[(int) MAX_DIZ_LINES * 256] = 0;
  794.     }
  795.     sh_close(f);
  796.     ss = strtok(b, "\n");
  797.     if (LAST(ss) == '\r')
  798.       LAST(ss) = '\0';
  799.     sprintf(u->description, "%.58s", ss);
  800.     ss = strtok(NULL, "");
  801.     if (ss) {
  802.       for (i = strlen(ss) - 1; i > 0; i--) {
  803.         if ((ss[i] == 26) || (ss[i] == 12))
  804.           ss[i] = 32;
  805.       }
  806.       add_extended_description(u->filename, ss);
  807.       u->mask |= mask_extended;
  808.     }
  809.     if (b)
  810.       farfree(b);
  811.     sprintf(s4, "%sFILE_ID.DIZ", temp_dir);
  812.     unlink(s4);
  813.     sprintf(s4, "%sDESC.SDI", temp_dir);
  814.     unlink(s4);
  815.   }
  816.   return 0;
  817. }
  818.  
  819.  
  820. static char *fdldate(void)
  821. {
  822.   char *ds;
  823.   struct date today;
  824.  
  825.   ds = NULL;
  826.   getdate(&today);
  827.   sprintf(ds, "%02d/%02d/%02d", today.da_mon, today.da_day, today.da_year - 1900);
  828.   return ds;
  829. }
  830.  
  831. int compare(char *s1, char *s2)
  832. {
  833.   int ok, i;
  834.  
  835.   ok = 1;
  836.   for (i = 0; i < 12; i++)
  837.     if ((s1[i] != s2[i]) && (s1[i] != '?') && (s2[i] != '?'))
  838.       ok = 0;
  839.   return (ok);
  840. }
  841.  
  842. void dliscan(int dn)
  843. {
  844.   int i, f;
  845.   long l;
  846.   uploadsrec u;
  847.   directoryrec d;
  848.  
  849.   d = directories[dn];
  850.   sprintf(dlfn, "%s%s.DIR", syscfg.datadir, d.filename);
  851.   sprintf(edlfn, "%s%s/EXT", syscfg.datadir, d.filename);
  852.   f = sh_open(dlfn, O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  853.   i = filelength(f) / sizeof(uploadsrec);
  854.   if (i == 0) {
  855.     output("\n ■ Creating new directory %s.", dlfn);
  856.     memset(&u, 0, sizeof(uploadsrec));
  857.     strcpy(u.filename, "|MARKER|");
  858.     time(&l);
  859.     u.daten = l;
  860.     SETREC(f, 0);
  861.     sh_write(f, (void *) &u, sizeof(uploadsrec));
  862.   } else {
  863.     SETREC(f, 0);
  864.     sh_read(f, (void *) &u, sizeof(uploadsrec));
  865.     if (strcmp(u.filename, "|MARKER|")) {
  866.       numf = u.numbytes;
  867.       memset(&u, 0, sizeof(uploadsrec));
  868.       strcpy(u.filename, "|MARKER|");
  869.       time(&l);
  870.       u.daten = l;
  871.       u.numbytes = numf;
  872.       SETREC(f, 0);
  873.       sh_write(f, &u, sizeof(uploadsrec));
  874.     }
  875.   }
  876.   if (f > -1)
  877.     f = sh_close(f);
  878.   numf = u.numbytes;
  879. }
  880.  
  881.  
  882.  
  883.  
  884. int recno(char *s)
  885. {
  886.   int i, f;
  887.   uploadsrec u;
  888.  
  889.   i = 1;
  890.   if (numf < 1)
  891.     return (-1);
  892.   f = sh_open1(dlfn, O_RDONLY | O_BINARY);
  893.   SETREC(f, i);
  894.   sh_read(f, (void *) &u, sizeof(uploadsrec));
  895.   while ((i < numf) && (compare(s, u.filename) == 0)) {
  896.     ++i;
  897.     SETREC(f, i);
  898.     sh_read(f, (void *) &u, sizeof(uploadsrec));
  899.   }
  900.   f = sh_close(f);
  901.   if (compare(s, u.filename))
  902.     return i;
  903.   else
  904.     return -1;
  905. }
  906.  
  907.  
  908. void upload_file(int dn, char *fn, char *desc, char *upby)
  909. {
  910.   char s1[MAXPATH], ff[MAXPATH], date[61];
  911.   int f;
  912.   long l;
  913.   directoryrec d;
  914.   uploadsrec u, u1;
  915.  
  916.   d = directories[dn];
  917.  
  918.   strcpy(u.filename, fn);
  919.   align(u.filename);
  920.   u.ownerusr = 1;
  921.   u.ownersys = 0;
  922.   u.numdloads = 0;
  923.   u.filetype = 0;
  924.   u.mask = 0;
  925.   sprintf(ff, "%s%s", d.path, fn);
  926.   f = sh_open1(ff, O_RDONLY | O_BINARY);
  927.   l = filelength(f);
  928.   u.numbytes = l;
  929.   sh_close(f);
  930.   strcpy(u.upby, upby);
  931.   strcpy(u.date, fdldate());
  932.   strcpy(u.description, desc);
  933.   time(&l);
  934.   u.daten = l;
  935.   get_file_idz(&u, &d);
  936.   f = sh_open(dlfn, O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  937.   SETREC(f, 0);
  938.   sh_read(f, &u1, sizeof(uploadsrec));
  939.   numf = u1.numbytes;
  940.   ++numf;
  941.   SETREC(f, numf);
  942.   sh_write(f, (void *) &u, sizeof(uploadsrec));
  943.   SETREC(f, 0);
  944.   sh_read(f, &u1, sizeof(uploadsrec));
  945.   u1.numbytes = numf;
  946.   u1.daten = l;
  947.   SETREC(f, 0);
  948.   sh_write(f, (void *) &u1, sizeof(uploadsrec));
  949.   f = sh_close(f);
  950.   sprintf(s1, "FDL : %s uploaded on %s", u.filename, d.name);
  951.   ssm(s1);
  952.   output("\n ■ %s", s1);
  953. }
  954.  
  955. void free_dirs(void)
  956. {
  957.   if (directories != NULL)
  958.     farfree(directories);
  959.   directories = NULL;
  960. }
  961.  
  962.  
  963. int read_dirs(void)
  964. {
  965.   char fn[MAXPATH];
  966.   int i, f, numdirs = 0;
  967.  
  968.   if (directories != NULL)
  969.     farfree(directories);
  970.   directories = NULL;
  971.   directories = (directoryrec *) mallocx((long) syscfg.max_dirs * (long) sizeof(directoryrec));
  972.   if (directories == NULL)
  973.     output("\n ■ Error : Insufficient memory to read all directories!");
  974.   else {
  975.     sprintf(fn, "%sDIRS.DAT", syscfg.datadir);
  976.     f = sh_open1(fn, O_RDONLY | O_BINARY);
  977.     if (f < 0)
  978.       output("\n ■ Unable to read %s.", fn);
  979.     else {
  980.       numdirs = (int) huge_xfer(f, directories, sizeof(directoryrec),
  981.                                 syscfg.max_dirs, 0) / sizeof(directoryrec);
  982.       f = sh_close(f);
  983.       i = (filelength(f) / numdirs);
  984.       if (i != sizeof(directoryrec)) {
  985.         output("\n ■ Modified directoryrec - no upload attempts.");
  986.         numdirs = -1;
  987.       }
  988.     }
  989.   }
  990.   return numdirs;
  991. }
  992.  
  993.  
  994. void name_file(int msg, char *newname)
  995. {
  996.   int ok;
  997.   struct stat info;
  998.   int i;
  999.  
  1000.   ok = 0;
  1001.   for (i = 0; ((i < 10000) && (!ok)); i++) {
  1002.     sprintf(newname, "%s%s\\%s-%04.04d.MSG",
  1003.             net_data,
  1004.             msg ? "CHECKNET" : "SPOOL",
  1005.             msg ? "CHK" : "UNK",
  1006.             i);
  1007.     if (stat(newname, &info) == -1)
  1008.       ok = 1;
  1009.   }
  1010. }
  1011.  
  1012. void move_bad(char *src)
  1013. {
  1014.   char dest[MAXPATH], file[12], ext[5];
  1015.   int i = 0;
  1016.  
  1017.   fnsplit(src, NULL, NULL, file, ext);
  1018.  
  1019.   sprintf(dest, "%sCHECKNET\\%s%s", net_data, file, ext);
  1020.   while (exist(dest))
  1021.     sprintf(dest, "%sCHECKNET\\%s.%03d", net_data, file, i++);
  1022.  
  1023.   if (copyfile(1, src, dest))
  1024.     unlink(src);
  1025. }
  1026.  
  1027. int init(void)
  1028. {
  1029.   int i, i1, f;
  1030.   char fn[MAXPATH];
  1031.  
  1032.   get_dir(maindir, 1);
  1033.   i = i1 = 0;
  1034.   while (environ[i] != NULL) {
  1035.     xenviron[i1++] = environ[i];
  1036.     ++i;
  1037.   }
  1038.   xenviron[i1] = NULL;
  1039.  
  1040.   sprintf(fn, "%sCONFIG.DAT", maindir);
  1041.   f = sh_open1(fn, O_RDONLY | O_BINARY);
  1042.   if (f < 0) {
  1043.     output("\n ■ Unable to read %s.", fn);
  1044.     return 1;
  1045.   }
  1046.   sh_read(f, (void *) (&syscfg), sizeof(configrec));
  1047.   sh_close(f);
  1048.   return 0;
  1049. }
  1050.  
  1051. main(int argc, char *argv[])
  1052. {
  1053.   char outname[181], buf[MAXPATH], dirfn[21], dirpath[MAXPATH], junk[80];
  1054.   char argfile[21], s1[181], s2[181], s3[21], s4[21], s5[21], fn[MAXPATH];
  1055.   int i, i1, i2, ok, ok1, dn, f, result;
  1056.   unsigned short dirtype;
  1057.   FILE *in, *out, *fp;
  1058.  
  1059.   detect_multitask();
  1060.  
  1061.   ok1 = 0;
  1062.  
  1063.   if (argc == 4 || argc == 5) {
  1064.     if (strcmpi(argv[1], "-encode") == 0 && argc == 4) {
  1065.       if (((in = fopen(argv[2], "r")) != NULL) && ((out = fopen(argv[3], "at+")) != NULL)) {
  1066.         output(" %ld bytes.", uuencode(in, out, argv[2]));
  1067.         if (in != NULL)
  1068.           fclose(in);
  1069.         if (out != NULL)
  1070.           fclose(out);
  1071.         ok1 = EXIT_SUCCESS;
  1072.       } else
  1073.         ok1 = EXIT_FAILURE;
  1074.     } else
  1075.       if (strcmpi(argv[1], "-decode") == 0 && argc == 5) {
  1076.       strcpy(argfile, argv[2]);
  1077.       strcpy(temp_dir, argv[3]);
  1078.       strcpy(net_data, argv[4]);
  1079.       if (init()) {
  1080.         output("\n ■ Failed to initialize UU variables.");
  1081.         ok1 = EXIT_FAILURE;
  1082.       }
  1083.       cd_to(temp_dir);
  1084.       if ((in = fopen(argfile, "r")) != NULL) {
  1085.         net_name[0] = 0;
  1086.         fdldesc[0] = 0;
  1087.         fdltype = 0;
  1088.         fdlfn[0] = 0;
  1089.         scanfdl(in);
  1090.         rewind(in);
  1091.         scanfor("begin", in);
  1092.         result = uudecode(in, temp_dir, outname);
  1093.         if (in != NULL)
  1094.           fclose(in);
  1095.         switch (result) {
  1096.           case UU_NO_MEM:
  1097.             sprintf(s1, "%s%s", temp_dir, argfile);
  1098.             move_bad(s1);
  1099.             cd_to(maindir);
  1100.             sprintf(s1, "Error decoding %s.", argfile);
  1101.             output("\n ■ %s", s1);
  1102.             ssm(s1);
  1103.             ok1 = EXIT_FAILURE;
  1104.             break;
  1105.           case UU_BAD_BEGIN:
  1106.             sprintf(s1, "%s%s", temp_dir, argfile);
  1107.             name_file(0, s2);
  1108.             if (copyfile(1, s1, s2))
  1109.               move_bad(s2);
  1110.             else
  1111.               unlink(s1);
  1112.             cd_to(maindir);
  1113.             ok1 = EXIT_FAILURE;
  1114.             break;
  1115.           case UU_CANT_OPEN:
  1116.             output("\n ■ Cannot open %s%s", argv[4], outname);
  1117.             cd_to(maindir);
  1118.             ok1 = EXIT_FAILURE;
  1119.             break;
  1120.           case UU_CHECKSUM:
  1121.             sprintf(s1, "%s%s", temp_dir, argfile);
  1122.             move_bad(s1);
  1123.             cd_to(maindir);
  1124.             sprintf(s1, "Checksum error decoding %s - moved to CHECKNET!", argfile);
  1125.             output("\n ■ %s", s1);
  1126.             ssm(s1);
  1127.             ok1 = EXIT_FAILURE;
  1128.             break;
  1129.           case UU_BAD_END:
  1130.             sprintf(s1, "%s%s", temp_dir, argfile);
  1131.             move_bad(s1);
  1132.             cd_to(maindir);
  1133.             sprintf(s1, "No \'end\' found in %s - moved to CHECKNET!", argfile);
  1134.             output("\n ■ %s", s1);
  1135.             ssm(s1);
  1136.             ok1 = EXIT_FAILURE;
  1137.             break;
  1138.           case UU_SUCCESS:
  1139.             sprintf(s1, "%s%s", temp_dir, argfile);
  1140.             unlink(s1);
  1141.             output("\n ■ Decoded %s", stripfn(outname));
  1142.             fnsplit(outname, NULL, NULL, s4, s3);
  1143.             sprintf(s5, "%s%s", s4, s3);
  1144.             if ((strcmpi(s3, ".NET") == NULL) && (strncmpi(argfile, "PKT", 3) == NULL)) {
  1145.               i = 0;
  1146.               sprintf(s2, "%sP1-%03d.NET", argv[4], i);
  1147.               while (exist(s2))
  1148.                 sprintf(s2, "%sP1-%03d.NET", argv[4], ++i);
  1149.               sprintf(s1, "%s%s", temp_dir, stripfn(outname));
  1150.               if (copyfile(1, s1, s2)) {
  1151.                 output("\n ■ Error creating %s", s2);
  1152.                 cd_to(maindir);
  1153.                 ok1 = EXIT_FAILURE;
  1154.                 break;
  1155.               } else
  1156.                 unlink(s1);
  1157.             } else {
  1158.               if (fdltype)
  1159.                 sprintf(s1, "Received : %s (FDL %hu)", s5, fdltype);
  1160.               else
  1161.                 sprintf(s1, "Received transferred file : %s.", s5);
  1162.               ssm(s1);
  1163.               output("\n ■ %s", s1);
  1164.               sprintf(s1, "%s%s", temp_dir, s5);
  1165.               num_dirs = read_dirs();
  1166.               if (num_dirs) {
  1167.                 dn = 0;
  1168.                 if (fdltype) {
  1169.                   for (i = 0; (i < num_dirs && !dn); i++) {
  1170.                     if (directories[i].type == fdltype) {
  1171.                       dn = i;
  1172.                       break;
  1173.                     }
  1174.                   }
  1175.                   if (!dn) {
  1176.                     output("\n ■ FDL %hu not in DIREDIT... checking FDLFTS.CFG.",
  1177.                            fdltype);
  1178.                     sprintf(fn, "%s\\FDLFTS.CFG", net_data);
  1179.                     if ((fp = fopen(fn, "rt")) == NULL) {
  1180.                       output("\n ■ %s does not exist... uploading to Sysop.", fn);
  1181.                     } else {
  1182.                       ok = 0;
  1183.                       while ((fgets(buf, 80, fp)) && !ok) {
  1184.                         if (strncmpi(buf, "FDL", 3) == 0) {
  1185.                           sscanf(buf, "%s %hu %s %s", &junk, &dirtype, &dirfn, &dirpath);
  1186.                           if (dirtype == fdltype) {
  1187.                             for (i = 0; i < num_dirs; i++) {
  1188.                               if (strcmp(directories[i].filename, dirfn) == 0) {
  1189.                                 dn = i;
  1190.                                 ok = 1;
  1191.                                 break;
  1192.                               }
  1193.                             }
  1194.                           }
  1195.                         }
  1196.                       }
  1197.                       if (fp != NULL)
  1198.                         fclose(fp);
  1199.                     }
  1200.                   }
  1201.                   if ((!ok) && (fdltype))
  1202.                     output("\n ■ FDL %hu not in FDLFTS.CFG... uploading to Sysop.",
  1203.                            fdltype);
  1204.                 } else {
  1205.                   strcpy(fdldesc, "[No Description Found]");
  1206.                   strcpy(fdlupby, "FILEnet Transfer");
  1207.                 }
  1208.                 sprintf(s1, "%s%s", temp_dir, s5);
  1209.                 sprintf(s2, "%s%s", directories[dn].path, s5);
  1210.                 if (exist(s2)) {
  1211.                   output("\n ■ %s already exists", s2);
  1212.                   move_bad(s1);
  1213.                 } else {
  1214.                   if (copyfile(0, s1, s2)) {
  1215.                     output("\n ■ Error copying %s", s2);
  1216.                     move_bad(s1);
  1217.                   } else {
  1218.                     dliscan(dn);
  1219.                     strcpy(fn, s5);
  1220.                     align(fn);
  1221.                     ok = recno(fn);
  1222.                     if (ok == -1)
  1223.                       upload_file(dn, s5, fdldesc, fdlupby);
  1224.                     else
  1225.                       output("\n ■ %s already in %s.", fn, directories[dn].name);
  1226.                   }
  1227.                 }
  1228.                 unlink(s1);
  1229.               } else {
  1230.                 output("\n ■ Moving %s to CHECKNET", s1);
  1231.                 move_bad(s1);
  1232.               }
  1233.               fdltype = 0;
  1234.               fdlfn[0] = 0;
  1235.               fdldesc[0] = 0;
  1236.               free_dirs();
  1237.             }
  1238.             cd_to(maindir);
  1239.             ok1 = EXIT_SUCCESS;
  1240.             break;
  1241.           default:
  1242.             sprintf(s1, "%s%s", temp_dir, argfile);
  1243.             name_file(1, s2);
  1244.             output("\n ■ Unknown error %s...", s2);
  1245.             if (copyfile(1, s1, s2))
  1246.               output("\n ■ Error during copy...");
  1247.             else
  1248.               unlink(s1);
  1249.             cd_to(maindir);
  1250.             sprintf(s1, "Unknown error %s...", s2);
  1251.             ssm(s1);
  1252.             ok1 = EXIT_FAILURE;
  1253.             break;
  1254.         }
  1255.       } else {
  1256.         cd_to(maindir);
  1257.         output("\n ■ Input file %s not found.", argfile);
  1258.         ok1 = EXIT_FAILURE;
  1259.       }
  1260.       }
  1261.   } else
  1262.     output("\n ■ %s\n", version);
  1263.   if (in != NULL)
  1264.     fclose(in);
  1265.   if (out != NULL)
  1266.     fclose(out);
  1267.   return ok1;
  1268. }
  1269.