home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / MYBBS.ZIP / WINDOWS / DESKTOP / MYBBS / WWIVSOR.ZIP / XFERTMP.C < prev    next >
C/C++ Source or Header  |  1995-05-12  |  23KB  |  1,003 lines
  1. /*****************************************************************************
  2.  
  3.                 WWIV Version 4
  4.                     Copyright (C) 1988-1995 by Wayne Bell
  5.  
  6. Distribution of the source code for WWIV, in any form, modified or unmodified,
  7. without PRIOR, WRITTEN APPROVAL by the author, is expressly prohibited.
  8. Distribution of compiled versions of WWIV is limited to copies compiled BY
  9. THE AUTHOR.  Distribution of any copies of WWIV not compiled by the author
  10. is expressly prohibited.
  11.  
  12.  
  13. *****************************************************************************/
  14.  
  15.  
  16.  
  17. #include "vars.h"
  18.  
  19. #pragma hdrstop
  20.  
  21. #include <dir.h>
  22.  
  23.  
  24. #define SETREC(f,i)  sh_lseek(f,((long) (i))*((long)sizeof(uploadsrec)),SEEK_SET);
  25.  
  26. /* the archive type to use */
  27. #define ARC_NUMBER 0
  28.  
  29.  
  30. /* strings not to allow in a .zip file to extract from */
  31. char *bad_words[] = {
  32.   "COMMAND",
  33.   "..",
  34.   NULL,
  35. };
  36.  
  37. long bad_filename(char *fn)
  38. {
  39.   int i;
  40.  
  41.   strupr(fn);
  42.   for (i=0; bad_words[i]; i++) {
  43.     if (strstr(fn,bad_words[i])) {
  44.       outstr(get_string(840));
  45.       pl(fn);
  46.       return(1);
  47.     }
  48.   }
  49.   if (!okfn(fn)) {
  50.     outstr(get_string(840));
  51.     pl(fn);
  52.     return(1);
  53.   }
  54.   return(0);
  55. }
  56.  
  57. /****************************************************************************/
  58.  
  59. typedef struct {
  60.   unsigned char type;
  61.   char name[13];
  62.   long len;
  63.   int date,time,crc;
  64.   long size;
  65. } arch;
  66.  
  67. int check_for_files_arc(char *fn)
  68. {
  69.   int f;
  70.   char s[20];
  71.   arch a;
  72.   long l1,l;
  73.  
  74.   f=sh_open1(fn,O_RDONLY | O_BINARY);
  75.   if (f>0) {
  76.     l1=filelength(f);
  77.     l=1;
  78.     sh_lseek(f,0L,SEEK_SET);
  79.     sh_read(f,&a,1);
  80.     if (a.type!=26) {
  81.       sh_close(f);
  82.       outstr(stripfn(fn));
  83.       pl(get_string(841));
  84.       return(1);
  85.     }
  86.     while (l<l1) {
  87.       sh_lseek(f,l,SEEK_SET);
  88.       if ((sh_read(f,&a,sizeof(arch)))==sizeof(arch)) {
  89.     l += sizeof(arch);
  90.     if (a.type==1) {
  91.       l-=4;
  92.       a.size=a.len;
  93.     }
  94.     if (a.type) {
  95.       l += a.len;
  96.       ++l;
  97.       strncpy(s,a.name,13);
  98.       s[13]=0;
  99.       if (bad_filename(s)) {
  100.         sh_close(f);
  101.         return(1);
  102.       }
  103.     } else
  104.       l=l1;
  105.       } else {
  106.         sh_close(f);
  107.         if (a.type!=0) {
  108.           outstr(stripfn(fn));
  109.           outstr(get_string(841));
  110.           return(1);
  111.         } else
  112.           l=l1;
  113.       }
  114.     }
  115.  
  116.     sh_close(f);
  117.     return(0);
  118.   }
  119.   outstr(get_string(842));
  120.   pl(stripfn(fn));
  121.   return(1);
  122. }
  123.  
  124. /****************************************************************************/
  125.  
  126. /* .ZIP structures and defines */
  127. #define ZIP_LOCAL_SIG 0x04034b50
  128. #define ZIP_CENT_START_SIG 0x02014b50
  129. #define ZIP_CENT_END_SIG 0x06054b50
  130.  
  131. typedef struct {
  132.   unsigned long         signature;    /* 0x04034b50 */
  133.   unsigned short        extract_ver;
  134.   unsigned short        flags;
  135.   unsigned short        comp_meth;
  136.   unsigned short        mod_time;
  137.   unsigned short        mod_date;
  138.   unsigned long         crc_32;
  139.   unsigned long         comp_size;
  140.   unsigned long         uncomp_size;
  141.   unsigned short        filename_len;
  142.   unsigned short        extra_length;
  143. } zip_local_header;
  144.  
  145. typedef struct {
  146.   unsigned long         signature;    /* 0x02014b50 */
  147.   unsigned short        made_ver;
  148.   unsigned short        extract_ver;
  149.   unsigned short        flags;
  150.   unsigned short        comp_meth;
  151.   unsigned short        mod_time;
  152.   unsigned short        mod_date;
  153.   unsigned long         crc_32;
  154.   unsigned long         comp_size;
  155.   unsigned long         uncomp_size;
  156.   unsigned short        filename_len;
  157.   unsigned short        extra_len;
  158.   unsigned short        comment_len;
  159.   unsigned short        disk_start;
  160.   unsigned short        int_attr;
  161.   unsigned long         ext_attr;
  162.   unsigned long         rel_ofs_header;
  163. } zip_central_dir;
  164.  
  165.  
  166. typedef struct {
  167.   unsigned long         signature;    /* 0x06054b50 */
  168.   unsigned short        disk_num;
  169.   unsigned short        cent_dir_disk_num;
  170.   unsigned short        total_entries_this_disk;
  171.   unsigned short        total_entries_total;
  172.   unsigned long         central_dir_size;
  173.   unsigned long         ofs_cent_dir;
  174.   unsigned short        comment_len;
  175. } zip_end_dir;
  176.  
  177.  
  178. int check_for_files_zip(char *fn)
  179. {
  180.   int f;
  181.   long l,sig,len;
  182.   zip_local_header zl;
  183.   zip_central_dir zc;
  184.   zip_end_dir ze;
  185.   char s[161];
  186.  
  187. #define READ_FN(ln) {sh_read(f,s,ln); s[ln]=0;}
  188.  
  189.   f=sh_open1(fn,O_RDONLY | O_BINARY);
  190.   if (f>0) {
  191.     l=0;
  192.     len=filelength(f);
  193.     while (l<len) {
  194.       sh_lseek(f,l,SEEK_SET);
  195.       sh_read(f,&sig, 4);
  196.       sh_lseek(f,l,SEEK_SET);
  197.       switch(sig) {
  198.         case ZIP_LOCAL_SIG:
  199.           sh_read(f,&zl, sizeof(zl));
  200.           READ_FN(zl.filename_len);
  201.           if (bad_filename(s)) {
  202.             sh_close(f);
  203.             return(1);
  204.           }
  205.           l += sizeof(zl);
  206.           l += zl.comp_size + zl.filename_len + zl.extra_length;
  207.           break;
  208.         case ZIP_CENT_START_SIG:
  209.           sh_read(f,&zc, sizeof(zc));
  210.           READ_FN(zc.filename_len);
  211.           if (bad_filename(s)) {
  212.             sh_close(f);
  213.             return(1);
  214.           }
  215.           l += sizeof(zc);
  216.           l += zc.filename_len + zc.extra_len;
  217.           break;
  218.         case ZIP_CENT_END_SIG:
  219.           sh_read(f,&ze, sizeof(ze));
  220.           sh_close(f);
  221.           return(0);
  222.         default:
  223.           sh_close(f);
  224.           pl(get_string(843));
  225.           return(1);
  226.       }
  227.     }
  228.     sh_close(f);
  229.     return(0);
  230.   }
  231.  
  232.   outstr(get_string(842));
  233.   pl(stripfn(fn));
  234.   return(1);
  235. }
  236.  
  237. /****************************************************************************/
  238.  
  239. typedef struct {
  240.   unsigned char   checksum;
  241.   char            ctype[5];
  242.   long            comp_size;
  243.   long            uncomp_size;
  244.   unsigned short  time;
  245.   unsigned short  date;
  246.   unsigned short  attr;
  247.   unsigned char   fn_len;
  248. } lharc_header;
  249.  
  250.  
  251.  
  252. int check_for_files_lzh(char *fn)
  253. {
  254.   long l1,l;
  255.   int f,err=0;
  256.   unsigned short crc;
  257.   char s[256];
  258.   char flag;
  259.   lharc_header a;
  260.  
  261.   if ((f=sh_open1(fn,O_RDONLY|O_BINARY))<0) {
  262.     outstr(get_string(842));
  263.     pl(stripfn(fn));
  264.     return(1);
  265.   }
  266.   l1=filelength(f);
  267.   for(l=0;l<l1;l+=a.fn_len+a.comp_size+sizeof(lharc_header)+sh_read(f,&crc,sizeof(crc))+1) {
  268.     sh_lseek(f,l,SEEK_SET);
  269.     sh_read(f,&flag,1);
  270.     if (!flag) {
  271.       l=l1;
  272.       break;
  273.     }
  274.     if ((sh_read(f,&a,sizeof(lharc_header)))!=sizeof(lharc_header)) {
  275.       outstr(stripfn(fn));
  276.       pl(get_string(844));
  277.       err=1;
  278.       break;
  279.     }
  280.     if (sh_read(f,s,a.fn_len)!=a.fn_len) {
  281.       outstr(stripfn(fn));
  282.       pl(get_string(844));
  283.       err=1;
  284.       break;
  285.     }
  286.     s[a.fn_len]=0;
  287.     if (bad_filename(s)) {
  288.       err=1;
  289.       break;
  290.     }
  291.   }
  292.   sh_close(f);
  293.   return(err);
  294. }
  295. /****************************************************************************/
  296.  
  297. int check_for_files_arj(char *fn)
  298. {
  299.   int f,i;
  300.   char s[256];
  301.   long l1,l,l2;
  302.   unsigned short sh;
  303.   unsigned char s1;
  304.  
  305.  
  306.   f=sh_open1(fn,O_RDONLY | O_BINARY);
  307.   if (f>0) {
  308.     l1=filelength(f);
  309.     l=0;
  310.     sh_lseek(f,0L,SEEK_SET);
  311.     while (l<l1) {
  312.       sh_lseek(f,l,SEEK_SET);
  313.       i=sh_read(f,&sh,2);
  314.       if ((i!=2) || (sh!=0xea60)) {
  315.         sh_close(f);
  316.         outstr(stripfn(fn));
  317.         outstr(get_string(845));
  318.         return(1);
  319.       }
  320.       l+=i+2;
  321.       sh_read(f,&sh,2);
  322.       sh_read(f,&s1,1);
  323.       sh_lseek(f,l+12,SEEK_SET);
  324.       sh_read(f,&l2,4);
  325.       sh_lseek(f,l+(long)s1,SEEK_SET);
  326.       sh_read(f,s,250);
  327.       s[250]=0;
  328.       if (strlen(s)>240) {
  329.         sh_close(f);
  330.         outstr(stripfn(fn));
  331.         outstr(get_string(845));
  332.         return(1);
  333.       }
  334.       l += 4+(long) sh;
  335.       sh_lseek(f,l,SEEK_SET);
  336.       sh_read(f,&sh,2);
  337.       l += 2;
  338.       while ((l<l1) && (sh)) {
  339.         l += 6+(long) sh;
  340.         sh_lseek(f,l-2,SEEK_SET);
  341.         sh_read(f,&sh,2);
  342.       }
  343.       l += l2;
  344.       if (bad_filename(s)) {
  345.         sh_close(f);
  346.         return(1);
  347.       }
  348.     }
  349.  
  350.     sh_close(f);
  351.     return(0);
  352.   }
  353.   outstr(get_string(842));
  354.   pl(stripfn(fn));
  355.   return(1);
  356. }
  357.  
  358.  
  359.  
  360. /****************************************************************************/
  361.  
  362.  
  363. typedef struct {
  364.   char *arc_name;
  365.   int (*func)(char *);
  366. } arc_testers;
  367.  
  368. arc_testers arc_t[] = {
  369.   {"ZIP", check_for_files_zip},
  370.   {"ARC", check_for_files_arc},
  371.   {"LZH", check_for_files_lzh},
  372.   {"ARJ", check_for_files_arj},
  373.   {NULL, NULL},
  374. };
  375.  
  376.  
  377.  
  378. int check_for_files(char *fn)
  379. {
  380.   char *ss;
  381.   int i;
  382.  
  383.   ss=strrchr(fn,'.');
  384.   if (ss) {
  385.     ss++;
  386.     for (i=0; arc_t[i].arc_name; i++) {
  387.       if (stricmp(ss,arc_t[i].arc_name)==0) {
  388.         return(arc_t[i].func(fn));
  389.       }
  390.     }
  391.   } else {
  392.     /* no extension? */
  393.     pl(get_string(846));
  394.     return(1);
  395.   }
  396.   return(0);
  397. }
  398.  
  399.  
  400. void download_temp_arc(char *fn, int xfer)
  401. {
  402.   char s[81],s1[81];
  403.   long numbytes;
  404.   int f,sent,abort;
  405.   double d;
  406.  
  407.   outstr(get_string(847));
  408.   npr("%s.%s:\r\n\r\n", fn, syscfg.arcs[ARC_NUMBER].extension);
  409.   if (xfer && !ratio_ok()) {
  410.     pl(get_string(848));
  411.     return;
  412.   }
  413.   sprintf(s1,"%s%s.%s",syscfgovr.tempdir,fn, syscfg.arcs[ARC_NUMBER].extension);
  414.   f=sh_open1(s1,O_RDONLY | O_BINARY);
  415.   if (f<0) {
  416.     pl(get_string(849));
  417.     nl();
  418.     return;
  419.   }
  420.   numbytes=filelength(f);
  421.   sh_close(f);
  422.   if (numbytes==0L) {
  423.     pl(get_string(850));
  424.     nl();
  425.     return;
  426.   }
  427.   d=XFER_TIME(numbytes);
  428.   if (d<=nsl()) {
  429.     outstr(get_string(851));
  430.     pl(ctim(d));
  431.     sent=0;
  432.     abort=0;
  433.     sprintf(s,"%s.%s",fn,syscfg.arcs[ARC_NUMBER].extension);
  434.     send_file(s1,&sent,&abort,0,s,-1,numbytes);
  435.     if (sent) {
  436.       if (xfer) {
  437.         ++thisuser.downloaded;
  438.         thisuser.dk += bytes_to_k(numbytes);
  439.         nln(2);
  440.         outstr(get_string(782)); npr("%-6.3f\r\n",ratio());
  441.       }
  442.       sprintf(s1,get_stringx(1,45),bytes_to_k(numbytes), s);
  443.       sysoplog(s1);
  444.       if (useron)
  445.         topscreen();
  446.     }
  447.   } else {
  448.     nln(2);
  449.     pl(get_string(787));
  450.     nl();
  451.   }
  452. }
  453.  
  454. void add_arc(char *arc, char *fn, int dos)
  455. {
  456.   char s[255], s1[81];
  457.  
  458.   sprintf(s1,"%s.%s",arc, syscfg.arcs[ARC_NUMBER].extension);
  459.   get_arc_cmd(s,s1,2,fn);
  460.   if (s[0]) {
  461.     cd_to(syscfgovr.tempdir);
  462.     outs(s);
  463.     outs("\r\n");
  464.     if (dos) {
  465.       extern_prog(s, sysinfo.spawn_opts[11]);
  466.     } else {
  467.       extern_prog(s, 0);
  468.       topscreen();
  469.     }
  470.     cd_to(cdir);
  471.     sprintf(s,get_stringx(1,46),fn, s1);
  472.     sysoplog(s);
  473.   } else
  474.     pl(get_string(852));
  475. }
  476.  
  477. void add_temp_arc(void)
  478. {
  479.   char s[81],s2[81];
  480.   int i;
  481.  
  482.   nl();
  483.   pl(get_string(853));
  484.   pl(get_string(854));
  485.   prt(2,": ");
  486.   input(s,12);
  487.   if (!okfn(s))
  488.     return;
  489.   if (s[0]==0)
  490.     return;
  491.   if (strchr(s,'.')==NULL)
  492.     strcat(s,".*");
  493.   strcpy(s2,stripfn(s));
  494.   for (i=0; i<strlen(s2); i++)
  495.     if ((s2[i]=='|') || (s2[i]=='>') || (s2[i]=='<') || (s2[i]==';') || (s2[i]==' ') ||
  496.         (s2[i]==':') || (s2[i]=='/') || (s2[i]=='\\'))
  497.       return;
  498.   add_arc("TEMP", s2, 1);
  499. }
  500.  
  501. void del_temp(void)
  502. {
  503.   char s1[81];
  504.   nl();
  505.   prt(2,get_string(855));
  506.   input(s1,12);
  507.   if (!okfn(s1))
  508.     return;
  509.   if (s1[0]) {
  510.     if (strchr(s1,'.')==NULL)
  511.       strcat(s1,".*");
  512.     remove_from_temp(s1,syscfgovr.tempdir, 1);
  513.   }
  514. }
  515.  
  516. void list_temp_dir(void)
  517. {
  518.   int i1,f1,abort;
  519.   char s[81],s1[81];
  520.   struct ffblk ff;
  521.  
  522.   sprintf(s1,"%s*.*",syscfgovr.tempdir);
  523.   f1=findfirst(s1,&ff,0);
  524.   nl();
  525.   pl(get_string(856));
  526.   nl();
  527.   i1=0;
  528.   abort=0;
  529.   while ((f1==0) && (!hangup) && (!abort)) {
  530.     strcpy(s,(ff.ff_name));
  531.     align(s);
  532.     sprintf(s1,"%12s  %-8ld",s,ff.ff_fsize);
  533.     pla(s1, &abort);
  534.     f1=findnext(&ff);
  535.     i1=1;
  536.   }
  537.   if (!i1)
  538.     pl(get_string(5));
  539.   nl();
  540.   if ((!abort) && (!hangup)) {
  541.     npr("%s: %ldk.\r\n", get_string(857),(long) freek1(syscfgovr.tempdir));
  542.     nl();
  543.   }
  544. }
  545.  
  546.  
  547. void temp_extract(void)
  548. {
  549.   int i,i1,i2,ok,abort,ok1,f, ot;
  550.   char s[255],s1[255],s2[81],s3[255],s4[129];
  551.   uploadsrec u;
  552.  
  553.   dliscan();
  554.   nl();
  555.   pl(get_string(858));
  556.   nl();
  557.   prt(2,get_string(44));
  558.   input(s,12);
  559.   if ((!okfn(s)) || (s[0]==0)) {
  560.     return;
  561.   }
  562.   if (strchr(s,'.')==NULL)
  563.     strcat(s,".*");
  564.   align(s);
  565.   i=recno(s);
  566.   ok=1;
  567.   while ((i>0) && (ok) && (!hangup)) {
  568.     f=sh_open1(dlfn,O_RDONLY | O_BINARY);
  569.     SETREC(f,i);
  570.     sh_read(f,(void *)&u,sizeof(uploadsrec));
  571.     sh_close(f);
  572.     sprintf(s2,"%s%s",directories[udir[curdir].subnum].path,u.filename);
  573.     if(directories[udir[curdir].subnum].mask & mask_cdrom) {
  574.       sprintf(s1,"%s%s",directories[udir[curdir].subnum].path,u.filename);
  575.       sprintf(s2,"%s%s",syscfgovr.tempdir,u.filename);
  576.       if(!exist(s2))
  577.         copy_file(s1,s2);
  578.     }
  579.     get_arc_cmd(s1,s2,1,"");
  580.     if ((s1[0]) && (exist(s2))) {
  581.       nln(2);
  582.       abort=0;
  583.       ot=tagging; tagging=2;
  584.       printinfo(&u,&abort);
  585.       tagging=ot;
  586.       nl();
  587.       if(directories[udir[curdir].subnum].mask & mask_cdrom) {
  588.         cd_to(syscfgovr.tempdir);
  589.       } else {
  590.         cd_to(directories[udir[curdir].subnum].path);
  591.       }
  592.       get_dir(s4,1);
  593.       strcat(s4,stripfn(u.filename));
  594.       cd_to(cdir);
  595.       if (!check_for_files(s4)) {
  596.         do {
  597.           prt(2,get_string(859));
  598.           input(s1,12);
  599.           if (s1[0]==0)
  600.             ok1=0;
  601.           else
  602.             ok1=1;
  603.           if (!okfn(s1))
  604.             ok1=0;
  605.           if (strcmp(s1,"?")==0) {
  606.             list_arc_out(stripfn(u.filename),directories[udir[curdir].subnum].path);
  607.             s1[0]=0;
  608.           }
  609.           if (strcmp(s1,"Q")==0) {
  610.             ok=0;
  611.             s1[0]=0;
  612.           }
  613.           i2=0;
  614.           for (i1=0; i1<strlen(s1); i1++)
  615.             if ((s1[i1]=='|') || (s1[i1]=='>') || (s1[i1]=='<') || (s1[i1]==';') || (s1[i1]==' '))
  616.               i2=1;
  617.           if (i2)
  618.             s1[0]=0;
  619.           if (s1[0]) {
  620.             if (strchr(s1,'.')==NULL)
  621.               strcat(s1,".*");
  622.             get_arc_cmd(s3,s4,1,stripfn(s1));
  623.             cd_to(syscfgovr.tempdir);
  624.             if (!okfn(s1))
  625.               s3[0]=0;
  626.             if (s3[0]) {
  627.               extern_prog(s3, sysinfo.spawn_opts[9]);
  628.               sprintf(s2,get_stringx(1,47),s1,u.filename);
  629.             } else
  630.               s2[0]=0;
  631.             cd_to(cdir);
  632.             if (s2[0])
  633.               sysoplog(s2);
  634.           }
  635.         } while ((!hangup) && (ok) && (ok1));
  636.       }
  637.     } else
  638.       if (s1[0]) {
  639.         nl();
  640.         pl(get_string(860));
  641.         nl();
  642.       }
  643.     if (ok)
  644.       i=nrecno(s,i);
  645.   }
  646. }
  647.  
  648. void list_temp_text(void)
  649. {
  650.   int f1,ok,sent;
  651.   char s[81],s1[81];
  652.   struct ffblk ff;
  653.   double percent;
  654.  
  655.   nl();
  656.   prt(2,get_string(861));
  657.   input(s,12);
  658.   if (!okfn(s))
  659.     return;
  660.   if (s[0]) {
  661.     if (strchr(s,'.')==NULL)
  662.       strcat(s,".*");
  663.     sprintf(s1,"%s%s",syscfgovr.tempdir,stripfn(s));
  664.     f1=findfirst(s1,&ff,0);
  665.     ok=1;
  666.     nl();
  667.     while ((f1==0) && (ok)) {
  668.       sprintf(s,"%s%s",syscfgovr.tempdir,ff.ff_name);
  669.       nl();
  670.       outstr(get_string(862));
  671.       pl(ff.ff_name);
  672.       nl();
  673.       ascii_send(s,&sent,&percent);
  674.       if (sent) {
  675.         sprintf(s,get_stringx(1,48),ff.ff_name);
  676.         sysoplog(s);
  677.       } else {
  678.         sprintf(s,get_stringx(1,49),ff.ff_name,percent*100.0);
  679.         sysoplog(s);
  680.         ok=0;
  681.       }
  682.       f1=findnext(&ff);
  683.     }
  684.   }
  685. }
  686.  
  687.  
  688. void list_temp_arc(void)
  689. {
  690.   char s1[81];
  691.  
  692.   sprintf(s1,"TEMP.%s",syscfg.arcs[ARC_NUMBER].extension);
  693.   list_arc_out(s1,syscfgovr.tempdir);
  694.   nl();
  695. }
  696.  
  697.  
  698.  
  699.  
  700. void temporary_stuff(void)
  701. {
  702.   char ch;
  703.   int done;
  704.  
  705.   done=0;
  706.   do {
  707.     nl();
  708.     if (menu_on()) {
  709.       rip_saveall();
  710.       printmenu(14);
  711.     } else
  712.       prt(2,get_string(863));
  713.     ch=onek("Q?DRAVLT");
  714.     if (menu_on())
  715.       rip_restoreall();
  716.     switch(ch) {
  717.       case 'Q':
  718.         done=1;
  719.         break;
  720.       case 'D':
  721.         download_temp_arc("TEMP", 1);
  722.         break;
  723.       case 'V':
  724.         list_temp_arc();
  725.         break;
  726.       case 'A':
  727.         add_temp_arc();
  728.         break;
  729.       case 'R':
  730.         del_temp();
  731.         break;
  732.       case 'L':
  733.         list_temp_dir();
  734.         break;
  735.       case 'T':
  736.         list_temp_text();
  737.         break;
  738.       case '?':
  739.         printmenu(14);
  740.         break;
  741.     }
  742.   } while ((!hangup) && (!done));
  743. }
  744.  
  745.  
  746.  
  747. void move_file_t(void)
  748. {
  749.   char sx[81],s1[81],s2[81],ch,*ss;
  750.   int i,i1,i2,ok,d1,d2,done,cp,f;
  751.   uploadsrec u,u1;
  752.  
  753.   tmp_disable_conf(1);
  754.  
  755.   nl();
  756.   if (numbatch==0) {
  757.     nl();
  758.     pl(get_string(1363));
  759.     pausescr();
  760.   }
  761.   for (i2=numbatch-1; i2>=0; i2--) {
  762.     ok=0;
  763.     strcpy(sx,batch[i2].filename);
  764.     align(sx);
  765.     dliscan1(batch[i2].dir);
  766.     i=recno(sx);
  767.     if (i<0) {
  768.       pl(get_string(89));
  769.       pausescr();
  770.     }
  771.     done=0;
  772.     while ((!hangup) && (i>0) && (!done)) {
  773.       cp=i;
  774.       f=sh_open1(dlfn,O_RDONLY | O_BINARY);
  775.       SETREC(f,i);
  776.       sh_read(f,(void *)&u,sizeof(uploadsrec));
  777.       f=sh_close(f);
  778.       printfileinfo(&u,batch[i2].dir);
  779.       prt(5,get_string(822));
  780.       ch=ynq();
  781.       if (ch=='Q') {
  782.         done=1;
  783.         tmp_disable_conf(0);
  784.         dliscan();
  785.         return;
  786.       }
  787.       else if (ch=='Y') {
  788.         sprintf(s1,"%s%s",directories[batch[i2].dir].path,u.filename);
  789.         do {
  790.           prt(2,get_string(823));
  791.           ss=mmkey(1);
  792.           if (ss[0]=='?') {
  793.             dirlist();
  794.             dliscan1(batch[i2].dir);
  795.           }
  796.         } while ((!hangup) && (ss[0]=='?'));
  797.         d1=-1;
  798.         if (ss[0])
  799.           for (i1=0; (i1<num_dirs) && (udir[i1].subnum!=-1); i1++)
  800.             if (strcmp(udir[i1].keys,ss)==0)
  801.               d1=i1;
  802.         if (d1!=-1) {
  803.           ok=1;
  804.           d1=udir[d1].subnum;
  805.           dliscan1(d1);
  806.           if (recno(u.filename)>0) {
  807.             ok=0;
  808.             pl(get_string(824));
  809.           }
  810.           if (numf>=directories[d1].maxfiles) {
  811.             ok=0;
  812.             pl(get_string(825));
  813.           }
  814.           if (freek1(directories[d1].path)<((double)(u.numbytes/1024L)+3)) {
  815.             ok=0;
  816.             pl(get_string(826));
  817.           }
  818.           dliscan();
  819.         } else
  820.           ok=0;
  821.       } else
  822.         ok=0;
  823.       if (ok && !done) {
  824.         prt(5,get_string(934));
  825.         if (yn()) {
  826.           time((long *)&u.daten);
  827.         }
  828.  
  829.         --cp;
  830.         f=sh_open(dlfn,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  831.         for (i1=i; i1<numf; i1++) {
  832.           SETREC(f,i1+1);
  833.           sh_read(f,(void *)&u1,sizeof(uploadsrec));
  834.           SETREC(f,i1);
  835.           sh_write(f,(void *)&u1,sizeof(uploadsrec));
  836.         }
  837.         --numf;
  838.         SETREC(f,0);
  839.         sh_read(f, &u1, sizeof(uploadsrec));
  840.         u1.numbytes=numf;
  841.         SETREC(f,0);
  842.         sh_write(f,(void *)&u1,sizeof(uploadsrec));
  843.         f=sh_close(f);
  844.         ss=read_extended_description(u.filename);
  845.         if (ss)
  846.           delete_extended_description(u.filename);
  847.  
  848.         sprintf(s2,"%s%s",directories[d1].path,u.filename);
  849.         dliscan1(d1);
  850.         f=sh_open(dlfn,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  851.         for (i=numf; i>=1; i--) {
  852.           SETREC(f,i);
  853.           sh_read(f,(void *)&u1,sizeof(uploadsrec));
  854.           SETREC(f,i+1);
  855.           sh_write(f,(void *)&u1,sizeof(uploadsrec));
  856.         }
  857.         SETREC(f,1);
  858.         sh_write(f,(void *)&u,sizeof(uploadsrec));
  859.         ++numf;
  860.         SETREC(f,0);
  861.         sh_read(f, &u1, sizeof(uploadsrec));
  862.         u1.numbytes=numf;
  863.         if (u.daten>u1.daten) {
  864.           u1.daten = u.daten;
  865.           dir_dates[d1]=u.daten;
  866.         }
  867.         SETREC(f,0);
  868.         sh_write(f,(void *)&u1,sizeof(uploadsrec));
  869.         f=sh_close(f);
  870.         if (ss) {
  871.           add_extended_description(u.filename,ss);
  872.           bbsfree(ss);
  873.         }
  874.  
  875.         if ((strcmp(s1,s2)!=0) && (exist(s1))) {
  876.           d2=0;
  877.           if ((s1[1]!=':') && (s2[1]!=':'))
  878.             d2=1;
  879.           if ((s1[1]==':') && (s2[1]==':') && (s1[0]==s2[0]))
  880.             d2=1;
  881.           if (d2) {
  882.             rename(s1,s2);
  883.             unlink(s1);
  884.             remlist(batch[i2].filename);
  885.             didnt_upload(i2);
  886.             delbatch(i2);
  887.           } else {
  888.             copy_file(s1,s2);
  889.             unlink(s1);
  890.             remlist(batch[i2].filename);
  891.             didnt_upload(i2);
  892.             delbatch(i2);
  893.           }
  894.         }
  895.         pl(get_string(827));
  896.       }
  897.       dliscan();
  898.       i=nrecno(sx,cp);
  899.     }
  900.   }
  901.  
  902.   tmp_disable_conf(0);
  903. }
  904.  
  905. void removefile(void)
  906. {
  907.   int i,i1,rm,abort,rdlp,f;
  908.   char ch,s[81],s1[81];
  909.   uploadsrec u;
  910.   userrec uu;
  911.  
  912.   dliscan();
  913.   nl();
  914.   pl(get_string(816));
  915.   outstr(":");
  916.   mpl(12);
  917.   input(s,12);
  918.   if (s[0]==0) {
  919.     return;
  920.   }
  921.   if (strchr(s,'.')==NULL)
  922.     strcat(s,".*");
  923.   align(s);
  924.   i=recno(s);
  925.   abort=0;
  926.   while ((!hangup) && (i>0) && (!abort)) {
  927.     f=sh_open1(dlfn,O_RDONLY | O_BINARY);
  928.     SETREC(f,i);
  929.     sh_read(f,(void *)&u,sizeof(uploadsrec));
  930.     f=sh_close(f);
  931.     if ((dcs()) || ((u.ownersys==0) && (u.ownerusr==usernum))) {
  932.       nl();
  933.       if (check_batch_queue(u.filename)) {
  934.         pl(get_string(817));
  935.         nl();
  936.       } else {
  937.         printfileinfo(&u,udir[curdir].subnum);
  938.         prt(2,get_string(818));
  939.         ch=ynq();
  940.         if (ch=='Q')
  941.           abort=1;
  942.         else if (ch=='Y') {
  943.           rdlp=1;
  944.           if (dcs()) {
  945.             prt(5,get_string(819));
  946.             rm=yn();
  947.             if (rm && (u.ownersys==0)) {
  948.               prt(5,get_string(820));
  949.               rdlp=yn();
  950.             }
  951.             if (sysinfo.flags & OP_FLAGS_FAST_SEARCH) {
  952.               nl();
  953.               prt(5,get_string(1381));
  954.               if (yn())
  955.                 modify_database(u.filename,0);
  956.             }
  957.           } else {
  958.             rm=1;
  959.             modify_database(u.filename,0);
  960.           }
  961.           if (rm) {
  962.             sprintf(s1,"%s%s",directories[udir[curdir].subnum].path,u.filename);
  963.             unlink(s1);
  964.             if ((rdlp) && (u.ownersys==0)) {
  965.               read_user(u.ownerusr,&uu);
  966.               if ((uu.inact & inact_deleted)==0) {
  967.                 if (date_to_daten(uu.firston) < u.daten) {
  968.                   --uu.uploaded;
  969.                   uu.uk -= bytes_to_k(u.numbytes);
  970.                   write_user(u.ownerusr,&uu);
  971.                 }
  972.               }
  973.             }
  974.           }
  975.           if (u.mask & mask_extended)
  976.             delete_extended_description(u.filename);
  977.           sprintf(s1,get_stringx(1,44),u.filename,
  978.                             directories[udir[curdir].subnum].name);
  979.           sysoplog(s1);
  980.           f=sh_open(dlfn,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  981.           for (i1=i; i1<numf; i1++) {
  982.             SETREC(f,i1+1);
  983.             sh_read(f,(void *)&u,sizeof(uploadsrec));
  984.             SETREC(f,i1);
  985.             sh_write(f,(void *)&u,sizeof(uploadsrec));
  986.           }
  987.           --i;
  988.           --numf;
  989.           SETREC(f,0);
  990.           sh_read(f, &u, sizeof(uploadsrec));
  991.           u.numbytes=numf;
  992.           SETREC(f,0);
  993.           sh_write(f,(void *)&u,sizeof(uploadsrec));
  994.           f=sh_close(f);
  995.         }
  996.       }
  997.     }
  998.     i=nrecno(s,i);
  999.   }
  1000. }
  1001.  
  1002.  
  1003.