source3/utils/regedit_valuelist.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_valuelist.h"
  21 #include "lib/registry/registry.h"
  22
  23 static void value_list_free_items(ITEM **items)
  24 {
  25         size_t i;
  26         ITEM *item;
  27         struct value_item *vitem;
  28
  29         if (items == NULL) {
  30                 return;
  31         }
  32
  33         for (i = 0; items[i] != NULL; ++i) {
  34                 item = items[i];
  35                 vitem = item_userptr(item);
  36                 SMB_ASSERT(vitem != NULL);
  37                 free_item(item);
  38         }
  39
  40         talloc_free(items);
  41 }
  42
  43 static int value_list_free(struct value_list *vl)
  44 {
  45         if (vl->menu) {
  46                 unpost_menu(vl->menu);
  47                 free_menu(vl->menu);
  48         }
  49         if (vl->empty && vl->empty[0]) {
  50                 free_item(vl->empty[0]);
  51         }
  52         if (vl->panel) {
  53                 del_panel(vl->panel);
  54         }
  55         if (vl->window) {
  56                 delwin(vl->window);
  57         }
  58         value_list_free_items(vl->items);
  59
  60         return 0;
  61 }
  62
  63 struct value_list *value_list_new(TALLOC_CTX *ctx, int nlines, int ncols,
  64                                   int begin_y, int begin_x)
  65 {
  66         static const char *empty = "(no values)";
  67         static const char *empty_desc = "";
  68         struct value_list *vl;
  69
  70         vl = talloc_zero(ctx, struct value_list);
  71         if (vl == NULL) {
  72                 return NULL;
  73         }
  74
  75         talloc_set_destructor(vl, value_list_free);
  76
  77         vl->empty = talloc_zero_array(vl, ITEM *, 2);
  78         if (vl->empty == NULL) {
  79                 goto fail;
  80         }
  81         vl->empty[0] = new_item(empty, empty_desc);
  82         if (vl->empty[0] == NULL) {
  83                 goto fail;
  84         }
  85
  86         vl->window = newwin(nlines, ncols, begin_y, begin_x);
  87         if (vl->window == NULL) {
  88                 goto fail;
  89         }
  90         vl->panel = new_panel(vl->window);
  91         if (vl->panel == NULL) {
  92                 goto fail;
  93         }
  94
  95         vl->menu = new_menu(vl->empty);
  96         if (vl->menu == NULL) {
  97                 goto fail;
  98         }
  99
 100         set_menu_format(vl->menu, nlines, 1);
 101         set_menu_win(vl->menu, vl->window);
 102
 103         menu_opts_on(vl->menu, O_SHOWDESC);
 104         set_menu_mark(vl->menu, "* ");
 105
 106         return vl;
 107
 108 fail:
 109         talloc_free(vl);
 110
 111         return NULL;
 112 }
 113
 114 void value_list_resize(struct value_list *vl, int nlines, int ncols,
 115                        int begin_y, int begin_x)
 116 {
 117         WINDOW *nwin;
 118
 119         unpost_menu(vl->menu);
 120         nwin = newwin(nlines, ncols, begin_y, begin_x);
 121         replace_panel(vl->panel, nwin);
 122         delwin(vl->window);
 123         vl->window = nwin;
 124         set_menu_format(vl->menu, nlines, 1);
 125         set_menu_win(vl->menu, vl->window);
 126         post_menu(vl->menu);
 127 }
 128
 129 static uint32_t get_num_values(TALLOC_CTX *ctx, const struct registry_key *key)
 130 {
 131         const char *classname;
 132         uint32_t num_subkeys;
 133         uint32_t num_values;
 134         NTTIME last_change_time;
 135         uint32_t max_subkeynamelen;
 136         uint32_t max_valnamelen;
 137         uint32_t max_valbufsize;
 138         WERROR rv;
 139
 140         rv = reg_key_get_info(ctx, key, &classname, &num_subkeys,
 141                               &num_values, &last_change_time,
 142                               &max_subkeynamelen, &max_valnamelen,
 143                               &max_valbufsize);
 144
 145         if (W_ERROR_IS_OK(rv)) {
 146                 return num_values;
 147         }
 148
 149         return 0;
 150 }
 151
 152 void value_list_show(struct value_list *vl)
 153 {
 154         post_menu(vl->menu);
 155 }
 156
 157 static WERROR append_data_summary(struct value_item *vitem)
 158 {
 159         char *tmp;
 160
 161 /* This is adapted from print_registry_value() in net_registry_util.c */
 162
 163         switch(vitem->type) {
 164         case REG_DWORD: {
 165                 uint32_t v = 0;
 166                 if (vitem->data.length >= 4) {
 167                         v = IVAL(vitem->data.data, 0);
 168                 }
 169                 tmp = talloc_asprintf_append(vitem->value_desc, "(0x%x)", v);
 170                 break;
 171         }
 172         case REG_SZ:
 173         case REG_EXPAND_SZ: {
 174                 const char *s;
 175
 176                 if (!pull_reg_sz(vitem, &vitem->data, &s)) {
 177                         break;
 178                 }
 179                 tmp = talloc_asprintf_append(vitem->value_desc, "(\"%s\")", s);
 180                 break;
 181         }
 182         case REG_MULTI_SZ: {
 183                 size_t i;
 184                 const char **a;
 185
 186                 if (!pull_reg_multi_sz(vitem, &vitem->data, &a)) {
 187                         break;
 188                 }
 189                 tmp = vitem->value_desc;
 190                 for (i = 0; a[i] != NULL; ++i) {
 191                         tmp = talloc_asprintf_append(tmp, "\"%s\" ", a[i]);
 192                         if (tmp == NULL) {
 193                                 return WERR_NOMEM;
 194                         }
 195                 }
 196                 break;
 197         }
 198         case REG_BINARY:
 199                 tmp = talloc_asprintf_append(vitem->value_desc, "(%d bytes)",
 200                                              (int)vitem->data.length);
 201                 break;
 202         default:
 203                 tmp = talloc_asprintf_append(vitem->value_desc,
 204                                              "(<unprintable>)");
 205                 break;
 206         }
 207
 208         if (tmp == NULL) {
 209                 return WERR_NOMEM;
 210         }
 211
 212         vitem->value_desc = tmp;
 213
 214         return WERR_OK;
 215 }
 216
 217 WERROR value_list_load(struct value_list *vl, struct registry_key *key)
 218 {
 219         uint32_t n_values;
 220         uint32_t idx;
 221         struct value_item *vitem;
 222         ITEM **new_items;
 223         WERROR rv;
 224         static const char *empty_name = "(empty)";
 225         const char *name;
 226
 227         unpost_menu(vl->menu);
 228
 229         n_values = get_num_values(vl, key);
 230         if (n_values == 0) {
 231                 set_menu_items(vl->menu, vl->empty);
 232                 return WERR_OK;
 233         }
 234
 235         new_items = talloc_zero_array(vl, ITEM *, n_values + 1);
 236         if (new_items == NULL) {
 237                 return WERR_NOMEM;
 238         }
 239
 240         for (idx = 0; idx < n_values; ++idx) {
 241                 vitem = talloc_zero(new_items, struct value_item);
 242                 if (vitem == NULL) {
 243                         return WERR_NOMEM;
 244                 }
 245
 246                 rv = reg_key_get_value_by_index(vitem, key, idx,
 247                                                 &vitem->value_name,
 248                                                 &vitem->type,
 249                                                 &vitem->data);
 250
 251                 if (!W_ERROR_IS_OK(rv)) {
 252                         talloc_free(vitem);
 253                         return rv;
 254                 }
 255
 256                 vitem->value_desc = talloc_asprintf(vitem, "%-14s",
 257                         str_regtype(vitem->type));
 258                 if (vitem->value_desc == NULL) {
 259                         talloc_free(vitem);
 260                         return rv;
 261                 }
 262
 263                 rv = append_data_summary(vitem);
 264                 if (!W_ERROR_IS_OK(rv)) {
 265                         talloc_free(vitem);
 266                         return rv;
 267                 }
 268
 269                 /* ncurses won't accept empty strings in menu items */
 270                 name = vitem->value_name;
 271                 if (name[0] == '\0') {
 272                         name = empty_name;
 273                 }
 274                 new_items[idx] = new_item(name, vitem->value_desc);
 275                 if (new_items[idx] == NULL) {
 276                         talloc_free(vitem);
 277                         return WERR_NOMEM;
 278                 }
 279
 280                 set_item_userptr(new_items[idx], vitem);
 281         }
 282
 283         set_menu_items(vl->menu, new_items);
 284         value_list_free_items(vl->items);
 285         vl->items = new_items;
 286
 287         return WERR_OK;
 288 }