source3/utils/regedit_dialog.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 "regedit.h"
  22 #include "regedit_dialog.h"
  23 #include "regedit_valuelist.h"
  24 #include "regedit_hexedit.h"
  25 #include "util_reg.h"
  26 #include "lib/registry/registry.h"
  27 #include <stdarg.h>
  28 #include <form.h>
  29
  30 static char *string_trim_n(TALLOC_CTX *ctx, const char *buf, size_t n)
  31 {
  32         char *str;
  33
  34         str = talloc_strndup(ctx, buf, n);
  35
  36         if (str) {
  37                 trim_string(str, " ", " ");
  38         }
  39
  40         return str;
  41 }
  42
  43 static char *string_trim(TALLOC_CTX *ctx, const char *buf)
  44 {
  45         char *str;
  46
  47         str = talloc_strdup(ctx, buf);
  48
  49         if (str) {
  50                 trim_string(str, " ", " ");
  51         }
  52
  53         return str;
  54 }
  55
  56 static int dialog_free(struct dialog *dia)
  57 {
  58         if (dia->window) {
  59                 delwin(dia->window);
  60         }
  61         if (dia->sub_window) {
  62                 delwin(dia->sub_window);
  63         }
  64         if (dia->panel) {
  65                 del_panel(dia->panel);
  66         }
  67         if (dia->choices) {
  68                 unpost_menu(dia->choices);
  69                 free_menu(dia->choices);
  70         }
  71         if (dia->choice_items) {
  72                 ITEM **it;
  73                 for (it = dia->choice_items; *it != NULL; ++it) {
  74                         free_item(*it);
  75                 }
  76         }
  77
  78         return 0;
  79 }
  80
  81 struct dialog *dialog_new(TALLOC_CTX *ctx, const char *title, int nlines,
  82                           int ncols, int y, int x)
  83 {
  84         struct dialog *dia;
  85
  86         dia = talloc_zero(ctx, struct dialog);
  87         if (dia == NULL) {
  88                 return NULL;
  89         }
  90
  91         talloc_set_destructor(dia, dialog_free);
  92
  93         dia->window = newwin(nlines, ncols, y, x);
  94         if (dia->window == NULL) {
  95                 goto fail;
  96         }
  97
  98         box(dia->window, 0, 0);
  99         mvwaddstr(dia->window, 0, 1, title);
 100
 101         /* body of the dialog within the box outline */
 102         dia->sub_window = derwin(dia->window, nlines - 2, ncols - 2, 1, 1);
 103         if (dia->sub_window == NULL) {
 104                 goto fail;
 105         }
 106
 107         dia->panel = new_panel(dia->window);
 108         if (dia->panel == NULL) {
 109                 goto fail;
 110         }
 111
 112         return dia;
 113
 114 fail:
 115         talloc_free(dia);
 116
 117         return NULL;
 118
 119 }
 120
 121 static void center_dialog_above_window(int *nlines, int *ncols,
 122                                        int *y, int *x)
 123 {
 124         int centery, centerx;
 125
 126         centery = LINES / 2;
 127         centerx = COLS / 2;
 128         *y = 0;
 129         *x = 0;
 130
 131         if (*nlines > LINES) {
 132                 *nlines = LINES;
 133         }
 134         if (*ncols > COLS) {
 135                 *ncols = COLS;
 136         }
 137
 138         if (*nlines/2 < centery) {
 139                 *y = centery - *nlines / 2;
 140         }
 141         if (*ncols/2 < centerx) {
 142                 *x = centerx - *ncols / 2;
 143         }
 144 }
 145
 146 static int dialog_getch(struct dialog *dia)
 147 {
 148         int c;
 149
 150         c = regedit_getch();
 151
 152         if (c == KEY_RESIZE) {
 153                 int nlines, ncols, y, x;
 154
 155                 getmaxyx(dia->window, nlines, ncols);
 156                 getbegyx(dia->window, y, x);
 157                 if (dia->centered) {
 158                         center_dialog_above_window(&nlines, &ncols, &y, &x);
 159                 } else {
 160                         if (nlines + y > LINES) {
 161                                 if (nlines > LINES) {
 162                                         y = 0;
 163                                 } else {
 164                                         y = LINES - nlines;
 165                                 }
 166                         }
 167                         if (ncols + x > COLS) {
 168                                 if (ncols > COLS) {
 169                                         x = 0;
 170                                 } else {
 171                                         x = COLS - ncols;
 172                                 }
 173                         }
 174                 }
 175                 move_panel(dia->panel, y, x);
 176                 doupdate();
 177         }
 178
 179         return c;
 180 }
 181
 182 struct dialog *dialog_center_new(TALLOC_CTX *ctx, const char *title, int nlines,
 183                                  int ncols)
 184 {
 185         struct dialog *dia;
 186         int y, x;
 187
 188         center_dialog_above_window(&nlines, &ncols, &y, &x);
 189
 190         dia = dialog_new(ctx, title, nlines, ncols, y, x);
 191         if (dia) {
 192                 dia->centered = true;
 193         }
 194
 195         return dia;
 196 }
 197
 198 struct dialog *dialog_choice_new(TALLOC_CTX *ctx, const char *title,
 199                                  const char **choices, int nlines,
 200                                  int ncols, int y, int x)
 201 {
 202         size_t nchoices, i;
 203         struct dialog *dia;
 204
 205         dia = dialog_new(ctx, title, nlines, ncols, y, x);
 206         if (dia == NULL) {
 207                 return NULL;
 208         }
 209
 210         dia->menu_window = derwin(dia->sub_window, 1, ncols - 3,
 211                                   nlines - 3, 0);
 212         if (dia->menu_window == NULL) {
 213                 goto fail;
 214         }
 215
 216         for (nchoices = 0; choices[nchoices] != NULL; ++nchoices)
 217                 ;
 218         dia->choice_items = talloc_zero_array(dia, ITEM *, nchoices + 1);
 219         if (dia->choice_items == NULL) {
 220                 goto fail;
 221         }
 222         for (i = 0; i < nchoices; ++i) {
 223                 char *desc = talloc_strdup(dia, choices[i]);
 224                 if (desc == NULL) {
 225                         goto fail;
 226                 }
 227                 dia->choice_items[i] = new_item(desc, desc);
 228                 if (dia->choice_items[i] == NULL) {
 229                         goto fail;
 230                 }
 231                 /* store choice index */
 232                 set_item_userptr(dia->choice_items[i], (void*)(uintptr_t)i);
 233         }
 234
 235         dia->choices = new_menu(dia->choice_items);
 236         if (dia->choices == NULL) {
 237                 goto fail;
 238         }
 239
 240         set_menu_format(dia->choices, 1, ncols);
 241         set_menu_win(dia->choices, dia->sub_window);
 242         set_menu_sub(dia->choices, dia->menu_window);
 243         menu_opts_off(dia->choices, O_SHOWDESC);
 244         set_menu_mark(dia->choices, "* ");
 245         post_menu(dia->choices);
 246         wmove(dia->sub_window, 0, 0);
 247
 248         return dia;
 249
 250 fail:
 251         talloc_free(dia);
 252
 253         return NULL;
 254 }
 255
 256 struct dialog *dialog_choice_center_new(TALLOC_CTX *ctx, const char *title,
 257                                         const char **choices, int nlines,
 258                                         int ncols)
 259 {
 260         int y, x;
 261         struct dialog *dia;
 262         center_dialog_above_window(&nlines, &ncols, &y, &x);
 263
 264         dia = dialog_choice_new(ctx, title, choices, nlines, ncols, y, x);
 265         if (dia) {
 266                 dia->centered = true;
 267         }
 268
 269         return dia;
 270 }
 271
 272 static int handle_menu_input(MENU *menu, int c)
 273 {
 274         ITEM *item;
 275
 276         switch (c) {
 277         case KEY_LEFT:
 278                 menu_driver(menu, REQ_LEFT_ITEM);
 279                 break;
 280         case KEY_RIGHT:
 281                 menu_driver(menu, REQ_RIGHT_ITEM);
 282                 break;
 283         case KEY_ENTER:
 284         case '\n':
 285                 item = current_item(menu);
 286                 return (int)(uintptr_t)item_userptr(item);
 287         }
 288
 289         return -1;
 290 }
 291
 292 static void handle_form_input(FORM *frm, int c)
 293 {
 294         switch (c) {
 295         case '\n':
 296                 form_driver(frm, REQ_NEW_LINE);
 297                 break;
 298         case KEY_UP:
 299                 form_driver(frm, REQ_UP_CHAR);
 300                 break;
 301         case KEY_DOWN:
 302                 form_driver(frm, REQ_DOWN_CHAR);
 303                 break;
 304         case '\b':
 305         case KEY_BACKSPACE:
 306                 form_driver(frm, REQ_DEL_PREV);
 307                 break;
 308         case KEY_LEFT:
 309                 form_driver(frm, REQ_LEFT_CHAR);
 310                 break;
 311         case KEY_RIGHT:
 312                 form_driver(frm, REQ_RIGHT_CHAR);
 313                 break;
 314         default:
 315                 form_driver(frm, c);
 316                 break;
 317         }
 318 }
 319
 320 static int modal_loop(struct dialog *dia)
 321 {
 322         int c;
 323         int selection = -1;
 324
 325         update_panels();
 326         doupdate();
 327
 328         while (selection == -1) {
 329                 c = dialog_getch(dia);
 330                 selection = handle_menu_input(dia->choices, c);
 331                 update_panels();
 332                 doupdate();
 333         }
 334
 335         talloc_free(dia);
 336
 337         return selection;
 338 }
 339
 340 static struct dialog *dialog_msg_new(TALLOC_CTX *ctx, const char *title,
 341                                      const char **choices, int nlines,
 342                                      const char *msg, va_list ap)
 343 {
 344         struct dialog *dia;
 345         char *str;
 346         int width;
 347 #define MIN_WIDTH 20
 348
 349         str = talloc_vasprintf(ctx, msg, ap);
 350         if (str == NULL) {
 351                 return NULL;
 352         }
 353
 354         width = strlen(str) + 2;
 355         if (width < MIN_WIDTH) {
 356                 width = MIN_WIDTH;
 357         }
 358         dia = dialog_choice_center_new(ctx, title, choices, nlines, width);
 359         if (dia == NULL) {
 360                 return NULL;
 361         }
 362
 363         waddstr(dia->sub_window, str);
 364         talloc_free(str);
 365
 366         return dia;
 367 }
 368
 369 int dialog_input(TALLOC_CTX *ctx, char **output, const char *title,
 370                  const char *msg, ...)
 371 {
 372         va_list ap;
 373         struct dialog *dia;
 374         const char *choices[] = {
 375                 "Ok",
 376                 "Cancel",
 377                 NULL
 378         };
 379         FIELD *field[2] = {0};
 380         FORM *input;
 381         WINDOW *input_win;
 382         int y, x;
 383         int rv = -1;
 384         bool input_section = true;
 385
 386         va_start(ap, msg);
 387         dia = dialog_msg_new(ctx, title, choices, 7, msg, ap);
 388         va_end(ap);
 389         if (dia == NULL) {
 390                 return -1;
 391         }
 392
 393         getmaxyx(dia->sub_window, y, x);
 394         input_win = derwin(dia->sub_window, 1, x - 2, 2, 1);
 395         if (input_win == NULL) {
 396                 goto finish;
 397         }
 398         field[0] = new_field(1, x - 2, 0, 0, 0, 0);
 399         if (field[0] == NULL) {
 400                 goto finish;
 401         }
 402
 403         field_opts_off(field[0], O_BLANK | O_AUTOSKIP | O_STATIC);
 404         set_field_back(field[0], A_REVERSE);
 405
 406         input = new_form(field);
 407         form_opts_off(input, O_NL_OVERLOAD | O_BS_OVERLOAD);
 408         set_form_win(input, dia->sub_window);
 409         set_form_sub(input, input_win);
 410         set_current_field(input, field[0]);
 411         post_form(input);
 412         *output = NULL;
 413
 414         update_panels();
 415         doupdate();
 416
 417         while (rv == -1) {
 418                 int c = dialog_getch(dia);
 419
 420                 if (c == '\t' || c == KEY_BTAB) {
 421                         if (input_section) {
 422                                 if (form_driver(input,REQ_VALIDATION) == E_OK) {
 423                                         input_section = false;
 424                                         menu_driver(dia->choices, REQ_FIRST_ITEM);
 425                                 }
 426                         } else {
 427                                 input_section = true;
 428                                 set_current_field(input, field[0]);
 429                         }
 430                 } else if (input_section) {
 431                         handle_form_input(input, c);
 432                 } else {
 433                         rv = handle_menu_input(dia->choices, c);
 434                         if (rv == DIALOG_OK) {
 435                                 const char *buf = field_buffer(field[0], 0);
 436                                 *output = string_trim(ctx, buf);
 437                         }
 438                 }
 439                 update_panels();
 440                 doupdate();
 441         }
 442
 443 finish:
 444         if (input) {
 445                 unpost_form(input);
 446                 free_form(input);
 447         }
 448         if (field[0]) {
 449                 free_field(field[0]);
 450         }
 451         if (input_win) {
 452                 delwin(input_win);
 453         }
 454         talloc_free(dia);
 455
 456         return rv;
 457 }
 458
 459 int dialog_notice(TALLOC_CTX *ctx, enum dialog_type type,
 460                   const char *title, const char *msg, ...)
 461 {
 462         va_list ap;
 463         struct dialog *dia;
 464         const char *choices[] = {
 465                 "Ok",
 466                 "Cancel",
 467                 NULL
 468         };
 469
 470         if (type == DIA_ALERT) {
 471                 choices[1] = NULL;
 472         }
 473
 474         va_start(ap, msg);
 475         dia = dialog_msg_new(ctx, title, choices, 5, msg, ap);
 476         va_end(ap);
 477         if (dia == NULL) {
 478                 return -1;
 479         }
 480
 481         return modal_loop(dia);
 482 }
 483
 484 #define EDIT_WIDTH              50
 485 #define EDIT_INTERNAL_WIDTH     (EDIT_WIDTH - 2)
 486 #define EDIT_INPUT_WIDTH        (EDIT_INTERNAL_WIDTH - 2)
 487
 488 #define EDIT_NAME_LABEL_Y       0
 489 #define EDIT_NAME_LABEL_X       0
 490 #define EDIT_NAME_LABEL_WIDTH   EDIT_INTERNAL_WIDTH
 491 #define EDIT_NAME_LABEL_HEIGHT  1
 492 #define EDIT_NAME_INPUT_Y       1
 493 #define EDIT_NAME_INPUT_X       1
 494 #define EDIT_NAME_INPUT_WIDTH   EDIT_INPUT_WIDTH
 495 #define EDIT_NAME_INPUT_HEIGHT  1
 496
 497 #define EDIT_DATA_LABEL_Y       3
 498 #define EDIT_DATA_LABEL_X       0
 499 #define EDIT_DATA_LABEL_WIDTH   EDIT_INTERNAL_WIDTH
 500 #define EDIT_DATA_LABEL_HEIGHT  1
 501 #define EDIT_DATA_INPUT_Y       4
 502 #define EDIT_DATA_INPUT_X       1
 503 #define EDIT_DATA_INPUT_WIDTH   EDIT_INPUT_WIDTH
 504 #define EDIT_DATA_HEIGHT_ONELINE        1
 505 #define EDIT_DATA_HEIGHT_MULTILINE      5
 506 #define EDIT_DATA_HEIGHT_BUF            10
 507
 508 #define EDIT_FORM_WIN_Y                 0
 509 #define EDIT_FORM_WIN_X                 0
 510 #define EDIT_FORM_WIN_HEIGHT_ONELINE    \
 511         (EDIT_NAME_LABEL_HEIGHT + EDIT_NAME_INPUT_HEIGHT + 1 + \
 512          EDIT_DATA_LABEL_HEIGHT + EDIT_DATA_HEIGHT_ONELINE)
 513
 514 #define EDIT_FORM_WIN_HEIGHT_MULTILINE  \
 515         (EDIT_NAME_LABEL_HEIGHT + EDIT_NAME_INPUT_HEIGHT + 1 + \
 516          EDIT_DATA_LABEL_HEIGHT + EDIT_DATA_HEIGHT_MULTILINE)
 517
 518 #define EDIT_FORM_WIN_HEIGHT_BUF        \
 519         (EDIT_NAME_LABEL_HEIGHT + EDIT_NAME_INPUT_HEIGHT + 1 + \
 520          EDIT_DATA_LABEL_HEIGHT)
 521
 522 #define EDIT_FORM_WIN_WIDTH             EDIT_INTERNAL_WIDTH
 523
 524 #define EDIT_PAD                5
 525 #define EDIT_HEIGHT_ONELINE     (EDIT_FORM_WIN_HEIGHT_ONELINE + EDIT_PAD)
 526
 527 #define EDIT_HEIGHT_MULTILINE   (EDIT_FORM_WIN_HEIGHT_MULTILINE + EDIT_PAD)
 528
 529 #define EDIT_HEIGHT_BUF         \
 530         (EDIT_FORM_WIN_HEIGHT_BUF + EDIT_DATA_HEIGHT_BUF + EDIT_PAD)
 531
 532 #define MAX_FIELDS 5
 533 #define FLD_NAME 1
 534 #define FLD_DATA 3
 535
 536 enum input_section {
 537         IN_NAME,
 538         IN_DATA,
 539         IN_MENU
 540 };
 541
 542 struct edit_dialog {
 543         struct dialog *dia;
 544         WINDOW *input_win;
 545         FORM *input;
 546         FIELD *field[MAX_FIELDS];
 547         struct hexedit *buf;
 548         enum input_section section;
 549 };
 550
 551 static int edit_dialog_free(struct edit_dialog *edit)
 552 {
 553         FIELD **f;
 554
 555         if (edit->input) {
 556                 unpost_form(edit->input);
 557                 free_form(edit->input);
 558         }
 559         for (f = edit->field; *f; ++f) {
 560                 free_field(*f);
 561         }
 562         delwin(edit->input_win);
 563
 564         return 0;
 565 }
 566
 567 static WERROR fill_value_buffer(struct edit_dialog *edit,
 568                                 const struct value_item *vitem)
 569 {
 570         char *tmp;
 571
 572         switch (vitem->type) {
 573         case REG_DWORD: {
 574                 uint32_t v = 0;
 575                 if (vitem->data.length >= 4) {
 576                         v = IVAL(vitem->data.data, 0);
 577                 }
 578                 tmp = talloc_asprintf(edit, "0x%x", v);
 579                 if (tmp == NULL) {
 580                         return WERR_NOMEM;
 581                 }
 582                 set_field_buffer(edit->field[FLD_DATA], 0, tmp);
 583                 talloc_free(tmp);
 584                 break;
 585         }
 586         case REG_SZ:
 587         case REG_EXPAND_SZ: {
 588                 const char *s;
 589
 590                 if (!pull_reg_sz(edit, &vitem->data, &s)) {
 591                         return WERR_NOMEM;
 592                 }
 593                 set_field_buffer(edit->field[FLD_DATA], 0, s);
 594                 break;
 595         }
 596         case REG_MULTI_SZ: {
 597                 const char **p, **a;
 598                 char *buf = NULL;
 599
 600                 if (!pull_reg_multi_sz(edit, &vitem->data, &a)) {
 601                         return WERR_NOMEM;
 602                 }
 603                 for (p = a; *p != NULL; ++p) {
 604                         if (buf == NULL) {
 605                                 buf = talloc_asprintf(edit, "%s\n", *p);
 606                         } else {
 607                                 buf = talloc_asprintf_append(buf, "%s\n", *p);
 608                         }
 609                         if (buf == NULL) {
 610                                 return WERR_NOMEM;
 611                         }
 612                 }
 613                 set_field_buffer(edit->field[FLD_DATA], 0, buf);
 614                 talloc_free(buf);
 615         }
 616         case REG_BINARY:
 617                 /* initialized upon dialog creation */
 618                 break;
 619         }
 620
 621         return WERR_OK;
 622 }
 623
 624 static bool value_exists(TALLOC_CTX *ctx, const struct registry_key *key,
 625                          const char *name)
 626 {
 627         uint32_t type;
 628         DATA_BLOB blob;
 629         WERROR rv;
 630
 631         rv = reg_key_get_value_by_name(ctx, key, name, &type, &blob);
 632
 633         return W_ERROR_IS_OK(rv);
 634 }
 635
 636 static WERROR set_value(struct edit_dialog *edit, struct registry_key *key,
 637                         uint32_t type, bool new_value)
 638 {
 639         WERROR rv;
 640         DATA_BLOB blob;
 641         char *name = string_trim(edit, field_buffer(edit->field[FLD_NAME], 0));
 642
 643         if (!new_value && !edit->buf && !field_status(edit->field[FLD_DATA])) {
 644                 return WERR_OK;
 645         }
 646         if (new_value && value_exists(edit, key, name)) {
 647                 return WERR_FILE_EXISTS;
 648         }
 649
 650         switch (type) {
 651         case REG_DWORD: {
 652                 uint32_t val;
 653                 int base = 10;
 654                 const char *buf = field_buffer(edit->field[FLD_DATA], 0);
 655
 656                 if (buf[0] == '0' && tolower(buf[1]) == 'x') {
 657                         base = 16;
 658                 }
 659
 660                 val = strtoul(buf, NULL, base);
 661                 blob = data_blob_talloc(edit, NULL, sizeof(val));
 662                 SIVAL(blob.data, 0, val);
 663                 rv = WERR_OK;
 664                 break;
 665         }
 666         case REG_SZ:
 667         case REG_EXPAND_SZ: {
 668                 const char *buf = field_buffer(edit->field[FLD_DATA], 0);
 669                 char *str = string_trim(edit, buf);
 670
 671                 if (!str || !push_reg_sz(edit, &blob, str)) {
 672                         rv = WERR_NOMEM;
 673                 }
 674                 break;
 675         }
 676         case REG_MULTI_SZ: {
 677                 int rows, cols, max;
 678                 const char **arr;
 679                 size_t i;
 680                 const char *buf = field_buffer(edit->field[FLD_DATA], 0);
 681
 682                 dynamic_field_info(edit->field[FLD_DATA], &rows, &cols, &max);
 683
 684                 arr = talloc_zero_array(edit, const char *, rows + 1);
 685                 if (arr == NULL) {
 686                         return WERR_NOMEM;
 687                 }
 688                 for (i = 0; *buf; ++i, buf += cols) {
 689                         SMB_ASSERT(i < rows);
 690                         arr[i] = string_trim_n(edit, buf, cols);
 691                 }
 692                 if (!push_reg_multi_sz(edit, &blob, arr)) {
 693                         rv = WERR_NOMEM;
 694                 }
 695                 break;
 696         }
 697         case REG_BINARY:
 698                 blob = data_blob_talloc(edit, NULL, edit->buf->len);
 699                 memcpy(blob.data, edit->buf->data, edit->buf->len);
 700                 break;
 701         }
 702
 703         rv = reg_val_set(key, name, type, blob);
 704
 705         return rv;
 706 }
 707
 708 static void section_down(struct edit_dialog *edit)
 709 {
 710         switch (edit->section) {
 711         case IN_NAME:
 712                 if (form_driver(edit->input, REQ_VALIDATION) == E_OK) {
 713                         edit->section = IN_DATA;
 714                         if (edit->buf) {
 715                                 hexedit_set_cursor(edit->buf);
 716                         } else {
 717                                 set_current_field(edit->input,
 718                                                   edit->field[FLD_DATA]);
 719                         }
 720                 }
 721                 break;
 722         case IN_DATA:
 723                 if (edit->buf ||
 724                     form_driver(edit->input, REQ_VALIDATION) == E_OK) {
 725                         edit->section = IN_MENU;
 726                         menu_driver(edit->dia->choices, REQ_FIRST_ITEM);
 727                 }
 728                 break;
 729         case IN_MENU:
 730                 edit->section = IN_NAME;
 731                 set_current_field(edit->input, edit->field[FLD_NAME]);
 732                 break;
 733         }
 734         update_panels();
 735         doupdate();
 736 }
 737
 738 static void section_up(struct edit_dialog *edit)
 739 {
 740         switch (edit->section) {
 741         case IN_NAME:
 742                 if (form_driver(edit->input, REQ_VALIDATION) == E_OK) {
 743                         edit->section = IN_MENU;
 744                         menu_driver(edit->dia->choices, REQ_FIRST_ITEM);
 745                 }
 746                 break;
 747         case IN_DATA:
 748                 if (edit->buf ||
 749                     form_driver(edit->input, REQ_VALIDATION) == E_OK) {
 750                         edit->section = IN_NAME;
 751                         set_current_field(edit->input, edit->field[FLD_NAME]);
 752                 }
 753                 break;
 754         case IN_MENU:
 755                 edit->section = IN_DATA;
 756                 if (edit->buf) {
 757                         hexedit_set_cursor(edit->buf);
 758                 } else {
 759                         set_current_field(edit->input, edit->field[FLD_DATA]);
 760                 }
 761                 break;
 762         }
 763         update_panels();
 764         doupdate();
 765 }
 766
 767 static void handle_hexedit_input(struct hexedit *buf, int c)
 768 {
 769         switch (c) {
 770         case KEY_UP:
 771                 hexedit_driver(buf, HE_CURSOR_UP);
 772                 break;
 773         case KEY_DOWN:
 774                 hexedit_driver(buf, HE_CURSOR_DOWN);
 775                 break;
 776         case KEY_LEFT:
 777                 hexedit_driver(buf, HE_CURSOR_LEFT);
 778                 break;
 779         case KEY_RIGHT:
 780                 hexedit_driver(buf, HE_CURSOR_RIGHT);
 781                 break;
 782         default:
 783                 hexedit_driver(buf, c);
 784                 break;
 785         }
 786
 787         hexedit_set_cursor(buf);
 788 }
 789
 790 static WERROR edit_init_dialog(struct edit_dialog *edit, uint32_t type)
 791 {
 792         char *title;
 793         int diaheight = -1;
 794         int winheight = -1;
 795         const char *choices[] = {
 796                 "Ok",
 797                 "Cancel",
 798                 "Resize",
 799                 NULL
 800         };
 801
 802         switch (type) {
 803         case REG_MULTI_SZ:
 804                 diaheight = EDIT_HEIGHT_MULTILINE;
 805                 winheight = EDIT_FORM_WIN_HEIGHT_MULTILINE;
 806                 choices[2] = NULL;
 807                 break;
 808         case REG_BINARY:
 809                 diaheight = EDIT_HEIGHT_BUF;
 810                 winheight = EDIT_FORM_WIN_HEIGHT_BUF;
 811                 break;
 812         default:
 813                 diaheight = EDIT_HEIGHT_ONELINE;
 814                 winheight = EDIT_FORM_WIN_HEIGHT_ONELINE;
 815                 choices[2] = NULL;
 816                 break;
 817         }
 818
 819         title = talloc_asprintf(edit, "Edit %s value", str_regtype(type));
 820         if (title == NULL) {
 821                 return WERR_NOMEM;
 822         }
 823         edit->dia = dialog_choice_center_new(edit, title, choices, diaheight,
 824                                              EDIT_WIDTH);
 825         talloc_free(title);
 826         if (edit->dia == NULL) {
 827                 return WERR_NOMEM;
 828         }
 829         edit->input_win = derwin(edit->dia->sub_window, winheight,
 830                                  EDIT_FORM_WIN_WIDTH,
 831                                  EDIT_FORM_WIN_Y, EDIT_FORM_WIN_X);
 832         if (edit->input_win == NULL) {
 833                 return WERR_NOMEM;
 834         }
 835
 836         return WERR_OK;
 837 }
 838
 839 static WERROR edit_init_form(struct edit_dialog *edit, uint32_t type,
 840                              const struct value_item *vitem)
 841 {
 842
 843         edit->field[0] = new_field(EDIT_NAME_LABEL_HEIGHT,
 844                                    EDIT_NAME_LABEL_WIDTH,
 845                                    EDIT_NAME_LABEL_Y,
 846                                    EDIT_NAME_LABEL_X, 0, 0);
 847         if (edit->field[0] == NULL) {
 848                 return WERR_NOMEM;
 849         }
 850         set_field_buffer(edit->field[0], 0, "Name");
 851         field_opts_off(edit->field[0], O_EDIT);
 852
 853         edit->field[FLD_NAME] = new_field(EDIT_NAME_INPUT_HEIGHT,
 854                                           EDIT_NAME_INPUT_WIDTH,
 855                                           EDIT_NAME_INPUT_Y,
 856                                           EDIT_NAME_INPUT_X, 0, 0);
 857         if (edit->field[FLD_NAME] == NULL) {
 858                 return WERR_NOMEM;
 859         }
 860
 861         edit->field[2] = new_field(EDIT_DATA_LABEL_HEIGHT,
 862                                    EDIT_DATA_LABEL_WIDTH,
 863                                    EDIT_DATA_LABEL_Y,
 864                                    EDIT_DATA_LABEL_X, 0, 0);
 865         if (edit->field[2] == NULL) {
 866                 return WERR_NOMEM;
 867         }
 868         set_field_buffer(edit->field[2], 0, "Data");
 869         field_opts_off(edit->field[2], O_EDIT);
 870
 871         if (type == REG_BINARY) {
 872                 size_t len = 8;
 873                 const void *buf = NULL;
 874
 875                 if (vitem) {
 876                         len = vitem->data.length;
 877                         buf = vitem->data.data;
 878                 }
 879                 edit->buf = hexedit_new(edit, edit->dia->sub_window,
 880                                         EDIT_DATA_HEIGHT_BUF,
 881                                         EDIT_DATA_INPUT_Y,
 882                                         EDIT_DATA_INPUT_X,
 883                                         buf, len);
 884                 if (edit->buf == NULL) {
 885                         return WERR_NOMEM;
 886                 }
 887                 hexedit_refresh(edit->buf);
 888                 hexedit_set_cursor(edit->buf);
 889         } else {
 890                 int val_rows = EDIT_DATA_HEIGHT_ONELINE;
 891
 892                 if (type == REG_MULTI_SZ) {
 893                         val_rows = EDIT_DATA_HEIGHT_MULTILINE;
 894                 }
 895                 edit->field[FLD_DATA] = new_field(val_rows,
 896                                                   EDIT_DATA_INPUT_WIDTH,
 897                                                   EDIT_DATA_INPUT_Y,
 898                                                   EDIT_DATA_INPUT_X, 0, 0);
 899                 if (edit->field[FLD_DATA] == NULL) {
 900                         return WERR_NOMEM;
 901                 }
 902         }
 903
 904         set_field_back(edit->field[FLD_NAME], A_REVERSE);
 905         field_opts_off(edit->field[FLD_NAME], O_BLANK | O_AUTOSKIP | O_STATIC);
 906         if (edit->field[FLD_DATA]) {
 907                 set_field_back(edit->field[FLD_DATA], A_REVERSE);
 908                 field_opts_off(edit->field[FLD_DATA],
 909                                O_BLANK | O_AUTOSKIP | O_STATIC | O_WRAP);
 910                 if (type == REG_DWORD) {
 911                         set_field_type(edit->field[FLD_DATA], TYPE_REGEXP,
 912                                        "^ *([0-9]+|0[xX][0-9a-fA-F]+) *$");
 913                 }
 914         }
 915
 916         if (vitem) {
 917                 set_field_buffer(edit->field[FLD_NAME], 0, vitem->value_name);
 918                 field_opts_off(edit->field[FLD_NAME], O_EDIT);
 919                 fill_value_buffer(edit, vitem);
 920         }
 921
 922         edit->input = new_form(edit->field);
 923         if (edit->input == NULL) {
 924                 return WERR_NOMEM;
 925         }
 926         form_opts_off(edit->input, O_NL_OVERLOAD | O_BS_OVERLOAD);
 927
 928         set_form_win(edit->input, edit->dia->sub_window);
 929         set_form_sub(edit->input, edit->input_win);
 930         set_current_field(edit->input, edit->field[FLD_NAME]);
 931         post_form(edit->input);
 932
 933         return WERR_OK;
 934 }
 935
 936 WERROR dialog_edit_value(TALLOC_CTX *ctx, struct registry_key *key, uint32_t type,
 937                       const struct value_item *vitem)
 938 {
 939         struct edit_dialog *edit;
 940 #define DIALOG_RESIZE 2
 941         WERROR rv = WERR_NOMEM;
 942         int selection;
 943
 944         edit = talloc_zero(ctx, struct edit_dialog);
 945         if (edit == NULL) {
 946                 return rv;
 947         }
 948         talloc_set_destructor(edit, edit_dialog_free);
 949
 950         rv = edit_init_dialog(edit, type);
 951         if (!W_ERROR_IS_OK(rv)) {
 952                 goto finish;
 953         }
 954         rv = edit_init_form(edit, type, vitem);
 955         if (!W_ERROR_IS_OK(rv)) {
 956                 goto finish;
 957         }
 958
 959         update_panels();
 960         doupdate();
 961
 962         edit->section = IN_NAME;
 963
 964         while (1) {
 965                 int c = dialog_getch(edit->dia);
 966                 if (c == '\t') {
 967                         section_down(edit);
 968                         continue;
 969                 } else if (c == KEY_BTAB) {
 970                         section_up(edit);
 971                         continue;
 972                 }
 973
 974                 if (edit->section == IN_NAME) {
 975                         handle_form_input(edit->input, c);
 976                 } else if (edit->section == IN_DATA) {
 977                         if (edit->buf) {
 978                                 handle_hexedit_input(edit->buf, c);
 979                         } else {
 980                                 handle_form_input(edit->input, c);
 981                         }
 982                 } else {
 983                         selection = handle_menu_input(edit->dia->choices, c);
 984                         if (selection == DIALOG_OK) {
 985                                 rv = set_value(edit, key, type, vitem == NULL);
 986                                 if (W_ERROR_EQUAL(rv, WERR_FILE_EXISTS)) {
 987                                         dialog_notice(edit, DIA_ALERT,
 988                                                       "Value exists",
 989                                                       "Value name already exists.");
 990                                         selection = -1;
 991                                 } else {
 992                                         goto finish;
 993                                 }
 994                         } else if (selection == DIALOG_RESIZE) {
 995                                 char *n;
 996                                 size_t newlen = 0;
 997
 998                                 dialog_input(edit, &n, "Resize buffer",
 999                                              "Enter new size");
1000                                 if (n) {
1001                                         newlen = strtoul(n, NULL, 10);
1002                                         hexedit_resize_buffer(edit->buf, newlen);
1003                                         hexedit_refresh(edit->buf);
1004                                         talloc_free(n);
1005                                 }
1006                         } else if (selection == DIALOG_CANCEL) {
1007                                 rv = WERR_OK;
1008                                 goto finish;
1009                         }
1010                 }
1011
1012                 update_panels();
1013                 doupdate();
1014         }
1015
1016 finish:
1017         talloc_free(edit);
1018
1019         return rv;
1020 }
1021
1022 int dialog_select_type(TALLOC_CTX *ctx, int *type)
1023 {
1024         struct dialog *dia;
1025         const char *choices[] = {
1026                 "OK",
1027                 "Cancel",
1028                 NULL
1029         };
1030         const char *reg_types[] = {
1031                 "REG_DWORD",
1032                 "REG_SZ",
1033                 "REG_EXPAND_SZ",
1034                 "REG_MULTI_SZ",
1035                 "REG_BINARY",
1036         };
1037 #define NTYPES (sizeof(reg_types) / sizeof(const char*))
1038         ITEM **item;
1039         MENU *list;
1040         WINDOW *type_win;
1041         int sel = -1;
1042         size_t i;
1043
1044         dia = dialog_choice_center_new(ctx, "New Value", choices, 10, 20);
1045         if (dia == NULL) {
1046                 return -1;
1047         }
1048
1049         mvwprintw(dia->sub_window, 0, 0, "Choose type:");
1050         type_win = derwin(dia->sub_window, 6, 18, 1, 0);
1051         if (type_win == NULL) {
1052                 goto finish;
1053         }
1054
1055         item = talloc_zero_array(dia, ITEM *, NTYPES + 1);
1056         if (item == NULL) {
1057                 goto finish;
1058         }
1059
1060         for (i = 0; i < NTYPES; ++i) {
1061                 int t = regtype_by_string(reg_types[i]);
1062
1063                 item[i] = new_item(reg_types[i], reg_types[i]);
1064                 if (item[i] == NULL) {
1065                         goto finish;
1066                 }
1067                 set_item_userptr(item[i], (void*)(uintptr_t)t);
1068         }
1069
1070         list = new_menu(item);
1071         if (list == NULL) {
1072                 goto finish;
1073         }
1074
1075         set_menu_format(list, 7, 1);
1076         set_menu_win(list, dia->sub_window);
1077         set_menu_sub(list, type_win);
1078         menu_opts_off(list, O_SHOWDESC);
1079         set_menu_mark(list, "* ");
1080         post_menu(list);
1081
1082         update_panels();
1083         doupdate();
1084
1085         while (sel == -1) {
1086                 ITEM *it;
1087                 int c = dialog_getch(dia);
1088
1089                 switch (c) {
1090                 case KEY_UP:
1091                         menu_driver(list, REQ_UP_ITEM);
1092                         break;
1093                 case KEY_DOWN:
1094                         menu_driver(list, REQ_DOWN_ITEM);
1095                         break;
1096                 case KEY_LEFT:
1097                         menu_driver(dia->choices, REQ_LEFT_ITEM);
1098                         break;
1099                 case KEY_RIGHT:
1100                         menu_driver(dia->choices, REQ_RIGHT_ITEM);
1101                         break;
1102                 case '\n':
1103                 case KEY_ENTER:
1104                         it = current_item(list);
1105                         *type = (int)(uintptr_t)item_userptr(it);
1106                         it = current_item(dia->choices);
1107                         sel = (int)(uintptr_t)item_userptr(it);
1108                         break;
1109                 }
1110
1111                 update_panels();
1112                 doupdate();
1113         }
1114
1115 finish:
1116         if (list) {
1117                 unpost_menu(list);
1118                 free_menu(list);
1119         }
1120         if (item) {
1121                 ITEM **it;
1122                 for (it = item; *it; ++it) {
1123                         free_item(*it);
1124                 }
1125         }
1126         if (type_win) {
1127                 delwin(type_win);
1128         }
1129         talloc_free(dia);
1130
1131         return sel;
1132 }