source/rpc_server/srv_reg_nt.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell               1992-1997.
   5  *  Copyright (C) Luke Kenneth Casson Leighton  1996-1997.
   6  *  Copyright (C) Paul Ashton                        1997.
   7  *  Copyright (C) Jeremy Allison                     2001.
   8  *  Copyright (C) Gerald Carter                      2002.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 /* Implementation of registry functions. */
  26
  27 #include "includes.h"
  28
  29 #undef DBGC_CLASS
  30 #define DBGC_CLASS DBGC_RPC_SRV
  31
  32 #define OUR_HANDLE(hnd) (((hnd)==NULL)?"NULL":(IVAL((hnd)->data5,4)==(uint32)sys_getpid()?"OURS":"OTHER")), \
  33 ((unsigned int)IVAL((hnd)->data5,4)),((unsigned int)sys_getpid())
  34
  35
  36 static REGISTRY_KEY *regkeys_list;
  37
  38
  39 /******************************************************************
  40  free() function for REGISTRY_KEY
  41  *****************************************************************/
  42
  43 static void free_regkey_info(void *ptr)
  44 {
  45         REGISTRY_KEY *info = (REGISTRY_KEY*)ptr;
  46
  47         DLIST_REMOVE(regkeys_list, info);
  48
  49         SAFE_FREE(info);
  50 }
  51
  52 /******************************************************************
  53  Find a registry key handle and return a REGISTRY_KEY
  54  *****************************************************************/
  55
  56 static REGISTRY_KEY *find_regkey_index_by_hnd(pipes_struct *p, POLICY_HND *hnd)
  57 {
  58         REGISTRY_KEY *regkey = NULL;
  59
  60         if(!find_policy_by_hnd(p,hnd,(void **)&regkey)) {
  61                 DEBUG(2,("find_regkey_index_by_hnd: Registry Key not found: "));
  62                 return NULL;
  63         }
  64
  65         return regkey;
  66 }
  67
  68
  69 /*******************************************************************
  70  Function for open a new registry handle and creating a handle
  71  Note that P should be valid & hnd should already have space
  72
  73  When we open a key, we store the full path to the key as
  74  HK[LM|U]\<key>\<key>\...
  75  *******************************************************************/
  76
  77 static NTSTATUS open_registry_key(pipes_struct *p, POLICY_HND *hnd, REGISTRY_KEY *parent,
  78                                 char *subkeyname, uint32 access_granted  )
  79 {
  80         REGISTRY_KEY    *regkey = NULL;
  81         pstring         parent_keyname;
  82         NTSTATUS        result = NT_STATUS_OK;
  83         REGSUBKEY_CTR   subkeys;
  84
  85         if ( parent ) {
  86                 pstrcpy( parent_keyname, parent->name );
  87                 pstrcat( parent_keyname, "\\" );
  88         }
  89         else
  90                 *parent_keyname = '\0';
  91
  92         DEBUG(7,("open_registry_key: name = [%s][%s]\n", parent_keyname, subkeyname));
  93
  94         /* All registry keys **must** have a name of non-zero length */
  95
  96         if (!subkeyname || !*subkeyname )
  97                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
  98
  99         if ((regkey=(REGISTRY_KEY*)malloc(sizeof(REGISTRY_KEY))) == NULL)
 100                 return NT_STATUS_NO_MEMORY;
 101
 102         ZERO_STRUCTP( regkey );
 103
 104         /* copy the name */
 105
 106         pstrcpy( regkey->name, parent_keyname );
 107         pstrcat( regkey->name, subkeyname );
 108
 109         /* Look up the table of registry I/O operations */
 110
 111         if ( !(regkey->hook = reghook_cache_find( regkey->name )) ) {
 112                 DEBUG(0,("open_registry_key: Failed to assigned a REGISTRY_HOOK to [%s]\n",
 113                         regkey->name ));
 114                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
 115         }
 116
 117         /* check if the path really exists; failed is indicated by -1 */
 118         /* if the subkey count failed, bail out */
 119
 120         ZERO_STRUCTP( &subkeys );
 121
 122         regsubkey_ctr_init( &subkeys );
 123
 124         if ( fetch_reg_keys( regkey, &subkeys ) == -1 )  {
 125
 126                 /* don't really know what to return here */
 127
 128                 result = NT_STATUS_ACCESS_DENIED;
 129         }
 130         else {
 131                 /*
 132                  * This would previously return NT_STATUS_TOO_MANY_SECRETS
 133                  * that doesn't sound quite right to me  --jerry
 134                  */
 135
 136                 if ( !create_policy_hnd( p, hnd, free_regkey_info, regkey ) )
 137                         result = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 138         }
 139
 140         /* clean up */
 141
 142         regsubkey_ctr_destroy( &subkeys );
 143
 144         if ( ! NT_STATUS_IS_OK(result) )
 145                 SAFE_FREE( regkey );
 146         else
 147                 DLIST_ADD( regkeys_list, regkey );
 148
 149
 150         DEBUG(7,("open_registry_key: exit\n"));
 151
 152         return result;
 153 }
 154
 155 /*******************************************************************
 156  Function for open a new registry handle and creating a handle
 157  Note that P should be valid & hnd should already have space
 158  *******************************************************************/
 159
 160 static BOOL close_registry_key(pipes_struct *p, POLICY_HND *hnd)
 161 {
 162         REGISTRY_KEY *regkey = find_regkey_index_by_hnd(p, hnd);
 163
 164         if ( !regkey ) {
 165                 DEBUG(2,("close_registry_key: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(hnd)));
 166                 return False;
 167         }
 168
 169         close_policy_hnd(p, hnd);
 170
 171         return True;
 172 }
 173
 174 /********************************************************************
 175  retrieve information about the subkeys
 176  *******************************************************************/
 177
 178 static BOOL get_subkey_information( REGISTRY_KEY *key, uint32 *maxnum, uint32 *maxlen )
 179 {
 180         int             num_subkeys, i;
 181         uint32          max_len;
 182         REGSUBKEY_CTR   subkeys;
 183         uint32          len;
 184
 185         if ( !key )
 186                 return False;
 187
 188         ZERO_STRUCTP( &subkeys );
 189
 190         regsubkey_ctr_init( &subkeys );
 191
 192         if ( fetch_reg_keys( key, &subkeys ) == -1 )
 193                 return False;
 194
 195         /* find the longest string */
 196
 197         max_len = 0;
 198         num_subkeys = regsubkey_ctr_numkeys( &subkeys );
 199
 200         for ( i=0; i<num_subkeys; i++ ) {
 201                 len = strlen( regsubkey_ctr_specific_key(&subkeys, i) );
 202                 max_len = MAX(max_len, len);
 203         }
 204
 205         *maxnum = num_subkeys;
 206         *maxlen = max_len*2;
 207
 208         regsubkey_ctr_destroy( &subkeys );
 209
 210         return True;
 211 }
 212
 213 /********************************************************************
 214  retrieve information about the values.  We don't store values
 215  here.  The registry tdb is intended to be a frontend to oether
 216  Samba tdb's (such as ntdrivers.tdb).
 217  *******************************************************************/
 218
 219 static BOOL get_value_information( REGISTRY_KEY *key, uint32 *maxnum,
 220                                     uint32 *maxlen, uint32 *maxsize )
 221 {
 222         REGVAL_CTR      values;
 223         REGISTRY_VALUE  *val;
 224         uint32          sizemax, lenmax;
 225         int             i, num_values;
 226
 227         if ( !key )
 228                 return False;
 229
 230         ZERO_STRUCTP( &val );
 231
 232         regval_ctr_init( &values );
 233
 234         if ( fetch_reg_values( key, &values ) == -1 )
 235                 return False;
 236
 237         lenmax = sizemax = 0;
 238         num_values = regval_ctr_numvals( &values );
 239
 240         for ( i=0; i<num_values && val; i++ ) {
 241                 val = regval_ctr_specific_value( &values, i );
 242                 lenmax  = MAX(lenmax,  strlen(val[i].valuename)+1 );
 243                 sizemax = MAX(sizemax, val[i].size );
 244         }
 245
 246         *maxnum   = num_values;
 247         *maxlen   = lenmax;
 248         *maxsize  = sizemax;
 249
 250         regval_ctr_destroy( &values );
 251
 252         return True;
 253 }
 254
 255
 256 /********************************************************************
 257  reg_close
 258  ********************************************************************/
 259
 260 NTSTATUS _reg_close(pipes_struct *p, REG_Q_CLOSE *q_u, REG_R_CLOSE *r_u)
 261 {
 262         /* set up the REG unknown_1 response */
 263         ZERO_STRUCT(r_u->pol);
 264
 265         /* close the policy handle */
 266         if (!close_registry_key(p, &q_u->pol))
 267                 return NT_STATUS_OBJECT_NAME_INVALID;
 268
 269         return NT_STATUS_OK;
 270 }
 271
 272 /*******************************************************************
 273  reg_reply_open
 274  ********************************************************************/
 275
 276 NTSTATUS _reg_open_hklm(pipes_struct *p, REG_Q_OPEN_HKLM *q_u, REG_R_OPEN_HKLM *r_u)
 277 {
 278         return open_registry_key( p, &r_u->pol, NULL, KEY_HKLM, 0x0 );
 279 }
 280
 281 /*******************************************************************
 282  reg_reply_open
 283  ********************************************************************/
 284
 285 NTSTATUS _reg_open_hku(pipes_struct *p, REG_Q_OPEN_HKU *q_u, REG_R_OPEN_HKU *r_u)
 286 {
 287         return open_registry_key( p, &r_u->pol, NULL, KEY_HKU, 0x0 );
 288 }
 289
 290 /*******************************************************************
 291  reg_reply_open_entry
 292  ********************************************************************/
 293
 294 NTSTATUS _reg_open_entry(pipes_struct *p, REG_Q_OPEN_ENTRY *q_u, REG_R_OPEN_ENTRY *r_u)
 295 {
 296         POLICY_HND pol;
 297         fstring name;
 298         REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->pol);
 299         NTSTATUS result;
 300
 301         DEBUG(5,("reg_open_entry: Enter\n"));
 302
 303         if ( !key )
 304                 return NT_STATUS_INVALID_HANDLE;
 305
 306         rpcstr_pull(name,q_u->uni_name.buffer,sizeof(name),q_u->uni_name.uni_str_len*2,0);
 307
 308         DEBUG(5,("reg_open_entry: Enter\n"));
 309
 310         result = open_registry_key( p, &pol, key, name, 0x0 );
 311
 312         init_reg_r_open_entry( r_u, &pol, result );
 313
 314         DEBUG(5,("reg_open_entry: Exit\n"));
 315
 316         return r_u->status;
 317 }
 318
 319 /*******************************************************************
 320  reg_reply_info
 321  ********************************************************************/
 322
 323 NTSTATUS _reg_info(pipes_struct *p, REG_Q_INFO *q_u, REG_R_INFO *r_u)
 324 {
 325         NTSTATUS status = NT_STATUS_OK;
 326         char *value = NULL;
 327         uint32 type = 0x1; /* key type: REG_SZ */
 328         UNISTR2 *uni_key = NULL;
 329         BUFFER2 *buf = NULL;
 330         fstring name;
 331         REGISTRY_KEY *key = find_regkey_index_by_hnd( p, &q_u->pol );
 332
 333         DEBUG(5,("_reg_info: Enter\n"));
 334
 335         if ( !key )
 336                 return NT_STATUS_INVALID_HANDLE;
 337
 338         DEBUG(7,("_reg_info: policy key name = [%s]\n", key->name));
 339
 340         rpcstr_pull(name, q_u->uni_type.buffer, sizeof(name), q_u->uni_type.uni_str_len*2, 0);
 341
 342         DEBUG(5,("reg_info: checking subkey: %s\n", name));
 343
 344         uni_key = (UNISTR2 *)talloc_zero(p->mem_ctx, sizeof(UNISTR2));
 345         buf = (BUFFER2 *)talloc_zero(p->mem_ctx, sizeof(BUFFER2));
 346
 347         if (!uni_key || !buf)
 348                 return NT_STATUS_NO_MEMORY;
 349
 350         if ( strequal(name, "RefusePasswordChange") ) {
 351                 type=0xF770;
 352                 status = NT_STATUS_NO_SUCH_FILE;
 353                 init_unistr2(uni_key, "", 0);
 354                 init_buffer2(buf, (uint8*) uni_key->buffer, uni_key->uni_str_len*2);
 355
 356                 buf->buf_max_len=4;
 357
 358                 goto out;
 359         }
 360
 361         switch (lp_server_role()) {
 362                 case ROLE_DOMAIN_PDC:
 363                 case ROLE_DOMAIN_BDC:
 364                         value = "LanmanNT";
 365                         break;
 366                 case ROLE_STANDALONE:
 367                         value = "ServerNT";
 368                         break;
 369                 case ROLE_DOMAIN_MEMBER:
 370                         value = "WinNT";
 371                         break;
 372         }
 373
 374         /* This makes the server look like a member server to clients */
 375         /* which tells clients that we have our own local user and    */
 376         /* group databases and helps with ACL support.                */
 377
 378         init_unistr2(uni_key, value, strlen(value)+1);
 379         init_buffer2(buf, (uint8*)uni_key->buffer, uni_key->uni_str_len*2);
 380
 381  out:
 382         init_reg_r_info(q_u->ptr_buf, r_u, buf, type, status);
 383
 384         DEBUG(5,("_reg_info: Exit\n"));
 385
 386         return status;
 387 }
 388
 389
 390 /*****************************************************************************
 391  Implementation of REG_QUERY_KEY
 392  ****************************************************************************/
 393
 394 NTSTATUS _reg_query_key(pipes_struct *p, REG_Q_QUERY_KEY *q_u, REG_R_QUERY_KEY *r_u)
 395 {
 396         NTSTATUS        status = NT_STATUS_OK;
 397         REGISTRY_KEY    *regkey = find_regkey_index_by_hnd( p, &q_u->pol );
 398
 399         DEBUG(5,("_reg_query_key: Enter\n"));
 400
 401         if ( !regkey )
 402                 return NT_STATUS_INVALID_HANDLE;
 403
 404         if ( !get_subkey_information( regkey, &r_u->num_subkeys, &r_u->max_subkeylen ) )
 405                 return NT_STATUS_ACCESS_DENIED;
 406
 407         if ( !get_value_information( regkey, &r_u->num_values, &r_u->max_valnamelen, &r_u->max_valbufsize ) )
 408                 return NT_STATUS_ACCESS_DENIED;
 409
 410
 411         r_u->sec_desc = 0x00000078;     /* size for key's sec_desc */
 412
 413         /* Win9x set this to 0x0 since it does not keep timestamps.
 414            Doing the same here for simplicity   --jerry */
 415
 416         ZERO_STRUCT(r_u->mod_time);
 417
 418         DEBUG(5,("_reg_query_key: Exit\n"));
 419
 420         return status;
 421 }
 422
 423
 424 /*****************************************************************************
 425  Implementation of REG_UNKNOWN_1A
 426  ****************************************************************************/
 427
 428 NTSTATUS _reg_unknown_1a(pipes_struct *p, REG_Q_UNKNOWN_1A *q_u, REG_R_UNKNOWN_1A *r_u)
 429 {
 430         NTSTATUS        status = NT_STATUS_OK;
 431         REGISTRY_KEY    *regkey = find_regkey_index_by_hnd( p, &q_u->pol );
 432
 433         DEBUG(5,("_reg_unknown_1a: Enter\n"));
 434
 435         if ( !regkey )
 436                 return NT_STATUS_INVALID_HANDLE;
 437
 438         r_u->unknown = 0x00000005;      /* seems to be consistent...no idea what it means */
 439
 440         DEBUG(5,("_reg_unknown_1a: Exit\n"));
 441
 442         return status;
 443 }
 444
 445
 446 /*****************************************************************************
 447  Implementation of REG_ENUM_KEY
 448  ****************************************************************************/
 449
 450 NTSTATUS _reg_enum_key(pipes_struct *p, REG_Q_ENUM_KEY *q_u, REG_R_ENUM_KEY *r_u)
 451 {
 452         NTSTATUS        status = NT_STATUS_OK;
 453         REGISTRY_KEY    *regkey = find_regkey_index_by_hnd( p, &q_u->pol );
 454         char            *subkey;
 455
 456
 457         DEBUG(5,("_reg_enum_key: Enter\n"));
 458
 459         if ( !regkey )
 460                 return NT_STATUS_INVALID_HANDLE;
 461
 462         DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", regkey->name));
 463
 464         if ( !fetch_reg_keys_specific( regkey, &subkey, q_u->key_index ) )
 465         {
 466                 status = NT_STATUS_NO_MORE_ENTRIES;
 467                 goto done;
 468         }
 469
 470         DEBUG(10,("_reg_enum_key: retrieved subkey named [%s]\n", subkey));
 471
 472         /* subkey has the string name now */
 473
 474         init_reg_r_enum_key( r_u, subkey, q_u->unknown_1, q_u->unknown_2 );
 475
 476         DEBUG(5,("_reg_enum_key: Exit\n"));
 477
 478 done:
 479         SAFE_FREE( subkey );
 480         return status;
 481 }
 482
 483
 484 /*******************************************************************
 485  reg_shutdwon
 486  ********************************************************************/
 487
 488 #define SHUTDOWN_R_STRING "-r"
 489 #define SHUTDOWN_F_STRING "-f"
 490
 491
 492 NTSTATUS _reg_shutdown(pipes_struct *p, REG_Q_SHUTDOWN *q_u, REG_R_SHUTDOWN *r_u)
 493 {
 494         NTSTATUS status = NT_STATUS_OK;
 495         pstring shutdown_script;
 496         UNISTR2 unimsg = q_u->uni_msg;
 497         pstring message;
 498         pstring chkmsg;
 499         fstring timeout;
 500         fstring r;
 501         fstring f;
 502
 503         /* message */
 504         rpcstr_pull (message, unimsg.buffer, sizeof(message), unimsg.uni_str_len*2,0);
 505                 /* security check */
 506         alpha_strcpy (chkmsg, message, NULL, sizeof(message));
 507         /* timeout */
 508         snprintf(timeout, sizeof(timeout), "%d", q_u->timeout);
 509         /* reboot */
 510         snprintf(r, sizeof(r), (q_u->flags & REG_REBOOT_ON_SHUTDOWN)?SHUTDOWN_R_STRING:"");
 511         /* force */
 512         snprintf(f, sizeof(f), (q_u->flags & REG_FORCE_SHUTDOWN)?SHUTDOWN_F_STRING:"");
 513
 514         pstrcpy(shutdown_script, lp_shutdown_script());
 515
 516         if(*shutdown_script) {
 517                 int shutdown_ret;
 518                 all_string_sub(shutdown_script, "%m", chkmsg, sizeof(shutdown_script));
 519                 all_string_sub(shutdown_script, "%t", timeout, sizeof(shutdown_script));
 520                 all_string_sub(shutdown_script, "%r", r, sizeof(shutdown_script));
 521                 all_string_sub(shutdown_script, "%f", f, sizeof(shutdown_script));
 522                 shutdown_ret = smbrun(shutdown_script,NULL);
 523                 DEBUG(3,("_reg_shutdown: Running the command `%s' gave %d\n",shutdown_script,shutdown_ret));
 524         }
 525
 526         return status;
 527 }
 528
 529 /*******************************************************************
 530  reg_abort_shutdwon
 531  ********************************************************************/
 532
 533 NTSTATUS _reg_abort_shutdown(pipes_struct *p, REG_Q_ABORT_SHUTDOWN *q_u, REG_R_ABORT_SHUTDOWN *r_u)
 534 {
 535         NTSTATUS status = NT_STATUS_OK;
 536         pstring abort_shutdown_script;
 537
 538         pstrcpy(abort_shutdown_script, lp_abort_shutdown_script());
 539
 540         if(*abort_shutdown_script) {
 541                 int abort_shutdown_ret;
 542                 abort_shutdown_ret = smbrun(abort_shutdown_script,NULL);
 543                 DEBUG(3,("_reg_abort_shutdown: Running the command `%s' gave %d\n",abort_shutdown_script,abort_shutdown_ret));
 544         }
 545
 546         return status;
 547 }
 548
 549