home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 10 / mycd10.iso / share / os2 / utilidad / fst03e / do_hpfs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-16  |  110.8 KB  |  3,124 lines
  1. /* do_hpfs.c -- HPFS-specific code for fst
  2.    Copyright (c) 1995-1996 by Eberhard Mattes
  3.  
  4. This file is part of fst.
  5.  
  6. fst is free software; you can redistribute it and/or modify it
  7. under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. fst is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with fst; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21.  
  22. #define INCL_DOSDEVIOCTL
  23. #define INCL_DOSNLS
  24. #define INCL_DOSERRORS
  25. #include <os2.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <stdarg.h>
  29. #include <stddef.h>
  30. #include <string.h>
  31. #include <ctype.h>
  32. #include <time.h>
  33. #include "fst.h"
  34. #include "crc.h"
  35. #include "diskio.h"
  36. #include "hpfs.h"
  37.  
  38. /* Return a non-zero value if sector X is allocated. */
  39.  
  40. #define ALLOCATED(x)    !BITSETP (alloc_vector, (x))
  41.  
  42.  
  43. /* Our own representation of a code page. */
  44.  
  45. typedef struct
  46. {
  47.   CPINFOENTRY info;
  48.   char hit;
  49.   BYTE case_map[256];
  50. } MYCP;
  51.  
  52. /* This structure is used for checking whether DIRENTs are arranged in
  53.    ascending order by file name. */
  54.  
  55. typedef struct
  56. {
  57.   BYTE name[256];               /* Previous file name */
  58.   ULONG cpindex;                /* Code page index for previous file name */
  59. } SORT;
  60.  
  61. /* This structure is used for counting extents. */
  62.  
  63. typedef struct
  64. {
  65.   ULONG size;                   /* Number of elements in `counts' */
  66.   ULONG *counts;                /* counts[i] = # of objects with i extents */
  67. } EXTENTS;
  68.  
  69. static ULONG total_sectors;     /* Total number of sectors of HPFS volume */
  70. static ULONG total_alloc;       /* # of bytes allocated for ∩alloc_vector' */
  71. static BYTE *usage_vector;      /* One byte per sector, indicating usage */
  72. static BYTE *seen_vector;       /* One byte per sector, to avoid loops */
  73. static BYTE *alloc_vector;      /* One bit per sector, indicating allocation */
  74. static const path_chain **path_vector; /* One path name chain per sector */
  75. static BYTE alloc_ready;        /* TRUE if alloc_vector contents valid */
  76. static ULONG code_page_count;   /* Number of code pages */
  77. static MYCP *code_pages;        /* All code pages of the HPFS volume */
  78. static ULONG cpdata_count;      /* Number of code page data sectors */
  79. static ULONG *cpdata_visited;   /* Sector numbers of visited cp data sectors */
  80. static ULONG min_time;          /* Minimum valid time stamp */
  81. static ULONG dirband_start;     /* First sector of DIRBLK band */
  82. static ULONG dirband_end;       /* Last sector of DIRBLK band */
  83. static ULONG dirblk_total;      /* Total number of DIRBLKs */
  84. static ULONG dirblk_outside;    /* Number of DIRBLKs outside DIRBLK band */
  85. static ULONG alsec_count;       /* Number of ALSECs */
  86. static ULONG file_count;        /* Number of files */
  87. static ULONG dir_count;         /* Number of directories */
  88. static ULONG sectors_per_block; /* Block size (in sectors) for `multimedia' */
  89. static EXTENTS file_extents;    /* Number of extents for files */
  90. static EXTENTS ea_extents;      /* Number of extents for EAs */
  91. static char no_country_sys;     /* COUNTRY.SYS not available */
  92. static char alsec_number[100];  /* Formatted ALSEC number */
  93. static char find_comp[256];     /* Current component of `find_path' */
  94. static char copy_buf[512];      /* Buffer for `copy' action */
  95.  
  96. static void dirblk_warning (int level, const char *fmt, ULONG secno,
  97.                             const path_chain *path, ...) ATTR_PRINTF (2, 5);
  98. static void dirent_warning (int level, const char *fmt, ULONG secno,
  99.                             const path_chain *path, int dirent_no,
  100.                             const char *fname, ...) ATTR_PRINTF (2, 7);
  101. static void alsec_warning (int level, const char *fmt, ULONG secno,
  102.                            const path_chain *path, ...) ATTR_PRINTF (2, 5);
  103. static void alloc_warning (int level, const char *fmt, ULONG secno,
  104.                            const path_chain *path,
  105.                            int fnode_flag, ...) ATTR_PRINTF (2, 6);
  106. static void fnode_warning (int level, const char *fmt, ULONG secno,
  107.                            const path_chain *path, ...) ATTR_PRINTF (2, 5);
  108.  
  109.  
  110. /* Compute the checksum for SIZE bytes at P. */
  111.  
  112. static ULONG chksum (const BYTE *p, size_t size)
  113. {
  114.   ULONG sum;
  115.  
  116.   sum = 0;
  117.   while (size != 0)
  118.     {
  119.       sum += *p++;
  120.       sum = (sum << 7) | (sum >> 25); /* Rotate left by 7 bits */
  121.       --size;
  122.     }
  123.   return sum;
  124. }
  125.  
  126.  
  127. /* Return a pointer to a string containing a formatted time stamp.
  128.    Note that the pointer points to static memory; do not use
  129.    format_time() more than once in one expression! */
  130.  
  131. static const char *format_time (ULONG x)
  132. {
  133.   static char buf[100];
  134.   time_t t;
  135.   struct tm *tm;
  136.  
  137.   if (x == 0)
  138.     strcpy (buf, "never");
  139.   else if (x < min_time)
  140.     sprintf (buf, "0x%lx", x);
  141.   else
  142.     {
  143.       t = (time_t)x;
  144.       tm = gmtime (&t);
  145.       sprintf (buf, "0x%lx (%d-%.2d-%.2d %.2d:%.2d:%.2d)",
  146.                x, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
  147.                tm->tm_hour, tm->tm_min, tm->tm_sec);
  148.     }
  149.   return buf;
  150. }
  151.  
  152.  
  153. /* Return a pointer to a string containing a formatted time stamp for
  154.    the `dir' action.  Note that the pointer points to static memory;
  155.    do not use format_dir_time() more than once in one expression! */
  156.  
  157. static const char *format_dir_time (ULONG x)
  158. {
  159.   static char buf[100];
  160.   time_t t;
  161.   struct tm *tm;
  162.  
  163.   if (x < min_time)
  164.     return "????-??-?? ??:??:??";
  165.   else
  166.     {
  167.       t = (time_t)x;
  168.       tm = gmtime (&t);
  169.       sprintf (buf, "%d-%.2d-%.2d %.2d:%.2d:%.2d",
  170.                tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
  171.                tm->tm_hour, tm->tm_min, tm->tm_sec);
  172.       return buf;
  173.     }
  174. }
  175.  
  176.  
  177. /* Return TRUE iff the file name pointed to by NAME would be a valid
  178.    file name on a FAT file system.  HPFS.IFS seems to treat the space
  179.    character (0x20) as being valid on FAT. */
  180.  
  181. static int is_fat_name (const BYTE *name)
  182. {
  183.   int n, len;
  184.   const BYTE *p;
  185.  
  186.   if (name[0] == '.')
  187.     return name[1] == 0 || (name[1] == '.' && name[2] == 0);
  188.   len = strlen ((const char *)name);
  189.   p = (const BYTE *)strchr ((const char *)name, '.');
  190.   if (p == NULL)
  191.     n = len;
  192.   else
  193.     n = p - name;
  194.   if (n > 8)
  195.     return FALSE;
  196.   if (p != NULL)
  197.     {
  198.       if (p[-1] == ' ')         /* (p > name) is guaranteed */
  199.         return FALSE;
  200.       if (len - (n + 1) > 3)
  201.         return FALSE;
  202.       if (strchr ((const char *)p + 1, '.') != NULL)
  203.         return FALSE;
  204.     }
  205.   for (p = name; *p != 0; ++p)
  206.     if (*p < 0x20 || strchr ("\"*+,/;:<=>?[\\]|", *p) != NULL)
  207.       return FALSE;
  208.   return TRUE;
  209. }
  210.  
  211.  
  212. /* Return TRUE iff the file name pointed to by NAME is a valid HPFS
  213.    file name.  "." and ".." are considered invalid by this
  214.    function. */
  215.  
  216. static int is_hpfs_name (const BYTE *name)
  217. {
  218.   const BYTE *p;
  219.  
  220.   for (p = name; *p != 0; ++p)
  221.     if (*p < 0x20 || strchr ("\"*/:<>?\\|", *p) != NULL)
  222.       return FALSE;
  223.   if (p == name)
  224.     return FALSE;
  225.   if (p[-1] == '.' || p[-1] == ' ')
  226.     return FALSE;
  227.   return TRUE;
  228. }
  229.  
  230.  
  231. /* Initialize an EXTENTS structure. */
  232.  
  233. static void extents_init (EXTENTS *e)
  234. {
  235.   e->size = 0;
  236.   e->counts = NULL;
  237. }
  238.  
  239.  
  240. /* Free any resources of an EXTENTS structure. */
  241.  
  242. static void extents_exit (EXTENTS *e)
  243. {
  244.   e->size = 0;
  245.   free (e->counts);
  246.   e->counts = NULL;
  247. }
  248.  
  249.  
  250. /* Add an object to an EXTENTS structure.  The object has COUNT
  251.    extents. */
  252.  
  253. static void extents_stat (EXTENTS *e, ULONG count)
  254. {
  255.   if (count >= e->size)
  256.     {
  257.       ULONG new_size, i;
  258.  
  259.       new_size = (count | 0xff) + 1;
  260.       e->counts = realloc (e->counts, new_size * sizeof (*e->counts));
  261.       for (i = e->size; i < new_size; ++i)
  262.         e->counts[i] = 0;
  263.       e->size = new_size;
  264.     }
  265.   e->counts[count] += 1;
  266. }
  267.  
  268.  
  269. /* Show the statistics collected in an EXTENTS structure. */
  270.  
  271. static void extents_show (const EXTENTS *e, const char *msg)
  272. {
  273.   ULONG i;
  274.  
  275.   info ("\nFragmentation of %s:\n", msg);
  276.   info ("Extents | Number\n");
  277.   info ("--------+-------\n");
  278.   for (i = 0; i < e->size; ++i)
  279.     if (e->counts[i] != 0)
  280.       info ("%7lu | %lu\n", i, e->counts[i]);
  281. }
  282.  
  283.  
  284. /* Bits in seen_vector[]. */
  285.  
  286. #define SEEN_FNODE      0x01
  287. #define SEEN_DIRBLK     0x02
  288. #define SEEN_ALSEC      0x04
  289. #define SEEN_BADLIST    0x08
  290. #define SEEN_CPINFOSEC  0x10
  291.  
  292.  
  293. /* Set and check a `have seen' bit.  Return TRUE if any of the COUNT
  294.    sectors starting at SECNO has been interpreted as WHAT.  MSG is a
  295.    string describing the type of sector.  This function is used to
  296.    avoid infinite loops. */
  297.  
  298. static int have_seen (ULONG secno, ULONG count, BYTE what, const char *msg)
  299. {
  300.   int seen;
  301.   ULONG i;
  302.  
  303.   seen = FALSE;
  304.   for (i = 0; i < count && secno < total_sectors; ++i, ++secno)
  305.     if (seen_vector[secno] & what)
  306.       {
  307.         seen = TRUE;
  308.         warning (1, "Sector #%lu already used for %s", secno, msg);
  309.       }
  310.     else
  311.       seen_vector[secno] |= what;
  312.   return seen;
  313. }
  314.  
  315.  
  316. /* Types of sectors. */
  317.  
  318. #define USE_EMPTY       0
  319. #define USE_SUPER       1
  320. #define USE_SPARE       2
  321. #define USE_BITMAPIND   3
  322. #define USE_BITMAP      4
  323. #define USE_DIRBLKBITMAP 5
  324. #define USE_SPAREDIRBLK 6
  325. #define USE_BANDDIRBLK  7
  326. #define USE_DIRBLK      8
  327. #define USE_FNODE       9
  328. #define USE_SID         10
  329. #define USE_CPINFOSEC   11
  330. #define USE_CPDATASEC   12
  331. #define USE_BAD         13
  332. #define USE_HOTFIXLIST  14
  333. #define USE_HOTFIX      15
  334. #define USE_BADLIST     16
  335. #define USE_FILE        17
  336. #define USE_ALSEC       18
  337. #define USE_EA          19
  338. #define USE_BOOT        20
  339. #define USE_LOADER      21
  340. #define USE_ACL         22
  341.  
  342. /* Return a pointer to a string containing a description of a sector
  343.    type. */
  344.  
  345. static const char *sec_usage (BYTE what)
  346. {
  347.   switch (what)
  348.     {
  349.     case USE_EMPTY:
  350.       return "empty";
  351.     case USE_SUPER:
  352.       return "super block";
  353.     case USE_SPARE:
  354.       return "spare block";
  355.     case USE_BITMAPIND:
  356.       return "bitmap indirect block";
  357.     case USE_BITMAP:
  358.       return "bitmap";
  359.     case USE_DIRBLKBITMAP:
  360.       return "DIRBLK band bitmap";
  361.     case USE_SPAREDIRBLK:
  362.       return "spare DIRBLK";
  363.     case USE_BANDDIRBLK:
  364.       return "DIRBLK band";
  365.     case USE_DIRBLK:
  366.       return "DIRBLK";
  367.     case USE_FNODE:
  368.       return "FNODE";
  369.     case USE_SID:
  370.       return "SID";
  371.     case USE_CPINFOSEC:
  372.       return "code page info";
  373.     case USE_CPDATASEC:
  374.       return "code page data";
  375.     case USE_BAD:
  376.       return "bad sector";
  377.     case USE_HOTFIXLIST:
  378.       return "hotfix list";
  379.     case USE_HOTFIX:
  380.       return "hotfix sector";
  381.     case USE_BADLIST:
  382.       return "bad block list";
  383.     case USE_FILE:
  384.       return "file data";
  385.     case USE_ALSEC:
  386.       return "allocation sector";
  387.     case USE_EA:
  388.       return "extended attributes";
  389.     case USE_BOOT:
  390.       return "boot sector";
  391.     case USE_LOADER:
  392.       return "loader";
  393.     case USE_ACL:
  394.       return "ACL";
  395.     default:
  396.       return "INTERNAL_ERROR";
  397.     }
  398. }
  399.  
  400.  
  401. /* Use COUNT sectors starting at SECNO for WHAT.  PATH points to the
  402.    path name chain for the file or directory and can be NULL for
  403.    sectors not used by a file or directory. */
  404.  
  405. static void use_sectors (ULONG secno, ULONG count, BYTE what,
  406.                          const path_chain *path)
  407. {
  408.   BYTE old;
  409.  
  410.   /* Handle the sectors one by one. */
  411.  
  412.   while (count > 0)
  413.     {
  414.       /* Before indexing any array with SECNO, check if SECNO is
  415.          valid. */
  416.  
  417.       if (secno >= total_sectors)
  418.         {
  419.           if (path == NULL)
  420.             warning (1, "Sector number #%lu (%s) is too big",
  421.                      secno, sec_usage (what));
  422.           else
  423.             warning (1, "Sector number #%lu (%s for \"%s\") is too big",
  424.                      secno, sec_usage (what), format_path_chain (path, NULL));
  425.         }
  426.       else
  427.         {
  428.           /* Check usage of the sector.  A previously unused sector
  429.              (USE_EMPTY) can be turned into any type of sector, Spare
  430.              DIRBLKs and sectors in the DIRBLK band can be turned into
  431.              DIRBLK sectors.  Note that reusing a code page data
  432.              sector as code page data sector is ignored here as
  433.              do_cpdatasec() can be called more than once for a single
  434.              sector. */
  435.  
  436.           old = usage_vector[secno];
  437.           if (old != USE_EMPTY
  438.               && !(what == USE_DIRBLK
  439.                    && (old == USE_SPAREDIRBLK || old == USE_BANDDIRBLK))
  440.               && !(what == USE_CPDATASEC && old == USE_CPDATASEC))
  441.             {
  442.               warning (1, "Sector #%lu usage conflict: %s vs. %s",
  443.                        secno, sec_usage (usage_vector[secno]),
  444.                        sec_usage (what));
  445.  
  446.               /* Display path names, if possible. */
  447.  
  448.               if (path_vector != NULL && path_vector[secno] != NULL)
  449.                 warning_cont ("File 1: \"%s\"",
  450.                               format_path_chain (path_vector[secno], NULL));
  451.               if (path != NULL)
  452.                 warning_cont ("File 2: \"%s\"",
  453.                               format_path_chain (path, NULL));
  454.             }
  455.           else
  456.             {
  457.               usage_vector[secno] = what;
  458.               if (path_vector != NULL)
  459.                 path_vector[secno] = path;
  460.             }
  461.  
  462.           /* Check if the sector is marked as allocated.  Don't check
  463.              if the allocation bitmap has not yet been read completely
  464.              into memory. */
  465.  
  466.           if (alloc_ready && !ALLOCATED (secno))
  467.             {
  468.               warning (1, "Sector #%lu used (%s) but not marked as allocated",
  469.                        secno, sec_usage (what));
  470.               if (path != NULL)
  471.                 warning_cont ("File: \"%s\"",
  472.                               format_path_chain (path, NULL));
  473.             }
  474.         }
  475.       ++secno; --count;
  476.     }
  477. }
  478.  
  479.  
  480. /* Process the bad block list starting in sector SECNO.  The list has
  481.    TOTAL entries. */
  482.  
  483. static void do_bad (DISKIO *d, ULONG secno, ULONG total)
  484. {
  485.   ULONG list[512];
  486.   ULONG rest, used, i, what_index = 0;
  487.  
  488.   /* The bad block list consists of one or more 4-sector blocks.  The
  489.      first 32-bit word of such a block points to the next 4-sector
  490.      block.  The end of the chain is marked by a zero sector number.
  491.      The remaining 511 32-bit words of the blocks contain the sector
  492.      numbers of bad sectors.  Entries which are zero do not point to
  493.      bad sectors. */
  494.  
  495.   used = 0; rest = total;
  496.   while (secno != 0)
  497.     {
  498.       if (a_info)
  499.         {
  500.           info ("Sectors #%lu-#%lu: Bad block list\n", secno, secno+3);
  501.           info ("  Sector number of next bad block: #%lu\n", list[0]);
  502.         }
  503.       else if (a_what && IN_RANGE (what_sector, secno, 4))
  504.         {
  505.           info ("Sector #%lu: Bad block list (+%lu)\n",
  506.                 what_sector, what_sector - secno);
  507.           if (secno + 0 == what_sector)
  508.             info ("  Next sector in list: #%lu\n", list[0]);
  509.           what_index = (secno - what_sector) / 4;
  510.         }
  511.       if (have_seen (secno, 4, SEEN_BADLIST, "bad block list"))
  512.         break;
  513.       use_sectors (secno, 4, USE_BADLIST, NULL);
  514.       read_sec (d, list, secno, 4, TRUE);
  515.       for (i = 1; i < 512 && i <= rest; ++i)
  516.         if (list[i] != 0)
  517.           {
  518.             ++used;
  519.             if (a_info || (a_what && IN_RANGE (i, what_index, 512/4)))
  520.               info ("  Bad sector: #%lu\n", list[i]);
  521.             else if (a_what && list[i] == what_sector)
  522.               info ("Sector #%lu: Bad sector\n", list[i]);
  523.             use_sectors (list[i], 1, USE_BAD, NULL);
  524.           }
  525.       secno = list[0];
  526.       if (rest > 511)
  527.         rest -= 511;
  528.       else
  529.         rest = 0;
  530.     }
  531.   if (rest != 0 || secno != 0)
  532.     warning (1, "Wrong length of bad block list");
  533.   if (used != total)
  534.     warning (1, "Wrong number of bad blocks");
  535. }
  536.  
  537.  
  538. /* Process the hotfix list starting at sector SECNO.  The list has
  539.    TOTAL entries. */
  540.  
  541. static void do_hotfix_list (DISKIO *d, ULONG secno, ULONG total)
  542. {
  543.   ULONG list[512];              /* 4 Sectors */
  544.   ULONG i, hsecno;
  545.  
  546.   if (total > 512 / 3)
  547.     {
  548.       warning (1, "Maximum number of hotfixes is too big");
  549.       total = 512 / 3;
  550.     }
  551.   if (a_info)
  552.     info ("Sectors #%lu-#%lu: Hotfix list\n", secno, secno + 3);
  553.   else if (a_what && IN_RANGE (what_sector, secno, 4))
  554.     info ("Sector #%lu: Hotfix list (+%lu)\n",
  555.           what_sector, what_sector - secno);
  556.   use_sectors (secno, 4, USE_HOTFIXLIST, NULL);
  557.   read_sec (d, list, secno, 4, TRUE);
  558.   for (i = 0; i < total; ++i)
  559.     {
  560.       hsecno = list[i+total];
  561.       if (hsecno == 0)
  562.         warning (1, "Hotfix sector number is zero");
  563.       else if (hsecno >= total_sectors)
  564.         warning (1, "Hotfix sector number #%lu is too big", hsecno);
  565.       else if (usage_vector[hsecno] == USE_EMPTY)
  566.         {
  567.           if (a_info)
  568.             info ("  Hotfix sector: #%lu for #%lu, FNODE #%lu\n",
  569.                   hsecno, list[i], list[i+2*total]);
  570.           if (a_what && hsecno == what_sector)
  571.             info ("Sector #%lu: Hotfix sector for #%lu, FNODE #%lu\n",
  572.                   hsecno, list[i], list[i+2*total]);
  573.           use_sectors (hsecno, 1, USE_HOTFIX, NULL);
  574.           if (alloc_vector != NULL && !ALLOCATED (hsecno))
  575.             warning (1, "Hotfix sector #%lu not marked as allocated", hsecno);
  576.         }
  577.     }
  578.   if (a_what && IN_RANGE (what_sector, secno, 4))
  579.     {
  580.       for (i = 0; i < total; ++i)
  581.         if (list[i] != 0 && what_sector == secno + i / (512 / 4))
  582.           info ("  Bad sector: #%lu\n", list[i]);
  583.       for (i = 0; i < total; ++i)
  584.         if (what_sector == secno + (i + total) / (512 / 4))
  585.           info ("  Hotfix sector: #%lu\n", list[i+total]);
  586.     }
  587. }
  588.  
  589.  
  590. /* One band has 8 MBytes, a run of free sectors may not span more than
  591.    two bands.  Therefore, there are at most 32768 successive free
  592.    sectors. */
  593.  
  594. #define MAX_FREE_SIZE   32768
  595.  
  596. /* Show fragmentation of free space. */
  597.  
  598. static void do_free_frag (void)
  599. {
  600.   ULONG *counts, count, start, end, j, k;
  601.  
  602.   counts = xmalloc (MAX_FREE_SIZE * sizeof (*counts));
  603.   for (j = 0; j < MAX_FREE_SIZE; ++j)
  604.     counts[j] = 0;
  605.   count = 0;
  606.   for (j = 0; j < total_sectors; ++j)
  607.     if (!ALLOCATED (j))
  608.       ++count;
  609.     else if (count != 0)
  610.       {
  611.         if (count < MAX_FREE_SIZE)
  612.           counts[count] += 1;
  613.         count = 0;
  614.       }
  615.   if (count != 0)
  616.     {
  617.       if (count < MAX_FREE_SIZE)
  618.         counts[count] += 1;
  619.     }
  620.   info ("\nFragmentation of free space:\n");
  621.   info ("Fragment size | Number of fragments of that size\n");
  622.   info ("--------------+---------------------------------\n");
  623.   for (j = 0; (1 << j) < MAX_FREE_SIZE; ++j)
  624.     {
  625.       start = 1 << j;
  626.       end = 2 * start;
  627.       if (end > MAX_FREE_SIZE)
  628.         end = MAX_FREE_SIZE;
  629.       count = 0;
  630.       for (k = start; k < end; ++k)
  631.         count += counts[k];
  632.       info (" %5lu-%-5lu  | %lu\n", start, end - 1, count);
  633.     }
  634.   info ("\n");
  635. }
  636.  
  637.  
  638. /* Show a range of COUNT free sectors starting at sector START. */
  639.  
  640. static void do_bitmap_show (ULONG start, ULONG count)
  641. {
  642.   if (count == 1)
  643.     info ("  Unallocated: 1 sector #%lu\n", start);
  644.   else
  645.     info ("  Unallocated: %lu sectors #%lu-#%lu\n",
  646.           count, start, start + count - 1);
  647. }
  648.  
  649.  
  650. /* Show free sectors in the bitmap pointed to by BITMAP.  BASE is the
  651.    number of the first sector mapped by the bitmap.  SIZE is the
  652.    number of bits in the bitmap.  Return the number of free
  653.    sectors. */
  654.  
  655. static ULONG do_bitmap2 (const BYTE *bitmap, ULONG base, ULONG size)
  656. {
  657.   ULONG start, count, j, total;
  658.  
  659.   start = count = total = 0;
  660.   for (j = 0; j < size; ++j)
  661.     if (BITSETP (bitmap, j))
  662.       {
  663.         if (count == 0)
  664.           start = j + base;
  665.         ++count;
  666.       }
  667.     else if (count != 0)
  668.       {
  669.         do_bitmap_show (start, count);
  670.         total += count;
  671.         count = 0;
  672.       }
  673.   if (count != 0)
  674.     {
  675.       do_bitmap_show (start, count);
  676.       total += count;
  677.     }
  678.   return total;
  679. }
  680.  
  681.  
  682. /* Process the bitmap block starting in sector SECNO for band BAND. */
  683.  
  684. static void do_bitmap (DISKIO *d, ULONG secno, ULONG band, int show)
  685. {
  686.   BYTE bitmap[2048];
  687.   ULONG pos, total, first_sec, rel_sec;
  688.  
  689.   if (a_info || show)
  690.     info ("Bitmap for band %lu is in sectors #%lu-#%lu\n",
  691.           band, secno, secno + 3);
  692.   if (a_what && IN_RANGE (what_sector, secno, 4))
  693.     info ("Sector #%lu: Bitmap for band %lu (+%lu)\n",
  694.           what_sector, band, what_sector - secno);
  695.   use_sectors (secno, 4, USE_BITMAP, NULL);
  696.   read_sec (d, bitmap, secno, 4, TRUE);
  697.   pos = band * 2048;
  698.   first_sec = band * 2048 * 8;
  699.   if (a_info || a_check || a_what)
  700.     {
  701.       if (pos + 2048 <= total_alloc)
  702.         memcpy (alloc_vector + pos, bitmap, 2048);
  703.       else if (pos < total_alloc)
  704.         memcpy (alloc_vector + pos, bitmap, total_alloc - pos);
  705.     }
  706.   if (a_info && show_unused)
  707.     {
  708.       total = do_bitmap2 (bitmap, first_sec, 2048 * 8);
  709.       info ("  Unallocated sectors in band %lu: %lu\n", band, total);
  710.     }
  711.   else if (a_what && IN_RANGE (what_sector, secno, 4))
  712.     do_bitmap2 (bitmap + (what_sector - secno) * 512,
  713.                 (band * 2048 + (what_sector - secno) * 512) * 8,
  714.                 512 * 8);
  715.   if (a_what && IN_RANGE (what_sector, first_sec, 2048 * 8))
  716.     {
  717.       rel_sec = what_sector - first_sec;
  718.       info ("Allocation bit for sector #%lu (%s) is in sector #%lu,\n"
  719.             "  byte 0x%lx, bit %lu\n",
  720.             what_sector,
  721.             (BITSETP (bitmap, rel_sec) ? "unallocated" : "allocated"),
  722.             secno + rel_sec / (512 * 8),
  723.             (rel_sec % (512 * 8)) / 8, rel_sec % 8);
  724.     }
  725. }
  726.  
  727.  
  728. /* Process the bitmap indirect block starting in sector SECNO. */
  729.  
  730. static void do_bitmap_indirect (DISKIO *d, ULONG secno)
  731. {
  732.   BYTE bit_count[256];
  733.   ULONG *list;
  734.   ULONG i, bsecno, nfree, resvd, bands, blocks;
  735.  
  736.   bands = DIVIDE_UP (total_sectors, 2048 * 8);
  737.   blocks = DIVIDE_UP (bands, 512);
  738.   if (a_info)
  739.     info ("Sectors #%lu-#%lu: Bitmap indirect block\n",
  740.           secno, secno + 4 * blocks - 1);
  741.   else if (a_what && IN_RANGE (what_sector, secno, 4 * blocks))
  742.     info ("Sector #%lu: Bitmap indirect block (+%lu)\n",
  743.           what_sector, what_sector - secno);
  744.   use_sectors (secno, 4 * blocks, USE_BITMAPIND, NULL);
  745.   list = xmalloc (2048 * blocks);
  746.   read_sec (d, list, secno, 4 * blocks, TRUE);
  747.   for (i = 0; i < bands; ++i)
  748.     {
  749.       bsecno = list[i];
  750.       if (bsecno == 0)
  751.         {
  752.           warning (1, "Bitmap indirect block starting at #%lu: "
  753.                    "Entry %lu is zero", secno, i);
  754.           break;
  755.         }
  756.       do_bitmap (d, bsecno, i,
  757.                  (a_what && what_sector == secno + i / (512 / 4)));
  758.     }
  759.   if (a_check)
  760.     {
  761.       for (i = bands; i < blocks * 512; ++i)
  762.         if (list[i] != 0)
  763.           {
  764.             warning (1, "Bitmap indirect block starting at #%lu: "
  765.                      "Too many entries", secno);
  766.             break;
  767.           }
  768.     }
  769.   free (list); list = NULL;
  770.  
  771.   if (a_check || a_info)
  772.     {
  773.       for (i = 0; i < 256; ++i)
  774.         {
  775.           bit_count[i] = 0;
  776.           if (i & 0x01) ++bit_count[i];
  777.           if (i & 0x02) ++bit_count[i];
  778.           if (i & 0x04) ++bit_count[i];
  779.           if (i & 0x08) ++bit_count[i];
  780.           if (i & 0x10) ++bit_count[i];
  781.           if (i & 0x20) ++bit_count[i];
  782.           if (i & 0x40) ++bit_count[i];
  783.           if (i & 0x80) ++bit_count[i];
  784.         }
  785.       nfree = 0;
  786.       for (i = 0; i < total_alloc; ++i)
  787.         nfree += bit_count[alloc_vector[i]];
  788.       resvd = total_sectors / 50;
  789.       if (resvd > 4096) resvd = 4096;
  790.       if (a_info)
  791.         info ("Number of reserved sectors:    %lu (%lu used)\n",
  792.               resvd, resvd > nfree ? resvd - nfree : 0);
  793.       if (resvd > nfree)
  794.         {
  795.           if (a_check)
  796.             warning (0, "Reserved sectors are in used (%lu)", resvd - nfree);
  797.           resvd = 0;
  798.         }
  799.       if (a_info)
  800.         info ("Number of unallocated sectors: %lu (%lu available)\n",
  801.               nfree, nfree - resvd);
  802.     }
  803.   if (alloc_vector != NULL)
  804.     alloc_ready = TRUE;
  805. }
  806.  
  807.  
  808. /* Compare two file names pointed to by P1 and P2.  CPIDX1 and CPIDX2
  809.    are the code page indices of the files.  If a code page index is
  810.    out of range, the current code page will be used. */
  811.  
  812. static int compare_fname (const BYTE *p1, const BYTE *p2,
  813.                           ULONG cpidx1, ULONG cpidx2)
  814. {
  815.   const BYTE *map1, *map2;
  816.  
  817.   map1 = (cpidx1 >= code_page_count
  818.           ? cur_case_map : code_pages[cpidx1].case_map);
  819.   map2 = (cpidx2 >= code_page_count
  820.           ? cur_case_map : code_pages[cpidx2].case_map);
  821.   for (;;)
  822.     {
  823.       if (*p1 == 0 && *p2 == 0)
  824.         return 0;
  825.       if (*p2 == 0)
  826.         return 1;
  827.       if (*p1 == 0)
  828.         return -1;
  829.       if (map1[*p1] > map2[*p2])
  830.         return 1;
  831.       if (map1[*p1] < map2[*p2])
  832.         return -1;
  833.       ++p1; ++p2;
  834.     }
  835. }
  836.  
  837.  
  838. /* Process one entry of a code page data sector.  The entry is in
  839.    sector SECNO (used for messages, only).  PD points to the code page
  840.    entry.  The length of the entry is LEN bytes.  CS is the expected
  841.    checksum for the entry. */
  842.  
  843. static void do_cpdata (ULONG secno, const CPDATAENTRY *pd, ULONG len, ULONG cs)
  844. {
  845.   ULONG rc, i, cs2;
  846.   COUNTRYCODE cc;
  847.   BYTE map[128], c;
  848.   BYTE dbcs[12];
  849.  
  850.   for (c = 0; c < 128; ++c)
  851.     map[c] = (BYTE)(c + 128);
  852.   cc.country = USHORT_FROM_FS (pd->usCountryCode);
  853.   cc.codepage = USHORT_FROM_FS (pd->usCodePageID);
  854.   rc = DosMapCase (128, &cc, (PCHAR)map);
  855.   if (rc == ERROR_NLS_NO_COUNTRY_FILE)
  856.     {
  857.       if (!no_country_sys)
  858.         warning (0, "COUNTRY.SYS not found -- "
  859.                  "cannot check case mapping tables");
  860.       no_country_sys = TRUE;
  861.     }
  862.   if (!no_country_sys)
  863.     {
  864.       if (rc != 0)
  865.         warning (1, "DosMapCase failed for %lu/%lu, rc=%lu",
  866.                  cc.country, cc.codepage, rc);
  867.       else if (memcmp (map, pd->bCaseMapTable, 128) != 0)
  868.         warning (1, "CPDATASEC #%lu: Case mapping table does not match "
  869.                  "DosMapCase for %lu/%lu", secno, cc.country, cc.codepage);
  870.       rc = DosQueryDBCSEnv (sizeof (dbcs), &cc, (PCHAR)&dbcs);
  871.       if (rc != 0)
  872.         warning (1, "DosQueryDBCSEnv failed for %lu/%lu, rc=%lu",
  873.                  cc.country, cc.codepage, rc);
  874.       else
  875.         {
  876.           for (i = 0; i < 6; ++i)
  877.             if (dbcs[2*i+0] == 0 && dbcs[2*i+1] == 0)
  878.               break;
  879.           if (i != USHORT_FROM_FS (pd->cDBCSRange))
  880.             warning (1, "CPDATASEC #%lu: Number of DBCS ranges does not match "
  881.                      "DosQueryDBCSEnv for %lu/%lu",
  882.                      secno, cc.country, cc.codepage);
  883.           else if (memcmp (dbcs, (const char *)pd->DBCSRange, 2 * i) != 0)
  884.             warning (1, "CPDATASEC #%lu: DBCS ranges does not match "
  885.                      "DosQueryDBCSEnv for %lu/%lu",
  886.                      secno, cc.country, cc.codepage);
  887.         }
  888.     }
  889.   cs2 = chksum ((const BYTE *)pd, len);
  890.   if (cs != cs2)
  891.     warning (1, "CPDATASEC #%lu: Incorrect checksum for %lu/%lu",
  892.              secno, cc.country, cc.codepage);
  893. }
  894.  
  895.  
  896. /* Process a code page data sector.  DI is an index into
  897.    code_pages[]. */
  898.  
  899. static void do_cpdatasec (DISKIO *d, ULONG di)
  900. {
  901.   ULONG secno, dcount, index, offset, len, j, c;
  902.   HPFS_SECTOR cpdatasec;
  903.   char used[512];
  904.   const CPDATAENTRY *pd;
  905.  
  906.   secno = ULONG_FROM_FS (code_pages[di].info.lsnCPData);
  907.   for (j = 0; j < cpdata_count; ++j)
  908.     if (cpdata_visited[j] == secno)
  909.       return;
  910.   cpdata_visited[cpdata_count++] = secno;
  911.   if (a_info || (a_what && secno == what_sector))
  912.     info ("Sector #%lu: Code page data sector\n", secno);
  913.   use_sectors (secno, 1, USE_CPDATASEC, NULL);
  914.   read_sec (d, &cpdatasec, secno, 1, TRUE);
  915.   if (ULONG_FROM_FS (cpdatasec.cpdatasec.sig) != CPDATA_SIG1)
  916.     {
  917.       warning (1, "CPDATASEC #%lu: Bad signature", secno);
  918.       return;
  919.     }
  920.   dcount = USHORT_FROM_FS (cpdatasec.cpdatasec.cCodePage);
  921.   if (dcount > 3)
  922.     {
  923.       warning (1, "CPDATASEC #%lu: Too many code pages", secno);
  924.       dcount = 3;
  925.     }
  926.   memset (used, FALSE, 512);
  927.   for (j = 0; j < dcount; ++j)
  928.     {
  929.       index = USHORT_FROM_FS (cpdatasec.cpdatasec.iFirstCP) + j;
  930.       if (index >= code_page_count)
  931.         warning (1, "CPDATASEC #%lu: Index too big", secno);
  932.       else
  933.         {
  934.           code_pages[index].hit = TRUE;
  935.           for (c = 0; c < 256; ++c)
  936.             code_pages[index].case_map[c] = (BYTE)c;
  937.           for (c = 'a'; c <= 'z'; ++c)
  938.             code_pages[index].case_map[c] = (BYTE)toupper (c);
  939.           if (ULONG_FROM_FS (cpdatasec.cpdatasec.cksCP[j])
  940.               != ULONG_FROM_FS (code_pages[index].info.cksCP))
  941.             warning (1, "CPDATASEC #%lu: Wrong checksum for code page %lu",
  942.                      secno, index);
  943.           offset = USHORT_FROM_FS (cpdatasec.cpdatasec.offCPData[j]);
  944.           len = sizeof (CPDATAENTRY) - sizeof (DBCSRG);
  945.           if (offset < sizeof (cpdatasec.cpdatasec) || offset + len > 512)
  946.             warning (1, "CPDATASEC #%lu: Invalid offset: %lu", secno, offset);
  947.           else
  948.             {
  949.               pd = (const CPDATAENTRY *)(cpdatasec.raw + offset);
  950.               if (USHORT_FROM_FS (pd->cDBCSRange)
  951.                   != USHORT_FROM_FS (code_pages[index].info.cDBCSRange))
  952.                 warning (1, "CPDATASEC #%lu: Incorrect number of DBCS ranges",
  953.                          secno);
  954.               else
  955.                 {
  956.                   len += ((USHORT_FROM_FS (pd->cDBCSRange) + 1)
  957.                           * sizeof (DBCSRG));
  958.                   if (offset + len > 512)
  959.                     warning (1, "CPDATASEC #%lu: Invalid offset: %lu",
  960.                              secno, offset);
  961.                   else if (memchr (used + offset, TRUE, len) != NULL)
  962.                     warning (1, "CPDATASEC #%lu: Overlapping data", secno);
  963.                   else
  964.                     {
  965.                       memset (used + offset, TRUE, len);
  966.                       do_cpdata (secno, pd, len,
  967.                                  ULONG_FROM_FS (cpdatasec.cpdatasec.cksCP[j]));
  968.                       memcpy (code_pages[index].case_map + 128,
  969.                               pd->bCaseMapTable, 128);
  970.                     }
  971.                 }
  972.             }
  973.         }
  974.     }
  975. }
  976.  
  977.  
  978. /* Process one code page information sector.  PSECNO points to an
  979.    object containing the sector number of the code page information
  980.    sector.  The object will be modified to contain the sector number
  981.    of the next code page information sector.  The object pointed to by
  982.    PCOUNT contains the number of code pages.  The object will be
  983.    updated.  Return TRUE iff successful. */
  984.  
  985. static int do_one_cpinfosec (DISKIO *d, ULONG *psecno, ULONG *pcount)
  986. {
  987.   ULONG secno, i, n, next;
  988.   HPFS_SECTOR cpinfosec;
  989.   const CPINFOENTRY *pi;
  990.  
  991.   secno = *psecno;
  992.   if (a_info || (a_what && secno == what_sector))
  993.     info ("Sector #%lu: Code page information sector\n", secno);
  994.   if (have_seen (secno, 1, SEEN_CPINFOSEC, "code page information"))
  995.     return FALSE;
  996.   use_sectors (secno, 1, USE_CPINFOSEC, NULL);
  997.   read_sec (d, &cpinfosec, secno, 1, TRUE);
  998.   if (ULONG_FROM_FS (cpinfosec.cpinfosec.sig) != CPINFO_SIG1)
  999.     {
  1000.       warning (1, "CPINFOSEC #%lu: Bad signature", secno);
  1001.       return FALSE;
  1002.     }
  1003.   if (ULONG_FROM_FS (cpinfosec.cpinfosec.iFirstCP) != *pcount)
  1004.     warning (1, "CPINFOSEC #%lu: Wrong code page index", secno);
  1005.   n = ULONG_FROM_FS (cpinfosec.cpinfosec.cCodePage);
  1006.   if (n > 31)
  1007.     {
  1008.       warning (1, "CPINFOSEC #%lu: Too many code pages", secno);
  1009.       n = 31;
  1010.     }
  1011.   for (i = 0; i < n; ++i)
  1012.     {
  1013.       pi = &cpinfosec.cpinfosec.CPInfoEnt[i];
  1014.       code_pages[*pcount].info = *pi;
  1015.       code_pages[*pcount].hit = FALSE;
  1016.       if (a_info || (a_what && what_sector == secno))
  1017.         info ("  Code page index %lu: code page %u, country %u\n",
  1018.               i, USHORT_FROM_FS (pi->usCodePageID),
  1019.               USHORT_FROM_FS (pi->usCountryCode));
  1020.       if (USHORT_FROM_FS (pi->iCPVol) != *pcount)
  1021.         warning (1, "CPINFOSEC #%lu: Incorrect index", secno);
  1022.       ++*pcount;
  1023.     }
  1024.   next = ULONG_FROM_FS (cpinfosec.cpinfosec.lsnNext);
  1025.   if (next == 0)
  1026.     return FALSE;
  1027.   *psecno = next;
  1028.   return TRUE;
  1029. }
  1030.  
  1031.  
  1032. /* Process the list of code page information sectors starting in
  1033.    sector SECNO. */
  1034.  
  1035. static void do_cpinfosec (DISKIO *d, ULONG secno)
  1036. {
  1037.   ULONG count, i;
  1038.  
  1039.   code_pages = xmalloc (code_page_count * sizeof (MYCP));
  1040.   count = 0;
  1041.   while (do_one_cpinfosec (d, &secno, &count))
  1042.     ;
  1043.   if (count != code_page_count)
  1044.     {
  1045.       warning (1, "Wrong number of code pages in code page information "
  1046.                "sectors");
  1047.       if (count < code_page_count)
  1048.         code_page_count = count;
  1049.     }
  1050.  
  1051.   cpdata_count = 0;
  1052.   cpdata_visited = xmalloc (code_page_count * sizeof (*cpdata_visited));
  1053.   for (i = 0; i < code_page_count; ++i)
  1054.     do_cpdatasec (d, i);
  1055.   free (cpdata_visited); cpdata_visited = NULL;
  1056.  
  1057.   for (i = 0; i < code_page_count; ++i)
  1058.     if (!code_pages[i].hit)
  1059.       warning (1, "No code page data for code page index %lu", i);
  1060.   /* TODO: check for duplicate code pages */
  1061. }
  1062.  
  1063.  
  1064. static void do_fnode (DISKIO *d, ULONG secno, const path_chain *path,
  1065.                       int dir_flag, ULONG parent_fnode, ULONG file_size,
  1066.                       ULONG ea_size, int check_ea_size, int need_eas,
  1067.                       int list);
  1068. static int do_storage (DISKIO *d, ULONG secno, const ALBLK *header,
  1069.                        ULONG leaf_count, const path_chain *path,
  1070.                        ULONG *pexp_file_sec, ULONG *pnext_disk_sec,
  1071.                        ULONG total_sectors, ULONG parent_fnode,
  1072.                        int alsec_level, BYTE what, ULONG *pextents,
  1073.                        int show, ULONG copy_size, BYTE *buf, ULONG buf_size);
  1074. static void do_dirblk (DISKIO *d, ULONG secno, const path_chain *path,
  1075.                        ULONG parent_fnode, ULONG parent, SORT *psort,
  1076.                        int *down_ptr, int level, int *pglobal_dirent_index,
  1077.                        int *pdotdot, int list);
  1078.  
  1079.  
  1080. /* Display a warning message for the DIRBLK starting in sector SECNO.
  1081.    PATH points to the path name chain of the directory. */
  1082.  
  1083. static void dirblk_warning (int level, const char *fmt, ULONG secno,
  1084.                             const path_chain *path, ...)
  1085. {
  1086.   va_list arg_ptr;
  1087.  
  1088.   warning_prolog (level);
  1089.   my_fprintf (diag_file, "DIRBLK #%lu (\"%s\"): ",
  1090.               secno, format_path_chain (path, NULL));
  1091.   va_start (arg_ptr, path);
  1092.   my_vfprintf (diag_file, fmt, arg_ptr);
  1093.   va_end (arg_ptr);
  1094.   fputc ('\n', diag_file);
  1095.   warning_epilog ();
  1096. }
  1097.  
  1098.  
  1099. /* Display a warning message for directory entry number DIRENT_NO of
  1100.    the DIRBLK starting in sector SECNO.  PATH points to the path name
  1101.    chain of the directory, FNAME is the file name in the directory
  1102.    entry. */
  1103.  
  1104. static void dirent_warning (int level, const char *fmt, ULONG secno,
  1105.                             const path_chain *path, int dirent_no,
  1106.                             const char *fname, ...)
  1107. {
  1108.   va_list arg_ptr;
  1109.  
  1110.   warning_prolog (level);
  1111.   my_fprintf (diag_file, "DIRBLK #%lu (\"%s\"): ",
  1112.               secno, format_path_chain (path, NULL));
  1113.   if (fname == NULL)
  1114.     my_fprintf (diag_file, "DIRENT %d: ", dirent_no);
  1115.   else
  1116.     my_fprintf (diag_file, "DIRENT %d (\"%s\"): ", dirent_no, fname);
  1117.   va_start (arg_ptr, fname);
  1118.   my_vfprintf (diag_file, fmt, arg_ptr);
  1119.   va_end (arg_ptr);
  1120.   fputc ('\n', diag_file);
  1121.   warning_epilog ();
  1122. }
  1123.  
  1124.  
  1125. /* Show the directory entry pointed to by P.  Indent with INDENT
  1126.    spaces. */
  1127.  
  1128. static void show_dirent (const DIRENT *p, int indent)
  1129. {
  1130.   ULONG cpindex, length, gap_size, ace_size, i;
  1131.   const BYTE *pb;
  1132.  
  1133.   length = USHORT_FROM_FS (p->cchThisEntry);
  1134.   infoi ("Length:                      %lu\n", indent, length);
  1135.   infoi ("Flags:                       0x%.2x", indent, p->bFlags);
  1136.   if (p->bFlags & DF_SPEC) info (" ..");
  1137.   if (p->bFlags & DF_END) info (" end");
  1138.   if (p->bFlags & DF_ATTR) info (" EA");
  1139.   if (p->bFlags & DF_NEEDEAS) info (" need-EA");
  1140.   if (p->bFlags & DF_PERM) info (" perms");
  1141.   if (p->bFlags & DF_ACL) info (" ACL");
  1142.   if (p->bFlags & DF_XACL) info (" explicit-ACL");
  1143.   info ("\n");
  1144.   if (!(p->bFlags & DF_END))
  1145.     {
  1146.       infoi ("Attributes:                  0x%.2x", indent, p->bAttr);
  1147.       if (p->bAttr & ATTR_DIR)
  1148.         info (" dir");
  1149.       if (p->bAttr & ATTR_READONLY)
  1150.         info (" r/o");
  1151.       if (p->bAttr & ATTR_HIDDEN)
  1152.         info (" hidden");
  1153.       if (p->bAttr & ATTR_SYSTEM)
  1154.         info (" system");
  1155.       if (p->bAttr & ATTR_LABEL)
  1156.         info (" label");
  1157.       if (p->bAttr & ATTR_ARCHIVED)
  1158.         info (" arch");
  1159.       if (p->bAttr & ATTR_NONFAT)
  1160.         info (" non-FAT");
  1161.       info ("\n");
  1162.       infoi ("FNODE:                       #%lu\n", indent,
  1163.              ULONG_FROM_FS (p->lsnFNode));
  1164.       infoi ("Time of creation:            %s\n", indent,
  1165.              format_time (ULONG_FROM_FS (p->timCreate)));
  1166.       infoi ("Time of last modification:   %s\n", indent,
  1167.              format_time (ULONG_FROM_FS (p->timLastMod)));
  1168.       infoi ("Time of last access:         %s\n", indent,
  1169.              format_time (ULONG_FROM_FS (p->timLastAccess)));
  1170.       infoi ("Size of file:                %lu\n", indent,
  1171.              ULONG_FROM_FS (p->cchFSize));
  1172.       infoi ("Size of extended attributes: %lu\n", indent,
  1173.              ULONG_FROM_FS (p->ulEALen));
  1174.       infoi ("Number of ACEs:              %u\n", indent, p->bFlex & 7);
  1175.       cpindex = p->bCodePage & 0x7f;
  1176.       if (cpindex >= code_page_count)
  1177.         infoi ("Code page index:             %lu\n", indent, cpindex);
  1178.       else
  1179.         infoi ("Code page:                   %u\n", indent,
  1180.                USHORT_FROM_FS (code_pages[cpindex].info.usCodePageID));
  1181.       if (p->bCodePage & 0x80)
  1182.         infoi ("Name contains DBCS characters\n", indent);
  1183.       if (p->bFlags & DF_ACL)
  1184.         {
  1185.           gap_size = length - (sizeof (DIRENT) + p->cchName - 1);
  1186.           if (p->bFlags & DF_BTP)
  1187.             gap_size -= sizeof (ULONG);
  1188.           ace_size = (p->bFlex & 7) * 4;
  1189.           pb = p->bName + p->cchName;
  1190.           for (i = 0; i < gap_size; ++i)
  1191.             {
  1192.               if (i % 16 == 0)
  1193.                 {
  1194.                   if (i != 0)
  1195.                     info ("\n");
  1196.                   infoi ("ACE data:                   ", indent);
  1197.                 }
  1198.               info ("%c%.2x",
  1199.                     i == ace_size ? '|' : i > 0 && i % 4 == 0 ? '.' : ' ',
  1200.                     pb[i]);
  1201.             }
  1202.           if (gap_size != 0)
  1203.             info ("\n");
  1204.         }
  1205.     }
  1206.   if (p->bFlags & DF_BTP)
  1207.     infoi ("Down pointer:                #%lu\n", indent,
  1208.            ((ULONG *)((const char *)p + length))[-1]);
  1209. }
  1210.  
  1211.  
  1212. /* Show the directory entry pointed to by P, formatted for the `dir'
  1213.    action. */
  1214.  
  1215. static void show_dir (const DIRENT *p, const char *name)
  1216. {
  1217.   info ("%s ", format_dir_time (ULONG_FROM_FS (p->timLastMod)));
  1218.   if (p->bAttr & ATTR_DIR)
  1219.     info ("     <DIR>      ");
  1220.   else
  1221.     info ("%10lu %c%c%c%c%c",
  1222.           ULONG_FROM_FS (p->cchFSize),
  1223.           (p->bAttr & ATTR_READONLY) ? 'R' : '-',
  1224.           (p->bAttr & ATTR_HIDDEN)   ? 'H' : '-',
  1225.           (p->bAttr & ATTR_SYSTEM)   ? 'S' : '-',
  1226.           (p->bAttr & ATTR_LABEL)    ? 'V' : '-',
  1227.           (p->bAttr & ATTR_ARCHIVED) ? 'A' : '-');
  1228.   info (" \"%s\"\n", name);
  1229. }
  1230.  
  1231.  
  1232. /* Perform basic checks for the DIRENT at offset POS of the DIRBLK
  1233.    pointed to by PDIR.  Return a pointer to the DIRENT if it looks
  1234.    reasonably good.  Return NULL if it looks bad.  Store the name to
  1235.    NAME, which points to an array of 256 characters.  Print warnings
  1236.    if WARN is TRUE.  The remaining arguments are passed to
  1237.    dirent_warning(). */
  1238.  
  1239. const DIRENT *check_dirent (const DIRBLK *pdir, size_t pos, char *name,
  1240.                             int warn, ULONG secno, const path_chain *path,
  1241.                             int index)
  1242. {
  1243.   const DIRENT *p;
  1244.   ULONG length;
  1245.  
  1246.   *name = 0;
  1247.   p = (const DIRENT *)((const char *)pdir + pos);
  1248.   if (pos + sizeof (DIRENT) > 2048)
  1249.     {
  1250.       if (warn)
  1251.         dirent_warning (1, "Extends beyond end of DIRBLK",
  1252.                         secno, path, index, NULL);
  1253.       return NULL;
  1254.     }
  1255.   length = USHORT_FROM_FS (p->cchThisEntry);
  1256.   if (pos + length > 2048)
  1257.     {
  1258.       if (warn)
  1259.         dirent_warning (1, "Extends beyond end of DIRBLK",
  1260.                         secno, path, index, NULL);
  1261.       return NULL;
  1262.     }
  1263.   if (length < sizeof (DIRENT))
  1264.     {
  1265.       if (warn)
  1266.         dirent_warning (1, "Length too small (case 1)",
  1267.                         secno, path, index, NULL);
  1268.       return NULL;
  1269.     }
  1270.   if (length < (ROUND_UP (sizeof (DIRENT) + p->cchName - 1, 4)
  1271.                 + ((p->bFlags & DF_BTP) ? sizeof (ULONG) : 0)))
  1272.     {
  1273.       if (warn)
  1274.         dirent_warning (1, "Length too small (case 2)",
  1275.                         secno, path, index, NULL);
  1276.       return NULL;
  1277.     }
  1278.   if (length & 3)
  1279.     {
  1280.       if (warn)
  1281.         dirent_warning (1, "Length is not a multiple of 4",
  1282.                         secno, path, index, NULL);
  1283.       return NULL;
  1284.     }
  1285.  
  1286.   if (p->bFlags & DF_END)
  1287.     {
  1288.       strcpy (name, "[END]");
  1289.       if (a_check && (p->cchName != 1 || memcmp (p->bName, "\377", 1) != 0))
  1290.         dirent_warning (0, "Wrong name for end entry",
  1291.                         secno, path, index, NULL);
  1292. #if 0
  1293.       /* This error(?) seems to be quite normal with HPFS386. */
  1294.       if (a_check && (p->bFlags & DF_SPEC))
  1295.         dirent_warning (1, "Both DF_END and DF_SPEC are set",
  1296.                         secno, path, index, NULL);
  1297. #endif
  1298.     }
  1299.   else if (p->bFlags & DF_SPEC)
  1300.     {
  1301.       strcpy (name, "..");
  1302.       if (a_check && (p->cchName != 2 || memcmp (p->bName, "\1\1", 2) != 0))
  1303.         dirent_warning (0, "Wrong name for \"..\" entry",
  1304.                         secno, path, index, NULL);
  1305.     }
  1306.   else
  1307.     {
  1308.       memcpy (name, p->bName, p->cchName);
  1309.       name[p->cchName] = 0;
  1310.     }
  1311.  
  1312.   return p;
  1313. }
  1314.  
  1315.  
  1316. /* Show DIRENTs for the `info <number>' action. */
  1317.  
  1318. static void do_dirblk_what (DISKIO *d, const DIRBLK *pdir, ULONG secno,
  1319.                             const path_chain *path)
  1320. {
  1321.   const DIRENT *p;
  1322.   char name[256];
  1323.   int dirent_index;
  1324.   size_t pos;
  1325.   ULONG length;
  1326.  
  1327.   if (what_sector == secno)
  1328.     {
  1329.       info ("  Change count(?):           %lu\n",
  1330.             ULONG_FROM_FS (pdir->dirblk.culChange) >> 1);
  1331.       info ("  Offset to first free byte: 0x%lx\n",
  1332.             ULONG_FROM_FS (pdir->dirblk.offulFirstFree));
  1333.       info ("  Pointer to parent:         #%lu\n",
  1334.             ULONG_FROM_FS (pdir->dirblk.lsnParent));
  1335.       info ("  Pointer to this directory: #%lu\n",
  1336.             ULONG_FROM_FS (pdir->dirblk.lsnThisDir));
  1337.     }
  1338.  
  1339.   pos = offsetof (DIRBLK, dirblk.dirent);
  1340.   for (dirent_index = 0;; ++dirent_index)
  1341.     {
  1342.       p = check_dirent (pdir, pos, name, FALSE, secno, path, dirent_index);
  1343.       if (p == NULL)
  1344.         break;
  1345.       length = USHORT_FROM_FS (p->cchThisEntry);
  1346.       if (secno + pos / 512 <= what_sector
  1347.           && secno + (pos + length - 1) / 512 >= what_sector)
  1348.         {
  1349.           info ("  ");
  1350.           if (secno + pos / 512 != what_sector
  1351.               || secno + (pos + length - 1) / 512 != what_sector)
  1352.             info ("Partial ");
  1353.           info ("DIRENT %d (offset 0x%lx):\n", dirent_index, pos);
  1354.           info ("    Name: \"%s\"\n", name);
  1355.           show_dirent (p, 4);
  1356.         }
  1357.       pos += length;
  1358.       if (p->bFlags & DF_END)
  1359.         break;
  1360.     }
  1361. }
  1362.  
  1363.  
  1364. /* Handle actions which search for a file: Search the DIRBLK for the
  1365.    current path name component.  If found, either show information
  1366.    about the path name (for `info <path>') or recurse. */
  1367.  
  1368. static void do_dirblk_find (DISKIO *d, const DIRBLK *pdir, ULONG secno,
  1369.                             const path_chain *path, ULONG parent_fnode)
  1370. {
  1371.   const DIRENT *p;
  1372.   char name[256];
  1373.   int dirent_index, cmp, list;
  1374.   ULONG cpindex, length;
  1375.   size_t pos;
  1376.   path_chain link, *plink;
  1377.  
  1378.   pos = offsetof (DIRBLK, dirblk.dirent);
  1379.   for (dirent_index = 0;; ++dirent_index)
  1380.     {
  1381.       p = check_dirent (pdir, pos, name, TRUE, secno, path, dirent_index);
  1382.       if (p == NULL)
  1383.         break;
  1384.  
  1385.       length = USHORT_FROM_FS (p->cchThisEntry);
  1386.       if (p->bFlags & DF_END)
  1387.         cmp = 1;
  1388.       else if (p->bFlags & DF_SPEC)
  1389.         cmp = -1;
  1390.       else
  1391.         {
  1392.           cpindex = p->bCodePage & 0x7f;
  1393.           cmp = compare_fname ((const BYTE *)name,
  1394.                                (const BYTE *)find_comp,
  1395.                                cpindex, code_page_count);
  1396.         }
  1397.  
  1398.       if (cmp < 0)
  1399.         {
  1400.           /* The DIRENT's name is less than the name we are looking
  1401.              for.  Examine the next DIRENT.  This is the only case in
  1402.              which the loop is continued. */
  1403.  
  1404.           pos += length;
  1405.         }
  1406.       else if (cmp == 0)
  1407.         {
  1408.           /* We found the name.  If it's the last component of the
  1409.              path name we are looking for, show information about the
  1410.              DIRENT. */
  1411.  
  1412.           if (*find_path == 0)
  1413.             {
  1414.               if (a_where)
  1415.                 {
  1416.                   info ("Directory entry %d of DIRBLK #%lu+%lu (#%lu)\n",
  1417.                         dirent_index, secno, pos / 512, secno + pos / 512);
  1418.                   show_dirent (p, 2);
  1419.                 }
  1420.               list = FALSE;
  1421.               if (a_dir)
  1422.                 {
  1423.                   if (p->bAttr & ATTR_DIR)
  1424.                     list = TRUE;
  1425.                   else
  1426.                     {
  1427.                       show_dir (p, name);
  1428.                       quit (0, FALSE);
  1429.                     }
  1430.                 }
  1431.               if (!(p->bFlags & DF_SPEC))
  1432.                 {
  1433.                   plink = PATH_CHAIN_NEW (&link, path, name);
  1434.                   do_fnode (d, ULONG_FROM_FS (p->lsnFNode), plink,
  1435.                             (p->bAttr & ATTR_DIR), parent_fnode,
  1436.                             ULONG_FROM_FS (p->cchFSize),
  1437.                             ULONG_FROM_FS (p->ulEALen), TRUE,
  1438.                             p->bFlags & DF_NEEDEAS, list);
  1439.                 }
  1440.               quit (0, FALSE);
  1441.             }
  1442.  
  1443.           /* There is at least one more component in the path name, so
  1444.              this DIRENT must be a directory. */
  1445.  
  1446.           if (!(p->bAttr & ATTR_DIR))
  1447.             error ("\"%s\" is not a directory",
  1448.                    format_path_chain (path, name));
  1449.  
  1450.           /* Recurse into the directory. */
  1451.  
  1452.           plink = PATH_CHAIN_NEW (&link, path, name);
  1453.           do_fnode (d, ULONG_FROM_FS (p->lsnFNode), plink, TRUE,
  1454.                     parent_fnode, 0, ULONG_FROM_FS (p->ulEALen), TRUE,
  1455.                     p->bFlags & DF_NEEDEAS, FALSE);
  1456.           return;
  1457.         }
  1458.       else
  1459.         {
  1460.           /* The DIRENT's name is greater than the name we are looking
  1461.              for.  If there is a down pointer, recurse into the next
  1462.              level of the B-tree.  Otherwise, there is no such
  1463.              name. */
  1464.  
  1465.           if (!(p->bFlags & DF_BTP))
  1466.             break;
  1467.           do_dirblk (d, ((ULONG *)((const char *)p + length))[-1],
  1468.                      path, parent_fnode, secno,
  1469.                      NULL, NULL, 0, NULL, NULL, FALSE);
  1470.           return;
  1471.         }
  1472.     }
  1473.   error ("\"%s\" not found in \"%s\"",
  1474.          find_comp, format_path_chain (path, NULL));
  1475. }
  1476.  
  1477.  
  1478. #define MAX_DIRBLK_LEVELS       32
  1479.  
  1480. /* Check the down pointer of a DIRENT.  INDEX is the index of the
  1481.    DIRENT, FLAG is zero for a leaf, one for a node.  See do_dirblk()
  1482.    for the remaining arguments. */
  1483.  
  1484. static void check_dirent_down (int *down_ptr, int level, ULONG secno,
  1485.                                const path_chain *path, int index, int flag)
  1486. {
  1487.   if (level < MAX_DIRBLK_LEVELS)
  1488.     {
  1489.       if (down_ptr[level] == -1)
  1490.         down_ptr[level] = flag;
  1491.       else if (down_ptr[level] != flag)
  1492.         dirent_warning (1, "%s down pointer",
  1493.                         secno, path, index, NULL,
  1494.                         flag == 0 ? "Undesired" : "Missing");
  1495.     }
  1496. }
  1497.  
  1498.  
  1499. /* Recurse into the next DIRBLK level for `check' action etc.  See
  1500.    do_dirbkl() for a description of the arguments. */
  1501.  
  1502. static void do_dirblk_recurse (DISKIO *d, const DIRBLK *pdir, ULONG secno,
  1503.                                const path_chain *path, ULONG parent_fnode,
  1504.                                ULONG parent, SORT *psort, int *down_ptr,
  1505.                                int level, int *pglobal_dirent_index,
  1506.                                int *pdotdot, int list)
  1507. {
  1508.   const DIRENT *p;
  1509.   const char *pname;
  1510.   char name[256];
  1511.   int dirent_index;
  1512.   ULONG cpindex, length;
  1513.   size_t pos;
  1514.   path_chain link, *plink;
  1515.  
  1516.   pos = offsetof (DIRBLK, dirblk.dirent);
  1517.   for (dirent_index = 0;; ++dirent_index)
  1518.     {
  1519.       p = check_dirent (pdir, pos, name, TRUE, secno, path, dirent_index);
  1520.       if (p == NULL)
  1521.         break;
  1522.       length = USHORT_FROM_FS (p->cchThisEntry);
  1523.       if (p->bFlags & DF_BTP)
  1524.         {
  1525.           do_dirblk (d, ((ULONG *)((const char *)p + length))[-1],
  1526.                      path, parent_fnode, secno, psort,
  1527.                      down_ptr, level + 1, pglobal_dirent_index, pdotdot,
  1528.                      list);
  1529.           check_dirent_down (down_ptr, level, secno, path,
  1530.                              dirent_index, 1);
  1531.         }
  1532.       else
  1533.         check_dirent_down (down_ptr, level, secno, path, dirent_index, 0);
  1534.       if (!(p->bFlags & DF_END))
  1535.         {
  1536.           if (p->bFlags & DF_SPEC)
  1537.             {
  1538.               pname = "";
  1539.               if (*pdotdot)
  1540.                 dirent_warning (1, "More than one \"..\" entry",
  1541.                                 secno, path, dirent_index, name);
  1542.               else if (*pglobal_dirent_index != 0)
  1543.                 dirent_warning (1, "\"..\" entry is not the first entry",
  1544.                                 secno, path, dirent_index, name);
  1545.               *pdotdot = TRUE;
  1546.             }
  1547.           else
  1548.               pname = name;
  1549.           if (verbose)
  1550.             my_fprintf (prog_file, "%s\n", format_path_chain (path, name));
  1551.           if (a_check && strlen (name) + path_chain_len (path) > 255)
  1552.             dirent_warning (1, "Path name too long",
  1553.                             secno, path, dirent_index, name);
  1554.           cpindex = p->bCodePage & 0x7f;
  1555.           if (cpindex >= code_page_count)
  1556.             dirent_warning (1, "Code page index too big",
  1557.                             secno, path, dirent_index, name);
  1558.           if (compare_fname (psort->name, (const BYTE *)pname,
  1559.                              psort->cpindex, cpindex) > 0)
  1560.             dirent_warning (1, "File names are not in ascending order "
  1561.                             "(\"%s\" vs \"%s\")",
  1562.                             secno, path, dirent_index, NULL,
  1563.                             psort->name, pname);
  1564.           strcpy ((char *)psort->name, pname);
  1565.           psort->cpindex = cpindex;
  1566.           if (a_check)
  1567.             {
  1568.               ULONG t, gap, ace_size, temp_size;
  1569.  
  1570.               t = ULONG_FROM_FS (p->timLastMod);
  1571.               if (t != 0 && t < min_time)
  1572.                 dirent_warning (1, "Modification time is out of range (%lu)",
  1573.                                 secno, path, dirent_index, name, t);
  1574.               t = ULONG_FROM_FS (p->timLastAccess);
  1575.               if (t != 0 && t < min_time)
  1576.                 dirent_warning (1, "Access time is out of range (%lu)",
  1577.                                 secno, path, dirent_index, name, t);
  1578.               t = ULONG_FROM_FS (p->timCreate);
  1579.               if (t != 0 && t < min_time)
  1580.                 dirent_warning (1, "Creation time is out of range (%lu)",
  1581.                                 secno, path, dirent_index, name, t);
  1582.  
  1583.               if (!(p->bFlags & DF_SPEC))
  1584.                 {
  1585.                   if (!is_hpfs_name ((const BYTE *)name))
  1586.                     dirent_warning (1, "Invalid character in file name",
  1587.                                     secno, path, dirent_index, name);
  1588.                   else if (!is_fat_name ((const BYTE *)name)
  1589.                            != !!(p->bAttr & ATTR_NONFAT))
  1590.                     dirent_warning (1, "Incorrect FAT compatibility bit",
  1591.                                     secno, path, dirent_index, name);
  1592.                 }
  1593.               if (p->bAttr & (0x80 | ATTR_LABEL))
  1594.                 dirent_warning (0, "Undefined attribute bit is set",
  1595.                                 secno, path, dirent_index, name);
  1596.  
  1597.               /* The following ACL stuff is based on a few examples;
  1598.                  the meaning of all this is quite unknown. */
  1599.  
  1600.               if (p->bFlags & DF_PERM)
  1601.                 dirent_warning (0, "DF_PERM bit is set -- meaning unknown",
  1602.                                 secno, path, dirent_index, name);
  1603.               if ((p->bFlags & (DF_ACL|DF_XACL)) == DF_XACL)
  1604.                 dirent_warning (0, "DF_XACL is set without DF_ACL",
  1605.                                 secno, path, dirent_index, name);
  1606.               gap = USHORT_FROM_FS (p->cchThisEntry);
  1607.               gap -= (sizeof (DIRENT) + p->cchName - 1);
  1608.               if (p->bFlags & DF_BTP)
  1609.                 gap -= sizeof (ULONG);
  1610.               if (gap > 3 && !(p->bFlags & DF_ACL))
  1611.                 dirent_warning (0, "DF_ACL should be set "
  1612.                                 "(up to %lu bytes of ACEs)",
  1613.                                 secno, path, dirent_index, name, gap);
  1614.               if ((p->bFlex & 7) && !(p->bFlags & DF_ACL))
  1615.                 dirent_warning (0, "DF_ACL should be set (ACE count: %u)",
  1616.                                 secno, path, dirent_index, name, p->bFlex & 7);
  1617.               ace_size = (p->bFlex & 7) * 4;
  1618.               temp_size = ROUND_UP (sizeof (DIRENT) + p->cchName - 1
  1619.                                     + ace_size, 4);
  1620.               if (p->bFlags & DF_BTP)
  1621.                 temp_size += sizeof (ULONG);
  1622.               if (temp_size != USHORT_FROM_FS (p->cchThisEntry))
  1623.                 dirent_warning (0, "ACE count/size mismatch (%u/%lu)",
  1624.                                 secno, path, dirent_index, name,
  1625.                                 p->bFlex & 7, gap);
  1626.               if (p->bFlex & ~7)
  1627.                 dirent_warning (0, "Bits with unknown meaning are set "
  1628.                                 "in bFlex (0x%.2x)",
  1629.                                 secno, path, dirent_index, name,
  1630.                                 p->bFlex & ~7);
  1631.             }
  1632.  
  1633.           if (list)
  1634.             show_dir (p, name);
  1635.           else if (!(p->bFlags & DF_SPEC))
  1636.             {
  1637.               plink = PATH_CHAIN_NEW (&link, path, name);
  1638.               do_fnode (d, ULONG_FROM_FS (p->lsnFNode), plink,
  1639.                         (p->bAttr & ATTR_DIR), parent_fnode,
  1640.                         ULONG_FROM_FS (p->cchFSize),
  1641.                         ULONG_FROM_FS (p->ulEALen), TRUE,
  1642.                         p->bFlags & DF_NEEDEAS, list);
  1643.             }
  1644.         }
  1645.  
  1646.       pos += length;
  1647.       if (p->bFlags & DF_END)
  1648.         break;
  1649.       *pglobal_dirent_index += 1;
  1650.     }
  1651.   if (pos != ULONG_FROM_FS (pdir->dirblk.offulFirstFree))
  1652.     dirblk_warning (1, "Wrong offset to first free byte", secno, path);
  1653. }
  1654.  
  1655.  
  1656. /* Process the DIRBLK starting in sector SECNO.  PATH points to the
  1657.    path name chain of the file or directory.  PARENT_FNODE is the
  1658.    sector number of the FNODE of the directory containing the DIRBLK.
  1659.    PARENT is the sector number of the parent DIRBLK or (for a DIRBLK
  1660.    in the top level) of the directory's FNODE.  PATH points to the
  1661.    path name chain of the directory.  PSORT points to a structure
  1662.    containing a file name which must compare less than (or equal to,
  1663.    for "") the first DIRENT of the current DIRBLK sub-tree.  The
  1664.    structure will be updated to contain the file name of the last
  1665.    DIRENT of this DIRBLK.  DOWN_PTR points to an array recording
  1666.    down-pointer usage.  The array has LEVEL entries.
  1667.    PGLOBAL_DIRENT_INDEX points to an object containing the index of
  1668.    the first DIRENT entry of this DIRBLK sub-tree, relative to the
  1669.    directory.  The object will be updated.  PDOTDOT points to an
  1670.    object recording presence of the ".." entry.  The object will be
  1671.    updated.  List the directory if LIST is true. */
  1672.  
  1673. static void do_dirblk (DISKIO *d, ULONG secno, const path_chain *path,
  1674.                        ULONG parent_fnode, ULONG parent, SORT *psort,
  1675.                        int *down_ptr, int level, int *pglobal_dirent_index,
  1676.                        int *pdotdot, int list)
  1677. {
  1678.   DIRBLK dir;
  1679.  
  1680.   if (a_what && IN_RANGE (what_sector, secno, 4))
  1681.     info ("Sector #%lu: DIRBLK of \"%s\" (+%lu)\n",
  1682.           what_sector, format_path_chain (path, NULL), what_sector - secno);
  1683.   if (have_seen (secno, 4, SEEN_DIRBLK, "DIRBLK"))
  1684.     return;
  1685.   use_sectors (secno, 4, USE_DIRBLK, path);
  1686.   if (secno & 3)
  1687.     dirblk_warning (1, "Sector number is not a multiple of 4", secno, path);
  1688.   read_sec (d, &dir, secno, 4, TRUE);
  1689.   if (ULONG_FROM_FS (dir.dirblk.sig) != DIRBLK_SIG1)
  1690.     {
  1691.       dirblk_warning (1, "Bad signature", secno, path);
  1692.       return;
  1693.     }
  1694.   ++dirblk_total;
  1695.   if (secno < dirband_start || secno > dirband_end)
  1696.     ++dirblk_outside;
  1697.   if (ULONG_FROM_FS (dir.dirblk.lsnThisDir) != secno)
  1698.     dirblk_warning (1, "Wrong self pointer", secno, path);
  1699.   if (ULONG_FROM_FS (dir.dirblk.lsnParent) != parent)
  1700.     dirblk_warning (1, "Wrong parent pointer", secno, path);
  1701.   if (a_check)
  1702.     {
  1703.       if (!(ULONG_FROM_FS (dir.dirblk.culChange) & 1) != (level != 0))
  1704.         dirblk_warning (1, "`top-most' bit is incorrect", secno, path);
  1705.     }
  1706.  
  1707.   /* Show DIRENTs for the `info <number>' action. */
  1708.  
  1709.   if (a_what && IN_RANGE (what_sector, secno, 4))
  1710.     do_dirblk_what (d, &dir, secno, path);
  1711.  
  1712.   /* Handle action which search for a file. */
  1713.  
  1714.   if (a_find && !list)
  1715.     {
  1716.       do_dirblk_find (d, &dir, secno, path, parent_fnode);
  1717.       return;
  1718.     }
  1719.  
  1720.   /* Recurse into the next level of the B-tree. */
  1721.  
  1722.   do_dirblk_recurse (d, &dir, secno, path, parent_fnode, parent, psort,
  1723.                      down_ptr, level, pglobal_dirent_index, pdotdot, list);
  1724. }
  1725.  
  1726.  
  1727. /* Display a warning message for the ALSEC in sector SECNO.  PATH
  1728.    points to the path name chain of the file or directory. */
  1729.  
  1730. static void alsec_warning (int level, const char *fmt, ULONG secno,
  1731.                            const path_chain *path, ...)
  1732. {
  1733.   va_list arg_ptr;
  1734.  
  1735.   warning_prolog (level);
  1736.   my_fprintf (diag_file, "ALSEC #%lu (\"%s\"): ",
  1737.               secno, format_path_chain (path, NULL));
  1738.   va_start (arg_ptr, path);
  1739.   my_vfprintf (diag_file, fmt, arg_ptr);
  1740.   va_end (arg_ptr);
  1741.   fputc ('\n', diag_file);
  1742.   warning_epilog ();
  1743. }
  1744.  
  1745.  
  1746. /* Process the ALSEC in sector SECNO.  PATH points to the path name
  1747.    chain of the file or directory.  PEXP_FILE_SEC points to an object
  1748.    containing the first logical sector number mapped by the ALSEC.
  1749.    The object's value will be incremented by the number of sectors
  1750.    mapped by the ALSEC.  The sector number of the sector following the
  1751.    previous run is passed in the object pointed to by PNEXT_DISK_SEC.
  1752.    The object will be updated to contain the sector number of the
  1753.    sector following the last run.  TOTAL_SECTORS is the number of
  1754.    sectors expected for the object.  PARENT_FNODE is the sector number
  1755.    of the FNODE of the directory containing the object.  PARENT_ALBLK
  1756.    is the sector number of the parent ALSEC or FNODE.  ALSEC_LEVEL
  1757.    contains the current level in the ALSEC tree.  WHAT is USE_FILE,
  1758.    USE_EA, or USE_ACL for file data, extended attributes, or ACL,
  1759.    respectively.  PEXTENTS points to an object counting the number of
  1760.    extents.  The value of that object will be updated.  Show
  1761.    information if SHOW is non-zero.  Copy up to COPY_SIZE bytes of
  1762.    data to the save file.  Read sectors to BUF (of BUF_SIZE bytes) if
  1763.    BUF is non-NULL.
  1764.  
  1765.    Return the height of the ALSEC sub-tree. */
  1766.  
  1767. static int do_alsec (DISKIO *d, ULONG secno, const path_chain *path,
  1768.                      ULONG *pexp_file_sec, ULONG *pnext_disk_sec,
  1769.                      ULONG total_sectors, ULONG parent_fnode,
  1770.                      ULONG parent_alblk, int alsec_level, BYTE what,
  1771.                      ULONG *pextents, int show, ULONG copy_size,
  1772.                      BYTE *buf, ULONG buf_size)
  1773. {
  1774.   HPFS_SECTOR alsec;
  1775.   int height;
  1776.  
  1777.   if (show)
  1778.     info ("ALSEC(%s): #%lu\n", alsec_number, secno);
  1779.   if (a_what && secno == what_sector)
  1780.     info ("Sector #%lu: Allocation sector (ALSEC) for \"%s\"\n",
  1781.           secno, format_path_chain (path, NULL));
  1782.   if (have_seen (secno, 1, SEEN_ALSEC, "ALSEC"))
  1783.     return 1;
  1784.   use_sectors (secno, 1, USE_ALSEC, path);
  1785.   read_sec (d, &alsec, secno, 1, TRUE);
  1786.   if (ULONG_FROM_FS (alsec.alsec.sig) != ALSEC_SIG1)
  1787.     {
  1788.       alsec_warning (1, "Bad signature", secno, path);
  1789.       return 1;
  1790.     }
  1791.   ++alsec_count;
  1792.   if (ULONG_FROM_FS (alsec.alsec.lsnSelf) != secno)
  1793.     alsec_warning (1, "Incorrect self pointer", secno, path);
  1794.   if (ULONG_FROM_FS (alsec.alsec.lsnRent) != parent_alblk)
  1795.     alsec_warning (1, "Incorrect parent pointer", secno, path);
  1796.  
  1797.   height = do_storage (d, secno, &alsec.alsec.alb, 40, path,
  1798.                        pexp_file_sec, pnext_disk_sec, total_sectors,
  1799.                        parent_fnode, alsec_level + 1, what, pextents,
  1800.                        show, copy_size, buf, buf_size);
  1801.   return height + 1;
  1802. }
  1803.  
  1804.  
  1805. /* Display a warning message for the allocation structure in sector
  1806.    SECNO.  PATH points to the path name chain of the file or
  1807.    directory. */
  1808.  
  1809. static void alloc_warning (int level, const char *fmt, ULONG secno,
  1810.                            const path_chain *path, int fnode_flag, ...)
  1811. {
  1812.   va_list arg_ptr;
  1813.  
  1814.   warning_prolog (level);
  1815.   my_fprintf (diag_file, "%s #%lu (\"%s\"): ",
  1816.               fnode_flag ? "FNODE" : "ALSEC",
  1817.               secno, format_path_chain (path, NULL));
  1818.   va_start (arg_ptr, path);
  1819.   my_vfprintf (diag_file, fmt, arg_ptr);
  1820.   va_end (arg_ptr);
  1821.   fputc ('\n', diag_file);
  1822.   warning_epilog ();
  1823. }
  1824.  
  1825.  
  1826. /* Process the allocation structure pointed to by HEADER.  It is in
  1827.    sector SECNO (used for messages only).  The structure contains
  1828.    LEAF_COUNT leaves (the number of nodes is computed from
  1829.    LEAF_COUNT).  PATH points to the path name chain of the file or
  1830.    directory.  PEXP_FILE_SEC points to an object containing the first
  1831.    logical sector number mapped by the allocation structure.  The
  1832.    object's value will be incremented by the number of sectors mapped
  1833.    by the allocation strcuture.  The sector number of the sector
  1834.    following the previous run is passed in the object pointed to by
  1835.    PNEXT_DISK_SEC.  The object will be updated to contain the sector
  1836.    number of the sector following the last run.  TOTAL_SECTORS is the
  1837.    number of sectors expected for the object.  PARENT_FNODE is the
  1838.    sector number of the FNODE of the directory containing the object.
  1839.    ALSEC_LEVEL contains the current level in the ALSEC tree.  WHAT is
  1840.    USE_FILE, USE_EA, or USE_ACL for file data, extended attributes, or
  1841.    ACL, respectively.  PEXTENTS points to an object counting the
  1842.    number of extents.  The value of that object will be updated.  Show
  1843.    information if SHOW is non-zero.  Copy up to COPY_SIZE bytes of
  1844.    data to the save file.  Read sectors to BUF (of BUF_SIZE bytes) if
  1845.    BUF is non-NULL.
  1846.  
  1847.    Return the height of the ALSEC tree. */
  1848.  
  1849. static int do_storage (DISKIO *d, ULONG secno, const ALBLK *header,
  1850.                        ULONG leaf_count, const path_chain *path,
  1851.                        ULONG *pexp_file_sec, ULONG *pnext_disk_sec,
  1852.                        ULONG total_sectors, ULONG parent_fnode,
  1853.                        int alsec_level, BYTE what, ULONG *pextents,
  1854.                        int show, ULONG copy_size, BYTE *buf, ULONG buf_size)
  1855. {
  1856.   const ALLEAF *pleaf = (ALLEAF *)((char *)header + sizeof (ALBLK));
  1857.   const ALNODE *pnode = (ALNODE *)((char *)header + sizeof (ALBLK));
  1858.   ULONG i, j, n, start, count, pos;
  1859.   const char *what_text;
  1860.   int fnode_flag = (leaf_count == 8);
  1861.  
  1862.   if (show)
  1863.     info ("  %s count:                  %u\n",
  1864.           (header->bFlag & ABF_NODE) ? "Node" : "Leaf", header->cUsed);
  1865.  
  1866.   /* Note: Do not check for underflow -- as the root node has a
  1867.      smaller maximum node/leaf count than the other nodes of the tree,
  1868.      it's impossible to make all (non-root) nodes at least half
  1869.      filled. */
  1870.  
  1871.   switch (what)
  1872.     {
  1873.     case USE_EA:
  1874.       what_text = "EA data";
  1875.       break;
  1876.     case USE_FILE:
  1877.       what_text = "file data";
  1878.       break;
  1879.     case USE_ACL:
  1880.       what_text = "ACL";
  1881.       break;
  1882.     default:
  1883.       what_text = "???";
  1884.       break;
  1885.     }
  1886.   if (!(header->bFlag & ABF_FNP) != !(alsec_level == 1))
  1887.     alloc_warning (1, "ABF_FNP bit is wrong (%d)", secno, path, fnode_flag,
  1888.                    !!(header->bFlag & ABF_FNP));
  1889.   n = header->cUsed;
  1890.   if (header->bFlag & ABF_NODE)
  1891.     {
  1892.       ULONG node_count = leaf_count + leaf_count / 2;
  1893.       size_t nlen;
  1894.       int height, max_height;
  1895.  
  1896.       if ((ULONG)header->cFree + (ULONG)header->cUsed != node_count)
  1897.         {
  1898.           alloc_warning (1, "Wrong number of ALNODEs",
  1899.                          secno, path, fnode_flag);
  1900.           if (n > node_count)
  1901.             n = node_count;
  1902.         }
  1903.       if (n * sizeof (ALNODE) + sizeof (ALBLK)
  1904.           != USHORT_FROM_FS (header->oFree))
  1905.         alloc_warning (1, "Offset to free entry is wrong",
  1906.                        secno, path, fnode_flag);
  1907.       nlen = strlen (alsec_number);
  1908.       max_height = 0;
  1909.       for (i = 0; i < n; ++i)
  1910.         {
  1911.           sprintf (alsec_number + nlen, ".%lu", i);
  1912.           height = do_alsec (d, ULONG_FROM_FS (pnode[i].lsnPhys), path,
  1913.                              pexp_file_sec, pnext_disk_sec, total_sectors,
  1914.                              parent_fnode, secno, alsec_level, what,
  1915.                              pextents, show, copy_size, buf, buf_size);
  1916.           if (ULONG_FROM_FS (pnode[i].lsnLog)
  1917.               != (i + 1 == n ? 0xffffffff : *pexp_file_sec))
  1918.             alloc_warning (1, "Wrong file sector in ALNODE (%lu vs. %lu)",
  1919.                            secno, path, fnode_flag,
  1920.                            ULONG_FROM_FS (pnode[i].lsnLog),
  1921.                            (i + 1 == n ? 0xffffffff : *pexp_file_sec));
  1922.           if (i == 0)
  1923.             max_height = height;
  1924.           else
  1925.             {
  1926.               if (height != max_height)
  1927.                 alloc_warning (1, "Unbalanced allocation tree",
  1928.                                secno, path, fnode_flag);
  1929.               if (height > max_height)
  1930.                 max_height = height;
  1931.             }
  1932.         }
  1933.       alsec_number[nlen] = 0;
  1934.       return max_height;
  1935.     }
  1936.   else
  1937.     {
  1938.       if ((ULONG)header->cFree + (ULONG)header->cUsed != leaf_count)
  1939.         {
  1940.           alloc_warning (1, "Wrong number of ALLEAFs",
  1941.                          secno, path, fnode_flag);
  1942.           if (n > leaf_count)
  1943.             n = leaf_count;
  1944.         }
  1945.       if (n * sizeof (ALLEAF) + sizeof (ALBLK)
  1946.           != USHORT_FROM_FS (header->oFree))
  1947.         alloc_warning (1, "Offset to free entry is wrong",
  1948.                        secno, path, fnode_flag);
  1949.       *pextents += n;
  1950.       for (i = 0; i < n; ++i)
  1951.         {
  1952.           start = ULONG_FROM_FS (pleaf[i].lsnPhys);
  1953.           count = ULONG_FROM_FS (pleaf[i].csecRun);
  1954.           if (ULONG_FROM_FS (pleaf[i].lsnLog) != *pexp_file_sec)
  1955.             alloc_warning (1, "Wrong file sector (%lu vs. %lu)",
  1956.                            secno, path, fnode_flag,
  1957.                            ULONG_FROM_FS (pleaf[i].lsnLog), *pexp_file_sec);
  1958.           if (check_pedantic && *pnext_disk_sec != 0
  1959.               && start == *pnext_disk_sec)
  1960.             alloc_warning (0, "Contiguous runs of disk sectors",
  1961.                            secno, path, fnode_flag);
  1962.           *pnext_disk_sec = start + count;
  1963.           if (show)
  1964.             info ("  %c%s in %s (file sector %lu)\n",
  1965.                   toupper (what_text[0]), what_text+1,
  1966.                   format_sector_range (start, count),
  1967.                   ULONG_FROM_FS (pleaf[i].lsnLog));
  1968.           if (a_what && IN_RANGE (what_sector, start, count))
  1969.             info ("Sector #%lu: Sector %lu of %s for \"%s\" (+%lu)\n",
  1970.                   what_sector,
  1971.                   *pexp_file_sec + what_sector - start,
  1972.                   what_text, format_path_chain (path, NULL),
  1973.                   what_sector - start);
  1974.           if (a_check && sectors_per_block > 1 && what == USE_FILE)
  1975.             {
  1976.               /* These criterions have been guessed... */
  1977.               if (count < sectors_per_block
  1978.                   && *pexp_file_sec + count < total_sectors)
  1979.                 alloc_warning (1, "Too fragmented for the `multimedia format'",
  1980.                                secno, path, fnode_flag);
  1981.               if (start & 3)
  1982.                 alloc_warning (1, "Run not properly aligned for the "
  1983.                                "`multimedia format'", secno, path, fnode_flag);
  1984.             }
  1985.           use_sectors (start, count, what, path);
  1986.           pos = *pexp_file_sec * 512;
  1987.           if (buf != NULL)
  1988.             {
  1989.               if ((*pexp_file_sec + count) * 512 > buf_size)
  1990.                 abort ();
  1991.               read_sec (d, buf + pos, start, count, TRUE);
  1992.             }
  1993.           for (j = 0; j < count && pos < copy_size; ++j)
  1994.             {
  1995.               read_sec (d, copy_buf, start, 1, FALSE);
  1996.               fwrite (copy_buf, MIN (copy_size - pos, 512), 1, save_file);
  1997.               if (ferror (save_file))
  1998.                 save_error ();
  1999.               ++start; pos += 512;
  2000.             }
  2001.           *pexp_file_sec += count;
  2002.         }
  2003.       return 0;
  2004.     }
  2005. }
  2006.  
  2007.  
  2008. /* Display a warning message for the FNODE in sector SECNO.  PATH
  2009.    points to the path name chain of the file or directory. */
  2010.  
  2011. static void fnode_warning (int level, const char *fmt, ULONG secno,
  2012.                            const path_chain *path, ...)
  2013. {
  2014.   va_list arg_ptr;
  2015.  
  2016.   warning_prolog (level);
  2017.   my_fprintf (diag_file, "FNODE #%lu (\"%s\"): ",
  2018.               secno, format_path_chain (path, NULL));
  2019.   va_start (arg_ptr, path);
  2020.   my_vfprintf (diag_file, fmt, arg_ptr);
  2021.   va_end (arg_ptr);
  2022.   fputc ('\n', diag_file);
  2023.   warning_epilog ();
  2024. }
  2025.  
  2026.  
  2027. /* Process extended attributes.  BUF points to a buffer containing
  2028.    BUF_SIZE bytes of data.  SECNO is the sector number of the FNODE.
  2029.    PATH is the path name chain for the file or directory.  EA_SIZE is
  2030.    the expected size of the extended attributes.  Ignore EA_SIZE if
  2031.    CHECK_EA_SIZE is FALSE.  EA_NEED is the expected number of `need'
  2032.    EAs.  Display information if SHOW is true. */
  2033.  
  2034. static void do_auxinfo_ea (DISKIO *d, const BYTE *buf, ULONG buf_size,
  2035.                            ULONG secno, const path_chain *path,
  2036.                            ULONG ea_size, int check_ea_size, ULONG ea_need,
  2037.                            int show)
  2038. {
  2039.   ULONG pos, size, need_ea_count, start, count, bytes;
  2040.   ULONG value_size, file_sec, disk_sec, extents;
  2041.   const FEA *pfea;
  2042.   const SPTR *psptr;
  2043.  
  2044.   /* BUF points to a list of FEA structures.  Process them one by
  2045.      one. */
  2046.  
  2047.   pos = 0; size = 0; need_ea_count = 0;
  2048.   while (pos < buf_size)
  2049.     {
  2050.       /* Stop if the FEA structure is not completely inside the
  2051.          buffer. */
  2052.  
  2053.       if (pos + sizeof (FEA) > buf_size)
  2054.         {
  2055.           fnode_warning (1, "Truncated FEA structure", secno, path);
  2056.           break;
  2057.         }
  2058.       pfea = (FEA *)(buf + pos);
  2059.       value_size = USHORT_FROM_FS (pfea->cbValue);
  2060.       if (pos + sizeof (FEA) + pfea->cbName + 1 + value_size > buf_size)
  2061.         {
  2062.           fnode_warning (1, "Truncated FEA structure", secno, path);
  2063.           break;
  2064.         }
  2065.  
  2066.       /* The name of an EA must be terminated by a null character. */
  2067.  
  2068.       if (buf[pos + sizeof (FEA) + pfea->cbName] != 0)
  2069.         fnode_warning (1, "Name of extended attribute not terminated by "
  2070.                        "a null character", secno, path);
  2071.  
  2072.       /* Count the number of `need' EAs.  After processing all FEA
  2073.          structures, we'll compare the actual count to the expected
  2074.          count (from the FNODE). */
  2075.  
  2076.       if (pfea->fEA & FEA_NEEDEA)
  2077.         ++need_ea_count;
  2078.  
  2079.       /* There are three methods for storing the value of an extended
  2080.          attribute.  The fEA member of the FEA structure tells us
  2081.          which one is used for the current EA.  Note that bit 7
  2082.          (FEA_NEEDEA) is used to mark `need' EAs. */
  2083.  
  2084.       if ((pfea->fEA & 0x7f) == 0x00)
  2085.         {
  2086.           /* Method 1: The EA value is stored inline, directly
  2087.              following the FEA structure. */
  2088.  
  2089.           if (show_eas >= 1)
  2090.             info ("  Extended attribute %s (%lu bytes) is stored inline\n",
  2091.                   format_ea_name (pfea), value_size);
  2092.           size += sizeof (FEA) + pfea->cbName + 1 + value_size;
  2093.           if (show_frag)
  2094.             extents_stat (&ea_extents, 0);
  2095.         }
  2096.       else if ((pfea->fEA & 0x7f) == 0x01)
  2097.         {
  2098.           /* Method 2: The EA value is stored externally, in one run
  2099.              of sectors pointed to by a SPTR structure directly
  2100.              following the FEA structure. */
  2101.  
  2102.           if (value_size != sizeof (SPTR))
  2103.             fnode_warning (1, "Incorrect size of FEA structure", secno, path);
  2104.           else
  2105.             {
  2106.               psptr = (const SPTR *)(buf + pos + sizeof (FEA)
  2107.                                      + pfea->cbName + 1);
  2108.               start = ULONG_FROM_FS (psptr->lsn);
  2109.               bytes = ULONG_FROM_FS (psptr->cbRun);
  2110.               count = DIVIDE_UP (bytes, 512);
  2111.               if (show_eas >= 1)
  2112.                 info ("  Extended attribute %s (%lu bytes) is stored "
  2113.                       "in %s\n",
  2114.                       format_ea_name (pfea), bytes,
  2115.                       format_sector_range (start, count));
  2116.               else if (show)
  2117.                 info ("  Extended attributes in %s\n",
  2118.                       format_sector_range (start, count));
  2119.               if (a_what && IN_RANGE (what_sector, start, count))
  2120.                 info ("Sector #%lu: EA data for \"%s\"\n",
  2121.                       what_sector, format_path_chain (path, NULL));
  2122.               use_sectors (start, count, USE_EA, path);
  2123.               size += sizeof (FEA) + pfea->cbName + 1 + bytes;
  2124.               if (show_frag)
  2125.                 extents_stat (&ea_extents, 1);
  2126.             }
  2127.         }
  2128.       else if ((pfea->fEA & 0x7f) == 0x03)
  2129.         {
  2130.           /* Method 3: The EA value is stored externally, in several
  2131.              runs of sectors, mapped by an ALSEC which is pointed to
  2132.              by a SPTR structure directly following the FEA
  2133.              structure. */
  2134.  
  2135.           if (value_size != sizeof (SPTR))
  2136.             fnode_warning (1, "Incorrect size of FEA structure", secno, path);
  2137.           else
  2138.             {
  2139.               psptr = (const SPTR *)(buf + pos + sizeof (FEA)
  2140.                                      + pfea->cbName + 1);
  2141.               start = ULONG_FROM_FS (psptr->lsn);
  2142.               bytes = ULONG_FROM_FS (psptr->cbRun);
  2143.               if (show_eas >= 1)
  2144.                 info ("  Extended attribute %s (%lu bytes) is stored in "
  2145.                       "sectors mapped by ALSEC #%lu\n",
  2146.                       format_ea_name (pfea), bytes, start);
  2147.  
  2148.               /* Process the ALSEC. */
  2149.  
  2150.               file_sec = 0; disk_sec = 0; extents = 0;
  2151.               strcpy (alsec_number, "0");
  2152.               do_alsec (d, start, path, &file_sec, &disk_sec,
  2153.                         DIVIDE_UP (bytes, 512), secno, secno,
  2154.                         0, USE_EA, &extents, show, 0, NULL, 0);
  2155.               if (show_eas >= 1)
  2156.                 info ("  Number of sectors for this EA: %lu\n", file_sec);
  2157.  
  2158.               /* Check the number of sectors.  There is a bug in
  2159.                  HPFS.IFS: It never assigns more than 40 extents (that
  2160.                  is, one ALSEC), truncating EAs. */
  2161.  
  2162.               if (file_sec * 512 < bytes)
  2163.                 fnode_warning (1, "Not enough sectors allocated for EA %s",
  2164.                                secno, path, format_ea_name (pfea));
  2165.               if (file_sec > DIVIDE_UP (bytes, 512))
  2166.                 fnode_warning (1, "Too many sectors allocated for EA %s (%lu)",
  2167.                                secno, path, format_ea_name (pfea),
  2168.                                file_sec - DIVIDE_UP (bytes, 512));
  2169.  
  2170.               size += sizeof (FEA) + pfea->cbName + 1 + bytes;
  2171.               if (show_frag)
  2172.                 extents_stat (&ea_extents, extents);
  2173.             }
  2174.         }
  2175.       else
  2176.         {
  2177.           /* No other methods are known. */
  2178.  
  2179.           fnode_warning (1, "Invalid FEA flag 0x%.2x for extended "
  2180.                          "attribute %s", secno, path, pfea->fEA,
  2181.                          format_ea_name (pfea));
  2182.           break;
  2183.         }
  2184.       pos += sizeof (FEA) + pfea->cbName + 1 + value_size;
  2185.     }
  2186.  
  2187.   /* Compare the actual EA size and `need' EA count to the values
  2188.      stored in the FNODE. */
  2189.  
  2190.   if (check_ea_size && size != ea_size)
  2191.     fnode_warning (1, "Incorrect EA size (%lu vs. %lu)",
  2192.                    secno, path, size, ea_size);
  2193.   if (need_ea_count != ea_need)
  2194.     fnode_warning (1, "Incorrect number of `need' EAs (%lu vs. %lu)",
  2195.                    secno, path, need_ea_count, ea_need);
  2196. }
  2197.  
  2198.  
  2199. /* Process the data pointed to by an AUXINFO structure (for EAs or
  2200.    ACL).  BUF points to a buffer containing BUF_SIZE bytes of data.
  2201.    WHAT indicates whether the AUXINFO structure is for EAs or an ACL.
  2202.    SECNO is the sector number of the FNODE.  PATH is the path name
  2203.    chain for the file or directory.  EA_SIZE is the expected size of
  2204.    the extended attributes.  Ignore EA_SIZE if CHECK_EA_SIZE is FALSE.
  2205.    EA_NEED is the expected number of `need' EAs.  Display information
  2206.    if SHOW is true. */
  2207.  
  2208. static void do_auxinfo_buf (DISKIO *d, const BYTE *buf, ULONG buf_size,
  2209.                             BYTE what, ULONG secno, const path_chain *path,
  2210.                             ULONG ea_size, int check_ea_size, ULONG ea_need,
  2211.                             int show)
  2212. {
  2213.   switch (what)
  2214.     {
  2215.     case USE_EA:
  2216.       do_auxinfo_ea (d, buf, buf_size, secno, path, ea_size, check_ea_size,
  2217.                      ea_need, show);
  2218.       break;
  2219.     case USE_ACL:
  2220.       /* I do not yet know anything about ACLs. */
  2221.       break;
  2222.     }
  2223. }
  2224.  
  2225.  
  2226. /* Process the AUXINFO structure (for EAs or ACL) pointed to by PAI.
  2227.    If the structure indicates that the data is stored inside the
  2228.    FNODE, take the data from PFNODE, starting at offset BASE.  SECNO
  2229.    is the sector number of the FNODE.  PATH is the path name chain for
  2230.    the file or directory.  WHAT indicates whether the AUXINFO
  2231.    structure is for EAs or an ACL.  EA_SIZE is the expected size of
  2232.    the extended attributes, EA_NEED is the expected number of `need'
  2233.    EAs.  Display information if SHOW is true. */
  2234.  
  2235. static void do_auxinfo (DISKIO *d, const FNODE *pfnode, const AUXINFO *pai,
  2236.                         unsigned base, ULONG secno, const path_chain *path,
  2237.                         BYTE what, ULONG ea_size, int check_ea_size,
  2238.                         ULONG ea_need, int show)
  2239. {
  2240.   BYTE *buf;
  2241.   ULONG buf_size, file_sec, disk_sec, extents, run_length, start, fnode_length;
  2242.  
  2243.   /* Fetch some values from the AUXINFO structure. */
  2244.  
  2245.   run_length = ULONG_FROM_FS (pai->sp.cbRun);
  2246.   start = ULONG_FROM_FS (pai->sp.lsn);
  2247.   fnode_length = USHORT_FROM_FS (pai->usFNL);
  2248.  
  2249.   /* EAs and ACLs are either stored entirely inside the FNODE or
  2250.      entirely externally.  Having data both inside the FNODE and
  2251.      externally is an error. */
  2252.  
  2253.   if (run_length != 0 && fnode_length != 0)
  2254.     fnode_warning (1, "Both internal and external %s",
  2255.                    secno, path, (what == USE_EA ? "EA" : "ACL"));
  2256.  
  2257.   /* No buffer has been allocated so far. */
  2258.  
  2259.   buf = NULL; buf_size = 0;
  2260.  
  2261.   /* Data is stored outside the FNODE if pai->sp.cbRun is non-zero. */
  2262.  
  2263.   if (run_length != 0)
  2264.     {
  2265.       buf_size = run_length;
  2266.  
  2267.       /* If pai->bDat is non-zero, pai->sp.lsn points to an ALSEC.
  2268.          Otherwise it directly points to the first data sector. */
  2269.  
  2270.       if (pai->bDat)
  2271.         {
  2272.           /* The data is mapped by an ALSEC. */
  2273.  
  2274.           if (a_where)
  2275.             {
  2276.               if (what == USE_EA)
  2277.                 info ("  Extended attributes (FEA structures, %lu bytes) "
  2278.                       "in sectors mapped by ALSEC #%lu\n",
  2279.                       run_length, start);
  2280.               else
  2281.                 info ("  ACL (%lu bytes) in sectors mapped by ALSEC #%lu\n",
  2282.                       run_length, start);
  2283.             }
  2284.           if (buf_size <= 0x100000)
  2285.             buf = malloc (ROUND_UP (buf_size, 512));
  2286.           if (buf != NULL)
  2287.             memset (buf, 0, buf_size);
  2288.           file_sec = 0; disk_sec = 0; extents = 0;
  2289.           strcpy (alsec_number, "0");
  2290.           do_alsec (d, start, path, &file_sec, &disk_sec,
  2291.                     DIVIDE_UP (run_length, 512), secno, secno, 0,
  2292.                     what, &extents, show, 0, buf, ROUND_UP (buf_size, 512));
  2293.           if (file_sec * 512 < run_length)
  2294.             fnode_warning (1, "Not enough sectors allocated for %s",
  2295.                            secno, path, (what == USE_EA ? "EAs" : "ACLs"));
  2296.           if (file_sec > DIVIDE_UP (run_length, 512))
  2297.             fnode_warning (1, "Too many sectors allocated for %s (%lu)",
  2298.                            secno, path, (what == USE_EA ? "EAs" : "ACLs"),
  2299.                            file_sec - DIVIDE_UP (run_length, 512));
  2300.         }
  2301.       else
  2302.         {
  2303.           /* The data is stored in one run of sectors. */
  2304.  
  2305.           ULONG count;
  2306.  
  2307.           count = DIVIDE_UP (run_length, 512);
  2308.           if (a_where)
  2309.             {
  2310.               if (what == USE_EA)
  2311.                 info ("  Extended attributes (FEA structures, %lu bytes) "
  2312.                       "in %s\n",
  2313.                       run_length, format_sector_range (start, count));
  2314.               else
  2315.                 info ("  ACL (%lu bytes) in %s\n",
  2316.                       run_length, format_sector_range (start, count));
  2317.             }
  2318.  
  2319.           if (a_what && IN_RANGE (what_sector, start, count))
  2320.             {
  2321.               if (what == USE_EA)
  2322.                 info ("Sector #%lu: Extended attributes (FEA structures) for "
  2323.                       "\"%s\" (+%lu)\n",
  2324.                       what_sector, format_path_chain (path, NULL),
  2325.                       what_sector - start);
  2326.               else
  2327.                 info ("Sector #%lu: ACL for \"%s\" (+%lu)\n",
  2328.                       what_sector, format_path_chain (path, NULL),
  2329.                       what_sector - start);
  2330.             }
  2331.           use_sectors (start, count, what, path);
  2332.           if (buf_size <= 0x100000)
  2333.             {
  2334.               buf = xmalloc (count * 512);
  2335.               read_sec (d, buf, start, count, TRUE);
  2336.             }
  2337.         }
  2338.     }
  2339.   else if (fnode_length != 0)
  2340.     {
  2341.       /* The data is stored inside the FNODE. */
  2342.  
  2343.       if (a_where)
  2344.         {
  2345.           if (what == USE_EA)
  2346.             info ("  Extended attributes (FEA structures, %lu bytes at 0x%x) "
  2347.                   "in FNODE #%lu\n", fnode_length, base, secno);
  2348.           else
  2349.             info ("  ACL (%lu bytes at 0x%x) in FNODE #%lu\n",
  2350.                   fnode_length, base, secno);
  2351.         }
  2352.       if (base < offsetof (FNODE, abFree))
  2353.         fnode_warning (1, "%s offset invalid", secno, path,
  2354.                        (what == USE_EA ? "EA" : "ACL"));
  2355.       else if (base + fnode_length > 512)
  2356.         fnode_warning (1, "%s beyond end of FNODE", secno, path,
  2357.                        (what == USE_EA ? "EA list" : "ACL"));
  2358.       else
  2359.         do_auxinfo_buf (d, (const BYTE *)pfnode + base, fnode_length,
  2360.                         what, secno, path, ea_size, check_ea_size, ea_need,
  2361.                         show);
  2362.     }
  2363.  
  2364.   /* If we have copied the data to a buffer, call do_auxinfo_buf() on
  2365.      that buffer.  (For data stored inside the FNODE, do_auxinfo_buf()
  2366.      has already been called above, without allocating a buffer.) */
  2367.  
  2368.   if (buf_size != 0)
  2369.     {
  2370.       if (buf == NULL)
  2371.         fnode_warning (1, "%s too big for examination", secno, path,
  2372.                        (what == USE_EA ? "EAs" : "ACL"));
  2373.       else
  2374.         {
  2375.           do_auxinfo_buf (d, buf, buf_size, what, secno, path,
  2376.                           ea_size, check_ea_size, ea_need, show);
  2377.           free (buf);
  2378.         }
  2379.     }
  2380. }
  2381.  
  2382.  
  2383. /* Process the FNODE in sector SECNO.  PATH points to the path name
  2384.    chain for the file or directory.  DIR_FLAG is true if the FNODE
  2385.    belongs to a directory.  PARENT_FNODE is the sector number of the
  2386.    FNODE of the directory containing the object.  FILE_SIZE is the
  2387.    size of the file.  EA_SIZE is the total size of the extended
  2388.    attributes of the file or directory.  Ignore EA_SIZE if
  2389.    CHECK_EA_SIZE is FALSE (the root directory is the only object for
  2390.    which EA_SIZE is unknown).  NEED_EAS is non-zero if the object has
  2391.    `need' EAs.  List the directory if LIST is true. */
  2392.  
  2393. static void do_fnode (DISKIO *d, ULONG secno, const path_chain *path,
  2394.                       int dir_flag, ULONG parent_fnode, ULONG file_size,
  2395.                       ULONG ea_size, int check_ea_size, int need_eas, int list)
  2396. {
  2397.   HPFS_SECTOR fnode;
  2398.   ULONG file_sec, disk_sec, extents, fn_fsize, i;
  2399.   size_t name_len;
  2400.   int show, found, height;
  2401.  
  2402.   found = (a_find && *find_path == 0);
  2403.   show = (found && a_where);
  2404.   if (show)
  2405.     info ("FNODE: #%lu\n", secno);
  2406.   if (a_what && secno == what_sector)
  2407.     {
  2408.       info ("Sector #%lu: FNODE for \"%s\"\n",
  2409.             secno, format_path_chain (path, NULL));
  2410.       show = TRUE;
  2411.     }
  2412.   if (have_seen (secno, 1, SEEN_FNODE, "FNODE"))
  2413.     return;
  2414.   use_sectors (secno, 1, USE_FNODE, path);
  2415.   read_sec (d, &fnode, secno, 1, TRUE);
  2416.   if (ULONG_FROM_FS (fnode.fnode.sig) != FNODE_SIG1)
  2417.     {
  2418.       fnode_warning (1, "Bad signature", secno, path);
  2419.       if (found)
  2420.         quit (0, FALSE);
  2421.       return;
  2422.     }
  2423.   if (dir_flag)
  2424.     ++dir_count;
  2425.   else
  2426.     ++file_count;
  2427.   fn_fsize = ULONG_FROM_FS (fnode.fnode.fst.ulVLen);
  2428.   if (!(fnode.fnode.bFlag & FNF_DIR) != !dir_flag)
  2429.     fnode_warning (1, "Incorrect directory bit", secno, path);
  2430.   if (ULONG_FROM_FS (fnode.fnode.lsnContDir) != parent_fnode)
  2431.     fnode_warning (1, "Wrong pointer to containing directory", secno, path);
  2432.   if (a_check)
  2433.     {
  2434.       if ((ULONG_FROM_FS (fnode.fnode.ulRefCount) == 0) != !need_eas)
  2435.         fnode_warning (1, "Need-EA bit of DIRENT is wrong", secno, path);
  2436.       name_len = strlen (path->name);
  2437.       if (fnode.fnode.achName[0] != name_len
  2438.           && memcmp (fnode.fnode.achName, path->name, MIN (name_len, 16)) == 0)
  2439.         fnode_warning (0, "Truncated name mangled by OS/2 2.0 bug",
  2440.                        secno, path);
  2441.       else if (fnode.fnode.achName[0] != name_len)
  2442.         fnode_warning (1, "Wrong full name length (%lu vs. %lu)",
  2443.                        secno, path, (ULONG)fnode.fnode.achName[0],
  2444.                        (ULONG)name_len);
  2445.       else if (memcmp (fnode.fnode.achName+1, path->name,
  2446.                        MIN (name_len, 15)) != 0)
  2447.         fnode_warning (1, "Wrong truncated name", secno, path);
  2448.       if (!dir_flag && file_size != fn_fsize)
  2449.         fnode_warning (1, "File size does not match DIRENT", secno, path);
  2450.       if (check_pedantic)
  2451.         {
  2452.           for (i = 0; i < sizeof (fnode.fnode.abSpare); ++i)
  2453.             if (fnode.fnode.abSpare[i] != 0)
  2454.               fnode_warning (0, "abSpare[%lu] is 0x%.2x", secno, path,
  2455.                              i, fnode.fnode.abSpare[i]);
  2456.         }
  2457.     }
  2458.  
  2459.   if (show)
  2460.     {
  2461.       info ("  Flags:                       0x%.2x", fnode.fnode.bFlag);
  2462.       if (fnode.fnode.bFlag & FNF_DIR)
  2463.         info (" dir");
  2464.       info ("\n");
  2465.       info ("  Size of file:                %lu\n", fn_fsize);
  2466.       info ("  Number of `need' EAs:        %lu\n",
  2467.             ULONG_FROM_FS (fnode.fnode.ulRefCount));
  2468.       info ("  Offset of first ACE:         %u\n",
  2469.             USHORT_FROM_FS (fnode.fnode.usACLBase));
  2470.       info ("  ACL size in FNODE:           %u\n",
  2471.             USHORT_FROM_FS (fnode.fnode.aiACL.usFNL));
  2472.       info ("  External ACL size:           %lu\n",
  2473.             ULONG_FROM_FS (fnode.fnode.aiACL.sp.cbRun));
  2474.     }
  2475.  
  2476.   if (dir_flag)
  2477.     {
  2478.       if (show)
  2479.         info ("  Root DIRBLK sector:          #%lu\n",
  2480.               ULONG_FROM_FS (fnode.fnode.fst.a.aall[0].lsnPhys));
  2481.       if (a_copy && found)
  2482.         error ("Directories cannot be copied");
  2483.       if (a_find && !found && !list)
  2484.         {
  2485.           const char *pdelim;
  2486.           size_t len;
  2487.  
  2488.           pdelim = strchr (find_path, '\\');
  2489.           if (pdelim == NULL)
  2490.             len = strlen (find_path);
  2491.           else
  2492.             len = pdelim - find_path;
  2493.           if (len > 255)
  2494.             error ("Path name component too long");
  2495.           memcpy (find_comp, find_path, len);
  2496.           find_comp[len] = 0;
  2497.           find_path += len;
  2498.           if (*find_path == '\\')
  2499.             {
  2500.               ++find_path;
  2501.               if (*find_path == 0)
  2502.                 error ("Trailing backslash");
  2503.             }
  2504.         }
  2505.       if (!found || list)
  2506.         {
  2507.           SORT sort;
  2508.           int index, dotdot, i;
  2509.           int down_ptr[MAX_DIRBLK_LEVELS];
  2510.  
  2511.           sort.name[0] = 0;
  2512.           sort.cpindex = code_page_count;
  2513.           index = 0; dotdot = FALSE;
  2514.           for (i = 0; i < MAX_DIRBLK_LEVELS; ++i)
  2515.             down_ptr[i] = -1; /* Existence of down pointer is unknown */
  2516.           do_dirblk (d,
  2517.                      ULONG_FROM_FS (fnode.fnode.fst.a.aall[0].lsnPhys),
  2518.                      path, secno, secno, &sort, down_ptr, 0, &index, &dotdot,
  2519.                      list);
  2520.           if (!dotdot)
  2521.             warning (1, "Missing \"..\" entry in directory \"%s\"",
  2522.                      format_path_chain (path, NULL));
  2523.         }
  2524.       if (a_find && !found)
  2525.         error ("\"%s\" not found in \"%s\"",
  2526.                find_comp, format_path_chain (path, NULL));
  2527.     }
  2528.   else
  2529.     {
  2530.       file_sec = 0; disk_sec = 0; extents = 0;
  2531.       alsec_number[0] = 0;
  2532.       height = do_storage (d, secno, &fnode.fnode.fst.alb, 8, path,
  2533.                            &file_sec, &disk_sec, DIVIDE_UP (fn_fsize, 512),
  2534.                            secno, 0, USE_FILE, &extents,
  2535.                            show, found && a_copy ? fn_fsize : 0, NULL, 0);
  2536.       if (show)
  2537.         {
  2538.           info ("  Allocation tree height:      %d\n", height);
  2539.           info ("  Number of sectors:           %lu\n", file_sec);
  2540.           info ("  Number of extents:           %lu\n", extents);
  2541.         }
  2542.       if (show_frag)
  2543.         extents_stat (&file_extents, extents);
  2544.       if (file_sec * 512 < fn_fsize)
  2545.         fnode_warning (1, "Not enough sectors allocated", secno, path);
  2546.       if (file_sec > DIVIDE_UP (fn_fsize, 512))
  2547.         fnode_warning (1, "Too many sectors allocated (%lu)",
  2548.                        secno, path, file_sec - DIVIDE_UP (fn_fsize, 512));
  2549.     }
  2550.  
  2551.   /* Extended attributes are stored in the FNODE.  ACL entries are
  2552.      stored first (at offset usACLBase), followed by the extended
  2553.      attributes. */
  2554.  
  2555.   do_auxinfo (d, &fnode.fnode, &fnode.fnode.aiEA,
  2556.               (USHORT_FROM_FS (fnode.fnode.usACLBase)
  2557.                + USHORT_FROM_FS (fnode.fnode.aiACL.usFNL)),
  2558.               secno, path, USE_EA, ea_size, check_ea_size,
  2559.               ULONG_FROM_FS (fnode.fnode.ulRefCount), show);
  2560.  
  2561.   do_auxinfo (d, &fnode.fnode, &fnode.fnode.aiACL,
  2562.               USHORT_FROM_FS (fnode.fnode.usACLBase),
  2563.               secno, path, USE_ACL, 0, FALSE, 0, show);
  2564.  
  2565.   if (found)
  2566.     {
  2567.       if (a_copy)
  2568.         save_close ();
  2569.       quit (0, TRUE);
  2570.     }
  2571. }
  2572.  
  2573.  
  2574. /* Complain about sectors which are used but marked unallocated.
  2575.    Optionally complain about sectors which are not in use but marked
  2576.    allocated. */
  2577.  
  2578. static void check_alloc (void)
  2579. {
  2580.   ULONG i, start, count;
  2581.   BYTE start_what, first;
  2582.   const path_chain *start_path;
  2583.  
  2584.   /* List used sectors not marked as allocated. */
  2585.  
  2586.   i = 0; first = TRUE;
  2587.   while (i < total_sectors)
  2588.     {
  2589.       if (usage_vector[i] != USE_EMPTY && !ALLOCATED (i))
  2590.         {
  2591.           start = i; start_what = usage_vector[i];
  2592.           start_path = path_vector != NULL ? path_vector[i] : NULL;
  2593.           do
  2594.             {
  2595.               ++i;
  2596.             } while (i < total_sectors
  2597.                      && usage_vector[i] != USE_EMPTY && !ALLOCATED (i)
  2598.                      && usage_vector[i] == start_what
  2599.                      && ((path_vector != NULL ? path_vector[i] : NULL)
  2600.                          == start_path));
  2601.           if (first)
  2602.             {
  2603.               warning (1, "There are used sectors which are not marked "
  2604.                        "as allocated:");
  2605.               first = FALSE;
  2606.             }
  2607.           warning (1, "Used (%s) but not marked as allocated: %s",
  2608.                    sec_usage (start_what),
  2609.                    format_sector_range (start, i - start));
  2610.           if (start_path != NULL)
  2611.             warning_cont ("File: \"%s\"",
  2612.                           format_path_chain (start_path, NULL));
  2613.         }
  2614.       else
  2615.         ++i;
  2616.     }
  2617.  
  2618.   /* List unused sectors marked as allocated. */
  2619.  
  2620.   i = 0; count = 0;
  2621.   while (i < total_sectors)
  2622.     {
  2623.       if (usage_vector[i] == USE_EMPTY && ALLOCATED (i))
  2624.         {
  2625.           start = i;
  2626.           do
  2627.             {
  2628.               ++i;
  2629.             } while (i < total_sectors
  2630.                      && usage_vector[i] == USE_EMPTY && ALLOCATED (i));
  2631.           if (check_unused)
  2632.             warning (0, "Unused but marked as allocated: %s",
  2633.                      format_sector_range (start, i - start));
  2634.           count += i - start;
  2635.           if (IN_RANGE (18, start, i - start))
  2636.             count -= 1;
  2637.           if (IN_RANGE (19, start, i - start))
  2638.             count -= 1;
  2639.         }
  2640.       else
  2641.         ++i;
  2642.     }
  2643.   if (count == 1)
  2644.     warning (0, "The file system has 1 lost sector");
  2645.   else if (count > 1)
  2646.     warning (0, "The file system has %lu lost sectors", count);
  2647. }
  2648.  
  2649.  
  2650. /* Process the DIRBLK band bitmap starting in sector BSECNO.  The
  2651.    bitmap describes COUNT DIRBLKs starting at sector number START. */
  2652.  
  2653. static void do_dirblk_bitmap (DISKIO *d, ULONG bsecno, ULONG start,
  2654.                               ULONG count)
  2655. {
  2656.   ULONG sectors, i, dsecno;
  2657.   BYTE bitmap[2048];
  2658.  
  2659.   /* Compute the number of sectors used for the DIRBLK bitmap. */
  2660.  
  2661.   sectors = DIVIDE_UP (count, 512 * 8);
  2662.  
  2663.   /* The DIRBLK band bitmap always occupies 4 sectors. */
  2664.  
  2665.   if (sectors > 4)
  2666.     {
  2667.       warning (1, "DIRBLK band too big\n");
  2668.       sectors = 4;
  2669.     }
  2670.   read_sec (d, bitmap, bsecno, sectors, TRUE);
  2671.  
  2672.   /* Compare the bitmap to our usage_vector[]. */
  2673.  
  2674.   dsecno = start;
  2675.   for (i = 0; i < count; ++i)
  2676.     {
  2677.       if (BITSETP (bitmap, i))
  2678.         {
  2679.           if (usage_vector[dsecno] != USE_BANDDIRBLK)
  2680.             warning (1, "Sector #%lu is marked available in the "
  2681.                      "DIRBLK bitmap, but is used as %s\n",
  2682.                      dsecno, sec_usage (usage_vector[dsecno]));
  2683.         }
  2684.       else
  2685.         {
  2686.           if (usage_vector[dsecno] != USE_DIRBLK)
  2687.             warning (1, "Sector #%lu is marked used in the DIRBLK bitmap, "
  2688.                      "but is used as %s\n",
  2689.                      dsecno, sec_usage (usage_vector[dsecno]));
  2690.         }
  2691.       dsecno += 4;
  2692.     }
  2693. }
  2694.  
  2695.  
  2696. /* Check the spare DIRBLKs.  LIST points to an array of COUNT sector
  2697.    numbers (in HPFS representation). */
  2698.  
  2699. static void check_sparedirblk (const ULONG *list, ULONG total, ULONG free)
  2700. {
  2701.   ULONG i, secno;
  2702.  
  2703.   for (i = free; i < total; ++i)
  2704.     {
  2705.       secno = ULONG_FROM_FS (list[i]);
  2706.       if (secno < total_sectors && usage_vector[secno] != USE_DIRBLK)
  2707.         warning (1, "Spare DIRBLK #%lu is not used for a DIRBLK", secno);
  2708.     }
  2709. }
  2710.  
  2711.  
  2712. /* Build a time stamp for year D, month M, day D. */
  2713.  
  2714. static ULONG make_time (int y, int m, int d)
  2715. {
  2716.   struct tm tm;
  2717.  
  2718.   tm.tm_sec = 0; tm.tm_min = 0; tm.tm_hour = 0;
  2719.   tm.tm_mday = d; tm.tm_mon = m - 1; tm.tm_year = y - 1900;
  2720.   tm.tm_isdst = 0;
  2721.   return (ULONG)mktime (&tm);
  2722. }
  2723.  
  2724.  
  2725. /* Process an HPFS volume. */
  2726.  
  2727. void do_hpfs (DISKIO *d)
  2728. {
  2729.   HPFS_SECTOR superb;
  2730.   HPFS_SECTOR spareb, spareb_tmp;
  2731.   ULONG i, n, superb_chksum, spareb_chksum;
  2732.   ULONG dirband_sectors;
  2733.  
  2734.   if (a_what && what_cluster_flag)
  2735.     error ("Cluster numbers not supported on HPFS");
  2736.  
  2737.   min_time = make_time (1980, 1, 1);
  2738.   alloc_ready = FALSE;
  2739.  
  2740.   /* All structures of HPFS are anchored in the Superblock (LSN 16)
  2741.      and Spare block (LSN 17) sectors. */
  2742.  
  2743.   /* Superblock. */
  2744.  
  2745.   read_sec (d, &superb, 16, 1, TRUE);
  2746.   if (ULONG_FROM_FS (superb.superb.sig1) != SUPER_SIG1
  2747.       || ULONG_FROM_FS (superb.superb.sig2) != SUPER_SIG2)
  2748.     error ("Invalid signature of superblock -- this is not an HPFS partition");
  2749.  
  2750.   /* Spare block. */
  2751.  
  2752.   read_sec (d, &spareb, 17, 1, TRUE);
  2753.   if (ULONG_FROM_FS (spareb.spareb.sig1) != SPARE_SIG1
  2754.       || ULONG_FROM_FS (spareb.spareb.sig2) != SPARE_SIG2)
  2755.     error ("Invalid signature of spare block");
  2756.  
  2757.   /* Compute and check the total number of sectors. */
  2758.  
  2759.   total_sectors = ULONG_FROM_FS (superb.superb.culSectsOnVol);
  2760.   if (a_what && what_sector >= total_sectors)
  2761.     warning (0, "Sector number #%lu is too big", what_sector);
  2762.   if (diskio_type (d) == DIO_DISK && total_sectors > diskio_total_sectors (d))
  2763.     warning (1, "HPFS extends beyond end of partition indicated by BPB");
  2764.  
  2765.   /* Set the block size.  The meaning of bAlign[1] is guessed. */
  2766.  
  2767.   sectors_per_block = 1;
  2768.   if (superb.superb.bFuncVersion == 4)
  2769.     sectors_per_block = 1 << spareb.spareb.bAlign[1];
  2770.  
  2771.   /* Allocate usage vector.  Initially, all sectors are unused. */
  2772.  
  2773.   usage_vector = (BYTE *)xmalloc (total_sectors);
  2774.   memset (usage_vector, USE_EMPTY, total_sectors);
  2775.  
  2776.   /* Allocate `have seen' vector which is used for avoiding loops.
  2777.      Initially, no sector has been seen. */
  2778.  
  2779.   seen_vector = (BYTE *)xmalloc (total_sectors);
  2780.   memset (seen_vector, 0, total_sectors);
  2781.  
  2782.   /* Allocate vector of path chains for improving error messages.
  2783.      Note that the following condition must match the condition in the
  2784.      PATH_CHAIN_NEW macro! */
  2785.  
  2786.   if (a_check && plenty_memory)
  2787.     {
  2788.       path_vector = xmalloc (total_sectors * sizeof (*path_vector));
  2789.       for (i = 0; i < total_sectors; ++i)
  2790.         path_vector[i] = NULL;
  2791.     }
  2792.   else
  2793.     path_vector = NULL;
  2794.  
  2795.   code_page_count = ULONG_FROM_FS (spareb.spareb.culCP);
  2796.  
  2797.   /* Compute the checksums. */
  2798.  
  2799.   superb_chksum = chksum (superb.raw, 512);
  2800.   spareb_tmp = spareb;
  2801.   spareb_tmp.spareb.bFlag &= (SPF_VER | SPF_FASTFMT);
  2802.   spareb_tmp.spareb.aulExtra[1] = 0; /* TODO: ULONG_TO_HPFS */
  2803.   spareb_chksum = chksum (spareb_tmp.raw, 512);
  2804.  
  2805.   /* Boot sector. */
  2806.  
  2807.   if (a_what && what_sector == 0)
  2808.     info ("Sector #%lu: Boot sector\n", what_sector);
  2809.   use_sectors (0, 1, USE_BOOT, NULL);
  2810.  
  2811.   /* Boot loader. */
  2812.  
  2813.   if (a_what && IN_RANGE (what_sector, 1, 15))
  2814.     info ("Sector #%lu: Boot loader\n", what_sector);
  2815.   use_sectors (1, 15, USE_LOADER, NULL);
  2816.  
  2817.   /* Superblock. */
  2818.  
  2819.   use_sectors (16, 1, USE_SUPER, NULL);
  2820.   if (a_info || (a_what && what_sector == 16))
  2821.     {
  2822.       info ("Sector #%lu: Super block\n", (ULONG)16);
  2823.       info ("  HPFS Version:                       %d\n",
  2824.             superb.superb.bVersion);
  2825.       info ("  Functional version:                 %d",
  2826.             superb.superb.bFuncVersion);
  2827.       if (superb.superb.bFuncVersion == 2)
  2828.         info (" (<=4GB)\n");
  2829.       else if (superb.superb.bFuncVersion == 3)
  2830.         info (" (>4GB)\n");
  2831.       else if (superb.superb.bFuncVersion == 4)
  2832.         info (" (multimedia)\n");
  2833.       else
  2834.         info ("\n");
  2835.       info ("  Root directory FNODE at:            #%lu\n",
  2836.             ULONG_FROM_FS (superb.superb.lsnRootFNode));
  2837.       info ("  Total number of sectors:            %lu\n",
  2838.             ULONG_FROM_FS (superb.superb.culSectsOnVol));
  2839.       if (sector_number_format != 0
  2840.           && ULONG_FROM_FS (superb.superb.culSectsOnVol) != 0)
  2841.         info (  "Last sector:                        #%lu\n",
  2842.               ULONG_FROM_FS (superb.superb.culSectsOnVol) - 1);
  2843.       info ("  Number of bad sectors:              %lu\n",
  2844.             ULONG_FROM_FS (superb.superb.culNumBadSects));
  2845.       info ("  Bitmap indirect block at:           #%lu\n",
  2846.             ULONG_FROM_FS (superb.superb.rspBitMapIndBlk.lsnMain));
  2847.       info ("  Bad block list starts at:           #%lu\n",
  2848.             ULONG_FROM_FS (superb.superb.rspBadBlkList.lsnMain));
  2849.       info ("  Time of last chkdsk:                %s\n",
  2850.             format_time (ULONG_FROM_FS (superb.superb.datLastChkdsk)));
  2851.       info ("  Time of last optimization:          %s\n",
  2852.             format_time (ULONG_FROM_FS (superb.superb.datLastOptimize)));
  2853.       info ("  Number of sectors in DIRBLK band:   %lu\n",
  2854.             ULONG_FROM_FS (superb.superb.clsnDirBlkBand));
  2855.       info ("  First sector in DIRBLK band:        #%lu\n",
  2856.             ULONG_FROM_FS (superb.superb.lsnFirstDirBlk));
  2857.       info ("  Last sector in DIRBLK band:         #%lu\n",
  2858.             ULONG_FROM_FS (superb.superb.lsnLastDirBlk));
  2859.       info ("  First sector of DIRBLK band bitmap: #%lu\n",
  2860.             ULONG_FROM_FS (superb.superb.lsnDirBlkMap));
  2861.       info ("  Sector number of user ID table:     #%lu\n",
  2862.             ULONG_FROM_FS (superb.superb.lsnSidTab));
  2863.       info ("  Check sum (computed):               0x%.8lx\n", superb_chksum);
  2864.     }
  2865.  
  2866.   /* The Superblock points to the DIRBLK band. */
  2867.  
  2868.   dirband_sectors = ULONG_FROM_FS (superb.superb.clsnDirBlkBand);
  2869.   dirband_start = ULONG_FROM_FS (superb.superb.lsnFirstDirBlk);
  2870.   dirband_end = ULONG_FROM_FS (superb.superb.lsnLastDirBlk);
  2871.   dirblk_total = 0; dirblk_outside = 0;
  2872.  
  2873.   /* Spare block. */
  2874.  
  2875.   use_sectors (17, 1, USE_SPARE, NULL);
  2876.   if (a_info || (a_what && what_sector == 17))
  2877.     {
  2878.       info ("Sector #%lu: Spare block\n", (ULONG)17);
  2879.       info ("  Spare block flags:                  0x%.2x (",
  2880.             spareb.spareb.bFlag);
  2881.       if (spareb.spareb.bFlag & SPF_DIRT)
  2882.         info ("dirty");
  2883.       else
  2884.         info ("clean");
  2885.       if (spareb.spareb.bFlag & SPF_SPARE) info (" spare");
  2886.       if (spareb.spareb.bFlag & SPF_HFUSED) info (" hotfix");
  2887.       if (spareb.spareb.bFlag & SPF_BADSEC) info (" badsec");
  2888.       if (spareb.spareb.bFlag & SPF_BADBM) info (" badbmp");
  2889.       if (spareb.spareb.bFlag & SPF_FASTFMT) info (" fastfmt");
  2890.       if (spareb.spareb.bFlag & SPF_VER) info (" version");
  2891.       info (")\n");
  2892.       info ("  Block size:                         %lu\n",
  2893.             sectors_per_block * 512);
  2894.       info ("  Hotfix sector mapping table at:     #%lu\n",
  2895.             ULONG_FROM_FS (spareb.spareb.lsnHotFix));
  2896.       info ("  Number of hotfixes used:            %lu\n",
  2897.             ULONG_FROM_FS (spareb.spareb.culHotFixes));
  2898.       info ("  Maximum number of hotfixes:         %lu\n",
  2899.             ULONG_FROM_FS (spareb.spareb.culMaxHotFixes));
  2900.       info ("  Number of free spare DIRBLKs:       %lu\n",
  2901.             ULONG_FROM_FS (spareb.spareb.cdbSpares));
  2902.       info ("  Total number of spare DIRBLKs:      %lu\n",
  2903.             ULONG_FROM_FS (spareb.spareb.cdbMaxSpare));
  2904.       info ("  Code page information sector at:    #%lu\n",
  2905.             ULONG_FROM_FS (spareb.spareb.lsnCPInfo));
  2906.       info ("  Number of code pages:               %lu\n",
  2907.             ULONG_FROM_FS (spareb.spareb.culCP));
  2908.       info ("  Checksum of Super block:            0x%.8lx\n",
  2909.             ULONG_FROM_FS (spareb.spareb.aulExtra[0]));
  2910.       info ("  Checksum of Spare block:            0x%.8lx\n",
  2911.             ULONG_FROM_FS (spareb.spareb.aulExtra[1]));
  2912.       info ("  Check sum (computed):               0x%.8lx\n", spareb_chksum);
  2913.       n = ULONG_FROM_FS (spareb.spareb.cdbMaxSpare);
  2914.       for (i = 0; i < n; ++i)
  2915.         info ("  Spare DIRBLK at #%lu\n",
  2916.               ULONG_FROM_FS (spareb.spareb.alsnSpareDirBlks[i]));
  2917.     }
  2918.  
  2919.   /* DIRBLK band.  This is where DIRBLK preferably live.  If there is
  2920.      not enough space in the DIRBLK band, HPFS puts DIRBLKs in other
  2921.      available sectors (starting at a 4-sector boundary). */
  2922.  
  2923.   i = dirband_end - dirband_start + 1;
  2924.   if (a_what && IN_RANGE (what_sector, dirband_start, i))
  2925.     info ("Sector #%lu is in the DIRBLK band\n", what_sector);
  2926.   use_sectors (dirband_start, i, USE_BANDDIRBLK, NULL);
  2927.  
  2928.   /* The DIRBLK band has its own allocation bitmap.  Each bit maps one
  2929.      DIRBLK, that is, 4 sectors. */
  2930.  
  2931.   i = ULONG_FROM_FS (superb.superb.lsnDirBlkMap);
  2932.   if (a_info)
  2933.     info ("Sectors #%lu-#%lu: DIRBLK band bitmap\n", i, i + 3);
  2934.   if (a_what && IN_RANGE (what_sector, i, 4))
  2935.     info ("Sector #%lu is in the DIRBLK band bitmap (+%lu)\n",
  2936.           what_sector, what_sector - i);
  2937.   use_sectors (i, 4, USE_DIRBLKBITMAP, NULL);
  2938.  
  2939.   /* 8 sectors are reserved for storing user IDs.  Currently
  2940.      unused. */
  2941.  
  2942.   i = ULONG_FROM_FS (superb.superb.lsnSidTab);
  2943.   if (a_what && IN_RANGE (what_sector, i, 8))
  2944.     info ("Sector #%lu: User ID\n", what_sector);
  2945.   use_sectors (i, 8, USE_SID, NULL);
  2946.  
  2947.   /* Spare DIRBLKs.  If HPFS runs out of disk space for DIRBLKs in a
  2948.      split operation, it will use preallocated Spare DIRBLKs. */
  2949.  
  2950.   n = ULONG_FROM_FS (spareb.spareb.cdbMaxSpare);
  2951.   for (i = 0; i < n; ++i)
  2952.     {
  2953.       if (a_what
  2954.           && IN_RANGE (what_sector,
  2955.                        ULONG_FROM_FS (spareb.spareb.alsnSpareDirBlks[i]), 4))
  2956.         info ("Sector #%lu: Spare DIRBLK (+%lu)\n",
  2957.               what_sector,
  2958.               what_sector
  2959.               - ULONG_FROM_FS (spareb.spareb.alsnSpareDirBlks[i]));
  2960.       use_sectors (ULONG_FROM_FS (spareb.spareb.alsnSpareDirBlks[i]),
  2961.                    4, USE_SPAREDIRBLK, NULL);
  2962.     }
  2963.  
  2964.   /* Allocate the allocation vector which contains one bit per sector,
  2965.      indicating whether the sector is in use (0) or available (1).
  2966.      The vector will be filled in by do_bitmap(), called by
  2967.      do_bitmap_indirect().  */
  2968.  
  2969.   if (a_check || a_info || a_what)
  2970.     {
  2971.       total_alloc = DIVIDE_UP (total_sectors, 8);
  2972.       alloc_vector = (BYTE *)xmalloc (total_alloc);
  2973.       memset (alloc_vector, 0, total_alloc);
  2974.     }
  2975.  
  2976.   /* Check the Superblock and the Spare block. */
  2977.  
  2978.   if (a_check)
  2979.     {
  2980.       if (dirband_start > dirband_end)
  2981.         warning (1, "SUPERBLK #%lu: DIRBLK band start greater than "
  2982.                  "DIRBLK band end", (ULONG)16);
  2983.       if (dirband_sectors & 3)
  2984.         warning (1, "SUPERBLK #%lu: Number of DIRBLK band sectors is "
  2985.                  "not a multiple of 4", (ULONG)16);
  2986.       if (dirband_start + dirband_sectors - 1 != dirband_end)
  2987.         warning (1, "SUPERBLK #%lu: Wrong DIRBLK band size", (ULONG)16);
  2988.       if (ULONG_FROM_FS (superb.superb.lsnDirBlkMap) & 3)
  2989.         warning (1, "SUPERBLK #%lu: DIRBLK band bitmap not on a 2K boundary",
  2990.                  (ULONG)16);
  2991.  
  2992.       if (!(spareb.spareb.bFlag & SPF_HFUSED)
  2993.           != (ULONG_FROM_FS (spareb.spareb.culHotFixes) == 0))
  2994.         warning (1, "SPAREBLK #%lu: Hotfix bit is wrong", (ULONG)17);
  2995.       if (!(spareb.spareb.bFlag & SPF_BADSEC)
  2996.           != (ULONG_FROM_FS (superb.superb.culNumBadSects) == 0))
  2997.         warning (1, "SPAREBLK #%lu: Bad sector bit is wrong", (ULONG)17);
  2998.       if (!(spareb.spareb.bFlag & SPF_SPARE)
  2999.           != (ULONG_FROM_FS (spareb.spareb.cdbSpares)
  3000.               == ULONG_FROM_FS (spareb.spareb.cdbMaxSpare)))
  3001.         warning (1, "SPAREBLK #%lu: Spare DIRBLK bit is wrong", (ULONG)17);
  3002.       if (ULONG_FROM_FS (spareb.spareb.cdbSpares)
  3003.           > ULONG_FROM_FS (spareb.spareb.cdbMaxSpare))
  3004.         warning (1, "SPAREBLK #%lu: Number of free spare DIRBLKs exceeds "
  3005.                  "maximum number", (ULONG)17);
  3006.       if (ULONG_FROM_FS (spareb.spareb.aulExtra[0]) != superb_chksum)
  3007.         warning (1, "SPAREBLK #%lu: Incorrect checksum for Super block",
  3008.                  (ULONG)17);
  3009.       if (ULONG_FROM_FS (spareb.spareb.aulExtra[1]) != spareb_chksum)
  3010.         warning (1, "SPAREBLK #%lu: Incorrect checksum for Spare block",
  3011.                  (ULONG)17);
  3012.  
  3013.       if (superb.superb.bFuncVersion == 4)
  3014.         {
  3015.           /* `Multimedia format'.  To collect more samples for
  3016.              .bAlign, we display warnings if the values differ from
  3017.              those on my test partition.  I guess that .bAlign[0] is a
  3018.              set of flag bits and .bAlign[1] indicates the block size
  3019.              (1 << .bAlign[1] sectors per block).  .bAlign[2] is still
  3020.              unused. */
  3021.  
  3022.           if (spareb.spareb.bAlign[0] != 8)
  3023.             warning (0, "SPAREBLK #%lu: .bAlign[0] is %u", (ULONG)17,
  3024.                      spareb.spareb.bAlign[0]);
  3025.           if (spareb.spareb.bAlign[1] != 9)
  3026.             warning (0, "SPAREBLK #%lu: .bAlign[1] is %u", (ULONG)17,
  3027.                      spareb.spareb.bAlign[1]);
  3028.         }
  3029.       if (check_pedantic)
  3030.         {
  3031.           if (spareb.spareb.bAlign[2] != 0)
  3032.             warning (0, "SPAREBLK #%lu: .bAlign[2] is %u", (ULONG)17,
  3033.                      spareb.spareb.bAlign[2]);
  3034.         }
  3035.     }
  3036.  
  3037.   if (a_check || a_info || a_save || a_what)
  3038.     {
  3039.       /* Process the bad block list. */
  3040.  
  3041.       do_bad (d, ULONG_FROM_FS (superb.superb.rspBadBlkList.lsnMain),
  3042.               ULONG_FROM_FS (superb.superb.culNumBadSects));
  3043.  
  3044.       /* Process the hotfix list. */
  3045.  
  3046.       do_hotfix_list (d, ULONG_FROM_FS (spareb.spareb.lsnHotFix),
  3047.                       ULONG_FROM_FS (spareb.spareb.culMaxHotFixes));
  3048.     }
  3049.  
  3050.   /* Process the allocation bitmaps.  This fills in alloc_vector. */
  3051.  
  3052.   if (a_check || a_info || a_save || a_what)
  3053.     do_bitmap_indirect (d, ULONG_FROM_FS (superb.superb.rspBitMapIndBlk.lsnMain));
  3054.  
  3055.   /* Process the list of code page sectors. */
  3056.  
  3057.   if (a_check || a_info || a_save || a_what || a_find)
  3058.     do_cpinfosec (d, ULONG_FROM_FS (spareb.spareb.lsnCPInfo));
  3059.  
  3060.   /* Now comes the most interesting part: Walk through all directories
  3061.      and files, starting in the root directory. */
  3062.  
  3063.   file_count = 0; dir_count = 0;
  3064.   extents_init (&file_extents);
  3065.   extents_init (&ea_extents);
  3066.   if (a_check || a_save || a_what || a_find)
  3067.     {
  3068.       path_chain link, *plink;
  3069.  
  3070.       plink = PATH_CHAIN_NEW (&link, NULL, "");
  3071.       do_fnode (d, ULONG_FROM_FS (superb.superb.lsnRootFNode), plink,
  3072.                 TRUE, ULONG_FROM_FS (superb.superb.lsnRootFNode),
  3073.                 0, 0, FALSE, FALSE, (a_dir && *find_path == 0));
  3074.     }
  3075.  
  3076.   /* Process the DIRBLK bitmap. */
  3077.  
  3078.   if (a_check || a_save)
  3079.     do_dirblk_bitmap (d, ULONG_FROM_FS (superb.superb.lsnDirBlkMap),
  3080.                       dirband_start, dirband_sectors / 4);
  3081.  
  3082.   if (a_check)
  3083.     {
  3084.       /* Check the Spare DIRBLKs. */
  3085.  
  3086.       check_sparedirblk (spareb.spareb.alsnSpareDirBlks,
  3087.                          ULONG_FROM_FS (spareb.spareb.cdbMaxSpare),
  3088.                          ULONG_FROM_FS (spareb.spareb.cdbSpares));
  3089.  
  3090.       /* Check allocation bits. */
  3091.  
  3092.       check_alloc ();
  3093.  
  3094.       /* Show a summary. */
  3095.  
  3096.       if (show_summary)
  3097.         {
  3098.           info ("Number of directories: %lu\n", dir_count);
  3099.           info ("Number of files:       %lu\n", file_count);
  3100.           info ("Number of DIRBLKs:     %lu (%lu outside DIRBLK band)\n",
  3101.                 dirblk_total, dirblk_outside);
  3102.           info ("Number of ALSECs:      %lu\n", alsec_count);
  3103.         }
  3104.     }
  3105.  
  3106.   /* Show fragmentation of free space. */
  3107.  
  3108.   if (a_info && show_free_frag)
  3109.     do_free_frag ();
  3110.  
  3111.   /* Show fragmentation of files and extended attributes. */
  3112.  
  3113.   if (show_frag)
  3114.     {
  3115.       extents_show (&file_extents, "file data");
  3116.       extents_show (&ea_extents, "extended attributes");
  3117.     }
  3118.  
  3119.   /* Clean up. */
  3120.  
  3121.   extents_exit (&file_extents);
  3122.   extents_exit (&ea_extents);
  3123. }
  3124.