source/utils/net_registry.c

   1 /*
   2  * Samba Unix/Linux SMB client library
   3  * Distributed SMB/CIFS Server Management Utility
   4  * Local registry interface
   5  *
   6  * Copyright (C) Michael Adam 2008
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "utils/net.h"
  24 #include "utils/net_registry_util.h"
  25
  26
  27 /*
  28  *
  29  * Helper functions
  30  *
  31  */
  32
  33 /**
  34  * split given path into hive and remaining path and open the hive key
  35  */
  36 static WERROR open_hive(TALLOC_CTX *ctx, const char *path,
  37                         uint32 desired_access,
  38                         struct registry_key **hive,
  39                         char **subkeyname)
  40 {
  41         WERROR werr;
  42         NT_USER_TOKEN *token = NULL;
  43         char *hivename = NULL;
  44         char *tmp_subkeyname = NULL;
  45         TALLOC_CTX *tmp_ctx = talloc_stackframe();
  46
  47         if ((hive == NULL) || (subkeyname == NULL)) {
  48                 werr = WERR_INVALID_PARAM;
  49                 goto done;
  50         }
  51
  52         werr = split_hive_key(tmp_ctx, path, &hivename, &tmp_subkeyname);
  53         if (!W_ERROR_IS_OK(werr)) {
  54                 goto done;
  55         }
  56         *subkeyname = talloc_strdup(ctx, tmp_subkeyname);
  57         if (*subkeyname == NULL) {
  58                 werr = WERR_NOMEM;
  59                 goto done;
  60         }
  61
  62         werr = ntstatus_to_werror(registry_create_admin_token(tmp_ctx, &token));
  63         if (!W_ERROR_IS_OK(werr)) {
  64                 goto done;
  65         }
  66
  67         werr = reg_openhive(ctx, hivename, desired_access, token, hive);
  68         if (!W_ERROR_IS_OK(werr)) {
  69                 goto done;
  70         }
  71
  72         werr = WERR_OK;
  73
  74 done:
  75         TALLOC_FREE(tmp_ctx);
  76         return werr;
  77 }
  78
  79 static WERROR open_key(TALLOC_CTX *ctx, const char *path,
  80                        uint32 desired_access,
  81                        struct registry_key **key)
  82 {
  83         WERROR werr;
  84         char *subkey_name = NULL;
  85         struct registry_key *hive = NULL;
  86         TALLOC_CTX *tmp_ctx = talloc_stackframe();
  87
  88         if ((path == NULL) || (key == NULL)) {
  89                 return WERR_INVALID_PARAM;
  90         }
  91
  92         werr = open_hive(tmp_ctx, path, desired_access, &hive, &subkey_name);
  93         if (!W_ERROR_IS_OK(werr)) {
  94                 d_fprintf(stderr, "open_hive failed: %s\n", dos_errstr(werr));
  95                 goto done;
  96         }
  97
  98         werr = reg_openkey(ctx, hive, subkey_name, desired_access, key);
  99         if (!W_ERROR_IS_OK(werr)) {
 100                 d_fprintf(stderr, "reg_openkey failed: %s\n",
 101                           dos_errstr(werr));
 102                 goto done;
 103         }
 104
 105         werr = WERR_OK;
 106
 107 done:
 108         TALLOC_FREE(tmp_ctx);
 109         return werr;
 110 }
 111
 112 /*
 113  *
 114  * the main "net registry" function implementations
 115  *
 116  */
 117
 118 static int net_registry_enumerate(int argc, const char **argv)
 119 {
 120         WERROR werr;
 121         struct registry_key *key = NULL;
 122         TALLOC_CTX *ctx = talloc_stackframe();
 123         char *subkey_name;
 124         NTTIME modtime;
 125         uint32_t count;
 126         char *valname = NULL;
 127         struct registry_value *valvalue = NULL;
 128         int ret = -1;
 129
 130         if (argc != 1) {
 131                 d_printf("Usage:    net registry enumerate <path>\n");
 132                 d_printf("Example:  net registry enumerate "
 133                          "'HKLM\\Software\\Samba'\n");
 134                 goto done;
 135         }
 136
 137         werr = open_key(ctx, argv[0], REG_KEY_READ, &key);
 138         if (!W_ERROR_IS_OK(werr)) {
 139                 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
 140                 goto done;
 141         }
 142
 143         for (count = 0;
 144              werr = reg_enumkey(ctx, key, count, &subkey_name, &modtime),
 145              W_ERROR_IS_OK(werr);
 146              count++)
 147         {
 148                 print_registry_key(subkey_name, &modtime);
 149         }
 150         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
 151                 goto done;
 152         }
 153
 154         for (count = 0;
 155              werr = reg_enumvalue(ctx, key, count, &valname, &valvalue),
 156              W_ERROR_IS_OK(werr);
 157              count++)
 158         {
 159                 print_registry_value(valname, valvalue);
 160         }
 161         if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
 162                 goto done;
 163         }
 164
 165         ret = 0;
 166 done:
 167         TALLOC_FREE(ctx);
 168         return ret;
 169 }
 170
 171 static int net_registry_createkey(int argc, const char **argv)
 172 {
 173         WERROR werr;
 174         enum winreg_CreateAction action;
 175         char *subkeyname;
 176         struct registry_key *hivekey = NULL;
 177         struct registry_key *subkey = NULL;
 178         TALLOC_CTX *ctx = talloc_stackframe();
 179         int ret = -1;
 180
 181         if (argc != 1) {
 182                 d_printf("Usage:    net registry createkey <path>\n");
 183                 d_printf("Example:  net registry createkey "
 184                          "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n");
 185                 goto done;
 186         }
 187         if (strlen(argv[0]) == 0) {
 188                 d_fprintf(stderr, "error: zero length key name given\n");
 189                 goto done;
 190         }
 191
 192         werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
 193         if (!W_ERROR_IS_OK(werr)) {
 194                 d_fprintf(stderr, "open_hive failed: %s\n", dos_errstr(werr));
 195                 goto done;
 196         }
 197
 198         werr = reg_createkey(ctx, hivekey, subkeyname, REG_KEY_WRITE,
 199                              &subkey, &action);
 200         if (!W_ERROR_IS_OK(werr)) {
 201                 d_fprintf(stderr, "reg_createkey failed: %s\n",
 202                           dos_errstr(werr));
 203                 goto done;
 204         }
 205         switch (action) {
 206                 case REG_ACTION_NONE:
 207                         d_printf("createkey did nothing -- huh?\n");
 208                         break;
 209                 case REG_CREATED_NEW_KEY:
 210                         d_printf("createkey created %s\n", argv[0]);
 211                         break;
 212                 case REG_OPENED_EXISTING_KEY:
 213                         d_printf("createkey opened existing %s\n", argv[0]);
 214                         break;
 215         }
 216
 217         ret = 0;
 218
 219 done:
 220         TALLOC_FREE(ctx);
 221         return ret;
 222 }
 223
 224 static int net_registry_deletekey(int argc, const char **argv)
 225 {
 226         WERROR werr;
 227         char *subkeyname;
 228         struct registry_key *hivekey = NULL;
 229         TALLOC_CTX *ctx = talloc_stackframe();
 230         int ret = -1;
 231
 232         if (argc != 1) {
 233                 d_printf("Usage:    net registry deletekey <path>\n");
 234                 d_printf("Example:  net registry deletekey "
 235                          "'HKLM\\Software\\Samba\\smbconf.127.0.0.1'\n");
 236                 goto done;
 237         }
 238         if (strlen(argv[0]) == 0) {
 239                 d_fprintf(stderr, "error: zero length key name given\n");
 240                 goto done;
 241         }
 242
 243         werr = open_hive(ctx, argv[0], REG_KEY_WRITE, &hivekey, &subkeyname);
 244         if (!W_ERROR_IS_OK(werr)) {
 245                 d_fprintf(stderr, "open_hive failed: %s\n", dos_errstr(werr));
 246                 goto done;
 247         }
 248
 249         werr = reg_deletekey(hivekey, subkeyname);
 250         if (!W_ERROR_IS_OK(werr)) {
 251                 d_fprintf(stderr, "reg_deletekey failed: %s\n",
 252                           dos_errstr(werr));
 253                 goto done;
 254         }
 255
 256         ret = 0;
 257
 258 done:
 259         TALLOC_FREE(ctx);
 260         return ret;
 261 }
 262
 263 static int net_registry_setvalue(int argc, const char **argv)
 264 {
 265         WERROR werr;
 266         struct registry_value value;
 267         struct registry_key *key = NULL;
 268         int ret = -1;
 269         TALLOC_CTX *ctx = talloc_stackframe();
 270
 271         if (argc < 4) {
 272                 d_fprintf(stderr, "usage: net rpc registry setvalue <key> "
 273                           "<valuename> <type> [<val>]+\n");
 274                 goto done;
 275         }
 276
 277         if (!strequal(argv[2], "multi_sz") && (argc != 4)) {
 278                 d_fprintf(stderr, "Too many args for type %s\n", argv[2]);
 279                 goto done;
 280         }
 281
 282         if (strequal(argv[2], "dword")) {
 283                 value.type = REG_DWORD;
 284                 value.v.dword = strtoul(argv[3], NULL, 10);
 285         } else if (strequal(argv[2], "sz")) {
 286                 value.type = REG_SZ;
 287                 value.v.sz.len = strlen(argv[3])+1;
 288                 value.v.sz.str = CONST_DISCARD(char *, argv[3]);
 289         } else {
 290                 d_fprintf(stderr, "type \"%s\" not implemented\n", argv[2]);
 291                 goto done;
 292         }
 293
 294         werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
 295         if (!W_ERROR_IS_OK(werr)) {
 296                 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
 297                 goto done;
 298         }
 299
 300         werr = reg_setvalue(key, argv[1], &value);
 301         if (!W_ERROR_IS_OK(werr)) {
 302                 d_fprintf(stderr, "reg_setvalue failed: %s\n",
 303                           dos_errstr(werr));
 304                 goto done;
 305         }
 306
 307         ret = 0;
 308
 309 done:
 310         TALLOC_FREE(ctx);
 311         return ret;
 312 }
 313
 314 static int net_registry_deletevalue(int argc, const char **argv)
 315 {
 316         WERROR werr;
 317         struct registry_key *key = NULL;
 318         TALLOC_CTX *ctx = talloc_stackframe();
 319         int ret = -1;
 320
 321         if (argc != 2) {
 322                 d_fprintf(stderr, "usage: net rpc registry deletevalue <key> "
 323                           "<valuename>\n");
 324                 goto done;
 325         }
 326
 327         werr = open_key(ctx, argv[0], REG_KEY_WRITE, &key);
 328         if (!W_ERROR_IS_OK(werr)) {
 329                 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
 330                 goto done;
 331         }
 332
 333         werr = reg_deletevalue(key, argv[1]);
 334         if (!W_ERROR_IS_OK(werr)) {
 335                 d_fprintf(stderr, "reg_deletekey failed: %s\n",
 336                           dos_errstr(werr));
 337                 goto done;
 338         }
 339
 340         ret = 0;
 341
 342 done:
 343         TALLOC_FREE(ctx);
 344         return ret;
 345 }
 346
 347 static int net_registry_getsd(int argc, const char **argv)
 348 {
 349         WERROR werr;
 350         int ret = -1;
 351         struct registry_key *key = NULL;
 352         struct security_descriptor *secdesc = NULL;
 353         TALLOC_CTX *ctx = talloc_stackframe();
 354         uint32_t access_mask = REG_KEY_READ |
 355                                SEC_RIGHT_MAXIMUM_ALLOWED |
 356                                SEC_RIGHT_SYSTEM_SECURITY;
 357
 358         /*
 359          * net_rpc_regsitry uses SEC_RIGHT_SYSTEM_SECURITY, but access
 360          * is denied with these perms right now...
 361          */
 362         access_mask = REG_KEY_READ;
 363
 364         if (argc != 1) {
 365                 d_printf("Usage:    net registry getsd <path>\n");
 366                 d_printf("Example:  net registry getsd "
 367                          "'HKLM\\Software\\Samba'\n");
 368                 goto done;
 369         }
 370         if (strlen(argv[0]) == 0) {
 371                 d_fprintf(stderr, "error: zero length key name given\n");
 372                 goto done;
 373         }
 374
 375         werr = open_key(ctx, argv[0], access_mask, &key);
 376         if (!W_ERROR_IS_OK(werr)) {
 377                 d_fprintf(stderr, "open_key failed: %s\n", dos_errstr(werr));
 378                 goto done;
 379         }
 380
 381         werr = reg_getkeysecurity(ctx, key, &secdesc);
 382         if (!W_ERROR_IS_OK(werr)) {
 383                 d_fprintf(stderr, "reg_getkeysecurity failed: %s\n",
 384                           dos_errstr(werr));
 385                 goto done;
 386         }
 387
 388         display_sec_desc(secdesc);
 389
 390         ret = 0;
 391
 392 done:
 393         TALLOC_FREE(ctx);
 394         return ret;
 395 }
 396
 397 int net_registry(int argc, const char **argv)
 398 {
 399         int ret = -1;
 400
 401         struct functable2 func[] = {
 402                 {
 403                         "enumerate",
 404                         net_registry_enumerate,
 405                         "Enumerate registry keys and values"
 406                 },
 407                 {
 408                         "createkey",
 409                         net_registry_createkey,
 410                         "Create a new registry key"
 411                 },
 412                 {
 413                         "deletekey",
 414                         net_registry_deletekey,
 415                         "Delete a registry key"
 416                 },
 417                 {
 418                         "setvalue",
 419                         net_registry_setvalue,
 420                         "Set a new registry value"
 421                 },
 422                 {
 423                         "deletevalue",
 424                         net_registry_deletevalue,
 425                         "Delete a registry value"
 426                 },
 427                 {
 428                         "getsd",
 429                         net_registry_getsd,
 430                         "Get security descriptor"
 431                 },
 432         { NULL, NULL, NULL }
 433         };
 434
 435         if (!registry_init_basic()) {
 436                 return -1;
 437         }
 438
 439         ret = net_run_function2(argc, argv, "net registry", func);
 440
 441         regdb_close();
 442
 443         return ret;
 444 }