![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to upload.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 upload.cpp CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* upload.cpp */
2:
3: /* Synchronet file upload-related routines */
4:
5: /* $Id: upload.cpp,v 1.48 2006/10/27 00:39:45 rswindell Exp $ */
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: * *
11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html *
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: /* Adds file data in 'f' to DIR#.DAT and DIR#.IXB and updates user */
42: /* info for uploader. Must have .name, .desc and .dir fields filled prior */
43: /* to a call to this function. */
44: /* Returns 1 if file uploaded sucessfully, 0 if not. */
45: /****************************************************************************/
46: bool sbbs_t::uploadfile(file_t *f)
47: {
48: char path[MAX_PATH+1];
49: char str[MAX_PATH+1],fname[25];
50: char ext[F_EXBSIZE+1];
51: char desc[F_EXBSIZE+1];
52: char tmp[MAX_PATH+1];
53: int file;
54: uint i;
55: long length;
56: FILE* stream;
57:
58: // f->misc=0; Removed AUG-22-2001 - broken anonymous uploads
59: curdirnum=f->dir;
60: if(findfile(&cfg,f->dir,f->name)) {
61: errormsg(WHERE,ERR_CHK,f->name,f->dir);
62: return(0);
63: }
64: sprintf(path,"%s%s",f->altpath>0 && f->altpath<=cfg.altpaths
65: ? cfg.altpath[f->altpath-1]
66: : cfg.dir[f->dir]->path,unpadfname(f->name,fname));
67: sprintf(tmp,"%s%s",cfg.temp_dir,fname);
68: if(!fexistcase(path) && fexistcase(tmp))
69: mv(tmp,path,0);
70: if(!fexistcase(path)) {
71: bprintf(text[FileNotReceived],f->name);
72: sprintf(str,"%s attempted to upload %s to %s %s (Not received)"
73: ,useron.alias
74: ,f->name
75: ,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname);
76: logline("U!",str);
77: return(0);
78: }
79: strcpy(tmp,f->name);
80: truncsp(tmp);
81: for(i=0;i<cfg.total_ftests;i++)
82: if(cfg.ftest[i]->ext[0]=='*' || !stricmp(tmp+9,cfg.ftest[i]->ext)) {
83: if(!chk_ar(cfg.ftest[i]->ar,&useron))
84: continue;
85: attr(LIGHTGRAY);
86: bputs(cfg.ftest[i]->workstr);
87:
88: sprintf(sbbsfilename,"SBBSFILENAME=%.64s",unpadfname(f->name,fname));
89: putenv(sbbsfilename);
90: sprintf(sbbsfiledesc,"SBBSFILEDESC=%.*s",LEN_FDESC,f->desc);
91: putenv(sbbsfiledesc);
92: sprintf(str,"%ssbbsfile.nam",cfg.node_dir);
93: if((stream=fopen(str,"w"))!=NULL) {
94: fwrite(fname,1,strlen(fname),stream);
95: fclose(stream);
96: }
97: sprintf(str,"%ssbbsfile.des",cfg.node_dir);
98: if((stream=fopen(str,"w"))!=NULL) {
99: fwrite(f->desc,1,strlen(f->desc),stream);
100: fclose(stream);
101: }
102: if(external(cmdstr(cfg.ftest[i]->cmd,path,f->desc,NULL),EX_OFFLINE)) {
103: sprintf(str,"%s attempted to upload %s to %s %s (%s Errors)"
104: ,useron.alias
105: ,f->name
106: ,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname,cfg.ftest[i]->ext);
107: logline("U!",str);
108: #if 0
109: sprintf(str,"Failed test: %s", cmdstr(cfg.ftest[i]->cmd,path,f->desc,NULL));
110: logline(" ",str);
111: #endif
112: bprintf(text[FileHadErrors],f->name,cfg.ftest[i]->ext);
113: if(!SYSOP || yesno(text[DeleteFileQ]))
114: remove(path);
115: return(0);
116: } else {
117: sprintf(str,"%ssbbsfile.nam",cfg.node_dir);
118: if((stream=fopen(str,"r"))!=NULL) {
119: if(fgets(str,128,stream)) {
120: truncsp(str);
121: padfname(str,f->name);
122: strcpy(tmp,f->name);
123: truncsp(tmp);
124: sprintf(path,"%s%s",f->altpath>0 && f->altpath<=cfg.altpaths
125: ? cfg.altpath[f->altpath-1] : cfg.dir[f->dir]->path
126: ,unpadfname(f->name,fname));
127: }
128: fclose(stream);
129: }
130: sprintf(str,"%ssbbsfile.des",cfg.node_dir);
131: if((stream=fopen(str,"r"))!=NULL) {
132: if(fgets(str,128,stream)) {
133: truncsp(str);
134: sprintf(f->desc,"%.*s",LEN_FDESC,str);
135: }
136: fclose(stream);
137: }
138: CRLF;
139: }
140: }
141:
142: if((length=flength(path))<=0L) {
143: bprintf(text[FileZeroLength],f->name);
144: remove(path);
145: sprintf(str,"%s attempted to upload %s to %s %s (Zero length)"
146: ,useron.alias
147: ,f->name
148: ,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname);
149: logline("U!",str);
150: return(0);
151: }
152: if(cfg.dir[f->dir]->misc&DIR_DIZ) {
153: for(i=0;i<cfg.total_fextrs;i++)
154: if(!stricmp(cfg.fextr[i]->ext,tmp+9) && chk_ar(cfg.fextr[i]->ar,&useron))
155: break;
156: if(i<cfg.total_fextrs) {
157: sprintf(str,"%sFILE_ID.DIZ",cfg.temp_dir);
158: if(fexistcase(str))
159: remove(str);
160: external(cmdstr(cfg.fextr[i]->cmd,path,"FILE_ID.DIZ",NULL),EX_OFFLINE);
161: if(!fexistcase(str)) {
162: sprintf(str,"%sDESC.SDI",cfg.temp_dir);
163: if(fexistcase(str))
164: remove(str);
165: external(cmdstr(cfg.fextr[i]->cmd,path,"DESC.SDI",NULL),EX_OFFLINE);
166: fexistcase(str);
167: }
168: if((file=nopen(str,O_RDONLY))!=-1) {
169: memset(ext,0,F_EXBSIZE+1);
170: read(file,ext,F_EXBSIZE);
171: for(i=F_EXBSIZE;i;i--)
172: if(ext[i-1]>' ')
173: break;
174: ext[i]=0;
175: if(!f->desc[0]) {
176: strcpy(desc,ext);
177: strip_exascii(desc);
178: prep_file_desc(desc);
179: for(i=0;desc[i];i++)
180: if(isalnum(desc[i]))
181: break;
182: sprintf(f->desc,"%.*s",LEN_FDESC,desc+i);
183: }
184: close(file);
185: remove(str);
186: f->misc|=FM_EXTDESC;
187: }
188: }
189: }
190:
191: if(!(cfg.dir[f->dir]->misc&DIR_NOSTAT)) {
192: logon_ulb+=length; /* Update 'this call' stats */
193: logon_uls++;
194: }
195: if(cfg.dir[f->dir]->misc&DIR_AONLY) /* Forced anonymous */
196: f->misc|=FM_ANON;
197: f->cdt=length;
198: f->dateuled=time(NULL);
199: f->timesdled=0;
200: f->datedled=0L;
201: f->opencount=0;
202: strcpy(f->uler,useron.alias);
203: bprintf(text[FileNBytesReceived],f->name,ultoac(length,tmp));
204: if(!f->desc[0]) {
205: if(stricmp(f->name,getfname(path)))
206: SAFECOPY(f->desc,getfname(path));
207: else
208: sprintf(f->desc,"%.*s",LEN_FDESC,text[NoDescription]);
209: }
210: if(!addfiledat(&cfg,f))
211: return(0);
212:
213: if(f->misc&FM_EXTDESC)
214: putextdesc(&cfg,f->dir,f->datoffset,ext);
215:
216: sprintf(str,"%s uploaded %s to %s %s"
217: ,useron.alias
218: ,f->name,cfg.lib[cfg.dir[f->dir]->lib]->sname
219: ,cfg.dir[f->dir]->sname);
220: if(cfg.dir[f->dir]->upload_sem[0])
221: ftouch(cmdstr(cfg.dir[f->dir]->upload_sem,nulstr,nulstr,NULL));
222: logline("U+",str);
223: /**************************/
224: /* Update Uploader's Info */
225: /**************************/
226: user_uploaded(&cfg, &useron, 1, length);
227: if(cfg.dir[f->dir]->up_pct && cfg.dir[f->dir]->misc&DIR_CDTUL) { /* credit for upload */
228: if(cfg.dir[f->dir]->misc&DIR_CDTMIN && cur_cps) /* Give min instead of cdt */
229: useron.min=adjustuserrec(&cfg,useron.number,U_MIN,10
230: ,((ulong)(length*(cfg.dir[f->dir]->up_pct/100.0))/cur_cps)/60);
231: else
232: useron.cdt=adjustuserrec(&cfg,useron.number,U_CDT,10
233: ,(ulong)(f->cdt*(cfg.dir[f->dir]->up_pct/100.0)));
234: }
235:
236: user_event(EVENT_UPLOAD);
237:
238: return(true);
239: }
240:
241: /****************************************************************************/
242: /* Uploads files */
243: /****************************************************************************/
244: bool sbbs_t::upload(uint dirnum)
245: {
246: char descbeg[25]={""},descend[25]={""}
247: ,fname[13],keys[256],ch,*p;
248: char str[MAX_PATH+1];
249: char path[MAX_PATH+1];
250: char spath[MAX_PATH+1];
251: char tmp[512];
252: time_t start,end;
253: uint i,j,k,destuser[MAX_USERXFER],destusers=0;
254: int file;
255: ulong space;
256: file_t f;
257: user_t user;
258: node_t node;
259:
260: /* Security Checks */
261: if(useron.rest&FLAG('U')) {
262: bputs(text[R_Upload]);
263: return(false);
264: }
265: if(dirnum==INVALID_DIR) {
266: bputs(text[CantUploadHere]);
267: return(false);
268: }
269: if(!chk_ar(cfg.dir[dirnum]->ul_ar,&useron)) {
270: bputs(dirnum==cfg.user_dir ? text[CantUploadToUser] :
271: dirnum==cfg.sysop_dir ? text[CantUploadToSysop] : text[CantUploadHere]);
272: return(false);
273: }
274: if(getfiles(&cfg,dirnum)>=cfg.dir[dirnum]->maxfiles) {
275: bputs(dirnum==cfg.user_dir ? text[UserDirFull] : text[DirFull]);
276: return(false);
277: }
278:
279: if(sys_status&SS_EVENT && online==ON_REMOTE && !dir_op(dirnum))
280: bprintf(text[UploadBeforeEvent],timeleft/60);
281: if(altul)
282: strcpy(path,cfg.altpath[altul-1]);
283: else
284: strcpy(path,cfg.dir[dirnum]->path);
285:
286:
287: /* get free disk space */
288: space=getfreediskspace(path,1024);
289: if(space<(ulong)cfg.min_dspace) {
290: bputs(text[LowDiskSpace]);
291: sprintf(str,"Diskspace is low: %s (%lu kilobytes)",path,space);
292: errorlog(str);
293: if(!dir_op(dirnum))
294: return(false);
295: }
296: bprintf(text[DiskNBytesFree],ultoac(space,tmp));
297:
298: f.dir=curdirnum=dirnum;
299: f.misc=0;
300: f.altpath=altul;
301: bputs(text[Filename]);
302: if(!getstr(fname,12,0) || strchr(fname,'?') || strchr(fname,'*')
303: || !checkfname(fname) || (trashcan(fname,"file") && !dir_op(dirnum))) {
304: if(fname[0])
305: bputs(text[BadFilename]);
306: return(false);
307: }
308: if(dirnum==cfg.sysop_dir)
309: sprintf(str,text[UploadToSysopDirQ],fname);
310: else if(dirnum==cfg.user_dir)
311: sprintf(str,text[UploadToUserDirQ],fname);
312: else
313: sprintf(str,text[UploadToCurDirQ],fname,cfg.lib[cfg.dir[dirnum]->lib]->sname
314: ,cfg.dir[dirnum]->sname);
315: if(!yesno(str)) return(false);
316: action=NODE_ULNG;
317: sprintf(str,"%s%s",path,fname);
318: if(fexistcase(str)) { /* File is on disk */
319: #ifdef _WIN32
320: GetShortPathName(str, spath, sizeof(spath));
321: #else
322: SAFECOPY(spath,str);
323: #endif
324: SAFECOPY(fname,getfname(spath));
325: if(!dir_op(dirnum) && online!=ON_LOCAL) { /* local users or sysops */
326: bprintf(text[FileAlreadyThere],fname);
327: return(false);
328: }
329: if(!yesno(text[FileOnDiskAddQ]))
330: return(false);
331: }
332: padfname(fname,f.name);
333: strcpy(str,cfg.dir[dirnum]->exts);
334: strcpy(tmp,f.name);
335: truncsp(tmp);
336: j=strlen(str);
337: for(i=0;i<j;i+=ch+1) { /* Check extension of upload with allowable exts */
338: p=strchr(str+i,',');
339: if(p!=NULL)
340: *p=0;
341: ch=strlen(str+i);
342: if(!stricmp(tmp+9,str+i))
343: break;
344: }
345: if(j && i>=j) {
346: bputs(text[TheseFileExtsOnly]);
347: bputs(cfg.dir[dirnum]->exts);
348: CRLF;
349: if(!dir_op(dirnum)) return(false);
350: }
351: bputs(text[SearchingForDupes]);
352: if(findfile(&cfg,dirnum,f.name)) {
353: bputs(text[SearchedForDupes]);
354: bprintf(text[FileAlreadyOnline],fname);
355: return(false); /* File is already in database */
356: }
357: for(i=k=0;i<usrlibs;i++) {
358: for(j=0;j<usrdirs[i];j++,k++) {
359: outchar('.');
360: if(k && !(k%5))
361: bputs("\b\b\b\b\b \b\b\b\b\b");
362: if(usrdir[i][j]==dirnum)
363: continue; /* we already checked this dir */
364: if(cfg.dir[usrdir[i][j]]->misc&DIR_DUPES
365: && findfile(&cfg,usrdir[i][j],f.name)) {
366: bputs(text[SearchedForDupes]);
367: bprintf(text[FileAlreadyOnline],fname);
368: if(!dir_op(dirnum))
369: return(false); /* File is in database for another dir */
370: }
371: }
372: }
373: bputs(text[SearchedForDupes]);
374: if(dirnum==cfg.user_dir) { /* User to User transfer */
375: bputs(text[EnterAfterLastDestUser]);
376: while((!dir_op(dirnum) && destusers<cfg.max_userxfer) || destusers<MAX_USERXFER) {
377: bputs(text[SendFileToUser]);
378: if(!getstr(str,LEN_ALIAS,cfg.uq&UQ_NOUPRLWR ? K_NONE:K_UPRLWR))
379: break;
380: if((user.number=finduser(str))!=0) {
381: if(!dir_op(dirnum) && user.number==useron.number) {
382: bputs(text[CantSendYourselfFiles]);
383: continue;
384: }
385: for(i=0;i<destusers;i++)
386: if(user.number==destuser[i])
387: break;
388: if(i<destusers) {
389: bputs(text[DuplicateUser]);
390: continue;
391: }
392: getuserdat(&cfg,&user);
393: if((user.rest&(FLAG('T')|FLAG('D')))
394: || !chk_ar(cfg.lib[cfg.dir[cfg.user_dir]->lib]->ar,&user)
395: || !chk_ar(cfg.dir[cfg.user_dir]->dl_ar,&user)) {
396: bprintf(text[UserWontBeAbleToDl],user.alias);
397: } else {
398: bprintf(text[UserAddedToDestList],user.alias);
399: destuser[destusers++]=user.number;
400: }
401: }
402: else {
403: CRLF;
404: }
405: }
406: if(!destusers)
407: return(false);
408: }
409: if(cfg.dir[dirnum]->misc&DIR_RATE) {
410: SYNC;
411: bputs(text[RateThisFile]);
412: ch=getkey(K_ALPHA);
413: if(!isalpha(ch) || sys_status&SS_ABORT)
414: return(false);
415: CRLF;
416: sprintf(descbeg,text[Rated],toupper(ch));
417: }
418: if(cfg.dir[dirnum]->misc&DIR_ULDATE) {
419: now=time(NULL);
420: if(descbeg[0])
421: strcat(descbeg," ");
422: sprintf(str,"%s ",unixtodstr(&cfg,now,tmp));
423: strcat(descbeg,str);
424: }
425: if(cfg.dir[dirnum]->misc&DIR_MULT) {
426: SYNC;
427: if(!noyes(text[MultipleDiskQ])) {
428: bputs(text[HowManyDisksTotal]);
429: if((int)(i=getnum(99))<2)
430: return(false);
431: bputs(text[NumberOfFile]);
432: if((int)(j=getnum(i))<1)
433: return(false);
434: if(j==1)
435: upload_lastdesc[0]=0;
436: if(i>9)
437: sprintf(descend,text[FileOneOfTen],j,i);
438: else
439: sprintf(descend,text[FileOneOfTwo],j,i);
440: } else
441: upload_lastdesc[0]=0;
442: }
443: else
444: upload_lastdesc[0]=0;
445: bputs(text[EnterDescNow]);
446: i=LEN_FDESC-(strlen(descbeg)+strlen(descend));
447: getstr(upload_lastdesc,i,K_LINE|K_EDIT|K_AUTODEL);
448: if(sys_status&SS_ABORT)
449: return(false);
450: if(descend[0]) /* end of desc specified, so pad desc with spaces */
451: sprintf(f.desc,"%s%-*s%s",descbeg,i,upload_lastdesc,descend);
452: else /* no end specified, so string ends at desc end */
453: sprintf(f.desc,"%s%s",descbeg,upload_lastdesc);
454:
455: if(cfg.dir[dirnum]->misc&DIR_ANON && !(cfg.dir[dirnum]->misc&DIR_AONLY)
456: && (dir_op(dirnum) || useron.exempt&FLAG('A'))) {
457: if(!noyes(text[AnonymousQ]))
458: f.misc|=FM_ANON;
459: }
460: sprintf(str,"%s%s",path,fname);
461: if(fexistcase(str)) { /* File is on disk */
462: if(!uploadfile(&f))
463: return(false);
464: } else {
465: xfer_prot_menu(XFER_UPLOAD);
466: SYNC;
467: strcpy(keys,"Q");
468: if(dirnum==cfg.user_dir || !cfg.max_batup) /* no batch user to user xfers */
469: mnemonics(text[ProtocolOrQuit]);
470: else {
471: mnemonics(text[ProtocolBatchOrQuit]);
472: strcat(keys,"B");
473: }
474: for(i=0;i<cfg.total_prots;i++)
475: if(cfg.prot[i]->ulcmd[0] && chk_ar(cfg.prot[i]->ar,&useron)) {
476: sprintf(tmp,"%c",cfg.prot[i]->mnemonic);
477: strcat(keys,tmp);
478: }
479: ch=(char)getkeys(keys,0);
480: if(ch=='Q')
481: return(false);
482: if(ch=='B') {
483: if(batup_total>=cfg.max_batup)
484: bputs(text[BatchUlQueueIsFull]);
485: else {
486: for(i=0;i<batup_total;i++)
487: if(!strcmp(batup_name[i],f.name)) {
488: bprintf(text[FileAlreadyInQueue],fname);
489: return(false);
490: }
491: strcpy(batup_name[batup_total],f.name);
492: strcpy(batup_desc[batup_total],f.desc);
493: batup_dir[batup_total]=dirnum;
494: batup_misc[batup_total]=f.misc;
495: batup_alt[batup_total]=altul;
496: batup_total++;
497: bprintf(text[FileAddedToUlQueue]
498: ,fname,batup_total,cfg.max_batup);
499: }
500: } else {
501: for(i=0;i<cfg.total_prots;i++)
502: if(cfg.prot[i]->ulcmd[0] && cfg.prot[i]->mnemonic==ch
503: && chk_ar(cfg.prot[i]->ar,&useron))
504: break;
505: if(i<cfg.total_prots) {
506: start=time(NULL);
507: protocol(cfg.prot[i],XFER_UPLOAD,str,nulstr,true);
508: end=time(NULL);
509: if(!(cfg.dir[dirnum]->misc&DIR_ULTIME)) /* Don't deduct upload time */
510: starttime+=end-start;
511: ch=uploadfile(&f);
512: autohangup();
513: if(!ch) /* upload failed, don't process user to user xfer */
514: return(false);
515: }
516: }
517: }
518: if(dirnum==cfg.user_dir) { /* Add files to XFER.IXT in INDX dir */
519: sprintf(str,"%sxfer.ixt",cfg.data_dir);
520: if((file=nopen(str,O_WRONLY|O_CREAT|O_APPEND))==-1) {
521: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_APPEND);
522: return(false);
523: }
524: for(j=0;j<destusers;j++) {
525: for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
526: getnodedat(i,&node,0);
527: if(node.useron==destuser[j] && !(node.misc&NODE_POFF)
528: && (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
529: sprintf(str,text[UserToUserXferNodeMsg],cfg.node_num,useron.alias);
530: putnmsg(&cfg,i,str);
531: break;
532: }
533: }
534: if(i>cfg.sys_nodes) { /* User not online */
535: sprintf(str,text[UserSentYouFile],useron.alias);
536: putsmsg(&cfg,destuser[j],str);
537: }
538: sprintf(str,"%4.4u %12.12s %4.4u\r\n"
539: ,destuser[j],f.name,useron.number);
540: write(file,str,strlen(str));
541: }
542: close(file);
543: }
544: return(true);
545: }
546:
547: /****************************************************************************/
548: /* Checks directory for 'dir' and prompts user to enter description for */
549: /* the files that aren't in the database. */
550: /* Returns 1 if the user aborted, 0 if not. */
551: /****************************************************************************/
552: bool sbbs_t::bulkupload(uint dirnum)
553: {
554: char str[MAX_PATH+1];
555: char path[MAX_PATH+1];
556: char spath[MAX_PATH+1];
557: file_t f;
558: DIR* dir;
559: DIRENT* dirent;
560:
561: memset(&f,0,sizeof(file_t));
562: f.dir=dirnum;
563: f.altpath=altul;
564: bprintf(text[BulkUpload],cfg.lib[cfg.dir[dirnum]->lib]->sname,cfg.dir[dirnum]->sname);
565: strcpy(path,altul>0 && altul<=cfg.altpaths ? cfg.altpath[altul-1]
566: : cfg.dir[dirnum]->path);
567: action=NODE_ULNG;
568: SYNC;
569: dir=opendir(path);
570: while(dir!=NULL && (dirent=readdir(dir))!=NULL && !msgabort()) {
571: if(getfiles(&cfg,dirnum)>=cfg.dir[dirnum]->maxfiles) {
572: bputs(text[DirFull]);
573: break;
574: }
575: sprintf(str,"%s%s",path,dirent->d_name);
576: if(isdir(str))
577: continue;
578: #ifdef _WIN32
579: /* Skip hidden/system files on Win32 */
580: if(getfattr(str)&(_A_HIDDEN|_A_SYSTEM))
581: continue;
582: #endif
583: #ifdef _WIN32
584: GetShortPathName(str,spath,sizeof(spath));
585: #else
586: strcpy(spath,str);
587: #endif
588: padfname(getfname(spath),str);
589:
590: if(findfile(&cfg,f.dir,str)==0) {
591: strcpy(f.name,str);
592: f.cdt=flength(spath);
593: bprintf(text[BulkUploadDescPrompt],f.name,f.cdt/1024);
594: getstr(f.desc,LEN_FDESC,K_LINE);
595: if(sys_status&SS_ABORT)
596: break;
597: uploadfile(&f);
598: }
599: }
600: if(dir!=NULL)
601: closedir(dir);
602: if(sys_status&SS_ABORT)
603: return(true);
604: return(false);
605: }
606:
607: bool sbbs_t::recvfile(char *fname, char prot)
608: {
609: char keys[32];
610: char ch;
611: size_t i;
612: bool result=false;
613:
614: if(prot)
615: ch=toupper(prot);
616: else {
617: xfer_prot_menu(XFER_UPLOAD);
618: mnemonics(text[ProtocolOrQuit]);
619: strcpy(keys,"Q");
620: for(i=0;i<cfg.total_prots;i++)
621: if(cfg.prot[i]->ulcmd[0] && chk_ar(cfg.prot[i]->ar,&useron))
622: sprintf(keys+strlen(keys),"%c",cfg.prot[i]->mnemonic);
623:
624: ch=(char)getkeys(keys,0);
625:
626: if(ch=='Q' || sys_status&SS_ABORT)
627: return(false);
628: }
629: for(i=0;i<cfg.total_prots;i++)
630: if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron))
631: break;
632: if(i<cfg.total_prots) {
633: if(protocol(cfg.prot[i],XFER_UPLOAD,fname,fname,true)==0)
634: result=true;
635: autohangup();
636: }
637:
638: return(result);
639: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.