![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smblib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / smblib|
Return to smblib.c CVS log | Up to [Synchronet] / sbbs / src / smblib |
1.1 root 1: /* smblib.c */
2:
3: /* Synchronet message base (SMB) library routines */
4:
5: /* $Id: smblib.c,v 1.137 2006/04/25 02:26:06 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 library is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU Lesser 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 Lesser General Public License for more details: lgpl.txt or *
18: * http://www.fsf.org/copyleft/lesser.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: /* ANSI C Library headers */
39:
40: #include <time.h>
41: #include <errno.h>
42: #include <fcntl.h>
43: #include <stdio.h>
44: #include <stdlib.h> /* malloc */
45: #include <string.h>
46: #include <ctype.h> /* isdigit */
47: #include <sys/types.h>
48: #include <sys/stat.h> /* must come after sys/types.h */
49:
50: /* SMB-specific headers */
51: #include "smblib.h"
52: #include "genwrap.h"
53: #include "filewrap.h"
54:
55: /* Use smb_ver() and smb_lib_ver() to obtain these values */
56: #define SMBLIB_VERSION "2.43" /* SMB library version */
57: #define SMB_VERSION 0x0121 /* SMB format version */
58: /* High byte major, low byte minor */
59:
60: static char* nulstr="";
61:
62: int SMBCALL smb_ver(void)
63: {
64: return(SMB_VERSION);
65: }
66:
67: char* SMBCALL smb_lib_ver(void)
68: {
69: return(SMBLIB_VERSION);
70: }
71:
72: /****************************************************************************/
73: /* Open a message base of name 'smb->file' */
74: /* Opens files for READing messages or updating message indices only */
75: /****************************************************************************/
76: int SMBCALL smb_open(smb_t* smb)
77: {
78: int i;
79: time_t start=0;
80: smbhdr_t hdr;
81:
82: /* Set default values, if uninitialized */
83: if(!smb->retry_time)
84: smb->retry_time=10; /* seconds */
85: if(!smb->retry_delay
86: || smb->retry_delay>(smb->retry_time*100)) /* at least ten retries */
87: smb->retry_delay=250; /* milliseconds */
88: smb->shd_fp=smb->sdt_fp=smb->sid_fp=NULL;
89: smb->sha_fp=smb->sda_fp=smb->hash_fp=NULL;
90: smb->last_error[0]=0;
91:
92: /* Check for message-base lock semaphore file (under maintenance?) */
93: while(smb_islocked(smb)) {
94: if(!start)
95: start=time(NULL);
96: else
97: if(time(NULL)-start>=(time_t)smb->retry_time)
98: return(SMB_ERR_TIMEOUT);
99: SLEEP(smb->retry_delay);
100: }
101:
102: if((i=smb_open_fp(smb,&smb->shd_fp,SH_DENYNO))!=SMB_SUCCESS)
103: return(i);
104:
105: memset(&(smb->status),0,sizeof(smb->status));
106: if(filelength(fileno(smb->shd_fp))>=(long)sizeof(smbhdr_t)) {
107: if(smb_locksmbhdr(smb)!=SMB_SUCCESS) {
108: smb_close(smb);
109: /* smb_lockmsghdr set last_error */
110: return(SMB_ERR_LOCK);
111: }
112: memset(&hdr,0,sizeof(smbhdr_t));
113: if(smb_fread(smb,&hdr,sizeof(smbhdr_t),smb->shd_fp)!=sizeof(smbhdr_t)) {
114: safe_snprintf(smb->last_error,sizeof(smb->last_error)
115: ,"%d '%s' reading header"
116: ,get_errno(),STRERROR(get_errno()));
117: smb_close(smb);
118: return(SMB_ERR_READ);
119: }
120: if(memcmp(hdr.id,SMB_HEADER_ID,LEN_HEADER_ID)) {
121: safe_snprintf(smb->last_error,sizeof(smb->last_error)
122: ,"corrupt SMB header ID: %.*s"
123: ,LEN_HEADER_ID,hdr.id);
124: smb_close(smb);
125: return(SMB_ERR_HDR_ID);
126: }
127: if(hdr.version<0x110) { /* Compatibility check */
128: safe_snprintf(smb->last_error,sizeof(smb->last_error)
129: ,"insufficient header version: %X"
130: ,hdr.version);
131: smb_close(smb);
132: return(SMB_ERR_HDR_VER);
133: }
134: if(smb_fread(smb,&(smb->status),sizeof(smbstatus_t),smb->shd_fp)!=sizeof(smbstatus_t)) {
135: safe_snprintf(smb->last_error,sizeof(smb->last_error)
136: ,"%d '%s' reading status"
137: ,get_errno(),STRERROR(get_errno()));
138: smb_close(smb);
139: return(SMB_ERR_READ);
140: }
141: if((i=smb_unlocksmbhdr(smb))!=SMB_SUCCESS) {
142: smb_close(smb);
143: return(i);
144: }
145: rewind(smb->shd_fp);
146: }
147:
148: if((i=smb_open_fp(smb,&smb->sdt_fp,SH_DENYNO))!=SMB_SUCCESS)
149: return(i);
150:
151: if((i=smb_open_fp(smb,&smb->sid_fp,SH_DENYNO))!=SMB_SUCCESS)
152: return(i);
153:
154: return(SMB_SUCCESS);
155: }
156:
157: /****************************************************************************/
158: /* Closes the currently open message base */
159: /****************************************************************************/
160: void SMBCALL smb_close(smb_t* smb)
161: {
162: if(smb->shd_fp!=NULL) {
163: smb_unlocksmbhdr(smb); /* In case it's been locked */
164: smb_close_fp(&smb->shd_fp);
165: }
166: smb_close_fp(&smb->sdt_fp);
167: smb_close_fp(&smb->sid_fp);
168: smb_close_fp(&smb->sda_fp);
169: smb_close_fp(&smb->sha_fp);
170: smb_close_fp(&smb->hash_fp);
171: }
172:
173: /****************************************************************************/
174: /* This set of functions is used to exclusively-lock an entire message base */
175: /* against any other process opening any of the message base files. */
176: /* Currently, this is only used while smbutil packs a message base. */
177: /* This is achieved with a semaphore lock file (e.g. mail.lock). */
178: /****************************************************************************/
179: static char* smb_lockfname(smb_t* smb, char* fname, size_t maxlen)
180: {
181: safe_snprintf(fname,maxlen,"%s.lock",smb->file);
182: return(fname);
183: }
184:
185: /****************************************************************************/
186: /* This function is used to lock an entire message base for exclusive */
187: /* (typically for maintenance/repair) */
188: /****************************************************************************/
189: int SMBCALL smb_lock(smb_t* smb)
190: {
191: char path[MAX_PATH+1];
192: int file;
193: time_t start=0;
194:
195: smb_lockfname(smb,path,sizeof(path)-1);
196: while((file=open(path,O_CREAT|O_EXCL|O_RDWR,S_IREAD|S_IWRITE))==-1) {
197: if(!start)
198: start=time(NULL);
199: else
200: if(time(NULL)-start>=(time_t)smb->retry_time) {
201: safe_snprintf(smb->last_error,sizeof(smb->last_error)
202: ,"%d '%s' creating %s"
203: ,get_errno(),STRERROR(get_errno()),path);
204: return(SMB_ERR_LOCK);
205: }
206: SLEEP(smb->retry_delay);
207: }
208: close(file);
209: return(SMB_SUCCESS);
210: }
211:
212: int SMBCALL smb_unlock(smb_t* smb)
213: {
214: char path[MAX_PATH+1];
215:
216: smb_lockfname(smb,path,sizeof(path)-1);
217: if(remove(path)!=0) {
218: safe_snprintf(smb->last_error,sizeof(smb->last_error)
219: ,"%d '%s' removing %s"
220: ,get_errno(),STRERROR(get_errno()),path);
221: return(SMB_ERR_DELETE);
222: }
223: return(SMB_SUCCESS);
224: }
225:
226: BOOL SMBCALL smb_islocked(smb_t* smb)
227: {
228: char path[MAX_PATH+1];
229:
230: if(access(smb_lockfname(smb,path,sizeof(path)-1),0)!=0)
231: return(FALSE);
232: safe_snprintf(smb->last_error,sizeof(smb->last_error),"%s exists",path);
233: return(TRUE);
234: }
235:
236: /****************************************************************************/
237: /* If the parameter 'push' is non-zero, this function stores the currently */
238: /* open message base to the "virtual" smb stack. Up to SMB_STACK_LEN */
239: /* message bases may be stored (defined in SMBDEFS.H). */
240: /* The parameter 'op' is the operation to perform on the stack. Either */
241: /* SMB_STACK_PUSH, SMB_STACK_POP, or SMB_STACK_XCHNG */
242: /* If the operation is SMB_STACK_POP, this function restores a message base */
243: /* previously saved with a SMB_STACK_PUSH call to this same function. */
244: /* If the operation is SMB_STACK_XCHNG, then the current message base is */
245: /* exchanged with the message base on the top of the stack (most recently */
246: /* pushed. */
247: /* If the current message base is not open, the SMB_STACK_PUSH and */
248: /* SMB_STACK_XCHNG operations do nothing */
249: /* Returns 0 on success, non-zero if stack full. */
250: /* If operation is SMB_STACK_POP or SMB_STACK_XCHNG, it always returns 0. */
251: /****************************************************************************/
252: int SMBCALL smb_stack(smb_t* smb, int op)
253: {
254: static smb_t stack[SMB_STACK_LEN];
255: static int stack_idx;
256: smb_t tmp_smb;
257:
258: if(op==SMB_STACK_PUSH) {
259: if(stack_idx>=SMB_STACK_LEN) {
260: safe_snprintf(smb->last_error,sizeof(smb->last_error),"SMB stack overflow");
261: return(SMB_FAILURE);
262: }
263: if(smb->shd_fp==NULL || smb->sdt_fp==NULL || smb->sid_fp==NULL)
264: return(SMB_SUCCESS); /* Msg base not open, do nothing */
265: memcpy(&stack[stack_idx],smb,sizeof(smb_t));
266: stack_idx++;
267: return(SMB_SUCCESS);
268: }
269: /* pop or xchng */
270: if(!stack_idx) /* Nothing on the stack, so do nothing */
271: return(SMB_SUCCESS);
272: if(op==SMB_STACK_XCHNG) {
273: if(smb->shd_fp==NULL)
274: return(SMB_SUCCESS);
275: memcpy(&tmp_smb,smb,sizeof(smb_t));
276: }
277:
278: stack_idx--;
279: memcpy(smb,&stack[stack_idx],sizeof(smb_t));
280: if(op==SMB_STACK_XCHNG) {
281: memcpy(&stack[stack_idx],&tmp_smb,sizeof(smb_t));
282: stack_idx++;
283: }
284: return(SMB_SUCCESS);
285: }
286:
287: /****************************************************************************/
288: /* Truncates header file */
289: /* Retrys for smb.retry_time number of seconds */
290: /* Return 0 on success, non-zero otherwise */
291: /****************************************************************************/
292: int SMBCALL smb_trunchdr(smb_t* smb)
293: {
294: time_t start=0;
295:
296: if(smb->shd_fp==NULL) {
297: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
298: return(SMB_ERR_NOT_OPEN);
299: }
300: rewind(smb->shd_fp);
301: while(1) {
302: if(chsize(fileno(smb->shd_fp),0L)==0)
303: break;
304: if(get_errno()!=EACCES && get_errno()!=EAGAIN) {
305: safe_snprintf(smb->last_error,sizeof(smb->last_error)
306: ,"%d '%s' changing header file size"
307: ,get_errno(),STRERROR(get_errno()));
308: return(SMB_ERR_WRITE);
309: }
310: if(!start)
311: start=time(NULL);
312: else
313: if(time(NULL)-start>=(time_t)smb->retry_time) { /* Time-out */
314: safe_snprintf(smb->last_error,sizeof(smb->last_error)
315: ,"timeout changing header file size (retry_time=%ld)"
316: ,smb->retry_time);
317: return(SMB_ERR_TIMEOUT);
318: }
319: SLEEP(smb->retry_delay);
320: }
321: return(SMB_SUCCESS);
322: }
323:
324: /*********************************/
325: /* Message Base Header Functions */
326: /*********************************/
327:
328: /****************************************************************************/
329: /* Attempts for smb.retry_time number of seconds to lock the msg base hdr */
330: /****************************************************************************/
331: int SMBCALL smb_locksmbhdr(smb_t* smb)
332: {
333: time_t start=0;
334:
335: if(smb->shd_fp==NULL) {
336: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
337: return(SMB_ERR_NOT_OPEN);
338: }
339: while(1) {
340: if(lock(fileno(smb->shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t))==0) {
341: smb->locked=TRUE;
342: return(SMB_SUCCESS);
343: }
344: if(!start)
345: start=time(NULL);
346: else
347: if(time(NULL)-start>=(time_t)smb->retry_time)
348: break;
349: /* In case we've already locked it */
350: if(unlock(fileno(smb->shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t))==0)
351: smb->locked=FALSE;
352: else {
353: SLEEP(smb->retry_delay);
354: }
355: }
356: safe_snprintf(smb->last_error,sizeof(smb->last_error),"timeout locking message base");
357: return(SMB_ERR_TIMEOUT);
358: }
359:
360: /****************************************************************************/
361: /* Read the SMB header from the header file and place into smb.status */
362: /****************************************************************************/
363: int SMBCALL smb_getstatus(smb_t* smb)
364: {
365: int i;
366:
367: if(smb->shd_fp==NULL) {
368: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
369: return(SMB_ERR_NOT_OPEN);
370: }
371: clearerr(smb->shd_fp);
372: if(fseek(smb->shd_fp,sizeof(smbhdr_t),SEEK_SET)) {
373: safe_snprintf(smb->last_error,sizeof(smb->last_error)
374: ,"%d '%s' seeking to %u in header file"
375: ,get_errno(),STRERROR(get_errno()),sizeof(smbhdr_t));
376: return(SMB_ERR_SEEK);
377: }
378: i=smb_fread(smb,&(smb->status),sizeof(smbstatus_t),smb->shd_fp);
379: if(i==sizeof(smbstatus_t))
380: return(SMB_SUCCESS);
381: safe_snprintf(smb->last_error,sizeof(smb->last_error)
382: ,"%d '%s' reading status",get_errno(),STRERROR(get_errno()));
383: return(SMB_ERR_READ);
384: }
385:
386: /****************************************************************************/
387: /* Writes message base header */
388: /****************************************************************************/
389: int SMBCALL smb_putstatus(smb_t* smb)
390: {
391: int i;
392:
393: if(smb->shd_fp==NULL) {
394: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
395: return(SMB_ERR_NOT_OPEN);
396: }
397: clearerr(smb->shd_fp);
398: if(fseek(smb->shd_fp,sizeof(smbhdr_t),SEEK_SET)) {
399: safe_snprintf(smb->last_error,sizeof(smb->last_error)
400: ,"%d '%s' seeking to %u in header file"
401: ,get_errno(),STRERROR(get_errno()),sizeof(smbhdr_t));
402: return(SMB_ERR_SEEK);
403: }
404: i=fwrite(&(smb->status),1,sizeof(smbstatus_t),smb->shd_fp);
405: fflush(smb->shd_fp);
406: if(i==sizeof(smbstatus_t))
407: return(SMB_SUCCESS);
408: safe_snprintf(smb->last_error,sizeof(smb->last_error)
409: ,"%d '%s' writing status",get_errno(),STRERROR(get_errno()));
410: return(SMB_ERR_WRITE);
411: }
412:
413: /****************************************************************************/
414: /* Unlocks previously locked message base header */
415: /****************************************************************************/
416: int SMBCALL smb_unlocksmbhdr(smb_t* smb)
417: {
418: if(smb->locked) {
419: if(smb->shd_fp==NULL) {
420: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
421: return(SMB_ERR_NOT_OPEN);
422: }
423: if(unlock(fileno(smb->shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t))!=0) {
424: safe_snprintf(smb->last_error,sizeof(smb->last_error)
425: ,"%d '%s' unlocking message base header",get_errno(),STRERROR(get_errno()));
426: return(SMB_ERR_UNLOCK);
427: }
428: smb->locked=FALSE;
429: }
430: return(SMB_SUCCESS);
431: }
432:
433: /********************************/
434: /* Individual Message Functions */
435: /********************************/
436:
437: /****************************************************************************/
438: /* Is the offset a valid message header offset? */
439: /****************************************************************************/
440: BOOL SMBCALL smb_valid_hdr_offset(smb_t* smb, ulong offset)
441: {
442: if(offset<sizeof(smbhdr_t)+sizeof(smbstatus_t)
443: || offset<smb->status.header_offset) {
444: safe_snprintf(smb->last_error,sizeof(smb->last_error)
445: ,"invalid header offset: %lu (0x%lX)"
446: ,offset,offset);
447: return(FALSE);
448: }
449: return(TRUE);
450: }
451:
452: /****************************************************************************/
453: /* Attempts for smb.retry_time number of seconds to lock the hdr for 'msg' */
454: /****************************************************************************/
455: int SMBCALL smb_lockmsghdr(smb_t* smb, smbmsg_t* msg)
456: {
457: time_t start=0;
458:
459: if(smb->shd_fp==NULL) {
460: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
461: return(SMB_ERR_NOT_OPEN);
462: }
463: if(!smb_valid_hdr_offset(smb,msg->idx.offset))
464: return(SMB_ERR_HDR_OFFSET);
465:
466: while(1) {
467: if(lock(fileno(smb->shd_fp),msg->idx.offset,sizeof(msghdr_t))==0)
468: return(SMB_SUCCESS);
469: if(!start)
470: start=time(NULL);
471: else
472: if(time(NULL)-start>=(time_t)smb->retry_time)
473: break;
474: /* In case we've already locked it */
475: if(unlock(fileno(smb->shd_fp),msg->idx.offset,sizeof(msghdr_t))!=0) {
476: SLEEP(smb->retry_delay);
477: }
478: }
479: safe_snprintf(smb->last_error,sizeof(smb->last_error),"timeout locking header");
480: return(SMB_ERR_TIMEOUT);
481: }
482:
483: /****************************************************************************/
484: /* Fills msg->idx with message index based on msg->hdr.number */
485: /* OR if msg->hdr.number is 0, based on msg->offset (record offset). */
486: /* if msg.hdr.number does not equal 0, then msg->offset is filled too. */
487: /* Either msg->hdr.number or msg->offset must be initialized before */
488: /* calling this function */
489: /* Returns 1 if message number wasn't found, 0 if it was */
490: /****************************************************************************/
491: int SMBCALL smb_getmsgidx(smb_t* smb, smbmsg_t* msg)
492: {
493: idxrec_t idx;
494: long byte_offset;
495: ulong l,total,bot,top;
496: long length;
497:
498: if(smb->sid_fp==NULL) {
499: safe_snprintf(smb->last_error,sizeof(smb->last_error),"index not open");
500: return(SMB_ERR_NOT_OPEN);
501: }
502: clearerr(smb->sid_fp);
503:
504: length=filelength(fileno(smb->sid_fp));
505: if(length<(long)sizeof(idxrec_t)) {
506: safe_snprintf(smb->last_error,sizeof(smb->last_error)
507: ,"invalid index file length: %ld",length);
508: return(SMB_ERR_FILE_LEN);
509: }
510: total=length/sizeof(idxrec_t);
511: if(!total) {
512: safe_snprintf(smb->last_error,sizeof(smb->last_error)
513: ,"invalid index file length: %ld",length);
514: return(SMB_ERR_FILE_LEN);
515: }
516:
517: if(!msg->hdr.number) {
518: if(msg->offset<0)
519: byte_offset=length-((-msg->offset)*sizeof(idxrec_t));
520: else
521: byte_offset=msg->offset*sizeof(idxrec_t);
522: if(byte_offset>=length) {
523: safe_snprintf(smb->last_error,sizeof(smb->last_error)
524: ,"invalid index offset: %ld, byte offset: %ld, length: %ld"
525: ,msg->offset, byte_offset, length);
526: return(SMB_ERR_HDR_OFFSET);
527: }
528: if(fseek(smb->sid_fp,byte_offset,SEEK_SET)) {
529: safe_snprintf(smb->last_error,sizeof(smb->last_error)
530: ,"%d '%s' seeking to offset %ld (byte %lu) in index file"
531: ,get_errno(),STRERROR(get_errno())
532: ,msg->offset,byte_offset);
533: return(SMB_ERR_SEEK);
534: }
535: if(smb_fread(smb,&msg->idx,sizeof(idxrec_t),smb->sid_fp)!=sizeof(idxrec_t)) {
536: safe_snprintf(smb->last_error,sizeof(smb->last_error)
537: ,"%d '%s' reading index at offset %ld (byte %lu)"
538: ,get_errno(),STRERROR(get_errno())
539: ,msg->offset,byte_offset);
540: return(SMB_ERR_READ);
541: }
542: /* Save the correct offset (from the beginning of the file) */
543: msg->offset=byte_offset/sizeof(idxrec_t);
544: return(SMB_SUCCESS);
545: }
546:
547: bot=0;
548: top=total;
549: l=total/2; /* Start at middle index */
550: while(1) {
551: if(l>=total) {
552: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msg %lu not found"
553: ,msg->hdr.number);
554: return(SMB_ERR_NOT_FOUND);
555: }
556: if(fseek(smb->sid_fp,l*sizeof(idxrec_t),SEEK_SET)) {
557: safe_snprintf(smb->last_error,sizeof(smb->last_error)
558: ,"%d '%s' seeking to offset %lu (byte %lu) in index file"
559: ,get_errno(),STRERROR(get_errno())
560: ,l,l*sizeof(idxrec_t));
561: return(SMB_ERR_SEEK);
562: }
563: if(smb_fread(smb,&idx,sizeof(idxrec_t),smb->sid_fp)!=sizeof(idxrec_t)) {
564: safe_snprintf(smb->last_error,sizeof(smb->last_error)
565: ,"%d '%s' reading index at offset %lu (byte %lu)"
566: ,get_errno(),STRERROR(get_errno()),l,l*sizeof(idxrec_t));
567: return(SMB_ERR_READ);
568: }
569: if(bot==top-1 && idx.number!=msg->hdr.number) {
570: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msg %lu not found"
571: ,msg->hdr.number);
572: return(SMB_ERR_NOT_FOUND);
573: }
574: if(idx.number>msg->hdr.number) {
575: top=l;
576: l=bot+((top-bot)/2);
577: continue;
578: }
579: if(idx.number<msg->hdr.number) {
580: bot=l;
581: l=top-((top-bot)/2);
582: continue;
583: }
584: break;
585: }
586: msg->idx=idx;
587: msg->offset=l;
588: return(SMB_SUCCESS);
589: }
590:
591: /****************************************************************************/
592: /* Reads the first index record in the open message base */
593: /****************************************************************************/
594: int SMBCALL smb_getfirstidx(smb_t* smb, idxrec_t *idx)
595: {
596: if(smb->sid_fp==NULL) {
597: safe_snprintf(smb->last_error,sizeof(smb->last_error),"index not open");
598: return(SMB_ERR_NOT_OPEN);
599: }
600: clearerr(smb->sid_fp);
601: if(fseek(smb->sid_fp,0,SEEK_SET)) {
602: safe_snprintf(smb->last_error,sizeof(smb->last_error)
603: ,"%d '%s' seeking to beginning of index file"
604: ,get_errno(),STRERROR(get_errno()));
605: return(SMB_ERR_SEEK);
606: }
607: if(smb_fread(smb,idx,sizeof(idxrec_t),smb->sid_fp)!=sizeof(idxrec_t)) {
608: safe_snprintf(smb->last_error,sizeof(smb->last_error)
609: ,"%d '%s' reading first index"
610: ,get_errno(),STRERROR(get_errno()));
611: return(SMB_ERR_READ);
612: }
613: return(SMB_SUCCESS);
614: }
615:
616: /****************************************************************************/
617: /* Reads the last index record in the open message base */
618: /****************************************************************************/
619: int SMBCALL smb_getlastidx(smb_t* smb, idxrec_t *idx)
620: {
621: long length;
622:
623: if(smb->sid_fp==NULL) {
624: safe_snprintf(smb->last_error,sizeof(smb->last_error),"index not open");
625: return(SMB_ERR_NOT_OPEN);
626: }
627: clearerr(smb->sid_fp);
628: length=filelength(fileno(smb->sid_fp));
629: if(length<(long)sizeof(idxrec_t)) {
630: safe_snprintf(smb->last_error,sizeof(smb->last_error)
631: ,"invalid index file length: %ld",length);
632: return(SMB_ERR_FILE_LEN);
633: }
634: if(fseek(smb->sid_fp,length-sizeof(idxrec_t),SEEK_SET)) {
635: safe_snprintf(smb->last_error,sizeof(smb->last_error)
636: ,"%d '%s' seeking to %u in index file"
637: ,get_errno(),STRERROR(get_errno())
638: ,(unsigned)(length-sizeof(idxrec_t)));
639: return(SMB_ERR_SEEK);
640: }
641: if(smb_fread(smb,idx,sizeof(idxrec_t),smb->sid_fp)!=sizeof(idxrec_t)) {
642: safe_snprintf(smb->last_error,sizeof(smb->last_error)
643: ,"%d '%s' reading last index"
644: ,get_errno(),STRERROR(get_errno()));
645: return(SMB_ERR_READ);
646: }
647: return(SMB_SUCCESS);
648: }
649:
650: /****************************************************************************/
651: /* Figures out the total length of the header record for 'msg' */
652: /* Returns length */
653: /****************************************************************************/
654: ulong SMBCALL smb_getmsghdrlen(smbmsg_t* msg)
655: {
656: int i;
657: ulong length;
658:
659: /* fixed portion */
660: length=sizeof(msghdr_t);
661: /* data fields */
662: length+=msg->hdr.total_dfields*sizeof(dfield_t);
663: /* header fields */
664: for(i=0;i<msg->total_hfields;i++) {
665: length+=sizeof(hfield_t);
666: length+=msg->hfield[i].length;
667: }
668: return(length);
669: }
670:
671: /****************************************************************************/
672: /* Figures out the total length of the data buffer for 'msg' */
673: /* Returns length */
674: /****************************************************************************/
675: ulong SMBCALL smb_getmsgdatlen(smbmsg_t* msg)
676: {
677: int i;
678: ulong length=0L;
679:
680: for(i=0;i<msg->hdr.total_dfields;i++)
681: length+=msg->dfield[i].length;
682: return(length);
683: }
684:
685: /****************************************************************************/
686: /* Figures out the total length of the text buffer for 'msg' */
687: /* Returns length */
688: /****************************************************************************/
689: ulong SMBCALL smb_getmsgtxtlen(smbmsg_t* msg)
690: {
691: int i;
692: ulong length=0L;
693:
694: for(i=0;i<msg->total_hfields;i++)
695: if(msg->hfield[i].type==SMB_COMMENT || msg->hfield[i].type==SMTPSYSMSG)
696: length+=msg->hfield[i].length+2;
697: for(i=0;i<msg->hdr.total_dfields;i++)
698: if(msg->dfield[i].type==TEXT_BODY || msg->dfield[i].type==TEXT_TAIL)
699: length+=msg->dfield[i].length;
700: return(length);
701: }
702:
703: static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_dat)
704: {
705: switch(hfield_type) { /* convenience variables */
706: case SENDER:
707: if(!msg->from) {
708: msg->from=(char*)hfield_dat;
709: break;
710: }
711: case FORWARDED: /* fall through */
712: msg->forwarded=TRUE;
713: break;
714: case SENDERAGENT:
715: if(!msg->forwarded)
716: msg->from_agent=*(ushort *)hfield_dat;
717: break;
718: case SENDEREXT:
719: if(!msg->forwarded)
720: msg->from_ext=(char*)hfield_dat;
721: break;
722: case SENDERORG:
723: if(!msg->forwarded)
724: msg->from_org=(char*)hfield_dat;
725: break;
726: case SENDERNETTYPE:
727: if(!msg->forwarded)
728: msg->from_net.type=*(ushort *)hfield_dat;
729: break;
730: case SENDERNETADDR:
731: if(!msg->forwarded)
732: msg->from_net.addr=(char*)hfield_dat;
733: break;
734: case REPLYTO:
735: msg->replyto=(char*)hfield_dat;
736: break;
737: case REPLYTOEXT:
738: msg->replyto_ext=(char*)hfield_dat;
739: break;
740: case REPLYTOAGENT:
741: msg->replyto_agent=*(ushort *)hfield_dat;
742: break;
743: case REPLYTONETTYPE:
744: msg->replyto_net.type=*(ushort *)hfield_dat;
745: break;
746: case REPLYTONETADDR:
747: msg->replyto_net.addr=(char*)hfield_dat;
748: break;
749: case RECIPIENT:
750: msg->to=(char*)hfield_dat;
751: break;
752: case RECIPIENTEXT:
753: msg->to_ext=(char*)hfield_dat;
754: break;
755: case RECIPIENTAGENT:
756: msg->to_agent=*(ushort *)hfield_dat;
757: break;
758: case RECIPIENTNETTYPE:
759: msg->to_net.type=*(ushort *)hfield_dat;
760: break;
761: case RECIPIENTNETADDR:
762: msg->to_net.addr=(char*)hfield_dat;
763: break;
764: case SUBJECT:
765: msg->subj=(char*)hfield_dat;
766: break;
767: case SMB_SUMMARY:
768: msg->summary=(char*)hfield_dat;
769: break;
770: case SMB_EXPIRATION:
771: msg->expiration=*(time_t*)hfield_dat;
772: break;
773: case SMB_PRIORITY:
774: msg->priority=*(ulong*)hfield_dat;
775: break;
776: case SMB_COST:
777: msg->cost=*(ulong*)hfield_dat;
778: break;
779: case RFC822MSGID:
780: msg->id=(char*)hfield_dat;
781: break;
782: case RFC822REPLYID:
783: msg->reply_id=(char*)hfield_dat;
784: break;
785: case SMTPREVERSEPATH:
786: msg->reverse_path=(char*)hfield_dat;
787: break;
788: case USENETPATH:
789: msg->path=(char*)hfield_dat;
790: break;
791: case USENETNEWSGROUPS:
792: msg->newsgroups=(char*)hfield_dat;
793: break;
794: case FIDOMSGID:
795: msg->ftn_msgid=(char*)hfield_dat;
796: break;
797: case FIDOREPLYID:
798: msg->ftn_reply=(char*)hfield_dat;
799: break;
800: case FIDOAREA:
801: msg->ftn_area=(char*)hfield_dat;
802: break;
803: case FIDOPID:
804: msg->ftn_pid=(char*)hfield_dat;
805: break;
806: case FIDOTID:
807: msg->ftn_tid=(char*)hfield_dat;
808: break;
809: case FIDOFLAGS:
810: msg->ftn_flags=(char*)hfield_dat;
811: break;
812: }
813: }
814:
815: static void clear_convenience_ptrs(smbmsg_t* msg)
816: {
817: msg->from=NULL;
818: msg->from_ext=NULL;
819: msg->from_org=NULL;
820: memset(&msg->from_net,0,sizeof(net_t));
821:
822: msg->replyto=NULL;
823: msg->replyto_ext=NULL;
824: memset(&msg->replyto_net,0,sizeof(net_t));
825:
826: msg->to=NULL;
827: msg->to_ext=NULL;
828: memset(&msg->to_net,0,sizeof(net_t));
829:
830: msg->subj=NULL;
831: msg->summary=NULL;
832: msg->id=NULL;
833: msg->reply_id=NULL;
834: msg->reverse_path=NULL;
835: msg->path=NULL;
836: msg->newsgroups=NULL;
837:
838: msg->ftn_msgid=NULL;
839: msg->ftn_reply=NULL;
840: msg->ftn_area=NULL;
841: msg->ftn_pid=NULL;
842: msg->ftn_tid=NULL;
843: msg->ftn_flags=NULL;
844: }
845:
846: /****************************************************************************/
847: /* Read header information into 'msg' structure */
848: /* msg->idx.offset must be set before calling this function */
849: /* Must call smb_freemsgmem() to free memory allocated for var len strs */
850: /* Returns 0 on success, non-zero if error */
851: /****************************************************************************/
852: int SMBCALL smb_getmsghdr(smb_t* smb, smbmsg_t* msg)
853: {
854: void *vp,**vpp;
855: ushort i;
856: ulong l,offset;
857: idxrec_t idx;
858:
859: if(smb->shd_fp==NULL) {
860: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
861: return(SMB_ERR_NOT_OPEN);
862: }
863:
864: if(!smb_valid_hdr_offset(smb,msg->idx.offset))
865: return(SMB_ERR_HDR_OFFSET);
866:
867: rewind(smb->shd_fp);
868: if(fseek(smb->shd_fp,msg->idx.offset,SEEK_SET)) {
869: safe_snprintf(smb->last_error,sizeof(smb->last_error)
870: ,"%d '%s' seeking to %lu in header"
871: ,get_errno(),STRERROR(get_errno())
872: ,msg->idx.offset);
873: return(SMB_ERR_SEEK);
874: }
875:
876: idx=msg->idx;
877: offset=msg->offset;
878: memset(msg,0,sizeof(smbmsg_t));
879: msg->idx=idx;
880: msg->offset=offset;
881: if(smb_fread(smb,&msg->hdr,sizeof(msghdr_t),smb->shd_fp)!=sizeof(msghdr_t)) {
882: safe_snprintf(smb->last_error,sizeof(smb->last_error)
883: ,"%d '%s' reading msg header"
884: ,get_errno(),STRERROR(get_errno()));
885: return(SMB_ERR_READ);
886: }
887: if(memcmp(msg->hdr.id,SHD_HEADER_ID,LEN_HEADER_ID)) {
888: safe_snprintf(smb->last_error,sizeof(smb->last_error)
889: ,"corrupt message header ID: %.*s at offset %lu"
890: ,LEN_HEADER_ID,msg->hdr.id,msg->idx.offset);
891: return(SMB_ERR_HDR_ID);
892: }
893: if(msg->hdr.version<0x110) {
894: safe_snprintf(smb->last_error,sizeof(smb->last_error)
895: ,"insufficient header version: %X"
896: ,msg->hdr.version);
897: return(SMB_ERR_HDR_VER);
898: }
899: l=sizeof(msghdr_t);
900: if(msg->hdr.total_dfields && (msg->dfield
901: =(dfield_t *)malloc(sizeof(dfield_t)*msg->hdr.total_dfields))==NULL) {
902: smb_freemsgmem(msg);
903: safe_snprintf(smb->last_error,sizeof(smb->last_error)
904: ,"malloc failure of %d bytes for %d data fields"
905: ,(int)sizeof(dfield_t)*msg->hdr.total_dfields, msg->hdr.total_dfields);
906: return(SMB_ERR_MEM);
907: }
908: i=0;
909: while(i<msg->hdr.total_dfields && l<(ulong)msg->hdr.length) {
910: if(smb_fread(smb,&msg->dfield[i],sizeof(dfield_t),smb->shd_fp)!=sizeof(dfield_t)) {
911: smb_freemsgmem(msg);
912: safe_snprintf(smb->last_error,sizeof(smb->last_error)
913: ,"%d '%s' reading data field %d"
914: ,get_errno(),STRERROR(get_errno()),i);
915: return(SMB_ERR_READ);
916: }
917: i++;
918: l+=sizeof(dfield_t);
919: }
920: if(i<msg->hdr.total_dfields) {
921: smb_freemsgmem(msg);
922: safe_snprintf(smb->last_error,sizeof(smb->last_error)
923: ,"insufficient data fields read (%d instead of %d)"
924: ,i,msg->hdr.total_dfields);
925: return(SMB_ERR_READ);
926: }
927: while(l<(ulong)msg->hdr.length) {
928: i=msg->total_hfields;
929: if((vpp=(void* *)realloc(msg->hfield_dat,sizeof(void* )*(i+1)))==NULL) {
930: smb_freemsgmem(msg);
931: safe_snprintf(smb->last_error,sizeof(smb->last_error)
932: ,"realloc failure of %d bytes for header field data"
933: ,(int)sizeof(void*)*(i+1));
934: return(SMB_ERR_MEM);
935: }
936: msg->hfield_dat=vpp;
937: if((vp=(hfield_t *)realloc(msg->hfield,sizeof(hfield_t)*(i+1)))==NULL) {
938: smb_freemsgmem(msg);
939: safe_snprintf(smb->last_error,sizeof(smb->last_error)
940: ,"realloc failure of %d bytes for header fields"
941: ,(int)sizeof(hfield_t)*(i+1));
942: return(SMB_ERR_MEM);
943: }
944: msg->hfield=vp;
945: if(smb_fread(smb,&msg->hfield[i],sizeof(hfield_t),smb->shd_fp)!=sizeof(hfield_t)) {
946: smb_freemsgmem(msg);
947: safe_snprintf(smb->last_error,sizeof(smb->last_error)
948: ,"%d '%s' reading header field"
949: ,get_errno(),STRERROR(get_errno()));
950: return(SMB_ERR_READ);
951: }
952: l+=sizeof(hfield_t);
953: if((msg->hfield_dat[i]=(char*)malloc(msg->hfield[i].length+1))
954: ==NULL) { /* Allocate 1 extra for ASCIIZ terminator */
955: safe_snprintf(smb->last_error,sizeof(smb->last_error)
956: ,"malloc failure of %d bytes for header field %d"
957: ,msg->hfield[i].length+1, i);
958: smb_freemsgmem(msg); /* or 0 length field */
959: return(SMB_ERR_MEM);
960: }
961: msg->total_hfields++;
962: memset(msg->hfield_dat[i],0,msg->hfield[i].length+1); /* init to NULL */
963: if(msg->hfield[i].length
964: && smb_fread(smb,msg->hfield_dat[i],msg->hfield[i].length,smb->shd_fp)
965: !=(size_t)msg->hfield[i].length) {
966: smb_freemsgmem(msg);
967: safe_snprintf(smb->last_error,sizeof(smb->last_error)
968: ,"%d '%s' reading header field data"
969: ,get_errno(),STRERROR(get_errno()));
970: return(SMB_ERR_READ);
971: }
972: set_convenience_ptr(msg,msg->hfield[i].type,msg->hfield_dat[i]);
973:
974: l+=msg->hfield[i].length;
975: }
976:
977: /* These convenience pointers must point to something */
978: if(msg->from==NULL) msg->from=nulstr;
979: if(msg->to==NULL) msg->to=nulstr;
980: if(msg->subj==NULL) msg->subj=nulstr;
981:
982: /* If no reverse path specified, use sender's address */
983: if(msg->reverse_path == NULL && msg->from_net.type==NET_INTERNET)
984: msg->reverse_path = msg->from_net.addr;
985:
986: return(SMB_SUCCESS);
987: }
988:
989: /****************************************************************************/
990: /* Frees memory allocated for variable-length header fields in 'msg' */
991: /****************************************************************************/
992: void SMBCALL smb_freemsghdrmem(smbmsg_t* msg)
993: {
994: ushort i;
995:
996: for(i=0;i<msg->total_hfields;i++)
997: if(msg->hfield_dat[i]) {
998: free(msg->hfield_dat[i]);
999: msg->hfield_dat[i]=NULL;
1000: }
1001: msg->total_hfields=0;
1002: if(msg->hfield) {
1003: free(msg->hfield);
1004: msg->hfield=NULL;
1005: }
1006: if(msg->hfield_dat) {
1007: free(msg->hfield_dat);
1008: msg->hfield_dat=NULL;
1009: }
1010: clear_convenience_ptrs(msg); /* don't leave pointers to freed memory */
1011: }
1012:
1013: /****************************************************************************/
1014: /* Frees memory allocated for 'msg' */
1015: /****************************************************************************/
1016: void SMBCALL smb_freemsgmem(smbmsg_t* msg)
1017: {
1018: if(msg->dfield) {
1019: free(msg->dfield);
1020: msg->dfield=NULL;
1021: }
1022: msg->hdr.total_dfields=0;
1023: smb_freemsghdrmem(msg);
1024: }
1025:
1026: /****************************************************************************/
1027: /* Copies memory allocated for 'srcmsg' to 'msg' */
1028: /****************************************************************************/
1029: int SMBCALL smb_copymsgmem(smb_t* smb, smbmsg_t* msg, smbmsg_t* srcmsg)
1030: {
1031: int i;
1032:
1033: memcpy(msg,srcmsg,sizeof(smbmsg_t));
1034:
1035: /* data field types/lengths */
1036: if(msg->hdr.total_dfields>0) {
1037: if((msg->dfield=(dfield_t *)malloc(msg->hdr.total_dfields*sizeof(dfield_t)))==NULL) {
1038: if(smb!=NULL)
1039: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1040: ,"malloc failure of %d bytes for %d data fields"
1041: ,msg->hdr.total_dfields*sizeof(dfield_t), msg->hdr.total_dfields);
1042: return(SMB_ERR_MEM);
1043: }
1044: memcpy(msg->dfield,srcmsg->dfield,msg->hdr.total_dfields*sizeof(dfield_t));
1045: }
1046:
1047: /* header field types/lengths */
1048: if(msg->total_hfields>0) {
1049: if((msg->hfield=(hfield_t *)malloc(msg->total_hfields*sizeof(hfield_t)))==NULL) {
1050: if(smb!=NULL)
1051: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1052: ,"malloc failure of %d bytes for %d header fields"
1053: ,msg->total_hfields*sizeof(hfield_t), msg->total_hfields);
1054: return(SMB_ERR_MEM);
1055: }
1056: memcpy(msg->hfield,srcmsg->hfield,msg->total_hfields*sizeof(hfield_t));
1057:
1058: /* header field data */
1059: if((msg->hfield_dat=(void**)malloc(msg->total_hfields*sizeof(void*)))==NULL) {
1060: if(smb!=NULL)
1061: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1062: ,"malloc failure of %d bytes for %d header fields"
1063: ,msg->total_hfields*sizeof(void*), msg->total_hfields);
1064: return(SMB_ERR_MEM);
1065: }
1066:
1067: for(i=0;i<msg->total_hfields;i++) {
1068: if((msg->hfield_dat[i]=(void*)malloc(msg->hfield[i].length+1))==NULL) {
1069: if(smb!=NULL)
1070: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1071: ,"malloc failure of %d bytes for header field #%d"
1072: ,msg->hfield[i].length+1, i+1);
1073: return(SMB_ERR_MEM);
1074: }
1075: memset(msg->hfield_dat[i],0,msg->hfield[i].length+1);
1076: memcpy(msg->hfield_dat[i],srcmsg->hfield_dat[i],msg->hfield[i].length);
1077: }
1078: }
1079:
1080: return(SMB_SUCCESS);
1081: }
1082:
1083: /****************************************************************************/
1084: /* Unlocks header for 'msg' */
1085: /****************************************************************************/
1086: int SMBCALL smb_unlockmsghdr(smb_t* smb, smbmsg_t* msg)
1087: {
1088: if(smb->shd_fp==NULL) {
1089: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
1090: return(SMB_ERR_NOT_OPEN);
1091: }
1092: if(!smb_valid_hdr_offset(smb,msg->idx.offset))
1093: return(SMB_ERR_HDR_OFFSET);
1094: return(unlock(fileno(smb->shd_fp),msg->idx.offset,sizeof(msghdr_t)));
1095: }
1096:
1097:
1098: /****************************************************************************/
1099: /* Adds a header field to the 'msg' structure (in memory only) */
1100: /****************************************************************************/
1101: int SMBCALL smb_hfield(smbmsg_t* msg, ushort type, size_t length, void* data)
1102: {
1103: void** vpp;
1104: hfield_t* hp;
1105: int i;
1106:
1107: if(smb_getmsghdrlen(msg)+sizeof(hfield_t)+length>SMB_MAX_HDR_LEN)
1108: return(SMB_ERR_HDR_LEN);
1109:
1110: i=msg->total_hfields;
1111: if((hp=(hfield_t *)realloc(msg->hfield,sizeof(hfield_t)*(i+1)))==NULL)
1112: return(SMB_ERR_MEM);
1113:
1114: msg->hfield=hp;
1115: if((vpp=(void* *)realloc(msg->hfield_dat,sizeof(void* )*(i+1)))==NULL)
1116: return(SMB_ERR_MEM);
1117:
1118: msg->hfield_dat=vpp;
1119: msg->total_hfields++;
1120: msg->hfield[i].type=type;
1121: msg->hfield[i].length=length;
1122: if(length) {
1123: if((msg->hfield_dat[i]=(void* )malloc(length+1))==NULL)
1124: return(SMB_ERR_MEM); /* Allocate 1 extra for ASCIIZ terminator */
1125: memset(msg->hfield_dat[i],0,length+1);
1126: memcpy(msg->hfield_dat[i],data,length);
1127: set_convenience_ptr(msg,type,msg->hfield_dat[i]);
1128: }
1129: else
1130: msg->hfield_dat[i]=NULL;
1131:
1132: return(SMB_SUCCESS);
1133: }
1134:
1135: /****************************************************************************/
1136: /* Adds a list of header fields to the 'msg' structure (in memory only) */
1137: /****************************************************************************/
1138: int SMBCALL smb_hfield_addlist(smbmsg_t* msg, hfield_t** hfield_list, void** hfield_dat)
1139: {
1140: int retval;
1141: unsigned n;
1142:
1143: if(hfield_list==NULL)
1144: return(SMB_FAILURE);
1145:
1146: for(n=0;hfield_list[n]!=NULL;n++)
1147: if((retval=smb_hfield(msg
1148: ,hfield_list[n]->type,hfield_list[n]->length,hfield_dat[n]))!=SMB_SUCCESS)
1149: return(retval);
1150:
1151: return(SMB_SUCCESS);
1152: }
1153:
1154: /****************************************************************************/
1155: /* Convenience function to add an ASCIIZ string header field */
1156: /****************************************************************************/
1157: int SMBCALL smb_hfield_str(smbmsg_t* msg, ushort type, const char* str)
1158: {
1159: return smb_hfield(msg, type, strlen(str), (void*)str);
1160: }
1161:
1162: /****************************************************************************/
1163: /* Convenience function to add an ASCIIZ string header field */
1164: /****************************************************************************/
1165: int SMBCALL smb_hfield_netaddr(smbmsg_t* msg, ushort type, const char* str, ushort* nettype)
1166: {
1167: fidoaddr_t sys_addr = {0,0,0,0}; /* replace unspecified fields with 0 (don't assume 1:1/1) */
1168: fidoaddr_t fidoaddr;
1169: ushort tmp_nettype=NET_UNKNOWN;
1170:
1171: if(nettype==NULL)
1172: nettype=&tmp_nettype;
1173: if(*nettype==NET_UNKNOWN)
1174: *nettype=smb_netaddr_type(str);
1175: if(*nettype==NET_FIDO) {
1176: fidoaddr=smb_atofaddr(&sys_addr,str);
1177: return smb_hfield_bin(msg,type,fidoaddr);
1178: } else
1179: return smb_hfield_str(msg,type,str);
1180: }
1181:
1182: /****************************************************************************/
1183: /* Appends data to an existing header field (in memory only) */
1184: /****************************************************************************/
1185: int SMBCALL smb_hfield_append(smbmsg_t* msg, ushort type, size_t length, void* data)
1186: {
1187: int i;
1188: BYTE* p;
1189:
1190: if(length==0) /* nothing to append */
1191: return(SMB_SUCCESS);
1192:
1193: if(msg->total_hfields<1)
1194: return(SMB_ERR_NOT_FOUND);
1195:
1196: /* search for the last header field of this type */
1197: for(i=msg->total_hfields-1;i>=0;i--)
1198: if(msg->hfield[i].type == type)
1199: break;
1200: if(i<0)
1201: return(SMB_ERR_NOT_FOUND);
1202:
1203: if(smb_getmsghdrlen(msg)+length>SMB_MAX_HDR_LEN)
1204: return(SMB_ERR_HDR_LEN);
1205:
1206: if((p=(BYTE*)realloc(msg->hfield_dat[i],msg->hfield[i].length+length+1))==NULL)
1207: return(SMB_ERR_MEM); /* Allocate 1 extra for ASCIIZ terminator */
1208:
1209: msg->hfield_dat[i]=p;
1210: p+=msg->hfield[i].length; /* skip existing data */
1211: memset(p,0,length+1);
1212: memcpy(p,data,length); /* append */
1213: msg->hfield[i].length+=length;
1214: set_convenience_ptr(msg,type,msg->hfield_dat[i]);
1215:
1216: return(SMB_SUCCESS);
1217: }
1218:
1219: /****************************************************************************/
1220: /* Appends data to an existing ASCIIZ header field (in memory only) */
1221: /****************************************************************************/
1222: int SMBCALL smb_hfield_append_str(smbmsg_t* msg, ushort type, const char* str)
1223: {
1224: return smb_hfield_append(msg, type, strlen(str), (void*)str);
1225: }
1226:
1227: /****************************************************************************/
1228: /* Searches for a specific header field (by type) and returns it */
1229: /****************************************************************************/
1230: void* SMBCALL smb_get_hfield(smbmsg_t* msg, ushort type, hfield_t* hfield)
1231: {
1232: int i;
1233:
1234: for(i=0;i<msg->total_hfields;i++)
1235: if(msg->hfield[i].type == type) {
1236: if(hfield != NULL)
1237: *hfield = msg->hfield[i];
1238: return(msg->hfield_dat[i]);
1239: }
1240:
1241: return(NULL);
1242: }
1243:
1244: /****************************************************************************/
1245: /* Adds a data field to the 'msg' structure (in memory only) */
1246: /* Automatically figures out the offset into the data buffer from existing */
1247: /* dfield lengths */
1248: /****************************************************************************/
1249: int SMBCALL smb_dfield(smbmsg_t* msg, ushort type, ulong length)
1250: {
1251: dfield_t* dp;
1252: int i,j;
1253:
1254: i=msg->hdr.total_dfields;
1255: if((dp=(dfield_t *)realloc(msg->dfield,sizeof(dfield_t)*(i+1)))==NULL)
1256: return(SMB_ERR_MEM);
1257:
1258: msg->dfield=dp;
1259: msg->hdr.total_dfields++;
1260: msg->dfield[i].type=type;
1261: msg->dfield[i].length=length;
1262: for(j=msg->dfield[i].offset=0;j<i;j++)
1263: msg->dfield[i].offset+=msg->dfield[j].length;
1264: return(SMB_SUCCESS);
1265: }
1266:
1267: /****************************************************************************/
1268: /* Checks CRC history file for duplicate crc. If found, returns 1. */
1269: /* If no dupe, adds to CRC history and returns 0, or negative if error. */
1270: /****************************************************************************/
1271: int SMBCALL smb_addcrc(smb_t* smb, ulong crc)
1272: {
1273: char str[MAX_PATH+1];
1274: int file;
1275: int wr;
1276: long length;
1277: long newlen;
1278: ulong l,*buf;
1279: time_t start=0;
1280:
1281: if(!smb->status.max_crcs)
1282: return(SMB_SUCCESS);
1283:
1284: SAFEPRINTF(str,"%s.sch",smb->file);
1285: while(1) {
1286: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYRW,S_IREAD|S_IWRITE))!=-1)
1287: break;
1288: if(get_errno()!=EACCES && get_errno()!=EAGAIN) {
1289: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1290: ,"%d '%s' opening %s"
1291: ,get_errno(),STRERROR(get_errno()),str);
1292: return(SMB_ERR_OPEN);
1293: }
1294: if(!start)
1295: start=time(NULL);
1296: else
1297: if(time(NULL)-start>=(time_t)smb->retry_time) {
1298: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1299: ,"timeout opening %s (retry_time=%ld)"
1300: ,str,smb->retry_time);
1301: return(SMB_ERR_TIMEOUT);
1302: }
1303: SLEEP(smb->retry_delay);
1304: }
1305:
1306: length=filelength(file);
1307: if(length<0L || length%sizeof(long)) {
1308: close(file);
1309: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1310: ,"invalid file length: %ld", length);
1311: return(SMB_ERR_FILE_LEN);
1312: }
1313:
1314: if(length!=0) {
1315: if((buf=(ulong*)malloc(length))==NULL) {
1316: close(file);
1317: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1318: ,"malloc failure of %ld bytes"
1319: ,length);
1320: return(SMB_ERR_MEM);
1321: }
1322:
1323: if(read(file,buf,length)!=length) {
1324: close(file);
1325: free(buf);
1326: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1327: ,"%d '%s' reading %ld bytes"
1328: ,get_errno(),STRERROR(get_errno()),length);
1329: return(SMB_ERR_READ);
1330: }
1331:
1332: for(l=0;l<length/sizeof(long);l++)
1333: if(crc==buf[l])
1334: break;
1335: if(l<length/sizeof(long)) { /* Dupe CRC found */
1336: close(file);
1337: free(buf);
1338: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1339: ,"duplicate message text CRC detected");
1340: return(SMB_DUPE_MSG);
1341: }
1342:
1343: if(length>=(long)(smb->status.max_crcs*sizeof(long))) {
1344: newlen=(smb->status.max_crcs-1)*sizeof(long);
1345: chsize(file,0); /* truncate it */
1346: lseek(file,0L,SEEK_SET);
1347: write(file,buf+(length-newlen),newlen);
1348: }
1349: free(buf);
1350: }
1351: wr=write(file,&crc,sizeof(crc)); /* Write to the end */
1352: close(file);
1353:
1354: if(wr!=sizeof(crc)) {
1355: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1356: ,"%d '%s' writing %u bytes"
1357: ,get_errno(),STRERROR(get_errno()),sizeof(crc));
1358: return(SMB_ERR_WRITE);
1359: }
1360:
1361: return(SMB_SUCCESS);
1362: }
1363:
1364: /****************************************************************************/
1365: /* Creates a new message header record in the header file. */
1366: /* If storage is SMB_SELFPACK, self-packing conservative allocation is used */
1367: /* If storage is SMB_FASTALLOC, fast allocation is used */
1368: /* If storage is SMB_HYPERALLOC, no allocation tables are used (fastest) */
1369: /* This function will UN-lock the SMB header */
1370: /****************************************************************************/
1371: int SMBCALL smb_addmsghdr(smb_t* smb, smbmsg_t* msg, int storage)
1372: {
1373: int i;
1374: long l;
1375: ulong hdrlen;
1376:
1377: if(smb->shd_fp==NULL) {
1378: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
1379: return(SMB_ERR_NOT_OPEN);
1380: }
1381:
1382: if(!smb->locked && smb_locksmbhdr(smb)!=SMB_SUCCESS)
1383: return(SMB_ERR_LOCK);
1384:
1385: hdrlen=smb_getmsghdrlen(msg);
1386: if(hdrlen>SMB_MAX_HDR_LEN) { /* headers are limited to 64k in size */
1387: smb_unlocksmbhdr(smb);
1388: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1389: ,"illegal message header length (%lu > %u)"
1390: ,hdrlen,SMB_MAX_HDR_LEN);
1391: return(SMB_ERR_HDR_LEN);
1392: }
1393:
1394: if((i=smb_getstatus(smb))!=SMB_SUCCESS) {
1395: smb_unlocksmbhdr(smb);
1396: return(i);
1397: }
1398: msg->hdr.number=smb->status.last_msg+1;
1399:
1400: /* This is *not* a dupe-check */
1401: if(!(msg->flags&MSG_FLAG_HASHED) /* not already hashed */
1402: && (i=smb_hashmsg(smb,msg,NULL,/* update? */TRUE))!=SMB_SUCCESS) {
1403: smb_unlocksmbhdr(smb);
1404: return(i); /* error updating hash table */
1405: }
1406:
1407: if(storage!=SMB_HYPERALLOC && (i=smb_open_ha(smb))!=SMB_SUCCESS) {
1408: smb_unlocksmbhdr(smb);
1409: return(i);
1410: }
1411:
1412: if(msg->hdr.version==0)
1413: msg->hdr.version=SMB_VERSION;
1414: msg->hdr.length=(ushort)hdrlen;
1415: if(storage==SMB_HYPERALLOC)
1416: l=smb_hallochdr(smb);
1417: else if(storage==SMB_FASTALLOC)
1418: l=smb_fallochdr(smb,msg->hdr.length);
1419: else
1420: l=smb_allochdr(smb,msg->hdr.length);
1421: if(storage!=SMB_HYPERALLOC)
1422: smb_close_ha(smb);
1423: if(l<0) {
1424: smb_unlocksmbhdr(smb);
1425: return(l);
1426: }
1427:
1428: msg->idx.offset=smb->status.header_offset+l;
1429: msg->offset=smb->status.total_msgs;
1430: i=smb_putmsg(smb,msg);
1431: if(i==SMB_SUCCESS) {
1432: smb->status.last_msg++;
1433: smb->status.total_msgs++;
1434: smb_putstatus(smb);
1435: }
1436: smb_unlocksmbhdr(smb);
1437: return(i);
1438: }
1439:
1440: /****************************************************************************/
1441: /* Safely updates existing index and header records for msg */
1442: /* Nothing should be locked prior to calling this function and nothing */
1443: /* should (normally) be locked when it exits */
1444: /****************************************************************************/
1445: int SMBCALL smb_updatemsg(smb_t* smb, smbmsg_t* msg)
1446: {
1447: int retval;
1448:
1449: /* Insure no one else can be changing the index at this time */
1450: if((retval=smb_locksmbhdr(smb))!=SMB_SUCCESS)
1451: return(retval);
1452: /* Get the current index record offset (for later update by smb_putmsgidx) */
1453: if((retval=smb_getmsgidx(smb, msg))==SMB_SUCCESS) {
1454: /* Don't let any one else read or write this header while we're updating it */
1455: if((retval=smb_lockmsghdr(smb,msg))==SMB_SUCCESS) {
1456: retval=smb_putmsg(smb,msg);
1457: smb_unlockmsghdr(smb,msg);
1458: }
1459: }
1460: smb_unlocksmbhdr(smb);
1461: return(retval);
1462: }
1463:
1464: /****************************************************************************/
1465: /* Writes both header and index information for msg 'msg' */
1466: /****************************************************************************/
1467: int SMBCALL smb_putmsg(smb_t* smb, smbmsg_t* msg)
1468: {
1469: int i;
1470:
1471: smb_init_idx(smb,msg);
1472:
1473: if((i=smb_putmsghdr(smb,msg))!=SMB_SUCCESS)
1474: return(i);
1475:
1476: return(smb_putmsgidx(smb,msg));
1477: }
1478:
1479: /****************************************************************************/
1480: /* Initializes/re-synchronizes all the fields of the message index record */
1481: /* with the values from the message header (except for the header offset) */
1482: /****************************************************************************/
1483: int SMBCALL smb_init_idx(smb_t* smb, smbmsg_t* msg)
1484: {
1485: msg->idx.subj=smb_subject_crc(msg->subj);
1486:
1487: if(smb->status.attr&SMB_EMAIL) {
1488: if(msg->to_ext)
1489: msg->idx.to=atoi(msg->to_ext);
1490: else
1491: msg->idx.to=0;
1492: if(msg->from_ext)
1493: msg->idx.from=atoi(msg->from_ext);
1494: else
1495: msg->idx.from=0;
1496: } else {
1497: msg->idx.to=smb_name_crc(msg->to);
1498: msg->idx.from=smb_name_crc(msg->from);
1499: }
1500:
1501: /* Make sure these index/header fields are always *nsync */
1502: msg->idx.number = msg->hdr.number;
1503: msg->idx.attr = msg->hdr.attr;
1504: msg->idx.time = msg->hdr.when_imported.time;
1505:
1506: return(SMB_SUCCESS);
1507: }
1508:
1509: /****************************************************************************/
1510: /* Writes index information for 'msg' */
1511: /* msg->idx */
1512: /* and msg->offset must be set prior to calling to this function */
1513: /* Returns 0 if everything ok */
1514: /****************************************************************************/
1515: int SMBCALL smb_putmsgidx(smb_t* smb, smbmsg_t* msg)
1516: {
1517: long length;
1518:
1519: if(smb->sid_fp==NULL) {
1520: safe_snprintf(smb->last_error,sizeof(smb->last_error),"index not open");
1521: return(SMB_ERR_NOT_OPEN);
1522: }
1523: clearerr(smb->sid_fp);
1524: length = filelength(fileno(smb->sid_fp));
1525: if(length < (long)(msg->offset*sizeof(idxrec_t))) {
1526: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1527: ,"invalid index offset: %ld, byte offset: %lu, length: %lu"
1528: ,msg->offset, msg->offset*sizeof(idxrec_t), length);
1529: return(SMB_ERR_HDR_OFFSET);
1530: }
1531: if(fseek(smb->sid_fp,msg->offset*sizeof(idxrec_t),SEEK_SET)) {
1532: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1533: ,"%d '%s' seeking to %u in header"
1534: ,get_errno(),STRERROR(get_errno())
1535: ,(unsigned)(msg->offset*sizeof(idxrec_t)));
1536: return(SMB_ERR_SEEK);
1537: }
1538: if(!fwrite(&msg->idx,sizeof(idxrec_t),1,smb->sid_fp)) {
1539: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1540: ,"%d '%s' writing index"
1541: ,get_errno(),STRERROR(get_errno()));
1542: return(SMB_ERR_WRITE);
1543: }
1544: return fflush(smb->sid_fp); /* SMB_SUCCESS == 0 */
1545: }
1546:
1547: /****************************************************************************/
1548: /* Writes header information for 'msg' */
1549: /* msg->hdr.length */
1550: /* msg->idx.offset */
1551: /* and msg->offset must be set prior to calling to this function */
1552: /* Returns 0 if everything ok */
1553: /****************************************************************************/
1554: int SMBCALL smb_putmsghdr(smb_t* smb, smbmsg_t* msg)
1555: {
1556: ushort i;
1557: ulong hdrlen;
1558:
1559: if(smb->shd_fp==NULL) {
1560: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
1561: return(SMB_ERR_NOT_OPEN);
1562: }
1563:
1564: if(!smb_valid_hdr_offset(smb,msg->idx.offset))
1565: return(SMB_ERR_HDR_OFFSET);
1566:
1567: clearerr(smb->shd_fp);
1568: if(fseek(smb->shd_fp,msg->idx.offset,SEEK_SET)) {
1569: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1570: ,"%d '%s' seeking to %lu in index"
1571: ,get_errno(),STRERROR(get_errno()),msg->idx.offset);
1572: return(SMB_ERR_SEEK);
1573: }
1574: /* Verify that the number of blocks required to stored the actual
1575: (calculated) header length does not exceed the number allocated. */
1576: hdrlen=smb_getmsghdrlen(msg);
1577: if(hdrlen>SMB_MAX_HDR_LEN) { /* headers are limited to 64k in size */
1578: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1579: ,"illegal message header length (%lu > %u)"
1580: ,hdrlen,SMB_MAX_HDR_LEN);
1581: return(SMB_ERR_HDR_LEN);
1582: }
1583: if(smb_hdrblocks(hdrlen) > smb_hdrblocks(msg->hdr.length)) {
1584: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1585: ,"illegal header length increase: %lu (%lu blocks) vs %hu (%lu blocks)"
1586: ,hdrlen, smb_hdrblocks(hdrlen)
1587: ,msg->hdr.length, smb_hdrblocks(msg->hdr.length));
1588: return(SMB_ERR_HDR_LEN);
1589: }
1590: msg->hdr.length=(ushort)hdrlen; /* store the actual header length */
1591: /**********************************/
1592: /* Set the message header ID here */
1593: /**********************************/
1594: memcpy(&msg->hdr.id,SHD_HEADER_ID,LEN_HEADER_ID);
1595:
1596: /************************************************/
1597: /* Write the fixed portion of the header record */
1598: /************************************************/
1599: if(!fwrite(&msg->hdr,sizeof(msghdr_t),1,smb->shd_fp)) {
1600: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1601: ,"%d '%s' writing fixed portion of header record"
1602: ,get_errno(),STRERROR(get_errno()));
1603: return(SMB_ERR_WRITE);
1604: }
1605:
1606: /************************************************/
1607: /* Write the data fields (each is fixed length) */
1608: /************************************************/
1609: for(i=0;i<msg->hdr.total_dfields;i++)
1610: if(!fwrite(&msg->dfield[i],sizeof(dfield_t),1,smb->shd_fp)) {
1611: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1612: ,"%d '%s' writing data field"
1613: ,get_errno(),STRERROR(get_errno()));
1614: return(SMB_ERR_WRITE);
1615: }
1616: /*******************************************/
1617: /* Write the variable length header fields */
1618: /*******************************************/
1619: for(i=0;i<msg->total_hfields;i++) {
1620: if(!fwrite(&msg->hfield[i],sizeof(hfield_t),1,smb->shd_fp)) {
1621: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1622: ,"%d '%s' writing header field"
1623: ,get_errno(),STRERROR(get_errno()));
1624: return(SMB_ERR_WRITE);
1625: }
1626: if(msg->hfield[i].length /* more then 0 bytes long */
1627: && !fwrite(msg->hfield_dat[i],msg->hfield[i].length,1,smb->shd_fp)) {
1628: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1629: ,"%d '%s' writing header field data"
1630: ,get_errno(),STRERROR(get_errno()));
1631: return(SMB_ERR_WRITE);
1632: }
1633: }
1634:
1635: while(hdrlen%SHD_BLOCK_LEN) {
1636: if(fputc(0,smb->shd_fp)!=0) {
1637: safe_snprintf(smb->last_error,sizeof(smb->last_error)
1638: ,"%d '%s' padding header block"
1639: ,get_errno(),STRERROR(get_errno()));
1640: return(SMB_ERR_WRITE); /* pad block with NULL */
1641: }
1642: hdrlen++;
1643: }
1644: return fflush(smb->shd_fp); /* SMB_SUCCESS == 0 */
1645: }
1646:
1647: /****************************************************************************/
1648: /* Creates a sub-board's initial header file */
1649: /* Truncates and deletes other associated SMB files */
1650: /****************************************************************************/
1651: int SMBCALL smb_create(smb_t* smb)
1652: {
1653: char str[MAX_PATH+1];
1654: smbhdr_t hdr;
1655:
1656: if(smb->shd_fp==NULL || smb->sdt_fp==NULL || smb->sid_fp==NULL) {
1657: safe_snprintf(smb->last_error,sizeof(smb->last_error),"msgbase not open");
1658: return(SMB_ERR_NOT_OPEN);
1659: }
1660: if(filelength(fileno(smb->shd_fp))>=(long)(sizeof(smbhdr_t)+sizeof(smbstatus_t))
1661: && smb_locksmbhdr(smb)!=SMB_SUCCESS) /* header exists, so lock it */
1662: return(SMB_ERR_LOCK);
1663: memset(&hdr,0,sizeof(smbhdr_t));
1664: memcpy(hdr.id,SMB_HEADER_ID,LEN_HEADER_ID);
1665: hdr.version=SMB_VERSION;
1666: hdr.length=sizeof(smbhdr_t)+sizeof(smbstatus_t);
1667: smb->status.last_msg=smb->status.total_msgs=0;
1668: smb->status.header_offset=sizeof(smbhdr_t)+sizeof(smbstatus_t);
1669: rewind(smb->shd_fp);
1670: fwrite(&hdr,1,sizeof(smbhdr_t),smb->shd_fp);
1671: fwrite(&(smb->status),1,sizeof(smbstatus_t),smb->shd_fp);
1672: rewind(smb->shd_fp);
1673: chsize(fileno(smb->shd_fp),sizeof(smbhdr_t)+sizeof(smbstatus_t));
1674: fflush(smb->shd_fp);
1675:
1676: rewind(smb->sdt_fp);
1677: chsize(fileno(smb->sdt_fp),0L);
1678: rewind(smb->sid_fp);
1679: chsize(fileno(smb->sid_fp),0L);
1680:
1681: SAFEPRINTF(str,"%s.sda",smb->file);
1682: remove(str); /* if it exists, delete it */
1683: SAFEPRINTF(str,"%s.sha",smb->file);
1684: remove(str); /* if it exists, delete it */
1685: SAFEPRINTF(str,"%s.sch",smb->file);
1686: remove(str);
1687: SAFEPRINTF(str,"%s.hash",smb->file);
1688: remove(str);
1689: smb_unlocksmbhdr(smb);
1690: return(SMB_SUCCESS);
1691: }
1692:
1693: /****************************************************************************/
1694: /* Returns number of data blocks required to store "length" amount of data */
1695: /****************************************************************************/
1696: ulong SMBCALL smb_datblocks(ulong length)
1697: {
1698: ulong blocks;
1699:
1700: blocks=length/SDT_BLOCK_LEN;
1701: if(length%SDT_BLOCK_LEN)
1702: blocks++;
1703: return(blocks);
1704: }
1705:
1706: /****************************************************************************/
1707: /* Returns number of header blocks required to store "length" size header */
1708: /****************************************************************************/
1709: ulong SMBCALL smb_hdrblocks(ulong length)
1710: {
1711: ulong blocks;
1712:
1713: blocks=length/SHD_BLOCK_LEN;
1714: if(length%SHD_BLOCK_LEN)
1715: blocks++;
1716: return(blocks);
1717: }
1718:
1719: /****************************************************************************/
1720: /* Returns difference from specified timezone and UTC/GMT */
1721: /****************************************************************************/
1722: int SMBCALL smb_tzutc(short zone)
1723: {
1724: int tz;
1725:
1726: if(OTHER_ZONE(zone))
1727: return(zone);
1728:
1729: tz=zone&0xfff;
1730: if(zone&(WESTERN_ZONE|US_ZONE)) { /* West of UTC? */
1731: if(zone&DAYLIGHT)
1732: tz-=60;
1733: return(-tz);
1734: }
1735: return(tz);
1736: }
1737:
1738: /****************************************************************************/
1739: /****************************************************************************/
1740: int SMBCALL smb_updatethread(smb_t* smb, smbmsg_t* remsg, ulong newmsgnum)
1741: {
1742: int retval=SMB_ERR_NOT_FOUND;
1743: ulong nextmsgnum;
1744: smbmsg_t nextmsg;
1745:
1746: if(!remsg->hdr.thread_first) { /* New msg is first reply */
1747: if(remsg->idx.offset==0 /* index not read? */
1748: && (retval=smb_getmsgidx(smb,remsg))!=SMB_SUCCESS)
1749: return(retval);
1750: if((retval=smb_lockmsghdr(smb,remsg))!=SMB_SUCCESS)
1751: return(retval);
1752: if(!remsg->hdr.length /* header not read? */
1753: && (retval=smb_getmsghdr(smb,remsg))!=SMB_SUCCESS)
1754: return(retval);
1755:
1756: remsg->hdr.thread_first=newmsgnum;
1757: retval=smb_putmsghdr(smb,remsg);
1758: smb_unlockmsghdr(smb,remsg);
1759: return(retval);
1760: }
1761:
1762: /* Search for last reply and extend chain */
1763: memset(&nextmsg,0,sizeof(nextmsg));
1764: nextmsgnum=remsg->hdr.thread_first; /* start with first reply */
1765:
1766: while(1) {
1767: nextmsg.idx.offset=0;
1768: nextmsg.hdr.number=nextmsgnum;
1769: if(smb_getmsgidx(smb, &nextmsg)!=SMB_SUCCESS) /* invalid thread origin */
1770: break;
1771: if(smb_lockmsghdr(smb,&nextmsg)!=SMB_SUCCESS)
1772: break;
1773: if(smb_getmsghdr(smb, &nextmsg)!=SMB_SUCCESS) {
1774: smb_unlockmsghdr(smb,&nextmsg);
1775: break;
1776: }
1777: if(nextmsg.hdr.thread_next && nextmsg.hdr.thread_next!=nextmsgnum) {
1778: nextmsgnum=nextmsg.hdr.thread_next;
1779: smb_unlockmsghdr(smb,&nextmsg);
1780: smb_freemsgmem(&nextmsg);
1781: continue;
1782: }
1783: nextmsg.hdr.thread_next=newmsgnum;
1784: retval=smb_putmsghdr(smb,&nextmsg);
1785: smb_unlockmsghdr(smb,&nextmsg);
1786: smb_freemsgmem(&nextmsg);
1787: break;
1788: }
1789:
1790: return(retval);
1791: }
1792:
1793: /* End of SMBLIB.C */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.