src/inspect_fs_windows.c

   1 /* libguestfs
   2  * Copyright (C) 2010-2011 Red Hat Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdint.h>
  24 #include <inttypes.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <string.h>
  28 #include <sys/stat.h>
  29 #include <errno.h>
  30 #include <endian.h>
  31
  32 #ifdef HAVE_PCRE
  33 #include <pcre.h>
  34 #endif
  35
  36 #ifdef HAVE_HIVEX
  37 #include <hivex.h>
  38 #endif
  39
  40 #include "c-ctype.h"
  41 #include "ignore-value.h"
  42 #include "xstrtol.h"
  43
  44 #include "guestfs.h"
  45 #include "guestfs-internal.h"
  46 #include "guestfs-internal-actions.h"
  47 #include "guestfs_protocol.h"
  48
  49 #if defined(HAVE_PCRE) && defined(HAVE_HIVEX)
  50
  51 /* Compile all the regular expressions once when the shared library is
  52  * loaded.  PCRE is thread safe so we're supposedly OK here if
  53  * multiple threads call into the libguestfs API functions below
  54  * simultaneously.
  55  */
  56 static pcre *re_windows_version;
  57
  58 static void compile_regexps (void) __attribute__((constructor));
  59 static void free_regexps (void) __attribute__((destructor));
  60
  61 static void
  62 compile_regexps (void)
  63 {
  64   const char *err;
  65   int offset;
  66
  67 #define COMPILE(re,pattern,options)                                     \
  68   do {                                                                  \
  69     re = pcre_compile ((pattern), (options), &err, &offset, NULL);      \
  70     if (re == NULL) {                                                   \
  71       ignore_value (write (2, err, strlen (err)));                      \
  72       abort ();                                                         \
  73     }                                                                   \
  74   } while (0)
  75
  76   COMPILE (re_windows_version, "^(\\d+)\\.(\\d+)", 0);
  77 }
  78
  79 static void
  80 free_regexps (void)
  81 {
  82   pcre_free (re_windows_version);
  83 }
  84
  85 static int check_windows_arch (guestfs_h *g, struct inspect_fs *fs);
  86 static int check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs);
  87 static int check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs);
  88 static char *map_registry_disk_blob (guestfs_h *g, const char *blob);
  89
  90 /* XXX Handling of boot.ini in the Perl version was pretty broken.  It
  91  * essentially didn't do anything for modern Windows guests.
  92  * Therefore I've omitted all that code.
  93  */
  94 int
  95 guestfs___check_windows_root (guestfs_h *g, struct inspect_fs *fs)
  96 {
  97   fs->type = OS_TYPE_WINDOWS;
  98   fs->distro = OS_DISTRO_WINDOWS;
  99
 100   /* Try to find Windows systemroot using some common locations. */
 101   const char *systemroots[] =
 102     { "/windows", "/winnt", "/win32", "/win" };
 103   size_t i;
 104   char *systemroot = NULL;
 105   for (i = 0;
 106        systemroot == NULL && i < sizeof systemroots / sizeof systemroots[0];
 107        ++i) {
 108     systemroot = guestfs___case_sensitive_path_silently (g, systemroots[i]);
 109   }
 110
 111   if (!systemroot) {
 112     error (g, _("cannot resolve Windows %%SYSTEMROOT%%"));
 113     return -1;
 114   }
 115
 116   debug (g, "windows %%SYSTEMROOT%% = %s", systemroot);
 117
 118   /* Freed by guestfs___free_inspect_info. */
 119   fs->windows_systemroot = systemroot;
 120
 121   if (check_windows_arch (g, fs) == -1)
 122     return -1;
 123
 124   /* Product name and version. */
 125   if (check_windows_software_registry (g, fs) == -1)
 126     return -1;
 127
 128   /* Hostname. */
 129   if (check_windows_system_registry (g, fs) == -1)
 130     return -1;
 131
 132   return 0;
 133 }
 134
 135 static int
 136 check_windows_arch (guestfs_h *g, struct inspect_fs *fs)
 137 {
 138   size_t len = strlen (fs->windows_systemroot) + 32;
 139   char cmd_exe[len];
 140   snprintf (cmd_exe, len, "%s/system32/cmd.exe", fs->windows_systemroot);
 141
 142   char *cmd_exe_path = guestfs___case_sensitive_path_silently (g, cmd_exe);
 143   if (!cmd_exe_path)
 144     return 0;
 145
 146   char *arch = guestfs_file_architecture (g, cmd_exe_path);
 147   free (cmd_exe_path);
 148
 149   if (arch)
 150     fs->arch = arch;        /* freed by guestfs___free_inspect_info */
 151
 152   return 0;
 153 }
 154
 155 /* At the moment, pull just the ProductName and version numbers from
 156  * the registry.  In future there is a case for making many more
 157  * registry fields available to callers.
 158  */
 159 static int
 160 check_windows_software_registry (guestfs_h *g, struct inspect_fs *fs)
 161 {
 162   const char *basename = "software";
 163   char tmpdir_basename[strlen (g->tmpdir) + strlen (basename) + 2];
 164   snprintf (tmpdir_basename, sizeof tmpdir_basename, "%s/%s",
 165             g->tmpdir, basename);
 166
 167   size_t len = strlen (fs->windows_systemroot) + 64;
 168   char software[len];
 169   snprintf (software, len, "%s/system32/config/software",
 170             fs->windows_systemroot);
 171
 172   char *software_path = guestfs___case_sensitive_path_silently (g, software);
 173   if (!software_path)
 174     /* If the software hive doesn't exist, just accept that we cannot
 175      * find product_name etc.
 176      */
 177     return 0;
 178
 179   int ret = -1;
 180   hive_h *h = NULL;
 181   hive_value_h *values = NULL;
 182
 183   if (guestfs___download_to_tmp (g, software_path, basename,
 184                                  MAX_REGISTRY_SIZE) == -1)
 185     goto out;
 186
 187   h = hivex_open (tmpdir_basename, g->verbose ? HIVEX_OPEN_VERBOSE : 0);
 188   if (h == NULL) {
 189     perrorf (g, "hivex_open");
 190     goto out;
 191   }
 192
 193   hive_node_h node = hivex_root (h);
 194   const char *hivepath[] =
 195     { "Microsoft", "Windows NT", "CurrentVersion" };
 196   size_t i;
 197   for (i = 0;
 198        node != 0 && i < sizeof hivepath / sizeof hivepath[0];
 199        ++i) {
 200     node = hivex_node_get_child (h, node, hivepath[i]);
 201   }
 202
 203   if (node == 0) {
 204     perrorf (g, "hivex: cannot locate HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion");
 205     goto out;
 206   }
 207
 208   values = hivex_node_values (h, node);
 209
 210   for (i = 0; values[i] != 0; ++i) {
 211     char *key = hivex_value_key (h, values[i]);
 212     if (key == NULL) {
 213       perrorf (g, "hivex_value_key");
 214       goto out;
 215     }
 216
 217     if (STRCASEEQ (key, "ProductName")) {
 218       fs->product_name = hivex_value_string (h, values[i]);
 219       if (!fs->product_name) {
 220         perrorf (g, "hivex_value_string");
 221         free (key);
 222         goto out;
 223       }
 224     }
 225     else if (STRCASEEQ (key, "CurrentVersion")) {
 226       char *version = hivex_value_string (h, values[i]);
 227       if (!version) {
 228         perrorf (g, "hivex_value_string");
 229         free (key);
 230         goto out;
 231       }
 232       char *major, *minor;
 233       if (match2 (g, version, re_windows_version, &major, &minor)) {
 234         fs->major_version = guestfs___parse_unsigned_int (g, major);
 235         free (major);
 236         if (fs->major_version == -1) {
 237           free (minor);
 238           free (key);
 239           free (version);
 240           goto out;
 241         }
 242         fs->minor_version = guestfs___parse_unsigned_int (g, minor);
 243         free (minor);
 244         if (fs->minor_version == -1) {
 245           free (key);
 246           free (version);
 247           goto out;
 248         }
 249       }
 250
 251       free (version);
 252     }
 253     else if (STRCASEEQ (key, "InstallationType")) {
 254       fs->product_variant = hivex_value_string (h, values[i]);
 255       if (!fs->product_variant) {
 256         perrorf (g, "hivex_value_string");
 257         free (key);
 258         goto out;
 259       }
 260     }
 261
 262     free (key);
 263   }
 264
 265   ret = 0;
 266
 267  out:
 268   if (h) hivex_close (h);
 269   free (values);
 270   free (software_path);
 271
 272   return ret;
 273 }
 274
 275 static int
 276 check_windows_system_registry (guestfs_h *g, struct inspect_fs *fs)
 277 {
 278   const char *basename = "system";
 279   char tmpdir_basename[strlen (g->tmpdir) + strlen (basename) + 2];
 280   snprintf (tmpdir_basename, sizeof tmpdir_basename, "%s/%s",
 281             g->tmpdir, basename);
 282
 283   size_t len = strlen (fs->windows_systemroot) + 64;
 284   char system[len];
 285   snprintf (system, len, "%s/system32/config/system",
 286             fs->windows_systemroot);
 287
 288   char *system_path = guestfs___case_sensitive_path_silently (g, system);
 289   if (!system_path)
 290     /* If the system hive doesn't exist, just accept that we cannot
 291      * find hostname etc.
 292      */
 293     return 0;
 294
 295   int ret = -1;
 296   hive_h *h = NULL;
 297   hive_node_h root, node;
 298   hive_value_h value, *values = NULL;
 299   int32_t dword;
 300   size_t i, count;
 301
 302   if (guestfs___download_to_tmp (g, system_path, basename,
 303                                  MAX_REGISTRY_SIZE) == -1)
 304     goto out;
 305
 306   h = hivex_open (tmpdir_basename, g->verbose ? HIVEX_OPEN_VERBOSE : 0);
 307   if (h == NULL) {
 308     perrorf (g, "hivex_open");
 309     goto out;
 310   }
 311
 312   root = hivex_root (h);
 313   if (root == 0) {
 314     perrorf (g, "hivex_root");
 315     goto out;
 316   }
 317
 318   /* Get the CurrentControlSet. */
 319   errno = 0;
 320   node = hivex_node_get_child (h, root, "Select");
 321   if (node == 0) {
 322     if (errno != 0)
 323       perrorf (g, "hivex_node_get_child");
 324     else
 325       error (g, "hivex: could not locate HKLM\\SYSTEM\\Select");
 326     goto out;
 327   }
 328
 329   errno = 0;
 330   value = hivex_node_get_value (h, node, "Current");
 331   if (value == 0) {
 332     if (errno != 0)
 333       perrorf (g, "hivex_node_get_value");
 334     else
 335       error (g, "hivex: HKLM\\System\\Select Default entry not found.");
 336     goto out;
 337   }
 338
 339   /* XXX Should check the type. */
 340   dword = hivex_value_dword (h, value);
 341   fs->windows_current_control_set = safe_asprintf (g, "ControlSet%03d", dword);
 342
 343   /* Get the drive mappings.
 344    * This page explains the contents of HKLM\System\MountedDevices:
 345    * http://www.goodells.net/multiboot/partsigs.shtml
 346    */
 347   errno = 0;
 348   node = hivex_node_get_child (h, root, "MountedDevices");
 349   if (node == 0) {
 350     if (errno != 0)
 351       perrorf (g, "hivex_node_get_child");
 352     else
 353       error (g, "hivex: could not locate HKLM\\SYSTEM\\MountedDevices");
 354     goto out;
 355   }
 356
 357   values = hivex_node_values (h, node);
 358
 359   /* Count how many DOS drive letter mappings there are.  This doesn't
 360    * ignore removable devices, so it overestimates, but that doesn't
 361    * matter because it just means we'll allocate a few bytes extra.
 362    */
 363   for (i = count = 0; values[i] != 0; ++i) {
 364     char *key = hivex_value_key (h, values[i]);
 365     if (key == NULL) {
 366       perrorf (g, "hivex_value_key");
 367       goto out;
 368     }
 369     if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
 370         c_isalpha (key[12]) && key[13] == ':')
 371       count++;
 372     free (key);
 373   }
 374
 375   fs->drive_mappings = calloc (2*count + 1, sizeof (char *));
 376   if (fs->drive_mappings == NULL) {
 377     perrorf (g, "calloc");
 378     goto out;
 379   }
 380
 381   for (i = count = 0; values[i] != 0; ++i) {
 382     char *key = hivex_value_key (h, values[i]);
 383     if (key == NULL) {
 384       perrorf (g, "hivex_value_key");
 385       goto out;
 386     }
 387     if (STRCASEEQLEN (key, "\\DosDevices\\", 12) &&
 388         c_isalpha (key[12]) && key[13] == ':') {
 389       /* Get the binary value.  Is it a fixed disk? */
 390       char *blob, *device;
 391       size_t len;
 392       hive_type type;
 393
 394       blob = hivex_value_value (h, values[i], &type, &len);
 395       if (blob != NULL && type == 3 && len == 12) {
 396         /* Try to map the blob to a known disk and partition. */
 397         device = map_registry_disk_blob (g, blob);
 398         if (device != NULL) {
 399           fs->drive_mappings[count++] = safe_strndup (g, &key[12], 1);
 400           fs->drive_mappings[count++] = device;
 401         }
 402       }
 403       free (blob);
 404     }
 405     free (key);
 406   }
 407
 408   /* Get the hostname. */
 409   const char *hivepath[] =
 410     { fs->windows_current_control_set, "Services", "Tcpip", "Parameters" };
 411   for (node = root, i = 0;
 412        node != 0 && i < sizeof hivepath / sizeof hivepath[0];
 413        ++i) {
 414     node = hivex_node_get_child (h, node, hivepath[i]);
 415   }
 416
 417   if (node == 0) {
 418     perrorf (g, "hivex: cannot locate HKLM\\SYSTEM\\%s\\Services\\Tcpip\\Parameters",
 419              fs->windows_current_control_set);
 420     goto out;
 421   }
 422
 423   free (values);
 424   values = hivex_node_values (h, node);
 425
 426   for (i = 0; values[i] != 0; ++i) {
 427     char *key = hivex_value_key (h, values[i]);
 428     if (key == NULL) {
 429       perrorf (g, "hivex_value_key");
 430       goto out;
 431     }
 432
 433     if (STRCASEEQ (key, "Hostname")) {
 434       fs->hostname = hivex_value_string (h, values[i]);
 435       if (!fs->hostname) {
 436         perrorf (g, "hivex_value_string");
 437         free (key);
 438         goto out;
 439       }
 440     }
 441     /* many other interesting fields here ... */
 442
 443     free (key);
 444   }
 445
 446   ret = 0;
 447
 448  out:
 449   if (h) hivex_close (h);
 450   free (values);
 451   free (system_path);
 452
 453   return ret;
 454 }
 455
 456 /* Windows Registry HKLM\SYSTEM\MountedDevices uses a blob of data
 457  * to store partitions.  This blob is described here:
 458  * http://www.goodells.net/multiboot/partsigs.shtml
 459  * The following function maps this blob to a libguestfs partition
 460  * name, if possible.
 461  */
 462 static char *
 463 map_registry_disk_blob (guestfs_h *g, const char *blob)
 464 {
 465   char **devices = NULL;
 466   struct guestfs_partition_list *partitions = NULL;
 467   char *diskid;
 468   size_t i, j, len;
 469   char *ret = NULL;
 470   uint64_t part_offset;
 471
 472   /* First 4 bytes are the disk ID.  Search all devices to find the
 473    * disk with this disk ID.
 474    */
 475   devices = guestfs_list_devices (g);
 476   if (devices == NULL)
 477     goto out;
 478
 479   for (i = 0; devices[i] != NULL; ++i) {
 480     /* Read the disk ID. */
 481     diskid = guestfs_pread_device (g, devices[i], 4, 0x01b8, &len);
 482     if (diskid == NULL)
 483       continue;
 484     if (len < 4) {
 485       free (diskid);
 486       continue;
 487     }
 488     if (memcmp (diskid, blob, 4) == 0) { /* found it */
 489       free (diskid);
 490       goto found_disk;
 491     }
 492     free (diskid);
 493   }
 494   goto out;
 495
 496  found_disk:
 497   /* Next 8 bytes are the offset of the partition in bytes(!) given as
 498    * a 64 bit little endian number.  Luckily it's easy to get the
 499    * partition byte offset from guestfs_part_list.
 500    */
 501   part_offset = le64toh (* (uint64_t *) &blob[4]);
 502
 503   partitions = guestfs_part_list (g, devices[i]);
 504   if (partitions == NULL)
 505     goto out;
 506
 507   for (j = 0; j < partitions->len; ++j) {
 508     if (partitions->val[j].part_start == part_offset) /* found it */
 509       goto found_partition;
 510   }
 511   goto out;
 512
 513  found_partition:
 514   /* Construct the full device name. */
 515   ret = safe_asprintf (g, "%s%d", devices[i], partitions->val[j].part_num);
 516
 517  out:
 518   if (devices)
 519     guestfs___free_string_list (devices);
 520   if (partitions)
 521     guestfs_free_partition_list (partitions);
 522   return ret;
 523 }
 524
 525 char *
 526 guestfs___case_sensitive_path_silently (guestfs_h *g, const char *path)
 527 {
 528   guestfs_error_handler_cb old_error_cb = g->error_cb;
 529   g->error_cb = NULL;
 530   char *ret = guestfs_case_sensitive_path (g, path);
 531   g->error_cb = old_error_cb;
 532   return ret;
 533 }
 534
 535 #endif /* defined(HAVE_PCRE) && defined(HAVE_HIVEX) */