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_USER_KEY_NAME              L"\\Registry\\User"
  22 #define  REG_DEFAULT_USER_KEY_NAME      L"\\Registry\\User\\.Default"
  23 #define  REG_CURRENT_USER_KEY_NAME      L"\\Registry\\User\\CurrentUser"
  24
  25 #define  SYSTEM_REG_FILE                L"\\SystemRoot\\System32\\Config\\SYSTEM"
  26 #define  SYSTEM_LOG_FILE                L"\\SystemRoot\\System32\\Config\\SYSTEM.log"
  27 #define  SOFTWARE_REG_FILE              L"\\SystemRoot\\System32\\Config\\SOFTWARE"
  28 #define  DEFAULT_USER_REG_FILE          L"\\SystemRoot\\System32\\Config\\DEFAULT"
  29 #define  SAM_REG_FILE                   L"\\SystemRoot\\System32\\Config\\SAM"
  30 #define  SEC_REG_FILE                   L"\\SystemRoot\\System32\\Config\\SECURITY"
  31
  32 #define  REG_SYSTEM_FILE_NAME           L"\\system"
  33 #define  REG_SOFTWARE_FILE_NAME         L"\\software"
  34 #define  REG_DEFAULT_USER_FILE_NAME     L"\\default"
  35 #define  REG_SAM_FILE_NAME              L"\\sam"
  36 #define  REG_SEC_FILE_NAME              L"\\security"
  37
  38 #define  REG_BLOCK_SIZE                4096
  39 #define  REG_HBIN_DATA_OFFSET          32
  40 #define  REG_INIT_BLOCK_LIST_SIZE      32
  41 #define  REG_INIT_HASH_TABLE_SIZE      3
  42 #define  REG_EXTEND_HASH_TABLE_SIZE    4
  43 #define  REG_VALUE_LIST_CELL_MULTIPLE  4
  44
  45 #define  REG_HIVE_ID                   0x66676572
  46 #define  REG_BIN_ID                    0x6e696268
  47 #define  REG_KEY_CELL_ID               0x6b6e
  48 #define  REG_HASH_TABLE_CELL_ID        0x666c
  49 #define  REG_VALUE_CELL_ID             0x6b76
  50 #define  REG_SECURITY_CELL_ID          0x6b73
  51
  52
  53 // BLOCK_OFFSET = offset in file after header block
  54 typedef ULONG BLOCK_OFFSET, *PBLOCK_OFFSET;
  55
  56 #include <pshpack1.h>
  57
  58 /* header for registry hive file : */
  59 typedef struct _HIVE_HEADER
  60 {
  61   /* Hive identifier "regf" (0x66676572) */
  62   ULONG  BlockId;
  63
  64   /* Update counter */
  65   ULONG  UpdateCounter1;
  66
  67   /* Update counter */
  68   ULONG  UpdateCounter2;
  69
  70   /* When this hive file was last modified */
  71   LARGE_INTEGER  DateModified;
  72
  73   /* Registry format version ? (1?) */
  74   ULONG  Unused3;
  75
  76   /* Registry format version ? (3?) */
  77   ULONG  Unused4;
  78
  79   /* Registry format version ? (0?) */
  80   ULONG  Unused5;
  81
  82   /* Registry format version ? (1?) */
  83   ULONG  Unused6;
  84
  85   /* Offset into file from the byte after the end of the base block.
  86      If the hive is volatile, this is the actual pointer to the KEY_CELL */
  87   BLOCK_OFFSET  RootKeyOffset;
  88
  89   /* Size of each hive block ? */
  90   ULONG  BlockSize;
  91
  92   /* (1?) */
  93   ULONG  Unused7;
  94
  95   /* Name of hive file */
  96   WCHAR  FileName[64];
  97
  98   /* ? */
  99   ULONG  Unused8[83];
 100
 101   /* Checksum of first 0x200 bytes */
 102   ULONG  Checksum;
 103 } HIVE_HEADER, *PHIVE_HEADER;
 104
 105 typedef struct _BIN_HEADER
 106 {
 107   /* Bin identifier "hbin" (0x6E696268) */
 108   ULONG  HeaderId;
 109
 110   /* Block offset of this bin */
 111   BLOCK_OFFSET  BinOffset;
 112
 113   /* Size in bytes, multiple of the block size (4KB) */
 114   ULONG  BinSize;
 115
 116   /* ? */
 117   ULONG  Unused1;
 118
 119   /* When this bin was last modified */
 120   LARGE_INTEGER  DateModified;
 121
 122   /* ? */
 123   ULONG  Unused2;
 124 } HBIN, *PHBIN;
 125
 126 typedef struct _CELL_HEADER
 127 {
 128   /* <0 if used, >0 if free */
 129   LONG  CellSize;
 130 } CELL_HEADER, *PCELL_HEADER;
 131
 132 typedef struct _KEY_CELL
 133 {
 134   /* Size of this cell */
 135   LONG  CellSize;
 136
 137   /* Key cell identifier "kn" (0x6b6e) */
 138   USHORT  Id;
 139
 140   /* Flags */
 141   USHORT  Flags;
 142
 143   /* Time of last flush */
 144   LARGE_INTEGER  LastWriteTime;
 145
 146   /* ? */
 147   ULONG  UnUsed1;
 148
 149   /* Block offset of parent key cell */
 150   BLOCK_OFFSET  ParentKeyOffset;
 151
 152   /* Count of sub keys for the key in this key cell */
 153   ULONG  NumberOfSubKeys;
 154
 155   /* ? */
 156   ULONG  UnUsed2;
 157
 158   /* Block offset of has table for FIXME: subkeys/values? */
 159   BLOCK_OFFSET  HashTableOffset;
 160
 161   /* ? */
 162   ULONG  UnUsed3;
 163
 164   /* Count of values contained in this key cell */
 165   ULONG  NumberOfValues;
 166
 167   /* Block offset of VALUE_LIST_CELL */
 168   BLOCK_OFFSET  ValueListOffset;
 169
 170   /* Block offset of security cell */
 171   BLOCK_OFFSET  SecurityKeyOffset;
 172
 173   /* Block offset of registry key class */
 174   BLOCK_OFFSET  ClassNameOffset;
 175
 176   /* ? */
 177   ULONG  Unused4[5];
 178
 179   /* Size in bytes of key name */
 180   USHORT NameSize;
 181
 182   /* Size of class name in bytes */
 183   USHORT ClassSize;
 184
 185   /* Name of key (not zero terminated) */
 186   UCHAR  Name[0];
 187 } KEY_CELL, *PKEY_CELL;
 188
 189 /* KEY_CELL.Flags constants */
 190 #define  REG_KEY_ROOT_CELL                 0x0C
 191 #define  REG_KEY_LINK_CELL                 0x10
 192 #define  REG_KEY_NAME_PACKED               0x20
 193
 194 /*
 195  * Hash record
 196  *
 197  * HashValue:
 198  *      packed name: four letters of value's name
 199  *      otherwise: Zero!
 200  */
 201 typedef struct _HASH_RECORD
 202 {
 203   BLOCK_OFFSET  KeyOffset;
 204   ULONG  HashValue;
 205 } HASH_RECORD, *PHASH_RECORD;
 206
 207 typedef struct _HASH_TABLE_CELL
 208 {
 209   LONG  CellSize;
 210   USHORT  Id;
 211   USHORT  HashTableSize;
 212   HASH_RECORD  Table[0];
 213 } HASH_TABLE_CELL, *PHASH_TABLE_CELL;
 214
 215
 216 typedef struct _VALUE_LIST_CELL
 217 {
 218   LONG  CellSize;
 219   BLOCK_OFFSET  ValueOffset[0];
 220 } VALUE_LIST_CELL, *PVALUE_LIST_CELL;
 221
 222 typedef struct _VALUE_CELL
 223 {
 224   LONG  CellSize;
 225   USHORT Id;    // "kv"
 226   USHORT NameSize;      // length of Name
 227   ULONG  DataSize;      // length of datas in the cell pointed by DataOffset
 228   BLOCK_OFFSET  DataOffset;// datas are here if high bit of DataSize is set
 229   ULONG  DataType;
 230   USHORT Flags;
 231   USHORT Unused1;
 232   UCHAR  Name[0]; /* warning : not zero terminated */
 233 } VALUE_CELL, *PVALUE_CELL;
 234
 235 /* VALUE_CELL.Flags constants */
 236 #define REG_VALUE_NAME_PACKED             0x0001
 237
 238 /* VALUE_CELL.DataSize mask constants */
 239 #define REG_DATA_SIZE_MASK                 0x7FFFFFFF
 240 #define REG_DATA_IN_OFFSET                 0x80000000
 241
 242
 243 typedef struct _SECURITY_CELL
 244 {
 245   LONG  CellSize;
 246   USHORT Id;    // "sk"
 247   USHORT Reserved;
 248   BLOCK_OFFSET PrevSecurityCell;
 249   BLOCK_OFFSET NextSecurityCell;
 250   ULONG RefCount;
 251   ULONG SdSize;
 252   UCHAR Data[0];
 253 } SECURITY_CELL, *PSECURITY_CELL;
 254
 255
 256 typedef struct _DATA_CELL
 257 {
 258   LONG  CellSize;
 259   UCHAR  Data[0];
 260 } DATA_CELL, *PDATA_CELL;
 261
 262 #include <poppack.h>
 263
 264
 265 typedef struct _BLOCK_LIST_ENTRY
 266 {
 267   PHBIN Bin;
 268   PVOID Block;
 269 } BLOCK_LIST_ENTRY, *PBLOCK_LIST_ENTRY;
 270
 271
 272 typedef struct _REGISTRY_HIVE
 273 {
 274   LIST_ENTRY  HiveList;
 275   ULONG  Flags;
 276   UNICODE_STRING  HiveFileName;
 277   UNICODE_STRING  LogFileName;
 278   ULONG  FileSize;
 279   PHIVE_HEADER  HiveHeader;
 280   ULONG  UpdateCounter;
 281   ULONG  BlockListSize;
 282   PBLOCK_LIST_ENTRY BlockList;
 283   ULONG  FreeListSize;
 284   ULONG  FreeListMax;
 285   PCELL_HEADER *FreeList;
 286   BLOCK_OFFSET *FreeListOffset;
 287
 288   PSECURITY_CELL RootSecurityCell;
 289
 290   PULONG BitmapBuffer;
 291   RTL_BITMAP  DirtyBitMap;
 292   BOOLEAN  HiveDirty;
 293 } REGISTRY_HIVE, *PREGISTRY_HIVE;
 294
 295 /* REGISTRY_HIVE.Flags constants */
 296 /* When set, the hive uses pointers instead of offsets. */
 297 #define HIVE_POINTER    0x00000001
 298
 299 /* When set, the hive is not backed by a file.
 300    Therefore, it can not be flushed to disk. */
 301 #define HIVE_NO_FILE    0x00000002
 302
 303 /* When set, a modified (dirty) hive is not synchronized automatically.
 304    Explicit synchronization (save/flush) works. */
 305 #define HIVE_NO_SYNCH   0x00000004
 306
 307 #define IsPointerHive(Hive)  ((Hive)->Flags & HIVE_POINTER)
 308 #define IsNoFileHive(Hive)  ((Hive)->Flags & HIVE_NO_FILE)
 309 #define IsNoSynchHive(Hive)  ((Hive)->Flags & HIVE_NO_SYNCH)
 310
 311
 312 #define IsFreeCell(Cell)(Cell->CellSize >= 0)
 313 #define IsUsedCell(Cell)(Cell->CellSize < 0)
 314
 315
 316 /* KEY_OBJECT.Flags */
 317
 318 /* When set, the key is scheduled for deletion, and all
 319    attempts to access the key must not succeed */
 320 #define KO_MARKED_FOR_DELETE              0x00000001
 321
 322
 323 /* Type defining the Object Manager Key Object */
 324 typedef struct _KEY_OBJECT
 325 {
 326   /* Fields used by the Object Manager */
 327   CSHORT Type;
 328   CSHORT Size;
 329
 330   /* Key flags */
 331   ULONG Flags;
 332
 333   /* Key name */
 334   UNICODE_STRING Name;
 335
 336   /* Registry hive the key belongs to */
 337   PREGISTRY_HIVE RegistryHive;
 338
 339   /* Block offset of the key cell this key belongs in */
 340   BLOCK_OFFSET KeyCellOffset;
 341
 342   /* KEY_CELL this key belong in */
 343   PKEY_CELL KeyCell;
 344
 345   /* Link to the parent KEY_OBJECT for this key */
 346   struct _KEY_OBJECT *ParentKey;
 347
 348   /* Subkeys loaded in SubKeys */
 349   ULONG NumberOfSubKeys;
 350
 351   /* Space allocated in SubKeys */
 352   ULONG SizeOfSubKeys;
 353
 354   /* List of subkeys loaded */
 355   struct _KEY_OBJECT **SubKeys;
 356 } KEY_OBJECT, *PKEY_OBJECT;
 357
 358 /* Bits 31-22 (top 10 bits) of the cell index is the directory index */
 359 #define CmiDirectoryIndex(CellIndex)(CellIndex & 0xffc000000)
 360 /* Bits 21-12 (middle 10 bits) of the cell index is the table index */
 361 #define CmiTableIndex(Cellndex)(CellIndex & 0x003ff000)
 362 /* Bits 11-0 (bottom 12 bits) of the cell index is the byte offset */
 363 #define CmiByteOffset(Cellndex)(CellIndex & 0x00000fff)
 364
 365
 366 extern BOOLEAN CmiDoVerify;
 367 extern PREGISTRY_HIVE CmiVolatileHive;
 368 extern POBJECT_TYPE CmiKeyType;
 369 extern KSPIN_LOCK CmiKeyListLock;
 370
 371 extern LIST_ENTRY CmiHiveListHead;
 372
 373 extern ERESOURCE CmiRegistryLock;
 374
 375 /* Registry Callback Function */
 376 typedef NTSTATUS (*PEX_CALLBACK_FUNCTION ) (
 377     IN PVOID CallbackContext,
 378     IN PVOID Argument1,
 379     IN PVOID Argument2
 380     );
 381
 382 VOID
 383 CmiVerifyBinHeader(PHBIN BinHeader);
 384 VOID
 385 CmiVerifyKeyCell(PKEY_CELL KeyCell);
 386 VOID
 387 CmiVerifyRootKeyCell(PKEY_CELL RootKeyCell);
 388 VOID
 389 CmiVerifyKeyObject(PKEY_OBJECT KeyObject);
 390 VOID
 391 CmiVerifyRegistryHive(PREGISTRY_HIVE RegistryHive);
 392
 393 #ifdef DBG
 394 #define VERIFY_BIN_HEADER CmiVerifyBinHeader
 395 #define VERIFY_KEY_CELL CmiVerifyKeyCell
 396 #define VERIFY_ROOT_KEY_CELL CmiVerifyRootKeyCell
 397 #define VERIFY_VALUE_CELL CmiVerifyValueCell
 398 #define VERIFY_VALUE_LIST_CELL CmiVerifyValueListCell
 399 #define VERIFY_KEY_OBJECT CmiVerifyKeyObject
 400 #define VERIFY_REGISTRY_HIVE CmiVerifyRegistryHive
 401 #else
 402 #define VERIFY_BIN_HEADER(x)
 403 #define VERIFY_KEY_CELL(x)
 404 #define VERIFY_ROOT_KEY_CELL(x)
 405 #define VERIFY_VALUE_CELL(x)
 406 #define VERIFY_VALUE_LIST_CELL(x)
 407 #define VERIFY_KEY_OBJECT(x)
 408 #define VERIFY_REGISTRY_HIVE(x)
 409 #endif
 410
 411 NTSTATUS STDCALL
 412 CmRegisterCallback(IN PEX_CALLBACK_FUNCTION Function,
 413                    IN PVOID                 Context,
 414                    IN OUT PLARGE_INTEGER    Cookie
 415                     );
 416
 417 NTSTATUS STDCALL
 418 CmUnRegisterCallback(IN LARGE_INTEGER    Cookie);
 419
 420 NTSTATUS STDCALL
 421 CmiObjectParse(IN PVOID ParsedObject,
 422                OUT PVOID *NextObject,
 423                IN PUNICODE_STRING FullPath,
 424                IN OUT PWSTR *Path,
 425                IN ULONG Attribute);
 426
 427 NTSTATUS STDCALL
 428 CmiObjectCreate(PVOID ObjectBody,
 429                 PVOID Parent,
 430                 PWSTR RemainingPath,
 431                 POBJECT_ATTRIBUTES ObjectAttributes);
 432
 433 VOID STDCALL
 434 CmiObjectDelete(PVOID  DeletedObject);
 435
 436 NTSTATUS STDCALL
 437 CmiObjectSecurity(PVOID ObjectBody,
 438                   SECURITY_OPERATION_CODE OperationCode,
 439                   SECURITY_INFORMATION SecurityInformation,
 440                   PSECURITY_DESCRIPTOR SecurityDescriptor,
 441                   PULONG BufferLength);
 442
 443 NTSTATUS STDCALL
 444 CmiObjectQueryName (PVOID ObjectBody,
 445                     POBJECT_NAME_INFORMATION ObjectNameInfo,
 446                     ULONG Length,
 447                     PULONG ReturnLength);
 448
 449 NTSTATUS
 450 CmiImportHiveBins(PREGISTRY_HIVE Hive,
 451                   PUCHAR ChunkPtr);
 452
 453 VOID
 454 CmiFreeHiveBins(PREGISTRY_HIVE Hive);
 455
 456 NTSTATUS
 457 CmiCreateHiveFreeCellList(PREGISTRY_HIVE Hive);
 458
 459 VOID
 460 CmiFreeHiveFreeCellList(PREGISTRY_HIVE Hive);
 461
 462 NTSTATUS
 463 CmiCreateHiveBitmap(PREGISTRY_HIVE Hive);
 464
 465
 466 VOID
 467 CmiAddKeyToList(IN PKEY_OBJECT ParentKey,
 468                 IN PKEY_OBJECT NewKey);
 469
 470 NTSTATUS
 471 CmiRemoveKeyFromList(IN PKEY_OBJECT NewKey);
 472
 473 PKEY_OBJECT
 474 CmiScanKeyList(IN PKEY_OBJECT Parent,
 475                IN PUNICODE_STRING KeyName,
 476                IN ULONG Attributes);
 477
 478 NTSTATUS
 479 CmiCreateVolatileHive(PREGISTRY_HIVE *RegistryHive);
 480
 481 NTSTATUS
 482 CmiLoadHive(POBJECT_ATTRIBUTES KeyObjectAttributes,
 483             PUNICODE_STRING FileName,
 484             ULONG Flags);
 485
 486 NTSTATUS
 487 CmiRemoveRegistryHive(PREGISTRY_HIVE RegistryHive);
 488
 489 NTSTATUS
 490 CmiFlushRegistryHive(PREGISTRY_HIVE RegistryHive);
 491
 492 ULONG
 493 CmiGetNumberOfSubKeys(PKEY_OBJECT KeyObject);
 494
 495 ULONG
 496 CmiGetMaxNameLength(IN PKEY_OBJECT KeyObject);
 497
 498 ULONG
 499 CmiGetMaxClassLength(IN PKEY_OBJECT KeyObject);
 500
 501 ULONG
 502 CmiGetMaxValueNameLength(IN PREGISTRY_HIVE RegistryHive,
 503                          IN PKEY_CELL KeyCell);
 504
 505 ULONG
 506 CmiGetMaxValueDataLength(IN PREGISTRY_HIVE RegistryHive,
 507                          IN PKEY_CELL KeyCell);
 508
 509 NTSTATUS
 510 CmiScanForSubKey(IN PREGISTRY_HIVE RegistryHive,
 511                  IN PKEY_CELL KeyCell,
 512                  OUT PKEY_CELL *SubKeyCell,
 513                  OUT BLOCK_OFFSET *BlockOffset,
 514                  IN PUNICODE_STRING KeyName,
 515                  IN ACCESS_MASK DesiredAccess,
 516                  IN ULONG Attributes);
 517
 518 NTSTATUS
 519 CmiAddSubKey(IN PREGISTRY_HIVE RegistryHive,
 520              IN PKEY_OBJECT ParentKey,
 521              OUT PKEY_OBJECT SubKey,
 522              IN PUNICODE_STRING SubKeyName,
 523              IN ULONG TitleIndex,
 524              IN PUNICODE_STRING Class,
 525              IN ULONG CreateOptions);
 526
 527 NTSTATUS
 528 CmiRemoveSubKey(IN PREGISTRY_HIVE RegistryHive,
 529                 IN PKEY_OBJECT Parent,
 530                 IN PKEY_OBJECT SubKey);
 531
 532 NTSTATUS
 533 CmiScanKeyForValue(IN PREGISTRY_HIVE RegistryHive,
 534                    IN PKEY_CELL KeyCell,
 535                    IN PUNICODE_STRING ValueName,
 536                    OUT PVALUE_CELL *ValueCell,
 537                    OUT BLOCK_OFFSET *VBOffset);
 538
 539 NTSTATUS
 540 CmiGetValueFromKeyByIndex(IN PREGISTRY_HIVE RegistryHive,
 541                           IN PKEY_CELL KeyCell,
 542                           IN ULONG Index,
 543                           OUT PVALUE_CELL *ValueCell);
 544
 545 NTSTATUS
 546 CmiAddValueToKey(IN PREGISTRY_HIVE RegistryHive,
 547                  IN PKEY_CELL KeyCell,
 548                  IN BLOCK_OFFSET KeyCellOffset,
 549                  IN PUNICODE_STRING ValueName,
 550                  OUT PVALUE_CELL *pValueCell,
 551                  OUT BLOCK_OFFSET *pValueCellOffset);
 552
 553 NTSTATUS
 554 CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive,
 555                       IN PKEY_CELL KeyCell,
 556                       IN BLOCK_OFFSET KeyCellOffset,
 557                       IN PUNICODE_STRING ValueName);
 558
 559 NTSTATUS
 560 CmiAllocateHashTableCell(IN PREGISTRY_HIVE RegistryHive,
 561                          OUT PHASH_TABLE_CELL *HashBlock,
 562                          OUT BLOCK_OFFSET *HBOffset,
 563                          IN ULONG HashTableSize);
 564
 565 PKEY_CELL
 566 CmiGetKeyFromHashByIndex(PREGISTRY_HIVE RegistryHive,
 567                          PHASH_TABLE_CELL HashBlock,
 568                          ULONG Index);
 569
 570 NTSTATUS
 571 CmiAddKeyToHashTable(PREGISTRY_HIVE RegistryHive,
 572                      PHASH_TABLE_CELL HashCell,
 573                      BLOCK_OFFSET HashCellOffset,
 574                      PKEY_CELL NewKeyCell,
 575                      BLOCK_OFFSET NKBOffset);
 576
 577 NTSTATUS
 578 CmiRemoveKeyFromHashTable(PREGISTRY_HIVE RegistryHive,
 579                           PHASH_TABLE_CELL HashBlock,
 580                           BLOCK_OFFSET NKBOffset);
 581
 582 NTSTATUS
 583 CmiAllocateValueCell(IN PREGISTRY_HIVE RegistryHive,
 584                      OUT PVALUE_CELL *ValueCell,
 585                      OUT BLOCK_OFFSET *VBOffset,
 586                      IN PUNICODE_STRING ValueName);
 587
 588 NTSTATUS
 589 CmiDestroyValueCell(PREGISTRY_HIVE RegistryHive,
 590                     PVALUE_CELL ValueCell,
 591                     BLOCK_OFFSET VBOffset);
 592
 593 NTSTATUS
 594 CmiAllocateCell(PREGISTRY_HIVE RegistryHive,
 595                 LONG CellSize,
 596                 PVOID *Cell,
 597                 BLOCK_OFFSET *CellOffset);
 598
 599 NTSTATUS
 600 CmiDestroyCell(PREGISTRY_HIVE RegistryHive,
 601                PVOID Cell,
 602                BLOCK_OFFSET CellOffset);
 603
 604 PHBIN
 605 CmiGetBin (PREGISTRY_HIVE RegistryHive,
 606            BLOCK_OFFSET CellOffset);
 607
 608 PVOID
 609 CmiGetCell (PREGISTRY_HIVE RegistryHive,
 610             BLOCK_OFFSET CellOffset,
 611             OUT PHBIN *Bin);
 612
 613 VOID
 614 CmiMarkBlockDirty(PREGISTRY_HIVE RegistryHive,
 615                   BLOCK_OFFSET BlockOffset);
 616
 617 VOID
 618 CmiMarkBinDirty(PREGISTRY_HIVE RegistryHive,
 619                 BLOCK_OFFSET BinOffset);
 620
 621 NTSTATUS
 622 CmiAddFree(PREGISTRY_HIVE RegistryHive,
 623            PCELL_HEADER FreeBlock,
 624            BLOCK_OFFSET FreeOffset,
 625            BOOLEAN MergeFreeBlocks);
 626
 627 NTSTATUS
 628 CmiConnectHive(POBJECT_ATTRIBUTES KeyObjectAttributes,
 629                PREGISTRY_HIVE RegistryHive);
 630
 631 NTSTATUS
 632 CmiDisconnectHive (POBJECT_ATTRIBUTES KeyObjectAttributes,
 633                    PREGISTRY_HIVE *RegistryHive);
 634
 635 NTSTATUS
 636 CmiInitHives(BOOLEAN SetupBoot);
 637
 638 ULONG
 639 CmiGetPackedNameLength(IN PUNICODE_STRING Name,
 640                        OUT PBOOLEAN Packable);
 641
 642 BOOLEAN
 643 CmiComparePackedNames(IN PUNICODE_STRING Name,
 644                       IN PCHAR NameBuffer,
 645                       IN USHORT NameBufferSize,
 646                       IN BOOLEAN NamePacked);
 647
 648 VOID
 649 CmiCopyPackedName(PWCHAR NameBuffer,
 650                   PCHAR PackedNameBuffer,
 651                   ULONG PackedNameSize);
 652
 653 BOOLEAN
 654 CmiCompareHash(PUNICODE_STRING KeyName,
 655                PCHAR HashString);
 656
 657 BOOLEAN
 658 CmiCompareHashI(PUNICODE_STRING KeyName,
 659                 PCHAR HashString);
 660
 661 BOOLEAN
 662 CmiCompareKeyNames(PUNICODE_STRING KeyName,
 663                    PKEY_CELL KeyCell);
 664
 665 BOOLEAN
 666 CmiCompareKeyNamesI(PUNICODE_STRING KeyName,
 667                     PKEY_CELL KeyCell);
 668
 669
 670 VOID
 671 CmiSyncHives(VOID);
 672
 673
 674 NTSTATUS
 675 CmiCreateTempHive(PREGISTRY_HIVE *RegistryHive);
 676
 677 NTSTATUS
 678 CmiCopyKey (PREGISTRY_HIVE DstHive,
 679             PKEY_CELL DstKeyCell,
 680             PREGISTRY_HIVE SrcHive,
 681             PKEY_CELL SrcKeyCell);
 682
 683 NTSTATUS
 684 CmiSaveTempHive (PREGISTRY_HIVE Hive,
 685                  HANDLE FileHandle);
 686
 687 #endif /*__INCLUDE_CM_H*/