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         struct ndr_pull *pull;
  12         struct ndr_push *push;
  13         NTSTATUS status;
  14         DATA_BLOB blob;
  15         struct wkssvc_NetWkstaGetInfo r;
  16         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaGetInfo");
  17
  18         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
  19                 talloc_free(mem_ctx);
  20                 return False;
  21         }
  22
  23         pull = ndr_pull_init_blob(&blob, mem_ctx);
  24         if (pull == NULL)
  25                 return False;
  26
  27         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  28         status = ndr_pull_wkssvc_NetWkstaGetInfo(pull, NDR_IN, &r);
  29         if (NT_STATUS_IS_ERR(status)) {
  30                 talloc_free(mem_ctx);
  31                 return False;
  32         }
  33
  34         if (DEBUGLEVEL >= 10)
  35                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, &r);
  36
  37         ZERO_STRUCT(r.out);
  38         r.out.info = talloc_size(mem_ctx, sizeof(*r.out.info));
  39         if (r.out.info == NULL) {
  40                 talloc_free(mem_ctx);
  41                 return False;
  42         }
  43
  44         r.out.result = _wkssvc_NetWkstaGetInfo(p, r.in.server_name, r.in.level, r.out.info);
  45
  46         if (DEBUGLEVEL >= 10)
  47                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, &r);
  48
  49         push = ndr_push_init_ctx(mem_ctx);
  50         if (push == NULL) {
  51                 talloc_free(mem_ctx);
  52                 return False;
  53         }
  54
  55         status = ndr_push_wkssvc_NetWkstaGetInfo(push, NDR_OUT, &r);
  56         if (NT_STATUS_IS_ERR(status)) {
  57                 talloc_free(mem_ctx);
  58                 return False;
  59         }
  60
  61         blob = ndr_push_blob(push);
  62         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
  63                 talloc_free(mem_ctx);
  64                 return False;
  65         }
  66
  67         talloc_free(mem_ctx);
  68
  69         return True;
  70 }
  71
  72 static BOOL api_wkssvc_NetWkstaSetInfo(pipes_struct *p)
  73 {
  74         struct ndr_pull *pull;
  75         struct ndr_push *push;
  76         NTSTATUS status;
  77         DATA_BLOB blob;
  78         struct wkssvc_NetWkstaSetInfo r;
  79         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaSetInfo");
  80
  81         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
  82                 talloc_free(mem_ctx);
  83                 return False;
  84         }
  85
  86         pull = ndr_pull_init_blob(&blob, mem_ctx);
  87         if (pull == NULL)
  88                 return False;
  89
  90         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  91         status = ndr_pull_wkssvc_NetWkstaSetInfo(pull, NDR_IN, &r);
  92         if (NT_STATUS_IS_ERR(status)) {
  93                 talloc_free(mem_ctx);
  94                 return False;
  95         }
  96
  97         if (DEBUGLEVEL >= 10)
  98                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, &r);
  99
 100         ZERO_STRUCT(r.out);
 101         r.out.parm_error = r.in.parm_error;
 102         r.out.result = _wkssvc_NetWkstaSetInfo(p, r.in.server_name, r.in.level, r.in.info, r.in.parm_error);
 103
 104         if (DEBUGLEVEL >= 10)
 105                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &r);
 106
 107         push = ndr_push_init_ctx(mem_ctx);
 108         if (push == NULL) {
 109                 talloc_free(mem_ctx);
 110                 return False;
 111         }
 112
 113         status = ndr_push_wkssvc_NetWkstaSetInfo(push, NDR_OUT, &r);
 114         if (NT_STATUS_IS_ERR(status)) {
 115                 talloc_free(mem_ctx);
 116                 return False;
 117         }
 118
 119         blob = ndr_push_blob(push);
 120         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 121                 talloc_free(mem_ctx);
 122                 return False;
 123         }
 124
 125         talloc_free(mem_ctx);
 126
 127         return True;
 128 }
 129
 130 static BOOL api_wkssvc_NetWkstaEnumUsers(pipes_struct *p)
 131 {
 132         struct ndr_pull *pull;
 133         struct ndr_push *push;
 134         NTSTATUS status;
 135         DATA_BLOB blob;
 136         struct wkssvc_NetWkstaEnumUsers r;
 137         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaEnumUsers");
 138
 139         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 140                 talloc_free(mem_ctx);
 141                 return False;
 142         }
 143
 144         pull = ndr_pull_init_blob(&blob, mem_ctx);
 145         if (pull == NULL)
 146                 return False;
 147
 148         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 149         status = ndr_pull_wkssvc_NetWkstaEnumUsers(pull, NDR_IN, &r);
 150         if (NT_STATUS_IS_ERR(status)) {
 151                 talloc_free(mem_ctx);
 152                 return False;
 153         }
 154
 155         if (DEBUGLEVEL >= 10)
 156                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
 157
 158         ZERO_STRUCT(r.out);
 159         r.out.users = r.in.users;
 160         r.out.entriesread = talloc_size(mem_ctx, sizeof(*r.out.entriesread));
 161         if (r.out.entriesread == NULL) {
 162                 talloc_free(mem_ctx);
 163                 return False;
 164         }
 165
 166         r.out.totalentries = talloc_size(mem_ctx, sizeof(*r.out.totalentries));
 167         if (r.out.totalentries == NULL) {
 168                 talloc_free(mem_ctx);
 169                 return False;
 170         }
 171
 172         r.out.resumehandle = r.in.resumehandle;
 173         r.out.result = _wkssvc_NetWkstaEnumUsers(p, r.in.server_name, r.in.level, r.in.users, r.in.prefmaxlen, r.out.entriesread, r.out.totalentries, r.in.resumehandle);
 174
 175         if (DEBUGLEVEL >= 10)
 176                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
 177
 178         push = ndr_push_init_ctx(mem_ctx);
 179         if (push == NULL) {
 180                 talloc_free(mem_ctx);
 181                 return False;
 182         }
 183
 184         status = ndr_push_wkssvc_NetWkstaEnumUsers(push, NDR_OUT, &r);
 185         if (NT_STATUS_IS_ERR(status)) {
 186                 talloc_free(mem_ctx);
 187                 return False;
 188         }
 189
 190         blob = ndr_push_blob(push);
 191         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 192                 talloc_free(mem_ctx);
 193                 return False;
 194         }
 195
 196         talloc_free(mem_ctx);
 197
 198         return True;
 199 }
 200
 201 static BOOL api_WKSSVC_NETRWKSTAUSERGETINFO(pipes_struct *p)
 202 {
 203         struct ndr_pull *pull;
 204         struct ndr_push *push;
 205         NTSTATUS status;
 206         DATA_BLOB blob;
 207         struct WKSSVC_NETRWKSTAUSERGETINFO r;
 208         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTAUSERGETINFO");
 209
 210         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 211                 talloc_free(mem_ctx);
 212                 return False;
 213         }
 214
 215         pull = ndr_pull_init_blob(&blob, mem_ctx);
 216         if (pull == NULL)
 217                 return False;
 218
 219         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 220         status = ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO(pull, NDR_IN, &r);
 221         if (NT_STATUS_IS_ERR(status)) {
 222                 talloc_free(mem_ctx);
 223                 return False;
 224         }
 225
 226         if (DEBUGLEVEL >= 10)
 227                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
 228
 229         r.out.result = _WKSSVC_NETRWKSTAUSERGETINFO(p);
 230
 231         if (DEBUGLEVEL >= 10)
 232                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
 233
 234         push = ndr_push_init_ctx(mem_ctx);
 235         if (push == NULL) {
 236                 talloc_free(mem_ctx);
 237                 return False;
 238         }
 239
 240         status = ndr_push_WKSSVC_NETRWKSTAUSERGETINFO(push, NDR_OUT, &r);
 241         if (NT_STATUS_IS_ERR(status)) {
 242                 talloc_free(mem_ctx);
 243                 return False;
 244         }
 245
 246         blob = ndr_push_blob(push);
 247         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 248                 talloc_free(mem_ctx);
 249                 return False;
 250         }
 251
 252         talloc_free(mem_ctx);
 253
 254         return True;
 255 }
 256
 257 static BOOL api_WKSSVC_NETRWKSTAUSERSETINFO(pipes_struct *p)
 258 {
 259         struct ndr_pull *pull;
 260         struct ndr_push *push;
 261         NTSTATUS status;
 262         DATA_BLOB blob;
 263         struct WKSSVC_NETRWKSTAUSERSETINFO r;
 264         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTAUSERSETINFO");
 265
 266         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 267                 talloc_free(mem_ctx);
 268                 return False;
 269         }
 270
 271         pull = ndr_pull_init_blob(&blob, mem_ctx);
 272         if (pull == NULL)
 273                 return False;
 274
 275         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 276         status = ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO(pull, NDR_IN, &r);
 277         if (NT_STATUS_IS_ERR(status)) {
 278                 talloc_free(mem_ctx);
 279                 return False;
 280         }
 281
 282         if (DEBUGLEVEL >= 10)
 283                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
 284
 285         r.out.result = _WKSSVC_NETRWKSTAUSERSETINFO(p);
 286
 287         if (DEBUGLEVEL >= 10)
 288                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
 289
 290         push = ndr_push_init_ctx(mem_ctx);
 291         if (push == NULL) {
 292                 talloc_free(mem_ctx);
 293                 return False;
 294         }
 295
 296         status = ndr_push_WKSSVC_NETRWKSTAUSERSETINFO(push, NDR_OUT, &r);
 297         if (NT_STATUS_IS_ERR(status)) {
 298                 talloc_free(mem_ctx);
 299                 return False;
 300         }
 301
 302         blob = ndr_push_blob(push);
 303         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 304                 talloc_free(mem_ctx);
 305                 return False;
 306         }
 307
 308         talloc_free(mem_ctx);
 309
 310         return True;
 311 }
 312
 313 static BOOL api_wkssvc_NetWkstaTransportEnum(pipes_struct *p)
 314 {
 315         struct ndr_pull *pull;
 316         struct ndr_push *push;
 317         NTSTATUS status;
 318         DATA_BLOB blob;
 319         struct wkssvc_NetWkstaTransportEnum r;
 320         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaTransportEnum");
 321
 322         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 323                 talloc_free(mem_ctx);
 324                 return False;
 325         }
 326
 327         pull = ndr_pull_init_blob(&blob, mem_ctx);
 328         if (pull == NULL)
 329                 return False;
 330
 331         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 332         status = ndr_pull_wkssvc_NetWkstaTransportEnum(pull, NDR_IN, &r);
 333         if (NT_STATUS_IS_ERR(status)) {
 334                 talloc_free(mem_ctx);
 335                 return False;
 336         }
 337
 338         if (DEBUGLEVEL >= 10)
 339                 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
 340
 341         ZERO_STRUCT(r.out);
 342         r.out.level = r.in.level;
 343         r.out.ctr = r.in.ctr;
 344         r.out.totalentries = talloc_size(mem_ctx, sizeof(*r.out.totalentries));
 345         if (r.out.totalentries == NULL) {
 346                 talloc_free(mem_ctx);
 347                 return False;
 348         }
 349
 350         r.out.resume_handle = r.in.resume_handle;
 351         r.out.result = _wkssvc_NetWkstaTransportEnum(p, r.in.server_name, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
 352
 353         if (DEBUGLEVEL >= 10)
 354                 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
 355
 356         push = ndr_push_init_ctx(mem_ctx);
 357         if (push == NULL) {
 358                 talloc_free(mem_ctx);
 359                 return False;
 360         }
 361
 362         status = ndr_push_wkssvc_NetWkstaTransportEnum(push, NDR_OUT, &r);
 363         if (NT_STATUS_IS_ERR(status)) {
 364                 talloc_free(mem_ctx);
 365                 return False;
 366         }
 367
 368         blob = ndr_push_blob(push);
 369         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 370                 talloc_free(mem_ctx);
 371                 return False;
 372         }
 373
 374         talloc_free(mem_ctx);
 375
 376         return True;
 377 }
 378
 379 static BOOL api_WKSSVC_NETRWKSTATRANSPORTADD(pipes_struct *p)
 380 {
 381         struct ndr_pull *pull;
 382         struct ndr_push *push;
 383         NTSTATUS status;
 384         DATA_BLOB blob;
 385         struct WKSSVC_NETRWKSTATRANSPORTADD r;
 386         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTATRANSPORTADD");
 387
 388         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 389                 talloc_free(mem_ctx);
 390                 return False;
 391         }
 392
 393         pull = ndr_pull_init_blob(&blob, mem_ctx);
 394         if (pull == NULL)
 395                 return False;
 396
 397         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 398         status = ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD(pull, NDR_IN, &r);
 399         if (NT_STATUS_IS_ERR(status)) {
 400                 talloc_free(mem_ctx);
 401                 return False;
 402         }
 403
 404         if (DEBUGLEVEL >= 10)
 405                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
 406
 407         r.out.result = _WKSSVC_NETRWKSTATRANSPORTADD(p);
 408
 409         if (DEBUGLEVEL >= 10)
 410                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
 411
 412         push = ndr_push_init_ctx(mem_ctx);
 413         if (push == NULL) {
 414                 talloc_free(mem_ctx);
 415                 return False;
 416         }
 417
 418         status = ndr_push_WKSSVC_NETRWKSTATRANSPORTADD(push, NDR_OUT, &r);
 419         if (NT_STATUS_IS_ERR(status)) {
 420                 talloc_free(mem_ctx);
 421                 return False;
 422         }
 423
 424         blob = ndr_push_blob(push);
 425         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 426                 talloc_free(mem_ctx);
 427                 return False;
 428         }
 429
 430         talloc_free(mem_ctx);
 431
 432         return True;
 433 }
 434
 435 static BOOL api_WKSSVC_NETRWKSTATRANSPORTDEL(pipes_struct *p)
 436 {
 437         struct ndr_pull *pull;
 438         struct ndr_push *push;
 439         NTSTATUS status;
 440         DATA_BLOB blob;
 441         struct WKSSVC_NETRWKSTATRANSPORTDEL r;
 442         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTATRANSPORTDEL");
 443
 444         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 445                 talloc_free(mem_ctx);
 446                 return False;
 447         }
 448
 449         pull = ndr_pull_init_blob(&blob, mem_ctx);
 450         if (pull == NULL)
 451                 return False;
 452
 453         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 454         status = ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL(pull, NDR_IN, &r);
 455         if (NT_STATUS_IS_ERR(status)) {
 456                 talloc_free(mem_ctx);
 457                 return False;
 458         }
 459
 460         if (DEBUGLEVEL >= 10)
 461                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
 462
 463         r.out.result = _WKSSVC_NETRWKSTATRANSPORTDEL(p);
 464
 465         if (DEBUGLEVEL >= 10)
 466                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
 467
 468         push = ndr_push_init_ctx(mem_ctx);
 469         if (push == NULL) {
 470                 talloc_free(mem_ctx);
 471                 return False;
 472         }
 473
 474         status = ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL(push, NDR_OUT, &r);
 475         if (NT_STATUS_IS_ERR(status)) {
 476                 talloc_free(mem_ctx);
 477                 return False;
 478         }
 479
 480         blob = ndr_push_blob(push);
 481         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 482                 talloc_free(mem_ctx);
 483                 return False;
 484         }
 485
 486         talloc_free(mem_ctx);
 487
 488         return True;
 489 }
 490
 491 static BOOL api_WKSSVC_NETRUSEADD(pipes_struct *p)
 492 {
 493         struct ndr_pull *pull;
 494         struct ndr_push *push;
 495         NTSTATUS status;
 496         DATA_BLOB blob;
 497         struct WKSSVC_NETRUSEADD r;
 498         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEADD");
 499
 500         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 501                 talloc_free(mem_ctx);
 502                 return False;
 503         }
 504
 505         pull = ndr_pull_init_blob(&blob, mem_ctx);
 506         if (pull == NULL)
 507                 return False;
 508
 509         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 510         status = ndr_pull_WKSSVC_NETRUSEADD(pull, NDR_IN, &r);
 511         if (NT_STATUS_IS_ERR(status)) {
 512                 talloc_free(mem_ctx);
 513                 return False;
 514         }
 515
 516         if (DEBUGLEVEL >= 10)
 517                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEADD, &r);
 518
 519         r.out.result = _WKSSVC_NETRUSEADD(p);
 520
 521         if (DEBUGLEVEL >= 10)
 522                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEADD, &r);
 523
 524         push = ndr_push_init_ctx(mem_ctx);
 525         if (push == NULL) {
 526                 talloc_free(mem_ctx);
 527                 return False;
 528         }
 529
 530         status = ndr_push_WKSSVC_NETRUSEADD(push, NDR_OUT, &r);
 531         if (NT_STATUS_IS_ERR(status)) {
 532                 talloc_free(mem_ctx);
 533                 return False;
 534         }
 535
 536         blob = ndr_push_blob(push);
 537         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 538                 talloc_free(mem_ctx);
 539                 return False;
 540         }
 541
 542         talloc_free(mem_ctx);
 543
 544         return True;
 545 }
 546
 547 static BOOL api_WKSSVC_NETRUSEGETINFO(pipes_struct *p)
 548 {
 549         struct ndr_pull *pull;
 550         struct ndr_push *push;
 551         NTSTATUS status;
 552         DATA_BLOB blob;
 553         struct WKSSVC_NETRUSEGETINFO r;
 554         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEGETINFO");
 555
 556         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 557                 talloc_free(mem_ctx);
 558                 return False;
 559         }
 560
 561         pull = ndr_pull_init_blob(&blob, mem_ctx);
 562         if (pull == NULL)
 563                 return False;
 564
 565         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 566         status = ndr_pull_WKSSVC_NETRUSEGETINFO(pull, NDR_IN, &r);
 567         if (NT_STATUS_IS_ERR(status)) {
 568                 talloc_free(mem_ctx);
 569                 return False;
 570         }
 571
 572         if (DEBUGLEVEL >= 10)
 573                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
 574
 575         r.out.result = _WKSSVC_NETRUSEGETINFO(p);
 576
 577         if (DEBUGLEVEL >= 10)
 578                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
 579
 580         push = ndr_push_init_ctx(mem_ctx);
 581         if (push == NULL) {
 582                 talloc_free(mem_ctx);
 583                 return False;
 584         }
 585
 586         status = ndr_push_WKSSVC_NETRUSEGETINFO(push, NDR_OUT, &r);
 587         if (NT_STATUS_IS_ERR(status)) {
 588                 talloc_free(mem_ctx);
 589                 return False;
 590         }
 591
 592         blob = ndr_push_blob(push);
 593         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 594                 talloc_free(mem_ctx);
 595                 return False;
 596         }
 597
 598         talloc_free(mem_ctx);
 599
 600         return True;
 601 }
 602
 603 static BOOL api_WKSSVC_NETRUSEDEL(pipes_struct *p)
 604 {
 605         struct ndr_pull *pull;
 606         struct ndr_push *push;
 607         NTSTATUS status;
 608         DATA_BLOB blob;
 609         struct WKSSVC_NETRUSEDEL r;
 610         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEDEL");
 611
 612         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 613                 talloc_free(mem_ctx);
 614                 return False;
 615         }
 616
 617         pull = ndr_pull_init_blob(&blob, mem_ctx);
 618         if (pull == NULL)
 619                 return False;
 620
 621         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 622         status = ndr_pull_WKSSVC_NETRUSEDEL(pull, NDR_IN, &r);
 623         if (NT_STATUS_IS_ERR(status)) {
 624                 talloc_free(mem_ctx);
 625                 return False;
 626         }
 627
 628         if (DEBUGLEVEL >= 10)
 629                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEDEL, &r);
 630
 631         r.out.result = _WKSSVC_NETRUSEDEL(p);
 632
 633         if (DEBUGLEVEL >= 10)
 634                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEDEL, &r);
 635
 636         push = ndr_push_init_ctx(mem_ctx);
 637         if (push == NULL) {
 638                 talloc_free(mem_ctx);
 639                 return False;
 640         }
 641
 642         status = ndr_push_WKSSVC_NETRUSEDEL(push, NDR_OUT, &r);
 643         if (NT_STATUS_IS_ERR(status)) {
 644                 talloc_free(mem_ctx);
 645                 return False;
 646         }
 647
 648         blob = ndr_push_blob(push);
 649         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 650                 talloc_free(mem_ctx);
 651                 return False;
 652         }
 653
 654         talloc_free(mem_ctx);
 655
 656         return True;
 657 }
 658
 659 static BOOL api_WKSSVC_NETRUSEENUM(pipes_struct *p)
 660 {
 661         struct ndr_pull *pull;
 662         struct ndr_push *push;
 663         NTSTATUS status;
 664         DATA_BLOB blob;
 665         struct WKSSVC_NETRUSEENUM r;
 666         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEENUM");
 667
 668         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 669                 talloc_free(mem_ctx);
 670                 return False;
 671         }
 672
 673         pull = ndr_pull_init_blob(&blob, mem_ctx);
 674         if (pull == NULL)
 675                 return False;
 676
 677         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 678         status = ndr_pull_WKSSVC_NETRUSEENUM(pull, NDR_IN, &r);
 679         if (NT_STATUS_IS_ERR(status)) {
 680                 talloc_free(mem_ctx);
 681                 return False;
 682         }
 683
 684         if (DEBUGLEVEL >= 10)
 685                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEENUM, &r);
 686
 687         r.out.result = _WKSSVC_NETRUSEENUM(p);
 688
 689         if (DEBUGLEVEL >= 10)
 690                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEENUM, &r);
 691
 692         push = ndr_push_init_ctx(mem_ctx);
 693         if (push == NULL) {
 694                 talloc_free(mem_ctx);
 695                 return False;
 696         }
 697
 698         status = ndr_push_WKSSVC_NETRUSEENUM(push, NDR_OUT, &r);
 699         if (NT_STATUS_IS_ERR(status)) {
 700                 talloc_free(mem_ctx);
 701                 return False;
 702         }
 703
 704         blob = ndr_push_blob(push);
 705         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 706                 talloc_free(mem_ctx);
 707                 return False;
 708         }
 709
 710         talloc_free(mem_ctx);
 711
 712         return True;
 713 }
 714
 715 static BOOL api_WKSSVC_NETRMESSAGEBUFFERSEND(pipes_struct *p)
 716 {
 717         struct ndr_pull *pull;
 718         struct ndr_push *push;
 719         NTSTATUS status;
 720         DATA_BLOB blob;
 721         struct WKSSVC_NETRMESSAGEBUFFERSEND r;
 722         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRMESSAGEBUFFERSEND");
 723
 724         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 725                 talloc_free(mem_ctx);
 726                 return False;
 727         }
 728
 729         pull = ndr_pull_init_blob(&blob, mem_ctx);
 730         if (pull == NULL)
 731                 return False;
 732
 733         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 734         status = ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND(pull, NDR_IN, &r);
 735         if (NT_STATUS_IS_ERR(status)) {
 736                 talloc_free(mem_ctx);
 737                 return False;
 738         }
 739
 740         if (DEBUGLEVEL >= 10)
 741                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
 742
 743         r.out.result = _WKSSVC_NETRMESSAGEBUFFERSEND(p);
 744
 745         if (DEBUGLEVEL >= 10)
 746                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
 747
 748         push = ndr_push_init_ctx(mem_ctx);
 749         if (push == NULL) {
 750                 talloc_free(mem_ctx);
 751                 return False;
 752         }
 753
 754         status = ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND(push, NDR_OUT, &r);
 755         if (NT_STATUS_IS_ERR(status)) {
 756                 talloc_free(mem_ctx);
 757                 return False;
 758         }
 759
 760         blob = ndr_push_blob(push);
 761         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 762                 talloc_free(mem_ctx);
 763                 return False;
 764         }
 765
 766         talloc_free(mem_ctx);
 767
 768         return True;
 769 }
 770
 771 static BOOL api_WKSSVC_NETRWORKSTATIONSTATISTICSGET(pipes_struct *p)
 772 {
 773         struct ndr_pull *pull;
 774         struct ndr_push *push;
 775         NTSTATUS status;
 776         DATA_BLOB blob;
 777         struct WKSSVC_NETRWORKSTATIONSTATISTICSGET r;
 778         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWORKSTATIONSTATISTICSGET");
 779
 780         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 781                 talloc_free(mem_ctx);
 782                 return False;
 783         }
 784
 785         pull = ndr_pull_init_blob(&blob, mem_ctx);
 786         if (pull == NULL)
 787                 return False;
 788
 789         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 790         status = ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET(pull, NDR_IN, &r);
 791         if (NT_STATUS_IS_ERR(status)) {
 792                 talloc_free(mem_ctx);
 793                 return False;
 794         }
 795
 796         if (DEBUGLEVEL >= 10)
 797                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
 798
 799         r.out.result = _WKSSVC_NETRWORKSTATIONSTATISTICSGET(p);
 800
 801         if (DEBUGLEVEL >= 10)
 802                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
 803
 804         push = ndr_push_init_ctx(mem_ctx);
 805         if (push == NULL) {
 806                 talloc_free(mem_ctx);
 807                 return False;
 808         }
 809
 810         status = ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET(push, NDR_OUT, &r);
 811         if (NT_STATUS_IS_ERR(status)) {
 812                 talloc_free(mem_ctx);
 813                 return False;
 814         }
 815
 816         blob = ndr_push_blob(push);
 817         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 818                 talloc_free(mem_ctx);
 819                 return False;
 820         }
 821
 822         talloc_free(mem_ctx);
 823
 824         return True;
 825 }
 826
 827 static BOOL api_WKSSVC_NETRLOGONDOMAINNAMEADD(pipes_struct *p)
 828 {
 829         struct ndr_pull *pull;
 830         struct ndr_push *push;
 831         NTSTATUS status;
 832         DATA_BLOB blob;
 833         struct WKSSVC_NETRLOGONDOMAINNAMEADD r;
 834         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRLOGONDOMAINNAMEADD");
 835
 836         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 837                 talloc_free(mem_ctx);
 838                 return False;
 839         }
 840
 841         pull = ndr_pull_init_blob(&blob, mem_ctx);
 842         if (pull == NULL)
 843                 return False;
 844
 845         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 846         status = ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD(pull, NDR_IN, &r);
 847         if (NT_STATUS_IS_ERR(status)) {
 848                 talloc_free(mem_ctx);
 849                 return False;
 850         }
 851
 852         if (DEBUGLEVEL >= 10)
 853                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
 854
 855         r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEADD(p);
 856
 857         if (DEBUGLEVEL >= 10)
 858                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
 859
 860         push = ndr_push_init_ctx(mem_ctx);
 861         if (push == NULL) {
 862                 talloc_free(mem_ctx);
 863                 return False;
 864         }
 865
 866         status = ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD(push, NDR_OUT, &r);
 867         if (NT_STATUS_IS_ERR(status)) {
 868                 talloc_free(mem_ctx);
 869                 return False;
 870         }
 871
 872         blob = ndr_push_blob(push);
 873         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 874                 talloc_free(mem_ctx);
 875                 return False;
 876         }
 877
 878         talloc_free(mem_ctx);
 879
 880         return True;
 881 }
 882
 883 static BOOL api_WKSSVC_NETRLOGONDOMAINNAMEDEL(pipes_struct *p)
 884 {
 885         struct ndr_pull *pull;
 886         struct ndr_push *push;
 887         NTSTATUS status;
 888         DATA_BLOB blob;
 889         struct WKSSVC_NETRLOGONDOMAINNAMEDEL r;
 890         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRLOGONDOMAINNAMEDEL");
 891
 892         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 893                 talloc_free(mem_ctx);
 894                 return False;
 895         }
 896
 897         pull = ndr_pull_init_blob(&blob, mem_ctx);
 898         if (pull == NULL)
 899                 return False;
 900
 901         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 902         status = ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL(pull, NDR_IN, &r);
 903         if (NT_STATUS_IS_ERR(status)) {
 904                 talloc_free(mem_ctx);
 905                 return False;
 906         }
 907
 908         if (DEBUGLEVEL >= 10)
 909                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
 910
 911         r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEDEL(p);
 912
 913         if (DEBUGLEVEL >= 10)
 914                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
 915
 916         push = ndr_push_init_ctx(mem_ctx);
 917         if (push == NULL) {
 918                 talloc_free(mem_ctx);
 919                 return False;
 920         }
 921
 922         status = ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL(push, NDR_OUT, &r);
 923         if (NT_STATUS_IS_ERR(status)) {
 924                 talloc_free(mem_ctx);
 925                 return False;
 926         }
 927
 928         blob = ndr_push_blob(push);
 929         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 930                 talloc_free(mem_ctx);
 931                 return False;
 932         }
 933
 934         talloc_free(mem_ctx);
 935
 936         return True;
 937 }
 938
 939 static BOOL api_WKSSVC_NETRJOINDOMAIN(pipes_struct *p)
 940 {
 941         struct ndr_pull *pull;
 942         struct ndr_push *push;
 943         NTSTATUS status;
 944         DATA_BLOB blob;
 945         struct WKSSVC_NETRJOINDOMAIN r;
 946         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRJOINDOMAIN");
 947
 948         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
 949                 talloc_free(mem_ctx);
 950                 return False;
 951         }
 952
 953         pull = ndr_pull_init_blob(&blob, mem_ctx);
 954         if (pull == NULL)
 955                 return False;
 956
 957         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 958         status = ndr_pull_WKSSVC_NETRJOINDOMAIN(pull, NDR_IN, &r);
 959         if (NT_STATUS_IS_ERR(status)) {
 960                 talloc_free(mem_ctx);
 961                 return False;
 962         }
 963
 964         if (DEBUGLEVEL >= 10)
 965                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
 966
 967         r.out.result = _WKSSVC_NETRJOINDOMAIN(p);
 968
 969         if (DEBUGLEVEL >= 10)
 970                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
 971
 972         push = ndr_push_init_ctx(mem_ctx);
 973         if (push == NULL) {
 974                 talloc_free(mem_ctx);
 975                 return False;
 976         }
 977
 978         status = ndr_push_WKSSVC_NETRJOINDOMAIN(push, NDR_OUT, &r);
 979         if (NT_STATUS_IS_ERR(status)) {
 980                 talloc_free(mem_ctx);
 981                 return False;
 982         }
 983
 984         blob = ndr_push_blob(push);
 985         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
 986                 talloc_free(mem_ctx);
 987                 return False;
 988         }
 989
 990         talloc_free(mem_ctx);
 991
 992         return True;
 993 }
 994
 995 static BOOL api_WKSSVC_NETRUNJOINDOMAIN(pipes_struct *p)
 996 {
 997         struct ndr_pull *pull;
 998         struct ndr_push *push;
 999         NTSTATUS status;
1000         DATA_BLOB blob;
1001         struct WKSSVC_NETRUNJOINDOMAIN r;
1002         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUNJOINDOMAIN");
1003
1004         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1005                 talloc_free(mem_ctx);
1006                 return False;
1007         }
1008
1009         pull = ndr_pull_init_blob(&blob, mem_ctx);
1010         if (pull == NULL)
1011                 return False;
1012
1013         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1014         status = ndr_pull_WKSSVC_NETRUNJOINDOMAIN(pull, NDR_IN, &r);
1015         if (NT_STATUS_IS_ERR(status)) {
1016                 talloc_free(mem_ctx);
1017                 return False;
1018         }
1019
1020         if (DEBUGLEVEL >= 10)
1021                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
1022
1023         r.out.result = _WKSSVC_NETRUNJOINDOMAIN(p);
1024
1025         if (DEBUGLEVEL >= 10)
1026                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
1027
1028         push = ndr_push_init_ctx(mem_ctx);
1029         if (push == NULL) {
1030                 talloc_free(mem_ctx);
1031                 return False;
1032         }
1033
1034         status = ndr_push_WKSSVC_NETRUNJOINDOMAIN(push, NDR_OUT, &r);
1035         if (NT_STATUS_IS_ERR(status)) {
1036                 talloc_free(mem_ctx);
1037                 return False;
1038         }
1039
1040         blob = ndr_push_blob(push);
1041         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1042                 talloc_free(mem_ctx);
1043                 return False;
1044         }
1045
1046         talloc_free(mem_ctx);
1047
1048         return True;
1049 }
1050
1051 static BOOL api_WKSSVC_NETRRENAMEMACHINEINDOMAIN(pipes_struct *p)
1052 {
1053         struct ndr_pull *pull;
1054         struct ndr_push *push;
1055         NTSTATUS status;
1056         DATA_BLOB blob;
1057         struct WKSSVC_NETRRENAMEMACHINEINDOMAIN r;
1058         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRRENAMEMACHINEINDOMAIN");
1059
1060         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1061                 talloc_free(mem_ctx);
1062                 return False;
1063         }
1064
1065         pull = ndr_pull_init_blob(&blob, mem_ctx);
1066         if (pull == NULL)
1067                 return False;
1068
1069         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1070         status = ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN(pull, NDR_IN, &r);
1071         if (NT_STATUS_IS_ERR(status)) {
1072                 talloc_free(mem_ctx);
1073                 return False;
1074         }
1075
1076         if (DEBUGLEVEL >= 10)
1077                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
1078
1079         r.out.result = _WKSSVC_NETRRENAMEMACHINEINDOMAIN(p);
1080
1081         if (DEBUGLEVEL >= 10)
1082                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
1083
1084         push = ndr_push_init_ctx(mem_ctx);
1085         if (push == NULL) {
1086                 talloc_free(mem_ctx);
1087                 return False;
1088         }
1089
1090         status = ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN(push, NDR_OUT, &r);
1091         if (NT_STATUS_IS_ERR(status)) {
1092                 talloc_free(mem_ctx);
1093                 return False;
1094         }
1095
1096         blob = ndr_push_blob(push);
1097         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1098                 talloc_free(mem_ctx);
1099                 return False;
1100         }
1101
1102         talloc_free(mem_ctx);
1103
1104         return True;
1105 }
1106
1107 static BOOL api_WKSSVC_NETRVALIDATENAME(pipes_struct *p)
1108 {
1109         struct ndr_pull *pull;
1110         struct ndr_push *push;
1111         NTSTATUS status;
1112         DATA_BLOB blob;
1113         struct WKSSVC_NETRVALIDATENAME r;
1114         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRVALIDATENAME");
1115
1116         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1117                 talloc_free(mem_ctx);
1118                 return False;
1119         }
1120
1121         pull = ndr_pull_init_blob(&blob, mem_ctx);
1122         if (pull == NULL)
1123                 return False;
1124
1125         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1126         status = ndr_pull_WKSSVC_NETRVALIDATENAME(pull, NDR_IN, &r);
1127         if (NT_STATUS_IS_ERR(status)) {
1128                 talloc_free(mem_ctx);
1129                 return False;
1130         }
1131
1132         if (DEBUGLEVEL >= 10)
1133                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
1134
1135         r.out.result = _WKSSVC_NETRVALIDATENAME(p);
1136
1137         if (DEBUGLEVEL >= 10)
1138                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
1139
1140         push = ndr_push_init_ctx(mem_ctx);
1141         if (push == NULL) {
1142                 talloc_free(mem_ctx);
1143                 return False;
1144         }
1145
1146         status = ndr_push_WKSSVC_NETRVALIDATENAME(push, NDR_OUT, &r);
1147         if (NT_STATUS_IS_ERR(status)) {
1148                 talloc_free(mem_ctx);
1149                 return False;
1150         }
1151
1152         blob = ndr_push_blob(push);
1153         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1154                 talloc_free(mem_ctx);
1155                 return False;
1156         }
1157
1158         talloc_free(mem_ctx);
1159
1160         return True;
1161 }
1162
1163 static BOOL api_WKSSVC_NETRGETJOININFORMATION(pipes_struct *p)
1164 {
1165         struct ndr_pull *pull;
1166         struct ndr_push *push;
1167         NTSTATUS status;
1168         DATA_BLOB blob;
1169         struct WKSSVC_NETRGETJOININFORMATION r;
1170         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOININFORMATION");
1171
1172         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1173                 talloc_free(mem_ctx);
1174                 return False;
1175         }
1176
1177         pull = ndr_pull_init_blob(&blob, mem_ctx);
1178         if (pull == NULL)
1179                 return False;
1180
1181         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1182         status = ndr_pull_WKSSVC_NETRGETJOININFORMATION(pull, NDR_IN, &r);
1183         if (NT_STATUS_IS_ERR(status)) {
1184                 talloc_free(mem_ctx);
1185                 return False;
1186         }
1187
1188         if (DEBUGLEVEL >= 10)
1189                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
1190
1191         r.out.result = _WKSSVC_NETRGETJOININFORMATION(p);
1192
1193         if (DEBUGLEVEL >= 10)
1194                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
1195
1196         push = ndr_push_init_ctx(mem_ctx);
1197         if (push == NULL) {
1198                 talloc_free(mem_ctx);
1199                 return False;
1200         }
1201
1202         status = ndr_push_WKSSVC_NETRGETJOININFORMATION(push, NDR_OUT, &r);
1203         if (NT_STATUS_IS_ERR(status)) {
1204                 talloc_free(mem_ctx);
1205                 return False;
1206         }
1207
1208         blob = ndr_push_blob(push);
1209         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1210                 talloc_free(mem_ctx);
1211                 return False;
1212         }
1213
1214         talloc_free(mem_ctx);
1215
1216         return True;
1217 }
1218
1219 static BOOL api_WKSSVC_NETRGETJOINABLEOUS(pipes_struct *p)
1220 {
1221         struct ndr_pull *pull;
1222         struct ndr_push *push;
1223         NTSTATUS status;
1224         DATA_BLOB blob;
1225         struct WKSSVC_NETRGETJOINABLEOUS r;
1226         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOINABLEOUS");
1227
1228         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1229                 talloc_free(mem_ctx);
1230                 return False;
1231         }
1232
1233         pull = ndr_pull_init_blob(&blob, mem_ctx);
1234         if (pull == NULL)
1235                 return False;
1236
1237         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1238         status = ndr_pull_WKSSVC_NETRGETJOINABLEOUS(pull, NDR_IN, &r);
1239         if (NT_STATUS_IS_ERR(status)) {
1240                 talloc_free(mem_ctx);
1241                 return False;
1242         }
1243
1244         if (DEBUGLEVEL >= 10)
1245                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
1246
1247         r.out.result = _WKSSVC_NETRGETJOINABLEOUS(p);
1248
1249         if (DEBUGLEVEL >= 10)
1250                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
1251
1252         push = ndr_push_init_ctx(mem_ctx);
1253         if (push == NULL) {
1254                 talloc_free(mem_ctx);
1255                 return False;
1256         }
1257
1258         status = ndr_push_WKSSVC_NETRGETJOINABLEOUS(push, NDR_OUT, &r);
1259         if (NT_STATUS_IS_ERR(status)) {
1260                 talloc_free(mem_ctx);
1261                 return False;
1262         }
1263
1264         blob = ndr_push_blob(push);
1265         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1266                 talloc_free(mem_ctx);
1267                 return False;
1268         }
1269
1270         talloc_free(mem_ctx);
1271
1272         return True;
1273 }
1274
1275 static BOOL api_wkssvc_NetrJoinDomain2(pipes_struct *p)
1276 {
1277         struct ndr_pull *pull;
1278         struct ndr_push *push;
1279         NTSTATUS status;
1280         DATA_BLOB blob;
1281         struct wkssvc_NetrJoinDomain2 r;
1282         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrJoinDomain2");
1283
1284         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1285                 talloc_free(mem_ctx);
1286                 return False;
1287         }
1288
1289         pull = ndr_pull_init_blob(&blob, mem_ctx);
1290         if (pull == NULL)
1291                 return False;
1292
1293         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1294         status = ndr_pull_wkssvc_NetrJoinDomain2(pull, NDR_IN, &r);
1295         if (NT_STATUS_IS_ERR(status)) {
1296                 talloc_free(mem_ctx);
1297                 return False;
1298         }
1299
1300         if (DEBUGLEVEL >= 10)
1301                 NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &r);
1302
1303         r.out.result = _wkssvc_NetrJoinDomain2(p, r.in.server_name, r.in.domain_name, r.in.account_name, r.in.admin_account, r.in.encrypted_password, r.in.join_flags);
1304
1305         if (DEBUGLEVEL >= 10)
1306                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &r);
1307
1308         push = ndr_push_init_ctx(mem_ctx);
1309         if (push == NULL) {
1310                 talloc_free(mem_ctx);
1311                 return False;
1312         }
1313
1314         status = ndr_push_wkssvc_NetrJoinDomain2(push, NDR_OUT, &r);
1315         if (NT_STATUS_IS_ERR(status)) {
1316                 talloc_free(mem_ctx);
1317                 return False;
1318         }
1319
1320         blob = ndr_push_blob(push);
1321         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1322                 talloc_free(mem_ctx);
1323                 return False;
1324         }
1325
1326         talloc_free(mem_ctx);
1327
1328         return True;
1329 }
1330
1331 static BOOL api_wkssvc_NetrUnjoinDomain2(pipes_struct *p)
1332 {
1333         struct ndr_pull *pull;
1334         struct ndr_push *push;
1335         NTSTATUS status;
1336         DATA_BLOB blob;
1337         struct wkssvc_NetrUnjoinDomain2 r;
1338         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrUnjoinDomain2");
1339
1340         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1341                 talloc_free(mem_ctx);
1342                 return False;
1343         }
1344
1345         pull = ndr_pull_init_blob(&blob, mem_ctx);
1346         if (pull == NULL)
1347                 return False;
1348
1349         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1350         status = ndr_pull_wkssvc_NetrUnjoinDomain2(pull, NDR_IN, &r);
1351         if (NT_STATUS_IS_ERR(status)) {
1352                 talloc_free(mem_ctx);
1353                 return False;
1354         }
1355
1356         if (DEBUGLEVEL >= 10)
1357                 NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
1358
1359         r.out.result = _wkssvc_NetrUnjoinDomain2(p, r.in.server_name, r.in.account, r.in.encrypted_password, r.in.unjoin_flags);
1360
1361         if (DEBUGLEVEL >= 10)
1362                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
1363
1364         push = ndr_push_init_ctx(mem_ctx);
1365         if (push == NULL) {
1366                 talloc_free(mem_ctx);
1367                 return False;
1368         }
1369
1370         status = ndr_push_wkssvc_NetrUnjoinDomain2(push, NDR_OUT, &r);
1371         if (NT_STATUS_IS_ERR(status)) {
1372                 talloc_free(mem_ctx);
1373                 return False;
1374         }
1375
1376         blob = ndr_push_blob(push);
1377         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1378                 talloc_free(mem_ctx);
1379                 return False;
1380         }
1381
1382         talloc_free(mem_ctx);
1383
1384         return True;
1385 }
1386
1387 static BOOL api_wkssvc_NetrRenameMachineInDomain2(pipes_struct *p)
1388 {
1389         struct ndr_pull *pull;
1390         struct ndr_push *push;
1391         NTSTATUS status;
1392         DATA_BLOB blob;
1393         struct wkssvc_NetrRenameMachineInDomain2 r;
1394         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrRenameMachineInDomain2");
1395
1396         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1397                 talloc_free(mem_ctx);
1398                 return False;
1399         }
1400
1401         pull = ndr_pull_init_blob(&blob, mem_ctx);
1402         if (pull == NULL)
1403                 return False;
1404
1405         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1406         status = ndr_pull_wkssvc_NetrRenameMachineInDomain2(pull, NDR_IN, &r);
1407         if (NT_STATUS_IS_ERR(status)) {
1408                 talloc_free(mem_ctx);
1409                 return False;
1410         }
1411
1412         if (DEBUGLEVEL >= 10)
1413                 NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
1414
1415         r.out.result = _wkssvc_NetrRenameMachineInDomain2(p, r.in.server_name, r.in.NewMachineName, r.in.Account, r.in.EncryptedPassword, r.in.RenameOptions);
1416
1417         if (DEBUGLEVEL >= 10)
1418                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
1419
1420         push = ndr_push_init_ctx(mem_ctx);
1421         if (push == NULL) {
1422                 talloc_free(mem_ctx);
1423                 return False;
1424         }
1425
1426         status = ndr_push_wkssvc_NetrRenameMachineInDomain2(push, NDR_OUT, &r);
1427         if (NT_STATUS_IS_ERR(status)) {
1428                 talloc_free(mem_ctx);
1429                 return False;
1430         }
1431
1432         blob = ndr_push_blob(push);
1433         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1434                 talloc_free(mem_ctx);
1435                 return False;
1436         }
1437
1438         talloc_free(mem_ctx);
1439
1440         return True;
1441 }
1442
1443 static BOOL api_WKSSVC_NETRVALIDATENAME2(pipes_struct *p)
1444 {
1445         struct ndr_pull *pull;
1446         struct ndr_push *push;
1447         NTSTATUS status;
1448         DATA_BLOB blob;
1449         struct WKSSVC_NETRVALIDATENAME2 r;
1450         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRVALIDATENAME2");
1451
1452         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1453                 talloc_free(mem_ctx);
1454                 return False;
1455         }
1456
1457         pull = ndr_pull_init_blob(&blob, mem_ctx);
1458         if (pull == NULL)
1459                 return False;
1460
1461         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1462         status = ndr_pull_WKSSVC_NETRVALIDATENAME2(pull, NDR_IN, &r);
1463         if (NT_STATUS_IS_ERR(status)) {
1464                 talloc_free(mem_ctx);
1465                 return False;
1466         }
1467
1468         if (DEBUGLEVEL >= 10)
1469                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
1470
1471         r.out.result = _WKSSVC_NETRVALIDATENAME2(p);
1472
1473         if (DEBUGLEVEL >= 10)
1474                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
1475
1476         push = ndr_push_init_ctx(mem_ctx);
1477         if (push == NULL) {
1478                 talloc_free(mem_ctx);
1479                 return False;
1480         }
1481
1482         status = ndr_push_WKSSVC_NETRVALIDATENAME2(push, NDR_OUT, &r);
1483         if (NT_STATUS_IS_ERR(status)) {
1484                 talloc_free(mem_ctx);
1485                 return False;
1486         }
1487
1488         blob = ndr_push_blob(push);
1489         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1490                 talloc_free(mem_ctx);
1491                 return False;
1492         }
1493
1494         talloc_free(mem_ctx);
1495
1496         return True;
1497 }
1498
1499 static BOOL api_WKSSVC_NETRGETJOINABLEOUS2(pipes_struct *p)
1500 {
1501         struct ndr_pull *pull;
1502         struct ndr_push *push;
1503         NTSTATUS status;
1504         DATA_BLOB blob;
1505         struct WKSSVC_NETRGETJOINABLEOUS2 r;
1506         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOINABLEOUS2");
1507
1508         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1509                 talloc_free(mem_ctx);
1510                 return False;
1511         }
1512
1513         pull = ndr_pull_init_blob(&blob, mem_ctx);
1514         if (pull == NULL)
1515                 return False;
1516
1517         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1518         status = ndr_pull_WKSSVC_NETRGETJOINABLEOUS2(pull, NDR_IN, &r);
1519         if (NT_STATUS_IS_ERR(status)) {
1520                 talloc_free(mem_ctx);
1521                 return False;
1522         }
1523
1524         if (DEBUGLEVEL >= 10)
1525                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
1526
1527         r.out.result = _WKSSVC_NETRGETJOINABLEOUS2(p);
1528
1529         if (DEBUGLEVEL >= 10)
1530                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
1531
1532         push = ndr_push_init_ctx(mem_ctx);
1533         if (push == NULL) {
1534                 talloc_free(mem_ctx);
1535                 return False;
1536         }
1537
1538         status = ndr_push_WKSSVC_NETRGETJOINABLEOUS2(push, NDR_OUT, &r);
1539         if (NT_STATUS_IS_ERR(status)) {
1540                 talloc_free(mem_ctx);
1541                 return False;
1542         }
1543
1544         blob = ndr_push_blob(push);
1545         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1546                 talloc_free(mem_ctx);
1547                 return False;
1548         }
1549
1550         talloc_free(mem_ctx);
1551
1552         return True;
1553 }
1554
1555 static BOOL api_wkssvc_NetrAddAlternateComputerName(pipes_struct *p)
1556 {
1557         struct ndr_pull *pull;
1558         struct ndr_push *push;
1559         NTSTATUS status;
1560         DATA_BLOB blob;
1561         struct wkssvc_NetrAddAlternateComputerName r;
1562         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrAddAlternateComputerName");
1563
1564         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1565                 talloc_free(mem_ctx);
1566                 return False;
1567         }
1568
1569         pull = ndr_pull_init_blob(&blob, mem_ctx);
1570         if (pull == NULL)
1571                 return False;
1572
1573         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1574         status = ndr_pull_wkssvc_NetrAddAlternateComputerName(pull, NDR_IN, &r);
1575         if (NT_STATUS_IS_ERR(status)) {
1576                 talloc_free(mem_ctx);
1577                 return False;
1578         }
1579
1580         if (DEBUGLEVEL >= 10)
1581                 NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
1582
1583         r.out.result = _wkssvc_NetrAddAlternateComputerName(p, r.in.server_name, r.in.NewAlternateMachineName, r.in.Account, r.in.EncryptedPassword, r.in.Reserved);
1584
1585         if (DEBUGLEVEL >= 10)
1586                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
1587
1588         push = ndr_push_init_ctx(mem_ctx);
1589         if (push == NULL) {
1590                 talloc_free(mem_ctx);
1591                 return False;
1592         }
1593
1594         status = ndr_push_wkssvc_NetrAddAlternateComputerName(push, NDR_OUT, &r);
1595         if (NT_STATUS_IS_ERR(status)) {
1596                 talloc_free(mem_ctx);
1597                 return False;
1598         }
1599
1600         blob = ndr_push_blob(push);
1601         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1602                 talloc_free(mem_ctx);
1603                 return False;
1604         }
1605
1606         talloc_free(mem_ctx);
1607
1608         return True;
1609 }
1610
1611 static BOOL api_wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p)
1612 {
1613         struct ndr_pull *pull;
1614         struct ndr_push *push;
1615         NTSTATUS status;
1616         DATA_BLOB blob;
1617         struct wkssvc_NetrRemoveAlternateComputerName r;
1618         TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrRemoveAlternateComputerName");
1619
1620         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1621                 talloc_free(mem_ctx);
1622                 return False;
1623         }
1624
1625         pull = ndr_pull_init_blob(&blob, mem_ctx);
1626         if (pull == NULL)
1627                 return False;
1628
1629         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1630         status = ndr_pull_wkssvc_NetrRemoveAlternateComputerName(pull, NDR_IN, &r);
1631         if (NT_STATUS_IS_ERR(status)) {
1632                 talloc_free(mem_ctx);
1633                 return False;
1634         }
1635
1636         if (DEBUGLEVEL >= 10)
1637                 NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
1638
1639         r.out.result = _wkssvc_NetrRemoveAlternateComputerName(p, r.in.server_name, r.in.AlternateMachineNameToRemove, r.in.Account, r.in.EncryptedPassword, r.in.Reserved);
1640
1641         if (DEBUGLEVEL >= 10)
1642                 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
1643
1644         push = ndr_push_init_ctx(mem_ctx);
1645         if (push == NULL) {
1646                 talloc_free(mem_ctx);
1647                 return False;
1648         }
1649
1650         status = ndr_push_wkssvc_NetrRemoveAlternateComputerName(push, NDR_OUT, &r);
1651         if (NT_STATUS_IS_ERR(status)) {
1652                 talloc_free(mem_ctx);
1653                 return False;
1654         }
1655
1656         blob = ndr_push_blob(push);
1657         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1658                 talloc_free(mem_ctx);
1659                 return False;
1660         }
1661
1662         talloc_free(mem_ctx);
1663
1664         return True;
1665 }
1666
1667 static BOOL api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pipes_struct *p)
1668 {
1669         struct ndr_pull *pull;
1670         struct ndr_push *push;
1671         NTSTATUS status;
1672         DATA_BLOB blob;
1673         struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME r;
1674         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
1675
1676         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1677                 talloc_free(mem_ctx);
1678                 return False;
1679         }
1680
1681         pull = ndr_pull_init_blob(&blob, mem_ctx);
1682         if (pull == NULL)
1683                 return False;
1684
1685         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1686         status = ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pull, NDR_IN, &r);
1687         if (NT_STATUS_IS_ERR(status)) {
1688                 talloc_free(mem_ctx);
1689                 return False;
1690         }
1691
1692         if (DEBUGLEVEL >= 10)
1693                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
1694
1695         r.out.result = _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(p);
1696
1697         if (DEBUGLEVEL >= 10)
1698                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
1699
1700         push = ndr_push_init_ctx(mem_ctx);
1701         if (push == NULL) {
1702                 talloc_free(mem_ctx);
1703                 return False;
1704         }
1705
1706         status = ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(push, NDR_OUT, &r);
1707         if (NT_STATUS_IS_ERR(status)) {
1708                 talloc_free(mem_ctx);
1709                 return False;
1710         }
1711
1712         blob = ndr_push_blob(push);
1713         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1714                 talloc_free(mem_ctx);
1715                 return False;
1716         }
1717
1718         talloc_free(mem_ctx);
1719
1720         return True;
1721 }
1722
1723 static BOOL api_WKSSVC_NETRENUMERATECOMPUTERNAMES(pipes_struct *p)
1724 {
1725         struct ndr_pull *pull;
1726         struct ndr_push *push;
1727         NTSTATUS status;
1728         DATA_BLOB blob;
1729         struct WKSSVC_NETRENUMERATECOMPUTERNAMES r;
1730         TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRENUMERATECOMPUTERNAMES");
1731
1732         if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
1733                 talloc_free(mem_ctx);
1734                 return False;
1735         }
1736
1737         pull = ndr_pull_init_blob(&blob, mem_ctx);
1738         if (pull == NULL)
1739                 return False;
1740
1741         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1742         status = ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES(pull, NDR_IN, &r);
1743         if (NT_STATUS_IS_ERR(status)) {
1744                 talloc_free(mem_ctx);
1745                 return False;
1746         }
1747
1748         if (DEBUGLEVEL >= 10)
1749                 NDR_PRINT_IN_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
1750
1751         r.out.result = _WKSSVC_NETRENUMERATECOMPUTERNAMES(p);
1752
1753         if (DEBUGLEVEL >= 10)
1754                 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
1755
1756         push = ndr_push_init_ctx(mem_ctx);
1757         if (push == NULL) {
1758                 talloc_free(mem_ctx);
1759                 return False;
1760         }
1761
1762         status = ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES(push, NDR_OUT, &r);
1763         if (NT_STATUS_IS_ERR(status)) {
1764                 talloc_free(mem_ctx);
1765                 return False;
1766         }
1767
1768         blob = ndr_push_blob(push);
1769         if (!prs_init_data_blob(&p->out_data.rdata, &blob, p->mem_ctx)) {
1770                 talloc_free(mem_ctx);
1771                 return False;
1772         }
1773
1774         talloc_free(mem_ctx);
1775
1776         return True;
1777 }
1778
1779
1780 /* Tables */
1781 static struct api_struct api_wkssvc_cmds[] =
1782 {
1783         {"WKSSVC_NETWKSTAGETINFO", DCERPC_WKSSVC_NETWKSTAGETINFO, api_wkssvc_NetWkstaGetInfo},
1784         {"WKSSVC_NETWKSTASETINFO", DCERPC_WKSSVC_NETWKSTASETINFO, api_wkssvc_NetWkstaSetInfo},
1785         {"WKSSVC_NETWKSTAENUMUSERS", DCERPC_WKSSVC_NETWKSTAENUMUSERS, api_wkssvc_NetWkstaEnumUsers},
1786         {"WKSSVC_NETRWKSTAUSERGETINFO", DCERPC_WKSSVC_NETRWKSTAUSERGETINFO, api_WKSSVC_NETRWKSTAUSERGETINFO},
1787         {"WKSSVC_NETRWKSTAUSERSETINFO", DCERPC_WKSSVC_NETRWKSTAUSERSETINFO, api_WKSSVC_NETRWKSTAUSERSETINFO},
1788         {"WKSSVC_NETWKSTATRANSPORTENUM", DCERPC_WKSSVC_NETWKSTATRANSPORTENUM, api_wkssvc_NetWkstaTransportEnum},
1789         {"WKSSVC_NETRWKSTATRANSPORTADD", DCERPC_WKSSVC_NETRWKSTATRANSPORTADD, api_WKSSVC_NETRWKSTATRANSPORTADD},
1790         {"WKSSVC_NETRWKSTATRANSPORTDEL", DCERPC_WKSSVC_NETRWKSTATRANSPORTDEL, api_WKSSVC_NETRWKSTATRANSPORTDEL},
1791         {"WKSSVC_NETRUSEADD", DCERPC_WKSSVC_NETRUSEADD, api_WKSSVC_NETRUSEADD},
1792         {"WKSSVC_NETRUSEGETINFO", DCERPC_WKSSVC_NETRUSEGETINFO, api_WKSSVC_NETRUSEGETINFO},
1793         {"WKSSVC_NETRUSEDEL", DCERPC_WKSSVC_NETRUSEDEL, api_WKSSVC_NETRUSEDEL},
1794         {"WKSSVC_NETRUSEENUM", DCERPC_WKSSVC_NETRUSEENUM, api_WKSSVC_NETRUSEENUM},
1795         {"WKSSVC_NETRMESSAGEBUFFERSEND", DCERPC_WKSSVC_NETRMESSAGEBUFFERSEND, api_WKSSVC_NETRMESSAGEBUFFERSEND},
1796         {"WKSSVC_NETRWORKSTATIONSTATISTICSGET", DCERPC_WKSSVC_NETRWORKSTATIONSTATISTICSGET, api_WKSSVC_NETRWORKSTATIONSTATISTICSGET},
1797         {"WKSSVC_NETRLOGONDOMAINNAMEADD", DCERPC_WKSSVC_NETRLOGONDOMAINNAMEADD, api_WKSSVC_NETRLOGONDOMAINNAMEADD},
1798         {"WKSSVC_NETRLOGONDOMAINNAMEDEL", DCERPC_WKSSVC_NETRLOGONDOMAINNAMEDEL, api_WKSSVC_NETRLOGONDOMAINNAMEDEL},
1799         {"WKSSVC_NETRJOINDOMAIN", DCERPC_WKSSVC_NETRJOINDOMAIN, api_WKSSVC_NETRJOINDOMAIN},
1800         {"WKSSVC_NETRUNJOINDOMAIN", DCERPC_WKSSVC_NETRUNJOINDOMAIN, api_WKSSVC_NETRUNJOINDOMAIN},
1801         {"WKSSVC_NETRRENAMEMACHINEINDOMAIN", DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN, api_WKSSVC_NETRRENAMEMACHINEINDOMAIN},
1802         {"WKSSVC_NETRVALIDATENAME", DCERPC_WKSSVC_NETRVALIDATENAME, api_WKSSVC_NETRVALIDATENAME},
1803         {"WKSSVC_NETRGETJOININFORMATION", DCERPC_WKSSVC_NETRGETJOININFORMATION, api_WKSSVC_NETRGETJOININFORMATION},
1804         {"WKSSVC_NETRGETJOINABLEOUS", DCERPC_WKSSVC_NETRGETJOINABLEOUS, api_WKSSVC_NETRGETJOINABLEOUS},
1805         {"WKSSVC_NETRJOINDOMAIN2", DCERPC_WKSSVC_NETRJOINDOMAIN2, api_wkssvc_NetrJoinDomain2},
1806         {"WKSSVC_NETRUNJOINDOMAIN2", DCERPC_WKSSVC_NETRUNJOINDOMAIN2, api_wkssvc_NetrUnjoinDomain2},
1807         {"WKSSVC_NETRRENAMEMACHINEINDOMAIN2", DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, api_wkssvc_NetrRenameMachineInDomain2},
1808         {"WKSSVC_NETRVALIDATENAME2", DCERPC_WKSSVC_NETRVALIDATENAME2, api_WKSSVC_NETRVALIDATENAME2},
1809         {"WKSSVC_NETRGETJOINABLEOUS2", DCERPC_WKSSVC_NETRGETJOINABLEOUS2, api_WKSSVC_NETRGETJOINABLEOUS2},
1810         {"WKSSVC_NETRADDALTERNATECOMPUTERNAME", DCERPC_WKSSVC_NETRADDALTERNATECOMPUTERNAME, api_wkssvc_NetrAddAlternateComputerName},
1811         {"WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME", DCERPC_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, api_wkssvc_NetrRemoveAlternateComputerName},
1812         {"WKSSVC_NETRSETPRIMARYCOMPUTERNAME", DCERPC_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME},
1813         {"WKSSVC_NETRENUMERATECOMPUTERNAMES", DCERPC_WKSSVC_NETRENUMERATECOMPUTERNAMES, api_WKSSVC_NETRENUMERATECOMPUTERNAMES},
1814 };
1815
1816 void wkssvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
1817 {
1818         *fns = api_wkssvc_cmds;
1819         *n_fns = sizeof(api_wkssvc_cmds) / sizeof(struct api_struct);
1820 }
1821
1822 NTSTATUS rpc_wkssvc_init(void)
1823 {
1824         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "wkssvc", "wkssvc", api_wkssvc_cmds, sizeof(api_wkssvc_cmds) / sizeof(struct api_struct));
1825 }