source/rpc_server/srv_winreg_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *
   5  *  Copyright (C) Gerald Carter                 2002-2006.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /* Implementation of registry functions. */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_RPC_SRV
  27
  28 /******************************************************************
  29  free() function for struct registry_key
  30  *****************************************************************/
  31
  32 static void free_regkey(void *ptr)
  33 {
  34         struct registry_key *key = (struct registry_key *)ptr;
  35         TALLOC_FREE(key);
  36 }
  37
  38 /******************************************************************
  39  Find a registry key handle and return a struct registry_key *
  40  *****************************************************************/
  41
  42 static struct registry_key *find_regkey_by_hnd(pipes_struct *p,
  43                                                POLICY_HND *hnd)
  44 {
  45         struct registry_key *regkey = NULL;
  46
  47         if(!find_policy_by_hnd(p,hnd,(void **)(void *)&regkey)) {
  48                 DEBUG(2,("find_regkey_index_by_hnd: Registry Key not found: "));
  49                 return NULL;
  50         }
  51
  52         return regkey;
  53 }
  54
  55 /*******************************************************************
  56  Function for open a new registry handle and creating a handle
  57  Note that P should be valid & hnd should already have space
  58
  59  When we open a key, we store the full path to the key as
  60  HK[LM|U]\<key>\<key>\...
  61  *******************************************************************/
  62
  63 static WERROR open_registry_key( pipes_struct *p, POLICY_HND *hnd,
  64                                  struct registry_key *parent,
  65                                  const char *subkeyname,
  66                                  uint32 access_desired  )
  67 {
  68         WERROR result = WERR_OK;
  69         struct registry_key *key;
  70
  71         if (parent == NULL) {
  72                 result = reg_openhive(NULL, subkeyname, access_desired,
  73                                       p->pipe_user.nt_user_token, &key);
  74         }
  75         else {
  76                 result = reg_openkey(NULL, parent, subkeyname, access_desired,
  77                                      &key);
  78         }
  79
  80         if ( !W_ERROR_IS_OK(result) ) {
  81                 return result;
  82         }
  83
  84         if ( !create_policy_hnd( p, hnd, free_regkey, key ) ) {
  85                 return WERR_BADFILE;
  86         }
  87
  88         return WERR_OK;
  89 }
  90
  91 /*******************************************************************
  92  Function for open a new registry handle and creating a handle
  93  Note that P should be valid & hnd should already have space
  94  *******************************************************************/
  95
  96 static bool close_registry_key(pipes_struct *p, POLICY_HND *hnd)
  97 {
  98         struct registry_key *regkey = find_regkey_by_hnd(p, hnd);
  99
 100         if ( !regkey ) {
 101                 DEBUG(2,("close_registry_key: Invalid handle (%s:%u:%u)\n",
 102                          OUR_HANDLE(hnd)));
 103                 return False;
 104         }
 105
 106         close_policy_hnd(p, hnd);
 107
 108         return True;
 109 }
 110
 111 /********************************************************************
 112  reg_close
 113  ********************************************************************/
 114
 115 WERROR _winreg_CloseKey(pipes_struct *p, struct winreg_CloseKey *r)
 116 {
 117         /* close the policy handle */
 118
 119         if (!close_registry_key(p, r->in.handle))
 120                 return WERR_BADFID;
 121
 122         ZERO_STRUCTP(r->out.handle);
 123
 124         return WERR_OK;
 125 }
 126
 127 /*******************************************************************
 128  ********************************************************************/
 129
 130 WERROR _winreg_OpenHKLM(pipes_struct *p, struct winreg_OpenHKLM *r)
 131 {
 132         return open_registry_key(p, r->out.handle, NULL, KEY_HKLM, r->in.access_mask);
 133 }
 134
 135 /*******************************************************************
 136  ********************************************************************/
 137
 138 WERROR _winreg_OpenHKPD(pipes_struct *p, struct winreg_OpenHKPD *r)
 139 {
 140         return open_registry_key(p, r->out.handle, NULL, KEY_HKPD, r->in.access_mask);
 141 }
 142
 143 /*******************************************************************
 144  ********************************************************************/
 145
 146 WERROR _winreg_OpenHKPT(pipes_struct *p, struct winreg_OpenHKPT *r)
 147 {
 148         return open_registry_key(p, r->out.handle, NULL, KEY_HKPT, r->in.access_mask);
 149 }
 150
 151 /*******************************************************************
 152  ********************************************************************/
 153
 154 WERROR _winreg_OpenHKCR(pipes_struct *p, struct winreg_OpenHKCR *r)
 155 {
 156         return open_registry_key(p, r->out.handle, NULL, KEY_HKCR, r->in.access_mask);
 157 }
 158
 159 /*******************************************************************
 160  ********************************************************************/
 161
 162 WERROR _winreg_OpenHKU(pipes_struct *p, struct winreg_OpenHKU *r)
 163 {
 164         return open_registry_key(p, r->out.handle, NULL, KEY_HKU, r->in.access_mask);
 165 }
 166
 167 /*******************************************************************
 168  ********************************************************************/
 169
 170 WERROR _winreg_OpenHKCU(pipes_struct *p, struct winreg_OpenHKCU *r)
 171 {
 172         return open_registry_key(p, r->out.handle, NULL, KEY_HKCU, r->in.access_mask);
 173 }
 174
 175 /*******************************************************************
 176  ********************************************************************/
 177
 178 WERROR _winreg_OpenHKCC(pipes_struct *p, struct winreg_OpenHKCC *r)
 179 {
 180         return open_registry_key(p, r->out.handle, NULL, KEY_HKCC, r->in.access_mask);
 181 }
 182
 183 /*******************************************************************
 184  ********************************************************************/
 185
 186 WERROR _winreg_OpenHKDD(pipes_struct *p, struct winreg_OpenHKDD *r)
 187 {
 188         return open_registry_key(p, r->out.handle, NULL, KEY_HKDD, r->in.access_mask);
 189 }
 190
 191 /*******************************************************************
 192  ********************************************************************/
 193
 194 WERROR _winreg_OpenHKPN(pipes_struct *p, struct winreg_OpenHKPN *r)
 195 {
 196         return open_registry_key(p, r->out.handle, NULL, KEY_HKPN, r->in.access_mask);
 197 }
 198
 199 /*******************************************************************
 200  reg_reply_open_entry
 201  ********************************************************************/
 202
 203 WERROR _winreg_OpenKey(pipes_struct *p, struct winreg_OpenKey *r)
 204 {
 205         struct registry_key *parent = find_regkey_by_hnd(p, r->in.parent_handle );
 206
 207         if ( !parent )
 208                 return WERR_BADFID;
 209
 210         return open_registry_key(p, r->out.handle, parent, r->in.keyname.name, r->in.access_mask);
 211 }
 212
 213 /*******************************************************************
 214  reg_reply_info
 215  ********************************************************************/
 216
 217 WERROR _winreg_QueryValue(pipes_struct *p, struct winreg_QueryValue *r)
 218 {
 219         WERROR        status = WERR_BADFILE;
 220         struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 221         prs_struct    prs_hkpd;
 222
 223         uint8_t *outbuf;
 224         uint32_t outbuf_size;
 225
 226         DATA_BLOB val_blob;
 227         bool free_buf = False;
 228         bool free_prs = False;
 229
 230         if ( !regkey )
 231                 return WERR_BADFID;
 232
 233         if ((r->out.value_length == NULL) || (r->out.type == NULL)) {
 234                 return WERR_INVALID_PARAM;
 235         }
 236
 237         *r->out.value_length = *r->out.type = REG_NONE;
 238
 239         DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
 240         DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
 241
 242         /* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
 243         if(regkey->key->type == REG_KEY_HKPD)
 244         {
 245                 if (strequal(r->in.value_name->name, "Global")) {
 246                         if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
 247                                 return WERR_NOMEM;
 248                         status = reg_perfcount_get_hkpd(
 249                                 &prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
 250                         outbuf = (uint8_t *)prs_hkpd.data_p;
 251                         free_prs = True;
 252                 }
 253                 else if (strequal(r->in.value_name->name, "Counter 009")) {
 254                         outbuf_size = reg_perfcount_get_counter_names(
 255                                 reg_perfcount_get_base_index(),
 256                                 (char **)(void *)&outbuf);
 257                         free_buf = True;
 258                 }
 259                 else if (strequal(r->in.value_name->name, "Explain 009")) {
 260                         outbuf_size = reg_perfcount_get_counter_help(
 261                                 reg_perfcount_get_base_index(),
 262                                 (char **)(void *)&outbuf);
 263                         free_buf = True;
 264                 }
 265                 else if (isdigit(r->in.value_name->name[0])) {
 266                         /* we probably have a request for a specific object
 267                          * here */
 268                         if (!prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL))
 269                                 return WERR_NOMEM;
 270                         status = reg_perfcount_get_hkpd(
 271                                 &prs_hkpd, *r->in.data_size, &outbuf_size,
 272                                 r->in.value_name->name);
 273                         outbuf = (uint8_t *)prs_hkpd.data_p;
 274                         free_prs = True;
 275                 }
 276                 else {
 277                         DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
 278                                  r->in.value_name->name));
 279                         return WERR_BADFILE;
 280                 }
 281
 282                 *r->out.type = REG_BINARY;
 283         }
 284         else {
 285                 struct registry_value *val;
 286
 287                 status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name->name,
 288                                         &val);
 289                 if (!W_ERROR_IS_OK(status)) {
 290                         if (r->out.data_size) {
 291                                 *r->out.data_size = 0;
 292                         }
 293                         if (r->out.value_length) {
 294                                 *r->out.value_length = 0;
 295                         }
 296                         return status;
 297                 }
 298
 299                 status = registry_push_value(p->mem_ctx, val, &val_blob);
 300                 if (!W_ERROR_IS_OK(status)) {
 301                         return status;
 302                 }
 303
 304                 outbuf = val_blob.data;
 305                 outbuf_size = val_blob.length;
 306                 *r->out.type = val->type;
 307         }
 308
 309         *r->out.value_length = outbuf_size;
 310
 311         if ( *r->in.data_size == 0 || !r->out.data ) {
 312                 status = WERR_OK;
 313         } else if ( *r->out.value_length > *r->in.data_size ) {
 314                 status = WERR_MORE_DATA;
 315         } else {
 316                 memcpy( r->out.data, outbuf, *r->out.value_length );
 317                 status = WERR_OK;
 318         }
 319
 320         *r->out.data_size = *r->out.value_length;
 321
 322         if (free_prs) prs_mem_free(&prs_hkpd);
 323         if (free_buf) SAFE_FREE(outbuf);
 324
 325         return status;
 326 }
 327
 328 /*****************************************************************************
 329  Implementation of REG_QUERY_KEY
 330  ****************************************************************************/
 331
 332 WERROR _winreg_QueryInfoKey(pipes_struct *p, struct winreg_QueryInfoKey *r)
 333 {
 334         WERROR  status = WERR_OK;
 335         struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 336
 337         if ( !regkey )
 338                 return WERR_BADFID;
 339
 340         r->out.classname->name = NULL;
 341
 342         status = reg_queryinfokey(regkey, r->out.num_subkeys, r->out.max_subkeylen,
 343                                   r->out.max_classlen, r->out.num_values, r->out.max_valnamelen,
 344                                   r->out.max_valbufsize, r->out.secdescsize,
 345                                   r->out.last_changed_time);
 346         if (!W_ERROR_IS_OK(status)) {
 347                 return status;
 348         }
 349
 350         /*
 351          * These calculations account for the registry buffers being
 352          * UTF-16. They are inexact at best, but so far they worked.
 353          */
 354
 355         *r->out.max_subkeylen *= 2;
 356
 357         *r->out.max_valnamelen += 1;
 358         *r->out.max_valnamelen *= 2;
 359
 360         return WERR_OK;
 361 }
 362
 363
 364 /*****************************************************************************
 365  Implementation of REG_GETVERSION
 366  ****************************************************************************/
 367
 368 WERROR _winreg_GetVersion(pipes_struct *p, struct winreg_GetVersion *r)
 369 {
 370         struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 371
 372         if ( !regkey )
 373                 return WERR_BADFID;
 374
 375         return reg_getversion(r->out.version);
 376 }
 377
 378
 379 /*****************************************************************************
 380  Implementation of REG_ENUM_KEY
 381  ****************************************************************************/
 382
 383 WERROR _winreg_EnumKey(pipes_struct *p, struct winreg_EnumKey *r)
 384 {
 385         WERROR err;
 386         struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
 387
 388         if ( !key )
 389                 return WERR_BADFID;
 390
 391         if ( !r->in.name || !r->in.keyclass )
 392                 return WERR_INVALID_PARAM;
 393
 394         DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
 395
 396         err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
 397                           r->out.last_changed_time);
 398         if (!W_ERROR_IS_OK(err)) {
 399                 return err;
 400         }
 401         r->out.keyclass->name = "";
 402         return WERR_OK;
 403 }
 404
 405 /*****************************************************************************
 406  Implementation of REG_ENUM_VALUE
 407  ****************************************************************************/
 408
 409 WERROR _winreg_EnumValue(pipes_struct *p, struct winreg_EnumValue *r)
 410 {
 411         WERROR err;
 412         struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
 413         char *valname;
 414         struct registry_value *val;
 415         DATA_BLOB value_blob;
 416
 417         if ( !key )
 418                 return WERR_BADFID;
 419
 420         if ( !r->in.name )
 421                 return WERR_INVALID_PARAM;
 422
 423         DEBUG(8,("_winreg_EnumValue: enumerating values for key [%s]\n",
 424                  key->key->name));
 425
 426         err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
 427         if (!W_ERROR_IS_OK(err)) {
 428                 return err;
 429         }
 430
 431         err = registry_push_value(p->mem_ctx, val, &value_blob);
 432         if (!W_ERROR_IS_OK(err)) {
 433                 return err;
 434         }
 435
 436         if (r->out.name != NULL) {
 437                 r->out.name->name = valname;
 438         }
 439
 440         if (r->out.type != NULL) {
 441                 *r->out.type = val->type;
 442         }
 443
 444         if (r->out.value != NULL) {
 445                 if ((r->out.size == NULL) || (r->out.length == NULL)) {
 446                         return WERR_INVALID_PARAM;
 447                 }
 448
 449                 if (value_blob.length > *r->out.size) {
 450                         return WERR_MORE_DATA;
 451                 }
 452
 453                 memcpy( r->out.value, value_blob.data, value_blob.length );
 454         }
 455
 456         if (r->out.length != NULL) {
 457                 *r->out.length = value_blob.length;
 458         }
 459         if (r->out.size != NULL) {
 460                 *r->out.size = value_blob.length;
 461         }
 462
 463         return WERR_OK;
 464 }
 465
 466 /*******************************************************************
 467  reg_shutdwon
 468  ********************************************************************/
 469
 470 WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, struct winreg_InitiateSystemShutdown *r)
 471 {
 472         struct winreg_InitiateSystemShutdownEx s;
 473
 474         s.in.hostname = r->in.hostname;
 475         s.in.message = r->in.message;
 476         s.in.timeout = r->in.timeout;
 477         s.in.force_apps = r->in.force_apps;
 478         s.in.do_reboot = r->in.do_reboot;
 479         s.in.reason = 0;
 480
 481         /* thunk down to _winreg_InitiateSystemShutdownEx()
 482            (just returns a status) */
 483
 484         return _winreg_InitiateSystemShutdownEx( p, &s );
 485 }
 486
 487 /*******************************************************************
 488  reg_shutdown_ex
 489  ********************************************************************/
 490
 491 #define SHUTDOWN_R_STRING "-r"
 492 #define SHUTDOWN_F_STRING "-f"
 493
 494
 495 WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r)
 496 {
 497         char *shutdown_script = NULL;
 498         char *msg = NULL;
 499         char *chkmsg = NULL;
 500         fstring str_timeout;
 501         fstring str_reason;
 502         fstring do_reboot;
 503         fstring f;
 504         int ret;
 505         bool can_shutdown;
 506
 507         shutdown_script = talloc_strdup(p->mem_ctx, lp_shutdown_script());
 508         if (!shutdown_script) {
 509                 return WERR_NOMEM;
 510         }
 511         if (!*shutdown_script) {
 512                 return WERR_ACCESS_DENIED;
 513         }
 514
 515         /* pull the message string and perform necessary sanity checks on it */
 516
 517         if ( r->in.message && r->in.message->name && r->in.message->name->name ) {
 518                 if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->name->name )) == NULL ) {
 519                         return WERR_NOMEM;
 520                 }
 521                 chkmsg = TALLOC_ARRAY(p->mem_ctx, char, strlen(msg)+1);
 522                 if (!chkmsg) {
 523                         return WERR_NOMEM;
 524                 }
 525                 alpha_strcpy(chkmsg, msg, NULL, strlen(msg)+1);
 526         }
 527
 528         fstr_sprintf(str_timeout, "%d", r->in.timeout);
 529         fstr_sprintf(do_reboot, r->in.do_reboot ? SHUTDOWN_R_STRING : "");
 530         fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
 531         fstr_sprintf(str_reason, "%d", r->in.reason );
 532
 533         shutdown_script = talloc_all_string_sub(p->mem_ctx,
 534                                 shutdown_script, "%z", chkmsg ? chkmsg : "");
 535         if (!shutdown_script) {
 536                 return WERR_NOMEM;
 537         }
 538         shutdown_script = talloc_all_string_sub(p->mem_ctx,
 539                                         shutdown_script, "%t", str_timeout);
 540         if (!shutdown_script) {
 541                 return WERR_NOMEM;
 542         }
 543         shutdown_script = talloc_all_string_sub(p->mem_ctx,
 544                                                 shutdown_script, "%r", do_reboot);
 545         if (!shutdown_script) {
 546                 return WERR_NOMEM;
 547         }
 548         shutdown_script = talloc_all_string_sub(p->mem_ctx,
 549                                                 shutdown_script, "%f", f);
 550         if (!shutdown_script) {
 551                 return WERR_NOMEM;
 552         }
 553         shutdown_script = talloc_all_string_sub(p->mem_ctx,
 554                                         shutdown_script, "%x", str_reason);
 555         if (!shutdown_script) {
 556                 return WERR_NOMEM;
 557         }
 558
 559         can_shutdown = user_has_privileges( p->pipe_user.nt_user_token, &se_remote_shutdown );
 560
 561         /* IF someone has privs, run the shutdown script as root. OTHERWISE run it as not root
 562            Take the error return from the script and provide it as the Windows return code. */
 563
 564         /********** BEGIN SeRemoteShutdownPrivilege BLOCK **********/
 565
 566         if ( can_shutdown )
 567                 become_root();
 568
 569         ret = smbrun( shutdown_script, NULL );
 570
 571         if ( can_shutdown )
 572                 unbecome_root();
 573
 574         /********** END SeRemoteShutdownPrivilege BLOCK **********/
 575
 576         DEBUG(3,("_reg_shutdown_ex: Running the command `%s' gave %d\n",
 577                 shutdown_script, ret));
 578
 579         return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
 580 }
 581
 582 /*******************************************************************
 583  reg_abort_shutdwon
 584  ********************************************************************/
 585
 586 WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r)
 587 {
 588         const char *abort_shutdown_script;
 589         int ret;
 590         bool can_shutdown;
 591
 592         abort_shutdown_script = lp_abort_shutdown_script();
 593
 594         if (!*abort_shutdown_script)
 595                 return WERR_ACCESS_DENIED;
 596
 597         can_shutdown = user_has_privileges( p->pipe_user.nt_user_token, &se_remote_shutdown );
 598
 599         /********** BEGIN SeRemoteShutdownPrivilege BLOCK **********/
 600
 601         if ( can_shutdown )
 602                 become_root();
 603
 604         ret = smbrun( abort_shutdown_script, NULL );
 605
 606         if ( can_shutdown )
 607                 unbecome_root();
 608
 609         /********** END SeRemoteShutdownPrivilege BLOCK **********/
 610
 611         DEBUG(3,("_reg_abort_shutdown: Running the command `%s' gave %d\n",
 612                 abort_shutdown_script, ret));
 613
 614         return (ret == 0) ? WERR_OK : WERR_ACCESS_DENIED;
 615 }
 616
 617 /*******************************************************************
 618  ********************************************************************/
 619
 620 static int validate_reg_filename(TALLOC_CTX *ctx, char **pp_fname )
 621 {
 622         char *p = NULL;
 623         int num_services = lp_numservices();
 624         int snum = -1;
 625         const char *share_path;
 626         char *fname = *pp_fname;
 627
 628         /* convert to a unix path, stripping the C:\ along the way */
 629
 630         if (!(p = valid_share_pathname(ctx, fname))) {
 631                 return -1;
 632         }
 633
 634         /* has to exist within a valid file share */
 635
 636         for (snum=0; snum<num_services; snum++) {
 637                 if (!lp_snum_ok(snum) || lp_print_ok(snum)) {
 638                         continue;
 639                 }
 640
 641                 share_path = lp_pathname(snum);
 642
 643                 /* make sure we have a path (e.g. [homes] ) */
 644                 if (strlen(share_path) == 0) {
 645                         continue;
 646                 }
 647
 648                 if (strncmp(share_path, p, strlen(share_path)) == 0) {
 649                         break;
 650                 }
 651         }
 652
 653         *pp_fname = p;
 654         return (snum < num_services) ? snum : -1;
 655 }
 656
 657 /*******************************************************************
 658  ********************************************************************/
 659
 660 WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r)
 661 {
 662         struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 663         char *fname = NULL;
 664         int             snum;
 665
 666         if ( !regkey )
 667                 return WERR_BADFID;
 668
 669         if ( !r->in.filename || !r->in.filename->name )
 670                 return WERR_INVALID_PARAM;
 671
 672         fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
 673         if (!fname) {
 674                 return WERR_NOMEM;
 675         }
 676
 677         DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
 678                  "\"%s\"\n", regkey->key->name, fname));
 679
 680         if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1)
 681                 return WERR_OBJECT_PATH_INVALID;
 682
 683         /* user must posses SeRestorePrivilege for this this proceed */
 684
 685         if ( !user_has_privileges( p->pipe_user.nt_user_token, &se_restore ) )
 686                 return WERR_ACCESS_DENIED;
 687
 688         DEBUG(2,("_winreg_RestoreKey: Restoring [%s] from %s in share %s\n",
 689                  regkey->key->name, fname, lp_servicename(snum) ));
 690
 691         return reg_restorekey(regkey, fname);
 692 }
 693
 694 WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r)
 695 {
 696         struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
 697         char *fname = NULL;
 698         int snum = -1;
 699
 700         if ( !regkey )
 701                 return WERR_BADFID;
 702
 703         if ( !r->in.filename || !r->in.filename->name )
 704                 return WERR_INVALID_PARAM;
 705
 706         fname = talloc_strdup(p->mem_ctx, r->in.filename->name);
 707         if (!fname) {
 708                 return WERR_NOMEM;
 709         }
 710
 711         DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
 712                  regkey->key->name, fname));
 713
 714         if ((snum = validate_reg_filename(p->mem_ctx, &fname)) == -1 )
 715                 return WERR_OBJECT_PATH_INVALID;
 716
 717         DEBUG(2,("_winreg_SaveKey: Saving [%s] to %s in share %s\n",
 718                  regkey->key->name, fname, lp_servicename(snum) ));
 719
 720         return reg_savekey(regkey, fname);
 721 }
 722
 723 /*******************************************************************
 724  ********************************************************************/
 725
 726 WERROR _winreg_SaveKeyEx(pipes_struct *p, struct winreg_SaveKeyEx *r)
 727 {
 728         /* fill in your code here if you think this call should
 729            do anything */
 730
 731         p->rng_fault_state = True;
 732         return WERR_NOT_SUPPORTED;
 733 }
 734
 735 /*******************************************************************
 736  ********************************************************************/
 737
 738 WERROR _winreg_CreateKey( pipes_struct *p, struct winreg_CreateKey *r)
 739 {
 740         struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
 741         struct registry_key *new_key;
 742         WERROR result;
 743
 744         if ( !parent )
 745                 return WERR_BADFID;
 746
 747         DEBUG(10, ("_winreg_CreateKey called with parent key '%s' and "
 748                    "subkey name '%s'\n", parent->key->name, r->in.name.name));
 749
 750         result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
 751                                &new_key, r->out.action_taken);
 752         if (!W_ERROR_IS_OK(result)) {
 753                 return result;
 754         }
 755
 756         if (!create_policy_hnd(p, r->out.new_handle, free_regkey, new_key)) {
 757                 TALLOC_FREE(new_key);
 758                 return WERR_BADFILE;
 759         }
 760
 761         return WERR_OK;
 762 }
 763
 764 /*******************************************************************
 765  ********************************************************************/
 766
 767 WERROR _winreg_SetValue(pipes_struct *p, struct winreg_SetValue *r)
 768 {
 769         struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 770         struct registry_value *val;
 771         WERROR status;
 772
 773         if ( !key )
 774                 return WERR_BADFID;
 775
 776         DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n",
 777                          key->key->name, r->in.name.name));
 778
 779         status = registry_pull_value(p->mem_ctx, &val, r->in.type, r->in.data,
 780                                                                  r->in.size, r->in.size);
 781         if (!W_ERROR_IS_OK(status)) {
 782                 return status;
 783         }
 784
 785         return reg_setvalue(key, r->in.name.name, val);
 786 }
 787
 788 /*******************************************************************
 789  ********************************************************************/
 790
 791 WERROR _winreg_DeleteKey(pipes_struct *p, struct winreg_DeleteKey *r)
 792 {
 793         struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
 794
 795         if ( !parent )
 796                 return WERR_BADFID;
 797
 798         return reg_deletekey(parent, r->in.key.name);
 799 }
 800
 801
 802 /*******************************************************************
 803  ********************************************************************/
 804
 805 WERROR _winreg_DeleteValue(pipes_struct *p, struct winreg_DeleteValue *r)
 806 {
 807         struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 808
 809         if ( !key )
 810                 return WERR_BADFID;
 811
 812         return reg_deletevalue(key, r->in.value.name);
 813 }
 814
 815 /*******************************************************************
 816  ********************************************************************/
 817
 818 WERROR _winreg_GetKeySecurity(pipes_struct *p, struct winreg_GetKeySecurity *r)
 819 {
 820         struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 821         WERROR err;
 822         struct security_descriptor *secdesc;
 823         uint8 *data;
 824         size_t len;
 825
 826         if ( !key )
 827                 return WERR_BADFID;
 828
 829         /* access checks first */
 830
 831         if ( !(key->key->access_granted & STD_RIGHT_READ_CONTROL_ACCESS) )
 832                 return WERR_ACCESS_DENIED;
 833
 834         err = reg_getkeysecurity(p->mem_ctx, key, &secdesc);
 835         if (!W_ERROR_IS_OK(err)) {
 836                 return err;
 837         }
 838
 839         err = ntstatus_to_werror(marshall_sec_desc(p->mem_ctx, secdesc,
 840                                                    &data, &len));
 841         if (!W_ERROR_IS_OK(err)) {
 842                 return err;
 843         }
 844
 845         if (len > r->out.sd->size) {
 846                 r->out.sd->size = len;
 847                 return WERR_INSUFFICIENT_BUFFER;
 848         }
 849
 850         r->out.sd->size = len;
 851         r->out.sd->len = len;
 852         r->out.sd->data = data;
 853
 854         return WERR_OK;
 855 }
 856
 857 /*******************************************************************
 858  ********************************************************************/
 859
 860 WERROR _winreg_SetKeySecurity(pipes_struct *p, struct winreg_SetKeySecurity *r)
 861 {
 862         struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
 863         struct security_descriptor *secdesc;
 864         WERROR err;
 865
 866         if ( !key )
 867                 return WERR_BADFID;
 868
 869         /* access checks first */
 870
 871         if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
 872                 return WERR_ACCESS_DENIED;
 873
 874         err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, r->in.sd->data,
 875                                                      r->in.sd->len, &secdesc));
 876         if (!W_ERROR_IS_OK(err)) {
 877                 return err;
 878         }
 879
 880         return reg_setkeysecurity(key, secdesc);
 881 }
 882
 883 /*******************************************************************
 884  ********************************************************************/
 885
 886 WERROR _winreg_FlushKey(pipes_struct *p, struct winreg_FlushKey *r)
 887 {
 888         /* I'm just replying OK because there's not a lot
 889            here I see to do i  --jerry */
 890
 891         return WERR_OK;
 892 }
 893
 894 /*******************************************************************
 895  ********************************************************************/
 896
 897 WERROR _winreg_UnLoadKey(pipes_struct *p, struct winreg_UnLoadKey *r)
 898 {
 899         /* fill in your code here if you think this call should
 900            do anything */
 901
 902         p->rng_fault_state = True;
 903         return WERR_NOT_SUPPORTED;
 904 }
 905
 906 /*******************************************************************
 907  ********************************************************************/
 908
 909 WERROR _winreg_ReplaceKey(pipes_struct *p, struct winreg_ReplaceKey *r)
 910 {
 911         /* fill in your code here if you think this call should
 912            do anything */
 913
 914         p->rng_fault_state = True;
 915         return WERR_NOT_SUPPORTED;
 916 }
 917
 918 /*******************************************************************
 919  ********************************************************************/
 920
 921 WERROR _winreg_LoadKey(pipes_struct *p, struct winreg_LoadKey *r)
 922 {
 923         /* fill in your code here if you think this call should
 924            do anything */
 925
 926         p->rng_fault_state = True;
 927         return WERR_NOT_SUPPORTED;
 928 }
 929
 930 /*******************************************************************
 931  ********************************************************************/
 932
 933 WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct winreg_NotifyChangeKeyValue *r)
 934 {
 935         /* fill in your code here if you think this call should
 936            do anything */
 937
 938         p->rng_fault_state = True;
 939         return WERR_NOT_SUPPORTED;
 940 }
 941
 942 /*******************************************************************
 943  ********************************************************************/
 944
 945 WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct winreg_QueryMultipleValues *r)
 946 {
 947         /* fill in your code here if you think this call should
 948            do anything */
 949
 950         p->rng_fault_state = True;
 951         return WERR_NOT_SUPPORTED;
 952 }
 953
 954 /*******************************************************************
 955  ********************************************************************/
 956
 957 WERROR _winreg_QueryMultipleValues2(pipes_struct *p, struct winreg_QueryMultipleValues2 *r)
 958 {
 959         /* fill in your code here if you think this call should
 960            do anything */
 961
 962         p->rng_fault_state = True;
 963         return WERR_NOT_SUPPORTED;
 964 }
 965