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