tools/mkhive/registry.h

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2003 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  * COPYRIGHT:       See COPYING in the top level directory
  21  * PROJECT:         ReactOS hive maker
  22  * FILE:            tools/mkhive/registry.h
  23  * PURPOSE:         Registry code
  24  * PROGRAMMER:      Eric Kohl
  25  */
  26
  27 #ifndef __REGISTRY_H__
  28 #define __REGISTRY_H__
  29
  30
  31 #define INVALID_HANDLE_VALUE  NULL
  32
  33 typedef struct _LIST_ENTRY
  34 {
  35   struct _LIST_ENTRY *Flink;
  36   struct _LIST_ENTRY *Blink;
  37 } LIST_ENTRY, *PLIST_ENTRY;
  38
  39
  40 typedef struct _REG_KEY
  41 {
  42   LIST_ENTRY KeyList;
  43   LIST_ENTRY SubKeyList;
  44   LIST_ENTRY ValueList;
  45
  46   ULONG SubKeyCount;
  47   ULONG ValueCount;
  48
  49   ULONG NameSize;
  50   PUCHAR Name;
  51
  52   /* default data */
  53   ULONG DataType;
  54   ULONG DataSize;
  55   PUCHAR Data;
  56 } KEY, *HKEY, **PHKEY;
  57
  58
  59 typedef struct _REG_VALUE
  60 {
  61   LIST_ENTRY ValueList;
  62
  63   /* value name */
  64   ULONG NameSize;
  65   PUCHAR Name;
  66
  67   /* value data */
  68   ULONG DataType;
  69   ULONG DataSize;
  70   PUCHAR Data;
  71 } VALUE, *PVALUE;
  72
  73
  74 #define ERROR_SUCCESS                    0L
  75 #define ERROR_PATH_NOT_FOUND             2L
  76 #define ERROR_OUTOFMEMORY                14L
  77 #define ERROR_INVALID_PARAMETER          87L
  78 #define ERROR_MORE_DATA                  234L
  79 #define ERROR_NO_MORE_ITEMS              259L
  80
  81
  82 #define assert(x)
  83
  84 /*
  85  * VOID
  86  * InitializeListHead (
  87  *              PLIST_ENTRY     ListHead
  88  *              );
  89  *
  90  * FUNCTION: Initializes a double linked list
  91  * ARGUMENTS:
  92  *         ListHead = Caller supplied storage for the head of the list
  93  */
  94 #define InitializeListHead(ListHead) \
  95 { \
  96         (ListHead)->Flink = (ListHead); \
  97         (ListHead)->Blink = (ListHead); \
  98 }
  99
 100
 101 /*
 102  * VOID
 103  * InsertHeadList (
 104  *              PLIST_ENTRY     ListHead,
 105  *              PLIST_ENTRY     Entry
 106  *              );
 107  *
 108  * FUNCTION: Inserts an entry in a double linked list
 109  * ARGUMENTS:
 110  *        ListHead = Head of the list
 111  *        Entry = Entry to insert
 112  */
 113 #define InsertHeadList(ListHead, ListEntry) \
 114 { \
 115         PLIST_ENTRY OldFlink; \
 116         OldFlink = (ListHead)->Flink; \
 117         (ListEntry)->Flink = OldFlink; \
 118         (ListEntry)->Blink = (ListHead); \
 119         OldFlink->Blink = (ListEntry); \
 120         (ListHead)->Flink = (ListEntry); \
 121         assert((ListEntry) != NULL); \
 122         assert((ListEntry)->Blink!=NULL); \
 123         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 124         assert((ListEntry)->Flink != NULL); \
 125         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 126 }
 127
 128
 129 /*
 130  * VOID
 131  * InsertTailList (
 132  *              PLIST_ENTRY     ListHead,
 133  *              PLIST_ENTRY     Entry
 134  *              );
 135  *
 136  * FUNCTION:
 137  *      Inserts an entry in a double linked list
 138  *
 139  * ARGUMENTS:
 140  *      ListHead = Head of the list
 141  *      Entry = Entry to insert
 142  */
 143 #define InsertTailList(ListHead, ListEntry) \
 144 { \
 145         PLIST_ENTRY OldBlink; \
 146         OldBlink = (ListHead)->Blink; \
 147         (ListEntry)->Flink = (ListHead); \
 148         (ListEntry)->Blink = OldBlink; \
 149         OldBlink->Flink = (ListEntry); \
 150         (ListHead)->Blink = (ListEntry); \
 151         assert((ListEntry) != NULL); \
 152         assert((ListEntry)->Blink != NULL); \
 153         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 154         assert((ListEntry)->Flink != NULL); \
 155         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 156 }
 157
 158 /*
 159  * BOOLEAN
 160  * IsListEmpty (
 161  *      PLIST_ENTRY     ListHead
 162  *      );
 163  *
 164  * FUNCTION:
 165  *      Checks if a double linked list is empty
 166  *
 167  * ARGUMENTS:
 168  *      ListHead = Head of the list
 169 */
 170 #define IsListEmpty(ListHead) \
 171         ((ListHead)->Flink == (ListHead))
 172
 173
 174 /*
 175  *VOID
 176  *RemoveEntryList (
 177  *      PLIST_ENTRY     Entry
 178  *      );
 179  *
 180  * FUNCTION:
 181  *      Removes an entry from a double linked list
 182  *
 183  * ARGUMENTS:
 184  *      ListEntry = Entry to remove
 185  */
 186 #define RemoveEntryList(ListEntry) \
 187 { \
 188         PLIST_ENTRY OldFlink; \
 189         PLIST_ENTRY OldBlink; \
 190         assert((ListEntry) != NULL); \
 191         assert((ListEntry)->Blink!=NULL); \
 192         assert((ListEntry)->Blink->Flink == (ListEntry)); \
 193         assert((ListEntry)->Flink != NULL); \
 194         assert((ListEntry)->Flink->Blink == (ListEntry)); \
 195         OldFlink = (ListEntry)->Flink; \
 196         OldBlink = (ListEntry)->Blink; \
 197         OldFlink->Blink = OldBlink; \
 198         OldBlink->Flink = OldFlink; \
 199         (ListEntry)->Flink = NULL; \
 200         (ListEntry)->Blink = NULL; \
 201 }
 202
 203 /*
 204  * PURPOSE: Returns the byte offset of a field within a structure
 205  */
 206 #define FIELD_OFFSET(Type,Field) (LONG)(&(((Type *)(0))->Field))
 207
 208 /*
 209  * PURPOSE: Returns the base address structure if the caller knows the
 210  * address of a field within the structure
 211  * ARGUMENTS:
 212  *          Address = address of the field
 213  *          Type = Type of the whole structure
 214  *          Field = Name of the field whose address is none
 215  */
 216 #define CONTAINING_RECORD(Address,Type,Field) \
 217         (Type *)(((LONG)Address) - FIELD_OFFSET(Type,Field))
 218
 219
 220 #define REG_NONE 0
 221 #define REG_SZ 1
 222 #define REG_EXPAND_SZ 2
 223 #define REG_BINARY 3
 224 #define REG_DWORD 4
 225 #define REG_DWORD_BIG_ENDIAN 5
 226 #define REG_DWORD_LITTLE_ENDIAN 4
 227 #define REG_LINK 6
 228 #define REG_MULTI_SZ 7
 229 #define REG_RESOURCE_LIST 8
 230 #define REG_FULL_RESOURCE_DESCRIPTOR 9
 231 #define REG_RESOURCE_REQUIREMENTS_LIST 10
 232
 233
 234
 235 VOID
 236 RegInitializeRegistry(VOID);
 237
 238 LONG
 239 RegCreateKey(HKEY ParentKey,
 240              PCHAR KeyName,
 241              PHKEY Key);
 242
 243 LONG
 244 RegDeleteKey(HKEY Key,
 245              PCHAR Name);
 246
 247 LONG
 248 RegEnumKey(HKEY Key,
 249            ULONG Index,
 250            PCHAR Name,
 251            PULONG NameSize);
 252
 253 LONG
 254 RegOpenKey(HKEY ParentKey,
 255            PCHAR KeyName,
 256            PHKEY Key);
 257
 258
 259 LONG
 260 RegSetValue(HKEY Key,
 261             PCHAR ValueName,
 262             ULONG Type,
 263             PUCHAR Data,
 264             ULONG DataSize);
 265
 266 LONG
 267 RegQueryValue(HKEY Key,
 268               PCHAR ValueName,
 269               PULONG Type,
 270               PUCHAR Data,
 271               PULONG DataSize);
 272
 273 LONG
 274 RegDeleteValue(HKEY Key,
 275                PCHAR ValueName);
 276
 277 LONG
 278 RegEnumValue(HKEY Key,
 279              ULONG Index,
 280              PCHAR ValueName,
 281              PULONG NameSize,
 282              PULONG Type,
 283              PUCHAR Data,
 284              PULONG DataSize);
 285
 286 ULONG
 287 RegGetSubKeyCount (HKEY Key);
 288
 289 ULONG
 290 RegGetValueCount (HKEY Key);
 291
 292
 293 #if 0
 294 BOOL
 295 RegImportTextHive(PCHAR ChunkBase,
 296                   U32 ChunkSize);
 297
 298 BOOL
 299 RegImportBinaryHive(PCHAR ChunkBase,
 300                     U32 ChunkSize);
 301 #endif
 302
 303 #endif /* __REGISTRY_H__ */
 304
 305 /* EOF */
 306