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