source4/lib/registry/interface.c

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