![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to writemsg.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs3|
Return to writemsg.cpp CVS log | Up to [Synchronet] / sbbs / sbbs3 |
1.1 root 1: /* writemsg.cpp */
2:
3: /* Synchronet message creation routines */
4:
5: /* $Id: writemsg.cpp,v 1.7 2000/12/31 03:41:55 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 2000 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: #define MAX_LINE_LEN 82L
41:
42: const char *qstr=" > %.76s\r\n";
43: void quotestr(char *str);
44:
45: /****************************************************************************/
46: /* Creates a message (post or mail) using standard line editor. 'fname' is */
47: /* is name of file to create, 'top' is a buffer to place at beginning of */
48: /* message and 'title' is the title (70chars max) for the message. */
49: /* 'dest' contains a text description of where the message is going. */
50: /****************************************************************************/
51: bool sbbs_t::writemsg(char *fname, char *top, char *title, long mode, int subnum
52: ,char *dest)
53: {
54: char str[256],quote[128],msgtmp[32],c,HUGE16 *buf,ex_mode=0,*p,*tp
55: ,useron_level;
56: char tmp[512];
57: int i,j,file,linesquoted=0;
58: long length,qlen,qtime;
59: ulong l;
60: FILE * stream;
61:
62: useron_level=useron.level;
63:
64: if((buf=(char HUGE16*)LMALLOC(cfg.level_linespermsg[useron_level]*MAX_LINE_LEN))
65: ==NULL) {
66: errormsg(WHERE,ERR_ALLOC,fname
67: ,cfg.level_linespermsg[useron_level]*MAX_LINE_LEN);
68: return(false); }
69:
70: if(mode&WM_NETMAIL ||
71: (!(mode&(WM_EMAIL|WM_NETMAIL)) && cfg.sub[subnum]->misc&SUB_PNET))
72: mode|=WM_NOTOP;
73:
74: if(useron.xedit && cfg.xedit[useron.xedit-1]->misc&QUICKBBS)
75: strcpy(msgtmp,"MSGTMP");
76: else
77: strcpy(msgtmp,"INPUT.MSG");
78:
79: if(mode&WM_QUOTE && !(useron.rest&FLAG('J'))
80: && ((mode&(WM_EMAIL|WM_NETMAIL) && cfg.sys_misc&SM_QUOTE_EM)
81: || (!(mode&(WM_EMAIL|WM_NETMAIL)) && (uint)subnum!=INVALID_SUB
82: && cfg.sub[subnum]->misc&SUB_QUOTE))) {
83:
84: /* Quote entire message to MSGTMP or INPUT.MSG */
85:
86: if(useron.xedit && cfg.xedit[useron.xedit-1]->misc"EALL) {
87: sprintf(str,"%sQUOTES.TXT",cfg.node_dir);
88: if((stream=fnopen(NULL,str,O_RDONLY))==NULL) {
89: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
90: LFREE(buf);
91: return(false);
92: }
93:
94: sprintf(str,"%s%s",cfg.node_dir,msgtmp); /* file for quoted msg */
95: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
96: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
97: LFREE(buf);
98: fclose(stream);
99: return(false);
100: }
101:
102: while(!feof(stream) && !ferror(stream)) {
103: if(!fgets(str,255,stream))
104: break;
105: quotestr(str);
106: sprintf(tmp,qstr,str);
107: write(file,tmp,strlen(tmp));
108: linesquoted++;
109: }
110: fclose(stream);
111: close(file);
112: }
113:
114: /* Quote nothing to MSGTMP or INPUT.MSG automatically */
115:
116: else if(useron.xedit && cfg.xedit[useron.xedit-1]->misc"ENONE)
117: ;
118:
119: else if(yesno(text[QuoteMessageQ])) {
120: sprintf(str,"%sQUOTES.TXT",cfg.node_dir);
121: if((stream=fnopen(&file,str,O_RDONLY))==NULL) {
122: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
123: LFREE(buf);
124: return(false); }
125:
126: sprintf(str,"%s%s",cfg.node_dir,msgtmp); /* file for quoted msg */
127: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
128: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
129: LFREE(buf);
130: fclose(stream);
131: return(false); }
132:
133: l=ftell(stream); /* l now points to start of message */
134:
135: while(online) {
136: sprintf(str,text[QuoteLinesPrompt],linesquoted ? "Done":"All");
137: mnemonics(str);
138: i=getstr(quote,10,K_UPPER);
139: if(sys_status&SS_ABORT) {
140: fclose(stream);
141: close(file);
142: LFREE(buf);
143: return(false); }
144: if(!i && linesquoted)
145: break;
146: if(!i || quote[0]=='A') { /* Quote all */
147: fseek(stream,l,SEEK_SET);
148: while(!feof(stream) && !ferror(stream)) {
149: if(!fgets(str,255,stream))
150: break;
151: quotestr(str);
152: sprintf(tmp,qstr,str);
153: write(file,tmp,strlen(tmp));
154: linesquoted++; }
155: break; }
156: if(quote[0]=='L') {
157: fseek(stream,l,SEEK_SET);
158: i=1;
159: CRLF;
160: attr(LIGHTGRAY);
161: while(!feof(stream) && !ferror(stream) && !msgabort()) {
162: if(!fgets(str,255,stream))
163: break;
164: quotestr(str);
165: bprintf("%3d: %.74s\r\n",i,str);
166: i++; }
167: continue; }
168:
169: if(!isdigit(quote[0]))
170: break;
171: p=quote;
172: while(p) {
173: if(*p==',' || *p==SP)
174: p++;
175: i=atoi(p);
176: if(!i)
177: break;
178: fseek(stream,l,SEEK_SET);
179: j=1;
180: while(!feof(stream) && !ferror(stream) && j<i) {
181: if(!fgets(tmp,255,stream))
182: break;
183: j++; } /* skip beginning */
184: tp=strchr(p,'-'); /* tp for temp pointer */
185: if(tp) { /* range */
186: i=atoi(tp+1);
187: while(!feof(stream) && !ferror(stream) && j<=i) {
188: if(!fgets(str,255,stream))
189: break;
190: quotestr(str);
191: sprintf(tmp,qstr,str);
192: write(file,tmp,strlen(tmp));
193: linesquoted++;
194: j++; } }
195: else { /* one line */
196: if(fgets(str,255,stream)) {
197: quotestr(str);
198: sprintf(tmp,qstr,str);
199: write(file,tmp,strlen(tmp));
200: linesquoted++; } }
201: p=strchr(p,',');
202: // if(!p) p=strchr(p,SP); 02/05/96 huh?
203: } }
204:
205: fclose(stream);
206: close(file); } }
207: else {
208: sprintf(str,"%sQUOTES.TXT",cfg.node_dir);
209: remove(str); }
210:
211: if(!online || sys_status&SS_ABORT) {
212: LFREE(buf);
213: return(false); }
214:
215: if(!(mode&WM_EXTDESC)) {
216: if(mode&WM_FILE) {
217: c=12;
218: CRLF;
219: bputs(text[Filename]); }
220: else {
221: c=LEN_TITLE;
222: bputs(text[TitlePrompt]); }
223: if(!(mode&(WM_EMAIL|WM_NETMAIL)) && !(mode&WM_FILE)
224: && cfg.sub[subnum]->misc&(SUB_QNET /* |SUB_PNET */ ))
225: c=25;
226: if(mode&WM_QWKNET)
227: c=25;
228: if(!getstr(title,c,mode&WM_FILE ? K_LINE|K_UPPER : K_LINE|K_EDIT|K_AUTODEL)
229: && useron_level && useron.logons) {
230: LFREE(buf);
231: return(false); }
232: if(!(mode&(WM_EMAIL|WM_NETMAIL)) && cfg.sub[subnum]->misc&SUB_QNET
233: && !SYSOP
234: && (!stricmp(title,"DROP") || !stricmp(title,"ADD")
235: || !strnicmp(dest,"SBBS",4))) {
236: LFREE(buf); /* Users can't post DROP or ADD in QWK netted subs */
237: return(false); } } /* or messages to "SBBS" */
238:
239: if(!online || sys_status&SS_ABORT) {
240: LFREE(buf);
241: return(false); }
242:
243: /* Create WWIV compatible EDITOR.INF file */
244:
245: if(useron.xedit) {
246: editor_inf(useron.xedit,dest,title,mode,subnum);
247: if(cfg.xedit[useron.xedit-1]->type) {
248: gettimeleft();
249: xtrndat(useron.alias,cfg.node_dir,cfg.xedit[useron.xedit-1]->type
250: ,timeleft,cfg.xedit[useron.xedit-1]->misc); }
251: }
252:
253: if(console&CON_RAW_IN) {
254: bprintf(text[EnterMsgNowRaw]
255: ,(ulong)cfg.level_linespermsg[useron_level]*MAX_LINE_LEN);
256: if(top[0] && !(mode&WM_NOTOP)) {
257: strcpy((char *)buf,top);
258: strcat((char *)buf,crlf);
259: l=strlen((char *)buf); }
260: else
261: l=0;
262: while(l<(ulong)(cfg.level_linespermsg[useron_level]*MAX_LINE_LEN)) {
263: c=getkey(0);
264: if(sys_status&SS_ABORT) { /* Ctrl-C */
265: LFREE(buf);
266: return(false); }
267: if((c==ESC || c==1) && useron.rest&FLAG('A')) /* ANSI restriction */
268: continue;
269: if(c==BEL && useron.rest&FLAG('B')) /* Beep restriction */
270: continue;
271: if(!(console&CON_RAW_IN)) /* Ctrl-Z was hit */
272: break;
273: outchar(c);
274: buf[l++]=c; }
275: buf[l]=0;
276: if(l==(ulong)cfg.level_linespermsg[useron_level]*MAX_LINE_LEN)
277: bputs(text[OutOfBytes]); }
278:
279:
280: else if((online==ON_LOCAL && cfg.node_misc&NM_LCL_EDIT && cfg.node_editor[0])
281: || useron.xedit) {
282:
283: if(useron.xedit && cfg.xedit[useron.xedit-1]->misc&IO_INTS) {
284: ex_mode|=EX_OUTL;
285: if(online==ON_REMOTE)
286: ex_mode|=(EX_OUTR|EX_INR);
287: if(cfg.xedit[useron.xedit-1]->misc&WWIVCOLOR)
288: ex_mode|=EX_WWIV; }
289:
290: sprintf(str,"%s%s",cfg.node_dir,msgtmp); /* temporary file for input */
291: if(!linesquoted && fexist(str))
292: remove(str);
293: if(linesquoted) {
294: qlen=flength(str);
295: qtime=fdate(str); }
296: if(online==ON_LOCAL) {
297: if(cfg.node_misc&NM_LCL_EDIT && cfg.node_editor[0])
298: external(cmdstr(cfg.node_editor,str,nulstr,NULL)
299: ,0,cfg.node_dir);
300: else
301: external(cmdstr(cfg.xedit[useron.xedit-1]->lcmd,str,nulstr,NULL)
302: ,ex_mode,cfg.node_dir); }
303:
304: else {
305: rioctl(IOCM|PAUSE|ABORT);
306: external(cmdstr(cfg.xedit[useron.xedit-1]->rcmd,str,nulstr,NULL),ex_mode,cfg.node_dir);
307: rioctl(IOSM|PAUSE|ABORT); }
308: checkline();
309: if(!fexist(str) || !online
310: || (linesquoted && qlen==flength(str) && qtime==fdate(str))) {
311: LFREE(buf);
312: return(false); }
313: buf[0]=0;
314: if(!(mode&WM_NOTOP))
315: strcpy((char *)buf,top);
316: if((file=nopen(str,O_RDONLY))==-1) {
317: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
318: LFREE(buf);
319: return(false); }
320: length=filelength(file);
321: l=strlen((char *)buf); /* reserve space for top and terminating null */
322: /* truncate if too big */
323: if(length>(long)((cfg.level_linespermsg[useron_level]*MAX_LINE_LEN)-(l+1))) {
324: length=(cfg.level_linespermsg[useron_level]*MAX_LINE_LEN)-(l+1);
325: bputs(text[OutOfBytes]); }
326: lread(file,buf+l,length);
327: close(file);
328: // remove(str); /* no need to save the temp input file */
329: buf[l+length]=0; }
330: else {
331: buf[0]=0;
332: if(linesquoted) {
333: sprintf(str,"%s%s",cfg.node_dir,msgtmp);
334: if((file=nopen(str,O_RDONLY))!=-1) {
335: length=filelength(file);
336: l=length>cfg.level_linespermsg[useron_level]*MAX_LINE_LEN
337: ? cfg.level_linespermsg[useron_level]*MAX_LINE_LEN : length;
338: lread(file,buf,l);
339: buf[l]=0;
340: close(file);
341: // remove(str);
342: } }
343: if(!(msgeditor((char *)buf,mode&WM_NOTOP ? nulstr : top,title))) {
344: LFREE(buf);
345: return(false); } }
346:
347: now=time(NULL);
348: bputs(text[Saving]);
349: if((stream=fnopen(&file,fname,O_WRONLY|O_CREAT|O_TRUNC))==NULL) {
350: errormsg(WHERE,ERR_OPEN,fname,O_WRONLY|O_CREAT|O_TRUNC);
351: LFREE(buf);
352: return(false); }
353: for(l=i=0;buf[l] && i<cfg.level_linespermsg[useron_level];l++) {
354: if((uchar)buf[l]==141 && useron.xedit
355: && cfg.xedit[useron.xedit-1]->misc&QUICKBBS) {
356: fwrite(crlf,2,1,stream);
357: i++;
358: continue; }
359: if(buf[l]==LF && (!l || buf[l-1]!=CR) && useron.xedit
360: && cfg.xedit[useron.xedit-1]->misc&EXPANDLF) {
361: fwrite(crlf,2,1,stream);
362: i++;
363: continue; }
364: if(!(mode&(WM_EMAIL|WM_NETMAIL))
365: && (!l || buf[l-1]==LF)
366: && buf[l]=='-' && buf[l+1]=='-' && buf[l+2]=='-'
367: && (buf[l+3]==SP || buf[l+3]==TAB || buf[l+3]==CR))
368: buf[l+1]='+';
369: if(buf[l]==LF)
370: i++;
371: fputc(buf[l],stream); }
372:
373: if(buf[l])
374: bputs(text[NoMoreLines]);
375: fclose(stream);
376: LFREE((char *)buf);
377: bprintf(text[SavedNBytes],l,i);
378: return(true);
379: }
380:
381: void remove_re(char *str)
382: {
383: while(!strnicmp(str,"RE:",3)) {
384: strcpy(str,str+3);
385: while(str[0]==SP)
386: strcpy(str,str+1); }
387: }
388:
389: /****************************************************************************/
390: /* Modify 'str' to for quoted format. Remove ^A codes, etc. */
391: /****************************************************************************/
392: void quotestr(char *str)
393: {
394: int j;
395:
396: j=strlen(str);
397: while(j && (str[j-1]==SP || str[j-1]==LF || str[j-1]==CR)) j--;
398: str[j]=0;
399: remove_ctrl_a(str);
400: }
401:
402: void sbbs_t::editor_inf(int xeditnum,char *dest, char *title, long mode
403: ,uint subnum)
404: {
405: char str[512];
406: int file;
407:
408: xeditnum--;
409:
410: if(cfg.xedit[xeditnum]->misc&QUICKBBS) {
411: sprintf(str,"%sMSGINF",cfg.node_dir);
412: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
413: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
414: return; }
415: sprintf(str,"%s\r\n%s\r\n%s\r\n%u\r\n%s\r\n%s\r\n"
416: ,(subnum!=INVALID_SUB && cfg.sub[subnum]->misc&SUB_NAME) ? useron.name
417: : useron.alias
418: ,dest,title,1
419: ,mode&WM_NETMAIL ? "NetMail"
420: :mode&WM_EMAIL ? "Electronic Mail"
421: :subnum==INVALID_SUB ? nulstr
422: :cfg.sub[subnum]->sname
423: ,mode&WM_PRIVATE ? "YES":"NO");
424: write(file,str,strlen(str));
425: close(file); }
426: else {
427: sprintf(str,"%sEDITOR.INF",cfg.node_dir);
428: if((file=nopen(str,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
429: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_CREAT|O_TRUNC);
430: return; }
431: sprintf(str,"%s\r\n%s\r\n%u\r\n%s\r\n%s\r\n%u\r\n"
432: ,title,dest,useron.number
433: ,(subnum!=INVALID_SUB && cfg.sub[subnum]->misc&SUB_NAME) ? useron.name
434: : useron.alias
435: ,useron.name,useron.level);
436: write(file,str,strlen(str));
437: close(file); }
438: }
439:
440:
441:
442: /****************************************************************************/
443: /* Removes from file 'str' every LF terminated line that starts with 'str2' */
444: /* That is divisable by num. Function skips first 'skip' number of lines */
445: /****************************************************************************/
446: void sbbs_t::removeline(char *str, char *str2, char num, char skip)
447: {
448: char HUGE16 *buf;
449: char slen;
450: int i,file;
451: long l=0,flen;
452: FILE *stream;
453:
454: if((file=nopen(str,O_RDONLY))==-1) {
455: errormsg(WHERE,ERR_OPEN,str,O_RDONLY);
456: return; }
457: flen=filelength(file);
458: slen=strlen(str2);
459: if((buf=(char *)MALLOC(flen))==NULL) {
460: close(file);
461: errormsg(WHERE,ERR_ALLOC,str,flen);
462: return; }
463: if(lread(file,buf,flen)!=flen) {
464: close(file);
465: errormsg(WHERE,ERR_READ,str,flen);
466: FREE(buf);
467: return; }
468: close(file);
469: if((stream=fnopen(&file,str,O_WRONLY|O_TRUNC))==NULL) {
470: close(file);
471: errormsg(WHERE,ERR_OPEN,str,O_WRONLY|O_TRUNC);
472: FREE(buf);
473: return; }
474: for(i=0;l<flen && i<skip;l++) {
475: fputc(buf[l],stream);
476: if(buf[l]==LF)
477: i++; }
478: while(l<flen) {
479: if(!strncmp((char *)buf+l,str2,slen)) {
480: for(i=0;i<num && l<flen;i++) {
481: while(l<flen && buf[l]!=LF) l++;
482: l++; } }
483: else {
484: for(i=0;i<num && l<flen;i++) {
485: while(l<flen && buf[l]!=LF) fputc(buf[l++],stream);
486: fputc(buf[l++],stream); } } }
487: fclose(stream);
488: FREE((char *)buf);
489: }
490:
491: /*****************************************************************************/
492: /* The Synchronet editor. */
493: /* Returns the number of lines edited. */
494: /*****************************************************************************/
495: ulong sbbs_t::msgeditor(char *buf, char *top, char *title)
496: {
497: int i,j,line,lines=0,maxlines;
498: char strin[256],**str,done=0;
499: char tmp[512];
500: ulong l,m;
501:
502: if(online==ON_REMOTE) {
503: rioctl(IOCM|ABORT);
504: rioctl(IOCS|ABORT); }
505:
506: maxlines=cfg.level_linespermsg[useron.level];
507:
508: if((str=(char **)MALLOC(sizeof(char *)*(maxlines+1)))==NULL) {
509: errormsg(WHERE,ERR_ALLOC,"msgeditor",sizeof(char *)*(maxlines+1));
510: return(0); }
511: m=strlen(buf);
512: l=0;
513: while(l<m && lines<maxlines) {
514: msgabort(); /* to allow pausing */
515: if((str[lines]=(char *)MALLOC(MAX_LINE_LEN))==NULL) {
516: errormsg(WHERE,ERR_ALLOC,nulstr,MAX_LINE_LEN);
517: for(i=0;i<lines;i++)
518: FREE(str[lines]);
519: FREE(str);
520: if(online==ON_REMOTE)
521: rioctl(IOSM|ABORT);
522: return(0); }
523: for(i=0;i<79 && l<m;i++,l++) {
524: if(buf[l]==CR) {
525: l+=2;
526: break; }
527: if(buf[l]==TAB) {
528: if(!(i%8)) /* hard-coded tabstop of 8 */
529: str[lines][i++]=SP; /* for expansion */
530: while(i%8 && i<79)
531: str[lines][i++]=SP;
532: i--;
533: /***
534: bprintf("\r\nMessage editor: Expanded tab on line #%d",lines+1);
535: ***/ }
536: else str[lines][i]=buf[l]; }
537: if(i==79) {
538: if(buf[l]==CR)
539: l+=2;
540: else
541: bprintf("\r\nMessage editor: Split line #%d",lines+1); }
542: str[lines][i]=0;
543: lines++; }
544: if(lines)
545: bprintf("\r\nMessage editor: Read in %d lines\r\n",lines);
546: bprintf(text[EnterMsgNow],maxlines);
547: for(i=0;i<79;i++)
548: if(i%TABSIZE || !i)
549: outchar('-');
550: else outchar('+');
551: CRLF;
552: putmsg(top,P_SAVEATR|P_NOATCODES);
553: for(line=0;line<lines && !msgabort();line++) { /* display lines in buf */
554: putmsg(str[line],P_SAVEATR|P_NOATCODES);
555: if(useron.misc&ANSI)
556: bputs("\x1b[K"); /* delete to end of line */
557: CRLF; }
558: SYNC;
559: if(online==ON_REMOTE)
560: rioctl(IOSM|ABORT);
561: while(online && !done) {
562: checkline();
563: if(line==lines) {
564: if((str[line]=(char *)MALLOC(MAX_LINE_LEN))==NULL) {
565: errormsg(WHERE,ERR_ALLOC,nulstr,MAX_LINE_LEN);
566: for(i=0;i<lines;i++)
567: FREE(str[i]);
568: FREE(str);
569: return(0); }
570: str[line][0]=0; }
571: if(line>(maxlines-10)) {
572: if(line==maxlines)
573: bputs(text[NoMoreLines]);
574: else
575: bprintf(text[OnlyNLinesLeft],maxlines-line); }
576: strcpy(strin,str[line]);
577: do {
578: if(!line)
579: outchar(CR);
580: getstr(strin,79,K_WRAP|K_MSG|K_EDIT);
581: } while(console&CON_UPARROW && !line);
582:
583: if(sys_status&SS_ABORT) {
584: if(line==lines)
585: FREE(str[line]);
586: continue; }
587: if(strin[0]=='/' && strlen(strin)<8) {
588: if(!stricmp(strin,"/DEBUG") && SYSOP) {
589: if(line==lines)
590: FREE(str[line]);
591: bprintf("\r\nline=%d lines=%d rows=%d\r\n",line,lines,rows);
592: continue; }
593: else if(!stricmp(strin,"/ABT")) {
594: if(line==lines) /* delete a line */
595: FREE(str[line]);
596: for(i=0;i<lines;i++)
597: FREE(str[i]);
598: FREE(str);
599: return(0); }
600: else if(toupper(strin[1])=='D') {
601: if(line==lines) /* delete a line */
602: FREE(str[line]);
603: if(!lines)
604: continue;
605: i=atoi(strin+2)-1;
606: if(i==-1) /* /D means delete last line */
607: i=lines-1;
608: if(i>=lines || i<0)
609: bputs(text[InvalidLineNumber]);
610: else {
611: FREE(str[i]);
612: lines--;
613: while(i<lines) {
614: str[i]=str[i+1];
615: i++; }
616: if(line>lines)
617: line=lines; }
618: continue; }
619: else if(toupper(strin[1])=='I') {
620: if(line==lines) /* insert a line before number x */
621: FREE(str[line]);
622: if(line==maxlines || !lines)
623: continue;
624: i=atoi(strin+2)-1;
625: if(i==-1)
626: i=lines-1;
627: if(i>=lines || i<0)
628: bputs(text[InvalidLineNumber]);
629: else {
630: for(line=lines;line>i;line--) /* move the pointers */
631: str[line]=str[line-1];
632: if((str[i]=(char *)MALLOC(MAX_LINE_LEN))==NULL) {
633: errormsg(WHERE,ERR_ALLOC,nulstr,MAX_LINE_LEN);
634: for(i=0;i<lines;i++)
635: FREE(str[i]);
636: FREE(str);
637: return(0); }
638: str[i][0]=0;
639: line=++lines; }
640: continue; }
641: else if(toupper(strin[1])=='E') {
642: if(line==lines) /* edit a line */
643: FREE(str[line]);
644: if(!lines)
645: continue;
646: i=atoi(strin+2)-1;
647: j=K_MSG|K_EDIT; /* use j for the getstr mode */
648: if(i==-1) { /* /E means edit last line */
649: i=lines-1;
650: j|=K_WRAP; } /* wrap when editing last line */
651: if(i>=lines || i<0)
652: bputs(text[InvalidLineNumber]);
653: else
654: getstr(str[i],79,j);
655: continue; }
656: else if(!stricmp(strin,"/CLR")) {
657: bputs(text[MsgCleared]);
658: if(line!=lines)
659: lines--;
660: for(i=0;i<=lines;i++)
661: FREE(str[i]);
662: line=0;
663: lines=0;
664: putmsg(top,P_SAVEATR|P_NOATCODES);
665: continue; }
666: else if(toupper(strin[1])=='L') { /* list message */
667: if(line==lines)
668: FREE(str[line]);
669: if(lines)
670: i=!noyes(text[WithLineNumbersQ]);
671: CRLF;
672: attr(LIGHTGRAY);
673: putmsg(top,P_SAVEATR|P_NOATCODES);
674: if(!lines) {
675: continue; }
676: j=atoi(strin+2);
677: if(j) j--; /* start from line j */
678: while(j<lines && !msgabort()) {
679: if(i) { /* line numbers */
680: sprintf(tmp,"%3d: %-.74s",j+1,str[j]);
681: putmsg(tmp,P_SAVEATR|P_NOATCODES); }
682: else
683: putmsg(str[j],P_SAVEATR|P_NOATCODES);
684: if(useron.misc&ANSI)
685: bputs("\x1b[K"); /* delete to end of line */
686: CRLF;
687: j++; }
688: SYNC;
689: continue; }
690: else if(!stricmp(strin,"/S")) { /* Save */
691: if(line==lines)
692: FREE(str[line]);
693: done=1;
694: continue;}
695: else if(!stricmp(strin,"/T")) { /* Edit title */
696: if(line==lines)
697: FREE(str[line]);
698: if(title[0]) {
699: bputs(text[TitlePrompt]);
700: getstr(title,LEN_TITLE,K_LINE|K_EDIT|K_AUTODEL);
701: SYNC;
702: CRLF; }
703: continue; }
704: else if(!stricmp(strin,"/?")) {
705: if(line==lines)
706: FREE(str[line]);
707: menu("editor"); /* User Editor Commands */
708: SYNC;
709: continue; }
710: else if(!stricmp(strin,"/ATTR")) {
711: if(line==lines)
712: FREE(str[line]);
713: menu("attr"); /* User ANSI Commands */
714: SYNC;
715: continue; } }
716: strcpy(str[line],strin);
717: if(line<maxlines)
718: line++;
719: else
720: FREE(str[line]);
721: if(line>lines)
722: lines++;
723: if(console&CON_UPARROW) {
724: outchar(CR);
725: bprintf("\x1b[A\x1b[K"); /* up one line, clear to eol */
726: line-=2; }
727: }
728: if(!online) {
729: for(i=0;i<lines;i++)
730: FREE(str[i]);
731: FREE(str);
732: return(0); }
733: strcpy(buf,top);
734: for(i=0;i<lines;i++) {
735: strcat(buf,str[i]);
736: strcat(buf,crlf);
737: FREE(str[i]); }
738: FREE(str);
739: return(lines);
740: }
741:
742:
743: /****************************************************************************/
744: /* Edits an existing file or creates a new one in MSG format */
745: /****************************************************************************/
746: void sbbs_t::editfile(char *str)
747: {
748: char *buf,str2[128],mode=0; /* EX_CC */
749: int file;
750: long length,maxlines,lines,l;
751:
752: maxlines=cfg.level_linespermsg[useron.level];
753: sprintf(str2,"%sQUOTES.TXT",cfg.node_dir);
754: remove(str2);
755: if(cfg.node_editor[0] && online==ON_LOCAL) {
756: external(cmdstr(cfg.node_editor,str,nulstr,NULL),0,cfg.node_dir);
757: return; }
758: if(useron.xedit) {
759: editor_inf(useron.xedit,nulstr,nulstr,0,INVALID_SUB);
760: if(cfg.xedit[useron.xedit-1]->misc&IO_INTS) {
761: mode|=EX_OUTL;
762: if(online==ON_REMOTE)
763: mode|=(EX_OUTR|EX_INR);
764: if(cfg.xedit[useron.xedit-1]->misc&WWIVCOLOR)
765: mode|=EX_WWIV; }
766: if(online==ON_LOCAL)
767: external(cmdstr(cfg.xedit[useron.xedit-1]->lcmd,str,nulstr,NULL),mode,cfg.node_dir);
768: else {
769: rioctl(IOCM|PAUSE|ABORT);
770: external(cmdstr(cfg.xedit[useron.xedit-1]->rcmd,str,nulstr,NULL),mode,cfg.node_dir);
771: rioctl(IOSM|PAUSE|ABORT); }
772: return; }
773: if((buf=(char *)MALLOC(maxlines*MAX_LINE_LEN))==NULL) {
774: errormsg(WHERE,ERR_ALLOC,nulstr,maxlines*MAX_LINE_LEN);
775: return; }
776: if((file=nopen(str,O_RDONLY))!=-1) {
777: length=filelength(file);
778: if(length>(long)maxlines*MAX_LINE_LEN) {
779: attr(cfg.color[clr_err]);
780: bprintf("\7\r\nFile size (%lu bytes) is larger than (%lu).\r\n"
781: ,length,(ulong)maxlines*MAX_LINE_LEN);
782: close(file);
783: FREE(buf); }
784: if(read(file,buf,length)!=length) {
785: close(file);
786: FREE(buf);
787: errormsg(WHERE,ERR_READ,str,length);
788: return; }
789: buf[length]=0;
790: close(file); }
791: else {
792: buf[0]=0;
793: bputs(text[NewFile]); }
794: if(!msgeditor(buf,nulstr,nulstr)) {
795: FREE(buf);
796: return; }
797: bputs(text[Saving]);
798: if((file=nopen(str,O_CREAT|O_WRONLY|O_TRUNC))==-1) {
799: errormsg(WHERE,ERR_OPEN,str,O_CREAT|O_WRONLY|O_TRUNC);
800: FREE(buf);
801: return; }
802: if((size_t)write(file,buf,strlen(buf))!=strlen(buf)) {
803: close(file);
804: errormsg(WHERE,ERR_WRITE,str,strlen(buf));
805: FREE(buf);
806: return; }
807: for(l=lines=0;buf[l];l++)
808: if(buf[l]==LF)
809: lines++;
810: bprintf(text[SavedNBytes],l,lines);
811: close(file);
812: FREE(buf);
813: return;
814: }
815:
816: /*************************/
817: /* Copy file attachments */
818: /*************************/
819: void sbbs_t::copyfattach(uint to, uint from, char *title)
820: {
821: char str[128],str2[128],str3[128],*tp,*sp,*p;
822:
823: strcpy(str,title);
824: tp=str;
825: while(1) {
826: p=strchr(tp,SP);
827: if(p) *p=0;
828: sp=strrchr(tp,'/'); /* sp is slash pointer */
829: if(!sp) sp=strrchr(tp,'\\');
830: if(sp) tp=sp+1;
831: sprintf(str2,"%sfile/%04u.in/%s" /* str2 is path/fname */
832: ,cfg.data_dir,to,tp);
833: sprintf(str3,"%sfile/%04u.in/%s" /* str2 is path/fname */
834: ,cfg.data_dir,from,tp);
835: if(strcmp(str2,str3))
836: mv(str3,str2,1);
837: if(!p)
838: break;
839: tp=p+1; }
840: }
841:
842:
843: /****************************************************************************/
844: /* Forwards mail (fname) to usernumber */
845: /* Called from function readmail */
846: /****************************************************************************/
847: void sbbs_t::forwardmail(smbmsg_t *msg, int usernumber)
848: {
849: char str[256],touser[128];
850: char tmp[512];
851: int i;
852: node_t node;
853: msghdr_t hdr=msg->hdr;
854: idxrec_t idx=msg->idx;
855:
856: if(useron.etoday>=cfg.level_emailperday[useron.level] && !SYSOP) {
857: bputs(text[TooManyEmailsToday]);
858: return; }
859: if(useron.rest&FLAG('F')) {
860: bputs(text[R_Forward]);
861: return; }
862: if(usernumber==1 && useron.rest&FLAG('S')) {
863: bprintf(text[R_Feedback],cfg.sys_op);
864: return; }
865: if(usernumber!=1 && useron.rest&FLAG('E')) {
866: bputs(text[R_Email]);
867: return; }
868:
869: msg->idx.attr&=~(MSG_READ|MSG_DELETE);
870: msg->hdr.attr=msg->idx.attr;
871:
872:
873: smb_hfield(msg,SENDER,strlen(useron.alias),useron.alias);
874: sprintf(str,"%u",useron.number);
875: smb_hfield(msg,SENDEREXT,strlen(str),str);
876:
877: username(&cfg,usernumber,touser);
878: smb_hfield(msg,RECIPIENT,strlen(touser),touser);
879: sprintf(str,"%u",usernumber);
880: smb_hfield(msg,RECIPIENTEXT,sizeof(str),str);
881: msg->idx.to=usernumber;
882:
883: now=time(NULL);
884: smb_hfield(msg,FORWARDED,sizeof(time_t),&now);
885:
886:
887: if((i=smb_open_da(&smb))!=0) {
888: errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
889: return; }
890: if((i=smb_incdat(&smb,msg->hdr.offset,smb_getmsgdatlen(msg),1))!=0) {
891: errormsg(WHERE,ERR_WRITE,smb.file,i);
892: return; }
893: smb_close_da(&smb);
894:
895:
896: if((i=smb_addmsghdr(&smb,msg,SMB_SELFPACK))!=0) {
897: errormsg(WHERE,ERR_WRITE,smb.file,i);
898: return; }
899:
900: if(msg->hdr.auxattr&MSG_FILEATTACH)
901: copyfattach(usernumber,useron.number,msg->subj);
902:
903: bprintf(text[Forwarded],username(&cfg,usernumber,str),usernumber);
904: sprintf(str,"Forwarded mail to %s #%d",username(&cfg,usernumber,tmp)
905: ,usernumber);
906: logline("E",str);
907: msg->idx=idx;
908: msg->hdr=hdr;
909:
910:
911: if(usernumber==1) {
912: useron.fbacks++;
913: logon_fbacks++;
914: putuserrec(&cfg,useron.number,U_FBACKS,5,ultoa(useron.fbacks,tmp,10)); }
915: else {
916: useron.emails++;
917: logon_emails++;
918: putuserrec(&cfg,useron.number,U_EMAILS,5,ultoa(useron.emails,tmp,10)); }
919: useron.etoday++;
920: putuserrec(&cfg,useron.number,U_ETODAY,5,ultoa(useron.etoday,tmp,10));
921:
922: for(i=1;i<=cfg.sys_nodes;i++) { /* Tell user, if online */
923: getnodedat(i,&node,0);
924: if(node.useron==usernumber && !(node.misc&NODE_POFF)
925: && (node.status==NODE_INUSE || node.status==NODE_QUIET)) {
926: sprintf(str,text[EmailNodeMsg],cfg.node_num,useron.alias);
927: putnmsg(i,str);
928: break; } }
929: if(i>cfg.sys_nodes) { /* User wasn't online, so leave short msg */
930: sprintf(str,text[UserSentYouMail],useron.alias);
931: putsmsg(&cfg,usernumber,str); }
932: }
933:
934: /****************************************************************************/
935: /* Auto-Message Routine ('A' from the main menu) */
936: /****************************************************************************/
937: void sbbs_t::automsg()
938: {
939: char str[256],buf[300],anon=0;
940: char tmp[512];
941: char automsg[MAX_PATH];
942: int file;
943:
944: sprintf(automsg,"%smsgs/auto.msg",cfg.data_dir);
945: while(online) {
946: SYNC;
947: mnemonics(text[AutoMsg]);
948: switch(getkeys("RWQ",0)) {
949: case 'R':
950: printfile(automsg,P_NOABORT|P_NOATCODES);
951: break;
952: case 'W':
953: if(useron.rest&FLAG('W')) {
954: bputs(text[R_AutoMsg]);
955: break; }
956: action=NODE_AMSG;
957: SYNC;
958: bputs("\r\n3 lines:\r\n");
959: if(!getstr(str,68,K_WRAP|K_MSG))
960: break;
961: strcpy(buf,str);
962: strcat(buf,"\r\n ");
963: getstr(str,68,K_WRAP|K_MSG);
964: strcat(buf,str);
965: strcat(buf,"\r\n ");
966: getstr(str,68,K_MSG);
967: strcat(str,crlf);
968: strcat(buf,str);
969: if(yesno(text[OK])) {
970: if(useron.exempt&FLAG('A')) {
971: if(!noyes(text[AnonymousQ]))
972: anon=1; }
973: if((file=nopen(automsg,O_WRONLY|O_CREAT|O_TRUNC))==-1) {
974: errormsg(WHERE,ERR_OPEN,automsg,O_WRONLY|O_CREAT|O_TRUNC);
975: return; }
976: if(anon)
977: sprintf(tmp,"%.80s",text[Anonymous]);
978: else
979: sprintf(tmp,"%s #%d",useron.alias,useron.number);
980: sprintf(str,text[AutoMsgBy],tmp);
981: strcat(str," ");
982: write(file,str,strlen(str));
983: write(file,buf,strlen(buf));
984: close(file); }
985: break;
986: case 'Q':
987: return; } }
988: }
989:
990: /****************************************************************************/
991: /* Edits messages */
992: /****************************************************************************/
993: void sbbs_t::editmsg(smbmsg_t *msg, uint subnum)
994: {
995: char str[256],buf[SDT_BLOCK_LEN];
996: ushort xlat;
997: int file,i,j,x;
998: ulong length,offset;
999: FILE *instream;
1000:
1001: if(!msg->hdr.total_dfields)
1002: return;
1003: sprintf(str,"%sINPUT.MSG",cfg.node_dir);
1004: remove(str);
1005: msgtotxt(msg,str,0,1);
1006: editfile(str);
1007: length=flength(str)+2; /* +2 for translation string */
1008: if(length<1L)
1009: return;
1010:
1011: if((i=smb_locksmbhdr(&smb))!=0) {
1012: errormsg(WHERE,ERR_LOCK,smb.file,i);
1013: return; }
1014:
1015: if((i=smb_getstatus(&smb))!=0) {
1016: errormsg(WHERE,ERR_READ,smb.file,i);
1017: return; }
1018:
1019: if(!(smb.status.attr&SMB_HYPERALLOC)) {
1020: if((i=smb_open_da(&smb))!=0) {
1021: errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
1022: return; }
1023: for(x=0;x<msg->hdr.total_dfields;x++)
1024: if((i=smb_freemsgdat(&smb,msg->hdr.offset+msg->dfield[x].offset
1025: ,msg->dfield[x].length,1))!=0)
1026: errormsg(WHERE,ERR_WRITE,smb.file,i,smb.last_error); }
1027:
1028: msg->dfield[0].type=TEXT_BODY; /* Make one single data field */
1029: msg->dfield[0].length=length;
1030: msg->dfield[0].offset=0;
1031: for(x=1;x<msg->hdr.total_dfields;x++) { /* Clear the other data fields */
1032: msg->dfield[x].type=UNUSED; /* so we leave the header length */
1033: msg->dfield[x].length=0; /* unchanged */
1034: msg->dfield[x].offset=0; }
1035:
1036:
1037: if(smb.status.attr&SMB_HYPERALLOC) {
1038: offset=smb_hallocdat(&smb); }
1039: else {
1040: if((subnum!=INVALID_SUB && cfg.sub[subnum]->misc&SUB_FAST)
1041: || (subnum==INVALID_SUB && cfg.sys_misc&SM_FASTMAIL))
1042: offset=smb_fallocdat(&smb,length,1);
1043: else
1044: offset=smb_allocdat(&smb,length,1);
1045: smb_close_da(&smb); }
1046:
1047: msg->hdr.offset=offset;
1048: if((file=open(str,O_RDONLY|O_BINARY))==-1
1049: || (instream=fdopen(file,"rb"))==NULL) {
1050: smb_unlocksmbhdr(&smb);
1051: smb_freemsgdat(&smb,offset,length,1);
1052: errormsg(WHERE,ERR_OPEN,str,O_RDONLY|O_BINARY);
1053: return; }
1054:
1055: setvbuf(instream,NULL,_IOFBF,2*1024);
1056: fseek(smb.sdt_fp,offset,SEEK_SET);
1057: xlat=XLAT_NONE;
1058: fwrite(&xlat,2,1,smb.sdt_fp);
1059: x=SDT_BLOCK_LEN-2; /* Don't read/write more than 255 */
1060: while(!feof(instream)) {
1061: memset(buf,0,x);
1062: j=fread(buf,1,x,instream);
1063: if((j!=x || feof(instream)) && buf[j-1]==LF && buf[j-2]==CR)
1064: buf[j-1]=buf[j-2]=0; /* Convert to NULL */
1065: fwrite(buf,j,1,smb.sdt_fp);
1066: x=SDT_BLOCK_LEN; }
1067: fflush(smb.sdt_fp);
1068: fclose(instream);
1069:
1070: smb_unlocksmbhdr(&smb);
1071: msg->hdr.length=smb_getmsghdrlen(msg);
1072: if((i=smb_putmsghdr(&smb,msg))!=0)
1073: errormsg(WHERE,ERR_WRITE,smb.file,i);
1074: }
1075:
1076: /****************************************************************************/
1077: /* Moves a message from one message base to another */
1078: /****************************************************************************/
1079: bool sbbs_t::movemsg(smbmsg_t* msg, uint subnum)
1080: {
1081: char str[256],*buf;
1082: uint i;
1083: int file,newgrp,newsub,storage;
1084: ulong offset,length;
1085:
1086: for(i=0;i<usrgrps;i++) /* Select New Group */
1087: uselect(1,i,"Message Group",cfg.grp[usrgrp[i]]->lname,0);
1088: if((newgrp=uselect(0,0,0,0,0))<0)
1089: return(false);
1090:
1091: for(i=0;i<usrsubs[newgrp];i++) /* Select New Sub-Board */
1092: uselect(1,i,"Sub-Board",cfg.sub[usrsub[newgrp][i]]->lname,0);
1093: if((newsub=uselect(0,0,0,0,0))<0)
1094: return(false);
1095: newsub=usrsub[newgrp][newsub];
1096:
1097: length=smb_getmsgdatlen(msg);
1098: if((buf=(char *)MALLOC(length))==NULL) {
1099: errormsg(WHERE,ERR_ALLOC,smb.file,length);
1100: return(false); }
1101:
1102: fseek(smb.sdt_fp,msg->hdr.offset,SEEK_SET);
1103: fread(buf,length,1,smb.sdt_fp);
1104:
1105: if((i=smb_stack(&smb,SMB_STACK_PUSH))!=0) {
1106: FREE(buf);
1107: errormsg(WHERE,ERR_OPEN,cfg.sub[newsub]->code,i);
1108: return(false); }
1109:
1110: sprintf(smb.file,"%s%s",cfg.sub[newsub]->data_dir,cfg.sub[newsub]->code);
1111: smb.retry_time=cfg.smb_retry_time;
1112: if((i=smb_open(&smb))!=0) {
1113: FREE(buf);
1114: smb_stack(&smb,SMB_STACK_POP);
1115: errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
1116: return(false); }
1117:
1118: if(filelength(fileno(smb.shd_fp))<1) { /* Create it if it doesn't exist */
1119: smb.status.max_crcs=cfg.sub[newsub]->maxcrcs;
1120: smb.status.max_msgs=cfg.sub[newsub]->maxmsgs;
1121: smb.status.max_age=cfg.sub[newsub]->maxage;
1122: smb.status.attr=cfg.sub[newsub]->misc&SUB_HYPER ? SMB_HYPERALLOC :0;
1123: if((i=smb_create(&smb))!=0) {
1124: FREE(buf);
1125: smb_close(&smb);
1126: smb_stack(&smb,SMB_STACK_POP);
1127: errormsg(WHERE,ERR_CREATE,smb.file,i);
1128: return(false); } }
1129:
1130: if((i=smb_locksmbhdr(&smb))!=0) {
1131: FREE(buf);
1132: smb_close(&smb);
1133: smb_stack(&smb,SMB_STACK_POP);
1134: errormsg(WHERE,ERR_LOCK,smb.file,i);
1135: return(false); }
1136:
1137: if((i=smb_getstatus(&smb))!=0) {
1138: FREE(buf);
1139: smb_close(&smb);
1140: smb_stack(&smb,SMB_STACK_POP);
1141: errormsg(WHERE,ERR_READ,smb.file,i);
1142: return(false); }
1143:
1144: if(smb.status.attr&SMB_HYPERALLOC) {
1145: offset=smb_hallocdat(&smb);
1146: storage=SMB_HYPERALLOC; }
1147: else {
1148: if((i=smb_open_da(&smb))!=0) {
1149: FREE(buf);
1150: smb_close(&smb);
1151: smb_stack(&smb,SMB_STACK_POP);
1152: errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
1153: return(false); }
1154: if(cfg.sub[newsub]->misc&SUB_FAST) {
1155: offset=smb_fallocdat(&smb,length,1);
1156: storage=SMB_FASTALLOC; }
1157: else {
1158: offset=smb_allocdat(&smb,length,1);
1159: storage=SMB_SELFPACK; }
1160: smb_close_da(&smb); }
1161:
1162: msg->hdr.offset=offset;
1163:
1164: memcpy(msg->hdr.id,"SHD\x1a",4);
1165: msg->hdr.version=smb_ver();
1166:
1167: smb_unlocksmbhdr(&smb);
1168:
1169: fseek(smb.sdt_fp,offset,SEEK_SET);
1170: fwrite(buf,length,1,smb.sdt_fp);
1171: fflush(smb.sdt_fp);
1172: FREE(buf);
1173:
1174: i=smb_addmsghdr(&smb,msg,storage);
1175: smb_close(&smb);
1176: smb_stack(&smb,SMB_STACK_POP);
1177:
1178: if(i) {
1179: smb_freemsgdat(&smb,offset,length,1);
1180: errormsg(WHERE,ERR_WRITE,smb.file,i);
1181: return(false); }
1182:
1183: bprintf("\r\nMoved to %s %s\r\n\r\n"
1184: ,cfg.grp[usrgrp[newgrp]]->sname,cfg.sub[newsub]->lname);
1185: sprintf(str,"Moved message from %s %s to %s %s"
1186: ,cfg.grp[newgrp]->sname,cfg.sub[newsub]->sname
1187: ,cfg.grp[cfg.sub[subnum]->grp]->sname,cfg.sub[subnum]->sname);
1188: logline("M+",str);
1189: if(cfg.sub[newsub]->misc&SUB_FIDO && cfg.sub[newsub]->echomail_sem[0])
1190: if((file=nopen(cmdstr(cfg.sub[newsub]->echomail_sem,nulstr,nulstr,NULL)
1191: ,O_WRONLY|O_CREAT|O_TRUNC))!=-1)
1192: close(file);
1193: return(true);
1194: }
1195:
1196: ushort sbbs_t::chmsgattr(ushort attr)
1197: {
1198: int ch;
1199:
1200: while(online && !(sys_status&SS_ABORT)) {
1201: CRLF;
1202: show_msgattr(attr);
1203: menu("msgattr");
1204: ch=getkey(K_UPPER);
1205: if(ch)
1206: bprintf("%c\r\n",ch);
1207: switch(ch) {
1208: case 'P':
1209: attr^=MSG_PRIVATE;
1210: break;
1211: case 'R':
1212: attr^=MSG_READ;
1213: break;
1214: case 'K':
1215: attr^=MSG_KILLREAD;
1216: break;
1217: case 'A':
1218: attr^=MSG_ANONYMOUS;
1219: break;
1220: case 'N': /* Non-purgeable */
1221: attr^=MSG_PERMANENT;
1222: break;
1223: case 'M':
1224: attr^=MSG_MODERATED;
1225: break;
1226: case 'V':
1227: attr^=MSG_VALIDATED;
1228: break;
1229: case 'D':
1230: attr^=MSG_DELETE;
1231: break;
1232: case 'L':
1233: attr^=MSG_LOCKED;
1234: break;
1235: default:
1236: return(attr); } }
1237: return(attr);
1238: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.