Samba: rpc_server/srv_reg.c ソースファイル

00001 /*
00002  *  Unix SMB/CIFS implementation.
00003  *  RPC Pipe client / server routines
00004  *  Copyright (C) Andrew Tridgell              1992-1997,
00005  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
00006  *  Copyright (C) Paul Ashton                       1997,
00007  *  Copyright (C) Marc Jacobsen                     2000,
00008  *  Copyright (C) Jeremy Allison                    2001,
00009  *  Copyright (C) Gerald Carter                     2002,
00010  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2003.
00011  *
00012  *  This program is free software; you can redistribute it and/or modify
00013  *  it under the terms of the GNU General Public License as published by
00014  *  the Free Software Foundation; either version 2 of the License, or
00015  *  (at your option) any later version.
00016  *  
00017  *  This program is distributed in the hope that it will be useful,
00018  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00019  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020  *  GNU General Public License for more details.
00021  *  
00022  *  You should have received a copy of the GNU General Public License
00023  *  along with this program; if not, write to the Free Software
00024  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00025  */
00026 
00027 /* This is the interface for the registry functions. */
00028 
00029 #include "includes.h"
00030 
00031 #undef DBGC_CLASS
00032 #define DBGC_CLASS DBGC_RPC_SRV
00033 
00034 /*******************************************************************
00035  api_reg_close
00036  ********************************************************************/
00037 
00038 static BOOL api_reg_close(pipes_struct *p)
00039 {
00040         REG_Q_CLOSE q_u;
00041         REG_R_CLOSE r_u;
00042         prs_struct *data = &p->in_data.data;
00043         prs_struct *rdata = &p->out_data.rdata;
00044 
00045         ZERO_STRUCT(q_u);
00046         ZERO_STRUCT(r_u);
00047 
00048         /* grab the reg unknown 1 */
00049         if(!reg_io_q_close("", &q_u, data, 0))
00050                 return False;
00051 
00052         r_u.status = _reg_close(p, &q_u, &r_u);
00053 
00054         if(!reg_io_r_close("", &r_u, rdata, 0))
00055                 return False;
00056 
00057         return True;
00058 }
00059 
00060 /*******************************************************************
00061  api_reg_open_khlm
00062  ********************************************************************/
00063 
00064 static BOOL api_reg_open_hklm(pipes_struct *p)
00065 {
00066         REG_Q_OPEN_HIVE q_u;
00067         REG_R_OPEN_HIVE r_u;
00068         prs_struct *data = &p->in_data.data;
00069         prs_struct *rdata = &p->out_data.rdata;
00070 
00071         ZERO_STRUCT(q_u);
00072         ZERO_STRUCT(r_u);
00073 
00074         /* grab the reg open */
00075         if(!reg_io_q_open_hive("", &q_u, data, 0))
00076                 return False;
00077 
00078         r_u.status = _reg_open_hklm(p, &q_u, &r_u);
00079 
00080         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
00081                 return False;
00082 
00083         return True;
00084 }
00085 
00086 /*******************************************************************
00087  api_reg_open_khu
00088  ********************************************************************/
00089 
00090 static BOOL api_reg_open_hku(pipes_struct *p)
00091 {
00092         REG_Q_OPEN_HIVE q_u;
00093         REG_R_OPEN_HIVE r_u;
00094         prs_struct *data = &p->in_data.data;
00095         prs_struct *rdata = &p->out_data.rdata;
00096 
00097         ZERO_STRUCT(q_u);
00098         ZERO_STRUCT(r_u);
00099 
00100         /* grab the reg open */
00101         if(!reg_io_q_open_hive("", &q_u, data, 0))
00102                 return False;
00103 
00104         r_u.status = _reg_open_hku(p, &q_u, &r_u);
00105 
00106         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
00107                 return False;
00108 
00109         return True;
00110 }
00111 
00112 /*******************************************************************
00113  api_reg_open_khcr
00114  ********************************************************************/
00115 
00116 static BOOL api_reg_open_hkcr(pipes_struct *p)
00117 {
00118         REG_Q_OPEN_HIVE q_u;
00119         REG_R_OPEN_HIVE r_u;
00120         prs_struct *data = &p->in_data.data;
00121         prs_struct *rdata = &p->out_data.rdata;
00122 
00123         ZERO_STRUCT(q_u);
00124         ZERO_STRUCT(r_u);
00125 
00126         /* grab the reg open */
00127         if(!reg_io_q_open_hive("", &q_u, data, 0))
00128                 return False;
00129 
00130         r_u.status = _reg_open_hkcr(p, &q_u, &r_u);
00131 
00132         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
00133                 return False;
00134 
00135         return True;
00136 }
00137 
00138 
00139 /*******************************************************************
00140  api_reg_open_entry
00141  ********************************************************************/
00142 
00143 static BOOL api_reg_open_entry(pipes_struct *p)
00144 {
00145         REG_Q_OPEN_ENTRY q_u;
00146         REG_R_OPEN_ENTRY r_u;
00147         prs_struct *data = &p->in_data.data;
00148         prs_struct *rdata = &p->out_data.rdata;
00149 
00150         ZERO_STRUCT(q_u);
00151         ZERO_STRUCT(r_u);
00152 
00153         /* grab the reg open entry */
00154         if(!reg_io_q_open_entry("", &q_u, data, 0))
00155                 return False;
00156 
00157         /* construct reply. */
00158         r_u.status = _reg_open_entry(p, &q_u, &r_u);
00159 
00160         if(!reg_io_r_open_entry("", &r_u, rdata, 0))
00161                 return False;
00162 
00163         return True;
00164 }
00165 
00166 /*******************************************************************
00167  api_reg_query_value
00168  ********************************************************************/
00169 
00170 static BOOL api_reg_query_value(pipes_struct *p)
00171 {
00172         REG_Q_QUERY_VALUE q_u;
00173         REG_R_QUERY_VALUE r_u;
00174         prs_struct *data = &p->in_data.data;
00175         prs_struct *rdata = &p->out_data.rdata;
00176 
00177         ZERO_STRUCT(q_u);
00178         ZERO_STRUCT(r_u);
00179 
00180         /* grab the reg unknown 0x11*/
00181         if(!reg_io_q_query_value("", &q_u, data, 0))
00182                 return False;
00183 
00184         r_u.status = _reg_query_value(p, &q_u, &r_u);
00185 
00186         if(!reg_io_r_query_value("", &r_u, rdata, 0))
00187                 return False;
00188 
00189         return True;
00190 }
00191 
00192 /*******************************************************************
00193  api_reg_shutdown
00194  ********************************************************************/
00195 
00196 static BOOL api_reg_shutdown(pipes_struct *p)
00197 {
00198         REG_Q_SHUTDOWN q_u;
00199         REG_R_SHUTDOWN r_u;
00200         prs_struct *data = &p->in_data.data;
00201         prs_struct *rdata = &p->out_data.rdata;
00202 
00203         ZERO_STRUCT(q_u);
00204         ZERO_STRUCT(r_u);
00205 
00206         /* grab the reg shutdown */
00207         if(!reg_io_q_shutdown("", &q_u, data, 0))
00208                 return False;
00209 
00210         r_u.status = _reg_shutdown(p, &q_u, &r_u);
00211 
00212         if(!reg_io_r_shutdown("", &r_u, rdata, 0))
00213                 return False;
00214 
00215         return True;
00216 }
00217 
00218 /*******************************************************************
00219  api_reg_shutdown_ex
00220  ********************************************************************/
00221 
00222 static BOOL api_reg_shutdown_ex(pipes_struct *p)
00223 {
00224         REG_Q_SHUTDOWN_EX q_u;
00225         REG_R_SHUTDOWN_EX r_u;
00226         prs_struct *data = &p->in_data.data;
00227         prs_struct *rdata = &p->out_data.rdata;
00228 
00229         ZERO_STRUCT(q_u);
00230         ZERO_STRUCT(r_u);
00231 
00232         /* grab the reg shutdown ex */
00233         if(!reg_io_q_shutdown_ex("", &q_u, data, 0))
00234                 return False;
00235 
00236         r_u.status = _reg_shutdown_ex(p, &q_u, &r_u);
00237 
00238         if(!reg_io_r_shutdown_ex("", &r_u, rdata, 0))
00239                 return False;
00240 
00241         return True;
00242 }
00243 
00244 /*******************************************************************
00245  api_reg_abort_shutdown
00246  ********************************************************************/
00247 
00248 static BOOL api_reg_abort_shutdown(pipes_struct *p)
00249 {
00250         REG_Q_ABORT_SHUTDOWN q_u;
00251         REG_R_ABORT_SHUTDOWN r_u;
00252         prs_struct *data = &p->in_data.data;
00253         prs_struct *rdata = &p->out_data.rdata;
00254 
00255         ZERO_STRUCT(q_u);
00256         ZERO_STRUCT(r_u);
00257 
00258         /* grab the reg shutdown */
00259         if(!reg_io_q_abort_shutdown("", &q_u, data, 0))
00260                 return False;
00261 
00262         r_u.status = _reg_abort_shutdown(p, &q_u, &r_u);
00263 
00264         if(!reg_io_r_abort_shutdown("", &r_u, rdata, 0))
00265                 return False;
00266 
00267         return True;
00268 }
00269 
00270 
00271 /*******************************************************************
00272  api_reg_query_key
00273  ********************************************************************/
00274 
00275 static BOOL api_reg_query_key(pipes_struct *p)
00276 {
00277         REG_Q_QUERY_KEY q_u;
00278         REG_R_QUERY_KEY r_u;
00279         prs_struct *data = &p->in_data.data;
00280         prs_struct *rdata = &p->out_data.rdata;
00281 
00282         ZERO_STRUCT(q_u);
00283         ZERO_STRUCT(r_u);
00284 
00285         if(!reg_io_q_query_key("", &q_u, data, 0))
00286                 return False;
00287 
00288         r_u.status = _reg_query_key(p, &q_u, &r_u);
00289 
00290         if(!reg_io_r_query_key("", &r_u, rdata, 0))
00291                 return False;
00292 
00293         return True;
00294 }
00295 
00296 /*******************************************************************
00297  api_reg_getversion
00298  ********************************************************************/
00299 
00300 static BOOL api_reg_getversion(pipes_struct *p)
00301 {
00302         REG_Q_GETVERSION q_u;
00303         REG_R_GETVERSION r_u;
00304         prs_struct *data = &p->in_data.data;
00305         prs_struct *rdata = &p->out_data.rdata;
00306 
00307         ZERO_STRUCT(q_u);
00308         ZERO_STRUCT(r_u);
00309 
00310         if(!reg_io_q_getversion("", &q_u, data, 0))
00311                 return False;
00312 
00313         r_u.status = _reg_getversion(p, &q_u, &r_u);
00314 
00315         if(!reg_io_r_getversion("", &r_u, rdata, 0))
00316                 return False;
00317 
00318         return True;
00319 }
00320 
00321 /*******************************************************************
00322  api_reg_enum_key
00323  ********************************************************************/
00324 
00325 static BOOL api_reg_enum_key(pipes_struct *p)
00326 {
00327         REG_Q_ENUM_KEY q_u;
00328         REG_R_ENUM_KEY r_u;
00329         prs_struct *data = &p->in_data.data;
00330         prs_struct *rdata = &p->out_data.rdata;
00331 
00332         ZERO_STRUCT(q_u);
00333         ZERO_STRUCT(r_u);
00334 
00335         if(!reg_io_q_enum_key("", &q_u, data, 0))
00336                 return False;
00337 
00338         r_u.status = _reg_enum_key(p, &q_u, &r_u);
00339 
00340         if(!reg_io_r_enum_key("", &r_u, rdata, 0))
00341                 return False;
00342 
00343         return True;
00344 }
00345 
00346 /*******************************************************************
00347  api_reg_enum_value
00348  ********************************************************************/
00349 
00350 static BOOL api_reg_enum_value(pipes_struct *p)
00351 {
00352         REG_Q_ENUM_VALUE q_u;
00353         REG_R_ENUM_VALUE r_u;
00354         prs_struct *data = &p->in_data.data;
00355         prs_struct *rdata = &p->out_data.rdata;
00356 
00357         ZERO_STRUCT(q_u);
00358         ZERO_STRUCT(r_u);
00359 
00360         if(!reg_io_q_enum_val("", &q_u, data, 0))
00361                 return False;
00362                 
00363         r_u.status = _reg_enum_value(p, &q_u, &r_u);
00364 
00365         if(!reg_io_r_enum_val("", &r_u, rdata, 0))
00366                 return False;
00367 
00368         return True;
00369 }
00370 
00371 /*******************************************************************
00372  ******************************************************************/
00373 
00374 static BOOL api_reg_restore_key(pipes_struct *p)
00375 {
00376         REG_Q_RESTORE_KEY q_u;
00377         REG_R_RESTORE_KEY r_u;
00378         prs_struct *data = &p->in_data.data;
00379         prs_struct *rdata = &p->out_data.rdata;
00380 
00381         ZERO_STRUCT(q_u);
00382         ZERO_STRUCT(r_u);
00383 
00384         if(!reg_io_q_restore_key("", &q_u, data, 0))
00385                 return False;
00386 
00387         r_u.status = _reg_restore_key(p, &q_u, &r_u);
00388 
00389         if(!reg_io_r_restore_key("", &r_u, rdata, 0))
00390                 return False;
00391 
00392         return True;
00393 }
00394 
00395 /*******************************************************************
00396  ********************************************************************/
00397 
00398 static BOOL api_reg_save_key(pipes_struct *p)
00399 {
00400         REG_Q_SAVE_KEY q_u;
00401         REG_R_SAVE_KEY r_u;
00402         prs_struct *data = &p->in_data.data;
00403         prs_struct *rdata = &p->out_data.rdata;
00404 
00405         ZERO_STRUCT(q_u);
00406         ZERO_STRUCT(r_u);
00407 
00408         if(!reg_io_q_save_key("", &q_u, data, 0))
00409                 return False;
00410                 
00411         r_u.status = _reg_save_key(p, &q_u, &r_u);
00412 
00413         if(!reg_io_r_save_key("", &r_u, rdata, 0))
00414                 return False;
00415 
00416         return True;
00417 }
00418 
00419 /*******************************************************************
00420  api_reg_open_hkpd
00421  ********************************************************************/
00422 
00423 static BOOL api_reg_open_hkpd(pipes_struct *p)
00424 {
00425         REG_Q_OPEN_HIVE q_u;
00426         REG_R_OPEN_HIVE r_u;
00427         prs_struct *data = &p->in_data.data;
00428         prs_struct *rdata = &p->out_data.rdata;
00429 
00430         ZERO_STRUCT(q_u);
00431         ZERO_STRUCT(r_u);
00432 
00433         /* grab the reg open */
00434         if(!reg_io_q_open_hive("", &q_u, data, 0))
00435                 return False;
00436 
00437         r_u.status = _reg_open_hkpd(p, &q_u, &r_u);
00438 
00439         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
00440                 return False;
00441 
00442         return True;
00443 }
00444 
00445 /*******************************************************************
00446  api_reg_open_hkpd
00447  ********************************************************************/
00448 static BOOL api_reg_open_hkpt(pipes_struct *p)
00449 {
00450         REG_Q_OPEN_HIVE q_u;
00451         REG_R_OPEN_HIVE r_u;
00452         prs_struct *data = &p->in_data.data;
00453         prs_struct *rdata = &p->out_data.rdata;
00454 
00455         ZERO_STRUCT(q_u);
00456         ZERO_STRUCT(r_u);
00457 
00458         /* grab the reg open */
00459         if(!reg_io_q_open_hive("", &q_u, data, 0))
00460                 return False;
00461 
00462         r_u.status = _reg_open_hkpt(p, &q_u, &r_u);
00463 
00464         if(!reg_io_r_open_hive("", &r_u, rdata, 0))
00465                 return False;
00466 
00467         return True;
00468 }
00469 
00470 /*******************************************************************
00471  ******************************************************************/
00472 
00473 static BOOL api_reg_create_key_ex(pipes_struct *p)
00474 {
00475         REG_Q_CREATE_KEY_EX q_u;
00476         REG_R_CREATE_KEY_EX r_u;
00477         prs_struct *data = &p->in_data.data;
00478         prs_struct *rdata = &p->out_data.rdata;
00479 
00480         ZERO_STRUCT(q_u);
00481         ZERO_STRUCT(r_u);
00482 
00483         if(!reg_io_q_create_key_ex("", &q_u, data, 0))
00484                 return False;
00485                 
00486         r_u.status = _reg_create_key_ex(p, &q_u, &r_u);
00487 
00488         if(!reg_io_r_create_key_ex("", &r_u, rdata, 0))
00489                 return False;
00490 
00491         return True;
00492 }
00493 
00494 /*******************************************************************
00495  ******************************************************************/
00496 
00497 static BOOL api_reg_set_value(pipes_struct *p)
00498 {
00499         REG_Q_SET_VALUE q_u;
00500         REG_R_SET_VALUE r_u;
00501         prs_struct *data = &p->in_data.data;
00502         prs_struct *rdata = &p->out_data.rdata;
00503 
00504         ZERO_STRUCT(q_u);
00505         ZERO_STRUCT(r_u);
00506 
00507         if(!reg_io_q_set_value("", &q_u, data, 0))
00508                 return False;
00509                 
00510         r_u.status = _reg_set_value(p, &q_u, &r_u);
00511 
00512         if(!reg_io_r_set_value("", &r_u, rdata, 0))
00513                 return False;
00514 
00515         return True;
00516 }
00517 
00518 /*******************************************************************
00519  ******************************************************************/
00520 
00521 static BOOL api_reg_delete_key(pipes_struct *p)
00522 {
00523         REG_Q_DELETE_KEY q_u;
00524         REG_R_DELETE_KEY r_u;
00525         prs_struct *data = &p->in_data.data;
00526         prs_struct *rdata = &p->out_data.rdata;
00527 
00528         ZERO_STRUCT(q_u);
00529         ZERO_STRUCT(r_u);
00530 
00531         if(!reg_io_q_delete_key("", &q_u, data, 0))
00532                 return False;
00533                 
00534         r_u.status = _reg_delete_key(p, &q_u, &r_u);
00535 
00536         if(!reg_io_r_delete_key("", &r_u, rdata, 0))
00537                 return False;
00538 
00539         return True;
00540 }
00541 
00542 /*******************************************************************
00543  ******************************************************************/
00544 
00545 static BOOL api_reg_delete_value(pipes_struct *p)
00546 {
00547         REG_Q_DELETE_VALUE q_u;
00548         REG_R_DELETE_VALUE r_u;
00549         prs_struct *data = &p->in_data.data;
00550         prs_struct *rdata = &p->out_data.rdata;
00551 
00552         ZERO_STRUCT(q_u);
00553         ZERO_STRUCT(r_u);
00554 
00555         if(!reg_io_q_delete_value("", &q_u, data, 0))
00556                 return False;
00557                 
00558         r_u.status = _reg_delete_value(p, &q_u, &r_u);
00559 
00560         if(!reg_io_r_delete_value("", &r_u, rdata, 0))
00561                 return False;
00562 
00563         return True;
00564 }
00565 
00566 
00567 /*******************************************************************
00568  ******************************************************************/
00569 
00570 static BOOL api_reg_get_key_sec(pipes_struct *p)
00571 {
00572         REG_Q_GET_KEY_SEC q_u;
00573         REG_R_GET_KEY_SEC r_u;
00574         prs_struct *data = &p->in_data.data;
00575         prs_struct *rdata = &p->out_data.rdata;
00576 
00577         ZERO_STRUCT(q_u);
00578         ZERO_STRUCT(r_u);
00579 
00580         if(!reg_io_q_get_key_sec("", &q_u, data, 0))
00581                 return False;
00582                 
00583         r_u.status = _reg_get_key_sec(p, &q_u, &r_u);
00584 
00585         if(!reg_io_r_get_key_sec("", &r_u, rdata, 0))
00586                 return False;
00587 
00588         return True;
00589 }
00590 
00591 
00592 /*******************************************************************
00593  ******************************************************************/
00594 
00595 static BOOL api_reg_set_key_sec(pipes_struct *p)
00596 {
00597         REG_Q_SET_KEY_SEC q_u;
00598         REG_R_SET_KEY_SEC r_u;
00599         prs_struct *data = &p->in_data.data;
00600         prs_struct *rdata = &p->out_data.rdata;
00601 
00602         ZERO_STRUCT(q_u);
00603         ZERO_STRUCT(r_u);
00604 
00605         if(!reg_io_q_set_key_sec("", &q_u, data, 0))
00606                 return False;
00607                 
00608         r_u.status = _reg_set_key_sec(p, &q_u, &r_u);
00609 
00610         if(!reg_io_r_set_key_sec("", &r_u, rdata, 0))
00611                 return False;
00612 
00613         return True;
00614 }
00615 
00616 
00617 /*******************************************************************
00618  array of \PIPE\reg operations
00619  ********************************************************************/
00620 
00621 static struct api_struct api_reg_cmds[] =
00622 {
00623       { "REG_CLOSE"              , REG_CLOSE              , api_reg_close            },
00624       { "REG_OPEN_ENTRY"         , REG_OPEN_ENTRY         , api_reg_open_entry       },
00625       { "REG_OPEN_HKCR"          , REG_OPEN_HKCR          , api_reg_open_hkcr        },
00626       { "REG_OPEN_HKLM"          , REG_OPEN_HKLM          , api_reg_open_hklm        },
00627       { "REG_OPEN_HKPD"          , REG_OPEN_HKPD          , api_reg_open_hkpd        },
00628       { "REG_OPEN_HKPT"          , REG_OPEN_HKPT          , api_reg_open_hkpt        },
00629       { "REG_OPEN_HKU"           , REG_OPEN_HKU           , api_reg_open_hku         },
00630       { "REG_ENUM_KEY"           , REG_ENUM_KEY           , api_reg_enum_key         },
00631       { "REG_ENUM_VALUE"         , REG_ENUM_VALUE         , api_reg_enum_value       },
00632       { "REG_QUERY_KEY"          , REG_QUERY_KEY          , api_reg_query_key        },
00633       { "REG_QUERY_VALUE"        , REG_QUERY_VALUE        , api_reg_query_value      },
00634       { "REG_SHUTDOWN"           , REG_SHUTDOWN           , api_reg_shutdown         },
00635       { "REG_SHUTDOWN_EX"        , REG_SHUTDOWN_EX        , api_reg_shutdown_ex      },
00636       { "REG_ABORT_SHUTDOWN"     , REG_ABORT_SHUTDOWN     , api_reg_abort_shutdown   },
00637       { "REG_GETVERSION"         , REG_GETVERSION         , api_reg_getversion       },
00638       { "REG_SAVE_KEY"           , REG_SAVE_KEY           , api_reg_save_key         },
00639       { "REG_RESTORE_KEY"        , REG_RESTORE_KEY        , api_reg_restore_key      },
00640       { "REG_CREATE_KEY_EX"      , REG_CREATE_KEY_EX      , api_reg_create_key_ex    },
00641       { "REG_SET_VALUE"          , REG_SET_VALUE          , api_reg_set_value        },
00642       { "REG_DELETE_KEY"         , REG_DELETE_KEY         , api_reg_delete_key       },
00643       { "REG_DELETE_VALUE"       , REG_DELETE_VALUE       , api_reg_delete_value     },
00644       { "REG_GET_KEY_SEC"        , REG_GET_KEY_SEC        , api_reg_get_key_sec      },
00645       { "REG_SET_KEY_SEC"        , REG_SET_KEY_SEC        , api_reg_set_key_sec      }
00646 };
00647 
00648 void reg_get_pipe_fns( struct api_struct **fns, int *n_fns )
00649 {
00650         *fns = api_reg_cmds;
00651         *n_fns = sizeof(api_reg_cmds) / sizeof(struct api_struct);
00652 }
00653     
00654 NTSTATUS rpc_reg_init(void)
00655 {
00656 
00657   return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "winreg", "winreg", api_reg_cmds,
00658                                     sizeof(api_reg_cmds) / sizeof(struct api_struct));
00659 }