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 29static 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_werror("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 62static 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 107BOOL svcctl_io_enum_services_status( const char *desc, ENUM_SERVICES_STATUS *enum_status, RPC_BUFFER *buffer, int depth ) 108{ 109 prs_struct *ps=&buffer->prs; 110 111 prs_debug(ps, depth, desc, "svcctl_io_enum_services_status"); 112 depth++; 113 114 if ( !smb_io_relstr("servicename", buffer, depth, &enum_status->servicename) ) 115 return False; 116 if ( !smb_io_relstr("displayname", buffer, depth, &enum_status->displayname) ) 117 return False; 118 119 if ( !svcctl_io_service_status("svc_status", &enum_status->status, ps, depth) ) 120 return False; 121 122 return True; 123} 124 125/******************************************************************* 126********************************************************************/ 127 128BOOL svcctl_io_service_status_process( const char *desc, SERVICE_STATUS_PROCESS *status, RPC_BUFFER *buffer, int depth ) 129{ 130 prs_struct *ps=&buffer->prs; 131 132 prs_debug(ps, depth, desc, "svcctl_io_service_status_process"); 133 depth++; 134 135 if ( !svcctl_io_service_status("status", &status->status, ps, depth) ) 136 return False; 137 if(!prs_align(ps)) 138 return False; 139 140 if(!prs_uint32("process_id", ps, depth, &status->process_id)) 141 return False; 142 if(!prs_uint32("service_flags", ps, depth, &status->service_flags)) 143 return False; 144 145 return True; 146} 147 148/******************************************************************* 149********************************************************************/ 150 151uint32 svcctl_sizeof_enum_services_status( ENUM_SERVICES_STATUS *status ) 152{ 153 uint32 size = 0; 154 155 size += size_of_relative_string( &status->servicename ); 156 size += size_of_relative_string( &status->displayname ); 157 size += sizeof(SERVICE_STATUS); 158 159 return size; 160} 161 162/******************************************************************** 163********************************************************************/ 164 165static uint32 sizeof_unistr2( UNISTR2 *string ) 166{ 167 uint32 size = 0; 168 169 if ( !string ) 170 return 0; 171 172 size = sizeof(uint32) * 3; /* length fields */ 173 size += 2 * string->uni_max_len; /* string data */ 174 size += size % 4; /* alignment */ 175 176 return size; 177} 178 179/******************************************************************** 180********************************************************************/ 181 182uint32 svcctl_sizeof_service_config( SERVICE_CONFIG *config ) 183{ 184 uint32 size = 0; 185 186 size = sizeof(uint32) * 4; /* static uint32 fields */ 187 188 /* now add the UNISTR2 + pointer sizes */ 189 190 size += sizeof(uint32) * sizeof_unistr2(config->executablepath); 191 size += sizeof(uint32) * sizeof_unistr2(config->loadordergroup); 192 size += sizeof(uint32) * sizeof_unistr2(config->dependencies); 193 size += sizeof(uint32) * sizeof_unistr2(config->startname); 194 size += sizeof(uint32) * sizeof_unistr2(config->displayname); 195 196 return size; 197} 198 199 200 201/******************************************************************* 202********************************************************************/ 203 204BOOL svcctl_io_q_close_service(const char *desc, SVCCTL_Q_CLOSE_SERVICE *q_u, prs_struct *ps, int depth) 205{ 206 207 if (q_u == NULL) 208 return False; 209 210 prs_debug(ps, depth, desc, "svcctl_io_q_close_service"); 211 depth++; 212 213 if(!prs_align(ps)) 214 return False; 215 216 if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth)) 217 return False; 218 219 return True; 220} 221 222 223/******************************************************************* 224********************************************************************/ 225 226BOOL svcctl_io_r_close_service(const char *desc, SVCCTL_R_CLOSE_SERVICE *r_u, prs_struct *ps, int depth) 227{ 228 if (r_u == NULL) 229 return False; 230 231 prs_debug(ps, depth, desc, "svcctl_io_r_close_service"); 232 depth++; 233 234 if(!prs_align(ps)) 235 return False; 236 237 if(!smb_io_pol_hnd("pol_handle", &r_u->handle, ps, depth)) 238 return False; 239 240 if(!prs_werror("status", ps, depth, &r_u->status)) 241 return False; 242 243 return True; 244} 245 246/******************************************************************* 247********************************************************************/ 248 249BOOL svcctl_io_q_open_scmanager(const char *desc, SVCCTL_Q_OPEN_SCMANAGER *q_u, prs_struct *ps, int depth) 250{ 251 if (q_u == NULL) 252 return False; 253 254 prs_debug(ps, depth, desc, "svcctl_io_q_open_scmanager"); 255 depth++; 256 257 if(!prs_align(ps)) 258 return False; 259 260 if(!prs_pointer("servername", ps, depth, (void*)&q_u->servername, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2)) 261 return False; 262 if(!prs_align(ps)) 263 return False; 264 265 if(!prs_pointer("database", ps, depth, (void*)&q_u->database, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2)) 266 return False; 267 if(!prs_align(ps)) 268 return False; 269 270 if(!prs_uint32("access", ps, depth, &q_u->access)) 271 return False; 272 273 return True; 274} 275 276/******************************************************************* 277********************************************************************/ 278 279BOOL svcctl_io_r_open_scmanager(const char *desc, SVCCTL_R_OPEN_SCMANAGER *r_u, prs_struct *ps, int depth) 280{ 281 if (r_u == NULL) 282 return False; 283 284 prs_debug(ps, depth, desc, "svcctl_io_r_open_scmanager"); 285 depth++; 286 287 if(!prs_align(ps)) 288 return False; 289 290 if(!smb_io_pol_hnd("scm_pol", &r_u->handle, ps, depth)) 291 return False; 292 293 if(!prs_werror("status", ps, depth, &r_u->status)) 294 return False; 295 296 return True; 297} 298 299/******************************************************************* 300********************************************************************/ 301 302BOOL svcctl_io_q_get_display_name(const char *desc, SVCCTL_Q_GET_DISPLAY_NAME *q_u, prs_struct *ps, int depth) 303{ 304 if (q_u == NULL) 305 return False; 306 307 prs_debug(ps, depth, desc, "svcctl_io_q_get_display_name"); 308 depth++; 309 310 if(!prs_align(ps)) 311 return False; 312 313 if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth)) 314 return False; 315 316 if(!smb_io_unistr2("servicename", &q_u->servicename, 1, ps, depth)) 317 return False; 318 319 if(!prs_align(ps)) 320 return False; 321 322 if(!prs_uint32("display_name_len", ps, depth, &q_u->display_name_len)) 323 return False; 324 325 return True; 326} 327 328/******************************************************************* 329********************************************************************/ 330 331BOOL init_svcctl_r_get_display_name( SVCCTL_R_GET_DISPLAY_NAME *r_u, const char *displayname ) 332{ 333 r_u->display_name_len = strlen(displayname); 334 init_unistr2( &r_u->displayname, displayname, UNI_STR_TERMINATE ); 335 336 return True; 337} 338 339/******************************************************************* 340********************************************************************/ 341 342BOOL svcctl_io_r_get_display_name(const char *desc, SVCCTL_R_GET_DISPLAY_NAME *r_u, prs_struct *ps, int depth) 343{ 344 if (r_u == NULL) 345 return False; 346 347 prs_debug(ps, depth, desc, "svcctl_io_r_get_display_name"); 348 depth++; 349 350 if(!prs_align(ps)) 351 return False; 352 353 354 if(!smb_io_unistr2("displayname", &r_u->displayname, 1, ps, depth)) 355 return False; 356 357 if(!prs_align(ps)) 358 return False; 359 360 if(!prs_uint32("display_name_len", ps, depth, &r_u->display_name_len)) 361 return False; 362 363 if(!prs_werror("status", ps, depth, &r_u->status)) 364 return False; 365 366 return True; 367} 368 369 370/******************************************************************* 371********************************************************************/ 372 373BOOL svcctl_io_q_open_service(const char *desc, SVCCTL_Q_OPEN_SERVICE *q_u, prs_struct *ps, int depth) 374{ 375 if (q_u == NULL) 376 return False; 377 378 prs_debug(ps, depth, desc, "svcctl_io_q_open_service"); 379 depth++; 380 381 if(!prs_align(ps)) 382 return False; 383 384 if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth)) 385 return False; 386 387 if(!smb_io_unistr2("servicename", &q_u->servicename, 1, ps, depth)) 388 return False; 389 390 if(!prs_align(ps)) 391 return False; 392 393 if(!prs_uint32("access", ps, depth, &q_u->access)) 394 return False; 395 396 return True; 397} 398 399/******************************************************************* 400********************************************************************/ 401 402BOOL svcctl_io_r_open_service(const char *desc, SVCCTL_R_OPEN_SERVICE *r_u, prs_struct *ps, int depth) 403{ 404 if (r_u == NULL) 405 return False; 406 407 prs_debug(ps, depth, desc, "svcctl_io_r_open_service"); 408 depth++; 409 410 if(!prs_align(ps)) 411 return False; 412 413 if(!smb_io_pol_hnd("service_pol", &r_u->handle, ps, depth)) 414 return False; 415 416 if(!prs_werror("status", ps, depth, &r_u->status)) 417 return False; 418 419 return True; 420} 421 422/******************************************************************* 423********************************************************************/ 424 425BOOL svcctl_io_q_query_status(const char *desc, SVCCTL_Q_QUERY_STATUS *q_u, prs_struct *ps, int depth) 426{ 427 if (q_u == NULL) 428 return False; 429 430 prs_debug(ps, depth, desc, "svcctl_io_q_query_status"); 431 depth++; 432 433 if(!prs_align(ps)) 434 return False; 435 436 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 437 return False; 438 439 return True; 440} 441 442/******************************************************************* 443********************************************************************/ 444 445BOOL svcctl_io_r_query_status(const char *desc, SVCCTL_R_QUERY_STATUS *r_u, prs_struct *ps, int depth) 446{ 447 if (r_u == NULL) 448 return False; 449 450 prs_debug(ps, depth, desc, "svcctl_io_r_query_status"); 451 depth++; 452 453 if(!prs_align(ps)) 454 return False; 455 456 if(!svcctl_io_service_status("service_status", &r_u->svc_status, ps, depth)) 457 return False; 458 459 if(!prs_werror("status", ps, depth, &r_u->status)) 460 return False; 461 462 return True; 463} 464 465/******************************************************************* 466********************************************************************/ 467 468BOOL svcctl_io_q_enum_services_status(const char *desc, SVCCTL_Q_ENUM_SERVICES_STATUS *q_u, prs_struct *ps, int depth) 469{ 470 if (q_u == NULL) 471 return False; 472 473 prs_debug(ps, depth, desc, "svcctl_io_q_enum_services_status"); 474 depth++; 475 476 if(!prs_align(ps)) 477 return False; 478 479 if(!smb_io_pol_hnd("scm_pol", &q_u->handle, ps, depth)) 480 return False; 481 482 if(!prs_uint32("type", ps, depth, &q_u->type)) 483 return False; 484 if(!prs_uint32("state", ps, depth, &q_u->state)) 485 return False; 486 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 487 return False; 488 489 if(!prs_pointer("resume", ps, depth, (void*)&q_u->resume, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32)) 490 return False; 491 492 return True; 493} 494 495/******************************************************************* 496********************************************************************/ 497 498BOOL svcctl_io_r_enum_services_status(const char *desc, SVCCTL_R_ENUM_SERVICES_STATUS *r_u, prs_struct *ps, int depth) 499{ 500 if (r_u == NULL) 501 return False; 502 503 prs_debug(ps, depth, desc, "svcctl_io_r_enum_services_status"); 504 depth++; 505 506 if(!prs_align(ps)) 507 return False; 508 509 if (!prs_rpcbuffer("", ps, depth, &r_u->buffer)) 510 return False; 511 512 if(!prs_align(ps)) 513 return False; 514 515 if(!prs_uint32("needed", ps, depth, &r_u->needed)) 516 return False; 517 if(!prs_uint32("returned", ps, depth, &r_u->returned)) 518 return False; 519 520 if(!prs_pointer("resume", ps, depth, (void*)&r_u->resume, sizeof(uint32), (PRS_POINTER_CAST)prs_uint32)) 521 return False; 522 523 if(!prs_werror("status", ps, depth, &r_u->status)) 524 return False; 525 526 return True; 527} 528 529/******************************************************************* 530********************************************************************/ 531 532BOOL svcctl_io_q_start_service(const char *desc, SVCCTL_Q_START_SERVICE *q_u, prs_struct *ps, int depth) 533{ 534 if (q_u == NULL) 535 return False; 536 537 prs_debug(ps, depth, desc, "svcctl_io_q_start_service"); 538 depth++; 539 540 if(!prs_align(ps)) 541 return False; 542 543 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 544 return False; 545 546 if(!prs_uint32("parmcount", ps, depth, &q_u->parmcount)) 547 return False; 548 549 if ( !prs_pointer("rights", ps, depth, (void*)&q_u->parameters, sizeof(UNISTR4_ARRAY), (PRS_POINTER_CAST)prs_unistr4_array) ) 550 return False; 551 552 return True; 553} 554 555/******************************************************************* 556********************************************************************/ 557 558BOOL svcctl_io_r_start_service(const char *desc, SVCCTL_R_START_SERVICE *r_u, prs_struct *ps, int depth) 559{ 560 if (r_u == NULL) 561 return False; 562 563 prs_debug(ps, depth, desc, "svcctl_io_r_start_service"); 564 depth++; 565 566 if(!prs_werror("status", ps, depth, &r_u->status)) 567 return False; 568 569 return True; 570} 571 572 573/******************************************************************* 574********************************************************************/ 575 576BOOL svcctl_io_q_enum_dependent_services(const char *desc, SVCCTL_Q_ENUM_DEPENDENT_SERVICES *q_u, prs_struct *ps, int depth) 577{ 578 if (q_u == NULL) 579 return False; 580 581 prs_debug(ps, depth, desc, "svcctl_io_q_enum_dependent_services"); 582 depth++; 583 584 if(!prs_align(ps)) 585 return False; 586 587 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 588 return False; 589 590 if(!prs_uint32("state", ps, depth, &q_u->state)) 591 return False; 592 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 593 return False; 594 595 return True; 596} 597 598/******************************************************************* 599********************************************************************/ 600 601BOOL svcctl_io_r_enum_dependent_services(const char *desc, SVCCTL_R_ENUM_DEPENDENT_SERVICES *r_u, prs_struct *ps, int depth) 602{ 603 if (r_u == NULL) 604 return False; 605 606 prs_debug(ps, depth, desc, "svcctl_io_r_enum_dependent_services"); 607 depth++; 608 609 if(!prs_align(ps)) 610 return False; 611 612 if (!prs_rpcbuffer("", ps, depth, &r_u->buffer)) 613 return False; 614 615 if(!prs_align(ps)) 616 return False; 617 618 if(!prs_uint32("needed", ps, depth, &r_u->needed)) 619 return False; 620 if(!prs_uint32("returned", ps, depth, &r_u->returned)) 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 632BOOL svcctl_io_q_control_service(const char *desc, SVCCTL_Q_CONTROL_SERVICE *q_u, prs_struct *ps, int depth) 633{ 634 if (q_u == NULL) 635 return False; 636 637 prs_debug(ps, depth, desc, "svcctl_io_q_control_service"); 638 depth++; 639 640 if(!prs_align(ps)) 641 return False; 642 643 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 644 return False; 645 646 if(!prs_uint32("control", ps, depth, &q_u->control)) 647 return False; 648 649 return True; 650} 651 652/******************************************************************* 653********************************************************************/ 654 655BOOL svcctl_io_r_control_service(const char *desc, SVCCTL_R_CONTROL_SERVICE *r_u, prs_struct *ps, int depth) 656{ 657 if (r_u == NULL) 658 return False; 659 660 prs_debug(ps, depth, desc, "svcctl_io_r_control_service"); 661 depth++; 662 663 if(!prs_align(ps)) 664 return False; 665 666 if(!svcctl_io_service_status("service_status", &r_u->svc_status, ps, depth)) 667 return False; 668 669 if(!prs_werror("status", ps, depth, &r_u->status)) 670 return False; 671 672 return True; 673} 674 675 676/******************************************************************* 677********************************************************************/ 678 679BOOL svcctl_io_q_query_service_config(const char *desc, SVCCTL_Q_QUERY_SERVICE_CONFIG *q_u, prs_struct *ps, int depth) 680{ 681 if (q_u == NULL) 682 return False; 683 684 prs_debug(ps, depth, desc, "svcctl_io_q_query_service_config"); 685 depth++; 686 687 if(!prs_align(ps)) 688 return False; 689 690 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 691 return False; 692 693 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 694 return False; 695 696 return True; 697} 698 699/******************************************************************* 700********************************************************************/ 701 702BOOL svcctl_io_r_query_service_config(const char *desc, SVCCTL_R_QUERY_SERVICE_CONFIG *r_u, prs_struct *ps, int depth) 703{ 704 if (r_u == NULL) 705 return False; 706 707 prs_debug(ps, depth, desc, "svcctl_io_r_query_service_config"); 708 depth++; 709 710 711 if(!prs_align(ps)) 712 return False; 713 714 if(!svcctl_io_service_config("config", &r_u->config, ps, depth)) 715 return False; 716 717 if(!prs_uint32("needed", ps, depth, &r_u->needed)) 718 return False; 719 720 if(!prs_werror("status", ps, depth, &r_u->status)) 721 return False; 722 723 724 return True; 725} 726 727/******************************************************************* 728********************************************************************/ 729 730BOOL svcctl_io_q_query_service_config2(const char *desc, SVCCTL_Q_QUERY_SERVICE_CONFIG2 *q_u, prs_struct *ps, int depth) 731{ 732 if (q_u == NULL) 733 return False; 734 735 prs_debug(ps, depth, desc, "svcctl_io_q_query_service_config2"); 736 depth++; 737 738 if(!prs_align(ps)) 739 return False; 740 741 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 742 return False; 743 744 if(!prs_uint32("level", ps, depth, &q_u->level)) 745 return False; 746 747 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 748 return False; 749 750 return True; 751} 752 753 754/******************************************************************* 755********************************************************************/ 756 757void init_service_description_buffer(SERVICE_DESCRIPTION *desc, const char *service_desc ) 758{ 759 desc->unknown = 0x04; /* always 0x0000 0004 (no idea what this is) */ 760 init_unistr( &desc->description, service_desc ); 761} 762 763/******************************************************************* 764********************************************************************/ 765 766BOOL svcctl_io_service_description( const char *desc, SERVICE_DESCRIPTION *description, RPC_BUFFER *buffer, int depth ) 767{ 768 prs_struct *ps = &buffer->prs; 769 770 prs_debug(ps, depth, desc, "svcctl_io_service_description"); 771 depth++; 772 773 if ( !prs_uint32("unknown", ps, depth, &description->unknown) ) 774 return False; 775 if ( !prs_unistr("description", ps, depth, &description->description) ) 776 return False; 777 778 return True; 779} 780 781/******************************************************************* 782********************************************************************/ 783 784uint32 svcctl_sizeof_service_description( SERVICE_DESCRIPTION *desc ) 785{ 786 if ( !desc ) 787 return 0; 788 789 /* make sure to include the terminating NULL */ 790 return ( sizeof(uint32) + (2*(str_len_uni(&desc->description)+1)) ); 791} 792 793/******************************************************************* 794********************************************************************/ 795 796static BOOL svcctl_io_action( const char *desc, SC_ACTION *action, prs_struct *ps, int depth ) 797{ 798 799 prs_debug(ps, depth, desc, "svcctl_io_action"); 800 depth++; 801 802 if ( !prs_uint32("type", ps, depth, &action->type) ) 803 return False; 804 if ( !prs_uint32("delay", ps, depth, &action->delay) ) 805 return False; 806 807 return True; 808} 809 810/******************************************************************* 811********************************************************************/ 812 813BOOL svcctl_io_service_fa( const char *desc, SERVICE_FAILURE_ACTIONS *fa, RPC_BUFFER *buffer, int depth ) 814{ 815 prs_struct *ps = &buffer->prs; 816 int i; 817 818 prs_debug(ps, depth, desc, "svcctl_io_service_description"); 819 depth++; 820 821 if ( !prs_uint32("reset_period", ps, depth, &fa->reset_period) ) 822 return False; 823 824 if ( !prs_pointer( desc, ps, depth, (void*)&fa->rebootmsg, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) ) 825 return False; 826 if ( !prs_pointer( desc, ps, depth, (void*)&fa->command, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) ) 827 return False; 828 829 if ( !prs_uint32("num_actions", ps, depth, &fa->num_actions) ) 830 return False; 831 832 if ( UNMARSHALLING(ps)) { 833 if (fa->num_actions) { 834 if ( !(fa->actions = TALLOC_ARRAY( get_talloc_ctx(), SC_ACTION, fa->num_actions )) ) { 835 DEBUG(0,("svcctl_io_service_fa: talloc() failure!\n")); 836 return False; 837 } 838 } else { 839 fa->actions = NULL; 840 } 841 } 842 843 for ( i=0; i<fa->num_actions; i++ ) { 844 if ( !svcctl_io_action( "actions", &fa->actions[i], ps, depth ) ) 845 return False; 846 } 847 848 return True; 849} 850 851/******************************************************************* 852********************************************************************/ 853 854uint32 svcctl_sizeof_service_fa( SERVICE_FAILURE_ACTIONS *fa) 855{ 856 uint32 size = 0; 857 858 if ( !fa ) 859 return 0; 860 861 size = sizeof(uint32) * 2; 862 size += sizeof_unistr2( fa->rebootmsg ); 863 size += sizeof_unistr2( fa->command ); 864 size += sizeof(SC_ACTION) * fa->num_actions; 865 866 return size; 867} 868 869/******************************************************************* 870********************************************************************/ 871 872BOOL svcctl_io_r_query_service_config2(const char *desc, SVCCTL_R_QUERY_SERVICE_CONFIG2 *r_u, prs_struct *ps, int depth) 873{ 874 if ( !r_u ) 875 return False; 876 877 prs_debug(ps, depth, desc, "svcctl_io_r_query_service_config2"); 878 depth++; 879 880 if ( !prs_align(ps) ) 881 return False; 882 883 if (!prs_rpcbuffer("", ps, depth, &r_u->buffer)) 884 return False; 885 if(!prs_align(ps)) 886 return False; 887 888 if (!prs_uint32("needed", ps, depth, &r_u->needed)) 889 return False; 890 891 if(!prs_werror("status", ps, depth, &r_u->status)) 892 return False; 893 894 return True; 895} 896 897 898/******************************************************************* 899********************************************************************/ 900 901BOOL svcctl_io_q_query_service_status_ex(const char *desc, SVCCTL_Q_QUERY_SERVICE_STATUSEX *q_u, prs_struct *ps, int depth) 902{ 903 if (q_u == NULL) 904 return False; 905 906 prs_debug(ps, depth, desc, "svcctl_io_q_query_service_status_ex"); 907 depth++; 908 909 if(!prs_align(ps)) 910 return False; 911 912 if(!smb_io_pol_hnd("service_pol", &q_u->handle, ps, depth)) 913 return False; 914 915 if(!prs_uint32("level", ps, depth, &q_u->level)) 916 return False; 917 918 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 919 return False; 920 921 return True; 922 923} 924 925/******************************************************************* 926********************************************************************/ 927 928BOOL svcctl_io_r_query_service_status_ex(const char *desc, SVCCTL_R_QUERY_SERVICE_STATUSEX *r_u, prs_struct *ps, int depth) 929{ 930 if ( !r_u ) 931 return False; 932 933 prs_debug(ps, depth, desc, "svcctl_io_r_query_service_status_ex"); 934 depth++; 935 936 if (!prs_rpcbuffer("", ps, depth, &r_u->buffer)) 937 return False; 938 939 if(!prs_align(ps)) 940 return False; 941 942 if(!prs_uint32("needed", ps, depth, &r_u->needed)) 943 return False; 944 945 if(!prs_werror("status", ps, depth, &r_u->status)) 946 return False; 947 948 return True; 949} 950 951/******************************************************************* 952********************************************************************/ 953 954BOOL svcctl_io_q_lock_service_db(const char *desc, SVCCTL_Q_LOCK_SERVICE_DB *q_u, prs_struct *ps, int depth) 955{ 956 if (q_u == NULL) 957 return False; 958 959 prs_debug(ps, depth, desc, "svcctl_io_q_lock_service_db"); 960 depth++; 961 962 if(!prs_align(ps)) 963 return False; 964 965 if(!smb_io_pol_hnd("scm_handle", &q_u->handle, ps, depth)) 966 return False; 967 968 return True; 969 970} 971 972/******************************************************************* 973********************************************************************/ 974 975BOOL svcctl_io_r_lock_service_db(const char *desc, SVCCTL_R_LOCK_SERVICE_DB *r_u, prs_struct *ps, int depth) 976{ 977 if ( !r_u ) 978 return False; 979 980 prs_debug(ps, depth, desc, "svcctl_io_r_lock_service_db"); 981 depth++; 982 983 if(!prs_align(ps)) 984 return False; 985 986 if(!smb_io_pol_hnd("lock_handle", &r_u->h_lock, ps, depth)) 987 return False; 988 989 if(!prs_werror("status", ps, depth, &r_u->status)) 990 return False; 991 992 return True; 993} 994 995/******************************************************************* 996********************************************************************/ 997 998BOOL svcctl_io_q_unlock_service_db(const char *desc, SVCCTL_Q_UNLOCK_SERVICE_DB *q_u, prs_struct *ps, int depth) 999{ 1000 if (q_u == NULL) 1001 return False; 1002 1003 prs_debug(ps, depth, desc, "svcctl_io_q_unlock_service_db"); 1004 depth++; 1005 1006 if(!prs_align(ps)) 1007 return False; 1008 1009 if(!smb_io_pol_hnd("h_lock", &q_u->h_lock, ps, depth)) 1010 return False; 1011 1012 return True; 1013 1014} 1015 1016/******************************************************************* 1017********************************************************************/ 1018 1019BOOL svcctl_io_r_unlock_service_db(const char *desc, SVCCTL_R_UNLOCK_SERVICE_DB *r_u, prs_struct *ps, int depth) 1020{ 1021 if ( !r_u ) 1022 return False; 1023 1024 prs_debug(ps, depth, desc, "svcctl_io_r_unlock_service_db"); 1025 depth++; 1026 1027 if(!prs_align(ps)) 1028 return False; 1029 1030 if(!prs_werror("status", ps, depth, &r_u->status)) 1031 return False; 1032 1033 return True; 1034} 1035 1036/******************************************************************* 1037********************************************************************/ 1038 1039BOOL svcctl_io_q_query_service_sec(const char *desc, SVCCTL_Q_QUERY_SERVICE_SEC *q_u, prs_struct *ps, int depth) 1040{ 1041 if (q_u == NULL) 1042 return False; 1043 1044 prs_debug(ps, depth, desc, "svcctl_io_q_query_service_sec"); 1045 depth++; 1046 1047 if(!prs_align(ps)) 1048 return False; 1049 1050 if(!smb_io_pol_hnd("handle", &q_u->handle, ps, depth)) 1051 return False; 1052 if(!prs_uint32("security_flags", ps, depth, &q_u->security_flags)) 1053 return False; 1054 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 1055 return False; 1056 1057 return True; 1058 1059} 1060 1061/******************************************************************* 1062********************************************************************/ 1063 1064BOOL svcctl_io_r_query_service_sec(const char *desc, SVCCTL_R_QUERY_SERVICE_SEC *r_u, prs_struct *ps, int depth) 1065{ 1066 if ( !r_u ) 1067 return False; 1068 1069 prs_debug(ps, depth, desc, "svcctl_io_r_query_service_sec"); 1070 depth++; 1071 1072 if(!prs_align(ps)) 1073 return False; 1074 1075 if (!prs_rpcbuffer("buffer", ps, depth, &r_u->buffer)) 1076 return False; 1077 1078 if(!prs_uint32("needed", ps, depth, &r_u->needed)) 1079 return False; 1080 1081 if(!prs_werror("status", ps, depth, &r_u->status)) 1082 return False; 1083 1084 return True; 1085} 1086 1087/******************************************************************* 1088********************************************************************/ 1089 1090BOOL svcctl_io_q_set_service_sec(const char *desc, SVCCTL_Q_SET_SERVICE_SEC *q_u, prs_struct *ps, int depth) 1091{ 1092 if (q_u == NULL) 1093 return False; 1094 1095 prs_debug(ps, depth, desc, "svcctl_io_q_set_service_sec"); 1096 depth++; 1097 1098 if(!prs_align(ps)) 1099 return False; 1100 1101 if(!smb_io_pol_hnd("handle", &q_u->handle, ps, depth)) 1102 return False; 1103 if(!prs_uint32("security_flags", ps, depth, &q_u->security_flags)) 1104 return False; 1105 1106 if (!prs_rpcbuffer("buffer", ps, depth, &q_u->buffer)) 1107 return False; 1108 1109 if(!prs_align(ps)) 1110 return False; 1111 1112 if(!prs_uint32("buffer_size", ps, depth, &q_u->buffer_size)) 1113 return False; 1114 1115 return True; 1116 1117} 1118 1119/******************************************************************* 1120********************************************************************/ 1121 1122BOOL svcctl_io_r_set_service_sec(const char *desc, SVCCTL_R_SET_SERVICE_SEC *r_u, prs_struct *ps, int depth) 1123{ 1124 if ( !r_u ) 1125 return False; 1126 1127 prs_debug(ps, depth, desc, "svcctl_io_r_set_service_sec"); 1128 depth++; 1129 1130 if(!prs_align(ps)) 1131 return False; 1132 1133 if(!prs_werror("status", ps, depth, &r_u->status)) 1134 return False; 1135 1136 return True; 1137} 1138 1139 1140 1141 1142