![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xfer_hi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to xfer_hi.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "XFER_HI.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: uint temp_dirnum;
8:
9: /****************************************************************************/
10: /* Uploads files */
11: /****************************************************************************/
12: void upload(uint dirnum)
13: {
14: static char lastdesc[59];
15: uchar str[256],src[256]={""},descbeg[25]={""},descend[25]={""},path[256]
16: ,fname[13],keys[256],ch,*p;
17: time_t start,end;
18: int i,j,file,destuser[MAX_USERXFER],destusers=0;
19: uint k;
20: file_t f;
21: struct dfree d;
22: user_t user;
23: node_t node;
24:
25: if(sys_status&SS_EVENT && online==ON_REMOTE && !dir_op(dirnum))
26: bprintf(text[UploadBeforeEvent],timeleft/60);
27: if(altul)
28: strcpy(path,altpath[altul-1]);
29: else
30: strcpy(path,dir[dirnum]->path);
31: if(path[1]==':')
32: i=path[0]-'A'+1;
33: else i=0;
34: getdfree(i,&d);
35: if(d.df_sclus==0xffff)
36: errormsg(WHERE,ERR_CHK,path,0);
37: if((ulong)d.df_bsec*(ulong)d.df_sclus
38: *(ulong)d.df_avail<(ulong)min_dspace*1024L) {
39: bputs(text[LowDiskSpace]);
40: sprintf(str,"Diskspace is low: %s",path);
41: errorlog(str);
42: if(!dir_op(dirnum))
43: return; }
44: bprintf(text[DiskNBytesFree],ultoac((ulong)d.df_bsec
45: *(ulong)d.df_sclus*(ulong)d.df_avail,tmp));
46: f.dir=curdirnum=dirnum;
47: f.misc=0;
48: f.altpath=altul;
49: bputs(text[Filename]);
50: if(!getstr(fname,12,K_UPPER) || strchr(fname,'?') || strchr(fname,'*')
51: || !checkfname(fname) || (trashcan(fname,"FILE") && !dir_op(dirnum))) {
52: if(fname[0])
53: bputs(text[BadFilename]);
54: return; }
55: if(dirnum==sysop_dir)
56: sprintf(str,text[UploadToSysopDirQ],fname);
57: else if(dirnum==user_dir)
58: sprintf(str,text[UploadToUserDirQ],fname);
59: else
60: sprintf(str,text[UploadToCurDirQ],fname,lib[dir[dirnum]->lib]->sname
61: ,dir[dirnum]->sname);
62: if(!yesno(str)) return;
63: action=NODE_ULNG;
64: padfname(fname,f.name);
65: sprintf(str,"%s%s",path,fname);
66: if(fexist(str)) { /* File is on disk */
67: if(!dir_op(dirnum) && online!=ON_LOCAL) { /* local users or sysops */
68: bprintf(text[FileAlreadyThere],fname);
69: return; }
70: if(!yesno(text[FileOnDiskAddQ]))
71: return; }
72: else if(online==ON_LOCAL) {
73: bputs(text[FileNotOnDisk]);
74: bputs(text[EnterPath]);
75: if(!getstr(tmp,60,K_LINE|K_UPPER))
76: return;
77: backslash(tmp);
78: sprintf(src,"%s%s",tmp,fname); }
79: strcpy(str,dir[dirnum]->exts);
80: strcpy(tmp,f.name);
81: truncsp(tmp);
82: j=strlen(str);
83: for(i=0;i<j;i+=ch+1) { /* Check extension of upload with allowable exts */
84: p=strchr(str+i,',');
85: if(p!=NULL)
86: *p=0;
87: ch=strlen(str+i);
88: if(!strcmp(tmp+9,str+i))
89: break; }
90: if(j && i>=j) {
91: bputs(text[TheseFileExtsOnly]);
92: bputs(dir[dirnum]->exts);
93: CRLF;
94: if(!dir_op(dirnum)) return; }
95: bputs(text[SearchingForDupes]);
96: for(i=k=0;i<usrlibs;i++)
97: for(j=0;j<usrdirs[i];j++,k++) {
98: outchar('.');
99: if(k && !(k%5))
100: bputs("\b\b\b\b\b \b\b\b\b\b");
101: if((usrdir[i][j]==dirnum || dir[usrdir[i][j]]->misc&DIR_DUPES)
102: && findfile(usrdir[i][j],f.name)) {
103: bputs(text[SearchedForDupes]);
104: bprintf(text[FileAlreadyOnline],f.name);
105: if(!dir_op(dirnum))
106: return; /* File is in database for another dir */
107: if(usrdir[i][j]==dirnum)
108: return; } } /* don't allow duplicates */
109: bputs(text[SearchedForDupes]);
110: if(dirnum==user_dir) { /* User to User transfer */
111: bputs(text[EnterAfterLastDestUser]);
112: while((!dir_op(dirnum) && destusers<max_userxfer) || destusers<MAX_USERXFER) {
113: bputs(text[SendFileToUser]);
114: if(!getstr(str,LEN_ALIAS,K_UPRLWR))
115: break;
116: if((user.number=finduser(str))!=0) {
117: if(!dir_op(dirnum) && user.number==useron.number) {
118: bputs(text[CantSendYourselfFiles]);
119: continue; }
120: for(i=0;i<destusers;i++)
121: if(user.number==destuser[i])
122: break;
123: if(i<destusers) {
124: bputs(text[DuplicateUser]);
125: continue; }
126: getuserdat(&user);
127: if((user.rest&(FLAG('T')|FLAG('D')))
128: || !chk_ar(lib[dir[user_dir]->lib]->ar,user)
129: || !chk_ar(dir[user_dir]->dl_ar,user)) {
130: bprintf(text[UserWontBeAbleToDl],user.alias); }
131: else {
132: bprintf(text[UserAddedToDestList],user.alias);
133: destuser[destusers++]=user.number; } }
134: else {
135: CRLF; } }
136: if(!destusers)
137: return; }
138: if(dir[dirnum]->misc&DIR_RATE) {
139: SYNC;
140: bputs(text[RateThisFile]);
141: ch=getkey(K_ALPHA);
142: if(!isalpha(ch) || sys_status&SS_ABORT)
143: return;
144: CRLF;
145: sprintf(descbeg,text[Rated],toupper(ch)); }
146: if(dir[dirnum]->misc&DIR_ULDATE) {
147: now=time(NULL);
148: if(descbeg[0])
149: strcat(descbeg," ");
150: sprintf(str,"%s ",unixtodstr(now,tmp));
151: strcat(descbeg,str); }
152: if(dir[dirnum]->misc&DIR_MULT) {
153: SYNC;
154: if(!noyes(text[MultipleDiskQ])) {
155: bputs(text[HowManyDisksTotal]);
156: if((i=getnum(99))<2)
157: return;
158: bputs(text[NumberOfFile]);
159: if((j=getnum(i))<1)
160: return;
161: if(j==1)
162: lastdesc[0]=0;
163: if(i>9)
164: sprintf(descend,text[FileOneOfTen],j,i);
165: else
166: sprintf(descend,text[FileOneOfTwo],j,i); }
167: else
168: lastdesc[0]=0; }
169: else
170: lastdesc[0]=0;
171: bputs(text[EnterDescNow]);
172: i=LEN_FDESC-(strlen(descbeg)+strlen(descend));
173: getstr(lastdesc,i,K_LINE|K_EDIT|K_AUTODEL);
174: if(sys_status&SS_ABORT)
175: return;
176: if(descend[0]) /* end of desc specified, so pad desc with spaces */
177: sprintf(f.desc,"%s%-*s%s",descbeg,i,lastdesc,descend);
178: else /* no end specified, so string ends at desc end */
179: sprintf(f.desc,"%s%s",descbeg,lastdesc);
180:
181: if(dir[dirnum]->misc&DIR_ANON && !(dir[dirnum]->misc&DIR_AONLY)
182: && (dir_op(dirnum) || useron.exempt&FLAG('A'))) {
183: if(!noyes(text[AnonymousQ]))
184: f.misc|=FM_ANON; }
185: sprintf(str,"%s%s",path,fname);
186: if(src[0]) { /* being copied from another local dir */
187: bprintf(text[RetrievingFile],fname);
188: if(mv(src,str,1))
189: return;
190: CRLF; }
191: if(fexist(str)) { /* File is on disk */
192: if(!uploadfile(&f))
193: return; }
194: else {
195: menu("ULPROT");
196: SYNC;
197: strcpy(keys,"Q");
198: if(dirnum==user_dir || !max_batup) /* no batch user to user xfers */
199: mnemonics(text[ProtocolOrQuit]);
200: else {
201: mnemonics(text[ProtocolBatchOrQuit]);
202: strcat(keys,"B"); }
203: for(i=0;i<total_prots;i++)
204: if(prot[i]->ulcmd[0] && chk_ar(prot[i]->ar,useron)) {
205: sprintf(tmp,"%c",prot[i]->mnemonic);
206: strcat(keys,tmp); }
207: ch=getkeys(keys,0);
208: if(ch=='Q')
209: return;
210: if(ch=='B') {
211: if(batup_total>=max_batup)
212: bputs(text[BatchUlQueueIsFull]);
213: else {
214: for(i=0;i<batup_total;i++)
215: if(!strcmp(batup_name[i],f.name)) {
216: bprintf(text[FileAlreadyInQueue],f.name);
217: return; }
218: strcpy(batup_name[batup_total],f.name);
219: strcpy(batup_desc[batup_total],f.desc);
220: batup_dir[batup_total]=dirnum;
221: batup_misc[batup_total]=f.misc;
222: batup_alt[batup_total]=altul;
223: batup_total++;
224: bprintf(text[FileAddedToUlQueue]
225: ,f.name,batup_total,max_batup); } }
226: else {
227: for(i=0;i<total_prots;i++)
228: if(prot[i]->ulcmd[0] && prot[i]->mnemonic==ch
229: && chk_ar(prot[i]->ar,useron))
230: break;
231: if(i<total_prots) {
232: start=time(NULL);
233: protocol(cmdstr(prot[i]->ulcmd,str,nulstr,NULL),0);
234: end=time(NULL);
235: if(!(dir[dirnum]->misc&DIR_ULTIME)) /* Don't deduct upload time */
236: starttime+=end-start;
237: ch=uploadfile(&f);
238: autohangup();
239: if(!ch) /* upload failed, don't process user to user xfer */
240: return; } } }
241: if(dirnum==user_dir) { /* Add files to XFER.IXT in INDX dir */
242: sprintf(str,"%sXFER.IXT",data_dir);
243: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
244: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_APPEND);
245: return; }
246: for(j=0;j<destusers;j++) {
247: for(i=1;i<=sys_nodes;i++) { /* Tell user, if online */
248: getnodedat(i,&node,0);
249: if(node.useron==destuser[j] && !(node.misc&NODE_POFF)
250: && (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
251: sprintf(str,text[UserToUserXferNodeMsg],node_num,useron.alias);
252: putnmsg(i,str);
253: break; } }
254: if(i>sys_nodes) { /* User not online */
255: sprintf(str,text[UserSentYouFile],useron.alias);
256: putsmsg(destuser[j],str); }
257: sprintf(str,"%4.4u %12.12s %4.4u\r\n"
258: ,destuser[j],f.name,useron.number);
259: write(file,str,strlen(str)); }
260: close(file); }
261: }
262:
263: /****************************************************************************/
264: /* Checks directory for 'dir' and prompts user to enter description for */
265: /* the files that aren't in the database. */
266: /* Returns 1 if the user aborted, 0 if not. */
267: /****************************************************************************/
268: char bulkupload(uint dirnum)
269: {
270: char done,str[256];
271: struct ffblk ff;
272: file_t f;
273:
274: memset(&f,0,sizeof(file_t));
275: f.dir=dirnum;
276: f.altpath=altul;
277: bprintf(text[BulkUpload],lib[dir[dirnum]->lib]->sname,dir[dirnum]->sname);
278: sprintf(str,"%s*.*",altul>0 && altul<=altpaths ? altpath[altul-1]
279: : dir[dirnum]->path);
280: done=findfirst(str,&ff,0);
281: action=NODE_ULNG;
282: SYNC;
283: while(!done && !msgabort()) {
284: if(gettotalfiles(dirnum)>dir[dirnum]->maxfiles) {
285: bputs(text[DirFull]);
286: return(0); }
287: strupr(ff.ff_name);
288: padfname(ff.ff_name,str);
289: if(findfile(f.dir,str)==0) {
290: strcpy(f.name,str);
291: f.cdt=ff.ff_fsize;
292: bprintf(text[BulkUploadDescPrompt],f.name,f.cdt);
293: getstr(f.desc,LEN_FDESC,K_LINE);
294: if(sys_status&SS_ABORT)
295: return(1);
296: uploadfile(&f); } /* used to abort here if the file failed upload */
297: done=findnext(&ff); }
298: return(0);
299: }
300:
301:
302:
303: /****************************************************************************/
304: /* This is the batch menu section */
305: /****************************************************************************/
306: void batchmenu()
307: {
308: char str[129],tmp2[250],done=0,ch;
309: uint i,j,xfrprot,xfrdir;
310: ulong totalcdt,totalsize,totaltime;
311: time_t start,end;
312: int file,n;
313: file_t f;
314:
315: if(!batdn_total && !batup_total && upload_dir==INVALID_DIR) {
316: bputs(text[NoFilesInBatchQueue]);
317: return; }
318: if(useron.misc&(RIP|WIP) && !(useron.misc&EXPERT))
319: menu("BATCHXFR");
320: lncntr=0;
321: while(online && !done && (batdn_total || batup_total
322: || upload_dir!=INVALID_DIR)) {
323: if(!(useron.misc&(EXPERT|RIP|WIP))) {
324: sys_status&=~SS_ABORT;
325: if(lncntr) {
326: SYNC;
327: CRLF;
328: if(lncntr) /* CRLF or SYNC can cause pause */
329: pause(); }
330: menu("BATCHXFR"); }
331: ASYNC;
332: bputs(text[BatchMenuPrompt]);
333: ch=getkeys("BCDLQRU?\r",0);
334: if(ch>SP)
335: logch(ch,0);
336: switch(ch) {
337: case '?':
338: if(useron.misc&(EXPERT|RIP|WIP))
339: menu("BATCHXFR");
340: break;
341: case CR:
342: case 'Q':
343: lncntr=0;
344: done=1;
345: break;
346: case 'B': /* Bi-directional transfers */
347: if(useron.rest&FLAG('D')) {
348: bputs(text[R_Download]);
349: break; }
350: if(useron.rest&FLAG('U')) {
351: bputs(text[R_Upload]);
352: break; }
353: if(!batdn_total) {
354: bputs(text[DownloadQueueIsEmpty]);
355: break; }
356: if(!batup_total && upload_dir==INVALID_DIR) {
357: bputs(text[UploadQueueIsEmpty]);
358: break; }
359: for(i=0,totalcdt=0;i<batdn_total;i++)
360: totalcdt+=batdn_cdt[i];
361: if(!(useron.exempt&FLAG('D'))
362: && totalcdt>useron.cdt+useron.freecdt) {
363: bprintf(text[YouOnlyHaveNCredits]
364: ,ultoac(useron.cdt+useron.freecdt,tmp));
365: break; }
366: for(i=0,totalsize=totaltime=0;i<batdn_total;i++) {
367: totalsize+=batdn_size[i];
368: if(!(dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
369: totaltime+=batdn_size[i]/(ulong)cur_cps; }
370: if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft) {
371: bputs(text[NotEnoughTimeToDl]);
372: break; }
373: menu("BIPROT");
374: if(!create_batchdn_lst())
375: break;
376: if(!create_batchup_lst())
377: break;
378: if(!create_bimodem_pth())
379: break;
380: SYNC;
381: mnemonics(text[ProtocolOrQuit]);
382: strcpy(tmp2,"Q");
383: for(i=0;i<total_prots;i++)
384: if(prot[i]->bicmd[0] && chk_ar(prot[i]->ar,useron)) {
385: sprintf(tmp,"%c",prot[i]->mnemonic);
386: strcat(tmp2,tmp); }
387: ungetkey(useron.prot);
388: ch=getkeys(tmp2,0);
389: if(ch=='Q')
390: break;
391: for(i=0;i<total_prots;i++)
392: if(prot[i]->bicmd[0] && prot[i]->mnemonic==ch
393: && chk_ar(prot[i]->ar,useron))
394: break;
395: if(i<total_prots) {
396: xfrprot=i;
397: action=NODE_BXFR;
398: SYNC;
399: for(i=0;i<batdn_total;i++)
400: if(dir[batdn_dir[i]]->seqdev) {
401: lncntr=0;
402: unpadfname(batdn_name[i],tmp);
403: sprintf(tmp2,"%s%s",temp_dir,tmp);
404: if(!fexist(tmp2)) {
405: seqwait(dir[batdn_dir[i]]->seqdev);
406: bprintf(text[RetrievingFile],tmp);
407: sprintf(str,"%s%s"
408: ,batdn_alt[i]>0 && batdn_alt[i]<=altpaths
409: ? altpath[batdn_alt[i]-1]
410: : dir[batdn_dir[i]]->path
411: ,tmp);
412: mv(str,tmp2,1); /* copy the file to temp dir */
413: getnodedat(node_num,&thisnode,1);
414: thisnode.aux=0xff;
415: putnodedat(node_num,thisnode);
416: CRLF; } }
417: sprintf(str,"%sBATCHDN.LST",node_dir);
418: sprintf(tmp2,"%sBATCHUP.LST",node_dir);
419: start=time(NULL);
420: protocol(cmdstr(prot[xfrprot]->bicmd,str,tmp2,NULL),0);
421: end=time(NULL);
422: for(i=0;i<batdn_total;i++)
423: if(dir[batdn_dir[i]]->seqdev) {
424: unpadfname(batdn_name[i],tmp);
425: sprintf(tmp2,"%s%s",temp_dir,tmp);
426: remove(tmp2); }
427: batch_upload();
428: batch_download(xfrprot);
429: if(batdn_total) /* files still in queue, not xfered */
430: notdownloaded(totalsize,start,end);
431: autohangup(); }
432: break;
433: case 'C':
434: if(batup_total) {
435: if(!noyes(text[ClearUploadQueueQ])) {
436: batup_total=0;
437: bputs(text[UploadQueueCleared]); } }
438: if(batdn_total) {
439: if(!noyes(text[ClearDownloadQueueQ])) {
440: for(i=0;i<batdn_total;i++) {
441: f.dir=batdn_dir[i];
442: f.datoffset=batdn_offset[i];
443: f.size=batdn_size[i];
444: strcpy(f.name,batdn_name[i]);
445: closefile(f); }
446: batdn_total=0;
447: bputs(text[DownloadQueueCleared]); } }
448: break;
449: case 'D':
450: if(useron.rest&FLAG('D')) {
451: bputs(text[R_Download]);
452: break; }
453: if(!batdn_total) {
454: bputs(text[DownloadQueueIsEmpty]);
455: break; }
456: start_batch_download();
457: break;
458: case 'L':
459: if(batup_total) {
460: bputs(text[UploadQueueLstHdr]);
461: for(i=0;i<batup_total;i++)
462: bprintf(text[UploadQueueLstFmt],i+1,batup_name[i]
463: ,batup_desc[i]); }
464: if(batdn_total) {
465: bputs(text[DownloadQueueLstHdr]);
466: for(i=0,totalcdt=0,totalsize=0;i<batdn_total;i++) {
467: bprintf(text[DownloadQueueLstFmt],i+1
468: ,batdn_name[i],ultoac(batdn_cdt[i],tmp)
469: ,ultoac(batdn_size[i],str)
470: ,cur_cps
471: ? sectostr(batdn_size[i]/(ulong)cur_cps,tmp2)
472: : "??:??:??");
473: totalsize+=batdn_size[i];
474: totalcdt+=batdn_cdt[i]; }
475: bprintf(text[DownloadQueueTotals]
476: ,ultoac(totalcdt,tmp),ultoac(totalsize,str),cur_cps
477: ? sectostr(totalsize/(ulong)cur_cps,tmp2)
478: : "??:??:??"); }
479: break; /* Questionable line ^^^, see note above function */
480: case 'R':
481: if(batup_total) {
482: bprintf(text[RemoveWhichFromUlQueue],batup_total);
483: n=getnum(batup_total);
484: if(n>=1) {
485: n--;
486: batup_total--;
487: while(n<batup_total) {
488: batup_dir[n]=batup_dir[n+1];
489: batup_misc[n]=batup_misc[n+1];
490: batup_alt[n]=batup_alt[n+1];
491: strcpy(batup_name[n],batup_name[n+1]);
492: strcpy(batup_desc[n],batup_desc[n+1]);
493: n++; }
494: if(!batup_total)
495: bputs(text[UploadQueueCleared]); } }
496: if(batdn_total) {
497: bprintf(text[RemoveWhichFromDlQueue],batdn_total);
498: n=getnum(batdn_total);
499: if(n>=1) {
500: n--;
501: f.dir=batdn_dir[n];
502: strcpy(f.name,batdn_name[n]);
503: f.datoffset=batdn_offset[n];
504: f.size=batdn_size[n];
505: closefile(f);
506: batdn_total--;
507: while(n<batdn_total) {
508: strcpy(batdn_name[n],batdn_name[n+1]);
509: batdn_dir[n]=batdn_dir[n+1];
510: batdn_cdt[n]=batdn_cdt[n+1];
511: batdn_alt[n]=batdn_alt[n+1];
512: batdn_size[n]=batdn_size[n+1];
513: batdn_offset[n]=batdn_offset[n+1];
514: n++; }
515: if(!batdn_total)
516: bputs(text[DownloadQueueCleared]); } }
517: break;
518: case 'U':
519: if(useron.rest&FLAG('U')) {
520: bputs(text[R_Upload]);
521: break; }
522: if(!batup_total && upload_dir==INVALID_DIR) {
523: bputs(text[UploadQueueIsEmpty]);
524: break; }
525: menu("BATUPROT");
526: if(!create_batchup_lst())
527: break;
528: if(!create_bimodem_pth())
529: break;
530: ASYNC;
531: mnemonics(text[ProtocolOrQuit]);
532: strcpy(str,"Q");
533: for(i=0;i<total_prots;i++)
534: if(prot[i]->batulcmd[0] && chk_ar(prot[i]->ar,useron)) {
535: sprintf(tmp,"%c",prot[i]->mnemonic);
536: strcat(str,tmp); }
537: ch=getkeys(str,0);
538: if(ch=='Q')
539: break;
540: for(i=0;i<total_prots;i++)
541: if(prot[i]->batulcmd[0] && prot[i]->mnemonic==ch
542: && chk_ar(prot[i]->ar,useron))
543: break;
544: if(i<total_prots) {
545: sprintf(str,"%sBATCHUP.LST",node_dir);
546: xfrprot=i;
547: if(batup_total)
548: xfrdir=batup_dir[0];
549: else
550: xfrdir=upload_dir;
551: action=NODE_ULNG;
552: SYNC;
553: if(online==ON_REMOTE) {
554: delfiles(temp_dir,"*.*");
555: start=time(NULL);
556: protocol(cmdstr(prot[xfrprot]->batulcmd,str,nulstr,NULL),1);
557: end=time(NULL);
558: if(!(dir[xfrdir]->misc&DIR_ULTIME))
559: starttime+=end-start; }
560: batch_upload();
561: delfiles(temp_dir,"*.*");
562: autohangup(); }
563: break; } }
564: delfiles(temp_dir,"*.*");
565: }
566:
567: /****************************************************************************/
568: /* Download files from batch queue */
569: /****************************************************************************/
570: void start_batch_download()
571: {
572: char ch,str[256],tmp2[256],tmp3[128],fname[64];
573: int j;
574: uint i,xfrprot;
575: ulong totalcdt,totalsize,totaltime;
576: time_t start,end;
577: file_t f;
578:
579: if(useron.rest&FLAG('D')) { /* Download restriction */
580: bputs(text[R_Download]);
581: return; }
582: for(i=0,totalcdt=0;i<batdn_total;i++)
583: totalcdt+=batdn_cdt[i];
584: if(!(useron.exempt&FLAG('D'))
585: && totalcdt>useron.cdt+useron.freecdt) {
586: bprintf(text[YouOnlyHaveNCredits]
587: ,ultoac(useron.cdt+useron.freecdt,tmp));
588: return; }
589:
590: if(online==ON_LOCAL) { /* Local download */
591: bputs(text[EnterPath]);
592: if(!getstr(str,60,K_LINE|K_UPPER))
593: return;
594: backslash(str);
595: for(i=0;i<batdn_total;i++) {
596: curdirnum=batdn_dir[i]; /* for ARS */
597: lncntr=0;
598: unpadfname(batdn_name[i],tmp);
599: sprintf(tmp2,"%s%s",str,tmp);
600: seqwait(dir[batdn_dir[i]]->seqdev);
601: bprintf(text[RetrievingFile],tmp);
602: sprintf(tmp3,"%s%s"
603: ,batdn_alt[i]>0 && batdn_alt[i]<=altpaths
604: ? altpath[batdn_alt[i]-1]
605: : dir[batdn_dir[i]]->path
606: ,tmp);
607: j=mv(tmp3,tmp2,1);
608: getnodedat(node_num,&thisnode,1);
609: thisnode.aux=30; /* clear the seq dev # */
610: putnodedat(node_num,thisnode);
611: CRLF;
612: if(j) /* copy unsuccessful */
613: return;
614: for(j=0;j<total_dlevents;j++)
615: if(!stricmp(dlevent[j]->ext,batdn_name[i]+9)
616: && chk_ar(dlevent[j]->ar,useron)) {
617: bputs(dlevent[j]->workstr);
618: external(cmdstr(dlevent[j]->cmd,tmp2,nulstr,NULL),EX_OUTL);
619: CRLF; }
620: }
621: for(i=0;i<batdn_total;i++) {
622: curdirnum=batdn_dir[i]; /* for ARS */
623: f.dir=batdn_dir[i];
624: strcpy(f.name,batdn_name[i]);
625: f.datoffset=batdn_offset[i];
626: f.size=batdn_size[i];
627: f.altpath=batdn_alt[i];
628: downloadfile(f);
629: closefile(f); }
630: batdn_total=0;
631: return; }
632:
633: for(i=0,totalsize=totaltime=0;i<batdn_total;i++) {
634: totalsize+=batdn_size[i];
635: if(!(dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
636: totaltime+=batdn_size[i]/(ulong)cur_cps; }
637: if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft) {
638: bputs(text[NotEnoughTimeToDl]);
639: return; }
640: menu("BATDPROT");
641: if(!create_batchdn_lst())
642: return;
643: if(!create_bimodem_pth())
644: return;
645: ASYNC;
646: mnemonics(text[ProtocolOrQuit]);
647: strcpy(tmp2,"Q");
648: for(i=0;i<total_prots;i++)
649: if(prot[i]->batdlcmd[0] && chk_ar(prot[i]->ar,useron)) {
650: sprintf(tmp,"%c",prot[i]->mnemonic);
651: strcat(tmp2,tmp); }
652: ungetkey(useron.prot);
653: ch=getkeys(tmp2,0);
654: if(ch=='Q' || sys_status&SS_ABORT)
655: return;
656: for(i=0;i<total_prots;i++)
657: if(prot[i]->batdlcmd[0] && prot[i]->mnemonic==ch
658: && chk_ar(prot[i]->ar,useron))
659: break;
660: if(i<total_prots) {
661: xfrprot=i;
662: /* delfiles(temp_dir,"*.*"); fix for CD-ROM */
663: for(i=0;i<batdn_total;i++) {
664: curdirnum=batdn_dir[i]; /* for ARS */
665: unpadfname(batdn_name[i],fname);
666: if(dir[batdn_dir[i]]->seqdev) {
667: lncntr=0;
668: sprintf(tmp2,"%s%s",temp_dir,fname);
669: if(!fexist(tmp2)) {
670: seqwait(dir[batdn_dir[i]]->seqdev);
671: bprintf(text[RetrievingFile],fname);
672: sprintf(str,"%s%s"
673: ,batdn_alt[i]>0 && batdn_alt[i]<=altpaths
674: ? altpath[batdn_alt[i]-1]
675: : dir[batdn_dir[i]]->path
676: ,fname);
677: mv(str,tmp2,1); /* copy the file to temp dir */
678: getnodedat(node_num,&thisnode,1);
679: thisnode.aux=40; /* clear the seq dev # */
680: putnodedat(node_num,thisnode);
681: CRLF; } }
682: else
683: sprintf(tmp2,"%s%s"
684: ,batdn_alt[i]>0 && batdn_alt[i]<=altpaths
685: ? altpath[batdn_alt[i]-1]
686: : dir[batdn_dir[i]]->path
687: ,fname);
688: sprintf(str,"total_dlevents=%d",total_dlevents);
689: // logline("dl",str);
690: for(j=0;j<total_dlevents;j++) {
691: // logline("dl",dlevent[j]->ext);
692: // logline("dl",dlevent[j]->cmd);
693: // logline("dl",tmp2);
694: if(stricmp(dlevent[j]->ext,batdn_name[i]+9))
695: continue;
696: // logline("dl","chkar");
697: if(!chk_ar(dlevent[j]->ar,useron))
698: continue;
699: // logline("dl","bputs");
700: bputs(dlevent[j]->workstr);
701: // logline("dl","external");
702: external(cmdstr(dlevent[j]->cmd,tmp2,nulstr,NULL),EX_OUTL);
703: // logline("dl","crlf");
704: CRLF; }
705: // logline("dl","after dlevents");
706: }
707:
708: sprintf(str,"%sBATCHDN.LST",node_dir);
709: getnodedat(node_num,&thisnode,1);
710: action=NODE_DLNG;
711: if(cur_cps)
712: unixtodos(now+(totalsize/(ulong)cur_cps)
713: ,&date,&curtime);
714: thisnode.aux=(curtime.ti_hour*60)+curtime.ti_min;
715: thisnode.action=action;
716: putnodedat(node_num,thisnode); /* calculate ETA */
717: start=time(NULL);
718: protocol(cmdstr(prot[xfrprot]->batdlcmd,str,nulstr,NULL),0);
719: end=time(NULL);
720: batch_download(xfrprot);
721: if(batdn_total)
722: notdownloaded(totalsize,start,end);
723: /* delfiles(temp_dir,"*.*"); fix for CD-ROM */
724: autohangup(); }
725: }
726:
727: /*****************************************************************************/
728: /* Temp directory section. Files must be extracted here and both temp_uler */
729: /* and temp_uler fields should be filled before entrance. */
730: /*****************************************************************************/
731: void temp_xfer()
732: {
733: char str[256],tmp2[256],done=0,ch;
734: uint i,dirnum=total_dirs,j,files;
735: ulong bytes;
736: time_t start,end;
737: struct ffblk ff;
738: struct dfree d;
739: file_t f;
740:
741: if(!usrlibs)
742: return;
743: if(useron.rest&FLAG('D')) {
744: bputs(text[R_Download]);
745: return; }
746: /*************************************/
747: /* Create TEMP directory information */
748: /*************************************/
749: if((dir[dirnum]=(dir_t *)MALLOC(sizeof(dir_t)))==0) {
750: errormsg(WHERE,ERR_ALLOC,"temp_dir",sizeof(dir_t));
751: return; }
752: memset(dir[dirnum],0,sizeof(dir_t));
753: dir[dirnum]->lname="Temporary";
754: dir[dirnum]->sname="Temp";
755: strcpy(dir[dirnum]->code,"TEMP");
756: dir[dirnum]->path=temp_dir;
757: dir[dirnum]->maxfiles=MAX_FILES;
758: dir[dirnum]->data_dir=dir[0]->data_dir;
759: dir[dirnum]->op_ar=nulstr;
760: temp_dirnum=curdirnum=usrdir[curlib][curdir[curlib]];
761: total_dirs++;
762:
763: /****************************/
764: /* Fill filedat information */
765: /****************************/
766: sprintf(f.name,"TEMP_%3.3d.%s",node_num,useron.tmpext);
767: strcpy(f.desc,"Temp File");
768: f.dir=dirnum;
769: f.misc=f.timesdled=f.dateuled=f.datedled=0L;
770:
771: if(useron.misc&(RIP|WIP) && !(useron.misc&EXPERT))
772: menu("TEMPXFER");
773: lncntr=0;
774: while(online && !done) {
775: if(!(useron.misc&(EXPERT|RIP|WIP))) {
776: sys_status&=~SS_ABORT;
777: if(lncntr) {
778: SYNC;
779: CRLF;
780: if(lncntr) /* CRLF or SYNC can cause pause */
781: pause(); }
782: menu("TEMPXFER"); }
783: ASYNC;
784: bputs(text[TempDirPrompt]);
785: strcpy(f.uler,temp_uler);
786: ch=getkeys("ADEFNILQRVX?\r",0);
787: if(ch>SP)
788: logch(ch,0);
789: switch(ch) {
790: case 'A': /* add to temp file */
791: if(temp_dir[1]==':')
792: i=temp_dir[0]-'A'+1;
793: else i=0;
794: getdfree(i,&d);
795: if(d.df_sclus==0xffff)
796: errormsg(WHERE,ERR_CHK,temp_dir,0);
797: if((ulong)d.df_bsec*(ulong)d.df_sclus
798: *(ulong)d.df_avail<(ulong)min_dspace*1024L) {
799: bputs(text[LowDiskSpace]);
800: sprintf(str,"Diskspace is low: %s",temp_dir);
801: errorlog(str);
802: if(!dir_op(dirnum))
803: break; }
804: bprintf(text[DiskNBytesFree],ultoac((ulong)d.df_bsec
805: *(ulong)d.df_sclus*(ulong)d.df_avail,tmp));
806: if(!getfilespec(str))
807: break;
808: if(!checkfname(str))
809: break;
810: sprintf(tmp2,"Added %s to %s",str,f.name);
811: logline(nulstr,tmp2);
812: sprintf(tmp2,"%s%s",temp_dir,str);
813: sprintf(str,"%s%s",temp_dir,f.name);
814: external(cmdstr(temp_cmd(),str,tmp2,NULL),EX_CC|EX_OUTL|EX_OUTR);
815: break;
816: case 'D': /* download from temp dir */
817: sprintf(str,"%s%s",temp_dir,f.name);
818: if(!fexist(str)) {
819: bprintf(text[TempFileNotCreatedYet],f.name);
820: break; }
821: f.size=f.cdt=flength(str);
822: f.opencount=0;
823: if(temp_cdt) /* if file was not free */
824: f.cdt=f.size;
825: else
826: f.cdt=0;
827: if(!(useron.exempt&FLAG('D'))
828: && f.cdt>useron.cdt+useron.freecdt) {
829: bprintf(text[YouOnlyHaveNCredits]
830: ,ultoac(useron.cdt+useron.freecdt,tmp));
831: break; } /* f.cdt must equal size here */
832: if(!(useron.exempt&FLAG('T')) && !dir_op(dirnum)
833: && !(dir[temp_dirnum]->misc&DIR_TFREE) && cur_cps
834: && f.size/(ulong)cur_cps>timeleft) {
835: bputs(text[NotEnoughTimeToDl]);
836: break; }
837: if(!chk_ar(dir[temp_dirnum]->dl_ar,useron)) {
838: bputs(text[CantDownloadFromDir]);
839: break; }
840: addfiledat(&f);
841: menu("DLPROT");
842: SYNC;
843: mnemonics(text[ProtocolOrQuit]);
844: strcpy(tmp2,"Q");
845: for(i=0;i<total_prots;i++)
846: if(prot[i]->dlcmd[0] && chk_ar(prot[i]->ar,useron)) {
847: sprintf(tmp,"%c",prot[i]->mnemonic);
848: strcat(tmp2,tmp); }
849: ungetkey(useron.prot);
850: ch=getkeys(tmp2,0);
851: for(i=0;i<total_prots;i++)
852: if(prot[i]->dlcmd[0] && prot[i]->mnemonic==ch
853: && chk_ar(prot[i]->ar,useron))
854: break;
855: if(i<total_prots) {
856: getnodedat(node_num,&thisnode,1);
857: action=NODE_DLNG;
858: if(cur_cps)
859: unixtodos(now+(f.size/(ulong)cur_cps)
860: ,&date,&curtime);
861: thisnode.aux=(curtime.ti_hour*60)+curtime.ti_min;
862: putnodedat(node_num,thisnode); /* calculate ETA */
863: start=time(NULL);
864: j=protocol(cmdstr(prot[i]->dlcmd,str,nulstr,NULL),0);
865: end=time(NULL);
866: if(dir[temp_dirnum]->misc&DIR_TFREE)
867: starttime+=end-start;
868: if(prot[i]->misc&PROT_DSZLOG) {
869: if(checkprotlog(f))
870: downloadfile(f);
871: else
872: notdownloaded(f.size,start,end); }
873: else {
874: if(!j)
875: downloadfile(f);
876: else {
877: bprintf(text[FileNotSent],f.name);
878: notdownloaded(f.size,start,end); } }
879: autohangup(); }
880: removefiledat(f);
881: break;
882: case 'E':
883: extract(usrdir[curlib][curdir[curlib]]);
884: sys_status&=~SS_ABORT;
885: break;
886: case 'F': /* Create a file list */
887: delfiles(temp_dir,"*.*");
888: create_filelist("FILELIST.TXT",0);
889: if(!(sys_status&SS_ABORT))
890: logline(nulstr,"Created list of all files");
891: CRLF;
892: sys_status&=~SS_ABORT;
893: break;
894: case 'I': /* information on what's here */
895: bprintf(text[TempFileInfo],f.uler,temp_file);
896: break;
897: case 'L': /* list files in dir */
898: if(!getfilespec(str))
899: break;
900: if(!checkfname(str))
901: break;
902: bytes=files=0L;
903: CRLF;
904: sprintf(tmp2,"%s%s",temp_dir,str);
905: i=findfirst(tmp2,&ff,0);
906: while(!i && !msgabort()) {
907: bprintf("%s %10s\r\n",padfname(ff.ff_name,str)
908: ,ultoac(ff.ff_fsize,tmp));
909: files++;
910: bytes+=ff.ff_fsize;
911: i=findnext(&ff); }
912: if(!files)
913: bputs(text[EmptyDir]);
914: else if(files>1)
915: bprintf(text[TempDirTotal],ultoac(bytes,tmp),files);
916: break;
917: case 'N': /* Create a list of new files */
918: delfiles(temp_dir,"*.*");
919: create_filelist("NEWFILES.TXT",FL_ULTIME);
920: if(!(sys_status&SS_ABORT))
921: logline(nulstr,"Created list of new files");
922: CRLF;
923: sys_status&=~SS_ABORT;
924: break;
925: case 'R': /* Remove files from dir */
926: if(!getfilespec(str))
927: break;
928: // padfname(str,tmp); Removed 04/14/96
929: bprintf(text[NFilesRemoved],delfiles(temp_dir,tmp));
930: break;
931: case 'V': /* view files in dir */
932: bputs(text[FileSpec]);
933: if(!getstr(str,12,K_UPPER) || !checkfname(str))
934: break;
935: viewfiles(dirnum,str);
936: break;
937: case CR:
938: case 'Q': /* quit */
939: done=1;
940: break;
941: case 'X': /* extract from archive in temp dir */
942: extract(dirnum);
943: sys_status&=~SS_ABORT;
944: break;
945: case '?': /* menu */
946: if(useron.misc&(EXPERT|RIP|WIP))
947: menu("TEMPXFER");
948: break; }
949: if(sys_status&SS_ABORT)
950: break; }
951: FREE(dir[dirnum]);
952: total_dirs--;
953: }
954:
955:
956: /****************************************************************************/
957: /* Re-sorts file directory 'dirnum' according to dir[dirnum]->sort type */
958: /****************************************************************************/
959: void resort(uint dirnum)
960: {
961: char str[25],ixbfname[128],datfname[128],exbfname[128],txbfname[128]
962: ,ext[512],nulbuf[512];
963: uchar HUGE16 *ixbbuf, HUGE16 *datbuf;
964: uchar HUGE16 *ixbptr[MAX_FILES];
965: int ixbfile,datfile,exbfile,txbfile,i,j;
966: ulong ixblen,datlen,offset,newoffset,l;
967:
968: memset(nulbuf,0,512);
969: bprintf(text[ResortLineFmt],lib[dir[dirnum]->lib]->sname,dir[dirnum]->sname);
970: sprintf(ixbfname,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
971: sprintf(datfname,"%s%s.DAT",dir[dirnum]->data_dir,dir[dirnum]->code);
972: sprintf(exbfname,"%s%s.EXB",dir[dirnum]->data_dir,dir[dirnum]->code);
973: sprintf(txbfname,"%s%s.TXB",dir[dirnum]->data_dir,dir[dirnum]->code);
974:
975: if(flength(ixbfname)<1L || flength(datfname)<1L) {
976: remove(exbfname);
977: remove(txbfname);
978: remove(ixbfname);
979: remove(datfname);
980: bputs(text[ResortEmptyDir]);
981: return; }
982: bputs(text[Sorting]);
983: if((ixbfile=nopen(ixbfname,O_RDONLY))==-1) {
984: errormsg(WHERE,ERR_OPEN,ixbfname,O_RDONLY);
985: return; }
986: if((datfile=nopen(datfname,O_RDONLY))==-1) {
987: close(ixbfile);
988: errormsg(WHERE,ERR_OPEN,datfname,O_RDONLY);
989: return; }
990: ixblen=filelength(ixbfile);
991: datlen=filelength(datfile);
992: if((ixbbuf=MALLOC(ixblen))==NULL) {
993: close(ixbfile);
994: close(datfile);
995: errormsg(WHERE,ERR_ALLOC,ixbfname,ixblen);
996: return; }
997: if((datbuf=MALLOC(datlen))==NULL) {
998: close(ixbfile);
999: close(datfile);
1000: FREE((char *)ixbbuf);
1001: errormsg(WHERE,ERR_ALLOC,datfname,datlen);
1002: return; }
1003: if(lread(ixbfile,ixbbuf,ixblen)!=ixblen) {
1004: close(ixbfile);
1005: close(datfile);
1006: FREE((char *)ixbbuf);
1007: FREE((char *)datbuf);
1008: errormsg(WHERE,ERR_READ,ixbfname,ixblen);
1009: return; }
1010: if(lread(datfile,datbuf,datlen)!=datlen) {
1011: close(ixbfile);
1012: close(datfile);
1013: FREE((char *)ixbbuf);
1014: FREE((char *)datbuf);
1015: errormsg(WHERE,ERR_READ,datfname,datlen);
1016: return; }
1017: close(ixbfile);
1018: close(datfile);
1019: if((ixbfile=nopen(ixbfname,O_WRONLY|O_TRUNC))==-1) {
1020: FREE((char *)ixbbuf);
1021: FREE((char *)datbuf);
1022: errormsg(WHERE,ERR_OPEN,ixbfname,O_WRONLY|O_TRUNC);
1023: return; }
1024: if((datfile=nopen(datfname,O_WRONLY|O_TRUNC))==-1) {
1025: close(ixbfile);
1026: FREE((char *)ixbbuf);
1027: FREE((char *)datbuf);
1028: errormsg(WHERE,ERR_OPEN,datfname,O_WRONLY|O_TRUNC);
1029: return; }
1030: for(l=0,i=0;l<ixblen && i<MAX_FILES;l+=F_IXBSIZE,i++)
1031: ixbptr[i]=ixbbuf+l;
1032: switch(dir[dirnum]->sort) {
1033: case SORT_NAME_A:
1034: qsort((void *)ixbptr,ixblen/F_IXBSIZE,sizeof(ixbptr[0])
1035: ,(int(*)(const void*, const void*))fnamecmp_a);
1036: break;
1037: case SORT_NAME_D:
1038: qsort((void *)ixbptr,ixblen/F_IXBSIZE,sizeof(ixbptr[0])
1039: ,(int(*)(const void*, const void*))fnamecmp_d);
1040: break;
1041: case SORT_DATE_A:
1042: qsort((void *)ixbptr,ixblen/F_IXBSIZE,sizeof(ixbptr[0])
1043: ,(int(*)(const void*, const void*))fdatecmp_a);
1044: break;
1045: case SORT_DATE_D:
1046: qsort((void *)ixbptr,ixblen/F_IXBSIZE,sizeof(ixbptr[0])
1047: ,(int(*)(const void*, const void*))fdatecmp_d);
1048: break; }
1049:
1050: if((exbfile=nopen(exbfname,O_RDWR|O_CREAT))==-1) {
1051: close(ixbfile);
1052: close(datfile);
1053: FREE((char *)ixbbuf);
1054: FREE((char *)datbuf);
1055: errormsg(WHERE,ERR_OPEN,exbfname,O_RDWR|O_CREAT);
1056: return; }
1057: if((txbfile=nopen(txbfname,O_RDWR|O_CREAT))==-1) {
1058: close(exbfile);
1059: close(datfile);
1060: close(exbfile);
1061: FREE((char *)ixbbuf);
1062: FREE((char *)datbuf);
1063: errormsg(WHERE,ERR_OPEN,txbfname,O_RDWR|O_CREAT);
1064: return; }
1065:
1066: for(i=0;i<ixblen/F_IXBSIZE;i++) {
1067: offset=ixbptr[i][11]|((long)ixbptr[i][12]<<8)|((long)ixbptr[i][13]<<16);
1068: lwrite(datfile,&datbuf[offset],F_LEN);
1069:
1070: newoffset=(ulong)i*(ulong)F_LEN;
1071:
1072: j=datbuf[offset+F_MISC]; /* misc bits */
1073: if(j!=ETX) j-=SP;
1074: if(j&FM_EXTDESC) { /* extended description */
1075: lseek(exbfile,(offset/F_LEN)*512L,SEEK_SET);
1076: memset(ext,0,512);
1077: read(exbfile,ext,512);
1078: while(filelength(txbfile)<(newoffset/F_LEN)*512L) {
1079: // lseek(txbfile,0L,SEEK_END);
1080: write(txbfile,nulbuf,512); }
1081: lseek(txbfile,(newoffset/F_LEN)*512L,SEEK_SET);
1082: write(txbfile,ext,512); }
1083:
1084: str[0]=newoffset&0xff; /* Get offset within DAT file for IXB file */
1085: str[1]=(newoffset>>8)&0xff;
1086: str[2]=(newoffset>>16)&0xff;
1087: lwrite(ixbfile,ixbptr[i],11); /* filename */
1088: lwrite(ixbfile,str,3); /* offset */
1089: lwrite(ixbfile,ixbptr[i]+14,8); } /* upload and download times */
1090: close(exbfile);
1091: close(txbfile);
1092: close(ixbfile);
1093: close(datfile);
1094: remove(exbfname);
1095: rename(txbfname,exbfname);
1096: if(!flength(exbfname))
1097: remove(exbfname);
1098: FREE((char *)ixbbuf);
1099: FREE((char *)datbuf);
1100: if(ixblen/F_IXBSIZE==datlen/F_LEN)
1101: bputs(text[Sorted]);
1102: else
1103: bprintf(text[Compressed]
1104: ,(uint)((datlen/F_LEN)-(ixblen/F_IXBSIZE))
1105: ,ultoac(((datlen/F_LEN)-(ixblen/F_IXBSIZE))*F_LEN,tmp));
1106: }
1107:
1108: /*****************************************************************************/
1109: /* Handles extraction from a normal transfer file to the temp directory */
1110: /*****************************************************************************/
1111: void extract(uint dirnum)
1112: {
1113: char fname[13],str[256],excmd[256],path[256],done
1114: ,files[256],tmp[256],intmp=0;
1115: int i,j;
1116: struct ffblk ff;
1117: file_t f;
1118: struct dfree d;
1119:
1120: temp_dirnum=curdirnum=dirnum;
1121: if(!strcmp(dir[dirnum]->code,"TEMP"))
1122: intmp=1;
1123: if(temp_dir[1]==':')
1124: i=temp_dir[0]-'A'+1;
1125: else i=0;
1126: getdfree(i,&d);
1127: if(d.df_sclus==0xffff)
1128: errormsg(WHERE,ERR_CHK,temp_dir,0);
1129: if((ulong)d.df_bsec*(ulong)d.df_sclus
1130: *(ulong)d.df_avail<(ulong)min_dspace*1024L) {
1131: bputs(text[LowDiskSpace]);
1132: sprintf(str,"Diskspace is low: %s",temp_dir);
1133: errorlog(str);
1134: if(!dir_op(dirnum))
1135: return; }
1136: else if(!intmp) { /* not in temp dir */
1137: CRLF; }
1138: bprintf(text[DiskNBytesFree],ultoac((ulong)d.df_bsec
1139: *(ulong)d.df_sclus*(ulong)d.df_avail,tmp));
1140: if(!intmp) { /* not extracting FROM temp directory */
1141: sprintf(str,"%s*.*",temp_dir);
1142: if(fexist(str)) {
1143: bputs(text[RemovingTempFiles]);
1144: done=findfirst(str,&ff,0);
1145: while(!done) {
1146: sprintf(str,"%s%s",temp_dir,ff.ff_name);
1147: remove(str);
1148: done=findnext(&ff); }
1149: CRLF; } }
1150: bputs(text[ExtractFrom]);
1151: if(!getstr(fname,12,K_UPPER) || !checkfname(fname) || strchr(fname,'*')
1152: || strchr(fname,'?'))
1153: return;
1154: padfname(fname,f.name);
1155: strcpy(str,f.name);
1156: truncsp(str);
1157: for(i=0;i<total_fextrs;i++)
1158: if(!strcmp(str+9,fextr[i]->ext) && chk_ar(fextr[i]->ar,useron)) {
1159: strcpy(excmd,fextr[i]->cmd);
1160: break; }
1161: if(i==total_fextrs) {
1162: bputs(text[UnextractableFile]);
1163: return; }
1164: if(!intmp && !findfile(dirnum,f.name)) { /* not temp dir */
1165: bputs(text[SearchingAllDirs]);
1166: for(i=0;i<usrdirs[curlib] && !msgabort();i++) {
1167: if(i==dirnum) continue;
1168: if(findfile(usrdir[curlib][i],f.name))
1169: break; }
1170: if(i==usrdirs[curlib]) { /* not found in cur lib */
1171: bputs(text[SearchingAllLibs]);
1172: for(i=0;i<usrlibs;i++) {
1173: if(i==curlib) continue;
1174: for(j=0;j<usrdirs[i] && !msgabort();j++)
1175: if(findfile(usrdir[i][j],f.name))
1176: break;
1177: if(j<usrdirs[i])
1178: break; }
1179: if(i==usrlibs) {
1180: bputs(text[FileNotFound]); /* not in database */
1181: return; }
1182: dirnum=usrdir[i][j]; }
1183: else
1184: dirnum=usrdir[curlib][i]; }
1185: if(sys_status&SS_ABORT)
1186: return;
1187: sprintf(path,"%s%s",dir[dirnum]->path,fname);
1188: if(!intmp) { /* not temp dir, so get temp_file info */
1189: f.datoffset=f.dateuled=f.datedled=0L;
1190: f.dir=dirnum;
1191: getfileixb(&f);
1192: if(!f.datoffset && !f.dateuled && !f.datedled) /* error reading ixb */
1193: return;
1194: f.size=0;
1195: getfiledat(&f);
1196: fileinfo(f);
1197: if(f.altpath>0 && f.altpath<=altpaths)
1198: sprintf(path,"%s%s",altpath[f.altpath-1],fname);
1199: temp_dirnum=dirnum;
1200: if(dir[f.dir]->misc&DIR_FREE)
1201: temp_cdt=0L;
1202: else
1203: temp_cdt=f.cdt;
1204: strcpy(temp_uler,f.uler);
1205: strcpy(temp_file,f.name); } /* padded filename */
1206: if(!fexist(path)) {
1207: bputs(text[FileNotThere]); /* not on disk */
1208: return; }
1209: done=0;
1210: while(online && !done) {
1211: mnemonics(text[ExtractFilesPrompt]);
1212: switch(getkeys("EVQ",0)) {
1213: case 'E':
1214: if(!getfilespec(str))
1215: break;
1216: if(!checkfname(str))
1217: break;
1218: if((i=external(cmdstr(excmd,path,str,NULL)
1219: ,EX_INR|EX_OUTL|EX_OUTR|EX_CC))!=0) {
1220: errormsg(WHERE,ERR_EXEC,cmdstr(excmd,path,str,NULL),i);
1221: return; }
1222: sprintf(tmp,"Extracted %s from %s",str,path);
1223: logline(nulstr,tmp);
1224: CRLF;
1225: break;
1226: case 'V':
1227: viewfiles(dirnum,fname);
1228: break;
1229: default:
1230: done=1;
1231: break; } }
1232: }
1233:
1234: /****************************************************************************/
1235: /* Creates the file BATCHDN.LST in the node directory. Returns 1 if */
1236: /* everything goes okay. 0 if not. */
1237: /****************************************************************************/
1238: int create_batchdn_lst()
1239: {
1240: char str[256];
1241: int i,file;
1242:
1243: sprintf(str,"%sBATCHDN.LST",node_dir);
1244: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
1245: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
1246: return(0); }
1247: for(i=0;i<batdn_total;i++) {
1248: if(batdn_dir[i]>=total_dirs || dir[batdn_dir[i]]->seqdev)
1249: strcpy(str,temp_dir);
1250: else
1251: strcpy(str,batdn_alt[i]>0 && batdn_alt[i]<=altpaths
1252: ? altpath[batdn_alt[i]-1] : dir[batdn_dir[i]]->path);
1253: write(file,str,strlen(str));
1254: unpadfname(batdn_name[i],str);
1255: strcat(str,crlf);
1256: write(file,str,strlen(str)); }
1257: close(file);
1258: return(1);
1259: }
1260:
1261: /****************************************************************************/
1262: /* Creates the file BATCHUP.LST in the node directory. Returns 1 if */
1263: /* everything goes okay. 0 if not. */
1264: /* This list is not used by any protocols to date. */
1265: /****************************************************************************/
1266: int create_batchup_lst()
1267: {
1268: char str[256];
1269: int i,file;
1270:
1271: sprintf(str,"%sBATCHUP.LST",node_dir);
1272: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
1273: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
1274: return(0); }
1275: for(i=0;i<batup_total;i++) {
1276: if(batup_dir[i]>=total_dirs)
1277: strcpy(str,temp_dir);
1278: else
1279: strcpy(str,batup_alt[i]>0 && batup_alt[i]<=altpaths
1280: ? altpath[batup_alt[i]-1] : dir[batup_dir[i]]->path);
1281: write(file,str,strlen(str));
1282: unpadfname(batup_name[i],str);
1283: strcat(str,crlf);
1284: write(file,str,strlen(str)); }
1285: close(file);
1286: return(1);
1287: }
1288:
1289: /****************************************************************************/
1290: /* Creates the file BIMODEM.PTH in the node directory. Returns 1 if */
1291: /* everything goes okay. 0 if not. */
1292: /****************************************************************************/
1293: int create_bimodem_pth()
1294: {
1295: char str[256],tmp2[512];
1296: int i,file;
1297:
1298: sprintf(str,"%sBIMODEM.PTH",node_dir); /* Create bimodem file */
1299: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
1300: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
1301: return(0); }
1302: for(i=0;i<batup_total;i++) {
1303: sprintf(str,"%s%s",batup_dir[i]>=total_dirs ? temp_dir
1304: : batup_alt[i]>0 && batup_alt[i]<=altpaths
1305: ? altpath[batup_alt[i]-1] : dir[batup_dir[i]]->path
1306: ,unpadfname(batup_name[i],tmp));
1307: sprintf(tmp2,"D %-80.80s%-160.160s"
1308: ,unpadfname(batup_name[i],tmp),str);
1309: write(file,tmp2,248); }
1310: for(i=0;i<batdn_total;i++) {
1311: sprintf(str,"%s%s"
1312: ,(batdn_dir[i]>=total_dirs || dir[batdn_dir[i]]->seqdev)
1313: ? temp_dir : batdn_alt[i]>0 && batdn_alt[i]<=altpaths
1314: ? altpath[batdn_alt[i]-1] : dir[batdn_dir[i]]->path
1315: ,unpadfname(batdn_name[i],tmp));
1316: sprintf(tmp2,"U %-240.240s",str);
1317: write(file,tmp2,248); }
1318: close(file);
1319: return(1);
1320: }
1321:
1322: /****************************************************************************/
1323: /* Processes files that were supposed to be received in the batch queue */
1324: /****************************************************************************/
1325: void batch_upload()
1326: {
1327: char str1[256],str2[256];
1328: int i,j,x,y;
1329: file_t f;
1330: struct ffblk ff;
1331:
1332: for(i=0;i<batup_total;) {
1333: curdirnum=batup_dir[i]; /* for ARS */
1334: lncntr=0; /* defeat pause */
1335: unpadfname(batup_name[i],tmp);
1336: sprintf(str1,"%s%s",temp_dir,tmp);
1337: sprintf(str2,"%s%s",dir[batup_dir[i]]->path,tmp);
1338: if(fexist(str1) && fexist(str2)) { /* file's in two places */
1339: bprintf(text[FileAlreadyThere],batup_name[i]);
1340: remove(str1); /* this is the one received */
1341: i++;
1342: continue; }
1343: if(fexist(str1))
1344: mv(str1,str2,0);
1345: strcpy(f.name,batup_name[i]);
1346: strcpy(f.desc,batup_desc[i]);
1347: f.dir=batup_dir[i];
1348: f.misc=batup_misc[i];
1349: f.altpath=batup_alt[i];
1350: if(uploadfile(&f)) {
1351: batup_total--;
1352: for(j=i;j<batup_total;j++) {
1353: batup_dir[j]=batup_dir[j+1];
1354: batup_alt[j]=batup_alt[j+1];
1355: batup_misc[j]=batup_misc[j+1];
1356: strcpy(batup_name[j],batup_name[j+1]);
1357: strcpy(batup_desc[j],batup_desc[j+1]); } }
1358: else i++; }
1359: if(upload_dir==INVALID_DIR)
1360: return;
1361: sprintf(str1,"%s*.*",temp_dir);
1362: i=findfirst(str1,&ff,0);
1363: while(!i) {
1364: memset(&f,0,sizeof(file_t));
1365: f.dir=upload_dir;
1366: padfname(ff.ff_name,f.name);
1367: strupr(f.name);
1368: sprintf(str1,"%s%s",temp_dir,ff.ff_name);
1369: for(x=0;x<usrlibs;x++) {
1370: for(y=0;y<usrdirs[x];y++)
1371: if(dir[usrdir[x][y]]->misc&DIR_DUPES
1372: && findfile(usrdir[x][y],f.name))
1373: break;
1374: if(y<usrdirs[x])
1375: break; }
1376: sprintf(str2,"%s%s",dir[f.dir]->path,ff.ff_name);
1377: if(x<usrlibs || fexist(str2)) {
1378: bprintf(text[FileAlreadyOnline],f.name);
1379: remove(str1); }
1380: else {
1381: mv(str1,str2,0);
1382: uploadfile(&f); }
1383: i=findnext(&ff); }
1384: }
1385:
1386: /****************************************************************************/
1387: /* Processes files that were supposed to be sent from the batch queue */
1388: /* xfrprot is -1 if downloading files from within QWK (no DSZLOG) */
1389: /****************************************************************************/
1390: void batch_download(int xfrprot)
1391: {
1392: int i,j;
1393: file_t f;
1394:
1395: for(i=0;i<batdn_total;) {
1396: lncntr=0; /* defeat pause */
1397: f.dir=curdirnum=batdn_dir[i];
1398: strcpy(f.name,batdn_name[i]);
1399: f.datoffset=batdn_offset[i];
1400: f.size=batdn_size[i];
1401: /* Removed 05/18/95
1402: if(dir[f.dir]->misc&DIR_TFREE && cur_cps) Looks like it gave back double
1403: starttime+=f.size/(ulong)cur_cps;
1404: */
1405: f.altpath=batdn_alt[i];
1406: if(xfrprot==-1 || (prot[xfrprot]->misc&PROT_DSZLOG && checkprotlog(f))
1407: || !(prot[xfrprot]->misc&PROT_DSZLOG)) {
1408: if(dir[f.dir]->misc&DIR_TFREE && cur_cps)
1409: starttime+=f.size/(ulong)cur_cps;
1410: downloadfile(f);
1411: closefile(f);
1412: batdn_total--;
1413: for(j=i;j<batdn_total;j++) {
1414: strcpy(batdn_name[j],batdn_name[j+1]);
1415: batdn_dir[j]=batdn_dir[j+1];
1416: batdn_cdt[j]=batdn_cdt[j+1];
1417: batdn_alt[j]=batdn_alt[j+1];
1418: batdn_size[j]=batdn_size[j+1];
1419: batdn_offset[j]=batdn_offset[j+1]; } }
1420: else i++; }
1421: }
1422:
1423: /****************************************************************************/
1424: /* Adds a list of files to the batch download queue */
1425: /****************************************************************************/
1426: void batch_add_list(char *list)
1427: {
1428: char str[128];
1429: int file,i,j,k;
1430: FILE *stream;
1431: file_t f;
1432:
1433: if((stream=fnopen(&file,list,O_RDONLY))!=NULL) {
1434: bputs(text[SearchingAllLibs]);
1435: while(!feof(stream)) {
1436: checkline();
1437: if(!online)
1438: break;
1439: if(!fgets(str,127,stream))
1440: break;
1441: truncsp(str);
1442: sprintf(f.name,"%.12s",str);
1443: strupr(f.name);
1444: lncntr=0;
1445: for(i=k=0;i<usrlibs;i++) {
1446: for(j=0;j<usrdirs[i];j++,k++) {
1447: outchar('.');
1448: if(k && !(k%5))
1449: bputs("\b\b\b\b\b \b\b\b\b\b");
1450: if(findfile(usrdir[i][j],f.name))
1451: break; }
1452: if(j<usrdirs[i])
1453: break; }
1454: if(i<usrlibs) {
1455: f.dir=usrdir[i][j];
1456: getfileixb(&f);
1457: f.size=0;
1458: getfiledat(&f);
1459: if(f.size==-1L)
1460: bprintf(text[FileIsNotOnline],f.name);
1461: else
1462: addtobatdl(f); } }
1463: fclose(stream);
1464: remove(list);
1465: CRLF; }
1466: }
1467:
1468: /****************************************************************************/
1469: /* Creates a text file named NEWFILES.DAT in the temp directory that */
1470: /* all new files since p-date. Returns number of files in list. */
1471: /****************************************************************************/
1472: ulong create_filelist(char *name, char mode)
1473: {
1474: char str[256];
1475: int i,j,d,file;
1476: ulong l,k;
1477:
1478: bprintf(text[CreatingFileList],name);
1479: sprintf(str,"%s%s",temp_dir,name);
1480: if((file=nopen(str,O_CREAT|O_WRONLY|O_APPEND))==-1) {
1481: errormsg(WHERE,ERR_OPEN,str,O_CREAT|O_WRONLY|O_APPEND);
1482: return(0); }
1483: k=0;
1484: if(mode&FL_ULTIME) {
1485: sprintf(str,"New files since: %s\r\n",timestr(&ns_time));
1486: write(file,str,strlen(str)); }
1487: for(i=d=0;i<usrlibs;i++) {
1488: for(j=0;j<usrdirs[i];j++,d++) {
1489: outchar('.');
1490: if(d && !(d%5))
1491: bputs("\b\b\b\b\b \b\b\b\b\b");
1492: if(mode&FL_ULTIME /* New-scan */
1493: && (lib[usrlib[i]]->offline_dir==usrdir[i][j]
1494: || dir[usrdir[i][j]]->misc&DIR_NOSCAN))
1495: continue;
1496: l=listfiles(usrdir[i][j],nulstr,file,mode);
1497: if((long)l==-1)
1498: break;
1499: k+=l; }
1500: if(j<usrdirs[i])
1501: break; }
1502: if(k>1) {
1503: sprintf(str,"\r\n%d Files Listed.\r\n",k);
1504: write(file,str,strlen(str)); }
1505: close(file);
1506: if(k)
1507: bprintf(text[CreatedFileList],name);
1508: else {
1509: bputs(text[NoFiles]);
1510: sprintf(str,"%s%s",temp_dir,name);
1511: remove(str); }
1512: strcpy(temp_file,name);
1513: strcpy(temp_uler,"File List");
1514: return(k);
1515: }
1516:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.