upload.cpp 18.5 KB
Newer Older
1
2
3
4
5
6
/* Synchronet file upload-related routines */

/****************************************************************************
 * @format.tab-size 4		(Plain Text/Source Code File Header)			*
 * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
 *																			*
7
 * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 *																			*
 * This program is free software; you can redistribute it and/or			*
 * modify it under the terms of the GNU General Public License				*
 * as published by the Free Software Foundation; either version 2			*
 * of the License, or (at your option) any later version.					*
 * See the GNU General Public License for more details: gpl.txt or			*
 * http://www.fsf.org/copyleft/gpl.html										*
 *																			*
 * For Synchronet coding style and modification guidelines, see				*
 * http://www.synchro.net/source.html										*
 *																			*
 * Note: If this box doesn't appear square, then you need to fix your tabs.	*
 ****************************************************************************/

#include "sbbs.h"
23
#include "filedat.h"
24
25
26

/****************************************************************************/
/****************************************************************************/
27
bool sbbs_t::uploadfile(file_t* f)
28
{
29
	char	path[MAX_PATH+1];
30
31
	char	str[MAX_PATH+1] = "";
	char	ext[LEN_EXTDESC + 1] = "";
32
33
34
35
	char	tmp[MAX_PATH+1];
    uint	i;
    long	length;
	FILE*	stream;
36
37

	curdirnum=f->dir;
38
39
40
	if(findfile(&cfg, f->dir, f->name, NULL)) {
		errormsg(WHERE, ERR_CHK, f->name, f->dir);
		return false;
41
	}
42
43
	getfilepath(&cfg, f, path);
	SAFEPRINTF2(tmp, "%s%s", cfg.temp_dir, getfname(path));
44
	if(!fexistcase(path) && fexistcase(tmp))
45
		mv(tmp,path,0);
46
	if(!fexistcase(path)) {
47
		bprintf(text[FileNotReceived],f->name);
48
		safe_snprintf(str,sizeof(str),"attempted to upload %s to %s %s (Not received)"
49
			,f->name
50
			,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname);
51
		logline(LOG_NOTICE,"U!",str);
52
		return false;
53
	}
54
55
	f->hdr.when_written.time = (uint32_t)fdate(path);
	char* fext = getfext(f->name);
56
	for(i=0;i<cfg.total_ftests;i++)
57
		if(cfg.ftest[i]->ext[0]=='*' || (fext != NULL && stricmp(fext, cfg.ftest[i]->ext) == 0)) {
rswindell's avatar
rswindell committed
58
			if(!chk_ar(cfg.ftest[i]->ar,&useron,&client))
59
60
61
62
				continue;
			attr(LIGHTGRAY);
			bputs(cfg.ftest[i]->workstr);

63
			safe_snprintf(sbbsfilename,sizeof(sbbsfilename),"SBBSFILENAME=%s",f->name);
64
			putenv(sbbsfilename);
65
			safe_snprintf(sbbsfiledesc,sizeof(sbbsfiledesc),"SBBSFILEDESC=%s",f->desc);
66
			putenv(sbbsfiledesc);
67
			SAFEPRINTF(str,"%ssbbsfile.nam",cfg.node_dir);
68
			if((stream=fopen(str,"w"))!=NULL) {
69
				fprintf(stream, "%s", f->desc);
70
71
				fclose(stream); 
			}
72
			SAFEPRINTF(str,"%ssbbsfile.des",cfg.node_dir);
73
74
			if((stream=fopen(str,"w"))!=NULL) {
				fwrite(f->desc,1,strlen(f->desc),stream);
75
76
				fclose(stream); 
			}
77
			if(external(cmdstr(cfg.ftest[i]->cmd,path,f->desc,NULL),EX_OFFLINE)) {
78
				safe_snprintf(str,sizeof(str),"attempted to upload %s to %s %s (%s Errors)"
79
					,f->name
80
					,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname,cfg.ftest[i]->ext);
81
				logline(LOG_NOTICE,"U!",str);
82
83
84
85
86
87
88
#if 0
				sprintf(str,"Failed test: %s", cmdstr(cfg.ftest[i]->cmd,path,f->desc,NULL));
				logline("  ",str);
#endif
				bprintf(text[FileHadErrors],f->name,cfg.ftest[i]->ext);
				if(!SYSOP || yesno(text[DeleteFileQ]))
					remove(path);
89
90
				return(0); 
			} else {
91
#if 0 // NFB-TODO - uploader tester changes filename or description
92
				sprintf(str,"%ssbbsfile.nam",cfg.node_dir);
93
94
95
96
97
98
				if((stream=fopen(str,"r"))!=NULL) {
					if(fgets(str,128,stream)) {
						truncsp(str);
						padfname(str,f->name);
						strcpy(tmp,f->name);
						truncsp(tmp);
99
						sprintf(path,"%s%s", cfg.dir[f->dir]->path
100
101
							,unpadfname(f->name,fname)); 
					}
102
103
					fclose(stream);
					}
104
				sprintf(str,"%ssbbsfile.des",cfg.node_dir);
105
106
107
				if((stream=fopen(str,"r"))!=NULL) {
					if(fgets(str,128,stream)) {
						truncsp(str);
108
109
110
111
						sprintf(f->desc,"%.*s",LEN_FDESC,str); 
					}
					fclose(stream); 
				}
112
113
114
				CRLF;
#endif
			}
115
		}
116

117
	if((length=(long)flength(path))==0L) {
118
119
		bprintf(text[FileZeroLength],f->name);
		remove(path);
120
		safe_snprintf(str,sizeof(str),"attempted to upload %s to %s %s (Zero length)"
121
			,f->name
122
			,cfg.lib[cfg.dir[f->dir]->lib]->sname,cfg.dir[f->dir]->sname);
123
		logline(LOG_NOTICE,"U!",str);
124
		return false; 
125
	}
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

	bputs(text[SearchingForDupes]);
	/* Note: Hashes file *after* running upload-testers (which could modify file) */
	if(hashfile(&cfg, f)) {
		bputs(text[SearchedForDupes]);
		for(uint i=0, k=0; i < usrlibs; i++) {
			progress(text[Scanning], i, usrlibs, 1);
			for(uint j=0; j < usrdirs[i]; j++,k++) {
				if(cfg.dir[usrdir[i][j]]->misc&DIR_DUPES
					&& findfile(&cfg, usrdir[i][j], /* filename: */NULL, f)) {
					bprintf(text[FileAlreadyOnline], f->name);
					if(!dir_op(f->dir)) {
						remove(path);
						safe_snprintf(str, sizeof(str), "attempted to upload %s to %s %s (duplicate hash)"
							,f->name
							,cfg.lib[cfg.dir[f->dir]->lib]->sname, cfg.dir[f->dir]->sname);
						logline(LOG_NOTICE, "U!", str);
						return(false); 	 /* File is in database for another dir */
					}
				}
146
			}
147
148
149
150
151
152
153
154
155
156
		}
		progress(text[Done], usrlibs, usrlibs);
	} else
		bputs(text[SearchedForDupes]);

	if(cfg.dir[f->dir]->misc&DIR_DIZ) {
		lprintf(LOG_DEBUG, "Extracting DIZ from: %s", path);
		if(extract_diz(&cfg, f, /* diz_fnames: */NULL, str, sizeof(str))) {
			lprintf(LOG_DEBUG, "Parsing DIZ: %s", str);

157
			str_list_t lines = read_diz(str);
158
159
160
161
162
163
164
165
166
167
168
			if(lines != NULL)
				format_diz(lines, ext, sizeof(ext), /* allow_ansi: */false);
			strListFree(&lines);

			if(f->desc == NULL || f->desc[0] == 0) {
				char	desc[LEN_FDESC];
				SAFECOPY(desc, (char*)ext);
				strip_exascii(desc, desc);
				prep_file_desc(desc, desc);
				for(i=0;desc[i];i++)
					if(IS_ALPHANUMERIC(desc[i]))
169
						break;
170
171
172
173
174
175
176
				if(desc[i] == '\0')
					i = 0;
				smb_hfield_str(f, SMB_FILEDESC, desc + i);
			}
			remove(str);
		} else
			lprintf(LOG_DEBUG, "DIZ does not exist in: %s", path);
177
	}
178

179
180
181
182
	if(!(cfg.dir[f->dir]->misc&DIR_NOSTAT)) {
		logon_ulb+=length;  /* Update 'this call' stats */
		logon_uls++;
	}
183
	if(cfg.dir[f->dir]->misc&DIR_AONLY)  /* Forced anonymous */
184
185
186
187
		f->hdr.attr |= MSG_ANONYMOUS;
	uint32_t cdt = (uint32_t)length;
	smb_hfield_bin(f, SMB_COST, cdt);
	smb_hfield_str(f, SENDER, useron.alias);
188
	bprintf(text[FileNBytesReceived],f->name,ultoac(length,tmp));
189
	if(!addfile(&cfg, f->dir, f, ext, &client))
190
		return false;
191

192
	safe_snprintf(str,sizeof(str),"uploaded %s to %s %s"
193
		,f->name,cfg.lib[cfg.dir[f->dir]->lib]->sname
194
195
		,cfg.dir[f->dir]->sname);
	if(cfg.dir[f->dir]->upload_sem[0])
196
		ftouch(cmdstr(cfg.dir[f->dir]->upload_sem,nulstr,nulstr,NULL));
197
198
199
200
	logline("U+",str);
	/**************************/
	/* Update Uploader's Info */
	/**************************/
201
	user_uploaded(&cfg, &useron, 1, length);
202
203
204
205
206
207
	if(cfg.dir[f->dir]->up_pct && cfg.dir[f->dir]->misc&DIR_CDTUL) { /* credit for upload */
		if(cfg.dir[f->dir]->misc&DIR_CDTMIN && cur_cps)    /* Give min instead of cdt */
			useron.min=adjustuserrec(&cfg,useron.number,U_MIN,10
				,((ulong)(length*(cfg.dir[f->dir]->up_pct/100.0))/cur_cps)/60);
		else
			useron.cdt=adjustuserrec(&cfg,useron.number,U_CDT,10
208
				,(ulong)(f->cost * (cfg.dir[f->dir]->up_pct/100.0))); 
209
210
211
	}

	user_event(EVENT_UPLOAD);
212

213
	return true;
214
215
216
217
218
}

/****************************************************************************/
/* Uploads files                                                            */
/****************************************************************************/
219
bool sbbs_t::upload(uint dirnum)
220
{
221
	char	descbeg[25]={""},descend[25]={""}
222
				,fname[MAX_FILENAME_LEN + 1],keys[256],ch,*p;
223
224
	char	str[MAX_PATH+1];
	char	path[MAX_PATH+1];
225
	char 	tmp[512];
226
    time_t	start,end;
227
    uint	i,j,k;
228
	ulong	space;
229
	file_t	f = {{}};
230
	str_list_t dest_user_list = NULL;
231

232
233
234
235
236
237
238
239
240
	/* Security Checks */
	if(useron.rest&FLAG('U')) {
		bputs(text[R_Upload]);
		return(false); 
	}
	if(dirnum==INVALID_DIR) {
		bputs(text[CantUploadHere]);
		return(false);
	}
241
242
243
244
245
246
247
248
249
250
	if(!(useron.exempt&FLAG('U')) && !dir_op(dirnum)) {
		if(!chk_ar(cfg.dir[dirnum]->ul_ar,&useron,&client)) {
			bputs(dirnum==cfg.user_dir ? text[CantUploadToUser] : 
				dirnum==cfg.sysop_dir ? text[CantUploadToSysop] : text[CantUploadHere]);
			return(false); 
		}
		if(cfg.dir[dirnum]->maxfiles && getfiles(&cfg,dirnum)>=cfg.dir[dirnum]->maxfiles) {
			bputs(dirnum==cfg.user_dir ? text[UserDirFull] : text[DirFull]);
			return(false);
		}
251
252
	}

253
254
	if(sys_status&SS_EVENT && online==ON_REMOTE && !dir_op(dirnum))
		bprintf(text[UploadBeforeEvent],timeleft/60);
255
256

	SAFECOPY(path,cfg.dir[dirnum]->path);
257

258
259
	if(!isdir(path)) {
		bprintf(text[DirectoryDoesNotExist], path);
260
		lprintf(LOG_ERR,"File directory does not exist: %s", path);
261
262
		return(false);
	}
263
264

	/* get free disk space */
265
266
	space=getfreediskspace(path,1024);
	if(space<(ulong)cfg.min_dspace) {
267
		bputs(text[LowDiskSpace]);
268
		lprintf(LOG_ERR,"Diskspace is low: %s (%lu kilobytes)",path,space);
269
		if(!dir_op(dirnum))
270
271
			return(false); 
	}
272
273
274
275
	bprintf(text[DiskNBytesFree],ultoac(space,tmp));

	f.dir=curdirnum=dirnum;
	bputs(text[Filename]);
276
	if(getstr(fname, sizeof(fname) - 1, 0) < 1 || strchr(fname,'?') || strchr(fname,'*')
277
		|| !checkfname(fname) || (trashcan(fname,"file") && !dir_op(dirnum))) {
278
279
		if(fname[0])
			bputs(text[BadFilename]);
280
281
		return(false); 
	}
282
	if(dirnum==cfg.sysop_dir)
283
		SAFEPRINTF(str,text[UploadToSysopDirQ],fname);
284
	else if(dirnum==cfg.user_dir)
285
		SAFEPRINTF(str,text[UploadToUserDirQ],fname);
286
	else
287
		SAFEPRINTF3(str,text[UploadToCurDirQ],fname,cfg.lib[cfg.dir[dirnum]->lib]->sname
288
			,cfg.dir[dirnum]->sname);
289
	if(!yesno(str)) return(false);
290
	action=NODE_ULNG;
291
292
293
	SAFECOPY(f.file_idx.name, fname);
	getfilepath(&cfg, &f, path);
	if(fexistcase(path)) {   /* File is on disk */
294
295
		if(!dir_op(dirnum) && online!=ON_LOCAL) {		 /* local users or sysops */
			bprintf(text[FileAlreadyThere],fname);
296
297
			return(false); 
		}
298
		if(!yesno(text[FileOnDiskAddQ]))
299
300
			return(false); 
	}
301
302
	char* ext = getfext(fname);
	SAFECOPY(str,cfg.dir[dirnum]->exts);
303
304
305
306
307
	j=strlen(str);
	for(i=0;i<j;i+=ch+1) { /* Check extension of upload with allowable exts */
		p=strchr(str+i,',');
		if(p!=NULL)
			*p=0;
308
		ch=(char)strlen(str+i);
309
310
		if(ext != NULL && stricmp(ext + 1, str + i) == 0)
			break;
311
	}
312
313
314
315
	if(j && i>=j) {
		bputs(text[TheseFileExtsOnly]);
		bputs(cfg.dir[dirnum]->exts);
		CRLF;
316
317
		if(!dir_op(dirnum)) return(false); 
	}
318
	bputs(text[SearchingForDupes]);
319
320
321
	bool found = findfile(&cfg, dirnum, fname, NULL);
	bputs(text[SearchedForDupes]);
	if(found) {
322
323
324
		bprintf(text[FileAlreadyOnline],fname);
		return(false); 	 /* File is already in database */
	}
325
	for(i=k=0;i<usrlibs;i++) {
326
		progress(text[SearchingForDupes], i, usrlibs, 1);
327
		for(j=0;j<usrdirs[i];j++,k++) {
328
329
330
			if(usrdir[i][j]==dirnum)
				continue;	/* we already checked this dir */
			if(cfg.dir[usrdir[i][j]]->misc&DIR_DUPES
331
				&& findfile(&cfg, usrdir[i][j], fname, NULL)) {
332
				bputs(text[SearchedForDupes]);
333
				bprintf(text[FileAlreadyOnline],fname);
334
				if(!dir_op(dirnum))
335
					return(false); 	 /* File is in database for another dir */
336
337
338
			}
		}
	}
339
340
341
342
343
	bputs(text[SearchedForDupes]);
	if(cfg.dir[dirnum]->misc&DIR_RATE) {
		SYNC;
		bputs(text[RateThisFile]);
		ch=getkey(K_ALPHA);
344
		if(!IS_ALPHA(ch) || sys_status&SS_ABORT)
345
			return(false);
346
		CRLF;
347
		SAFEPRINTF(descbeg,text[Rated],toupper(ch)); 
348
	}
349
350
351
352
	if(cfg.dir[dirnum]->misc&DIR_ULDATE) {
		now=time(NULL);
		if(descbeg[0])
			strcat(descbeg," ");
353
		SAFEPRINTF(str,"%s  ",unixtodstr(&cfg,(time32_t)now,tmp));
354
355
		strcat(descbeg,str); 
	}
356
357
358
359
	if(cfg.dir[dirnum]->misc&DIR_MULT) {
		SYNC;
		if(!noyes(text[MultipleDiskQ])) {
			bputs(text[HowManyDisksTotal]);
360
			if((int)(i=getnum(99))<2)
361
				return(false);
362
			bputs(text[NumberOfFile]);
363
			if((int)(j=getnum(i))<1)
364
				return(false);
365
366
367
			if(j==1)
				upload_lastdesc[0]=0;
			if(i>9)
368
				SAFEPRINTF2(descend,text[FileOneOfTen],j,i);
369
			else
370
				SAFEPRINTF2(descend,text[FileOneOfTwo],j,i); 
371
372
373
		} else
			upload_lastdesc[0]=0; 
	}
374
375
	else
		upload_lastdesc[0]=0;
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
	if(dirnum == cfg.user_dir) {  /* User to User transfer */
		bputs(text[EnterAfterLastDestUser]);
		while(dir_op(dirnum) || strListCount(dest_user_list) < cfg.max_userxfer) {
			bputs(text[SendFileToUser]);
			if(!getstr(str,LEN_ALIAS,cfg.uq&UQ_NOUPRLWR ? K_NONE:K_UPRLWR))
				break;
			user_t user;
			if((user.number=finduser(str))!=0) {
				if(!dir_op(dirnum) && user.number==useron.number) {
					bputs(text[CantSendYourselfFiles]);
					continue; 
				}
				char usernum[16];
				SAFEPRINTF(usernum, "%u", user.number);
				if(strListFind(dest_user_list, usernum, /* case-sensitive: */true) >= 0) {
					bputs(text[DuplicateUser]);
					continue; 
				}
				getuserdat(&cfg,&user);
				if((user.rest&(FLAG('T')|FLAG('D')))
					|| !chk_ar(cfg.lib[cfg.dir[cfg.user_dir]->lib]->ar,&user,/* client: */NULL)
					|| !chk_ar(cfg.dir[cfg.user_dir]->dl_ar,&user,/* client: */NULL)) {
					bprintf(text[UserWontBeAbleToDl],user.alias); 
				} else {
					bprintf(text[UserAddedToDestList],user.alias,usernum);
					strListPush(&dest_user_list, usernum);
				} 
			}
			else {
				CRLF;
			}
		}
		if(strListCount(dest_user_list) < 1)
			return false;
	}
411
412

	char fdesc[LEN_FDESC + 1] = "";
413
414
	bputs(text[EnterDescNow]);
	i=LEN_FDESC-(strlen(descbeg)+strlen(descend));
415
	getstr(upload_lastdesc,i,K_LINE|K_EDIT|K_AUTODEL|K_TRIM);
416
417
	if(sys_status&SS_ABORT) {
		strListFree(&dest_user_list);
418
		return(false);
419
	}
420
	if(descend[0])      /* end of desc specified, so pad desc with spaces */
421
		safe_snprintf(fdesc,sizeof(fdesc),"%s%-*s%s",descbeg,i,upload_lastdesc,descend);
422
	else                /* no end specified, so string ends at desc end */
423
424
425
426
427
428
429
		safe_snprintf(fdesc,sizeof(fdesc),"%s%s",descbeg,upload_lastdesc);

	char tags[64] = "";
	if((cfg.dir[dirnum]->misc&DIR_FILETAGS) && (text[TagFileQ][0] == 0 || !noyes(text[TagFileQ]))) {
		bputs(text[TagFilePrompt]);
		getstr(tags, sizeof(tags)-1, K_EDIT|K_LINE|K_TRIM);
	}
430
431
432
433

	if(cfg.dir[dirnum]->misc&DIR_ANON && !(cfg.dir[dirnum]->misc&DIR_AONLY)
		&& (dir_op(dirnum) || useron.exempt&FLAG('A'))) {
		if(!noyes(text[AnonymousQ]))
434
			f.hdr.attr |= MSG_ANONYMOUS;
435
	}
436
437
438
439

	bool result = false;
	smb_hfield_str(&f, SMB_FILENAME, fname);
	smb_hfield_str(&f, SMB_FILEDESC, fdesc);
440
441
	if(strListCount(dest_user_list) > 0)
		smb_hfield_str(&f, RECIPIENTLIST, strListCombine(dest_user_list, tmp, sizeof(tmp), ","));
442
443
444
445
	if(tags[0])
		smb_hfield_str(&f, SMB_TAGS, tags);
	if(fexistcase(path)) {   /* File is on disk */
		result = uploadfile(&f);
446
	} else {
447
		xfer_prot_menu(XFER_UPLOAD);
448
		SYNC;
449
		SAFEPRINTF(keys,"%c",text[YNQP][2]);
450
451
452
453
		if(dirnum==cfg.user_dir || !cfg.max_batup)  /* no batch user to user xfers */
			mnemonics(text[ProtocolOrQuit]);
		else {
			mnemonics(text[ProtocolBatchOrQuit]);
454
455
			strcat(keys,"B"); 
		}
456
		for(i=0;i<cfg.total_prots;i++)
rswindell's avatar
rswindell committed
457
			if(cfg.prot[i]->ulcmd[0] && chk_ar(cfg.prot[i]->ar,&useron,&client)) {
458
				SAFEPRINTF(tmp,"%c",cfg.prot[i]->mnemonic);
459
460
				strcat(keys,tmp); 
			}
461
		ch=(char)getkeys(keys,0);
462
		if(ch==text[YNQP][2] || (sys_status&SS_ABORT))
463
464
465
			result = false;
		else if(ch=='B') {
			if(batup_total() >= cfg.max_batup)
466
				bputs(text[BatchUlQueueIsFull]);
467
468
469
			else if(batch_file_exists(&cfg, useron.number, XFER_BATCH_UPLOAD, f.name))
				bprintf(text[FileAlreadyInQueue],fname);
			else if(batch_file_add(&cfg, useron.number, XFER_BATCH_UPLOAD, &f)) {
470
				bprintf(text[FileAddedToUlQueue]
471
472
473
					,fname, batup_total(), cfg.max_batup);
				result = true;
			}
474
		} else {
475
476
			for(i=0;i<cfg.total_prots;i++)
				if(cfg.prot[i]->ulcmd[0] && cfg.prot[i]->mnemonic==ch
rswindell's avatar
rswindell committed
477
					&& chk_ar(cfg.prot[i]->ar,&useron,&client))
478
479
480
					break;
			if(i<cfg.total_prots) {
				start=time(NULL);
481
				protocol(cfg.prot[i],XFER_UPLOAD,path,nulstr,true);
482
483
484
				end=time(NULL);
				if(!(cfg.dir[dirnum]->misc&DIR_ULTIME)) /* Don't deduct upload time */
					starttime+=end-start;
485
				result = uploadfile(&f);
486
				autohangup();
487
488
489
			} 
		} 
	}
490
	smb_freefilemem(&f);
491
	strListFree(&dest_user_list);
492
	return result;
493
494
495
496
497
498
499
500
501
}

/****************************************************************************/
/* Checks directory for 'dir' and prompts user to enter description for     */
/* the files that aren't in the database.                                   */
/* Returns 1 if the user aborted, 0 if not.                                 */
/****************************************************************************/
bool sbbs_t::bulkupload(uint dirnum)
{
502
503
    char	str[MAX_PATH+1];
	char	path[MAX_PATH+1];
504
505
506
	char	desc[LEN_FDESC + 1];
	smb_t	smb;
    file_t f;
507
508
	DIR*	dir;
	DIRENT*	dirent;
509

510
	memset(&f,0,sizeof(f));
511
512
	f.dir=dirnum;
	bprintf(text[BulkUpload],cfg.lib[cfg.dir[dirnum]->lib]->sname,cfg.dir[dirnum]->sname);
513
514
515
516
517
518
519
	SAFECOPY(path, cfg.dir[dirnum]->path);

	int result = smb_open_dir(&cfg, &smb, dirnum);
	if(result != SMB_SUCCESS) {
		errormsg(WHERE, ERR_OPEN, smb.file, result, smb.last_error);
		return false;
	}
520
521
	action=NODE_ULNG;
	SYNC;
522
523
	str_list_t list = loadfilenames(&smb, ALLFILES, /* time_t */0, FILE_SORT_NATURAL, NULL);
	smb_close(&smb);
524
	dir=opendir(path);
525
	while(dir!=NULL && (dirent=readdir(dir))!=NULL && !msgabort()) {
526
		char fname[SMB_FILEIDX_NAMELEN + 1];
527
		SAFEPRINTF2(str,"%s%s",path,dirent->d_name);
528
529
		if(isdir(str))
			continue;
530
531
532
533
534
#ifdef _WIN32
		/* Skip hidden/system files on Win32 */
		if(getfattr(str)&(_A_HIDDEN|_A_SYSTEM))
			continue;
#endif
535
536
537
538
539
540
541
		smb_fileidxname(dirent->d_name, fname, sizeof(fname));
		if(strListFind(list, fname, /* case-sensitive: */FALSE) < 0) {
			smb_freemsgmem(&f);
			smb_hfield_str(&f, SMB_FILENAME, dirent->d_name);
			uint32_t cdt = (uint32_t)flength(str);
			smb_hfield_bin(&f, SMB_COST, cdt);
			bprintf(text[BulkUploadDescPrompt], format_filename(f.name, fname, 12, /* pad: */FALSE), cdt/1024);
542
543
544
545
546
			if(strcmp(f.name, fname) != 0)
				SAFECOPY(desc, f.name);
			else
				desc[0] = 0;
			getstr(desc, LEN_FDESC, K_LINE|K_EDIT|K_AUTODEL);
547
548
			if(sys_status&SS_ABORT)
				break;
549
			if(strcmp(desc,"-")==0)	/* don't add this file */
550
				continue;
551
552
			smb_hfield_str(&f, SMB_FILEDESC, desc);
			uploadfile(&f);
553
554
		}
	}
555
556
	if(dir!=NULL)
		closedir(dir);
557
558
	strListFree(&list);
	smb_freemsgmem(&f);
559
560
	if(sys_status&SS_ABORT)
		return(true);
561
562
563
	return(false);
}

564
bool sbbs_t::recvfile(char *fname, char prot, bool autohang)
565
566
567
568
569
570
{
	char	keys[32];
	char	ch;
	size_t	i;
	bool	result=false;

571
572
573
574
575
	if(prot)
		ch=toupper(prot);
	else {
		xfer_prot_menu(XFER_UPLOAD);
		mnemonics(text[ProtocolOrQuit]);
576
		SAFEPRINTF(keys,"%c",text[YNQP][2]);
577
		for(i=0;i<cfg.total_prots;i++)
rswindell's avatar
rswindell committed
578
			if(cfg.prot[i]->ulcmd[0] && chk_ar(cfg.prot[i]->ar,&useron,&client))
579
				sprintf(keys+strlen(keys),"%c",cfg.prot[i]->mnemonic);
580

581
		ch=(char)getkeys(keys,0);
582

583
		if(ch==text[YNQP][2] || sys_status&SS_ABORT)
584
585
			return(false); 
	}
586
	for(i=0;i<cfg.total_prots;i++)
rswindell's avatar
rswindell committed
587
		if(cfg.prot[i]->mnemonic==ch && chk_ar(cfg.prot[i]->ar,&useron,&client))
588
589
			break;
	if(i<cfg.total_prots) {
590
		if(protocol(cfg.prot[i], XFER_UPLOAD, fname, fname, true, autohang)==0)
591
592
593
594
595
596
			result=true;
		autohangup(); 
	}

	return(result);
}