source/librpc/gen_ndr/srv_wkssvc.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/srv_wkssvc.h"
   8
   9 static bool api_wkssvc_NetWkstaGetInfo(pipes_struct *p)
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         NTSTATUS status;
  15         DATA_BLOB blob;
  16         struct wkssvc_NetWkstaGetInfo *r;
  17
  18         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTAGETINFO];
  19
  20         r = talloc(NULL, struct wkssvc_NetWkstaGetInfo);
  21         if (r == NULL) {
  22                 return False;
  23         }
  24
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return False;
  28         }
  29
  30         pull = ndr_pull_init_blob(&blob, r);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return False;
  34         }
  35
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         status = call->ndr_pull(pull, NDR_IN, r);
  38         if (NT_STATUS_IS_ERR(status)) {
  39                 talloc_free(r);
  40                 return False;
  41         }
  42
  43         if (DEBUGLEVEL >= 10)
  44                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, r);
  45
  46         ZERO_STRUCT(r->out);
  47         r->out.info = talloc_zero(r, union wkssvc_NetWkstaInfo);
  48         if (r->out.info == NULL) {
  49                 talloc_free(r);
  50                 return False;
  51         }
  52
  53         r->out.result = _wkssvc_NetWkstaGetInfo(p, r);
  54
  55         if (p->rng_fault_state) {
  56                 talloc_free(r);
  57                 /* Return True here, srv_pipe_hnd.c will take care */
  58                 return True;
  59         }
  60
  61         if (DEBUGLEVEL >= 10)
  62                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, r);
  63
  64         push = ndr_push_init_ctx(r);
  65         if (push == NULL) {
  66                 talloc_free(r);
  67                 return False;
  68         }
  69
  70         status = call->ndr_push(push, NDR_OUT, r);
  71         if (NT_STATUS_IS_ERR(status)) {
  72                 talloc_free(r);
  73                 return False;
  74         }
  75
  76         blob = ndr_push_blob(push);
  77         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
  78                 talloc_free(r);
  79                 return False;
  80         }
  81
  82         talloc_free(r);
  83
  84         return True;
  85 }
  86
  87 static bool api_wkssvc_NetWkstaSetInfo(pipes_struct *p)
  88 {
  89         const struct ndr_interface_call *call;
  90         struct ndr_pull *pull;
  91         struct ndr_push *push;
  92         NTSTATUS status;
  93         DATA_BLOB blob;
  94         struct wkssvc_NetWkstaSetInfo *r;
  95
  96         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTASETINFO];
  97
  98         r = talloc(NULL, struct wkssvc_NetWkstaSetInfo);
  99         if (r == NULL) {
 100                 return False;
 101         }
 102
 103         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 104                 talloc_free(r);
 105                 return False;
 106         }
 107
 108         pull = ndr_pull_init_blob(&blob, r);
 109         if (pull == NULL) {
 110                 talloc_free(r);
 111                 return False;
 112         }
 113
 114         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 115         status = call->ndr_pull(pull, NDR_IN, r);
 116         if (NT_STATUS_IS_ERR(status)) {
 117                 talloc_free(r);
 118                 return False;
 119         }
 120
 121         if (DEBUGLEVEL >= 10)
 122                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, r);
 123
 124         ZERO_STRUCT(r->out);
 125         r->out.parm_error = r->in.parm_error;
 126         r->out.result = _wkssvc_NetWkstaSetInfo(p, r);
 127
 128         if (p->rng_fault_state) {
 129                 talloc_free(r);
 130                 /* Return True here, srv_pipe_hnd.c will take care */
 131                 return True;
 132         }
 133
 134         if (DEBUGLEVEL >= 10)
 135                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, r);
 136
 137         push = ndr_push_init_ctx(r);
 138         if (push == NULL) {
 139                 talloc_free(r);
 140                 return False;
 141         }
 142
 143         status = call->ndr_push(push, NDR_OUT, r);
 144         if (NT_STATUS_IS_ERR(status)) {
 145                 talloc_free(r);
 146                 return False;
 147         }
 148
 149         blob = ndr_push_blob(push);
 150         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 151                 talloc_free(r);
 152                 return False;
 153         }
 154
 155         talloc_free(r);
 156
 157         return True;
 158 }
 159
 160 static bool api_wkssvc_NetWkstaEnumUsers(pipes_struct *p)
 161 {
 162         const struct ndr_interface_call *call;
 163         struct ndr_pull *pull;
 164         struct ndr_push *push;
 165         NTSTATUS status;
 166         DATA_BLOB blob;
 167         struct wkssvc_NetWkstaEnumUsers *r;
 168
 169         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTAENUMUSERS];
 170
 171         r = talloc(NULL, struct wkssvc_NetWkstaEnumUsers);
 172         if (r == NULL) {
 173                 return False;
 174         }
 175
 176         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 177                 talloc_free(r);
 178                 return False;
 179         }
 180
 181         pull = ndr_pull_init_blob(&blob, r);
 182         if (pull == NULL) {
 183                 talloc_free(r);
 184                 return False;
 185         }
 186
 187         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 188         status = call->ndr_pull(pull, NDR_IN, r);
 189         if (NT_STATUS_IS_ERR(status)) {
 190                 talloc_free(r);
 191                 return False;
 192         }
 193
 194         if (DEBUGLEVEL >= 10)
 195                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, r);
 196
 197         ZERO_STRUCT(r->out);
 198         r->out.users = r->in.users;
 199         r->out.entriesread = talloc_zero(r, uint32_t);
 200         if (r->out.entriesread == NULL) {
 201                 talloc_free(r);
 202                 return False;
 203         }
 204
 205         r->out.totalentries = talloc_zero(r, uint32_t);
 206         if (r->out.totalentries == NULL) {
 207                 talloc_free(r);
 208                 return False;
 209         }
 210
 211         r->out.resumehandle = r->in.resumehandle;
 212         r->out.result = _wkssvc_NetWkstaEnumUsers(p, r);
 213
 214         if (p->rng_fault_state) {
 215                 talloc_free(r);
 216                 /* Return True here, srv_pipe_hnd.c will take care */
 217                 return True;
 218         }
 219
 220         if (DEBUGLEVEL >= 10)
 221                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, r);
 222
 223         push = ndr_push_init_ctx(r);
 224         if (push == NULL) {
 225                 talloc_free(r);
 226                 return False;
 227         }
 228
 229         status = call->ndr_push(push, NDR_OUT, r);
 230         if (NT_STATUS_IS_ERR(status)) {
 231                 talloc_free(r);
 232                 return False;
 233         }
 234
 235         blob = ndr_push_blob(push);
 236         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 237                 talloc_free(r);
 238                 return False;
 239         }
 240
 241         talloc_free(r);
 242
 243         return True;
 244 }
 245
 246 static bool api_WKSSVC_NETRWKSTAUSERGETINFO(pipes_struct *p)
 247 {
 248         const struct ndr_interface_call *call;
 249         struct ndr_pull *pull;
 250         struct ndr_push *push;
 251         NTSTATUS status;
 252         DATA_BLOB blob;
 253         struct WKSSVC_NETRWKSTAUSERGETINFO *r;
 254
 255         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTAUSERGETINFO];
 256
 257         r = talloc(NULL, struct WKSSVC_NETRWKSTAUSERGETINFO);
 258         if (r == NULL) {
 259                 return False;
 260         }
 261
 262         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 263                 talloc_free(r);
 264                 return False;
 265         }
 266
 267         pull = ndr_pull_init_blob(&blob, r);
 268         if (pull == NULL) {
 269                 talloc_free(r);
 270                 return False;
 271         }
 272
 273         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 274         status = call->ndr_pull(pull, NDR_IN, r);
 275         if (NT_STATUS_IS_ERR(status)) {
 276                 talloc_free(r);
 277                 return False;
 278         }
 279
 280         if (DEBUGLEVEL >= 10)
 281                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, r);
 282
 283         r->out.result = _WKSSVC_NETRWKSTAUSERGETINFO(p, r);
 284
 285         if (p->rng_fault_state) {
 286                 talloc_free(r);
 287                 /* Return True here, srv_pipe_hnd.c will take care */
 288                 return True;
 289         }
 290
 291         if (DEBUGLEVEL >= 10)
 292                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, r);
 293
 294         push = ndr_push_init_ctx(r);
 295         if (push == NULL) {
 296                 talloc_free(r);
 297                 return False;
 298         }
 299
 300         status = call->ndr_push(push, NDR_OUT, r);
 301         if (NT_STATUS_IS_ERR(status)) {
 302                 talloc_free(r);
 303                 return False;
 304         }
 305
 306         blob = ndr_push_blob(push);
 307         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 308                 talloc_free(r);
 309                 return False;
 310         }
 311
 312         talloc_free(r);
 313
 314         return True;
 315 }
 316
 317 static bool api_WKSSVC_NETRWKSTAUSERSETINFO(pipes_struct *p)
 318 {
 319         const struct ndr_interface_call *call;
 320         struct ndr_pull *pull;
 321         struct ndr_push *push;
 322         NTSTATUS status;
 323         DATA_BLOB blob;
 324         struct WKSSVC_NETRWKSTAUSERSETINFO *r;
 325
 326         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTAUSERSETINFO];
 327
 328         r = talloc(NULL, struct WKSSVC_NETRWKSTAUSERSETINFO);
 329         if (r == NULL) {
 330                 return False;
 331         }
 332
 333         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 334                 talloc_free(r);
 335                 return False;
 336         }
 337
 338         pull = ndr_pull_init_blob(&blob, r);
 339         if (pull == NULL) {
 340                 talloc_free(r);
 341                 return False;
 342         }
 343
 344         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 345         status = call->ndr_pull(pull, NDR_IN, r);
 346         if (NT_STATUS_IS_ERR(status)) {
 347                 talloc_free(r);
 348                 return False;
 349         }
 350
 351         if (DEBUGLEVEL >= 10)
 352                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, r);
 353
 354         r->out.result = _WKSSVC_NETRWKSTAUSERSETINFO(p, r);
 355
 356         if (p->rng_fault_state) {
 357                 talloc_free(r);
 358                 /* Return True here, srv_pipe_hnd.c will take care */
 359                 return True;
 360         }
 361
 362         if (DEBUGLEVEL >= 10)
 363                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, r);
 364
 365         push = ndr_push_init_ctx(r);
 366         if (push == NULL) {
 367                 talloc_free(r);
 368                 return False;
 369         }
 370
 371         status = call->ndr_push(push, NDR_OUT, r);
 372         if (NT_STATUS_IS_ERR(status)) {
 373                 talloc_free(r);
 374                 return False;
 375         }
 376
 377         blob = ndr_push_blob(push);
 378         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 379                 talloc_free(r);
 380                 return False;
 381         }
 382
 383         talloc_free(r);
 384
 385         return True;
 386 }
 387
 388 static bool api_wkssvc_NetWkstaTransportEnum(pipes_struct *p)
 389 {
 390         const struct ndr_interface_call *call;
 391         struct ndr_pull *pull;
 392         struct ndr_push *push;
 393         NTSTATUS status;
 394         DATA_BLOB blob;
 395         struct wkssvc_NetWkstaTransportEnum *r;
 396
 397         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTATRANSPORTENUM];
 398
 399         r = talloc(NULL, struct wkssvc_NetWkstaTransportEnum);
 400         if (r == NULL) {
 401                 return False;
 402         }
 403
 404         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 405                 talloc_free(r);
 406                 return False;
 407         }
 408
 409         pull = ndr_pull_init_blob(&blob, r);
 410         if (pull == NULL) {
 411                 talloc_free(r);
 412                 return False;
 413         }
 414
 415         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 416         status = call->ndr_pull(pull, NDR_IN, r);
 417         if (NT_STATUS_IS_ERR(status)) {
 418                 talloc_free(r);
 419                 return False;
 420         }
 421
 422         if (DEBUGLEVEL >= 10)
 423                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, r);
 424
 425         ZERO_STRUCT(r->out);
 426         r->out.level = r->in.level;
 427         r->out.ctr = r->in.ctr;
 428         r->out.totalentries = talloc_zero(r, uint32_t);
 429         if (r->out.totalentries == NULL) {
 430                 talloc_free(r);
 431                 return False;
 432         }
 433
 434         r->out.resume_handle = r->in.resume_handle;
 435         r->out.result = _wkssvc_NetWkstaTransportEnum(p, r);
 436
 437         if (p->rng_fault_state) {
 438                 talloc_free(r);
 439                 /* Return True here, srv_pipe_hnd.c will take care */
 440                 return True;
 441         }
 442
 443         if (DEBUGLEVEL >= 10)
 444                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, r);
 445
 446         push = ndr_push_init_ctx(r);
 447         if (push == NULL) {
 448                 talloc_free(r);
 449                 return False;
 450         }
 451
 452         status = call->ndr_push(push, NDR_OUT, r);
 453         if (NT_STATUS_IS_ERR(status)) {
 454                 talloc_free(r);
 455                 return False;
 456         }
 457
 458         blob = ndr_push_blob(push);
 459         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 460                 talloc_free(r);
 461                 return False;
 462         }
 463
 464         talloc_free(r);
 465
 466         return True;
 467 }
 468
 469 static bool api_WKSSVC_NETRWKSTATRANSPORTADD(pipes_struct *p)
 470 {
 471         const struct ndr_interface_call *call;
 472         struct ndr_pull *pull;
 473         struct ndr_push *push;
 474         NTSTATUS status;
 475         DATA_BLOB blob;
 476         struct WKSSVC_NETRWKSTATRANSPORTADD *r;
 477
 478         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTATRANSPORTADD];
 479
 480         r = talloc(NULL, struct WKSSVC_NETRWKSTATRANSPORTADD);
 481         if (r == NULL) {
 482                 return False;
 483         }
 484
 485         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 486                 talloc_free(r);
 487                 return False;
 488         }
 489
 490         pull = ndr_pull_init_blob(&blob, r);
 491         if (pull == NULL) {
 492                 talloc_free(r);
 493                 return False;
 494         }
 495
 496         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 497         status = call->ndr_pull(pull, NDR_IN, r);
 498         if (NT_STATUS_IS_ERR(status)) {
 499                 talloc_free(r);
 500                 return False;
 501         }
 502
 503         if (DEBUGLEVEL >= 10)
 504                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, r);
 505
 506         r->out.result = _WKSSVC_NETRWKSTATRANSPORTADD(p, r);
 507
 508         if (p->rng_fault_state) {
 509                 talloc_free(r);
 510                 /* Return True here, srv_pipe_hnd.c will take care */
 511                 return True;
 512         }
 513
 514         if (DEBUGLEVEL >= 10)
 515                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, r);
 516
 517         push = ndr_push_init_ctx(r);
 518         if (push == NULL) {
 519                 talloc_free(r);
 520                 return False;
 521         }
 522
 523         status = call->ndr_push(push, NDR_OUT, r);
 524         if (NT_STATUS_IS_ERR(status)) {
 525                 talloc_free(r);
 526                 return False;
 527         }
 528
 529         blob = ndr_push_blob(push);
 530         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 531                 talloc_free(r);
 532                 return False;
 533         }
 534
 535         talloc_free(r);
 536
 537         return True;
 538 }
 539
 540 static bool api_WKSSVC_NETRWKSTATRANSPORTDEL(pipes_struct *p)
 541 {
 542         const struct ndr_interface_call *call;
 543         struct ndr_pull *pull;
 544         struct ndr_push *push;
 545         NTSTATUS status;
 546         DATA_BLOB blob;
 547         struct WKSSVC_NETRWKSTATRANSPORTDEL *r;
 548
 549         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTATRANSPORTDEL];
 550
 551         r = talloc(NULL, struct WKSSVC_NETRWKSTATRANSPORTDEL);
 552         if (r == NULL) {
 553                 return False;
 554         }
 555
 556         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 557                 talloc_free(r);
 558                 return False;
 559         }
 560
 561         pull = ndr_pull_init_blob(&blob, r);
 562         if (pull == NULL) {
 563                 talloc_free(r);
 564                 return False;
 565         }
 566
 567         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 568         status = call->ndr_pull(pull, NDR_IN, r);
 569         if (NT_STATUS_IS_ERR(status)) {
 570                 talloc_free(r);
 571                 return False;
 572         }
 573
 574         if (DEBUGLEVEL >= 10)
 575                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, r);
 576
 577         r->out.result = _WKSSVC_NETRWKSTATRANSPORTDEL(p, r);
 578
 579         if (p->rng_fault_state) {
 580                 talloc_free(r);
 581                 /* Return True here, srv_pipe_hnd.c will take care */
 582                 return True;
 583         }
 584
 585         if (DEBUGLEVEL >= 10)
 586                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, r);
 587
 588         push = ndr_push_init_ctx(r);
 589         if (push == NULL) {
 590                 talloc_free(r);
 591                 return False;
 592         }
 593
 594         status = call->ndr_push(push, NDR_OUT, r);
 595         if (NT_STATUS_IS_ERR(status)) {
 596                 talloc_free(r);
 597                 return False;
 598         }
 599
 600         blob = ndr_push_blob(push);
 601         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 602                 talloc_free(r);
 603                 return False;
 604         }
 605
 606         talloc_free(r);
 607
 608         return True;
 609 }
 610
 611 static bool api_WKSSVC_NETRUSEADD(pipes_struct *p)
 612 {
 613         const struct ndr_interface_call *call;
 614         struct ndr_pull *pull;
 615         struct ndr_push *push;
 616         NTSTATUS status;
 617         DATA_BLOB blob;
 618         struct WKSSVC_NETRUSEADD *r;
 619
 620         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEADD];
 621
 622         r = talloc(NULL, struct WKSSVC_NETRUSEADD);
 623         if (r == NULL) {
 624                 return False;
 625         }
 626
 627         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 628                 talloc_free(r);
 629                 return False;
 630         }
 631
 632         pull = ndr_pull_init_blob(&blob, r);
 633         if (pull == NULL) {
 634                 talloc_free(r);
 635                 return False;
 636         }
 637
 638         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 639         status = call->ndr_pull(pull, NDR_IN, r);
 640         if (NT_STATUS_IS_ERR(status)) {
 641                 talloc_free(r);
 642                 return False;
 643         }
 644
 645         if (DEBUGLEVEL >= 10)
 646                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEADD, r);
 647
 648         r->out.result = _WKSSVC_NETRUSEADD(p, r);
 649
 650         if (p->rng_fault_state) {
 651                 talloc_free(r);
 652                 /* Return True here, srv_pipe_hnd.c will take care */
 653                 return True;
 654         }
 655
 656         if (DEBUGLEVEL >= 10)
 657                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEADD, r);
 658
 659         push = ndr_push_init_ctx(r);
 660         if (push == NULL) {
 661                 talloc_free(r);
 662                 return False;
 663         }
 664
 665         status = call->ndr_push(push, NDR_OUT, r);
 666         if (NT_STATUS_IS_ERR(status)) {
 667                 talloc_free(r);
 668                 return False;
 669         }
 670
 671         blob = ndr_push_blob(push);
 672         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 673                 talloc_free(r);
 674                 return False;
 675         }
 676
 677         talloc_free(r);
 678
 679         return True;
 680 }
 681
 682 static bool api_WKSSVC_NETRUSEGETINFO(pipes_struct *p)
 683 {
 684         const struct ndr_interface_call *call;
 685         struct ndr_pull *pull;
 686         struct ndr_push *push;
 687         NTSTATUS status;
 688         DATA_BLOB blob;
 689         struct WKSSVC_NETRUSEGETINFO *r;
 690
 691         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEGETINFO];
 692
 693         r = talloc(NULL, struct WKSSVC_NETRUSEGETINFO);
 694         if (r == NULL) {
 695                 return False;
 696         }
 697
 698         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 699                 talloc_free(r);
 700                 return False;
 701         }
 702
 703         pull = ndr_pull_init_blob(&blob, r);
 704         if (pull == NULL) {
 705                 talloc_free(r);
 706                 return False;
 707         }
 708
 709         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 710         status = call->ndr_pull(pull, NDR_IN, r);
 711         if (NT_STATUS_IS_ERR(status)) {
 712                 talloc_free(r);
 713                 return False;
 714         }
 715
 716         if (DEBUGLEVEL >= 10)
 717                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEGETINFO, r);
 718
 719         r->out.result = _WKSSVC_NETRUSEGETINFO(p, r);
 720
 721         if (p->rng_fault_state) {
 722                 talloc_free(r);
 723                 /* Return True here, srv_pipe_hnd.c will take care */
 724                 return True;
 725         }
 726
 727         if (DEBUGLEVEL >= 10)
 728                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEGETINFO, r);
 729
 730         push = ndr_push_init_ctx(r);
 731         if (push == NULL) {
 732                 talloc_free(r);
 733                 return False;
 734         }
 735
 736         status = call->ndr_push(push, NDR_OUT, r);
 737         if (NT_STATUS_IS_ERR(status)) {
 738                 talloc_free(r);
 739                 return False;
 740         }
 741
 742         blob = ndr_push_blob(push);
 743         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 744                 talloc_free(r);
 745                 return False;
 746         }
 747
 748         talloc_free(r);
 749
 750         return True;
 751 }
 752
 753 static bool api_WKSSVC_NETRUSEDEL(pipes_struct *p)
 754 {
 755         const struct ndr_interface_call *call;
 756         struct ndr_pull *pull;
 757         struct ndr_push *push;
 758         NTSTATUS status;
 759         DATA_BLOB blob;
 760         struct WKSSVC_NETRUSEDEL *r;
 761
 762         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEDEL];
 763
 764         r = talloc(NULL, struct WKSSVC_NETRUSEDEL);
 765         if (r == NULL) {
 766                 return False;
 767         }
 768
 769         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 770                 talloc_free(r);
 771                 return False;
 772         }
 773
 774         pull = ndr_pull_init_blob(&blob, r);
 775         if (pull == NULL) {
 776                 talloc_free(r);
 777                 return False;
 778         }
 779
 780         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 781         status = call->ndr_pull(pull, NDR_IN, r);
 782         if (NT_STATUS_IS_ERR(status)) {
 783                 talloc_free(r);
 784                 return False;
 785         }
 786
 787         if (DEBUGLEVEL >= 10)
 788                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEDEL, r);
 789
 790         r->out.result = _WKSSVC_NETRUSEDEL(p, r);
 791
 792         if (p->rng_fault_state) {
 793                 talloc_free(r);
 794                 /* Return True here, srv_pipe_hnd.c will take care */
 795                 return True;
 796         }
 797
 798         if (DEBUGLEVEL >= 10)
 799                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEDEL, r);
 800
 801         push = ndr_push_init_ctx(r);
 802         if (push == NULL) {
 803                 talloc_free(r);
 804                 return False;
 805         }
 806
 807         status = call->ndr_push(push, NDR_OUT, r);
 808         if (NT_STATUS_IS_ERR(status)) {
 809                 talloc_free(r);
 810                 return False;
 811         }
 812
 813         blob = ndr_push_blob(push);
 814         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 815                 talloc_free(r);
 816                 return False;
 817         }
 818
 819         talloc_free(r);
 820
 821         return True;
 822 }
 823
 824 static bool api_WKSSVC_NETRUSEENUM(pipes_struct *p)
 825 {
 826         const struct ndr_interface_call *call;
 827         struct ndr_pull *pull;
 828         struct ndr_push *push;
 829         NTSTATUS status;
 830         DATA_BLOB blob;
 831         struct WKSSVC_NETRUSEENUM *r;
 832
 833         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEENUM];
 834
 835         r = talloc(NULL, struct WKSSVC_NETRUSEENUM);
 836         if (r == NULL) {
 837                 return False;
 838         }
 839
 840         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 841                 talloc_free(r);
 842                 return False;
 843         }
 844
 845         pull = ndr_pull_init_blob(&blob, r);
 846         if (pull == NULL) {
 847                 talloc_free(r);
 848                 return False;
 849         }
 850
 851         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 852         status = call->ndr_pull(pull, NDR_IN, r);
 853         if (NT_STATUS_IS_ERR(status)) {
 854                 talloc_free(r);
 855                 return False;
 856         }
 857
 858         if (DEBUGLEVEL >= 10)
 859                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEENUM, r);
 860
 861         r->out.result = _WKSSVC_NETRUSEENUM(p, r);
 862
 863         if (p->rng_fault_state) {
 864                 talloc_free(r);
 865                 /* Return True here, srv_pipe_hnd.c will take care */
 866                 return True;
 867         }
 868
 869         if (DEBUGLEVEL >= 10)
 870                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEENUM, r);
 871
 872         push = ndr_push_init_ctx(r);
 873         if (push == NULL) {
 874                 talloc_free(r);
 875                 return False;
 876         }
 877
 878         status = call->ndr_push(push, NDR_OUT, r);
 879         if (NT_STATUS_IS_ERR(status)) {
 880                 talloc_free(r);
 881                 return False;
 882         }
 883
 884         blob = ndr_push_blob(push);
 885         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 886                 talloc_free(r);
 887                 return False;
 888         }
 889
 890         talloc_free(r);
 891
 892         return True;
 893 }
 894
 895 static bool api_WKSSVC_NETRMESSAGEBUFFERSEND(pipes_struct *p)
 896 {
 897         const struct ndr_interface_call *call;
 898         struct ndr_pull *pull;
 899         struct ndr_push *push;
 900         NTSTATUS status;
 901         DATA_BLOB blob;
 902         struct WKSSVC_NETRMESSAGEBUFFERSEND *r;
 903
 904         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRMESSAGEBUFFERSEND];
 905
 906         r = talloc(NULL, struct WKSSVC_NETRMESSAGEBUFFERSEND);
 907         if (r == NULL) {
 908                 return False;
 909         }
 910
 911         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 912                 talloc_free(r);
 913                 return False;
 914         }
 915
 916         pull = ndr_pull_init_blob(&blob, r);
 917         if (pull == NULL) {
 918                 talloc_free(r);
 919                 return False;
 920         }
 921
 922         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 923         status = call->ndr_pull(pull, NDR_IN, r);
 924         if (NT_STATUS_IS_ERR(status)) {
 925                 talloc_free(r);
 926                 return False;
 927         }
 928
 929         if (DEBUGLEVEL >= 10)
 930                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, r);
 931
 932         r->out.result = _WKSSVC_NETRMESSAGEBUFFERSEND(p, r);
 933
 934         if (p->rng_fault_state) {
 935                 talloc_free(r);
 936                 /* Return True here, srv_pipe_hnd.c will take care */
 937                 return True;
 938         }
 939
 940         if (DEBUGLEVEL >= 10)
 941                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, r);
 942
 943         push = ndr_push_init_ctx(r);
 944         if (push == NULL) {
 945                 talloc_free(r);
 946                 return False;
 947         }
 948
 949         status = call->ndr_push(push, NDR_OUT, r);
 950         if (NT_STATUS_IS_ERR(status)) {
 951                 talloc_free(r);
 952                 return False;
 953         }
 954
 955         blob = ndr_push_blob(push);
 956         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
 957                 talloc_free(r);
 958                 return False;
 959         }
 960
 961         talloc_free(r);
 962
 963         return True;
 964 }
 965
 966 static bool api_WKSSVC_NETRWORKSTATIONSTATISTICSGET(pipes_struct *p)
 967 {
 968         const struct ndr_interface_call *call;
 969         struct ndr_pull *pull;
 970         struct ndr_push *push;
 971         NTSTATUS status;
 972         DATA_BLOB blob;
 973         struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r;
 974
 975         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET];
 976
 977         r = talloc(NULL, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET);
 978         if (r == NULL) {
 979                 return False;
 980         }
 981
 982         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 983                 talloc_free(r);
 984                 return False;
 985         }
 986
 987         pull = ndr_pull_init_blob(&blob, r);
 988         if (pull == NULL) {
 989                 talloc_free(r);
 990                 return False;
 991         }
 992
 993         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 994         status = call->ndr_pull(pull, NDR_IN, r);
 995         if (NT_STATUS_IS_ERR(status)) {
 996                 talloc_free(r);
 997                 return False;
 998         }
 999
1000         if (DEBUGLEVEL >= 10)
1001                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, r);
1002
1003         r->out.result = _WKSSVC_NETRWORKSTATIONSTATISTICSGET(p, r);
1004
1005         if (p->rng_fault_state) {
1006                 talloc_free(r);
1007                 /* Return True here, srv_pipe_hnd.c will take care */
1008                 return True;
1009         }
1010
1011         if (DEBUGLEVEL >= 10)
1012                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, r);
1013
1014         push = ndr_push_init_ctx(r);
1015         if (push == NULL) {
1016                 talloc_free(r);
1017                 return False;
1018         }
1019
1020         status = call->ndr_push(push, NDR_OUT, r);
1021         if (NT_STATUS_IS_ERR(status)) {
1022                 talloc_free(r);
1023                 return False;
1024         }
1025
1026         blob = ndr_push_blob(push);
1027         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1028                 talloc_free(r);
1029                 return False;
1030         }
1031
1032         talloc_free(r);
1033
1034         return True;
1035 }
1036
1037 static bool api_WKSSVC_NETRLOGONDOMAINNAMEADD(pipes_struct *p)
1038 {
1039         const struct ndr_interface_call *call;
1040         struct ndr_pull *pull;
1041         struct ndr_push *push;
1042         NTSTATUS status;
1043         DATA_BLOB blob;
1044         struct WKSSVC_NETRLOGONDOMAINNAMEADD *r;
1045
1046         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRLOGONDOMAINNAMEADD];
1047
1048         r = talloc(NULL, struct WKSSVC_NETRLOGONDOMAINNAMEADD);
1049         if (r == NULL) {
1050                 return False;
1051         }
1052
1053         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1054                 talloc_free(r);
1055                 return False;
1056         }
1057
1058         pull = ndr_pull_init_blob(&blob, r);
1059         if (pull == NULL) {
1060                 talloc_free(r);
1061                 return False;
1062         }
1063
1064         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1065         status = call->ndr_pull(pull, NDR_IN, r);
1066         if (NT_STATUS_IS_ERR(status)) {
1067                 talloc_free(r);
1068                 return False;
1069         }
1070
1071         if (DEBUGLEVEL >= 10)
1072                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, r);
1073
1074         r->out.result = _WKSSVC_NETRLOGONDOMAINNAMEADD(p, r);
1075
1076         if (p->rng_fault_state) {
1077                 talloc_free(r);
1078                 /* Return True here, srv_pipe_hnd.c will take care */
1079                 return True;
1080         }
1081
1082         if (DEBUGLEVEL >= 10)
1083                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, r);
1084
1085         push = ndr_push_init_ctx(r);
1086         if (push == NULL) {
1087                 talloc_free(r);
1088                 return False;
1089         }
1090
1091         status = call->ndr_push(push, NDR_OUT, r);
1092         if (NT_STATUS_IS_ERR(status)) {
1093                 talloc_free(r);
1094                 return False;
1095         }
1096
1097         blob = ndr_push_blob(push);
1098         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1099                 talloc_free(r);
1100                 return False;
1101         }
1102
1103         talloc_free(r);
1104
1105         return True;
1106 }
1107
1108 static bool api_WKSSVC_NETRLOGONDOMAINNAMEDEL(pipes_struct *p)
1109 {
1110         const struct ndr_interface_call *call;
1111         struct ndr_pull *pull;
1112         struct ndr_push *push;
1113         NTSTATUS status;
1114         DATA_BLOB blob;
1115         struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r;
1116
1117         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL];
1118
1119         r = talloc(NULL, struct WKSSVC_NETRLOGONDOMAINNAMEDEL);
1120         if (r == NULL) {
1121                 return False;
1122         }
1123
1124         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1125                 talloc_free(r);
1126                 return False;
1127         }
1128
1129         pull = ndr_pull_init_blob(&blob, r);
1130         if (pull == NULL) {
1131                 talloc_free(r);
1132                 return False;
1133         }
1134
1135         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1136         status = call->ndr_pull(pull, NDR_IN, r);
1137         if (NT_STATUS_IS_ERR(status)) {
1138                 talloc_free(r);
1139                 return False;
1140         }
1141
1142         if (DEBUGLEVEL >= 10)
1143                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, r);
1144
1145         r->out.result = _WKSSVC_NETRLOGONDOMAINNAMEDEL(p, r);
1146
1147         if (p->rng_fault_state) {
1148                 talloc_free(r);
1149                 /* Return True here, srv_pipe_hnd.c will take care */
1150                 return True;
1151         }
1152
1153         if (DEBUGLEVEL >= 10)
1154                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, r);
1155
1156         push = ndr_push_init_ctx(r);
1157         if (push == NULL) {
1158                 talloc_free(r);
1159                 return False;
1160         }
1161
1162         status = call->ndr_push(push, NDR_OUT, r);
1163         if (NT_STATUS_IS_ERR(status)) {
1164                 talloc_free(r);
1165                 return False;
1166         }
1167
1168         blob = ndr_push_blob(push);
1169         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1170                 talloc_free(r);
1171                 return False;
1172         }
1173
1174         talloc_free(r);
1175
1176         return True;
1177 }
1178
1179 static bool api_WKSSVC_NETRJOINDOMAIN(pipes_struct *p)
1180 {
1181         const struct ndr_interface_call *call;
1182         struct ndr_pull *pull;
1183         struct ndr_push *push;
1184         NTSTATUS status;
1185         DATA_BLOB blob;
1186         struct WKSSVC_NETRJOINDOMAIN *r;
1187
1188         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRJOINDOMAIN];
1189
1190         r = talloc(NULL, struct WKSSVC_NETRJOINDOMAIN);
1191         if (r == NULL) {
1192                 return False;
1193         }
1194
1195         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1196                 talloc_free(r);
1197                 return False;
1198         }
1199
1200         pull = ndr_pull_init_blob(&blob, r);
1201         if (pull == NULL) {
1202                 talloc_free(r);
1203                 return False;
1204         }
1205
1206         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1207         status = call->ndr_pull(pull, NDR_IN, r);
1208         if (NT_STATUS_IS_ERR(status)) {
1209                 talloc_free(r);
1210                 return False;
1211         }
1212
1213         if (DEBUGLEVEL >= 10)
1214                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN, r);
1215
1216         r->out.result = _WKSSVC_NETRJOINDOMAIN(p, r);
1217
1218         if (p->rng_fault_state) {
1219                 talloc_free(r);
1220                 /* Return True here, srv_pipe_hnd.c will take care */
1221                 return True;
1222         }
1223
1224         if (DEBUGLEVEL >= 10)
1225                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN, r);
1226
1227         push = ndr_push_init_ctx(r);
1228         if (push == NULL) {
1229                 talloc_free(r);
1230                 return False;
1231         }
1232
1233         status = call->ndr_push(push, NDR_OUT, r);
1234         if (NT_STATUS_IS_ERR(status)) {
1235                 talloc_free(r);
1236                 return False;
1237         }
1238
1239         blob = ndr_push_blob(push);
1240         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1241                 talloc_free(r);
1242                 return False;
1243         }
1244
1245         talloc_free(r);
1246
1247         return True;
1248 }
1249
1250 static bool api_WKSSVC_NETRUNJOINDOMAIN(pipes_struct *p)
1251 {
1252         const struct ndr_interface_call *call;
1253         struct ndr_pull *pull;
1254         struct ndr_push *push;
1255         NTSTATUS status;
1256         DATA_BLOB blob;
1257         struct WKSSVC_NETRUNJOINDOMAIN *r;
1258
1259         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUNJOINDOMAIN];
1260
1261         r = talloc(NULL, struct WKSSVC_NETRUNJOINDOMAIN);
1262         if (r == NULL) {
1263                 return False;
1264         }
1265
1266         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1267                 talloc_free(r);
1268                 return False;
1269         }
1270
1271         pull = ndr_pull_init_blob(&blob, r);
1272         if (pull == NULL) {
1273                 talloc_free(r);
1274                 return False;
1275         }
1276
1277         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1278         status = call->ndr_pull(pull, NDR_IN, r);
1279         if (NT_STATUS_IS_ERR(status)) {
1280                 talloc_free(r);
1281                 return False;
1282         }
1283
1284         if (DEBUGLEVEL >= 10)
1285                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN, r);
1286
1287         r->out.result = _WKSSVC_NETRUNJOINDOMAIN(p, r);
1288
1289         if (p->rng_fault_state) {
1290                 talloc_free(r);
1291                 /* Return True here, srv_pipe_hnd.c will take care */
1292                 return True;
1293         }
1294
1295         if (DEBUGLEVEL >= 10)
1296                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN, r);
1297
1298         push = ndr_push_init_ctx(r);
1299         if (push == NULL) {
1300                 talloc_free(r);
1301                 return False;
1302         }
1303
1304         status = call->ndr_push(push, NDR_OUT, r);
1305         if (NT_STATUS_IS_ERR(status)) {
1306                 talloc_free(r);
1307                 return False;
1308         }
1309
1310         blob = ndr_push_blob(push);
1311         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1312                 talloc_free(r);
1313                 return False;
1314         }
1315
1316         talloc_free(r);
1317
1318         return True;
1319 }
1320
1321 static bool api_WKSSVC_NETRRENAMEMACHINEINDOMAIN(pipes_struct *p)
1322 {
1323         const struct ndr_interface_call *call;
1324         struct ndr_pull *pull;
1325         struct ndr_push *push;
1326         NTSTATUS status;
1327         DATA_BLOB blob;
1328         struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r;
1329
1330         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN];
1331
1332         r = talloc(NULL, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN);
1333         if (r == NULL) {
1334                 return False;
1335         }
1336
1337         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1338                 talloc_free(r);
1339                 return False;
1340         }
1341
1342         pull = ndr_pull_init_blob(&blob, r);
1343         if (pull == NULL) {
1344                 talloc_free(r);
1345                 return False;
1346         }
1347
1348         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1349         status = call->ndr_pull(pull, NDR_IN, r);
1350         if (NT_STATUS_IS_ERR(status)) {
1351                 talloc_free(r);
1352                 return False;
1353         }
1354
1355         if (DEBUGLEVEL >= 10)
1356                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, r);
1357
1358         r->out.result = _WKSSVC_NETRRENAMEMACHINEINDOMAIN(p, r);
1359
1360         if (p->rng_fault_state) {
1361                 talloc_free(r);
1362                 /* Return True here, srv_pipe_hnd.c will take care */
1363                 return True;
1364         }
1365
1366         if (DEBUGLEVEL >= 10)
1367                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, r);
1368
1369         push = ndr_push_init_ctx(r);
1370         if (push == NULL) {
1371                 talloc_free(r);
1372                 return False;
1373         }
1374
1375         status = call->ndr_push(push, NDR_OUT, r);
1376         if (NT_STATUS_IS_ERR(status)) {
1377                 talloc_free(r);
1378                 return False;
1379         }
1380
1381         blob = ndr_push_blob(push);
1382         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1383                 talloc_free(r);
1384                 return False;
1385         }
1386
1387         talloc_free(r);
1388
1389         return True;
1390 }
1391
1392 static bool api_WKSSVC_NETRVALIDATENAME(pipes_struct *p)
1393 {
1394         const struct ndr_interface_call *call;
1395         struct ndr_pull *pull;
1396         struct ndr_push *push;
1397         NTSTATUS status;
1398         DATA_BLOB blob;
1399         struct WKSSVC_NETRVALIDATENAME *r;
1400
1401         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRVALIDATENAME];
1402
1403         r = talloc(NULL, struct WKSSVC_NETRVALIDATENAME);
1404         if (r == NULL) {
1405                 return False;
1406         }
1407
1408         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1409                 talloc_free(r);
1410                 return False;
1411         }
1412
1413         pull = ndr_pull_init_blob(&blob, r);
1414         if (pull == NULL) {
1415                 talloc_free(r);
1416                 return False;
1417         }
1418
1419         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1420         status = call->ndr_pull(pull, NDR_IN, r);
1421         if (NT_STATUS_IS_ERR(status)) {
1422                 talloc_free(r);
1423                 return False;
1424         }
1425
1426         if (DEBUGLEVEL >= 10)
1427                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME, r);
1428
1429         r->out.result = _WKSSVC_NETRVALIDATENAME(p, r);
1430
1431         if (p->rng_fault_state) {
1432                 talloc_free(r);
1433                 /* Return True here, srv_pipe_hnd.c will take care */
1434                 return True;
1435         }
1436
1437         if (DEBUGLEVEL >= 10)
1438                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME, r);
1439
1440         push = ndr_push_init_ctx(r);
1441         if (push == NULL) {
1442                 talloc_free(r);
1443                 return False;
1444         }
1445
1446         status = call->ndr_push(push, NDR_OUT, r);
1447         if (NT_STATUS_IS_ERR(status)) {
1448                 talloc_free(r);
1449                 return False;
1450         }
1451
1452         blob = ndr_push_blob(push);
1453         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1454                 talloc_free(r);
1455                 return False;
1456         }
1457
1458         talloc_free(r);
1459
1460         return True;
1461 }
1462
1463 static bool api_WKSSVC_NETRGETJOININFORMATION(pipes_struct *p)
1464 {
1465         const struct ndr_interface_call *call;
1466         struct ndr_pull *pull;
1467         struct ndr_push *push;
1468         NTSTATUS status;
1469         DATA_BLOB blob;
1470         struct WKSSVC_NETRGETJOININFORMATION *r;
1471
1472         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOININFORMATION];
1473
1474         r = talloc(NULL, struct WKSSVC_NETRGETJOININFORMATION);
1475         if (r == NULL) {
1476                 return False;
1477         }
1478
1479         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1480                 talloc_free(r);
1481                 return False;
1482         }
1483
1484         pull = ndr_pull_init_blob(&blob, r);
1485         if (pull == NULL) {
1486                 talloc_free(r);
1487                 return False;
1488         }
1489
1490         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1491         status = call->ndr_pull(pull, NDR_IN, r);
1492         if (NT_STATUS_IS_ERR(status)) {
1493                 talloc_free(r);
1494                 return False;
1495         }
1496
1497         if (DEBUGLEVEL >= 10)
1498                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOININFORMATION, r);
1499
1500         r->out.result = _WKSSVC_NETRGETJOININFORMATION(p, r);
1501
1502         if (p->rng_fault_state) {
1503                 talloc_free(r);
1504                 /* Return True here, srv_pipe_hnd.c will take care */
1505                 return True;
1506         }
1507
1508         if (DEBUGLEVEL >= 10)
1509                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOININFORMATION, r);
1510
1511         push = ndr_push_init_ctx(r);
1512         if (push == NULL) {
1513                 talloc_free(r);
1514                 return False;
1515         }
1516
1517         status = call->ndr_push(push, NDR_OUT, r);
1518         if (NT_STATUS_IS_ERR(status)) {
1519                 talloc_free(r);
1520                 return False;
1521         }
1522
1523         blob = ndr_push_blob(push);
1524         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1525                 talloc_free(r);
1526                 return False;
1527         }
1528
1529         talloc_free(r);
1530
1531         return True;
1532 }
1533
1534 static bool api_WKSSVC_NETRGETJOINABLEOUS(pipes_struct *p)
1535 {
1536         const struct ndr_interface_call *call;
1537         struct ndr_pull *pull;
1538         struct ndr_push *push;
1539         NTSTATUS status;
1540         DATA_BLOB blob;
1541         struct WKSSVC_NETRGETJOINABLEOUS *r;
1542
1543         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOINABLEOUS];
1544
1545         r = talloc(NULL, struct WKSSVC_NETRGETJOINABLEOUS);
1546         if (r == NULL) {
1547                 return False;
1548         }
1549
1550         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1551                 talloc_free(r);
1552                 return False;
1553         }
1554
1555         pull = ndr_pull_init_blob(&blob, r);
1556         if (pull == NULL) {
1557                 talloc_free(r);
1558                 return False;
1559         }
1560
1561         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1562         status = call->ndr_pull(pull, NDR_IN, r);
1563         if (NT_STATUS_IS_ERR(status)) {
1564                 talloc_free(r);
1565                 return False;
1566         }
1567
1568         if (DEBUGLEVEL >= 10)
1569                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, r);
1570
1571         r->out.result = _WKSSVC_NETRGETJOINABLEOUS(p, r);
1572
1573         if (p->rng_fault_state) {
1574                 talloc_free(r);
1575                 /* Return True here, srv_pipe_hnd.c will take care */
1576                 return True;
1577         }
1578
1579         if (DEBUGLEVEL >= 10)
1580                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, r);
1581
1582         push = ndr_push_init_ctx(r);
1583         if (push == NULL) {
1584                 talloc_free(r);
1585                 return False;
1586         }
1587
1588         status = call->ndr_push(push, NDR_OUT, r);
1589         if (NT_STATUS_IS_ERR(status)) {
1590                 talloc_free(r);
1591                 return False;
1592         }
1593
1594         blob = ndr_push_blob(push);
1595         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1596                 talloc_free(r);
1597                 return False;
1598         }
1599
1600         talloc_free(r);
1601
1602         return True;
1603 }
1604
1605 static bool api_wkssvc_NetrJoinDomain2(pipes_struct *p)
1606 {
1607         const struct ndr_interface_call *call;
1608         struct ndr_pull *pull;
1609         struct ndr_push *push;
1610         NTSTATUS status;
1611         DATA_BLOB blob;
1612         struct wkssvc_NetrJoinDomain2 *r;
1613
1614         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRJOINDOMAIN2];
1615
1616         r = talloc(NULL, struct wkssvc_NetrJoinDomain2);
1617         if (r == NULL) {
1618                 return False;
1619         }
1620
1621         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1622                 talloc_free(r);
1623                 return False;
1624         }
1625
1626         pull = ndr_pull_init_blob(&blob, r);
1627         if (pull == NULL) {
1628                 talloc_free(r);
1629                 return False;
1630         }
1631
1632         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1633         status = call->ndr_pull(pull, NDR_IN, r);
1634         if (NT_STATUS_IS_ERR(status)) {
1635                 talloc_free(r);
1636                 return False;
1637         }
1638
1639         if (DEBUGLEVEL >= 10)
1640                 NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, r);
1641
1642         r->out.result = _wkssvc_NetrJoinDomain2(p, r);
1643
1644         if (p->rng_fault_state) {
1645                 talloc_free(r);
1646                 /* Return True here, srv_pipe_hnd.c will take care */
1647                 return True;
1648         }
1649
1650         if (DEBUGLEVEL >= 10)
1651                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, r);
1652
1653         push = ndr_push_init_ctx(r);
1654         if (push == NULL) {
1655                 talloc_free(r);
1656                 return False;
1657         }
1658
1659         status = call->ndr_push(push, NDR_OUT, r);
1660         if (NT_STATUS_IS_ERR(status)) {
1661                 talloc_free(r);
1662                 return False;
1663         }
1664
1665         blob = ndr_push_blob(push);
1666         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1667                 talloc_free(r);
1668                 return False;
1669         }
1670
1671         talloc_free(r);
1672
1673         return True;
1674 }
1675
1676 static bool api_wkssvc_NetrUnjoinDomain2(pipes_struct *p)
1677 {
1678         const struct ndr_interface_call *call;
1679         struct ndr_pull *pull;
1680         struct ndr_push *push;
1681         NTSTATUS status;
1682         DATA_BLOB blob;
1683         struct wkssvc_NetrUnjoinDomain2 *r;
1684
1685         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUNJOINDOMAIN2];
1686
1687         r = talloc(NULL, struct wkssvc_NetrUnjoinDomain2);
1688         if (r == NULL) {
1689                 return False;
1690         }
1691
1692         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1693                 talloc_free(r);
1694                 return False;
1695         }
1696
1697         pull = ndr_pull_init_blob(&blob, r);
1698         if (pull == NULL) {
1699                 talloc_free(r);
1700                 return False;
1701         }
1702
1703         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1704         status = call->ndr_pull(pull, NDR_IN, r);
1705         if (NT_STATUS_IS_ERR(status)) {
1706                 talloc_free(r);
1707                 return False;
1708         }
1709
1710         if (DEBUGLEVEL >= 10)
1711                 NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, r);
1712
1713         r->out.result = _wkssvc_NetrUnjoinDomain2(p, r);
1714
1715         if (p->rng_fault_state) {
1716                 talloc_free(r);
1717                 /* Return True here, srv_pipe_hnd.c will take care */
1718                 return True;
1719         }
1720
1721         if (DEBUGLEVEL >= 10)
1722                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, r);
1723
1724         push = ndr_push_init_ctx(r);
1725         if (push == NULL) {
1726                 talloc_free(r);
1727                 return False;
1728         }
1729
1730         status = call->ndr_push(push, NDR_OUT, r);
1731         if (NT_STATUS_IS_ERR(status)) {
1732                 talloc_free(r);
1733                 return False;
1734         }
1735
1736         blob = ndr_push_blob(push);
1737         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1738                 talloc_free(r);
1739                 return False;
1740         }
1741
1742         talloc_free(r);
1743
1744         return True;
1745 }
1746
1747 static bool api_wkssvc_NetrRenameMachineInDomain2(pipes_struct *p)
1748 {
1749         const struct ndr_interface_call *call;
1750         struct ndr_pull *pull;
1751         struct ndr_push *push;
1752         NTSTATUS status;
1753         DATA_BLOB blob;
1754         struct wkssvc_NetrRenameMachineInDomain2 *r;
1755
1756         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2];
1757
1758         r = talloc(NULL, struct wkssvc_NetrRenameMachineInDomain2);
1759         if (r == NULL) {
1760                 return False;
1761         }
1762
1763         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1764                 talloc_free(r);
1765                 return False;
1766         }
1767
1768         pull = ndr_pull_init_blob(&blob, r);
1769         if (pull == NULL) {
1770                 talloc_free(r);
1771                 return False;
1772         }
1773
1774         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1775         status = call->ndr_pull(pull, NDR_IN, r);
1776         if (NT_STATUS_IS_ERR(status)) {
1777                 talloc_free(r);
1778                 return False;
1779         }
1780
1781         if (DEBUGLEVEL >= 10)
1782                 NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, r);
1783
1784         r->out.result = _wkssvc_NetrRenameMachineInDomain2(p, r);
1785
1786         if (p->rng_fault_state) {
1787                 talloc_free(r);
1788                 /* Return True here, srv_pipe_hnd.c will take care */
1789                 return True;
1790         }
1791
1792         if (DEBUGLEVEL >= 10)
1793                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, r);
1794
1795         push = ndr_push_init_ctx(r);
1796         if (push == NULL) {
1797                 talloc_free(r);
1798                 return False;
1799         }
1800
1801         status = call->ndr_push(push, NDR_OUT, r);
1802         if (NT_STATUS_IS_ERR(status)) {
1803                 talloc_free(r);
1804                 return False;
1805         }
1806
1807         blob = ndr_push_blob(push);
1808         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1809                 talloc_free(r);
1810                 return False;
1811         }
1812
1813         talloc_free(r);
1814
1815         return True;
1816 }
1817
1818 static bool api_WKSSVC_NETRVALIDATENAME2(pipes_struct *p)
1819 {
1820         const struct ndr_interface_call *call;
1821         struct ndr_pull *pull;
1822         struct ndr_push *push;
1823         NTSTATUS status;
1824         DATA_BLOB blob;
1825         struct WKSSVC_NETRVALIDATENAME2 *r;
1826
1827         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRVALIDATENAME2];
1828
1829         r = talloc(NULL, struct WKSSVC_NETRVALIDATENAME2);
1830         if (r == NULL) {
1831                 return False;
1832         }
1833
1834         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1835                 talloc_free(r);
1836                 return False;
1837         }
1838
1839         pull = ndr_pull_init_blob(&blob, r);
1840         if (pull == NULL) {
1841                 talloc_free(r);
1842                 return False;
1843         }
1844
1845         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1846         status = call->ndr_pull(pull, NDR_IN, r);
1847         if (NT_STATUS_IS_ERR(status)) {
1848                 talloc_free(r);
1849                 return False;
1850         }
1851
1852         if (DEBUGLEVEL >= 10)
1853                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME2, r);
1854
1855         r->out.result = _WKSSVC_NETRVALIDATENAME2(p, r);
1856
1857         if (p->rng_fault_state) {
1858                 talloc_free(r);
1859                 /* Return True here, srv_pipe_hnd.c will take care */
1860                 return True;
1861         }
1862
1863         if (DEBUGLEVEL >= 10)
1864                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME2, r);
1865
1866         push = ndr_push_init_ctx(r);
1867         if (push == NULL) {
1868                 talloc_free(r);
1869                 return False;
1870         }
1871
1872         status = call->ndr_push(push, NDR_OUT, r);
1873         if (NT_STATUS_IS_ERR(status)) {
1874                 talloc_free(r);
1875                 return False;
1876         }
1877
1878         blob = ndr_push_blob(push);
1879         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1880                 talloc_free(r);
1881                 return False;
1882         }
1883
1884         talloc_free(r);
1885
1886         return True;
1887 }
1888
1889 static bool api_WKSSVC_NETRGETJOINABLEOUS2(pipes_struct *p)
1890 {
1891         const struct ndr_interface_call *call;
1892         struct ndr_pull *pull;
1893         struct ndr_push *push;
1894         NTSTATUS status;
1895         DATA_BLOB blob;
1896         struct WKSSVC_NETRGETJOINABLEOUS2 *r;
1897
1898         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOINABLEOUS2];
1899
1900         r = talloc(NULL, struct WKSSVC_NETRGETJOINABLEOUS2);
1901         if (r == NULL) {
1902                 return False;
1903         }
1904
1905         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1906                 talloc_free(r);
1907                 return False;
1908         }
1909
1910         pull = ndr_pull_init_blob(&blob, r);
1911         if (pull == NULL) {
1912                 talloc_free(r);
1913                 return False;
1914         }
1915
1916         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1917         status = call->ndr_pull(pull, NDR_IN, r);
1918         if (NT_STATUS_IS_ERR(status)) {
1919                 talloc_free(r);
1920                 return False;
1921         }
1922
1923         if (DEBUGLEVEL >= 10)
1924                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, r);
1925
1926         r->out.result = _WKSSVC_NETRGETJOINABLEOUS2(p, r);
1927
1928         if (p->rng_fault_state) {
1929                 talloc_free(r);
1930                 /* Return True here, srv_pipe_hnd.c will take care */
1931                 return True;
1932         }
1933
1934         if (DEBUGLEVEL >= 10)
1935                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, r);
1936
1937         push = ndr_push_init_ctx(r);
1938         if (push == NULL) {
1939                 talloc_free(r);
1940                 return False;
1941         }
1942
1943         status = call->ndr_push(push, NDR_OUT, r);
1944         if (NT_STATUS_IS_ERR(status)) {
1945                 talloc_free(r);
1946                 return False;
1947         }
1948
1949         blob = ndr_push_blob(push);
1950         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
1951                 talloc_free(r);
1952                 return False;
1953         }
1954
1955         talloc_free(r);
1956
1957         return True;
1958 }
1959
1960 static bool api_wkssvc_NetrAddAlternateComputerName(pipes_struct *p)
1961 {
1962         const struct ndr_interface_call *call;
1963         struct ndr_pull *pull;
1964         struct ndr_push *push;
1965         NTSTATUS status;
1966         DATA_BLOB blob;
1967         struct wkssvc_NetrAddAlternateComputerName *r;
1968
1969         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME];
1970
1971         r = talloc(NULL, struct wkssvc_NetrAddAlternateComputerName);
1972         if (r == NULL) {
1973                 return False;
1974         }
1975
1976         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1977                 talloc_free(r);
1978                 return False;
1979         }
1980
1981         pull = ndr_pull_init_blob(&blob, r);
1982         if (pull == NULL) {
1983                 talloc_free(r);
1984                 return False;
1985         }
1986
1987         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1988         status = call->ndr_pull(pull, NDR_IN, r);
1989         if (NT_STATUS_IS_ERR(status)) {
1990                 talloc_free(r);
1991                 return False;
1992         }
1993
1994         if (DEBUGLEVEL >= 10)
1995                 NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, r);
1996
1997         r->out.result = _wkssvc_NetrAddAlternateComputerName(p, r);
1998
1999         if (p->rng_fault_state) {
2000                 talloc_free(r);
2001                 /* Return True here, srv_pipe_hnd.c will take care */
2002                 return True;
2003         }
2004
2005         if (DEBUGLEVEL >= 10)
2006                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, r);
2007
2008         push = ndr_push_init_ctx(r);
2009         if (push == NULL) {
2010                 talloc_free(r);
2011                 return False;
2012         }
2013
2014         status = call->ndr_push(push, NDR_OUT, r);
2015         if (NT_STATUS_IS_ERR(status)) {
2016                 talloc_free(r);
2017                 return False;
2018         }
2019
2020         blob = ndr_push_blob(push);
2021         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2022                 talloc_free(r);
2023                 return False;
2024         }
2025
2026         talloc_free(r);
2027
2028         return True;
2029 }
2030
2031 static bool api_wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p)
2032 {
2033         const struct ndr_interface_call *call;
2034         struct ndr_pull *pull;
2035         struct ndr_push *push;
2036         NTSTATUS status;
2037         DATA_BLOB blob;
2038         struct wkssvc_NetrRemoveAlternateComputerName *r;
2039
2040         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME];
2041
2042         r = talloc(NULL, struct wkssvc_NetrRemoveAlternateComputerName);
2043         if (r == NULL) {
2044                 return False;
2045         }
2046
2047         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2048                 talloc_free(r);
2049                 return False;
2050         }
2051
2052         pull = ndr_pull_init_blob(&blob, r);
2053         if (pull == NULL) {
2054                 talloc_free(r);
2055                 return False;
2056         }
2057
2058         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2059         status = call->ndr_pull(pull, NDR_IN, r);
2060         if (NT_STATUS_IS_ERR(status)) {
2061                 talloc_free(r);
2062                 return False;
2063         }
2064
2065         if (DEBUGLEVEL >= 10)
2066                 NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, r);
2067
2068         r->out.result = _wkssvc_NetrRemoveAlternateComputerName(p, r);
2069
2070         if (p->rng_fault_state) {
2071                 talloc_free(r);
2072                 /* Return True here, srv_pipe_hnd.c will take care */
2073                 return True;
2074         }
2075
2076         if (DEBUGLEVEL >= 10)
2077                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, r);
2078
2079         push = ndr_push_init_ctx(r);
2080         if (push == NULL) {
2081                 talloc_free(r);
2082                 return False;
2083         }
2084
2085         status = call->ndr_push(push, NDR_OUT, r);
2086         if (NT_STATUS_IS_ERR(status)) {
2087                 talloc_free(r);
2088                 return False;
2089         }
2090
2091         blob = ndr_push_blob(push);
2092         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2093                 talloc_free(r);
2094                 return False;
2095         }
2096
2097         talloc_free(r);
2098
2099         return True;
2100 }
2101
2102 static bool api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pipes_struct *p)
2103 {
2104         const struct ndr_interface_call *call;
2105         struct ndr_pull *pull;
2106         struct ndr_push *push;
2107         NTSTATUS status;
2108         DATA_BLOB blob;
2109         struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r;
2110
2111         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME];
2112
2113         r = talloc(NULL, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME);
2114         if (r == NULL) {
2115                 return False;
2116         }
2117
2118         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2119                 talloc_free(r);
2120                 return False;
2121         }
2122
2123         pull = ndr_pull_init_blob(&blob, r);
2124         if (pull == NULL) {
2125                 talloc_free(r);
2126                 return False;
2127         }
2128
2129         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2130         status = call->ndr_pull(pull, NDR_IN, r);
2131         if (NT_STATUS_IS_ERR(status)) {
2132                 talloc_free(r);
2133                 return False;
2134         }
2135
2136         if (DEBUGLEVEL >= 10)
2137                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, r);
2138
2139         r->out.result = _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(p, r);
2140
2141         if (p->rng_fault_state) {
2142                 talloc_free(r);
2143                 /* Return True here, srv_pipe_hnd.c will take care */
2144                 return True;
2145         }
2146
2147         if (DEBUGLEVEL >= 10)
2148                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, r);
2149
2150         push = ndr_push_init_ctx(r);
2151         if (push == NULL) {
2152                 talloc_free(r);
2153                 return False;
2154         }
2155
2156         status = call->ndr_push(push, NDR_OUT, r);
2157         if (NT_STATUS_IS_ERR(status)) {
2158                 talloc_free(r);
2159                 return False;
2160         }
2161
2162         blob = ndr_push_blob(push);
2163         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2164                 talloc_free(r);
2165                 return False;
2166         }
2167
2168         talloc_free(r);
2169
2170         return True;
2171 }
2172
2173 static bool api_WKSSVC_NETRENUMERATECOMPUTERNAMES(pipes_struct *p)
2174 {
2175         const struct ndr_interface_call *call;
2176         struct ndr_pull *pull;
2177         struct ndr_push *push;
2178         NTSTATUS status;
2179         DATA_BLOB blob;
2180         struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r;
2181
2182         call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES];
2183
2184         r = talloc(NULL, struct WKSSVC_NETRENUMERATECOMPUTERNAMES);
2185         if (r == NULL) {
2186                 return False;
2187         }
2188
2189         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2190                 talloc_free(r);
2191                 return False;
2192         }
2193
2194         pull = ndr_pull_init_blob(&blob, r);
2195         if (pull == NULL) {
2196                 talloc_free(r);
2197                 return False;
2198         }
2199
2200         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2201         status = call->ndr_pull(pull, NDR_IN, r);
2202         if (NT_STATUS_IS_ERR(status)) {
2203                 talloc_free(r);
2204                 return False;
2205         }
2206
2207         if (DEBUGLEVEL >= 10)
2208                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, r);
2209
2210         r->out.result = _WKSSVC_NETRENUMERATECOMPUTERNAMES(p, r);
2211
2212         if (p->rng_fault_state) {
2213                 talloc_free(r);
2214                 /* Return True here, srv_pipe_hnd.c will take care */
2215                 return True;
2216         }
2217
2218         if (DEBUGLEVEL >= 10)
2219                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, r);
2220
2221         push = ndr_push_init_ctx(r);
2222         if (push == NULL) {
2223                 talloc_free(r);
2224                 return False;
2225         }
2226
2227         status = call->ndr_push(push, NDR_OUT, r);
2228         if (NT_STATUS_IS_ERR(status)) {
2229                 talloc_free(r);
2230                 return False;
2231         }
2232
2233         blob = ndr_push_blob(push);
2234         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
2235                 talloc_free(r);
2236                 return False;
2237         }
2238
2239         talloc_free(r);
2240
2241         return True;
2242 }
2243
2244
2245 /* Tables */
2246 static struct api_struct api_wkssvc_cmds[] =
2247 {
2248         {"WKSSVC_NETWKSTAGETINFO", NDR_WKSSVC_NETWKSTAGETINFO, api_wkssvc_NetWkstaGetInfo},
2249         {"WKSSVC_NETWKSTASETINFO", NDR_WKSSVC_NETWKSTASETINFO, api_wkssvc_NetWkstaSetInfo},
2250         {"WKSSVC_NETWKSTAENUMUSERS", NDR_WKSSVC_NETWKSTAENUMUSERS, api_wkssvc_NetWkstaEnumUsers},
2251         {"WKSSVC_NETRWKSTAUSERGETINFO", NDR_WKSSVC_NETRWKSTAUSERGETINFO, api_WKSSVC_NETRWKSTAUSERGETINFO},
2252         {"WKSSVC_NETRWKSTAUSERSETINFO", NDR_WKSSVC_NETRWKSTAUSERSETINFO, api_WKSSVC_NETRWKSTAUSERSETINFO},
2253         {"WKSSVC_NETWKSTATRANSPORTENUM", NDR_WKSSVC_NETWKSTATRANSPORTENUM, api_wkssvc_NetWkstaTransportEnum},
2254         {"WKSSVC_NETRWKSTATRANSPORTADD", NDR_WKSSVC_NETRWKSTATRANSPORTADD, api_WKSSVC_NETRWKSTATRANSPORTADD},
2255         {"WKSSVC_NETRWKSTATRANSPORTDEL", NDR_WKSSVC_NETRWKSTATRANSPORTDEL, api_WKSSVC_NETRWKSTATRANSPORTDEL},
2256         {"WKSSVC_NETRUSEADD", NDR_WKSSVC_NETRUSEADD, api_WKSSVC_NETRUSEADD},
2257         {"WKSSVC_NETRUSEGETINFO", NDR_WKSSVC_NETRUSEGETINFO, api_WKSSVC_NETRUSEGETINFO},
2258         {"WKSSVC_NETRUSEDEL", NDR_WKSSVC_NETRUSEDEL, api_WKSSVC_NETRUSEDEL},
2259         {"WKSSVC_NETRUSEENUM", NDR_WKSSVC_NETRUSEENUM, api_WKSSVC_NETRUSEENUM},
2260         {"WKSSVC_NETRMESSAGEBUFFERSEND", NDR_WKSSVC_NETRMESSAGEBUFFERSEND, api_WKSSVC_NETRMESSAGEBUFFERSEND},
2261         {"WKSSVC_NETRWORKSTATIONSTATISTICSGET", NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET, api_WKSSVC_NETRWORKSTATIONSTATISTICSGET},
2262         {"WKSSVC_NETRLOGONDOMAINNAMEADD", NDR_WKSSVC_NETRLOGONDOMAINNAMEADD, api_WKSSVC_NETRLOGONDOMAINNAMEADD},
2263         {"WKSSVC_NETRLOGONDOMAINNAMEDEL", NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL, api_WKSSVC_NETRLOGONDOMAINNAMEDEL},
2264         {"WKSSVC_NETRJOINDOMAIN", NDR_WKSSVC_NETRJOINDOMAIN, api_WKSSVC_NETRJOINDOMAIN},
2265         {"WKSSVC_NETRUNJOINDOMAIN", NDR_WKSSVC_NETRUNJOINDOMAIN, api_WKSSVC_NETRUNJOINDOMAIN},
2266         {"WKSSVC_NETRRENAMEMACHINEINDOMAIN", NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN, api_WKSSVC_NETRRENAMEMACHINEINDOMAIN},
2267         {"WKSSVC_NETRVALIDATENAME", NDR_WKSSVC_NETRVALIDATENAME, api_WKSSVC_NETRVALIDATENAME},
2268         {"WKSSVC_NETRGETJOININFORMATION", NDR_WKSSVC_NETRGETJOININFORMATION, api_WKSSVC_NETRGETJOININFORMATION},
2269         {"WKSSVC_NETRGETJOINABLEOUS", NDR_WKSSVC_NETRGETJOINABLEOUS, api_WKSSVC_NETRGETJOINABLEOUS},
2270         {"WKSSVC_NETRJOINDOMAIN2", NDR_WKSSVC_NETRJOINDOMAIN2, api_wkssvc_NetrJoinDomain2},
2271         {"WKSSVC_NETRUNJOINDOMAIN2", NDR_WKSSVC_NETRUNJOINDOMAIN2, api_wkssvc_NetrUnjoinDomain2},
2272         {"WKSSVC_NETRRENAMEMACHINEINDOMAIN2", NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, api_wkssvc_NetrRenameMachineInDomain2},
2273         {"WKSSVC_NETRVALIDATENAME2", NDR_WKSSVC_NETRVALIDATENAME2, api_WKSSVC_NETRVALIDATENAME2},
2274         {"WKSSVC_NETRGETJOINABLEOUS2", NDR_WKSSVC_NETRGETJOINABLEOUS2, api_WKSSVC_NETRGETJOINABLEOUS2},
2275         {"WKSSVC_NETRADDALTERNATECOMPUTERNAME", NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME, api_wkssvc_NetrAddAlternateComputerName},
2276         {"WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME", NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, api_wkssvc_NetrRemoveAlternateComputerName},
2277         {"WKSSVC_NETRSETPRIMARYCOMPUTERNAME", NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME},
2278         {"WKSSVC_NETRENUMERATECOMPUTERNAMES", NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES, api_WKSSVC_NETRENUMERATECOMPUTERNAMES},
2279 };
2280
2281 void wkssvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
2282 {
2283         *fns = api_wkssvc_cmds;
2284         *n_fns = sizeof(api_wkssvc_cmds) / sizeof(struct api_struct);
2285 }
2286
2287 NTSTATUS rpc_wkssvc_init(void)
2288 {
2289         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "wkssvc", "wkssvc", api_wkssvc_cmds, sizeof(api_wkssvc_cmds) / sizeof(struct api_struct));
2290 }