reactos/boot/freeldr/freeldr/reactos/registry.h

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