Changeset 169 for trunk/include/regfi.h
- Timestamp:
- 03/03/10 14:24:58 (14 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/regfi.h
r168 r169 1 /** @file 2 * Windows NT (and later) registry parsing library 3 * 4 * Branched from Samba project Subversion repository, version #6903: 5 * http://viewcvs.samba.org/cgi-bin/viewcvs.cgi/trunk/source/include/regfio.h?rev=6903&view=auto 6 * 1 /* 7 2 * Copyright (C) 2005-2010 Timothy D. Morgan 8 3 * Copyright (C) 2005 Gerald (Jerry) Carter … … 24 19 */ 25 20 26 /************************************************************ 27 * Most of this information was obtained from 28 * http://www.wednesday.demon.co.uk/dosreg.html 29 * Thanks Nigel! 30 ***********************************************************/ 21 /** 22 * @file 23 * Windows NT (and later) read-only registry library 24 * 25 * This library is intended for use in digital forensics investigations, but 26 * is likely useful in other applications. 27 * 28 * Branched from Samba project Subversion repository, version #6903: 29 * http://viewcvs.samba.org/cgi-bin/viewcvs.cgi/trunk/source/include/regfio.h?rev=6903&view=auto 30 * 31 * Since then, it has been heavily rewritten, simplified, and improved. 32 */ 31 33 32 34 /** 33 35 * @mainpage Home 34 36 * 35 * See \ref regfiTopLayer 36 */ 37 * The regfi library is a read-only NT registry library which serves as the main 38 * engine behind the reglookup tool. It is designed with digital forensic 39 * analysis in mind, but it should also be useful in other tools which need to 40 * efficiently traverse and query registry data structures. 41 * 42 * The library is broken down into four main parts, the 43 * @ref regfiBase "Base Layer", which any code dependent on the library will 44 * likely need to rely on, as well as three main functional layers: 45 * @li @ref regfiIteratorLayer 46 * @li @ref regfiGlueLayer 47 * @li @ref regfiParseLayer 48 * 49 * Most users will find that a combination of the Base Layer and the Iterator Layer 50 * will be sufficient for accessing registry hive files. Those who are wiling 51 * to dive deep into registry data structures, for instance to recover deleted 52 * data structures or to research Windows registry behavior in detail, will 53 * find the Parse Layer to be quite useful. 54 */ 55 37 56 38 57 #ifndef _REGFI_H … … 42 61 #include <stdio.h> 43 62 #include <stdbool.h> 44 #include <stdarg.h>45 63 #include <string.h> 46 64 #include <errno.h> … … 50 68 #include <sys/types.h> 51 69 #include <unistd.h> 52 #include <assert.h>53 70 #include <iconv.h> 54 71 … … 230 247 231 248 232 /* HBIN block */ 249 /** HBIN block information 250 * @ingroup regfiMiddleLayer 251 */ 233 252 typedef struct _regfi_hbin 234 253 { 235 uint32_t file_off; /* my offset in the registry file */ 236 uint32_t ref_count; /* how many active records are pointing to this 237 * block (not used currently) 238 */ 239 240 uint32_t first_hbin_off; /* offset from first hbin block */ 241 uint32_t block_size; /* block size of this block 242 * Should be a multiple of 4096 (0x1000) 243 */ 244 uint32_t next_block; /* relative offset to next block. 245 * NOTE: This value may be unreliable! 246 */ 247 248 uint8_t magic[REGFI_HBIN_MAGIC_SIZE]; /* "hbin" */ 254 /** Offset of this HBIN in the registry file */ 255 uint32_t file_off; 256 257 /** Number of active records pointing to this block (not used currently) */ 258 uint32_t ref_count; 259 260 /** Offset from first hbin block */ 261 uint32_t first_hbin_off; 262 263 /** Block size of this block Should be a multiple of 4096 (0x1000) */ 264 uint32_t block_size; 265 266 /** Relative offset to next block. 267 * 268 * @note This value may be unreliable! 269 */ 270 uint32_t next_block; 271 272 /** Magic number for the HBIN (should be "hbin"). */ 273 uint8_t magic[REGFI_HBIN_MAGIC_SIZE]; 249 274 } REGFI_HBIN; 250 275 … … 262 287 263 288 289 /** Subkey-list structure 290 * @ingroup regfiMiddleLayer 291 */ 264 292 typedef struct _regfi_subkey_list 265 293 { … … 284 312 285 313 typedef uint32_t REGFI_VALUE_LIST_ELEM; 314 /** Value-list structure 315 * @ingroup regfiMiddleLayer 316 */ 286 317 typedef struct _regfi_value_list 287 318 { … … 295 326 296 327 328 /** Class name structure (used in storing SysKeys) 329 * @ingroup regfiBase 330 */ 297 331 typedef struct _regfi_classname 298 332 { 299 /* As converted to requested character encoding.*/333 /** As converted to requested REGFI_ENCODING */ 300 334 char* interpreted; 301 335 302 /* Represents raw buffer read from classname cell. */ 336 /** Represents raw buffer read from classname cell. 337 * 338 * Length of this item is specified in the size field. 339 */ 303 340 uint8_t* raw; 304 341 305 /* Length of the raw data. May be shorter than that indicated by parent key.*/ 342 /** Length of the raw data. 343 * 344 * May be shorter than that indicated by parent key. 345 */ 306 346 uint16_t size; 307 347 } REGFI_CLASSNAME; 308 348 309 349 350 /** Data record structure 351 * @ingroup regfiBase 352 */ 310 353 typedef struct _regfi_data 311 354 { 355 /** Data type of this data, as indicated by the referencing VK record. */ 312 356 uint32_t type; 313 357 314 /* Length of the raw data. */358 /** Length of the raw data. */ 315 359 uint32_t size; 316 360 317 /* This is always present, representing the raw data cell contents. */361 /** This is always present, representing the raw data cell contents. */ 318 362 uint8_t* raw; 319 363 320 /* Represents the length of the interpreted value. Meaning is type-specific.*/364 /** Represents the length of the interpreted value. Meaning is type-specific. */ 321 365 uint32_t interpreted_size; 322 366 323 /* These items represent interpreted versions of the raw attribute above. 324 * Only use the appropriate member according to the type field. 325 * In the event of an unknown type, use only the raw field. 367 /** These items represent interpreted versions of the REGFI_DATA::raw field. 368 * 369 * Only use the appropriate member according to the REGFI_DATA::type field. 370 * In the event of an unknown type, use only the REGFI_DATA::raw field. 326 371 */ 327 372 union _regfi_data_interpreted 328 373 { 329 uint8_t* none; /* */ 374 /** REG_NONE 375 * 376 * Stored as a raw buffer. Use REGFI_DATA::interpreted_size to determine 377 * length. 378 */ 379 uint8_t* none; 380 381 /** REG_SZ 382 * 383 * Stored as a NUL terminated string. Converted to the specified 384 * REGFI_ENCODING. 385 */ 330 386 uint8_t* string; 387 388 /** REG_EXPAND_SZ 389 * 390 * Stored as a NUL terminated string. Converted to the specified 391 * REGFI_ENCODING. 392 */ 331 393 uint8_t* expand_string; 332 uint8_t* binary; /* */ 394 395 /** REG_BINARY 396 * 397 * Stored as a raw buffer. Use REGFI_DATA::interpreted_size to determine 398 * length. 399 */ 400 uint8_t* binary; 401 402 /** REG_DWORD */ 333 403 uint32_t dword; 404 405 /** REG_DWORD_BE */ 334 406 uint32_t dword_be; 407 408 /** REG_LINK 409 * 410 * Stored as a NUL terminated string. Converted to the specified 411 * REGFI_ENCODING. 412 */ 335 413 uint8_t* link; 414 415 /** REG_MULTI_SZ 416 * 417 * Stored as a list of uint8_t* pointers, terminated with a NULL pointer. 418 * Each string element in the list is NUL terminated, and the character set 419 * is determined by the specified REGFI_ENCODING. 420 */ 336 421 uint8_t** multiple_string; 422 423 /** REG_QWORD */ 337 424 uint64_t qword; 338 425 … … 340 427 * the future as the formats become better understood. 341 428 */ 429 430 /** REG_RESOURCE_LIST 431 * 432 * Stored as a raw buffer. Use REGFI_DATA::interpreted_size to determine 433 * length. 434 */ 342 435 uint8_t* resource_list; 436 437 /** REG_FULL_RESOURCE_DESCRIPTOR 438 * 439 * Stored as a raw buffer. Use REGFI_DATA::interpreted_size to determine 440 * length. 441 */ 343 442 uint8_t* full_resource_descriptor; 443 444 /** REG_RESOURCE_REQUIREMENTS_LIST 445 * 446 * Stored as a raw buffer. Use REGFI_DATA::interpreted_size to determine 447 * length. 448 */ 344 449 uint8_t* resource_requirements_list; 345 450 } interpreted; … … 347 452 348 453 349 /* Value record */ 350 typedef struct 454 /** Value structure 455 * @ingroup regfiBase 456 */ 457 typedef struct 351 458 { 352 uint32_t offset; /* Real offset of this record's cell in the file */ 353 uint32_t cell_size; /* ((start_offset - end_offset) & 0xfffffff8) */ 354 355 REGFI_DATA* data; /* XXX: deprecated */ 356 357 char* valuename; 459 /** Real offset of this record's cell in the file */ 460 uint32_t offset; 461 462 /** ((start_offset - end_offset) & 0xfffffff8) */ 463 uint32_t cell_size; 464 465 /* XXX: deprecated */ 466 REGFI_DATA* data; 467 468 /** The name of this value converted to desired REGFI_ENCODING. 469 * 470 * This conversion typically occurs automatically through REGFI_ITERATOR 471 * settings. String is NUL terminated. 472 */ 473 char* valuename; 474 475 /** The raw value name 476 * 477 * Length of the buffer is stored in name_length. 478 */ 358 479 uint8_t* valuename_raw; 480 481 /** Length of valuename_raw */ 359 482 uint16_t name_length; 360 uint32_t hbin_off; /* offset from beginning of this hbin block */ 483 484 /** Offset from beginning of this hbin block */ 485 uint32_t hbin_off; 361 486 362 uint32_t data_size; /* As reported in the VK record. May be different than 363 * That obtained while parsing the data cell itself. */ 364 uint32_t data_off; /* Offset of data cell (virtual) */ 487 /** Size of the value's data as reported in the VK record. 488 * 489 * May be different than that obtained while parsing the data cell itself. 490 */ 491 uint32_t data_size; 492 493 /** Virtual offset of data cell */ 494 uint32_t data_off; 495 496 /** Value's data type */ 365 497 uint32_t type; 498 499 /** VK record's magic number (should be "vk") */ 366 500 uint8_t magic[REGFI_CELL_MAGIC_SIZE]; 501 502 /** VK record flags */ 367 503 uint16_t flags; 504 505 /* XXX: A 2-byte field of unknown purpose stored in the VK record */ 368 506 uint16_t unknown1; 369 bool data_in_offset; 507 508 /** Whether or not the data record is stored in the VK record's data_off field. 509 * 510 * This information is derived from the high bit of the raw data size field. 511 */ 512 bool data_in_offset; 370 513 } REGFI_VK_REC; 371 514 … … 374 517 struct _regfi_sk_rec; 375 518 519 /** Security structure 520 * @ingroup regfiBase 521 */ 376 522 typedef struct _regfi_sk_rec 377 523 { 378 uint32_t offset; /* Real file offset of this record */ 379 uint32_t cell_size; /* ((start_offset - end_offset) & 0xfffffff8) */ 380 524 /** Real file offset of this record */ 525 uint32_t offset; 526 527 /** ((start_offset - end_offset) & 0xfffffff8) */ 528 uint32_t cell_size; 529 530 /** The stored Windows security descriptor for this SK record */ 381 531 WINSEC_DESC* sec_desc; 382 uint32_t hbin_off; /* offset from beginning of this hbin block */ 532 533 /** Offset of this record from beginning of this hbin block */ 534 uint32_t hbin_off; 383 535 536 /** Offset of the previous SK record in the linked list of SK records */ 384 537 uint32_t prev_sk_off; 538 539 /** Offset of the next SK record in the linked list of SK records */ 385 540 uint32_t next_sk_off; 541 542 /** Number of keys referencing this SK record */ 386 543 uint32_t ref_count; 387 uint32_t desc_size; /* size of security descriptor */ 544 545 /** Size of security descriptor (sec_desc) */ 546 uint32_t desc_size; 547 548 /* XXX: A 2-byte field of unknown purpose */ 388 549 uint16_t unknown_tag; 550 551 /** The magic number for this record (should be "sk") */ 389 552 uint8_t magic[REGFI_CELL_MAGIC_SIZE]; 390 553 } REGFI_SK_REC; 391 554 392 555 393 /* Key Name */ 556 /** Key structure 557 * @ingroup regfiBase 558 */ 394 559 typedef struct 395 560 { 396 uint32_t offset; /* Real offset of this record's cell in the file */ 397 uint32_t cell_size; /* Actual or estimated length of the cell. 398 * Always in multiples of 8. 399 */ 400 401 /* link in the other records here */ 561 /** Real offset of this record's cell in the file */ 562 uint32_t offset; 563 564 /** Actual or estimated length of the cell. 565 * Always in multiples of 8. 566 */ 567 uint32_t cell_size; 568 569 /** Preloaded value-list for this key. 570 * This element is loaded automatically when using the iterator interface and 571 * possibly some lower layer interfaces. 572 */ 402 573 REGFI_VALUE_LIST* values; 574 575 576 /** Preloaded subkey-list for this key. 577 * This element is loaded automatically when using the iterator interface and 578 * possibly some lower layer interfaces. 579 */ 403 580 REGFI_SUBKEY_LIST* subkeys; 404 581 405 /* header information*/582 /** Key flags */ 406 583 uint16_t flags; 584 585 /** Magic number of key (should be "nk") */ 407 586 uint8_t magic[REGFI_CELL_MAGIC_SIZE]; 587 588 /** Key's last modification time */ 408 589 REGFI_NTTIME mtime; 590 591 /** Length of keyname_raw */ 409 592 uint16_t name_length; 593 594 /** Length of referenced classname */ 410 595 uint16_t classname_length; 596 597 /** The name of this key converted to desired REGFI_ENCODING. 598 * 599 * This conversion typically occurs automatically through REGFI_ITERATOR 600 * settings. String is NUL terminated. 601 */ 411 602 char* keyname; 603 604 /** The raw key name 605 * 606 * Length of the buffer is stored in name_length. 607 */ 412 608 uint8_t* keyname_raw; 413 uint32_t parent_off; /* pointer to parent key */ 609 610 /** Virutal offset of parent key */ 611 uint32_t parent_off; 612 613 /** Virutal offset of classname key */ 414 614 uint32_t classname_off; 415 615 416 /* max lengths */ 417 uint32_t max_bytes_subkeyname; /* max subkey name * 2 */ 418 uint32_t max_bytes_subkeyclassname; /* max subkey classname length (as if) */ 419 uint32_t max_bytes_valuename; /* max valuename * 2 */ 420 uint32_t max_bytes_value; /* max value data size */ 616 /* XXX: max subkey name * 2 */ 617 uint32_t max_bytes_subkeyname; 618 619 /* XXX: max subkey classname length (as if) */ 620 uint32_t max_bytes_subkeyclassname; 621 622 /* XXX: max valuename * 2 */ 623 uint32_t max_bytes_valuename; 624 625 /* XXX: max value data size */ 626 uint32_t max_bytes_value; 421 627 422 /* unknowns*/628 /* XXX: Fields of unknown purpose */ 423 629 uint32_t unknown1; 424 630 uint32_t unknown2; … … 426 632 uint32_t unk_index; /* nigel says run time index ? */ 427 633 428 /* children*/634 /** Number of subkeys */ 429 635 uint32_t num_subkeys; 430 uint32_t subkeys_off; /* offset of subkey list that points to NK records */ 636 637 /** Virtual offset of subkey-list */ 638 uint32_t subkeys_off; 639 640 /** Number of values for this key */ 431 641 uint32_t num_values; 432 uint32_t values_off; /* value lists which point to VK records */ 433 uint32_t sk_off; /* offset to SK record */ 642 643 /** Virtual offset of value-list */ 644 uint32_t values_off; 645 646 /** Virtual offset of SK record */ 647 uint32_t sk_off; 434 648 } REGFI_NK_REC; 435 649 436 650 437 651 438 /* REGF block */ 652 /** Registry hive file data structure 653 * 654 * This essential structure stores run-time information about a single open 655 * registry hive as well as file header (REGF block) data. This structure 656 * also stores a list of warnings and error messages generated while parsing 657 * the registry hive. These can be tuned using @ref regfi_set_message_mask. 658 * Messages may be retrieved using @ref regfi_get_messages. 659 * 660 * @note If the message mask is set to record any messages, dependent code 661 * must use @ref regfi_get_messages periodically to clear the message 662 * queue. Otherwise, this structure will grow in size over time as 663 * messages queue up. 664 * 665 * @ingroup regfiBase 666 */ 439 667 typedef struct 440 668 { … … 513 741 514 742 743 /** Registry hive iterator 744 * @ingroup regfiIteratorLayer 745 */ 515 746 typedef struct _regfi_iterator 516 747 { 748 /** The registry hive this iterator is associated with */ 517 749 REGFI_FILE* f; 750 751 /** All current parent keys and associated iterator positions */ 518 752 void_stack* key_positions; 753 754 /** The current key */ 519 755 REGFI_NK_REC* cur_key; 756 757 /** The encoding that all strings are converted to as set during iterator 758 * creation. 759 */ 520 760 REGFI_ENCODING string_encoding; 761 762 /** Index of the current subkey */ 521 763 uint32_t cur_subkey; 764 765 /** Index of the current value */ 522 766 uint32_t cur_value; 523 767 } REGFI_ITERATOR; … … 534 778 535 779 780 /** General purpose buffer with stored length 781 * @ingroup regfiBottomLayer 782 */ 536 783 typedef struct _regfi_buffer 537 784 { … … 541 788 542 789 790 543 791 /******************************************************************************/ 544 792 /** 545 * @defgroup regfiBase Base Functions: Usable with Any Layer546 * 547 * These functions don't fit particularly well in any of the other layers or548 * are intended for use with any of the APIlayers.793 * @defgroup regfiBase Base Layer: Essential Functions and Data Structures 794 * 795 * These functions are either necessary for normal use of the regfi API or just 796 * don't fit particularly well in any of the other layers. 549 797 */ 550 798 /******************************************************************************/ 551 552 799 553 800 /** Attempts to open a registry hive and allocate related data structures. … … 658 905 /******************************************************************************/ 659 906 /** 660 * @defgroup regfi TopLayer TopLayer: Primary regfi Library Interface907 * @defgroup regfiIteratorLayer Iterator Layer: Primary regfi Library Interface 661 908 * 662 909 * This top layer of API functions provides an iterator interface which makes … … 681 928 * Must be free()d with regfi_iterator_free. 682 929 * 683 * @ingroup regfi TopLayer930 * @ingroup regfiIteratorLayer 684 931 */ 685 932 REGFI_ITERATOR* regfi_iterator_new(REGFI_FILE* file, … … 693 940 * @param i the iterator to be freed 694 941 * 695 * @ingroup regfi TopLayer942 * @ingroup regfiIteratorLayer 696 943 */ 697 944 void regfi_iterator_free(REGFI_ITERATOR* i); … … 709 956 * depth-first iteration particularly easy. 710 957 * 711 * @ingroup regfi TopLayer958 * @ingroup regfiIteratorLayer 712 959 */ 713 960 bool regfi_iterator_down(REGFI_ITERATOR* i); … … 721 968 * associated with the current key is lost. 722 969 * 723 * @ingroup regfi TopLayer970 * @ingroup regfiIteratorLayer 724 971 */ 725 972 bool regfi_iterator_up(REGFI_ITERATOR* i); … … 732 979 * @return true on success, false on failure. 733 980 * 734 * @ingroup regfi TopLayer981 * @ingroup regfiIteratorLayer 735 982 */ 736 983 bool regfi_iterator_to_root(REGFI_ITERATOR* i); … … 753 1000 * in its original position. 754 1001 * 755 * @ingroup regfi TopLayer1002 * @ingroup regfiIteratorLayer 756 1003 */ 757 1004 bool regfi_iterator_walk_path(REGFI_ITERATOR* i, const char** path); … … 764 1011 * @return A read-only key structure for the current key, or NULL on failure. 765 1012 * 766 * @ingroup regfi TopLayer1013 * @ingroup regfiIteratorLayer 767 1014 */ 768 1015 const REGFI_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i); … … 775 1022 * @return A read-only SK structure, or NULL on failure. 776 1023 * 777 * @ingroup regfi TopLayer1024 * @ingroup regfiIteratorLayer 778 1025 */ 779 1026 const REGFI_SK_REC* regfi_iterator_cur_sk(REGFI_ITERATOR* i); … … 790 1037 * regfi_free_key. 791 1038 * 792 * @ingroup regfi TopLayer1039 * @ingroup regfiIteratorLayer 793 1040 */ 794 1041 REGFI_NK_REC* regfi_iterator_first_subkey(REGFI_ITERATOR* i); … … 803 1050 * regfi_free_key. 804 1051 * 805 * @ingroup regfi TopLayer1052 * @ingroup regfiIteratorLayer 806 1053 */ 807 1054 REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i); … … 816 1063 * failure. Newly allocated keys must be freed with regfi_free_key. 817 1064 * 818 * @ingroup regfi TopLayer1065 * @ingroup regfiIteratorLayer 819 1066 */ 820 1067 REGFI_NK_REC* regfi_iterator_next_subkey(REGFI_ITERATOR* i); … … 830 1077 * the subkey index remains at the same location as before the call. 831 1078 * 832 * @ingroup regfi TopLayer1079 * @ingroup regfiIteratorLayer 833 1080 */ 834 1081 bool regfi_iterator_find_subkey(REGFI_ITERATOR* i, … … 845 1092 * regfi_free_value. 846 1093 * 847 * @ingroup regfi TopLayer1094 * @ingroup regfiIteratorLayer 848 1095 */ 849 1096 REGFI_VK_REC* regfi_iterator_first_value(REGFI_ITERATOR* i); … … 858 1105 * regfi_free_value. 859 1106 * 860 * @ingroup regfi TopLayer1107 * @ingroup regfiIteratorLayer 861 1108 */ 862 1109 REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i); … … 871 1118 * failure. Newly allocated keys must be freed with regfi_free_value. 872 1119 * 873 * @ingroup regfi TopLayer1120 * @ingroup regfiIteratorLayer 874 1121 */ 875 1122 REGFI_VK_REC* regfi_iterator_next_value(REGFI_ITERATOR* i); … … 885 1132 * the value index remains at the same location as before the call. 886 1133 * 887 * @ingroup regfi TopLayer1134 * @ingroup regfiIteratorLayer 888 1135 */ 889 1136 bool regfi_iterator_find_value(REGFI_ITERATOR* i, … … 898 1145 * Classname structures must be freed with regfi_free_classname. 899 1146 * 900 * @ingroup regfi TopLayer1147 * @ingroup regfiIteratorLayer 901 1148 */ 902 1149 REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i, … … 912 1159 * Data structures must be freed with regfi_free_data. 913 1160 * 914 * @ingroup regfi TopLayer1161 * @ingroup regfiIteratorLayer 915 1162 */ 916 1163 REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i, … … 921 1168 /******************************************************************************/ 922 1169 /** 923 * @defgroup regfi MiddleLayer Middle Layer: Logical Data Structure Loading1170 * @defgroup regfiGlueLayer Glue Layer: Logical Data Structure Loading 924 1171 */ 925 1172 /******************************************************************************/ … … 929 1176 * XXX: finish documenting 930 1177 * 931 * @ingroup regfi MiddleLayer1178 * @ingroup regfiGlueLayer 932 1179 */ 933 1180 REGFI_NK_REC* regfi_load_key(REGFI_FILE* file, uint32_t offset, … … 940 1187 * XXX: finish documenting 941 1188 * 942 * @ingroup regfi MiddleLayer1189 * @ingroup regfiGlueLayer 943 1190 */ 944 1191 REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32_t offset, … … 951 1198 * XXX: finish documenting 952 1199 * 953 * @ingroup regfi MiddleLayer1200 * @ingroup regfiGlueLayer 954 1201 */ 955 1202 REGFI_SUBKEY_LIST* regfi_load_subkeylist(REGFI_FILE* file, uint32_t offset, … … 962 1209 * XXX: finish documenting 963 1210 * 964 * @ingroup regfi MiddleLayer1211 * @ingroup regfiGlueLayer 965 1212 */ 966 1213 REGFI_VALUE_LIST* regfi_load_valuelist(REGFI_FILE* file, uint32_t offset, … … 974 1221 * XXX: finish documenting 975 1222 * 976 * @ingroup regfi MiddleLayer1223 * @ingroup regfiGlueLayer 977 1224 */ 978 1225 REGFI_BUFFER regfi_load_data(REGFI_FILE* file, uint32_t voffset, … … 985 1232 * XXX: finish documenting 986 1233 * 987 * @ingroup regfi MiddleLayer1234 * @ingroup regfiGlueLayer 988 1235 */ 989 1236 REGFI_BUFFER regfi_load_big_data(REGFI_FILE* file, uint32_t offset, … … 998 1245 * XXX: finish documenting 999 1246 * 1000 * @ingroup regfi MiddleLayer1247 * @ingroup regfiGlueLayer 1001 1248 */ 1002 1249 bool regfi_interpret_data(REGFI_FILE* file, … … 1009 1256 * XXX: finish documenting 1010 1257 * 1011 * @ingroup regfi MiddleLayer1258 * @ingroup regfiGlueLayer 1012 1259 */ 1013 1260 void regfi_free_classname(REGFI_CLASSNAME* classname); … … 1018 1265 * XXX: finish documenting 1019 1266 * 1020 * @ingroup regfi MiddleLayer1267 * @ingroup regfiGlueLayer 1021 1268 */ 1022 1269 void regfi_free_data(REGFI_DATA* data); … … 1029 1276 * XXX: finish documenting 1030 1277 * 1031 * @ingroup regfi MiddleLayer1278 * @ingroup regfiGlueLayer 1032 1279 */ 1033 1280 const REGFI_SK_REC* regfi_load_sk(REGFI_FILE* file, uint32_t offset, … … 1039 1286 * XXX: finish documenting 1040 1287 * 1041 * @ingroup regfi MiddleLayer1288 * @ingroup regfiGlueLayer 1042 1289 */ 1043 1290 const REGFI_HBIN* regfi_lookup_hbin(REGFI_FILE* file, uint32_t offset); … … 1047 1294 /******************************************************************************/ 1048 1295 /** 1049 * @defgroup regfi BottomLayer BottomLayer: Direct Data Structure Access1296 * @defgroup regfiParseLayer Parsing Layer: Direct Data Structure Access 1050 1297 */ 1051 1298 /******************************************************************************/ … … 1066 1313 * @return A newly allocated NK record structure, or NULL on failure. 1067 1314 * 1068 * @ingroup regfi BottomLayer1315 * @ingroup regfiParseLayer 1069 1316 */ 1070 1317 REGFI_NK_REC* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, … … 1076 1323 * XXX: finish documenting 1077 1324 * 1078 * @ingroup regfi BottomLayer1325 * @ingroup regfiParseLayer 1079 1326 */ 1080 1327 REGFI_SUBKEY_LIST* regfi_parse_subkeylist(REGFI_FILE* file, uint32_t offset, … … 1086 1333 * XXX: finish documenting 1087 1334 * 1088 * @ingroup regfi BottomLayer1335 * @ingroup regfiParseLayer 1089 1336 */ 1090 1337 REGFI_VK_REC* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, … … 1096 1343 * XXX: finish documenting 1097 1344 * 1098 * @ingroup regfi BottomLayer1345 * @ingroup regfiParseLayer 1099 1346 */ 1100 1347 REGFI_SK_REC* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, … … 1109 1356 * XXX: finish documenting 1110 1357 * 1111 * @ingroup regfi BottomLayer1358 * @ingroup regfiParseLayer 1112 1359 */ 1113 1360 range_list* regfi_parse_unalloc_cells(REGFI_FILE* file); … … 1118 1365 * XXX: finish documenting 1119 1366 * 1120 * @ingroup regfi BottomLayer1367 * @ingroup regfiParseLayer 1121 1368 */ 1122 1369 bool regfi_parse_cell(int fd, uint32_t offset, … … 1129 1376 * XXX: finish documenting 1130 1377 * 1131 * @ingroup regfi BottomLayer1378 * @ingroup regfiParseLayer 1132 1379 */ 1133 1380 uint8_t* regfi_parse_classname(REGFI_FILE* file, uint32_t offset, … … 1140 1387 * XXX: finish documenting 1141 1388 * 1142 * @ingroup regfi BottomLayer1389 * @ingroup regfiParseLayer 1143 1390 */ 1144 1391 REGFI_BUFFER regfi_parse_data(REGFI_FILE* file, uint32_t offset, … … 1151 1398 * XXX: finish documenting 1152 1399 * 1153 * @ingroup regfi BottomLayer1400 * @ingroup regfiParseLayer 1154 1401 */ 1155 1402 REGFI_BUFFER regfi_parse_little_data(REGFI_FILE* file, uint32_t voffset, … … 1163 1410 REGFI_ENCODING output_encoding); 1164 1411 void regfi_subkeylist_free(REGFI_SUBKEY_LIST* list); 1165 uint32_t 1412 uint32_t regfi_read(int fd, uint8_t* buf, uint32_t* length); 1166 1413 1167 1414 const char* regfi_type_val2str(unsigned int val);
Note: See TracChangeset
for help on using the changeset viewer.