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 tree_node *node)
 201 {
 202         SMB_ASSERT(node->parent != NULL);
 203         SMB_ASSERT(node->name != NULL);
 204         TALLOC_FREE(node->key);
 205         return reg_open_key(node->parent, node->parent->key, node->name,
 206                             &node->key);
 207 }
 208
 209 bool tree_node_has_children(struct tree_node *node)
 210 {
 211         if (node->child_head) {
 212                 return true;
 213         }
 214
 215         return get_num_subkeys(node) > 0;
 216 }
 217
 218 static int node_cmp(struct tree_node **a, struct tree_node **b)
 219 {
 220         return strcmp((*a)->name, (*b)->name);
 221 }
 222
 223 void tree_node_insert_sorted(struct tree_node *list, struct tree_node *node)
 224 {
 225         list = tree_node_first(list);
 226
 227         if (node_cmp(&list, &node) >= 0) {
 228                 tree_node_append(node, list);
 229                 if (list->parent) {
 230                         list->parent->child_head = node;
 231                 }
 232                 return;
 233         }
 234
 235         while (list->next && node_cmp(&list->next, &node) < 0) {
 236                 list = list->next;
 237         }
 238
 239         tree_node_append(list, node);
 240 }
 241
 242 WERROR tree_node_load_children(struct tree_node *node)
 243 {
 244         struct registry_key *key;
 245         const char *key_name, *klass;
 246         NTTIME modified;
 247         uint32_t i, nsubkeys, count;
 248         WERROR rv;
 249         struct tree_node *prev, **array;
 250
 251         /* does this node already have it's children loaded? */
 252         if (node->child_head)
 253                 return WERR_OK;
 254
 255         nsubkeys = get_num_subkeys(node);
 256         if (nsubkeys == 0)
 257                 return WERR_OK;
 258
 259         array = talloc_zero_array(node, struct tree_node *, nsubkeys);
 260         if (array == NULL) {
 261                 return WERR_NOMEM;
 262         }
 263
 264         for (count = 0, i = 0; i < nsubkeys; ++i) {
 265                 rv = reg_key_get_subkey_by_index(node, node->key, i,
 266                                                  &key_name, &klass,
 267                                                  &modified);
 268                 if (!W_ERROR_IS_OK(rv)) {
 269                         goto finish;
 270                 }
 271
 272                 rv = reg_open_key(node, node->key, key_name, &key);
 273                 if (!W_ERROR_IS_OK(rv)) {
 274                         continue;
 275                 }
 276
 277                 array[count] = tree_node_new(array, node, key_name, key);
 278                 if (array[count] == NULL) {
 279                         rv = WERR_NOMEM;
 280                         goto finish;
 281                 }
 282                 ++count;
 283         }
 284
 285         if (count) {
 286                 TYPESAFE_QSORT(array, count, node_cmp);
 287
 288                 for (i = 1, prev = array[0]; i < count; ++i) {
 289                         talloc_steal(node, array[i]);
 290                         tree_node_append(prev, array[i]);
 291                         prev = array[i];
 292                 }
 293                 node->child_head = talloc_steal(node, array[0]);
 294
 295                 rv = WERR_OK;
 296         }
 297
 298 finish:
 299         talloc_free(array);
 300
 301         return rv;
 302 }
 303
 304 void tree_view_clear(struct tree_view *view)
 305 {
 306         multilist_set_data(view->list, NULL);
 307 }
 308
 309 WERROR tree_view_set_root(struct tree_view *view, struct tree_node *root)
 310 {
 311         multilist_set_data(view->list, NULL);
 312         talloc_free(view->root);
 313         view->root = root;
 314         return tree_view_update(view, root->child_head);
 315 }
 316
 317 WERROR tree_view_set_path(struct tree_view *view, const char **path)
 318 {
 319         struct tree_node *top, *node;
 320         WERROR rv;
 321
 322         top = view->root->child_head;
 323         while (*path) {
 324                 for (node = top; node != NULL; node = node->next) {
 325                         if (strcmp(*path, node->name) == 0) {
 326                                 if (path[1] && tree_node_has_children(node)) {
 327                                         rv = tree_node_load_children(node);
 328                                         if (!W_ERROR_IS_OK(rv)) {
 329                                                 return rv;
 330                                         }
 331                                         SMB_ASSERT(node->child_head);
 332                                         top = node->child_head;
 333                                         break;
 334                                 } else {
 335                                         tree_view_update(view, top);
 336                                         tree_view_set_current_node(view, node);
 337                                         return WERR_OK;
 338                                 }
 339                         }
 340                 }
 341                 ++path;
 342         }
 343
 344         return WERR_OK;
 345 }
 346
 347 WERROR tree_view_update(struct tree_view *view, struct tree_node *list)
 348 {
 349         WERROR rv;
 350
 351         rv = multilist_set_data(view->list, list);
 352         if (W_ERROR_IS_OK(rv)) {
 353                 multilist_refresh(view->list);
 354         }
 355
 356         return rv;
 357 }
 358
 359 /* is this node in the current level? */
 360 bool tree_view_is_node_visible(struct tree_view *view, struct tree_node *node)
 361 {
 362         const struct tree_node *first;
 363
 364         first = multilist_get_data(view->list);
 365
 366         return first && first->parent == node->parent;
 367 }
 368
 369 void tree_view_set_current_node(struct tree_view *view, struct tree_node *node)
 370 {
 371         multilist_set_current_row(view->list, node);
 372 }
 373
 374 struct tree_node *tree_view_get_current_node(struct tree_view *view)
 375 {
 376         const void *row = multilist_get_current_row(view->list);
 377         return talloc_get_type_abort(row, struct tree_node);
 378 }
 379
 380 void tree_view_driver(struct tree_view *view, int c)
 381 {
 382         multilist_driver(view->list, c);
 383 }
 384
 385 void tree_view_set_selected(struct tree_view *view, bool select)
 386 {
 387         attr_t attr = A_NORMAL;
 388
 389         if (select) {
 390                 attr = A_REVERSE;
 391         }
 392         mvwchgat(view->window, 0, HEADING_X, 3, attr, 0, NULL);
 393 }
 394
 395 void tree_view_show(struct tree_view *view)
 396 {
 397         multilist_refresh(view->list);
 398         touchwin(view->window);
 399         wnoutrefresh(view->window);
 400         wnoutrefresh(view->sub);
 401 }
 402
 403 static int tree_view_free(struct tree_view *view)
 404 {
 405         if (view->panel) {
 406                 del_panel(view->panel);
 407         }
 408         if (view->sub) {
 409                 delwin(view->sub);
 410         }
 411         if (view->window) {
 412                 delwin(view->window);
 413         }
 414
 415         return 0;
 416 }
 417
 418 static const char *tv_get_column_header(const void *data, unsigned col)
 419 {
 420         SMB_ASSERT(col == 0);
 421         return "Name";
 422 }
 423
 424 static const void *tv_get_first_row(const void *data)
 425 {
 426         if (data == NULL) {
 427                 return NULL;
 428         }
 429
 430         return talloc_get_type_abort(data, struct tree_node);
 431 }
 432
 433 static const void *tv_get_next_row(const void *data, const void *row)
 434 {
 435         const struct tree_node *node;
 436         SMB_ASSERT(row != NULL);
 437         node = talloc_get_type_abort(row, struct tree_node);
 438         return node->next;
 439 }
 440
 441 static const void *tv_get_prev_row(const void *data, const void *row)
 442 {
 443         const struct tree_node *node;
 444         SMB_ASSERT(row != NULL);
 445         node = talloc_get_type_abort(row, struct tree_node);
 446         return node->previous;
 447 }
 448
 449 static const char *tv_get_item_prefix(const void *row, unsigned col)
 450 {
 451         struct tree_node *node;
 452
 453         SMB_ASSERT(col == 0);
 454         SMB_ASSERT(row != NULL);
 455         node = talloc_get_type_abort(row, struct tree_node);
 456         if (tree_node_has_children(node)) {
 457                 return "+";
 458         }
 459         return " ";
 460 }
 461
 462 static const char *tv_get_item_label(const void *row, unsigned col)
 463 {
 464         const struct tree_node *node;
 465         SMB_ASSERT(col == 0);
 466         SMB_ASSERT(row != NULL);
 467         node = talloc_get_type_abort(row, struct tree_node);
 468         return node->name;
 469 }
 470
 471 static struct multilist_accessors tv_accessors = {
 472         .get_column_header = tv_get_column_header,
 473         .get_first_row = tv_get_first_row,
 474         .get_next_row = tv_get_next_row,
 475         .get_prev_row = tv_get_prev_row,
 476         .get_item_prefix = tv_get_item_prefix,
 477         .get_item_label = tv_get_item_label
 478 };
 479
 480 struct tree_view *tree_view_new(TALLOC_CTX *ctx, struct tree_node *root,
 481                                 int nlines, int ncols, int begin_y,
 482                                 int begin_x)
 483 {
 484         struct tree_view *view;
 485
 486         view = talloc_zero(ctx, struct tree_view);
 487         if (view == NULL) {
 488                 return NULL;
 489         }
 490
 491         talloc_set_destructor(view, tree_view_free);
 492
 493         view->window = newwin(nlines, ncols, begin_y, begin_x);
 494         if (view->window == NULL) {
 495                 goto fail;
 496         }
 497         view->sub = subwin(view->window, nlines - 2, ncols - 2,
 498                            begin_y + 1, begin_x + 1);
 499         if (view->sub == NULL) {
 500                 goto fail;
 501         }
 502         box(view->window, 0, 0);
 503         mvwprintw(view->window, 0, HEADING_X, "Key");
 504
 505         view->panel = new_panel(view->window);
 506         if (view->panel == NULL) {
 507                 goto fail;
 508         }
 509         view->root = root;
 510
 511         view->list = multilist_new(view, view->sub, &tv_accessors, 1);
 512         if (view->list == NULL) {
 513                 goto fail;
 514         }
 515         tree_view_update(view, root->child_head);
 516
 517         return view;
 518
 519 fail:
 520         talloc_free(view);
 521
 522         return NULL;
 523 }
 524
 525 void tree_view_resize(struct tree_view *view, int nlines, int ncols,
 526                       int begin_y, int begin_x)
 527 {
 528         WINDOW *nwin, *nsub;
 529
 530         nwin = newwin(nlines, ncols, begin_y, begin_x);
 531         if (nwin == NULL) {
 532                 return;
 533         }
 534         nsub = subwin(nwin, nlines - 2, ncols - 2, begin_y + 1, begin_x + 1);
 535         if (nsub == NULL) {
 536                 delwin(nwin);
 537                 return;
 538         }
 539         replace_panel(view->panel, nwin);
 540         delwin(view->sub);
 541         delwin(view->window);
 542         view->window = nwin;
 543         view->sub = nsub;
 544         box(view->window, 0, 0);
 545         mvwprintw(view->window, 0, HEADING_X, "Key");
 546         multilist_set_window(view->list, view->sub);
 547         tree_view_show(view);
 548 }
 549
 550 const char **tree_node_get_path(TALLOC_CTX *ctx, struct tree_node *node)
 551 {
 552         const char **array;
 553         size_t nitems, index;
 554         struct tree_node *p;
 555
 556         for (nitems = 0, p = node; !tree_node_is_root(p); p = p->parent) {
 557                 ++nitems;
 558         }
 559
 560         array = talloc_zero_array(ctx, const char *, nitems + 1);
 561         if (array == NULL) {
 562                 return NULL;
 563         }
 564
 565         for (index = nitems - 1, p = node;
 566              !tree_node_is_root(p);
 567              p = p->parent, --index) {
 568                 array[index] = talloc_strdup(array, p->name);
 569                 if (array[index] == NULL) {
 570                         talloc_free(discard_const(array));
 571                         return NULL;
 572                 }
 573         }
 574
 575         return array;
 576 }
 577
 578 /* print the path of node to label */
 579 size_t tree_node_print_path(WINDOW *label, struct tree_node *node)
 580 {
 581         size_t len = 1;
 582         const char **path;
 583         TALLOC_CTX *frame;
 584
 585         if (node == NULL)
 586                 return 0;
 587
 588         werase(label);
 589         wprintw(label, "/");
 590
 591         if (tree_node_is_top_level(node))
 592                 return 0;
 593
 594         frame = talloc_stackframe();
 595         path = tree_node_get_path(frame, node->parent);
 596
 597         while (*path) {
 598                 len += strlen(*path) + 1;
 599                 wprintw(label, "%s/", *path);
 600                 ++path;
 601         }
 602
 603         talloc_free(frame);
 604
 605         return len;
 606 }