![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msg1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2|
Return to msg1.c CVS log | Up to [Synchronet] / sbbs / sbbs2 |
1.1 root 1: #line 1 "MSG1.C"
2:
3: /* Developed 1990-1997 by Rob Swindell; PO Box 501, Yorba Linda, CA 92885 */
4:
5: /***********************************************************************/
6: /* Functions that do i/o with messages (posts/mail/auto) or their data */
7: /***********************************************************************/
8:
9: #include "sbbs.h"
10:
11: #define LZH 1
12:
13: void lfputs(char HUGE16 *buf, FILE *fp)
14: {
15: while(*buf) {
16: fputc(*buf,fp);
17: buf++; }
18: }
19:
20: /****************************************************************************/
21: /* Loads an SMB message from the open msg base the fastest way possible */
22: /* first by offset, and if that's the wrong message, then by number. */
23: /* Returns 1 if the message was loaded and left locked, otherwise */
24: /****************************************************************************/
25: int loadmsg(smbmsg_t *msg, ulong number)
26: {
27: char str[128];
28: int i;
29:
30: if(msg->idx.offset) { /* Load by offset if specified */
31:
32: if((i=smb_lockmsghdr(&smb,msg))!=0) {
33: errormsg(WHERE,ERR_LOCK,smb.file,i);
34: return(0); }
35:
36: i=smb_getmsghdr(&smb,msg);
37: if(!i && msg->hdr.number==number)
38: return(1);
39:
40: /* Wrong offset */
41:
42: if(!i) {
43: smb_freemsgmem(msg);
44: msg->total_hfields=0; }
45:
46: smb_unlockmsghdr(&smb,msg); }
47:
48: msg->hdr.number=number;
49: if((i=smb_getmsgidx(&smb,msg))!=0) /* Message is deleted */
50: return(0);
51: if((i=smb_lockmsghdr(&smb,msg))!=0) {
52: errormsg(WHERE,ERR_LOCK,smb.file,i);
53: return(0); }
54: if((i=smb_getmsghdr(&smb,msg))!=0) {
55: sprintf(str,"(%06lX) #%lu/%lu %s",msg->idx.offset,msg->idx.number
56: ,number,smb.file);
57: smb_unlockmsghdr(&smb,msg);
58: errormsg(WHERE,ERR_READ,str,i);
59: return(0); }
60: return(msg->total_hfields);
61: }
62:
63: /****************************************************************************/
64: /* Displays a text file to the screen, reading/display a block at time */
65: /****************************************************************************/
66: void putmsg_fp(FILE *fp, long length, int mode)
67: {
68: uchar *buf,tmpatr;
69: int i,j,b=8192,orgcon=console;
70: long l;
71:
72: tmpatr=curatr; /* was lclatr(-1) */
73: if((buf=MALLOC(b+1))==NULL) {
74: errormsg(WHERE,ERR_ALLOC,nulstr,b+1L);
75: return; }
76: for(l=0;l<length;l+=b) {
77: if(l+b>length)
78: b=length-l;
79: i=j=fread(buf,1,b,fp);
80: if(!j) break; /* No bytes read */
81: if(l+i<length) /* Not last block */
82: while(i && buf[i-1]!=LF) i--; /* Search for last LF */
83: if(!i) i=j; /* None found */
84: buf[i]=0;
85: if(i<j)
86: fseek(fp,(long)-(j-i),SEEK_CUR);
87: b=i;
88: if(putmsg(buf,mode|P_SAVEATR))
89: break; }
90: if(!(mode&P_SAVEATR)) {
91: console=orgcon;
92: attr(tmpatr); }
93: FREE(buf);
94: }
95:
96: void show_msgattr(ushort attr)
97: {
98:
99: bprintf(text[MsgAttr]
100: ,attr&MSG_PRIVATE ? "Private " :nulstr
101: ,attr&MSG_READ ? "Read " :nulstr
102: ,attr&MSG_DELETE ? "Deleted " :nulstr
103: ,attr&MSG_KILLREAD ? "Kill " :nulstr
104: ,attr&MSG_ANONYMOUS ? "Anonymous " :nulstr
105: ,attr&MSG_LOCKED ? "Locked " :nulstr
106: ,attr&MSG_PERMANENT ? "Permanent " :nulstr
107: ,attr&MSG_MODERATED ? "Moderated " :nulstr
108: ,attr&MSG_VALIDATED ? "Validated " :nulstr
109: );
110: }
111:
112: /****************************************************************************/
113: /* Displays a message header to the screen */
114: /****************************************************************************/
115: void show_msghdr(smbmsg_t msg)
116: {
117: char *sender=NULL;
118: int i;
119:
120: attr(LIGHTGRAY);
121: if(useron.misc&CLRSCRN)
122: outchar(FF);
123: else
124: CRLF;
125: bprintf(text[MsgSubj],msg.subj);
126: if(msg.hdr.attr)
127: show_msgattr(msg.hdr.attr);
128:
129: bprintf(text[MsgTo],msg.to);
130: if(msg.to_ext)
131: bprintf(text[MsgToExt],msg.to_ext);
132: if(msg.to_net.addr)
133: bprintf(text[MsgToNet],msg.to_net.type==NET_FIDO
134: ? faddrtoa(*(faddr_t *)msg.to_net.addr) : msg.to_net.addr);
135: if(!(msg.hdr.attr&MSG_ANONYMOUS) || SYSOP) {
136: bprintf(text[MsgFrom],msg.from);
137: if(msg.from_ext)
138: bprintf(text[MsgFromExt],msg.from_ext);
139: if(msg.from_net.addr)
140: bprintf(text[MsgFromNet],msg.from_net.type==NET_FIDO
141: ? faddrtoa(*(faddr_t *)msg.from_net.addr)
142: : msg.from_net.addr); }
143: bprintf(text[MsgDate]
144: ,timestr((time_t *)&msg.hdr.when_written.time)
145: ,zonestr(msg.hdr.when_written.zone));
146:
147: CRLF;
148:
149: for(i=0;i<msg.total_hfields;i++) {
150: if(msg.hfield[i].type==SENDER)
151: sender=msg.hfield_dat[i];
152: if(msg.hfield[i].type==FORWARDED && sender)
153: bprintf(text[ForwardedFrom],sender
154: ,timestr((time_t *)msg.hfield_dat[i])); }
155:
156: /* Debug stuff
157: if(SYSOP) {
158: bprintf("\1n\1c\r\nAux : \1h%08lX",msg.hdr.auxattr);
159: bprintf("\1n\1c\r\nNum : \1h%lu",msg.hdr.number); }
160: */
161:
162: CRLF;
163: }
164:
165: #if !LZH
166:
167: /****************************************************************************/
168: /* Displays message header and text (if not deleted) */
169: /****************************************************************************/
170: void show_msg(smbmsg_t msg, int mode)
171: {
172: ushort xlat;
173: int i;
174:
175: show_msghdr(msg);
176: for(i=0;i<msg.hdr.total_dfields;i++)
177: switch(msg.dfield[i].type) {
178: case TEXT_BODY:
179: case TEXT_TAIL:
180: fseek(smb.sdt_fp,msg.hdr.offset+msg.dfield[i].offset
181: ,SEEK_SET);
182: fread(&xlat,2,1,smb.sdt_fp);
183: if(xlat!=XLAT_NONE) /* no translations supported */
184: continue;
185: putmsg_fp(smb.sdt_fp,msg.dfield[i].length-2,mode);
186: CRLF;
187: break; }
188: }
189:
190: #else
191:
192: /****************************************************************************/
193: /* Displays message header and text (if not deleted) */
194: /****************************************************************************/
195: void show_msg(smbmsg_t msg, int mode)
196: {
197: char *inbuf,*lzhbuf;
198: ushort xlat;
199: int i,lzh;
200: long lzhlen,length;
201:
202: show_msghdr(msg);
203: for(i=0;i<msg.hdr.total_dfields;i++)
204: switch(msg.dfield[i].type) {
205: case TEXT_BODY:
206: case TEXT_TAIL:
207: fseek(smb.sdt_fp,msg.hdr.offset+msg.dfield[i].offset
208: ,SEEK_SET);
209: fread(&xlat,2,1,smb.sdt_fp);
210: lzh=0;
211: if(xlat==XLAT_LZH) {
212: lzh=1;
213: fread(&xlat,2,1,smb.sdt_fp); }
214: if(xlat!=XLAT_NONE) /* no translations supported */
215: continue;
216: if(lzh) {
217: length=msg.dfield[i].length-4;
218: if((inbuf=MALLOC(length))==NULL) {
219: errormsg(WHERE,ERR_ALLOC,nulstr,length);
220: continue; }
221: fread(inbuf,length,1,smb.sdt_fp);
222: lzhlen=*(long *)inbuf;
223: /**
224: if(SYSOP)
225: bprintf("Decoding %lu bytes of LZH into %lu bytes of text "
226: "(%d%% compression)"
227: ,length,lzhlen
228: ,(int)(((float)(lzhlen-length)/lzhlen)*100.0));
229: **/
230: if((lzhbuf=MALLOC(lzhlen+2L))==NULL) {
231: FREE(inbuf);
232: errormsg(WHERE,ERR_ALLOC,nulstr,lzhlen+2L);
233: continue; }
234: lzh_decode(inbuf,length,lzhbuf);
235: lzhbuf[lzhlen]=0;
236: // CRLF;
237: putmsg(lzhbuf,P_NOATCODES);
238: FREE(lzhbuf);
239: FREE(inbuf); }
240: else
241: putmsg_fp(smb.sdt_fp,msg.dfield[i].length-2,mode);
242: CRLF;
243: break; }
244: }
245:
246: #endif
247:
248: void quotemsg(smbmsg_t msg, int tails)
249: {
250: char str[256];
251:
252: sprintf(str,"%sQUOTES.TXT",node_dir);
253: remove(str);
254: msgtotxt(msg,str,0,tails);
255: }
256:
257:
258: /****************************************************************************/
259: /* Writes message header and text data to a text file */
260: /****************************************************************************/
261: void msgtotxt(smbmsg_t msg, char *str, int header, int tails)
262: {
263: uchar HUGE16 *buf;
264: ushort xlat;
265: int i,j,x;
266: ulong l;
267: FILE *out;
268:
269: if((out=fnopen(&i,str,O_WRONLY|O_CREAT|O_APPEND))==NULL) {
270: errormsg(WHERE,ERR_OPEN,str,0);
271: return; }
272: if(header) {
273: fprintf(out,"\r\n");
274: fprintf(out,"Subj : %s\r\n",msg.subj);
275: fprintf(out,"To : %s",msg.to);
276: if(msg.to_ext)
277: fprintf(out," #%s",msg.to_ext);
278: if(msg.to_net.addr)
279: fprintf(out," (%s)",msg.to_net.type==NET_FIDO
280: ? faddrtoa(*(faddr_t *)msg.to_net.addr) : msg.to_net.addr);
281: fprintf(out,"\r\nFrom : %s",msg.from);
282: if(msg.from_ext && !(msg.hdr.attr&MSG_ANONYMOUS))
283: fprintf(out," #%s",msg.from_ext);
284: if(msg.from_net.addr)
285: fprintf(out," (%s)",msg.from_net.type==NET_FIDO
286: ? faddrtoa(*(faddr_t *)msg.from_net.addr)
287: : msg.from_net.addr);
288: fprintf(out,"\r\nDate : %.24s %s"
289: ,timestr((time_t *)&msg.hdr.when_written.time)
290: ,zonestr(msg.hdr.when_written.zone));
291: fprintf(out,"\r\n\r\n"); }
292:
293: buf=smb_getmsgtxt(&smb,&msg,tails);
294: if(buf) {
295: lfputs(buf,out);
296: LFREE(buf); }
297: else if(smb_getmsgdatlen(&msg)>2)
298: errormsg(WHERE,ERR_ALLOC,smb.file,smb_getmsgdatlen(&msg));
299: fclose(out);
300: }
301:
302:
303: /****************************************************************************/
304: /* Returns total number of posts in a sub-board */
305: /****************************************************************************/
306: ulong getposts(uint subnum)
307: {
308: char str[128];
309: ulong l;
310:
311: sprintf(str,"%s%s.SID",sub[subnum]->data_dir,sub[subnum]->code);
312: l=flength(str);
313: if((long)l==-1)
314: return(0);
315: return(l/sizeof(idxrec_t));
316: }
317:
318: /****************************************************************************/
319: /* Returns message number posted at or after time */
320: /****************************************************************************/
321: ulong getmsgnum(uint subnum, time_t t)
322: {
323: int i;
324: ulong l,total,bot,top;
325: smbmsg_t msg;
326:
327: if(!t)
328: return(0);
329:
330: sprintf(smb.file,"%s%s",sub[subnum]->data_dir,sub[subnum]->code);
331: smb.retry_time=smb_retry_time;
332: if((i=smb_open(&smb))!=0) {
333: errormsg(WHERE,ERR_OPEN,smb.file,i);
334: return(0); }
335:
336: total=filelength(fileno(smb.sid_fp))/sizeof(idxrec_t);
337:
338: if(!total) { /* Empty base */
339: smb_close(&smb);
340: return(0); }
341:
342: if((i=smb_locksmbhdr(&smb))!=0) {
343: smb_close(&smb);
344: errormsg(WHERE,ERR_LOCK,smb.file,i);
345: return(0); }
346:
347: if((i=smb_getlastidx(&smb,&msg.idx))!=0) {
348: smb_close(&smb);
349: errormsg(WHERE,ERR_READ,smb.file,i);
350: return(0); }
351:
352: if(msg.idx.time<=t) {
353: smb_close(&smb);
354: return(msg.idx.number); }
355:
356: bot=0;
357: top=total;
358: l=total/2; /* Start at middle index */
359: clearerr(smb.sid_fp);
360: while(1) {
361: fseek(smb.sid_fp,l*sizeof(idxrec_t),SEEK_SET);
362: if(!fread(&msg.idx,sizeof(idxrec_t),1,smb.sid_fp))
363: break;
364: if(bot==top-1)
365: break;
366: if(msg.idx.time>t) {
367: top=l;
368: l=bot+((top-bot)/2);
369: continue; }
370: if(msg.idx.time<t) {
371: bot=l;
372: l=top-((top-bot)/2);
373: continue; }
374: break; }
375: smb_close(&smb);
376: return(msg.idx.number);
377: }
378:
379: /****************************************************************************/
380: /* Returns the time of the message number pointed to by 'ptr' */
381: /****************************************************************************/
382: time_t getmsgtime(uint subnum, ulong ptr)
383: {
384: char str[128];
385: int i;
386: long l;
387: smbmsg_t msg;
388: idxrec_t lastidx;
389:
390: sprintf(smb.file,"%s%s",sub[subnum]->data_dir,sub[subnum]->code);
391: smb.retry_time=smb_retry_time;
392: if((i=smb_open(&smb))!=0) {
393: errormsg(WHERE,ERR_OPEN,smb.file,i);
394: return(0); }
395: if(!filelength(fileno(smb.sid_fp))) { /* Empty base */
396: smb_close(&smb);
397: return(0); }
398: msg.offset=0;
399: msg.hdr.number=0;
400: if(smb_getmsgidx(&smb,&msg)) { /* Get first message index */
401: smb_close(&smb);
402: return(0); }
403: if(!ptr || msg.idx.number>=ptr) { /* ptr is before first message */
404: smb_close(&smb);
405: return(msg.idx.time); } /* so return time of first msg */
406:
407: if(smb_getlastidx(&smb,&lastidx)) { /* Get last message index */
408: smb_close(&smb);
409: return(0); }
410: if(lastidx.number<ptr) { /* ptr is after last message */
411: smb_close(&smb);
412: return(lastidx.time); } /* so return time of last msg */
413:
414: msg.idx.time=0;
415: msg.hdr.number=ptr;
416: if(!smb_getmsgidx(&smb,&msg)) {
417: smb_close(&smb);
418: return(msg.idx.time); }
419:
420: if(ptr-msg.idx.number < lastidx.number-ptr) {
421: msg.offset=0;
422: msg.idx.number=0;
423: while(msg.idx.number<ptr) {
424: msg.hdr.number=0;
425: if(smb_getmsgidx(&smb,&msg) || msg.idx.number>=ptr)
426: break;
427: msg.offset++; }
428: smb_close(&smb);
429: return(msg.idx.time); }
430:
431: ptr--;
432: while(ptr) {
433: msg.hdr.number=ptr;
434: if(!smb_getmsgidx(&smb,&msg))
435: break;
436: ptr--; }
437: smb_close(&smb);
438: return(msg.idx.time);
439: }
440:
441:
442: /****************************************************************************/
443: /* Returns the total number of msgs in the sub-board and sets 'ptr' to the */
444: /* number of the last message in the sub (0) if no messages. */
445: /****************************************************************************/
446: ulong getlastmsg(uint subnum, ulong *ptr, time_t *t)
447: {
448: char str[256];
449: int i;
450: ulong total;
451: idxrec_t idx;
452:
453: if(ptr)
454: (*ptr)=0;
455: if(t)
456: (*t)=0;
457: if(subnum>=total_subs)
458: return(0);
459:
460: sprintf(smb.file,"%s%s",sub[subnum]->data_dir,sub[subnum]->code);
461: smb.retry_time=smb_retry_time;
462: if((i=smb_open(&smb))!=0) {
463: errormsg(WHERE,ERR_OPEN,smb.file,i);
464: return(0); }
465:
466: if(!filelength(fileno(smb.sid_fp))) { /* Empty base */
467: smb_close(&smb);
468: return(0); }
469: if((i=smb_locksmbhdr(&smb))!=0) {
470: smb_close(&smb);
471: errormsg(WHERE,ERR_LOCK,smb.file,i);
472: return(0); }
473: if((i=smb_getlastidx(&smb,&idx))!=0) {
474: smb_close(&smb);
475: errormsg(WHERE,ERR_READ,smb.file,i);
476: return(0); }
477: total=filelength(fileno(smb.sid_fp))/sizeof(idxrec_t);
478: smb_unlocksmbhdr(&smb);
479: smb_close(&smb);
480: if(ptr)
481: (*ptr)=idx.number;
482: if(t)
483: (*t)=idx.time;
484: return(total);
485: }
486:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.