home *** CD-ROM | disk | FTP | other *** search
/ The Devil's Doorknob BBS Capture (1996-2003) / devilsdoorknobbbscapture1996-2003.iso / UTIL / WWIVE / MYWIVE.ZIP / XFEROVL.C < prev    next >
C/C++ Source or Header  |  1993-05-21  |  13KB  |  533 lines
  1. #include "vars.h"
  2. #pragma hdrstop
  3. #include <time.h>
  4. #include <dir.h>
  5. #define SETREC(i)  lseek(dlf,((long) (i))*((long)sizeof(uploadsrec)),SEEK_SET);
  6.  
  7. void move_file()
  8. {
  9.   char sx[81],s[81],s1[81],s2[81],ch,*ss;
  10.   int i,i1,ok,d1,d2,done,cp;
  11.   uploadsrec u,u1,u2;
  12.   char *b;
  13.  
  14.   ok=0;
  15.   nl();
  16.   nl();
  17.   prt(2,"Filename to move: ");
  18.   input(sx,12);
  19.   if (strchr(sx,'.')==NULL)
  20.     strcat(sx,".*");
  21.   align(sx);
  22.   dliscan();
  23.   i=recno(sx);
  24.   if (i<0) {
  25.     nl();
  26.     pl("File not found.");
  27.     closedl();
  28.     return;
  29.   }
  30.   done=0;
  31.   while ((!hangup) && (i>0) && (!done)) {
  32.     cp=i;
  33.     SETREC(i);
  34.     read(dlf,(void *)&u,sizeof(uploadsrec));
  35.     nl();
  36.     printfileinfo(&u,udir[curdir].subnum);
  37.     nl();
  38.     prt(5,"Move this (Y/N/Q)? ");
  39.     ch=onek("QNY");
  40.     if (ch=='Q')
  41.       done=1;
  42.     if (ch=='Y') {
  43.       sprintf(s1,"%s%s",directories[udir[curdir].subnum].path,u.filename);
  44.       do {
  45.         nl();
  46.         nl();
  47.         prt(2,"To which directory? ");
  48.         ss=mmkey(1);
  49.         if (ss[0]=='?')
  50.           dirlist();
  51.       } while ((!hangup) && (ss[0]=='?'));
  52.       d1=-1;
  53.       if (ss[0])
  54.         for (i1=0; (i1<64) && (udir[i1].subnum!=-1); i1++)
  55.           if (strcmp(udir[i1].keys,ss)==0)
  56.             d1=i1;
  57.       if (d1!=-1) {
  58.         ok=1;
  59.         d1=udir[d1].subnum;
  60.         closedl();
  61.         dliscan1(d1);
  62.         if (recno(u.filename)>0) {
  63.           ok=0;
  64.           nl();
  65.           pl("Filename already in use in that directory.");
  66.         }
  67.         if (numf>=directories[d1].maxfiles) {
  68.           ok=0;
  69.           nl();
  70.           pl("Too many files in that directory.");
  71.         }
  72.         if (freek1(directories[d1].path)<((double)(u.numbytes/1024L)+3)) {
  73.           ok=0;
  74.           nl();
  75.           pl("Not enough disk space to move it.");
  76.         }
  77.         closedl();
  78.         dliscan();
  79.       } else
  80.         ok=0;
  81.     } else
  82.       ok=0;
  83.     if (ok) {
  84.       --cp;
  85.       for (i1=i; i1<numf; i1++) {
  86.         SETREC(i1+1);
  87.         read(dlf,(void *)&u1,sizeof(uploadsrec));
  88.         SETREC(i1);
  89.         write(dlf,(void *)&u1,sizeof(uploadsrec));
  90.       }
  91.       --numf;
  92.       SETREC(0);
  93.       read(dlf, &u1, sizeof(uploadsrec));
  94.       u1.numbytes=numf;
  95.       SETREC(0);
  96.       write(dlf,(void *)&u1,sizeof(uploadsrec));
  97.       ss=read_extended_description(u.filename);
  98.       if (ss)
  99.         delete_extended_description(u.filename);
  100.       closedl();
  101.       sprintf(s2,"%s%s",directories[d1].path,u.filename);
  102.       dliscan1(d1);
  103.       for (i=numf; i>=1; i--) {
  104.         SETREC(i);
  105.         read(dlf,(void *)&u1,sizeof(uploadsrec));
  106.         SETREC(i+1);
  107.         write(dlf,(void *)&u1,sizeof(uploadsrec));
  108.       }
  109.       SETREC(1);
  110.       write(dlf,(void *)&u,sizeof(uploadsrec));
  111.       ++numf;
  112.       SETREC(0);
  113.       read(dlf, &u1, sizeof(uploadsrec));
  114.       u1.numbytes=numf;
  115.       if (u.daten>u1.daten) {
  116.         u1.daten = u.daten;
  117.         dir_dates[d1]=u.daten;
  118.       }
  119.       SETREC(0);
  120.       write(dlf,(void *)&u1,sizeof(uploadsrec));
  121.       if (ss) {
  122.         add_extended_description(u.filename,ss);
  123.         farfree(ss);
  124.       }
  125.       closedl();
  126.       if ((strcmp(s1,s2)!=0) && (exist(s1))) {
  127.         d2=0;
  128.         if ((s1[1]!=':') && (s2[1]!=':'))
  129.           d2=1;
  130.         if ((s1[1]==':') && (s2[1]==':') && (s1[0]==s2[0]))
  131.           d2=1;
  132.         if (d2) {
  133.           rename(s1,s2);
  134.           unlink(s1);
  135.         } else {
  136.           if ((b=malloca(16400))==NULL)
  137.             return;
  138.           d1=open(s1,O_RDONLY | O_BINARY);
  139.           d2=open(s2,O_RDWR | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
  140.           i=read(d1,(void *)b,16384);
  141.           while (i>0) {
  142.             write(d2,(void *)b,i);
  143.             i=read(d1,(void *)b,16384);
  144.           }
  145.           close(d1);
  146.           close(d2);
  147.           unlink(s1);
  148.           farfree(b);
  149.         }
  150.       }
  151.       nl();
  152.       pl("File moved.");
  153.     } else
  154.       closedl();
  155.     dliscan();
  156.     i=nrecno(sx,cp);
  157.   }
  158.   closedl();
  159. }
  160.  
  161. int comparedl(uploadsrec *x, uploadsrec *y, int type)
  162. {
  163.   switch(type) {
  164.     case 0:
  165.       return(strcmp(x->filename,y->filename));
  166.     case 1:
  167.       if (x->daten < y->daten)
  168.         return(-1);
  169.       else
  170.         if (x->daten > y->daten)
  171.           return(1);
  172.         else
  173.           return(0);
  174.     case 2:
  175.       if (x->daten < y->daten)
  176.         return(1);
  177.       else
  178.         if (x->daten > y->daten)
  179.           return(-1);
  180.         else
  181.           return(0);
  182.   }
  183.   return(0);
  184. }
  185.  
  186. void quicksort(int l,int r,int type)
  187. {
  188.   register int i,j;
  189.   uploadsrec a,a2,x;
  190.  
  191.   i=l; j=r;
  192.   SETREC(((l+r)/2));
  193.   read(dlf, (void *)&x,sizeof(uploadsrec));
  194.   do {
  195.     SETREC(i);
  196.     read(dlf, (void *)&a,sizeof(uploadsrec));
  197.     while (comparedl(&a,&x,type)<0) {
  198.       SETREC(++i);
  199.       read(dlf, (void *)&a,sizeof(uploadsrec));
  200.     }
  201.     SETREC(j);
  202.     read(dlf, (void *)&a2,sizeof(uploadsrec));
  203.     while (comparedl(&a2,&x,type)>0) {
  204.       SETREC(--j);
  205.       read(dlf, (void *)&a2,sizeof(uploadsrec));
  206.     }
  207.     if (i<=j) {
  208.       if (i!=j) {
  209.         SETREC(i);
  210.         write(dlf,(void *)&a2,sizeof(uploadsrec));
  211.         SETREC(j);
  212.         write(dlf,(void *)&a,sizeof(uploadsrec));
  213.       }
  214.       i++;
  215.       j--;
  216.     }
  217.   } while (i<j);
  218.   if (l<j)
  219.     quicksort(l,j,type);
  220.   if (i<r)
  221.     quicksort(i,r,type);
  222. }
  223.  
  224. void sortdir(int dn, int type)
  225. {
  226.   dliscan1(dn);
  227.   if (numf>1)
  228.     quicksort(1,numf,type);
  229.   closedl();
  230. }
  231.  
  232. void sort_all(int type)
  233. {
  234.   int i;
  235.  
  236.   for (i=0; (i<64) && (udir[i].subnum!=-1) && (!kbhitb()); i++) {
  237.     nl();
  238.     ansic(1);
  239.     npr("Sorting %s.\r\n",directories[udir[i].subnum].name);
  240.     sortdir(i,type);
  241.   }
  242. }
  243.  
  244. void rename_file()
  245. {
  246.   char s[81],s1[81],s2[81],*ss,s3[81],ch;
  247.   int i,cp;
  248.   uploadsrec u;
  249.  
  250.   nl();
  251.   nl();
  252.   prt(2,"File to rename: ");
  253.   input(s,12);
  254.   if (s[0]==0)
  255.     return;
  256.   if (strchr(s,'.')==NULL)
  257.     strcat(s,".*");
  258.   align(s);
  259.   dliscan();
  260.   nl();
  261.   strcpy(s3,s);
  262.   i=recno(s);
  263.   while (i>0) {
  264.     cp=i;
  265.     SETREC(i);
  266.     read(dlf,(void *)&u,sizeof(uploadsrec));
  267.     nl();
  268.     printfileinfo(&u,udir[curdir].subnum);
  269.     nl();
  270.     prt(5,"Change info for this file (Y/N/Q)? ");
  271.     ch=onek("QNY");
  272.     if (ch=='Q')
  273.       break;
  274.     else if (ch=='N') {
  275.       i=nrecno(s3,cp);
  276.       continue;
  277.     }
  278.     nl();
  279.     prt(2,"New filename? ");
  280.     input(s,12);
  281.     if (!okfn(s))
  282.       s[0]=0;
  283.     if (s[0]) {
  284.       align(s);
  285.       if (strcmp(s,"        .   ")) {
  286.         strcpy(s1,directories[udir[curdir].subnum].path);
  287.         strcpy(s2,s1);
  288.         strcat(s1,s);
  289.         if (exist(s1))
  290.           pl("Filename already in use; not changed.");
  291.         else {
  292.           strcat(s2,u.filename);
  293.           rename(s2,s1);
  294.           if (exist(s1)) {
  295.             ss=read_extended_description(u.filename);
  296.             if (ss) {
  297.               delete_extended_description(u.filename);
  298.               add_extended_description(s,ss);
  299.               farfree(ss);
  300.             }
  301.             strcpy(u.filename,s);
  302.           } else
  303.             pl("Bad filename.");
  304.         }
  305.       }
  306.     }
  307.     nl();
  308.     pl("New description:");
  309.     prt(2,": ");
  310.     inputl(s,58);
  311.     if (s[0]) {
  312.       strcpy(u.description,s);
  313.     }
  314.     ss=read_extended_description(u.filename);
  315.     nl();
  316.     nl();
  317.     prt(5,"Modify extended description? ");
  318.     if (yn()) {
  319.       nl();
  320.       if (ss) {
  321.         prt(5,"Delete it? ");
  322.         if (yn()) {
  323.           farfree(ss);
  324.           delete_extended_description(u.filename);
  325.           u.mask &= ~mask_extended;
  326.         } else {
  327.           u.mask |= mask_extended;
  328.           modify_extended_description(&ss);
  329.           if (ss) {
  330.             delete_extended_description(u.filename);
  331.             add_extended_description(u.filename,ss);
  332.             farfree(ss);
  333.           }
  334.         }
  335.       } else {
  336.         modify_extended_description(&ss);
  337.         if (ss) {
  338.           add_extended_description(u.filename,ss);
  339.           farfree(ss);
  340.           u.mask |= mask_extended;
  341.         } else
  342.           u.mask &= ~mask_extended;
  343.       }
  344.     } else
  345.       if (ss) {
  346.         farfree(ss);
  347.         u.mask |= mask_extended;
  348.       } else
  349.         u.mask &= ~mask_extended;
  350.     SETREC(i);
  351.     write(dlf,(void *)&u,sizeof(uploadsrec));
  352.     i=nrecno(s3,cp);
  353.   }
  354.   closedl();
  355. }
  356.  
  357. int upload_file(char *fn, int dn, char *desc)
  358. {
  359.   directoryrec d;
  360.   uploadsrec u,u1;
  361.   int i,i1,i2,ok,f;
  362.   char s[81],s1[81],ff[81];
  363.   long l;
  364.   double ti;
  365.  
  366.   d=directories[dn];
  367.   strcpy(s,fn);
  368.   align(s);
  369.   strcpy(u.filename,s);
  370.   u.ownerusr=usernum;
  371.   u.ownersys=0;
  372.   u.numdloads=0;
  373.   u.filetype=0;
  374.   u.mask=0;
  375.   if (check_ul_event(dn,&u)) {
  376.     npr("File '%s' deleted by upload event.\r\n",fn);
  377.   } else {
  378.     sprintf(ff,"%s%s",d.path,s);
  379.     f=open(ff,O_RDONLY | O_BINARY);
  380.     if (f<=0) {
  381.       if (desc && (*desc)) {
  382.         npr("ERR: %s: %s\r\n",fn,desc);
  383.       } else {
  384.         npr("File '%s' doesn't exist.\r\n",fn);
  385.       }
  386.       return(1);
  387.     }
  388.     l=filelength(f);
  389.     u.numbytes=l;
  390.     close(f);
  391.     strcpy(u.upby,nam1(&thisuser,usernum,syscfg.systemnumber));
  392.     strcpy(u.date,date());
  393.     if (d.mask & mask_PD)
  394.       d.mask=mask_PD;
  395.     npr("%s: %4ldk :",u.filename,((u.numbytes)+1023)/1024);
  396.     if ((desc) && (*desc)) {
  397.       strncpy(u.description,desc,58);
  398.       u.description[58]=0;
  399.       pl(u.description);
  400.     } else
  401.       inputf(u.description,58);
  402.     if (u.description[0]==0)
  403.       return(0);
  404.     ++thisuser.uploaded;
  405.     thisuser.uk += ((l+1023)/1024);
  406.     time(&l);
  407.     u.daten=l;
  408.     for (i=numf; i>=1; i--) {
  409.       SETREC(i);
  410.       read(dlf,(void *)&u1,sizeof(uploadsrec));
  411.       SETREC(i+1);
  412.       write(dlf,(void *)&u1,sizeof(uploadsrec));
  413.     }
  414.     SETREC(1);
  415.     write(dlf,(void *)&u,sizeof(uploadsrec));
  416.     ++numf;
  417.     SETREC(0);
  418.     read(dlf, &u1, sizeof(uploadsrec));
  419.     u1.numbytes=numf;
  420.     u1.daten=l;
  421.     dir_dates[dn]=l;
  422.     SETREC(0);
  423.     write(dlf,(void *)&u1,sizeof(uploadsrec));
  424.     ++status.uptoday;
  425.     save_status();
  426.     sprintf(s,"+%s uploaded on %s",u.filename,d.name);
  427.     sysoplog(s);
  428.   }
  429.   return(1);
  430. }
  431.  
  432. int maybe_upload(char *fn, int dn, char *desc)
  433. {
  434.   char s[81];
  435.   int i,i1=0,ok=1,ocd;
  436.   uploadsrec u;
  437.  
  438.   strcpy(s,fn);
  439.   align(s);
  440.   i=recno(s);
  441.   if (i==-1) {
  442.     if (!upload_file(s,dn,desc))
  443.       ok=0;
  444.   } else {
  445.     SETREC(i);
  446.     read(dlf,(void *)&u, sizeof(uploadsrec));
  447.     ocd=curdir;
  448.     curdir=dn;
  449.     printinfo(&u,&i1);
  450.     curdir=ocd;
  451.     if (i1)
  452.       ok=0;
  453.   }
  454.   return(ok);
  455. }
  456.  
  457. void upload_files(char *fn, int dn, int type)
  458. /* This assumes the file holds listings of files, one per line, to be
  459.  * uploaded.  The first word (delimited by space/tab) must be the filename.
  460.  * after the filename are optional tab/space separated words (such as file
  461.  * size or date/time).  After the optional words is the description, which
  462.  * is from that position to the end of the line.  the "type" parameter gives
  463.  * the number of optional words between the filename and description.
  464.  * the optional words (size, date/time) are ignored completely.
  465.  */
  466. {
  467.   char s[255],*fn1,*desc;
  468.   FILE *f;
  469.   int ok=1,abort=0,next=0,ok1,i;
  470.  
  471.   dliscan1(dn);
  472.   f=fopen(fn,"r");
  473.   if (!f) {
  474.     npr("\r\nFile '%s' not found.\r\n\r\n",fn);
  475.   } else {
  476.     while (ok && fgets(s,250,f)) {
  477.       if ((s[0]<=32) || (s[0]>127))
  478.         continue;
  479.       ok1=0;
  480.       fn1=strtok(s," \t\n");
  481.       if (fn1) {
  482.         ok1=1;
  483.         for (i=0; ok1 && (i<type); i++)
  484.           if (strtok(NULL," \t\n")==NULL)
  485.             ok1=0;
  486.         if (ok1) {
  487.           desc=strtok(NULL,"\n");
  488.           if (!desc)
  489.             ok1=0;
  490.         }
  491.       }
  492.       if (ok1) {
  493.         while ((*desc==' ') || (*desc=='\t'))
  494.           ++desc;
  495.         ok=maybe_upload(fn1,dn,desc);
  496.         checka(&abort,&next);
  497.         if (abort)
  498.           ok=0;
  499.       }
  500.     }
  501.     fclose(f);
  502.   }
  503.   closedl();
  504. }
  505.  
  506. int uploadall(int dn)
  507. {
  508.   int i,i1,f1,maxf,ok;
  509.   char s[81],s1[81];
  510.   struct ffblk ff;
  511.  
  512.   dliscan1(dn);
  513.   nl();
  514.   nl();
  515.   strcpy(s,"*.*");
  516.   strcpy(s1,(directories[dn].path));
  517.   maxf=directories[dn].maxfiles;
  518.   strcat(s1,s);
  519.   f1=findfirst(s1,&ff,0);
  520.   ok=1;
  521.   i1=0;
  522.   while ((f1==0) && (!hangup) && (numf<maxf) && (ok) && (!i1)) {
  523.     ok=maybe_upload(ff.ff_name,dn,NULL);
  524.     f1=findnext(&ff);
  525.   }
  526.   closedl();
  527.   if (!ok)
  528.     pl("Aborted.");
  529.   if (numf>=maxf)
  530.     pl("directory full.");
  531.   return(i1);
  532. }
  533.