source/rpc_client/cli_svcctl.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald Carter                   2005.
   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 2 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, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21
  22 #include "includes.h"
  23 #include "rpc_client.h"
  24
  25 struct svc_state_msg {
  26         uint32 flag;
  27         const char *message;
  28 };
  29
  30 static struct svc_state_msg state_msg_table[] = {
  31         { SVCCTL_STOPPED,            "stopped" },
  32         { SVCCTL_START_PENDING,      "start pending" },
  33         { SVCCTL_STOP_PENDING,       "stop pending" },
  34         { SVCCTL_RUNNING,            "running" },
  35         { SVCCTL_CONTINUE_PENDING,   "resume pending" },
  36         { SVCCTL_PAUSE_PENDING,      "pause pending" },
  37         { SVCCTL_PAUSED,             "paused" },
  38         { 0,                          NULL }
  39 };
  40
  41
  42 /********************************************************************
  43 ********************************************************************/
  44 const char* svc_status_string( uint32 state )
  45 {
  46         static fstring msg;
  47         int i;
  48
  49         fstr_sprintf( msg, "Unknown State [%d]", state );
  50
  51         for ( i=0; state_msg_table[i].message; i++ ) {
  52                 if ( state_msg_table[i].flag == state ) {
  53                         fstrcpy( msg, state_msg_table[i].message );
  54                         break;
  55                 }
  56         }
  57
  58         return msg;
  59 }
  60
  61 /********************************************************************
  62 ********************************************************************/
  63
  64 WERROR rpccli_svcctl_open_scm(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
  65                               POLICY_HND *hSCM, uint32 access_desired )
  66 {
  67         SVCCTL_Q_OPEN_SCMANAGER in;
  68         SVCCTL_R_OPEN_SCMANAGER out;
  69         prs_struct qbuf, rbuf;
  70         fstring server;
  71
  72         ZERO_STRUCT(in);
  73         ZERO_STRUCT(out);
  74
  75         /* leave the database name NULL to get the default service db */
  76
  77         in.database = NULL;
  78
  79         /* set the server name */
  80
  81         if ( !(in.servername = TALLOC_P( mem_ctx, UNISTR2 )) )
  82                 return WERR_NOMEM;
  83         fstr_sprintf( server, "\\\\%s", cli->cli->desthost );
  84         init_unistr2( in.servername, server, UNI_STR_TERMINATE );
  85
  86         in.access = access_desired;
  87
  88         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_OPEN_SCMANAGER_W,
  89                     in, out,
  90                     qbuf, rbuf,
  91                     svcctl_io_q_open_scmanager,
  92                     svcctl_io_r_open_scmanager,
  93                     WERR_GENERAL_FAILURE );
  94
  95         if ( !W_ERROR_IS_OK( out.status ) )
  96                 return out.status;
  97
  98         memcpy( hSCM, &out.handle, sizeof(POLICY_HND) );
  99
 100         return out.status;
 101 }
 102
 103 /********************************************************************
 104 ********************************************************************/
 105
 106 WERROR rpccli_svcctl_open_service( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 107                                 POLICY_HND *hSCM, POLICY_HND *hService,
 108                                 const char *servicename, uint32 access_desired )
 109 {
 110         SVCCTL_Q_OPEN_SERVICE in;
 111         SVCCTL_R_OPEN_SERVICE out;
 112         prs_struct qbuf, rbuf;
 113
 114         ZERO_STRUCT(in);
 115         ZERO_STRUCT(out);
 116
 117         memcpy( &in.handle, hSCM, sizeof(POLICY_HND) );
 118         init_unistr2( &in.servicename, servicename, UNI_STR_TERMINATE );
 119         in.access = access_desired;
 120
 121         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_OPEN_SERVICE_W,
 122                     in, out,
 123                     qbuf, rbuf,
 124                     svcctl_io_q_open_service,
 125                     svcctl_io_r_open_service,
 126                     WERR_GENERAL_FAILURE );
 127
 128         if ( !W_ERROR_IS_OK( out.status ) )
 129                 return out.status;
 130
 131         memcpy( hService, &out.handle, sizeof(POLICY_HND) );
 132
 133         return out.status;
 134 }
 135
 136 /********************************************************************
 137 ********************************************************************/
 138
 139 WERROR rpccli_svcctl_close_service(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, POLICY_HND *hService )
 140 {
 141         SVCCTL_Q_CLOSE_SERVICE in;
 142         SVCCTL_R_CLOSE_SERVICE out;
 143         prs_struct qbuf, rbuf;
 144
 145         ZERO_STRUCT(in);
 146         ZERO_STRUCT(out);
 147
 148         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 149
 150         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_CLOSE_SERVICE,
 151                     in, out,
 152                     qbuf, rbuf,
 153                     svcctl_io_q_close_service,
 154                     svcctl_io_r_close_service,
 155                     WERR_GENERAL_FAILURE );
 156
 157         return out.status;
 158 }
 159
 160 /*******************************************************************
 161 *******************************************************************/
 162
 163 WERROR rpccli_svcctl_enumerate_services( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 164                                       POLICY_HND *hSCM, uint32 type, uint32 state,
 165                                       uint32 *returned, ENUM_SERVICES_STATUS **service_array  )
 166 {
 167         SVCCTL_Q_ENUM_SERVICES_STATUS in;
 168         SVCCTL_R_ENUM_SERVICES_STATUS out;
 169         prs_struct qbuf, rbuf;
 170         uint32 resume = 0;
 171         ENUM_SERVICES_STATUS *services;
 172         int i;
 173
 174         ZERO_STRUCT(in);
 175         ZERO_STRUCT(out);
 176
 177         /* setup the request */
 178
 179         memcpy( &in.handle, hSCM, sizeof(POLICY_HND) );
 180
 181         in.type        = type;
 182         in.state       = state;
 183         in.resume      = &resume;
 184
 185         /* first time is to get the buffer size */
 186         in.buffer_size = 0;
 187
 188         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_ENUM_SERVICES_STATUS_W,
 189                     in, out,
 190                     qbuf, rbuf,
 191                     svcctl_io_q_enum_services_status,
 192                     svcctl_io_r_enum_services_status,
 193                     WERR_GENERAL_FAILURE );
 194
 195         /* second time with correct buffer size...should be ok */
 196
 197         if ( W_ERROR_EQUAL( out.status, WERR_MORE_DATA ) ) {
 198                 in.buffer_size = out.needed;
 199
 200                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_ENUM_SERVICES_STATUS_W,
 201                             in, out,
 202                             qbuf, rbuf,
 203                             svcctl_io_q_enum_services_status,
 204                             svcctl_io_r_enum_services_status,
 205                             WERR_GENERAL_FAILURE );
 206         }
 207
 208         if ( !W_ERROR_IS_OK(out.status) )
 209                 return out.status;
 210
 211         /* pull out the data */
 212         if (out.returned) {
 213                 if ( !(services = TALLOC_ARRAY( mem_ctx, ENUM_SERVICES_STATUS, out.returned )) )
 214                         return WERR_NOMEM;
 215         } else {
 216                 services = NULL;
 217         }
 218
 219         for ( i=0; i<out.returned; i++ ) {
 220                 svcctl_io_enum_services_status( "", &services[i], &out.buffer, 0 );
 221         }
 222
 223         *service_array = services;
 224         *returned      = out.returned;
 225
 226         return out.status;
 227 }
 228
 229 /*******************************************************************
 230 *******************************************************************/
 231
 232 WERROR rpccli_svcctl_query_status( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 233                                 POLICY_HND *hService, SERVICE_STATUS *status )
 234 {
 235         SVCCTL_Q_QUERY_STATUS in;
 236         SVCCTL_R_QUERY_STATUS out;
 237         prs_struct qbuf, rbuf;
 238
 239         ZERO_STRUCT(in);
 240         ZERO_STRUCT(out);
 241
 242         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 243
 244         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_QUERY_STATUS,
 245                     in, out,
 246                     qbuf, rbuf,
 247                     svcctl_io_q_query_status,
 248                     svcctl_io_r_query_status,
 249                     WERR_GENERAL_FAILURE );
 250
 251         if ( !W_ERROR_IS_OK( out.status ) )
 252                 return out.status;
 253
 254         memcpy( status, &out.svc_status, sizeof(SERVICE_STATUS) );
 255
 256         return out.status;
 257 }
 258
 259 /*******************************************************************
 260 *******************************************************************/
 261
 262 WERROR rpccli_svcctl_query_config(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 263                                 POLICY_HND *hService, SERVICE_CONFIG *config )
 264 {
 265         SVCCTL_Q_QUERY_SERVICE_CONFIG in;
 266         SVCCTL_R_QUERY_SERVICE_CONFIG out;
 267         prs_struct qbuf, rbuf;
 268
 269         ZERO_STRUCT(in);
 270         ZERO_STRUCT(out);
 271
 272         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 273         in.buffer_size = 0;
 274
 275
 276         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_QUERY_SERVICE_CONFIG_W,
 277                     in, out,
 278                     qbuf, rbuf,
 279                     svcctl_io_q_query_service_config,
 280                     svcctl_io_r_query_service_config,
 281                     WERR_GENERAL_FAILURE );
 282
 283         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 284                 in.buffer_size = out.needed;
 285
 286                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_QUERY_SERVICE_CONFIG_W,
 287                             in, out,
 288                             qbuf, rbuf,
 289                             svcctl_io_q_query_service_config,
 290                             svcctl_io_r_query_service_config,
 291                             WERR_GENERAL_FAILURE );
 292         }
 293
 294         if ( !W_ERROR_IS_OK( out.status ) )
 295                 return out.status;
 296
 297         memcpy( config, &out.config, sizeof(SERVICE_CONFIG) );
 298
 299         config->executablepath = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 300         config->loadordergroup = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 301         config->dependencies   = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 302         config->startname      = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 303         config->displayname    = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 304
 305         if ( out.config.executablepath ) {
 306                 config->executablepath = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 307                 copy_unistr2( config->executablepath, out.config.executablepath );
 308         }
 309
 310         if ( out.config.loadordergroup ) {
 311                 config->loadordergroup = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 312                 copy_unistr2( config->loadordergroup, out.config.loadordergroup );
 313         }
 314
 315         if ( out.config.dependencies ) {
 316                 config->dependencies = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 317                 copy_unistr2( config->dependencies, out.config.dependencies );
 318         }
 319
 320         if ( out.config.startname ) {
 321                 config->startname = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 322                 copy_unistr2( config->startname, out.config.startname );
 323         }
 324
 325         if ( out.config.displayname ) {
 326                 config->displayname = TALLOC_ZERO_P( mem_ctx, UNISTR2 );
 327                 copy_unistr2( config->displayname, out.config.displayname );
 328         }
 329
 330         return out.status;
 331 }
 332
 333 /*******************************************************************
 334 *******************************************************************/
 335
 336 WERROR rpccli_svcctl_start_service( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 337                                  POLICY_HND *hService,
 338                                  const char **parm_array, uint32 parmcount )
 339 {
 340         SVCCTL_Q_START_SERVICE in;
 341         SVCCTL_R_START_SERVICE out;
 342         prs_struct qbuf, rbuf;
 343
 344         ZERO_STRUCT(in);
 345         ZERO_STRUCT(out);
 346
 347         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 348
 349         in.parmcount  = 0;
 350         in.parameters = NULL;
 351
 352         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_START_SERVICE_W,
 353                     in, out,
 354                     qbuf, rbuf,
 355                     svcctl_io_q_start_service,
 356                     svcctl_io_r_start_service,
 357                     WERR_GENERAL_FAILURE );
 358
 359         return out.status;
 360 }
 361
 362 /*******************************************************************
 363 *******************************************************************/
 364
 365 WERROR rpccli_svcctl_control_service( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 366                                    POLICY_HND *hService, uint32 control,
 367                                    SERVICE_STATUS *status )
 368 {
 369         SVCCTL_Q_CONTROL_SERVICE in;
 370         SVCCTL_R_CONTROL_SERVICE out;
 371         prs_struct qbuf, rbuf;
 372
 373         ZERO_STRUCT(in);
 374         ZERO_STRUCT(out);
 375
 376         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 377         in.control = control;
 378
 379         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_CONTROL_SERVICE,
 380                     in, out,
 381                     qbuf, rbuf,
 382                     svcctl_io_q_control_service,
 383                     svcctl_io_r_control_service,
 384                     WERR_GENERAL_FAILURE );
 385
 386         if ( !W_ERROR_IS_OK( out.status ) )
 387                 return out.status;
 388
 389         memcpy( status, &out.svc_status, sizeof(SERVICE_STATUS) );
 390
 391         return out.status;
 392 }
 393
 394
 395 /*******************************************************************
 396 *******************************************************************/
 397
 398 WERROR rpccli_svcctl_get_dispname( struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 399                                 POLICY_HND *hService, fstring displayname )
 400 {
 401         SVCCTL_Q_GET_DISPLAY_NAME in;
 402         SVCCTL_R_GET_DISPLAY_NAME out;
 403         prs_struct qbuf, rbuf;
 404
 405         ZERO_STRUCT(in);
 406         ZERO_STRUCT(out);
 407
 408         memcpy( &in.handle, hService, sizeof(POLICY_HND) );
 409         in.display_name_len = 0;
 410
 411         CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_GET_DISPLAY_NAME,
 412                     in, out,
 413                     qbuf, rbuf,
 414                     svcctl_io_q_get_display_name,
 415                     svcctl_io_r_get_display_name,
 416                     WERR_GENERAL_FAILURE );
 417
 418         /* second time with correct buffer size...should be ok */
 419
 420         if ( W_ERROR_EQUAL( out.status, WERR_INSUFFICIENT_BUFFER ) ) {
 421                 in.display_name_len = out.display_name_len;
 422
 423                 CLI_DO_RPC_WERR( cli, mem_ctx, PI_SVCCTL, SVCCTL_GET_DISPLAY_NAME,
 424                             in, out,
 425                             qbuf, rbuf,
 426                             svcctl_io_q_get_display_name,
 427                             svcctl_io_r_get_display_name,
 428                             WERR_GENERAL_FAILURE );
 429         }
 430
 431         if ( !W_ERROR_IS_OK( out.status ) )
 432                 return out.status;
 433
 434         rpcstr_pull( displayname, out.displayname.buffer, sizeof(displayname), -1, STR_TERMINATE );
 435
 436         return out.status;
 437 }