source3/rpc_server/srv_svcctl.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald Carter                   2005 - 2007
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21
  22 #undef DBGC_CLASS
  23 #define DBGC_CLASS DBGC_RPC_SRV
  24
  25 static bool proxy_svcctl_call(pipes_struct *p, uint8 opnum)
  26 {
  27         struct api_struct *fns;
  28         int n_fns;
  29
  30         svcctl_get_pipe_fns(&fns, &n_fns);
  31
  32         if (opnum >= n_fns)
  33                 return False;
  34
  35         if (fns[opnum].opnum != opnum) {
  36                 smb_panic("SVCCTL function table not sorted\n");
  37         }
  38
  39         return fns[opnum].fn(p);
  40 }
  41
  42
  43 /*******************************************************************
  44  ********************************************************************/
  45
  46 static bool api_svcctl_close_service(pipes_struct *p)
  47 {
  48         return proxy_svcctl_call( p, NDR_SVCCTL_CLOSESERVICEHANDLE );
  49 }
  50
  51 /*******************************************************************
  52  ********************************************************************/
  53
  54 static bool api_svcctl_open_scmanager(pipes_struct *p)
  55 {
  56         SVCCTL_Q_OPEN_SCMANAGER q_u;
  57         SVCCTL_R_OPEN_SCMANAGER r_u;
  58         prs_struct *data = &p->in_data.data;
  59         prs_struct *rdata = &p->out_data.rdata;
  60
  61         ZERO_STRUCT(q_u);
  62         ZERO_STRUCT(r_u);
  63
  64         if(!svcctl_io_q_open_scmanager("", &q_u, data, 0))
  65                 return False;
  66
  67         r_u.status = _svcctl_open_scmanager(p, &q_u, &r_u);
  68
  69         if(!svcctl_io_r_open_scmanager("", &r_u, rdata, 0))
  70                 return False;
  71
  72         return True;
  73 }
  74
  75 /*******************************************************************
  76  ********************************************************************/
  77
  78 static bool api_svcctl_open_service(pipes_struct *p)
  79 {
  80         SVCCTL_Q_OPEN_SERVICE q_u;
  81         SVCCTL_R_OPEN_SERVICE r_u;
  82         prs_struct *data = &p->in_data.data;
  83         prs_struct *rdata = &p->out_data.rdata;
  84
  85         ZERO_STRUCT(q_u);
  86         ZERO_STRUCT(r_u);
  87
  88         if(!svcctl_io_q_open_service("", &q_u, data, 0))
  89                 return False;
  90
  91         r_u.status = _svcctl_open_service(p, &q_u, &r_u);
  92
  93         if(!svcctl_io_r_open_service("", &r_u, rdata, 0))
  94                 return False;
  95
  96         return True;
  97 }
  98
  99 /*******************************************************************
 100  ********************************************************************/
 101
 102 static bool api_svcctl_get_display_name(pipes_struct *p)
 103 {
 104         SVCCTL_Q_GET_DISPLAY_NAME q_u;
 105         SVCCTL_R_GET_DISPLAY_NAME r_u;
 106         prs_struct *data = &p->in_data.data;
 107         prs_struct *rdata = &p->out_data.rdata;
 108
 109         ZERO_STRUCT(q_u);
 110         ZERO_STRUCT(r_u);
 111
 112         if(!svcctl_io_q_get_display_name("", &q_u, data, 0))
 113                 return False;
 114
 115         r_u.status = _svcctl_get_display_name(p, &q_u, &r_u);
 116
 117         if(!svcctl_io_r_get_display_name("", &r_u, rdata, 0))
 118                 return False;
 119
 120         return True;
 121 }
 122
 123 /*******************************************************************
 124  ********************************************************************/
 125
 126 static bool api_svcctl_query_status(pipes_struct *p)
 127 {
 128         SVCCTL_Q_QUERY_STATUS q_u;
 129         SVCCTL_R_QUERY_STATUS r_u;
 130         prs_struct *data = &p->in_data.data;
 131         prs_struct *rdata = &p->out_data.rdata;
 132
 133         ZERO_STRUCT(q_u);
 134         ZERO_STRUCT(r_u);
 135
 136         if(!svcctl_io_q_query_status("", &q_u, data, 0))
 137                 return False;
 138
 139         r_u.status = _svcctl_query_status(p, &q_u, &r_u);
 140
 141         if(!svcctl_io_r_query_status("", &r_u, rdata, 0))
 142                 return False;
 143
 144         return True;
 145 }
 146
 147 /*******************************************************************
 148  ********************************************************************/
 149
 150 static bool api_svcctl_enum_services_status(pipes_struct *p)
 151 {
 152         SVCCTL_Q_ENUM_SERVICES_STATUS q_u;
 153         SVCCTL_R_ENUM_SERVICES_STATUS r_u;
 154         prs_struct *data = &p->in_data.data;
 155         prs_struct *rdata = &p->out_data.rdata;
 156
 157         ZERO_STRUCT(q_u);
 158         ZERO_STRUCT(r_u);
 159
 160         if(!svcctl_io_q_enum_services_status("", &q_u, data, 0))
 161                 return False;
 162
 163         r_u.status = _svcctl_enum_services_status(p, &q_u, &r_u);
 164
 165         if(!svcctl_io_r_enum_services_status("", &r_u, rdata, 0))
 166                 return False;
 167
 168         return True;
 169 }
 170 /*******************************************************************
 171  ********************************************************************/
 172
 173 static bool api_svcctl_query_service_status_ex(pipes_struct *p)
 174 {
 175         SVCCTL_Q_QUERY_SERVICE_STATUSEX q_u;
 176         SVCCTL_R_QUERY_SERVICE_STATUSEX r_u;
 177         prs_struct *data = &p->in_data.data;
 178         prs_struct *rdata = &p->out_data.rdata;
 179
 180         ZERO_STRUCT(q_u);
 181         ZERO_STRUCT(r_u);
 182
 183         if(!svcctl_io_q_query_service_status_ex("", &q_u, data, 0))
 184                 return False;
 185
 186         r_u.status = _svcctl_query_service_status_ex(p, &q_u, &r_u);
 187
 188         if(!svcctl_io_r_query_service_status_ex("", &r_u, rdata, 0))
 189                 return False;
 190
 191         return True;
 192 }
 193 /*******************************************************************
 194  ********************************************************************/
 195
 196 static bool api_svcctl_enum_dependent_services(pipes_struct *p)
 197 {
 198         SVCCTL_Q_ENUM_DEPENDENT_SERVICES q_u;
 199         SVCCTL_R_ENUM_DEPENDENT_SERVICES 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         if(!svcctl_io_q_enum_dependent_services("", &q_u, data, 0))
 207                 return False;
 208
 209         r_u.status = _svcctl_enum_dependent_services(p, &q_u, &r_u);
 210
 211         if(!svcctl_io_r_enum_dependent_services("", &r_u, rdata, 0))
 212                 return False;
 213
 214         return True;
 215 }
 216
 217 /*******************************************************************
 218  ********************************************************************/
 219
 220 static bool api_svcctl_start_service(pipes_struct *p)
 221 {
 222         SVCCTL_Q_START_SERVICE q_u;
 223         SVCCTL_R_START_SERVICE r_u;
 224         prs_struct *data = &p->in_data.data;
 225         prs_struct *rdata = &p->out_data.rdata;
 226
 227         ZERO_STRUCT(q_u);
 228         ZERO_STRUCT(r_u);
 229
 230         if(!svcctl_io_q_start_service("", &q_u, data, 0))
 231                 return False;
 232
 233         r_u.status = _svcctl_start_service(p, &q_u, &r_u);
 234
 235         if(!svcctl_io_r_start_service("", &r_u, rdata, 0))
 236                 return False;
 237
 238         return True;
 239 }
 240
 241 /*******************************************************************
 242  ********************************************************************/
 243
 244 static bool api_svcctl_control_service(pipes_struct *p)
 245 {
 246         SVCCTL_Q_CONTROL_SERVICE q_u;
 247         SVCCTL_R_CONTROL_SERVICE r_u;
 248         prs_struct *data = &p->in_data.data;
 249         prs_struct *rdata = &p->out_data.rdata;
 250
 251         ZERO_STRUCT(q_u);
 252         ZERO_STRUCT(r_u);
 253
 254         if(!svcctl_io_q_control_service("", &q_u, data, 0))
 255                 return False;
 256
 257         r_u.status = _svcctl_control_service(p, &q_u, &r_u);
 258
 259         if(!svcctl_io_r_control_service("", &r_u, rdata, 0))
 260                 return False;
 261
 262         return True;
 263 }
 264
 265 /*******************************************************************
 266  ********************************************************************/
 267
 268 static bool api_svcctl_query_service_config(pipes_struct *p)
 269 {
 270         SVCCTL_Q_QUERY_SERVICE_CONFIG q_u;
 271         SVCCTL_R_QUERY_SERVICE_CONFIG r_u;
 272         prs_struct *data = &p->in_data.data;
 273         prs_struct *rdata = &p->out_data.rdata;
 274
 275         ZERO_STRUCT(q_u);
 276         ZERO_STRUCT(r_u);
 277
 278         if(!svcctl_io_q_query_service_config("", &q_u, data, 0))
 279                 return False;
 280
 281         r_u.status = _svcctl_query_service_config(p, &q_u, &r_u);
 282
 283         if(!svcctl_io_r_query_service_config("", &r_u, rdata, 0))
 284                 return False;
 285
 286         return True;
 287 }
 288
 289 /*******************************************************************
 290  ********************************************************************/
 291
 292 static bool api_svcctl_query_service_config2(pipes_struct *p)
 293 {
 294         SVCCTL_Q_QUERY_SERVICE_CONFIG2 q_u;
 295         SVCCTL_R_QUERY_SERVICE_CONFIG2 r_u;
 296         prs_struct *data = &p->in_data.data;
 297         prs_struct *rdata = &p->out_data.rdata;
 298
 299         ZERO_STRUCT(q_u);
 300         ZERO_STRUCT(r_u);
 301
 302         if(!svcctl_io_q_query_service_config2("", &q_u, data, 0))
 303                 return False;
 304
 305         r_u.status = _svcctl_query_service_config2(p, &q_u, &r_u);
 306
 307         if(!svcctl_io_r_query_service_config2("", &r_u, rdata, 0))
 308                 return False;
 309
 310         return True;
 311 }
 312
 313 /*******************************************************************
 314  ********************************************************************/
 315
 316 static bool api_svcctl_lock_service_db(pipes_struct *p)
 317 {
 318         SVCCTL_Q_LOCK_SERVICE_DB q_u;
 319         SVCCTL_R_LOCK_SERVICE_DB r_u;
 320         prs_struct *data = &p->in_data.data;
 321         prs_struct *rdata = &p->out_data.rdata;
 322
 323         ZERO_STRUCT(q_u);
 324         ZERO_STRUCT(r_u);
 325
 326         if(!svcctl_io_q_lock_service_db("", &q_u, data, 0))
 327                 return False;
 328
 329         r_u.status = _svcctl_lock_service_db(p, &q_u, &r_u);
 330
 331         if(!svcctl_io_r_lock_service_db("", &r_u, rdata, 0))
 332                 return False;
 333
 334         return True;
 335 }
 336
 337
 338 /*******************************************************************
 339  ********************************************************************/
 340
 341 static bool api_svcctl_unlock_service_db(pipes_struct *p)
 342 {
 343         SVCCTL_Q_UNLOCK_SERVICE_DB q_u;
 344         SVCCTL_R_UNLOCK_SERVICE_DB r_u;
 345         prs_struct *data = &p->in_data.data;
 346         prs_struct *rdata = &p->out_data.rdata;
 347
 348         ZERO_STRUCT(q_u);
 349         ZERO_STRUCT(r_u);
 350
 351         if(!svcctl_io_q_unlock_service_db("", &q_u, data, 0))
 352                 return False;
 353
 354         r_u.status = _svcctl_unlock_service_db(p, &q_u, &r_u);
 355
 356         if(!svcctl_io_r_unlock_service_db("", &r_u, rdata, 0))
 357                 return False;
 358
 359         return True;
 360 }
 361
 362 /*******************************************************************
 363  ********************************************************************/
 364
 365 static bool api_svcctl_query_security_sec(pipes_struct *p)
 366 {
 367         SVCCTL_Q_QUERY_SERVICE_SEC q_u;
 368         SVCCTL_R_QUERY_SERVICE_SEC r_u;
 369         prs_struct *data = &p->in_data.data;
 370         prs_struct *rdata = &p->out_data.rdata;
 371
 372         ZERO_STRUCT(q_u);
 373         ZERO_STRUCT(r_u);
 374
 375         if(!svcctl_io_q_query_service_sec("", &q_u, data, 0))
 376                 return False;
 377
 378         r_u.status = _svcctl_query_service_sec(p, &q_u, &r_u);
 379
 380         if(!svcctl_io_r_query_service_sec("", &r_u, rdata, 0))
 381                 return False;
 382
 383         return True;
 384 }
 385
 386 /*******************************************************************
 387  ********************************************************************/
 388
 389 static bool api_svcctl_set_security_sec(pipes_struct *p)
 390 {
 391         SVCCTL_Q_SET_SERVICE_SEC q_u;
 392         SVCCTL_R_SET_SERVICE_SEC r_u;
 393         prs_struct *data = &p->in_data.data;
 394         prs_struct *rdata = &p->out_data.rdata;
 395
 396         ZERO_STRUCT(q_u);
 397         ZERO_STRUCT(r_u);
 398
 399         if(!svcctl_io_q_set_service_sec("", &q_u, data, 0))
 400                 return False;
 401
 402         r_u.status = _svcctl_set_service_sec(p, &q_u, &r_u);
 403
 404         if(!svcctl_io_r_set_service_sec("", &r_u, rdata, 0))
 405                 return False;
 406
 407         return True;
 408 }
 409
 410
 411 /*******************************************************************
 412  \PIPE\svcctl commands
 413  ********************************************************************/
 414
 415 static struct api_struct api_svcctl_cmds[] =
 416 {
 417       { "SVCCTL_CLOSE_SERVICE"              , SVCCTL_CLOSE_SERVICE              , api_svcctl_close_service },
 418       { "SVCCTL_OPEN_SCMANAGER_W"           , SVCCTL_OPEN_SCMANAGER_W           , api_svcctl_open_scmanager },
 419       { "SVCCTL_OPEN_SERVICE_W"             , SVCCTL_OPEN_SERVICE_W             , api_svcctl_open_service },
 420       { "SVCCTL_GET_DISPLAY_NAME"           , SVCCTL_GET_DISPLAY_NAME           , api_svcctl_get_display_name },
 421       { "SVCCTL_QUERY_STATUS"               , SVCCTL_QUERY_STATUS               , api_svcctl_query_status },
 422       { "SVCCTL_QUERY_SERVICE_CONFIG_W"     , SVCCTL_QUERY_SERVICE_CONFIG_W     , api_svcctl_query_service_config },
 423       { "SVCCTL_QUERY_SERVICE_CONFIG2_W"    , SVCCTL_QUERY_SERVICE_CONFIG2_W    , api_svcctl_query_service_config2 },
 424       { "SVCCTL_ENUM_SERVICES_STATUS_W"     , SVCCTL_ENUM_SERVICES_STATUS_W     , api_svcctl_enum_services_status },
 425       { "SVCCTL_ENUM_DEPENDENT_SERVICES_W"  , SVCCTL_ENUM_DEPENDENT_SERVICES_W  , api_svcctl_enum_dependent_services },
 426       { "SVCCTL_START_SERVICE_W"            , SVCCTL_START_SERVICE_W            , api_svcctl_start_service },
 427       { "SVCCTL_CONTROL_SERVICE"            , SVCCTL_CONTROL_SERVICE            , api_svcctl_control_service },
 428       { "SVCCTL_QUERY_SERVICE_STATUSEX_W"   , SVCCTL_QUERY_SERVICE_STATUSEX_W   , api_svcctl_query_service_status_ex },
 429       { "SVCCTL_LOCK_SERVICE_DB"            , SVCCTL_LOCK_SERVICE_DB            , api_svcctl_lock_service_db },
 430       { "SVCCTL_UNLOCK_SERVICE_DB"          , SVCCTL_UNLOCK_SERVICE_DB          , api_svcctl_unlock_service_db },
 431       { "SVCCTL_QUERY_SERVICE_SEC"          , SVCCTL_QUERY_SERVICE_SEC          , api_svcctl_query_security_sec },
 432       { "SVCCTL_SET_SERVICE_SEC"            , SVCCTL_SET_SERVICE_SEC            , api_svcctl_set_security_sec }
 433 };
 434
 435
 436 void svcctl2_get_pipe_fns( struct api_struct **fns, int *n_fns )
 437 {
 438         *fns = api_svcctl_cmds;
 439         *n_fns = sizeof(api_svcctl_cmds) / sizeof(struct api_struct);
 440 }
 441
 442 NTSTATUS rpc_svcctl2_init(void)
 443 {
 444         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION,
 445                                           "svcctl", "ntsvcs", api_svcctl_cmds,
 446                                           sizeof(api_svcctl_cmds) / sizeof(struct api_struct));
 447 }