source/registry/reg_frontend.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Virtual Windows Registry Layer
   4  *  Copyright (C) Gerald Carter                     2002-2005
   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 registry frontend view functions. */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_RPC_SRV
  27
  28 extern REGISTRY_OPS printing_ops;
  29 extern REGISTRY_OPS eventlog_ops;
  30 extern REGISTRY_OPS shares_reg_ops;
  31 extern REGISTRY_OPS regdb_ops;          /* these are the default */
  32
  33 /* array of REGISTRY_HOOK's which are read into a tree for easy access */
  34
  35 REGISTRY_HOOK reg_hooks[] = {
  36   { KEY_PRINTING,               &printing_ops },
  37   { KEY_PRINTING_2K,            &printing_ops },
  38   { KEY_PRINTING_PORTS,         &printing_ops },
  39   { KEY_EVENTLOG,               &eventlog_ops },
  40   { KEY_SHARES,                 &shares_reg_ops },
  41   { NULL, NULL }
  42 };
  43
  44
  45 /***********************************************************************
  46  Open the registry database and initialize the REGISTRY_HOOK cache
  47  ***********************************************************************/
  48
  49 BOOL init_registry( void )
  50 {
  51         int i;
  52
  53         if ( !init_registry_db() ) {
  54                 DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
  55                 return False;
  56         }
  57
  58         /* build the cache tree of registry hooks */
  59
  60         reghook_cache_init();
  61
  62         for ( i=0; reg_hooks[i].keyname; i++ ) {
  63                 if ( !reghook_cache_add(&reg_hooks[i]) )
  64                         return False;
  65         }
  66
  67         if ( DEBUGLEVEL >= 20 )
  68                 reghook_dump_cache(20);
  69
  70         return True;
  71 }
  72
  73 /***********************************************************************
  74  High level wrapper function for storing registry subkeys
  75  ***********************************************************************/
  76
  77 BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys )
  78 {
  79         if ( key->hook && key->hook->ops && key->hook->ops->store_subkeys )
  80                 return key->hook->ops->store_subkeys( key->name, subkeys );
  81
  82         return False;
  83
  84 }
  85
  86 /***********************************************************************
  87  High level wrapper function for storing registry values
  88  ***********************************************************************/
  89
  90 BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
  91 {
  92         if ( check_dynamic_reg_values( key ) )
  93                 return False;
  94
  95         if ( key->hook && key->hook->ops && key->hook->ops->store_values )
  96                 return key->hook->ops->store_values( key->name, val );
  97
  98         return False;
  99 }
 100
 101
 102 /***********************************************************************
 103  High level wrapper function for enumerating registry subkeys
 104  Initialize the TALLOC_CTX if necessary
 105  ***********************************************************************/
 106
 107 int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
 108 {
 109         int result = -1;
 110
 111         if ( key->hook && key->hook->ops && key->hook->ops->fetch_subkeys )
 112                 result = key->hook->ops->fetch_subkeys( key->name, subkey_ctr );
 113
 114         return result;
 115 }
 116
 117 /***********************************************************************
 118  retreive a specific subkey specified by index.  Caller is
 119  responsible for freeing memory
 120  ***********************************************************************/
 121
 122 BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index )
 123 {
 124         static REGSUBKEY_CTR ctr;
 125         static pstring save_path;
 126         static BOOL ctr_init = False;
 127         char *s;
 128
 129         *subkey = NULL;
 130
 131         /* simple caching for performance; very basic heuristic */
 132
 133         DEBUG(8,("fetch_reg_keys_specific: Looking for key [%d] of  [%s]\n", key_index, key->name));
 134
 135         if ( !ctr_init ) {
 136                 DEBUG(8,("fetch_reg_keys_specific: Initializing cache of subkeys for [%s]\n", key->name));
 137                 regsubkey_ctr_init( &ctr );
 138
 139                 pstrcpy( save_path, key->name );
 140
 141                 if ( fetch_reg_keys( key, &ctr) == -1 )
 142                         return False;
 143
 144                 ctr_init = True;
 145         }
 146         /* clear the cache when key_index == 0 or the path has changed */
 147         else if ( !key_index || StrCaseCmp( save_path, key->name) ) {
 148
 149                 DEBUG(8,("fetch_reg_keys_specific: Updating cache of subkeys for [%s]\n", key->name));
 150
 151                 regsubkey_ctr_destroy( &ctr );
 152                 regsubkey_ctr_init( &ctr );
 153
 154                 pstrcpy( save_path, key->name );
 155
 156                 if ( fetch_reg_keys( key, &ctr) == -1 )
 157                         return False;
 158         }
 159
 160         if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
 161                 return False;
 162
 163         *subkey = SMB_STRDUP( s );
 164
 165         return True;
 166 }
 167
 168 /***********************************************************************
 169  High level wrapper function for enumerating registry values
 170  ***********************************************************************/
 171
 172 int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
 173 {
 174         int result = -1;
 175
 176         if ( key->hook && key->hook->ops && key->hook->ops->fetch_values )
 177                 result = key->hook->ops->fetch_values( key->name, val );
 178
 179         /* if the backend lookup returned no data, try the dynamic overlay */
 180
 181         if ( result == 0 ) {
 182                 result = fetch_dynamic_reg_values( key, val );
 183
 184                 return ( result != -1 ) ? result : 0;
 185         }
 186
 187         return result;
 188 }
 189
 190
 191 /***********************************************************************
 192  retreive a specific subkey specified by index.  Caller is
 193  responsible for freeing memory
 194  ***********************************************************************/
 195
 196 BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 val_index )
 197 {
 198         static REGVAL_CTR       ctr;
 199         static pstring          save_path;
 200         static BOOL             ctr_init = False;
 201         REGISTRY_VALUE          *v;
 202
 203         *val = NULL;
 204
 205         /* simple caching for performance; very basic heuristic */
 206
 207         if ( !ctr_init ) {
 208                 DEBUG(8,("fetch_reg_values_specific: Initializing cache of values for [%s]\n", key->name));
 209
 210                 regval_ctr_init( &ctr );
 211
 212                 pstrcpy( save_path, key->name );
 213
 214                 if ( fetch_reg_values( key, &ctr) == -1 )
 215                         return False;
 216
 217                 ctr_init = True;
 218         }
 219         /* clear the cache when val_index == 0 or the path has changed */
 220         else if ( !val_index || !strequal(save_path, key->name) ) {
 221
 222                 DEBUG(8,("fetch_reg_values_specific: Updating cache of values for [%s]\n", key->name));
 223
 224                 regval_ctr_destroy( &ctr );
 225                 regval_ctr_init( &ctr );
 226
 227                 pstrcpy( save_path, key->name );
 228
 229                 if ( fetch_reg_values( key, &ctr) == -1 )
 230                         return False;
 231         }
 232
 233         if ( !(v = regval_ctr_specific_value( &ctr, val_index )) )
 234                 return False;
 235
 236         *val = dup_registry_value( v );
 237
 238         return True;
 239 }
 240
 241 /***********************************************************************
 242  High level access check for passing the required access mask to the
 243  underlying registry backend
 244  ***********************************************************************/
 245
 246 BOOL regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted, NT_USER_TOKEN *token )
 247 {
 248         /* use the default security check if the backend has not defined its own */
 249
 250         if ( !(key->hook && key->hook->ops && key->hook->ops->reg_access_check) ) {
 251                 SEC_DESC *sec_desc;
 252                 NTSTATUS status;
 253
 254                 if ( !(sec_desc = construct_registry_sd( get_talloc_ctx() )) )
 255                         return False;
 256
 257                 status = registry_access_check( sec_desc, token, requested, granted );
 258
 259                 return NT_STATUS_IS_OK(status);
 260         }
 261
 262         return key->hook->ops->reg_access_check( key->name, requested, granted, token );
 263 }
 264
 265