reactos/ntoskrnl/cm/cm.h

   1 #ifndef __INCLUDE_CM_H
   2 #define __INCLUDE_CM_H
   3
   4 #ifdef DBG
   5 #define CHECKED 1
   6 #else
   7 #define CHECKED 0
   8 #endif
   9
  10 #define  REG_ROOT_KEY_NAME              L"\\Registry"
  11 #define  REG_MACHINE_KEY_NAME           L"\\Registry\\Machine"
  12 #define  REG_HARDWARE_KEY_NAME          L"\\Registry\\Machine\\HARDWARE"
  13 #define  REG_DESCRIPTION_KEY_NAME       L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION"
  14 #define  REG_DEVICEMAP_KEY_NAME         L"\\Registry\\Machine\\HARDWARE\\DEVICEMAP"
  15 #define  REG_RESOURCEMAP_KEY_NAME       L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP"
  16 #define  REG_CLASSES_KEY_NAME           L"\\Registry\\Machine\\Software\\Classes"
  17 #define  REG_SYSTEM_KEY_NAME            L"\\Registry\\Machine\\System"
  18 #define  REG_SOFTWARE_KEY_NAME          L"\\Registry\\Machine\\Software"
  19 #define  REG_SAM_KEY_NAME               L"\\Registry\\Machine\\Sam"
  20 #define  REG_SEC_KEY_NAME               L"\\Registry\\Machine\\Security"
  21 #define  REG_USERS_KEY_NAME             L"\\Registry\\User"
  22 #define  REG_USER_KEY_NAME              L"\\Registry\\User\\CurrentUser"
  23 #define  SYSTEM_REG_FILE                L"\\SystemRoot\\System32\\Config\\SYSTEM"
  24 #define  SOFTWARE_REG_FILE              L"\\SystemRoot\\System32\\Config\\SOFTWARE"
  25 #define  USER_REG_FILE                  L"\\SystemRoot\\System32\\Config\\DEFAULT"
  26 #define  SAM_REG_FILE                   L"\\SystemRoot\\System32\\Config\\SAM"
  27 #define  SEC_REG_FILE                   L"\\SystemRoot\\System32\\Config\\SECURITY"
  28
  29 #define  REG_SYSTEM_FILE_NAME           L"\\SYSTEM"
  30 #define  REG_SOFTWARE_FILE_NAME         L"\\SOFTWARE"
  31 #define  REG_USER_FILE_NAME             L"\\DEFAULT"
  32 #define  REG_SAM_FILE_NAME              L"\\SAM"
  33 #define  REG_SEC_FILE_NAME              L"\\SECURITY"
  34
  35 #define  REG_BLOCK_SIZE                4096
  36 #define  REG_HBIN_DATA_OFFSET          32
  37 #define  REG_BIN_ID                    0x6e696268
  38 #define  REG_INIT_BLOCK_LIST_SIZE      32
  39 #define  REG_INIT_HASH_TABLE_SIZE      3
  40 #define  REG_EXTEND_HASH_TABLE_SIZE    4
  41 #define  REG_VALUE_LIST_CELL_MULTIPLE  4
  42 #define  REG_KEY_CELL_ID               0x6b6e
  43 #define  REG_HASH_TABLE_BLOCK_ID       0x666c
  44 #define  REG_VALUE_CELL_ID             0x6b76
  45 #define  REG_HIVE_ID                   0x66676572
  46
  47 #define  REGISTRY_FILE_MAGIC    "REGEDIT4"
  48
  49 #define  REG_MACHINE_STD_HANDLE_NAME  "HKEY_LOCAL_MACHINE"
  50 #define  REG_CLASSES_STD_HANDLE_NAME  "HKEY_CLASSES_ROOT"
  51 #define  REG_USERS_STD_HANDLE_NAME    "HKEY_USERS"
  52 #define  REG_USER_STD_HANDLE_NAME     "HKEY_CURRENT_USER"
  53 #define  REG_CONFIG_STD_HANDLE_NAME   "HKEY_CURRENT_CONFIG"
  54 #define  REG_DYN_STD_HANDLE_NAME      "HKEY_DYN_DATA"
  55 #define  MAX_REG_STD_HANDLE_NAME      19
  56
  57 // BLOCK_OFFSET = offset in file after header block
  58 typedef ULONG BLOCK_OFFSET;
  59
  60 /* header for registry hive file : */
  61 typedef struct _HIVE_HEADER
  62 {
  63   /* Hive identifier "regf" (0x66676572) */
  64   ULONG  BlockId;
  65
  66   /* File version ? */
  67   ULONG  Version;
  68
  69   /* File version ? - same as Version */
  70   ULONG  VersionOld;
  71
  72   /* When this hive file was last modified */
  73   FILETIME  DateModified;
  74
  75   /* Registry format version ? (1?) */
  76   ULONG  Unused3;
  77
  78   /* Registry format version ? (3?) */
  79   ULONG  Unused4;
  80
  81   /* Registry format version ? (0?) */
  82   ULONG  Unused5;
  83
  84   /* Registry format version ? (1?) */
  85   ULONG  Unused6;
  86
  87   /* Offset into file from the byte after the end of the base block.
  88      If the hive is volatile, this is the actual pointer to the KEY_CELL */
  89   BLOCK_OFFSET  RootKeyCell;
  90
  91   /* Size of each hive block ? */
  92   ULONG  BlockSize;
  93
  94   /* (1?) */
  95   ULONG  Unused7;
  96
  97   /* Name of hive file */
  98   WCHAR  FileName[64];
  99
 100   /* ? */
 101   ULONG  Unused8[83];
 102
 103   /* Checksum of first 0x200 bytes */
 104   ULONG  Checksum;
 105 } __attribute__((packed)) HIVE_HEADER, *PHIVE_HEADER;
 106
 107 typedef struct _HBIN
 108 {
 109   /* Bin identifier "hbin" (0x6E696268) */
 110   ULONG  BlockId;
 111
 112   /* Block offset of this bin */
 113   BLOCK_OFFSET  BlockOffset;
 114
 115   /* Size in bytes, multiple of the block size (4KB) */
 116   ULONG  BlockSize;
 117
 118   /* ? */
 119   ULONG  Unused1;
 120
 121   /* When this bin was last modified */
 122   FILETIME  DateModified;
 123
 124   /* ? */
 125   ULONG  Unused2;
 126 } __attribute__((packed)) HBIN, *PHBIN;
 127
 128 typedef struct _CELL_HEADER
 129 {
 130   /* <0 if used, >0 if free */
 131   LONG  CellSize;
 132 } __attribute__((packed)) CELL_HEADER, *PCELL_HEADER;
 133
 134 typedef struct _KEY_CELL
 135 {
 136   /* Size of this cell */
 137   LONG  CellSize;
 138
 139   /* Key cell identifier "kn" (0x6b6e) */
 140   USHORT  Id;
 141
 142   /* ? */
 143   USHORT  Type;
 144
 145   /* Time of last flush */
 146   FILETIME  LastWriteTime;
 147
 148   /* ? */
 149   ULONG  UnUsed1;
 150
 151   /* Block offset of parent key cell */
 152   BLOCK_OFFSET  ParentKeyOffset;
 153
 154   /* Count of sub keys for the key in this key cell */
 155   ULONG  NumberOfSubKeys;
 156
 157   /* ? */
 158   ULONG  UnUsed2;
 159
 160   /* Block offset of has table for FIXME: subkeys/values? */
 161   BLOCK_OFFSET  HashTableOffset;
 162
 163   /* ? */
 164   ULONG  UnUsed3;
 165
 166   /* Count of values contained in this key cell */
 167   ULONG  NumberOfValues;
 168
 169   /* Block offset of VALUE_LIST_CELL */
 170   BLOCK_OFFSET  ValuesOffset;
 171
 172   /* Block offset of security cell */
 173   BLOCK_OFFSET  SecurityKeyOffset;
 174
 175   /* Block offset of registry key class */
 176   BLOCK_OFFSET  ClassNameOffset;
 177
 178   /* ? */
 179   ULONG  Unused4[5];
 180
 181   /* Size in bytes of key name */
 182   USHORT NameSize;
 183
 184   /* Size of class name in bytes */
 185   USHORT ClassSize;
 186
 187   /* Name of key (not zero terminated) */
 188   UCHAR  Name[0];
 189 } __attribute__((packed)) KEY_CELL, *PKEY_CELL;
 190
 191 /* KEY_CELL.Type constants */
 192 #define  REG_LINK_KEY_CELL_TYPE        0x10
 193 #define  REG_KEY_CELL_TYPE             0x20
 194 #define  REG_ROOT_KEY_CELL_TYPE        0x2c
 195
 196
 197 // hash record :
 198 // HashValue=four letters of value's name
 199 typedef struct _HASH_RECORD
 200 {
 201   BLOCK_OFFSET  KeyOffset;
 202   ULONG  HashValue;
 203 } __attribute__((packed)) HASH_RECORD, *PHASH_RECORD;
 204
 205 typedef struct _HASH_TABLE_CELL
 206 {
 207   LONG  CellSize;
 208   USHORT  Id;
 209   USHORT  HashTableSize;
 210   HASH_RECORD  Table[0];
 211 } __attribute__((packed)) HASH_TABLE_CELL, *PHASH_TABLE_CELL;
 212
 213 typedef struct _VALUE_LIST_CELL
 214 {
 215   LONG  CellSize;
 216   BLOCK_OFFSET  Values[0];
 217 } __attribute__((packed)) VALUE_LIST_CELL, *PVALUE_LIST_CELL;
 218
 219 typedef struct _VALUE_CELL
 220 {
 221   LONG  CellSize;
 222   USHORT Id;    // "kv"
 223   USHORT NameSize;      // length of Name
 224   LONG  DataSize;       // length of datas in the cell pointed by DataOffset
 225   BLOCK_OFFSET  DataOffset;// datas are here if high bit of DataSize is set
 226   ULONG  DataType;
 227   USHORT Flags;
 228   USHORT Unused1;
 229   UCHAR  Name[0]; /* warning : not zero terminated */
 230 } __attribute__((packed)) VALUE_CELL, *PVALUE_CELL;
 231
 232 /* VALUE_CELL.Flags constants */
 233 #define REG_VALUE_NAME_PACKED             0x0001
 234
 235
 236 typedef struct _DATA_CELL
 237 {
 238   LONG  CellSize;
 239   UCHAR  Data[0];
 240 } __attribute__((packed)) DATA_CELL, *PDATA_CELL;
 241
 242 typedef struct _REGISTRY_HIVE
 243 {
 244   LIST_ENTRY HiveList;
 245   ULONG  Flags;
 246   UNICODE_STRING  Filename;
 247   ULONG  FileSize;
 248   PFILE_OBJECT  FileObject;
 249   PVOID  Bcb;
 250   PHIVE_HEADER  HiveHeader;
 251   ULONG  BlockListSize;
 252   PHBIN  *BlockList;
 253   ULONG  FreeListSize;
 254   ULONG  FreeListMax;
 255   PCELL_HEADER *FreeList;
 256   BLOCK_OFFSET *FreeListOffset;
 257   ERESOURCE HiveResource;
 258
 259   RTL_BITMAP DirtyBitMap;
 260   BOOLEAN HiveDirty;
 261
 262 //  NTSTATUS  (*Extend)(ULONG NewSize);
 263 //  PVOID  (*Flush)(VOID);
 264 } REGISTRY_HIVE, *PREGISTRY_HIVE;
 265
 266 /* REGISTRY_HIVE.Flags constants */
 267 #define HIVE_VOLATILE   0x00000001
 268
 269 #define IsVolatileHive(Hive)(Hive->Flags & HIVE_VOLATILE)
 270 #define IsPermanentHive(Hive)(!(Hive->Flags & HIVE_VOLATILE))
 271
 272 #define IsFreeCell(Cell)(Cell->CellSize >= 0)
 273 #define IsUsedCell(Cell)(Cell->CellSize < 0)
 274
 275
 276 /* KEY_OBJECT.Flags */
 277
 278 /* When set, the key is scheduled for deletion, and all
 279    attempts to access the key must not succeed */
 280 #define KO_MARKED_FOR_DELETE              0x00000001
 281
 282
 283 /* Type defining the Object Manager Key Object */
 284 typedef struct _KEY_OBJECT
 285 {
 286   /* Fields used by the Object Manager */
 287   CSHORT Type;
 288   CSHORT Size;
 289
 290   /* Key flags */
 291   ULONG Flags;
 292
 293   /* Length of Name */
 294   USHORT NameSize;
 295
 296   /* Name of key */
 297   PCHAR Name;
 298
 299   /* Registry hive the key belongs to */
 300   PREGISTRY_HIVE RegistryHive;
 301
 302   /* Block offset of the key cell this key belongs in */
 303   BLOCK_OFFSET BlockOffset;
 304
 305   /* KEY_CELL this key belong in */
 306   PKEY_CELL KeyCell;
 307
 308   /* Link to the parent KEY_OBJECT for this key */
 309   struct _KEY_OBJECT *ParentKey;
 310
 311   /* Subkeys loaded in SubKeys */
 312   ULONG NumberOfSubKeys;
 313
 314   /* Space allocated in SubKeys */
 315   ULONG SizeOfSubKeys;
 316
 317   /* List of subkeys loaded */
 318   struct _KEY_OBJECT **SubKeys;
 319 } KEY_OBJECT, *PKEY_OBJECT;
 320
 321 /* Bits 31-22 (top 10 bits) of the cell index is the directory index */
 322 #define CmiDirectoryIndex(CellIndex)(CellIndex & 0xffc000000)
 323 /* Bits 21-12 (middle 10 bits) of the cell index is the table index */
 324 #define CmiTableIndex(Cellndex)(CellIndex & 0x003ff000)
 325 /* Bits 11-0 (bottom 12 bits) of the cell index is the byte offset */
 326 #define CmiByteOffset(Cellndex)(CellIndex & 0x00000fff)
 327
 328
 329 extern BOOLEAN CmiDoVerify;
 330 extern PREGISTRY_HIVE CmiVolatileHive;
 331 extern POBJECT_TYPE CmiKeyType;
 332 extern KSPIN_LOCK CmiKeyListLock;
 333
 334 extern LIST_ENTRY CmiHiveListHead;
 335 extern ERESOURCE CmiHiveListLock;
 336
 337
 338 VOID
 339 CmiVerifyBinCell(PHBIN BinCell);
 340 VOID
 341 CmiVerifyKeyCell(PKEY_CELL KeyCell);
 342 VOID
 343 CmiVerifyRootKeyCell(PKEY_CELL RootKeyCell);
 344 VOID
 345 CmiVerifyKeyObject(PKEY_OBJECT KeyObject);
 346 VOID
 347 CmiVerifyRegistryHive(PREGISTRY_HIVE RegistryHive);
 348
 349 #ifdef DBG
 350 #define VERIFY_BIN_CELL CmiVerifyBinCell
 351 #define VERIFY_KEY_CELL CmiVerifyKeyCell
 352 #define VERIFY_ROOT_KEY_CELL CmiVerifyRootKeyCell
 353 #define VERIFY_VALUE_CELL CmiVerifyValueCell
 354 #define VERIFY_VALUE_LIST_CELL CmiVerifyValueListCell
 355 #define VERIFY_KEY_OBJECT CmiVerifyKeyObject
 356 #define VERIFY_REGISTRY_HIVE CmiVerifyRegistryHive
 357 #else
 358 #define VERIFY_BIN_CELL(x)
 359 #define VERIFY_KEY_CELL(x)
 360 #define VERIFY_ROOT_KEY_CELL(x)
 361 #define VERIFY_VALUE_CELL(x)
 362 #define VERIFY_VALUE_LIST_CELL(x)
 363 #define VERIFY_KEY_OBJECT(x)
 364 #define VERIFY_REGISTRY_HIVE(x)
 365 #endif
 366
 367 NTSTATUS STDCALL
 368 CmiObjectParse(IN PVOID  ParsedObject,
 369                OUT PVOID  *NextObject,
 370                IN PUNICODE_STRING  FullPath,
 371                IN OUT PWSTR  *Path,
 372                IN ULONG  Attribute);
 373
 374 NTSTATUS STDCALL
 375 CmiObjectCreate(PVOID ObjectBody,
 376                 PVOID Parent,
 377                 PWSTR RemainingPath,
 378                 struct _OBJECT_ATTRIBUTES* ObjectAttributes);
 379
 380 VOID STDCALL
 381 CmiObjectDelete(PVOID  DeletedObject);
 382
 383 VOID
 384 CmiAddKeyToList(PKEY_OBJECT ParentKey,
 385   IN PKEY_OBJECT  NewKey);
 386
 387 NTSTATUS
 388 CmiRemoveKeyFromList(IN PKEY_OBJECT  NewKey);
 389
 390 PKEY_OBJECT  CmiScanKeyList(IN PKEY_OBJECT Parent,
 391   IN PCHAR  KeyNameBuf,
 392   IN ULONG  Attributes);
 393
 394 NTSTATUS
 395 CmiCreateRegistryHive(PWSTR Filename,
 396   PREGISTRY_HIVE *RegistryHive,
 397   BOOLEAN CreateNew);
 398
 399 NTSTATUS
 400 CmiRemoveRegistryHive(PREGISTRY_HIVE RegistryHive);
 401
 402 NTSTATUS
 403 CmiFlushRegistryHive(PREGISTRY_HIVE RegistryHive);
 404
 405 ULONG
 406 CmiGetMaxNameLength(IN PREGISTRY_HIVE  RegistryHive,
 407   IN PKEY_CELL  KeyCell);
 408
 409 ULONG
 410 CmiGetMaxClassLength(IN PREGISTRY_HIVE  RegistryHive,
 411   IN PKEY_CELL  KeyCell);
 412
 413 ULONG
 414 CmiGetMaxValueNameLength(IN PREGISTRY_HIVE  RegistryHive,
 415   IN PKEY_CELL  KeyCell);
 416
 417 ULONG
 418 CmiGetMaxValueDataLength(IN PREGISTRY_HIVE  RegistryHive,
 419   IN PKEY_CELL  KeyCell);
 420
 421 NTSTATUS
 422 CmiScanForSubKey(IN PREGISTRY_HIVE  RegistryHive,
 423   IN PKEY_CELL  KeyCell,
 424   OUT PKEY_CELL  *SubKeyCell,
 425   OUT BLOCK_OFFSET *BlockOffset,
 426   IN PCHAR  KeyName,
 427   IN ACCESS_MASK  DesiredAccess,
 428   IN ULONG Attributes);
 429
 430 NTSTATUS
 431 CmiAddSubKey(IN PREGISTRY_HIVE  RegistryHive,
 432   IN PKEY_OBJECT Parent,
 433   OUT PKEY_OBJECT SubKey,
 434   IN PWSTR  NewSubKeyName,
 435   IN USHORT  NewSubKeyNameSize,
 436   IN ULONG  TitleIndex,
 437   IN PUNICODE_STRING  Class,
 438   IN ULONG  CreateOptions);
 439
 440 NTSTATUS
 441 CmiRemoveSubKey(IN PREGISTRY_HIVE RegistryHive,
 442                 IN PKEY_OBJECT Parent,
 443                 IN PKEY_OBJECT SubKey);
 444
 445 NTSTATUS
 446 CmiScanKeyForValue(IN PREGISTRY_HIVE  RegistryHive,
 447   IN PKEY_CELL  KeyCell,
 448   IN PUNICODE_STRING  ValueName,
 449   OUT PVALUE_CELL  *ValueCell,
 450   OUT BLOCK_OFFSET *VBOffset);
 451
 452 NTSTATUS
 453 CmiGetValueFromKeyByIndex(IN PREGISTRY_HIVE  RegistryHive,
 454   IN PKEY_CELL  KeyCell,
 455   IN ULONG  Index,
 456   OUT PVALUE_CELL  *ValueCell);
 457
 458 NTSTATUS
 459 CmiAddValueToKey(IN PREGISTRY_HIVE  RegistryHive,
 460   IN PKEY_CELL  KeyCell,
 461   IN PUNICODE_STRING ValueName,
 462   OUT PVALUE_CELL *pValueCell,
 463   OUT BLOCK_OFFSET *pVBOffset);
 464
 465 NTSTATUS
 466 CmiDeleteValueFromKey(IN PREGISTRY_HIVE  RegistryHive,
 467   IN PKEY_CELL  KeyCell,
 468   IN PUNICODE_STRING ValueName);
 469
 470 NTSTATUS
 471 CmiAllocateHashTableBlock(IN PREGISTRY_HIVE  RegistryHive,
 472   OUT PHASH_TABLE_CELL  *HashBlock,
 473   OUT BLOCK_OFFSET  *HBOffset,
 474   IN ULONG  HashTableSize);
 475
 476 PKEY_CELL
 477 CmiGetKeyFromHashByIndex(PREGISTRY_HIVE RegistryHive,
 478 PHASH_TABLE_CELL  HashBlock,
 479 ULONG  Index);
 480
 481 NTSTATUS
 482 CmiAddKeyToHashTable(PREGISTRY_HIVE  RegistryHive,
 483   PHASH_TABLE_CELL  HashBlock,
 484   PKEY_CELL  NewKeyCell,
 485   BLOCK_OFFSET  NKBOffset);
 486
 487 NTSTATUS
 488 CmiRemoveKeyFromHashTable(PREGISTRY_HIVE RegistryHive,
 489                           PHASH_TABLE_CELL HashBlock,
 490                           BLOCK_OFFSET NKBOffset);
 491
 492 NTSTATUS
 493 CmiAllocateValueCell(IN PREGISTRY_HIVE  RegistryHive,
 494   OUT PVALUE_CELL  *ValueCell,
 495   OUT BLOCK_OFFSET  *VBOffset,
 496   IN PUNICODE_STRING ValueName);
 497
 498 NTSTATUS
 499 CmiDestroyValueCell(PREGISTRY_HIVE  RegistryHive,
 500   PVALUE_CELL  ValueCell,
 501   BLOCK_OFFSET  VBOffset);
 502
 503 NTSTATUS
 504 CmiAllocateBlock(PREGISTRY_HIVE  RegistryHive,
 505   PVOID  *Block,
 506   LONG  BlockSize,
 507         BLOCK_OFFSET * pBlockOffset);
 508
 509 NTSTATUS
 510 CmiDestroyBlock(PREGISTRY_HIVE  RegistryHive,
 511   PVOID  Block,
 512   BLOCK_OFFSET Offset);
 513
 514 PVOID
 515 CmiGetBlock(PREGISTRY_HIVE  RegistryHive,
 516             BLOCK_OFFSET  BlockOffset,
 517             OUT PHBIN * ppBin);
 518
 519 VOID
 520 CmiLockBlock(PREGISTRY_HIVE  RegistryHive,
 521   PVOID  Block);
 522
 523 VOID
 524 CmiReleaseBlock(PREGISTRY_HIVE  RegistryHive,
 525                 PVOID  Block);
 526
 527 VOID
 528 CmiMarkBlockDirty(PREGISTRY_HIVE RegistryHive,
 529                   BLOCK_OFFSET BlockOffset);
 530
 531 NTSTATUS
 532 CmiAddFree(PREGISTRY_HIVE  RegistryHive,
 533         PCELL_HEADER FreeBlock,
 534   BLOCK_OFFSET FreeOffset);
 535
 536 NTSTATUS
 537 CmiInitHives(BOOLEAN SetUpBoot);
 538
 539 ULONG
 540 CmiGetPackedNameLength(IN PUNICODE_STRING Name,
 541                        OUT PBOOLEAN Packable);
 542
 543 BOOLEAN
 544 CmiComparePackedNames(IN PUNICODE_STRING Name,
 545                       IN PCHAR NameBuffer,
 546                       IN USHORT NameBufferSize,
 547                       IN BOOLEAN NamePacked);
 548
 549 VOID
 550 CmiCopyPackedName(PWCHAR NameBuffer,
 551                   PCHAR PackedNameBuffer,
 552                   ULONG PackedNameSize);
 553
 554 VOID
 555 CmiSyncHives(VOID);
 556
 557 #endif /*__INCLUDE_CM_H*/