source/registry/reg_db.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald Carter                     2002.
   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 /* Implementation of internal registry database functions. */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_RPC_SRV
  27
  28 static TDB_CONTEXT *tdb_reg;
  29
  30
  31 /***********************************************************************
  32  Open the registry data in the tdb
  33  ***********************************************************************/
  34
  35 static BOOL init_registry_data( void )
  36 {
  37         pstring         keyname;
  38         REGSUBKEY_CTR   subkeys;
  39
  40         ZERO_STRUCTP( &subkeys );
  41
  42         regsubkey_ctr_init( &subkeys );
  43
  44         /* HKEY_LOCAL_MACHINE */
  45
  46         regsubkey_ctr_init( &subkeys );
  47         pstrcpy( keyname, KEY_HKLM );
  48         regsubkey_ctr_addkey( &subkeys, "SYSTEM" );
  49         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  50                 return False;
  51         regsubkey_ctr_destroy( &subkeys );
  52
  53         regsubkey_ctr_init( &subkeys );
  54         pstrcpy( keyname, KEY_HKLM );
  55         pstrcat( keyname, "/SYSTEM" );
  56         regsubkey_ctr_addkey( &subkeys, "CurrentControlSet" );
  57         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  58                 return False;
  59         regsubkey_ctr_destroy( &subkeys );
  60
  61         regsubkey_ctr_init( &subkeys );
  62         pstrcpy( keyname, KEY_HKLM );
  63         pstrcat( keyname, "/SYSTEM/CurrentControlSet" );
  64         regsubkey_ctr_addkey( &subkeys, "Control" );
  65         regsubkey_ctr_addkey( &subkeys, "services" );
  66         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  67                 return False;
  68         regsubkey_ctr_destroy( &subkeys );
  69
  70         regsubkey_ctr_init( &subkeys );
  71         pstrcpy( keyname, KEY_HKLM );
  72         pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control" );
  73         regsubkey_ctr_addkey( &subkeys, "Print" );
  74         regsubkey_ctr_addkey( &subkeys, "ProductOptions" );
  75         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  76                 return False;
  77         regsubkey_ctr_destroy( &subkeys );
  78
  79         pstrcpy( keyname, KEY_HKLM );
  80         pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control/ProductOptions" );
  81         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  82                 return False;
  83
  84         regsubkey_ctr_init( &subkeys );
  85         pstrcpy( keyname, KEY_HKLM );
  86         pstrcat( keyname, "/SYSTEM/CurrentControlSet/services" );
  87         regsubkey_ctr_addkey( &subkeys, "Netlogon" );
  88         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  89                 return False;
  90         regsubkey_ctr_destroy( &subkeys );
  91
  92         regsubkey_ctr_init( &subkeys );
  93         pstrcpy( keyname, KEY_HKLM );
  94         pstrcat( keyname, "/SYSTEM/CurrentControlSet/services/Netlogon" );
  95         regsubkey_ctr_addkey( &subkeys, "parameters" );
  96         if ( !regdb_store_reg_keys( keyname, &subkeys ))
  97                 return False;
  98         regsubkey_ctr_destroy( &subkeys );
  99
 100         pstrcpy( keyname, KEY_HKLM );
 101         pstrcat( keyname, "/SYSTEM/CurrentControlSet/services/Netlogon/parameters" );
 102         if ( !regdb_store_reg_keys( keyname, &subkeys ))
 103                 return False;
 104
 105         /* HKEY_USER */
 106
 107         pstrcpy( keyname, KEY_HKU );
 108         if ( !regdb_store_reg_keys( keyname, &subkeys ) )
 109                 return False;
 110
 111         return True;
 112 }
 113
 114 /***********************************************************************
 115  Open the registry database
 116  ***********************************************************************/
 117
 118 BOOL init_registry_db( void )
 119 {
 120         static pid_t local_pid;
 121
 122         if (tdb_reg && local_pid == sys_getpid())
 123                 return True;
 124
 125         /*
 126          * try to open first without creating so we can determine
 127          * if we need to init the data in the registry
 128          */
 129
 130         tdb_reg = tdb_open_log(lock_path("registry.tdb"), 0, TDB_DEFAULT, O_RDWR, 0600);
 131         if ( !tdb_reg )
 132         {
 133                 tdb_reg = tdb_open_log(lock_path("registry.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
 134                 if ( !tdb_reg ) {
 135                         DEBUG(0,("init_registry: Failed to open registry %s (%s)\n",
 136                                 lock_path("registry.tdb"), strerror(errno) ));
 137                         return False;
 138                 }
 139
 140                 DEBUG(10,("init_registry: Successfully created registry tdb\n"));
 141
 142                 /* create the registry here */
 143                 if ( !init_registry_data() ) {
 144                         DEBUG(0,("init_registry: Failed to initiailize data in registry!\n"));
 145                         return False;
 146                 }
 147         }
 148
 149         local_pid = sys_getpid();
 150
 151         return True;
 152 }
 153
 154
 155
 156 /***********************************************************************
 157  Add subkey strings to the registry tdb under a defined key
 158  fmt is the same format as tdb_pack except this function only supports
 159  fstrings
 160
 161  The full path to the registry key is used as database after the
 162  \'s are converted to /'s.
 163  ***********************************************************************/
 164
 165 BOOL regdb_store_reg_keys( char *keyname, REGSUBKEY_CTR *ctr )
 166 {
 167         TDB_DATA kbuf, dbuf;
 168         char *buffer, *tmpbuf;
 169         int i = 0;
 170         uint32 len, buflen;
 171         BOOL ret = True;
 172         uint32 num_subkeys = regsubkey_ctr_numkeys( ctr );
 173
 174         if ( !keyname )
 175                 return False;
 176
 177         /* allocate some initial memory */
 178
 179         buffer = malloc(sizeof(pstring));
 180         buflen = sizeof(pstring);
 181         len = 0;
 182
 183         /* store the number of subkeys */
 184
 185         len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys );
 186
 187         /* pack all the strings */
 188
 189         for (i=0; i<num_subkeys; i++) {
 190                 len += tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
 191                 if ( len > buflen ) {
 192                         /* allocate some extra space */
 193                         if ((tmpbuf = Realloc( buffer, len*2 )) == NULL) {
 194                                 DEBUG(0,("regdb_store_reg_keys: Failed to realloc memory of size [%d]\n", len*2));
 195                                 ret = False;
 196                                 goto done;
 197                         }
 198                         buffer = tmpbuf;
 199                         buflen = len*2;
 200
 201                         len = tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
 202                 }
 203         }
 204
 205         /* finally write out the data */
 206
 207         kbuf.dptr = keyname;
 208         kbuf.dsize = strlen(keyname)+1;
 209         dbuf.dptr = buffer;
 210         dbuf.dsize = len;
 211         if ( tdb_store( tdb_reg, kbuf, dbuf, TDB_REPLACE ) == -1) {
 212                 ret = False;
 213                 goto done;
 214         }
 215
 216 done:
 217         SAFE_FREE( buffer );
 218         return ret;
 219 }
 220
 221 /***********************************************************************
 222  Retrieve an array of strings containing subkeys.  Memory should be
 223  released by the caller.  The subkeys are stored in a catenated string
 224  of null terminated character strings
 225  ***********************************************************************/
 226
 227 int regdb_fetch_reg_keys( char* key, REGSUBKEY_CTR *ctr )
 228 {
 229         pstring path;
 230         uint32 num_items;
 231         TDB_DATA dbuf;
 232         char *buf;
 233         uint32 buflen, len;
 234         int i;
 235         fstring subkeyname;
 236
 237
 238         pstrcpy( path, key );
 239
 240         /* convert to key format */
 241         pstring_sub( path, "\\", "/" );
 242
 243         dbuf = tdb_fetch_by_string( tdb_reg, path );
 244
 245         buf = dbuf.dptr;
 246         buflen = dbuf.dsize;
 247
 248         if ( !buf ) {
 249                 DEBUG(5,("regdb_fetch_reg_keys: Failed to fetch any subkeys for [%s]\n", key));
 250                 return 0;
 251         }
 252
 253         len = tdb_unpack( buf, buflen, "d", &num_items);
 254
 255         for (i=0; i<num_items; i++) {
 256                 len += tdb_unpack( buf+len, buflen-len, "f", subkeyname );
 257                 regsubkey_ctr_addkey( ctr, subkeyname );
 258         }
 259
 260         SAFE_FREE(dbuf.dptr);
 261         return num_items;
 262 }
 263
 264
 265 /***********************************************************************
 266  Retrieve an array of strings containing subkeys.  Memory should be
 267  released by the caller.  The subkeys are stored in a catenated string
 268  of null terminated character strings
 269  ***********************************************************************/
 270
 271 int regdb_fetch_reg_values( char* key, REGVAL_CTR *val )
 272 {
 273         return 0;
 274 }
 275
 276 /***********************************************************************
 277  Stub function since we do not currently support storing registry
 278  values in the registry.tdb
 279  ***********************************************************************/
 280
 281 BOOL regdb_store_reg_values( char *key, REGVAL_CTR *val )
 282 {
 283         return False;
 284 }
 285
 286
 287 /*
 288  * Table of function pointers for default access
 289  */
 290
 291 REGISTRY_OPS regdb_ops = {
 292         regdb_fetch_reg_keys,
 293         regdb_fetch_reg_values,
 294         regdb_store_reg_keys,
 295         regdb_store_reg_values
 296 };
 297
 298