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 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 using System;
  36 using System.Runtime.InteropServices;
  37 using System.Text;
  38
  39 namespace Microsoft.Win32
  40 {
  41         /// <summary>
  42         ///     Function stubs, constants and helper functions for
  43         ///     the Win32 registry manipulation utilities.
  44         /// </summary>
  45         internal class Win32RegistryApi : IRegistryApi
  46         {
  47                 // bit masks for registry key open access permissions
  48                 public int OpenRegKeyRead {
  49                         get { return 0x00020019; }
  50                 }
  51
  52                 public int OpenRegKeyWrite {
  53                         get { return 0x00020006; }
  54                 }
  55
  56                 // type values for registry value data
  57                 public int RegStringType {
  58                         get { return 1; }
  59                 }
  60
  61                 public int RegEnvironmentString {
  62                         get { return 2; }
  63                 }
  64
  65                 public int RegBinaryType {
  66                         get { return 3; }
  67                 }
  68
  69                 public int RegDwordType {
  70                         get { return 4; }
  71                 }
  72
  73                 public int RegStringArrayType {
  74                         get { return 7; }
  75                 }
  76
  77                 /// <summary>
  78                 ///     Create a registry key.
  79                 /// </summary>
  80                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegCreateKey")]
  81                 private static extern int RegCreateKey_Internal (IntPtr keyBase,
  82                                 string keyName, out IntPtr keyHandle);
  83
  84                 public int RegCreateKey (IntPtr keybase, string keyname, out IntPtr handle)
  85                 {
  86                         return RegCreateKey_Internal (keybase, keyname, out handle);
  87                 }
  88
  89                 /// <summary>
  90                 ///     Close a registry key.
  91                 /// </summary>
  92                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegCloseKey")]
  93                 private static extern int RegCloseKey_Internal (IntPtr keyHandle);
  94
  95                 public int RegCloseKey (IntPtr handle)
  96                 {
  97                         return RegCloseKey_Internal (handle);
  98                 }
  99
 100                 /// <summary>
 101                 ///     Flush a registry key's current state to disk.
 102                 /// </summary>
 103                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegFlushKey")]
 104                 private static extern int RegFlushKey_Internal (IntPtr keyHandle);
 105
 106                 public int RegFlushKey (IntPtr handle)
 107                 {
 108                         return RegFlushKey_Internal (handle);
 109                 }
 110
 111                 /// <summary>
 112                 ///     Open a registry key.
 113                 ///     'unknown' must be zero.
 114                 /// </summary>
 115                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegOpenKeyEx")]
 116                 private static extern int RegOpenKeyEx_Internal (IntPtr keyBase,
 117                                 string keyName, IntPtr reserved, int access,
 118                                 out IntPtr keyHandle);
 119
 120                 public int RegOpenKeyEx (IntPtr keybase, string keyname, IntPtr reserved,
 121                                 int access, out IntPtr handle)
 122                 {
 123                         return RegOpenKeyEx_Internal (keybase, keyname, reserved, access, out handle);
 124                 }
 125
 126                 /// <summary>
 127                 ///     Delete a registry key.
 128                 /// </summary>
 129                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegDeleteKey")]
 130                 private static extern int RegDeleteKey_Internal (IntPtr keyHandle,
 131                                 string valueName);
 132
 133                 public int RegDeleteKey (IntPtr handle, string valuename)
 134                 {
 135                         return RegDeleteKey_Internal (handle, valuename);
 136                 }
 137
 138                 /// <summary>
 139                 ///     Delete a registry value.
 140                 /// </summary>
 141                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegDeleteValue")]
 142                 private static extern int RegDeleteValue_Internal (IntPtr keyHandle,
 143                                 string valueName);
 144
 145                 public int RegDeleteValue (IntPtr handle, string valuename)
 146                 {
 147                         return RegDeleteValue_Internal (handle, valuename);
 148                 }
 149
 150                 /// <summary>
 151                 ///     Fetch registry key subkeys itteratively.
 152                 /// </summary>
 153                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegEnumKey")]
 154                 private static extern int RegEnumKey_Internal (IntPtr keyBase, int index,
 155                                 [Out] byte[] nameBuffer, int bufferLength);
 156
 157                 public int RegEnumKey (IntPtr keybase, int index,
 158                                 [Out] byte [] namebuffer, int buffer_length)
 159                 {
 160                         return RegEnumKey_Internal (keybase, index, namebuffer, buffer_length);
 161                 }
 162
 163                 /// <summary>
 164                 ///     Fetch registry key value names itteratively.
 165                 ///
 166                 ///     Arguments 'reserved', 'data', 'dataLength'
 167                 ///     should be set to IntPtr.Zero.
 168                 /// </summary>
 169                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegEnumValue")]
 170                 private static extern int RegEnumValue_Internal (IntPtr keyBase,
 171                                 int index, StringBuilder nameBuffer,
 172                                 ref int nameLength, IntPtr reserved,
 173                                 ref int type, IntPtr data, IntPtr dataLength);
 174
 175                 public int RegEnumValue (IntPtr keybase, int index, StringBuilder namebuffer,
 176                                 ref int namelength, IntPtr reserved, ref int type, IntPtr data,
 177                                 IntPtr datalength)
 178                 {
 179                         return RegEnumValue_Internal (keybase, index, namebuffer, ref namelength,
 180                                         reserved, ref type, data, datalength);
 181                 }
 182
 183                 /// <summary>
 184                 ///     Set a registry value with string builder data.
 185                 /// </summary>
 186                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegSetValueEx")]
 187                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 188                                 string valueName, IntPtr reserved, int type,
 189                                 StringBuilder data, int rawDataLength);
 190
 191                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 192                                 int type, StringBuilder data, int datalength)
 193                 {
 194                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 195                                         type, data, datalength);
 196                 }
 197
 198                 /// <summary>
 199                 ///     Set a registry value with string data.
 200                 /// </summary>
 201                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegSetValueEx")]
 202                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 203                                 string valueName, IntPtr reserved, int type,
 204                                 string data, int rawDataLength);
 205
 206                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 207                                 int type, string data, int datalength)
 208                 {
 209                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 210                                         type, data, datalength);
 211                 }
 212
 213                 /// <summary>
 214                 ///     Set a registry value with binary data (a byte array).
 215                 /// </summary>
 216                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegSetValueEx")]
 217                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 218                                 string valueName, IntPtr reserved, int type,
 219                                 byte[] rawData, int rawDataLength);
 220
 221                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 222                                 int type, byte [] data, int datalength)
 223                 {
 224                         return RegSetValueEx_Internal (keybase, valuename, reserved,
 225                                         type, data, datalength);
 226                 }
 227
 228                 /// <summary>
 229                 ///     Set a registry value to a DWORD value.
 230                 /// </summary>
 231                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegSetValueEx")]
 232                 private static extern int RegSetValueEx_Internal (IntPtr keyBase,
 233                                 string valueName, IntPtr reserved, int type,
 234                                 ref int data, int rawDataLength);
 235
 236                 public int RegSetValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 237                                 int type, ref int data, int datalength)
 238                 {
 239                         return RegSetValueEx_Internal (keybase, valuename, reserved, type,
 240                                         ref data, datalength);
 241                 }
 242
 243                 /// <summary>
 244                 ///     Get a registry value's info. No data.
 245                 /// </summary>
 246                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegQueryValueEx")]
 247                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 248                                 string valueName, IntPtr reserved, ref int type,
 249                                 IntPtr zero, ref int dataSize);
 250
 251                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 252                                 ref int type, IntPtr zero, ref int datasize)
 253                 {
 254                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 255                                         ref type, zero, ref datasize);
 256                 }
 257
 258                 /// <summary>
 259                 ///     Get a registry value. Binary data.
 260                 /// </summary>
 261                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegQueryValueEx")]
 262                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 263                                 string valueName, IntPtr reserved, ref int type,
 264                                 [Out] byte[] data, ref int dataSize);
 265
 266                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 267                                 ref int type, [Out] byte [] data, ref int datasize)
 268                 {
 269                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 270                                         ref type, data, ref datasize);
 271                 }
 272
 273                 /// <summary>
 274                 ///     Get a registry value. DWORD data.
 275                 /// </summary>
 276                 [DllImport ("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegQueryValueEx")]
 277                 private static extern int RegQueryValueEx_Internal (IntPtr keyBase,
 278                                 string valueName, IntPtr reserved, ref int type,
 279                                 ref int data, ref int dataSize);
 280
 281                 public int RegQueryValueEx (IntPtr keybase, string valuename, IntPtr reserved,
 282                                 ref int type, ref int data, ref int datasize)
 283                 {
 284                         return RegQueryValueEx_Internal (keybase, valuename, reserved,
 285                                         ref type, ref data, ref datasize);
 286                 }
 287         }
 288 }
 289