source3/rpc_client/cli_svcctl.c

   1
   2 /*
   3  *  Unix SMB/Netbios implementation.
   4  *  Version 1.9.
   5  *  RPC Pipe client / server routines
   6  *  Copyright (C) Andrew Tridgell              1992-1998,
   7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
   8  *  Copyright (C) Paul Ashton                  1997-1998.
   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
  26 #ifdef SYSLOG
  27 #undef SYSLOG
  28 #endif
  29
  30 #include "includes.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 /****************************************************************************
  35 do a SVC Open Policy
  36 ****************************************************************************/
  37 BOOL svc_open_sc_man(struct cli_state *cli, uint16 fnum,
  38                                 char *srv_name, char *db_name,
  39                                 uint32 des_access,
  40                                 POLICY_HND *hnd)
  41 {
  42         prs_struct rbuf;
  43         prs_struct buf;
  44         SVC_Q_OPEN_SC_MAN q_o;
  45         BOOL valid_pol = False;
  46
  47         if (hnd == NULL) return False;
  48
  49         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
  50         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
  51
  52         /* create and send a MSRPC command with api SVC_OPEN_SC_MAN */
  53
  54         DEBUG(4,("SVC Open SC_MAN\n"));
  55
  56         make_svc_q_open_sc_man(&q_o, srv_name, db_name, des_access);
  57
  58         /* turn parameters into data stream */
  59         svc_io_q_open_sc_man("", &q_o, &buf, 0);
  60
  61         /* send the data on \PIPE\ */
  62         if (rpc_api_pipe_req(cli, fnum, SVC_OPEN_SC_MAN, &buf, &rbuf))
  63         {
  64                 SVC_R_OPEN_SC_MAN r_o;
  65                 BOOL p;
  66
  67                 ZERO_STRUCT(r_o);
  68
  69                 svc_io_r_open_sc_man("", &r_o, &rbuf, 0);
  70                 p = rbuf.offset != 0;
  71
  72                 if (p && r_o.status != 0)
  73                 {
  74                         /* report error code */
  75                         DEBUG(1,("SVC_OPEN_SC_MAN: %s\n", get_nt_error_msg(r_o.status)));
  76                         p = False;
  77                 }
  78
  79                 if (p)
  80                 {
  81                         /* ok, at last: we're happy. return the policy handle */
  82                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
  83                         valid_pol = True;
  84                 }
  85         }
  86
  87         prs_mem_free(&rbuf);
  88         prs_mem_free(&buf );
  89
  90         return valid_pol;
  91 }
  92
  93
  94 /****************************************************************************
  95 do a SVC Open Service
  96 ****************************************************************************/
  97 BOOL svc_open_service(struct cli_state *cli, uint16 fnum,
  98                                 POLICY_HND *scm_hnd,
  99                                 const char *srv_name,
 100                                 uint32 des_access,
 101                                 POLICY_HND *hnd)
 102 {
 103         prs_struct rbuf;
 104         prs_struct buf;
 105         SVC_Q_OPEN_SERVICE q_o;
 106         BOOL valid_pol = False;
 107
 108         if (hnd == NULL || scm_hnd == NULL) return False;
 109
 110         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 111         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 112
 113         /* create and send a MSRPC command with api SVC_OPEN_SERVICE */
 114
 115         DEBUG(4,("SVC Open Service\n"));
 116
 117         make_svc_q_open_service(&q_o, scm_hnd, srv_name, des_access);
 118
 119         /* turn parameters into data stream */
 120         svc_io_q_open_service("", &q_o, &buf, 0);
 121
 122         /* send the data on \PIPE\ */
 123         if (rpc_api_pipe_req(cli, fnum, SVC_OPEN_SERVICE, &buf, &rbuf))
 124         {
 125                 SVC_R_OPEN_SERVICE r_o;
 126                 BOOL p;
 127
 128                 ZERO_STRUCT(r_o);
 129
 130                 svc_io_r_open_service("", &r_o, &rbuf, 0);
 131                 p = rbuf.offset != 0;
 132
 133                 if (p && r_o.status != 0)
 134                 {
 135                         /* report error code */
 136                         DEBUG(1,("SVC_OPEN_SC_MAN: %s\n", get_nt_error_msg(r_o.status)));
 137                         p = False;
 138                 }
 139
 140                 if (p)
 141                 {
 142                         /* ok, at last: we're happy. return the policy handle */
 143                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
 144                         valid_pol = True;
 145                 }
 146         }
 147
 148         prs_mem_free(&rbuf);
 149         prs_mem_free(&buf );
 150
 151         return valid_pol;
 152 }
 153
 154
 155 /****************************************************************************
 156 do a SVC Enumerate Services
 157 ****************************************************************************/
 158 BOOL svc_enum_svcs(struct cli_state *cli, uint16 fnum,
 159                                 POLICY_HND *hnd,
 160                                 uint32 services_type, uint32 services_state,
 161                                 uint32 *buf_size, uint32 *resume_hnd,
 162                                 uint32 *dos_error,
 163                                 ENUM_SRVC_STATUS **svcs, uint32 *num_svcs)
 164 {
 165         prs_struct rbuf;
 166         prs_struct buf;
 167         SVC_Q_ENUM_SVCS_STATUS q_o;
 168         BOOL valid_pol = False;
 169
 170         if (hnd == NULL || buf_size == NULL || dos_error == NULL || num_svcs == NULL)
 171         {
 172                 return False;
 173         }
 174
 175         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 176         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 177
 178         /* create and send a MSRPC command with api SVC_ENUM_SVCS_STATUS */
 179
 180         DEBUG(4,("SVC Enum Services Status\n"));
 181
 182         make_svc_q_enum_svcs_status(&q_o, hnd,
 183                                     services_type, services_state,
 184                                     *buf_size, *resume_hnd);
 185
 186         /* turn parameters into data stream */
 187         svc_io_q_enum_svcs_status("", &q_o, &buf, 0);
 188
 189         /* send the data on \PIPE\ */
 190         if (rpc_api_pipe_req(cli, fnum, SVC_ENUM_SVCS_STATUS, &buf, &rbuf))
 191         {
 192                 SVC_R_ENUM_SVCS_STATUS r_o;
 193                 BOOL p;
 194
 195                 ZERO_STRUCT(r_o);
 196
 197                 svc_io_r_enum_svcs_status("", &r_o, &rbuf, 0);
 198                 p = rbuf.offset != 0;
 199
 200                 if (p && r_o.dos_status != 0)
 201                 {
 202                         fstring errmsg;
 203
 204                         if (r_o.dos_status != ERRmoredata)
 205                         {
 206                                 smb_safe_err_msg(ERRDOS, r_o.dos_status,
 207                                                  errmsg, sizeof(errmsg));
 208                                 /* report error code */
 209                                 DEBUG(1,("SVC_ENUM_SVCS_STATUS: %s\n", errmsg));
 210                         }
 211                         p = r_o.dos_status == ERRmoredata;
 212                 }
 213
 214                 if (p)
 215                 {
 216                         (*svcs) = r_o.svcs;
 217                         (*num_svcs) = r_o.num_svcs;
 218                         (*resume_hnd) = get_enum_hnd(&r_o.resume_hnd);
 219                         (*buf_size) = r_o.more_buf_size;
 220                         (*dos_error) = r_o.dos_status;
 221                         valid_pol = True;
 222                 }
 223         }
 224
 225         prs_mem_free(&rbuf);
 226         prs_mem_free(&buf );
 227
 228         return valid_pol;
 229 }
 230
 231
 232 /****************************************************************************
 233 do a SVC Stop Service
 234 ****************************************************************************/
 235 BOOL svc_stop_service(struct cli_state *cli, uint16 fnum,
 236                                 POLICY_HND *hnd,
 237                                 uint32 unknown)
 238 {
 239         prs_struct rbuf;
 240         prs_struct buf;
 241         SVC_Q_STOP_SERVICE q_c;
 242         BOOL valid_cfg = False;
 243
 244         if (hnd == NULL) return False;
 245
 246         /* create and send a MSRPC command with api SVC_STOP_SERVICE */
 247
 248         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 249         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 250
 251         DEBUG(4,("SVC Stop Service\n"));
 252
 253         /* store the parameters */
 254         make_svc_q_stop_service(&q_c, hnd, unknown);
 255
 256         /* turn parameters into data stream */
 257         svc_io_q_stop_service("", &q_c, &buf, 0);
 258
 259         /* send the data on \PIPE\ */
 260         if (rpc_api_pipe_req(cli, fnum, SVC_STOP_SERVICE, &buf, &rbuf))
 261         {
 262                 SVC_R_STOP_SERVICE r_c;
 263                 BOOL p;
 264
 265                 ZERO_STRUCT (r_c);
 266
 267                 svc_io_r_stop_service("", &r_c, &rbuf, 0);
 268                 p = rbuf.offset != 0;
 269
 270                 if (p && r_c.status != 0)
 271                 {
 272                         /* report error code */
 273                         DEBUG(1,("SVC_START_SERVICE: %s\n", get_nt_error_msg(r_c.status)));
 274                         p = False;
 275                 }
 276
 277                 if (p)
 278                 {
 279                         valid_cfg = True;
 280                 }
 281         }
 282
 283         prs_mem_free(&rbuf);
 284         prs_mem_free(&buf );
 285
 286         return valid_cfg;
 287 }
 288
 289
 290 /****************************************************************************
 291 do a SVC Start Service
 292 ****************************************************************************/
 293 BOOL svc_start_service(struct cli_state *cli, uint16 fnum,
 294                                 POLICY_HND *hnd,
 295                                 uint32 argc,
 296                                 char **argv)
 297 {
 298         prs_struct rbuf;
 299         prs_struct buf;
 300         SVC_Q_START_SERVICE q_c;
 301         BOOL valid_cfg = False;
 302
 303         if (hnd == NULL) return False;
 304
 305         /* create and send a MSRPC command with api SVC_START_SERVICE */
 306
 307         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 308         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 309
 310         DEBUG(4,("SVC Start Service\n"));
 311
 312         /* store the parameters */
 313         make_svc_q_start_service(&q_c, hnd, argc, argv);
 314
 315         /* turn parameters into data stream */
 316         svc_io_q_start_service("", &q_c, &buf, 0);
 317
 318         /* send the data on \PIPE\ */
 319         if (rpc_api_pipe_req(cli, fnum, SVC_START_SERVICE, &buf, &rbuf))
 320         {
 321                 SVC_R_START_SERVICE r_c;
 322                 BOOL p;
 323
 324                 ZERO_STRUCT (r_c);
 325
 326                 svc_io_r_start_service("", &r_c, &rbuf, 0);
 327                 p = rbuf.offset != 0;
 328
 329                 if (p && r_c.status != 0)
 330                 {
 331                         /* report error code */
 332                         DEBUG(1,("SVC_START_SERVICE: %s\n", get_nt_error_msg(r_c.status)));
 333                         p = False;
 334                 }
 335
 336                 if (p)
 337                 {
 338                         valid_cfg = True;
 339                 }
 340         }
 341
 342         prs_mem_free(&rbuf);
 343         prs_mem_free(&buf );
 344
 345         return valid_cfg;
 346 }
 347
 348
 349 /****************************************************************************
 350 do a SVC Query Service Config
 351 ****************************************************************************/
 352 BOOL svc_query_svc_cfg(struct cli_state *cli, uint16 fnum,
 353                                 POLICY_HND *hnd,
 354                                 QUERY_SERVICE_CONFIG *cfg,
 355                                 uint32 *buf_size)
 356 {
 357         prs_struct rbuf;
 358         prs_struct buf;
 359         SVC_Q_QUERY_SVC_CONFIG q_c;
 360         BOOL valid_cfg = False;
 361
 362         if (hnd == NULL || buf_size == NULL) return False;
 363
 364         /* create and send a MSRPC command with api SVC_QUERY_SVC_CONFIG */
 365
 366         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 367         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 368
 369         DEBUG(4,("SVC Query Service Config\n"));
 370
 371         /* store the parameters */
 372         make_svc_q_query_svc_config(&q_c, hnd, *buf_size);
 373
 374         /* turn parameters into data stream */
 375         svc_io_q_query_svc_config("", &q_c, &buf, 0);
 376
 377         /* send the data on \PIPE\ */
 378         if (rpc_api_pipe_req(cli, fnum, SVC_QUERY_SVC_CONFIG, &buf, &rbuf))
 379         {
 380                 SVC_R_QUERY_SVC_CONFIG r_c;
 381                 BOOL p;
 382
 383                 ZERO_STRUCT (r_c);
 384                 ZERO_STRUCTP(cfg);
 385
 386                 r_c.cfg = cfg;
 387
 388                 svc_io_r_query_svc_config("", &r_c, &rbuf, 0);
 389                 p = rbuf.offset != 0;
 390
 391                 if (p && r_c.status != 0)
 392                 {
 393                         /* report error code */
 394                         DEBUG(1,("SVC_QUERY_SVC_CONFIG: %s\n", get_nt_error_msg(r_c.status)));
 395                         p = False;
 396                 }
 397
 398                 if (p)
 399                 {
 400                         valid_cfg = r_c.buf_size != 0;
 401                 }
 402         }
 403
 404         prs_mem_free(&rbuf);
 405         prs_mem_free(&buf );
 406
 407         return valid_cfg;
 408 }
 409
 410
 411 /****************************************************************************
 412 do a SVC Close
 413 ****************************************************************************/
 414 BOOL svc_close(struct cli_state *cli, uint16 fnum, POLICY_HND *hnd)
 415 {
 416         prs_struct rbuf;
 417         prs_struct buf;
 418         SVC_Q_CLOSE q_c;
 419         BOOL valid_close = False;
 420
 421         if (hnd == NULL) return False;
 422
 423         /* create and send a MSRPC command with api SVC_CLOSE */
 424
 425         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 426         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 427
 428         DEBUG(4,("SVC Close\n"));
 429
 430         /* store the parameters */
 431         make_svc_q_close(&q_c, hnd);
 432
 433         /* turn parameters into data stream */
 434         svc_io_q_close("", &q_c, &buf, 0);
 435
 436         /* send the data on \PIPE\ */
 437         if (rpc_api_pipe_req(cli, fnum, SVC_CLOSE, &buf, &rbuf))
 438         {
 439                 SVC_R_CLOSE r_c;
 440                 BOOL p;
 441
 442                 ZERO_STRUCT(r_c);
 443
 444                 svc_io_r_close("", &r_c, &rbuf, 0);
 445                 p = rbuf.offset != 0;
 446
 447                 if (p && r_c.status != 0)
 448                 {
 449                         /* report error code */
 450                         DEBUG(1,("SVC_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
 451                         p = False;
 452                 }
 453
 454                 if (p)
 455                 {
 456                         /* check that the returned policy handle is all zeros */
 457                         uint32 i;
 458                         valid_close = True;
 459
 460                         for (i = 0; i < sizeof(r_c.pol.data); i++)
 461                         {
 462                                 if (r_c.pol.data[i] != 0)
 463                                 {
 464                                         valid_close = False;
 465                                         break;
 466                                 }
 467                         }
 468                         if (!valid_close)
 469                         {
 470                                 DEBUG(1,("SVC_CLOSE: non-zero handle returned\n"));
 471                         }
 472                 }
 473         }
 474
 475         prs_mem_free(&rbuf);
 476         prs_mem_free(&buf );
 477
 478         return valid_close;
 479 }
 480
 481 /****************************************************************************
 482 do a SVC Change Service Config
 483 ****************************************************************************/
 484 BOOL svc_change_svc_cfg(struct cli_state *cli, uint16 fnum,
 485                                 POLICY_HND *hnd,
 486                                 uint32 service_type, uint32 start_type,
 487                                 uint32 unknown_0,
 488                                 uint32 error_control,
 489                                 char* bin_path_name, char* load_order_grp,
 490                                 uint32 tag_id,
 491                                 char* dependencies, char* service_start_name,
 492                                 char* password,
 493                                 char* disp_name)
 494 {
 495         prs_struct rbuf;
 496         prs_struct buf;
 497         SVC_Q_CHANGE_SVC_CONFIG q_c;
 498         BOOL valid_cfg = False;
 499
 500         if (hnd == NULL) return False;
 501
 502         /* create and send a MSRPC command with api SVC_CHANGE_SVC_CONFIG */
 503
 504         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
 505         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
 506
 507         DEBUG(4,("SVC Change Service Config\n"));
 508
 509         /* store the parameters */
 510         make_svc_q_change_svc_config(&q_c, hnd,
 511                                 service_type, start_type,
 512                                 unknown_0, error_control,
 513                                 bin_path_name, load_order_grp,
 514                                 tag_id,
 515                                 dependencies, service_start_name,
 516                                 password, disp_name);
 517
 518         /* turn parameters into data stream */
 519         svc_io_q_change_svc_config("", &q_c, &buf, 0);
 520
 521         /* send the data on \PIPE\ */
 522         if (rpc_api_pipe_req(cli, fnum, SVC_CHANGE_SVC_CONFIG, &buf, &rbuf))
 523         {
 524                 SVC_R_CHANGE_SVC_CONFIG r_c;
 525                 BOOL p;
 526
 527                 ZERO_STRUCT (r_c);
 528
 529                 svc_io_r_change_svc_config("", &r_c, &rbuf, 0);
 530                 p = rbuf.offset != 0;
 531
 532                 if (p && r_c.status != 0)
 533                 {
 534                         /* report error code */
 535                         DEBUG(1,("SVC_CHANGE_SVC_CONFIG: %s\n", get_nt_error_msg(r_c.status)));
 536                         p = False;
 537                 }
 538
 539                 if (p)
 540                 {
 541                         valid_cfg = True;
 542                 }
 543         }
 544
 545         prs_mem_free(&rbuf);
 546         prs_mem_free(&buf );
 547
 548         return valid_cfg;
 549 }
 550
 551