source3/rpcclient/cmd_svcctl.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NT Domain Authentication SMB / MSRPC client
   5    Copyright (C) Andrew Tridgell 1994-1997
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23
  24
  25 #ifdef SYSLOG
  26 #undef SYSLOG
  27 #endif
  28
  29 #include "includes.h"
  30 #include "nterr.h"
  31
  32 extern int DEBUGLEVEL;
  33
  34 extern FILE* out_hnd;
  35
  36 void svc_display_query_svc_cfg(const QUERY_SERVICE_CONFIG *cfg)
  37 {
  38         display_query_svc_cfg(out_hnd, ACTION_HEADER   , cfg);
  39         display_query_svc_cfg(out_hnd, ACTION_ENUMERATE, cfg);
  40         display_query_svc_cfg(out_hnd, ACTION_FOOTER   , cfg);
  41 }
  42
  43 BOOL svc_query_service( POLICY_HND *pol_scm,
  44                                 const char *svc_name,
  45                                 SVC_QUERY_FN(svc_query_fn))
  46 {
  47         BOOL res2 = True;
  48         BOOL res3;
  49         POLICY_HND pol_svc;
  50         QUERY_SERVICE_CONFIG cfg;
  51         uint32 svc_buf_size = 0x8000;
  52
  53         res2 = res2 ? svc_open_service( pol_scm,
  54                                        svc_name, 0x80000001,
  55                                        &pol_svc) : False;
  56         res3 = res2 ? svc_query_svc_cfg( &pol_svc, &cfg,
  57                                        &svc_buf_size) : False;
  58
  59         if (res3 && svc_query_fn != NULL)
  60         {
  61                 svc_query_fn(&cfg);
  62         }
  63
  64         res2 = res2 ? svc_close(&pol_svc) : False;
  65
  66         return res3;
  67 }
  68
  69 /****************************************************************************
  70 nt service info
  71 ****************************************************************************/
  72 void cmd_svc_info(struct client_info *info, int argc, char *argv[])
  73 {
  74         BOOL res = True;
  75         BOOL res1 = True;
  76         char *svc_name;
  77
  78         POLICY_HND pol_scm;
  79
  80         fstring srv_name;
  81
  82         fstrcpy(srv_name, "\\\\");
  83         fstrcat(srv_name, info->dest_host);
  84         strupper(srv_name);
  85
  86         DEBUG(4,("cmd_svc_info: server:%s\n", srv_name));
  87
  88         if (argc < 2)
  89         {
  90                 report(out_hnd,"svcinfo <service name>\n");
  91                 return;
  92         }
  93
  94         svc_name = argv[1];
  95
  96         /* open service control manager receive a policy handle */
  97         res = res ? svc_open_sc_man( srv_name, NULL, 0x80000004,
  98                                 &pol_scm) : False;
  99
 100         res1 = svc_query_service(&pol_scm, svc_name,
 101                                 svc_display_query_svc_cfg);
 102
 103         res = res ? svc_close(&pol_scm) : False;
 104
 105         if (res && res1)
 106         {
 107                 DEBUG(5,("cmd_svc_info: query succeeded\n"));
 108         }
 109         else
 110         {
 111                 DEBUG(5,("cmd_svc_info: query failed\n"));
 112         }
 113 }
 114
 115 static void svc_display_svc_info(const ENUM_SRVC_STATUS *svc)
 116 {
 117         display_svc_info(out_hnd, ACTION_HEADER   , svc);
 118         display_svc_info(out_hnd, ACTION_ENUMERATE, svc);
 119         display_svc_info(out_hnd, ACTION_FOOTER   , svc);
 120 }
 121
 122 /****************************************************************************
 123 nt service enum
 124 ****************************************************************************/
 125 BOOL msrpc_svc_enum(const char* srv_name,
 126                                 ENUM_SRVC_STATUS **svcs,
 127                                 uint32 *num_svcs,
 128                                 SVC_INFO_FN(info_fn),
 129                                 SVC_QUERY_FN(query_fn))
 130 {
 131         BOOL res = True;
 132         BOOL res1 = False;
 133         int i;
 134         uint32 resume_hnd = 0;
 135         uint32 buf_size = 0;
 136         uint32 dos_error = 0;
 137
 138         POLICY_HND pol_scm;
 139
 140         (*svcs) = NULL;
 141         (*num_svcs) = 0;
 142
 143         /* open service control manager receive a policy handle */
 144         res = res ? svc_open_sc_man( srv_name, NULL, 0x80000004,
 145                                 &pol_scm) : False;
 146
 147         do
 148         {
 149                 if ((*svcs) != NULL)
 150                 {
 151                         free(*svcs);
 152                         (*svcs) = NULL;
 153                         (*num_svcs) = 0;
 154                 }
 155
 156                 buf_size += 0x800;
 157
 158                 /* enumerate services */
 159                 res1 = res ? svc_enum_svcs( &pol_scm,
 160                                         0x00000030, 0x00000003,
 161                                         &buf_size, &resume_hnd, &dos_error,
 162                                         svcs, num_svcs) : False;
 163
 164         } while (res1 && dos_error == ERRmoredata);
 165
 166         for (i = 0; i < (*num_svcs) && (*svcs) != NULL && res1; i++)
 167         {
 168                 fstring svc_name;
 169
 170                 unistr_to_ascii(svc_name, (*svcs)[i].uni_srvc_name.buffer,
 171                                 sizeof(svc_name)-1);
 172
 173                 if (query_fn != NULL)
 174                 {
 175                         res1 = svc_query_service(&pol_scm,
 176                                                  svc_name, query_fn);
 177                 }
 178                 else if (info_fn != NULL)
 179                 {
 180                         info_fn(&(*svcs)[i]);
 181                 }
 182         }
 183
 184         res = res ? svc_close(&pol_scm) : False;
 185
 186         return res1;
 187 }
 188
 189 /****************************************************************************
 190 nt service enum
 191 ****************************************************************************/
 192 void cmd_svc_enum(struct client_info *info, int argc, char *argv[])
 193 {
 194         ENUM_SRVC_STATUS *svcs = NULL;
 195         uint32 num_svcs = 0;
 196         BOOL request_info = False;
 197         int opt;
 198         fstring srv_name;
 199
 200         fstrcpy(srv_name, "\\\\");
 201         fstrcat(srv_name, info->dest_host);
 202         strupper(srv_name);
 203
 204         while ((opt = getopt(argc, argv,"i")) != EOF)
 205         {
 206                 switch (opt)
 207                 {
 208                         case 'i':
 209                         {
 210                                 request_info = True;
 211                                 break;
 212                         }
 213                 }
 214         }
 215
 216         report(out_hnd,"Services\n");
 217         report(out_hnd,"--------\n");
 218
 219         msrpc_svc_enum(srv_name, &svcs, &num_svcs,
 220                        request_info ? NULL : svc_display_svc_info,
 221                        request_info ? svc_display_query_svc_cfg : NULL);
 222
 223         if (svcs != NULL)
 224         {
 225                 free(svcs);
 226         }
 227 }
 228
 229 /****************************************************************************
 230 nt stop service
 231 ****************************************************************************/
 232 void cmd_svc_stop(struct client_info *info, int argc, char *argv[])
 233 {
 234         BOOL res = True;
 235         BOOL res1 = True;
 236         char *svc_name;
 237         BOOL res2 = True;
 238         POLICY_HND pol_svc;
 239         POLICY_HND pol_scm;
 240
 241         fstring srv_name;
 242
 243         fstrcpy(srv_name, "\\\\");
 244         fstrcat(srv_name, info->dest_host);
 245         strupper(srv_name);
 246
 247         DEBUG(4,("cmd_svc_stop: server:%s\n", srv_name));
 248
 249         if (argc < 2)
 250         {
 251                 report(out_hnd,"svcstop <service name>\n");
 252                 return;
 253         }
 254
 255         svc_name = argv[1];
 256
 257         /* open service control manager receive a policy handle */
 258         res = res ? svc_open_sc_man( srv_name, NULL, 0x80000000,
 259                                 &pol_scm) : False;
 260
 261         res1 = res ? svc_open_service( &pol_scm,
 262                                        svc_name, 0x00000020,
 263                                        &pol_svc) : False;
 264         res2 = res1 ? svc_stop_service(&pol_svc, 0x1) : False;
 265
 266         res1 = res1 ? svc_close(&pol_svc) : False;
 267         res  = res  ? svc_close(&pol_scm) : False;
 268
 269         if (res2)
 270         {
 271                 report(out_hnd,"Stopped Service %s\n", svc_name);
 272                 DEBUG(5,("cmd_svc_stop: succeeded\n"));
 273         }
 274         else
 275                 report(out_hnd,"Failed Service Stopped (%s)\n", svc_name);
 276         {
 277                 DEBUG(5,("cmd_svc_stop: failed\n"));
 278         }
 279 }
 280
 281 /****************************************************************************
 282 nt start service
 283 ****************************************************************************/
 284 void cmd_svc_start(struct client_info *info, int argc, char *argv[])
 285 {
 286         BOOL res = True;
 287         BOOL res1 = True;
 288         char *svc_name;
 289         BOOL res2 = True;
 290         POLICY_HND pol_svc;
 291         POLICY_HND pol_scm;
 292
 293         fstring srv_name;
 294
 295         fstrcpy(srv_name, "\\\\");
 296         fstrcat(srv_name, info->dest_host);
 297         strupper(srv_name);
 298
 299         DEBUG(4,("cmd_svc_start: server:%s\n", srv_name));
 300
 301         if (argc < 2)
 302         {
 303                 report(out_hnd,"svcstart <service name> [arg 0] [arg 1]...]\n");
 304                 return;
 305         }
 306
 307         argv++;
 308         argc--;
 309
 310         svc_name = argv[0];
 311
 312         argv++;
 313         argc--;
 314
 315         /* open service control manager receive a policy handle */
 316         res = res ? svc_open_sc_man( srv_name, NULL, 0x80000000,
 317                                 &pol_scm) : False;
 318
 319         res1 = res ? svc_open_service( &pol_scm,
 320                                        svc_name, 0x80000010,
 321                                        &pol_svc) : False;
 322         res2 = res1 ? svc_start_service( &pol_svc, argc, argv) : False;
 323
 324         res1 = res1 ? svc_close(&pol_svc) : False;
 325         res  = res  ? svc_close(&pol_scm) : False;
 326
 327         if (res2)
 328         {
 329                 report(out_hnd,"Started Service %s\n", svc_name);
 330                 DEBUG(5,("cmd_svc_start: succeeded\n"));
 331         }
 332         else
 333                 report(out_hnd,"Failed Service Startup (%s)\n", svc_name);
 334         {
 335                 DEBUG(5,("cmd_svc_start: failed\n"));
 336         }
 337 }
 338
 339 /****************************************************************************
 340 nt service set
 341 ****************************************************************************/
 342 void cmd_svc_set(struct client_info *info, int argc, char *argv[])
 343 {
 344         BOOL res = True;
 345         BOOL res2 = True;
 346         BOOL res3;
 347         POLICY_HND pol_svc;
 348         QUERY_SERVICE_CONFIG cfg;
 349         uint32 svc_buf_size = 0x8000;
 350
 351         char *svc_name;
 352
 353         POLICY_HND pol_scm;
 354
 355         fstring srv_name;
 356
 357         fstrcpy(srv_name, "\\\\");
 358         fstrcat(srv_name, info->dest_host);
 359         strupper(srv_name);
 360
 361         DEBUG(4,("cmd_svc_set: server:%s\n", srv_name));
 362
 363         if (argc < 2)
 364         {
 365                 report(out_hnd,"svcset <service name>\n");
 366                 return;
 367         }
 368
 369         svc_name = argv[1];
 370
 371         /* open service control manager receive a policy handle */
 372         res = res ? svc_open_sc_man( srv_name, NULL, 0x80000004,
 373                                 &pol_scm) : False;
 374
 375         res2 = res ? svc_open_service( &pol_scm,
 376                                        svc_name, 0x80000001,
 377                                        &pol_svc) : False;
 378         res3 = res2 ? svc_query_svc_cfg( &pol_svc, &cfg,
 379                                        &svc_buf_size) : False;
 380
 381         if (res3)
 382         {
 383                 res3 = svc_change_svc_cfg(&pol_svc,
 384                                    cfg.service_type,
 385                                    cfg.start_type,
 386                                    0xffffffff,
 387                                    0,
 388                                    NULL, NULL,
 389                                    cfg.tag_id,
 390                                    NULL, "administrator", NULL, NULL);
 391
 392         }
 393
 394         res2 = res2 ? svc_close(&pol_svc) : False;
 395
 396         res = res ? svc_close(&pol_scm) : False;
 397
 398         if (res3)
 399         {
 400                 DEBUG(5,("cmd_svc_set: change succeeded\n"));
 401         }
 402         else
 403         {
 404                 DEBUG(5,("cmd_svc_set: change failed\n"));
 405         }
 406 }
 407