![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chksmb.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 chksmb.c CVS log | Up to [Synchronet] / sbbs / sbbs2 / smb / 121a |
1.1 root 1: /* CHKSMB.C */
2:
3: #include <dos.h>
4: #include "smblib.h"
5:
6: /****************************************************************************/
7: /* Checks the disk drive for the existence of a file. Returns 1 if it */
8: /* exists, 0 if it doesn't. */
9: /* Called from upload */
10: /****************************************************************************/
11: char fexist(char *filespec)
12: {
13: struct find_t f;
14:
15: if(!_dos_findfirst(filespec,0,&f))
16: return(1);
17: return(0);
18: }
19:
20: /****************************************************************************/
21: /* Returns in 'string' a character representation of the number in l with */
22: /* commas. */
23: /****************************************************************************/
24: char *ultoac(ulong l, char *string)
25: {
26: char str[256];
27: signed char i,j,k;
28:
29: ultoa(l,str,10);
30: i=strlen(str)-1;
31: j=i/3+1+i;
32: string[j--]=0;
33: for(k=1;i>-1;k++) {
34: string[j--]=str[i--];
35: if(j>0 && !(k%3))
36: string[j--]=','; }
37: return(string);
38: }
39:
40: /****************************************************************************/
41: /* Returns an ASCII string for FidoNet address 'addr' */
42: /****************************************************************************/
43: char *faddrtoa(fidoaddr_t addr)
44: {
45: static char str[25];
46: char point[25];
47:
48: sprintf(str,"%u:%u/%u",addr.zone,addr.net,addr.node);
49: if(addr.point) {
50: sprintf(point,".%u",addr.point);
51: strcat(str,point); }
52: return(str);
53: }
54:
55: char *usage="\nusage: chksmb [/opts] <filespec.SHD>\n"
56: "\n"
57: " opts:\n"
58: " s - stop after errored message base\n"
59: " p - pause after errored messsage base\n"
60: " q - quiet mode (no beeps while checking)\n"
61: " t - don't check translation strings\n"
62: " e - display extended info on corrupted msgs\n";
63:
64: int main(int argc, char **argv)
65: {
66: char str[128],*p,*s,*beep="\7";
67: int i,j,x,y,lzh,errors,errlast,stop_on_error=0,pause_on_error=0
68: ,chkxlat=1,lzhmsg,extinfo=0,msgerr;
69: ushort xlat;
70: ulong l,m,n,length,size,total=0,orphan=0,deleted=0,headers=0
71: ,*offset,*number,xlaterr
72: ,delhdrblocks,deldatblocks,hdrerr=0,lockerr=0,hdrnumerr=0
73: ,acthdrblocks,actdatblocks
74: ,dfieldlength=0,dfieldoffset=0
75: ,dupenum=0,dupenumhdr=0,dupeoff=0,attr=0,actalloc=0
76: ,datactalloc=0,misnumbered=0,timeerr=0,idxofferr=0,idxerr
77: ,zeronum,idxzeronum,idxnumerr,packable=0L,totallzhsaved=0L
78: ,totalmsgs=0,totallzhmsgs=0,totaldelmsgs=0,totalmsgbytes=0L
79: ,lzhblocks,lzhsaved;
80: idxrec_t idx;
81: smbmsg_t msg;
82: smbstatus_t status;
83:
84: fprintf(stderr,"\nCHKSMB v1.24 � Check Synchronet Message Base � "
85: "Copyright 1995 Digital Dynamics\n");
86:
87: if(argc<2) {
88: printf("%s",usage);
89: exit(1); }
90:
91: errlast=errors=0;
92: for(x=1;x<argc;x++) {
93: if(stop_on_error && errors)
94: break;
95: if(pause_on_error && errlast!=errors) {
96: fprintf(stderr,"\7\nHit any key to continue...");
97: if(!getch())
98: getch();
99: printf("\n"); }
100: errlast=errors;
101: if(argv[x][0]=='/') {
102: for(y=1;argv[x][y];y++)
103: switch(toupper(argv[x][y])) {
104: case 'Q':
105: beep="";
106: break;
107: case 'P':
108: pause_on_error=1;
109: break;
110: case 'S':
111: stop_on_error=1;
112: break;
113: case 'T':
114: chkxlat=0;
115: break;
116: case 'E':
117: extinfo=1;
118: break;
119: default:
120: printf("%s",usage);
121: exit(1); }
122: continue; }
123:
124: strcpy(smb_file,argv[x]);
125: p=strrchr(smb_file,'.');
126: s=strrchr(smb_file,'\\');
127: if(p>s) *p=0;
128: strupr(smb_file);
129:
130: sprintf(str,"%s.SHD",smb_file);
131: if(!fexist(str)) {
132: printf("\n%s doesn't exist.\n",smb_file);
133: continue; }
134:
135: fprintf(stderr,"\nChecking %s Headers\n\n",smb_file);
136:
137: if((i=smb_open(10))!=0) {
138: printf("smb_open returned %d\n",i);
139: errors++;
140: continue; }
141:
142: if(filelength(fileno(shd_fp))<sizeof(smbhdr_t)) {
143: printf("Empty\n");
144: smb_close();
145: continue; }
146:
147: if((i=smb_locksmbhdr(10))!=0) {
148: smb_close();
149: printf("smb_locksmbhdr returned %d\n",i);
150: errors++;
151: continue; }
152:
153: if((i=smb_getstatus(&status))!=0) {
154: smb_unlocksmbhdr();
155: smb_close();
156: printf("smb_getstatus returned %d\n",i);
157: errors++;
158: continue; }
159:
160:
161: length=filelength(fileno(shd_fp));
162:
163: if((length/SHD_BLOCK_LEN)*sizeof(ulong)) {
164: if((number=(ulong *)MALLOC(((length/SHD_BLOCK_LEN)+2)*sizeof(ulong)))
165: ==NULL) {
166: printf("Error allocating %lu bytes of memory\n"
167: ,(length/SHD_BLOCK_LEN)*sizeof(ulong));
168: return(++errors); } }
169: else
170: number=NULL;
171:
172: if(!(status.attr&SMB_HYPERALLOC)) {
173: if((i=smb_open_ha(10))!=0) {
174: printf("smb_open_ha returned %d\n",i);
175: return(++errors); }
176:
177: if((i=smb_open_da(10))!=0) {
178: printf("smb_open_da returned %d\n",i);
179: return(++errors); } }
180:
181: headers=deleted=orphan=dupenumhdr=attr=zeronum=timeerr=lockerr=hdrerr=0;
182: actalloc=datactalloc=deldatblocks=delhdrblocks=xlaterr=0;
183: lzhblocks=lzhsaved=acthdrblocks=actdatblocks=0;
184:
185: for(l=status.header_offset;l<length;l+=size) {
186: fprintf(stderr,"\r%2u%% ",(long)(100.0/((float)length/l)));
187: msg.idx.offset=l;
188: msgerr=0;
189: if((i=smb_lockmsghdr(msg,10))!=0) {
190: printf("\n(%06lX) smb_lockmsghdr returned %d\n",l,i);
191: lockerr++;
192: headers++;
193: size=SHD_BLOCK_LEN;
194: continue; }
195: if((i=smb_getmsghdr(&msg))!=0) {
196: smb_unlockmsghdr(msg);
197: if(!(status.attr&SMB_HYPERALLOC)) {
198: fseek(sha_fp,(l-status.header_offset)/SHD_BLOCK_LEN,SEEK_SET);
199: j=fgetc(sha_fp);
200: if(j) { /* Allocated block or at EOF */
201: printf("%s\n(%06lX) smb_getmsghdr returned %d\n",beep,l,i);
202: hdrerr++; }
203: else
204: delhdrblocks++; }
205: else {
206: /* printf("%s\n(%06lX) smb_getmsghdr returned %d\n",beep,l,i); */
207: delhdrblocks++; }
208: size=SHD_BLOCK_LEN;
209: continue; }
210: smb_unlockmsghdr(msg);
211: fprintf(stderr,"#%-5lu (%06lX) %-25.25s ",msg.hdr.number,l,msg.from);
212:
213: lzhmsg=0;
214: if(msg.hdr.attr&MSG_DELETE) {
215: deleted++;
216: if(number)
217: number[headers]=0;
218: if(status.attr&SMB_HYPERALLOC)
219: deldatblocks+=smb_datblocks(smb_getmsgdatlen(msg)); }
220: else {
221: actdatblocks+=smb_datblocks(smb_getmsgdatlen(msg));
222: if(msg.hdr.number>status.last_msg) {
223: fprintf(stderr,"%sOut-Of-Range message number\n",beep);
224: msgerr=1;
225: if(extinfo)
226: printf("MSGERR: Header number (%lu) greater than last (%lu)\n"
227: ,msg.hdr.number,status.last_msg);
228: hdrnumerr++; }
229:
230: if(smb_getmsgidx(&msg)) {
231: fprintf(stderr,"%sNot found in index\n",beep);
232: msgerr=1;
233: if(extinfo)
234: printf("MSGERR: Header number (%lu) not found in index\n"
235: ,msg.hdr.number);
236: orphan++; }
237: else if(msg.hdr.attr!=msg.idx.attr) {
238: fprintf(stderr,"%sAttributes mismatch index\n",beep);
239: msgerr=1;
240: if(extinfo)
241: printf("MSGERR: Header attributes (%04X) do not match index "
242: "attributes (%04X)\n"
243: ,msg.hdr.attr,msg.idx.attr);
244: attr++; }
245: else if(msg.hdr.when_imported.time!=msg.idx.time) {
246: fprintf(stderr,"%sImport date/time mismatch index\n",beep);
247: msgerr=1;
248: if(extinfo)
249: printf("MSGERR: Header import date/time does not match "
250: "index import date/time\n");
251: timeerr++; }
252:
253: if(msg.hdr.number==0) {
254: fprintf(stderr,"%sZero message number\n",beep);
255: msgerr=1;
256: if(extinfo)
257: printf("MSGERR: Header number is zero (invalid)\n");
258: zeronum++; }
259: if(number) {
260: for(m=0;m<headers;m++)
261: if(number[m] && msg.hdr.number==number[m]) {
262: fprintf(stderr,"%sDuplicate message number\n",beep);
263: msgerr=1;
264: if(extinfo)
265: printf("MSGERR: Header number (%lu) duplicated\n"
266: ,msg.hdr.number);
267: dupenumhdr++;
268: break; }
269: number[headers]=msg.hdr.number; }
270: if(chkxlat) { /* Check translation strings */
271: for(i=0;i<msg.hdr.total_dfields;i++) {
272: fseek(sdt_fp,msg.hdr.offset+msg.dfield[i].offset,SEEK_SET);
273: if(!fread(&xlat,2,1,sdt_fp))
274: xlat=0xffff;
275: lzh=0;
276: if(xlat==XLAT_LZH) {
277: lzh=1;
278: if(!fread(&xlat,2,1,sdt_fp))
279: xlat=0xffff; }
280: if(xlat!=XLAT_NONE) {
281: fprintf(stderr,"%sUnsupported Xlat %04X dfield[%u]\n"
282: ,beep,xlat,i);
283: msgerr=1;
284: if(extinfo)
285: printf("MSGERR: Unsupported translation type (%04X) "
286: "in dfield[%u]\n"
287: ,xlat,i);
288: xlaterr++; }
289: else {
290: if(lzh) {
291: lzhmsg=1;
292: if(fread(&m,4,1,sdt_fp)) { /* Get uncompressed len */
293: lzhsaved+=(smb_datblocks(m+2)
294: -smb_datblocks(msg.dfield[i].length))
295: *SDT_BLOCK_LEN;
296: lzhblocks+=smb_datblocks(msg.dfield[i].length);
297: } } } } } }
298:
299: size=smb_getmsghdrlen(msg);
300: while(size%SHD_BLOCK_LEN)
301: size++;
302:
303: if(!(status.attr&SMB_HYPERALLOC)) {
304: fseek(sha_fp,(l-status.header_offset)/SHD_BLOCK_LEN,SEEK_SET);
305: for(m=0;m<size;m+=SHD_BLOCK_LEN) {
306: /***
307: if(msg.hdr.attr&MSG_DELETE && (i=fgetc(sha_fp))!=0) {
308: fprintf(stderr,"%sDeleted Header Block %lu marked %02X\n"
309: ,beep,m/SHD_BLOCK_LEN,i);
310: msgerr=1;
311: delalloc++; }
312: ***/
313: if(!(msg.hdr.attr&MSG_DELETE) && (i=fgetc(sha_fp))!=1) {
314: fprintf(stderr,"%sActive Header Block %lu marked %02X\n"
315: ,beep,m/SHD_BLOCK_LEN,i);
316: msgerr=1;
317: if(extinfo)
318: printf("MSGERR: Active header block %lu marked %02X "
319: "instead of 01\n"
320: ,m/SHD_BLOCK_LEN,i);
321: actalloc++; } }
322:
323: if(!(msg.hdr.attr&MSG_DELETE)) {
324: acthdrblocks+=(size/SHD_BLOCK_LEN);
325: for(n=0;n<msg.hdr.total_dfields;n++) {
326: if(msg.dfield[n].offset&0x80000000UL) {
327: msgerr=1;
328: if(extinfo)
329: printf("MSGERR: Invalid Data Field [%u] Offset: %lu\n"
330: ,n,msg.dfield[n].offset);
331: dfieldoffset++; }
332: if(msg.dfield[n].length&0x80000000UL) {
333: msgerr=1;
334: if(extinfo)
335: printf("MSGERR: Invalid Data Field [%u] Length: %lu\n"
336: ,n,msg.dfield[n].length);
337: dfieldlength++; }
338: fseek(sda_fp
339: ,((msg.hdr.offset+msg.dfield[n].offset)/SDT_BLOCK_LEN)*2
340: ,SEEK_SET);
341: for(m=0;m<msg.dfield[n].length;m+=SDT_BLOCK_LEN) {
342: if(!fread(&i,2,1,sda_fp) || !i) {
343: fprintf(stderr
344: ,"%sActive Data Block %lu.%lu marked free\n"
345: ,beep,n,m/SHD_BLOCK_LEN);
346: msgerr=1;
347: if(extinfo)
348: printf("MSGERR: Active Data Block %lu.%lu "
349: "marked free\n"
350: ,n,m/SHD_BLOCK_LEN);
351: datactalloc++; } } } }
352: else
353: delhdrblocks+=(size/SHD_BLOCK_LEN); }
354:
355: else { /* Hyper Alloc */
356: if(msg.hdr.attr&MSG_DELETE)
357: delhdrblocks+=(size/SHD_BLOCK_LEN);
358: else
359: acthdrblocks+=(size/SHD_BLOCK_LEN); }
360:
361: totallzhmsgs+=lzhmsg;
362: headers++;
363: if(msgerr && extinfo) {
364: printf("\n");
365: printf("%-20s: %s\n","Message Base",smb_file);
366: printf("%-20s: %lu (%lu)\n","Message Number"
367: ,msg.hdr.number,msg.offset+1);
368: printf("%-20s: %s\n","Subject",msg.subj);
369: printf("%-20s: %s","To",msg.to);
370: if(msg.to_net.type)
371: printf(" (%s)",msg.to_net.type==NET_FIDO
372: ? faddrtoa(*(fidoaddr_t *)msg.to_net.addr) : msg.to_net.addr);
373: printf("\n%-20s: %s","From",msg.from);
374: if(msg.from_net.type)
375: printf(" (%s)",msg.from_net.type==NET_FIDO
376: ? faddrtoa(*(fidoaddr_t *)msg.from_net.addr)
377: : msg.from_net.addr);
378: printf("\n");
379: printf("%-20s: %.24s\n","When Written"
380: ,ctime((time_t *)&msg.hdr.when_written.time));
381: printf("%-20s: %.24s\n","When Imported"
382: ,ctime((time_t *)&msg.hdr.when_imported.time));
383: printf("%-20s: %04hXh\n","Type"
384: ,msg.hdr.type);
385: printf("%-20s: %04hXh\n","Version"
386: ,msg.hdr.version);
387: printf("%-20s: %u\n","Length"
388: ,msg.hdr.length);
389: printf("%-20s: %04hXh\n","Attributes"
390: ,msg.hdr.attr);
391: printf("%-20s: %08lXh\n","Auxilary Attributes"
392: ,msg.hdr.auxattr);
393: printf("%-20s: %08lXh\n","Network Attributes"
394: ,msg.hdr.netattr);
395: printf("%-20s: %06lXh\n","Header Offset"
396: ,msg.idx.offset);
397: printf("%-20s: %06lXh\n","Data Offset"
398: ,msg.hdr.offset);
399: printf("%-20s: %u\n","Total Data Fields"
400: ,msg.hdr.total_dfields);
401: printf("\n"); }
402:
403: smb_freemsgmem(msg); }
404:
405: if(number)
406: FREE(number);
407:
408: fprintf(stderr,"\r%79s\r100%%\n","");
409:
410:
411: if(!(status.attr&SMB_HYPERALLOC)) {
412:
413: fprintf(stderr,"\nChecking %s Data Blocks\n\n",smb_file);
414:
415: length=filelength(fileno(sda_fp));
416:
417: fseek(sda_fp,0L,SEEK_SET);
418: for(l=0;l<length;l+=2) {
419: fprintf(stderr,"\r%2u%% ",l ? (long)(100.0/((float)length/l)) : 0);
420: i=0;
421: if(!fread(&i,2,1,sda_fp))
422: break;
423: if(!i)
424: deldatblocks++; }
425:
426: fclose(sha_fp);
427: fclose(sda_fp);
428:
429: fprintf(stderr,"\r%79s\r100%%\n",""); }
430:
431: total=filelength(fileno(sid_fp))/sizeof(idxrec_t);
432:
433: dupenum=dupeoff=misnumbered=idxzeronum=idxnumerr=idxofferr=idxerr=0;
434:
435: if(total) {
436:
437: fprintf(stderr,"\nChecking %s Index\n\n",smb_file);
438:
439: if((offset=(ulong *)MALLOC(total*sizeof(ulong)))==NULL) {
440: printf("Error allocating %lu bytes of memory\n",total*sizeof(ulong));
441: return(++errors); }
442: if((number=(ulong *)MALLOC(total*sizeof(ulong)))==NULL) {
443: printf("Error allocating %lu bytes of memory\n",total*sizeof(ulong));
444: return(++errors); }
445: fseek(sid_fp,0L,SEEK_SET);
446:
447: for(l=0;l<total;l++) {
448: fprintf(stderr,"\r%2lu%% %5lu ",l ? (long)(100.0/((float)total/l)) : 0,l);
449: if(!fread(&idx,sizeof(idxrec_t),1,sid_fp))
450: break;
451: fprintf(stderr,"#%-5lu (%06lX) 1st Pass ",idx.number,idx.offset);
452: /***
453: if(idx.attr&MSG_DELETE) {
454: fprintf(stderr,"%sMarked for deletion\n",beep);
455: delidx++; }
456: ***/
457: for(m=0;m<l;m++)
458: if(number[m]==idx.number) {
459: fprintf(stderr,"%sDuplicate message number\n",beep);
460: dupenum++;
461: break; }
462: for(m=0;m<l;m++)
463: if(offset[m]==idx.offset) {
464: fprintf(stderr,"%sDuplicate offset\n",beep,idx.offset);
465: dupeoff++;
466: break; }
467: if(idx.offset<status.header_offset) {
468: fprintf(stderr,"%sInvalid offset\n",beep);
469: idxofferr++;
470: break; }
471: if(idx.number==0) {
472: fprintf(stderr,"%sZero message number\n",beep);
473: idxzeronum++;
474: break; }
475: if(idx.number>status.last_msg) {
476: fprintf(stderr,"%sOut-Of-Range message number\n",beep);
477: idxnumerr++;
478: break; }
479: number[l]=idx.number;
480: offset[l]=idx.offset; }
481:
482: if(l<total) {
483: fprintf(stderr,"%sError reading index record\n",beep);
484: idxerr=1; }
485: else {
486: fprintf(stderr,"\r%79s\r","");
487: for(m=0;m<total;m++) {
488: fprintf(stderr,"\r%2lu%% %5lu ",m ? (long)(100.0/((float)total/m)) : 0,m);
489: fprintf(stderr,"#%-5lu (%06lX) 2nd Pass ",number[m],offset[m]);
490: for(n=0;n<m;n++)
491: if(number[m] && number[n] && number[m]<number[n]) {
492: fprintf(stderr,"%sMisordered message number\n",beep);
493: misnumbered++;
494: number[n]=0;
495: break; } }
496: fprintf(stderr,"\r%79s\r100%%\n",""); }
497: FREE(number);
498: FREE(offset);
499:
500: } /* if(total) */
501:
502: totalmsgs+=status.total_msgs;
503: totalmsgbytes+=(acthdrblocks*SHD_BLOCK_LEN)+(actdatblocks*SDT_BLOCK_LEN);
504: totaldelmsgs+=deleted;
505: totallzhsaved+=lzhsaved;
506: printf("\n");
507: printf("%-35.35s (=): %lu\n"
508: ,"Status Total"
509: ,status.total_msgs);
510: printf("%-35.35s (=): %lu\n"
511: ,"Index Records"
512: ,total);
513: printf("%-35.35s (=): %lu\n"
514: ,"Active Headers"
515: ,headers-deleted);
516: printf("%-35.35s ( ): %-8lu %13s bytes used\n"
517: ,"Active Header Blocks"
518: ,acthdrblocks,ultoac(acthdrblocks*SHD_BLOCK_LEN,str));
519: printf("%-35.35s ( ): %-8lu %13s bytes used\n"
520: ,"Active Data Blocks"
521: ,actdatblocks,ultoac(actdatblocks*SDT_BLOCK_LEN,str));
522: if(lzhblocks)
523: printf("%-35.35s ( ): %-8lu %13s bytes saved\n"
524: ,"Active LZH Compressed Data Blocks"
525: ,lzhblocks,ultoac(lzhsaved,str));
526: printf("%-35.35s ( ): %lu\n"
527: ,"Header Records"
528: ,headers);
529: printf("%-35.35s ( ): %lu\n"
530: ,"Deleted Headers"
531: ,deleted);
532: printf("%-35.35s ( ): %-8lu %13s bytes used\n"
533: ,"Deleted Header Blocks"
534: ,delhdrblocks,ultoac(delhdrblocks*SHD_BLOCK_LEN,str));
535: packable+=(delhdrblocks*SHD_BLOCK_LEN);
536: printf("%-35.35s ( ): %-8lu %13s bytes used\n"
537: ,"Deleted Data Blocks"
538: ,deldatblocks,ultoac(deldatblocks*SDT_BLOCK_LEN,str));
539: packable+=(deldatblocks*SDT_BLOCK_LEN);
540:
541: if(orphan)
542: printf("%-35.35s (!): %lu\n"
543: ,"Orphaned Headers"
544: ,orphan);
545: if(idxzeronum)
546: printf("%-35.35s (!): %lu\n"
547: ,"Zeroed Index Numbers"
548: ,idxzeronum);
549: if(zeronum)
550: printf("%-35.35s (!): %lu\n"
551: ,"Zeroed Header Numbers"
552: ,zeronum);
553: /***
554: if(delidx)
555: printf("%-35.35s (!): %lu\n"
556: ,"Deleted Index Records"
557: ,delidx);
558: ***/
559: if(idxofferr)
560: printf("%-35.35s (!): %lu\n"
561: ,"Invalid Index Offsets"
562: ,idxofferr);
563: if(dupenum)
564: printf("%-35.35s (!): %lu\n"
565: ,"Duplicate Index Numbers"
566: ,dupenum);
567: if(dupeoff)
568: printf("%-35.35s (!): %lu\n"
569: ,"Duplicate Index Offsets"
570: ,dupeoff);
571: if(dupenumhdr)
572: printf("%-35.35s (!): %lu\n"
573: ,"Duplicate Header Numbers"
574: ,dupenumhdr);
575: if(misnumbered)
576: printf("%-35.35s (!): %lu\n"
577: ,"Misordered Index Numbers"
578: ,misnumbered);
579: if(lockerr)
580: printf("%-35.35s (!): %lu\n"
581: ,"Unlockable Header Records"
582: ,lockerr);
583: if(hdrerr)
584: printf("%-35.35s (!): %lu\n"
585: ,"Unreadable Header Records"
586: ,hdrerr);
587: if(idxnumerr)
588: printf("%-35.35s (!): %lu\n"
589: ,"Out-Of-Range Index Numbers"
590: ,idxnumerr);
591: if(hdrnumerr)
592: printf("%-35.35s (!): %lu\n"
593: ,"Out-Of-Range Header Numbers"
594: ,hdrnumerr);
595: if(attr)
596: printf("%-35.35s (!): %lu\n"
597: ,"Mismatched Header Attributes"
598: ,attr);
599: if(timeerr)
600: printf("%-35.35s (!): %lu\n"
601: ,"Mismatched Header Import Time"
602: ,timeerr);
603: if(xlaterr)
604: printf("%-35.35s (!): %lu\n"
605: ,"Unsupported Translation Types"
606: ,xlaterr);
607: if(datactalloc)
608: printf("%-35.35s (!): %lu\n"
609: ,"Misallocated Active Data Blocks"
610: ,datactalloc);
611: if(actalloc)
612: printf("%-35.35s (!): %lu\n"
613: ,"Misallocated Active Header Blocks"
614: ,actalloc);
615: /***
616: if(delalloc)
617: printf("%-35.35s (!): %lu\n"
618: ,"Misallocated Deleted Header Blocks"
619: ,delalloc);
620: ***/
621:
622: if(dfieldoffset)
623: printf("%-35.35s (!): %lu\n"
624: ,"Invalid Data Field Offsets"
625: ,dfieldoffset);
626:
627: if(dfieldlength)
628: printf("%-35.35s (!): %lu\n"
629: ,"Invalid Data Field Lengths"
630: ,dfieldlength);
631:
632:
633: printf("\n%s Message Base ",smb_file);
634: if((headers-deleted)!=status.total_msgs || total!=status.total_msgs
635: || (headers-deleted)!=total || idxzeronum || zeronum
636: || orphan || dupenumhdr || dupenum || dupeoff || attr
637: || lockerr || hdrerr || hdrnumerr || idxnumerr || idxofferr
638: || actalloc || datactalloc || misnumbered || timeerr
639: || dfieldoffset || dfieldlength || xlaterr || idxerr) {
640: printf("%shas Errors!\n",beep);
641: errors++; }
642: else
643: printf("is OK\n");
644:
645: smb_unlocksmbhdr();
646: smb_close();
647: }
648: if(pause_on_error && errlast!=errors) {
649: fprintf(stderr,"\7\nHit any key to continue...");
650: if(!getch())
651: getch();
652: fprintf(stderr,"\n"); }
653:
654: if((totalmsgs && (totalmsgs!=status.total_msgs || totallzhmsgs))
655: || packable)
656: printf("\n");
657: if(totalmsgs && totalmsgs!=status.total_msgs)
658: printf("%-39.39s: %-8lu %13s bytes used\n"
659: ,"Total Active Messages"
660: ,totalmsgs,ultoac(totalmsgbytes,str));
661: if(totallzhmsgs && totalmsgs!=status.total_msgs)
662: printf("%-39.39s: %-8lu %13s bytes saved\n"
663: ,"Total LZH Compressed Messages"
664: ,totallzhmsgs,ultoac(totallzhsaved,str));
665: if(packable)
666: printf("%-39.39s: %-8lu %13s bytes used\n"
667: ,"Total Deleted Messages"
668: ,totaldelmsgs,ultoac(packable,str));
669:
670: return(errors);
671: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.