![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to delfiles.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / delfiles|
Return to delfiles.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / delfiles |
1.1 root 1: #line 1 "DELFILES.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: #define DELFILES_VER "1.01"
8:
9: char tmp[256];
10:
11: #define MAX_NOTS 25
12:
13: #define ALL (1L<<0)
14: #define OFFLINE (1L<<1)
15: #define NO_LINK (1L<<2)
16: #define REPORT (1L<<3)
17:
18: void bail(int code)
19: {
20: exit(code);
21: }
22:
23: long lputs(char FAR16 *str)
24: {
25: char tmp[256];
26: int i,j,k;
27:
28: j=strlen(str);
29: for(i=k=0;i<j;i++) /* remove CRs */
30: if(str[i]==CR && str[i+1]==LF)
31: continue;
32: else
33: tmp[k++]=str[i];
34: tmp[k]=0;
35: return(fputs(tmp,stdout));
36: }
37:
38: /****************************************************************************/
39: /* Performs printf() through local assembly routines */
40: /* Called from everywhere */
41: /****************************************************************************/
42: int lprintf(char *fmat, ...)
43: {
44: va_list argptr;
45: char sbuf[256];
46: int chcount;
47:
48: va_start(argptr,fmat);
49: chcount=vsprintf(sbuf,fmat,argptr);
50: va_end(argptr);
51: lputs(sbuf);
52: return(chcount);
53: }
54:
55: /****************************************************************************/
56: /* Truncates white-space chars off end of 'str' and terminates at first tab */
57: /****************************************************************************/
58: void truncsp(char *str)
59: {
60: int c;
61:
62: str[strcspn(str,"\t")]=0;
63: c=strlen(str);
64: while(c && (uchar)str[c-1]<=SP) c--;
65: str[c]=0;
66: }
67:
68: /****************************************************************************/
69: /* Puts a backslash on path strings */
70: /****************************************************************************/
71: void backslash(char *str)
72: {
73: int i;
74:
75: i=strlen(str);
76: if(i && str[i-1]!='\\') {
77: str[i]='\\'; str[i+1]=0; }
78: }
79:
80: /****************************************************************************/
81: /* Network open function. Opens all files DENYALL and retries LOOP_NOPEN */
82: /* number of times if the attempted file is aREADy open or denying access */
83: /* for some other reason. All files are opened in BINARY mode. */
84: /****************************************************************************/
85: int nopen(char *str, int access)
86: {
87: char logstr[256];
88: int file,share,count=0;
89:
90: if(access==O_RDONLY) share=SH_DENYWR;
91: else share=SH_DENYRW;
92: while(((file=sopen(str,O_BINARY|access,share,S_IWRITE))==-1)
93: && errno==EACCES && count++<LOOP_NOPEN);
94: if(file==-1 && errno==EACCES)
95: lputs("\7\r\nNOPEN: ACCESS DENIED\r\n\7");
96: return(file);
97: }
98:
99: /****************************************************************************/
100: /* This function performs an nopen, but returns a file stream with a buffer */
101: /* allocated. */
102: /****************************************************************************/
103: FILE *fnopen(int *file, char *str, int access)
104: {
105: char mode[128];
106: FILE *stream;
107:
108: if(((*file)=nopen(str,access))==-1) {
109: printf("nopen -1\n");
110: return(NULL); }
111:
112: if(access&O_APPEND) {
113: if(access&O_RDONLY)
114: strcpy(mode,"a+");
115: else
116: strcpy(mode,"a"); }
117: else {
118: if(access&O_WRONLY)
119: strcpy(mode,"r+");
120: else
121: strcpy(mode,"r"); }
122: stream=fdopen((*file),mode);
123: if(stream==NULL) {
124: printf("fdopen NULL mode='%s'\n",mode);
125: close(*file);
126: return(NULL); }
127: setvbuf(stream,NULL,_IOFBF,16*1024);
128: return(stream);
129: }
130:
131: /****************************************************************************/
132: /* Checks the disk drive for the existence of a file. Returns 1 if it */
133: /* exists, 0 if it doesn't. */
134: /****************************************************************************/
135: char fexist(char *filespec)
136: {
137: struct find_t f;
138: uint i;
139:
140: i=_dos_findfirst(filespec,_A_NORMAL,&f);
141: #ifdef __WATCOMC__
142: _dos_findclose(&f);
143: #endif
144: if(!i)
145: return(1);
146: return(0);
147: }
148:
149: /****************************************************************************/
150: /* Returns the length of the file in 'filespec' */
151: /****************************************************************************/
152: long flength(char *filespec)
153: {
154: struct find_t f;
155: uint i;
156:
157: i=_dos_findfirst(filespec,_A_NORMAL,&f);
158: #ifdef __WATCOMC__
159: _dos_findclose(&f);
160: #endif
161: if(!i)
162: return(f.size);
163: return(-1L);
164: }
165:
166: #ifndef __FLAT__
167: /****************************************************************************/
168: /* This function reads files that are potentially larger than 32k. */
169: /* Up to one megabyte of data can be read with each call. */
170: /****************************************************************************/
171: long lread(int file, char HUGE16 *buf,long bytes)
172: {
173: long count;
174:
175: for(count=bytes;count>32767;count-=32767,buf+=32767)
176: if(read(file,(char *)buf,32767)!=32767)
177: return(-1L);
178: if(read(file,(char *)buf,(int)count)!=count)
179: return(-1L);
180: return(bytes);
181: }
182:
183: /****************************************************************************/
184: /* This function writes files that are potentially larger than 32767 bytes */
185: /* Up to one megabytes of data can be written with each call. */
186: /****************************************************************************/
187: long lwrite(int file, char HUGE16 *buf, long bytes)
188: {
189:
190: long count;
191:
192: for(count=bytes;count>32767;count-=32767,buf+=32767)
193: if(write(file,(char *)buf,32767)!=32767)
194: return(-1L);
195: if(write(file,(char *)buf,(int)count)!=count)
196: return(-1L);
197: return(bytes);
198: }
199: #endif
200:
201: /****************************************************************************/
202: /* Removes any files in the user transfer index (XFER.IXT) that match the */
203: /* specifications of dest, or source user, or filename or any combination. */
204: /****************************************************************************/
205: void rmuserxfers(int fromuser, int destuser, char *fname)
206: {
207: char str[256],*ixtbuf;
208: int file;
209: long l,length;
210:
211: sprintf(str,"%sXFER.IXT",data_dir);
212: if(!fexist(str))
213: return;
214: if(!flength(str)) {
215: remove(str);
216: return; }
217: if((file=nopen(str,O_RDONLY))==-1) {
218: printf("ERROR opening %s\r\n",str);
219: return; }
220: length=filelength(file);
221: if((ixtbuf=(char *)MALLOC(length))==NULL) {
222: close(file);
223: printf("ERROR allocating %lu bytes for %s\r\n",length,str);
224: return; }
225: if(read(file,ixtbuf,length)!=length) {
226: close(file);
227: FREE(ixtbuf);
228: printf("ERROR reading %lu bytes from %s\r\n",length,str);
229: return; }
230: close(file);
231: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
232: FREE(ixtbuf);
233: printf("ERROR opening %s\r\n",str);
234: return; }
235: for(l=0;l<length;l+=24) {
236: if(fname!=NULL && fname[0]) { /* fname specified */
237: if(!strncmp(ixtbuf+l+5,fname,12)) { /* this is the file */
238: if(destuser && fromuser) { /* both dest and from user */
239: if(atoi(ixtbuf+l)==destuser && atoi(ixtbuf+l+18)==fromuser)
240: continue; } /* both match */
241: else if(fromuser) { /* from user */
242: if(atoi(ixtbuf+l+18)==fromuser) /* matches */
243: continue; }
244: else if(destuser) { /* dest user */
245: if(atoi(ixtbuf+l)==destuser) /* matches */
246: continue; }
247: else continue; } } /* no users, so match */
248: else if(destuser && fromuser) {
249: if(atoi(ixtbuf+l+18)==fromuser && atoi(ixtbuf+l)==destuser)
250: continue; }
251: else if(destuser && atoi(ixtbuf+l)==destuser)
252: continue;
253: else if(fromuser && atoi(ixtbuf+l+18)==fromuser)
254: continue;
255: write(file,ixtbuf+l,24); }
256: close(file);
257: FREE(ixtbuf);
258: }
259:
260: /****************************************************************************/
261: /* Removes DAT and IXB entries for the file in the struct 'f' */
262: /****************************************************************************/
263: void removefiledat(file_t f)
264: {
265: char c,str[256],ixbname[12],HUGE16 *ixbbuf,fname[13];
266: int file;
267: ulong l,length;
268:
269: strcpy(fname,f.name);
270: for(c=8;c<12;c++) /* Turn FILENAME.EXT into FILENAMEEXT */
271: fname[c]=fname[c+1];
272: sprintf(str,"%s%s.IXB",dir[f.dir]->data_dir,dir[f.dir]->code);
273: if((file=nopen(str,O_RDONLY))==-1) {
274: printf("ERROR opening %s\r\n",str);
275: return; }
276: length=filelength(file);
277: if(!length) {
278: close(file);
279: return; }
280: if((ixbbuf=(char *)MALLOC(length))==0) {
281: close(file);
282: printf("ERROR allocating %lu bytes for %s\r\n",length,str);
283: return; }
284: if(lread(file,ixbbuf,length)!=length) {
285: close(file);
286: printf("ERROR reading %lu bytes from %s\r\n",length,str);
287: FREE((char *)ixbbuf);
288: return; }
289: close(file);
290: if((file=nopen(str,O_WRONLY|O_TRUNC))==-1) {
291: printf("ERROR opening %s\r\n",str);
292: return; }
293: for(l=0;l<length;l+=F_IXBSIZE) {
294: for(c=0;c<11;c++)
295: ixbname[c]=ixbbuf[l+c];
296: ixbname[c]=0;
297: if(strcmp(ixbname,fname))
298: if(lwrite(file,&ixbbuf[l],F_IXBSIZE)!=F_IXBSIZE) {
299: close(file);
300: printf("ERROR writing %lu bytes to %s\r\n",F_IXBSIZE,str);
301: FREE((char *)ixbbuf);
302: return; } }
303: FREE((char *)ixbbuf);
304: close(file);
305: sprintf(str,"%s%s.DAT",dir[f.dir]->data_dir,dir[f.dir]->code);
306: if((file=nopen(str,O_WRONLY))==-1) {
307: printf("ERROR opening %s\r\n",str);
308: return; }
309: lseek(file,f.datoffset,SEEK_SET);
310: c=ETX; /* If first char of record is ETX, record is unused */
311: if(write(file,&c,1)!=1) { /* So write a D_T on the first byte of the record */
312: close(file);
313: printf("ERROR writing to %s\r\n",str);
314: return; }
315: close(file);
316: if(f.dir==user_dir) /* remove file from index */
317: rmuserxfers(0,0,f.name);
318: }
319:
320: /****************************************************************************/
321: /* Places into 'strout' CR or ETX terminated string starting at */
322: /* 'start' and ending at 'start'+'length' or terminator from 'strin' */
323: /****************************************************************************/
324: void getrec(char *strin,int start,int length,char *strout)
325: {
326: int i=0,stop;
327:
328: stop=start+length;
329: while(start<stop) {
330: if(strin[start]==ETX)
331: break;
332: strout[i++]=strin[start++]; }
333: strout[i]=0;
334: }
335:
336: /****************************************************************************/
337: /* Turns FILE .EXT into FILE.EXT */
338: /****************************************************************************/
339: char *unpadfname(char *filename, char *str)
340: {
341: char c,d;
342:
343: for(c=0,d=0;c<strlen(filename);c++)
344: if(filename[c]!=SP) str[d++]=filename[c];
345: str[d]=0;
346: return(str);
347: }
348:
349: /****************************************************************************/
350: /* Returns the time/date of the file in 'filespec' in time_t (unix) format */
351: /****************************************************************************/
352: long fdate(char *filespec)
353: {
354: int file;
355: #ifdef __WATCOMC__
356: unsigned short ft,fd;
357: #else
358: unsigned ft,fd;
359: #endif
360: struct tm t;
361:
362: if((file=nopen(filespec,O_RDONLY))==-1)
363: return(0);
364: _dos_getftime(file,&fd,&ft);
365: close(file);
366: memset(&t,0,sizeof(t));
367: t.tm_year=((fd&0xfe00)>>9)+80;
368: t.tm_mon=((fd&0x01e0)>>5)-1;
369: t.tm_mday=fd&0x1f;
370: t.tm_hour=(ft&0xf800)>>11;
371: t.tm_min=(ft&0x07e0)>>5;
372: t.tm_sec=(ft&0x001f)<<1;
373: return(mktime(&t));
374: }
375:
376: /****************************************************************************/
377: /* Converts an ASCII Hex string into an ulong */
378: /****************************************************************************/
379: ulong ahtoul(char *str)
380: {
381: ulong l,val=0;
382:
383: while((l=(*str++)|0x20)!=0x20)
384: val=(l&0xf)+(l>>6&1)*9+val*16;
385: return(val);
386: }
387:
388: uint hptoi(char *str)
389: {
390: char tmp[128];
391: uint i;
392:
393: if(!str[1] || toupper(str[0])<='F')
394: return(ahtoul(str));
395: strcpy(tmp,str);
396: tmp[0]='F';
397: i=ahtoul(tmp)+((toupper(str[0])-'F')*0x10);
398: return(i);
399: }
400:
401: /****************************************************************************/
402: /* Gets filedata from dircode.DAT file */
403: /* Need fields .name ,.dir and .offset to get other info */
404: /* Does not fill .dateuled or .datedled fields. */
405: /****************************************************************************/
406: void getfiledat(file_t *f)
407: {
408: char buf[F_LEN+1],str[256],tmp[256];
409: int file;
410: long length;
411:
412: sprintf(str,"%s%s.DAT",dir[f->dir]->data_dir,dir[f->dir]->code);
413: if((file=nopen(str,O_RDONLY))==-1) {
414: printf("ERROR opening %s\r\n",str);
415: return; }
416: length=filelength(file);
417: if(f->datoffset>length) {
418: close(file);
419: printf("ERROR %s filelength %ld is less than offset\r\n",str,length);
420: return; }
421: if(length%F_LEN) {
422: close(file);
423: printf("ERROR %s filelength %ld is not evenly divisible\r\n",str,length);
424: return; }
425: lseek(file,f->datoffset,SEEK_SET);
426: if(read(file,buf,F_LEN)!=F_LEN) {
427: close(file);
428: printf("ERROR reading %ld bytes from %s\r\n",F_LEN,str);
429: return; }
430: close(file);
431: getrec(buf,F_ALTPATH,2,str);
432: f->altpath=hptoi(str);
433: getrec(buf,F_CDT,7,str);
434: f->cdt=atol(str);
435:
436: if(!f->size) { /* only read disk if this is null */
437: if(dir[f->dir]->misc&DIR_FCHK) {
438: sprintf(str,"%s%s"
439: ,f->altpath>0 && f->altpath<=altpaths ? altpath[f->altpath-1]
440: : dir[f->dir]->path,unpadfname(f->name,tmp));
441: f->size=flength(str);
442: f->date=fdate(str); }
443: else {
444: f->size=f->cdt;
445: f->date=0; } }
446: //if((f->size>0L) && cur_cps)
447: // f->timetodl=(f->size/(ulong)cur_cps);
448: //else
449: f->timetodl=0;
450:
451: getrec(buf,F_DESC,LEN_FDESC,f->desc);
452: getrec(buf,F_ULER,LEN_ALIAS,f->uler);
453: getrec(buf,F_TIMESDLED,5,str);
454: f->timesdled=atoi(str);
455: getrec(buf,F_OPENCOUNT,3,str);
456: f->opencount=atoi(str);
457: if(buf[F_MISC]!=ETX)
458: f->misc=buf[F_MISC]-SP;
459: else
460: f->misc=0;
461: }
462:
463: /****************************************************************************/
464: /* Checks directory data file for 'filename' (must be padded). If found, */
465: /* it returns the 1, else returns 0. */
466: /* Called from upload and bulkupload */
467: /****************************************************************************/
468: char findfile(uint dirnum, char *filename)
469: {
470: char str[256],c,fname[128],HUGE16 *ixbbuf;
471: int file;
472: ulong length,l;
473:
474: strcpy(fname,filename);
475: for(c=8;c<12;c++) /* Turn FILENAME.EXT into FILENAMEEXT */
476: fname[c]=fname[c+1];
477: sprintf(str,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
478: if((file=nopen(str,O_RDONLY))==-1) return(0);
479: length=filelength(file);
480: if(!length) {
481: close(file);
482: return(0); }
483: if((ixbbuf=(char *)MALLOC(length))==NULL) {
484: close(file);
485: printf("ERR_ALLOC %s %lu\n",str,length);
486: return(0); }
487: if(lread(file,ixbbuf,length)!=length) {
488: close(file);
489: FREE((char *)ixbbuf);
490: return(0); }
491: close(file);
492: for(l=0;l<length;l+=F_IXBSIZE) {
493: for(c=0;c<11;c++)
494: if(fname[c]!=ixbbuf[l+c]) break;
495: if(c==11) break; }
496: FREE((char *)ixbbuf);
497: if(l<length)
498: return(1);
499: return(0);
500: }
501:
502: /****************************************************************************/
503: /* Turns FILE.EXT into FILE .EXT */
504: /* Called from upload */
505: /****************************************************************************/
506: char *padfname(char *filename, char *str)
507: {
508: char c,d;
509:
510: for(c=0;c<8;c++)
511: if(filename[c]=='.' || !filename[c]) break;
512: else str[c]=filename[c];
513: d=c;
514: if(filename[c]=='.') c++;
515: while(d<8)
516: str[d++]=SP;
517: str[d++]='.';
518: while(d<12)
519: if(!filename[c]) break;
520: else str[d++]=filename[c++];
521: while(d<12)
522: str[d++]=SP;
523: str[d]=0;
524: return(str);
525: }
526:
527: void main(int argc, char **argv)
528: {
529: char str[256],fname[256],not[MAX_NOTS][9],nots=0,*p;
530: uchar HUGE16 *ixbbuf;
531: int i,j,dirnum,libnum,file;
532: ulong l,m,n,length;
533: long misc=0;
534: time_t now;
535: read_cfg_text_t txt;
536: file_t workfile;
537: struct find_t ff;
538:
539: putenv("TZ=UCT0");
540: _fmode=O_BINARY;
541: setvbuf(stdout,NULL,_IONBF,0);
542:
543: fprintf(stderr,"\nDELFILES Version %s (%s) - Removes files from Synchronet "
544: "Filebase\n"
545: ,DELFILES_VER
546: #if defined(__OS2__)
547: ,"OS/2"
548: #elif defined(__NT__)
549: ,"Win32"
550: #elif defined(__DOS4G__)
551: ,"DOS4G"
552: #elif defined(__FLAT__)
553: ,"DOS32"
554: #else
555: ,"DOS16"
556: #endif
557: );
558:
559: if(argc<2) {
560: printf("\n usage: DELFILES <dir_code or * for ALL> [switches]\n");
561: printf("\nswitches: /LIB name All directories of specified library\n");
562: printf(" /NOT code Exclude specific directory\n");
563: printf(" /OFF Remove files that are offline "
564: "(don't exist on disk)\n");
565: printf(" /NOL Remove files with no link "
566: "(don't exist in database)\n");
567: printf(" /RPT Report findings only "
568: "(don't delete any files)\n");
569: exit(0); }
570:
571: p=getenv("SBBSNODE");
572: if(p==NULL) {
573: printf("\nSBBSNODE environment variable not set.\n");
574: printf("\nExample: SET SBBSNODE=C:\\SBBS\\NODE1\n");
575: exit(1); }
576:
577: putenv("TZ=UCT0");
578:
579: strcpy(node_dir,p);
580: if(node_dir[strlen(node_dir)-1]!='\\')
581: strcat(node_dir,"\\");
582:
583: txt.openerr="\7\nError opening %s for read.\n";
584: txt.reading="\nReading %s...";
585: txt.readit="\rRead %s ";
586: txt.allocerr="\7\nError allocating %u bytes of memory\n";
587: txt.error="\7\nERROR: Offset %lu in %s\r\n\n";
588:
589: read_node_cfg(txt);
590: if(ctrl_dir[0]=='.') { /* Relative path */
591: strcpy(str,ctrl_dir);
592: sprintf(ctrl_dir,"%s%s",node_dir,str); }
593: read_main_cfg(txt);
594: if(data_dir[0]=='.') { /* Relative path */
595: strcpy(str,data_dir);
596: sprintf(data_dir,"%s%s",node_dir,str); }
597: if(temp_dir[1]!=':' && temp_dir[0]!='\\') {
598: strcpy(str,temp_dir);
599: sprintf(temp_dir,"%s%s",node_dir,str); }
600: read_file_cfg(txt);
601: printf("\n\n");
602:
603: dirnum=libnum=-1;
604: if(argv[1][0]=='*')
605: misc|=ALL;
606: else if(argv[1][0]!='/') {
607: strupr(argv[1]);
608: for(i=0;i<total_dirs;i++)
609: if(!stricmp(argv[1],dir[i]->code))
610: break;
611: if(i>=total_dirs) {
612: printf("\nDirectory code '%s' not found.\n",argv[1]);
613: exit(1); }
614: dirnum=i; }
615: for(i=1;i<argc;i++) {
616: if(!stricmp(argv[i],"/LIB")) {
617: if(dirnum!=-1) {
618: printf("\nBoth directory code and /LIB parameters were used.\n");
619: exit(1); }
620: i++;
621: if(i>=argc) {
622: printf("\nLibrary short name must follow /LIB parameter.\n");
623: exit(1); }
624: strupr(argv[i]);
625: for(j=0;j<total_libs;j++)
626: if(!stricmp(lib[j]->sname,argv[i]))
627: break;
628: if(j>=total_libs) {
629: printf("\nLibrary short name '%s' not found.\n",argv[i]);
630: exit(1); }
631: libnum=j; }
632: else if(!stricmp(argv[i],"/NOT")) {
633: if(nots>=MAX_NOTS) {
634: printf("\nMaximum number of /NOT options (%u) exceeded.\n"
635: ,MAX_NOTS);
636: exit(1); }
637: i++;
638: if(i>=argc) {
639: printf("\nDirectory internal code must follow /NOT parameter.\n");
640: exit(1); }
641: sprintf(not[nots++],"%.8s",argv[i]); }
642: else if(!stricmp(argv[i],"/OFF"))
643: misc|=OFFLINE;
644: else if(!stricmp(argv[i],"/NOL"))
645: misc|=NO_LINK;
646: else if(!stricmp(argv[i],"/RPT"))
647: misc|=REPORT;
648: else if(!stricmp(argv[i],"/ALL")) {
649: if(dirnum!=-1) {
650: printf("\nBoth directory code and /ALL parameters were used.\n");
651: exit(1); }
652: if(libnum!=-1) {
653: printf("\nBoth library name and /ALL parameters were used.\n");
654: exit(1); }
655: misc|=ALL; } }
656:
657: for(i=0;i<total_dirs;i++) {
658: if(!(misc&ALL) && i!=dirnum && dir[i]->lib!=libnum)
659: continue;
660: for(j=0;j<nots;j++)
661: if(!stricmp(not[j],dir[i]->code))
662: break;
663: if(j<nots)
664: continue;
665:
666: if(misc&NO_LINK && dir[i]->misc&DIR_FCHK) {
667: strcpy(tmp,dir[i]->path);
668: if(tmp[0]=='.') {
669: sprintf(str,"%s%s",node_dir,tmp);
670: strcpy(tmp,str); }
671: sprintf(str,"%s*.*",tmp);
672: printf("\nSearching %s for unlinked files\n",str);
673: for(j=_dos_findfirst(str,_A_NORMAL,&ff);!j
674: ;j=_dos_findnext(&ff)) {
675: strupr(ff.name);
676: padfname(ff.name,str);
677: if(!findfile(i,str)) {
678: sprintf(str,"%s%s",tmp,ff.name);
679: printf("Removing %s (not in database)\n",ff.name);
680: if(!(misc&REPORT) && remove(str))
681: printf("Error removing %s\n",str); } }
682: #ifdef __WATCOMC__
683: _dos_findclose(&ff);
684: #endif
685: }
686:
687: if(!dir[i]->maxage && !(misc&OFFLINE))
688: continue;
689:
690: printf("\nScanning %s %s\n",lib[dir[i]->lib]->sname,dir[i]->lname);
691:
692: sprintf(str,"%s%s.IXB",dir[i]->data_dir,dir[i]->code);
693: if((file=nopen(str,O_RDONLY))==-1)
694: continue;
695: l=filelength(file);
696: if(!l) {
697: close(file);
698: continue; }
699: if((ixbbuf=(char *)MALLOC(l))==NULL) {
700: close(file);
701: printf("\7ERR_ALLOC %s %lu\n",str,l);
702: continue; }
703: if(read(file,ixbbuf,l)!=l) {
704: close(file);
705: printf("\7ERR_READ %s %lu\n",str,l);
706: FREE((char *)ixbbuf);
707: continue; }
708: close(file);
709:
710: m=0L;
711: now=time(NULL);
712: while(m<l) {
713: memset(&workfile,0,sizeof(file_t));
714: for(j=0;j<12 && m<l;j++)
715: if(j==8)
716: fname[j]='.';
717: else
718: fname[j]=ixbbuf[m++];
719: fname[j]=0;
720: strcpy(workfile.name,fname);
721: unpadfname(workfile.name,fname);
722: workfile.dir=i;
723: sprintf(str,"%s%s"
724: ,workfile.altpath>0 && workfile.altpath<=altpaths
725: ? altpath[workfile.altpath-1]
726: : dir[workfile.dir]->path,fname);
727: if(str[0]=='.') {
728: sprintf(tmp,"%s%s",node_dir,str);
729: strcpy(str,tmp); }
730: workfile.datoffset=ixbbuf[m]|((long)ixbbuf[m+1]<<8)
731: |((long)ixbbuf[m+2]<<16);
732: workfile.dateuled=(ixbbuf[m+3]|((long)ixbbuf[m+4]<<8)
733: |((long)ixbbuf[m+5]<<16)|((long)ixbbuf[m+6]<<24));
734: workfile.datedled=(ixbbuf[m+7]|((long)ixbbuf[m+8]<<8)
735: |((long)ixbbuf[m+9]<<16)|((long)ixbbuf[m+10]<<24));
736: m+=11;
737: if(dir[i]->maxage && dir[i]->misc&DIR_SINCEDL && workfile.datedled
738: && (now-workfile.datedled)/86400L>dir[i]->maxage) {
739: printf("Deleting %s (%ld days since last download)\n",fname
740: ,(now-workfile.datedled)/86400L);
741: getfiledat(&workfile);
742: if(!(misc&REPORT)) {
743: removefiledat(workfile);
744: if(remove(str))
745: printf("Error removing %s\n",str); } }
746: else if(dir[i]->maxage
747: && !(workfile.datedled && dir[i]->misc&DIR_SINCEDL)
748: && (now-workfile.dateuled)/86400L>dir[i]->maxage) {
749: printf("Deleting %s (uploaded %ld days ago)\n",fname
750: ,(now-workfile.dateuled)/86400L);
751: getfiledat(&workfile);
752: if(!(misc&REPORT)) {
753: removefiledat(workfile);
754: if(remove(str))
755: printf("Error removing %s\n",str); } }
756: else if(misc&OFFLINE && dir[i]->misc&DIR_FCHK && !fexist(str)) {
757: printf("Removing %s (doesn't exist)\n",fname);
758: getfiledat(&workfile);
759: if(!(misc&REPORT))
760: removefiledat(workfile); } }
761:
762: FREE((char *)ixbbuf); }
763: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.