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 "regedit_list.h"
  29 #include <ncurses.h>
  30 #include <menu.h>
  31 #include <panel.h>
  32
  33 #define KEY_START_X     0
  34 #define KEY_START_Y     1
  35 #define KEY_WIDTH       (COLS / 4)
  36 #define KEY_HEIGHT      (LINES - KEY_START_Y - 2)
  37 #define VAL_START_X     KEY_WIDTH
  38 #define VAL_START_Y     1
  39 #define VAL_WIDTH       (COLS - KEY_WIDTH)
  40 #define VAL_HEIGHT      (LINES - VAL_START_Y - 2)
  41
  42 #define HELP1_START_Y   (LINES - 2)
  43 #define HELP1_START_X   0
  44 #define HELP1_WIDTH     (LINES)
  45 #define HELP2_START_Y   (LINES - 1)
  46 #define HELP2_START_X   0
  47 #define HELP2_WIDTH     (LINES)
  48 #define PATH_START_Y    0
  49 #define PATH_START_X    6
  50 #define PATH_MAX_Y      (COLS - 1)
  51 #define PATH_WIDTH      (COLS - 6)
  52 #define PATH_WIDTH_MAX  1024
  53
  54 struct regedit {
  55         struct registry_context *registry_context;
  56         WINDOW *main_window;
  57         WINDOW *path_label;
  58         size_t path_len;
  59         struct value_list *vl;
  60         struct tree_view *keys;
  61         bool tree_input;
  62         struct regedit_search_opts active_search;
  63 };
  64
  65 static struct regedit *regedit_main = NULL;
  66
  67 static void show_path(struct regedit *regedit)
  68 {
  69         int start_pad = 0;
  70         int start_win = PATH_START_X;
  71
  72         if (PATH_START_X + regedit->path_len > COLS) {
  73                 start_pad = 3 + PATH_START_X + regedit->path_len - COLS;
  74                 mvprintw(PATH_START_Y, start_win, "...");
  75                 start_win += 3;
  76         }
  77         copywin(regedit->path_label, regedit->main_window, 0, start_pad,
  78                 PATH_START_Y, start_win, PATH_START_Y, PATH_MAX_Y, false);
  79
  80         mvchgat(0, 0, COLS, A_BOLD, PAIR_YELLOW_CYAN, NULL);
  81 }
  82
  83 static void print_path(struct regedit *regedit, struct tree_node *node)
  84 {
  85         regedit->path_len = tree_node_print_path(regedit->path_label, node);
  86         show_path(regedit);
  87 }
  88
  89 static void print_help(struct regedit *regedit)
  90 {
  91         const char *khelp = "[n] New Key [s] New Subkey [d] Del Key "
  92                             "[LEFT] Ascend [RIGHT] Descend";
  93         const char *vhelp = "[n] New Value [d] Del Value [ENTER] Edit "
  94                             "[b] Edit binary";
  95         const char *msg = "KEYS";
  96         const char *help = khelp;
  97         const char *genhelp = "[TAB] Switch sections [q] Quit "
  98                               "[UP] List up [DOWN] List down "
  99                               "[/] Search [x] Next";
 100         int i, pad;
 101
 102         if (!regedit->tree_input) {
 103                 msg = "VALUES";
 104                 help = vhelp;
 105         }
 106
 107         move(HELP1_START_Y, HELP1_START_X);
 108         clrtoeol();
 109         attron(COLOR_PAIR(PAIR_BLACK_CYAN));
 110         mvaddstr(HELP1_START_Y, HELP1_START_X, help);
 111         pad = COLS - strlen(msg) - strlen(help);
 112         for (i = 0; i < pad; ++i) {
 113                 addch(' ');
 114         }
 115         attroff(COLOR_PAIR(PAIR_BLACK_CYAN));
 116         attron(COLOR_PAIR(PAIR_YELLOW_CYAN) | A_BOLD);
 117         addstr(msg);
 118         attroff(COLOR_PAIR(PAIR_YELLOW_CYAN) | A_BOLD);
 119
 120         move(HELP2_START_Y, HELP2_START_X);
 121         clrtoeol();
 122         mvaddstr(HELP2_START_Y, HELP2_START_X, genhelp);
 123 }
 124
 125 static void print_heading(struct regedit *regedit)
 126 {
 127         if (regedit->tree_input) {
 128                 tree_view_set_selected(regedit->keys, true);
 129                 value_list_set_selected(regedit->vl, false);
 130         } else {
 131                 tree_view_set_selected(regedit->keys, false);
 132                 value_list_set_selected(regedit->vl, true);
 133         }
 134
 135         print_help(regedit);
 136 }
 137
 138 static void load_values(struct regedit *regedit)
 139 {
 140         struct tree_node *node;
 141
 142         node = tree_view_get_current_node(regedit->keys);
 143         value_list_load(regedit->vl, node->key);
 144 }
 145
 146 static void add_reg_key(struct regedit *regedit, struct tree_node *node,
 147                         bool subkey)
 148 {
 149         const char *name;
 150         const char *msg;
 151
 152         if (!subkey && tree_node_is_top_level(node)) {
 153                 return;
 154         }
 155
 156         msg = "Enter name of new key";
 157         if (subkey) {
 158                 msg = "Enter name of new subkey";
 159         }
 160         dialog_input(regedit, &name, "New Key", msg);
 161         if (name) {
 162                 WERROR rv;
 163                 struct registry_key *new_key;
 164                 struct tree_node *new_node = NULL;
 165                 struct tree_node *list;
 166                 struct tree_node *parent;
 167
 168                 if (subkey) {
 169                         parent = node;
 170                         list = node->child_head;
 171                 } else {
 172                         parent = node->parent;
 173                         list = tree_node_first(node);
 174                         SMB_ASSERT(list != NULL);
 175                 }
 176                 rv = reg_key_add_name(regedit, parent->key, name,
 177                                       NULL, NULL, &new_key);
 178                 if (W_ERROR_IS_OK(rv)) {
 179                         /* The list of subkeys may not be present in
 180                            cache yet, so if not, don't bother allocating
 181                            a new node for the key. */
 182                         if (list) {
 183                                 new_node = tree_node_new(parent, parent,
 184                                                          name, new_key);
 185                                 SMB_ASSERT(new_node);
 186                                 tree_node_insert_sorted(list, new_node);
 187                         } else {
 188                                 /* Reopen the parent key to make sure the
 189                                    new subkey will be noticed. */
 190                                 tree_node_reopen_key(regedit->registry_context,
 191                                                      parent);
 192                         }
 193
 194                         list = tree_node_first(node);
 195                         tree_view_clear(regedit->keys);
 196                         tree_view_update(regedit->keys, list);
 197                         if (!subkey) {
 198                                 node = new_node;
 199                         }
 200                         tree_view_set_current_node(regedit->keys, node);
 201                         load_values(regedit);
 202                 } else {
 203                         msg = get_friendly_werror_msg(rv);
 204                         dialog_notice(regedit, DIA_ALERT, "New Key",
 205                                       "Failed to create key: %s", msg);
 206                 }
 207                 talloc_free(discard_const(name));
 208         }
 209 }
 210
 211 enum search_flags {
 212         SEARCH_NEXT = (1<<0),
 213         SEARCH_PREV = (1<<1),
 214         SEARCH_REPEAT = (1<<2)
 215 };
 216 static WERROR regedit_search(struct regedit *regedit, struct tree_node *node,
 217                              struct value_item *vitem, unsigned flags)
 218 {
 219         struct regedit_search_opts *opts;
 220         struct tree_node *found;
 221         struct value_item *found_value;
 222         bool search_key, need_sync;
 223         char *save_value_name;
 224         WERROR rv;
 225         bool (*iterate)(struct tree_node **, bool, WERROR *);
 226         struct value_item *(*find_item)(struct value_list *,
 227                                         struct value_item *,
 228                                         const char *,
 229                                         regedit_search_match_fn_t);
 230
 231         opts = &regedit->active_search;
 232
 233         if (!opts->query || !opts->match) {
 234                 return WERR_OK;
 235         }
 236
 237         SMB_ASSERT(opts->search_key || opts->search_value);
 238
 239         rv = WERR_OK;
 240         found = NULL;
 241         found_value = NULL;
 242         save_value_name = NULL;
 243         search_key = opts->search_key;
 244         need_sync = false;
 245         iterate = tree_node_next;
 246         find_item = value_list_find_next_item;
 247
 248         if (flags & SEARCH_PREV) {
 249                 iterate = tree_node_prev;
 250                 find_item = value_list_find_prev_item;
 251         }
 252
 253         if (opts->search_value) {
 254                 struct value_item *it;
 255
 256                 it = value_list_get_current_item(regedit->vl);
 257                 if (it) {
 258                         save_value_name = talloc_strdup(regedit,
 259                                                         it->value_name);
 260                         if (save_value_name == NULL) {
 261                                 return WERR_NOMEM;
 262                         }
 263                 }
 264
 265                 if (vitem) {
 266                         search_key = false;
 267                 }
 268         }
 269
 270         if (!vitem && (flags & SEARCH_REPEAT)) {
 271                 if (opts->search_value) {
 272                         search_key = false;
 273                 } else if (!iterate(&node, opts->search_recursive, &rv)) {
 274                         beep();
 275                         return rv;
 276                 }
 277         }
 278
 279         do {
 280                 if (search_key) {
 281                         SMB_ASSERT(opts->search_key == true);
 282                         if (opts->match(node->name, opts->query)) {
 283                                 found = node;
 284                         } else if (opts->search_value) {
 285                                 search_key = false;
 286                         }
 287                 }
 288                 if (!search_key) {
 289                         SMB_ASSERT(opts->search_value == true);
 290                         if (!vitem) {
 291                                 rv = value_list_load_quick(regedit->vl,
 292                                                            node->key);
 293                                 if (!W_ERROR_IS_OK(rv)) {
 294                                         goto out;
 295                                 }
 296                                 need_sync = true;
 297                         }
 298                         found_value = find_item(regedit->vl, vitem, opts->query,
 299                                                 opts->match);
 300                         if (found_value) {
 301                                 found = node;
 302                         } else {
 303                                 vitem = NULL;
 304                                 search_key = opts->search_key;
 305                         }
 306                 }
 307         } while (!found && iterate(&node, opts->search_recursive, &rv));
 308
 309         if (!W_ERROR_IS_OK(rv)) {
 310                 goto out;
 311         }
 312
 313         if (found) {
 314                 /* Put the cursor on the node that was found */
 315                 if (!tree_view_is_node_visible(regedit->keys, found)) {
 316                         tree_view_update(regedit->keys,
 317                                          tree_node_first(found));
 318                         print_path(regedit, found);
 319                 }
 320                 tree_view_set_current_node(regedit->keys, found);
 321                 if (found_value) {
 322                         if (need_sync) {
 323                                 value_list_sync(regedit->vl);
 324                         }
 325                         value_list_set_current_item(regedit->vl, found_value);
 326                         regedit->tree_input = false;
 327                 } else {
 328                         load_values(regedit);
 329                         regedit->tree_input = true;
 330                 }
 331                 tree_view_show(regedit->keys);
 332                 value_list_show(regedit->vl);
 333                 print_heading(regedit);
 334         } else {
 335                 if (need_sync) {
 336                         load_values(regedit);
 337                         value_list_set_current_item_by_name(regedit->vl,
 338                                                             save_value_name);
 339                 }
 340                 beep();
 341         }
 342
 343 out:
 344         talloc_free(save_value_name);
 345
 346         return rv;
 347 }
 348
 349 static void regedit_search_repeat(struct regedit *regedit, unsigned flags)
 350 {
 351         struct tree_node *node;
 352         struct value_item *vitem;
 353         struct regedit_search_opts *opts;
 354
 355         opts = &regedit->active_search;
 356         if (opts->query == NULL) {
 357                 return;
 358         }
 359
 360         node = tree_view_get_current_node(regedit->keys);
 361         vitem = NULL;
 362         if (opts->search_value && !regedit->tree_input) {
 363                 vitem = value_list_get_current_item(regedit->vl);
 364         }
 365         regedit_search(regedit, node, vitem, flags | SEARCH_REPEAT);
 366 }
 367
 368 static void handle_tree_input(struct regedit *regedit, int c)
 369 {
 370         struct tree_node *node;
 371
 372         switch (c) {
 373         case KEY_DOWN:
 374                 tree_view_driver(regedit->keys, ML_CURSOR_DOWN);
 375                 load_values(regedit);
 376                 break;
 377         case KEY_UP:
 378                 tree_view_driver(regedit->keys, ML_CURSOR_UP);
 379                 load_values(regedit);
 380                 break;
 381         case KEY_NPAGE:
 382                 tree_view_driver(regedit->keys, ML_CURSOR_PGDN);
 383                 load_values(regedit);
 384                 break;
 385         case KEY_PPAGE:
 386                 tree_view_driver(regedit->keys, ML_CURSOR_PGUP);
 387                 load_values(regedit);
 388                 break;
 389         case KEY_HOME:
 390                 tree_view_driver(regedit->keys, ML_CURSOR_HOME);
 391                 load_values(regedit);
 392                 break;
 393         case KEY_END:
 394                 tree_view_driver(regedit->keys, ML_CURSOR_END);
 395                 load_values(regedit);
 396                 break;
 397         case '\n':
 398         case KEY_ENTER:
 399         case KEY_RIGHT:
 400                 node = tree_view_get_current_node(regedit->keys);
 401                 if (node && tree_node_has_children(node)) {
 402                         WERROR rv;
 403
 404                         rv = tree_node_load_children(node);
 405                         if (W_ERROR_IS_OK(rv)) {
 406                                 print_path(regedit, node->child_head);
 407                                 tree_view_update(regedit->keys, node->child_head);
 408                                 value_list_load(regedit->vl, node->child_head->key);
 409                         } else {
 410                                 const char *msg = get_friendly_werror_msg(rv);
 411                                 dialog_notice(regedit, DIA_ALERT, "Loading Subkeys",
 412                                               "Failed to load subkeys: %s", msg);
 413                         }
 414                 }
 415                 break;
 416         case KEY_LEFT:
 417                 node = tree_view_get_current_node(regedit->keys);
 418                 if (node && !tree_node_is_top_level(node)) {
 419                         print_path(regedit, node->parent);
 420                         node = node->parent;
 421                         tree_view_update(regedit->keys, tree_node_first(node));
 422                         tree_view_set_current_node(regedit->keys, node);
 423                         value_list_load(regedit->vl, node->key);
 424                 }
 425                 break;
 426         case 'n':
 427         case 'N':
 428                 node = tree_view_get_current_node(regedit->keys);
 429                 add_reg_key(regedit, node, false);
 430                 break;
 431         case 's':
 432         case 'S':
 433                 node = tree_view_get_current_node(regedit->keys);
 434                 add_reg_key(regedit, node, true);
 435                 break;
 436         case 'd':
 437         case 'D': {
 438                 int sel;
 439
 440                 node = tree_view_get_current_node(regedit->keys);
 441                 if (tree_node_is_top_level(node)) {
 442                         break;
 443                 }
 444                 sel = dialog_notice(regedit, DIA_CONFIRM,
 445                                     "Delete Key",
 446                                      "Really delete key \"%s\"?",
 447                                      node->name);
 448                 if (sel == DIALOG_OK) {
 449                         WERROR rv;
 450                         struct tree_node *pop;
 451                         struct tree_node *parent = node->parent;
 452
 453                         rv = reg_key_del(node, parent->key, node->name);
 454                         if (W_ERROR_IS_OK(rv)) {
 455                                 tree_node_reopen_key(regedit->registry_context,
 456                                                      parent);
 457                                 tree_view_clear(regedit->keys);
 458                                 pop = tree_node_pop(&node);
 459                                 talloc_free(pop);
 460                                 node = parent->child_head;
 461                                 if (node == NULL) {
 462                                         node = tree_node_first(parent);
 463                                         print_path(regedit, node);
 464                                 }
 465                                 tree_view_update(regedit->keys, node);
 466                                 value_list_load(regedit->vl, node->key);
 467                         } else {
 468                                 const char *msg = get_friendly_werror_msg(rv);
 469                                 dialog_notice(regedit, DIA_ALERT, "Delete Key",
 470                                               "Failed to delete key: %s", msg);
 471                         }
 472                 }
 473                 break;
 474         }
 475         }
 476
 477         tree_view_show(regedit->keys);
 478         value_list_show(regedit->vl);
 479 }
 480
 481 static void handle_value_input(struct regedit *regedit, int c)
 482 {
 483         struct value_item *vitem;
 484         bool binmode = false;
 485         WERROR err;
 486         int sel;
 487
 488         switch (c) {
 489         case KEY_DOWN:
 490                 value_list_driver(regedit->vl, ML_CURSOR_DOWN);
 491                 break;
 492         case KEY_UP:
 493                 value_list_driver(regedit->vl, ML_CURSOR_UP);
 494                 break;
 495         case KEY_NPAGE:
 496                 value_list_driver(regedit->vl, ML_CURSOR_PGDN);
 497                 break;
 498         case KEY_PPAGE:
 499                 value_list_driver(regedit->vl, ML_CURSOR_PGUP);
 500                 break;
 501         case KEY_HOME:
 502                 value_list_driver(regedit->vl, ML_CURSOR_HOME);
 503                 break;
 504         case KEY_END:
 505                 value_list_driver(regedit->vl, ML_CURSOR_END);
 506                 break;
 507         case 'b':
 508         case 'B':
 509                 binmode = true;
 510                 /* Falthrough... */
 511         case '\n':
 512         case KEY_ENTER:
 513                 vitem = value_list_get_current_item(regedit->vl);
 514                 if (vitem) {
 515                         struct tree_node *node;
 516                         const char *name = NULL;
 517                         node = tree_view_get_current_node(regedit->keys);
 518                         sel = dialog_edit_value(regedit, node->key, vitem->type,
 519                                                 vitem, binmode, &err, &name);
 520                         if (!W_ERROR_IS_OK(err)) {
 521                                 const char *msg = get_friendly_werror_msg(err);
 522                                 dialog_notice(regedit, DIA_ALERT, "Error",
 523                                               "Error editing value:\n%s", msg);
 524                         } else if (sel == DIALOG_OK) {
 525                                 tree_node_reopen_key(regedit->registry_context,
 526                                                      node);
 527                                 value_list_load(regedit->vl, node->key);
 528                                 value_list_set_current_item_by_name(regedit->vl,
 529                                                                     name);
 530                                 talloc_free(discard_const(name));
 531                         }
 532                 }
 533                 break;
 534         case 'n':
 535         case 'N': {
 536                 int new_type;
 537
 538                 sel = dialog_select_type(regedit, &new_type);
 539                 if (sel == DIALOG_OK) {
 540                         struct tree_node *node;
 541                         const char *name = NULL;
 542                         node = tree_view_get_current_node(regedit->keys);
 543                         sel = dialog_edit_value(regedit, node->key, new_type,
 544                                                 NULL, false, &err, &name);
 545                         if (!W_ERROR_IS_OK(err)) {
 546                                 const char *msg = get_friendly_werror_msg(err);
 547                                 dialog_notice(regedit, DIA_ALERT, "Error",
 548                                               "Error creating value:\n%s", msg);
 549                         } else if (sel == DIALOG_OK) {
 550                                 tree_node_reopen_key(regedit->registry_context,
 551                                                      node);
 552                                 value_list_load(regedit->vl, node->key);
 553                                 value_list_set_current_item_by_name(regedit->vl,
 554                                                                     name);
 555                                 talloc_free(discard_const(name));
 556                         }
 557                 }
 558                 break;
 559         }
 560         case 'd':
 561         case 'D':
 562                 vitem = value_list_get_current_item(regedit->vl);
 563                 if (vitem) {
 564                         sel = dialog_notice(regedit, DIA_CONFIRM,
 565                                             "Delete Value",
 566                                              "Really delete value \"%s\"?",
 567                                              vitem->value_name);
 568                         if (sel == DIALOG_OK) {
 569                                 struct tree_node *node;
 570                                 node = tree_view_get_current_node(regedit->keys);
 571                                 reg_del_value(regedit, node->key,
 572                                               vitem->value_name);
 573                                 tree_node_reopen_key(regedit->registry_context,
 574                                                      node);
 575                                 value_list_load(regedit->vl, node->key);
 576                         }
 577                 }
 578                 break;
 579         }
 580
 581         value_list_show(regedit->vl);
 582 }
 583
 584 static bool find_substring(const char *haystack, const char *needle)
 585 {
 586         return strstr(haystack, needle) != NULL;
 587 }
 588
 589 static bool find_substring_nocase(const char *haystack, const char *needle)
 590 {
 591         return strcasestr(haystack, needle) != NULL;
 592 }
 593
 594 static void handle_main_input(struct regedit *regedit, int c)
 595 {
 596         switch (c) {
 597         case 18: { /* CTRL-R */
 598                 struct tree_node *root, *node;
 599                 const char **path;
 600
 601                 node = tree_view_get_current_node(regedit->keys);
 602                 path = tree_node_get_path(regedit, node);
 603                 SMB_ASSERT(path != NULL);
 604
 605                 root = tree_node_new_root(regedit, regedit->registry_context);
 606                 SMB_ASSERT(root != NULL);
 607
 608                 tree_view_set_root(regedit->keys, root);
 609                 tree_view_set_path(regedit->keys, path);
 610                 node = tree_view_get_current_node(regedit->keys);
 611                 value_list_load(regedit->vl, node->key);
 612                 tree_view_show(regedit->keys);
 613                 value_list_show(regedit->vl);
 614                 print_path(regedit, node);
 615                 talloc_free(discard_const(path));
 616                 break;
 617         }
 618         case 'f':
 619         case 'F':
 620         case '/': {
 621                 int rv;
 622                 struct regedit_search_opts *opts;
 623                 struct tree_node *node;
 624
 625                 opts = &regedit->active_search;
 626                 rv = dialog_search_input(regedit, opts);
 627                 if (rv == DIALOG_OK) {
 628                         SMB_ASSERT(opts->query != NULL);
 629                         opts->match = find_substring_nocase;
 630                         node = regedit->keys->root->child_head;
 631                         if (opts->search_case) {
 632                                 opts->match = find_substring;
 633                         }
 634                         if (!opts->search_recursive) {
 635                                 node = tree_view_get_current_node(regedit->keys);
 636                                 node = tree_node_first(node);
 637                         }
 638                         regedit_search(regedit, node, NULL, SEARCH_NEXT);
 639                 }
 640                 break;
 641         }
 642         case 'x':
 643                 regedit_search_repeat(regedit, SEARCH_NEXT);
 644                 break;
 645         case 'X':
 646                 regedit_search_repeat(regedit, SEARCH_PREV);
 647                 break;
 648         case '\t':
 649                 regedit->tree_input = !regedit->tree_input;
 650                 print_heading(regedit);
 651                 break;
 652         default:
 653                 if (regedit->tree_input) {
 654                         handle_tree_input(regedit, c);
 655                 } else {
 656                         handle_value_input(regedit, c);
 657                 }
 658         }
 659 }
 660
 661 int regedit_getch(void)
 662 {
 663         int c;
 664
 665         SMB_ASSERT(regedit_main);
 666
 667         c = getch();
 668         if (c == KEY_RESIZE) {
 669                 tree_view_resize(regedit_main->keys, KEY_HEIGHT, KEY_WIDTH,
 670                                  KEY_START_Y, KEY_START_X);
 671                 value_list_resize(regedit_main->vl, VAL_HEIGHT, VAL_WIDTH,
 672                                   VAL_START_Y, VAL_START_X);
 673                 print_heading(regedit_main);
 674                 show_path(regedit_main);
 675         }
 676
 677         return c;
 678 }
 679
 680 static void regedit_panic_handler(const char *msg)
 681 {
 682         endwin();
 683         smb_panic_s3(msg);
 684 }
 685
 686 static void display_window(TALLOC_CTX *mem_ctx, struct registry_context *ctx)
 687 {
 688         struct regedit *regedit;
 689         struct tree_node *root;
 690         bool colors;
 691         int key;
 692
 693         initscr();
 694
 695         cbreak();
 696         noecho();
 697
 698         fault_configure(regedit_panic_handler);
 699
 700         colors = has_colors();
 701         if (colors) {
 702                 start_color();
 703                 use_default_colors();
 704                 assume_default_colors(COLOR_WHITE, COLOR_BLUE);
 705                 init_pair(PAIR_YELLOW_CYAN, COLOR_YELLOW, COLOR_CYAN);
 706                 init_pair(PAIR_BLACK_CYAN, COLOR_BLACK, COLOR_CYAN);
 707                 init_pair(PAIR_YELLOW_BLUE, COLOR_YELLOW, COLOR_BLUE);
 708         }
 709
 710         regedit = talloc_zero(mem_ctx, struct regedit);
 711         SMB_ASSERT(regedit != NULL);
 712         regedit_main = regedit;
 713
 714         regedit->registry_context = ctx;
 715         regedit->main_window = stdscr;
 716         keypad(regedit->main_window, TRUE);
 717
 718         mvwprintw(regedit->main_window, 0, 0, "Path: ");
 719         regedit->path_label = newpad(1, PATH_WIDTH_MAX);
 720         SMB_ASSERT(regedit->path_label);
 721         wprintw(regedit->path_label, "/");
 722         show_path(regedit_main);
 723
 724         root = tree_node_new_root(regedit, ctx);
 725         SMB_ASSERT(root != NULL);
 726
 727         regedit->keys = tree_view_new(regedit, root, KEY_HEIGHT, KEY_WIDTH,
 728                                       KEY_START_Y, KEY_START_X);
 729         SMB_ASSERT(regedit->keys != NULL);
 730
 731         regedit->vl = value_list_new(regedit, VAL_HEIGHT, VAL_WIDTH,
 732                                      VAL_START_Y, VAL_START_X);
 733         SMB_ASSERT(regedit->vl != NULL);
 734
 735         regedit->tree_input = true;
 736         print_heading(regedit);
 737
 738         tree_view_show(regedit->keys);
 739         load_values(regedit);
 740         value_list_show(regedit->vl);
 741
 742         update_panels();
 743         doupdate();
 744
 745         do {
 746                 key = regedit_getch();
 747
 748                 handle_main_input(regedit, key);
 749                 update_panels();
 750                 doupdate();
 751         } while (key != 'q' || key == 'Q');
 752
 753         endwin();
 754 }
 755
 756 int main(int argc, const char **argv)
 757 {
 758         struct poptOption long_options[] = {
 759                 POPT_AUTOHELP
 760                 /* ... */
 761                 POPT_COMMON_SAMBA
 762                 POPT_COMMON_CONNECTION
 763                 POPT_COMMON_CREDENTIALS
 764                 POPT_TABLEEND
 765         };
 766         int opt;
 767         poptContext pc;
 768         struct user_auth_info *auth_info;
 769         TALLOC_CTX *frame;
 770         struct registry_context *ctx;
 771         WERROR rv;
 772
 773         frame = talloc_stackframe();
 774
 775         setup_logging("regedit", DEBUG_DEFAULT_STDERR);
 776         lp_set_cmdline("log level", "0");
 777
 778         /* process options */
 779         auth_info = user_auth_info_init(frame);
 780         if (auth_info == NULL) {
 781                 exit(1);
 782         }
 783         popt_common_set_auth_info(auth_info);
 784         pc = poptGetContext("regedit", argc, argv, long_options, 0);
 785
 786         while ((opt = poptGetNextOpt(pc)) != -1) {
 787                 /* TODO */
 788         }
 789
 790         if (!lp_load_global(get_dyn_CONFIGFILE())) {
 791                 DEBUG(0, ("ERROR loading config file...\n"));
 792                 exit(1);
 793         }
 794
 795         rv = reg_open_samba3(frame, &ctx);
 796         if (!W_ERROR_IS_OK(rv)) {
 797                 fprintf(stderr, "Unable to open registry: %s\n",
 798                         win_errstr(rv));
 799                 TALLOC_FREE(frame);
 800
 801                 return 1;
 802         }
 803
 804         display_window(frame, ctx);
 805
 806         TALLOC_FREE(frame);
 807
 808         return 0;
 809 }