source/rpc_server/srv_reg.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) Marc Jacobsen                     2000,
   8  *  Copyright (C) Jeremy Allison                    2001,
   9  *  Copyright (C) Gerald Carter                     2002,
  10  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 /* This is the interface for the registry functions. */
  28
  29 #include "includes.h"
  30
  31 #undef DBGC_CLASS
  32 #define DBGC_CLASS DBGC_RPC_SRV
  33
  34 /*******************************************************************
  35  api_reg_close
  36  ********************************************************************/
  37
  38 static BOOL api_reg_close(pipes_struct *p)
  39 {
  40         REG_Q_CLOSE q_u;
  41         REG_R_CLOSE r_u;
  42         prs_struct *data = &p->in_data.data;
  43         prs_struct *rdata = &p->out_data.rdata;
  44
  45         ZERO_STRUCT(q_u);
  46         ZERO_STRUCT(r_u);
  47
  48         /* grab the reg unknown 1 */
  49         if(!reg_io_q_close("", &q_u, data, 0))
  50                 return False;
  51
  52         r_u.status = _reg_close(p, &q_u, &r_u);
  53
  54         if(!reg_io_r_close("", &r_u, rdata, 0))
  55                 return False;
  56
  57         return True;
  58 }
  59
  60 /*******************************************************************
  61  api_reg_open_khlm
  62  ********************************************************************/
  63
  64 static BOOL api_reg_open_hklm(pipes_struct *p)
  65 {
  66         REG_Q_OPEN_HIVE q_u;
  67         REG_R_OPEN_HIVE r_u;
  68         prs_struct *data = &p->in_data.data;
  69         prs_struct *rdata = &p->out_data.rdata;
  70
  71         ZERO_STRUCT(q_u);
  72         ZERO_STRUCT(r_u);
  73
  74         /* grab the reg open */
  75         if(!reg_io_q_open_hive("", &q_u, data, 0))
  76                 return False;
  77
  78         r_u.status = _reg_open_hklm(p, &q_u, &r_u);
  79
  80         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
  81                 return False;
  82
  83         return True;
  84 }
  85
  86 /*******************************************************************
  87  api_reg_open_khu
  88  ********************************************************************/
  89
  90 static BOOL api_reg_open_hku(pipes_struct *p)
  91 {
  92         REG_Q_OPEN_HIVE q_u;
  93         REG_R_OPEN_HIVE r_u;
  94         prs_struct *data = &p->in_data.data;
  95         prs_struct *rdata = &p->out_data.rdata;
  96
  97         ZERO_STRUCT(q_u);
  98         ZERO_STRUCT(r_u);
  99
 100         /* grab the reg open */
 101         if(!reg_io_q_open_hive("", &q_u, data, 0))
 102                 return False;
 103
 104         r_u.status = _reg_open_hku(p, &q_u, &r_u);
 105
 106         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
 107                 return False;
 108
 109         return True;
 110 }
 111
 112 /*******************************************************************
 113  api_reg_open_khcr
 114  ********************************************************************/
 115
 116 static BOOL api_reg_open_hkcr(pipes_struct *p)
 117 {
 118         REG_Q_OPEN_HIVE q_u;
 119         REG_R_OPEN_HIVE r_u;
 120         prs_struct *data = &p->in_data.data;
 121         prs_struct *rdata = &p->out_data.rdata;
 122
 123         ZERO_STRUCT(q_u);
 124         ZERO_STRUCT(r_u);
 125
 126         /* grab the reg open */
 127         if(!reg_io_q_open_hive("", &q_u, data, 0))
 128                 return False;
 129
 130         r_u.status = _reg_open_hkcr(p, &q_u, &r_u);
 131
 132         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
 133                 return False;
 134
 135         return True;
 136 }
 137
 138
 139 /*******************************************************************
 140  api_reg_open_entry
 141  ********************************************************************/
 142
 143 static BOOL api_reg_open_entry(pipes_struct *p)
 144 {
 145         REG_Q_OPEN_ENTRY q_u;
 146         REG_R_OPEN_ENTRY r_u;
 147         prs_struct *data = &p->in_data.data;
 148         prs_struct *rdata = &p->out_data.rdata;
 149
 150         ZERO_STRUCT(q_u);
 151         ZERO_STRUCT(r_u);
 152
 153         /* grab the reg open entry */
 154         if(!reg_io_q_open_entry("", &q_u, data, 0))
 155                 return False;
 156
 157         /* construct reply. */
 158         r_u.status = _reg_open_entry(p, &q_u, &r_u);
 159
 160         if(!reg_io_r_open_entry("", &r_u, rdata, 0))
 161                 return False;
 162
 163         return True;
 164 }
 165
 166 /*******************************************************************
 167  api_reg_info
 168  ********************************************************************/
 169
 170 static BOOL api_reg_info(pipes_struct *p)
 171 {
 172         REG_Q_INFO q_u;
 173         REG_R_INFO r_u;
 174         prs_struct *data = &p->in_data.data;
 175         prs_struct *rdata = &p->out_data.rdata;
 176
 177         ZERO_STRUCT(q_u);
 178         ZERO_STRUCT(r_u);
 179
 180         /* grab the reg unknown 0x11*/
 181         if(!reg_io_q_info("", &q_u, data, 0))
 182                 return False;
 183
 184         r_u.status = _reg_info(p, &q_u, &r_u);
 185
 186         if(!reg_io_r_info("", &r_u, rdata, 0))
 187                 return False;
 188
 189         return True;
 190 }
 191
 192 /*******************************************************************
 193  api_reg_shutdown
 194  ********************************************************************/
 195
 196 static BOOL api_reg_shutdown(pipes_struct *p)
 197 {
 198         REG_Q_SHUTDOWN q_u;
 199         REG_R_SHUTDOWN r_u;
 200         prs_struct *data = &p->in_data.data;
 201         prs_struct *rdata = &p->out_data.rdata;
 202
 203         ZERO_STRUCT(q_u);
 204         ZERO_STRUCT(r_u);
 205
 206         /* grab the reg shutdown */
 207         if(!reg_io_q_shutdown("", &q_u, data, 0))
 208                 return False;
 209
 210         r_u.status = _reg_shutdown(p, &q_u, &r_u);
 211
 212         if(!reg_io_r_shutdown("", &r_u, rdata, 0))
 213                 return False;
 214
 215         return True;
 216 }
 217
 218 /*******************************************************************
 219  api_reg_shutdown_ex
 220  ********************************************************************/
 221
 222 static BOOL api_reg_shutdown_ex(pipes_struct *p)
 223 {
 224         REG_Q_SHUTDOWN_EX q_u;
 225         REG_R_SHUTDOWN_EX r_u;
 226         prs_struct *data = &p->in_data.data;
 227         prs_struct *rdata = &p->out_data.rdata;
 228
 229         ZERO_STRUCT(q_u);
 230         ZERO_STRUCT(r_u);
 231
 232         /* grab the reg shutdown ex */
 233         if(!reg_io_q_shutdown_ex("", &q_u, data, 0))
 234                 return False;
 235
 236         r_u.status = _reg_shutdown_ex(p, &q_u, &r_u);
 237
 238         if(!reg_io_r_shutdown_ex("", &r_u, rdata, 0))
 239                 return False;
 240
 241         return True;
 242 }
 243
 244 /*******************************************************************
 245  api_reg_abort_shutdown
 246  ********************************************************************/
 247
 248 static BOOL api_reg_abort_shutdown(pipes_struct *p)
 249 {
 250         REG_Q_ABORT_SHUTDOWN q_u;
 251         REG_R_ABORT_SHUTDOWN r_u;
 252         prs_struct *data = &p->in_data.data;
 253         prs_struct *rdata = &p->out_data.rdata;
 254
 255         ZERO_STRUCT(q_u);
 256         ZERO_STRUCT(r_u);
 257
 258         /* grab the reg shutdown */
 259         if(!reg_io_q_abort_shutdown("", &q_u, data, 0))
 260                 return False;
 261
 262         r_u.status = _reg_abort_shutdown(p, &q_u, &r_u);
 263
 264         if(!reg_io_r_abort_shutdown("", &r_u, rdata, 0))
 265                 return False;
 266
 267         return True;
 268 }
 269
 270
 271 /*******************************************************************
 272  api_reg_query_key
 273  ********************************************************************/
 274
 275 static BOOL api_reg_query_key(pipes_struct *p)
 276 {
 277         REG_Q_QUERY_KEY q_u;
 278         REG_R_QUERY_KEY r_u;
 279         prs_struct *data = &p->in_data.data;
 280         prs_struct *rdata = &p->out_data.rdata;
 281
 282         ZERO_STRUCT(q_u);
 283         ZERO_STRUCT(r_u);
 284
 285         if(!reg_io_q_query_key("", &q_u, data, 0))
 286                 return False;
 287
 288         r_u.status = _reg_query_key(p, &q_u, &r_u);
 289
 290         if(!reg_io_r_query_key("", &r_u, rdata, 0))
 291                 return False;
 292
 293         return True;
 294 }
 295
 296 /*******************************************************************
 297  api_reg_getversion
 298  ********************************************************************/
 299
 300 static BOOL api_reg_getversion(pipes_struct *p)
 301 {
 302         REG_Q_GETVERSION q_u;
 303         REG_R_GETVERSION r_u;
 304         prs_struct *data = &p->in_data.data;
 305         prs_struct *rdata = &p->out_data.rdata;
 306
 307         ZERO_STRUCT(q_u);
 308         ZERO_STRUCT(r_u);
 309
 310         if(!reg_io_q_getversion("", &q_u, data, 0))
 311                 return False;
 312
 313         r_u.status = _reg_getversion(p, &q_u, &r_u);
 314
 315         if(!reg_io_r_getversion("", &r_u, rdata, 0))
 316                 return False;
 317
 318         return True;
 319 }
 320
 321 /*******************************************************************
 322  api_reg_enum_key
 323  ********************************************************************/
 324
 325 static BOOL api_reg_enum_key(pipes_struct *p)
 326 {
 327         REG_Q_ENUM_KEY q_u;
 328         REG_R_ENUM_KEY r_u;
 329         prs_struct *data = &p->in_data.data;
 330         prs_struct *rdata = &p->out_data.rdata;
 331
 332         ZERO_STRUCT(q_u);
 333         ZERO_STRUCT(r_u);
 334
 335         if(!reg_io_q_enum_key("", &q_u, data, 0))
 336                 return False;
 337
 338         r_u.status = _reg_enum_key(p, &q_u, &r_u);
 339
 340         if(!reg_io_r_enum_key("", &r_u, rdata, 0))
 341                 return False;
 342
 343         return True;
 344 }
 345
 346 /*******************************************************************
 347  api_reg_enum_value
 348  ********************************************************************/
 349
 350 static BOOL api_reg_enum_value(pipes_struct *p)
 351 {
 352         REG_Q_ENUM_VALUE q_u;
 353         REG_R_ENUM_VALUE r_u;
 354         prs_struct *data = &p->in_data.data;
 355         prs_struct *rdata = &p->out_data.rdata;
 356
 357         ZERO_STRUCT(q_u);
 358         ZERO_STRUCT(r_u);
 359
 360         if(!reg_io_q_enum_val("", &q_u, data, 0))
 361                 return False;
 362
 363         r_u.status = _reg_enum_value(p, &q_u, &r_u);
 364
 365         if(!reg_io_r_enum_val("", &r_u, rdata, 0))
 366                 return False;
 367
 368         return True;
 369 }
 370
 371 /*******************************************************************
 372  ******************************************************************/
 373
 374 static BOOL api_reg_restore_key(pipes_struct *p)
 375 {
 376         REG_Q_RESTORE_KEY q_u;
 377         REG_R_RESTORE_KEY r_u;
 378         prs_struct *data = &p->in_data.data;
 379         prs_struct *rdata = &p->out_data.rdata;
 380
 381         ZERO_STRUCT(q_u);
 382         ZERO_STRUCT(r_u);
 383
 384         if(!reg_io_q_restore_key("", &q_u, data, 0))
 385                 return False;
 386
 387         r_u.status = _reg_restore_key(p, &q_u, &r_u);
 388
 389         if(!reg_io_r_restore_key("", &r_u, rdata, 0))
 390                 return False;
 391
 392         return True;
 393 }
 394
 395 /*******************************************************************
 396  ******************************************************************/
 397
 398 static BOOL api_reg_save_key(pipes_struct *p)
 399 {
 400         REG_Q_SAVE_KEY q_u;
 401         REG_R_SAVE_KEY r_u;
 402         prs_struct *data = &p->in_data.data;
 403         prs_struct *rdata = &p->out_data.rdata;
 404
 405         ZERO_STRUCT(q_u);
 406         ZERO_STRUCT(r_u);
 407
 408         if(!reg_io_q_save_key("", &q_u, data, 0))
 409                 return False;
 410
 411         r_u.status = _reg_save_key(p, &q_u, &r_u);
 412
 413         if(!reg_io_r_save_key("", &r_u, rdata, 0))
 414                 return False;
 415
 416         return True;
 417 }
 418
 419 /*******************************************************************
 420  ******************************************************************/
 421
 422 static BOOL api_reg_create_key(pipes_struct *p)
 423 {
 424         REG_Q_CREATE_KEY q_u;
 425         REG_R_CREATE_KEY r_u;
 426         prs_struct *data = &p->in_data.data;
 427         prs_struct *rdata = &p->out_data.rdata;
 428
 429         ZERO_STRUCT(q_u);
 430         ZERO_STRUCT(r_u);
 431
 432         if(!reg_io_q_create_key("", &q_u, data, 0))
 433                 return False;
 434
 435         r_u.status = _reg_create_key(p, &q_u, &r_u);
 436
 437         if(!reg_io_r_create_key("", &r_u, rdata, 0))
 438                 return False;
 439
 440         return True;
 441 }
 442
 443 /*******************************************************************
 444  ******************************************************************/
 445
 446 static BOOL api_reg_set_value(pipes_struct *p)
 447 {
 448         REG_Q_SET_VALUE q_u;
 449         REG_R_SET_VALUE r_u;
 450         prs_struct *data = &p->in_data.data;
 451         prs_struct *rdata = &p->out_data.rdata;
 452
 453         ZERO_STRUCT(q_u);
 454         ZERO_STRUCT(r_u);
 455
 456         if(!reg_io_q_set_value("", &q_u, data, 0))
 457                 return False;
 458
 459         r_u.status = _reg_set_value(p, &q_u, &r_u);
 460
 461         if(!reg_io_r_set_value("", &r_u, rdata, 0))
 462                 return False;
 463
 464         return True;
 465 }
 466
 467 /*******************************************************************
 468  ******************************************************************/
 469
 470 static BOOL api_reg_delete_key(pipes_struct *p)
 471 {
 472         REG_Q_DELETE_KEY q_u;
 473         REG_R_DELETE_KEY r_u;
 474         prs_struct *data = &p->in_data.data;
 475         prs_struct *rdata = &p->out_data.rdata;
 476
 477         ZERO_STRUCT(q_u);
 478         ZERO_STRUCT(r_u);
 479
 480         if(!reg_io_q_delete_key("", &q_u, data, 0))
 481                 return False;
 482
 483         r_u.status = _reg_delete_key(p, &q_u, &r_u);
 484
 485         if(!reg_io_r_delete_key("", &r_u, rdata, 0))
 486                 return False;
 487
 488         return True;
 489 }
 490
 491 /*******************************************************************
 492  ******************************************************************/
 493
 494 static BOOL api_reg_delete_value(pipes_struct *p)
 495 {
 496         REG_Q_DELETE_VALUE q_u;
 497         REG_R_DELETE_VALUE r_u;
 498         prs_struct *data = &p->in_data.data;
 499         prs_struct *rdata = &p->out_data.rdata;
 500
 501         ZERO_STRUCT(q_u);
 502         ZERO_STRUCT(r_u);
 503
 504         if(!reg_io_q_delete_value("", &q_u, data, 0))
 505                 return False;
 506
 507         r_u.status = _reg_delete_value(p, &q_u, &r_u);
 508
 509         if(!reg_io_r_delete_value("", &r_u, rdata, 0))
 510                 return False;
 511
 512         return True;
 513 }
 514
 515 /*******************************************************************
 516  array of \PIPE\reg operations
 517  ********************************************************************/
 518
 519 static struct api_struct api_reg_cmds[] =
 520 {
 521       { "REG_CLOSE"              , REG_CLOSE              , api_reg_close            },
 522       { "REG_OPEN_ENTRY"         , REG_OPEN_ENTRY         , api_reg_open_entry       },
 523       { "REG_OPEN_HKCR"          , REG_OPEN_HKCR          , api_reg_open_hkcr        },
 524       { "REG_OPEN_HKLM"          , REG_OPEN_HKLM          , api_reg_open_hklm        },
 525       { "REG_OPEN_HKU"           , REG_OPEN_HKU           , api_reg_open_hku         },
 526       { "REG_ENUM_KEY"           , REG_ENUM_KEY           , api_reg_enum_key         },
 527       { "REG_ENUM_VALUE"         , REG_ENUM_VALUE         , api_reg_enum_value       },
 528       { "REG_QUERY_KEY"          , REG_QUERY_KEY          , api_reg_query_key        },
 529       { "REG_INFO"               , REG_INFO               , api_reg_info             },
 530       { "REG_SHUTDOWN"           , REG_SHUTDOWN           , api_reg_shutdown         },
 531       { "REG_SHUTDOWN_EX"        , REG_SHUTDOWN_EX        , api_reg_shutdown_ex      },
 532       { "REG_ABORT_SHUTDOWN"     , REG_ABORT_SHUTDOWN     , api_reg_abort_shutdown   },
 533       { "REG_GETVERSION"         , REG_GETVERSION         , api_reg_getversion       },
 534       { "REG_SAVE_KEY"           , REG_SAVE_KEY           , api_reg_save_key         },
 535       { "REG_RESTORE_KEY"        , REG_RESTORE_KEY        , api_reg_restore_key      },
 536       { "REG_CREATE_KEY"         , REG_CREATE_KEY         , api_reg_create_key       },
 537       { "REG_SET_VALUE"          , REG_SET_VALUE          , api_reg_set_value        },
 538       { "REG_DELETE_KEY"         , REG_DELETE_KEY         , api_reg_delete_key       },
 539       { "REG_DELETE_VALUE"       , REG_DELETE_VALUE       , api_reg_delete_value     }
 540 };
 541
 542 void reg_get_pipe_fns( struct api_struct **fns, int *n_fns )
 543 {
 544         *fns = api_reg_cmds;
 545         *n_fns = sizeof(api_reg_cmds) / sizeof(struct api_struct);
 546 }
 547
 548 NTSTATUS rpc_reg_init(void)
 549 {
 550
 551   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", api_reg_cmds,
 552                                     sizeof(api_reg_cmds) / sizeof(struct api_struct));
 553 }