home *** CD-ROM | disk | FTP | other *** search
/ Windows Undocumented File Formats / Windows Undocumented File Formats.img / CHAP4 / HLPDUMP2.C next >
Encoding:
C/C++ Source or Header  |  1997-07-21  |  33.3 KB  |  1,131 lines
  1. /**********************************************************************
  2.  *
  3.  * PROGRAM: HLPDUMP2.C
  4.  *
  5.  * PURPOSE: A dump program that lets you view internal WinHelp files
  6.  *
  7.  * Copyright 1997, Mike Wallace and Pete Davis
  8.  *
  9.  * Chapter 4, Windows Help File Format, from Undocumented Windows
  10.  * File Formats, published by R&D Books, an imprint of Miller Freeman, Inc.
  11.  *
  12.  **********************************************************************/
  13.  
  14. #define MEM_DEBUG 1
  15.  
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <time.h>
  19. #include <conio.h>
  20. #include <ctype.h>
  21. #include <limits.h>
  22. #include <string.h>
  23. #include "winhelp.h"
  24. #include "hlpdump2.h"
  25.  
  26. #define HLP_DEBUG 1
  27.  
  28. #define CHECK_SIGNATURE(is, shouldbe) \
  29.          {if (is != shouldbe) { \
  30.             printf("Signature should be %x, but is %x\n"); \
  31.             return;} }
  32.              
  33.  
  34. /* Tells us if a particular bit is set or not */
  35. #define BITSET(bitmap, bit) \
  36.         ((bitmap & (1 << bit)) ? 1 : 0 )
  37.  
  38. /* Sum of set bits in a byte + 8 */
  39. #define BYTESTOREAD(bitmap) \
  40.         ( BITSET(bitmap, 0) + BITSET(bitmap, 1) + \
  41.           BITSET(bitmap, 2) + BITSET(bitmap, 3) + \
  42.           BITSET(bitmap, 4) + BITSET(bitmap, 5) + \
  43.           BITSET(bitmap, 6) + BITSET(bitmap, 7) + 8 )
  44.  
  45.  
  46. /***************************************************
  47.   Loads the HFSFileHeader
  48. ****************************************************/
  49.  
  50. long LoadHeader(FILE *HelpFile) 
  51. {
  52.   HFSFILEHEADER fileHeader;
  53.   
  54.   fread(&fileHeader, sizeof(HFSFILEHEADER), 1, HelpFile);
  55.   
  56. #ifdef HLP_DEBUG
  57.   printf("DEBUG -> LoadHeader()\n");
  58.   printf("File plus Header: %ld\n", fileHeader.FilePlusHeader);
  59.   printf("File size: %ld\n", fileHeader.FileSize);
  60.   printf("File type: 0x%02x\n\n", fileHeader.FileType);
  61. #endif
  62.   
  63.   return fileHeader.FileSize;
  64. }
  65.  
  66.  
  67. /*************************************************
  68.   Decompresses the data using Microsoft's LZ77
  69. derivative (called Zeck Compression)
  70. **************************************************/ 
  71.  
  72. long Decompress(FILE *HelpFile, long CompSize, char *Buffer) {
  73.  
  74. long InBytes = 0;        /* How many bytes read in                    */
  75. long OutBytes = 0;       /* How many bytes written out                */
  76. BYTE BitMap, Set[16];    /* Bitmap and bytes associated with it       */
  77. long NumToRead;          /* Number of bytes to read for next group    */
  78. long counter, Index;     /* Going through next 8-16 codes or chars    */
  79. long Length, Distance;   /* Code length and distance back in 'window' */
  80. char *CurrPos;           /* Where we are at any given moment          */
  81. char *CodePtr;           /* Pointer to back-up in LZ77 'window'       */
  82.  
  83.  
  84.   CurrPos = Buffer;
  85.  
  86.   /* Go through until we're done */
  87.   while (InBytes < CompSize) {
  88.  
  89.     /* Get BitMap and data following it */
  90.     BitMap = (BYTE) fgetc(HelpFile);
  91.     NumToRead = BYTESTOREAD(BitMap);
  92.  
  93.     /* If we're trying to read more than we've 
  94.        got left, only read what we have left.  */
  95.     NumToRead = (CompSize - InBytes) < NumToRead ? 
  96.                                     CompSize-InBytes : NumToRead;
  97.  
  98.     fread(Set, 1, (int) NumToRead, HelpFile);    
  99.     InBytes += NumToRead + 1;
  100.  
  101.     /* Go through and decode data */
  102.     for (counter = 0, Index = 0; counter < 8; counter++) {
  103.  
  104.       /* It's a code, so decode it and copy the data */
  105.       if (BITSET(BitMap, counter)) {
  106.         Length = ((Set[Index+1] & 0xF0) >> 4) + 3;
  107.         Distance = ((Set[Index+1] & 0x0F) << 8) + Set[Index] + 1;
  108.         CodePtr = CurrPos - Distance;
  109.  
  110.         /* Copy data from 'window' */
  111.         while (Length) {
  112.           *CurrPos++ = *CodePtr++;
  113.           OutBytes++;
  114.           Length--;
  115.         } 
  116.         Index += 2;
  117.       } 
  118.       else {
  119.         *CurrPos++ = Set[Index++];
  120.         OutBytes++;
  121.       }
  122.     } /* for */
  123.   } /* while  */
  124.   return OutBytes;
  125. } 
  126.  
  127.  
  128. /***************************************************
  129.   Performs a Hex/ASCII dump of an HFS file.
  130. ****************************************************/
  131.  
  132. void HexDumpData(FILE *HelpFile, long fileSize) 
  133. {
  134.   char           Buffer[16];
  135.   long           counter;
  136.   long           BytesToPrint, Index;
  137.  
  138.   printf("Offset                   Hex Values                           Ascii\n");
  139.   printf("-------------------------------------------------------------------------\n");
  140.  
  141.   for (counter = 0; counter < fileSize; counter+=16) {
  142.  
  143.     printf("0x%08lX: ", counter);
  144.  
  145.     /* If this is the last line, how many bytes are in it? */
  146.     BytesToPrint = ((fileSize - counter) > 16) ? 16 : (fileSize - counter);
  147.     fread(Buffer, BytesToPrint, 1, HelpFile);
  148.  
  149.     /* Dump Hex */
  150.     for (Index=0; Index < BytesToPrint; Index++)
  151.       printf("%02X ", (BYTE) Buffer[Index]);
  152.  
  153.     /* If last line, fill in blanks */
  154.     for (Index=0; Index < 16-BytesToPrint; Index++) 
  155.       printf("   ");
  156.  
  157.     /* Dump Ascii */
  158.     for (Index=0; Index < BytesToPrint; Index++) 
  159.       putchar( isprint( Buffer[Index] ) ? Buffer[Index] : '.' );
  160.  
  161.     putchar('\n');
  162.   }
  163.  
  164.   free(Buffer);
  165. }
  166.  
  167.  
  168. /***************************************************
  169.   Performs a Hex/ASCII dump of an HFS file.
  170. ****************************************************/
  171.  
  172. void HexDumpFile(FILE *HelpFile, long FileStart) 
  173. {
  174.   long           fileSize;
  175.  
  176.   fseek(HelpFile, FileStart, SEEK_SET);
  177.  
  178.   fileSize = LoadHeader(HelpFile);  
  179.   
  180.   printf("File Size: 0x%08lX\n\n", fileSize);
  181.   
  182.   HexDumpData(HelpFile, fileSize);
  183. }
  184.  
  185. /***************************************************
  186.   Dumps the |SYSTEM info
  187. ****************************************************/
  188.  
  189. void SystemDump(FILE *HelpFile, long FileStart) 
  190. {
  191.  
  192.   char            HelpFileTitle[33];
  193.   SYSTEMREC       SystemRec;
  194.   long            CurrentLocation;
  195.   struct tm       *TimeRec;
  196.   SECWINDOW       *SWin;     /* Secondary Window record */
  197.   long            fileSize;
  198.   SYSTEMHEADER    SysHeader;
  199.  
  200.   fseek(HelpFile, FileStart, SEEK_SET);
  201.  
  202.   fileSize = LoadHeader(HelpFile);
  203.  
  204.   fread(&SysHeader, sizeof(SysHeader), 1, HelpFile);
  205.   printf("|SYSTEM Dump\n\n\n");
  206.  
  207.   /* Figure out Version and Revision */
  208.   if (SysHeader.Revision == 0x15) printf("HC.EXE  3.10 Help Compiler used\n");
  209.   else if (SysHeader.Revision == 0x21) printf("HCW.EXE. 4.00 or MVC.EXE\n");
  210.  
  211.   printf("\nVersion: %d\nRevision: %d\n", SysHeader.Version, SysHeader.Revision);
  212.   printf("Flag: 0x%04X  - ",SysHeader.Flags);
  213.  
  214.   /* Determine compression, if any. */
  215.   if (SysHeader.Flags == NO_COMPRESSION) printf("No compression\n");
  216.   else if (SysHeader.Flags & COMPRESSION_HIGH) printf("High Compression\n");
  217.   else printf("Unknown Compression: 0x%02x\n", SysHeader.Flags);
  218.  
  219.   TimeRec=localtime(&SysHeader.GenDate);
  220.   printf("Help File Generated: %s", asctime(TimeRec));
  221.  
  222.   /* If 3.0 get title */
  223.   CurrentLocation=12;
  224.   if (SysHeader.Revision == 0x0F) {
  225.      fgets(HelpFileTitle, 33, HelpFile);
  226.      printf("Help File Title: %s\n", HelpFileTitle);
  227.   }
  228.  
  229.   /* Else, get 3.1 System records */
  230.   else {
  231.     while (CurrentLocation < fileSize) {
  232.  
  233.       /* Read in system record and SystemRec data */
  234.       fread(&SystemRec, 4, 1, HelpFile);
  235.       SystemRec.RData = malloc(SystemRec.DataSize);
  236.       if (SystemRec.RData == NULL)
  237.       {
  238.         printf("Allocation of SystemRec.RData failed.");
  239.         return;
  240.       }
  241.       fread(SystemRec.RData, SystemRec.DataSize, 1, HelpFile);
  242.       CurrentLocation=CurrentLocation+4+SystemRec.DataSize;
  243.  
  244.       switch(SystemRec.RecordType) 
  245.       {
  246.         case 0x0001:  printf("Help File Title: %s\n", SystemRec.RData);
  247.           break;
  248.  
  249.         case 0x0002:  printf("Copyright Notice: %s\n", SystemRec.RData);
  250.           break;
  251.  
  252.         case 0x0003:  printf("Contents ID: 0x%04X\n", (long) *SystemRec.RData);
  253.           break;
  254.  
  255.         case 0x0004:  printf("Macro Data: %s\n",SystemRec.RData);
  256.           break;
  257.  
  258.         case 0x0005:  printf("Icon in System record\n");
  259.           break;
  260.  
  261.         case 0x0006:  printf("\nSecondary window:\n");
  262.                       SWin = (SECWINDOW *)SystemRec.RData;
  263.                       printf("Flag: %d\n", SWin->Flags);
  264.                       if (SWin->Flags & WSYSFLAG_TYPE) 
  265.                         printf("Type: %s\n", SWin->Type);
  266.                       if (SWin->Flags & WSYSFLAG_NAME) 
  267.                         printf("Name: %s\n", SWin->Name);
  268.                       if (SWin->Flags & WSYSFLAG_CAPTION) 
  269.                         printf("Caption: %s\n", SWin->Caption);
  270.                       if (SWin->Flags & WSYSFLAG_X) 
  271.                         printf("X: %d\n", SWin->X);
  272.                       if (SWin->Flags & WSYSFLAG_Y) 
  273.                         printf("Y: %d\n", SWin->Y);
  274.                       if (SWin->Flags & WSYSFLAG_WIDTH)
  275.                         printf("Width: %d\n", SWin->Width);
  276.                       if (SWin->Flags & WSYSFLAG_HEIGHT)
  277.                         printf("Height: %d\n", SWin->Height);
  278.                       if (SWin->Flags & WSYSFLAG_MAXIMIZE) 
  279.                         printf("Maximize Flag: %d\n", SWin->Maximize);
  280.                       if (SWin->Flags & WSYSFLAG_RGB) 
  281.                         printf("RGB Foreground Colors Set\n");
  282.                       if (SWin->Flags & WSYSFLAG_RGBNSR)
  283.                         printf("RGB For Non-Scrollable Region Set\n");
  284.                       if (SWin->Flags & WSYSFLAG_TOP) 
  285.                         printf("Secondary Window is always On Top\n");
  286.           break;
  287.  
  288.         case 0x0008:  printf("Citation: %s\n", SystemRec.RData);
  289.           break;
  290.  
  291.         case 0x000A:  printf("\nContents File: %s\n\n",SystemRec.RData);
  292.           break;                                                 
  293.           
  294.         default:      printf("\nUnknown record type: 0x%04X\n",SystemRec.RecordType);
  295.                       /* Back-up and hex-dump the data */
  296.                       fseek(HelpFile, 
  297.                             ftell(HelpFile) - SystemRec.DataSize, 
  298.                             SEEK_SET);
  299.                       HexDumpData(HelpFile, SystemRec.DataSize);
  300.       } /* switch */
  301.      
  302.       free(SystemRec.RData);
  303.  
  304.     } /* while */
  305.   } /* else */
  306. } /* SysDump */
  307.  
  308.  
  309. /***************************************************
  310.   Dumps the |FONT file
  311. ****************************************************/
  312.  
  313. void FontDump(FILE *HelpFile, long FileStart) 
  314. {
  315.   FONTHEADER      FontHdr;
  316.   FONTDESCRIPTOR  FontDesc;
  317.   char            AFont[32];
  318.   long            FontStart, CurrLoc;
  319.   long            fileSize;
  320.   long            counter;
  321.   long            NameLen;
  322.  
  323.   /* Go to the FONT file and get the headers */
  324.   fseek(HelpFile, FileStart, SEEK_SET);
  325.   fileSize = LoadHeader(HelpFile);
  326.  
  327.   fread(&FontHdr, sizeof(FontHdr), 1, HelpFile);
  328.  
  329.   printf("|FONTS\n\n Number Fonts: %d\n",FontHdr.NumFonts);
  330.   printf("Font #  -  Font Name\n");
  331.  
  332.  
  333.   /* Font names are 20 chars prior to Winhelp 4.0 */
  334.   /* In WinHelp 4.0, they are 32 characters.      */
  335.   if (SysInfo.Revision == 0x15)
  336.   {
  337.     NameLen = 20;
  338.   }
  339.   else
  340.   {
  341.     NameLen = 32;
  342.   }
  343.  
  344.   /* Keep track of start of fonts */
  345.   FontStart = ftell(HelpFile);
  346.   for (counter = 0; counter < (long) FontHdr.NumFonts; counter++) 
  347.   {
  348.     fread(AFont, NameLen, 1, HelpFile);
  349.     printf(" %3d    -  %s\n", counter, AFont);
  350.   }
  351.  
  352.   /* Go to Font Descriptors. Don't actually need this, because we're
  353.      there, but wanted to show how to get there using the offset.    */
  354.   fseek(HelpFile, FontStart + (long)(FontHdr.DescriptorsOffset) - sizeof(FontHdr), SEEK_SET); 
  355.   printf("\nNum Font Descriptors: %d\n", FontHdr.NumDescriptors);
  356.   printf("Default Descriptor: %d\n\n", FontHdr.DefDescriptor);
  357.   printf("Attributes: n=none  b=bold  i=ital  u=undr  s=strkout  d=dblundr  C=smallcaps\n\n");
  358.   printf("Font Name                        PointSize  Family   FG RGB      BG RGB   Attr\n");
  359.   printf("------------------------------------------------------------------------------\n");
  360.  
  361.   for (counter = 0; counter < (long) FontHdr.NumDescriptors; counter++) {
  362.     fread(&FontDesc, sizeof(FontDesc), 1, HelpFile);
  363.     CurrLoc = ftell(HelpFile);
  364.     fseek(HelpFile, FontStart + (NameLen * FontDesc.FontName), SEEK_SET);
  365.     fread(AFont, NameLen, 1, HelpFile);
  366.     fseek(HelpFile, CurrLoc, SEEK_SET);
  367.       
  368.     /* write out info on Font descriptor */
  369.     printf("%-32s    %4.1f    ", AFont, (float)(FontDesc.HalfPoints / 2));
  370.     switch (FontDesc.FontFamily) {
  371.       case FAM_MODERN: printf("Modern");
  372.                           break;
  373.  
  374.       case FAM_ROMAN:  printf("Roman ");
  375.                        break;
  376.  
  377.       case FAM_SWISS:  printf("Swiss ");
  378.                        break;
  379.  
  380.       case FAM_SCRIPT: printf("Script");
  381.                        break;
  382.  
  383.       case FAM_DECOR:  printf("Decor ");
  384.                        break;
  385.  
  386.       default:         printf("0X%02X ", FontDesc.FontFamily);
  387.                        break;
  388.     } /* Switch */
  389.     printf(" 0X%08lX  ",RGB(FontDesc.SRRGB.rgbRed,
  390.                             FontDesc.SRRGB.rgbGreen,
  391.                             FontDesc.SRRGB.rgbBlue));
  392.     printf("0X%08lX    ",RGB(FontDesc.NSRRGB.rgbRed,
  393.                              FontDesc.NSRRGB.rgbGreen,
  394.                              FontDesc.NSRRGB.rgbBlue));
  395.  
  396.     if (FontDesc.Attributes == 0) putchar('n');
  397.     if (FontDesc.Attributes & FONT_BOLD) putchar('b');
  398.     if (FontDesc.Attributes & FONT_ITAL) putchar('i');
  399.     if (FontDesc.Attributes & FONT_UNDR) putchar('u');
  400.     if (FontDesc.Attributes & FONT_STRK) putchar('s');
  401.     if (FontDesc.Attributes & FONT_DBUN) putchar('d');
  402.     if (FontDesc.Attributes & FONT_SMCP) putchar('C');
  403.     printf("\n");
  404.  
  405. #ifdef HLP_DEBUG
  406.     printf("Unknown = %d\n", FontDesc.Unknown);
  407. #endif
  408.   }
  409. }
  410.  
  411.  
  412. /***************************************************
  413.   Dumps the |CONTEXT file
  414. ****************************************************/
  415.  
  416. void ContextDump(FILE *HelpFile, long FileStart) 
  417. {
  418.   long            count;
  419.   long            CurrPage, FirstPageLoc;
  420.   long            TopicOffset, HashValue;
  421.   BTREEHEADER     BTreeHdr;
  422.   BTREELEAFHEADER CurrNode;
  423.  
  424.   /* Go to the TTLBTREE file and get the headers */
  425.   fseek(HelpFile, FileStart, SEEK_SET);
  426.   LoadHeader(HelpFile);
  427.   fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  428.  
  429.   /* Save the current location */
  430.   FirstPageLoc = ftell(HelpFile);
  431.    
  432.   fseek(HelpFile, 
  433.         FirstPageLoc+(BTreeHdr.RootPage * BTreeHdr.PageSize), 
  434.         SEEK_SET);
  435.  
  436.   printf("# Context Hash Values in |CONTEXT %lu\n\n", BTreeHdr.TotalBtreeEntries);
  437.   CurrPage = BTreeHdr.FirstLeaf;
  438.  
  439.   do 
  440.   {
  441.     fseek(HelpFile, 
  442.           FirstPageLoc+(CurrPage * BTreeHdr.PageSize), 
  443.           SEEK_SET);
  444.     fread(&CurrNode, 8, 1, HelpFile);
  445.     for(count = 1; count <= CurrNode.NEntries; count++) 
  446.     {
  447.       fread(&HashValue, sizeof(HashValue), 1, HelpFile);
  448.       fread(&TopicOffset, sizeof(TopicOffset), 1, HelpFile);
  449.       printf("Topic Offset:0x%08lX  Hash Value: 0x%08lX\n", TopicOffset, HashValue);
  450.     }
  451.     CurrPage = CurrNode.NextPage;
  452.   } while(CurrPage != -1);
  453. }
  454.  
  455.  
  456. /***************************************************
  457.   Prints a Phrase from the Phrase table.
  458. ****************************************************/
  459. void PrintPhrase(long PhraseNum) 
  460. {
  461.   short *Offsets;
  462.   char  *p;
  463.  
  464.   p = Phrases+Offsets[PhraseNum];
  465.   while (p < Phrases + Offsets[PhraseNum + 1])
  466.     putchar(*p++);
  467. }
  468.  
  469.  
  470. /***************************************************
  471.   Dumps the Keyword B-Tree
  472. ****************************************************/
  473.  
  474. void KWBTreeDump(FILE *HelpFile, long FileStart) 
  475. {
  476.   char            Keyword[80], c;
  477.   long            count, Index;
  478.   long            CurrPage, FirstPageLoc;
  479.   long            KeywordOffset;
  480.   long            KeywordCount;
  481.   BTREEHEADER     BTreeHdr;
  482.   BTREELEAFHEADER CurrNode;
  483.  
  484.   /* Go to the KWBTREE file and get the headers */
  485.   fseek(HelpFile, FileStart, SEEK_SET);
  486.   LoadHeader(HelpFile);
  487.   fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  488.  
  489.   /* Save the current location */
  490.   FirstPageLoc = ftell(HelpFile);
  491.    
  492.   fseek(HelpFile, 
  493.         FirstPageLoc+(BTreeHdr.RootPage * BTreeHdr.PageSize), 
  494.         SEEK_SET);
  495.  
  496.   printf("# Keywords - %lu\n\n", BTreeHdr.TotalBtreeEntries);
  497.   CurrPage = BTreeHdr.FirstLeaf;
  498.  
  499.   do 
  500.   {
  501.     fseek(HelpFile, 
  502.           FirstPageLoc+(CurrPage * BTreeHdr.PageSize), 
  503.           SEEK_SET);
  504.     fread(&CurrNode, 8, 1, HelpFile);
  505.     for(count = 1; count <= CurrNode.NEntries; count++) 
  506.     {
  507.       Index = 0;
  508.       while(c = (char) fgetc(HelpFile))
  509.         Keyword[Index++] = c;
  510.         
  511.       Keyword[Index] = 0;
  512.       fread(&KeywordCount, sizeof(KeywordCount), 1, HelpFile);
  513.       fread(&KeywordOffset, sizeof(KeywordOffset), 1, HelpFile);
  514.  
  515.       printf("Offset: 0x%08lX  Count: %d  Keyword: %s\n", 
  516.                           KeywordOffset, KeywordCount, Keyword);
  517.     }
  518.     CurrPage = CurrNode.NextPage;
  519.   } while(CurrPage != -1);
  520. }
  521.  
  522.  
  523. /***************************************************
  524.   Dumps the Keyword Data file
  525. ****************************************************/
  526.  
  527. void KWDataDump(FILE *HelpFile, long FileStart) 
  528. {
  529.   long fileSize;
  530.   long nIndex;
  531.   long Offset;
  532.   
  533.   /* Go to the KWDATA file and get the headers */
  534.   fseek(HelpFile, FileStart, SEEK_SET);
  535.   fileSize = LoadHeader(HelpFile);
  536.           
  537.   printf("Dumping Keyword Data File\n\n");
  538.   /* Go through all keyword offsets (fileSize / 4) */
  539.   for (nIndex = 0; nIndex < (fileSize / sizeof(Offset)); nIndex++)
  540.   {
  541.     fread(&Offset, sizeof(Offset), 1, HelpFile);
  542.     printf("Index: %d   Offset: 0x%08lX\n", nIndex, Offset);
  543.   }
  544. }
  545.  
  546.  
  547. /***************************************************
  548.   Dumps the Keyword Map file
  549. ****************************************************/
  550.  
  551. void KWMapDump(FILE *HelpFile, long FileStart) 
  552. {
  553.   long      fileSize;
  554.   long      nIndex;
  555.   WORD      nKWMaps;
  556.   KWMAPREC  kwMap;
  557.   
  558.   /* Go to the KWMAP file and get the headers */
  559.   fseek(HelpFile, FileStart, SEEK_SET);
  560.   fileSize = LoadHeader(HelpFile);
  561.           
  562.   printf("Dumping Keyword Map\n\n");
  563.   
  564.   fread(&nKWMaps, sizeof(nKWMaps), 1, HelpFile);
  565.   
  566.   /* Go through all keyword offsets (fileSize / 4) */
  567.   for (nIndex = 0; nIndex < (int) nKWMaps; nIndex++)
  568.   {
  569.     fread(&kwMap, sizeof(KWMAPREC), 1, HelpFile);
  570.     printf("Index: %d   First Keyword 0x%08lX    Leaf Page#: %05u\n", 
  571.                           nIndex, kwMap.FirstRec, kwMap.PageNum);
  572.   }
  573. }
  574.  
  575.  
  576. /***************************************************
  577.   Dumps the Topic Titles B-Tree
  578. ****************************************************/
  579.  
  580. void TTLDump(FILE *HelpFile, long FileStart) 
  581. {
  582.   char            Title[80], c;
  583.   long            count, Index;
  584.   long            CurrPage, FirstPageLoc, TopicOffset;
  585.   BTREEHEADER     BTreeHdr;
  586.   BTREELEAFHEADER CurrNode;
  587.  
  588.   /* Go to the TTLBTREE file and get the headers */
  589.   fseek(HelpFile, FileStart, SEEK_SET);
  590.   LoadHeader(HelpFile);
  591.   fread(&BTreeHdr, sizeof(BTreeHdr), 1, HelpFile);
  592.  
  593.   /* Save the current location */
  594.   FirstPageLoc = ftell(HelpFile);
  595.    
  596.   fseek(HelpFile, 
  597.         FirstPageLoc+(BTreeHdr.RootPage * BTreeHdr.PageSize), 
  598.         SEEK_SET);
  599.  
  600.   printf("# Titles in |TTLBTREE %lu\n\n", BTreeHdr.TotalBtreeEntries);
  601.   CurrPage = BTreeHdr.FirstLeaf;
  602.  
  603.   do 
  604.   {
  605.     fseek(HelpFile, 
  606.           FirstPageLoc+(CurrPage * BTreeHdr.PageSize), 
  607.           SEEK_SET);
  608.     fread(&CurrNode, 8, 1, HelpFile);
  609.     for(count = 1; count <= CurrNode.NEntries; count++) 
  610.     {
  611.       fread(&TopicOffset, sizeof(TopicOffset), 1, HelpFile);
  612.       Index = 0;
  613.       while(c = (char) fgetc(HelpFile))
  614.         Title[Index++] = c;
  615.         
  616.       Title[Index] = 0;
  617.  
  618.       printf("Topic Offset:0x%08lX  Title: %s\n", TopicOffset, Title);
  619.     }
  620.     CurrPage = CurrNode.NextPage;
  621.  
  622.   } while(CurrPage != -1);
  623. }
  624.  
  625.  
  626. /***************************************************
  627.   Dumps the |Phrases file
  628. ****************************************************/
  629.  
  630. void PhrasesDump(FILE *HelpFile, long FileStart) 
  631. {
  632.   long  nOuterIndex, nInnerIndex;
  633.   WORD  start, len;
  634.   
  635.   PhrasesLoad(HelpFile, FileStart);
  636.  
  637.   printf("Phrase#     Phrase\n");
  638.   for (nOuterIndex = 0; nOuterIndex < NumPhrases; nOuterIndex++)
  639.   {
  640.     start = (WORD) PhrOffsets[nOuterIndex] ;
  641.     len = PhrOffsets[nOuterIndex + 1] - start;
  642.     printf(" %5d     ", nOuterIndex + 1);
  643.     for (nInnerIndex = 0; nInnerIndex < (int) len; nInnerIndex++)
  644.     {
  645.       printf("%c", (Phrases[start + nInnerIndex]));
  646.     }
  647.     printf("\n");
  648.   }
  649. }
  650.  
  651.  
  652. /***************************************************
  653.   Loads the |SYSTEM info
  654. ****************************************************/
  655.  
  656. int SysLoad(FILE *HelpFile, long FileStart) 
  657. {
  658.   fseek(HelpFile, FileStart, SEEK_SET);
  659.  
  660.   LoadHeader(HelpFile);
  661.   
  662.   fread(&SysInfo, sizeof(SYSTEMHEADER), 1, HelpFile);
  663.   
  664. #ifdef HLP_DEBUG
  665.   printf("DEBUG -> SysLoad()\n");
  666.   printf("Magic: 0x%02x\n", SysInfo.Magic);
  667.   printf("Version: 0x%02x\n", SysInfo.Version);
  668.   printf("Revision: 0x%02x\n", SysInfo.Revision);
  669.   printf("Flags: 0x%04x\n\n", SysInfo.Flags);
  670. #endif
  671.  
  672.   if (SysInfo.Magic != SYS_MAGIC)
  673.   {
  674.     return 0;
  675.   }
  676.   
  677.   return 1;
  678. }
  679.  
  680.  
  681. /***************************************************
  682.   Loads the compression phrases
  683. ****************************************************/
  684.  
  685. void PhrasesLoad(FILE *HelpFile, long FileStart) 
  686. {
  687.   PHRASEHEADER  phraseHeader;
  688.   long          FileSize;
  689.   long          DeCompSize;
  690.   
  691.   fseek(HelpFile, FileStart, SEEK_SET);
  692.   FileSize = LoadHeader(HelpFile);
  693.  
  694.   fread(&phraseHeader, sizeof(phraseHeader), 1, HelpFile);
  695.   
  696.   if (SysInfo.Flags != NO_COMPRESSION)
  697.   {
  698.     if ((PhrOffsets = malloc(phraseHeader.PhrasesSize + 
  699.                             (phraseHeader.NumPhrases + 1) * 2 + 10)) == NULL)
  700.     {
  701.       printf("Unable to allocate space for Phrases.\n");
  702.       return;
  703.     }
  704.  
  705.     /* Assign Phrases to  where the comrpessed phrases are */   
  706.     Phrases = (char*) PhrOffsets + fread(PhrOffsets, 
  707.                                          2, 
  708.                                          phraseHeader.NumPhrases + 1, 
  709.                                          HelpFile);
  710.  
  711.     DeCompSize = Decompress(HelpFile,
  712.                             FileSize - (sizeof(phraseHeader) +
  713.                             2 * (phraseHeader.NumPhrases + 1)),
  714.                             Phrases);
  715.     if (DeCompSize != (long) phraseHeader.PhrasesSize)
  716.     {
  717.       printf("Warning, Phrases did not decompress to the proper size.\n");
  718.     }
  719.   }
  720.   else
  721.   {
  722.     if ((PhrOffsets = malloc(phraseHeader.PhrasesSize + 
  723.                             (phraseHeader.NumPhrases + 1) * 2 + 10)) == NULL)
  724.     {
  725.       printf("Unable to allocate space for Phrases.\n");
  726.       return;
  727.     }
  728.     /* Back up four bytes if phrases aren't compressed */
  729.     /* because PhrasesSize field doesn't exist.        */
  730.     fseek(HelpFile, -4, SEEK_CUR);
  731.     fread(PhrOffsets, FileSize - 4, 1, HelpFile);
  732.   }
  733.   /* Reset Phrases to be equal to PhrOffsets */
  734.   Phrases = (char *) PhrOffsets;  
  735.   NumPhrases = phraseHeader.NumPhrases;
  736. }
  737.  
  738.  
  739. /***************************************************
  740.   Finds an HFS File by traversing the HFS b-tree
  741.   Note: This is the only place I actually traverse
  742.   the b-tree instead of cycling through the leaf
  743.   pages. I put this in specifically to show how to
  744.   traverse the b-tree, since speed isn't a real
  745.   concern for HelpDump.
  746. ****************************************************/
  747.  
  748. char FindFile(FILE *HelpFile, char* filename, long* offset)
  749. {
  750.   BTREEHEADER       HFSHeader;
  751.   BTREEINDEXHEADER* HFSIndexHeader;
  752.   BTREELEAFHEADER*  HFSLeafHeader;
  753.   long              HFSStart;
  754.   short*            pNextPage;
  755.   char*             buffer;
  756.   char*             currPtr;
  757.   long              nKeys, nFiles;
  758.   char              found = 0;
  759.   long              currLevel = 1;
  760.  
  761.   /* Go to the HFS and read the header. */
  762.   fseek(HelpFile, HelpHeader.HFSLoc, SEEK_SET);
  763.   LoadHeader(HelpFile);
  764.   fread(&HFSHeader, sizeof(HFSHeader), 1, HelpFile);
  765.  
  766.   /* Allocate space for read buffer */
  767.   buffer = malloc(HFSHeader.PageSize);
  768.   if (buffer == NULL)
  769.   {
  770.     printf("Unable to allocate space for buffer.\n");
  771.     return found;
  772.   }
  773.   HFSIndexHeader = (BTREEINDEXHEADER*) buffer;
  774.  
  775.   HFSStart = ftell(HelpFile);
  776.   
  777.   /* Advance to root page */
  778.   fseek(HelpFile, 
  779.         (HFSHeader.RootPage * HFSHeader.PageSize) + HFSStart, 
  780.         SEEK_SET);
  781.       
  782.   /* If there's only one page, then it must be a leaf */
  783.   if (HFSHeader.TotalPages > 1)
  784.   {
  785.     /* Traverse b-tree looking for the key for the leaf page */  
  786.     while (!found)
  787.     {
  788.       /* Read in the page */
  789.       fread(buffer, HFSHeader.PageSize, 1, HelpFile);
  790.       currPtr = buffer + sizeof(BTREEINDEXHEADER);
  791.       pNextPage = (int *) currPtr;
  792.  
  793.       currPtr += sizeof(int);
  794.       
  795.       /* Go through all keys in the page */
  796.       for (nKeys = 0; nKeys < HFSIndexHeader->NEntries; nKeys++)
  797.       {
  798.         /* If filename is less than key, this is our page. */
  799.         if (strcmp(filename, currPtr) < 0)
  800.         {
  801.           break;
  802.         }
  803.         else
  804.         {
  805.           /* Advance to the next page# */
  806.           while (*currPtr)
  807.             currPtr++;
  808.           currPtr++;
  809.           pNextPage = (int *) currPtr;
  810.           currPtr += sizeof(int);
  811.         }
  812.       }
  813.       
  814.       /* Advance to next page */
  815.       fseek(HelpFile, 
  816.             (*pNextPage * HFSHeader.PageSize) + HFSStart, 
  817.             SEEK_SET);
  818.       
  819.       /* If this is the last index page */
  820.       /* then pNextPage points to a     */
  821.       /* leaf page                      */
  822.       if (currLevel == HFSHeader.nLevels - 1)
  823.       {
  824.         found = 1;
  825.       }
  826.       currLevel++;
  827.     }
  828.   }
  829.   
  830.   fread(buffer, HFSHeader.PageSize, 1, HelpFile);
  831.   HFSLeafHeader = (BTREELEAFHEADER*) buffer;
  832.   currPtr = buffer + sizeof(BTREELEAFHEADER);
  833.  
  834.  
  835.   found = 0;
  836.   
  837.   /* Loop through all files in this page */
  838.   for (nFiles = 0; nFiles < HFSLeafHeader->NEntries; nFiles++)
  839.   {
  840.     if (strcmp(filename, currPtr))
  841.     {  
  842.       /* Advance to the file offset */
  843.       while (*currPtr)
  844.         currPtr++;
  845.       
  846.       /* Move past the null and file offset */
  847.       /* to next file                       */
  848.       currPtr += 5;    
  849.     }
  850.     else
  851.     {
  852.       /* Save the offset of the file */
  853.       while (*currPtr)
  854.         currPtr++;
  855.       currPtr++;
  856.       
  857.       *offset = (long) *((long*) currPtr);
  858.       found = 1;
  859.       break;
  860.     }
  861.   }
  862.  
  863.   /* TRUE if file was found, FALSE if it wasn't */
  864.   return found;
  865. }
  866.  
  867.  
  868. /***************************************************
  869.   DumpFile
  870. ****************************************************/
  871.  
  872. void DumpFile(FILE *HelpFile)
  873. {
  874.   long fileOffset;
  875.   char fileName[255];
  876.   
  877.   /* For many files we need to know information about    */
  878.   /* The system, so we'll load the system data info here */
  879.   /* if it's available                                   */
  880.   SysLoaded = 0;
  881.   strcpy(fileName, "|SYSTEM");
  882.   if (FindFile(HelpFile, fileName, &fileOffset))
  883.   {
  884.      SysLoaded = (char) SysLoad(HelpFile, fileOffset);
  885.   }
  886.  
  887.   /* If it's not a version 3 help file */
  888.   /* then we can't handle it.          */
  889.   if (SysInfo.Version != 0x03)
  890.   {
  891.     printf("Warning: Not a version 3 help file. Version is %d.\n",
  892.            SysInfo.Version);
  893.   }
  894.   
  895.   /* If it's version 3, but not revision   */
  896.   /* 0x15 or 0x21, we also can't handle it */
  897.   if (SysInfo.Revision != 0x15 && SysInfo.Revision != 0x21)
  898.   {
  899.     printf("Revision not 0x15 or 0x21. Revision is 0x%02x.\n",
  900.            SysInfo.Revision);
  901.   }
  902.   
  903.   /* If we're reading the |TOPIC file, then we need to */
  904.   /* pre-load the phrases from the |Phrases file       */  
  905.   if (!strcmp(HFSFileToRead, "|TOPIC") ||
  906.       !strcmp(HFSFileToRead, "TOPIC"))
  907.   {
  908.     strcpy(fileName, "|Phrases");
  909.     if (FindFile(HelpFile, fileName, &fileOffset))
  910.     {
  911.       PhrasesLoad(HelpFile, fileOffset);
  912.     }
  913.   }
  914.  
  915.   strcpy(fileName, HFSFileToRead);
  916.   if (!FindFile(HelpFile, fileName, &fileOffset))
  917.   {
  918.     /* Append a "|" character to the beginning  */
  919.     /* of the filename and try to find the file */
  920.     strcpy(fileName, "|");
  921.     strcat(fileName, HFSFileToRead);
  922.     if (!FindFile(HelpFile, fileName, &fileOffset))
  923.     {
  924.       /* File not found */
  925.       printf("Error: Unable to find HFS file %s or %s\n",
  926.              HFSFileToRead, fileName);
  927.       return;
  928.     }
  929.   }
  930.  
  931.   if (!ForceHex)
  932.   {  
  933.     if (!strcmp(fileName, "|SYSTEM"))
  934.       SystemDump(HelpFile, fileOffset);
  935.     else if (!strcmp(fileName, "|TTLBTREE"))
  936.       TTLDump(HelpFile, fileOffset);
  937.     else if (!strcmp(fileName, "|CONTEXT"))
  938.       ContextDump(HelpFile, fileOffset);
  939.     else if (!strcmp(fileName, "|FONT"))
  940.       FontDump(HelpFile, fileOffset);
  941.     else if (!strcmp(fileName, "|KWBTREE"))
  942.       KWBTreeDump(HelpFile, fileOffset);
  943.     else if (!strcmp(fileName, "|AWBTREE"))
  944.       KWBTreeDump(HelpFile, fileOffset);
  945.     else if (!strcmp(fileName, "|KWDATA"))
  946.       KWDataDump(HelpFile, fileOffset);
  947.     else if (!strcmp(fileName, "|AWDATA"))
  948.       KWDataDump(HelpFile, fileOffset);
  949.     else if (!strcmp(fileName, "|KWMAP"))
  950.       KWMapDump(HelpFile, fileOffset);
  951.     else if (!strcmp(fileName, "|Phrases"))
  952.       PhrasesDump(HelpFile, fileOffset);
  953.     else 
  954.       HexDumpFile(HelpFile, fileOffset);
  955.   }
  956.   else
  957.   {
  958.     HexDumpFile(HelpFile, fileOffset);
  959.   }  
  960. }
  961.  
  962. /***************************************************
  963.   List out all the HFS files in a .HLP file
  964. ****************************************************/
  965.  
  966. void ListFiles(FILE *HelpFile)
  967. {
  968.   BTREEHEADER       HFSHeader;
  969.   BTREELEAFHEADER*  HFSLeafHeader;
  970.   long              HFSStart;
  971.   char*             buffer;
  972.   char*             currPtr;
  973.   long              nIndex, nFiles;
  974.   long*             offset;
  975.  
  976.   /* Go to the HFS and read the header. */
  977.   fseek(HelpFile, HelpHeader.HFSLoc, SEEK_SET);
  978.   LoadHeader(HelpFile);
  979.   fread(&HFSHeader, sizeof(HFSHeader), 1, HelpFile);
  980.  
  981.   CHECK_SIGNATURE(HFSHeader.Signature, 0x293B);
  982.  
  983. #ifdef HLP_DEBUG  
  984.   printf("DEBUG -> ListFiles()\n");
  985.   printf("B-Tree Page Size %d\n", HFSHeader.PageSize);
  986.   printf("B-Tree First Leaf %d\n", HFSHeader.FirstLeaf);
  987.   printf("B-Tree Num. Levels %d\n", HFSHeader.nLevels);
  988.   printf("B-Tree Total Pages %d\n", HFSHeader.TotalPages);
  989.   printf("B-Tree Total # Entries %ld\n", HFSHeader.TotalBtreeEntries);
  990. #endif 
  991.   /* Start of the HFS b-tree pages */
  992.   HFSStart = ftell(HelpFile);
  993.  
  994.   /* Go to the first leaf page of the HFS */  
  995.   fseek(HelpFile, HFSHeader.FirstLeaf * HFSHeader.PageSize, SEEK_CUR);
  996.  
  997.   /* Allocate space for read buffer and read first page */
  998.   buffer = malloc(HFSHeader.PageSize);
  999.   if (buffer == NULL)
  1000.   {
  1001.     printf("Unable to allocate space for buffer.\n");
  1002.     return;
  1003.   }
  1004.   HFSLeafHeader = (BTREELEAFHEADER*) buffer;
  1005.   
  1006.   printf("\nHFS Filename                 Offset\n");
  1007.   printf("-----------------------------------\n");
  1008.   
  1009.   /* Loop through all HFS leaf pages */
  1010.   for (nIndex = 0; nIndex < HFSHeader.TotalPages; nIndex++)
  1011.   {
  1012.     fread(buffer, HFSHeader.PageSize, 1, HelpFile);
  1013.  
  1014.     currPtr = buffer + sizeof(BTREELEAFHEADER);
  1015.  
  1016.     /* Loop through all files in this page */
  1017.     for (nFiles = 0; nFiles < HFSLeafHeader->NEntries; nFiles++)
  1018.     {
  1019.  
  1020.       /* Print filename */
  1021.       printf("%-30s", currPtr);
  1022.     
  1023.       /* Advance to next filename */
  1024.       while (*currPtr)
  1025.         currPtr++;
  1026.       currPtr++;
  1027.       
  1028.       offset = (long*) currPtr;
  1029.       /* print offset to file */
  1030.       printf("0x%08lX\n", *offset);
  1031.  
  1032.       /* Move past the file offset to next file */
  1033.       currPtr += 4;    
  1034.     }
  1035.   }
  1036. }
  1037.  
  1038. /***************************************************
  1039.   Check to make sure it's a help file. Then
  1040.   either dump the HFS directory or dump an HFS
  1041.   file.
  1042. ****************************************************/
  1043.  
  1044. void HelpDump(FILE *HelpFile) 
  1045. {
  1046.   fread(&HelpHeader, sizeof(HelpHeader), 1, HelpFile);
  1047.   if (HelpHeader.MagicNumber != HF_MAGIC) 
  1048.   {
  1049.     printf("Fatal Error:\n");
  1050.     printf("  Not a valid WinHelp file!\n");
  1051.     return;
  1052.   }
  1053.  
  1054.   if (ReadHFSFile) 
  1055.      DumpFile(HelpFile);
  1056.   else
  1057.      ListFiles(HelpFile);
  1058.  
  1059. }
  1060.  
  1061.  
  1062. /***************************************************
  1063.   Show usage
  1064. ****************************************************/
  1065.  
  1066. void Usage()
  1067. {
  1068.   printf("HLPDUMP2  (version 2.0 of Help Dump)\n");
  1069.   printf("By Pete Davis and Mike Wallace               Copyright 1997\n\n");
  1070.   printf("Usage: HLPDUMP2 helpfile[.hlp] [hfsfilename] [/H]\n\n");
  1071.   printf("where:\n");
  1072.   printf("  helpfile    - name of .HLP/.GID/.ANN/.BMK file to open\n");
  1073.   printf("  hfsfilename - name of HFS file to read\n");
  1074.   printf("  /H          - force a hex dump\n\n");
  1075.   printf("note: Do not include the pipe '|' character in the hfsfilename.\n");
  1076. }
  1077.  
  1078.  
  1079. /***************************************************
  1080.  Entry point to HLPDUMP2
  1081. ****************************************************/
  1082.  
  1083. int main(int argc, char *argv[])
  1084. {
  1085.   char filename[_MAX_PATH];
  1086.   FILE *HelpFile;
  1087.  
  1088.   if (argc < 2) 
  1089.   {
  1090.     Usage();
  1091.     return EXIT_FAILURE;
  1092.   }
  1093.   ReadHFSFile = 0;
  1094.   if (argc >= 3) 
  1095.   {
  1096.     strcpy(HFSFileToRead, argv[2]);
  1097.     ReadHFSFile = 1;
  1098.   }
  1099.  
  1100.   /* Are we forcing a hex dump? */
  1101.   ForceHex = 0;
  1102.   if (argc == 4)
  1103.   {
  1104.  
  1105.   if (stricmp(argv[3], "/H"))
  1106.     {
  1107.       printf("Error: Argument 3 unrecognized\n");
  1108.       return EXIT_FAILURE;
  1109.     }
  1110.     ForceHex = 1;
  1111.  
  1112.   }
  1113.   strcpy(filename, argv[1]);
  1114.   strupr(filename);
  1115.   if (!strchr(filename, '.')) 
  1116.     strcat(filename, ".HLP");
  1117.  
  1118.   if ((HelpFile = fopen(filename, "rb")) == NULL) 
  1119.   {
  1120.     printf("%s does not exist!", filename);
  1121.     return EXIT_FAILURE;
  1122.   }
  1123.  
  1124.   printf("Dumping %s\n\n", filename);
  1125.   HelpDump(HelpFile);
  1126.   fclose(HelpFile);
  1127.  
  1128.   return EXIT_SUCCESS;
  1129.   
  1130. }
  1131.