![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bat_xfer.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / sbbs3|
Return to bat_xfer.cpp CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* bat_xfer.cpp */
2:
3: /* Synchronet batch file transfer functions */
4:
1.1.1.2 ! root 5: /* $Id: bat_xfer.cpp,v 1.34 2011/07/21 11:19:19 rswindell Exp $ */
1.1 root 6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
1.1.1.2 ! root 11: * Copyright 2011 Rob Swindell - http://www.synchro.net/copyright.html *
1.1 root 12: * *
13: * This program is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU General Public License for more details: gpl.txt or *
18: * http://www.fsf.org/copyleft/gpl.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include "sbbs.h"
39:
40: /****************************************************************************/
41: /* This is the batch menu section */
42: /****************************************************************************/
43: void sbbs_t::batchmenu()
44: {
45: char str[129],tmp2[250],done=0,ch;
46: char tmp[512];
47: uint i,n,xfrprot,xfrdir;
48: ulong totalcdt,totalsize,totaltime;
49: time_t start,end;
50: file_t f;
51:
52: if(!batdn_total && !batup_total && cfg.upload_dir==INVALID_DIR) {
53: bputs(text[NoFilesInBatchQueue]);
54: return;
55: }
56: if(useron.misc&(RIP|WIP|HTML) && !(useron.misc&EXPERT))
57: menu("batchxfer");
58: lncntr=0;
59: while(online && !done && (batdn_total || batup_total
60: || cfg.upload_dir!=INVALID_DIR)) {
61: if(!(useron.misc&(EXPERT|RIP|WIP|HTML))) {
62: sys_status&=~SS_ABORT;
63: if(lncntr) {
64: SYNC;
65: CRLF;
66: if(lncntr) /* CRLF or SYNC can cause pause */
67: pause();
68: }
69: menu("batchxfr");
70: }
71: ASYNC;
72: bputs(text[BatchMenuPrompt]);
73: ch=(char)getkeys("BCDLQRU?\r",0);
74: if(ch>' ')
75: logch(ch,0);
76: switch(ch) {
77: case '?':
78: if(useron.misc&(EXPERT|RIP|WIP|HTML))
79: menu("batchxfr");
80: break;
81: case CR:
82: case 'Q':
83: lncntr=0;
84: done=1;
85: break;
86: case 'B': /* Bi-directional transfers */
87: if(useron.rest&FLAG('D')) {
88: bputs(text[R_Download]);
89: break;
90: }
91: if(useron.rest&FLAG('U')) {
92: bputs(text[R_Upload]);
93: break;
94: }
95: if(!batdn_total) {
96: bputs(text[DownloadQueueIsEmpty]);
97: break;
98: }
99: if(!batup_total && cfg.upload_dir==INVALID_DIR) {
100: bputs(text[UploadQueueIsEmpty]);
101: break;
102: }
103: for(i=0,totalcdt=0;i<batdn_total;i++)
1.1.1.2 ! root 104: if(!is_download_free(&cfg,batdn_dir[i],&useron,&client))
1.1 root 105: totalcdt+=batdn_cdt[i];
106: if(totalcdt>useron.cdt+useron.freecdt) {
107: bprintf(text[YouOnlyHaveNCredits]
108: ,ultoac(useron.cdt+useron.freecdt,tmp));
109: break;
110: }
111: for(i=0,totalsize=totaltime=0;i<batdn_total;i++) {
112: totalsize+=batdn_size[i];
113: if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
114: totaltime+=batdn_size[i]/(ulong)cur_cps;
115: }
116: if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft) {
117: bputs(text[NotEnoughTimeToDl]);
118: break;
119: }
120: xfer_prot_menu(XFER_BIDIR);
121: SYNC;
122: mnemonics(text[ProtocolOrQuit]);
123: strcpy(tmp2,"Q");
124: for(i=0;i<cfg.total_prots;i++)
1.1.1.2 ! root 125: if(cfg.prot[i]->bicmd[0] && chk_ar(cfg.prot[i]->ar,&useron,&client)) {
1.1 root 126: sprintf(tmp,"%c",cfg.prot[i]->mnemonic);
1.1.1.2 ! root 127: strcat(tmp2,tmp);
! 128: }
1.1 root 129: ungetkey(useron.prot);
130: ch=(char)getkeys(tmp2,0);
131: if(ch=='Q')
132: break;
133: for(i=0;i<cfg.total_prots;i++)
134: if(cfg.prot[i]->bicmd[0] && cfg.prot[i]->mnemonic==ch
1.1.1.2 ! root 135: && chk_ar(cfg.prot[i]->ar,&useron,&client))
1.1 root 136: break;
137: if(i<cfg.total_prots) {
138: if(!create_batchdn_lst((cfg.prot[i]->misc&PROT_NATIVE) ? true:false))
139: break;
140: if(!create_batchup_lst())
141: break;
142: if(!create_bimodem_pth())
143: break;
144:
145: xfrprot=i;
146: action=NODE_BXFR;
147: SYNC;
148: for(i=0;i<batdn_total;i++)
149: if(cfg.dir[batdn_dir[i]]->seqdev) {
150: lncntr=0;
151: unpadfname(batdn_name[i],tmp);
152: sprintf(tmp2,"%s%s",cfg.temp_dir,tmp);
153: if(!fexistcase(tmp2)) {
154: seqwait(cfg.dir[batdn_dir[i]]->seqdev);
155: bprintf(text[RetrievingFile],tmp);
156: sprintf(str,"%s%s"
157: ,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
158: ? cfg.altpath[batdn_alt[i]-1]
159: : cfg.dir[batdn_dir[i]]->path
160: ,tmp);
161: mv(str,tmp2,1); /* copy the file to temp dir */
162: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
163: thisnode.aux=0xff;
164: putnodedat(cfg.node_num,&thisnode);
165: }
166: CRLF;
167: }
168: }
169: sprintf(str,"%sBATCHDN.LST",cfg.node_dir);
170: sprintf(tmp2,"%sBATCHUP.LST",cfg.node_dir);
171: start=time(NULL);
172: protocol(cfg.prot[xfrprot],XFER_BIDIR,str,tmp2,true);
173: end=time(NULL);
174: for(i=0;i<batdn_total;i++)
175: if(cfg.dir[batdn_dir[i]]->seqdev) {
176: unpadfname(batdn_name[i],tmp);
177: sprintf(tmp2,"%s%s",cfg.temp_dir,tmp);
1.1.1.2 ! root 178: remove(tmp2);
! 179: }
1.1 root 180: batch_upload();
181: batch_download(xfrprot);
182: if(batdn_total) /* files still in queue, not xfered */
183: notdownloaded(totalsize,start,end);
184: autohangup();
185: }
186: break;
187: case 'C':
188: if(batup_total) {
1.1.1.2 ! root 189: if(text[ClearUploadQueueQ][0]==0 || !noyes(text[ClearUploadQueueQ])) {
1.1 root 190: batup_total=0;
191: bputs(text[UploadQueueCleared]);
192: }
193: }
194: if(batdn_total) {
1.1.1.2 ! root 195: if(text[ClearDownloadQueueQ][0]==0 || !noyes(text[ClearDownloadQueueQ])) {
1.1 root 196: for(i=0;i<batdn_total;i++) {
197: f.dir=batdn_dir[i];
198: f.datoffset=batdn_offset[i];
199: f.size=batdn_size[i];
200: strcpy(f.name,batdn_name[i]);
1.1.1.2 ! root 201: closefile(&f);
! 202: }
1.1 root 203: batdn_total=0;
204: bputs(text[DownloadQueueCleared]);
205: }
206: }
207: break;
208: case 'D':
209: start_batch_download();
210: break;
211: case 'L':
212: if(batup_total) {
213: bputs(text[UploadQueueLstHdr]);
214: for(i=0;i<batup_total;i++)
215: bprintf(text[UploadQueueLstFmt],i+1,batup_name[i]
1.1.1.2 ! root 216: ,batup_desc[i]);
! 217: }
1.1 root 218: if(batdn_total) {
219: bputs(text[DownloadQueueLstHdr]);
220: for(i=0,totalcdt=0,totalsize=0;i<batdn_total;i++) {
221: bprintf(text[DownloadQueueLstFmt],i+1
222: ,batdn_name[i],ultoac(batdn_cdt[i],tmp)
223: ,ultoac(batdn_size[i],str)
224: ,cur_cps
225: ? sectostr(batdn_size[i]/(ulong)cur_cps,tmp2)
226: : "??:??:??");
227: totalsize+=batdn_size[i];
1.1.1.2 ! root 228: totalcdt+=batdn_cdt[i];
! 229: }
1.1 root 230: bprintf(text[DownloadQueueTotals]
231: ,ultoac(totalcdt,tmp),ultoac(totalsize,str),cur_cps
232: ? sectostr(totalsize/(ulong)cur_cps,tmp2)
1.1.1.2 ! root 233: : "??:??:??");
! 234: }
1.1 root 235: break; /* Questionable line ^^^, see note above function */
236: case 'R':
237: if(batup_total) {
238: bprintf(text[RemoveWhichFromUlQueue],batup_total);
239: n=getnum(batup_total);
240: if((int)n>=1) {
241: n--;
242: batup_total--;
243: while(n<batup_total) {
244: batup_dir[n]=batup_dir[n+1];
245: batup_misc[n]=batup_misc[n+1];
246: batup_alt[n]=batup_alt[n+1];
247: strcpy(batup_name[n],batup_name[n+1]);
248: strcpy(batup_desc[n],batup_desc[n+1]);
1.1.1.2 ! root 249: n++;
! 250: }
1.1 root 251: if(!batup_total)
252: bputs(text[UploadQueueCleared]);
253: }
254: }
255: if(batdn_total) {
256: bprintf(text[RemoveWhichFromDlQueue],batdn_total);
257: n=getnum(batdn_total);
258: if((int)n>=1) {
259: n--;
260: f.dir=batdn_dir[n];
261: strcpy(f.name,batdn_name[n]);
262: f.datoffset=batdn_offset[n];
263: f.size=batdn_size[n];
264: closefile(&f);
265: batdn_total--;
266: while(n<batdn_total) {
267: strcpy(batdn_name[n],batdn_name[n+1]);
268: batdn_dir[n]=batdn_dir[n+1];
269: batdn_cdt[n]=batdn_cdt[n+1];
270: batdn_alt[n]=batdn_alt[n+1];
271: batdn_size[n]=batdn_size[n+1];
272: batdn_offset[n]=batdn_offset[n+1];
273: n++;
274: }
275: if(!batdn_total)
276: bputs(text[DownloadQueueCleared]);
277: }
278: }
279: break;
280: case 'U':
281: if(useron.rest&FLAG('U')) {
282: bputs(text[R_Upload]);
283: break;
284: }
285: if(!batup_total && cfg.upload_dir==INVALID_DIR) {
286: bputs(text[UploadQueueIsEmpty]);
287: break;
288: }
289: xfer_prot_menu(XFER_BATCH_UPLOAD);
290: if(!create_batchup_lst())
291: break;
292: if(!create_bimodem_pth())
293: break;
294: ASYNC;
295: mnemonics(text[ProtocolOrQuit]);
296: strcpy(str,"Q");
297: for(i=0;i<cfg.total_prots;i++)
1.1.1.2 ! root 298: if(cfg.prot[i]->batulcmd[0] && chk_ar(cfg.prot[i]->ar,&useron,&client)) {
1.1 root 299: sprintf(tmp,"%c",cfg.prot[i]->mnemonic);
300: strcat(str,tmp);
301: }
302: ch=(char)getkeys(str,0);
303: if(ch=='Q')
304: break;
305: for(i=0;i<cfg.total_prots;i++)
306: if(cfg.prot[i]->batulcmd[0] && cfg.prot[i]->mnemonic==ch
1.1.1.2 ! root 307: && chk_ar(cfg.prot[i]->ar,&useron,&client))
1.1 root 308: break;
309: if(i<cfg.total_prots) {
310: sprintf(str,"%sBATCHUP.LST",cfg.node_dir);
311: xfrprot=i;
312: if(batup_total)
313: xfrdir=batup_dir[0];
314: else
315: xfrdir=cfg.upload_dir;
316: action=NODE_ULNG;
317: SYNC;
318: if(online==ON_REMOTE) {
319: delfiles(cfg.temp_dir,ALLFILES);
320: start=time(NULL);
321: protocol(cfg.prot[xfrprot],XFER_BATCH_UPLOAD,str,nulstr,true);
322: end=time(NULL);
323: if(!(cfg.dir[xfrdir]->misc&DIR_ULTIME))
324: starttime+=end-start;
325: }
326: batch_upload();
327: delfiles(cfg.temp_dir,ALLFILES);
328: autohangup();
329: }
330: break;
331: }
332: }
333: delfiles(cfg.temp_dir,ALLFILES);
334: }
335:
336: /****************************************************************************/
337: /* Download files from batch queue */
338: /****************************************************************************/
339: BOOL sbbs_t::start_batch_download()
340: {
341: char ch;
342: char tmp[32];
343: char fname[64];
344: char str[MAX_PATH+1];
345: char path[MAX_PATH+1];
346: char* list;
347: size_t list_len;
348: int error;
349: int j;
350: uint i,xfrprot;
351: ulong totalcdt,totalsize,totaltime;
352: time_t start,end,t;
353: struct tm tm;
354:
355: if(batdn_total==0) {
356: bputs(text[DownloadQueueIsEmpty]);
357: return(FALSE);
358: }
359: if(useron.rest&FLAG('D')) { /* Download restriction */
360: bputs(text[R_Download]);
361: return(FALSE);
362: }
363: for(i=0,totalcdt=0;i<batdn_total;i++)
1.1.1.2 ! root 364: if(is_download_free(&cfg,batdn_dir[i],&useron,&client))
1.1 root 365: totalcdt+=batdn_cdt[i];
366: if(totalcdt>useron.cdt+useron.freecdt) {
367: bprintf(text[YouOnlyHaveNCredits]
368: ,ultoac(useron.cdt+useron.freecdt,tmp));
369: return(FALSE);
370: }
371:
372: for(i=0,totalsize=totaltime=0;i<batdn_total;i++) {
373: totalsize+=batdn_size[i];
374: if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
375: totaltime+=batdn_size[i]/(ulong)cur_cps;
376: }
377: if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft) {
378: bputs(text[NotEnoughTimeToDl]);
379: return(FALSE);
380: }
381: xfer_prot_menu(XFER_BATCH_DOWNLOAD);
382: ASYNC;
383: mnemonics(text[ProtocolOrQuit]);
384: strcpy(str,"Q");
385: for(i=0;i<cfg.total_prots;i++)
1.1.1.2 ! root 386: if(cfg.prot[i]->batdlcmd[0] && chk_ar(cfg.prot[i]->ar,&useron,&client)) {
1.1 root 387: sprintf(tmp,"%c",cfg.prot[i]->mnemonic);
388: strcat(str,tmp);
389: }
390: ungetkey(useron.prot);
391: ch=(char)getkeys(str,0);
392: if(ch=='Q' || sys_status&SS_ABORT)
393: return(FALSE);
394: for(i=0;i<cfg.total_prots;i++)
395: if(cfg.prot[i]->batdlcmd[0] && cfg.prot[i]->mnemonic==ch
1.1.1.2 ! root 396: && chk_ar(cfg.prot[i]->ar,&useron,&client))
1.1 root 397: break;
398: if(i>=cfg.total_prots)
399: return(FALSE); /* no protocol selected */
400:
401: if(!create_batchdn_lst((cfg.prot[i]->misc&PROT_NATIVE) ? true:false))
402: return(FALSE);
403: if(!create_bimodem_pth())
404: return(FALSE);
405:
406: xfrprot=i;
407: list=NULL;
408: for(i=0;i<batdn_total;i++) {
409: curdirnum=batdn_dir[i]; /* for ARS */
410: unpadfname(batdn_name[i],fname);
411: if(cfg.dir[batdn_dir[i]]->seqdev) {
412: lncntr=0;
413: sprintf(path,"%s%s",cfg.temp_dir,fname);
414: if(!fexistcase(path)) {
415: seqwait(cfg.dir[batdn_dir[i]]->seqdev);
416: bprintf(text[RetrievingFile],fname);
417: sprintf(str,"%s%s"
418: ,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
419: ? cfg.altpath[batdn_alt[i]-1]
420: : cfg.dir[batdn_dir[i]]->path
421: ,fname);
422: mv(str,path,1); /* copy the file to temp dir */
423: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
424: thisnode.aux=40; /* clear the seq dev # */
425: putnodedat(cfg.node_num,&thisnode);
426: }
427: CRLF;
428: }
429: }
430: else
431: sprintf(path,"%s%s"
432: ,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
433: ? cfg.altpath[batdn_alt[i]-1]
434: : cfg.dir[batdn_dir[i]]->path
435: ,fname);
436: if(list==NULL)
437: list_len=0;
438: else
439: list_len=strlen(list)+1; /* add one for ' ' */
440: if((list=(char*)realloc(list,list_len+strlen(path)+1 /* add one for '\0'*/))==NULL) {
441: errormsg(WHERE,ERR_ALLOC,"list",list_len+strlen(path));
442: return(FALSE);
443: }
444: if(!list_len)
445: strcpy(list,path);
446: else {
447: strcat(list," ");
448: strcat(list,path);
449: }
450: for(j=0;j<cfg.total_dlevents;j++) {
451: if(stricmp(cfg.dlevent[j]->ext,batdn_name[i]+9))
452: continue;
1.1.1.2 ! root 453: if(!chk_ar(cfg.dlevent[j]->ar,&useron,&client))
1.1 root 454: continue;
455: bputs(cfg.dlevent[j]->workstr);
456: external(cmdstr(cfg.dlevent[j]->cmd,path,nulstr,NULL),EX_OUTL);
457: CRLF;
458: }
459: }
460:
461: sprintf(str,"%sBATCHDN.LST",cfg.node_dir);
462: action=NODE_DLNG;
463: t=now;
464: if(cur_cps)
465: t+=(totalsize/(ulong)cur_cps);
466: localtime_r(&t,&tm);
467: if(getnodedat(cfg.node_num,&thisnode,true)==0) {
468: thisnode.aux=(tm.tm_hour*60)+tm.tm_min;
469: thisnode.action=action;
470: putnodedat(cfg.node_num,&thisnode); /* calculate ETA */
471: }
472: start=time(NULL);
473: error=protocol(cfg.prot[xfrprot],XFER_BATCH_DOWNLOAD,str,list,false);
474: end=time(NULL);
475: if(cfg.prot[xfrprot]->misc&PROT_DSZLOG || !error)
476: batch_download(xfrprot);
477: if(batdn_total)
478: notdownloaded(totalsize,start,end);
479: autohangup();
480: if(list!=NULL)
481: free(list);
482:
483: return(TRUE);
484: }
485:
486: /****************************************************************************/
487: /* Creates the file BATCHDN.LST in the node directory. Returns true if */
488: /* everything goes okay, false if not. */
489: /****************************************************************************/
490: bool sbbs_t::create_batchdn_lst(bool native)
491: {
492: char path[MAX_PATH+1];
493: char fname[MAX_PATH+1];
494: int file;
495: uint i;
496:
497: sprintf(path,"%sBATCHDN.LST",cfg.node_dir);
498: if((file=nopen(path,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
499: errormsg(WHERE,ERR_OPEN,path,O_WRONLY|O_CREAT|O_TRUNC);
500: return(false);
501: }
502: for(i=0;i<batdn_total;i++) {
503: if(batdn_dir[i]>=cfg.total_dirs || cfg.dir[batdn_dir[i]]->seqdev)
504: SAFECOPY(path,cfg.temp_dir);
505: else
506: SAFECOPY(path,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
507: ? cfg.altpath[batdn_alt[i]-1] : cfg.dir[batdn_dir[i]]->path);
508:
509: unpadfname(batdn_name[i],fname);
510: strcat(path,fname);
511: if(native)
512: fexistcase(path);
513: strcat(path,crlf);
514: write(file,path,strlen(path));
515: }
516: close(file);
517: return(true);
518: }
519:
520: /****************************************************************************/
521: /* Creates the file BATCHUP.LST in the node directory. Returns true if */
522: /* everything goes okay, false if not. */
523: /* This list is not used by any protocols to date. */
524: /****************************************************************************/
525: bool sbbs_t::create_batchup_lst()
526: {
527: char str[256];
528: int file;
529: uint i;
530:
531: sprintf(str,"%sBATCHUP.LST",cfg.node_dir);
532: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
533: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
534: return(false);
535: }
536: for(i=0;i<batup_total;i++) {
537: if(batup_dir[i]>=cfg.total_dirs)
538: strcpy(str,cfg.temp_dir);
539: else
540: strcpy(str,batup_alt[i]>0 && batup_alt[i]<=cfg.altpaths
541: ? cfg.altpath[batup_alt[i]-1] : cfg.dir[batup_dir[i]]->path);
542: write(file,str,strlen(str));
543: unpadfname(batup_name[i],str);
544: strcat(str,crlf);
545: write(file,str,strlen(str));
546: }
547: close(file);
548: return(true);
549: }
550:
551: /****************************************************************************/
552: /* Creates the file BIMODEM.PTH in the node directory. Returns true if */
553: /* everything goes okay, false if not. */
554: /****************************************************************************/
555: bool sbbs_t::create_bimodem_pth()
556: {
557: char str[256],tmp2[512];
558: char tmp[512];
559: int file;
560: uint i;
561:
562: sprintf(str,"%sBIMODEM.PTH",cfg.node_dir); /* Create bimodem file */
563: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
564: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
565: return(false);
566: }
567: for(i=0;i<batup_total;i++) {
568: sprintf(str,"%s%s",batup_dir[i]>=cfg.total_dirs ? cfg.temp_dir
569: : batup_alt[i]>0 && batup_alt[i]<=cfg.altpaths
570: ? cfg.altpath[batup_alt[i]-1] : cfg.dir[batup_dir[i]]->path
571: ,unpadfname(batup_name[i],tmp));
572: sprintf(tmp2,"D %-80.80s%-160.160s"
573: ,unpadfname(batup_name[i],tmp),str);
574: write(file,tmp2,248);
575: }
576: for(i=0;i<batdn_total;i++) {
577: sprintf(str,"%s%s"
578: ,(batdn_dir[i]>=cfg.total_dirs || cfg.dir[batdn_dir[i]]->seqdev)
579: ? cfg.temp_dir : batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
580: ? cfg.altpath[batdn_alt[i]-1] : cfg.dir[batdn_dir[i]]->path
581: ,unpadfname(batdn_name[i],tmp));
582: sprintf(tmp2,"U %-240.240s",str);
583: write(file,tmp2,248);
584: }
585: close(file);
586: return(true);
587: }
588:
589: /****************************************************************************/
590: /* Processes files that were supposed to be received in the batch queue */
591: /****************************************************************************/
592: void sbbs_t::batch_upload()
593: {
594: char str1[MAX_PATH+1],str2[MAX_PATH+1];
595: char path[MAX_PATH+1];
596: char tmp[MAX_PATH+1];
597: uint i,j,x,y;
598: file_t f;
599: DIR* dir;
600: DIRENT* dirent;
601:
602: for(i=0;i<batup_total;) {
603: curdirnum=batup_dir[i]; /* for ARS */
604: lncntr=0; /* defeat pause */
605: unpadfname(batup_name[i],tmp);
606: sprintf(str1,"%s%s",cfg.temp_dir,tmp);
607: sprintf(str2,"%s%s",cfg.dir[batup_dir[i]]->path,tmp);
608: if(fexistcase(str1) && fexistcase(str2)) { /* file's in two places */
609: bprintf(text[FileAlreadyThere],batup_name[i]);
610: remove(str1); /* this is the one received */
611: i++;
612: continue;
613: }
614: if(fexist(str1))
615: mv(str1,str2,0);
616: strcpy(f.name,batup_name[i]);
617: strcpy(f.desc,batup_desc[i]);
618: f.dir=batup_dir[i];
619: f.misc=batup_misc[i];
620: f.altpath=batup_alt[i];
621: if(uploadfile(&f)) {
622: batup_total--;
623: for(j=i;j<batup_total;j++) {
624: batup_dir[j]=batup_dir[j+1];
625: batup_alt[j]=batup_alt[j+1];
626: batup_misc[j]=batup_misc[j+1];
627: strcpy(batup_name[j],batup_name[j+1]);
628: strcpy(batup_desc[j],batup_desc[j+1]);
629: }
630: }
631: else i++;
632: }
633: if(cfg.upload_dir==INVALID_DIR)
634: return;
635: dir=opendir(cfg.temp_dir);
636: while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
637: sprintf(str1,"%s%s",cfg.temp_dir,dirent->d_name);
638: if(isdir(str1))
639: continue;
640: memset(&f,0,sizeof(file_t));
641: f.dir=cfg.upload_dir;
642:
643: SAFECOPY(path,str1);
644: #ifdef _WIN32
645: GetShortPathName(str1, path, sizeof(path));
646: #endif
647: padfname(getfname(path),f.name);
648:
649: for(x=0;x<usrlibs;x++) {
650: for(y=0;y<usrdirs[x];y++)
651: if(cfg.dir[usrdir[x][y]]->misc&DIR_DUPES
652: && findfile(&cfg,usrdir[x][y],f.name))
653: break;
654: if(y<usrdirs[x])
655: break;
656: }
657: sprintf(str2,"%s%s",cfg.dir[f.dir]->path,dirent->d_name);
658: if(x<usrlibs || fexistcase(str2)) {
659: bprintf(text[FileAlreadyOnline],f.name);
660: remove(str1);
661: } else {
662: mv(str1,str2,0);
663: uploadfile(&f);
664: }
665: }
666: if(dir!=NULL)
667: closedir(dir);
668: }
669:
670: /****************************************************************************/
671: /* Processes files that were supposed to be sent from the batch queue */
672: /* xfrprot is -1 if downloading files from within QWK (no DSZLOG) */
673: /****************************************************************************/
674: void sbbs_t::batch_download(int xfrprot)
675: {
676: uint i,j;
677: file_t f;
678:
679: for(i=0;i<batdn_total;) {
680: lncntr=0; /* defeat pause */
681: f.dir=curdirnum=batdn_dir[i];
682: strcpy(f.name,batdn_name[i]);
683: f.datoffset=batdn_offset[i];
684: f.size=batdn_size[i];
685: f.altpath=batdn_alt[i];
686: if(xfrprot==-1 || checkprotresult(cfg.prot[xfrprot],0,&f)) {
687: if(cfg.dir[f.dir]->misc&DIR_TFREE && cur_cps)
688: starttime+=f.size/(ulong)cur_cps;
689: downloadfile(&f);
690: closefile(&f);
691: batdn_total--;
692: for(j=i;j<batdn_total;j++) {
693: strcpy(batdn_name[j],batdn_name[j+1]);
694: batdn_dir[j]=batdn_dir[j+1];
695: batdn_cdt[j]=batdn_cdt[j+1];
696: batdn_alt[j]=batdn_alt[j+1];
697: batdn_size[j]=batdn_size[j+1];
698: batdn_offset[j]=batdn_offset[j+1];
699: }
700: }
701: else i++;
702: }
703: }
704:
705: /****************************************************************************/
706: /* Adds a list of files to the batch download queue */
707: /****************************************************************************/
708: void sbbs_t::batch_add_list(char *list)
709: {
710: char str[128];
711: int file;
712: uint i,j,k;
713: FILE * stream;
714: file_t f;
715:
716: if((stream=fnopen(&file,list,O_RDONLY))!=NULL) {
717: bputs(text[SearchingAllLibs]);
718: while(!feof(stream)) {
719: checkline();
720: if(!online)
721: break;
722: if(!fgets(str,127,stream))
723: break;
724: truncsp(str);
725: sprintf(f.name,"%.12s",str);
726: lncntr=0;
727: for(i=j=k=0;i<usrlibs;i++) {
728: for(j=0;j<usrdirs[i];j++,k++) {
729: outchar('.');
730: if(k && !(k%5))
731: bputs("\b\b\b\b\b \b\b\b\b\b");
732: if(findfile(&cfg,usrdir[i][j],f.name))
733: break;
734: }
735: if(j<usrdirs[i])
736: break;
737: }
738: if(i<usrlibs) {
739: f.dir=usrdir[i][j];
740: getfileixb(&cfg,&f);
741: f.size=0;
742: getfiledat(&cfg,&f);
743: if(f.size==-1L)
744: bprintf(text[FileIsNotOnline],f.name);
745: else
746: addtobatdl(&f);
747: }
748: }
749: fclose(stream);
750: remove(list);
751: CRLF;
752: }
753: }
754: /****************************************************************************/
755: void sbbs_t::batch_create_list()
756: {
757: char str[MAX_PATH+1];
758: int i;
759: FILE* stream;
760:
761: if(batdn_total) {
762: sprintf(str,"%sfile/%04u.dwn",cfg.data_dir,useron.number);
763: if((stream=fnopen(NULL,str,O_WRONLY|O_TRUNC|O_CREAT))!=NULL) {
764: for(i=0;i<(int)batdn_total;i++)
765: fprintf(stream,"%s\r\n",batdn_name[i]);
766: fclose(stream);
767: }
768: }
769: }
770:
771: /**************************************************************************/
772: /* Add file 'f' to batch download queue. Return 1 if successful, 0 if not */
773: /**************************************************************************/
774: bool sbbs_t::addtobatdl(file_t* f)
775: {
776: char str[256],tmp2[256];
777: char tmp[512];
778: uint i;
779: ulong totalcdt, totalsize, totaltime;
780:
781: if(useron.rest&FLAG('D')) {
782: bputs(text[R_Download]);
783: return(false);
784: }
785: for(i=0;i<batdn_total;i++) {
786: if(!strcmp(batdn_name[i],f->name) && f->dir==batdn_dir[i]) {
787: bprintf(text[FileAlreadyInQueue],f->name);
788: return(false);
789: }
790: }
791: if(f->size<=0 /* !fexist(str) */) {
792: bprintf(text[CantAddToQueue],f->name);
1.1.1.2 ! root 793: bprintf(text[FileIsNotOnline],f->name);
1.1 root 794: return(false);
795: }
796: if(batdn_total>=cfg.max_batdn) {
797: bprintf(text[CantAddToQueue],f->name);
798: bputs(text[BatchDlQueueIsFull]);
799: return(false);
800: }
801: for(i=0,totalcdt=0;i<batdn_total;i++)
1.1.1.2 ! root 802: if(!is_download_free(&cfg,batdn_dir[i],&useron,&client))
1.1 root 803: totalcdt+=batdn_cdt[i];
804: if(cfg.dir[f->dir]->misc&DIR_FREE) f->cdt=0L;
1.1.1.2 ! root 805: if(!is_download_free(&cfg,f->dir,&useron,&client))
1.1 root 806: totalcdt+=f->cdt;
807: if(totalcdt>useron.cdt+useron.freecdt) {
808: bprintf(text[CantAddToQueue],f->name);
809: bprintf(text[YouOnlyHaveNCredits],ultoac(useron.cdt+useron.freecdt,tmp));
810: return(false);
811: }
1.1.1.2 ! root 812: if(!chk_ar(cfg.dir[f->dir]->dl_ar,&useron,&client)) {
1.1 root 813: bprintf(text[CantAddToQueue],f->name);
814: bputs(text[CantDownloadFromDir]);
815: return(false);
816: }
817: for(i=0,totalsize=totaltime=0;i<batdn_total;i++) {
818: totalsize+=batdn_size[i];
819: if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
820: totaltime+=batdn_size[i]/(ulong)cur_cps;
821: }
822: totalsize+=f->size;
823: if(!(cfg.dir[f->dir]->misc&DIR_TFREE) && cur_cps)
824: totaltime+=f->size/(ulong)cur_cps;
825: if(!(useron.exempt&FLAG('T')) && totaltime>timeleft) {
826: bprintf(text[CantAddToQueue],f->name);
827: bputs(text[NotEnoughTimeToDl]);
828: return(false);
829: }
830: strcpy(batdn_name[batdn_total],f->name);
831: batdn_dir[batdn_total]=f->dir;
832: batdn_cdt[batdn_total]=f->cdt;
833: batdn_offset[batdn_total]=f->datoffset;
834: batdn_size[batdn_total]=f->size;
835: batdn_alt[batdn_total]=f->altpath;
836: batdn_total++;
837: openfile(f);
838: bprintf(text[FileAddedToBatDlQueue]
839: ,f->name,batdn_total,cfg.max_batdn,ultoac(totalcdt,tmp)
840: ,ultoac(totalsize,tmp2)
841: ,sectostr(totalsize/(ulong)cur_cps,str));
842: return(true);
843: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.