![[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 / sbbs2 / fido|
Return to smblib.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / fido |
1.1 root 1: /* SMBLIB.C */
2:
3: #include "smblib.h"
4:
5: /****************************************************************************/
6: /* Open a message base of name 'smb_file' */
7: /* If retry_time is 0, fast open method (no compatibility/validity check) */
8: /* Opens files for READing messages or updating message indices only */
9: /****************************************************************************/
10: int smb_open(int retry_time)
11: {
12: int file;
13: char str[128];
14: smbhdr_t hdr;
15:
16: shd_fp=sdt_fp=sid_fp=NULL;
17: sprintf(str,"%s.SHD",smb_file);
18: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYNO,S_IWRITE|S_IREAD))==-1
19: || (shd_fp=fdopen(file,"r+b"))==NULL) {
20: if(file!=-1)
21: close(file);
22: return(2); }
23:
24: if(retry_time && filelength(file)>=sizeof(smbhdr_t)) {
25: setvbuf(shd_fp,shd_buf,_IONBF,SHD_BLOCK_LEN);
26: if(smb_locksmbhdr(retry_time)) {
27: smb_close();
28: return(-1); }
29: memset(&hdr,0,sizeof(smbhdr_t));
30: fread(&hdr,sizeof(smbhdr_t),1,shd_fp);
31: if(memcmp(hdr.id,"SMB\x1a",4)) {
32: smb_close();
33: return(-2); }
34: if(hdr.version<0x110) { /* Compatibility check */
35: smb_close();
36: return(-3); }
37: smb_unlocksmbhdr();
38: rewind(shd_fp); }
39:
40: setvbuf(shd_fp,shd_buf,_IOFBF,SHD_BLOCK_LEN);
41:
42: sprintf(str,"%s.SDT",smb_file);
43: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYNO,S_IWRITE|S_IREAD))==-1
44: || (sdt_fp=fdopen(file,"r+b"))==NULL) {
45: if(file!=-1)
46: close(file);
47: smb_close();
48: return(1); }
49: setvbuf(sdt_fp,NULL,_IOFBF,2*1024);
50:
51: sprintf(str,"%s.SID",smb_file);
52: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYNO,S_IWRITE|S_IREAD))==-1
53: || (sid_fp=fdopen(file,"r+b"))==NULL) {
54: if(file!=-1)
55: close(file);
56: smb_close();
57: return(3); }
58: setvbuf(sid_fp,NULL,_IOFBF,2*1024);
59:
60: return(0);
61: }
62:
63: /****************************************************************************/
64: /* Closes the currently open message base */
65: /****************************************************************************/
66: void smb_close(void)
67: {
68: if(shd_fp!=NULL) {
69: smb_unlocksmbhdr(); /* In case it's been locked */
70: fclose(shd_fp); }
71: if(sid_fp!=NULL)
72: fclose(sid_fp);
73: if(sdt_fp!=NULL)
74: fclose(sdt_fp);
75: sid_fp=shd_fp=sdt_fp=NULL;
76: }
77:
78: /****************************************************************************/
79: /* Opens the data block allocation table message base 'smb_file' */
80: /* Retrys for retry_time number of seconds */
81: /* Return 0 on success, non-zero otherwise */
82: /****************************************************************************/
83: int smb_open_da(int retry_time)
84: {
85: int file;
86: char str[128];
87: long start;
88:
89: start=time(NULL);
90: sprintf(str,"%s.SDA",smb_file);
91: while(1) {
92: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYRW,S_IWRITE|S_IREAD))!=-1)
93: break;
94: if(errno!=EACCES)
95: return(-1);
96: if(time(NULL)-start>=retry_time)
97: return(-2); }
98: if((sda_fp=fdopen(file,"r+b"))==NULL)
99: return(-3);
100: setvbuf(sda_fp,NULL,_IOFBF,2*1024);
101: return(0);
102: }
103:
104: /****************************************************************************/
105: /* Opens the header block allocation table for message base 'smb_file' */
106: /* Retrys for retry_time number of seconds */
107: /* Return 0 on success, non-zero otherwise */
108: /****************************************************************************/
109: int smb_open_ha(int retry_time)
110: {
111: int file;
112: char str[128];
113: long start;
114:
115: start=time(NULL);
116: sprintf(str,"%s.SHA",smb_file);
117: while(1) {
118: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYRW,S_IWRITE|S_IREAD))!=-1)
119: break;
120: if(errno!=EACCES)
121: return(-1);
122: if(time(NULL)-start>=retry_time)
123: return(-2); }
124: if((sha_fp=fdopen(file,"r+b"))==NULL)
125: return(-3);
126: setvbuf(sha_fp,NULL,_IOFBF,2*1024);
127: return(0);
128: }
129:
130: /****************************************************************************/
131: /* If the parameter 'push' is non-zero, this function stores the currently */
132: /* open message base to the "virtual" smb stack. Up to SMB_STACK_LEN */
133: /* message bases may be stored (defined in SMBDEFS.H). */
134: /* The parameter 'op' is the operation to perform on the stack. Either */
135: /* SMB_STACK_PUSH, SMB_STACK_POP, or SMB_STACK_XCHNG */
136: /* If the operation is SMB_STACK_POP, this function restores a message base */
137: /* previously saved with a SMB_STACK_PUSH call to this same function. */
138: /* If the operation is SMB_STACK_XCHNG, then the current message base is */
139: /* exchanged with the message base on the top of the stack (most recently */
140: /* pushed. */
141: /* If the current message base is not open, the SMB_STACK_PUSH and */
142: /* SMB_STACK_XCHNG operations do nothing */
143: /* Returns 0 on success, non-zero if stack full. */
144: /* If operation is SMB_STACK_POP or SMB_STACK_XCHNG, it always returns 0. */
145: /****************************************************************************/
146: int smb_stack(int op)
147: {
148: static char stack_file[SMB_STACK_LEN][128];
149: static FILE *stack_sdt[SMB_STACK_LEN],
150: *stack_shd[SMB_STACK_LEN],
151: *stack_sid[SMB_STACK_LEN],
152: *stack_sda[SMB_STACK_LEN],
153: *stack_sha[SMB_STACK_LEN];
154: static int stack_idx;
155: char tmp_file[128];
156: FILE *tmp_sdt,
157: *tmp_shd,
158: *tmp_sid,
159: *tmp_sda,
160: *tmp_sha;
161:
162: if(op==SMB_STACK_PUSH) {
163: if(stack_idx>=SMB_STACK_LEN)
164: return(1);
165: if(shd_fp==NULL || sdt_fp==NULL || sid_fp==NULL) /* Msg base not open */
166: return(0);
167: memcpy(stack_file[stack_idx],smb_file,128);
168: stack_sdt[stack_idx]=sdt_fp;
169: stack_shd[stack_idx]=shd_fp;
170: stack_sid[stack_idx]=sid_fp;
171: stack_sda[stack_idx]=sda_fp;
172: stack_sha[stack_idx]=sha_fp;
173: stack_idx++;
174: return(0); }
175: /* pop or xchng */
176: if(!stack_idx) /* Nothing on the stack, so do nothing */
177: return(0);
178: if(op==SMB_STACK_XCHNG) {
179: if(!shd_fp)
180: return(0);
181: memcpy(tmp_file,smb_file,128);
182: tmp_sdt=sdt_fp;
183: tmp_shd=shd_fp;
184: tmp_sid=sid_fp;
185: tmp_sda=sda_fp;
186: tmp_sha=sha_fp; }
187:
188: stack_idx--;
189: memcpy(smb_file,stack_file[stack_idx],128);
190: sdt_fp=stack_sdt[stack_idx];
191: shd_fp=stack_shd[stack_idx];
192: sid_fp=stack_sid[stack_idx];
193: sda_fp=stack_sda[stack_idx];
194: sha_fp=stack_sha[stack_idx];
195: if(op==SMB_STACK_XCHNG) {
196: stack_idx++;
197: memcpy(stack_file[stack_idx-1],tmp_file,128);
198: stack_sdt[stack_idx-1]=tmp_sdt;
199: stack_shd[stack_idx-1]=tmp_shd;
200: stack_sid[stack_idx-1]=tmp_sid;
201: stack_sda[stack_idx-1]=tmp_sda;
202: stack_sha[stack_idx-1]=tmp_sha; }
203: return(0);
204: }
205:
206: /****************************************************************************/
207: /* Truncates header file */
208: /* Retrys for retry_time number of seconds */
209: /* Return 0 on success, non-zero otherwise */
210: /****************************************************************************/
211: int smb_trunchdr(int retry_time)
212: {
213: long start;
214:
215: start=time(NULL);
216: rewind(shd_fp);
217: while(1) {
218: if(!chsize(fileno(shd_fp),0L))
219: break;
220: if(errno!=EACCES)
221: return(-1);
222: if(time(NULL)-start>=retry_time) /* Time-out */
223: return(-2); }
224: return(0);
225: }
226:
227: /*********************************/
228: /* Message Base Header Functions */
229: /*********************************/
230:
231: /****************************************************************************/
232: /* Attempts for retry_time number of seconds to lock the message base hdr */
233: /****************************************************************************/
234: int smb_locksmbhdr(int retry_time)
235: {
236: ulong start;
237:
238: start=time(NULL);
239: while(1) {
240: if(!lock(fileno(shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t)))
241: return(0);
242: if(time(NULL)-start>=retry_time)
243: break; /* Incase we've already locked it */
244: unlock(fileno(shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t)); }
245: return(-1);
246: }
247:
248: /****************************************************************************/
249: /* Read the SMB header from the header file and place into "status" */
250: /****************************************************************************/
251: int smb_getstatus(smbstatus_t *status)
252: {
253: char str[128];
254: int i;
255:
256: setvbuf(shd_fp,shd_buf,_IONBF,SHD_BLOCK_LEN);
257: clearerr(shd_fp);
258: fseek(shd_fp,sizeof(smbhdr_t),SEEK_SET);
259: i=fread(status,1,sizeof(smbstatus_t),shd_fp);
260: setvbuf(shd_fp,shd_buf,_IOFBF,SHD_BLOCK_LEN);
261: if(i==sizeof(smbstatus_t))
262: return(0);
263: return(1);
264: }
265:
266: /****************************************************************************/
267: /* Writes message base header */
268: /****************************************************************************/
269: int smb_putstatus(smbstatus_t status)
270: {
271: int i;
272:
273: clearerr(shd_fp);
274: fseek(shd_fp,sizeof(smbhdr_t),SEEK_SET);
275: i=fwrite(&status,1,sizeof(smbstatus_t),shd_fp);
276: fflush(shd_fp);
277: if(i==sizeof(smbstatus_t))
278: return(0);
279: return(1);
280: }
281:
282: /****************************************************************************/
283: /* Unlocks previously locks message base header */
284: /****************************************************************************/
285: int smb_unlocksmbhdr()
286: {
287: return(unlock(fileno(shd_fp),0L,sizeof(smbhdr_t)+sizeof(smbstatus_t)));
288: }
289:
290: /********************************/
291: /* Individual Message Functions */
292: /********************************/
293:
294: /****************************************************************************/
295: /* Attempts for retry_time number of seconds to lock the header for 'msg' */
296: /****************************************************************************/
297: int smb_lockmsghdr(smbmsg_t msg, int retry_time)
298: {
299: ulong start;
300:
301: start=time(NULL);
302: while(1) {
303: if(!lock(fileno(shd_fp),msg.idx.offset,sizeof(msghdr_t)))
304: return(0);
305: if(time(NULL)-start>=retry_time)
306: break;
307: unlock(fileno(shd_fp),msg.idx.offset,sizeof(msghdr_t)); }
308: return(-1);
309: }
310:
311: /****************************************************************************/
312: /* Fills msg->idx with message index based on msg->hdr.number */
313: /* OR if msg->hdr.number is 0, based on msg->offset (record offset). */
314: /* if msg.hdr.number does not equal 0, then msg->offset is filled too. */
315: /* Either msg->hdr.number or msg->offset must be initialized before */
316: /* calling this function */
317: /* Returns 1 if message number wasn't found, 0 if it was */
318: /****************************************************************************/
319: int smb_getmsgidx(smbmsg_t *msg)
320: {
321: idxrec_t idx;
322: ulong l,length,total,bot,top;
323:
324: clearerr(sid_fp);
325: if(!msg->hdr.number) {
326: fseek(sid_fp,msg->offset*sizeof(idxrec_t),SEEK_SET);
327: if(!fread(&msg->idx,sizeof(idxrec_t),1,sid_fp))
328: return(1);
329: return(0); }
330:
331: length=filelength(fileno(sid_fp));
332: if(!length)
333: return(1);
334: total=length/sizeof(idxrec_t);
335: if(!total)
336: return(1);
337:
338: bot=0;
339: top=total;
340: l=total/2; /* Start at middle index */
341: while(1) {
342: fseek(sid_fp,l*sizeof(idxrec_t),SEEK_SET);
343: if(!fread(&idx,sizeof(idxrec_t),1,sid_fp))
344: return(1);
345: if(bot==top-1 && idx.number!=msg->hdr.number)
346: return(1);
347: if(idx.number>msg->hdr.number) {
348: top=l;
349: l=bot+((top-bot)/2);
350: continue; }
351: if(idx.number<msg->hdr.number) {
352: bot=l;
353: l=top-((top-bot)/2);
354: continue; }
355: break; }
356: msg->idx=idx;
357: msg->offset=l;
358: return(0);
359: }
360:
361: /****************************************************************************/
362: /* Reads the last index record in the open message base */
363: /****************************************************************************/
364: int smb_getlastidx(idxrec_t *idx)
365: {
366: long length;
367:
368: clearerr(sid_fp);
369: length=filelength(fileno(sid_fp));
370: if(length<sizeof(idxrec_t))
371: return(-1);
372: fseek(sid_fp,length-sizeof(idxrec_t),SEEK_SET);
373: if(!fread(idx,sizeof(idxrec_t),1,sid_fp))
374: return(-2);
375: return(0);
376: }
377:
378: /****************************************************************************/
379: /* Figures out the total length of the header record for 'msg' */
380: /* Returns length */
381: /****************************************************************************/
382: uint smb_getmsghdrlen(smbmsg_t msg)
383: {
384: int i;
385:
386: /* fixed portion */
387: msg.hdr.length=sizeof(msghdr_t);
388: /* data fields */
389: msg.hdr.length+=msg.hdr.total_dfields*sizeof(dfield_t);
390: /* header fields */
391: for(i=0;i<msg.total_hfields;i++) {
392: msg.hdr.length+=sizeof(hfield_t);
393: msg.hdr.length+=msg.hfield[i].length; }
394: return(msg.hdr.length);
395: }
396:
397: /****************************************************************************/
398: /* Figures out the total length of the data buffer for 'msg' */
399: /* Returns length */
400: /****************************************************************************/
401: ulong smb_getmsgdatlen(smbmsg_t msg)
402: {
403: int i;
404: ulong length=0L;
405:
406: for(i=0;i<msg.hdr.total_dfields;i++)
407: length+=msg.dfield[i].length;
408: return(length);
409: }
410:
411: /****************************************************************************/
412: /* Read header information into 'msg' structure */
413: /* msg->idx.offset must be set before calling this function */
414: /* Must call smb_freemsgmem() to free memory allocated for var len strs */
415: /* Returns 0 on success, non-zero if error */
416: /****************************************************************************/
417: int smb_getmsghdr(smbmsg_t *msg)
418: {
419: ushort i;
420: ulong l,offset;
421: idxrec_t idx;
422:
423: rewind(shd_fp);
424: fseek(shd_fp,msg->idx.offset,SEEK_SET);
425: idx=msg->idx;
426: offset=msg->offset;
427: memset(msg,0,sizeof(smbmsg_t));
428: msg->idx=idx;
429: msg->offset=offset;
430: if(!fread(&msg->hdr,sizeof(msghdr_t),1,shd_fp))
431: return(-1);
432: if(memcmp(msg->hdr.id,"SHD\x1a",4))
433: return(-2);
434: if(msg->hdr.version<0x110)
435: return(-9);
436: l=sizeof(msghdr_t);
437: if(msg->hdr.total_dfields && (msg->dfield
438: =(dfield_t *)MALLOC(sizeof(dfield_t)*msg->hdr.total_dfields))==NULL) {
439: smb_freemsgmem(*msg);
440: return(-3); }
441: i=0;
442: while(i<msg->hdr.total_dfields && l<msg->hdr.length) {
443: if(!fread(&msg->dfield[i],sizeof(dfield_t),1,shd_fp)) {
444: smb_freemsgmem(*msg);
445: return(-4); }
446: i++;
447: l+=sizeof(dfield_t); }
448: if(i<msg->hdr.total_dfields) {
449: smb_freemsgmem(*msg);
450: return(-8); }
451:
452: while(l<msg->hdr.length) {
453: i=msg->total_hfields;
454: if((msg->hfield_dat=(void **)REALLOC(msg->hfield_dat,sizeof(void *)*(i+1)))
455: ==NULL) {
456: smb_freemsgmem(*msg);
457: return(-3); }
458: if((msg->hfield=(hfield_t *)REALLOC(msg->hfield
459: ,sizeof(hfield_t)*(i+1)))==NULL) {
460: smb_freemsgmem(*msg);
461: return(-3); }
462: msg->total_hfields++;
463: if(!fread(&msg->hfield[i],sizeof(hfield_t),1,shd_fp)) {
464: smb_freemsgmem(*msg);
465: return(-5); }
466: l+=sizeof(hfield_t);
467: if((msg->hfield_dat[i]=(char *)MALLOC(msg->hfield[i].length+1))
468: ==NULL) { /* Allocate 1 extra for NULL terminator */
469: smb_freemsgmem(*msg); /* or 0 length field */
470: return(-3); }
471: memset(msg->hfield_dat[i],0,msg->hfield[i].length+1); /* init to NULL */
472: if(msg->hfield[i].length
473: && !fread(msg->hfield_dat[i],msg->hfield[i].length,1,shd_fp)) {
474: smb_freemsgmem(*msg);
475: return(-6); }
476:
477: switch(msg->hfield[i].type) { /* convenience variables */
478: case SENDER:
479: if(!msg->from) {
480: msg->from=msg->hfield_dat[i];
481: break; }
482: case FORWARDED: /* fall through */
483: msg->forwarded=1;
484: break;
485: case SENDERAGENT:
486: if(!msg->forwarded)
487: msg->from_agent=*(ushort *)msg->hfield_dat[i];
488: break;
489: case SENDEREXT:
490: if(!msg->forwarded)
491: msg->from_ext=msg->hfield_dat[i];
492: break;
493: case SENDERNETTYPE:
494: if(!msg->forwarded)
495: msg->from_net.type=*(ushort *)msg->hfield_dat[i];
496: break;
497: case SENDERNETADDR:
498: if(!msg->forwarded)
499: msg->from_net.addr=msg->hfield_dat[i];
500: break;
501: case REPLYTO:
502: msg->replyto=msg->hfield_dat[i];
503: break;
504: case REPLYTOEXT:
505: msg->replyto_ext=msg->hfield_dat[i];
506: break;
507: case REPLYTOAGENT:
508: msg->replyto_agent=*(ushort *)msg->hfield_dat[i];
509: break;
510: case REPLYTONETTYPE:
511: msg->replyto_net.type=*(ushort *)msg->hfield_dat[i];
512: break;
513: case REPLYTONETADDR:
514: msg->replyto_net.addr=msg->hfield_dat[i];
515: break;
516: case RECIPIENT:
517: msg->to=msg->hfield_dat[i];
518: break;
519: case RECIPIENTEXT:
520: msg->to_ext=msg->hfield_dat[i];
521: break;
522: case RECIPIENTAGENT:
523: msg->to_agent=*(ushort *)msg->hfield_dat[i];
524: break;
525: case RECIPIENTNETTYPE:
526: msg->to_net.type=*(ushort *)msg->hfield_dat[i];
527: break;
528: case RECIPIENTNETADDR:
529: msg->to_net.addr=msg->hfield_dat[i];
530: break;
531: case SUBJECT:
532: msg->subj=msg->hfield_dat[i];
533: break; }
534: l+=msg->hfield[i].length; }
535:
536: if(!msg->from || !msg->to || !msg->subj) {
537: smb_freemsgmem(*msg);
538: return(-7); }
539: return(0);
540: }
541:
542: /****************************************************************************/
543: /* Frees memory allocated for 'msg' */
544: /****************************************************************************/
545: void smb_freemsgmem(smbmsg_t msg)
546: {
547: ushort i;
548:
549: if(msg.dfield)
550: FREE(msg.dfield);
551: for(i=0;i<msg.total_hfields;i++)
552: if(msg.hfield_dat[i])
553: FREE(msg.hfield_dat[i]);
554: if(msg.hfield)
555: FREE(msg.hfield);
556: if(msg.hfield_dat)
557: FREE(msg.hfield_dat);
558: }
559:
560: /****************************************************************************/
561: /* Unlocks header for 'msg' */
562: /****************************************************************************/
563: int smb_unlockmsghdr(smbmsg_t msg)
564: {
565: return(unlock(fileno(shd_fp),msg.idx.offset,sizeof(msghdr_t)));
566: }
567:
568:
569: /****************************************************************************/
570: /* Adds a header field to the 'msg' structure (in memory only) */
571: /****************************************************************************/
572: int smb_hfield(smbmsg_t *msg, ushort type, ushort length, void *data)
573: {
574: int i;
575:
576: i=msg->total_hfields;
577: if((msg->hfield=(hfield_t *)REALLOC(msg->hfield,sizeof(hfield_t)*(i+1)))
578: ==NULL)
579: return(1);
580: if((msg->hfield_dat=(void **)REALLOC(msg->hfield_dat,sizeof(void *)*(i+1)))
581: ==NULL)
582: return(2);
583: msg->total_hfields++;
584: msg->hfield[i].type=type;
585: msg->hfield[i].length=length;
586: if(length) {
587: if((msg->hfield_dat[i]=(void *)MALLOC(length))==NULL)
588: return(4);
589: memcpy(msg->hfield_dat[i],data,length); }
590: else
591: msg->hfield_dat[i]=NULL;
592: return(0);
593: }
594:
595: /****************************************************************************/
596: /* Adds a data field to the 'msg' structure (in memory only) */
597: /* Automatically figures out the offset into the data buffer from existing */
598: /* dfield lengths */
599: /****************************************************************************/
600: int smb_dfield(smbmsg_t *msg, ushort type, ulong length)
601: {
602: int i,j;
603:
604: i=msg->hdr.total_dfields;
605: if((msg->dfield=(dfield_t *)REALLOC(msg->dfield,sizeof(dfield_t)*(i+1)))
606: ==NULL)
607: return(1);
608: msg->hdr.total_dfields++;
609: msg->dfield[i].type=type;
610: msg->dfield[i].length=length;
611: for(j=msg->dfield[i].offset=0;j<i;j++)
612: msg->dfield[i].offset+=msg->dfield[j].length;
613: return(0);
614: }
615:
616: /****************************************************************************/
617: /* Checks CRC history file for duplicate crc. If found, returns 1. */
618: /* If no dupe, adds to CRC history and returns 0, or negative if error. */
619: /****************************************************************************/
620: int smb_addcrc(ulong max_crcs, ulong crc, int retry_time)
621: {
622: char str[128];
623: int file;
624: long length;
625: ulong l,*buf;
626: time_t start;
627:
628: if(!max_crcs)
629: return(0);
630: start=time(NULL);
631: sprintf(str,"%s.SCH",smb_file);
632: while(1) {
633: if((file=sopen(str,O_RDWR|O_CREAT|O_BINARY,SH_DENYRW,S_IWRITE|S_IREAD))!=-1)
634: break;
635: if(errno!=EACCES)
636: return(-1);
637: if(time(NULL)-start>=retry_time)
638: return(-2); }
639: length=filelength(file);
640: if(length<0L) {
641: close(file);
642: return(-4); }
643: if((buf=(ulong *)MALLOC(max_crcs*4))==NULL) {
644: close(file);
645: return(-3); }
646: if(length>=max_crcs*4) { /* Reached or exceeds max crcs */
647: read(file,buf,max_crcs*4);
648: for(l=0;l<max_crcs;l++)
649: if(crc==buf[l])
650: break;
651: if(l<max_crcs) { /* Dupe CRC found */
652: close(file);
653: FREE(buf);
654: return(1); }
655: chsize(file,0L); /* truncate it */
656: lseek(file,0L,SEEK_SET);
657: write(file,buf+4,(max_crcs-1)*4); }
658:
659: else if(length/4) { /* Less than max crcs */
660: read(file,buf,length);
661: for(l=0;l<length/4;l++)
662: if(crc==buf[l])
663: break;
664: if(l<length/4) { /* Dupe CRC found */
665: close(file);
666: FREE(buf);
667: return(1); } }
668:
669: lseek(file,0L,SEEK_END);
670: write(file,&crc,4); /* Write to the end */
671: FREE(buf);
672: close(file);
673: return(0);
674: }
675:
676:
677: /****************************************************************************/
678: /* Creates a new message header record in the header file. */
679: /* If storage is SMB_SELFPACK, self-packing conservative allocation is used */
680: /* If storage is SMB_FASTALLOC, fast allocation is used */
681: /* If storage is SMB_HYPERALLOC, no allocation tables are used (fastest) */
682: /****************************************************************************/
683: int smb_addmsghdr(smbmsg_t *msg, smbstatus_t *status, int storage
684: ,int retry_time)
685: {
686: int i;
687: long l;
688:
689: if(smb_locksmbhdr(retry_time))
690: return(1);
691: if(smb_getstatus(status))
692: return(2);
693:
694: if(storage!=SMB_HYPERALLOC && (i=smb_open_ha(retry_time))!=0)
695: return(i);
696:
697: msg->hdr.length=smb_getmsghdrlen(*msg);
698: if(storage==SMB_HYPERALLOC)
699: l=smb_hallochdr(status->header_offset);
700: else if(storage==SMB_FASTALLOC)
701: l=smb_fallochdr(msg->hdr.length);
702: else
703: l=smb_allochdr(msg->hdr.length);
704: if(l==-1L) {
705: smb_unlocksmbhdr();
706: fclose(sha_fp);
707: return(-1); }
708:
709: status->last_msg++;
710: msg->idx.number=msg->hdr.number=status->last_msg;
711: msg->idx.offset=status->header_offset+l;
712: msg->idx.time=msg->hdr.when_imported.time;
713: msg->idx.attr=msg->hdr.attr;
714: msg->offset=status->total_msgs;
715: status->total_msgs++;
716: smb_putstatus(*status);
717:
718: if(storage!=SMB_HYPERALLOC)
719: fclose(sha_fp);
720: i=smb_putmsg(*msg);
721: smb_unlocksmbhdr();
722: return(i);
723: }
724:
725: /****************************************************************************/
726: /* Writes both header and index information for msg 'msg' */
727: /****************************************************************************/
728: int smb_putmsg(smbmsg_t msg)
729: {
730: int i;
731:
732: i=smb_putmsghdr(msg);
733: if(i)
734: return(i);
735: return(smb_putmsgidx(msg));
736: }
737:
738: /****************************************************************************/
739: /* Writes index information for 'msg' */
740: /* msg.idx */
741: /* and msg.offset must be set prior to calling to this function */
742: /* Returns 0 if everything ok */
743: /****************************************************************************/
744: int smb_putmsgidx(smbmsg_t msg)
745: {
746:
747: clearerr(sid_fp);
748: fseek(sid_fp,msg.offset*sizeof(idxrec_t),SEEK_SET);
749: if(!fwrite(&msg.idx,sizeof(idxrec_t),1,sid_fp))
750: return(1);
751: fflush(sid_fp);
752: return(0);
753: }
754:
755: /****************************************************************************/
756: /* Writes header information for 'msg' */
757: /* msg.hdr.length */
758: /* msg.idx.offset */
759: /* and msg.offset must be set prior to calling to this function */
760: /* Returns 0 if everything ok */
761: /****************************************************************************/
762: int smb_putmsghdr(smbmsg_t msg)
763: {
764: ushort i;
765: ulong l;
766:
767: clearerr(shd_fp);
768: if(fseek(shd_fp,msg.idx.offset,SEEK_SET))
769: return(-1);
770:
771: /************************************************/
772: /* Write the fixed portion of the header record */
773: /************************************************/
774: if(!fwrite(&msg.hdr,sizeof(msghdr_t),1,shd_fp))
775: return(-2);
776:
777: /************************************************/
778: /* Write the data fields (each is fixed length) */
779: /************************************************/
780: for(i=0;i<msg.hdr.total_dfields;i++)
781: if(!fwrite(&msg.dfield[i],sizeof(dfield_t),1,shd_fp))
782: return(-3);
783:
784: /*******************************************/
785: /* Write the variable length header fields */
786: /*******************************************/
787: for(i=0;i<msg.total_hfields;i++) {
788: if(!fwrite(&msg.hfield[i],sizeof(hfield_t),1,shd_fp))
789: return(-4);
790: if(msg.hfield[i].length /* more then 0 bytes long */
791: && !fwrite(msg.hfield_dat[i],msg.hfield[i].length,1,shd_fp))
792: return(-5); }
793:
794: l=smb_getmsghdrlen(msg);
795: while(l%SHD_BLOCK_LEN) {
796: if(fputc(0,shd_fp)==EOF)
797: return(-6); /* pad block with NULL */
798: l++; }
799: fflush(shd_fp);
800: return(0);
801: }
802:
803: /****************************************************************************/
804: /* Creates a sub-board's initial header file */
805: /* Truncates and deletes other associated SMB files */
806: /****************************************************************************/
807: int smb_create(ulong max_crcs, ulong max_msgs, ushort max_age, ushort attr
808: ,int retry_time)
809: {
810: char str[128];
811: smbhdr_t hdr;
812: smbstatus_t status;
813:
814: if(filelength(fileno(shd_fp))>=sizeof(smbhdr_t)+sizeof(smbstatus_t)
815: && smb_locksmbhdr(retry_time)) /* header exists, so lock it */
816: return(1);
817: memset(&hdr,0,sizeof(smbhdr_t));
818: memset(&status,0,sizeof(smbstatus_t));
819: memcpy(hdr.id,"SMB\x1a",4); /* <S> <M> <B> <^Z> */
820: hdr.version=SMB_VERSION;
821: hdr.length=sizeof(smbhdr_t)+sizeof(smbstatus_t);
822: status.last_msg=status.total_msgs=0;
823: status.header_offset=sizeof(smbhdr_t)+sizeof(smbstatus_t);
824: status.max_crcs=max_crcs;
825: status.max_msgs=max_msgs;
826: status.max_age=max_age;
827: status.attr=attr;
828: rewind(shd_fp);
829: fwrite(&hdr,1,sizeof(smbhdr_t),shd_fp);
830: fwrite(&status,1,sizeof(smbstatus_t),shd_fp);
831: rewind(shd_fp);
832: chsize(fileno(shd_fp),sizeof(smbhdr_t)+sizeof(smbstatus_t));
833: fflush(shd_fp);
834:
835: rewind(sdt_fp);
836: chsize(fileno(sdt_fp),0L);
837: rewind(sid_fp);
838: chsize(fileno(sid_fp),0L);
839:
840: sprintf(str,"%s.SDA",smb_file);
841: remove(str); /* if it exists, delete it */
842: sprintf(str,"%s.SHA",smb_file);
843: remove(str); /* if it exists, delete it */
844: sprintf(str,"%s.SCH",smb_file);
845: remove(str);
846: smb_unlocksmbhdr();
847: return(0);
848: }
849:
850: /****************************************************************************/
851: /* Returns number of data blocks required to store "length" amount of data */
852: /****************************************************************************/
853: ulong smb_datblocks(ulong length)
854: {
855: ulong blocks;
856:
857: blocks=length/SDT_BLOCK_LEN;
858: if(length%SDT_BLOCK_LEN)
859: blocks++;
860: return(blocks);
861: }
862:
863: /****************************************************************************/
864: /* Returns number of header blocks required to store "length" size header */
865: /****************************************************************************/
866: ulong smb_hdrblocks(ulong length)
867: {
868: ulong blocks;
869:
870: blocks=length/SHD_BLOCK_LEN;
871: if(length%SHD_BLOCK_LEN)
872: blocks++;
873: return(blocks);
874: }
875:
876: /****************************************************************************/
877: /* Finds unused space in data file based on block allocation table and */
878: /* marks space as used in allocation table. */
879: /* File must be opened read/write DENY ALL */
880: /* Returns offset to beginning of data (in bytes, not blocks) */
881: /* Assumes smb_open_da() has been called */
882: /* fclose(sda_fp) should be called after */
883: /* Returns negative on error */
884: /****************************************************************************/
885: long smb_allocdat(ulong length, ushort headers)
886: {
887: ushort i,j;
888: ulong l,blocks,offset=0L;
889:
890: blocks=smb_datblocks(length);
891: j=0; /* j is consecutive unused block counter */
892: fflush(sda_fp);
893: rewind(sda_fp);
894: while(!feof(sda_fp)) {
895: if(!fread(&i,2,1,sda_fp))
896: break;
897: offset+=SDT_BLOCK_LEN;
898: if(!i) j++;
899: else j=0;
900: if(j==blocks) {
901: offset-=(blocks*SDT_BLOCK_LEN);
902: break; } }
903: clearerr(sda_fp);
904: fseek(sda_fp,(offset/SDT_BLOCK_LEN)*2L,SEEK_SET);
905: for(l=0;l<blocks;l++)
906: if(!fwrite(&headers,2,1,sda_fp))
907: return(-1);
908: fflush(sda_fp);
909: return(offset);
910: }
911:
912: /****************************************************************************/
913: /* Allocates space for data, but doesn't search for unused blocks */
914: /* Returns negative on error */
915: /****************************************************************************/
916: long smb_fallocdat(ulong length, ushort headers)
917: {
918: ulong l,blocks,offset;
919:
920: fflush(sda_fp);
921: clearerr(sda_fp);
922: blocks=smb_datblocks(length);
923: fseek(sda_fp,0L,SEEK_END);
924: offset=(ftell(sda_fp)/2L)*SDT_BLOCK_LEN;
925: for(l=0;l<blocks;l++)
926: if(!fwrite(&headers,2,1,sda_fp))
927: break;
928: fflush(sda_fp);
929: if(l<blocks)
930: return(-1L);
931: return(offset);
932: }
933:
934: /****************************************************************************/
935: /* De-allocates space for data */
936: /* Returns non-zero on error */
937: /****************************************************************************/
938: int smb_freemsgdat(ulong offset, ulong length, ushort headers)
939: {
940: ushort i;
941: ulong l,blocks;
942:
943: blocks=smb_datblocks(length);
944:
945: clearerr(sda_fp);
946: for(l=0;l<blocks;l++) {
947: if(fseek(sda_fp,((offset/SDT_BLOCK_LEN)+l)*2L,SEEK_SET))
948: return(1);
949: if(!fread(&i,2,1,sda_fp))
950: return(2);
951: if(headers>i)
952: i=0; /* don't want to go negative */
953: else
954: i-=headers;
955: if(fseek(sda_fp,-2L,SEEK_CUR))
956: return(3);
957: if(!fwrite(&i,2,1,sda_fp))
958: return(4); }
959: fflush(sda_fp);
960: return(0);
961: }
962:
963: /****************************************************************************/
964: /* Adds to data allocation records for blocks starting at 'offset' */
965: /* Returns non-zero on error */
966: /****************************************************************************/
967: int smb_incdat(ulong offset, ulong length, ushort headers)
968: {
969: ushort i;
970: ulong l,blocks;
971:
972: clearerr(sda_fp);
973: blocks=smb_datblocks(length);
974: for(l=0;l<blocks;l++) {
975: fseek(sda_fp,((offset/SDT_BLOCK_LEN)+l)*2L,SEEK_SET);
976: if(!fread(&i,2,1,sda_fp))
977: return(1);
978: i+=headers;
979: fseek(sda_fp,-2L,SEEK_CUR);
980: if(!fwrite(&i,2,1,sda_fp))
981: return(2); }
982: fflush(sda_fp);
983: return(0);
984: }
985:
986: /****************************************************************************/
987: /* De-allocates blocks for header record */
988: /* Returns non-zero on error */
989: /****************************************************************************/
990: int smb_freemsghdr(ulong offset, ulong length)
991: {
992: uchar c=0;
993: ulong l,blocks;
994:
995: clearerr(sha_fp);
996: blocks=smb_hdrblocks(length);
997: fseek(sha_fp,offset/SHD_BLOCK_LEN,SEEK_SET);
998: for(l=0;l<blocks;l++)
999: if(!fwrite(&c,1,1,sha_fp))
1000: return(1);
1001: fflush(sha_fp);
1002: return(0);
1003: }
1004:
1005: /****************************************************************************/
1006: /* Frees all allocated header and data blocks for 'msg' */
1007: /****************************************************************************/
1008: int smb_freemsg(smbmsg_t msg, smbstatus_t status)
1009: {
1010: int i;
1011: ushort x;
1012:
1013: if(status.attr&SMB_HYPERALLOC) /* Nothing to do */
1014: return(0);
1015:
1016: for(x=0;x<msg.hdr.total_dfields;x++) {
1017: if((i=smb_freemsgdat(msg.hdr.offset+msg.dfield[x].offset
1018: ,msg.dfield[x].length,1))!=0)
1019: return(i); }
1020: return(smb_freemsghdr(msg.idx.offset-status.header_offset,msg.hdr.length));
1021: }
1022:
1023: /****************************************************************************/
1024: /* Finds unused space in header file based on block allocation table and */
1025: /* marks space as used in allocation table. */
1026: /* File must be opened read/write DENY ALL */
1027: /* Returns offset to beginning of header (in bytes, not blocks) */
1028: /* Assumes smb_open_ha() has been called */
1029: /* fclose(sha_fp) should be called after */
1030: /* Returns -1L on error */
1031: /****************************************************************************/
1032: long smb_allochdr(ulong length)
1033: {
1034: uchar c;
1035: ushort i;
1036: ulong l,blocks,offset=0;
1037:
1038: blocks=smb_hdrblocks(length);
1039: i=0; /* i is consecutive unused block counter */
1040: fflush(sha_fp);
1041: rewind(sha_fp);
1042: while(!feof(sha_fp)) {
1043: if(!fread(&c,1,1,sha_fp))
1044: break;
1045: offset+=SHD_BLOCK_LEN;
1046: if(!c) i++;
1047: else i=0;
1048: if(i==blocks) {
1049: offset-=(blocks*SHD_BLOCK_LEN);
1050: break; } }
1051: clearerr(sha_fp);
1052: fseek(sha_fp,offset/SHD_BLOCK_LEN,SEEK_SET);
1053: c=1;
1054: for(l=0;l<blocks;l++)
1055: if(!fwrite(&c,1,1,sha_fp))
1056: return(-1L);
1057: fflush(sha_fp);
1058: return(offset);
1059: }
1060:
1061: /****************************************************************************/
1062: /* Allocates space for index, but doesn't search for unused blocks */
1063: /* Returns -1L on error */
1064: /****************************************************************************/
1065: long smb_fallochdr(ulong length)
1066: {
1067: uchar c=1;
1068: ulong l,blocks,offset;
1069:
1070: blocks=smb_hdrblocks(length);
1071: fflush(sha_fp);
1072: clearerr(sha_fp);
1073: fseek(sha_fp,0L,SEEK_END);
1074: offset=ftell(sha_fp)*SHD_BLOCK_LEN;
1075: for(l=0;l<blocks;l++)
1076: if(!fwrite(&c,1,1,sha_fp))
1077: return(-1L);
1078: fflush(sha_fp);
1079: return(offset);
1080: }
1081:
1082: /************************************************************************/
1083: /* Allocate header blocks using Hyper Allocation */
1084: /* this function should be most likely not be called from anywhere but */
1085: /* smb_addmsghdr() */
1086: /************************************************************************/
1087: long smb_hallochdr(ulong header_offset)
1088: {
1089: long l;
1090:
1091: fflush(shd_fp);
1092: fseek(shd_fp,0L,SEEK_END);
1093: l=ftell(shd_fp);
1094: if(l<header_offset) /* Header file truncated?!? */
1095: return(header_offset);
1096: while((l-header_offset)%SHD_BLOCK_LEN) /* Make sure even block boundry */
1097: l++;
1098: return(l-header_offset);
1099: }
1100:
1101: /************************************************************************/
1102: /* Allocate data blocks using Hyper Allocation */
1103: /* smb_locksmbhdr() should be called before this function and not */
1104: /* unlocked until all data fields for this message have been written */
1105: /* to the SDT file */
1106: /************************************************************************/
1107: long smb_hallocdat()
1108: {
1109: long l;
1110:
1111: fflush(sdt_fp);
1112: fseek(sdt_fp,0L,SEEK_END);
1113: l=ftell(sdt_fp);
1114: if(l<=0)
1115: return(l);
1116: while(l%SDT_BLOCK_LEN) /* Make sure even block boundry */
1117: l++;
1118: return(l);
1119: }
1120:
1121: /* End of SMBLIB.C */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.