source3/utils/regedit_treeview.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 "regedit_treeview.h"
  21 #include "regedit_list.h"
  22 #include "lib/registry/registry.h"
  23
  24 #define HEADING_X 3
  25
  26 static int tree_node_free(struct tree_node *node)
  27 {
  28         DEBUG(9, ("tree_node_free('%s', %p)\n", node->name, node));
  29         return 0;
  30 }
  31
  32 struct tree_node *tree_node_new(TALLOC_CTX *ctx, struct tree_node *parent,
  33                                 const char *name, struct registry_key *key)
  34 {
  35         struct tree_node *node;
  36
  37         node = talloc_zero(ctx, struct tree_node);
  38         if (!node) {
  39                 return NULL;
  40         }
  41         talloc_set_destructor(node, tree_node_free);
  42         DEBUG(9, ("tree_node_new('%s', %p)\n", name, node));
  43
  44         node->name = talloc_strdup(node, name);
  45         if (!node->name) {
  46                 talloc_free(node);
  47                 return NULL;
  48         }
  49
  50         if (key) {
  51                 node->key = talloc_steal(node, key);
  52         }
  53
  54         if (parent) {
  55                 /* Check if this node is the first descendant of parent. */
  56                 if (!parent->child_head) {
  57                         parent->child_head = node;
  58                 }
  59                 node->parent = parent;
  60         }
  61
  62         return node;
  63 }
  64
  65 /* prepare a root node with all available hives as children */
  66 struct tree_node *tree_node_new_root(TALLOC_CTX *ctx,
  67                                      struct registry_context *regctx)
  68 {
  69         const char *hives[] = {
  70                 "HKEY_CLASSES_ROOT",
  71                 "HKEY_CURRENT_USER",
  72                 "HKEY_LOCAL_MACHINE",
  73                 "HKEY_PERFORMANCE_DATA",
  74                 "HKEY_USERS",
  75                 "HKEY_CURRENT_CONFIG",
  76                 "HKEY_DYN_DATA",
  77                 "HKEY_PERFORMANCE_TEXT",
  78                 "HKEY_PERFORMANCE_NLSTEXT",
  79                 NULL
  80         };
  81         struct tree_node *root, *prev, *node;
  82         struct registry_key *key;
  83         WERROR rv;
  84         size_t i;
  85
  86         root = tree_node_new(ctx, NULL, "ROOT", NULL);
  87         if (root == NULL) {
  88                 return NULL;
  89         }
  90         prev = NULL;
  91
  92         for (i = 0; hives[i] != NULL; ++i) {
  93                 rv = reg_get_predefined_key_by_name(regctx, hives[i], &key);
  94                 if (!W_ERROR_IS_OK(rv)) {
  95                         continue;
  96                 }
  97
  98                 node = tree_node_new(root, root, hives[i], key);
  99                 if (node == NULL) {
 100                         return NULL;
 101                 }
 102                 if (prev) {
 103                         tree_node_append(prev, node);
 104                 }
 105                 prev = node;
 106         }
 107
 108         return root;
 109 }
 110
 111 void tree_node_append(struct tree_node *left, struct tree_node *right)
 112 {
 113         if (left->next) {
 114                 right->next = left->next;
 115                 left->next->previous = right;
 116         }
 117         left->next = right;
 118         right->previous = left;
 119 }
 120
 121 void tree_node_append_last(struct tree_node *list, struct tree_node *node)
 122 {
 123         tree_node_append(tree_node_last(list), node);
 124 }
 125
 126 struct tree_node *tree_node_pop(struct tree_node **plist)
 127 {
 128         struct tree_node *node;
 129
 130         node = *plist;
 131
 132         if (node == NULL)
 133                 return NULL;
 134
 135         *plist = node->previous;
 136         if (*plist == NULL) {
 137                 *plist = node->next;
 138         }
 139         if (node->previous) {
 140                 node->previous->next = node->next;
 141         }
 142         if (node->next) {
 143                 node->next->previous = node->previous;
 144         }
 145         if (node->parent && node->parent->child_head == node) {
 146                 node->parent->child_head = node->next;
 147         }
 148         node->next = NULL;
 149         node->previous = NULL;
 150
 151         return node;
 152 }
 153
 154 struct tree_node *tree_node_first(struct tree_node *list)
 155 {
 156         /* Grab the first node in this list from the parent if available. */
 157         if (list->parent) {
 158                 return list->parent->child_head;
 159         }
 160
 161         while (list && list->previous) {
 162                 list = list->previous;
 163         }
 164
 165         return list;
 166 }
 167
 168 struct tree_node *tree_node_last(struct tree_node *list)
 169 {
 170         while (list && list->next) {
 171                 list = list->next;
 172         }
 173
 174         return list;
 175 }
 176
 177 static uint32_t get_num_subkeys(struct tree_node *node)
 178 {
 179         const char *classname;
 180         uint32_t num_subkeys;
 181         uint32_t num_values;
 182         NTTIME last_change_time;
 183         uint32_t max_subkeynamelen;
 184         uint32_t max_valnamelen;
 185         uint32_t max_valbufsize;
 186         WERROR rv;
 187
 188         rv = reg_key_get_info(node, node->key, &classname, &num_subkeys,
 189                               &num_values, &last_change_time,
 190                               &max_subkeynamelen, &max_valnamelen,
 191                               &max_valbufsize);
 192
 193         if (W_ERROR_IS_OK(rv)) {
 194                 return num_subkeys;
 195         }
 196
 197         return 0;
 198 }
 199
 200 WERROR tree_node_reopen_key(struct registry_context *ctx,
 201                             struct tree_node *node)
 202 {
 203         SMB_ASSERT(node->parent != NULL);
 204         SMB_ASSERT(node->name != NULL);
 205         TALLOC_FREE(node->key);
 206
 207         if (tree_node_is_top_level(node)) {
 208                 WERROR rv;
 209                 struct registry_key *key;
 210                 rv = reg_get_predefined_key_by_name(ctx, node->name, &key);
 211                 if (W_ERROR_IS_OK(rv)) {
 212                         node->key = talloc_steal(node, key);
 213                 }
 214                 return rv;
 215         }
 216
 217         return reg_open_key(node, node->parent->key, node->name, &node->key);
 218 }
 219
 220 bool tree_node_has_children(struct tree_node *node)
 221 {
 222         if (node->child_head) {
 223                 return true;
 224         }
 225
 226         return get_num_subkeys(node) > 0;
 227 }
 228
 229 static int node_cmp(struct tree_node **a, struct tree_node **b)
 230 {
 231         return strcmp((*a)->name, (*b)->name);
 232 }
 233
 234 void tree_node_insert_sorted(struct tree_node *list, struct tree_node *node)
 235 {
 236         list = tree_node_first(list);
 237
 238         if (node_cmp(&list, &node) >= 0) {
 239                 tree_node_append(node, list);
 240                 if (list->parent) {
 241                         list->parent->child_head = node;
 242                 }
 243                 return;
 244         }
 245
 246         while (list->next && node_cmp(&list->next, &node) < 0) {
 247                 list = list->next;
 248         }
 249
 250         tree_node_append(list, node);
 251 }
 252
 253 WERROR tree_node_load_children(struct tree_node *node)
 254 {
 255         struct registry_key *key;
 256         const char *key_name, *klass;
 257         NTTIME modified;
 258         uint32_t i, nsubkeys, count;
 259         WERROR rv;
 260         struct tree_node *prev, **array;
 261
 262         /* does this node already have it's children loaded? */
 263         if (node->child_head)
 264                 return WERR_OK;
 265
 266         nsubkeys = get_num_subkeys(node);
 267         if (nsubkeys == 0)
 268                 return WERR_OK;
 269
 270         array = talloc_zero_array(node, struct tree_node *, nsubkeys);
 271         if (array == NULL) {
 272                 return WERR_NOMEM;
 273         }
 274
 275         for (count = 0, i = 0; i < nsubkeys; ++i) {
 276                 rv = reg_key_get_subkey_by_index(node, node->key, i,
 277                                                  &key_name, &klass,
 278                                                  &modified);
 279                 if (!W_ERROR_IS_OK(rv)) {
 280                         goto finish;
 281                 }
 282
 283                 rv = reg_open_key(node, node->key, key_name, &key);
 284                 if (!W_ERROR_IS_OK(rv)) {
 285                         continue;
 286                 }
 287
 288                 array[count] = tree_node_new(array, node, key_name, key);
 289                 if (array[count] == NULL) {
 290                         rv = WERR_NOMEM;
 291                         goto finish;
 292                 }
 293                 ++count;
 294         }
 295
 296         if (count) {
 297                 TYPESAFE_QSORT(array, count, node_cmp);
 298
 299                 for (i = 1, prev = array[0]; i < count; ++i) {
 300                         talloc_steal(node, array[i]);
 301                         tree_node_append(prev, array[i]);
 302                         prev = array[i];
 303                 }
 304                 node->child_head = talloc_steal(node, array[0]);
 305
 306                 rv = WERR_OK;
 307         }
 308
 309 finish:
 310         talloc_free(array);
 311
 312         return rv;
 313 }
 314
 315 static WERROR next_depth_first(struct tree_node **node)
 316 {
 317         WERROR rv = WERR_OK;
 318
 319         SMB_ASSERT(node != NULL && *node != NULL);
 320
 321         if (tree_node_has_children(*node)) {
 322                 /* 1. If the node has children, go to the first one. */
 323                 rv = tree_node_load_children(*node);
 324                 if (W_ERROR_IS_OK(rv)) {
 325                         SMB_ASSERT((*node)->child_head != NULL);
 326                         *node = (*node)->child_head;
 327                 }
 328         } else if ((*node)->next) {
 329                 /* 2. If there's a node directly after this one, go there */
 330                 *node = (*node)->next;
 331         } else {
 332                 /* 3. Otherwise, go up the hierarchy to find the next one */
 333                 do {
 334                         *node = (*node)->parent;
 335                         if (*node && (*node)->next) {
 336                                 *node = (*node)->next;
 337                                 break;
 338                         }
 339                 } while (*node);
 340         }
 341
 342         return rv;
 343 }
 344
 345 bool tree_node_next(struct tree_node **node, bool depth, WERROR *err)
 346 {
 347         *err = WERR_OK;
 348
 349         if (*node == NULL) {
 350                 return false;
 351         }
 352
 353         if (depth) {
 354                 *err = next_depth_first(node);
 355         } else {
 356                 *node = (*node)->next;
 357         }
 358
 359         return *node != NULL && W_ERROR_IS_OK(*err);
 360 }
 361
 362 void tree_view_clear(struct tree_view *view)
 363 {
 364         multilist_set_data(view->list, NULL);
 365 }
 366
 367 WERROR tree_view_set_root(struct tree_view *view, struct tree_node *root)
 368 {
 369         multilist_set_data(view->list, NULL);
 370         talloc_free(view->root);
 371         view->root = root;
 372         return tree_view_update(view, root->child_head);
 373 }
 374
 375 WERROR tree_view_set_path(struct tree_view *view, const char **path)
 376 {
 377         struct tree_node *top, *node;
 378         WERROR rv;
 379
 380         top = view->root->child_head;
 381         while (*path) {
 382                 for (node = top; node != NULL; node = node->next) {
 383                         if (strcmp(*path, node->name) == 0) {
 384                                 if (path[1] && tree_node_has_children(node)) {
 385                                         rv = tree_node_load_children(node);
 386                                         if (!W_ERROR_IS_OK(rv)) {
 387                                                 return rv;
 388                                         }
 389                                         SMB_ASSERT(node->child_head);
 390                                         top = node->child_head;
 391                                         break;
 392                                 } else {
 393                                         tree_view_update(view, top);
 394                                         tree_view_set_current_node(view, node);
 395                                         return WERR_OK;
 396                                 }
 397                         }
 398                 }
 399                 ++path;
 400         }
 401
 402         return WERR_OK;
 403 }
 404
 405 WERROR tree_view_update(struct tree_view *view, struct tree_node *list)
 406 {
 407         WERROR rv;
 408
 409         rv = multilist_set_data(view->list, list);
 410         if (W_ERROR_IS_OK(rv)) {
 411                 multilist_refresh(view->list);
 412         }
 413
 414         return rv;
 415 }
 416
 417 /* is this node in the current level? */
 418 bool tree_view_is_node_visible(struct tree_view *view, struct tree_node *node)
 419 {
 420         const struct tree_node *first;
 421
 422         first = multilist_get_data(view->list);
 423
 424         return first && first->parent == node->parent;
 425 }
 426
 427 void tree_view_set_current_node(struct tree_view *view, struct tree_node *node)
 428 {
 429         multilist_set_current_row(view->list, node);
 430 }
 431
 432 struct tree_node *tree_view_get_current_node(struct tree_view *view)
 433 {
 434         const void *row = multilist_get_current_row(view->list);
 435         return talloc_get_type_abort(row, struct tree_node);
 436 }
 437
 438 void tree_view_driver(struct tree_view *view, int c)
 439 {
 440         multilist_driver(view->list, c);
 441 }
 442
 443 void tree_view_set_selected(struct tree_view *view, bool select)
 444 {
 445         attr_t attr = A_NORMAL;
 446
 447         if (select) {
 448                 attr = A_REVERSE;
 449         }
 450         mvwchgat(view->window, 0, HEADING_X, 3, attr, 0, NULL);
 451 }
 452
 453 void tree_view_show(struct tree_view *view)
 454 {
 455         multilist_refresh(view->list);
 456         touchwin(view->window);
 457         wnoutrefresh(view->window);
 458         wnoutrefresh(view->sub);
 459 }
 460
 461 static int tree_view_free(struct tree_view *view)
 462 {
 463         if (view->panel) {
 464                 del_panel(view->panel);
 465         }
 466         if (view->sub) {
 467                 delwin(view->sub);
 468         }
 469         if (view->window) {
 470                 delwin(view->window);
 471         }
 472
 473         return 0;
 474 }
 475
 476 static const char *tv_get_column_header(const void *data, unsigned col)
 477 {
 478         SMB_ASSERT(col == 0);
 479         return "Name";
 480 }
 481
 482 static const void *tv_get_first_row(const void *data)
 483 {
 484         if (data == NULL) {
 485                 return NULL;
 486         }
 487
 488         return talloc_get_type_abort(data, struct tree_node);
 489 }
 490
 491 static const void *tv_get_next_row(const void *data, const void *row)
 492 {
 493         const struct tree_node *node;
 494         SMB_ASSERT(row != NULL);
 495         node = talloc_get_type_abort(row, struct tree_node);
 496         return node->next;
 497 }
 498
 499 static const void *tv_get_prev_row(const void *data, const void *row)
 500 {
 501         const struct tree_node *node;
 502         SMB_ASSERT(row != NULL);
 503         node = talloc_get_type_abort(row, struct tree_node);
 504         return node->previous;
 505 }
 506
 507 static const char *tv_get_item_prefix(const void *row, unsigned col)
 508 {
 509         struct tree_node *node;
 510
 511         SMB_ASSERT(col == 0);
 512         SMB_ASSERT(row != NULL);
 513         node = talloc_get_type_abort(row, struct tree_node);
 514         if (tree_node_has_children(node)) {
 515                 return "+";
 516         }
 517         return " ";
 518 }
 519
 520 static const char *tv_get_item_label(const void *row, unsigned col)
 521 {
 522         const struct tree_node *node;
 523         SMB_ASSERT(col == 0);
 524         SMB_ASSERT(row != NULL);
 525         node = talloc_get_type_abort(row, struct tree_node);
 526         return node->name;
 527 }
 528
 529 static struct multilist_accessors tv_accessors = {
 530         .get_column_header = tv_get_column_header,
 531         .get_first_row = tv_get_first_row,
 532         .get_next_row = tv_get_next_row,
 533         .get_prev_row = tv_get_prev_row,
 534         .get_item_prefix = tv_get_item_prefix,
 535         .get_item_label = tv_get_item_label
 536 };
 537
 538 struct tree_view *tree_view_new(TALLOC_CTX *ctx, struct tree_node *root,
 539                                 int nlines, int ncols, int begin_y,
 540                                 int begin_x)
 541 {
 542         struct tree_view *view;
 543
 544         view = talloc_zero(ctx, struct tree_view);
 545         if (view == NULL) {
 546                 return NULL;
 547         }
 548
 549         talloc_set_destructor(view, tree_view_free);
 550
 551         view->window = newwin(nlines, ncols, begin_y, begin_x);
 552         if (view->window == NULL) {
 553                 goto fail;
 554         }
 555         view->sub = subwin(view->window, nlines - 2, ncols - 2,
 556                            begin_y + 1, begin_x + 1);
 557         if (view->sub == NULL) {
 558                 goto fail;
 559         }
 560         box(view->window, 0, 0);
 561         mvwprintw(view->window, 0, HEADING_X, "Key");
 562
 563         view->panel = new_panel(view->window);
 564         if (view->panel == NULL) {
 565                 goto fail;
 566         }
 567         view->root = root;
 568
 569         view->list = multilist_new(view, view->sub, &tv_accessors, 1);
 570         if (view->list == NULL) {
 571                 goto fail;
 572         }
 573         tree_view_update(view, root->child_head);
 574
 575         return view;
 576
 577 fail:
 578         talloc_free(view);
 579
 580         return NULL;
 581 }
 582
 583 void tree_view_resize(struct tree_view *view, int nlines, int ncols,
 584                       int begin_y, int begin_x)
 585 {
 586         WINDOW *nwin, *nsub;
 587
 588         nwin = newwin(nlines, ncols, begin_y, begin_x);
 589         if (nwin == NULL) {
 590                 return;
 591         }
 592         nsub = subwin(nwin, nlines - 2, ncols - 2, begin_y + 1, begin_x + 1);
 593         if (nsub == NULL) {
 594                 delwin(nwin);
 595                 return;
 596         }
 597         replace_panel(view->panel, nwin);
 598         delwin(view->sub);
 599         delwin(view->window);
 600         view->window = nwin;
 601         view->sub = nsub;
 602         box(view->window, 0, 0);
 603         mvwprintw(view->window, 0, HEADING_X, "Key");
 604         multilist_set_window(view->list, view->sub);
 605         tree_view_show(view);
 606 }
 607
 608 const char **tree_node_get_path(TALLOC_CTX *ctx, struct tree_node *node)
 609 {
 610         const char **array;
 611         size_t nitems, index;
 612         struct tree_node *p;
 613
 614         for (nitems = 0, p = node; !tree_node_is_root(p); p = p->parent) {
 615                 ++nitems;
 616         }
 617
 618         array = talloc_zero_array(ctx, const char *, nitems + 1);
 619         if (array == NULL) {
 620                 return NULL;
 621         }
 622
 623         for (index = nitems - 1, p = node;
 624              !tree_node_is_root(p);
 625              p = p->parent, --index) {
 626                 array[index] = talloc_strdup(array, p->name);
 627                 if (array[index] == NULL) {
 628                         talloc_free(discard_const(array));
 629                         return NULL;
 630                 }
 631         }
 632
 633         return array;
 634 }
 635
 636 /* print the path of node to label */
 637 size_t tree_node_print_path(WINDOW *label, struct tree_node *node)
 638 {
 639         size_t len = 1;
 640         const char **path;
 641         TALLOC_CTX *frame;
 642
 643         if (node == NULL)
 644                 return 0;
 645
 646         werase(label);
 647         wprintw(label, "/");
 648
 649         if (tree_node_is_top_level(node))
 650                 return 0;
 651
 652         frame = talloc_stackframe();
 653         path = tree_node_get_path(frame, node->parent);
 654
 655         while (*path) {
 656                 len += strlen(*path) + 1;
 657                 wprintw(label, "%s/", *path);
 658                 ++path;
 659         }
 660
 661         talloc_free(frame);
 662
 663         return len;
 664 }