mcs/class/corlib/Microsoft.Win32/Win32RegistryApi.cs

   1 //
   2 // Microsoft.Win32/Win32RegistryApi.cs: wrapper for win32 registry API
   3 //
   4 // Authos:
   5 //      Erik LeBel (eriklebel@yahoo.ca)
   6 //      Jackson Harper (jackson@ximian.com)
   7 //
   8 // Copyright (C) Erik LeBel 2004
   9 // (C) 2004 Novell, Inc (http://www.novell.com)
  10 //
  11
  12 using System;
  13 using System.Runtime.InteropServices;
  14 using System.Text;
  15
  16 namespace Microsoft.Win32
  17 {
  18         /// <summary>
  19         ///     Function stubs, constants and helper functions for
  20         ///     the Win32 registry manipulation utilities.
  21         /// </summary>
  22         internal class Win32RegistryApi : IRegistryApi
  23         {
  24                 // bit masks for registry key open access permissions
  25                 public int OpenRegKeyRead {
  26                         get { return 0x00020019; }
  27                 }
  28
  29                 public int OpenRegKeyWrite {
  30                         get { return 0x00020006; }
  31                 }
  32
  33                 // type values for registry value data
  34                 public int RegStringType {
  35                         get { return 1; }
  36                 }
  37
  38                 public int RegEnvironmentString {
  39                         get { return 2; }
  40                 }
  41
  42                 public int RegBinaryType {
  43                         get { return 3; }
  44                 }
  45
  46                 public int RegDwordType {
  47                         get { return 4; }
  48                 }
  49
  50                 public int RegStringArrayType {
  51                         get { return 7; }
  52                 }
  53
  54                 /// <summary>
  55                 ///     Create a registry key.
  56                 /// </summary>
  57                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
  58                 private static extern int RegCreateKey_Internal (IntPtr keyBase,
  59                                 string keyName, out IntPtr keyHandle);
  60
  61                 public int RegCreateKey (IntPtr keybase, string keyname, out IntPtr handle)
  62                 {
  63                         return RegCreateKey_Internal (keybase, keyname, out handle);
  64                 }
  65
  66                 /// <summary>
  67                 ///     Close a registry key.
  68                 /// </summary>
  69                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
  70                 private static extern int RegCloseKey_Internal (IntPtr keyHandle);
  71
  72                 public int RegCloseKey (IntPtr handle)
  73                 {
  74                         return RegCloseKey_Internal (handle);
  75                 }
  76
  77                 /// <summary>
  78                 ///     Flush a registry key's current state to disk.
  79                 /// </summary>
  80                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
  81                 private static extern int RegFlushKey_Internal (IntPtr keyHandle);
  82
  83                 public int RegFlushKey (IntPtr handle)
  84                 {
  85                         return RegFlushKey_Internal (handle);
  86                 }
  87
  88                 /// <summary>
  89                 ///     Open a registry key.
  90                 ///     'unknown' must be zero.
  91                 /// </summary>
  92                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
  93                 private static extern int RegOpenKeyEx_Internal (IntPtr keyBase,
  94                                 string keyName, IntPtr reserved, int access,
  95                                 out IntPtr keyHandle);
  96
  97                 public int RegOpenKeyEx (IntPtr keybase, string keyname, IntPtr reserved,
  98                                 int access, out IntPtr handle)
  99                 {
 100                         return RegOpenKeyEx_Internal (keybase, keyname, reserved, access, out handle);
 101                 }
 102
 103                 /// <summary>
 104                 ///     Delete a registry key.
 105                 /// </summary>
 106                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 107                 private static extern int RegDeleteKey_Internal (IntPtr keyHandle,
 108                                 string valueName);
 109
 110                 public int RegDeleteKey (IntPtr handle, string valuename)
 111                 {
 112                         return RegDeleteKey_Internal (handle, valuename);
 113                 }
 114
 115                 /// <summary>
 116                 ///     Delete a registry value.
 117                 /// </summary>
 118                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 119                 private static extern int RegDeleteValue_Internal (IntPtr keyHandle,
 120                                 string valueName);
 121
 122                 public int RegDeleteValue (IntPtr handle, string valuename)
 123                 {
 124                         return RegDeleteValue_Internal (handle, valuename);
 125                 }
 126
 127                 /// <summary>
 128                 ///     Fetch registry key subkeys itteratively.
 129                 /// </summary>
 130                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 131                 private static extern int RegEnumKey_Internal (IntPtr keyBase, int index,
 132                                 [Out] byte[] nameBuffer, int bufferLength);
 133
 134                 public int RegEnumKey (IntPtr keybase, int index,
 135                                 [Out] byte [] namebuffer, int buffer_length)
 136                 {
 137                         return RegEnumKey_Internal (keybase, index, namebuffer, buffer_length);
 138                 }
 139
 140                 /// <summary>
 141                 ///     Fetch registry key value names itteratively.
 142                 ///
 143                 ///     Arguments 'reserved', 'data', 'dataLength'
 144                 ///     should be set to IntPtr.Zero.
 145                 /// </summary>
 146                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 147                 private static extern int RegEnumValue_Internal (IntPtr keyBase,
 148                                 int index, StringBuilder nameBuffer,
 149                                 ref int nameLength, IntPtr reserved,
 150                                 ref int type, IntPtr data, IntPtr dataLength);
 151
 152                 public int RegEnumValue (IntPtr keybase, int index, StringBuilder namebuffer,
 153                                 ref int namelength, IntPtr reserved, ref int type, IntPtr data,
 154                                 IntPtr datalength)
 155                 {
 156                         return RegEnumValue_Internal (keybase, index, namebuffer, ref namelength,
 157                                         reserved, ref type, data, datalength);
 158                 }
 159
 160                 /// <summary>
 161                 ///     Set a registry value with string builder data.
 162                 /// </summary>
 163                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 164                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 165                                 string valueName, IntPtr reserved, int type,
 166                                 StringBuilder data, int rawDataLength);
 167
 168                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 169                                 int type, StringBuilder data, int datalength)
 170                 {
 171                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 172                                         type, data, datalength);
 173                 }
 174
 175                 /// <summary>
 176                 ///     Set a registry value with string data.
 177                 /// </summary>
 178                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 179                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 180                                 string valueName, IntPtr reserved, int type,
 181                                 string data, int rawDataLength);
 182
 183                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 184                                 int type, string data, int datalength)
 185                 {
 186                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 187                                         type, data, datalength);
 188                 }
 189
 190                 /// <summary>
 191                 ///     Set a registry value with binary data (a byte array).
 192                 /// </summary>
 193                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 194                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 195                                 string valueName, IntPtr reserved, int type,
 196                                 byte[] rawData, int rawDataLength);
 197
 198                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 199                                 int type, byte [] data, int datalength)
 200                 {
 201                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 202                                         type, data, datalength);
 203                 }
 204
 205                 /// <summary>
 206                 ///     Set a registry value to a DWORD value.
 207                 /// </summary>
 208                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 209                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 210                                 string valueName, IntPtr reserved, int type,
 211                                 ref int data, int rawDataLength);
 212
 213                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 214                                 int type, ref int data, int datalength)
 215                 {
 216                         return RegSetValueEx_Internal (keybase, valuename, reserved, type,
 217                                         ref data, datalength);
 218                 }
 219
 220                 /// <summary>
 221                 ///     Get a registry value's info. No data.
 222                 /// </summary>
 223                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 224                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 225                                 string valueName, IntPtr reserved, ref int type,
 226                                 IntPtr zero, ref int dataSize);
 227
 228                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 229                                 ref int type, IntPtr zero, ref int datasize)
 230                 {
 231                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 232                                         ref type, zero, ref datasize);
 233                 }
 234
 235                 /// <summary>
 236                 ///     Get a registry value. Binary data.
 237                 /// </summary>
 238                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 239                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 240                                 string valueName, IntPtr reserved, ref int type,
 241                                 [Out] byte[] data, ref int dataSize);
 242
 243                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 244                                 ref int type, [Out] byte [] data, ref int datasize)
 245                 {
 246                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 247                                         ref type, data, ref datasize);
 248                 }
 249
 250                 /// <summary>
 251                 ///     Get a registry value. DWORD data.
 252                 /// </summary>
 253                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode)]
 254                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 255                                 string valueName, IntPtr reserved, ref int type,
 256                                 ref int data, ref int dataSize);
 257
 258                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 259                                 ref int type, ref int data, ref int datasize)
 260                 {
 261                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 262                                         ref type, ref data, ref datasize);
 263                 }
 264         }
 265 }
 266