![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to smbutil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / sbbs2 / smb / 121a|
Return to smbutil.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / smb / 121a |
1.1 root 1: /* SMBUTIL.C */
2:
3: /* Synchronet Message Base Utility */
4:
5: #define SMBUTIL_VER "1.24"
6:
7: #include "smblib.h"
8: #include "smbutil.h"
9: #include "crc32.h"
10: #include "crc16.c"
11:
12: #ifdef __WATCOMC__
13: #include <dos.h>
14: #endif
15:
16: /********************/
17: /* Global variables */
18: /********************/
19:
20: ulong mode=0L;
21: ushort tzone=PST;
22: char filein[128];
23: char attach[128];
24:
25: /************************/
26: /* Program usage/syntax */
27: /************************/
28:
29: char *usage=
30: "usage: smbutil [/opts] cmd <filespec.SHD>\n"
31: "\n"
32: "cmd:\n"
33: " l[n] = list msgs starting at number n\n"
34: " r[n] = read msgs starting at number n\n"
35: " v[n] = view msg headers starting at number n\n"
36: " k[n] = kill (delete) n msgs\n"
37: " i<f> = import from text file f\n"
38: " s = display msg base status\n"
39: " c = change msg base status\n"
40: " m = maintain msg base - delete old msgs and msgs over max\n"
41: " p[k] = pack msg base (k specifies minimum packable Kbytes)\n"
42: "opts:\n"
43: " a = always pack msg base (disable compression analysis)\n"
44: " z[n] = set time zone (n=min +/- from UT or 'EST','EDT','CST',etc)\n"
45: ;
46:
47: /****************************************************************************/
48: /* Checks the disk drive for the existence of a file. Returns 1 if it */
49: /* exists, 0 if it doesn't. */
50: /****************************************************************************/
51: char fexist(char *filespec)
52: {
53: struct ffblk f;
54:
55: if(findfirst(filespec,&f,0)==0)
56: return(1);
57: return(0);
58: }
59:
60: /****************************************************************************/
61: /* Returns the length of the file in 'filespec' */
62: /****************************************************************************/
63: long flength(char *filespec)
64: {
65: struct ffblk f;
66:
67: if(findfirst(filespec,&f,0)==0)
68: #ifdef __WATCOMC__
69: return(f.size);
70: #else
71: return(f.ff_fsize);
72: #endif
73: return(-1L);
74: }
75:
76:
77: /****************************************************************************/
78: /* Adds a new message to the message base */
79: /****************************************************************************/
80: void postmsg(smbstatus_t status)
81: {
82: char str[128],buf[SDT_BLOCK_LEN];
83: ushort xlat;
84: int i,j,k,file;
85: long length;
86: ulong offset,crc=0xffffffffUL;
87: FILE *instream;
88: smbmsg_t msg;
89:
90: length=flength(filein);
91: if(length<1L) {
92: printf("Invalid file size for '%s'\n",filein);
93: exit(1); }
94: length+=2; /* for translation string */
95: if(!(status.attr&SMB_HYPERALLOC)) {
96: i=smb_open_da(10);
97: if(i) {
98: printf("smb_open_da returned %d\n",i);
99: exit(1); }
100: offset=smb_allocdat(length,1);
101: fclose(sda_fp); }
102: else
103: offset=smb_hallocdat();
104:
105: if((file=open(filein,O_RDONLY|O_BINARY))==-1
106: || (instream=fdopen(file,"rb"))==NULL) {
107: printf("Error opening %s for read\n",filein);
108: smb_freemsgdat(offset,length,1);
109: exit(1); }
110: setvbuf(instream,NULL,_IOFBF,32*1024);
111: fseek(sdt_fp,offset,SEEK_SET);
112: xlat=XLAT_NONE;
113: fwrite(&xlat,2,1,sdt_fp);
114: k=SDT_BLOCK_LEN-2;
115: while(!feof(instream)) {
116: memset(buf,0,k);
117: j=fread(buf,1,k,instream);
118: if(status.max_crcs)
119: for(i=0;i<j;i++)
120: crc=ucrc32(buf[i],crc);
121: fwrite(buf,k,1,sdt_fp);
122: k=SDT_BLOCK_LEN; }
123: fflush(sdt_fp);
124: fclose(instream);
125: crc=~crc;
126:
127: memset(&msg,0,sizeof(smbmsg_t));
128: memcpy(msg.hdr.id,"SHD\x1a",4);
129: msg.hdr.version=SMB_VERSION;
130: msg.hdr.when_written.time=time(NULL);
131: msg.hdr.when_written.zone=tzone;
132: msg.hdr.when_imported=msg.hdr.when_written;
133:
134: if(status.max_crcs) {
135: i=smb_addcrc(status.max_crcs,crc,10);
136: if(i) {
137: printf("smb_addcrc returned %d\n",i);
138: smb_freemsgdat(offset,length,1);
139: exit(1); } }
140:
141: msg.hdr.offset=offset;
142:
143: printf("To User Name: ");
144: gets(str);
145: i=smb_hfield(&msg,RECIPIENT,strlen(str),str);
146: if(i) {
147: printf("smb_hfield returned %d\n",i);
148: smb_freemsgdat(offset,length,1);
149: exit(1); }
150: if(status.attr&SMB_EMAIL) {
151: printf("To User Number: ");
152: gets(str);
153: i=smb_hfield(&msg,RECIPIENTEXT,strlen(str),str);
154: if(i) {
155: printf("smb_hfield returned %d\n",i);
156: smb_freemsgdat(offset,length,1);
157: exit(1); }
158: msg.idx.to=atoi(str); }
159: else {
160: strlwr(str);
161: msg.idx.to=crc16(str); }
162:
163: printf("From User Name: ");
164: gets(str);
165: i=smb_hfield(&msg,SENDER,strlen(str),str);
166: if(i) {
167: printf("smb_hfield returned %d\n",i);
168: smb_freemsgdat(offset,length,1);
169: exit(1); }
170: if(status.attr&SMB_EMAIL) {
171: printf("From User Number: ");
172: gets(str);
173: i=smb_hfield(&msg,SENDEREXT,strlen(str),str);
174: if(i) {
175: printf("smb_hfield returned %d\n",i);
176: smb_freemsgdat(offset,length,1);
177: exit(1); }
178: msg.idx.from=atoi(str); }
179: else {
180: strlwr(str);
181: msg.idx.from=crc16(str); }
182:
183: printf("Subject: ");
184: gets(str);
185: i=smb_hfield(&msg,SUBJECT,strlen(str),str);
186: if(i) {
187: printf("smb_hfield returned %d\n",i);
188: smb_freemsgdat(offset,length,1);
189: exit(1); }
190: strlwr(str);
191: msg.idx.subj=crc16(str);
192:
193: i=smb_dfield(&msg,TEXT_BODY,length);
194: if(i) {
195: printf("smb_dfield returned %d\n",i);
196: smb_freemsgdat(offset,length,1);
197: exit(1); }
198:
199: i=smb_addmsghdr(&msg,&status,status.attr&SMB_HYPERALLOC,10);
200:
201: if(i) {
202: printf("smb_addmsghdr returned %d\n",i);
203: smb_freemsgdat(offset,length,1);
204: exit(1); }
205: smb_freemsgmem(msg);
206:
207: }
208:
209: /****************************************************************************/
210: /* Shows the message base header */
211: /****************************************************************************/
212: void showstatus()
213: {
214: int i;
215: smbstatus_t status;
216:
217: i=smb_locksmbhdr(10);
218: if(i) {
219: printf("smb_locksmbhdr returned %d\n",i);
220: return; }
221: i=smb_getstatus(&status);
222: smb_unlocksmbhdr();
223: if(i) {
224: printf("smb_getstatus returned %d\n",i);
225: return; }
226: printf("last_msg =%lu\n"
227: "total_msgs =%lu\n"
228: "header_offset =%lu\n"
229: "max_crcs =%lu\n"
230: "max_msgs =%lu\n"
231: "max_age =%u\n"
232: "attr =%04Xh\n"
233: ,status.last_msg
234: ,status.total_msgs
235: ,status.header_offset
236: ,status.max_crcs
237: ,status.max_msgs
238: ,status.max_age
239: ,status.attr
240: );
241: }
242:
243: /****************************************************************************/
244: /* Configure message base header */
245: /****************************************************************************/
246: void config()
247: {
248: char max_msgs[128],max_crcs[128],max_age[128],header_offset[128],attr[128];
249: int i;
250: smbstatus_t status;
251:
252: i=smb_locksmbhdr(10);
253: if(i) {
254: printf("smb_locksmbhdr returned %d\n",i);
255: return; }
256: i=smb_getstatus(&status);
257: smb_unlocksmbhdr();
258: if(i) {
259: printf("smb_getstatus returned %d\n",i);
260: return; }
261: printf("Header offset =%-5lu New value (CR=No Change): ",status.header_offset);
262: gets(header_offset);
263: printf("Max msgs =%-5lu New value (CR=No Change): ",status.max_msgs);
264: gets(max_msgs);
265: printf("Max crcs =%-5lu New value (CR=No Change): ",status.max_crcs);
266: gets(max_crcs);
267: printf("Max age =%-5u New value (CR=No Change): ",status.max_age);
268: gets(max_age);
269: printf("Attributes =%-5u New value (CR=No Change): ",status.attr);
270: gets(attr);
271: i=smb_locksmbhdr(10);
272: if(i) {
273: printf("smb_locksmbhdr returned %d\n",i);
274: return; }
275: i=smb_getstatus(&status);
276: if(i) {
277: printf("smb_getstatus returned %d\n",i);
278: smb_unlocksmbhdr();
279: return; }
280: if(isdigit(max_msgs[0]))
281: status.max_msgs=atol(max_msgs);
282: if(isdigit(max_crcs[0]))
283: status.max_crcs=atol(max_crcs);
284: if(isdigit(max_age[0]))
285: status.max_age=atoi(max_age);
286: if(isdigit(header_offset[0]))
287: status.header_offset=atol(header_offset);
288: if(isdigit(attr[0]))
289: status.attr=atoi(attr);
290: i=smb_putstatus(status);
291: smb_unlocksmbhdr();
292: if(i)
293: printf("smb_putstatus returned %d\n",i);
294: }
295:
296: /****************************************************************************/
297: /* Lists messages' to, from, and subject */
298: /****************************************************************************/
299: void listmsgs(ulong start, ulong count)
300: {
301: int i;
302: ulong l=0;
303: smbmsg_t msg;
304: idxrec_t idxrec;
305:
306: if(!start)
307: start=1;
308: fseek(sid_fp,(start-1L)*sizeof(idxrec_t),SEEK_SET);
309: while(l<count) {
310: if(!fread(&msg.idx,1,sizeof(idxrec_t),sid_fp))
311: break;
312: i=smb_lockmsghdr(msg,10);
313: if(i) {
314: printf("smb_lockmsghdr returned %d\n",i);
315: break; }
316: i=smb_getmsghdr(&msg);
317: smb_unlockmsghdr(msg);
318: if(i) {
319: printf("smb_getmsghdr returned %d\n",i);
320: break; }
321: printf("%4lu %-25.25s %-25.25s %.20s\n"
322: ,msg.hdr.number,msg.from,msg.to,msg.subj);
323: smb_freemsgmem(msg);
324: l++; }
325: }
326:
327: /****************************************************************************/
328: /* Returns an ASCII string for FidoNet address 'addr' */
329: /****************************************************************************/
330: char *faddrtoa(fidoaddr_t addr)
331: {
332: static char str[25];
333: char point[25];
334:
335: sprintf(str,"%u:%u/%u",addr.zone,addr.net,addr.node);
336: if(addr.point) {
337: sprintf(point,".%u",addr.point);
338: strcat(str,point); }
339: return(str);
340: }
341:
342: char *binstr(uchar *buf, ushort length)
343: {
344: static char str[128];
345: char tmp[128];
346: int i;
347:
348: str[0]=0;
349: for(i=0;i<length;i++)
350: if(buf[i] && (buf[i]<SP || buf[i]>=0x7f))
351: break;
352: if(i==length) /* not binary */
353: return(buf);
354: for(i=0;i<length;i++) {
355: sprintf(tmp,"%02X ",buf[i]);
356: strcat(str,tmp); }
357: return(str);
358: }
359:
360: /****************************************************************************/
361: /* Converts when_t.zone into ASCII format */
362: /****************************************************************************/
363: char *zonestr(short zone)
364: {
365: static char str[32];
366:
367: switch(zone) {
368: case 0: return("UT");
369: case AST: return("AST");
370: case EST: return("EST");
371: case CST: return("CST");
372: case MST: return("MST");
373: case PST: return("PST");
374: case YST: return("YST");
375: case HST: return("HST");
376: case BST: return("BST");
377: case ADT: return("ADT");
378: case EDT: return("EDT");
379: case CDT: return("CDT");
380: case MDT: return("MDT");
381: case PDT: return("PDT");
382: case YDT: return("YDT");
383: case HDT: return("HDT");
384: case BDT: return("BDT");
385: case MID: return("MID");
386: case VAN: return("VAN");
387: case EDM: return("EDM");
388: case WIN: return("WIN");
389: case BOG: return("BOG");
390: case CAR: return("CAR");
391: case RIO: return("RIO");
392: case FER: return("FER");
393: case AZO: return("AZO");
394: case LON: return("LON");
395: case BER: return("BER");
396: case ATH: return("ATH");
397: case MOS: return("MOS");
398: case DUB: return("DUB");
399: case KAB: return("KAB");
400: case KAR: return("KAR");
401: case BOM: return("BOM");
402: case KAT: return("KAT");
403: case DHA: return("DHA");
404: case BAN: return("BAN");
405: case HON: return("HON");
406: case TOK: return("TOK");
407: case SYD: return("SYD");
408: case NOU: return("NOU");
409: case WEL: return("WEL");
410: }
411:
412: sprintf(str,"%02d:%02d",zone/60,zone<0 ? (-zone)%60 : zone%60);
413: return(str);
414: }
415:
416:
417: /****************************************************************************/
418: /* Displays message header information */
419: /****************************************************************************/
420: void viewmsgs(ulong start, ulong count)
421: {
422: char when_written[128]
423: ,when_imported[128];
424: int i;
425: ulong l=0;
426: smbmsg_t msg;
427: idxrec_t idxrec;
428:
429: if(!start)
430: start=1;
431: fseek(sid_fp,(start-1L)*sizeof(idxrec_t),SEEK_SET);
432: while(l<count) {
433: if(!fread(&msg.idx,1,sizeof(idxrec_t),sid_fp))
434: break;
435: i=smb_lockmsghdr(msg,10);
436: if(i) {
437: printf("smb_lockmsghdr returned %d\n",i);
438: break; }
439: i=smb_getmsghdr(&msg);
440: smb_unlockmsghdr(msg);
441: if(i) {
442: printf("smb_getmsghdr returned %d\n",i);
443: break; }
444:
445: sprintf(when_written,"%.24s %s"
446: ,ctime((time_t *)&msg.hdr.when_written.time)
447: ,zonestr(msg.hdr.when_written.zone));
448: sprintf(when_imported,"%.24s %s"
449: ,ctime((time_t *)&msg.hdr.when_imported.time)
450: ,zonestr(msg.hdr.when_imported.zone));
451:
452: printf( "%-20.20s %s\n"
453: "%-20.20s %s\n"
454: "%-20.20s %s\n"
455: "%-20.20s %04Xh\n"
456: "%-20.20s %04Xh\n"
457: "%-20.20s %u\n"
458: "%-20.20s %04Xh\n"
459: "%-20.20s %08lXh\n"
460: "%-20.20s %08lXh\n"
461: "%-20.20s %s\n"
462: "%-20.20s %s\n"
463: "%-20.20s %ld (%ld)\n"
464: "%-20.20s %ld\n"
465: "%-20.20s %ld\n"
466: "%-20.20s %ld\n"
467: "%-20.20s %s\n"
468: "%-20.20s %06lXh\n"
469: "%-20.20s %u\n",
470:
471: "subj",
472: msg.subj,
473:
474: "from",
475: msg.from,
476:
477: "to",
478: msg.to,
479:
480: "type",
481: msg.hdr.type,
482:
483: "version",
484: msg.hdr.version,
485:
486: "length",
487: msg.hdr.length,
488:
489: "attr",
490: msg.hdr.attr,
491:
492: "auxattr",
493: msg.hdr.auxattr,
494:
495: "netattr",
496: msg.hdr.netattr,
497:
498: "when_written",
499: when_written,
500:
501: "when_imported",
502: when_imported,
503:
504: "number",
505: msg.hdr.number,
506: ftell(sid_fp)/sizeof(idxrec_t),
507:
508: "thread_orig",
509: msg.hdr.thread_orig,
510:
511: "thread_next",
512: msg.hdr.thread_next,
513:
514: "thread_first",
515: msg.hdr.thread_first,
516:
517: "reserved[16]",
518: binstr(msg.hdr.reserved,16),
519:
520: "offset",
521: msg.hdr.offset,
522:
523: "total_dfields",
524: msg.hdr.total_dfields
525: );
526: for(i=0;i<msg.hdr.total_dfields;i++)
527: printf("dfield[%02u].type %02Xh\n"
528: "dfield[%02u].offset %lu\n"
529: "dfield[%02u].length %lu\n"
530: ,i,msg.dfield[i].type
531: ,i,msg.dfield[i].offset
532: ,i,msg.dfield[i].length);
533:
534: for(i=0;i<msg.total_hfields;i++)
535: printf("hfield[%02u].type %02Xh\n"
536: "hfield[%02u].length %d\n"
537: "hfield[%02u]_dat %s\n"
538: ,i,msg.hfield[i].type
539: ,i,msg.hfield[i].length
540: ,i,binstr(msg.hfield_dat[i],msg.hfield[i].length));
541:
542: if(msg.from_net.type)
543: printf("from_net.type %02Xh\n"
544: "from_net.addr %s\n"
545: ,msg.from_net.type
546: ,msg.from_net.type==NET_FIDO
547: ? faddrtoa(*(fidoaddr_t *)msg.from_net.addr) : msg.from_net.addr);
548:
549: if(msg.to_net.type)
550: printf("to_net.type %02Xh\n"
551: "to_net.addr %s\n"
552: ,msg.to_net.type
553: ,msg.to_net.type==NET_FIDO
554: ? faddrtoa(*(fidoaddr_t *)msg.to_net.addr) : msg.to_net.addr);
555:
556: if(msg.replyto_net.type)
557: printf("replyto_net.type %02Xh\n"
558: "replyto_net.addr %s\n"
559: ,msg.replyto_net.type
560: ,msg.replyto_net.type==NET_FIDO
561: ? faddrtoa(*(fidoaddr_t *)msg.replyto_net.addr)
562: : msg.replyto_net.addr);
563:
564: printf("from_agent %02Xh\n"
565: "to_agent %02Xh\n"
566: "replyto_agent %02Xh\n"
567: ,msg.from_agent
568: ,msg.to_agent
569: ,msg.replyto_agent);
570:
571: printf("\n");
572: smb_freemsgmem(msg);
573: l++; }
574: }
575:
576: /****************************************************************************/
577: /* Maintain message base - deletes messages older than max age (in days) */
578: /* or messages that exceed maximum */
579: /****************************************************************************/
580: void maint(void)
581: {
582: int i;
583: ulong l,m,n,f,flagged=0;
584: time_t now;
585: smbstatus_t status;
586: smbmsg_t msg;
587: idxrec_t HUGE16 *idx;
588:
589: printf("Maintaining %s\r\n",smb_file);
590: now=time(NULL);
591: i=smb_locksmbhdr(10);
592: if(i) {
593: printf("smb_locksmbhdr returned %d\n",i);
594: return; }
595: i=smb_getstatus(&status);
596: if(i) {
597: smb_unlocksmbhdr();
598: printf("smb_getstatus returned %d\n",i);
599: return; }
600: if(!status.total_msgs) {
601: smb_unlocksmbhdr();
602: printf("Empty\n");
603: return; }
604: printf("Loading index...\n");
605: if((idx=(idxrec_t *)LMALLOC(sizeof(idxrec_t)*status.total_msgs))
606: ==NULL) {
607: smb_unlocksmbhdr();
608: printf("can't allocate %lu bytes of memory\n"
609: ,sizeof(idxrec_t)*status.total_msgs);
610: return; }
611: fseek(sid_fp,0L,SEEK_SET);
612: for(l=0;l<status.total_msgs;l++) {
613: printf("%lu of %lu\r"
614: ,l+1,status.total_msgs);
615: if(!fread(&idx[l],1,sizeof(idxrec_t),sid_fp))
616: break; }
617: printf("\nDone.\n\n");
618:
619: printf("Scanning for pre-flagged messages...\n");
620: for(m=0;m<l;m++) {
621: printf("\r%2u%%",m ? (long)(100.0/((float)l/m)) : 0);
622: if(idx[m].attr&MSG_DELETE)
623: flagged++; }
624: printf("\r100%% (%lu pre-flagged for deletion)\n",flagged);
625:
626: if(status.max_age) {
627: printf("Scanning for messages more than %u days old...\n"
628: ,status.max_age);
629: for(m=f=0;m<l;m++) {
630: printf("\r%2u%%",m ? (long)(100.0/((float)l/m)) : 0);
631: if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
632: continue;
633: if(now>idx[m].time && (now-idx[m].time)/(24L*60L*60L)>status.max_age) {
634: f++;
635: flagged++;
636: idx[m].attr|=MSG_DELETE; } } /* mark for deletion */
637: printf("\r100%% (%lu flagged for deletion)\n",f); }
638:
639: printf("Scanning for read messages to be killed...\n");
640: for(m=f=0;m<l;m++) {
641: printf("\r%2u%%",m ? (long)(100.0/((float)l/m)) : 0);
642: if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
643: continue;
644: if((idx[m].attr&(MSG_READ|MSG_KILLREAD))==(MSG_READ|MSG_KILLREAD)) {
645: f++;
646: flagged++;
647: idx[m].attr|=MSG_DELETE; } }
648: printf("\r100%% (%lu flagged for deletion)\n",f);
649:
650: if(l-flagged>status.max_msgs) {
651: printf("Flagging excess messages for deletion...\n");
652: for(m=n=0,f=flagged;l-flagged>status.max_msgs && m<l;m++) {
653: if(idx[m].attr&(MSG_PERMANENT|MSG_DELETE))
654: continue;
655: printf("%lu of %lu\r",++n,(l-f)-status.max_msgs);
656: flagged++;
657: idx[m].attr|=MSG_DELETE; } /* mark for deletion */
658: printf("\nDone.\n\n"); }
659:
660: if(!flagged) { /* No messages to delete */
661: LFREE(idx);
662: smb_unlocksmbhdr();
663: return; }
664:
665: if(!(mode&NOANALYSIS)) {
666:
667: printf("Freeing allocated header and data blocks for deleted messages...\n");
668: if(!(status.attr&SMB_HYPERALLOC)) {
669: i=smb_open_da(10);
670: if(i) {
671: smb_unlocksmbhdr();
672: printf("smb_open_da returned %d\n",i);
673: exit(1); }
674: i=smb_open_ha(10);
675: if(i) {
676: smb_unlocksmbhdr();
677: printf("smb_open_ha returned %d\n",i);
678: exit(1); } }
679:
680: for(m=n=0;m<l;m++) {
681: if(idx[m].attr&MSG_DELETE) {
682: printf("%lu of %lu\r",++n,flagged);
683: msg.idx=idx[m];
684: msg.hdr.number=msg.idx.number;
685: if((i=smb_getmsgidx(&msg))!=0) {
686: printf("\nsmb_getmsgidx returned %d\n",i);
687: continue; }
688: i=smb_lockmsghdr(msg,10);
689: if(i) {
690: printf("\nsmb_lockmsghdr returned %d\n",i);
691: break; }
692: if((i=smb_getmsghdr(&msg))!=0) {
693: smb_unlockmsghdr(msg);
694: printf("\nsmb_getmsghdr returned %d\n",i);
695: break; }
696: msg.hdr.attr|=MSG_DELETE; /* mark header as deleted */
697: if((i=smb_putmsg(msg))!=0) {
698: smb_freemsgmem(msg);
699: smb_unlockmsghdr(msg);
700: printf("\nsmb_putmsg returned %d\n",i);
701: break; }
702: smb_unlockmsghdr(msg);
703: if((i=smb_freemsg(msg,status))!=0) {
704: smb_freemsgmem(msg);
705: printf("\nsmb_freemsg returned %d\n",i);
706: break; }
707: smb_freemsgmem(msg); } }
708: if(!(status.attr&SMB_HYPERALLOC)) {
709: fclose(sha_fp);
710: fclose(sda_fp); }
711: printf("\nDone.\n\n"); }
712:
713: printf("Re-writing index...\n");
714: rewind(sid_fp);
715: if(chsize(fileno(sid_fp),0L))
716: printf("chsize failed!\n");
717: for(m=n=0;m<l;m++) {
718: if(idx[m].attr&MSG_DELETE)
719: continue;
720: printf("%lu of %lu\r",++n,l-flagged);
721: fwrite(&idx[m],sizeof(idxrec_t),1,sid_fp); }
722: printf("\nDone.\n\n");
723: fflush(sid_fp);
724:
725: LFREE(idx);
726: status.total_msgs-=flagged;
727: smb_putstatus(status);
728: smb_unlocksmbhdr();
729: }
730:
731: /****************************************************************************/
732: /* Kills 'msgs' number of messags */
733: /* Returns actual number of messages killed. */
734: /****************************************************************************/
735: ulong kill(ulong msgs)
736: {
737: int i;
738: ulong l,m,n,flagged=0;
739: smbstatus_t status;
740: smbmsg_t msg;
741: idxrec_t *idx;
742:
743: i=smb_locksmbhdr(10);
744: if(i) {
745: printf("smb_locksmbhdr returned %d\n",i);
746: return(0); }
747: i=smb_getstatus(&status);
748: if(i) {
749: smb_unlocksmbhdr();
750: printf("smb_getstatus returned %d\n",i);
751: return(0); }
752: printf("Loading index...\n");
753: if((idx=(idxrec_t *)LMALLOC(sizeof(idxrec_t)*status.total_msgs))
754: ==NULL) {
755: smb_unlocksmbhdr();
756: printf("can't allocate %lu bytes of memory\n"
757: ,sizeof(idxrec_t)*status.total_msgs);
758: return(0); }
759: fseek(sid_fp,0L,SEEK_SET);
760: for(l=0;l<status.total_msgs;l++) {
761: printf("%lu of %lu\r"
762: ,l+1,status.total_msgs);
763: if(!fread(&idx[l],1,sizeof(idxrec_t),sid_fp))
764: break; }
765: printf("\nDone.\n\n");
766:
767: printf("Flagging messages for deletion...\n");
768: for(m=0;m<l && flagged<msgs;m++) {
769: if(idx[m].attr&(MSG_PERMANENT))
770: continue;
771: printf("%lu of %lu\r",++flagged,msgs);
772: idx[m].attr|=MSG_DELETE; } /* mark for deletion */
773: printf("\nDone.\n\n");
774:
775: printf("Freeing allocated header and data blocks for deleted messages...\n");
776: if(!(status.attr&SMB_HYPERALLOC)) {
777: i=smb_open_da(10);
778: if(i) {
779: smb_unlocksmbhdr();
780: printf("smb_open_da returned %d\n",i);
781: exit(1); }
782: i=smb_open_ha(10);
783: if(i) {
784: smb_unlocksmbhdr();
785: printf("smb_open_ha returned %d\n",i);
786: exit(1); } }
787:
788: for(m=n=0;m<l;m++) {
789: if(idx[m].attr&MSG_DELETE) {
790: printf("%lu of %lu\r",++n,flagged);
791: msg.idx=idx[m];
792: i=smb_lockmsghdr(msg,10);
793: if(i) {
794: printf("\nsmb_lockmsghdr returned %d\n",i);
795: break; }
796: msg.hdr.number=msg.idx.number;
797: if((i=smb_getmsgidx(&msg))!=0) {
798: smb_unlockmsghdr(msg);
799: printf("\nsmb_getmsgidx returned %d\n",i);
800: break; }
801: if((i=smb_getmsghdr(&msg))!=0) {
802: smb_unlockmsghdr(msg);
803: printf("\nsmb_getmsghdr returned %d\n",i);
804: break; }
805: msg.hdr.attr|=MSG_DELETE; /* mark header as deleted */
806: if((i=smb_putmsg(msg))!=0) {
807: smb_unlockmsghdr(msg);
808: printf("\nsmb_putmsg returned %d\n",i);
809: break; }
810: smb_unlockmsghdr(msg);
811: smb_freemsg(msg,status);
812: smb_freemsgmem(msg); } }
813:
814: if(!(status.attr&SMB_HYPERALLOC)) {
815: fclose(sha_fp);
816: fclose(sda_fp); }
817:
818: printf("\nDone.\n\n");
819:
820: printf("Re-writing index...\n");
821: rewind(sid_fp);
822: chsize(fileno(sid_fp),0L);
823: for(m=n=0;m<l;m++) {
824: if(idx[m].attr&MSG_DELETE)
825: continue;
826: printf("%lu of %lu\r",++n,l-flagged);
827: fwrite(&idx[m],1,sizeof(idxrec_t),sid_fp); }
828: printf("\nDone.\n\n");
829:
830: fflush(sid_fp);
831:
832: LFREE(idx);
833: status.total_msgs-=flagged;
834: smb_putstatus(status);
835: smb_unlocksmbhdr();
836: return(flagged);
837: }
838:
839: typedef struct {
840: ulong old,new;
841: } datoffset_t;
842:
843: /****************************************************************************/
844: /* Removes all unused blocks from SDT and SHD files */
845: /****************************************************************************/
846: void packmsgs(ulong packable)
847: {
848: uchar buf[SDT_BLOCK_LEN],ch,fname[128],tmpfname[128];
849: int i,file,size;
850: ulong l,m,n,datoffsets=0,length,total;
851: FILE *tmp_sdt,*tmp_shd,*tmp_sid;
852: smbhdr_t hdr;
853: smbstatus_t status;
854: smbmsg_t msg;
855: datoffset_t *datoffset=NULL;
856:
857: printf("Packing %s\n",smb_file);
858: i=smb_locksmbhdr(10);
859: if(i) {
860: printf("smb_locksmbhdr returned %d\n",i);
861: return; }
862: i=smb_getstatus(&status);
863: if(i) {
864: smb_unlocksmbhdr();
865: printf("smb_getstatus returned %d\n",i);
866: return; }
867:
868: if(!(status.attr&SMB_HYPERALLOC)) {
869: i=smb_open_ha(10);
870: if(i) {
871: smb_unlocksmbhdr();
872: printf("smb_open_ha returned %d\n",i);
873: return; }
874: i=smb_open_da(10);
875: if(i) {
876: smb_unlocksmbhdr();
877: fclose(sha_fp);
878: printf("smb_open_da returned %d\n",i);
879: return; } }
880:
881: if(!status.total_msgs) {
882: printf("Empty\n");
883: rewind(shd_fp);
884: chsize(fileno(shd_fp),status.header_offset);
885: rewind(sdt_fp);
886: chsize(fileno(sdt_fp),0L);
887: rewind(sid_fp);
888: chsize(fileno(sid_fp),0L);
889: if(!(status.attr&SMB_HYPERALLOC)) {
890: rewind(sha_fp);
891: chsize(fileno(sha_fp),0L);
892: rewind(sda_fp);
893: chsize(fileno(sda_fp),0L);
894: fclose(sha_fp);
895: fclose(sda_fp); }
896: smb_unlocksmbhdr();
897: return; }
898:
899:
900: if(!(status.attr&SMB_HYPERALLOC) && !(mode&NOANALYSIS)) {
901: printf("Analyzing data blocks...\n");
902:
903: length=filelength(fileno(sda_fp));
904:
905: fseek(sda_fp,0L,SEEK_SET);
906: for(l=m=0;l<length;l+=2) {
907: printf("\r%2u%% ",l ? (long)(100.0/((float)length/l)) : 0);
908: i=0;
909: if(!fread(&i,2,1,sda_fp))
910: break;
911: if(!i)
912: m++; }
913:
914: printf("\rAnalyzing header blocks...\n");
915:
916: length=filelength(fileno(sha_fp));
917:
918: fseek(sha_fp,0L,SEEK_SET);
919: for(l=n=0;l<length;l++) {
920: printf("\r%2u%% ",l ? (long)(100.0/((float)length/l)) : 0);
921: ch=0;
922: if(!fread(&ch,1,1,sha_fp))
923: break;
924: if(!ch)
925: n++; }
926:
927: if(!m && !n) {
928: printf("\rAlready compressed.\n\n");
929: fclose(sha_fp);
930: fclose(sda_fp);
931: smb_unlocksmbhdr();
932: return; }
933:
934: if(packable && (m*SDT_BLOCK_LEN)+(n*SHD_BLOCK_LEN)<packable*1024L) {
935: printf("\rLess than %luk compressable bytes.\n\n",packable);
936: fclose(sha_fp);
937: fclose(sda_fp);
938: smb_unlocksmbhdr();
939: return; }
940:
941: printf("\rCompressing %lu data blocks (%lu bytes)\n"
942: " and %lu header blocks (%lu bytes)\n"
943: ,m,m*SDT_BLOCK_LEN,n,n*SHD_BLOCK_LEN); }
944:
945: if(!(status.attr&SMB_HYPERALLOC)) {
946: rewind(sha_fp);
947: chsize(fileno(sha_fp),0L); /* Reset both allocation tables */
948: rewind(sda_fp);
949: chsize(fileno(sda_fp),0L); }
950:
951: if(status.attr&SMB_HYPERALLOC && !(mode&NOANALYSIS)) {
952: printf("Analyzing %s\n",smb_file);
953:
954: length=filelength(fileno(shd_fp));
955: m=n=0;
956: for(l=status.header_offset;l<length;l+=size) {
957: printf("\r%2u%% ",(long)(100.0/((float)length/l)));
958: msg.idx.offset=l;
959: if((i=smb_lockmsghdr(msg,10))!=0) {
960: printf("\n(%06lX) smb_lockmsghdr returned %d\n",l,i);
961: size=SHD_BLOCK_LEN;
962: continue; }
963: if((i=smb_getmsghdr(&msg))!=0) {
964: smb_unlockmsghdr(msg);
965: m++;
966: size=SHD_BLOCK_LEN;
967: continue; }
968: smb_unlockmsghdr(msg);
969: if(msg.hdr.attr&MSG_DELETE) {
970: m+=smb_hdrblocks(msg.hdr.length);
971: total=0;
972: for(i=0;i<msg.hdr.total_dfields;i++)
973: total+=msg.dfield[i].length;
974: n+=smb_datblocks(total); }
975: size=smb_getmsghdrlen(msg);
976: if(size<1) size=SHD_BLOCK_LEN;
977: while(size%SHD_BLOCK_LEN)
978: size++;
979: smb_freemsgmem(msg); }
980:
981:
982: if(!m && !n) {
983: printf("\rAlready compressed.\n\n");
984: smb_unlocksmbhdr();
985: return; }
986:
987: if(packable && (n*SDT_BLOCK_LEN)+(m*SHD_BLOCK_LEN)<packable*1024L) {
988: printf("\rLess than %luk compressable bytes.\n\n",packable);
989: smb_unlocksmbhdr();
990: return; }
991:
992: printf("\rCompressing %lu data blocks (%lu bytes)\n"
993: " and %lu header blocks (%lu bytes)\n"
994: ,n,n*SDT_BLOCK_LEN,m,m*SHD_BLOCK_LEN); }
995:
996: sprintf(fname,"%s.SD$",smb_file);
997: tmp_sdt=fopen(fname,"wb");
998: sprintf(fname,"%s.SH$",smb_file);
999: tmp_shd=fopen(fname,"wb");
1000: sprintf(fname,"%s.SI$",smb_file);
1001: tmp_sid=fopen(fname,"wb");
1002: if(!tmp_sdt || !tmp_shd || !tmp_sid) {
1003: smb_unlocksmbhdr();
1004: if(!(status.attr&SMB_HYPERALLOC)) {
1005: fclose(sha_fp);
1006: fclose(sda_fp); }
1007: printf("error opening temp file\n");
1008: return; }
1009: setvbuf(tmp_sdt,NULL,_IOFBF,2*1024);
1010: setvbuf(tmp_shd,NULL,_IOFBF,2*1024);
1011: setvbuf(tmp_sid,NULL,_IOFBF,2*1024);
1012: if(!(status.attr&SMB_HYPERALLOC)
1013: && (datoffset=(datoffset_t *)LMALLOC(sizeof(datoffset_t)*status.total_msgs))
1014: ==NULL) {
1015: smb_unlocksmbhdr();
1016: fclose(sha_fp);
1017: fclose(sda_fp);
1018: fclose(tmp_sdt);
1019: fclose(tmp_shd);
1020: fclose(tmp_sid);
1021: printf("error allocating mem\n");
1022: return; }
1023: fseek(shd_fp,0L,SEEK_SET);
1024: fread(&hdr,1,sizeof(smbhdr_t),shd_fp);
1025: fwrite(&hdr,1,sizeof(smbhdr_t),tmp_shd);
1026: fwrite(&status,1,sizeof(smbstatus_t),tmp_shd);
1027: for(l=sizeof(smbhdr_t)+sizeof(smbstatus_t);l<status.header_offset;l++) {
1028: fread(&ch,1,1,shd_fp); /* copy additional base header records */
1029: fwrite(&ch,1,1,tmp_shd); }
1030: fseek(sid_fp,0L,SEEK_SET);
1031: total=0;
1032: for(l=0;l<status.total_msgs;l++) {
1033: printf("%lu of %lu\r",l+1,status.total_msgs);
1034: if(!fread(&msg.idx,1,sizeof(idxrec_t),sid_fp))
1035: break;
1036: if(msg.idx.attr&MSG_DELETE) {
1037: printf("\nDeleted index.\n");
1038: continue; }
1039: i=smb_lockmsghdr(msg,10);
1040: if(i) {
1041: printf("\nsmb_lockmsghdr returned %d\n",i);
1042: continue; }
1043: i=smb_getmsghdr(&msg);
1044: smb_unlockmsghdr(msg);
1045: if(i) {
1046: printf("\nsmb_getmsghdr returned %d\n",i);
1047: continue; }
1048: if(msg.hdr.attr&MSG_DELETE) {
1049: printf("\nDeleted header.\n");
1050: smb_freemsgmem(msg);
1051: continue; }
1052: for(m=0;m<datoffsets;m++)
1053: if(msg.hdr.offset==datoffset[m].old)
1054: break;
1055: if(m<datoffsets) { /* another index pointed to this data */
1056: printf("duplicate index\n");
1057: msg.hdr.offset=datoffset[m].new;
1058: smb_incdat(datoffset[m].new,smb_getmsgdatlen(msg),1); }
1059: else {
1060:
1061: if(!(status.attr&SMB_HYPERALLOC))
1062: datoffset[datoffsets].old=msg.hdr.offset;
1063:
1064: fseek(sdt_fp,msg.hdr.offset,SEEK_SET);
1065:
1066: m=smb_getmsgdatlen(msg);
1067: if(m>16L*1024L*1024L) {
1068: printf("\nInvalid data length (%lu)\n",m);
1069: continue; }
1070:
1071: if(!(status.attr&SMB_HYPERALLOC)) {
1072: datoffset[datoffsets].new=msg.hdr.offset
1073: =smb_fallocdat(m,1);
1074: datoffsets++;
1075: fseek(tmp_sdt,msg.hdr.offset,SEEK_SET); }
1076: else {
1077: fseek(tmp_sdt,0L,SEEK_END);
1078: msg.hdr.offset=ftell(tmp_sdt); }
1079:
1080: /* Actually copy the data */
1081:
1082: n=smb_datblocks(m);
1083: for(m=0;m<n;m++) {
1084: fread(buf,1,SDT_BLOCK_LEN,sdt_fp);
1085: if(!m && *(ushort *)buf!=XLAT_NONE && *(ushort *)buf!=XLAT_LZH) {
1086: printf("\nUnsupported translation type (%04X)\n"
1087: ,*(ushort *)buf);
1088: break; }
1089: fwrite(buf,1,SDT_BLOCK_LEN,tmp_sdt); }
1090: if(m<n)
1091: continue; }
1092:
1093: /* Write the new index entry */
1094: length=smb_getmsghdrlen(msg);
1095: if(status.attr&SMB_HYPERALLOC)
1096: msg.idx.offset=ftell(tmp_shd);
1097: else
1098: msg.idx.offset=smb_fallochdr(length)+status.header_offset;
1099: fwrite(&msg.idx,1,sizeof(idxrec_t),tmp_sid);
1100:
1101: /* Write the new header entry */
1102: fseek(tmp_shd,msg.idx.offset,SEEK_SET);
1103: fwrite(&msg.hdr,1,sizeof(msghdr_t),tmp_shd);
1104: for(n=0;n<msg.hdr.total_dfields;n++)
1105: fwrite(&msg.dfield[n],1,sizeof(dfield_t),tmp_shd);
1106: for(n=0;n<msg.total_hfields;n++) {
1107: fwrite(&msg.hfield[n],1,sizeof(hfield_t),tmp_shd);
1108: fwrite(msg.hfield_dat[n],1,msg.hfield[n].length,tmp_shd); }
1109: while(length%SHD_BLOCK_LEN) { /* pad with NULLs */
1110: fputc(0,tmp_shd);
1111: length++; }
1112: total++;
1113: smb_freemsgmem(msg); }
1114:
1115: if(datoffset)
1116: LFREE(datoffset);
1117: if(!(status.attr&SMB_HYPERALLOC)) {
1118: fclose(sha_fp);
1119: fclose(sda_fp); }
1120:
1121: /* Change *.SH$ into *.SHD */
1122: fclose(shd_fp);
1123: fclose(tmp_shd);
1124: sprintf(fname,"%s.SHD",smb_file);
1125: remove(fname);
1126: sprintf(tmpfname,"%s.SH$",smb_file);
1127: rename(tmpfname,fname);
1128:
1129: /* Change *.SD$ into *.SDT */
1130: fclose(sdt_fp);
1131: fclose(tmp_sdt);
1132: sprintf(fname,"%s.SDT",smb_file);
1133: remove(fname);
1134: sprintf(tmpfname,"%s.SD$",smb_file);
1135: rename(tmpfname,fname);
1136:
1137: /* Change *.SI$ into *.SID */
1138: fclose(sid_fp);
1139: fclose(tmp_sid);
1140: sprintf(fname,"%s.SID",smb_file);
1141: remove(fname);
1142: sprintf(tmpfname,"%s.SI$",smb_file);
1143: rename(tmpfname,fname);
1144:
1145: if((i=smb_open(10))!=0) {
1146: printf("Error %d reopening %s\n",i,smb_file);
1147: return; }
1148:
1149: status.total_msgs=total;
1150: if((i=smb_putstatus(status))!=0)
1151: printf("\nsmb_putstatus returned %d\n",i);
1152: printf("\nDone.\n\n");
1153: }
1154:
1155:
1156: /****************************************************************************/
1157: /* Read messages in message base */
1158: /****************************************************************************/
1159: void readmsgs(ulong start)
1160: {
1161: char str[128],*inbuf,*outbuf;
1162: int i,ch,done=0,domsg=1,lzh;
1163: ushort xlat;
1164: ulong l,count,outlen;
1165: smbmsg_t msg;
1166:
1167: if(start)
1168: msg.offset=start-1;
1169: else
1170: msg.offset=0;
1171: while(!done) {
1172: if(domsg) {
1173: fseek(sid_fp,msg.offset*sizeof(idxrec_t),SEEK_SET);
1174: if(!fread(&msg.idx,1,sizeof(idxrec_t),sid_fp))
1175: break;
1176: i=smb_lockmsghdr(msg,10);
1177: if(i) {
1178: printf("smb_lockmsghdr returned %d\n",i);
1179: break; }
1180: i=smb_getmsghdr(&msg);
1181: if(i) {
1182: printf("smb_getmsghdr returned %d\n",i);
1183: break; }
1184:
1185: printf("\n%lu (%lu)\n",msg.hdr.number,msg.offset+1);
1186: printf("Subj : %s\n",msg.subj);
1187: printf("To : %s",msg.to);
1188: if(msg.to_net.type)
1189: printf(" (%s)",msg.to_net.type==NET_FIDO
1190: ? faddrtoa(*(fidoaddr_t *)msg.to_net.addr) : msg.to_net.addr);
1191: printf("\nFrom : %s",msg.from);
1192: if(msg.from_net.type)
1193: printf(" (%s)",msg.from_net.type==NET_FIDO
1194: ? faddrtoa(*(fidoaddr_t *)msg.from_net.addr)
1195: : msg.from_net.addr);
1196: printf("\nDate : %.24s %s",ctime((time_t *)&msg.hdr.when_written.time)
1197: ,zonestr(msg.hdr.when_written.zone));
1198: printf("\n\n");
1199: for(i=0;i<msg.hdr.total_dfields;i++)
1200: switch(msg.dfield[i].type) {
1201: case TEXT_BODY:
1202: case TEXT_TAIL:
1203: fseek(sdt_fp,msg.hdr.offset+msg.dfield[i].offset
1204: ,SEEK_SET);
1205: fread(&xlat,2,1,sdt_fp);
1206: l=2;
1207: lzh=0;
1208: while(xlat!=XLAT_NONE) {
1209: if(xlat==XLAT_LZH)
1210: lzh=1;
1211: fread(&xlat,2,1,sdt_fp);
1212: l+=2; }
1213: if(lzh) {
1214: if((inbuf=(char *)LMALLOC(msg.dfield[i].length))
1215: ==NULL) {
1216: printf("Malloc error of %lu\n"
1217: ,msg.dfield[i].length);
1218: exit(1); }
1219: fread(inbuf,msg.dfield[i].length-l,1,sdt_fp);
1220: outlen=*(long *)inbuf;
1221: if((outbuf=(char *)LMALLOC(outlen))==NULL) {
1222: printf("Malloc error of lzh %lu\n"
1223: ,outlen);
1224: exit(1); }
1225: lzh_decode(inbuf,msg.dfield[i].length-l,outbuf);
1226: LFREE(inbuf);
1227: for(l=0;l<outlen;l++)
1228: putchar(outbuf[l]);
1229: LFREE(outbuf); }
1230: else {
1231: for(;l<msg.dfield[i].length;l++) {
1232: ch=fgetc(sdt_fp);
1233: if(ch)
1234: putchar(ch); } }
1235: printf("\n");
1236: break; }
1237: i=smb_unlockmsghdr(msg);
1238: if(i) {
1239: printf("smb_unlockmsghdr returned %d\n",i);
1240: break; }
1241: smb_freemsgmem(msg); }
1242: domsg=1;
1243: printf("\nReading %s (?=Menu): ",smb_file);
1244: switch(toupper(getch())) {
1245: case '?':
1246: printf("\n"
1247: "\n"
1248: "(R)e-read current message\n"
1249: "(L)ist messages\n"
1250: "(T)en more titles\n"
1251: "(V)iew message headers\n"
1252: "(Q)uit\n"
1253: "(+/-) Forward/Backward\n"
1254: "\n");
1255: domsg=0;
1256: break;
1257: case 'Q':
1258: printf("Quit\n");
1259: done=1;
1260: break;
1261: case 'R':
1262: printf("Re-read\n");
1263: break;
1264: case '-':
1265: printf("Backwards\n");
1266: if(msg.offset)
1267: msg.offset--;
1268: break;
1269: case 'T':
1270: printf("Ten titles\n");
1271: listmsgs(msg.offset+2,10);
1272: msg.offset+=10;
1273: domsg=0;
1274: break;
1275: case 'L':
1276: printf("List messages\n");
1277: listmsgs(1,-1);
1278: domsg=0;
1279: break;
1280: case 'V':
1281: printf("View message headers\n");
1282: viewmsgs(1,-1);
1283: domsg=0;
1284: break;
1285: case CR:
1286: case '+':
1287: printf("Next\n");
1288: msg.offset++;
1289: break; } }
1290: }
1291:
1292: /***************/
1293: /* Entry point */
1294: /***************/
1295: int main(int argc, char **argv)
1296: {
1297: char cmd[128]="",*p,*s;
1298: int i,j,x,y;
1299: ulong l;
1300: smbstatus_t status;
1301:
1302: #ifdef __TURBOC__
1303: timezone=0; /* Fix for Borland C++ EST default */
1304: daylight=0; /* Fix for Borland C++ EDT default */
1305: #elif defined(__WATCOMC__)
1306: putenv("TZ=UCT0"); /* Fix for Watcom C++ EDT default */
1307: #endif
1308: setvbuf(stdout,0,_IONBF,0);
1309:
1310: smb_file[0]=0;
1311: printf("\nSynchronet Message Base Utility v%s "\
1312: "Copyright 1995 Digital Dynamics\n\n"
1313: ,SMBUTIL_VER);
1314: for(x=1;x<argc;x++) {
1315: if(argv[x][0]=='/') {
1316: for(j=1;argv[x][j];j++)
1317: switch(toupper(argv[x][j])) {
1318: case 'A':
1319: mode|=NOANALYSIS;
1320: break;
1321: case 'Z':
1322: if(isdigit(argv[x][j+1]))
1323: tzone=atoi(argv[x]+j+1);
1324: else if(!stricmp(argv[x]+j+1,"EST"))
1325: tzone=EST;
1326: else if(!stricmp(argv[x]+j+1,"EDT"))
1327: tzone=EDT;
1328: else if(!stricmp(argv[x]+j+1,"CST"))
1329: tzone=CST;
1330: else if(!stricmp(argv[x]+j+1,"CDT"))
1331: tzone=CDT;
1332: else if(!stricmp(argv[x]+j+1,"MST"))
1333: tzone=MST;
1334: else if(!stricmp(argv[x]+j+1,"MDT"))
1335: tzone=MDT;
1336: else if(!stricmp(argv[x]+j+1,"PST"))
1337: tzone=PST;
1338: else if(!stricmp(argv[x]+j+1,"PDT"))
1339: tzone=PDT;
1340: j=strlen(argv[x])-1;
1341: break;
1342: default:
1343: printf("\nUnknown opt '%c'\n",argv[x][j]);
1344: case '?':
1345: printf("%s",usage);
1346: exit(1);
1347: break; } }
1348: else {
1349: if(!cmd[0])
1350: strcpy(cmd,argv[x]);
1351: else {
1352: sprintf(smb_file,"%.64s",argv[x]);
1353: p=strrchr(smb_file,'.');
1354: s=strrchr(smb_file,'\\');
1355: if(p>s) *p=0;
1356: strupr(smb_file);
1357: printf("Opening %s\r\n",smb_file);
1358: if((i=smb_open(10))!=0) {
1359: printf("error %d opening %s message base\n",i,smb_file);
1360: exit(1); }
1361: if(!filelength(fileno(shd_fp))) {
1362: printf("Empty\n");
1363: smb_close();
1364: continue; }
1365: for(y=0;cmd[y];y++)
1366: switch(toupper(cmd[y])) {
1367: case 'I':
1368: strcpy(filein,cmd+1);
1369: i=smb_locksmbhdr(10);
1370: if(i) {
1371: printf("smb_locksmbhdr returned %d\n",i);
1372: return(1); }
1373: i=smb_getstatus(&status);
1374: if(i) {
1375: printf("smb_getstatus returned %d\n",i);
1376: return(1); }
1377: smb_unlocksmbhdr();
1378: postmsg(status);
1379: y=strlen(cmd)-1;
1380: break;
1381: case 'K':
1382: printf("Killing %lu messages...\n",atol(cmd+1));
1383: l=kill(atol(cmd+1));
1384: printf("%lu messages killed.\n",l);
1385: y=strlen(cmd)-1;
1386: break;
1387: case 'S':
1388: showstatus();
1389: break;
1390: case 'C':
1391: config();
1392: break;
1393: case 'L':
1394: listmsgs(atol(cmd+1),-1L);
1395: y=strlen(cmd)-1;
1396: break;
1397: case 'P':
1398: packmsgs(atol(cmd+y+1));
1399: y=strlen(cmd)-1;
1400: break;
1401: case 'R':
1402: readmsgs(atol(cmd+1));
1403: y=strlen(cmd)-1;
1404: break;
1405: case 'V':
1406: viewmsgs(atol(cmd+1),-1L);
1407: y=strlen(cmd)-1;
1408: break;
1409: case 'M':
1410: maint();
1411: break;
1412: default:
1413: printf("%s",usage);
1414: break; }
1415: smb_close(); } } }
1416: if(!cmd[0])
1417: printf("%s",usage);
1418: return(0);
1419: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.