source3/utils/regedit.c

   1 /*
   2  * Samba Unix/Linux SMB client library
   3  * Registry Editor
   4  * Copyright (C) Christopher Davis 2012
   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 "popt_common.h"
  22 #include "lib/util/data_blob.h"
  23 #include "lib/registry/registry.h"
  24 #include "regedit.h"
  25 #include "regedit_treeview.h"
  26 #include "regedit_valuelist.h"
  27 #include "regedit_dialog.h"
  28 #include <ncurses.h>
  29 #include <menu.h>
  30 #include <panel.h>
  31
  32 #define KEY_START_X     0
  33 #define KEY_START_Y     3
  34 #define KEY_WIDTH       (COLS / 4)
  35 #define KEY_HEIGHT      (LINES - KEY_START_Y - 1)
  36 #define VAL_START_X     KEY_WIDTH
  37 #define VAL_START_Y     3
  38 #define VAL_WIDTH       (COLS - KEY_WIDTH)
  39 #define VAL_HEIGHT      (LINES - VAL_START_Y - 1)
  40 #define HEADING_START_Y (KEY_START_Y - 1)
  41 #define INFO_START_Y    (LINES - 1)
  42 #define INFO_WIDTH      (LINES)
  43 #define PATH_START_Y    0
  44 #define PATH_START_X    6
  45 #define PATH_MAX_Y      (COLS-1)
  46 #define PATH_WIDTH_MAX  1024
  47
  48 struct regedit {
  49         WINDOW *main_window;
  50         WINDOW *path_label;
  51         struct value_list *vl;
  52         struct tree_view *keys;
  53         bool tree_input;
  54 };
  55
  56 static struct regedit *regedit_main = NULL;
  57
  58 static void show_path(struct regedit *regedit)
  59 {
  60         prefresh(regedit->path_label, 0, 0, PATH_START_Y, PATH_START_X,
  61                  PATH_START_Y, PATH_MAX_Y);
  62 }
  63
  64 static void print_path(struct regedit *regedit, struct tree_node *node)
  65 {
  66         tree_node_print_path(regedit->path_label, node);
  67 }
  68
  69 /* load all available hives */
  70 static struct tree_node *load_hives(TALLOC_CTX *mem_ctx,
  71                                     struct registry_context *ctx)
  72 {
  73         const char *hives[] = {
  74                 "HKEY_CLASSES_ROOT",
  75                 "HKEY_CURRENT_USER",
  76                 "HKEY_LOCAL_MACHINE",
  77                 "HKEY_PERFORMANCE_DATA",
  78                 "HKEY_USERS",
  79                 "HKEY_CURRENT_CONFIG",
  80                 "HKEY_DYN_DATA",
  81                 "HKEY_PERFORMANCE_TEXT",
  82                 "HKEY_PERFORMANCE_NLSTEXT",
  83                 NULL
  84         };
  85         struct tree_node *root, *prev, *node;
  86         struct registry_key *key;
  87         WERROR rv;
  88         size_t i;
  89
  90         root = NULL;
  91         prev = NULL;
  92
  93         for (i = 0; hives[i] != NULL; ++i) {
  94                 rv = reg_get_predefined_key_by_name(ctx, hives[i], &key);
  95                 if (!W_ERROR_IS_OK(rv)) {
  96                         continue;
  97                 }
  98
  99                 node = tree_node_new(mem_ctx, NULL, hives[i], key);
 100                 if (node == NULL) {
 101                         return NULL;
 102                 }
 103
 104                 if (root == NULL) {
 105                         root = node;
 106                 }
 107                 if (prev) {
 108                         tree_node_append(prev, node);
 109                 }
 110                 prev = node;
 111         }
 112
 113         return root;
 114 }
 115
 116 static void print_heading(struct regedit *regedit)
 117 {
 118         move(HEADING_START_Y, 0);
 119         clrtoeol();
 120
 121         if (regedit->tree_input) {
 122                 attron(A_REVERSE);
 123         } else {
 124                 attroff(A_REVERSE);
 125         }
 126         mvprintw(HEADING_START_Y, KEY_START_X, "Key");
 127         attroff(A_REVERSE);
 128
 129         if (!regedit->tree_input) {
 130                 attron(A_REVERSE);
 131         } else {
 132                 attroff(A_REVERSE);
 133         }
 134         mvprintw(HEADING_START_Y, VAL_START_X, "Value");
 135         attroff(A_REVERSE);
 136 }
 137
 138 static void add_reg_key(struct regedit *regedit, struct tree_node *node,
 139                         bool subkey)
 140 {
 141         char *name;
 142         const char *msg;
 143
 144         if (!subkey && !node->parent) {
 145                 return;
 146         }
 147
 148         msg = "Enter name of new key";
 149         if (subkey) {
 150                 msg = "Enter name of new subkey";
 151         }
 152         dialog_input(regedit, &name, "New Key", msg);
 153         if (name) {
 154                 WERROR rv;
 155                 struct registry_key *new_key;
 156                 struct tree_node *new_node;
 157                 struct tree_node *list;
 158                 struct tree_node *parent;
 159
 160                 if (subkey) {
 161                         parent = node;
 162                         list = node->child_head;
 163                 } else {
 164                         parent = node->parent;
 165                         list = tree_node_first(node);
 166                         SMB_ASSERT(list != NULL);
 167                 }
 168                 rv = reg_key_add_name(regedit, parent->key, name,
 169                                       NULL, NULL, &new_key);
 170                 if (W_ERROR_IS_OK(rv)) {
 171                         /* The list of subkeys may not be present in
 172                            cache yet, so if not, don't bother allocating
 173                            a new node for the key. */
 174                         if (list) {
 175                                 new_node = tree_node_new(parent, parent,
 176                                                          name, new_key);
 177                                 SMB_ASSERT(new_node);
 178                                 tree_node_append_last(list, new_node);
 179                         }
 180
 181                         list = tree_node_first(node);
 182                         tree_view_clear(regedit->keys);
 183                         tree_view_update(regedit->keys, list);
 184                 } else {
 185                         dialog_notice(regedit, DIA_ALERT, "New Key",
 186                                       "Failed to create key.");
 187                 }
 188                 talloc_free(name);
 189         }
 190 }
 191
 192 static void handle_tree_input(struct regedit *regedit, int c)
 193 {
 194         struct tree_node *node;
 195
 196         switch (c) {
 197         case KEY_DOWN:
 198                 menu_driver(regedit->keys->menu, REQ_DOWN_ITEM);
 199                 node = item_userptr(current_item(regedit->keys->menu));
 200                 value_list_load(regedit->vl, node->key);
 201                 break;
 202         case KEY_UP:
 203                 menu_driver(regedit->keys->menu, REQ_UP_ITEM);
 204                 node = item_userptr(current_item(regedit->keys->menu));
 205                 value_list_load(regedit->vl, node->key);
 206                 break;
 207         case '\n':
 208         case KEY_ENTER:
 209         case KEY_RIGHT:
 210                 node = item_userptr(current_item(regedit->keys->menu));
 211                 if (node && tree_node_has_children(node)) {
 212                         tree_node_load_children(node);
 213                         print_path(regedit, node->child_head);
 214                         tree_view_update(regedit->keys, node->child_head);
 215                         value_list_load(regedit->vl, node->child_head->key);
 216                 }
 217                 break;
 218         case KEY_LEFT:
 219                 node = item_userptr(current_item(regedit->keys->menu));
 220                 if (node && node->parent) {
 221                         print_path(regedit, node->parent);
 222                         node = tree_node_first(node->parent);
 223                         tree_view_update(regedit->keys, node);
 224                         value_list_load(regedit->vl, node->key);
 225                 }
 226                 break;
 227         case 'n':
 228         case 'N':
 229                 node = item_userptr(current_item(regedit->keys->menu));
 230                 add_reg_key(regedit, node, false);
 231                 break;
 232         case 's':
 233         case 'S':
 234                 node = item_userptr(current_item(regedit->keys->menu));
 235                 add_reg_key(regedit, node, true);
 236                 break;
 237         case 'd':
 238         case 'D': {
 239                 int sel;
 240
 241                 node = item_userptr(current_item(regedit->keys->menu));
 242                 if (!node->parent) {
 243                         break;
 244                 }
 245                 sel = dialog_notice(regedit, DIA_CONFIRM,
 246                                     "Delete Key",
 247                                      "Really delete key \"%s\"?",
 248                                      node->name);
 249                 if (sel == DIALOG_OK) {
 250                         WERROR rv;
 251                         struct tree_node *pop;
 252                         struct tree_node *parent = node->parent;
 253
 254                         rv = reg_key_del(node, parent->key, node->name);
 255                         if (W_ERROR_IS_OK(rv)) {
 256                                 tree_view_clear(regedit->keys);
 257                                 pop = tree_node_pop(&node);
 258                                 tree_node_free_recursive(pop);
 259                                 node = parent->child_head;
 260                                 if (node == NULL) {
 261                                         node = tree_node_first(parent);
 262                                         print_path(regedit, node);
 263                                 }
 264                                 tree_view_update(regedit->keys, node);
 265                                 value_list_load(regedit->vl, node->key);
 266                         } else {
 267                                 dialog_notice(regedit, DIA_ALERT, "Delete Key",
 268                                               "Failed to delete key.");
 269                         }
 270                 }
 271                 break;
 272         }
 273         }
 274
 275         tree_view_show(regedit->keys);
 276         value_list_show(regedit->vl);
 277 }
 278
 279 static void handle_value_input(struct regedit *regedit, int c)
 280 {
 281         struct value_item *vitem;
 282
 283         switch (c) {
 284         case KEY_DOWN:
 285                 menu_driver(regedit->vl->menu, REQ_DOWN_ITEM);
 286                 break;
 287         case KEY_UP:
 288                 menu_driver(regedit->vl->menu, REQ_UP_ITEM);
 289                 break;
 290         case '\n':
 291         case KEY_ENTER:
 292                 vitem = item_userptr(current_item(regedit->vl->menu));
 293                 if (vitem) {
 294                         struct tree_node *node;
 295                         node = item_userptr(current_item(regedit->keys->menu));
 296                         dialog_edit_value(regedit, node->key, vitem->type,
 297                                           vitem);
 298                         value_list_load(regedit->vl, node->key);
 299                 }
 300                 break;
 301         case 'n':
 302         case 'N': {
 303                 int new_type;
 304                 int sel;
 305
 306                 sel = dialog_select_type(regedit, &new_type);
 307                 if (sel == DIALOG_OK) {
 308                         struct tree_node *node;
 309                         node = item_userptr(current_item(regedit->keys->menu));
 310                         dialog_edit_value(regedit, node->key, new_type, NULL);
 311                         value_list_load(regedit->vl, node->key);
 312                 }
 313                 break;
 314         }
 315         case 'd':
 316         case 'D':
 317                 vitem = item_userptr(current_item(regedit->vl->menu));
 318                 if (vitem) {
 319                         int sel;
 320
 321                         sel = dialog_notice(regedit, DIA_CONFIRM,
 322                                             "Delete Value",
 323                                              "Really delete value \"%s\"?",
 324                                              vitem->value_name);
 325                         if (sel == DIALOG_OK) {
 326                                 ITEM *it = current_item(regedit->keys->menu);
 327                                 struct tree_node *node = item_userptr(it);
 328                                 reg_del_value(regedit, node->key,
 329                                               vitem->value_name);
 330                                 value_list_load(regedit->vl, node->key);
 331                         }
 332                 }
 333                 break;
 334         }
 335
 336         value_list_show(regedit->vl);
 337 }
 338
 339 static void handle_main_input(struct regedit *regedit, int c)
 340 {
 341         switch (c) {
 342         case '\t':
 343                 regedit->tree_input = !regedit->tree_input;
 344                 print_heading(regedit);
 345                 break;
 346         default:
 347                 if (regedit->tree_input) {
 348                         handle_tree_input(regedit, c);
 349                 } else {
 350                         handle_value_input(regedit, c);
 351                 }
 352         }
 353 }
 354
 355 int regedit_getch(void)
 356 {
 357         int c;
 358
 359         SMB_ASSERT(regedit_main);
 360
 361         c = getch();
 362         if (c == KEY_RESIZE) {
 363                 tree_view_resize(regedit_main->keys, KEY_HEIGHT, KEY_WIDTH,
 364                                  KEY_START_Y, KEY_START_X);
 365                 value_list_resize(regedit_main->vl, VAL_HEIGHT, VAL_WIDTH,
 366                                   VAL_START_Y, VAL_START_X);
 367                 print_heading(regedit_main);
 368         }
 369
 370         return c;
 371 }
 372
 373 static void display_window(TALLOC_CTX *mem_ctx, struct registry_context *ctx)
 374 {
 375         struct regedit *regedit;
 376         struct tree_node *root;
 377         int c;
 378
 379         initscr();
 380         start_color();
 381         cbreak();
 382         noecho();
 383
 384         regedit = talloc_zero(mem_ctx, struct regedit);
 385         SMB_ASSERT(regedit != NULL);
 386         regedit_main = regedit;
 387
 388         regedit->main_window = stdscr;
 389         keypad(regedit->main_window, TRUE);
 390
 391         mvwprintw(regedit->main_window, 0, 0, "Path: ");
 392         regedit->path_label = newpad(1, PATH_WIDTH_MAX);
 393         SMB_ASSERT(regedit->path_label);
 394         wprintw(regedit->path_label, "/");
 395
 396         root = load_hives(regedit, ctx);
 397         SMB_ASSERT(root != NULL);
 398
 399         regedit->keys = tree_view_new(regedit, root, KEY_HEIGHT, KEY_WIDTH,
 400                                       KEY_START_Y, KEY_START_X);
 401         SMB_ASSERT(regedit->keys != NULL);
 402
 403         regedit->vl = value_list_new(regedit, VAL_HEIGHT, VAL_WIDTH,
 404                                      VAL_START_Y, VAL_START_X);
 405         SMB_ASSERT(regedit->vl != NULL);
 406
 407         regedit->tree_input = true;
 408         print_heading(regedit);
 409
 410         tree_view_show(regedit->keys);
 411         value_list_show(regedit->vl);
 412
 413         update_panels();
 414         doupdate();
 415         show_path(regedit_main);
 416         while (1) {
 417                 c = regedit_getch();
 418                 if (c == 'q' || c == 'Q') {
 419                         break;
 420                 }
 421                 handle_main_input(regedit, c);
 422                 update_panels();
 423                 doupdate();
 424                 show_path(regedit_main);
 425         }
 426
 427         endwin();
 428 }
 429
 430 int main(int argc, char **argv)
 431 {
 432         struct poptOption long_options[] = {
 433                 POPT_AUTOHELP
 434                 /* ... */
 435                 POPT_COMMON_SAMBA
 436                 POPT_COMMON_CONNECTION
 437                 POPT_COMMON_CREDENTIALS
 438                 POPT_TABLEEND
 439         };
 440         int opt;
 441         poptContext pc;
 442         struct user_auth_info *auth_info;
 443         TALLOC_CTX *frame;
 444         struct registry_context *ctx;
 445         WERROR rv;
 446
 447         talloc_enable_leak_report_full();
 448
 449         frame = talloc_stackframe();
 450
 451         setup_logging("regedit", DEBUG_DEFAULT_STDERR);
 452         lp_set_cmdline("log level", "0");
 453
 454         /* process options */
 455         auth_info = user_auth_info_init(frame);
 456         if (auth_info == NULL) {
 457                 exit(1);
 458         }
 459         popt_common_set_auth_info(auth_info);
 460         pc = poptGetContext("regedit", argc, (const char **)argv, long_options, 0);
 461
 462         while ((opt = poptGetNextOpt(pc)) != -1) {
 463                 /* TODO */
 464         }
 465
 466         if (!lp_load_global(get_dyn_CONFIGFILE())) {
 467                 DEBUG(0, ("ERROR loading config file...\n"));
 468                 exit(1);
 469         }
 470
 471         /* some simple tests */
 472
 473         rv = reg_open_samba3(frame, &ctx);
 474         if (!W_ERROR_IS_OK(rv)) {
 475                 TALLOC_FREE(frame);
 476
 477                 return 1;
 478         }
 479
 480         display_window(frame, ctx);
 481
 482         //talloc_report_full(frame, stdout);
 483
 484         TALLOC_FREE(frame);
 485
 486         return 0;
 487 }