LCOV - code coverage report
Current view: top level - source4/lib/registry - interface.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 57 90 63.3 %
Date: 2021-09-23 10:06:22 Functions: 14 15 93.3 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    Transparent registry backend handling
       4             :    Copyright (C) Jelmer Vernooij                        2003-2007.
       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 3 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, see <http://www.gnu.org/licenses/>.
      18             : */
      19             : 
      20             : #include "includes.h"
      21             : #include "../lib/util/dlinklist.h"
      22             : #include "lib/registry/registry.h"
      23             : #include "system/filesys.h"
      24             : 
      25             : #undef strcasecmp
      26             : 
      27             : /**
      28             :  * @file
      29             :  * @brief Main registry functions
      30             :  */
      31             : 
      32             : const struct reg_predefined_key reg_predefined_keys[] = {
      33             :         {HKEY_CLASSES_ROOT,"HKEY_CLASSES_ROOT" },
      34             :         {HKEY_CURRENT_USER,"HKEY_CURRENT_USER" },
      35             :         {HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE" },
      36             :         {HKEY_PERFORMANCE_DATA, "HKEY_PERFORMANCE_DATA" },
      37             :         {HKEY_USERS, "HKEY_USERS" },
      38             :         {HKEY_CURRENT_CONFIG, "HKEY_CURRENT_CONFIG" },
      39             :         {HKEY_DYN_DATA, "HKEY_DYN_DATA" },
      40             :         {HKEY_PERFORMANCE_TEXT, "HKEY_PERFORMANCE_TEXT" },
      41             :         {HKEY_PERFORMANCE_NLSTEXT, "HKEY_PERFORMANCE_NLSTEXT" },
      42             :         { 0, NULL }
      43             : };
      44             : 
      45             : /** Obtain name of specific hkey. */
      46           1 : _PUBLIC_ const char *reg_get_predef_name(uint32_t hkey)
      47             : {
      48             :         unsigned int i;
      49           3 :         for (i = 0; reg_predefined_keys[i].name; i++) {
      50           3 :                 if (reg_predefined_keys[i].handle == hkey)
      51           0 :                         return reg_predefined_keys[i].name;
      52             :         }
      53             : 
      54           0 :         return NULL;
      55             : }
      56             : 
      57             : /** Get predefined key by name. */
      58       10653 : _PUBLIC_ WERROR reg_get_predefined_key_by_name(struct registry_context *ctx,
      59             :                                                const char *name,
      60             :                                                struct registry_key **key)
      61             : {
      62             :         unsigned int i;
      63             : 
      64       31954 :         for (i = 0; reg_predefined_keys[i].name; i++) {
      65       31953 :                 if (!strcasecmp(reg_predefined_keys[i].name, name))
      66       10652 :                         return reg_get_predefined_key(ctx,
      67        1705 :                                                       reg_predefined_keys[i].handle,
      68             :                                                       key);
      69             :         }
      70             : 
      71           1 :         DEBUG(1, ("No predefined key with name '%s'\n", name));
      72             : 
      73           1 :         return WERR_FILE_NOT_FOUND;
      74             : }
      75             : 
      76             : /** Get predefined key by id. */
      77       10786 : _PUBLIC_ WERROR reg_get_predefined_key(struct registry_context *ctx,
      78             :                                        uint32_t hkey, struct registry_key **key)
      79             : {
      80       10786 :         return ctx->ops->get_predefined_key(ctx, hkey, key);
      81             : }
      82             : 
      83             : /**
      84             :  * Open a key
      85             :  * First tries to use the open_key function from the backend
      86             :  * then falls back to get_subkey_by_name and later get_subkey_by_index
      87             :  */
      88        7561 : _PUBLIC_ WERROR reg_open_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
      89             :                              const char *name, struct registry_key **result)
      90             : {
      91        7561 :         if (parent == NULL) {
      92           0 :                 DEBUG(0, ("Invalid parent key specified for open of '%s'\n",
      93             :                         name));
      94           0 :                 return WERR_INVALID_PARAMETER;
      95             :         }
      96             : 
      97        7561 :         if (parent->context->ops->open_key == NULL) {
      98           0 :                 DEBUG(0, ("Registry backend doesn't have open_key!\n"));
      99           0 :                 return WERR_NOT_SUPPORTED;
     100             :         }
     101             : 
     102        7561 :         return parent->context->ops->open_key(mem_ctx, parent, name, result);
     103             : }
     104             : 
     105             : /**
     106             :  * Get value by index
     107             :  */
     108         125 : _PUBLIC_ WERROR reg_key_get_value_by_index(TALLOC_CTX *mem_ctx,
     109             :                                            const struct registry_key *key,
     110             :                                            uint32_t idx, const char **name,
     111             :                                            uint32_t *type, DATA_BLOB *data)
     112             : {
     113         125 :         if (key == NULL)
     114           0 :                 return WERR_INVALID_PARAMETER;
     115             : 
     116         125 :         if (key->context->ops->enum_value == NULL)
     117           0 :                 return WERR_NOT_SUPPORTED;
     118             : 
     119         125 :         return key->context->ops->enum_value(mem_ctx, key, idx, name,
     120             :                                              type, data);
     121             : }
     122             : 
     123             : /**
     124             :  * Get the number of subkeys.
     125             :  */
     126          88 : _PUBLIC_ WERROR reg_key_get_info(TALLOC_CTX *mem_ctx,
     127             :                                  const struct registry_key *key,
     128             :                                  const char **classname,
     129             :                                  uint32_t *num_subkeys,
     130             :                                  uint32_t *num_values,
     131             :                                  NTTIME *last_change_time,
     132             :                                  uint32_t *max_subkeynamelen,
     133             :                                  uint32_t *max_valnamelen,
     134             :                                  uint32_t *max_valbufsize)
     135             : {
     136          88 :         if (key == NULL)
     137           0 :                 return WERR_INVALID_PARAMETER;
     138             : 
     139          88 :         if (key->context->ops->get_key_info == NULL)
     140           0 :                 return WERR_NOT_SUPPORTED;
     141             : 
     142          88 :         return key->context->ops->get_key_info(mem_ctx,
     143             :                                                key, classname, num_subkeys,
     144             :                                                num_values, last_change_time,
     145             :                                                max_subkeynamelen,
     146             :                                                max_valnamelen, max_valbufsize);
     147             : }
     148             : 
     149             : /**
     150             :  * Get subkey by index.
     151             :  */
     152          80 : _PUBLIC_ WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
     153             :                                             const struct registry_key *key,
     154             :                                             uint32_t idx, const char **name,
     155             :                                             const char **keyclass,
     156             :                                             NTTIME *last_changed_time)
     157             : {
     158          80 :         if (key == NULL)
     159           0 :                 return WERR_INVALID_PARAMETER;
     160             : 
     161          80 :         if (key->context->ops->enum_key == NULL)
     162           0 :                 return WERR_NOT_SUPPORTED;
     163             : 
     164          80 :         return key->context->ops->enum_key(mem_ctx, key, idx, name,
     165             :                                            keyclass, last_changed_time);
     166             : }
     167             : 
     168             : /**
     169             :  * Get value by name.
     170             :  */
     171        2045 : _PUBLIC_ WERROR reg_key_get_value_by_name(TALLOC_CTX *mem_ctx,
     172             :                                           const struct registry_key *key,
     173             :                                           const char *name,
     174             :                                           uint32_t *type,
     175             :                                           DATA_BLOB *data)
     176             : {
     177        2045 :         if (key == NULL)
     178           0 :                 return WERR_INVALID_PARAMETER;
     179             : 
     180        2045 :         if (key->context->ops->get_value == NULL)
     181           0 :                 return WERR_NOT_SUPPORTED;
     182             : 
     183        2045 :         return key->context->ops->get_value(mem_ctx, key, name, type, data);
     184             : }
     185             : 
     186             : /**
     187             :  * Delete a key.
     188             :  */
     189         644 : _PUBLIC_ WERROR reg_key_del(TALLOC_CTX *mem_ctx, struct registry_key *parent,
     190             :                             const char *name)
     191             : {
     192         644 :         if (parent == NULL)
     193           0 :                 return WERR_INVALID_PARAMETER;
     194             : 
     195         644 :         if (parent->context->ops->delete_key == NULL)
     196           0 :                 return WERR_NOT_SUPPORTED;
     197             : 
     198         644 :         return parent->context->ops->delete_key(mem_ctx, parent, name);
     199             : }
     200             : 
     201             : /**
     202             :  * Add a key.
     203             :  */
     204       10498 : _PUBLIC_ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
     205             :                                  struct registry_key *parent,
     206             :                                  const char *path, const char *key_class,
     207             :                                  struct security_descriptor *desc,
     208             :                                  struct registry_key **newkey)
     209             : {
     210       10498 :         if (parent == NULL)
     211           0 :                 return WERR_INVALID_PARAMETER;
     212             : 
     213       10498 :         if (parent->context->ops->create_key == NULL) {
     214           0 :                 DEBUG(1, ("Backend '%s' doesn't support method add_key\n",
     215             :                                   parent->context->ops->name));
     216           0 :                 return WERR_NOT_SUPPORTED;
     217             :         }
     218             : 
     219       10498 :         return parent->context->ops->create_key(mem_ctx, parent, path,
     220             :                                                 key_class, desc, newkey);
     221             : }
     222             : 
     223             : /**
     224             :  * Set a value.
     225             :  */
     226         950 : _PUBLIC_ WERROR reg_val_set(struct registry_key *key, const char *value,
     227             :                             uint32_t type, const DATA_BLOB data)
     228             : {
     229         950 :         if (key == NULL)
     230           0 :                 return WERR_INVALID_PARAMETER;
     231             : 
     232             :         /* A 'real' set function has preference */
     233         950 :         if (key->context->ops->set_value == NULL) {
     234           0 :                 DEBUG(1, ("Backend '%s' doesn't support method set_value\n",
     235             :                                   key->context->ops->name));
     236           0 :                 return WERR_NOT_SUPPORTED;
     237             :         }
     238             : 
     239         950 :         return key->context->ops->set_value(key, value, type, data);
     240             : }
     241             : 
     242             : /**
     243             :  * Get the security descriptor on a key.
     244             :  */
     245           0 : _PUBLIC_ WERROR reg_get_sec_desc(TALLOC_CTX *ctx,
     246             :                                  const struct registry_key *key,
     247             :                                  struct security_descriptor **secdesc)
     248             : {
     249           0 :         if (key == NULL)
     250           0 :                 return WERR_INVALID_PARAMETER;
     251             : 
     252             :         /* A 'real' set function has preference */
     253           0 :         if (key->context->ops->get_sec_desc == NULL)
     254           0 :                 return WERR_NOT_SUPPORTED;
     255             : 
     256           0 :         return key->context->ops->get_sec_desc(ctx, key, secdesc);
     257             : }
     258             : 
     259             : /**
     260             :  * Delete a value.
     261             :  */
     262         363 : _PUBLIC_ WERROR reg_del_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
     263             :                               const char *valname)
     264             : {
     265         363 :         if (key == NULL)
     266           0 :                 return WERR_INVALID_PARAMETER;
     267             : 
     268         363 :         if (key->context->ops->delete_value == NULL)
     269           0 :                 return WERR_NOT_SUPPORTED;
     270             : 
     271         363 :         return key->context->ops->delete_value(mem_ctx, key, valname);
     272             : }
     273             : 
     274             : /**
     275             :  * Flush a key to disk.
     276             :  */
     277         162 : _PUBLIC_ WERROR reg_key_flush(struct registry_key *key)
     278             : {
     279         162 :         if (key == NULL)
     280           1 :                 return WERR_INVALID_PARAMETER;
     281             : 
     282         161 :         if (key->context->ops->flush_key == NULL)
     283           0 :                 return WERR_NOT_SUPPORTED;
     284             : 
     285         161 :         return key->context->ops->flush_key(key);
     286             : }
     287             : 
     288           1 : _PUBLIC_ WERROR reg_set_sec_desc(struct registry_key *key,
     289             :                                  const struct security_descriptor *security)
     290             : {
     291           1 :         if (key == NULL)
     292           0 :                 return WERR_INVALID_PARAMETER;
     293             : 
     294           1 :         if (key->context->ops->set_sec_desc == NULL)
     295           0 :                 return WERR_NOT_SUPPORTED;
     296             : 
     297           1 :         return key->context->ops->set_sec_desc(key, security);
     298             : }

Generated by: LCOV version 1.13