Return to addfiles.c CVS log

Up to [Synchronet] / sbbs / sbbs2 / addfiles

Annotation of sbbs/sbbs2/addfiles/addfiles.c, revision 1.1

1.1     ! root        1: /* ADDFILES.C */
        !             2: 
        !             3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
        !             4: 
        !             5: /* Program to add files to a Synchronet file database */
        !             6: 
        !             7: #include "sbbs.h"
        !             8: 
        !             9: #define ADDFILES_VER "2.23"
        !            10: 
        !            11: char tmp[256];
        !            12: char *crlf="\r\n";
        !            13: 
        !            14: #ifdef __TURBOC__
        !            15: unsigned _stklen=16000;
        !            16: #else
        !            17: unsigned _stacksize=16000;
        !            18: #endif
        !            19: 
        !            20: int cur_altpath=0;
        !            21: 
        !            22: long files=0,removed=0,mode=0;
        !            23: 
        !            24: #define DEL_LIST       (1L<<0)
        !            25: #define NO_EXTEND      (1L<<1)
        !            26: #define FILE_DATE      (1L<<2)
        !            27: #define TODAYS_DATE (1L<<3)
        !            28: #define FILE_ID        (1L<<4)
        !            29: #define NO_UPDATE      (1L<<5)
        !            30: #define NO_NEWDATE     (1L<<6)
        !            31: #define ASCII_ONLY     (1L<<7)
        !            32: #define UL_STATS       (1L<<8)
        !            33: #define ULDATE_ONLY (1L<<9)
        !            34: #define KEEP_DESC      (1L<<10)
        !            35: #define AUTO_ADD       (1L<<11)
        !            36: #define SEARCH_DIR     (1L<<12)
        !            37: #define SYNC_LIST      (1L<<13)
        !            38: #define KEEP_SPACE     (1L<<14)
        !            39: 
        !            40: #ifndef __FLAT__
        !            41: /****************************************************************************/
        !            42: /* This function reads files that are potentially larger than 32k.             */
        !            43: /* Up to one megabyte of data can be read with each call.                   */
        !            44: /****************************************************************************/
        !            45: long lread(int file, char HUGE16 *buf,long bytes)
        !            46: {
        !            47:        long count;
        !            48: 
        !            49: for(count=bytes;count>32767;count-=32767,buf+=32767)
        !            50:        if(read(file,(char *)buf,32767)!=32767)
        !            51:                return(-1L);
        !            52: if(read(file,(char *)buf,(int)count)!=count)
        !            53:        return(-1L);
        !            54: return(bytes);
        !            55: }
        !            56: 
        !            57: /****************************************************************************/
        !            58: /* This function writes files that are potentially larger than 32767 bytes  */
        !            59: /* Up to one megabytes of data can be written with each call.                          */
        !            60: /****************************************************************************/
        !            61: long lwrite(int file, char HUGE16 *buf, long bytes)
        !            62: {
        !            63: 
        !            64:        long count;
        !            65: 
        !            66: for(count=bytes;count>32767;count-=32767,buf+=32767)
        !            67:        if(write(file,(char *)buf,32767)!=32767)
        !            68:                return(-1L);
        !            69: if(write(file,(char *)buf,(int)count)!=count)
        !            70:        return(-1L);
        !            71: return(bytes);
        !            72: }
        !            73: #endif
        !            74: 
        !            75: long lputs(char FAR16 *str)
        !            76: {
        !            77:     char tmp[256];
        !            78:     int i,j,k;
        !            79: 
        !            80: j=strlen(str);
        !            81: for(i=k=0;i<j;i++)      /* remove CRs */
        !            82:     if(str[i]==CR && str[i+1]==LF)
        !            83:         continue;
        !            84:     else
        !            85:         tmp[k++]=str[i];
        !            86: tmp[k]=0;
        !            87: return(fputs(tmp,stdout));
        !            88: }
        !            89: 
        !            90: /****************************************************************************/
        !            91: /* Returns string for 2 digit hex+ numbers up to 575                                           */
        !            92: /****************************************************************************/
        !            93: char *hexplus(uint num, char *str)
        !            94: {
        !            95: sprintf(str,"%03x",num);
        !            96: str[0]=num/0x100 ? 'f'+(num/0x10)-0xf : str[1];
        !            97: str[1]=str[2];
        !            98: str[2]=0;
        !            99: return(str);
        !           100: }
        !           101: 
        !           102: 
        !           103: /****************************************************************************/
        !           104: /* Places into 'strout', 'strin' starting at 'start' and ending at                     */
        !           105: /* 'start'+'length'                                                                                                            */
        !           106: /****************************************************************************/
        !           107: void putrec(char *strout,int start,int length,char *strin)
        !           108: {
        !           109:        int i=0,j;
        !           110: 
        !           111: j=strlen(strin);
        !           112: while(i<j && i<length)
        !           113:        strout[start++]=strin[i++];
        !           114: while(i++<length)
        !           115:        strout[start++]=ETX;
        !           116: }
        !           117: 
        !           118: /****************************************************************************/
        !           119: /* Performs printf() through local assembly routines                        */
        !           120: /* Called from everywhere                                                   */
        !           121: /****************************************************************************/
        !           122: int lprintf(char *fmat, ...)
        !           123: {
        !           124:        va_list argptr;
        !           125:        char sbuf[256];
        !           126:        int chcount;
        !           127: 
        !           128: va_start(argptr,fmat);
        !           129: chcount=vsprintf(sbuf,fmat,argptr);
        !           130: va_end(argptr);
        !           131: lputs(sbuf);
        !           132: return(chcount);
        !           133: }
        !           134: 
        !           135: /****************************************************************************/
        !           136: /* Truncates white-space chars off end of 'str' and terminates at first tab */
        !           137: /****************************************************************************/
        !           138: void truncsp(char *str)
        !           139: {
        !           140:        int c;
        !           141: 
        !           142: str[strcspn(str,"\t")]=0;
        !           143: c=strlen(str);
        !           144: while(c && (uchar)str[c-1]<=SP) c--;
        !           145: str[c]=0;
        !           146: }
        !           147: 
        !           148: /****************************************************************************/
        !           149: /* Puts a backslash on path strings                                                                            */
        !           150: /****************************************************************************/
        !           151: void backslash(char *str)
        !           152: {
        !           153:     int i;
        !           154: 
        !           155: i=strlen(str);
        !           156: if(i && str[i-1]!='\\') {
        !           157:     str[i]='\\'; str[i+1]=0; }
        !           158: }
        !           159: 
        !           160: /****************************************************************************/
        !           161: /* Checks the disk drive for the existence of a file. Returns 1 if it       */
        !           162: /* exists, 0 if it doesn't.                                                 */
        !           163: /****************************************************************************/
        !           164: char fexist(char *filespec)
        !           165: {
        !           166:        struct find_t f;
        !           167:        uint i;
        !           168: 
        !           169: i=_dos_findfirst(filespec,_A_NORMAL,&f);
        !           170: #ifdef __WATCOMC__
        !           171: _dos_findclose(&f);
        !           172: #endif
        !           173: if(!i)
        !           174:     return(1);
        !           175: return(0);
        !           176: }
        !           177: 
        !           178: /****************************************************************************/
        !           179: /* Returns the time/date of the file in 'filespec' in time_t (unix) format  */
        !           180: /****************************************************************************/
        !           181: long fdate(char *filespec)
        !           182: {
        !           183:        int     file;
        !           184:        ushort  fd,ft;
        !           185:        struct  tm t;
        !           186: 
        !           187: if((file=nopen(filespec,O_RDONLY))==-1)
        !           188:        return(0);
        !           189: _dos_getftime(file,&fd,&ft);
        !           190: close(file);
        !           191: memset(&t,0,sizeof(t));
        !           192: t.tm_year=((fd&0xfe00)>>9)+80;
        !           193: t.tm_mon=((fd&0x01e0)>>5)-1;
        !           194: t.tm_mday=fd&0x1f;
        !           195: t.tm_hour=(ft&0xf800)>>11;
        !           196: t.tm_min=(ft&0x07e0)>>5;
        !           197: t.tm_sec=(ft&0x001f)<<1;
        !           198: return(mktime(&t));
        !           199: }
        !           200: 
        !           201: /*****************************************************************************/
        !           202: /* Returns command line generated from instr with %c replacments             */
        !           203: /*****************************************************************************/
        !           204: char *cmdstr(char *instr, char *fpath, char *fspec, char *outstr)
        !           205: {
        !           206:     static char cmd[128];
        !           207:     char str[256];
        !           208:     int i,j,len;
        !           209: 
        !           210: len=strlen(instr);
        !           211: for(i=j=0;i<len && j<128;i++) {
        !           212:     if(instr[i]=='%') {
        !           213:         i++;
        !           214:         cmd[j]=0;
        !           215:         switch(toupper(instr[i])) {
        !           216:             case 'F':   /* File path */
        !           217:                 strcat(cmd,fpath);
        !           218:                 break;
        !           219:             case 'G':   /* Temp directory */
        !           220:                 if(temp_dir[0]!='\\' && temp_dir[1]!=':')
        !           221:                     strcat(cmd,node_dir);
        !           222:                 strcat(cmd,temp_dir);
        !           223:                 break;
        !           224:             case 'N':   /* Node Directory (same as SBBSNODE environment var) */
        !           225:                 strcat(cmd,node_dir);
        !           226:                 break;
        !           227:             case 'S':   /* File Spec */
        !           228:                 strcat(cmd,fspec);
        !           229:                 break;
        !           230:             case '!':   /* EXEC Directory */
        !           231:                 if(exec_dir[0]!='\\' && exec_dir[1]!=':')
        !           232:                     strcat(cmd,node_dir);
        !           233:                 strcat(cmd,exec_dir);
        !           234:                 break;
        !           235:             case '#':   /* Node number (same as SBBSNNUM environment var) */
        !           236:                 sprintf(str,"%d",node_num);
        !           237:                 strcat(cmd,str);
        !           238:                 break;
        !           239:             case '%':   /* %% for percent sign */
        !           240:                 strcat(cmd,"%");
        !           241:                 break;
        !           242:             default:    /* unknown specification */
        !           243:                 break; }
        !           244:         j=strlen(cmd); }
        !           245:     else
        !           246:         cmd[j++]=instr[i]; }
        !           247: cmd[j]=0;
        !           248: 
        !           249: return(cmd);
        !           250: }
        !           251: 
        !           252: 
        !           253: /****************************************************************************/
        !           254: /* Converts unix time format (long - time_t) into a char str MM/DD/YY          */
        !           255: /****************************************************************************/
        !           256: char *unixtodstr(time_t unix, char *str)
        !           257: {
        !           258:        struct tm *t;
        !           259: 
        !           260: if(!unix)
        !           261:        strcpy(str,"00/00/00");
        !           262: else {
        !           263:        t=gmtime(&unix);
        !           264:        sprintf(str,"%02u/%02u/%02u",t->tm_mon+1,t->tm_mday
        !           265:                ,t->tm_year); }
        !           266: return(str);
        !           267: }
        !           268: 
        !           269: /****************************************************************************/
        !           270: /* Network open function. Opens all files DENYALL and retries LOOP_NOPEN    */
        !           271: /* number of times if the attempted file is already open or denying access     */
        !           272: /* for some other reason.      All files are opened in BINARY mode.                    */
        !           273: /****************************************************************************/
        !           274: int nopen(char *str, int access)
        !           275: {
        !           276:        char logstr[256];
        !           277:        int file,share,count=0;
        !           278: 
        !           279: if(access==O_RDONLY) share=SH_DENYWR;
        !           280:        else share=SH_DENYRW;
        !           281: while(((file=sopen(str,O_BINARY|access,share,S_IWRITE))==-1)
        !           282:        && errno==EACCES && count++<LOOP_NOPEN);
        !           283: if(file==-1 && errno==EACCES)
        !           284:        lputs("\7\r\nNOPEN: ACCESS DENIED\r\n\7");
        !           285: return(file);
        !           286: }
        !           287: 
        !           288: /****************************************************************************/
        !           289: /* This function performs an nopen, but returns a file stream with a buffer */
        !           290: /* allocated.                                                                                                                          */
        !           291: /****************************************************************************/
        !           292: FILE *fnopen(int *file, char *str, int access)
        !           293: {
        !           294:        char mode[128];
        !           295:        FILE *stream;
        !           296: 
        !           297: if(access&O_WRONLY) access|=O_RDWR;    /* fdopen can't open WRONLY */
        !           298: 
        !           299: if(((*file)=nopen(str,access))==-1)
        !           300:        return(NULL);
        !           301: 
        !           302: if(access&O_APPEND) {
        !           303:        if(access&(O_RDONLY|O_RDWR))
        !           304:                strcpy(mode,"a+");
        !           305:        else
        !           306:                strcpy(mode,"a"); }
        !           307: else {
        !           308:        if(access&(O_WRONLY|O_RDWR))
        !           309:                strcpy(mode,"r+");
        !           310:        else
        !           311:                strcpy(mode,"r"); }
        !           312: stream=fdopen((*file),mode);
        !           313: if(stream==NULL) {
        !           314:        close(*file);
        !           315:        return(NULL); }
        !           316: setvbuf(stream,NULL,_IOFBF,16*1024);
        !           317: return(stream);
        !           318: }
        !           319: 
        !           320: void allocfail(uint size)
        !           321: {
        !           322: lprintf("\7Error allocating %u bytes of memory.\r\n",size);
        !           323: bail(1);
        !           324: }
        !           325: 
        !           326: void bail(int code)
        !           327: {
        !           328: exit(code);
        !           329: }
        !           330: 
        !           331: /****************************************************************************/
        !           332: /* Returns the length of the file in 'filespec'                             */
        !           333: /****************************************************************************/
        !           334: long flength(char *filespec)
        !           335: {
        !           336:        struct find_t f;
        !           337:        uint i;
        !           338: 
        !           339: i=_dos_findfirst(filespec,_A_NORMAL,&f);
        !           340: #ifdef __WATCOMC__
        !           341: _dos_findclose(&f);
        !           342: #endif
        !           343: if(!i)
        !           344:        return(f.size);
        !           345: return(-1L);
        !           346: }
        !           347: 
        !           348: /****************************************************************************/
        !           349: /* Turns FILE.EXT into FILE    .EXT                                         */
        !           350: /* Called from upload                                                       */
        !           351: /****************************************************************************/
        !           352: char *padfname(char *filename, char *str)
        !           353: {
        !           354:     char c,d;
        !           355: 
        !           356: for(c=0;c<8;c++)
        !           357:     if(filename[c]=='.' || !filename[c]) break;
        !           358:     else str[c]=filename[c];
        !           359: d=c;
        !           360: if(filename[c]=='.') c++;
        !           361: while(d<8)
        !           362:     str[d++]=SP;
        !           363: str[d++]='.';
        !           364: while(d<12)
        !           365:     if(!filename[c]) break;
        !           366:     else str[d++]=filename[c++];
        !           367: while(d<12)
        !           368:     str[d++]=SP;
        !           369: str[d]=0;
        !           370: return(str);
        !           371: }
        !           372: 
        !           373: /****************************************************************************/
        !           374: /* Turns FILE    .EXT into FILE.EXT                                         */
        !           375: /****************************************************************************/
        !           376: char *unpadfname(char *filename, char *str)
        !           377: {
        !           378:     char c,d;
        !           379: 
        !           380: for(c=0,d=0;c<strlen(filename);c++)
        !           381:     if(filename[c]!=SP) str[d++]=filename[c];
        !           382: str[d]=0;
        !           383: return(str);
        !           384: }
        !           385: 
        !           386: /****************************************************************************/
        !           387: /* Checks  directory data file for 'filename' (must be padded). If found,   */
        !           388: /* it returns the 1, else returns 0.                                        */
        !           389: /* Called from upload and bulkupload                                        */
        !           390: /****************************************************************************/
        !           391: char findfile(uint dirnum, char *filename)
        !           392: {
        !           393:        char str[256],c,fname[128],HUGE16 *ixbbuf;
        !           394:     int file;
        !           395:     ulong length,l;
        !           396: 
        !           397: strcpy(fname,filename);
        !           398: for(c=8;c<12;c++)   /* Turn FILENAME.EXT into FILENAMEEXT */
        !           399:     fname[c]=fname[c+1];
        !           400: sprintf(str,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
        !           401: if((file=nopen(str,O_RDONLY))==-1) return(0);
        !           402: length=filelength(file);
        !           403: if(!length) {
        !           404:     close(file);
        !           405:     return(0); }
        !           406: if((ixbbuf=(char *)MALLOC(length))==NULL) {
        !           407:     close(file);
        !           408:        printf("ERR_ALLOC %s %lu\n",str,length);
        !           409:     return(0); }
        !           410: if(lread(file,ixbbuf,length)!=length) {
        !           411:     close(file);
        !           412:        FREE((char *)ixbbuf);
        !           413:     return(0); }
        !           414: close(file);
        !           415: for(l=0;l<length;l+=F_IXBSIZE) {
        !           416:     for(c=0;c<11;c++)
        !           417:         if(fname[c]!=ixbbuf[l+c]) break;
        !           418:     if(c==11) break; }
        !           419: FREE((char *)ixbbuf);
        !           420: if(l<length)
        !           421:     return(1);
        !           422: return(0);
        !           423: }
        !           424: 
        !           425: 
        !           426: /****************************************************************************/
        !           427: /* Adds the data for struct filedat to the directory's data base.           */
        !           428: /* changes the .datoffset field only                                        */
        !           429: /****************************************************************************/
        !           430: char addfiledat(file_t *f)
        !           431: {
        !           432:        char str[256],fdat[F_LEN+1],fname[128],idx[128],c,HUGE16 *ixbbuf;
        !           433:     int i,file;
        !           434:     ulong length,l,uldate;
        !           435: 
        !           436: /************************/
        !           437: /* Add data to DAT File */
        !           438: /************************/
        !           439: sprintf(str,"%s%s.DAT",dir[f->dir]->data_dir,dir[f->dir]->code);
        !           440: if((file=nopen(str,O_RDWR|O_CREAT))==-1) {
        !           441:        printf("ERROR opening %s\n",str);
        !           442:        return(0); }
        !           443: length=filelength(file);
        !           444: if(length==0L)
        !           445:     l=0L;
        !           446: else {
        !           447:     if(length%F_LEN) {
        !           448:         close(file);
        !           449:                printf("ERR_LEN %s %lu\n",str,length);
        !           450:                return(0); }
        !           451:     for(l=0;l<length;l+=F_LEN) {    /* Find empty slot */
        !           452:         lseek(file,l,SEEK_SET);
        !           453:         read(file,&c,1);
        !           454:         if(c==ETX) break; } }
        !           455: putrec(fdat,F_CDT,7,ultoa(f->cdt,tmp,10));
        !           456: putrec(fdat,F_CDT+7,2,crlf);
        !           457: putrec(fdat,F_DESC,LEN_FDESC,f->desc);
        !           458: putrec(fdat,F_DESC+LEN_FDESC,2,crlf);
        !           459: putrec(fdat,F_ULER,LEN_ALIAS+5,f->uler);
        !           460: putrec(fdat,F_ULER+LEN_ALIAS+5,2,crlf);
        !           461: putrec(fdat,F_TIMESDLED,5,ultoa(f->timesdled,tmp,10));
        !           462: putrec(fdat,F_TIMESDLED+5,2,crlf);
        !           463: putrec(fdat,F_OPENCOUNT,3,itoa(f->opencount,tmp,10));
        !           464: putrec(fdat,F_OPENCOUNT+3,2,crlf);
        !           465: fdat[F_MISC]=f->misc+SP;
        !           466: putrec(fdat,F_ALTPATH,2,hexplus(f->altpath,tmp));
        !           467: putrec(fdat,F_ALTPATH+2,2,crlf);
        !           468: f->datoffset=l;
        !           469: idx[0]=l&0xff;          /* Get offset within DAT file for IXB file */
        !           470: idx[1]=(l>>8)&0xff;
        !           471: idx[2]=(l>>16)&0xff;
        !           472: lseek(file,l,SEEK_SET);
        !           473: if(write(file,fdat,F_LEN)!=F_LEN) {
        !           474:     close(file);
        !           475:        return(0); }
        !           476: length=filelength(file);
        !           477: close(file);
        !           478: if(length%F_LEN)
        !           479:        printf("ERR_LEN %s %lu\n",str,length);
        !           480: 
        !           481: /*******************************************/
        !           482: /* Update last upload date/time stamp file */
        !           483: /*******************************************/
        !           484: sprintf(str,"%s%s.DAB",dir[f->dir]->data_dir,dir[f->dir]->code);
        !           485: if((file=nopen(str,O_WRONLY|O_CREAT))==-1)
        !           486:        printf("ERR_OPEN %s\r\n",str);
        !           487: else {
        !           488:        uldate=time(NULL);
        !           489:        write(file,&uldate,4);
        !           490:     close(file); }
        !           491: 
        !           492: /************************/
        !           493: /* Add data to IXB File */
        !           494: /************************/
        !           495: strcpy(fname,f->name);
        !           496: for(i=8;i<12;i++)   /* Turn FILENAME.EXT into FILENAMEEXT */
        !           497:     fname[i]=fname[i+1];
        !           498: sprintf(str,"%s%s.IXB",dir[f->dir]->data_dir,dir[f->dir]->code);
        !           499: if((file=nopen(str,O_RDWR|O_CREAT))==-1) {
        !           500:        printf("ERR_OPEN %s\n",str);
        !           501:        return(0); }
        !           502: length=filelength(file);
        !           503: if(length) {    /* IXB file isn't empty */
        !           504:     if(length%F_IXBSIZE) {
        !           505:         close(file);
        !           506:                printf("ERR_LEN %s %lu\n",str,length);
        !           507:                return(0); }
        !           508:        if((ixbbuf=(char *)MALLOC(length))==NULL) {
        !           509:         close(file);
        !           510:                printf("ERR_ALLOC %s %lu\n",str,length);
        !           511:                return(0); }
        !           512:        if(lread(file,ixbbuf,length)!=length) {
        !           513:         close(file);
        !           514:                printf("ERR_READ %s %lu\n",str,length);
        !           515:                FREE((char *)ixbbuf);
        !           516:                return(0); }
        !           517: /************************************************/
        !           518: /* Sort by Name or Date, Assending or Decending */
        !           519: /************************************************/
        !           520:     if(dir[f->dir]->sort==SORT_NAME_A || dir[f->dir]->sort==SORT_NAME_D) {
        !           521:         for(l=0;l<length;l+=F_IXBSIZE) {
        !           522:             for(i=0;i<12 && fname[i]==ixbbuf[l+i];i++);
        !           523:                        if(i==12) {     /* file already in directory index */
        !           524:                 close(file);
        !           525:                                printf("ERR_CHK %s\n",fname);
        !           526:                                FREE((char *)ixbbuf);
        !           527:                                return(0); }
        !           528:             if(dir[f->dir]->sort==SORT_NAME_A && fname[i]<ixbbuf[l+i])
        !           529:                 break;
        !           530:             if(dir[f->dir]->sort==SORT_NAME_D && fname[i]>ixbbuf[l+i])
        !           531:                 break; } }
        !           532:     else {  /* sort by date */
        !           533:         for(l=0;l<length;l+=F_IXBSIZE) {
        !           534:             uldate=(ixbbuf[l+15]|((long)ixbbuf[l+16]<<8)
        !           535:                 |((long)ixbbuf[l+17]<<16)|((long)ixbbuf[l+18]<<24));
        !           536:             if(dir[f->dir]->sort==SORT_DATE_A && f->dateuled>uldate)
        !           537:                 break;
        !           538:             if(dir[f->dir]->sort==SORT_DATE_D && f->dateuled<uldate)
        !           539:                 break; } }
        !           540:     lseek(file,l,SEEK_SET);
        !           541:     if(write(file,fname,11)!=11) {  /* Write filename to IXB file */
        !           542:         close(file);
        !           543:                FREE((char *)ixbbuf);
        !           544:                return(0); }
        !           545:     if(write(file,idx,3)!=3) {  /* Write DAT offset into IXB file */
        !           546:         close(file);
        !           547:                FREE((char *)ixbbuf);
        !           548:                return(0); }
        !           549:     write(file,&f->dateuled,sizeof(time_t));
        !           550:     write(file,&f->datedled,4);              /* Write 0 for datedled */
        !           551:        if(lwrite(file,&ixbbuf[l],length-l)!=length-l) { /* Write rest of IXB */
        !           552:         close(file);
        !           553:                FREE((char *)ixbbuf);
        !           554:                return(0); }
        !           555:        FREE((char *)ixbbuf); }
        !           556: else {              /* IXB file is empty... No files */
        !           557:     if(write(file,fname,11)!=11) {  /* Write filename it IXB file */
        !           558:         close(file);
        !           559:                return(0); }
        !           560:     if(write(file,idx,3)!=3) {  /* Write DAT offset into IXB file */
        !           561:         close(file);
        !           562:                return(0); }
        !           563:     write(file,&f->dateuled,sizeof(time_t));
        !           564:     write(file,&f->datedled,4); }
        !           565: length=filelength(file);
        !           566: close(file);
        !           567: if(length%F_IXBSIZE)
        !           568:        printf("ERR_LEN %s %lu\n",str,length);
        !           569: return(1);
        !           570: }
        !           571: 
        !           572: void putextdesc(uint dirnum, ulong datoffset, char *ext)
        !           573: {
        !           574:        char str[256],nulbuf[512];
        !           575:        int file;
        !           576: 
        !           577: sprintf(str,"%s%s.EXB",dir[dirnum]->data_dir,dir[dirnum]->code);
        !           578: if((file=nopen(str,O_WRONLY|O_CREAT))==-1)
        !           579:        return;
        !           580: lseek(file,0L,SEEK_END);
        !           581: while(filelength(file)<(datoffset/F_LEN)*512L)
        !           582:     write(file,nulbuf,512);
        !           583: lseek(file,(datoffset/F_LEN)*512L,SEEK_SET);
        !           584: write(file,ext,512);
        !           585: close(file);
        !           586: }
        !           587: 
        !           588: /****************************************************************************/
        !           589: /* Gets file data from dircode.IXB file                                                                                */
        !           590: /* Need fields .name and .dir filled.                                       */
        !           591: /* only fills .offset, .dateuled, and .datedled                             */
        !           592: /****************************************************************************/
        !           593: void getfileixb(file_t *f)
        !           594: {
        !           595:        uchar HUGE16 *ixbbuf,str[256],fname[128];
        !           596:        int file;
        !           597:        ulong l,length;
        !           598: 
        !           599: sprintf(str,"%s%s.IXB",dir[f->dir]->data_dir,dir[f->dir]->code);
        !           600: if((file=nopen(str,O_RDONLY))==-1) {
        !           601:        printf("ERR_OPEN %s\n",str);
        !           602:        return; }
        !           603: length=filelength(file);
        !           604: if(length%F_IXBSIZE) {
        !           605:        close(file);
        !           606:        printf("ERR_LEN %s\n");
        !           607:        return; }
        !           608: if((ixbbuf=(uchar HUGE16 *)MALLOC(length))==NULL) {
        !           609:        close(file);
        !           610:        printf("ERR_ALLOC %s\n",str);
        !           611:        return; }
        !           612: if(lread(file,ixbbuf,length)!=length) {
        !           613:        close(file);
        !           614:        FREE((char *)ixbbuf);
        !           615:        printf("ERR_READ %s\n",str);
        !           616:        return; }
        !           617: close(file);
        !           618: strcpy(fname,f->name);
        !           619: for(l=8;l<12;l++)      /* Turn FILENAME.EXT into FILENAMEEXT */
        !           620:        fname[l]=fname[l+1];
        !           621: for(l=0;l<length;l+=F_IXBSIZE) {
        !           622:        sprintf(str,"%11.11s",ixbbuf+l);
        !           623:        if(!strcmp(str,fname))
        !           624:                break; }
        !           625: if(l>=length) {
        !           626:        printf("getfileixb: ERR_CHK %s\n",fname);
        !           627:        FREE((char *)ixbbuf);
        !           628:        return; }
        !           629: l+=11;
        !           630: f->datoffset=ixbbuf[l]|((long)ixbbuf[l+1]<<8)|((long)ixbbuf[l+2]<<16);
        !           631: f->dateuled=ixbbuf[l+3]|((long)ixbbuf[l+4]<<8)
        !           632:        |((long)ixbbuf[l+5]<<16)|((long)ixbbuf[l+6]<<24);
        !           633: f->datedled=ixbbuf[l+7]|((long)ixbbuf[l+8]<<8)
        !           634:        |((long)ixbbuf[l+9]<<16)|((long)ixbbuf[l+10]<<24);
        !           635: FREE((char *)ixbbuf);
        !           636: }
        !           637: 
        !           638: /****************************************************************************/
        !           639: /* Puts filedata into DIR_code.DAT file                                     */
        !           640: /* Called from removefiles                                                  */
        !           641: /****************************************************************************/
        !           642: void putfiledat(file_t f)
        !           643: {
        !           644:     char buf[F_LEN+1],str[256];
        !           645:     int file;
        !           646:     long length;
        !           647: 
        !           648: putrec(buf,F_CDT,7,ultoa(f.cdt,tmp,10));
        !           649: putrec(buf,F_CDT+7,2,crlf);
        !           650: putrec(buf,F_DESC,LEN_FDESC,f.desc);
        !           651: putrec(buf,F_DESC+LEN_FDESC,2,crlf);
        !           652: putrec(buf,F_ULER,LEN_ALIAS+5,f.uler);
        !           653: putrec(buf,F_ULER+LEN_ALIAS+5,2,crlf);
        !           654: putrec(buf,F_TIMESDLED,5,itoa(f.timesdled,tmp,10));
        !           655: putrec(buf,F_TIMESDLED+5,2,crlf);
        !           656: putrec(buf,F_OPENCOUNT,3,itoa(f.opencount,tmp,10));
        !           657: putrec(buf,F_OPENCOUNT+3,2,crlf);
        !           658: buf[F_MISC]=f.misc+SP;
        !           659: putrec(buf,F_ALTPATH,2,hexplus(f.altpath,tmp));
        !           660: putrec(buf,F_ALTPATH+2,2,crlf);
        !           661: sprintf(str,"%s%s.DAT",dir[f.dir]->data_dir,dir[f.dir]->code);
        !           662: if((file=nopen(str,O_WRONLY))==-1) {
        !           663:        printf("ERR_OPEN %s\n",str);
        !           664:     return; }
        !           665: length=filelength(file);
        !           666: if(length%F_LEN) {
        !           667:     close(file);
        !           668:        printf("ERR_LEN %s\n",str);
        !           669:     return; }
        !           670: if(f.datoffset>length) {
        !           671:     close(file);
        !           672:        printf("ERR_LEN %s\n",str);
        !           673:     return; }
        !           674: lseek(file,f.datoffset,SEEK_SET);
        !           675: if(write(file,buf,F_LEN)!=F_LEN) {
        !           676:     close(file);
        !           677:        printf("ERR_WRITE %s\n",str);
        !           678:     return; }
        !           679: length=filelength(file);
        !           680: close(file);
        !           681: if(length%F_LEN)
        !           682:        printf("ERR_LEN %s\n",str);
        !           683: }
        !           684: 
        !           685: /****************************************************************************/
        !           686: /* Update the upload date for the file 'f'                                  */
        !           687: /****************************************************************************/
        !           688: void update_uldate(file_t f)
        !           689: {
        !           690:        char str[256],fname[128];
        !           691:        int i,file;
        !           692:        long l,length;
        !           693: 
        !           694: /*******************/
        !           695: /* Update IXB File */
        !           696: /*******************/
        !           697: sprintf(str,"%s%s.IXB",dir[f.dir]->data_dir,dir[f.dir]->code);
        !           698: if((file=nopen(str,O_RDWR))==-1) {
        !           699:        printf("ERR_OPEN %s\n",str);
        !           700:     return; }
        !           701: length=filelength(file);
        !           702: if(length%F_IXBSIZE) {
        !           703:     close(file);
        !           704:        printf("ERR_LEN %s\n",str);
        !           705:     return; }
        !           706: strcpy(fname,f.name);
        !           707: for(i=8;i<12;i++)   /* Turn FILENAME.EXT into FILENAMEEXT */
        !           708:     fname[i]=fname[i+1];
        !           709: for(l=0;l<length;l+=F_IXBSIZE) {
        !           710:     read(file,str,F_IXBSIZE);      /* Look for the filename in the IXB file */
        !           711:     str[11]=0;
        !           712:     if(!strcmp(fname,str)) break; }
        !           713: if(l>=length) {
        !           714:     close(file);
        !           715:        printf("ERR_CHK %s\n",f.name);
        !           716:     return; }
        !           717: lseek(file,l+14,SEEK_SET);
        !           718: write(file,&f.dateuled,4);     /* Write the current time stamp for datedled */
        !           719: close(file);
        !           720: 
        !           721: /*******************************************/
        !           722: /* Update last upload date/time stamp file */
        !           723: /*******************************************/
        !           724: sprintf(str,"%s%s.DAB",dir[f.dir]->data_dir,dir[f.dir]->code);
        !           725: if((file=nopen(str,O_WRONLY|O_CREAT))==-1)
        !           726:        printf("ERR_OPEN %s\r\n",str);
        !           727: else {
        !           728:        write(file,&f.dateuled,4);
        !           729:     close(file); }
        !           730: 
        !           731: }
        !           732: 
        !           733: 
        !           734: void strip_ctrl(char *str)
        !           735: {
        !           736:        char tmp[1024];
        !           737:        int i,j,k;
        !           738: 
        !           739: k=strlen(str);
        !           740: for(i=j=0;i<k;i++)
        !           741:        if(j && str[i]==SP && tmp[j-1]==SP && (mode&KEEP_SPACE))
        !           742:                tmp[j++]=str[i];
        !           743:        else if(j && str[i]<=SP && tmp[j-1]==SP)
        !           744:                continue;
        !           745:        else if(i && !isalnum(str[i]) && str[i]==str[i-1])
        !           746:                continue;
        !           747:        else if((uchar)str[i]>=SP)
        !           748:                tmp[j++]=str[i];
        !           749:        else if(str[i]==TAB || (str[i]==CR && str[i+1]==LF))
        !           750:                tmp[j++]=SP;
        !           751: tmp[j]=0;
        !           752: strcpy(str,tmp);
        !           753: }
        !           754: 
        !           755: 
        !           756: void strip_exascii(char *str)
        !           757: {
        !           758:        char tmp[1024];
        !           759:        int i,j,k;
        !           760: 
        !           761: k=strlen(str);
        !           762: for(i=j=0;i<k;i++)
        !           763:        if(!(str[i]&0x80))
        !           764:                tmp[j++]=str[i];
        !           765: tmp[j]=0;
        !           766: strcpy(str,tmp);
        !           767: }
        !           768: 
        !           769: /****************************************************************************/
        !           770: /* Updates dstst.dab file                                                                                                      */
        !           771: /****************************************************************************/
        !           772: void updatestats(ulong size)
        !           773: {
        !           774:     char str[256];
        !           775:     int i,file;
        !           776:        ulong l;
        !           777: 
        !           778: sprintf(str,"%sDSTS.DAB",ctrl_dir);
        !           779: if((file=nopen(str,O_RDWR))==-1) {
        !           780:        printf("ERR_OPEN %s\n",str);
        !           781:        return; }
        !           782: lseek(file,20L,SEEK_SET);      /* Skip timestamp, logons and logons today */
        !           783: read(file,&l,4);                       /* Uploads today                 */
        !           784: l++;
        !           785: lseek(file,-4L,SEEK_CUR);
        !           786: write(file,&l,4);
        !           787: read(file,&l,4);                       /* Upload bytes today    */
        !           788: l+=size;
        !           789: lseek(file,-4L,SEEK_CUR);
        !           790: write(file,&l,4);
        !           791: close(file);
        !           792: }
        !           793: 
        !           794: void addlist(char *inpath, file_t f, char dskip, char sskip)
        !           795: {
        !           796:        uchar str[256],fname[256],listpath[256],filepath[256]
        !           797:                ,curline[256],nextline[256],*p,exist,ext[1024],tmpext[513];
        !           798:        int i,file;
        !           799:        long l;
        !           800:        FILE *stream;
        !           801:        struct find_t ff;
        !           802: 
        !           803: if(mode&SEARCH_DIR) {
        !           804:        strcpy(str,cur_altpath ? altpath[cur_altpath-1] : dir[f.dir]->path);
        !           805:        if(str[0]=='.') {
        !           806:                sprintf(tmp,"%s%s",node_dir,str);
        !           807:                strcpy(str,tmp); }
        !           808:        strcat(str,"*.*");
        !           809:        printf("Searching %s\n\n",str);
        !           810:        for(i=_dos_findfirst(str,0,&ff);!i;i=_dos_findnext(&ff)) {
        !           811:                strupr(ff.name);
        !           812:                sprintf(filepath,"%s%s",cur_altpath ? altpath[cur_altpath-1]
        !           813:             : dir[f.dir]->path,ff.name);
        !           814:         if(filepath[0]=='.') { /* relative path */
        !           815:             sprintf(tmp,"%s%s",node_dir,filepath);
        !           816:             strcpy(filepath,tmp); }
        !           817:                f.misc=0;
        !           818:                f.desc[0]=0;
        !           819:                f.cdt=flength(filepath);
        !           820:                padfname(ff.name,f.name);
        !           821:                printf("%s  %10lu  %s\n"
        !           822:                        ,f.name,f.cdt,unixtodstr(fdate(filepath),str));
        !           823:                exist=findfile(f.dir,f.name);
        !           824:                if(exist) {
        !           825:                        if(mode&NO_UPDATE)
        !           826:                                continue;
        !           827:                        getfileixb(&f);
        !           828:                        if(mode&ULDATE_ONLY) {
        !           829:                                f.dateuled=time(NULL);
        !           830:                                update_uldate(f);
        !           831:                                continue; } }
        !           832: 
        !           833:                if(mode&FILE_DATE) {            /* get the file date and put into desc */
        !           834:                        unixtodstr(fdate(filepath),f.desc);
        !           835:                        strcat(f.desc,"  "); }
        !           836: 
        !           837:                if(mode&TODAYS_DATE) {          /* put today's date in desc */
        !           838:                        unixtodstr(time(NULL),f.desc);
        !           839:                        strcat(f.desc,"  "); }
        !           840: 
        !           841:                if(mode&FILE_ID) {
        !           842:                        for(i=0;i<total_fextrs;i++)
        !           843:                                if(!stricmp(fextr[i]->ext,f.name+9))
        !           844:                                        break;
        !           845:                        if(i<total_fextrs) {
        !           846:                                sprintf(tmp,"%sFILE_ID.DIZ",temp_dir);
        !           847:                                remove(tmp);
        !           848:                                system(cmdstr(fextr[i]->cmd,filepath,"FILE_ID.DIZ",NULL));
        !           849:                                if(!fexist(tmp)) {
        !           850:                                        sprintf(tmp,"%sDESC.SDI",temp_dir);
        !           851:                                        remove(tmp);
        !           852:                                        system(cmdstr(fextr[i]->cmd,filepath,"DESC.SDI",NULL)); }
        !           853:                                if((file=nopen(tmp,O_RDONLY))!=-1) {
        !           854:                                        memset(ext,0,513);
        !           855:                                        read(file,ext,512);
        !           856:                                        for(i=512;i;i--)
        !           857:                                                if(ext[i-1]>SP)
        !           858:                                                        break;
        !           859:                                        ext[i]=0;
        !           860:                                        if(mode&ASCII_ONLY)
        !           861:                                                strip_exascii(ext);
        !           862:                                        if(!(mode&KEEP_DESC)) {
        !           863:                                                sprintf(tmpext,"%.256s",ext);
        !           864:                                                strip_ctrl(tmpext);
        !           865:                                                for(i=0;tmpext[i];i++)
        !           866:                                                        if(isalpha(tmpext[i]))
        !           867:                                                                break;
        !           868:                                                sprintf(f.desc,"%.*s",LEN_FDESC,tmpext+i);
        !           869:                                                for(i=0;f.desc[i]>=SP && i<LEN_FDESC;i++)
        !           870:                                                        ;
        !           871:                                                f.desc[i]=0; }
        !           872:                                        close(file);
        !           873:                                        f.misc|=FM_EXTDESC; } } }
        !           874: 
        !           875:                f.dateuled=time(NULL);
        !           876:                f.altpath=cur_altpath;
        !           877:                strip_ctrl(f.desc);
        !           878:                if(mode&ASCII_ONLY)
        !           879:                        strip_exascii(f.desc);
        !           880:                if(exist) {
        !           881:                        putfiledat(f);
        !           882:                        if(!(mode&NO_NEWDATE))
        !           883:                                update_uldate(f); }
        !           884:                else
        !           885:                        addfiledat(&f);
        !           886:                if(f.misc&FM_EXTDESC) {
        !           887:                        truncsp(ext);
        !           888:                        putextdesc(f.dir,f.datoffset,ext); }
        !           889: 
        !           890:                if(mode&UL_STATS)
        !           891:                        updatestats(f.cdt);
        !           892:                files++; }
        !           893: #ifdef __WATCOMC__
        !           894:    _dos_findclose(&ff);
        !           895: #endif
        !           896:        return; }
        !           897: 
        !           898: 
        !           899: strcpy(listpath,inpath);
        !           900: if((stream=fnopen(&file,listpath,O_RDONLY))==NULL) {
        !           901:        sprintf(listpath,"%s%s",cur_altpath ? altpath[cur_altpath-1]
        !           902:                        : dir[f.dir]->path,inpath);
        !           903:        if(listpath[0]=='.') { /* relative path */
        !           904:                sprintf(str,"%s%s",node_dir,listpath);
        !           905:                strcpy(listpath,str); }
        !           906:        if((stream=fnopen(&file,listpath,O_RDONLY))==NULL) {
        !           907:                printf("Can't open: %s\n"
        !           908:                           "        or: %s\n",inpath,listpath);
        !           909:                return; } }
        !           910: 
        !           911: printf("Adding %s to %s %s\n\n"
        !           912:        ,listpath,lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
        !           913: 
        !           914: fgets(nextline,255,stream);
        !           915: while(!feof(stream) && !ferror(stream)) {
        !           916:        f.misc=0;
        !           917:        f.desc[0]=0;
        !           918:        strcpy(curline,nextline);
        !           919:        nextline[0]=0;
        !           920:        fgets(nextline,255,stream);
        !           921:        truncsp(curline);
        !           922:        if(curline[0]<=SP || (uchar)curline[0]>=0x7e)
        !           923:                continue;
        !           924:        printf("%s\n",curline);
        !           925:        strcpy(fname,curline);
        !           926: 
        !           927:        p=strchr(fname,'.');
        !           928:        if(!p || p==fname || p>fname+8)    /* no dot or invalid dot location */
        !           929:                continue;
        !           930:        p=strchr(p,SP);
        !           931:        if(p) *p=0;
        !           932:        else                               /* no space after filename? */
        !           933:                continue;
        !           934:        strupr(fname);
        !           935:        strcpy(fname,unpadfname(fname,tmp));
        !           936: 
        !           937:        padfname(fname,f.name);
        !           938:        if(strcspn(f.name,"\\/|<>+[]:=\";,")!=strlen(f.name))
        !           939:                continue;
        !           940: 
        !           941:     for(i=0;i<12;i++)
        !           942:         if(f.name[i]<SP || (uchar)f.name[i]>0x7e)
        !           943:             break;
        !           944: 
        !           945:        if(i<12)                                        /* Ctrl chars or EX-ASCII in filename? */
        !           946:                continue;
        !           947:        exist=findfile(f.dir,f.name);
        !           948:     if(exist) {
        !           949:         if(mode&NO_UPDATE)
        !           950:             continue;
        !           951:                getfileixb(&f);
        !           952:                if(mode&ULDATE_ONLY) {
        !           953:                        f.dateuled=time(NULL);
        !           954:                        update_uldate(f);
        !           955:                        continue; } }
        !           956: 
        !           957:        sprintf(filepath,"%s%s",cur_altpath ? altpath[cur_altpath-1]
        !           958:                : dir[f.dir]->path,fname);
        !           959:        if(filepath[0]=='.') { /* relative path */
        !           960:                sprintf(tmp,"%s%s",node_dir,filepath);
        !           961:                strcpy(filepath,tmp); }
        !           962: 
        !           963:        if(mode&FILE_DATE) {            /* get the file date and put into desc */
        !           964:                l=fdate(filepath);
        !           965:                unixtodstr(l,f.desc);
        !           966:                strcat(f.desc,"  "); }
        !           967: 
        !           968:        if(mode&TODAYS_DATE) {          /* put today's date in desc */
        !           969:                l=time(NULL);
        !           970:                unixtodstr(l,f.desc);
        !           971:                strcat(f.desc,"  "); }
        !           972: 
        !           973:        if(dskip && strlen(curline)>=dskip) p=curline+dskip;
        !           974:        else {
        !           975:                p++;
        !           976:                while(*p==SP) p++; }
        !           977:        sprintf(tmp,"%.*s",LEN_FDESC-strlen(f.desc),p);
        !           978:        strcat(f.desc,tmp);
        !           979: 
        !           980:        if(nextline[0]==SP || strlen(p)>LEN_FDESC) {    /* ext desc */
        !           981:                if(!(mode&NO_EXTEND)) {
        !           982:                        memset(ext,0,513);
        !           983:                        f.misc|=FM_EXTDESC;
        !           984:                        sprintf(ext,"%s\r\n",p); }
        !           985: 
        !           986:                if(nextline[0]==SP) {
        !           987:                        strcpy(str,nextline);                              /* tack on to end of desc */
        !           988:                        p=str+dskip;
        !           989:                        i=LEN_FDESC-strlen(f.desc);
        !           990:                        if(i>1) {
        !           991:                                p[i-1]=0;
        !           992:                                truncsp(p);
        !           993:                                if(p[0]) {
        !           994:                                        strcat(f.desc," ");
        !           995:                                        strcat(f.desc,p); } } }
        !           996: 
        !           997:                while(!feof(stream) && !ferror(stream) && strlen(ext)<512) {
        !           998:                        if(nextline[0]!=SP)
        !           999:                                break;
        !          1000:                        truncsp(nextline);
        !          1001:                        printf("%s\n",nextline);
        !          1002:                        if(!(mode&NO_EXTEND)) {
        !          1003:                                f.misc|=FM_EXTDESC;
        !          1004:                                p=nextline+dskip;
        !          1005:                                while(*p==SP) p++;
        !          1006:                                strcat(ext,p);
        !          1007:                                strcat(ext,"\r\n"); }
        !          1008:                        nextline[0]=0;
        !          1009:                        fgets(nextline,255,stream); } }
        !          1010: 
        !          1011: 
        !          1012:        if(sskip) l=atol(fname+sskip);
        !          1013:        else {
        !          1014:                l=flength(filepath);
        !          1015:                if(l<1L) {
        !          1016:                        printf("%s not found.\n",filepath);
        !          1017:                        continue; } }
        !          1018: 
        !          1019:        if(mode&FILE_ID) {
        !          1020:         for(i=0;i<total_fextrs;i++)
        !          1021:             if(!stricmp(fextr[i]->ext,f.name+9))
        !          1022:                 break;
        !          1023:         if(i<total_fextrs) {
        !          1024:             sprintf(tmp,"%sFILE_ID.DIZ",temp_dir);
        !          1025:             remove(tmp);
        !          1026:                        system(cmdstr(fextr[i]->cmd,filepath,"FILE_ID.DIZ",NULL));
        !          1027:             if(!fexist(tmp)) {
        !          1028:                 sprintf(tmp,"%sDESC.SDI",temp_dir);
        !          1029:                 remove(tmp);
        !          1030:                                system(cmdstr(fextr[i]->cmd,filepath,"DESC.SDI",NULL)); }
        !          1031:                        if((file=nopen(tmp,O_RDONLY))!=-1) {
        !          1032:                                memset(ext,0,513);
        !          1033:                                read(file,ext,512);
        !          1034:                                for(i=512;i;i--)
        !          1035:                                        if(ext[i-1]>SP)
        !          1036:                                                break;
        !          1037:                                ext[i]=0;
        !          1038:                                if(mode&ASCII_ONLY)
        !          1039:                                        strip_exascii(ext);
        !          1040:                                if(!(mode&KEEP_DESC)) {
        !          1041:                                        sprintf(tmpext,"%.256s",ext);
        !          1042:                                        strip_ctrl(tmpext);
        !          1043:                                        for(i=0;tmpext[i];i++)
        !          1044:                                                if(isalpha(tmpext[i]))
        !          1045:                                                        break;
        !          1046:                                        sprintf(f.desc,"%.*s",LEN_FDESC,tmpext+i);
        !          1047:                                        for(i=0;f.desc[i]>=SP && i<LEN_FDESC;i++)
        !          1048:                                                ;
        !          1049:                                        f.desc[i]=0; }
        !          1050:                                close(file);
        !          1051:                                f.misc|=FM_EXTDESC; } } }
        !          1052: 
        !          1053:        f.cdt=l;
        !          1054:        f.dateuled=time(NULL);
        !          1055:        f.altpath=cur_altpath;
        !          1056:        strip_ctrl(f.desc);
        !          1057:        if(mode&ASCII_ONLY)
        !          1058:                strip_exascii(f.desc);
        !          1059:        if(exist) {
        !          1060:                putfiledat(f);
        !          1061:                if(!(mode&NO_NEWDATE))
        !          1062:                        update_uldate(f); }
        !          1063:        else
        !          1064:                addfiledat(&f);
        !          1065:        if(f.misc&FM_EXTDESC) {
        !          1066:                truncsp(ext);
        !          1067:                putextdesc(f.dir,f.datoffset,ext); }
        !          1068: 
        !          1069:        if(mode&UL_STATS)
        !          1070:                updatestats(l);
        !          1071:        files++; }
        !          1072: fclose(stream);
        !          1073: if(mode&DEL_LIST && !(mode&SYNC_LIST)) {
        !          1074:        printf("\nDeleting %s\n",listpath);
        !          1075:        remove(listpath); }
        !          1076: 
        !          1077: }
        !          1078: 
        !          1079: /***********************/
        !          1080: /* Hex-plus to integer */
        !          1081: /***********************/
        !          1082: uint hptoi(char *str)
        !          1083: {
        !          1084:        char tmp[128];
        !          1085:        uint i;
        !          1086: 
        !          1087: if(!str[1] || toupper(str[0])<='F')
        !          1088:        return(strtol(str,0,16));
        !          1089: strcpy(tmp,str);
        !          1090: tmp[0]='F';
        !          1091: i=strtol(tmp,0,16)+((toupper(str[0])-'F')*0x10);
        !          1092: return(i);
        !          1093: }
        !          1094: 
        !          1095: /****************************************************************************/
        !          1096: /* Places into 'strout' CR or ETX terminated string starting at             */
        !          1097: /* 'start' and ending at 'start'+'length' or terminator from 'strin'        */
        !          1098: /****************************************************************************/
        !          1099: void getrec(char *strin,int start,int length,char *strout)
        !          1100: {
        !          1101:     int i=0,stop;
        !          1102: 
        !          1103: stop=start+length;
        !          1104: while(start<stop) {
        !          1105:     if(strin[start]==ETX)
        !          1106:         break;
        !          1107:     strout[i++]=strin[start++]; }
        !          1108: strout[i]=0;
        !          1109: }
        !          1110: 
        !          1111: 
        !          1112: /****************************************************************************/
        !          1113: /* Gets filedata from dircode.DAT file                                                                         */
        !          1114: /* Need fields .name ,.dir and .offset to get other info                               */
        !          1115: /* Does not fill .dateuled or .datedled fields.                             */
        !          1116: /****************************************************************************/
        !          1117: void getfiledat(file_t *f)
        !          1118: {
        !          1119:        char buf[F_LEN+1],str[256];
        !          1120:        int file;
        !          1121:        long length;
        !          1122: 
        !          1123: sprintf(str,"%s%s.DAT",dir[f->dir]->data_dir,dir[f->dir]->code);
        !          1124: if((file=nopen(str,O_RDONLY))==-1) {
        !          1125:        printf("ERR_OPEN %s\n",str);
        !          1126:        return; }
        !          1127: length=filelength(file);
        !          1128: if(f->datoffset>length) {
        !          1129:        close(file);
        !          1130:        printf("ERR_LEN %s %lu\n",str,length);
        !          1131:        return; }
        !          1132: if(length%F_LEN) {
        !          1133:        close(file);
        !          1134:        printf("ERR_LEN %s %lu\n",str,length);
        !          1135:        return; }
        !          1136: lseek(file,f->datoffset,SEEK_SET);
        !          1137: if(read(file,buf,F_LEN)!=F_LEN) {
        !          1138:     close(file);
        !          1139:        printf("ERR_READ %s %lu\n",str,F_LEN);
        !          1140:        return; }
        !          1141: close(file);
        !          1142: getrec(buf,F_ALTPATH,2,str);
        !          1143: f->altpath=hptoi(str);
        !          1144: getrec(buf,F_CDT,7,str);
        !          1145: f->cdt=atol(str);
        !          1146: f->timetodl=0;
        !          1147: 
        !          1148: getrec(buf,F_DESC,LEN_FDESC,f->desc);
        !          1149: getrec(buf,F_ULER,LEN_ALIAS,f->uler);
        !          1150: getrec(buf,F_TIMESDLED,5,str);
        !          1151: f->timesdled=atoi(str);
        !          1152: getrec(buf,F_OPENCOUNT,3,str);
        !          1153: f->opencount=atoi(str);
        !          1154: if(buf[F_MISC]!=ETX)
        !          1155:        f->misc=buf[F_MISC]-SP;
        !          1156: else
        !          1157:        f->misc=0;
        !          1158: }
        !          1159: 
        !          1160: /****************************************************************************/
        !          1161: /* Removes any files in the user transfer index (XFER.IXT) that match the   */
        !          1162: /* specifications of dest, or source user, or filename or any combination.  */
        !          1163: /****************************************************************************/
        !          1164: void rmuserxfers(int fromuser, int destuser, char *fname)
        !          1165: {
        !          1166:     char str[256],*ixtbuf;
        !          1167:     int file;
        !          1168:     long l,length;
        !          1169: 
        !          1170: sprintf(str,"%sXFER.IXT",data_dir);
        !          1171: if(!fexist(str))
        !          1172:     return;
        !          1173: if(!flength(str)) {
        !          1174:     remove(str);
        !          1175:     return; }
        !          1176: if((file=nopen(str,O_RDONLY))==-1) {
        !          1177:        printf("ERR_OPEN %s\n",str);
        !          1178:     return; }
        !          1179: length=filelength(file);
        !          1180: if((ixtbuf=(char *)MALLOC(length))==NULL) {
        !          1181:     close(file);
        !          1182:        printf("ERR_ALLOC %s\n",str,length);
        !          1183:     return; }
        !          1184: if(read(file,ixtbuf,length)!=length) {
        !          1185:     close(file);
        !          1186:        FREE(ixtbuf);
        !          1187:        printf("ERR_READ %s %lu\n",str,length);
        !          1188:     return; }
        !          1189: close(file);
        !          1190: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
        !          1191:        FREE(ixtbuf);
        !          1192:        printf("ERR_OPEN %s\n",str);
        !          1193:     return; }
        !          1194: for(l=0;l<length;l+=24) {
        !          1195:     if(fname!=NULL && fname[0]) {               /* fname specified */
        !          1196:         if(!strncmp(ixtbuf+l+5,fname,12)) {     /* this is the file */
        !          1197:             if(destuser && fromuser) {          /* both dest and from user */
        !          1198:                 if(atoi(ixtbuf+l)==destuser && atoi(ixtbuf+l+18)==fromuser)
        !          1199:                     continue; }                 /* both match */
        !          1200:             else if(fromuser) {                 /* from user */
        !          1201:                 if(atoi(ixtbuf+l+18)==fromuser) /* matches */
        !          1202:                     continue; }
        !          1203:             else if(destuser) {                 /* dest user */
        !          1204:                 if(atoi(ixtbuf+l)==destuser)    /* matches */
        !          1205:                     continue; }
        !          1206:             else continue; } }                  /* no users, so match */
        !          1207:     else if(destuser && fromuser) {
        !          1208:         if(atoi(ixtbuf+l+18)==fromuser && atoi(ixtbuf+l)==destuser)
        !          1209:             continue; }
        !          1210:     else if(destuser && atoi(ixtbuf+l)==destuser)
        !          1211:         continue;
        !          1212:     else if(fromuser && atoi(ixtbuf+l+18)==fromuser)
        !          1213:         continue;
        !          1214:     write(file,ixtbuf+l,24); }
        !          1215: close(file);
        !          1216: FREE(ixtbuf);
        !          1217: }
        !          1218: 
        !          1219: 
        !          1220: 
        !          1221: /****************************************************************************/
        !          1222: /* Removes DAT and IXB entries for the file in the struct 'f'               */
        !          1223: /****************************************************************************/
        !          1224: void removefiledat(file_t f)
        !          1225: {
        !          1226:        char c,str[256],ixbname[12],HUGE16 *ixbbuf,fname[13];
        !          1227:     int file;
        !          1228:     ulong l,length;
        !          1229: 
        !          1230: strcpy(fname,f.name);
        !          1231: for(c=8;c<12;c++)   /* Turn FILENAME.EXT into FILENAMEEXT */
        !          1232:     fname[c]=fname[c+1];
        !          1233: sprintf(str,"%s%s.IXB",dir[f.dir]->data_dir,dir[f.dir]->code);
        !          1234: if((file=nopen(str,O_RDONLY))==-1) {
        !          1235:        printf("ERR_OPEN %s\n",str);
        !          1236:     return; }
        !          1237: length=filelength(file);
        !          1238: if(!length) {
        !          1239:        close(file);
        !          1240:        return; }
        !          1241: if((ixbbuf=(char *)MALLOC(length))==0) {
        !          1242:     close(file);
        !          1243:        printf("ERR_ALLOC %s %lu\n",str,length);
        !          1244:     return; }
        !          1245: if(lread(file,ixbbuf,length)!=length) {
        !          1246:     close(file);
        !          1247:        printf("ERR_READ %s %lu\n",str,length);
        !          1248:        FREE((char *)ixbbuf);
        !          1249:     return; }
        !          1250: close(file);
        !          1251: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
        !          1252:        printf("ERR_OPEN %s\n",str);
        !          1253:     return; }
        !          1254: for(l=0;l<length;l+=F_IXBSIZE) {
        !          1255:     for(c=0;c<11;c++)
        !          1256:         ixbname[c]=ixbbuf[l+c];
        !          1257:     ixbname[c]=0;
        !          1258:     if(strcmp(ixbname,fname))
        !          1259:                if(lwrite(file,&ixbbuf[l],F_IXBSIZE)!=F_IXBSIZE) {
        !          1260:             close(file);
        !          1261:                        printf("ERR_WRITE %s %lu\n",str,F_IXBSIZE);
        !          1262:                        FREE((char *)ixbbuf);
        !          1263:             return; } }
        !          1264: FREE((char *)ixbbuf);
        !          1265: close(file);
        !          1266: sprintf(str,"%s%s.DAT",dir[f.dir]->data_dir,dir[f.dir]->code);
        !          1267: if((file=nopen(str,O_WRONLY))==-1) {
        !          1268:        printf("ERR_OPEN %s\n",str);
        !          1269:     return; }
        !          1270: lseek(file,f.datoffset,SEEK_SET);
        !          1271: c=ETX;          /* If first char of record is ETX, record is unused */
        !          1272: if(write(file,&c,1)!=1) { /* So write a D_T on the first byte of the record */
        !          1273:     close(file);
        !          1274:        printf("ERR_WRITE %s 1",str);
        !          1275:     return; }
        !          1276: close(file);
        !          1277: if(f.dir==user_dir)  /* remove file from index */
        !          1278:     rmuserxfers(0,0,f.name);
        !          1279: 
        !          1280: }
        !          1281: 
        !          1282: 
        !          1283: void synclist(char *inpath, int dirnum)
        !          1284: {
        !          1285:        uchar str[1024],fname[256],listpath[256], HUGE16 *ixbbuf,*p;
        !          1286:        int i,file,found;
        !          1287:        long l,m,length;
        !          1288:        FILE *stream;
        !          1289:        file_t f;
        !          1290: 
        !          1291: sprintf(str,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
        !          1292: if((file=nopen(str,O_RDONLY))==-1) {
        !          1293:        printf("ERR_OPEN %s\n",str);
        !          1294:        return; }
        !          1295: length=filelength(file);
        !          1296: if(length%F_IXBSIZE) {
        !          1297:        close(file);
        !          1298:        printf("ERR_LEN %s\n");
        !          1299:        return; }
        !          1300: if((ixbbuf=(uchar HUGE16 *)MALLOC(length))==NULL) {
        !          1301:        close(file);
        !          1302:        printf("ERR_ALLOC %s\n",str);
        !          1303:        return; }
        !          1304: if(lread(file,ixbbuf,length)!=length) {
        !          1305:        close(file);
        !          1306:        FREE((char *)ixbbuf);
        !          1307:        printf("ERR_READ %s\n",str);
        !          1308:        return; }
        !          1309: close(file);
        !          1310: 
        !          1311: strcpy(listpath,inpath);
        !          1312: if((stream=fnopen(&file,listpath,O_RDONLY))==NULL) {
        !          1313:        sprintf(listpath,"%s%s",cur_altpath ? altpath[cur_altpath-1]
        !          1314:                        : dir[dirnum]->path,inpath);
        !          1315:        if(listpath[0]=='.') { /* relative path */
        !          1316:                sprintf(str,"%s%s",node_dir,listpath);
        !          1317:                strcpy(listpath,str); }
        !          1318:        if((stream=fnopen(&file,listpath,O_RDONLY))==NULL) {
        !          1319:                printf("Can't open: %s\n"
        !          1320:                           "        or: %s\n",inpath,listpath);
        !          1321:                return; } }
        !          1322: 
        !          1323: printf("\nSynchronizing %s with %s %s\n\n"
        !          1324:        ,listpath,lib[dir[dirnum]->lib]->sname,dir[dirnum]->sname);
        !          1325: 
        !          1326: for(l=0;l<length;l+=F_IXBSIZE) {
        !          1327:        m=l;
        !          1328:        for(i=0;i<12 && l<length;i++)
        !          1329:                if(i==8)
        !          1330:                        str[i]='.';
        !          1331:                else
        !          1332:                        str[i]=ixbbuf[m++];     /* Turns FILENAMEEXT into FILENAME.EXT */
        !          1333:        str[i]=0;
        !          1334:        unpadfname(str,fname);
        !          1335:        rewind(stream);
        !          1336:        found=0;
        !          1337:        while(!found) {
        !          1338:                if(!fgets(str,1000,stream))
        !          1339:                        break;
        !          1340:                truncsp(str);
        !          1341:                p=strchr(str,SP);
        !          1342:                if(p) *p=0;
        !          1343:                if(!stricmp(str,fname))
        !          1344:                        found=1; }
        !          1345:        if(found)
        !          1346:                continue;
        !          1347:        padfname(fname,f.name);
        !          1348:        printf("%s not found in list - ",f.name);
        !          1349:        f.dir=dirnum;
        !          1350:        f.datoffset=ixbbuf[m]|((long)ixbbuf[m+1]<<8)|((long)ixbbuf[m+2]<<16);
        !          1351:        getfiledat(&f);
        !          1352:        if(f.opencount) {
        !          1353:                printf("currently OPEN by %u users\n",f.opencount);
        !          1354:                continue; }
        !          1355:        removefiledat(f);
        !          1356:        sprintf(str,"%s%s"
        !          1357:                ,f.altpath>0 && f.altpath<=altpaths ? altpath[f.altpath-1]
        !          1358:                : dir[f.dir]->path,fname);
        !          1359:        if(str[0]=='.') {
        !          1360:                sprintf(tmp,"%s%s",node_dir,str);
        !          1361:         strcpy(str,tmp); }
        !          1362:        if(remove(str))
        !          1363:                printf("Error removing %s\n",str);
        !          1364:        removed++;
        !          1365:        printf("Removed from database\n"); }
        !          1366: 
        !          1367: if(mode&DEL_LIST) {
        !          1368:        printf("\nDeleting %s\n",listpath);
        !          1369:        remove(listpath); }
        !          1370: }
        !          1371: 
        !          1372: char *usage="\nusage: addfiles code [.alt_path] [/opts] [\"*user\"] +list "
        !          1373:                         "[desc_off] [size_off]"
        !          1374:        "\n   or: addfiles code [.alt_path] [/opts] [\"*user\"]  file "
        !          1375:                "\"description\"\n"
        !          1376:        "\navailable opts:"
        !          1377:        "\n       a    import ASCII only (no extended ASCII)"
        !          1378:        "\n       b    synchronize database with file list (use with caution)"
        !          1379:        "\n       c    do not remove extra spaces from file description"
        !          1380:        "\n       d    delete list after import"
        !          1381:        "\n       e    do not import extended descriptions"
        !          1382:        "\n       f    include file date in descriptions"
        !          1383:        "\n       t    include today's date in descriptions"
        !          1384:        "\n       i    include added files in upload statistics"
        !          1385:        "\n       n    do not update information for existing files"
        !          1386:        "\n       o    update upload date only for existing files"
        !          1387:        "\n       u    do not update upload date for existing files"
        !          1388:        "\n       z    check for and import FILE_ID.DIZ and DESC.SDI"
        !          1389:        "\n       k    keep original short description (not DIZ)"
        !          1390:        "\n       s    search directory for files (no file list)"
        !          1391:        "\n"
        !          1392:        "\nAuto-ADD:   use * in place of code for Auto-ADD of FILES.BBS"
        !          1393:        "\n            use *filename to Auto-ADD a different filename"
        !          1394:        "\n"
        !          1395:        ;
        !          1396: 
        !          1397: /*********************/
        !          1398: /* Entry point (duh) */
        !          1399: /*********************/
        !          1400: int main(int argc, char **argv)
        !          1401: {
        !          1402:        uchar str[256],str2[256],*p,exist,listgiven=0,namegiven=0,ext[513]
        !          1403:                ,auto_name[13]="FILES.BBS";
        !          1404:        int i,j,k,file;
        !          1405:        long l;
        !          1406:        read_cfg_text_t txt;
        !          1407:        file_t f;
        !          1408: 
        !          1409: putenv("TZ=UCT0");
        !          1410: _fmode=O_BINARY;
        !          1411: setvbuf(stdout,NULL,_IONBF,0);
        !          1412: 
        !          1413: fprintf(stderr,"\nADDFILES Version %s (%s) - Adds files to Synchronet "
        !          1414:        "Filebase\n"
        !          1415:        ,ADDFILES_VER
        !          1416: #if defined(__OS2__)
        !          1417:        ,"OS/2"
        !          1418: #elif defined(__NT__)
        !          1419:     ,"Win32"
        !          1420: #elif defined(__DOS4G__)
        !          1421:        ,"DOS4G"
        !          1422: #elif defined(__FLAT__)
        !          1423:        ,"DOS32"
        !          1424: #else
        !          1425:        ,"DOS16"
        !          1426: #endif
        !          1427:        );
        !          1428: 
        !          1429: if(argc<2) {
        !          1430:        printf(usage);
        !          1431:        return(1); }
        !          1432: 
        !          1433: p=getenv("SBBSNODE");
        !          1434: if(p==NULL) {
        !          1435:        printf("\nSBBSNODE environment variable not set.\n");
        !          1436:        printf("\nExample: SET SBBSNODE=C:\\SBBS\\NODE1\n");
        !          1437:        exit(1); }
        !          1438: 
        !          1439: putenv("TZ=UCT0");
        !          1440: 
        !          1441: strcpy(node_dir,p);
        !          1442: if(node_dir[strlen(node_dir)-1]!='\\')
        !          1443:        strcat(node_dir,"\\");
        !          1444: 
        !          1445: txt.openerr="\7\nError opening %s for read.\n";
        !          1446: txt.reading="\nReading %s...";
        !          1447: txt.readit="\rRead %s       ";
        !          1448: txt.allocerr="\7\nError allocating %u bytes of memory\n";
        !          1449: txt.error="\7\nERROR: Offset %lu in %s\r\n\n";
        !          1450: 
        !          1451: read_node_cfg(txt);
        !          1452: if(ctrl_dir[0]=='.') {   /* Relative path */
        !          1453:        strcpy(str,ctrl_dir);
        !          1454:        sprintf(ctrl_dir,"%s%s",node_dir,str); }
        !          1455: read_main_cfg(txt);
        !          1456: if(data_dir[0]=='.') {   /* Relative path */
        !          1457:        strcpy(str,data_dir);
        !          1458:        sprintf(data_dir,"%s%s",node_dir,str); }
        !          1459: if(temp_dir[1]!=':' && temp_dir[0]!='\\') {
        !          1460:        strcpy(str,temp_dir);
        !          1461:        sprintf(temp_dir,"%s%s",node_dir,str); }
        !          1462: read_file_cfg(txt);
        !          1463: printf("\n\n");
        !          1464: 
        !          1465: if(argv[1][0]=='*') {
        !          1466:        if(argv[1][1])
        !          1467:                sprintf(auto_name,"%.12s",argv[1]+1);
        !          1468:        mode|=AUTO_ADD;
        !          1469:        i=0; }
        !          1470: else {
        !          1471:        for(i=0;i<total_dirs;i++)
        !          1472:                if(!stricmp(dir[i]->code,argv[1]))
        !          1473:                        break;
        !          1474: 
        !          1475:        if(i>=total_dirs) {
        !          1476:                printf("Directory code '%s' not found.\n",argv[1]);
        !          1477:                exit(1); } }
        !          1478: 
        !          1479: memset(&f,0,sizeof(file_t));
        !          1480: f.dir=i;
        !          1481: strcpy(f.uler,"-> ADDFILES <-");
        !          1482: 
        !          1483: for(j=2;j<argc;j++) {
        !          1484:        if(argv[j][0]=='*')     /* set the uploader name */
        !          1485:                sprintf(f.uler,"%.25s",argv[j]+1);
        !          1486:        else if(argv[j][0]=='/') {      /* options */
        !          1487:                for(i=1;i<strlen(argv[j]);i++)
        !          1488:                        switch(toupper(argv[j][i])) {
        !          1489:                                case 'A':
        !          1490:                                        mode|=ASCII_ONLY;
        !          1491:                                        break;
        !          1492:                                case 'B':
        !          1493:                                        mode|=(SYNC_LIST|NO_UPDATE);
        !          1494:                                        break;
        !          1495:                                case 'C':
        !          1496:                                        mode|=KEEP_SPACE;
        !          1497:                                        break;
        !          1498:                                case 'D':
        !          1499:                                        mode|=DEL_LIST;
        !          1500:                                        break;
        !          1501:                                case 'E':
        !          1502:                                        mode|=NO_EXTEND;
        !          1503:                                        break;
        !          1504:                                case 'I':
        !          1505:                                        mode|=UL_STATS;
        !          1506:                                        break;
        !          1507:                                case 'Z':
        !          1508:                                        mode|=FILE_ID;
        !          1509:                                        break;
        !          1510:                                case 'K':
        !          1511:                                        mode|=KEEP_DESC;         /* Don't use DIZ for short desc */
        !          1512:                                        break;
        !          1513:                                case 'N':
        !          1514:                                        mode|=NO_UPDATE;
        !          1515:                                        break;
        !          1516:                                case 'O':
        !          1517:                                        mode|=ULDATE_ONLY;
        !          1518:                                        break;
        !          1519:                                case 'U':
        !          1520:                                        mode|=NO_NEWDATE;
        !          1521:                                        break;
        !          1522:                                case 'F':
        !          1523:                                        mode|=FILE_DATE;
        !          1524:                                        break;
        !          1525:                                case 'T':
        !          1526:                                        mode|=TODAYS_DATE;
        !          1527:                                        break;
        !          1528:                                case 'S':
        !          1529:                                        mode|=SEARCH_DIR;
        !          1530:                                        break;
        !          1531:                                default:
        !          1532:                                        printf(usage);
        !          1533:                                        return(1); } }
        !          1534:        else if(argv[j][0]=='+') {      /* filelist - FILES.BBS */
        !          1535:                listgiven=1;
        !          1536:                if(isdigit(argv[j+1][0])) { /* skip x characters before description */
        !          1537:                        if(isdigit(argv[j+2][0])) { /* skip x characters before size */
        !          1538:                                addlist(argv[j]+1,f,atoi(argv[j+1]),atoi(argv[j+2]));
        !          1539:                                j+=2; }
        !          1540:                        else {
        !          1541:                                addlist(argv[j]+1,f,atoi(argv[j+1]),0);
        !          1542:                                j++; } }
        !          1543:                else
        !          1544:                        addlist(argv[j]+1,f,0,0);
        !          1545:                if(mode&SYNC_LIST)
        !          1546:                        synclist(argv[j]+1,f.dir); }
        !          1547:        else if(argv[j][0]=='.') {      /* alternate file path */
        !          1548:                cur_altpath=atoi(argv[j]+1);
        !          1549:                if(cur_altpath>altpaths) {
        !          1550:                        printf("Invalid alternate path.\n");
        !          1551:                        exit(1); } }
        !          1552:        else {
        !          1553:                namegiven=1;
        !          1554:                padfname(argv[j],f.name);
        !          1555:                f.desc[0]=0;
        !          1556:                strupr(f.name);
        !          1557:                if(j+1==argc) {
        !          1558:                        printf("%s no description given.\n",f.name);
        !          1559:                        continue; }
        !          1560:                sprintf(str,"%s%s",cur_altpath ? altpath[cur_altpath-1]
        !          1561:                        : dir[f.dir]->path,argv[j]);
        !          1562:                if(str[0]=='.') {
        !          1563:                        sprintf(tmp,"%s%s",node_dir,str);
        !          1564:                        strcpy(str,tmp); }
        !          1565:                if(mode&FILE_DATE)
        !          1566:                        sprintf(f.desc,"%s  ",unixtodstr(fdate(str),tmp));
        !          1567:                if(mode&TODAYS_DATE)
        !          1568:                        sprintf(f.desc,"%s  ",unixtodstr(time(NULL),tmp));
        !          1569:                sprintf(tmp,"%.*s",LEN_FDESC-strlen(f.desc),argv[++j]);
        !          1570:                strcpy(f.desc,tmp);
        !          1571:                l=flength(str);
        !          1572:                if(l==-1) {
        !          1573:                        printf("%s not found.\n",str);
        !          1574:                        continue; }
        !          1575:                exist=findfile(f.dir,f.name);
        !          1576:                if(exist) {
        !          1577:                        if(mode&NO_UPDATE)
        !          1578:                                continue;
        !          1579:                        getfileixb(&f);
        !          1580:                        if(mode&ULDATE_ONLY) {
        !          1581:                                f.dateuled=time(NULL);
        !          1582:                                update_uldate(f);
        !          1583:                                continue; } }
        !          1584:                f.cdt=l;
        !          1585:                f.dateuled=time(NULL);
        !          1586:                f.altpath=cur_altpath;
        !          1587:                strip_ctrl(f.desc);
        !          1588:                if(mode&ASCII_ONLY)
        !          1589:                        strip_exascii(f.desc);
        !          1590:                printf("%s %7lu %s\n",f.name,f.cdt,f.desc);
        !          1591:                if(mode&FILE_ID) {
        !          1592:                        for(i=0;i<total_fextrs;i++)
        !          1593:                                if(!stricmp(fextr[i]->ext,f.name+9))
        !          1594:                                        break;
        !          1595:                        if(i<total_fextrs) {
        !          1596:                                sprintf(tmp,"%sFILE_ID.DIZ",temp_dir);
        !          1597:                                remove(tmp);
        !          1598:                                system(cmdstr(fextr[i]->cmd,str,"FILE_ID.DIZ",NULL));
        !          1599:                                if(!fexist(tmp)) {
        !          1600:                                        sprintf(tmp,"%sDESC.SDI",temp_dir);
        !          1601:                                        remove(tmp);
        !          1602:                                        system(cmdstr(fextr[i]->cmd,str,"DESC.SDI",NULL)); }
        !          1603:                                if((file=nopen(tmp,O_RDONLY))!=-1) {
        !          1604:                                        memset(ext,0,513);
        !          1605:                                        read(file,ext,512);
        !          1606:                                        if(!(mode&KEEP_DESC)) {
        !          1607:                                                sprintf(f.desc,"%.*s",LEN_FDESC,ext);
        !          1608:                                                for(i=0;f.desc[i]>=SP && i<LEN_FDESC;i++)
        !          1609:                                                        ;
        !          1610:                                                f.desc[i]=0; }
        !          1611:                                        close(file);
        !          1612:                                        f.misc|=FM_EXTDESC; } } }
        !          1613:                if(exist) {
        !          1614:                        putfiledat(f);
        !          1615:                        if(!(mode&NO_NEWDATE))
        !          1616:                                update_uldate(f); }
        !          1617:                else
        !          1618:                        addfiledat(&f);
        !          1619: 
        !          1620:                if(f.misc&FM_EXTDESC)
        !          1621:                        putextdesc(f.dir,f.datoffset,ext);
        !          1622: 
        !          1623:                if(mode&UL_STATS)
        !          1624:                        updatestats(l);
        !          1625:                files++; } }
        !          1626: 
        !          1627: if(mode&AUTO_ADD) {
        !          1628:        for(i=0;i<total_dirs;i++) {
        !          1629:                if(dir[i]->misc&DIR_NOAUTO)
        !          1630:                        continue;
        !          1631:                f.dir=i;
        !          1632:                if(mode&SEARCH_DIR) {
        !          1633:                        addlist("",f,0,0);
        !          1634:                        continue; }
        !          1635:         sprintf(str,"%s.LST",dir[f.dir]->code);
        !          1636:         if(flength(str)>0L) {
        !          1637:                        printf("Auto-adding %s\n",str);
        !          1638:             addlist(str,f,0,0);
        !          1639:                        if(mode&SYNC_LIST)
        !          1640:                                synclist(str,i);
        !          1641:             continue; }
        !          1642:                sprintf(str,"%s%s",dir[f.dir]->path,auto_name);
        !          1643:                if(str[0]=='.') {
        !          1644:                        sprintf(tmp,"%s%s",node_dir,str);
        !          1645:                        strcpy(str,tmp); }
        !          1646:                if(flength(str)>0L) {
        !          1647:                        printf("Auto-adding %s\n",str);
        !          1648:                        addlist(str,f,0,0);
        !          1649:                        if(mode&SYNC_LIST)
        !          1650:                                synclist(str,i);
        !          1651:                        continue; } } }
        !          1652: 
        !          1653: else {
        !          1654:        if(!listgiven && !namegiven) {
        !          1655:                sprintf(str,"%s.LST",dir[f.dir]->code);
        !          1656:                if(flength(str)<=0L)
        !          1657:                        strcpy(str,"FILES.BBS");
        !          1658:                addlist(str,f,0,0);
        !          1659:                if(mode&SYNC_LIST)
        !          1660:                        synclist(str,f.dir); } }
        !          1661: 
        !          1662: printf("\n%lu file(s) added.",files);
        !          1663: if(removed)
        !          1664:        printf("\n%lu files(s) removed.",removed);
        !          1665: printf("\n");
        !          1666: return(0);
        !          1667: }
        !          1668: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.