![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to addfiles.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / addfiles|
Return to addfiles.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / addfiles |
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.