source/registry/reg_frontend.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 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 regdb_ops;          /* these are the default */
  30
  31 /* array of REGISTRY_HOOK's which are read into a tree for easy access */
  32
  33
  34 REGISTRY_HOOK reg_hooks[] = {
  35   { KEY_PRINTING,   &printing_ops },
  36   { NULL, NULL }
  37 };
  38
  39
  40 /*
  41  * Utility functions for REGSUBKEY_CTR
  42  */
  43
  44 /***********************************************************************
  45  Init the talloc context held by a REGSUBKEY_CTR structure
  46  **********************************************************************/
  47
  48 void regsubkey_ctr_init( REGSUBKEY_CTR *ctr )
  49 {
  50         if ( !ctr->ctx )
  51                 ctr->ctx = talloc_init();
  52 }
  53
  54 /***********************************************************************
  55  Add a new key to the array
  56  **********************************************************************/
  57
  58 int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, char *keyname )
  59 {
  60         uint32 len;
  61         char **pp;
  62
  63         if ( keyname )
  64         {
  65                 len = strlen( keyname );
  66
  67                 /* allocate a space for the char* in the array */
  68
  69                 if (  ctr->subkeys == 0 )
  70                         ctr->subkeys = talloc( ctr->ctx, sizeof(char*) );
  71                 else {
  72                         pp = talloc_realloc( ctr->ctx, ctr->subkeys, sizeof(char*)*(ctr->num_subkeys+1) );
  73                         if ( pp )
  74                                 ctr->subkeys = pp;
  75                 }
  76
  77                 /* allocate the string and save it in the array */
  78
  79                 ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 );
  80                 strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 );
  81                 ctr->num_subkeys++;
  82         }
  83
  84         return ctr->num_subkeys;
  85 }
  86
  87 /***********************************************************************
  88  How many keys does the container hold ?
  89  **********************************************************************/
  90
  91 int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
  92 {
  93         return ctr->num_subkeys;
  94 }
  95
  96 /***********************************************************************
  97  Retreive a specific key string
  98  **********************************************************************/
  99
 100 char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
 101 {
 102         if ( ! (key_index < ctr->num_subkeys) )
 103                 return NULL;
 104
 105         return ctr->subkeys[key_index];
 106 }
 107
 108 /***********************************************************************
 109  free memory held by a REGSUBKEY_CTR structure
 110  **********************************************************************/
 111
 112 void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr )
 113 {
 114         if ( ctr ) {
 115                 talloc_destroy( ctr->ctx );
 116                 ZERO_STRUCTP( ctr );
 117         }
 118 }
 119
 120
 121 /*
 122  * Utility functions for REGVAL_CTR
 123  */
 124
 125 /***********************************************************************
 126  Init the talloc context held by a REGSUBKEY_CTR structure
 127  **********************************************************************/
 128
 129 void regval_ctr_init( REGVAL_CTR *ctr )
 130 {
 131         if ( !ctr->ctx )
 132                 ctr->ctx = talloc_init();
 133 }
 134
 135 /***********************************************************************
 136  How many keys does the container hold ?
 137  **********************************************************************/
 138
 139 int regval_ctr_numvals( REGVAL_CTR *ctr )
 140 {
 141         return ctr->num_values;
 142 }
 143
 144 /***********************************************************************
 145  allocate memory for and duplicate a REGISTRY_VALUE.
 146  This is malloc'd memory so the caller should free it when done
 147  **********************************************************************/
 148
 149 REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
 150 {
 151         REGISTRY_VALUE  *copy = NULL;
 152
 153         if ( !val )
 154                 return NULL;
 155
 156         if ( !(copy = malloc( sizeof(REGISTRY_VALUE) )) ) {
 157                 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
 158                 return NULL;
 159         }
 160
 161         /* copy all the non-pointer initial data */
 162
 163         memcpy( copy, val, sizeof(REGISTRY_VALUE) );
 164         if ( val->data_p )
 165         {
 166                 if ( !(copy->data_p = memdup( val->data_p, val->size )) ) {
 167                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
 168                                 val->size));
 169                         SAFE_FREE( copy );
 170                 }
 171         }
 172
 173         return copy;
 174 }
 175
 176 /**********************************************************************
 177  free the memory allocated to a REGISTRY_VALUE
 178  *********************************************************************/
 179
 180 void free_registry_value( REGISTRY_VALUE *val )
 181 {
 182         if ( !val )
 183                 return;
 184
 185         SAFE_FREE( val->data_p );
 186         SAFE_FREE( val );
 187
 188         return;
 189 }
 190
 191 /***********************************************************************
 192  Retreive a pointer to a specific value.  Caller shoud dup the structure
 193  since this memory may go away with a regval_ctr_destroy()
 194  **********************************************************************/
 195
 196 REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
 197 {
 198         if ( !(idx < ctr->num_values) )
 199                 return NULL;
 200
 201         return ctr->values[idx];
 202 }
 203
 204 /***********************************************************************
 205  Retrive the TALLOC_CTX associated with a REGISTRY_VALUE
 206  **********************************************************************/
 207
 208 TALLOC_CTX* regval_ctr_getctx( REGVAL_CTR *val )
 209 {
 210         if ( !val )
 211                 return NULL;
 212
 213         return val->ctx;
 214 }
 215
 216 /***********************************************************************
 217  Add a new regostry value to the array
 218  **********************************************************************/
 219
 220 int regval_ctr_addvalue( REGVAL_CTR *ctr, char *name, uint16 type,
 221                          char *data_p, size_t size )
 222 {
 223         REGISTRY_VALUE **ppreg;
 224         uint16 len;
 225
 226         if ( name )
 227         {
 228                 len = strlen( name );
 229
 230                 /* allocate a slot in the array of pointers */
 231
 232                 if (  ctr->num_values == 0 )
 233                         ctr->values = talloc( ctr->ctx, sizeof(REGISTRY_VALUE*) );
 234                 else {
 235                         ppreg = talloc_realloc( ctr->ctx, ctr->values, sizeof(REGISTRY_VALUE*)*(ctr->num_values+1) );
 236                         if ( ppreg )
 237                                 ctr->values = ppreg;
 238                 }
 239
 240                 /* allocate a new valuie and store the pointer in the arrya */
 241
 242                 ctr->values[ctr->num_values] = talloc( ctr->ctx, sizeof(REGISTRY_VALUE) );
 243
 244                 /* init the value */
 245
 246                 fstrcpy( ctr->values[ctr->num_values]->valuename, name );
 247                 ctr->values[ctr->num_values]->type = type;
 248                 ctr->values[ctr->num_values]->data_p = talloc_memdup( ctr->ctx, data_p, size );
 249                 ctr->values[ctr->num_values]->size = size;
 250                 ctr->num_values++;
 251         }
 252
 253         return ctr->num_values;
 254 }
 255
 256 /***********************************************************************
 257  free memory held by a REGVAL_CTR structure
 258  **********************************************************************/
 259
 260 void regval_ctr_destroy( REGVAL_CTR *ctr )
 261 {
 262         if ( ctr ) {
 263                 talloc_destroy( ctr->ctx );
 264                 ZERO_STRUCTP( ctr );
 265         }
 266 }
 267
 268 /***********************************************************************
 269  Open the registry database and initialize the REGISTRY_HOOK cache
 270  ***********************************************************************/
 271
 272 BOOL init_registry( void )
 273 {
 274         int i;
 275
 276         if ( !init_registry_db() ) {
 277                 DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
 278                 return False;
 279         }
 280
 281         /* build the cache tree of registry hooks */
 282
 283         reghook_cache_init();
 284
 285         for ( i=0; reg_hooks[i].keyname; i++ ) {
 286                 if ( !reghook_cache_add(&reg_hooks[i]) )
 287                         return False;
 288         }
 289
 290         if ( DEBUGLEVEL >= 20 )
 291                 reghook_dump_cache(20);
 292
 293         return True;
 294 }
 295
 296
 297
 298
 299 /***********************************************************************
 300  High level wrapper function for storing registry subkeys
 301  ***********************************************************************/
 302
 303 BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys )
 304 {
 305         if ( key->hook && key->hook->ops && key->hook->ops->store_subkeys_fn )
 306                 return key->hook->ops->store_subkeys_fn( key->name, subkeys );
 307         else
 308                 return False;
 309
 310 }
 311
 312 /***********************************************************************
 313  High level wrapper function for storing registry values
 314  ***********************************************************************/
 315
 316 BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
 317 {
 318         if ( key->hook && key->hook->ops && key->hook->ops->store_values_fn )
 319                 return key->hook->ops->store_values_fn( key->name, val );
 320         else
 321                 return False;
 322 }
 323
 324
 325 /***********************************************************************
 326  High level wrapper function for enumerating registry subkeys
 327  Initialize the TALLOC_CTX if necessary
 328  ***********************************************************************/
 329
 330 int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
 331 {
 332         int result = -1;
 333
 334         if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
 335                 result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
 336
 337         return result;
 338 }
 339
 340 /***********************************************************************
 341  retreive a specific subkey specified by index.  Caller is
 342  responsible for freeing memory
 343  ***********************************************************************/
 344
 345 BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index )
 346 {
 347         static REGSUBKEY_CTR ctr;
 348         static pstring save_path;
 349         static BOOL ctr_init = False;
 350         char *s;
 351
 352         *subkey = NULL;
 353
 354         /* simple caching for performance; very basic heuristic */
 355
 356         if ( !ctr_init ) {
 357                 DEBUG(8,("fetch_reg_keys_specific: Initializing cache of subkeys for [%s]\n", key->name));
 358                 ZERO_STRUCTP( &ctr );
 359                 regsubkey_ctr_init( &ctr );
 360
 361                 pstrcpy( save_path, key->name );
 362
 363                 if ( fetch_reg_keys( key, &ctr) == -1 )
 364                         return False;
 365
 366                 ctr_init = True;
 367         }
 368         /* clear the cache when key_index == 0 or the path has changed */
 369         else if ( !key_index || StrCaseCmp( save_path, key->name) ) {
 370
 371                 DEBUG(8,("fetch_reg_keys_specific: Updating cache of subkeys for [%s]\n", key->name));
 372
 373                 regsubkey_ctr_destroy( &ctr );
 374                 regsubkey_ctr_init( &ctr );
 375
 376                 pstrcpy( save_path, key->name );
 377
 378                 if ( fetch_reg_keys( key, &ctr) == -1 )
 379                         return False;
 380         }
 381
 382         if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
 383                 return False;
 384
 385         *subkey = strdup( s );
 386
 387         return True;
 388 }
 389
 390
 391 /***********************************************************************
 392  High level wrapper function for enumerating registry values
 393  Initialize the TALLOC_CTX if necessary
 394  ***********************************************************************/
 395
 396 int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
 397 {
 398         int result = -1;
 399
 400         if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
 401                 result = key->hook->ops->value_fn( key->name, val );
 402
 403         return result;
 404 }
 405
 406
 407 /***********************************************************************
 408  retreive a specific subkey specified by index.  Caller is
 409  responsible for freeing memory
 410  ***********************************************************************/
 411
 412 BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 val_index )
 413 {
 414         static REGVAL_CTR       ctr;
 415         static pstring          save_path;
 416         static BOOL             ctr_init = False;
 417         REGISTRY_VALUE          *v;
 418
 419         *val = NULL;
 420
 421         /* simple caching for performance; very basic heuristic */
 422
 423         if ( !ctr_init ) {
 424                 DEBUG(8,("fetch_reg_values_specific: Initializing cache of values for [%s]\n", key->name));
 425
 426                 ZERO_STRUCTP( &ctr );
 427                 regval_ctr_init( &ctr );
 428
 429                 pstrcpy( save_path, key->name );
 430
 431                 if ( fetch_reg_values( key, &ctr) == -1 )
 432                         return False;
 433
 434                 ctr_init = True;
 435         }
 436         /* clear the cache when val_index == 0 or the path has changed */
 437         else if ( !val_index || StrCaseCmp(save_path, key->name) ) {
 438
 439                 DEBUG(8,("fetch_reg_values_specific: Updating cache of values for [%s]\n", key->name));
 440
 441                 regval_ctr_destroy( &ctr );
 442                 regval_ctr_init( &ctr );
 443
 444                 pstrcpy( save_path, key->name );
 445
 446                 if ( fetch_reg_values( key, &ctr) == -1 )
 447                         return False;
 448         }
 449
 450         if ( !(v = regval_ctr_specific_value( &ctr, val_index )) )
 451                 return False;
 452
 453         *val = dup_registry_value( v );
 454
 455         return True;
 456 }
 457
 458 /***********************************************************************
 459  Utility function for splitting the base path of a registry path off
 460  by setting base and new_path to the apprapriate offsets withing the
 461  path.
 462
 463  WARNING!!  Does modify the original string!
 464  ***********************************************************************/
 465
 466 BOOL reg_split_path( char *path, char **base, char **new_path )
 467 {
 468         char *p;
 469
 470         *new_path = *base = NULL;
 471
 472         if ( !path)
 473                 return False;
 474
 475         *base = path;
 476
 477         p = strchr( path, '\\' );
 478
 479         if ( p ) {
 480                 *p = '\0';
 481                 *new_path = p+1;
 482         }
 483
 484         return True;
 485 }
 486
 487
 488