![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pack_qwk.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 pack_qwk.cpp CVS log | Up to [Synchronet] / sbbs / src / sbbs3 |
1.1 root 1: /* pack_qwk.cpp */
2:
3: /* Synchronet pack QWK packet routine */
4:
5: /* $Id: pack_qwk.cpp,v 1.51 2006/04/14 00:54:43 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: #include "qwk.h"
40:
41: /****************************************************************************/
42: /* Creates QWK packet, returning 1 if successful, 0 if not. */
43: /****************************************************************************/
44: bool sbbs_t::pack_qwk(char *packet, ulong *msgcnt, bool prepack)
45: {
46: char str[MAX_PATH+1],ch,*p;
47: char tmp[MAX_PATH+1],tmp2[MAX_PATH+1];
48: char* fname;
49: char* fmode;
50: int mode;
51: uint i,j,k,conf;
52: long l,size,msgndx,posts,ex;
53: long mailmsgs=0;
54: ulong totalcdt,totaltime,lastmsg
55: ,files,submsgs,msgs,netfiles=0,preqwk=0;
56: ulong subs_scanned=0;
57: float f; /* Sparky is responsible */
58: time_t start;
59: node_t node;
60: mail_t *mail;
61: post_t *post;
62: glob_t g;
63: FILE *stream,*qwk,*personal,*ndx;
64: DIR* dir;
65: DIRENT* dirent;
66: struct tm tm;
67: smbmsg_t msg;
68:
69: ex=EX_OUTL|EX_OUTR; /* Need sh for wildcard expansion */
70: if(prepack)
71: ex|=EX_OFFLINE;
72:
73: delfiles(cfg.temp_dir,ALLFILES);
74: sprintf(str,"%sfile/%04u.qwk",cfg.data_dir,useron.number);
75: if(fexistcase(str)) {
76: for(k=0;k<cfg.total_fextrs;k++)
77: if(!stricmp(cfg.fextr[k]->ext,useron.tmpext)
78: && chk_ar(cfg.fextr[k]->ar,&useron))
79: break;
80: if(k>=cfg.total_fextrs)
81: k=0;
82: p=cmdstr(cfg.fextr[k]->cmd,str,ALLFILES,NULL);
83: if((i=external(p,ex))==0)
84: preqwk=1;
85: else
86: errormsg(WHERE,ERR_EXEC,p,i);
87: }
88:
89: if(useron.rest&FLAG('Q') && useron.qwk&QWK_RETCTLA)
90: useron.qwk|=(QWK_NOINDEX|QWK_NOCTRL|QWK_VIA|QWK_TZ|QWK_MSGID);
91:
92: if(useron.qwk&QWK_EXPCTLA)
93: mode=A_EXPAND;
94: else if(useron.qwk&QWK_RETCTLA)
95: mode=A_LEAVE;
96: else mode=0;
97: if(useron.qwk&QWK_TZ)
98: mode|=QM_TZ;
99: if(useron.qwk&QWK_VIA)
100: mode|=QM_VIA;
101: if(useron.qwk&QWK_MSGID)
102: mode|=QM_MSGID;
103:
104: (*msgcnt)=0L;
105: if(/* !prepack && */ !(useron.qwk&QWK_NOCTRL)) {
106: /***************************/
107: /* Create CONTROL.DAT file */
108: /***************************/
109: sprintf(str,"%sCONTROL.DAT",cfg.temp_dir);
110: if((stream=fopen(str,"wb"))==NULL) {
111: errormsg(WHERE,ERR_OPEN,str,0);
112: return(false);
113: }
114:
115: now=time(NULL);
116: if(localtime_r(&now,&tm)==NULL)
117: return(false);
118:
119: fprintf(stream,"%s\r\n%s\r\n%s\r\n%s, Sysop\r\n0000,%s\r\n"
120: "%02u-%02u-%u,%02u:%02u:%02u\r\n"
121: ,cfg.sys_name
122: ,cfg.sys_location
123: ,cfg.node_phone
124: ,cfg.sys_op
125: ,cfg.sys_id
126: ,tm.tm_mon+1,tm.tm_mday,tm.tm_year+1900
127: ,tm.tm_hour,tm.tm_min,tm.tm_sec);
128: k=0;
129: for(i=0;i<usrgrps;i++)
130: for(j=0;j<usrsubs[i];j++)
131: k++; /* k is how many subs */
132: fprintf(stream,"%s\r\n\r\n0\r\n0\r\n%u\r\n",useron.alias,k);
133: fprintf(stream,"0\r\nE-mail\r\n"); /* first conference is e-mail */
134: char confname[256];
135: for(i=0;i<usrgrps;i++)
136: for(j=0;j<usrsubs[i];j++) {
137: if(useron.qwk&QWK_EXT) /* 255 char max */
138: sprintf(confname,"%s %s"
139: ,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
140: ,cfg.sub[usrsub[i][j]]->lname);
141: else /* 10 char max */
142: strcpy(confname,cfg.sub[usrsub[i][j]]->qwkname);
143: fprintf(stream,"%u\r\n%s\r\n"
144: ,cfg.sub[usrsub[i][j]]->qwkconf ? cfg.sub[usrsub[i][j]]->qwkconf
145: : ((i+1)*1000)+j+1,confname);
146: }
147: fprintf(stream,"HELLO\r\nBBSNEWS\r\nGOODBYE\r\n");
148: fclose(stream);
149: /***********************/
150: /* Create DOOR.ID File */
151: /***********************/
152: sprintf(str,"%sDOOR.ID",cfg.temp_dir);
153: if((stream=fopen(str,"wb"))==NULL) {
154: errormsg(WHERE,ERR_OPEN,str,0);
155: return(false);
156: }
157: p="CONTROLTYPE = ";
158: fprintf(stream,"DOOR = %.10s\r\nVERSION = %s%c\r\n"
159: "SYSTEM = %s\r\n"
160: "CONTROLNAME = SBBS\r\n"
161: "%sADD\r\n"
162: "%sDROP\r\n"
163: "%sYOURS\r\n"
164: "%sRESET\r\n"
165: "%sRESETALL\r\n"
166: "%sFILES\r\n"
167: "%sATTACH\r\n"
168: "%sOWN\r\n"
169: "%smail\r\n"
170: "%sDELMAIL\r\n"
171: "%sCTRL-A\r\n"
172: "%sFREQ\r\n"
173: "%sNDX\r\n"
174: "%sTZ\r\n"
175: "%sVIA\r\n"
176: "%sCONTROL\r\n"
177: "MIXEDCASE = YES\r\n"
178: ,VERSION_NOTICE
179: ,VERSION,REVISION
180: ,VERSION_NOTICE
181: ,p,p,p,p
182: ,p,p,p,p
183: ,p,p,p,p
184: ,p,p,p,p
185: );
186: fclose(stream);
187: if(useron.rest&FLAG('Q')) {
188: /***********************/
189: /* Create NETFLAGS.DAT */
190: /***********************/
191: sprintf(str,"%sNETFLAGS.DAT",cfg.temp_dir);
192: if((stream=fopen(str,"wb"))==NULL) {
193: errormsg(WHERE,ERR_CREATE,str,0);
194: return(false);
195: }
196: ch=1; /* Net enabled */
197: if(usrgrps)
198: for(i=0;i<(usrgrps*1000)+usrsubs[usrgrps-1];i++)
199: fputc(ch,stream);
200: fclose(stream);
201: }
202: }
203:
204: /****************************************************/
205: /* Create MESSAGES.DAT, write header and leave open */
206: /****************************************************/
207: sprintf(str,"%sMESSAGES.DAT",cfg.temp_dir);
208: if(fexistcase(str))
209: fmode="r+b";
210: else
211: fmode="w+b";
212: if((qwk=fopen(str,fmode))==NULL) {
213: errormsg(WHERE,ERR_OPEN,str,0);
214: return(false);
215: }
216: l=filelength(fileno(qwk));
217: if(l<1) {
218: fprintf(qwk,"%-128.128s","Produced by " VERSION_NOTICE " " COPYRIGHT_NOTICE);
219: msgndx=1;
220: } else {
221: msgndx=l/QWK_BLOCK_LEN;
222: fseek(qwk,0,SEEK_END);
223: }
224: sprintf(str,"%sNEWFILES.DAT",cfg.temp_dir);
225: remove(str);
226: if(!(useron.rest&FLAG('T')) && useron.qwk&QWK_FILES)
227: files=create_filelist("NEWFILES.DAT",FL_ULTIME);
228: else
229: files=0;
230:
231: start=time(NULL);
232:
233: if(useron.rest&FLAG('Q'))
234: useron.qwk|=(QWK_EMAIL|QWK_ALLMAIL|QWK_DELMAIL);
235:
236: if(!(useron.qwk&QWK_NOINDEX)) {
237: sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
238: if((personal=fopen(str,"ab"))==NULL) {
239: fclose(qwk);
240: errormsg(WHERE,ERR_OPEN,str,0);
241: return(false);
242: }
243: }
244: else
245: personal=NULL;
246:
247: if(useron.qwk&(QWK_EMAIL|QWK_ALLMAIL) /* && !prepack */) {
248: sprintf(smb.file,"%smail",cfg.data_dir);
249: smb.retry_time=cfg.smb_retry_time;
250: smb.subnum=INVALID_SUB;
251: if((i=smb_open(&smb))!=0) {
252: fclose(qwk);
253: if(personal)
254: fclose(personal);
255: errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
256: return(false);
257: }
258:
259: /***********************/
260: /* Pack E-mail, if any */
261: /***********************/
262: qwkmail_last=0;
263: mail=loadmail(&smb,&mailmsgs,useron.number,0,useron.qwk&QWK_ALLMAIL ? 0
264: : LM_UNREAD);
265: if(mailmsgs && !(sys_status&SS_ABORT)) {
266: bputs(text[QWKPackingEmail]);
267: if(!(useron.qwk&QWK_NOINDEX)) {
268: sprintf(str,"%s000.NDX",cfg.temp_dir);
269: if((ndx=fopen(str,"ab"))==NULL) {
270: fclose(qwk);
271: if(personal)
272: fclose(personal);
273: smb_close(&smb);
274: errormsg(WHERE,ERR_OPEN,str,0);
275: free(mail);
276: return(false);
277: }
278: }
279: else
280: ndx=NULL;
281:
282: if(useron.rest&FLAG('Q'))
283: mode|=QM_TO_QNET;
284: else
285: mode&=~QM_TO_QNET;
286:
287: for(l=0;l<mailmsgs;l++) {
288: bprintf("\b\b\b\b\b\b\b\b\b\b\b\b%4lu of %-4lu"
289: ,l+1,mailmsgs);
290:
291: memset(&msg,0,sizeof(msg));
292: msg.idx=mail[l];
293: if(msg.idx.number>qwkmail_last)
294: qwkmail_last=msg.idx.number;
295: if(!loadmsg(&msg,mail[l].number))
296: continue;
297:
298: if(msg.hdr.auxattr&MSG_FILEATTACH && useron.qwk&QWK_ATTACH) {
299: sprintf(str,"%sfile/%04u.in/%s"
300: ,cfg.data_dir,useron.number,msg.subj);
301: sprintf(tmp,"%s%s",cfg.temp_dir,msg.subj);
302: if(fexistcase(str) && !fexistcase(tmp))
303: mv(str,tmp,1);
304: }
305:
306: size=msgtoqwk(&msg,qwk,mode,INVALID_SUB,0);
307: smb_unlockmsghdr(&smb,&msg);
308: smb_freemsgmem(&msg);
309: if(ndx) {
310: msgndx++;
311: f=ltomsbin(msgndx); /* Record number */
312: ch=0; /* Sub number, not used */
313: if(personal) {
314: fwrite(&f,4,1,personal);
315: fwrite(&ch,1,1,personal);
316: }
317: fwrite(&f,4,1,ndx);
318: fwrite(&ch,1,1,ndx);
319: msgndx+=size/QWK_BLOCK_LEN;
320: }
321: YIELD(); /* yield */
322: }
323: bprintf(text[QWKPackedEmail],mailmsgs);
324: if(ndx)
325: fclose(ndx);
326: }
327: smb_close(&smb); /* Close the e-mail */
328: if(mailmsgs)
329: free(mail);
330: }
331:
332: /*********************/
333: /* Pack new messages */
334: /*********************/
335: for(i=0;i<usrgrps;i++) {
336: for(j=0;j<usrsubs[i] && !msgabort();j++) {
337: if(subscan[usrsub[i][j]].cfg&SUB_CFG_NSCAN
338: || (!(useron.rest&FLAG('Q'))
339: && cfg.sub[usrsub[i][j]]->misc&SUB_FORCED)) {
340: if(!chk_ar(cfg.sub[usrsub[i][j]]->read_ar,&useron))
341: continue;
342: lncntr=0; /* defeat pause */
343: if(useron.rest&FLAG('Q') && !(cfg.sub[usrsub[i][j]]->misc&SUB_QNET))
344: continue; /* QWK Net Node and not QWK networked, so skip */
345:
346: subs_scanned++;
347: msgs=getlastmsg(usrsub[i][j],&lastmsg,0);
348: if(!msgs || lastmsg<=subscan[usrsub[i][j]].ptr) { /* no msgs */
349: if(subscan[usrsub[i][j]].ptr>lastmsg) { /* corrupted ptr */
350: outchar('*');
351: subscan[usrsub[i][j]].ptr=lastmsg; /* so fix automatically */
352: subscan[usrsub[i][j]].last=lastmsg;
353: }
354: bprintf(text[NScanStatusFmt]
355: ,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
356: ,cfg.sub[usrsub[i][j]]->lname,0L,msgs);
357: continue;
358: }
359:
360: sprintf(smb.file,"%s%s"
361: ,cfg.sub[usrsub[i][j]]->data_dir,cfg.sub[usrsub[i][j]]->code);
362: smb.retry_time=cfg.smb_retry_time;
363: smb.subnum=usrsub[i][j];
364: if((k=smb_open(&smb))!=0) {
365: errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
366: continue;
367: }
368:
369: k=0;
370: if(useron.qwk&QWK_BYSELF)
371: k|=LP_BYSELF;
372: if(useron.rest&FLAG('Q') || !(subscan[usrsub[i][j]].cfg&SUB_CFG_YSCAN))
373: k|=LP_OTHERS;
374: post=loadposts(&posts,usrsub[i][j],subscan[usrsub[i][j]].ptr,k);
375:
376: bprintf(text[NScanStatusFmt]
377: ,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
378: ,cfg.sub[usrsub[i][j]]->lname,posts,msgs);
379: if(!posts) { /* no new messages */
380: smb_close(&smb);
381: continue;
382: }
383: bputs(text[QWKPackingSubboard]);
384: submsgs=0;
385: conf=cfg.sub[usrsub[i][j]]->qwkconf;
386: if(!conf)
387: conf=((i+1)*1000)+j+1;
388:
389: if(!(useron.qwk&QWK_NOINDEX)) {
390: sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
391: if((ndx=fopen(str,"ab"))==NULL) {
392: fclose(qwk);
393: if(personal)
394: fclose(personal);
395: smb_close(&smb);
396: errormsg(WHERE,ERR_OPEN,str,0);
397: free(post);
398: return(false);
399: }
400: }
401: else
402: ndx=NULL;
403:
404: for(l=0;l<posts && !msgabort();l++) {
405: bprintf("\b\b\b\b\b%-5lu",l+1);
406:
407: subscan[usrsub[i][j]].ptr=post[l].number; /* set ptr */
408: subscan[usrsub[i][j]].last=post[l].number; /* set last read */
409:
410: memset(&msg,0,sizeof(msg));
411: msg.idx=post[l];
412: if(!loadmsg(&msg,post[l].number))
413: continue;
414:
415: if(useron.rest&FLAG('Q')) {
416: if(msg.from_net.type && msg.from_net.type!=NET_QWK &&
417: !(cfg.sub[usrsub[i][j]]->misc&SUB_GATE)) { /* From other */
418: smb_freemsgmem(&msg); /* net, don't gate */
419: smb_unlockmsghdr(&smb,&msg);
420: continue;
421: }
422: mode|=(QM_TO_QNET|QM_TAGLINE);
423: if(msg.from_net.type==NET_QWK) {
424: mode&=~QM_TAGLINE;
425: if(route_circ((char *)msg.from_net.addr,useron.alias)
426: || !strnicmp(msg.subj,"NE:",3)) {
427: smb_freemsgmem(&msg);
428: smb_unlockmsghdr(&smb,&msg);
429: continue;
430: }
431: }
432: }
433: else
434: mode&=~(QM_TAGLINE|QM_TO_QNET);
435:
436: size=msgtoqwk(&msg,qwk,mode,usrsub[i][j],conf);
437: smb_unlockmsghdr(&smb,&msg);
438:
439: if(ndx) {
440: msgndx++;
441: f=ltomsbin(msgndx); /* Record number */
442: ch=0; /* Sub number, not used */
443: if(personal
444: && (!stricmp(msg.to,useron.alias)
445: || !stricmp(msg.to,useron.name))) {
446: fwrite(&f,4,1,personal);
447: fwrite(&ch,1,1,personal);
448: }
449: fwrite(&f,4,1,ndx);
450: fwrite(&ch,1,1,ndx);
451: msgndx+=size/QWK_BLOCK_LEN;
452: }
453:
454: smb_freemsgmem(&msg);
455: (*msgcnt)++;
456: submsgs++;
457: if(cfg.max_qwkmsgs
458: && !(useron.exempt&FLAG('O')) && (*msgcnt)>=cfg.max_qwkmsgs) {
459: bputs(text[QWKmsgLimitReached]);
460: break;
461: }
462: if(!(l%50))
463: YIELD(); /* yield */
464: }
465: if(!(sys_status&SS_ABORT))
466: bprintf(text[QWKPackedSubboard],submsgs,(*msgcnt));
467: if(ndx) {
468: fclose(ndx);
469: sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
470: if(!flength(str))
471: remove(str);
472: }
473: smb_close(&smb);
474: free(post);
475: if(l<posts)
476: break;
477: YIELD(); /* yield */
478: }
479: }
480: if(j<usrsubs[i]) /* if sub aborted, abort all */
481: break;
482: }
483:
484: if(online==ON_LOCAL) /* event */
485: eprintf(LOG_INFO,"%s scanned %lu sub-boards for new messages"
486: ,useron.alias,subs_scanned);
487: else
488: lprintf(LOG_INFO,"Node %d %s scanned %lu sub-boards for new messages"
489: ,cfg.node_num,useron.alias,subs_scanned);
490:
491: if((*msgcnt)+mailmsgs && time(NULL)-start) {
492: bprintf("\r\n\r\n\1n\1hPacked %lu messages (%lu bytes) in %lu seconds "
493: "(%lu messages/second)."
494: ,(*msgcnt)+mailmsgs
495: ,ftell(qwk)
496: ,time(NULL)-start
497: ,((*msgcnt)+mailmsgs)/(time(NULL)-start));
498: sprintf(str,"Packed %lu messages (%lu bytes) in %lu seconds (%lu msgs/sec)"
499: ,(*msgcnt)+mailmsgs
500: ,ftell(qwk)
501: ,(ulong)(time(NULL)-start)
502: ,((*msgcnt)+mailmsgs)/(time(NULL)-start));
503: if(online==ON_LOCAL) /* event */
504: eprintf(LOG_INFO,"%s",str);
505: else
506: lprintf(LOG_INFO,"%s",str);
507: }
508:
509: fclose(qwk); /* close MESSAGE.DAT */
510: if(personal) {
511: fclose(personal); /* close PERSONAL.NDX */
512: sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
513: if(!flength(str))
514: remove(str);
515: }
516: CRLF;
517:
518: if(!prepack && (sys_status&SS_ABORT || !online))
519: return(false);
520:
521: if(/*!prepack && */ useron.rest&FLAG('Q')) { /* If QWK Net node, check for files */
522: sprintf(str,"%sqnet/%s.out/",cfg.data_dir,useron.alias);
523: dir=opendir(str);
524: while(dir!=NULL && (dirent=readdir(dir))!=NULL) { /* Move files into temp dir */
525: sprintf(str,"%sqnet/%s.out/%s",cfg.data_dir,useron.alias,dirent->d_name);
526: if(isdir(str))
527: continue;
528: sprintf(tmp2,"%s%s",cfg.temp_dir,dirent->d_name);
529: lncntr=0; /* Default pause */
530: if(online==ON_LOCAL)
531: eprintf(LOG_INFO,"Including %s in packet",str);
532: else
533: lprintf(LOG_INFO,"Including %s in packet",str);
534: bprintf(text[RetrievingFile],str);
535: if(!mv(str,tmp2,1))
536: netfiles++;
537: }
538: if(dir!=NULL)
539: closedir(dir);
540: if(netfiles)
541: CRLF;
542: }
543:
544: if(batdn_total) {
545: for(i=0,totalcdt=0;i<batdn_total;i++)
546: if(!is_download_free(&cfg,batdn_dir[i],&useron))
547: totalcdt+=batdn_cdt[i];
548: if(totalcdt>useron.cdt+useron.freecdt) {
549: bprintf(text[YouOnlyHaveNCredits]
550: ,ultoac(useron.cdt+useron.freecdt,tmp));
551: }
552: else {
553: for(i=0,totaltime=0;i<batdn_total;i++) {
554: if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
555: totaltime+=batdn_size[i]/(ulong)cur_cps;
556: }
557: if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft)
558: bputs(text[NotEnoughTimeToDl]);
559: else {
560: for(i=0;i<batdn_total;i++) {
561: lncntr=0;
562: unpadfname(batdn_name[i],tmp);
563: sprintf(tmp2,"%s%s",cfg.temp_dir,tmp);
564: if(!fexistcase(tmp2)) {
565: seqwait(cfg.dir[batdn_dir[i]]->seqdev);
566: bprintf(text[RetrievingFile],tmp);
567: sprintf(str,"%s%s"
568: ,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
569: ? cfg.altpath[batdn_alt[i]-1]
570: : cfg.dir[batdn_dir[i]]->path
571: ,tmp);
572: mv(str,tmp2,1); /* copy the file to temp dir */
573: getnodedat(cfg.node_num,&thisnode,1);
574: thisnode.aux=0xfe;
575: putnodedat(cfg.node_num,&thisnode);
576: CRLF;
577: }
578: }
579: }
580: }
581: }
582:
583: if(!(*msgcnt) && !mailmsgs && !files && !netfiles && !batdn_total
584: && (prepack || !preqwk)) {
585: bputs(text[QWKNoNewMessages]);
586: return(false);
587: }
588:
589: if(!(useron.rest&FLAG('Q'))) { /* Don't include in network */
590: /***********************/ /* packets */
591: /* Copy QWK Text files */
592: /***********************/
593: sprintf(str,"%sQWK/HELLO",cfg.text_dir);
594: if(fexistcase(str)) {
595: sprintf(tmp2,"%sHELLO",cfg.temp_dir);
596: mv(str,tmp2,1);
597: }
598: sprintf(str,"%sQWK/BBSNEWS",cfg.text_dir);
599: if(fexistcase(str)) {
600: sprintf(tmp2,"%sBBSNEWS",cfg.temp_dir);
601: mv(str,tmp2,1);
602: }
603: sprintf(str,"%sQWK/GOODBYE",cfg.text_dir);
604: if(fexistcase(str)) {
605: sprintf(tmp2,"%sGOODBYE",cfg.temp_dir);
606: mv(str,tmp2,1);
607: }
608: sprintf(str,"%sQWK/BLT-*",cfg.text_dir);
609: glob(str,0,NULL,&g);
610: for(i=0;i<(uint)g.gl_pathc;i++) { /* Copy BLT-*.* files */
611: fname=getfname(g.gl_pathv[i]);
612: padfname(fname,str);
613: if(isdigit(str[4]) && isdigit(str[9])) {
614: sprintf(str,"%sQWK/%s",cfg.text_dir,fname);
615: sprintf(tmp2,"%s%s",cfg.temp_dir,fname);
616: mv(str,tmp2,1);
617: }
618: }
619: globfree(&g);
620: }
621:
622: if(prepack) {
623: for(i=1;i<=cfg.sys_nodes;i++) {
624: getnodedat(i,&node,0);
625: if((node.status==NODE_INUSE || node.status==NODE_QUIET
626: || node.status==NODE_LOGON) && node.useron==useron.number)
627: break;
628: }
629: if(i<=cfg.sys_nodes) /* Don't pre-pack with user online */
630: return(false);
631: }
632:
633: /*******************/
634: /* Compress Packet */
635: /*******************/
636: sprintf(tmp2,"%s%s",cfg.temp_dir,ALLFILES);
637: i=external(cmdstr(temp_cmd(),packet,tmp2,NULL)
638: ,ex|EX_WILDCARD);
639: if(!fexist(packet)) {
640: bputs(text[QWKCompressionFailed]);
641: if(i)
642: errormsg(WHERE,ERR_EXEC,cmdstr(temp_cmd(),packet,tmp2,NULL),i);
643: else
644: errorlog("Couldn't compress QWK packet");
645: return(false);
646: }
647:
648: if(prepack) /* Early return if pre-packing */
649: return(true);
650:
651: l=flength(packet);
652: sprintf(str,"%s.qwk",cfg.sys_id);
653: bprintf(text[FiFilename],str);
654: bprintf(text[FiFileSize],ultoac(l,tmp));
655: if(l>0L && cur_cps)
656: i=l/(ulong)cur_cps;
657: else
658: i=0;
659: bprintf(text[FiTransferTime],sectostr(i,tmp));
660: CRLF;
661: if(!(useron.exempt&FLAG('T')) && i>timeleft) {
662: bputs(text[NotEnoughTimeToDl]);
663: return(false);
664: }
665:
666: if(useron.rest&FLAG('Q')) {
667: sprintf(str,"%s.qwk",cfg.sys_id);
668: dir=opendir(cfg.temp_dir);
669: while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
670: if(!stricmp(str,dirent->d_name)) /* QWK packet */
671: continue;
672: sprintf(tmp,"%s%s",cfg.temp_dir,dirent->d_name);
673: if(!isdir(tmp))
674: remove(tmp);
675: }
676: if(dir!=NULL)
677: closedir(dir);
678: }
679:
680: return(true);
681: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.