![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xfer_mid.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_mid.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "XFER_MID.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: #include "sbbs.h"
6:
7: /****************************************************************************/
8: /* This function is called when a file is unsuccessfully downloaded. */
9: /* It logs the tranfer time and checks for possible leech protocol use. */
10: /****************************************************************************/
11: void notdownloaded(ulong size, time_t start, time_t end)
12: {
13: char str[256],tmp2[256];
14:
15: sprintf(str,"Estimated Time: %s Transfer Time: %s"
16: ,sectostr(cur_cps ? size/cur_cps : 0,tmp)
17: ,sectostr((uint)end-start,tmp2));
18: logline(nulstr,str);
19: if(leech_pct && cur_cps /* leech detection */
20: && end-start>=leech_sec
21: && end-start>=(double)(size/cur_cps)*(double)leech_pct/100.0) {
22: sprintf(str,"Possible use of leech protocol (leech=%u downloads=%u)"
23: ,useron.leech+1,useron.dls);
24: errorlog(str);
25: useron.leech=adjustuserrec(useron.number,U_LEECH,2,1); }
26: }
27:
28: /****************************************************************************/
29: /* List detailed information about the files in 'filespec'. Prompts for */
30: /* action depending on 'mode.' */
31: /* Returns number of files matching filespec that were found */
32: /****************************************************************************/
33: int listfileinfo(uint dirnum, char *filespec, char mode)
34: {
35: uchar str[258],path[258],dirpath[256],done=0,ch,fname[13],ext[513];
36: uchar HUGE16 *ixbbuf,*usrxfrbuf=NULL,*p;
37: int i,j,found=0,file;
38: ulong l,m,usrcdt,usrxfrlen;
39: time_t start,end;
40: file_t f;
41:
42: sprintf(str,"%sXFER.IXT",data_dir);
43: if(mode==FI_USERXFER && flength(str)>0L) {
44: if((file=nopen(str,O_RDONLY))==-1) {
45: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
46: return(0); }
47: usrxfrlen=filelength(file);
48: if((usrxfrbuf=MALLOC(usrxfrlen))==NULL) {
49: close(file);
50: errormsg(WHERE,ERR_ALLOC,str,usrxfrlen);
51: return(0); }
52: if(read(file,usrxfrbuf,usrxfrlen)!=usrxfrlen) {
53: close(file);
54: FREE(usrxfrbuf);
55: errormsg(WHERE,ERR_READ,str,usrxfrlen);
56: return(0); }
57: close(file); }
58: sprintf(str,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
59: if((file=nopen(str,O_RDONLY))==-1)
60: return(0);
61: l=filelength(file);
62: if(!l) {
63: close(file);
64: return(0); }
65: if((ixbbuf=(char *)MALLOC(l))==NULL) {
66: close(file);
67: errormsg(WHERE,ERR_ALLOC,str,l);
68: return(0); }
69: if(lread(file,ixbbuf,l)!=l) {
70: close(file);
71: errormsg(WHERE,ERR_READ,str,l);
72: FREE((char *)ixbbuf);
73: if(usrxfrbuf)
74: FREE(usrxfrbuf);
75: return(0); }
76: close(file);
77: sprintf(str,"%s%s.DAT",dir[dirnum]->data_dir,dir[dirnum]->code);
78: if((file=nopen(str,O_RDONLY))==-1) {
79: errormsg(WHERE,ERR_READ,str,O_RDONLY);
80: FREE((char *)ixbbuf);
81: if(usrxfrbuf)
82: FREE(usrxfrbuf);
83: return(0); }
84: close(file);
85: m=0;
86: while(online && !done && m<l) {
87: if(mode==FI_REMOVE && dir_op(dirnum))
88: action=NODE_SYSP;
89: else action=NODE_LFIL;
90: if(msgabort()) {
91: found=-1;
92: break; }
93: for(i=0;i<12 && m<l;i++)
94: if(i==8)
95: str[i]='.';
96: else
97: str[i]=ixbbuf[m++]; /* Turns FILENAMEEXT into FILENAME.EXT */
98: str[i]=0;
99: unpadfname(str,fname);
100: if(filespec[0] && !filematch(str,filespec)) {
101: m+=11;
102: continue; }
103: f.datoffset=ixbbuf[m]|((long)ixbbuf[m+1]<<8)|((long)ixbbuf[m+2]<<16);
104: f.dateuled=ixbbuf[m+3]|((long)ixbbuf[m+4]<<8)
105: |((long)ixbbuf[m+5]<<16)|((long)ixbbuf[m+6]<<24);
106: f.datedled=ixbbuf[m+7]|((long)ixbbuf[m+8]<<8)
107: |((long)ixbbuf[m+9]<<16)|((long)ixbbuf[m+10]<<24);
108: m+=11;
109: if(mode==FI_OLD && f.datedled>ns_time)
110: continue;
111: if((mode==FI_OLDUL || mode==FI_OLD) && f.dateuled>ns_time)
112: continue;
113: f.dir=curdirnum=dirnum;
114: strcpy(f.name,str);
115: f.size=0;
116: getfiledat(&f);
117: if(mode==FI_OFFLINE && f.size>=0)
118: continue;
119: if(f.altpath>0 && f.altpath<=altpaths)
120: strcpy(dirpath,altpath[f.altpath-1]);
121: else
122: strcpy(dirpath,dir[f.dir]->path);
123: if(mode==FI_CLOSE && !f.opencount)
124: continue;
125: if(mode==FI_USERXFER) {
126: for(p=usrxfrbuf;p<usrxfrbuf+usrxfrlen;p+=24) {
127: sprintf(str,"%17.17s",p); /* %4.4u %12.12s */
128: if(!strcmp(str+5,f.name) && useron.number==atoi(str))
129: break; }
130: if(p>=usrxfrbuf+usrxfrlen) /* file wasn't found */
131: continue; }
132: if((mode==FI_REMOVE) && (!dir_op(dirnum) && strcmpi(f.uler
133: ,useron.alias) && !(useron.exempt&FLAG('R'))))
134: continue;
135: found++;
136: if(mode==FI_INFO) {
137: if(!viewfile(f,1)) {
138: done=1;
139: found=-1; } }
140: else
141: fileinfo(f);
142: if(mode==FI_CLOSE) {
143: if(!noyes(text[CloseFileRecordQ])) {
144: f.opencount=0;
145: putfiledat(f); } }
146: else if(mode==FI_REMOVE || mode==FI_OLD || mode==FI_OLDUL
147: || mode==FI_OFFLINE) {
148: SYNC;
149: CRLF;
150: if(f.opencount) {
151: mnemonics(text[QuitOrNext]);
152: strcpy(str,"Q\r"); }
153: else if(dir_op(dirnum)) {
154: mnemonics(text[SysopRemoveFilePrompt]);
155: strcpy(str,"VEFMCQR\r"); }
156: else if(useron.exempt&FLAG('R')) {
157: mnemonics(text[RExemptRemoveFilePrompt]);
158: strcpy(str,"VEMQR\r"); }
159: else {
160: mnemonics(text[UserRemoveFilePrompt]);
161: strcpy(str,"VEQR\r"); }
162: switch(getkeys(str,0)) {
163: case 'V':
164: viewfilecontents(f);
165: CRLF;
166: ASYNC;
167: pause();
168: m-=F_IXBSIZE;
169: continue;
170: case 'E': /* edit file information */
171: if(dir_op(dirnum)) {
172: bputs(text[EditFilename]);
173: strcpy(str,fname);
174: getstr(str,12,K_EDIT|K_AUTODEL|K_UPPER);
175: if(strcmp(str,fname)) { /* rename */
176: padfname(str,path);
177: if(findfile(f.dir,path))
178: bprintf(text[FileAlreadyThere],path);
179: else {
180: sprintf(path,"%s%s",dirpath,fname);
181: sprintf(tmp,"%s%s",dirpath,str);
182: if(rename(path,tmp))
183: bprintf(text[CouldntRenameFile],path,tmp);
184: else {
185: bprintf(text[FileRenamed],path,tmp);
186: strcpy(fname,str);
187: removefiledat(f);
188: strcpy(f.name,padfname(str,tmp));
189: addfiledat(&f); } } } }
190: bputs(text[EditDescription]);
191: getstr(f.desc,LEN_FDESC,K_LINE|K_EDIT|K_AUTODEL);
192: if(f.misc&FM_EXTDESC) {
193: if(!noyes(text[DeleteExtDescriptionQ])) {
194: remove(str);
195: f.misc&=~FM_EXTDESC; } }
196: if(!dir_op(dirnum)) {
197: putfiledat(f);
198: break; }
199: bputs(text[EditUploader]);
200: getstr(f.uler,LEN_ALIAS,K_UPRLWR|K_EDIT|K_AUTODEL);
201: ultoa(f.cdt,str,10);
202: bputs(text[EditCreditValue]);
203: getstr(str,7,K_NUMBER|K_EDIT|K_AUTODEL);
204: f.cdt=atol(str);
205: itoa(f.timesdled,str,10);
206: bputs(text[EditTimesDownloaded]);
207: getstr(str,5,K_NUMBER|K_EDIT|K_AUTODEL);
208: f.timesdled=atoi(str);
209: if(f.opencount) {
210: itoa(f.opencount,str,10);
211: bputs(text[EditOpenCount]);
212: getstr(str,3,K_NUMBER|K_EDIT|K_AUTODEL);
213: f.opencount=atoi(str); }
214: if(altpaths || f.altpath) {
215: itoa(f.altpath,str,10);
216: bputs(text[EditAltPath]);
217: getstr(str,3,K_NUMBER|K_EDIT|K_AUTODEL);
218: f.altpath=atoi(str);
219: if(f.altpath>altpaths)
220: f.altpath=0; }
221: putfiledat(f);
222: inputnstime(&f.dateuled);
223: update_uldate(f);
224: break;
225: case 'F': /* delete file only */
226: sprintf(str,"%s%s",dirpath,fname);
227: if(!fexist(str))
228: bputs(text[FileNotThere]);
229: else {
230: if(!noyes(text[AreYouSureQ])) {
231: if(remove(str))
232: bprintf(text[CouldntRemoveFile],str);
233: else {
234: sprintf(tmp,"Deleted %s",str);
235: logline(nulstr,tmp); } } }
236: break;
237: case 'R': /* remove file from database */
238: if(noyes(text[AreYouSureQ]))
239: break;
240: removefiledat(f);
241: sprintf(str,"Removed %s from %s %s",f.name
242: ,lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
243: logline("U-",str);
244: sprintf(str,"%s%s",dirpath,fname);
245: if(fexist(str)) {
246: if(dir_op(dirnum)) {
247: if(!noyes(text[DeleteFileQ])) {
248: if(remove(str))
249: bprintf(text[CouldntRemoveFile],str);
250: else {
251: sprintf(tmp,"Deleted %s",str);
252: logline(nulstr,tmp); } } }
253: else if(remove(str)) /* always remove if not sysop */
254: bprintf(text[CouldntRemoveFile],str); }
255: if(dir_op(dirnum) || useron.exempt&FLAG('R')) {
256: i=lib[dir[f.dir]->lib]->offline_dir;
257: if(i!=dirnum && i!=(int)INVALID_DIR
258: && !findfile(i,f.name)) {
259: sprintf(str,text[AddToOfflineDirQ]
260: ,fname,lib[dir[i]->lib]->sname,dir[i]->sname);
261: if(yesno(str)) {
262: getextdesc(f.dir,f.datoffset,ext);
263: f.dir=i;
264: addfiledat(&f);
265: if(f.misc&FM_EXTDESC)
266: putextdesc(f.dir,f.datoffset,ext); } } }
267: if(dir_op(dirnum) || strcmpi(f.uler,useron.alias)) {
268: if(noyes(text[RemoveCreditsQ]))
269: /* Fall through */ break; }
270: case 'C': /* remove credits only */
271: if((i=matchuser(f.uler))==0) {
272: bputs(text[UnknownUser]);
273: break; }
274: if(dir_op(dirnum)) {
275: usrcdt=(ulong)(f.cdt*(dir[f.dir]->up_pct/100.0));
276: if(f.timesdled) /* all downloads */
277: usrcdt+=(ulong)((long)f.timesdled
278: *f.cdt*(dir[f.dir]->dn_pct/100.0));
279: ultoa(usrcdt,str,10);
280: bputs(text[CreditsToRemove]);
281: getstr(str,10,K_NUMBER|K_LINE|K_EDIT|K_AUTODEL);
282: f.cdt=atol(str); }
283: usrcdt=adjustuserrec(i,U_CDT,10,-f.cdt);
284: if(i==useron.number)
285: useron.cdt=usrcdt;
286: sprintf(str,text[FileRemovedUserMsg]
287: ,f.name,f.cdt ? ultoac(f.cdt,tmp) : text[No]);
288: putsmsg(i,str);
289: usrcdt=adjustuserrec(i,U_ULB,10,-f.size);
290: if(i==useron.number)
291: useron.ulb=usrcdt;
292: usrcdt=adjustuserrec(i,U_ULS,5,-1);
293: if(i==useron.number)
294: useron.uls=usrcdt;
295: break;
296: case 'M': /* move the file to another dir */
297: CRLF;
298: for(i=0;i<usrlibs;i++)
299: bprintf(text[MoveToLibLstFmt],i+1,lib[usrlib[i]]->lname);
300: SYNC;
301: bprintf(text[MoveToLibPrompt],dir[dirnum]->lib+1);
302: if((i=getnum(usrlibs))==-1)
303: continue;
304: if(!i)
305: i=dir[dirnum]->lib;
306: else
307: i--;
308: CRLF;
309: for(j=0;j<usrdirs[i];j++)
310: bprintf(text[MoveToDirLstFmt]
311: ,j+1,dir[usrdir[i][j]]->lname);
312: SYNC;
313: bprintf(text[MoveToDirPrompt],usrdirs[i]);
314: if((j=getnum(usrdirs[i]))==-1)
315: continue;
316: if(!j)
317: j=usrdirs[i]-1;
318: else j--;
319: CRLF;
320: if(findfile(usrdir[i][j],f.name)) {
321: bprintf(text[FileAlreadyThere],f.name);
322: break; }
323: getextdesc(f.dir,f.datoffset,ext);
324: removefiledat(f);
325: if(f.dir==upload_dir || f.dir==sysop_dir)
326: f.dateuled=time(NULL);
327: f.dir=usrdir[i][j];
328: addfiledat(&f);
329: bprintf(text[MovedFile],f.name
330: ,lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
331: sprintf(str,"Moved %s to %s %s",f.name
332: ,lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
333: logline(nulstr,str);
334: if(!f.altpath) { /* move actual file */
335: sprintf(str,"%s%s",dir[dirnum]->path,fname);
336: if(fexist(str)) {
337: sprintf(path,"%s%s",dir[f.dir]->path,fname);
338: mv(str,path,0); } }
339: if(f.misc&FM_EXTDESC)
340: putextdesc(f.dir,f.datoffset,ext);
341: break;
342: case 'Q': /* quit */
343: found=-1;
344: done=1;
345: break; } }
346: else if(mode==FI_DOWNLOAD || mode==FI_USERXFER) {
347: sprintf(path,"%s%s",dirpath,fname);
348: if(f.size<1L) { /* getfiledat will set this to -1 if non-existant */
349: SYNC; /* and 0 byte files shouldn't be d/led */
350: mnemonics(text[QuitOrNext]);
351: if(getkeys("\rQ",0)=='Q') {
352: found=-1;
353: break; }
354: continue; }
355: if(!(dir[f.dir]->misc&DIR_FREE) && !(useron.exempt&FLAG('D'))
356: && f.cdt>(useron.cdt+useron.freecdt)) {
357: SYNC;
358: bprintf(text[YouOnlyHaveNCredits]
359: ,ultoac(useron.cdt+useron.freecdt,tmp));
360: mnemonics(text[QuitOrNext]);
361: if(getkeys("\rQ",0)=='Q') {
362: found=-1;
363: break; }
364: continue; }
365: if(!chk_ar(dir[f.dir]->dl_ar,useron)) {
366: SYNC;
367: bputs(text[CantDownloadFromDir]);
368: mnemonics(text[QuitOrNext]);
369: if(getkeys("\rQ",0)=='Q') {
370: found=-1;
371: break; }
372: continue; }
373: if(!(dir[f.dir]->misc&DIR_TFREE) && f.timetodl>timeleft && !dir_op(dirnum)
374: && !(useron.exempt&FLAG('T'))) {
375: SYNC;
376: bputs(text[NotEnoughTimeToDl]);
377: mnemonics(text[QuitOrNext]);
378: if(getkeys("\rQ",0)=='Q') {
379: found=-1;
380: break; }
381: continue; }
382: menu("DLPROT");
383: openfile(f);
384: SYNC;
385: mnemonics(text[ProtocolBatchQuitOrNext]);
386: strcpy(str,"BQ\r");
387: for(i=0;i<total_prots;i++)
388: if(prot[i]->dlcmd[0]
389: && chk_ar(prot[i]->ar,useron)) {
390: sprintf(tmp,"%c",prot[i]->mnemonic);
391: strcat(str,tmp); }
392: // ungetkey(useron.prot);
393: ch=getkeys(str,0);
394: if(ch=='Q') {
395: found=-1;
396: done=1; }
397: else if(ch=='B') {
398: if(!addtobatdl(f)) {
399: closefile(f);
400: break; } }
401: else if(ch!=CR) {
402: for(i=0;i<total_prots;i++)
403: if(prot[i]->dlcmd[0] && prot[i]->mnemonic==ch
404: && chk_ar(prot[i]->ar,useron))
405: break;
406: if(i<total_prots) {
407: if(online==ON_LOCAL) {
408: bputs(text[EnterPath]);
409: if(getstr(path,60,K_UPPER|K_LINE)) {
410: backslash(path);
411: strcat(path,fname);
412: sprintf(str,"%s%s",dirpath,fname);
413: if(!mv(str,path,1))
414: downloadfile(f);
415: for(j=0;j<total_dlevents;j++)
416: if(!stricmp(dlevent[j]->ext,f.name+9)
417: && chk_ar(dlevent[j]->ar,useron)) {
418: bputs(dlevent[j]->workstr);
419: external(cmdstr(dlevent[j]->cmd,path,nulstr
420: ,NULL)
421: ,EX_OUTL);
422: CRLF; }
423: } }
424: else {
425: delfiles(temp_dir,"*.*");
426: if(dir[f.dir]->seqdev) {
427: lncntr=0;
428: seqwait(dir[f.dir]->seqdev);
429: bprintf(text[RetrievingFile],fname);
430: sprintf(str,"%s%s",dirpath,fname);
431: sprintf(path,"%s%s",temp_dir,fname);
432: mv(str,path,1); /* copy the file to temp dir */
433: getnodedat(node_num,&thisnode,1);
434: thisnode.aux=0xf0;
435: putnodedat(node_num,thisnode);
436: CRLF; }
437: for(j=0;j<total_dlevents;j++)
438: if(!stricmp(dlevent[j]->ext,f.name+9)
439: && chk_ar(dlevent[j]->ar,useron)) {
440: bputs(dlevent[j]->workstr);
441: external(cmdstr(dlevent[j]->cmd,path,nulstr,NULL)
442: ,EX_OUTL);
443: CRLF; }
444: getnodedat(node_num,&thisnode,1);
445: action=NODE_DLNG;
446: unixtodos(now+f.timetodl,&date,&curtime);
447: thisnode.aux=(curtime.ti_hour*60)+curtime.ti_min;
448: putnodedat(node_num,thisnode); /* calculate ETA */
449: start=time(NULL);
450: j=protocol(cmdstr(prot[i]->dlcmd,path,nulstr,NULL),0);
451: end=time(NULL);
452: if(dir[f.dir]->misc&DIR_TFREE)
453: starttime+=end-start;
454: if(prot[i]->misc&PROT_DSZLOG) {
455: if(checkprotlog(f))
456: downloadfile(f);
457: else
458: notdownloaded(f.size,start,end); }
459: else {
460: if(!j)
461: downloadfile(f);
462: else {
463: bprintf(text[FileNotSent],f.name);
464: notdownloaded(f.size,start,end); } }
465: delfiles(temp_dir,"*.*");
466: autohangup(); } } }
467: closefile(f); }
468: if(filespec[0] && !strchr(filespec,'*') && !strchr(filespec,'?')) break; }
469: FREE((char *)ixbbuf);
470: if(usrxfrbuf)
471: FREE(usrxfrbuf);
472: return(found);
473: }
474:
475:
476: /****************************************************************************/
477: /* Checks directory data file for 'filename' (must be padded). If found, */
478: /* it returns the 1, else returns 0. */
479: /* Called from upload and bulkupload */
480: /****************************************************************************/
481: char findfile(uint dirnum, char *filename)
482: {
483: char str[256],c,fname[13],HUGE16 *ixbbuf;
484: int file;
485: ulong length,l;
486:
487: sprintf(fname,"%.12s",filename);
488: strupr(fname);
489: for(c=8;c<12;c++) /* Turn FILENAME.EXT into FILENAMEEXT */
490: fname[c]=fname[c+1];
491: sprintf(str,"%s%s.IXB",dir[dirnum]->data_dir,dir[dirnum]->code);
492: if((file=nopen(str,O_RDONLY))==-1) return(0);
493: length=filelength(file);
494: if(!length) {
495: close(file);
496: return(0); }
497: if((ixbbuf=(char *)MALLOC(length))==NULL) {
498: close(file);
499: errormsg(WHERE,ERR_ALLOC,str,length);
500: return(0); }
501: if(lread(file,ixbbuf,length)!=length) {
502: close(file);
503: errormsg(WHERE,ERR_READ,str,length);
504: FREE((char *)ixbbuf);
505: return(0); }
506: close(file);
507: for(l=0;l<length;l+=F_IXBSIZE) {
508: for(c=0;c<11;c++)
509: if(fname[c]!=toupper(ixbbuf[l+c])) break;
510: if(c==11) break; }
511: FREE((char *)ixbbuf);
512: if(l!=length)
513: return(1);
514: return(0);
515: }
516:
517: /****************************************************************************/
518: /* Prints one file's information on a single line to a file 'file' */
519: /****************************************************************************/
520: void listfiletofile(char *fname, char HUGE16 *buf, uint dirnum, int file)
521: {
522: char str[256],exist=1;
523: uchar alt;
524: ulong cdt;
525:
526: strcpy(str,fname);
527: if(buf[F_MISC]!=ETX && (buf[F_MISC]-SP)&FM_EXTDESC)
528: strcat(str,"+");
529: else
530: strcat(str," ");
531: write(file,str,13);
532: getrec((char *)buf,F_ALTPATH,2,str);
533: alt=(uchar)ahtoul(str);
534: sprintf(str,"%s%s",alt>0 && alt<=altpaths ? altpath[alt-1]
535: : dir[dirnum]->path,unpadfname(fname,tmp));
536: if(dir[dirnum]->misc&DIR_FCHK && !fexist(str))
537: exist=0;
538: getrec((char *)buf,F_CDT,LEN_FCDT,str);
539: cdt=atol(str);
540: if(!cdt)
541: strcpy(str," FREE");
542: else
543: sprintf(str,"%7lu",cdt);
544: if(exist)
545: strcat(str," ");
546: else
547: strcat(str,"-");
548: write(file,str,8);
549: getrec((char *)buf,F_DESC,LEN_FDESC,str);
550: write(file,str,strlen(str));
551: write(file,crlf,2);
552: }
553:
554:
555:
556: /****************************************************************************/
557: /* Handles start and stop routines for transfer protocols */
558: /****************************************************************************/
559: int protocol(char *cmdline, int cd)
560: {
561: char tmp[128];
562: int i;
563:
564: sprintf(tmp,"%sPROTOCOL.LOG",node_dir);
565: remove(tmp); /* Deletes the protocol log */
566: if(useron.misc&AUTOHANG)
567: autohang=1;
568: else
569: autohang=yesno(text[HangUpAfterXferQ]);
570: if(sys_status&SS_ABORT) { /* if ctrl-c */
571: autohang=0;
572: return(-1); }
573: bputs(text[StartXferNow]);
574: RIOSYNC(0);
575: lprintf("%s\r\n",cmdline);
576: if(cd) {
577: if(temp_dir[1]==':') /* fix for DSZ */
578: setdisk(toupper(temp_dir[0])-'A');
579: strcpy(tmp,temp_dir);
580: tmp[strlen(tmp)-1]=0; /* take off '\' */
581: if(chdir(tmp))
582: errormsg(WHERE,ERR_CHDIR,tmp,0); }
583: i=external(cmdline,EX_OUTL); /* EX_CC removed because of error level prob */
584: if(online==ON_REMOTE)
585: rioctl(IOFB);
586: CRLF;
587: if(autohang) sys_status|=SS_PAUSEOFF; /* Pause off after download */
588: return(i);
589: }
590:
591: /****************************************************************************/
592: /* Invokes the timed auto-hangup after transfer routine */
593: /****************************************************************************/
594: void autohangup()
595: {
596: char a,c,k;
597:
598: SYNC;
599: sys_status&=~SS_PAUSEOFF; /* turn pause back on */
600: rioctl(IOFI);
601: if(!autohang) return;
602: lncntr=0;
603: bputs(text[Disconnecting]);
604: attr(GREEN);
605: outchar('[');
606: for(c=9,a=0;c>-1 && online && !a;c--) {
607: checkline();
608: attr(LIGHTGRAY|HIGH);
609: bputs(itoa(c,tmp,10));
610: attr(GREEN);
611: outchar(']');
612: while((k=inkey(0))!=0 && online) {
613: if(toupper(k)=='H') {
614: c=0;
615: break; }
616: if(toupper(k)=='A') {
617: a=1;
618: break; } }
619: mswait(DELAY_AUTOHG);
620: if(!a) {
621: outchar(BS);
622: outchar(BS); } }
623: if(c==-1) {
624: bputs(text[Disconnected]);
625: hangup(); }
626: else
627: CRLF;
628: }
629:
630: /****************************************************************************/
631: /* Checks dsz compatible log file for errors in transfer */
632: /* Returns 1 if the file in the struct file_t was successfuly transfered */
633: /****************************************************************************/
634: char checkprotlog(file_t f)
635: {
636: char str[256],size[128];
637: int file;
638: FILE *stream;
639:
640: sprintf(str,"%sPROTOCOL.LOG",node_dir);
641: if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
642: bprintf(text[FileNotSent],f.name);
643: if(f.dir<total_dirs)
644: sprintf(str,"Attempted to download %s (%s) from %s %s"
645: ,f.name,ultoac(f.size,size)
646: ,lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
647: else if(f.dir==total_dirs)
648: strcpy(str,"Attempted to download QWK packet");
649: else if(f.dir==total_dirs+1)
650: sprintf(str,"Attempted to download attached file: %s",f.name);
651: logline("D!",str);
652: return(0); }
653: unpadfname(f.name,tmp);
654: if(tmp[strlen(tmp)-1]=='.') /* DSZ log uses FILE instead of FILE. */
655: tmp[strlen(tmp)-1]=0; /* when there isn't an extension. */
656: while(!ferror(stream)) {
657: if(!fgets(str,256,stream))
658: break;
659: if(str[strlen(str)-2]==CR)
660: str[strlen(str)-2]=0; /* chop off CRLF */
661: strupr(str);
662: if(strstr(str,tmp)) { /* Only check for name, Bimodem doesn't put path */
663: logline(nulstr,str);
664: if(str[0]=='E' || str[0]=='L' || (str[6]==SP && str[7]=='0'))
665: break; /* E for Error or L for Lost Carrier */
666: fclose(stream); /* or only sent 0 bytes! */
667: return(1); } }
668: fclose(stream);
669: bprintf(text[FileNotSent],f.name);
670: if(f.dir<total_dirs)
671: sprintf(str,"Attempted to download %s (%s) from %s %s",f.name
672: ,ultoac(f.size,tmp),lib[dir[f.dir]->lib]->sname,dir[f.dir]->sname);
673: else
674: strcpy(str,"Attempted to download QWK packet");
675: logline("D!",str);
676: return(0);
677: }
678:
679: /*****************************************************************************/
680: /* View viewable file types from dir 'dirnum' */
681: /* 'fspec' must be padded */
682: /*****************************************************************************/
683: void viewfiles(uint dirnum, char *fspec)
684: {
685: char viewcmd[256];
686: int i;
687:
688: curdirnum=dirnum; /* for ARS */
689: sprintf(viewcmd,"%s%s",dir[dirnum]->path,fspec);
690: if(!fexist(viewcmd)) {
691: bputs(text[FileNotFound]);
692: return; }
693: padfname(fspec,tmp);
694: truncsp(tmp);
695: for(i=0;i<total_fviews;i++)
696: if(!strcmp(tmp+9,fview[i]->ext) && chk_ar(fview[i]->ar,useron)) {
697: strcpy(viewcmd,fview[i]->cmd);
698: break; }
699: if(i==total_fviews) {
700: bprintf(text[NonviewableFile],tmp+9);
701: return; }
702: sprintf(tmp,"%s%s",dir[dirnum]->path,fspec);
703: if((i=external(cmdstr(viewcmd,tmp,tmp,NULL),EX_OUTL|EX_OUTR|EX_INR|EX_CC))!=0)
704: errormsg(WHERE,ERR_EXEC,viewcmd,i); /* must of EX_CC to ^C */
705: }
706:
707: /****************************************************************************/
708: /* Compares filenames for ascending name sort */
709: /****************************************************************************/
710: int fnamecmp_a(char **str1, char **str2)
711: {
712: return(strncmp(*str1,*str2,11));
713: }
714:
715: /****************************************************************************/
716: /* Compares filenames for descending name sort */
717: /****************************************************************************/
718: int fnamecmp_d(char **str1, char **str2)
719: {
720: return(strncmp(*str2,*str1,11));
721: }
722:
723: /****************************************************************************/
724: /* Compares file upload dates for ascending date sort */
725: /****************************************************************************/
726: int fdatecmp_a(uchar **buf1, uchar **buf2)
727: {
728: time_t date1,date2;
729:
730: date1=((*buf1)[14]|((long)(*buf1)[15]<<8)|((long)(*buf1)[16]<<16)
731: |((long)(*buf1)[17]<<24));
732: date2=((*buf2)[14]|((long)(*buf2)[15]<<8)|((long)(*buf2)[16]<<16)
733: |((long)(*buf2)[17]<<24));
734: if(date1>date2) return(1);
735: if(date1<date2) return(-1);
736: return(0);
737: }
738:
739: /****************************************************************************/
740: /* Compares file upload dates for descending date sort */
741: /****************************************************************************/
742: int fdatecmp_d(uchar **buf1, uchar **buf2)
743: {
744: time_t date1,date2;
745:
746: date1=((*buf1)[14]|((long)(*buf1)[15]<<8)|((long)(*buf1)[16]<<16)
747: |((long)(*buf1)[17]<<24));
748: date2=((*buf2)[14]|((long)(*buf2)[15]<<8)|((long)(*buf2)[16]<<16)
749: |((long)(*buf2)[17]<<24));
750: if(date1>date2) return(-1);
751: if(date1<date2) return(1);
752: return(0);
753: }
754:
755: /************************************************************************/
756: /* Wait (for a limited period of time) for sequential dev to become */
757: /* available for file retrieval */
758: /************************************************************************/
759: void seqwait(uint devnum)
760: {
761: char loop=0;
762: int i;
763: time_t start;
764: node_t node;
765:
766:
767: if(!devnum)
768: return;
769: for(start=now=time(NULL);online && now-start<90;now=time(NULL)) {
770: if(msgabort()) /* max wait ^^^^ sec */
771: break;
772: getnodedat(node_num,&thisnode,1); /* open and lock this record */
773: for(i=1;i<=sys_nodes;i++) {
774: if(i==node_num) continue;
775: getnodedat(i,&node,1);
776: if((node.status==NODE_INUSE || node.status==NODE_QUIET)
777: && node.action==NODE_RFSD && node.aux==devnum) {
778: putnodedat(i,node);
779: break; }
780: putnodedat(i,node); }
781: if(i>sys_nodes) {
782: thisnode.action=NODE_RFSD;
783: thisnode.aux=devnum;
784: putnodedat(node_num,thisnode); /* write devnum, unlock, and ret */
785: return; }
786: putnodedat(node_num,thisnode);
787: if(!loop)
788: bprintf(text[WaitingForDeviceN],devnum);
789: loop=1;
790: mswait(100); }
791:
792: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.