source/rpc_parse/parse_svcctl.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald (Jerry) 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 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_RPC_PARSE
  25
  26 /*******************************************************************
  27 ********************************************************************/
  28
  29 static BOOL svcctl_io_service_status( const char *desc, SERVICE_STATUS *status, prs_struct *ps, int depth )
  30 {
  31
  32         prs_debug(ps, depth, desc, "svcctl_io_service_status");
  33         depth++;
  34
  35         if(!prs_uint32("type", ps, depth, &status->type))
  36                 return False;
  37
  38         if(!prs_uint32("state", ps, depth, &status->state))
  39                 return False;
  40
  41         if(!prs_uint32("controls_accepted", ps, depth, &status->controls_accepted))
  42                 return False;
  43
  44         if(!prs_uint32("win32_exit_code", ps, depth, &status->win32_exit_code))
  45                 return False;
  46
  47         if(!prs_uint32("service_exit_code", ps, depth, &status->service_exit_code))
  48                 return False;
  49
  50         if(!prs_uint32("check_point", ps, depth, &status->check_point))
  51                 return False;
  52
  53         if(!prs_uint32("wait_hint", ps, depth, &status->wait_hint))
  54                 return False;
  55
  56         return True;
  57 }
  58
  59 /*******************************************************************
  60 ********************************************************************/
  61
  62 static BOOL svcctl_io_service_config( const char *desc, SERVICE_CONFIG *config, prs_struct *ps, int depth )
  63 {
  64
  65         prs_debug(ps, depth, desc, "svcctl_io_service_config");
  66         depth++;
  67
  68         if(!prs_uint32("service_type", ps, depth, &config->service_type))
  69                 return False;
  70         if(!prs_uint32("start_type", ps, depth, &config->start_type))
  71                 return False;
  72         if(!prs_uint32("error_control", ps, depth, &config->error_control))
  73                 return False;
  74
  75         if (!prs_io_unistr2_p("", ps, depth, &config->executablepath))
  76                 return False;
  77         if (!prs_io_unistr2_p("", ps, depth, &config->loadordergroup))
  78                 return False;
  79
  80         if(!prs_uint32("tag_id", ps, depth, &config->tag_id))
  81                 return False;
  82
  83         if (!prs_io_unistr2_p("", ps, depth, &config->dependencies))
  84                 return False;
  85         if (!prs_io_unistr2_p("", ps, depth, &config->startname))
  86                 return False;
  87         if (!prs_io_unistr2_p("", ps, depth, &config->displayname))
  88                 return False;
  89
  90         if (!prs_io_unistr2("", ps, depth, config->executablepath))
  91                 return False;
  92         if (!prs_io_unistr2("", ps, depth, config->loadordergroup))
  93                 return False;
  94         if (!prs_io_unistr2("", ps, depth, config->dependencies))
  95                 return False;
  96         if (!prs_io_unistr2("", ps, depth, config->startname))
  97                 return False;
  98         if (!prs_io_unistr2("", ps, depth, config->displayname))
  99                 return False;
 100
 101         return True;
 102 }
 103 /*******************************************************************
 104 ********************************************************************/
 105
 106 BOOL svcctl_io_service_description( const char *desc, UNISTR2 *svcdesc, prs_struct *ps, int depth )
 107 {
 108
 109         prs_debug(ps, depth, desc, "svcctl_io_service_description");
 110         depth++;
 111
 112         //DEBUG(10, ("_svcctl_io_service_description: descrption is [%s]\n",svcdesc));
 113         if (!prs_io_unistr2("", ps, depth, svcdesc))
 114                 return False;
 115
 116         return True;
 117 }
 118
 119
 120 /*******************************************************************
 121 ********************************************************************/
 122
 123 BOOL svcctl_io_enum_services_status( const char *desc, ENUM_SERVICES_STATUS *enum_status, RPC_BUFFER *buffer, int depth )
 124 {
 125         prs_struct *ps=&buffer->prs;
 126
 127         prs_debug(ps, depth, desc, "svcctl_io_enum_services_status");
 128         depth++;
 129
 130         if ( !smb_io_relstr("servicename", buffer, depth, &enum_status->servicename) )
 131                 return False;
 132         if ( !smb_io_relstr("displayname", buffer, depth, &enum_status->displayname) )
 133                 return False;
 134
 135         if ( !svcctl_io_service_status("svc_status", &enum_status->status, ps, depth) )
 136                 return False;
 137
 138         return True;
 139 }
 140
 141 /*******************************************************************
 142 ********************************************************************/
 143
 144 uint32 svcctl_sizeof_enum_services_status( ENUM_SERVICES_STATUS *status )
 145 {
 146         uint32 size = 0;
 147
 148         size += size_of_relative_string( &status->servicename );
 149         size += size_of_relative_string( &status->displayname );
 150         size += sizeof(SERVICE_STATUS);
 151
 152         return size;
 153 }
 154
 155 /*******************************************************************
 156 ********************************************************************/
 157
 158 BOOL svcctl_io_q_close_service(const char *desc, SVCCTL_Q_CLOSE_SERVICE *q_u, prs_struct *ps, int depth)
 159 {
 160
 161         if (q_u == NULL)
 162                 return False;
 163
 164         prs_debug(ps, depth, desc, "svcctl_io_q_close_service");
 165         depth++;
 166
 167         if(!prs_align(ps))
 168                 return False;
 169
 170         if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth))
 171                 return False;
 172
 173         return True;
 174 }
 175
 176
 177 /*******************************************************************
 178 ********************************************************************/
 179
 180 BOOL svcctl_io_r_close_service(const char *desc, SVCCTL_R_CLOSE_SERVICE *r_u, prs_struct *ps, int depth)
 181 {
 182         if (r_u == NULL)
 183                 return False;
 184
 185         prs_debug(ps, depth, desc, "svcctl_io_r_close_service");
 186         depth++;
 187
 188         if(!prs_align(ps))
 189             return False;
 190
 191         if(!smb_io_pol_hnd("pol_handle", &r_u->handle, ps, depth))
 192            return False;
 193
 194         if(!prs_werror("status", ps, depth, &r_u->status))
 195                 return False;
 196
 197         return True;
 198 }
 199
 200 /*******************************************************************
 201 ********************************************************************/
 202
 203 BOOL svcctl_io_q_open_scmanager(const char *desc, SVCCTL_Q_OPEN_SCMANAGER *q_u, prs_struct *ps, int depth)
 204 {
 205         if (q_u == NULL)
 206                 return False;
 207
 208         prs_debug(ps, depth, desc, "svcctl_io_q_open_scmanager");
 209         depth++;
 210
 211         if(!prs_align(ps))
 212                 return False;
 213
 214         if(!prs_pointer("servername", ps, depth, (void**)&q_u->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 215                 return False;
 216         if(!prs_align(ps))
 217                 return False;
 218
 219         if(!prs_pointer("database", ps, depth, (void**)&q_u->database, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2))
 220                 return False;
 221         if(!prs_align(ps))
 222                 return False;
 223
 224         if(!prs_uint32("access", ps, depth, &q_u->access))
 225                 return False;
 226
 227         return True;
 228 }
 229
 230 /*******************************************************************
 231 ********************************************************************/
 232
 233 BOOL svcctl_io_r_open_scmanager(const char *desc, SVCCTL_R_OPEN_SCMANAGER *r_u, prs_struct *ps, int depth)
 234 {
 235         if (r_u == NULL)
 236                 return False;
 237
 238         prs_debug(ps, depth, desc, "svcctl_io_r_open_scmanager");
 239         depth++;
 240
 241         if(!prs_align(ps))
 242                 return False;
 243
 244         if(!smb_io_pol_hnd("scm_pol", &r_u->handle, ps, depth))
 245                 return False;
 246
 247         if(!prs_werror("status", ps, depth, &r_u->status))
 248                 return False;
 249
 250         return True;
 251 }
 252
 253 /*******************************************************************
 254 ********************************************************************/
 255
 256 BOOL svcctl_io_q_get_display_name(const char *desc, SVCCTL_Q_GET_DISPLAY_NAME *q_u, prs_struct *ps, int depth)
 257 {
 258         if (q_u == NULL)
 259                 return False;
 260
 261         prs_debug(ps, depth, desc, "svcctl_io_q_get_display_name");
 262         depth++;
 263
 264         if(!prs_align(ps))
 265                 return False;
 266
 267         if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth))
 268                 return False;
 269
 270         if(!smb_io_unistr2("servicename", &q_u->servicename, 1, ps, depth))
 271                 return False;
 272
 273         if(!prs_align(ps))
 274                 return False;
 275
 276         if(!prs_uint32("display_name_len", ps, depth, &q_u->display_name_len))
 277                 return False;
 278
 279         return True;
 280 }
 281
 282 /*******************************************************************
 283 ********************************************************************/
 284
 285 BOOL init_svcctl_r_get_display_name( SVCCTL_R_GET_DISPLAY_NAME *r_u, const char *displayname )
 286 {
 287         r_u->display_name_len = strlen(displayname);
 288         init_unistr2( &r_u->displayname, displayname, UNI_STR_TERMINATE );
 289
 290         return True;
 291 }
 292
 293 /*******************************************************************
 294 ********************************************************************/
 295
 296 BOOL svcctl_io_r_get_display_name(const char *desc, SVCCTL_R_GET_DISPLAY_NAME *r_u, prs_struct *ps, int depth)
 297 {
 298         if (r_u == NULL)
 299                 return False;
 300
 301         prs_debug(ps, depth, desc, "svcctl_io_r_get_display_name");
 302         depth++;
 303
 304         if(!prs_align(ps))
 305                 return False;
 306
 307
 308         if(!smb_io_unistr2("displayname", &r_u->displayname, 1, ps, depth))
 309                 return False;
 310
 311         if(!prs_align(ps))
 312                 return False;
 313
 314         if(!prs_uint32("display_name_len", ps, depth, &r_u->display_name_len))
 315                 return False;
 316
 317         if(!prs_werror("status", ps, depth, &r_u->status))
 318                 return False;
 319
 320         return True;
 321 }
 322
 323
 324 /*******************************************************************
 325 ********************************************************************/
 326
 327 BOOL svcctl_io_q_open_service(const char *desc, SVCCTL_Q_OPEN_SERVICE *q_u, prs_struct *ps, int depth)
 328 {
 329         if (q_u == NULL)
 330                 return False;
 331
 332         prs_debug(ps, depth, desc, "svcctl_io_q_open_service");
 333         depth++;
 334
 335         if(!prs_align(ps))
 336                 return False;
 337
 338         if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth))
 339                 return False;
 340
 341         if(!smb_io_unistr2("servicename", &q_u->servicename, 1, ps, depth))
 342                 return False;
 343
 344         if(!prs_align(ps))
 345                 return False;
 346
 347         if(!prs_uint32("access", ps, depth, &q_u->access))
 348                 return False;
 349
 350         return True;
 351 }
 352
 353 /*******************************************************************
 354 ********************************************************************/
 355
 356 BOOL svcctl_io_r_open_service(const char *desc, SVCCTL_R_OPEN_SERVICE *r_u, prs_struct *ps, int depth)
 357 {
 358         if (r_u == NULL)
 359                 return False;
 360
 361         prs_debug(ps, depth, desc, "svcctl_io_r_open_service");
 362         depth++;
 363
 364         if(!prs_align(ps))
 365                 return False;
 366
 367         if(!smb_io_pol_hnd("service_pol", &r_u->handle, ps, depth))
 368                 return False;
 369
 370         if(!prs_werror("status", ps, depth, &r_u->status))
 371                 return False;
 372
 373         return True;
 374 }
 375
 376 /*******************************************************************
 377 ********************************************************************/
 378
 379 BOOL svcctl_io_q_query_status(const char *desc, SVCCTL_Q_QUERY_STATUS *q_u, prs_struct *ps, int depth)
 380 {
 381         if (q_u == NULL)
 382                 return False;
 383
 384         prs_debug(ps, depth, desc, "svcctl_io_q_query_status");
 385         depth++;
 386
 387         if(!prs_align(ps))
 388                 return False;
 389
 390         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 391                 return False;
 392
 393         return True;
 394 }
 395
 396 /*******************************************************************
 397 ********************************************************************/
 398
 399 BOOL svcctl_io_r_query_status(const char *desc, SVCCTL_R_QUERY_STATUS *r_u, prs_struct *ps, int depth)
 400 {
 401         if (r_u == NULL)
 402                 return False;
 403
 404         prs_debug(ps, depth, desc, "svcctl_io_r_query_status");
 405         depth++;
 406
 407         if(!prs_align(ps))
 408                 return False;
 409
 410         if(!svcctl_io_service_status("service_status", &r_u->svc_status, ps, depth))
 411                 return False;
 412
 413         if(!prs_werror("status", ps, depth, &r_u->status))
 414                 return False;
 415
 416         return True;
 417 }
 418
 419 /*******************************************************************
 420 ********************************************************************/
 421
 422 BOOL svcctl_io_q_enum_services_status(const char *desc, SVCCTL_Q_ENUM_SERVICES_STATUS *q_u, prs_struct *ps, int depth)
 423 {
 424         if (q_u == NULL)
 425                 return False;
 426
 427         prs_debug(ps, depth, desc, "svcctl_io_q_enum_services_status");
 428         depth++;
 429
 430         if(!prs_align(ps))
 431                 return False;
 432
 433         if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth))
 434                 return False;
 435
 436         if(!prs_uint32("type", ps, depth, &q_u->type))
 437                 return False;
 438         if(!prs_uint32("state", ps, depth, &q_u->state))
 439                 return False;
 440         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
 441                 return False;
 442
 443         if(!prs_pointer("resume", ps, depth, (void**)&q_u->resume, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
 444                 return False;
 445
 446         return True;
 447 }
 448
 449 /*******************************************************************
 450 ********************************************************************/
 451
 452 BOOL svcctl_io_r_enum_services_status(const char *desc, SVCCTL_R_ENUM_SERVICES_STATUS *r_u, prs_struct *ps, int depth)
 453 {
 454         if (r_u == NULL)
 455                 return False;
 456
 457         prs_debug(ps, depth, desc, "svcctl_io_r_enum_services_status");
 458         depth++;
 459
 460         if(!prs_align(ps))
 461                 return False;
 462
 463         if (!prs_rpcbuffer("", ps, depth, &r_u->buffer))
 464                 return False;
 465
 466         if(!prs_align(ps))
 467                 return False;
 468
 469         if(!prs_uint32("needed", ps, depth, &r_u->needed))
 470                 return False;
 471         if(!prs_uint32("returned", ps, depth, &r_u->returned))
 472                 return False;
 473
 474         if(!prs_pointer("resume", ps, depth, (void**)&r_u->resume, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32))
 475                 return False;
 476
 477         if(!prs_werror("status", ps, depth, &r_u->status))
 478                 return False;
 479
 480         return True;
 481 }
 482
 483 /*******************************************************************
 484 ********************************************************************/
 485
 486 BOOL svcctl_io_q_start_service(const char *desc, SVCCTL_Q_START_SERVICE *q_u, prs_struct *ps, int depth)
 487 {
 488         if (q_u == NULL)
 489                 return False;
 490
 491         prs_debug(ps, depth, desc, "svcctl_io_q_start_service");
 492         depth++;
 493
 494         if(!prs_align(ps))
 495                 return False;
 496
 497         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 498                 return False;
 499
 500         if(!prs_uint32("parmcount", ps, depth, &q_u->parmcount))
 501                 return False;
 502
 503         if ( !prs_pointer("rights", ps, depth, (void**)&q_u->parameters, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) )
 504                 return False;
 505
 506         return True;
 507 }
 508
 509 /*******************************************************************
 510 ********************************************************************/
 511
 512 BOOL svcctl_io_r_start_service(const char *desc, SVCCTL_R_START_SERVICE *r_u, prs_struct *ps, int depth)
 513 {
 514         if (r_u == NULL)
 515                 return False;
 516
 517         prs_debug(ps, depth, desc, "svcctl_io_r_start_service");
 518         depth++;
 519
 520         if(!prs_werror("status", ps, depth, &r_u->status))
 521                 return False;
 522
 523         return True;
 524 }
 525
 526
 527 /*******************************************************************
 528 ********************************************************************/
 529
 530 BOOL svcctl_io_q_enum_dependent_services(const char *desc, SVCCTL_Q_ENUM_DEPENDENT_SERVICES *q_u, prs_struct *ps, int depth)
 531 {
 532         if (q_u == NULL)
 533                 return False;
 534
 535         prs_debug(ps, depth, desc, "svcctl_io_q_enum_dependent_services");
 536         depth++;
 537
 538         if(!prs_align(ps))
 539                 return False;
 540
 541         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 542                 return False;
 543
 544         if(!prs_uint32("state", ps, depth, &q_u->state))
 545                 return False;
 546         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
 547                 return False;
 548
 549         return True;
 550 }
 551
 552 /*******************************************************************
 553 ********************************************************************/
 554
 555 BOOL svcctl_io_r_enum_dependent_services(const char *desc, SVCCTL_R_ENUM_DEPENDENT_SERVICES *r_u, prs_struct *ps, int depth)
 556 {
 557         if (r_u == NULL)
 558                 return False;
 559
 560         prs_debug(ps, depth, desc, "svcctl_io_r_enum_dependent_services");
 561         depth++;
 562
 563         if(!prs_align(ps))
 564                 return False;
 565
 566         if (!prs_rpcbuffer("", ps, depth, &r_u->buffer))
 567                 return False;
 568
 569         if(!prs_align(ps))
 570                 return False;
 571
 572         if(!prs_uint32("needed", ps, depth, &r_u->needed))
 573                 return False;
 574         if(!prs_uint32("returned", ps, depth, &r_u->returned))
 575                 return False;
 576
 577         if(!prs_werror("status", ps, depth, &r_u->status))
 578                 return False;
 579
 580         return True;
 581 }
 582
 583 /*******************************************************************
 584 ********************************************************************/
 585
 586 BOOL svcctl_io_q_control_service(const char *desc, SVCCTL_Q_CONTROL_SERVICE *q_u, prs_struct *ps, int depth)
 587 {
 588         if (q_u == NULL)
 589                 return False;
 590
 591         prs_debug(ps, depth, desc, "svcctl_io_q_control_service");
 592         depth++;
 593
 594         if(!prs_align(ps))
 595                 return False;
 596
 597         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 598                 return False;
 599
 600         if(!prs_uint32("control", ps, depth, &q_u->control))
 601                 return False;
 602
 603         return True;
 604 }
 605
 606 /*******************************************************************
 607 ********************************************************************/
 608
 609 BOOL svcctl_io_r_control_service(const char *desc, SVCCTL_R_CONTROL_SERVICE *r_u, prs_struct *ps, int depth)
 610 {
 611         if (r_u == NULL)
 612                 return False;
 613
 614         prs_debug(ps, depth, desc, "svcctl_io_r_control_service");
 615         depth++;
 616
 617         if(!prs_align(ps))
 618                 return False;
 619
 620         if(!svcctl_io_service_status("service_status", &r_u->svc_status, ps, depth))
 621                 return False;
 622
 623         if(!prs_werror("status", ps, depth, &r_u->status))
 624                 return False;
 625
 626         return True;
 627 }
 628
 629
 630 /*******************************************************************
 631 ********************************************************************/
 632
 633 BOOL svcctl_io_q_query_service_config(const char *desc, SVCCTL_Q_QUERY_SERVICE_CONFIG *q_u, prs_struct *ps, int depth)
 634 {
 635         if (q_u == NULL)
 636                 return False;
 637
 638         prs_debug(ps, depth, desc, "svcctl_io_q_query_service_config");
 639         depth++;
 640
 641         if(!prs_align(ps))
 642                 return False;
 643
 644         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 645                 return False;
 646
 647         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
 648                 return False;
 649
 650         return True;
 651 }
 652
 653 /*******************************************************************
 654 ********************************************************************/
 655
 656 BOOL svcctl_io_r_query_service_config(const char *desc, SVCCTL_R_QUERY_SERVICE_CONFIG *r_u, prs_struct *ps, int depth)
 657 {
 658         if (r_u == NULL)
 659                 return False;
 660
 661         prs_debug(ps, depth, desc, "svcctl_io_r_query_service_config");
 662         depth++;
 663
 664
 665         if(!prs_align(ps))
 666                 return False;
 667
 668         if(!svcctl_io_service_config("config", &r_u->config, ps, depth))
 669                 return False;
 670
 671         if(!prs_uint32("needed", ps, depth, &r_u->needed))
 672                 return False;
 673
 674         if(!prs_werror("status", ps, depth, &r_u->status))
 675                 return False;
 676
 677
 678         return True;
 679 }
 680
 681 /*******************************************************************
 682 ********************************************************************/
 683
 684 BOOL svcctl_io_q_query_service_config2(const char *desc, SVCCTL_Q_QUERY_SERVICE_CONFIG2 *q_u, prs_struct *ps, int depth)
 685 {
 686         if (q_u == NULL)
 687                 return False;
 688
 689         prs_debug(ps, depth, desc, "svcctl_io_q_query_service_config2");
 690         depth++;
 691
 692         if(!prs_align(ps))
 693                 return False;
 694
 695         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 696                 return False;
 697
 698         if(!prs_uint32("info_level", ps, depth, &q_u->info_level))
 699                 return False;
 700
 701         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
 702                 return False;
 703
 704         return True;
 705 }
 706
 707
 708 /*******************************************************************
 709  Creates a service description response buffer.
 710  The format seems to be DWORD:length of buffer
 711                         DWORD:offset (fixed as four)
 712                         UNISTR: unicode description in the rest of the buffer
 713 ********************************************************************/
 714
 715 void init_service_description_buffer(RPC_DATA_BLOB *str,  const char *service_desc, int blob_length)
 716 {
 717         uint32 offset;
 718         char *bp;
 719
 720         ZERO_STRUCTP(str);
 721
 722         offset = 4;
 723
 724         /* set up string lengths. */
 725
 726         str->buf_len = create_rpc_blob(str, blob_length);
 727         DEBUG(10, ("init_service_description buffer: Allocated a blob of [%d] \n",str->buf_len));
 728
 729         if ( str && str->buffer && str->buf_len) {
 730                 memset(str->buffer,0,str->buf_len);
 731                 memcpy(str->buffer, &offset, sizeof(uint32));
 732                 bp = &str->buffer[4];
 733                 if (service_desc) {
 734                         rpcstr_push(bp, service_desc,str->buf_len-4,0);
 735                 }
 736         }
 737 }
 738
 739 /*******************************************************************
 740 ********************************************************************/
 741
 742 BOOL svcctl_io_q_query_service_status_ex(const char *desc, SVCCTL_Q_QUERY_SERVICE_STATUSEX *q_u, prs_struct *ps, int depth)
 743 {
 744         if (q_u == NULL)
 745                 return False;
 746
 747         prs_debug(ps, depth, desc, "svcctl_io_q_query_service_status_ex");
 748         depth++;
 749
 750         if(!prs_align(ps))
 751                 return False;
 752
 753         if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth))
 754                 return False;
 755
 756         if(!prs_uint32("info_level", ps, depth, &q_u->info_level))
 757                 return False;
 758
 759         if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size))
 760                 return False;
 761
 762         return True;
 763
 764 }
 765
 766 /*******************************************************************
 767 ********************************************************************/
 768
 769 BOOL svcctl_io_r_query_service_status_ex(const char *desc, SVCCTL_R_QUERY_SERVICE_STATUSEX *r_u, prs_struct *ps, int depth)
 770 {
 771         if ( !r_u )
 772                 return False;
 773
 774         prs_debug(ps, depth, desc, "svcctl_io_r_query_service_status_ex");
 775                 depth++;
 776
 777         if (!prs_rpcbuffer("", ps, depth, &r_u->buffer))
 778                 return False;
 779
 780         if(!prs_align(ps))
 781                 return False;
 782
 783         if(!prs_uint32("needed", ps, depth, &r_u->needed))
 784                 return False;
 785
 786         if(!prs_werror("status", ps, depth, &r_u->status))
 787                 return False;
 788
 789         return True;
 790 }
 791
 792 /*******************************************************************
 793 ********************************************************************/
 794
 795 BOOL svcctl_io_r_query_service_config2(const char *desc, SVCCTL_R_QUERY_SERVICE_CONFIG2 *r_u, prs_struct *ps, int depth)
 796 {
 797         if ( !r_u )
 798                 return False;
 799
 800         prs_debug(ps, depth, desc, "svcctl_io_r_query_service_config2");
 801         depth++;
 802
 803         if(!prs_align(ps))
 804                 return False;
 805
 806         if(!prs_uint32("returned", ps, depth, &r_u->returned))
 807                 return False;
 808
 809         if (r_u->returned > 4) {
 810                 if (!prs_uint32("offset", ps, depth, &r_u->offset))
 811                         return False;
 812                 if(!prs_unistr2(True, "description     ", ps, depth, r_u->description))
 813                         return False;
 814                 if(!prs_align(ps))
 815                         return False;
 816         } else {
 817                 /* offset does double duty here */
 818                 r_u->offset = 0;
 819                 if (!prs_uint32("offset", ps, depth, &r_u->offset))
 820                         return False;
 821         }
 822
 823         if (!prs_uint32("needed", ps, depth, &r_u->needed))
 824                 return False;
 825
 826         if(!prs_werror("status", ps, depth, &r_u->status))
 827                 return False;
 828
 829         return True;
 830 }
 831
 832