source4/torture/rpc/svcctl.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for srvsvc rpc operations
   4
   5    Copyright (C) Jelmer Vernooij 2004
   6    Copyright (C) Guenther Deschner 2008,2009
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "librpc/gen_ndr/ndr_svcctl_c.h"
  24 #include "librpc/gen_ndr/ndr_svcctl.h"
  25 #include "torture/rpc/rpc.h"
  26 #include "param/param.h"
  27
  28 #define TORTURE_DEFAULT_SERVICE "Spooler"
  29
  30 static bool test_OpenSCManager(struct dcerpc_binding_handle *b,
  31                                struct torture_context *tctx,
  32                                struct policy_handle *h)
  33 {
  34         struct svcctl_OpenSCManagerW r;
  35
  36         r.in.MachineName = NULL;
  37         r.in.DatabaseName = NULL;
  38         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
  39         r.out.handle = h;
  40
  41         torture_assert_ntstatus_ok(tctx,
  42                                    dcerpc_svcctl_OpenSCManagerW_r(b, tctx, &r),
  43                                    "OpenSCManager failed!");
  44
  45         return true;
  46 }
  47
  48 static bool test_CloseServiceHandle(struct dcerpc_binding_handle *b,
  49                                     struct torture_context *tctx,
  50                                     struct policy_handle *h)
  51 {
  52         struct svcctl_CloseServiceHandle r;
  53
  54         r.in.handle = h;
  55         r.out.handle = h;
  56         torture_assert_ntstatus_ok(tctx,
  57                                    dcerpc_svcctl_CloseServiceHandle_r(b, tctx, &r),
  58                                    "CloseServiceHandle failed");
  59
  60         return true;
  61 }
  62
  63 static bool test_OpenService(struct dcerpc_binding_handle *b,
  64                              struct torture_context *tctx,
  65                              struct policy_handle *h,
  66                              const char *name,
  67                              struct policy_handle *s)
  68 {
  69         struct svcctl_OpenServiceW r;
  70
  71         r.in.scmanager_handle = h;
  72         r.in.ServiceName = name;
  73         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
  74         r.out.handle = s;
  75
  76         torture_assert_ntstatus_ok(tctx,
  77                                    dcerpc_svcctl_OpenServiceW_r(b, tctx, &r),
  78                                    "OpenServiceW failed!");
  79         torture_assert_werr_ok(tctx, r.out.result, "OpenServiceW failed!");
  80
  81         return true;
  82
  83 }
  84
  85 static bool test_QueryServiceStatus(struct torture_context *tctx,
  86                                     struct dcerpc_pipe *p)
  87 {
  88         struct svcctl_QueryServiceStatus r;
  89         struct policy_handle h, s;
  90         struct SERVICE_STATUS service_status;
  91         NTSTATUS status;
  92         struct dcerpc_binding_handle *b = p->binding_handle;
  93
  94         if (!test_OpenSCManager(b, tctx, &h))
  95                 return false;
  96
  97         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
  98                 return false;
  99
 100         r.in.handle = &s;
 101         r.out.service_status = &service_status;
 102
 103         status = dcerpc_svcctl_QueryServiceStatus_r(b, tctx, &r);
 104         torture_assert_ntstatus_ok(tctx, status, "QueryServiceStatus failed!");
 105         torture_assert_werr_ok(tctx, r.out.result, "QueryServiceStatus failed!");
 106
 107         if (!test_CloseServiceHandle(b, tctx, &s))
 108                 return false;
 109
 110         if (!test_CloseServiceHandle(b, tctx, &h))
 111                 return false;
 112
 113         return true;
 114 }
 115
 116 static bool test_QueryServiceStatusEx(struct torture_context *tctx, struct dcerpc_pipe *p)
 117 {
 118         struct svcctl_QueryServiceStatusEx r;
 119         struct policy_handle h, s;
 120         NTSTATUS status;
 121         struct dcerpc_binding_handle *b = p->binding_handle;
 122
 123         uint32_t info_level = SVC_STATUS_PROCESS_INFO;
 124         uint8_t *buffer;
 125         uint32_t offered = 0;
 126         uint32_t needed = 0;
 127
 128         if (!test_OpenSCManager(b, tctx, &h))
 129                 return false;
 130
 131         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 132                 return false;
 133
 134         buffer = talloc(tctx, uint8_t);
 135
 136         r.in.handle = &s;
 137         r.in.info_level = info_level;
 138         r.in.offered = offered;
 139         r.out.buffer = buffer;
 140         r.out.needed = &needed;
 141
 142         status = dcerpc_svcctl_QueryServiceStatusEx_r(b, tctx, &r);
 143         torture_assert_ntstatus_ok(tctx, status, "QueryServiceStatusEx failed!");
 144
 145         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 146                 r.in.offered = needed;
 147                 buffer = talloc_array(tctx, uint8_t, needed);
 148                 r.out.buffer = buffer;
 149
 150                 status = dcerpc_svcctl_QueryServiceStatusEx_r(b, tctx, &r);
 151                 torture_assert_ntstatus_ok(tctx, status, "QueryServiceStatusEx failed!");
 152                 torture_assert_werr_ok(tctx, r.out.result, "QueryServiceStatusEx failed!");
 153         }
 154
 155         if (!test_CloseServiceHandle(b, tctx, &s))
 156                 return false;
 157
 158         if (!test_CloseServiceHandle(b, tctx, &h))
 159                 return false;
 160
 161         return true;
 162 }
 163
 164 static bool test_QueryServiceConfigW(struct torture_context *tctx,
 165                                      struct dcerpc_pipe *p)
 166 {
 167         struct svcctl_QueryServiceConfigW r;
 168         struct QUERY_SERVICE_CONFIG query;
 169         struct policy_handle h, s;
 170         NTSTATUS status;
 171         struct dcerpc_binding_handle *b = p->binding_handle;
 172
 173         uint32_t offered = 0;
 174         uint32_t needed = 0;
 175
 176         if (!test_OpenSCManager(b, tctx, &h))
 177                 return false;
 178
 179         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 180                 return false;
 181
 182         r.in.handle = &s;
 183         r.in.offered = offered;
 184         r.out.query = &query;
 185         r.out.needed = &needed;
 186
 187         status = dcerpc_svcctl_QueryServiceConfigW_r(b, tctx, &r);
 188         torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfigW failed!");
 189
 190         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 191                 r.in.offered = needed;
 192                 status = dcerpc_svcctl_QueryServiceConfigW_r(b, tctx, &r);
 193                 torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfigW failed!");
 194         }
 195
 196         torture_assert_werr_ok(tctx, r.out.result, "QueryServiceConfigW failed!");
 197
 198         if (!test_CloseServiceHandle(b, tctx, &s))
 199                 return false;
 200
 201         if (!test_CloseServiceHandle(b, tctx, &h))
 202                 return false;
 203
 204         return true;
 205 }
 206
 207 static bool test_QueryServiceConfig2W(struct torture_context *tctx, struct dcerpc_pipe *p)
 208 {
 209         struct svcctl_QueryServiceConfig2W r;
 210         struct policy_handle h, s;
 211         NTSTATUS status;
 212         struct dcerpc_binding_handle *b = p->binding_handle;
 213
 214         uint32_t info_level = SERVICE_CONFIG_DESCRIPTION;
 215         uint8_t *buffer;
 216         uint32_t offered = 0;
 217         uint32_t needed = 0;
 218
 219         if (!test_OpenSCManager(b, tctx, &h))
 220                 return false;
 221
 222         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 223                 return false;
 224
 225         buffer = talloc(tctx, uint8_t);
 226
 227         r.in.handle = &s;
 228         r.in.info_level = info_level;
 229         r.in.offered = offered;
 230         r.out.buffer = buffer;
 231         r.out.needed = &needed;
 232
 233         status = dcerpc_svcctl_QueryServiceConfig2W_r(b, tctx, &r);
 234         torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfig2W failed!");
 235
 236         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 237                 r.in.offered = needed;
 238                 buffer = talloc_array(tctx, uint8_t, needed);
 239                 r.out.buffer = buffer;
 240
 241                 status = dcerpc_svcctl_QueryServiceConfig2W_r(b, tctx, &r);
 242                 torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfig2W failed!");
 243                 torture_assert_werr_ok(tctx, r.out.result, "QueryServiceConfig2W failed!");
 244         }
 245
 246         r.in.info_level = SERVICE_CONFIG_FAILURE_ACTIONS;
 247         r.in.offered = offered;
 248         r.out.buffer = buffer;
 249         r.out.needed = &needed;
 250
 251         status = dcerpc_svcctl_QueryServiceConfig2W_r(b, tctx, &r);
 252         torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfig2W failed!");
 253
 254         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 255                 r.in.offered = needed;
 256                 buffer = talloc_array(tctx, uint8_t, needed);
 257                 r.out.buffer = buffer;
 258
 259                 status = dcerpc_svcctl_QueryServiceConfig2W_r(b, tctx, &r);
 260                 torture_assert_ntstatus_ok(tctx, status, "QueryServiceConfig2W failed!");
 261                 torture_assert_werr_ok(tctx, r.out.result, "QueryServiceConfig2W failed!");
 262         }
 263
 264         if (!test_CloseServiceHandle(b, tctx, &s))
 265                 return false;
 266
 267         if (!test_CloseServiceHandle(b, tctx, &h))
 268                 return false;
 269
 270         return true;
 271 }
 272
 273 static bool test_QueryServiceObjectSecurity(struct torture_context *tctx,
 274                                             struct dcerpc_pipe *p)
 275 {
 276         struct svcctl_QueryServiceObjectSecurity r;
 277         struct policy_handle h, s;
 278         struct dcerpc_binding_handle *b = p->binding_handle;
 279
 280         uint8_t *buffer;
 281         uint32_t needed;
 282
 283         if (!test_OpenSCManager(b, tctx, &h))
 284                 return false;
 285
 286         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 287                 return false;
 288
 289         r.in.handle = &s;
 290         r.in.security_flags = 0;
 291         r.in.offered = 0;
 292         r.out.buffer = NULL;
 293         r.out.needed = &needed;
 294
 295         torture_assert_ntstatus_ok(tctx,
 296                 dcerpc_svcctl_QueryServiceObjectSecurity_r(b, tctx, &r),
 297                 "QueryServiceObjectSecurity failed!");
 298         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
 299                 "QueryServiceObjectSecurity failed!");
 300
 301         r.in.security_flags = SECINFO_DACL;
 302
 303         torture_assert_ntstatus_ok(tctx,
 304                 dcerpc_svcctl_QueryServiceObjectSecurity_r(b, tctx, &r),
 305                 "QueryServiceObjectSecurity failed!");
 306
 307         if (W_ERROR_EQUAL(r.out.result, WERR_INSUFFICIENT_BUFFER)) {
 308                 r.in.offered = needed;
 309                 buffer = talloc_array(tctx, uint8_t, needed);
 310                 r.out.buffer = buffer;
 311                 torture_assert_ntstatus_ok(tctx,
 312                         dcerpc_svcctl_QueryServiceObjectSecurity_r(b, tctx, &r),
 313                         "QueryServiceObjectSecurity failed!");
 314         }
 315
 316         torture_assert_werr_ok(tctx, r.out.result, "QueryServiceObjectSecurity failed!");
 317
 318         if (!test_CloseServiceHandle(b, tctx, &s))
 319                 return false;
 320
 321         if (!test_CloseServiceHandle(b, tctx, &h))
 322                 return false;
 323
 324         return true;
 325 }
 326
 327 static bool test_StartServiceW(struct torture_context *tctx,
 328                                struct dcerpc_pipe *p)
 329 {
 330         struct svcctl_StartServiceW r;
 331         struct policy_handle h, s;
 332         struct dcerpc_binding_handle *b = p->binding_handle;
 333
 334         if (!test_OpenSCManager(b, tctx, &h))
 335                 return false;
 336
 337         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 338                 return false;
 339
 340         r.in.handle = &s;
 341         r.in.NumArgs = 0;
 342         r.in.Arguments = NULL;
 343
 344         torture_assert_ntstatus_ok(tctx,
 345                 dcerpc_svcctl_StartServiceW_r(b, tctx, &r),
 346                 "StartServiceW failed!");
 347         torture_assert_werr_equal(tctx, r.out.result,
 348                 WERR_SERVICE_ALREADY_RUNNING,
 349                 "StartServiceW failed!");
 350
 351         if (!test_CloseServiceHandle(b, tctx, &s))
 352                 return false;
 353
 354         if (!test_CloseServiceHandle(b, tctx, &h))
 355                 return false;
 356
 357         return true;
 358 }
 359
 360 static bool test_ControlService(struct torture_context *tctx,
 361                                 struct dcerpc_pipe *p)
 362 {
 363         struct svcctl_ControlService r;
 364         struct policy_handle h, s;
 365         struct SERVICE_STATUS service_status;
 366         struct dcerpc_binding_handle *b = p->binding_handle;
 367
 368         if (!test_OpenSCManager(b, tctx, &h))
 369                 return false;
 370
 371         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 372                 return false;
 373
 374         r.in.handle = &s;
 375         r.in.control = 0;
 376         r.out.service_status = &service_status;
 377
 378         torture_assert_ntstatus_ok(tctx,
 379                 dcerpc_svcctl_ControlService_r(b, tctx, &r),
 380                 "ControlService failed!");
 381         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
 382                 "ControlService failed!");
 383
 384         if (!test_CloseServiceHandle(b, tctx, &s))
 385                 return false;
 386
 387         if (!test_CloseServiceHandle(b, tctx, &h))
 388                 return false;
 389
 390         return true;
 391 }
 392
 393 static bool test_EnumServicesStatus(struct torture_context *tctx, struct dcerpc_pipe *p)
 394 {
 395         struct svcctl_EnumServicesStatusW r;
 396         struct policy_handle h;
 397         int i;
 398         NTSTATUS status;
 399         uint32_t resume_handle = 0;
 400         struct ENUM_SERVICE_STATUSW *service = NULL;
 401         uint32_t needed = 0;
 402         uint32_t services_returned = 0;
 403         struct dcerpc_binding_handle *b = p->binding_handle;
 404
 405         if (!test_OpenSCManager(b, tctx, &h))
 406                 return false;
 407
 408         r.in.handle = &h;
 409         r.in.type = SERVICE_TYPE_WIN32;
 410         r.in.state = SERVICE_STATE_ALL;
 411         r.in.offered = 0;
 412         r.in.resume_handle = &resume_handle;
 413         r.out.service = NULL;
 414         r.out.resume_handle = &resume_handle;
 415         r.out.services_returned = &services_returned;
 416         r.out.needed = &needed;
 417
 418         status = dcerpc_svcctl_EnumServicesStatusW_r(b, tctx, &r);
 419
 420         torture_assert_ntstatus_ok(tctx, status, "EnumServicesStatus failed!");
 421
 422         if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
 423                 r.in.offered = needed;
 424                 r.out.service = talloc_array(tctx, uint8_t, needed);
 425
 426                 status = dcerpc_svcctl_EnumServicesStatusW_r(b, tctx, &r);
 427
 428                 torture_assert_ntstatus_ok(tctx, status, "EnumServicesStatus failed!");
 429                 torture_assert_werr_ok(tctx, r.out.result, "EnumServicesStatus failed");
 430         }
 431
 432         if (services_returned > 0) {
 433
 434                 enum ndr_err_code ndr_err;
 435                 DATA_BLOB blob;
 436                 struct ndr_pull *ndr;
 437
 438                 blob.length = r.in.offered;
 439                 blob.data = talloc_steal(tctx, r.out.service);
 440
 441                 ndr = ndr_pull_init_blob(&blob, tctx, lp_iconv_convenience(tctx->lp_ctx));
 442
 443                 service = talloc_array(tctx, struct ENUM_SERVICE_STATUSW, services_returned);
 444                 if (!service) {
 445                         return false;
 446                 }
 447
 448                 ndr_err = ndr_pull_ENUM_SERVICE_STATUSW_array(
 449                                 ndr, services_returned, service);
 450                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 451                         return false;
 452                 }
 453         }
 454
 455         for(i = 0; i < services_returned; i++) {
 456
 457                 torture_assert(tctx, service[i].service_name,
 458                         "Service without name returned!");
 459
 460                 printf("%-20s   \"%s\", Type: %d, State: %d\n",
 461                         service[i].service_name, service[i].display_name,
 462                         service[i].status.type, service[i].status.state);
 463         }
 464
 465         if (!test_CloseServiceHandle(b, tctx, &h))
 466                 return false;
 467
 468         return true;
 469 }
 470
 471 static bool test_EnumDependentServicesW(struct torture_context *tctx,
 472                                         struct dcerpc_pipe *p)
 473 {
 474         struct svcctl_EnumDependentServicesW r;
 475         struct policy_handle h, s;
 476         uint32_t needed;
 477         uint32_t services_returned;
 478         uint32_t i;
 479         uint32_t states[] = { SERVICE_STATE_ACTIVE,
 480                               SERVICE_STATE_INACTIVE,
 481                               SERVICE_STATE_ALL };
 482         struct dcerpc_binding_handle *b = p->binding_handle;
 483
 484         if (!test_OpenSCManager(b, tctx, &h))
 485                 return false;
 486
 487         if (!test_OpenService(b, tctx, &h, TORTURE_DEFAULT_SERVICE, &s))
 488                 return false;
 489
 490         r.in.service = &s;
 491         r.in.offered = 0;
 492         r.in.state = 0;
 493         r.out.service_status = NULL;
 494         r.out.services_returned = &services_returned;
 495         r.out.needed = &needed;
 496
 497         torture_assert_ntstatus_ok(tctx,
 498                 dcerpc_svcctl_EnumDependentServicesW_r(b, tctx, &r),
 499                 "EnumDependentServicesW failed!");
 500
 501         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_PARAM,
 502                 "EnumDependentServicesW failed!");
 503
 504         for (i=0; i<ARRAY_SIZE(states); i++) {
 505
 506                 r.in.state = states[i];
 507
 508                 torture_assert_ntstatus_ok(tctx,
 509                         dcerpc_svcctl_EnumDependentServicesW_r(b, tctx, &r),
 510                         "EnumDependentServicesW failed!");
 511
 512                 if (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA)) {
 513                         r.in.offered = needed;
 514                         r.out.service_status = talloc_array(tctx, uint8_t, needed);
 515
 516                         torture_assert_ntstatus_ok(tctx,
 517                                 dcerpc_svcctl_EnumDependentServicesW_r(b, tctx, &r),
 518                                 "EnumDependentServicesW failed!");
 519
 520                 }
 521
 522                 torture_assert_werr_ok(tctx, r.out.result,
 523                         "EnumDependentServicesW failed");
 524         }
 525
 526         if (!test_CloseServiceHandle(b, tctx, &s))
 527                 return false;
 528
 529         if (!test_CloseServiceHandle(b, tctx, &h))
 530                 return false;
 531
 532         return true;
 533 }
 534
 535 static bool test_SCManager(struct torture_context *tctx,
 536                            struct dcerpc_pipe *p)
 537 {
 538         struct policy_handle h;
 539         struct dcerpc_binding_handle *b = p->binding_handle;
 540
 541         if (!test_OpenSCManager(b, tctx, &h))
 542                 return false;
 543
 544         if (!test_CloseServiceHandle(b, tctx, &h))
 545                 return false;
 546
 547         return true;
 548 }
 549
 550 struct torture_suite *torture_rpc_svcctl(TALLOC_CTX *mem_ctx)
 551 {
 552         struct torture_suite *suite = torture_suite_create(mem_ctx, "SVCCTL");
 553         struct torture_rpc_tcase *tcase;
 554
 555         tcase = torture_suite_add_rpc_iface_tcase(suite, "svcctl", &ndr_table_svcctl);
 556
 557         torture_rpc_tcase_add_test(tcase, "SCManager",
 558                                    test_SCManager);
 559         torture_rpc_tcase_add_test(tcase, "EnumServicesStatus",
 560                                    test_EnumServicesStatus);
 561         torture_rpc_tcase_add_test(tcase, "EnumDependentServicesW",
 562                                    test_EnumDependentServicesW);
 563         torture_rpc_tcase_add_test(tcase, "QueryServiceStatus",
 564                                    test_QueryServiceStatus);
 565         torture_rpc_tcase_add_test(tcase, "QueryServiceStatusEx",
 566                                    test_QueryServiceStatusEx);
 567         torture_rpc_tcase_add_test(tcase, "QueryServiceConfigW",
 568                                    test_QueryServiceConfigW);
 569         torture_rpc_tcase_add_test(tcase, "QueryServiceConfig2W",
 570                                    test_QueryServiceConfig2W);
 571         torture_rpc_tcase_add_test(tcase, "QueryServiceObjectSecurity",
 572                                    test_QueryServiceObjectSecurity);
 573         torture_rpc_tcase_add_test(tcase, "StartServiceW",
 574                                    test_StartServiceW);
 575         torture_rpc_tcase_add_test(tcase, "ControlService",
 576                                    test_ControlService);
 577
 578         return suite;
 579 }