1/* 2 * Unix SMB/CIFS implementation. 3 * client auto-generated by pidl. DO NOT MODIFY! 4 */ 5 6#include "includes.h" 7#include "../librpc/gen_ndr/cli_wkssvc.h" 8 9struct rpccli_wkssvc_NetWkstaGetInfo_state { 10 struct wkssvc_NetWkstaGetInfo orig; 11 struct wkssvc_NetWkstaGetInfo tmp; 12 TALLOC_CTX *out_mem_ctx; 13 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 14}; 15 16static void rpccli_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq); 17 18struct tevent_req *rpccli_wkssvc_NetWkstaGetInfo_send(TALLOC_CTX *mem_ctx, 19 struct tevent_context *ev, 20 struct rpc_pipe_client *cli, 21 const char *_server_name /* [in] [unique,charset(UTF16)] */, 22 uint32_t _level /* [in] */, 23 union wkssvc_NetWkstaInfo *_info /* [out] [ref,switch_is(level)] */) 24{ 25 struct tevent_req *req; 26 struct rpccli_wkssvc_NetWkstaGetInfo_state *state; 27 struct tevent_req *subreq; 28 29 req = tevent_req_create(mem_ctx, &state, 30 struct rpccli_wkssvc_NetWkstaGetInfo_state); 31 if (req == NULL) { 32 return NULL; 33 } 34 state->out_mem_ctx = NULL; 35 state->dispatch_recv = cli->dispatch_recv; 36 37 /* In parameters */ 38 state->orig.in.server_name = _server_name; 39 state->orig.in.level = _level; 40 41 /* Out parameters */ 42 state->orig.out.info = _info; 43 44 /* Result */ 45 ZERO_STRUCT(state->orig.out.result); 46 47 state->out_mem_ctx = talloc_named_const(state, 0, 48 "rpccli_wkssvc_NetWkstaGetInfo_out_memory"); 49 if (tevent_req_nomem(state->out_mem_ctx, req)) { 50 return tevent_req_post(req, ev); 51 } 52 53 /* make a temporary copy, that we pass to the dispatch function */ 54 state->tmp = state->orig; 55 56 subreq = cli->dispatch_send(state, ev, cli, 57 &ndr_table_wkssvc, 58 NDR_WKSSVC_NETWKSTAGETINFO, 59 &state->tmp); 60 if (tevent_req_nomem(subreq, req)) { 61 return tevent_req_post(req, ev); 62 } 63 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaGetInfo_done, req); 64 return req; 65} 66 67static void rpccli_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq) 68{ 69 struct tevent_req *req = tevent_req_callback_data( 70 subreq, struct tevent_req); 71 struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data( 72 req, struct rpccli_wkssvc_NetWkstaGetInfo_state); 73 NTSTATUS status; 74 TALLOC_CTX *mem_ctx; 75 76 if (state->out_mem_ctx) { 77 mem_ctx = state->out_mem_ctx; 78 } else { 79 mem_ctx = state; 80 } 81 82 status = state->dispatch_recv(subreq, mem_ctx); 83 TALLOC_FREE(subreq); 84 if (!NT_STATUS_IS_OK(status)) { 85 tevent_req_nterror(req, status); 86 return; 87 } 88 89 /* Copy out parameters */ 90 *state->orig.out.info = *state->tmp.out.info; 91 92 /* Copy result */ 93 state->orig.out.result = state->tmp.out.result; 94 95 /* Reset temporary structure */ 96 ZERO_STRUCT(state->tmp); 97 98 tevent_req_done(req); 99} 100 101NTSTATUS rpccli_wkssvc_NetWkstaGetInfo_recv(struct tevent_req *req, 102 TALLOC_CTX *mem_ctx, 103 WERROR *result) 104{ 105 struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data( 106 req, struct rpccli_wkssvc_NetWkstaGetInfo_state); 107 NTSTATUS status; 108 109 if (tevent_req_is_nterror(req, &status)) { 110 tevent_req_received(req); 111 return status; 112 } 113 114 /* Steal possbile out parameters to the callers context */ 115 talloc_steal(mem_ctx, state->out_mem_ctx); 116 117 /* Return result */ 118 *result = state->orig.out.result; 119 120 tevent_req_received(req); 121 return NT_STATUS_OK; 122} 123 124NTSTATUS rpccli_wkssvc_NetWkstaGetInfo(struct rpc_pipe_client *cli, 125 TALLOC_CTX *mem_ctx, 126 const char *server_name /* [in] [unique,charset(UTF16)] */, 127 uint32_t level /* [in] */, 128 union wkssvc_NetWkstaInfo *info /* [out] [ref,switch_is(level)] */, 129 WERROR *werror) 130{ 131 struct wkssvc_NetWkstaGetInfo r; 132 NTSTATUS status; 133 134 /* In parameters */ 135 r.in.server_name = server_name; 136 r.in.level = level; 137 138 status = cli->dispatch(cli, 139 mem_ctx, 140 &ndr_table_wkssvc, 141 NDR_WKSSVC_NETWKSTAGETINFO, 142 &r); 143 144 if (!NT_STATUS_IS_OK(status)) { 145 return status; 146 } 147 148 if (NT_STATUS_IS_ERR(status)) { 149 return status; 150 } 151 152 /* Return variables */ 153 *info = *r.out.info; 154 155 /* Return result */ 156 if (werror) { 157 *werror = r.out.result; 158 } 159 160 return werror_to_ntstatus(r.out.result); 161} 162 163struct rpccli_wkssvc_NetWkstaSetInfo_state { 164 struct wkssvc_NetWkstaSetInfo orig; 165 struct wkssvc_NetWkstaSetInfo tmp; 166 TALLOC_CTX *out_mem_ctx; 167 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 168}; 169 170static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq); 171 172struct tevent_req *rpccli_wkssvc_NetWkstaSetInfo_send(TALLOC_CTX *mem_ctx, 173 struct tevent_context *ev, 174 struct rpc_pipe_client *cli, 175 const char *_server_name /* [in] [unique,charset(UTF16)] */, 176 uint32_t _level /* [in] */, 177 union wkssvc_NetWkstaInfo *_info /* [in] [ref,switch_is(level)] */, 178 uint32_t *_parm_error /* [in,out] [ref] */) 179{ 180 struct tevent_req *req; 181 struct rpccli_wkssvc_NetWkstaSetInfo_state *state; 182 struct tevent_req *subreq; 183 184 req = tevent_req_create(mem_ctx, &state, 185 struct rpccli_wkssvc_NetWkstaSetInfo_state); 186 if (req == NULL) { 187 return NULL; 188 } 189 state->out_mem_ctx = NULL; 190 state->dispatch_recv = cli->dispatch_recv; 191 192 /* In parameters */ 193 state->orig.in.server_name = _server_name; 194 state->orig.in.level = _level; 195 state->orig.in.info = _info; 196 state->orig.in.parm_error = _parm_error; 197 198 /* Out parameters */ 199 state->orig.out.parm_error = _parm_error; 200 201 /* Result */ 202 ZERO_STRUCT(state->orig.out.result); 203 204 state->out_mem_ctx = talloc_named_const(state, 0, 205 "rpccli_wkssvc_NetWkstaSetInfo_out_memory"); 206 if (tevent_req_nomem(state->out_mem_ctx, req)) { 207 return tevent_req_post(req, ev); 208 } 209 210 /* make a temporary copy, that we pass to the dispatch function */ 211 state->tmp = state->orig; 212 213 subreq = cli->dispatch_send(state, ev, cli, 214 &ndr_table_wkssvc, 215 NDR_WKSSVC_NETWKSTASETINFO, 216 &state->tmp); 217 if (tevent_req_nomem(subreq, req)) { 218 return tevent_req_post(req, ev); 219 } 220 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaSetInfo_done, req); 221 return req; 222} 223 224static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq) 225{ 226 struct tevent_req *req = tevent_req_callback_data( 227 subreq, struct tevent_req); 228 struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data( 229 req, struct rpccli_wkssvc_NetWkstaSetInfo_state); 230 NTSTATUS status; 231 TALLOC_CTX *mem_ctx; 232 233 if (state->out_mem_ctx) { 234 mem_ctx = state->out_mem_ctx; 235 } else { 236 mem_ctx = state; 237 } 238 239 status = state->dispatch_recv(subreq, mem_ctx); 240 TALLOC_FREE(subreq); 241 if (!NT_STATUS_IS_OK(status)) { 242 tevent_req_nterror(req, status); 243 return; 244 } 245 246 /* Copy out parameters */ 247 *state->orig.out.parm_error = *state->tmp.out.parm_error; 248 249 /* Copy result */ 250 state->orig.out.result = state->tmp.out.result; 251 252 /* Reset temporary structure */ 253 ZERO_STRUCT(state->tmp); 254 255 tevent_req_done(req); 256} 257 258NTSTATUS rpccli_wkssvc_NetWkstaSetInfo_recv(struct tevent_req *req, 259 TALLOC_CTX *mem_ctx, 260 WERROR *result) 261{ 262 struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data( 263 req, struct rpccli_wkssvc_NetWkstaSetInfo_state); 264 NTSTATUS status; 265 266 if (tevent_req_is_nterror(req, &status)) { 267 tevent_req_received(req); 268 return status; 269 } 270 271 /* Steal possbile out parameters to the callers context */ 272 talloc_steal(mem_ctx, state->out_mem_ctx); 273 274 /* Return result */ 275 *result = state->orig.out.result; 276 277 tevent_req_received(req); 278 return NT_STATUS_OK; 279} 280 281NTSTATUS rpccli_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli, 282 TALLOC_CTX *mem_ctx, 283 const char *server_name /* [in] [unique,charset(UTF16)] */, 284 uint32_t level /* [in] */, 285 union wkssvc_NetWkstaInfo *info /* [in] [ref,switch_is(level)] */, 286 uint32_t *parm_error /* [in,out] [ref] */, 287 WERROR *werror) 288{ 289 struct wkssvc_NetWkstaSetInfo r; 290 NTSTATUS status; 291 292 /* In parameters */ 293 r.in.server_name = server_name; 294 r.in.level = level; 295 r.in.info = info; 296 r.in.parm_error = parm_error; 297 298 status = cli->dispatch(cli, 299 mem_ctx, 300 &ndr_table_wkssvc, 301 NDR_WKSSVC_NETWKSTASETINFO, 302 &r); 303 304 if (!NT_STATUS_IS_OK(status)) { 305 return status; 306 } 307 308 if (NT_STATUS_IS_ERR(status)) { 309 return status; 310 } 311 312 /* Return variables */ 313 *parm_error = *r.out.parm_error; 314 315 /* Return result */ 316 if (werror) { 317 *werror = r.out.result; 318 } 319 320 return werror_to_ntstatus(r.out.result); 321} 322 323struct rpccli_wkssvc_NetWkstaEnumUsers_state { 324 struct wkssvc_NetWkstaEnumUsers orig; 325 struct wkssvc_NetWkstaEnumUsers tmp; 326 TALLOC_CTX *out_mem_ctx; 327 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 328}; 329 330static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq); 331 332struct tevent_req *rpccli_wkssvc_NetWkstaEnumUsers_send(TALLOC_CTX *mem_ctx, 333 struct tevent_context *ev, 334 struct rpc_pipe_client *cli, 335 const char *_server_name /* [in] [unique,charset(UTF16)] */, 336 struct wkssvc_NetWkstaEnumUsersInfo *_info /* [in,out] [ref] */, 337 uint32_t _prefmaxlen /* [in] */, 338 uint32_t *_entries_read /* [out] [ref] */, 339 uint32_t *_resume_handle /* [in,out] [unique] */) 340{ 341 struct tevent_req *req; 342 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state; 343 struct tevent_req *subreq; 344 345 req = tevent_req_create(mem_ctx, &state, 346 struct rpccli_wkssvc_NetWkstaEnumUsers_state); 347 if (req == NULL) { 348 return NULL; 349 } 350 state->out_mem_ctx = NULL; 351 state->dispatch_recv = cli->dispatch_recv; 352 353 /* In parameters */ 354 state->orig.in.server_name = _server_name; 355 state->orig.in.info = _info; 356 state->orig.in.prefmaxlen = _prefmaxlen; 357 state->orig.in.resume_handle = _resume_handle; 358 359 /* Out parameters */ 360 state->orig.out.info = _info; 361 state->orig.out.entries_read = _entries_read; 362 state->orig.out.resume_handle = _resume_handle; 363 364 /* Result */ 365 ZERO_STRUCT(state->orig.out.result); 366 367 state->out_mem_ctx = talloc_named_const(state, 0, 368 "rpccli_wkssvc_NetWkstaEnumUsers_out_memory"); 369 if (tevent_req_nomem(state->out_mem_ctx, req)) { 370 return tevent_req_post(req, ev); 371 } 372 373 /* make a temporary copy, that we pass to the dispatch function */ 374 state->tmp = state->orig; 375 376 subreq = cli->dispatch_send(state, ev, cli, 377 &ndr_table_wkssvc, 378 NDR_WKSSVC_NETWKSTAENUMUSERS, 379 &state->tmp); 380 if (tevent_req_nomem(subreq, req)) { 381 return tevent_req_post(req, ev); 382 } 383 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaEnumUsers_done, req); 384 return req; 385} 386 387static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq) 388{ 389 struct tevent_req *req = tevent_req_callback_data( 390 subreq, struct tevent_req); 391 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data( 392 req, struct rpccli_wkssvc_NetWkstaEnumUsers_state); 393 NTSTATUS status; 394 TALLOC_CTX *mem_ctx; 395 396 if (state->out_mem_ctx) { 397 mem_ctx = state->out_mem_ctx; 398 } else { 399 mem_ctx = state; 400 } 401 402 status = state->dispatch_recv(subreq, mem_ctx); 403 TALLOC_FREE(subreq); 404 if (!NT_STATUS_IS_OK(status)) { 405 tevent_req_nterror(req, status); 406 return; 407 } 408 409 /* Copy out parameters */ 410 *state->orig.out.info = *state->tmp.out.info; 411 *state->orig.out.entries_read = *state->tmp.out.entries_read; 412 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { 413 *state->orig.out.resume_handle = *state->tmp.out.resume_handle; 414 } 415 416 /* Copy result */ 417 state->orig.out.result = state->tmp.out.result; 418 419 /* Reset temporary structure */ 420 ZERO_STRUCT(state->tmp); 421 422 tevent_req_done(req); 423} 424 425NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers_recv(struct tevent_req *req, 426 TALLOC_CTX *mem_ctx, 427 WERROR *result) 428{ 429 struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data( 430 req, struct rpccli_wkssvc_NetWkstaEnumUsers_state); 431 NTSTATUS status; 432 433 if (tevent_req_is_nterror(req, &status)) { 434 tevent_req_received(req); 435 return status; 436 } 437 438 /* Steal possbile out parameters to the callers context */ 439 talloc_steal(mem_ctx, state->out_mem_ctx); 440 441 /* Return result */ 442 *result = state->orig.out.result; 443 444 tevent_req_received(req); 445 return NT_STATUS_OK; 446} 447 448NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers(struct rpc_pipe_client *cli, 449 TALLOC_CTX *mem_ctx, 450 const char *server_name /* [in] [unique,charset(UTF16)] */, 451 struct wkssvc_NetWkstaEnumUsersInfo *info /* [in,out] [ref] */, 452 uint32_t prefmaxlen /* [in] */, 453 uint32_t *entries_read /* [out] [ref] */, 454 uint32_t *resume_handle /* [in,out] [unique] */, 455 WERROR *werror) 456{ 457 struct wkssvc_NetWkstaEnumUsers r; 458 NTSTATUS status; 459 460 /* In parameters */ 461 r.in.server_name = server_name; 462 r.in.info = info; 463 r.in.prefmaxlen = prefmaxlen; 464 r.in.resume_handle = resume_handle; 465 466 status = cli->dispatch(cli, 467 mem_ctx, 468 &ndr_table_wkssvc, 469 NDR_WKSSVC_NETWKSTAENUMUSERS, 470 &r); 471 472 if (!NT_STATUS_IS_OK(status)) { 473 return status; 474 } 475 476 if (NT_STATUS_IS_ERR(status)) { 477 return status; 478 } 479 480 /* Return variables */ 481 *info = *r.out.info; 482 *entries_read = *r.out.entries_read; 483 if (resume_handle && r.out.resume_handle) { 484 *resume_handle = *r.out.resume_handle; 485 } 486 487 /* Return result */ 488 if (werror) { 489 *werror = r.out.result; 490 } 491 492 return werror_to_ntstatus(r.out.result); 493} 494 495struct rpccli_wkssvc_NetrWkstaUserGetInfo_state { 496 struct wkssvc_NetrWkstaUserGetInfo orig; 497 struct wkssvc_NetrWkstaUserGetInfo tmp; 498 TALLOC_CTX *out_mem_ctx; 499 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 500}; 501 502static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq); 503 504struct tevent_req *rpccli_wkssvc_NetrWkstaUserGetInfo_send(TALLOC_CTX *mem_ctx, 505 struct tevent_context *ev, 506 struct rpc_pipe_client *cli, 507 const char *_unknown /* [in] [unique,charset(UTF16)] */, 508 uint32_t _level /* [in] */, 509 union wkssvc_NetrWkstaUserInfo *_info /* [out] [ref,switch_is(level)] */) 510{ 511 struct tevent_req *req; 512 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state; 513 struct tevent_req *subreq; 514 515 req = tevent_req_create(mem_ctx, &state, 516 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); 517 if (req == NULL) { 518 return NULL; 519 } 520 state->out_mem_ctx = NULL; 521 state->dispatch_recv = cli->dispatch_recv; 522 523 /* In parameters */ 524 state->orig.in.unknown = _unknown; 525 state->orig.in.level = _level; 526 527 /* Out parameters */ 528 state->orig.out.info = _info; 529 530 /* Result */ 531 ZERO_STRUCT(state->orig.out.result); 532 533 state->out_mem_ctx = talloc_named_const(state, 0, 534 "rpccli_wkssvc_NetrWkstaUserGetInfo_out_memory"); 535 if (tevent_req_nomem(state->out_mem_ctx, req)) { 536 return tevent_req_post(req, ev); 537 } 538 539 /* make a temporary copy, that we pass to the dispatch function */ 540 state->tmp = state->orig; 541 542 subreq = cli->dispatch_send(state, ev, cli, 543 &ndr_table_wkssvc, 544 NDR_WKSSVC_NETRWKSTAUSERGETINFO, 545 &state->tmp); 546 if (tevent_req_nomem(subreq, req)) { 547 return tevent_req_post(req, ev); 548 } 549 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserGetInfo_done, req); 550 return req; 551} 552 553static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq) 554{ 555 struct tevent_req *req = tevent_req_callback_data( 556 subreq, struct tevent_req); 557 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data( 558 req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); 559 NTSTATUS status; 560 TALLOC_CTX *mem_ctx; 561 562 if (state->out_mem_ctx) { 563 mem_ctx = state->out_mem_ctx; 564 } else { 565 mem_ctx = state; 566 } 567 568 status = state->dispatch_recv(subreq, mem_ctx); 569 TALLOC_FREE(subreq); 570 if (!NT_STATUS_IS_OK(status)) { 571 tevent_req_nterror(req, status); 572 return; 573 } 574 575 /* Copy out parameters */ 576 *state->orig.out.info = *state->tmp.out.info; 577 578 /* Copy result */ 579 state->orig.out.result = state->tmp.out.result; 580 581 /* Reset temporary structure */ 582 ZERO_STRUCT(state->tmp); 583 584 tevent_req_done(req); 585} 586 587NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo_recv(struct tevent_req *req, 588 TALLOC_CTX *mem_ctx, 589 WERROR *result) 590{ 591 struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data( 592 req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); 593 NTSTATUS status; 594 595 if (tevent_req_is_nterror(req, &status)) { 596 tevent_req_received(req); 597 return status; 598 } 599 600 /* Steal possbile out parameters to the callers context */ 601 talloc_steal(mem_ctx, state->out_mem_ctx); 602 603 /* Return result */ 604 *result = state->orig.out.result; 605 606 tevent_req_received(req); 607 return NT_STATUS_OK; 608} 609 610NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo(struct rpc_pipe_client *cli, 611 TALLOC_CTX *mem_ctx, 612 const char *unknown /* [in] [unique,charset(UTF16)] */, 613 uint32_t level /* [in] */, 614 union wkssvc_NetrWkstaUserInfo *info /* [out] [ref,switch_is(level)] */, 615 WERROR *werror) 616{ 617 struct wkssvc_NetrWkstaUserGetInfo r; 618 NTSTATUS status; 619 620 /* In parameters */ 621 r.in.unknown = unknown; 622 r.in.level = level; 623 624 status = cli->dispatch(cli, 625 mem_ctx, 626 &ndr_table_wkssvc, 627 NDR_WKSSVC_NETRWKSTAUSERGETINFO, 628 &r); 629 630 if (!NT_STATUS_IS_OK(status)) { 631 return status; 632 } 633 634 if (NT_STATUS_IS_ERR(status)) { 635 return status; 636 } 637 638 /* Return variables */ 639 *info = *r.out.info; 640 641 /* Return result */ 642 if (werror) { 643 *werror = r.out.result; 644 } 645 646 return werror_to_ntstatus(r.out.result); 647} 648 649struct rpccli_wkssvc_NetrWkstaUserSetInfo_state { 650 struct wkssvc_NetrWkstaUserSetInfo orig; 651 struct wkssvc_NetrWkstaUserSetInfo tmp; 652 TALLOC_CTX *out_mem_ctx; 653 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 654}; 655 656static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq); 657 658struct tevent_req *rpccli_wkssvc_NetrWkstaUserSetInfo_send(TALLOC_CTX *mem_ctx, 659 struct tevent_context *ev, 660 struct rpc_pipe_client *cli, 661 const char *_unknown /* [in] [unique,charset(UTF16)] */, 662 uint32_t _level /* [in] */, 663 union wkssvc_NetrWkstaUserInfo *_info /* [in] [ref,switch_is(level)] */, 664 uint32_t *_parm_err /* [in,out] [unique] */) 665{ 666 struct tevent_req *req; 667 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state; 668 struct tevent_req *subreq; 669 670 req = tevent_req_create(mem_ctx, &state, 671 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); 672 if (req == NULL) { 673 return NULL; 674 } 675 state->out_mem_ctx = NULL; 676 state->dispatch_recv = cli->dispatch_recv; 677 678 /* In parameters */ 679 state->orig.in.unknown = _unknown; 680 state->orig.in.level = _level; 681 state->orig.in.info = _info; 682 state->orig.in.parm_err = _parm_err; 683 684 /* Out parameters */ 685 state->orig.out.parm_err = _parm_err; 686 687 /* Result */ 688 ZERO_STRUCT(state->orig.out.result); 689 690 state->out_mem_ctx = talloc_named_const(state, 0, 691 "rpccli_wkssvc_NetrWkstaUserSetInfo_out_memory"); 692 if (tevent_req_nomem(state->out_mem_ctx, req)) { 693 return tevent_req_post(req, ev); 694 } 695 696 /* make a temporary copy, that we pass to the dispatch function */ 697 state->tmp = state->orig; 698 699 subreq = cli->dispatch_send(state, ev, cli, 700 &ndr_table_wkssvc, 701 NDR_WKSSVC_NETRWKSTAUSERSETINFO, 702 &state->tmp); 703 if (tevent_req_nomem(subreq, req)) { 704 return tevent_req_post(req, ev); 705 } 706 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserSetInfo_done, req); 707 return req; 708} 709 710static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq) 711{ 712 struct tevent_req *req = tevent_req_callback_data( 713 subreq, struct tevent_req); 714 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data( 715 req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); 716 NTSTATUS status; 717 TALLOC_CTX *mem_ctx; 718 719 if (state->out_mem_ctx) { 720 mem_ctx = state->out_mem_ctx; 721 } else { 722 mem_ctx = state; 723 } 724 725 status = state->dispatch_recv(subreq, mem_ctx); 726 TALLOC_FREE(subreq); 727 if (!NT_STATUS_IS_OK(status)) { 728 tevent_req_nterror(req, status); 729 return; 730 } 731 732 /* Copy out parameters */ 733 if (state->orig.out.parm_err && state->tmp.out.parm_err) { 734 *state->orig.out.parm_err = *state->tmp.out.parm_err; 735 } 736 737 /* Copy result */ 738 state->orig.out.result = state->tmp.out.result; 739 740 /* Reset temporary structure */ 741 ZERO_STRUCT(state->tmp); 742 743 tevent_req_done(req); 744} 745 746NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo_recv(struct tevent_req *req, 747 TALLOC_CTX *mem_ctx, 748 WERROR *result) 749{ 750 struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data( 751 req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); 752 NTSTATUS status; 753 754 if (tevent_req_is_nterror(req, &status)) { 755 tevent_req_received(req); 756 return status; 757 } 758 759 /* Steal possbile out parameters to the callers context */ 760 talloc_steal(mem_ctx, state->out_mem_ctx); 761 762 /* Return result */ 763 *result = state->orig.out.result; 764 765 tevent_req_received(req); 766 return NT_STATUS_OK; 767} 768 769NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo(struct rpc_pipe_client *cli, 770 TALLOC_CTX *mem_ctx, 771 const char *unknown /* [in] [unique,charset(UTF16)] */, 772 uint32_t level /* [in] */, 773 union wkssvc_NetrWkstaUserInfo *info /* [in] [ref,switch_is(level)] */, 774 uint32_t *parm_err /* [in,out] [unique] */, 775 WERROR *werror) 776{ 777 struct wkssvc_NetrWkstaUserSetInfo r; 778 NTSTATUS status; 779 780 /* In parameters */ 781 r.in.unknown = unknown; 782 r.in.level = level; 783 r.in.info = info; 784 r.in.parm_err = parm_err; 785 786 status = cli->dispatch(cli, 787 mem_ctx, 788 &ndr_table_wkssvc, 789 NDR_WKSSVC_NETRWKSTAUSERSETINFO, 790 &r); 791 792 if (!NT_STATUS_IS_OK(status)) { 793 return status; 794 } 795 796 if (NT_STATUS_IS_ERR(status)) { 797 return status; 798 } 799 800 /* Return variables */ 801 if (parm_err && r.out.parm_err) { 802 *parm_err = *r.out.parm_err; 803 } 804 805 /* Return result */ 806 if (werror) { 807 *werror = r.out.result; 808 } 809 810 return werror_to_ntstatus(r.out.result); 811} 812 813struct rpccli_wkssvc_NetWkstaTransportEnum_state { 814 struct wkssvc_NetWkstaTransportEnum orig; 815 struct wkssvc_NetWkstaTransportEnum tmp; 816 TALLOC_CTX *out_mem_ctx; 817 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 818}; 819 820static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq); 821 822struct tevent_req *rpccli_wkssvc_NetWkstaTransportEnum_send(TALLOC_CTX *mem_ctx, 823 struct tevent_context *ev, 824 struct rpc_pipe_client *cli, 825 const char *_server_name /* [in] [unique,charset(UTF16)] */, 826 struct wkssvc_NetWkstaTransportInfo *_info /* [in,out] [ref] */, 827 uint32_t _max_buffer /* [in] */, 828 uint32_t *_total_entries /* [out] [ref] */, 829 uint32_t *_resume_handle /* [in,out] [unique] */) 830{ 831 struct tevent_req *req; 832 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state; 833 struct tevent_req *subreq; 834 835 req = tevent_req_create(mem_ctx, &state, 836 struct rpccli_wkssvc_NetWkstaTransportEnum_state); 837 if (req == NULL) { 838 return NULL; 839 } 840 state->out_mem_ctx = NULL; 841 state->dispatch_recv = cli->dispatch_recv; 842 843 /* In parameters */ 844 state->orig.in.server_name = _server_name; 845 state->orig.in.info = _info; 846 state->orig.in.max_buffer = _max_buffer; 847 state->orig.in.resume_handle = _resume_handle; 848 849 /* Out parameters */ 850 state->orig.out.info = _info; 851 state->orig.out.total_entries = _total_entries; 852 state->orig.out.resume_handle = _resume_handle; 853 854 /* Result */ 855 ZERO_STRUCT(state->orig.out.result); 856 857 state->out_mem_ctx = talloc_named_const(state, 0, 858 "rpccli_wkssvc_NetWkstaTransportEnum_out_memory"); 859 if (tevent_req_nomem(state->out_mem_ctx, req)) { 860 return tevent_req_post(req, ev); 861 } 862 863 /* make a temporary copy, that we pass to the dispatch function */ 864 state->tmp = state->orig; 865 866 subreq = cli->dispatch_send(state, ev, cli, 867 &ndr_table_wkssvc, 868 NDR_WKSSVC_NETWKSTATRANSPORTENUM, 869 &state->tmp); 870 if (tevent_req_nomem(subreq, req)) { 871 return tevent_req_post(req, ev); 872 } 873 tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaTransportEnum_done, req); 874 return req; 875} 876 877static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq) 878{ 879 struct tevent_req *req = tevent_req_callback_data( 880 subreq, struct tevent_req); 881 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data( 882 req, struct rpccli_wkssvc_NetWkstaTransportEnum_state); 883 NTSTATUS status; 884 TALLOC_CTX *mem_ctx; 885 886 if (state->out_mem_ctx) { 887 mem_ctx = state->out_mem_ctx; 888 } else { 889 mem_ctx = state; 890 } 891 892 status = state->dispatch_recv(subreq, mem_ctx); 893 TALLOC_FREE(subreq); 894 if (!NT_STATUS_IS_OK(status)) { 895 tevent_req_nterror(req, status); 896 return; 897 } 898 899 /* Copy out parameters */ 900 *state->orig.out.info = *state->tmp.out.info; 901 *state->orig.out.total_entries = *state->tmp.out.total_entries; 902 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { 903 *state->orig.out.resume_handle = *state->tmp.out.resume_handle; 904 } 905 906 /* Copy result */ 907 state->orig.out.result = state->tmp.out.result; 908 909 /* Reset temporary structure */ 910 ZERO_STRUCT(state->tmp); 911 912 tevent_req_done(req); 913} 914 915NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum_recv(struct tevent_req *req, 916 TALLOC_CTX *mem_ctx, 917 WERROR *result) 918{ 919 struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data( 920 req, struct rpccli_wkssvc_NetWkstaTransportEnum_state); 921 NTSTATUS status; 922 923 if (tevent_req_is_nterror(req, &status)) { 924 tevent_req_received(req); 925 return status; 926 } 927 928 /* Steal possbile out parameters to the callers context */ 929 talloc_steal(mem_ctx, state->out_mem_ctx); 930 931 /* Return result */ 932 *result = state->orig.out.result; 933 934 tevent_req_received(req); 935 return NT_STATUS_OK; 936} 937 938NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli, 939 TALLOC_CTX *mem_ctx, 940 const char *server_name /* [in] [unique,charset(UTF16)] */, 941 struct wkssvc_NetWkstaTransportInfo *info /* [in,out] [ref] */, 942 uint32_t max_buffer /* [in] */, 943 uint32_t *total_entries /* [out] [ref] */, 944 uint32_t *resume_handle /* [in,out] [unique] */, 945 WERROR *werror) 946{ 947 struct wkssvc_NetWkstaTransportEnum r; 948 NTSTATUS status; 949 950 /* In parameters */ 951 r.in.server_name = server_name; 952 r.in.info = info; 953 r.in.max_buffer = max_buffer; 954 r.in.resume_handle = resume_handle; 955 956 status = cli->dispatch(cli, 957 mem_ctx, 958 &ndr_table_wkssvc, 959 NDR_WKSSVC_NETWKSTATRANSPORTENUM, 960 &r); 961 962 if (!NT_STATUS_IS_OK(status)) { 963 return status; 964 } 965 966 if (NT_STATUS_IS_ERR(status)) { 967 return status; 968 } 969 970 /* Return variables */ 971 *info = *r.out.info; 972 *total_entries = *r.out.total_entries; 973 if (resume_handle && r.out.resume_handle) { 974 *resume_handle = *r.out.resume_handle; 975 } 976 977 /* Return result */ 978 if (werror) { 979 *werror = r.out.result; 980 } 981 982 return werror_to_ntstatus(r.out.result); 983} 984 985struct rpccli_wkssvc_NetrWkstaTransportAdd_state { 986 struct wkssvc_NetrWkstaTransportAdd orig; 987 struct wkssvc_NetrWkstaTransportAdd tmp; 988 TALLOC_CTX *out_mem_ctx; 989 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 990}; 991 992static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq); 993 994struct tevent_req *rpccli_wkssvc_NetrWkstaTransportAdd_send(TALLOC_CTX *mem_ctx, 995 struct tevent_context *ev, 996 struct rpc_pipe_client *cli, 997 const char *_server_name /* [in] [unique,charset(UTF16)] */, 998 uint32_t _level /* [in] */, 999 struct wkssvc_NetWkstaTransportInfo0 *_info0 /* [in] [ref] */, 1000 uint32_t *_parm_err /* [in,out] [unique] */) 1001{ 1002 struct tevent_req *req; 1003 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state; 1004 struct tevent_req *subreq; 1005 1006 req = tevent_req_create(mem_ctx, &state, 1007 struct rpccli_wkssvc_NetrWkstaTransportAdd_state); 1008 if (req == NULL) { 1009 return NULL; 1010 } 1011 state->out_mem_ctx = NULL; 1012 state->dispatch_recv = cli->dispatch_recv; 1013 1014 /* In parameters */ 1015 state->orig.in.server_name = _server_name; 1016 state->orig.in.level = _level; 1017 state->orig.in.info0 = _info0; 1018 state->orig.in.parm_err = _parm_err; 1019 1020 /* Out parameters */ 1021 state->orig.out.parm_err = _parm_err; 1022 1023 /* Result */ 1024 ZERO_STRUCT(state->orig.out.result); 1025 1026 state->out_mem_ctx = talloc_named_const(state, 0, 1027 "rpccli_wkssvc_NetrWkstaTransportAdd_out_memory"); 1028 if (tevent_req_nomem(state->out_mem_ctx, req)) { 1029 return tevent_req_post(req, ev); 1030 } 1031 1032 /* make a temporary copy, that we pass to the dispatch function */ 1033 state->tmp = state->orig; 1034 1035 subreq = cli->dispatch_send(state, ev, cli, 1036 &ndr_table_wkssvc, 1037 NDR_WKSSVC_NETRWKSTATRANSPORTADD, 1038 &state->tmp); 1039 if (tevent_req_nomem(subreq, req)) { 1040 return tevent_req_post(req, ev); 1041 } 1042 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportAdd_done, req); 1043 return req; 1044} 1045 1046static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq) 1047{ 1048 struct tevent_req *req = tevent_req_callback_data( 1049 subreq, struct tevent_req); 1050 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data( 1051 req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state); 1052 NTSTATUS status; 1053 TALLOC_CTX *mem_ctx; 1054 1055 if (state->out_mem_ctx) { 1056 mem_ctx = state->out_mem_ctx; 1057 } else { 1058 mem_ctx = state; 1059 } 1060 1061 status = state->dispatch_recv(subreq, mem_ctx); 1062 TALLOC_FREE(subreq); 1063 if (!NT_STATUS_IS_OK(status)) { 1064 tevent_req_nterror(req, status); 1065 return; 1066 } 1067 1068 /* Copy out parameters */ 1069 if (state->orig.out.parm_err && state->tmp.out.parm_err) { 1070 *state->orig.out.parm_err = *state->tmp.out.parm_err; 1071 } 1072 1073 /* Copy result */ 1074 state->orig.out.result = state->tmp.out.result; 1075 1076 /* Reset temporary structure */ 1077 ZERO_STRUCT(state->tmp); 1078 1079 tevent_req_done(req); 1080} 1081 1082NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd_recv(struct tevent_req *req, 1083 TALLOC_CTX *mem_ctx, 1084 WERROR *result) 1085{ 1086 struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data( 1087 req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state); 1088 NTSTATUS status; 1089 1090 if (tevent_req_is_nterror(req, &status)) { 1091 tevent_req_received(req); 1092 return status; 1093 } 1094 1095 /* Steal possbile out parameters to the callers context */ 1096 talloc_steal(mem_ctx, state->out_mem_ctx); 1097 1098 /* Return result */ 1099 *result = state->orig.out.result; 1100 1101 tevent_req_received(req); 1102 return NT_STATUS_OK; 1103} 1104 1105NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd(struct rpc_pipe_client *cli, 1106 TALLOC_CTX *mem_ctx, 1107 const char *server_name /* [in] [unique,charset(UTF16)] */, 1108 uint32_t level /* [in] */, 1109 struct wkssvc_NetWkstaTransportInfo0 *info0 /* [in] [ref] */, 1110 uint32_t *parm_err /* [in,out] [unique] */, 1111 WERROR *werror) 1112{ 1113 struct wkssvc_NetrWkstaTransportAdd r; 1114 NTSTATUS status; 1115 1116 /* In parameters */ 1117 r.in.server_name = server_name; 1118 r.in.level = level; 1119 r.in.info0 = info0; 1120 r.in.parm_err = parm_err; 1121 1122 status = cli->dispatch(cli, 1123 mem_ctx, 1124 &ndr_table_wkssvc, 1125 NDR_WKSSVC_NETRWKSTATRANSPORTADD, 1126 &r); 1127 1128 if (!NT_STATUS_IS_OK(status)) { 1129 return status; 1130 } 1131 1132 if (NT_STATUS_IS_ERR(status)) { 1133 return status; 1134 } 1135 1136 /* Return variables */ 1137 if (parm_err && r.out.parm_err) { 1138 *parm_err = *r.out.parm_err; 1139 } 1140 1141 /* Return result */ 1142 if (werror) { 1143 *werror = r.out.result; 1144 } 1145 1146 return werror_to_ntstatus(r.out.result); 1147} 1148 1149struct rpccli_wkssvc_NetrWkstaTransportDel_state { 1150 struct wkssvc_NetrWkstaTransportDel orig; 1151 struct wkssvc_NetrWkstaTransportDel tmp; 1152 TALLOC_CTX *out_mem_ctx; 1153 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1154}; 1155 1156static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq); 1157 1158struct tevent_req *rpccli_wkssvc_NetrWkstaTransportDel_send(TALLOC_CTX *mem_ctx, 1159 struct tevent_context *ev, 1160 struct rpc_pipe_client *cli, 1161 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1162 const char *_transport_name /* [in] [unique,charset(UTF16)] */, 1163 uint32_t _unknown3 /* [in] */) 1164{ 1165 struct tevent_req *req; 1166 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state; 1167 struct tevent_req *subreq; 1168 1169 req = tevent_req_create(mem_ctx, &state, 1170 struct rpccli_wkssvc_NetrWkstaTransportDel_state); 1171 if (req == NULL) { 1172 return NULL; 1173 } 1174 state->out_mem_ctx = NULL; 1175 state->dispatch_recv = cli->dispatch_recv; 1176 1177 /* In parameters */ 1178 state->orig.in.server_name = _server_name; 1179 state->orig.in.transport_name = _transport_name; 1180 state->orig.in.unknown3 = _unknown3; 1181 1182 /* Out parameters */ 1183 1184 /* Result */ 1185 ZERO_STRUCT(state->orig.out.result); 1186 1187 /* make a temporary copy, that we pass to the dispatch function */ 1188 state->tmp = state->orig; 1189 1190 subreq = cli->dispatch_send(state, ev, cli, 1191 &ndr_table_wkssvc, 1192 NDR_WKSSVC_NETRWKSTATRANSPORTDEL, 1193 &state->tmp); 1194 if (tevent_req_nomem(subreq, req)) { 1195 return tevent_req_post(req, ev); 1196 } 1197 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportDel_done, req); 1198 return req; 1199} 1200 1201static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq) 1202{ 1203 struct tevent_req *req = tevent_req_callback_data( 1204 subreq, struct tevent_req); 1205 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data( 1206 req, struct rpccli_wkssvc_NetrWkstaTransportDel_state); 1207 NTSTATUS status; 1208 TALLOC_CTX *mem_ctx; 1209 1210 if (state->out_mem_ctx) { 1211 mem_ctx = state->out_mem_ctx; 1212 } else { 1213 mem_ctx = state; 1214 } 1215 1216 status = state->dispatch_recv(subreq, mem_ctx); 1217 TALLOC_FREE(subreq); 1218 if (!NT_STATUS_IS_OK(status)) { 1219 tevent_req_nterror(req, status); 1220 return; 1221 } 1222 1223 /* Copy out parameters */ 1224 1225 /* Copy result */ 1226 state->orig.out.result = state->tmp.out.result; 1227 1228 /* Reset temporary structure */ 1229 ZERO_STRUCT(state->tmp); 1230 1231 tevent_req_done(req); 1232} 1233 1234NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel_recv(struct tevent_req *req, 1235 TALLOC_CTX *mem_ctx, 1236 WERROR *result) 1237{ 1238 struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data( 1239 req, struct rpccli_wkssvc_NetrWkstaTransportDel_state); 1240 NTSTATUS status; 1241 1242 if (tevent_req_is_nterror(req, &status)) { 1243 tevent_req_received(req); 1244 return status; 1245 } 1246 1247 /* Steal possbile out parameters to the callers context */ 1248 talloc_steal(mem_ctx, state->out_mem_ctx); 1249 1250 /* Return result */ 1251 *result = state->orig.out.result; 1252 1253 tevent_req_received(req); 1254 return NT_STATUS_OK; 1255} 1256 1257NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel(struct rpc_pipe_client *cli, 1258 TALLOC_CTX *mem_ctx, 1259 const char *server_name /* [in] [unique,charset(UTF16)] */, 1260 const char *transport_name /* [in] [unique,charset(UTF16)] */, 1261 uint32_t unknown3 /* [in] */, 1262 WERROR *werror) 1263{ 1264 struct wkssvc_NetrWkstaTransportDel r; 1265 NTSTATUS status; 1266 1267 /* In parameters */ 1268 r.in.server_name = server_name; 1269 r.in.transport_name = transport_name; 1270 r.in.unknown3 = unknown3; 1271 1272 status = cli->dispatch(cli, 1273 mem_ctx, 1274 &ndr_table_wkssvc, 1275 NDR_WKSSVC_NETRWKSTATRANSPORTDEL, 1276 &r); 1277 1278 if (!NT_STATUS_IS_OK(status)) { 1279 return status; 1280 } 1281 1282 if (NT_STATUS_IS_ERR(status)) { 1283 return status; 1284 } 1285 1286 /* Return variables */ 1287 1288 /* Return result */ 1289 if (werror) { 1290 *werror = r.out.result; 1291 } 1292 1293 return werror_to_ntstatus(r.out.result); 1294} 1295 1296struct rpccli_wkssvc_NetrUseAdd_state { 1297 struct wkssvc_NetrUseAdd orig; 1298 struct wkssvc_NetrUseAdd tmp; 1299 TALLOC_CTX *out_mem_ctx; 1300 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1301}; 1302 1303static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq); 1304 1305struct tevent_req *rpccli_wkssvc_NetrUseAdd_send(TALLOC_CTX *mem_ctx, 1306 struct tevent_context *ev, 1307 struct rpc_pipe_client *cli, 1308 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1309 uint32_t _level /* [in] */, 1310 union wkssvc_NetrUseGetInfoCtr *_ctr /* [in] [ref,switch_is(level)] */, 1311 uint32_t *_parm_err /* [in,out] [unique] */) 1312{ 1313 struct tevent_req *req; 1314 struct rpccli_wkssvc_NetrUseAdd_state *state; 1315 struct tevent_req *subreq; 1316 1317 req = tevent_req_create(mem_ctx, &state, 1318 struct rpccli_wkssvc_NetrUseAdd_state); 1319 if (req == NULL) { 1320 return NULL; 1321 } 1322 state->out_mem_ctx = NULL; 1323 state->dispatch_recv = cli->dispatch_recv; 1324 1325 /* In parameters */ 1326 state->orig.in.server_name = _server_name; 1327 state->orig.in.level = _level; 1328 state->orig.in.ctr = _ctr; 1329 state->orig.in.parm_err = _parm_err; 1330 1331 /* Out parameters */ 1332 state->orig.out.parm_err = _parm_err; 1333 1334 /* Result */ 1335 ZERO_STRUCT(state->orig.out.result); 1336 1337 state->out_mem_ctx = talloc_named_const(state, 0, 1338 "rpccli_wkssvc_NetrUseAdd_out_memory"); 1339 if (tevent_req_nomem(state->out_mem_ctx, req)) { 1340 return tevent_req_post(req, ev); 1341 } 1342 1343 /* make a temporary copy, that we pass to the dispatch function */ 1344 state->tmp = state->orig; 1345 1346 subreq = cli->dispatch_send(state, ev, cli, 1347 &ndr_table_wkssvc, 1348 NDR_WKSSVC_NETRUSEADD, 1349 &state->tmp); 1350 if (tevent_req_nomem(subreq, req)) { 1351 return tevent_req_post(req, ev); 1352 } 1353 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseAdd_done, req); 1354 return req; 1355} 1356 1357static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq) 1358{ 1359 struct tevent_req *req = tevent_req_callback_data( 1360 subreq, struct tevent_req); 1361 struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data( 1362 req, struct rpccli_wkssvc_NetrUseAdd_state); 1363 NTSTATUS status; 1364 TALLOC_CTX *mem_ctx; 1365 1366 if (state->out_mem_ctx) { 1367 mem_ctx = state->out_mem_ctx; 1368 } else { 1369 mem_ctx = state; 1370 } 1371 1372 status = state->dispatch_recv(subreq, mem_ctx); 1373 TALLOC_FREE(subreq); 1374 if (!NT_STATUS_IS_OK(status)) { 1375 tevent_req_nterror(req, status); 1376 return; 1377 } 1378 1379 /* Copy out parameters */ 1380 if (state->orig.out.parm_err && state->tmp.out.parm_err) { 1381 *state->orig.out.parm_err = *state->tmp.out.parm_err; 1382 } 1383 1384 /* Copy result */ 1385 state->orig.out.result = state->tmp.out.result; 1386 1387 /* Reset temporary structure */ 1388 ZERO_STRUCT(state->tmp); 1389 1390 tevent_req_done(req); 1391} 1392 1393NTSTATUS rpccli_wkssvc_NetrUseAdd_recv(struct tevent_req *req, 1394 TALLOC_CTX *mem_ctx, 1395 WERROR *result) 1396{ 1397 struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data( 1398 req, struct rpccli_wkssvc_NetrUseAdd_state); 1399 NTSTATUS status; 1400 1401 if (tevent_req_is_nterror(req, &status)) { 1402 tevent_req_received(req); 1403 return status; 1404 } 1405 1406 /* Steal possbile out parameters to the callers context */ 1407 talloc_steal(mem_ctx, state->out_mem_ctx); 1408 1409 /* Return result */ 1410 *result = state->orig.out.result; 1411 1412 tevent_req_received(req); 1413 return NT_STATUS_OK; 1414} 1415 1416NTSTATUS rpccli_wkssvc_NetrUseAdd(struct rpc_pipe_client *cli, 1417 TALLOC_CTX *mem_ctx, 1418 const char *server_name /* [in] [unique,charset(UTF16)] */, 1419 uint32_t level /* [in] */, 1420 union wkssvc_NetrUseGetInfoCtr *ctr /* [in] [ref,switch_is(level)] */, 1421 uint32_t *parm_err /* [in,out] [unique] */, 1422 WERROR *werror) 1423{ 1424 struct wkssvc_NetrUseAdd r; 1425 NTSTATUS status; 1426 1427 /* In parameters */ 1428 r.in.server_name = server_name; 1429 r.in.level = level; 1430 r.in.ctr = ctr; 1431 r.in.parm_err = parm_err; 1432 1433 status = cli->dispatch(cli, 1434 mem_ctx, 1435 &ndr_table_wkssvc, 1436 NDR_WKSSVC_NETRUSEADD, 1437 &r); 1438 1439 if (!NT_STATUS_IS_OK(status)) { 1440 return status; 1441 } 1442 1443 if (NT_STATUS_IS_ERR(status)) { 1444 return status; 1445 } 1446 1447 /* Return variables */ 1448 if (parm_err && r.out.parm_err) { 1449 *parm_err = *r.out.parm_err; 1450 } 1451 1452 /* Return result */ 1453 if (werror) { 1454 *werror = r.out.result; 1455 } 1456 1457 return werror_to_ntstatus(r.out.result); 1458} 1459 1460struct rpccli_wkssvc_NetrUseGetInfo_state { 1461 struct wkssvc_NetrUseGetInfo orig; 1462 struct wkssvc_NetrUseGetInfo tmp; 1463 TALLOC_CTX *out_mem_ctx; 1464 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1465}; 1466 1467static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq); 1468 1469struct tevent_req *rpccli_wkssvc_NetrUseGetInfo_send(TALLOC_CTX *mem_ctx, 1470 struct tevent_context *ev, 1471 struct rpc_pipe_client *cli, 1472 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1473 const char *_use_name /* [in] [ref,charset(UTF16)] */, 1474 uint32_t _level /* [in] */, 1475 union wkssvc_NetrUseGetInfoCtr *_ctr /* [out] [ref,switch_is(level)] */) 1476{ 1477 struct tevent_req *req; 1478 struct rpccli_wkssvc_NetrUseGetInfo_state *state; 1479 struct tevent_req *subreq; 1480 1481 req = tevent_req_create(mem_ctx, &state, 1482 struct rpccli_wkssvc_NetrUseGetInfo_state); 1483 if (req == NULL) { 1484 return NULL; 1485 } 1486 state->out_mem_ctx = NULL; 1487 state->dispatch_recv = cli->dispatch_recv; 1488 1489 /* In parameters */ 1490 state->orig.in.server_name = _server_name; 1491 state->orig.in.use_name = _use_name; 1492 state->orig.in.level = _level; 1493 1494 /* Out parameters */ 1495 state->orig.out.ctr = _ctr; 1496 1497 /* Result */ 1498 ZERO_STRUCT(state->orig.out.result); 1499 1500 state->out_mem_ctx = talloc_named_const(state, 0, 1501 "rpccli_wkssvc_NetrUseGetInfo_out_memory"); 1502 if (tevent_req_nomem(state->out_mem_ctx, req)) { 1503 return tevent_req_post(req, ev); 1504 } 1505 1506 /* make a temporary copy, that we pass to the dispatch function */ 1507 state->tmp = state->orig; 1508 1509 subreq = cli->dispatch_send(state, ev, cli, 1510 &ndr_table_wkssvc, 1511 NDR_WKSSVC_NETRUSEGETINFO, 1512 &state->tmp); 1513 if (tevent_req_nomem(subreq, req)) { 1514 return tevent_req_post(req, ev); 1515 } 1516 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseGetInfo_done, req); 1517 return req; 1518} 1519 1520static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq) 1521{ 1522 struct tevent_req *req = tevent_req_callback_data( 1523 subreq, struct tevent_req); 1524 struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data( 1525 req, struct rpccli_wkssvc_NetrUseGetInfo_state); 1526 NTSTATUS status; 1527 TALLOC_CTX *mem_ctx; 1528 1529 if (state->out_mem_ctx) { 1530 mem_ctx = state->out_mem_ctx; 1531 } else { 1532 mem_ctx = state; 1533 } 1534 1535 status = state->dispatch_recv(subreq, mem_ctx); 1536 TALLOC_FREE(subreq); 1537 if (!NT_STATUS_IS_OK(status)) { 1538 tevent_req_nterror(req, status); 1539 return; 1540 } 1541 1542 /* Copy out parameters */ 1543 *state->orig.out.ctr = *state->tmp.out.ctr; 1544 1545 /* Copy result */ 1546 state->orig.out.result = state->tmp.out.result; 1547 1548 /* Reset temporary structure */ 1549 ZERO_STRUCT(state->tmp); 1550 1551 tevent_req_done(req); 1552} 1553 1554NTSTATUS rpccli_wkssvc_NetrUseGetInfo_recv(struct tevent_req *req, 1555 TALLOC_CTX *mem_ctx, 1556 WERROR *result) 1557{ 1558 struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data( 1559 req, struct rpccli_wkssvc_NetrUseGetInfo_state); 1560 NTSTATUS status; 1561 1562 if (tevent_req_is_nterror(req, &status)) { 1563 tevent_req_received(req); 1564 return status; 1565 } 1566 1567 /* Steal possbile out parameters to the callers context */ 1568 talloc_steal(mem_ctx, state->out_mem_ctx); 1569 1570 /* Return result */ 1571 *result = state->orig.out.result; 1572 1573 tevent_req_received(req); 1574 return NT_STATUS_OK; 1575} 1576 1577NTSTATUS rpccli_wkssvc_NetrUseGetInfo(struct rpc_pipe_client *cli, 1578 TALLOC_CTX *mem_ctx, 1579 const char *server_name /* [in] [unique,charset(UTF16)] */, 1580 const char *use_name /* [in] [ref,charset(UTF16)] */, 1581 uint32_t level /* [in] */, 1582 union wkssvc_NetrUseGetInfoCtr *ctr /* [out] [ref,switch_is(level)] */, 1583 WERROR *werror) 1584{ 1585 struct wkssvc_NetrUseGetInfo r; 1586 NTSTATUS status; 1587 1588 /* In parameters */ 1589 r.in.server_name = server_name; 1590 r.in.use_name = use_name; 1591 r.in.level = level; 1592 1593 status = cli->dispatch(cli, 1594 mem_ctx, 1595 &ndr_table_wkssvc, 1596 NDR_WKSSVC_NETRUSEGETINFO, 1597 &r); 1598 1599 if (!NT_STATUS_IS_OK(status)) { 1600 return status; 1601 } 1602 1603 if (NT_STATUS_IS_ERR(status)) { 1604 return status; 1605 } 1606 1607 /* Return variables */ 1608 *ctr = *r.out.ctr; 1609 1610 /* Return result */ 1611 if (werror) { 1612 *werror = r.out.result; 1613 } 1614 1615 return werror_to_ntstatus(r.out.result); 1616} 1617 1618struct rpccli_wkssvc_NetrUseDel_state { 1619 struct wkssvc_NetrUseDel orig; 1620 struct wkssvc_NetrUseDel tmp; 1621 TALLOC_CTX *out_mem_ctx; 1622 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1623}; 1624 1625static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq); 1626 1627struct tevent_req *rpccli_wkssvc_NetrUseDel_send(TALLOC_CTX *mem_ctx, 1628 struct tevent_context *ev, 1629 struct rpc_pipe_client *cli, 1630 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1631 const char *_use_name /* [in] [ref,charset(UTF16)] */, 1632 uint32_t _force_cond /* [in] */) 1633{ 1634 struct tevent_req *req; 1635 struct rpccli_wkssvc_NetrUseDel_state *state; 1636 struct tevent_req *subreq; 1637 1638 req = tevent_req_create(mem_ctx, &state, 1639 struct rpccli_wkssvc_NetrUseDel_state); 1640 if (req == NULL) { 1641 return NULL; 1642 } 1643 state->out_mem_ctx = NULL; 1644 state->dispatch_recv = cli->dispatch_recv; 1645 1646 /* In parameters */ 1647 state->orig.in.server_name = _server_name; 1648 state->orig.in.use_name = _use_name; 1649 state->orig.in.force_cond = _force_cond; 1650 1651 /* Out parameters */ 1652 1653 /* Result */ 1654 ZERO_STRUCT(state->orig.out.result); 1655 1656 /* make a temporary copy, that we pass to the dispatch function */ 1657 state->tmp = state->orig; 1658 1659 subreq = cli->dispatch_send(state, ev, cli, 1660 &ndr_table_wkssvc, 1661 NDR_WKSSVC_NETRUSEDEL, 1662 &state->tmp); 1663 if (tevent_req_nomem(subreq, req)) { 1664 return tevent_req_post(req, ev); 1665 } 1666 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseDel_done, req); 1667 return req; 1668} 1669 1670static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq) 1671{ 1672 struct tevent_req *req = tevent_req_callback_data( 1673 subreq, struct tevent_req); 1674 struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data( 1675 req, struct rpccli_wkssvc_NetrUseDel_state); 1676 NTSTATUS status; 1677 TALLOC_CTX *mem_ctx; 1678 1679 if (state->out_mem_ctx) { 1680 mem_ctx = state->out_mem_ctx; 1681 } else { 1682 mem_ctx = state; 1683 } 1684 1685 status = state->dispatch_recv(subreq, mem_ctx); 1686 TALLOC_FREE(subreq); 1687 if (!NT_STATUS_IS_OK(status)) { 1688 tevent_req_nterror(req, status); 1689 return; 1690 } 1691 1692 /* Copy out parameters */ 1693 1694 /* Copy result */ 1695 state->orig.out.result = state->tmp.out.result; 1696 1697 /* Reset temporary structure */ 1698 ZERO_STRUCT(state->tmp); 1699 1700 tevent_req_done(req); 1701} 1702 1703NTSTATUS rpccli_wkssvc_NetrUseDel_recv(struct tevent_req *req, 1704 TALLOC_CTX *mem_ctx, 1705 WERROR *result) 1706{ 1707 struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data( 1708 req, struct rpccli_wkssvc_NetrUseDel_state); 1709 NTSTATUS status; 1710 1711 if (tevent_req_is_nterror(req, &status)) { 1712 tevent_req_received(req); 1713 return status; 1714 } 1715 1716 /* Steal possbile out parameters to the callers context */ 1717 talloc_steal(mem_ctx, state->out_mem_ctx); 1718 1719 /* Return result */ 1720 *result = state->orig.out.result; 1721 1722 tevent_req_received(req); 1723 return NT_STATUS_OK; 1724} 1725 1726NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli, 1727 TALLOC_CTX *mem_ctx, 1728 const char *server_name /* [in] [unique,charset(UTF16)] */, 1729 const char *use_name /* [in] [ref,charset(UTF16)] */, 1730 uint32_t force_cond /* [in] */, 1731 WERROR *werror) 1732{ 1733 struct wkssvc_NetrUseDel r; 1734 NTSTATUS status; 1735 1736 /* In parameters */ 1737 r.in.server_name = server_name; 1738 r.in.use_name = use_name; 1739 r.in.force_cond = force_cond; 1740 1741 status = cli->dispatch(cli, 1742 mem_ctx, 1743 &ndr_table_wkssvc, 1744 NDR_WKSSVC_NETRUSEDEL, 1745 &r); 1746 1747 if (!NT_STATUS_IS_OK(status)) { 1748 return status; 1749 } 1750 1751 if (NT_STATUS_IS_ERR(status)) { 1752 return status; 1753 } 1754 1755 /* Return variables */ 1756 1757 /* Return result */ 1758 if (werror) { 1759 *werror = r.out.result; 1760 } 1761 1762 return werror_to_ntstatus(r.out.result); 1763} 1764 1765struct rpccli_wkssvc_NetrUseEnum_state { 1766 struct wkssvc_NetrUseEnum orig; 1767 struct wkssvc_NetrUseEnum tmp; 1768 TALLOC_CTX *out_mem_ctx; 1769 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1770}; 1771 1772static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq); 1773 1774struct tevent_req *rpccli_wkssvc_NetrUseEnum_send(TALLOC_CTX *mem_ctx, 1775 struct tevent_context *ev, 1776 struct rpc_pipe_client *cli, 1777 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1778 struct wkssvc_NetrUseEnumInfo *_info /* [in,out] [ref] */, 1779 uint32_t _prefmaxlen /* [in] */, 1780 uint32_t *_entries_read /* [out] [ref] */, 1781 uint32_t *_resume_handle /* [in,out] [unique] */) 1782{ 1783 struct tevent_req *req; 1784 struct rpccli_wkssvc_NetrUseEnum_state *state; 1785 struct tevent_req *subreq; 1786 1787 req = tevent_req_create(mem_ctx, &state, 1788 struct rpccli_wkssvc_NetrUseEnum_state); 1789 if (req == NULL) { 1790 return NULL; 1791 } 1792 state->out_mem_ctx = NULL; 1793 state->dispatch_recv = cli->dispatch_recv; 1794 1795 /* In parameters */ 1796 state->orig.in.server_name = _server_name; 1797 state->orig.in.info = _info; 1798 state->orig.in.prefmaxlen = _prefmaxlen; 1799 state->orig.in.resume_handle = _resume_handle; 1800 1801 /* Out parameters */ 1802 state->orig.out.info = _info; 1803 state->orig.out.entries_read = _entries_read; 1804 state->orig.out.resume_handle = _resume_handle; 1805 1806 /* Result */ 1807 ZERO_STRUCT(state->orig.out.result); 1808 1809 state->out_mem_ctx = talloc_named_const(state, 0, 1810 "rpccli_wkssvc_NetrUseEnum_out_memory"); 1811 if (tevent_req_nomem(state->out_mem_ctx, req)) { 1812 return tevent_req_post(req, ev); 1813 } 1814 1815 /* make a temporary copy, that we pass to the dispatch function */ 1816 state->tmp = state->orig; 1817 1818 subreq = cli->dispatch_send(state, ev, cli, 1819 &ndr_table_wkssvc, 1820 NDR_WKSSVC_NETRUSEENUM, 1821 &state->tmp); 1822 if (tevent_req_nomem(subreq, req)) { 1823 return tevent_req_post(req, ev); 1824 } 1825 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseEnum_done, req); 1826 return req; 1827} 1828 1829static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq) 1830{ 1831 struct tevent_req *req = tevent_req_callback_data( 1832 subreq, struct tevent_req); 1833 struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data( 1834 req, struct rpccli_wkssvc_NetrUseEnum_state); 1835 NTSTATUS status; 1836 TALLOC_CTX *mem_ctx; 1837 1838 if (state->out_mem_ctx) { 1839 mem_ctx = state->out_mem_ctx; 1840 } else { 1841 mem_ctx = state; 1842 } 1843 1844 status = state->dispatch_recv(subreq, mem_ctx); 1845 TALLOC_FREE(subreq); 1846 if (!NT_STATUS_IS_OK(status)) { 1847 tevent_req_nterror(req, status); 1848 return; 1849 } 1850 1851 /* Copy out parameters */ 1852 *state->orig.out.info = *state->tmp.out.info; 1853 *state->orig.out.entries_read = *state->tmp.out.entries_read; 1854 if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { 1855 *state->orig.out.resume_handle = *state->tmp.out.resume_handle; 1856 } 1857 1858 /* Copy result */ 1859 state->orig.out.result = state->tmp.out.result; 1860 1861 /* Reset temporary structure */ 1862 ZERO_STRUCT(state->tmp); 1863 1864 tevent_req_done(req); 1865} 1866 1867NTSTATUS rpccli_wkssvc_NetrUseEnum_recv(struct tevent_req *req, 1868 TALLOC_CTX *mem_ctx, 1869 WERROR *result) 1870{ 1871 struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data( 1872 req, struct rpccli_wkssvc_NetrUseEnum_state); 1873 NTSTATUS status; 1874 1875 if (tevent_req_is_nterror(req, &status)) { 1876 tevent_req_received(req); 1877 return status; 1878 } 1879 1880 /* Steal possbile out parameters to the callers context */ 1881 talloc_steal(mem_ctx, state->out_mem_ctx); 1882 1883 /* Return result */ 1884 *result = state->orig.out.result; 1885 1886 tevent_req_received(req); 1887 return NT_STATUS_OK; 1888} 1889 1890NTSTATUS rpccli_wkssvc_NetrUseEnum(struct rpc_pipe_client *cli, 1891 TALLOC_CTX *mem_ctx, 1892 const char *server_name /* [in] [unique,charset(UTF16)] */, 1893 struct wkssvc_NetrUseEnumInfo *info /* [in,out] [ref] */, 1894 uint32_t prefmaxlen /* [in] */, 1895 uint32_t *entries_read /* [out] [ref] */, 1896 uint32_t *resume_handle /* [in,out] [unique] */, 1897 WERROR *werror) 1898{ 1899 struct wkssvc_NetrUseEnum r; 1900 NTSTATUS status; 1901 1902 /* In parameters */ 1903 r.in.server_name = server_name; 1904 r.in.info = info; 1905 r.in.prefmaxlen = prefmaxlen; 1906 r.in.resume_handle = resume_handle; 1907 1908 status = cli->dispatch(cli, 1909 mem_ctx, 1910 &ndr_table_wkssvc, 1911 NDR_WKSSVC_NETRUSEENUM, 1912 &r); 1913 1914 if (!NT_STATUS_IS_OK(status)) { 1915 return status; 1916 } 1917 1918 if (NT_STATUS_IS_ERR(status)) { 1919 return status; 1920 } 1921 1922 /* Return variables */ 1923 *info = *r.out.info; 1924 *entries_read = *r.out.entries_read; 1925 if (resume_handle && r.out.resume_handle) { 1926 *resume_handle = *r.out.resume_handle; 1927 } 1928 1929 /* Return result */ 1930 if (werror) { 1931 *werror = r.out.result; 1932 } 1933 1934 return werror_to_ntstatus(r.out.result); 1935} 1936 1937struct rpccli_wkssvc_NetrMessageBufferSend_state { 1938 struct wkssvc_NetrMessageBufferSend orig; 1939 struct wkssvc_NetrMessageBufferSend tmp; 1940 TALLOC_CTX *out_mem_ctx; 1941 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 1942}; 1943 1944static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq); 1945 1946struct tevent_req *rpccli_wkssvc_NetrMessageBufferSend_send(TALLOC_CTX *mem_ctx, 1947 struct tevent_context *ev, 1948 struct rpc_pipe_client *cli, 1949 const char *_server_name /* [in] [unique,charset(UTF16)] */, 1950 const char *_message_name /* [in] [ref,charset(UTF16)] */, 1951 const char *_message_sender_name /* [in] [unique,charset(UTF16)] */, 1952 uint8_t *_message_buffer /* [in] [ref,size_is(message_size)] */, 1953 uint32_t _message_size /* [in] */) 1954{ 1955 struct tevent_req *req; 1956 struct rpccli_wkssvc_NetrMessageBufferSend_state *state; 1957 struct tevent_req *subreq; 1958 1959 req = tevent_req_create(mem_ctx, &state, 1960 struct rpccli_wkssvc_NetrMessageBufferSend_state); 1961 if (req == NULL) { 1962 return NULL; 1963 } 1964 state->out_mem_ctx = NULL; 1965 state->dispatch_recv = cli->dispatch_recv; 1966 1967 /* In parameters */ 1968 state->orig.in.server_name = _server_name; 1969 state->orig.in.message_name = _message_name; 1970 state->orig.in.message_sender_name = _message_sender_name; 1971 state->orig.in.message_buffer = _message_buffer; 1972 state->orig.in.message_size = _message_size; 1973 1974 /* Out parameters */ 1975 1976 /* Result */ 1977 ZERO_STRUCT(state->orig.out.result); 1978 1979 /* make a temporary copy, that we pass to the dispatch function */ 1980 state->tmp = state->orig; 1981 1982 subreq = cli->dispatch_send(state, ev, cli, 1983 &ndr_table_wkssvc, 1984 NDR_WKSSVC_NETRMESSAGEBUFFERSEND, 1985 &state->tmp); 1986 if (tevent_req_nomem(subreq, req)) { 1987 return tevent_req_post(req, ev); 1988 } 1989 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrMessageBufferSend_done, req); 1990 return req; 1991} 1992 1993static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq) 1994{ 1995 struct tevent_req *req = tevent_req_callback_data( 1996 subreq, struct tevent_req); 1997 struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data( 1998 req, struct rpccli_wkssvc_NetrMessageBufferSend_state); 1999 NTSTATUS status; 2000 TALLOC_CTX *mem_ctx; 2001 2002 if (state->out_mem_ctx) { 2003 mem_ctx = state->out_mem_ctx; 2004 } else { 2005 mem_ctx = state; 2006 } 2007 2008 status = state->dispatch_recv(subreq, mem_ctx); 2009 TALLOC_FREE(subreq); 2010 if (!NT_STATUS_IS_OK(status)) { 2011 tevent_req_nterror(req, status); 2012 return; 2013 } 2014 2015 /* Copy out parameters */ 2016 2017 /* Copy result */ 2018 state->orig.out.result = state->tmp.out.result; 2019 2020 /* Reset temporary structure */ 2021 ZERO_STRUCT(state->tmp); 2022 2023 tevent_req_done(req); 2024} 2025 2026NTSTATUS rpccli_wkssvc_NetrMessageBufferSend_recv(struct tevent_req *req, 2027 TALLOC_CTX *mem_ctx, 2028 WERROR *result) 2029{ 2030 struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data( 2031 req, struct rpccli_wkssvc_NetrMessageBufferSend_state); 2032 NTSTATUS status; 2033 2034 if (tevent_req_is_nterror(req, &status)) { 2035 tevent_req_received(req); 2036 return status; 2037 } 2038 2039 /* Steal possbile out parameters to the callers context */ 2040 talloc_steal(mem_ctx, state->out_mem_ctx); 2041 2042 /* Return result */ 2043 *result = state->orig.out.result; 2044 2045 tevent_req_received(req); 2046 return NT_STATUS_OK; 2047} 2048 2049NTSTATUS rpccli_wkssvc_NetrMessageBufferSend(struct rpc_pipe_client *cli, 2050 TALLOC_CTX *mem_ctx, 2051 const char *server_name /* [in] [unique,charset(UTF16)] */, 2052 const char *message_name /* [in] [ref,charset(UTF16)] */, 2053 const char *message_sender_name /* [in] [unique,charset(UTF16)] */, 2054 uint8_t *message_buffer /* [in] [ref,size_is(message_size)] */, 2055 uint32_t message_size /* [in] */, 2056 WERROR *werror) 2057{ 2058 struct wkssvc_NetrMessageBufferSend r; 2059 NTSTATUS status; 2060 2061 /* In parameters */ 2062 r.in.server_name = server_name; 2063 r.in.message_name = message_name; 2064 r.in.message_sender_name = message_sender_name; 2065 r.in.message_buffer = message_buffer; 2066 r.in.message_size = message_size; 2067 2068 status = cli->dispatch(cli, 2069 mem_ctx, 2070 &ndr_table_wkssvc, 2071 NDR_WKSSVC_NETRMESSAGEBUFFERSEND, 2072 &r); 2073 2074 if (!NT_STATUS_IS_OK(status)) { 2075 return status; 2076 } 2077 2078 if (NT_STATUS_IS_ERR(status)) { 2079 return status; 2080 } 2081 2082 /* Return variables */ 2083 2084 /* Return result */ 2085 if (werror) { 2086 *werror = r.out.result; 2087 } 2088 2089 return werror_to_ntstatus(r.out.result); 2090} 2091 2092struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state { 2093 struct wkssvc_NetrWorkstationStatisticsGet orig; 2094 struct wkssvc_NetrWorkstationStatisticsGet tmp; 2095 TALLOC_CTX *out_mem_ctx; 2096 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2097}; 2098 2099static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq); 2100 2101struct tevent_req *rpccli_wkssvc_NetrWorkstationStatisticsGet_send(TALLOC_CTX *mem_ctx, 2102 struct tevent_context *ev, 2103 struct rpc_pipe_client *cli, 2104 const char *_server_name /* [in] [unique,charset(UTF16)] */, 2105 const char *_unknown2 /* [in] [unique,charset(UTF16)] */, 2106 uint32_t _unknown3 /* [in] */, 2107 uint32_t _unknown4 /* [in] */, 2108 struct wkssvc_NetrWorkstationStatistics **_info /* [out] [ref] */) 2109{ 2110 struct tevent_req *req; 2111 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state; 2112 struct tevent_req *subreq; 2113 2114 req = tevent_req_create(mem_ctx, &state, 2115 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); 2116 if (req == NULL) { 2117 return NULL; 2118 } 2119 state->out_mem_ctx = NULL; 2120 state->dispatch_recv = cli->dispatch_recv; 2121 2122 /* In parameters */ 2123 state->orig.in.server_name = _server_name; 2124 state->orig.in.unknown2 = _unknown2; 2125 state->orig.in.unknown3 = _unknown3; 2126 state->orig.in.unknown4 = _unknown4; 2127 2128 /* Out parameters */ 2129 state->orig.out.info = _info; 2130 2131 /* Result */ 2132 ZERO_STRUCT(state->orig.out.result); 2133 2134 state->out_mem_ctx = talloc_named_const(state, 0, 2135 "rpccli_wkssvc_NetrWorkstationStatisticsGet_out_memory"); 2136 if (tevent_req_nomem(state->out_mem_ctx, req)) { 2137 return tevent_req_post(req, ev); 2138 } 2139 2140 /* make a temporary copy, that we pass to the dispatch function */ 2141 state->tmp = state->orig; 2142 2143 subreq = cli->dispatch_send(state, ev, cli, 2144 &ndr_table_wkssvc, 2145 NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET, 2146 &state->tmp); 2147 if (tevent_req_nomem(subreq, req)) { 2148 return tevent_req_post(req, ev); 2149 } 2150 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWorkstationStatisticsGet_done, req); 2151 return req; 2152} 2153 2154static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq) 2155{ 2156 struct tevent_req *req = tevent_req_callback_data( 2157 subreq, struct tevent_req); 2158 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data( 2159 req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); 2160 NTSTATUS status; 2161 TALLOC_CTX *mem_ctx; 2162 2163 if (state->out_mem_ctx) { 2164 mem_ctx = state->out_mem_ctx; 2165 } else { 2166 mem_ctx = state; 2167 } 2168 2169 status = state->dispatch_recv(subreq, mem_ctx); 2170 TALLOC_FREE(subreq); 2171 if (!NT_STATUS_IS_OK(status)) { 2172 tevent_req_nterror(req, status); 2173 return; 2174 } 2175 2176 /* Copy out parameters */ 2177 *state->orig.out.info = *state->tmp.out.info; 2178 2179 /* Copy result */ 2180 state->orig.out.result = state->tmp.out.result; 2181 2182 /* Reset temporary structure */ 2183 ZERO_STRUCT(state->tmp); 2184 2185 tevent_req_done(req); 2186} 2187 2188NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet_recv(struct tevent_req *req, 2189 TALLOC_CTX *mem_ctx, 2190 WERROR *result) 2191{ 2192 struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data( 2193 req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); 2194 NTSTATUS status; 2195 2196 if (tevent_req_is_nterror(req, &status)) { 2197 tevent_req_received(req); 2198 return status; 2199 } 2200 2201 /* Steal possbile out parameters to the callers context */ 2202 talloc_steal(mem_ctx, state->out_mem_ctx); 2203 2204 /* Return result */ 2205 *result = state->orig.out.result; 2206 2207 tevent_req_received(req); 2208 return NT_STATUS_OK; 2209} 2210 2211NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet(struct rpc_pipe_client *cli, 2212 TALLOC_CTX *mem_ctx, 2213 const char *server_name /* [in] [unique,charset(UTF16)] */, 2214 const char *unknown2 /* [in] [unique,charset(UTF16)] */, 2215 uint32_t unknown3 /* [in] */, 2216 uint32_t unknown4 /* [in] */, 2217 struct wkssvc_NetrWorkstationStatistics **info /* [out] [ref] */, 2218 WERROR *werror) 2219{ 2220 struct wkssvc_NetrWorkstationStatisticsGet r; 2221 NTSTATUS status; 2222 2223 /* In parameters */ 2224 r.in.server_name = server_name; 2225 r.in.unknown2 = unknown2; 2226 r.in.unknown3 = unknown3; 2227 r.in.unknown4 = unknown4; 2228 2229 status = cli->dispatch(cli, 2230 mem_ctx, 2231 &ndr_table_wkssvc, 2232 NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET, 2233 &r); 2234 2235 if (!NT_STATUS_IS_OK(status)) { 2236 return status; 2237 } 2238 2239 if (NT_STATUS_IS_ERR(status)) { 2240 return status; 2241 } 2242 2243 /* Return variables */ 2244 *info = *r.out.info; 2245 2246 /* Return result */ 2247 if (werror) { 2248 *werror = r.out.result; 2249 } 2250 2251 return werror_to_ntstatus(r.out.result); 2252} 2253 2254struct rpccli_wkssvc_NetrLogonDomainNameAdd_state { 2255 struct wkssvc_NetrLogonDomainNameAdd orig; 2256 struct wkssvc_NetrLogonDomainNameAdd tmp; 2257 TALLOC_CTX *out_mem_ctx; 2258 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2259}; 2260 2261static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq); 2262 2263struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameAdd_send(TALLOC_CTX *mem_ctx, 2264 struct tevent_context *ev, 2265 struct rpc_pipe_client *cli, 2266 const char *_domain_name /* [in] [ref,charset(UTF16)] */) 2267{ 2268 struct tevent_req *req; 2269 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state; 2270 struct tevent_req *subreq; 2271 2272 req = tevent_req_create(mem_ctx, &state, 2273 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); 2274 if (req == NULL) { 2275 return NULL; 2276 } 2277 state->out_mem_ctx = NULL; 2278 state->dispatch_recv = cli->dispatch_recv; 2279 2280 /* In parameters */ 2281 state->orig.in.domain_name = _domain_name; 2282 2283 /* Out parameters */ 2284 2285 /* Result */ 2286 ZERO_STRUCT(state->orig.out.result); 2287 2288 /* make a temporary copy, that we pass to the dispatch function */ 2289 state->tmp = state->orig; 2290 2291 subreq = cli->dispatch_send(state, ev, cli, 2292 &ndr_table_wkssvc, 2293 NDR_WKSSVC_NETRLOGONDOMAINNAMEADD, 2294 &state->tmp); 2295 if (tevent_req_nomem(subreq, req)) { 2296 return tevent_req_post(req, ev); 2297 } 2298 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameAdd_done, req); 2299 return req; 2300} 2301 2302static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq) 2303{ 2304 struct tevent_req *req = tevent_req_callback_data( 2305 subreq, struct tevent_req); 2306 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data( 2307 req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); 2308 NTSTATUS status; 2309 TALLOC_CTX *mem_ctx; 2310 2311 if (state->out_mem_ctx) { 2312 mem_ctx = state->out_mem_ctx; 2313 } else { 2314 mem_ctx = state; 2315 } 2316 2317 status = state->dispatch_recv(subreq, mem_ctx); 2318 TALLOC_FREE(subreq); 2319 if (!NT_STATUS_IS_OK(status)) { 2320 tevent_req_nterror(req, status); 2321 return; 2322 } 2323 2324 /* Copy out parameters */ 2325 2326 /* Copy result */ 2327 state->orig.out.result = state->tmp.out.result; 2328 2329 /* Reset temporary structure */ 2330 ZERO_STRUCT(state->tmp); 2331 2332 tevent_req_done(req); 2333} 2334 2335NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd_recv(struct tevent_req *req, 2336 TALLOC_CTX *mem_ctx, 2337 WERROR *result) 2338{ 2339 struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data( 2340 req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); 2341 NTSTATUS status; 2342 2343 if (tevent_req_is_nterror(req, &status)) { 2344 tevent_req_received(req); 2345 return status; 2346 } 2347 2348 /* Steal possbile out parameters to the callers context */ 2349 talloc_steal(mem_ctx, state->out_mem_ctx); 2350 2351 /* Return result */ 2352 *result = state->orig.out.result; 2353 2354 tevent_req_received(req); 2355 return NT_STATUS_OK; 2356} 2357 2358NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd(struct rpc_pipe_client *cli, 2359 TALLOC_CTX *mem_ctx, 2360 const char *domain_name /* [in] [ref,charset(UTF16)] */, 2361 WERROR *werror) 2362{ 2363 struct wkssvc_NetrLogonDomainNameAdd r; 2364 NTSTATUS status; 2365 2366 /* In parameters */ 2367 r.in.domain_name = domain_name; 2368 2369 status = cli->dispatch(cli, 2370 mem_ctx, 2371 &ndr_table_wkssvc, 2372 NDR_WKSSVC_NETRLOGONDOMAINNAMEADD, 2373 &r); 2374 2375 if (!NT_STATUS_IS_OK(status)) { 2376 return status; 2377 } 2378 2379 if (NT_STATUS_IS_ERR(status)) { 2380 return status; 2381 } 2382 2383 /* Return variables */ 2384 2385 /* Return result */ 2386 if (werror) { 2387 *werror = r.out.result; 2388 } 2389 2390 return werror_to_ntstatus(r.out.result); 2391} 2392 2393struct rpccli_wkssvc_NetrLogonDomainNameDel_state { 2394 struct wkssvc_NetrLogonDomainNameDel orig; 2395 struct wkssvc_NetrLogonDomainNameDel tmp; 2396 TALLOC_CTX *out_mem_ctx; 2397 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2398}; 2399 2400static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq); 2401 2402struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameDel_send(TALLOC_CTX *mem_ctx, 2403 struct tevent_context *ev, 2404 struct rpc_pipe_client *cli, 2405 const char *_domain_name /* [in] [ref,charset(UTF16)] */) 2406{ 2407 struct tevent_req *req; 2408 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state; 2409 struct tevent_req *subreq; 2410 2411 req = tevent_req_create(mem_ctx, &state, 2412 struct rpccli_wkssvc_NetrLogonDomainNameDel_state); 2413 if (req == NULL) { 2414 return NULL; 2415 } 2416 state->out_mem_ctx = NULL; 2417 state->dispatch_recv = cli->dispatch_recv; 2418 2419 /* In parameters */ 2420 state->orig.in.domain_name = _domain_name; 2421 2422 /* Out parameters */ 2423 2424 /* Result */ 2425 ZERO_STRUCT(state->orig.out.result); 2426 2427 /* make a temporary copy, that we pass to the dispatch function */ 2428 state->tmp = state->orig; 2429 2430 subreq = cli->dispatch_send(state, ev, cli, 2431 &ndr_table_wkssvc, 2432 NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL, 2433 &state->tmp); 2434 if (tevent_req_nomem(subreq, req)) { 2435 return tevent_req_post(req, ev); 2436 } 2437 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameDel_done, req); 2438 return req; 2439} 2440 2441static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq) 2442{ 2443 struct tevent_req *req = tevent_req_callback_data( 2444 subreq, struct tevent_req); 2445 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data( 2446 req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state); 2447 NTSTATUS status; 2448 TALLOC_CTX *mem_ctx; 2449 2450 if (state->out_mem_ctx) { 2451 mem_ctx = state->out_mem_ctx; 2452 } else { 2453 mem_ctx = state; 2454 } 2455 2456 status = state->dispatch_recv(subreq, mem_ctx); 2457 TALLOC_FREE(subreq); 2458 if (!NT_STATUS_IS_OK(status)) { 2459 tevent_req_nterror(req, status); 2460 return; 2461 } 2462 2463 /* Copy out parameters */ 2464 2465 /* Copy result */ 2466 state->orig.out.result = state->tmp.out.result; 2467 2468 /* Reset temporary structure */ 2469 ZERO_STRUCT(state->tmp); 2470 2471 tevent_req_done(req); 2472} 2473 2474NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel_recv(struct tevent_req *req, 2475 TALLOC_CTX *mem_ctx, 2476 WERROR *result) 2477{ 2478 struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data( 2479 req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state); 2480 NTSTATUS status; 2481 2482 if (tevent_req_is_nterror(req, &status)) { 2483 tevent_req_received(req); 2484 return status; 2485 } 2486 2487 /* Steal possbile out parameters to the callers context */ 2488 talloc_steal(mem_ctx, state->out_mem_ctx); 2489 2490 /* Return result */ 2491 *result = state->orig.out.result; 2492 2493 tevent_req_received(req); 2494 return NT_STATUS_OK; 2495} 2496 2497NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel(struct rpc_pipe_client *cli, 2498 TALLOC_CTX *mem_ctx, 2499 const char *domain_name /* [in] [ref,charset(UTF16)] */, 2500 WERROR *werror) 2501{ 2502 struct wkssvc_NetrLogonDomainNameDel r; 2503 NTSTATUS status; 2504 2505 /* In parameters */ 2506 r.in.domain_name = domain_name; 2507 2508 status = cli->dispatch(cli, 2509 mem_ctx, 2510 &ndr_table_wkssvc, 2511 NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL, 2512 &r); 2513 2514 if (!NT_STATUS_IS_OK(status)) { 2515 return status; 2516 } 2517 2518 if (NT_STATUS_IS_ERR(status)) { 2519 return status; 2520 } 2521 2522 /* Return variables */ 2523 2524 /* Return result */ 2525 if (werror) { 2526 *werror = r.out.result; 2527 } 2528 2529 return werror_to_ntstatus(r.out.result); 2530} 2531 2532struct rpccli_wkssvc_NetrJoinDomain_state { 2533 struct wkssvc_NetrJoinDomain orig; 2534 struct wkssvc_NetrJoinDomain tmp; 2535 TALLOC_CTX *out_mem_ctx; 2536 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2537}; 2538 2539static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq); 2540 2541struct tevent_req *rpccli_wkssvc_NetrJoinDomain_send(TALLOC_CTX *mem_ctx, 2542 struct tevent_context *ev, 2543 struct rpc_pipe_client *cli, 2544 const char *_server_name /* [in] [unique,charset(UTF16)] */, 2545 const char *_domain_name /* [in] [ref,charset(UTF16)] */, 2546 const char *_account_ou /* [in] [unique,charset(UTF16)] */, 2547 const char *_Account /* [in] [unique,charset(UTF16)] */, 2548 const char *_password /* [in] [unique,charset(UTF16)] */, 2549 uint32_t _join_flags /* [in] */) 2550{ 2551 struct tevent_req *req; 2552 struct rpccli_wkssvc_NetrJoinDomain_state *state; 2553 struct tevent_req *subreq; 2554 2555 req = tevent_req_create(mem_ctx, &state, 2556 struct rpccli_wkssvc_NetrJoinDomain_state); 2557 if (req == NULL) { 2558 return NULL; 2559 } 2560 state->out_mem_ctx = NULL; 2561 state->dispatch_recv = cli->dispatch_recv; 2562 2563 /* In parameters */ 2564 state->orig.in.server_name = _server_name; 2565 state->orig.in.domain_name = _domain_name; 2566 state->orig.in.account_ou = _account_ou; 2567 state->orig.in.Account = _Account; 2568 state->orig.in.password = _password; 2569 state->orig.in.join_flags = _join_flags; 2570 2571 /* Out parameters */ 2572 2573 /* Result */ 2574 ZERO_STRUCT(state->orig.out.result); 2575 2576 /* make a temporary copy, that we pass to the dispatch function */ 2577 state->tmp = state->orig; 2578 2579 subreq = cli->dispatch_send(state, ev, cli, 2580 &ndr_table_wkssvc, 2581 NDR_WKSSVC_NETRJOINDOMAIN, 2582 &state->tmp); 2583 if (tevent_req_nomem(subreq, req)) { 2584 return tevent_req_post(req, ev); 2585 } 2586 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain_done, req); 2587 return req; 2588} 2589 2590static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq) 2591{ 2592 struct tevent_req *req = tevent_req_callback_data( 2593 subreq, struct tevent_req); 2594 struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data( 2595 req, struct rpccli_wkssvc_NetrJoinDomain_state); 2596 NTSTATUS status; 2597 TALLOC_CTX *mem_ctx; 2598 2599 if (state->out_mem_ctx) { 2600 mem_ctx = state->out_mem_ctx; 2601 } else { 2602 mem_ctx = state; 2603 } 2604 2605 status = state->dispatch_recv(subreq, mem_ctx); 2606 TALLOC_FREE(subreq); 2607 if (!NT_STATUS_IS_OK(status)) { 2608 tevent_req_nterror(req, status); 2609 return; 2610 } 2611 2612 /* Copy out parameters */ 2613 2614 /* Copy result */ 2615 state->orig.out.result = state->tmp.out.result; 2616 2617 /* Reset temporary structure */ 2618 ZERO_STRUCT(state->tmp); 2619 2620 tevent_req_done(req); 2621} 2622 2623NTSTATUS rpccli_wkssvc_NetrJoinDomain_recv(struct tevent_req *req, 2624 TALLOC_CTX *mem_ctx, 2625 WERROR *result) 2626{ 2627 struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data( 2628 req, struct rpccli_wkssvc_NetrJoinDomain_state); 2629 NTSTATUS status; 2630 2631 if (tevent_req_is_nterror(req, &status)) { 2632 tevent_req_received(req); 2633 return status; 2634 } 2635 2636 /* Steal possbile out parameters to the callers context */ 2637 talloc_steal(mem_ctx, state->out_mem_ctx); 2638 2639 /* Return result */ 2640 *result = state->orig.out.result; 2641 2642 tevent_req_received(req); 2643 return NT_STATUS_OK; 2644} 2645 2646NTSTATUS rpccli_wkssvc_NetrJoinDomain(struct rpc_pipe_client *cli, 2647 TALLOC_CTX *mem_ctx, 2648 const char *server_name /* [in] [unique,charset(UTF16)] */, 2649 const char *domain_name /* [in] [ref,charset(UTF16)] */, 2650 const char *account_ou /* [in] [unique,charset(UTF16)] */, 2651 const char *Account /* [in] [unique,charset(UTF16)] */, 2652 const char *password /* [in] [unique,charset(UTF16)] */, 2653 uint32_t join_flags /* [in] */, 2654 WERROR *werror) 2655{ 2656 struct wkssvc_NetrJoinDomain r; 2657 NTSTATUS status; 2658 2659 /* In parameters */ 2660 r.in.server_name = server_name; 2661 r.in.domain_name = domain_name; 2662 r.in.account_ou = account_ou; 2663 r.in.Account = Account; 2664 r.in.password = password; 2665 r.in.join_flags = join_flags; 2666 2667 status = cli->dispatch(cli, 2668 mem_ctx, 2669 &ndr_table_wkssvc, 2670 NDR_WKSSVC_NETRJOINDOMAIN, 2671 &r); 2672 2673 if (!NT_STATUS_IS_OK(status)) { 2674 return status; 2675 } 2676 2677 if (NT_STATUS_IS_ERR(status)) { 2678 return status; 2679 } 2680 2681 /* Return variables */ 2682 2683 /* Return result */ 2684 if (werror) { 2685 *werror = r.out.result; 2686 } 2687 2688 return werror_to_ntstatus(r.out.result); 2689} 2690 2691struct rpccli_wkssvc_NetrUnjoinDomain_state { 2692 struct wkssvc_NetrUnjoinDomain orig; 2693 struct wkssvc_NetrUnjoinDomain tmp; 2694 TALLOC_CTX *out_mem_ctx; 2695 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2696}; 2697 2698static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq); 2699 2700struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain_send(TALLOC_CTX *mem_ctx, 2701 struct tevent_context *ev, 2702 struct rpc_pipe_client *cli, 2703 const char *_server_name /* [in] [unique,charset(UTF16)] */, 2704 const char *_Account /* [in] [unique,charset(UTF16)] */, 2705 const char *_password /* [in] [unique,charset(UTF16)] */, 2706 uint32_t _unjoin_flags /* [in] */) 2707{ 2708 struct tevent_req *req; 2709 struct rpccli_wkssvc_NetrUnjoinDomain_state *state; 2710 struct tevent_req *subreq; 2711 2712 req = tevent_req_create(mem_ctx, &state, 2713 struct rpccli_wkssvc_NetrUnjoinDomain_state); 2714 if (req == NULL) { 2715 return NULL; 2716 } 2717 state->out_mem_ctx = NULL; 2718 state->dispatch_recv = cli->dispatch_recv; 2719 2720 /* In parameters */ 2721 state->orig.in.server_name = _server_name; 2722 state->orig.in.Account = _Account; 2723 state->orig.in.password = _password; 2724 state->orig.in.unjoin_flags = _unjoin_flags; 2725 2726 /* Out parameters */ 2727 2728 /* Result */ 2729 ZERO_STRUCT(state->orig.out.result); 2730 2731 /* make a temporary copy, that we pass to the dispatch function */ 2732 state->tmp = state->orig; 2733 2734 subreq = cli->dispatch_send(state, ev, cli, 2735 &ndr_table_wkssvc, 2736 NDR_WKSSVC_NETRUNJOINDOMAIN, 2737 &state->tmp); 2738 if (tevent_req_nomem(subreq, req)) { 2739 return tevent_req_post(req, ev); 2740 } 2741 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain_done, req); 2742 return req; 2743} 2744 2745static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq) 2746{ 2747 struct tevent_req *req = tevent_req_callback_data( 2748 subreq, struct tevent_req); 2749 struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data( 2750 req, struct rpccli_wkssvc_NetrUnjoinDomain_state); 2751 NTSTATUS status; 2752 TALLOC_CTX *mem_ctx; 2753 2754 if (state->out_mem_ctx) { 2755 mem_ctx = state->out_mem_ctx; 2756 } else { 2757 mem_ctx = state; 2758 } 2759 2760 status = state->dispatch_recv(subreq, mem_ctx); 2761 TALLOC_FREE(subreq); 2762 if (!NT_STATUS_IS_OK(status)) { 2763 tevent_req_nterror(req, status); 2764 return; 2765 } 2766 2767 /* Copy out parameters */ 2768 2769 /* Copy result */ 2770 state->orig.out.result = state->tmp.out.result; 2771 2772 /* Reset temporary structure */ 2773 ZERO_STRUCT(state->tmp); 2774 2775 tevent_req_done(req); 2776} 2777 2778NTSTATUS rpccli_wkssvc_NetrUnjoinDomain_recv(struct tevent_req *req, 2779 TALLOC_CTX *mem_ctx, 2780 WERROR *result) 2781{ 2782 struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data( 2783 req, struct rpccli_wkssvc_NetrUnjoinDomain_state); 2784 NTSTATUS status; 2785 2786 if (tevent_req_is_nterror(req, &status)) { 2787 tevent_req_received(req); 2788 return status; 2789 } 2790 2791 /* Steal possbile out parameters to the callers context */ 2792 talloc_steal(mem_ctx, state->out_mem_ctx); 2793 2794 /* Return result */ 2795 *result = state->orig.out.result; 2796 2797 tevent_req_received(req); 2798 return NT_STATUS_OK; 2799} 2800 2801NTSTATUS rpccli_wkssvc_NetrUnjoinDomain(struct rpc_pipe_client *cli, 2802 TALLOC_CTX *mem_ctx, 2803 const char *server_name /* [in] [unique,charset(UTF16)] */, 2804 const char *Account /* [in] [unique,charset(UTF16)] */, 2805 const char *password /* [in] [unique,charset(UTF16)] */, 2806 uint32_t unjoin_flags /* [in] */, 2807 WERROR *werror) 2808{ 2809 struct wkssvc_NetrUnjoinDomain r; 2810 NTSTATUS status; 2811 2812 /* In parameters */ 2813 r.in.server_name = server_name; 2814 r.in.Account = Account; 2815 r.in.password = password; 2816 r.in.unjoin_flags = unjoin_flags; 2817 2818 status = cli->dispatch(cli, 2819 mem_ctx, 2820 &ndr_table_wkssvc, 2821 NDR_WKSSVC_NETRUNJOINDOMAIN, 2822 &r); 2823 2824 if (!NT_STATUS_IS_OK(status)) { 2825 return status; 2826 } 2827 2828 if (NT_STATUS_IS_ERR(status)) { 2829 return status; 2830 } 2831 2832 /* Return variables */ 2833 2834 /* Return result */ 2835 if (werror) { 2836 *werror = r.out.result; 2837 } 2838 2839 return werror_to_ntstatus(r.out.result); 2840} 2841 2842struct rpccli_wkssvc_NetrRenameMachineInDomain_state { 2843 struct wkssvc_NetrRenameMachineInDomain orig; 2844 struct wkssvc_NetrRenameMachineInDomain tmp; 2845 TALLOC_CTX *out_mem_ctx; 2846 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 2847}; 2848 2849static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq); 2850 2851struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain_send(TALLOC_CTX *mem_ctx, 2852 struct tevent_context *ev, 2853 struct rpc_pipe_client *cli, 2854 const char *_server_name /* [in] [unique,charset(UTF16)] */, 2855 const char *_NewMachineName /* [in] [unique,charset(UTF16)] */, 2856 const char *_Account /* [in] [unique,charset(UTF16)] */, 2857 const char *_password /* [in] [unique,charset(UTF16)] */, 2858 uint32_t _RenameOptions /* [in] */) 2859{ 2860 struct tevent_req *req; 2861 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state; 2862 struct tevent_req *subreq; 2863 2864 req = tevent_req_create(mem_ctx, &state, 2865 struct rpccli_wkssvc_NetrRenameMachineInDomain_state); 2866 if (req == NULL) { 2867 return NULL; 2868 } 2869 state->out_mem_ctx = NULL; 2870 state->dispatch_recv = cli->dispatch_recv; 2871 2872 /* In parameters */ 2873 state->orig.in.server_name = _server_name; 2874 state->orig.in.NewMachineName = _NewMachineName; 2875 state->orig.in.Account = _Account; 2876 state->orig.in.password = _password; 2877 state->orig.in.RenameOptions = _RenameOptions; 2878 2879 /* Out parameters */ 2880 2881 /* Result */ 2882 ZERO_STRUCT(state->orig.out.result); 2883 2884 /* make a temporary copy, that we pass to the dispatch function */ 2885 state->tmp = state->orig; 2886 2887 subreq = cli->dispatch_send(state, ev, cli, 2888 &ndr_table_wkssvc, 2889 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN, 2890 &state->tmp); 2891 if (tevent_req_nomem(subreq, req)) { 2892 return tevent_req_post(req, ev); 2893 } 2894 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain_done, req); 2895 return req; 2896} 2897 2898static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq) 2899{ 2900 struct tevent_req *req = tevent_req_callback_data( 2901 subreq, struct tevent_req); 2902 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data( 2903 req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state); 2904 NTSTATUS status; 2905 TALLOC_CTX *mem_ctx; 2906 2907 if (state->out_mem_ctx) { 2908 mem_ctx = state->out_mem_ctx; 2909 } else { 2910 mem_ctx = state; 2911 } 2912 2913 status = state->dispatch_recv(subreq, mem_ctx); 2914 TALLOC_FREE(subreq); 2915 if (!NT_STATUS_IS_OK(status)) { 2916 tevent_req_nterror(req, status); 2917 return; 2918 } 2919 2920 /* Copy out parameters */ 2921 2922 /* Copy result */ 2923 state->orig.out.result = state->tmp.out.result; 2924 2925 /* Reset temporary structure */ 2926 ZERO_STRUCT(state->tmp); 2927 2928 tevent_req_done(req); 2929} 2930 2931NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain_recv(struct tevent_req *req, 2932 TALLOC_CTX *mem_ctx, 2933 WERROR *result) 2934{ 2935 struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data( 2936 req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state); 2937 NTSTATUS status; 2938 2939 if (tevent_req_is_nterror(req, &status)) { 2940 tevent_req_received(req); 2941 return status; 2942 } 2943 2944 /* Steal possbile out parameters to the callers context */ 2945 talloc_steal(mem_ctx, state->out_mem_ctx); 2946 2947 /* Return result */ 2948 *result = state->orig.out.result; 2949 2950 tevent_req_received(req); 2951 return NT_STATUS_OK; 2952} 2953 2954NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain(struct rpc_pipe_client *cli, 2955 TALLOC_CTX *mem_ctx, 2956 const char *server_name /* [in] [unique,charset(UTF16)] */, 2957 const char *NewMachineName /* [in] [unique,charset(UTF16)] */, 2958 const char *Account /* [in] [unique,charset(UTF16)] */, 2959 const char *password /* [in] [unique,charset(UTF16)] */, 2960 uint32_t RenameOptions /* [in] */, 2961 WERROR *werror) 2962{ 2963 struct wkssvc_NetrRenameMachineInDomain r; 2964 NTSTATUS status; 2965 2966 /* In parameters */ 2967 r.in.server_name = server_name; 2968 r.in.NewMachineName = NewMachineName; 2969 r.in.Account = Account; 2970 r.in.password = password; 2971 r.in.RenameOptions = RenameOptions; 2972 2973 status = cli->dispatch(cli, 2974 mem_ctx, 2975 &ndr_table_wkssvc, 2976 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN, 2977 &r); 2978 2979 if (!NT_STATUS_IS_OK(status)) { 2980 return status; 2981 } 2982 2983 if (NT_STATUS_IS_ERR(status)) { 2984 return status; 2985 } 2986 2987 /* Return variables */ 2988 2989 /* Return result */ 2990 if (werror) { 2991 *werror = r.out.result; 2992 } 2993 2994 return werror_to_ntstatus(r.out.result); 2995} 2996 2997struct rpccli_wkssvc_NetrValidateName_state { 2998 struct wkssvc_NetrValidateName orig; 2999 struct wkssvc_NetrValidateName tmp; 3000 TALLOC_CTX *out_mem_ctx; 3001 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3002}; 3003 3004static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq); 3005 3006struct tevent_req *rpccli_wkssvc_NetrValidateName_send(TALLOC_CTX *mem_ctx, 3007 struct tevent_context *ev, 3008 struct rpc_pipe_client *cli, 3009 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3010 const char *_name /* [in] [ref,charset(UTF16)] */, 3011 const char *_Account /* [in] [unique,charset(UTF16)] */, 3012 const char *_Password /* [in] [unique,charset(UTF16)] */, 3013 enum wkssvc_NetValidateNameType _name_type /* [in] */) 3014{ 3015 struct tevent_req *req; 3016 struct rpccli_wkssvc_NetrValidateName_state *state; 3017 struct tevent_req *subreq; 3018 3019 req = tevent_req_create(mem_ctx, &state, 3020 struct rpccli_wkssvc_NetrValidateName_state); 3021 if (req == NULL) { 3022 return NULL; 3023 } 3024 state->out_mem_ctx = NULL; 3025 state->dispatch_recv = cli->dispatch_recv; 3026 3027 /* In parameters */ 3028 state->orig.in.server_name = _server_name; 3029 state->orig.in.name = _name; 3030 state->orig.in.Account = _Account; 3031 state->orig.in.Password = _Password; 3032 state->orig.in.name_type = _name_type; 3033 3034 /* Out parameters */ 3035 3036 /* Result */ 3037 ZERO_STRUCT(state->orig.out.result); 3038 3039 /* make a temporary copy, that we pass to the dispatch function */ 3040 state->tmp = state->orig; 3041 3042 subreq = cli->dispatch_send(state, ev, cli, 3043 &ndr_table_wkssvc, 3044 NDR_WKSSVC_NETRVALIDATENAME, 3045 &state->tmp); 3046 if (tevent_req_nomem(subreq, req)) { 3047 return tevent_req_post(req, ev); 3048 } 3049 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName_done, req); 3050 return req; 3051} 3052 3053static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq) 3054{ 3055 struct tevent_req *req = tevent_req_callback_data( 3056 subreq, struct tevent_req); 3057 struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data( 3058 req, struct rpccli_wkssvc_NetrValidateName_state); 3059 NTSTATUS status; 3060 TALLOC_CTX *mem_ctx; 3061 3062 if (state->out_mem_ctx) { 3063 mem_ctx = state->out_mem_ctx; 3064 } else { 3065 mem_ctx = state; 3066 } 3067 3068 status = state->dispatch_recv(subreq, mem_ctx); 3069 TALLOC_FREE(subreq); 3070 if (!NT_STATUS_IS_OK(status)) { 3071 tevent_req_nterror(req, status); 3072 return; 3073 } 3074 3075 /* Copy out parameters */ 3076 3077 /* Copy result */ 3078 state->orig.out.result = state->tmp.out.result; 3079 3080 /* Reset temporary structure */ 3081 ZERO_STRUCT(state->tmp); 3082 3083 tevent_req_done(req); 3084} 3085 3086NTSTATUS rpccli_wkssvc_NetrValidateName_recv(struct tevent_req *req, 3087 TALLOC_CTX *mem_ctx, 3088 WERROR *result) 3089{ 3090 struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data( 3091 req, struct rpccli_wkssvc_NetrValidateName_state); 3092 NTSTATUS status; 3093 3094 if (tevent_req_is_nterror(req, &status)) { 3095 tevent_req_received(req); 3096 return status; 3097 } 3098 3099 /* Steal possbile out parameters to the callers context */ 3100 talloc_steal(mem_ctx, state->out_mem_ctx); 3101 3102 /* Return result */ 3103 *result = state->orig.out.result; 3104 3105 tevent_req_received(req); 3106 return NT_STATUS_OK; 3107} 3108 3109NTSTATUS rpccli_wkssvc_NetrValidateName(struct rpc_pipe_client *cli, 3110 TALLOC_CTX *mem_ctx, 3111 const char *server_name /* [in] [unique,charset(UTF16)] */, 3112 const char *name /* [in] [ref,charset(UTF16)] */, 3113 const char *Account /* [in] [unique,charset(UTF16)] */, 3114 const char *Password /* [in] [unique,charset(UTF16)] */, 3115 enum wkssvc_NetValidateNameType name_type /* [in] */, 3116 WERROR *werror) 3117{ 3118 struct wkssvc_NetrValidateName r; 3119 NTSTATUS status; 3120 3121 /* In parameters */ 3122 r.in.server_name = server_name; 3123 r.in.name = name; 3124 r.in.Account = Account; 3125 r.in.Password = Password; 3126 r.in.name_type = name_type; 3127 3128 status = cli->dispatch(cli, 3129 mem_ctx, 3130 &ndr_table_wkssvc, 3131 NDR_WKSSVC_NETRVALIDATENAME, 3132 &r); 3133 3134 if (!NT_STATUS_IS_OK(status)) { 3135 return status; 3136 } 3137 3138 if (NT_STATUS_IS_ERR(status)) { 3139 return status; 3140 } 3141 3142 /* Return variables */ 3143 3144 /* Return result */ 3145 if (werror) { 3146 *werror = r.out.result; 3147 } 3148 3149 return werror_to_ntstatus(r.out.result); 3150} 3151 3152struct rpccli_wkssvc_NetrGetJoinInformation_state { 3153 struct wkssvc_NetrGetJoinInformation orig; 3154 struct wkssvc_NetrGetJoinInformation tmp; 3155 TALLOC_CTX *out_mem_ctx; 3156 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3157}; 3158 3159static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq); 3160 3161struct tevent_req *rpccli_wkssvc_NetrGetJoinInformation_send(TALLOC_CTX *mem_ctx, 3162 struct tevent_context *ev, 3163 struct rpc_pipe_client *cli, 3164 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3165 const char **_name_buffer /* [in,out] [ref,charset(UTF16)] */, 3166 enum wkssvc_NetJoinStatus *_name_type /* [out] [ref] */) 3167{ 3168 struct tevent_req *req; 3169 struct rpccli_wkssvc_NetrGetJoinInformation_state *state; 3170 struct tevent_req *subreq; 3171 3172 req = tevent_req_create(mem_ctx, &state, 3173 struct rpccli_wkssvc_NetrGetJoinInformation_state); 3174 if (req == NULL) { 3175 return NULL; 3176 } 3177 state->out_mem_ctx = NULL; 3178 state->dispatch_recv = cli->dispatch_recv; 3179 3180 /* In parameters */ 3181 state->orig.in.server_name = _server_name; 3182 state->orig.in.name_buffer = _name_buffer; 3183 3184 /* Out parameters */ 3185 state->orig.out.name_buffer = _name_buffer; 3186 state->orig.out.name_type = _name_type; 3187 3188 /* Result */ 3189 ZERO_STRUCT(state->orig.out.result); 3190 3191 state->out_mem_ctx = talloc_named_const(state, 0, 3192 "rpccli_wkssvc_NetrGetJoinInformation_out_memory"); 3193 if (tevent_req_nomem(state->out_mem_ctx, req)) { 3194 return tevent_req_post(req, ev); 3195 } 3196 3197 /* make a temporary copy, that we pass to the dispatch function */ 3198 state->tmp = state->orig; 3199 3200 subreq = cli->dispatch_send(state, ev, cli, 3201 &ndr_table_wkssvc, 3202 NDR_WKSSVC_NETRGETJOININFORMATION, 3203 &state->tmp); 3204 if (tevent_req_nomem(subreq, req)) { 3205 return tevent_req_post(req, ev); 3206 } 3207 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinInformation_done, req); 3208 return req; 3209} 3210 3211static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq) 3212{ 3213 struct tevent_req *req = tevent_req_callback_data( 3214 subreq, struct tevent_req); 3215 struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data( 3216 req, struct rpccli_wkssvc_NetrGetJoinInformation_state); 3217 NTSTATUS status; 3218 TALLOC_CTX *mem_ctx; 3219 3220 if (state->out_mem_ctx) { 3221 mem_ctx = state->out_mem_ctx; 3222 } else { 3223 mem_ctx = state; 3224 } 3225 3226 status = state->dispatch_recv(subreq, mem_ctx); 3227 TALLOC_FREE(subreq); 3228 if (!NT_STATUS_IS_OK(status)) { 3229 tevent_req_nterror(req, status); 3230 return; 3231 } 3232 3233 /* Copy out parameters */ 3234 *state->orig.out.name_buffer = *state->tmp.out.name_buffer; 3235 *state->orig.out.name_type = *state->tmp.out.name_type; 3236 3237 /* Copy result */ 3238 state->orig.out.result = state->tmp.out.result; 3239 3240 /* Reset temporary structure */ 3241 ZERO_STRUCT(state->tmp); 3242 3243 tevent_req_done(req); 3244} 3245 3246NTSTATUS rpccli_wkssvc_NetrGetJoinInformation_recv(struct tevent_req *req, 3247 TALLOC_CTX *mem_ctx, 3248 WERROR *result) 3249{ 3250 struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data( 3251 req, struct rpccli_wkssvc_NetrGetJoinInformation_state); 3252 NTSTATUS status; 3253 3254 if (tevent_req_is_nterror(req, &status)) { 3255 tevent_req_received(req); 3256 return status; 3257 } 3258 3259 /* Steal possbile out parameters to the callers context */ 3260 talloc_steal(mem_ctx, state->out_mem_ctx); 3261 3262 /* Return result */ 3263 *result = state->orig.out.result; 3264 3265 tevent_req_received(req); 3266 return NT_STATUS_OK; 3267} 3268 3269NTSTATUS rpccli_wkssvc_NetrGetJoinInformation(struct rpc_pipe_client *cli, 3270 TALLOC_CTX *mem_ctx, 3271 const char *server_name /* [in] [unique,charset(UTF16)] */, 3272 const char **name_buffer /* [in,out] [ref,charset(UTF16)] */, 3273 enum wkssvc_NetJoinStatus *name_type /* [out] [ref] */, 3274 WERROR *werror) 3275{ 3276 struct wkssvc_NetrGetJoinInformation r; 3277 NTSTATUS status; 3278 3279 /* In parameters */ 3280 r.in.server_name = server_name; 3281 r.in.name_buffer = name_buffer; 3282 3283 status = cli->dispatch(cli, 3284 mem_ctx, 3285 &ndr_table_wkssvc, 3286 NDR_WKSSVC_NETRGETJOININFORMATION, 3287 &r); 3288 3289 if (!NT_STATUS_IS_OK(status)) { 3290 return status; 3291 } 3292 3293 if (NT_STATUS_IS_ERR(status)) { 3294 return status; 3295 } 3296 3297 /* Return variables */ 3298 *name_buffer = *r.out.name_buffer; 3299 *name_type = *r.out.name_type; 3300 3301 /* Return result */ 3302 if (werror) { 3303 *werror = r.out.result; 3304 } 3305 3306 return werror_to_ntstatus(r.out.result); 3307} 3308 3309struct rpccli_wkssvc_NetrGetJoinableOus_state { 3310 struct wkssvc_NetrGetJoinableOus orig; 3311 struct wkssvc_NetrGetJoinableOus tmp; 3312 TALLOC_CTX *out_mem_ctx; 3313 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3314}; 3315 3316static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq); 3317 3318struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus_send(TALLOC_CTX *mem_ctx, 3319 struct tevent_context *ev, 3320 struct rpc_pipe_client *cli, 3321 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3322 const char *_domain_name /* [in] [ref,charset(UTF16)] */, 3323 const char *_Account /* [in] [unique,charset(UTF16)] */, 3324 const char *_unknown /* [in] [unique,charset(UTF16)] */, 3325 uint32_t *_num_ous /* [in,out] [ref] */, 3326 const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */) 3327{ 3328 struct tevent_req *req; 3329 struct rpccli_wkssvc_NetrGetJoinableOus_state *state; 3330 struct tevent_req *subreq; 3331 3332 req = tevent_req_create(mem_ctx, &state, 3333 struct rpccli_wkssvc_NetrGetJoinableOus_state); 3334 if (req == NULL) { 3335 return NULL; 3336 } 3337 state->out_mem_ctx = NULL; 3338 state->dispatch_recv = cli->dispatch_recv; 3339 3340 /* In parameters */ 3341 state->orig.in.server_name = _server_name; 3342 state->orig.in.domain_name = _domain_name; 3343 state->orig.in.Account = _Account; 3344 state->orig.in.unknown = _unknown; 3345 state->orig.in.num_ous = _num_ous; 3346 3347 /* Out parameters */ 3348 state->orig.out.num_ous = _num_ous; 3349 state->orig.out.ous = _ous; 3350 3351 /* Result */ 3352 ZERO_STRUCT(state->orig.out.result); 3353 3354 state->out_mem_ctx = talloc_named_const(state, 0, 3355 "rpccli_wkssvc_NetrGetJoinableOus_out_memory"); 3356 if (tevent_req_nomem(state->out_mem_ctx, req)) { 3357 return tevent_req_post(req, ev); 3358 } 3359 3360 /* make a temporary copy, that we pass to the dispatch function */ 3361 state->tmp = state->orig; 3362 3363 subreq = cli->dispatch_send(state, ev, cli, 3364 &ndr_table_wkssvc, 3365 NDR_WKSSVC_NETRGETJOINABLEOUS, 3366 &state->tmp); 3367 if (tevent_req_nomem(subreq, req)) { 3368 return tevent_req_post(req, ev); 3369 } 3370 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus_done, req); 3371 return req; 3372} 3373 3374static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq) 3375{ 3376 struct tevent_req *req = tevent_req_callback_data( 3377 subreq, struct tevent_req); 3378 struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data( 3379 req, struct rpccli_wkssvc_NetrGetJoinableOus_state); 3380 NTSTATUS status; 3381 TALLOC_CTX *mem_ctx; 3382 3383 if (state->out_mem_ctx) { 3384 mem_ctx = state->out_mem_ctx; 3385 } else { 3386 mem_ctx = state; 3387 } 3388 3389 status = state->dispatch_recv(subreq, mem_ctx); 3390 TALLOC_FREE(subreq); 3391 if (!NT_STATUS_IS_OK(status)) { 3392 tevent_req_nterror(req, status); 3393 return; 3394 } 3395 3396 /* Copy out parameters */ 3397 *state->orig.out.num_ous = *state->tmp.out.num_ous; 3398 *state->orig.out.ous = *state->tmp.out.ous; 3399 3400 /* Copy result */ 3401 state->orig.out.result = state->tmp.out.result; 3402 3403 /* Reset temporary structure */ 3404 ZERO_STRUCT(state->tmp); 3405 3406 tevent_req_done(req); 3407} 3408 3409NTSTATUS rpccli_wkssvc_NetrGetJoinableOus_recv(struct tevent_req *req, 3410 TALLOC_CTX *mem_ctx, 3411 WERROR *result) 3412{ 3413 struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data( 3414 req, struct rpccli_wkssvc_NetrGetJoinableOus_state); 3415 NTSTATUS status; 3416 3417 if (tevent_req_is_nterror(req, &status)) { 3418 tevent_req_received(req); 3419 return status; 3420 } 3421 3422 /* Steal possbile out parameters to the callers context */ 3423 talloc_steal(mem_ctx, state->out_mem_ctx); 3424 3425 /* Return result */ 3426 *result = state->orig.out.result; 3427 3428 tevent_req_received(req); 3429 return NT_STATUS_OK; 3430} 3431 3432NTSTATUS rpccli_wkssvc_NetrGetJoinableOus(struct rpc_pipe_client *cli, 3433 TALLOC_CTX *mem_ctx, 3434 const char *server_name /* [in] [unique,charset(UTF16)] */, 3435 const char *domain_name /* [in] [ref,charset(UTF16)] */, 3436 const char *Account /* [in] [unique,charset(UTF16)] */, 3437 const char *unknown /* [in] [unique,charset(UTF16)] */, 3438 uint32_t *num_ous /* [in,out] [ref] */, 3439 const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */, 3440 WERROR *werror) 3441{ 3442 struct wkssvc_NetrGetJoinableOus r; 3443 NTSTATUS status; 3444 3445 /* In parameters */ 3446 r.in.server_name = server_name; 3447 r.in.domain_name = domain_name; 3448 r.in.Account = Account; 3449 r.in.unknown = unknown; 3450 r.in.num_ous = num_ous; 3451 3452 status = cli->dispatch(cli, 3453 mem_ctx, 3454 &ndr_table_wkssvc, 3455 NDR_WKSSVC_NETRGETJOINABLEOUS, 3456 &r); 3457 3458 if (!NT_STATUS_IS_OK(status)) { 3459 return status; 3460 } 3461 3462 if (NT_STATUS_IS_ERR(status)) { 3463 return status; 3464 } 3465 3466 /* Return variables */ 3467 *num_ous = *r.out.num_ous; 3468 *ous = *r.out.ous; 3469 3470 /* Return result */ 3471 if (werror) { 3472 *werror = r.out.result; 3473 } 3474 3475 return werror_to_ntstatus(r.out.result); 3476} 3477 3478struct rpccli_wkssvc_NetrJoinDomain2_state { 3479 struct wkssvc_NetrJoinDomain2 orig; 3480 struct wkssvc_NetrJoinDomain2 tmp; 3481 TALLOC_CTX *out_mem_ctx; 3482 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3483}; 3484 3485static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq); 3486 3487struct tevent_req *rpccli_wkssvc_NetrJoinDomain2_send(TALLOC_CTX *mem_ctx, 3488 struct tevent_context *ev, 3489 struct rpc_pipe_client *cli, 3490 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3491 const char *_domain_name /* [in] [ref,charset(UTF16)] */, 3492 const char *_account_ou /* [in] [unique,charset(UTF16)] */, 3493 const char *_admin_account /* [in] [unique,charset(UTF16)] */, 3494 struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */, 3495 uint32_t _join_flags /* [in] */) 3496{ 3497 struct tevent_req *req; 3498 struct rpccli_wkssvc_NetrJoinDomain2_state *state; 3499 struct tevent_req *subreq; 3500 3501 req = tevent_req_create(mem_ctx, &state, 3502 struct rpccli_wkssvc_NetrJoinDomain2_state); 3503 if (req == NULL) { 3504 return NULL; 3505 } 3506 state->out_mem_ctx = NULL; 3507 state->dispatch_recv = cli->dispatch_recv; 3508 3509 /* In parameters */ 3510 state->orig.in.server_name = _server_name; 3511 state->orig.in.domain_name = _domain_name; 3512 state->orig.in.account_ou = _account_ou; 3513 state->orig.in.admin_account = _admin_account; 3514 state->orig.in.encrypted_password = _encrypted_password; 3515 state->orig.in.join_flags = _join_flags; 3516 3517 /* Out parameters */ 3518 3519 /* Result */ 3520 ZERO_STRUCT(state->orig.out.result); 3521 3522 /* make a temporary copy, that we pass to the dispatch function */ 3523 state->tmp = state->orig; 3524 3525 subreq = cli->dispatch_send(state, ev, cli, 3526 &ndr_table_wkssvc, 3527 NDR_WKSSVC_NETRJOINDOMAIN2, 3528 &state->tmp); 3529 if (tevent_req_nomem(subreq, req)) { 3530 return tevent_req_post(req, ev); 3531 } 3532 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain2_done, req); 3533 return req; 3534} 3535 3536static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq) 3537{ 3538 struct tevent_req *req = tevent_req_callback_data( 3539 subreq, struct tevent_req); 3540 struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data( 3541 req, struct rpccli_wkssvc_NetrJoinDomain2_state); 3542 NTSTATUS status; 3543 TALLOC_CTX *mem_ctx; 3544 3545 if (state->out_mem_ctx) { 3546 mem_ctx = state->out_mem_ctx; 3547 } else { 3548 mem_ctx = state; 3549 } 3550 3551 status = state->dispatch_recv(subreq, mem_ctx); 3552 TALLOC_FREE(subreq); 3553 if (!NT_STATUS_IS_OK(status)) { 3554 tevent_req_nterror(req, status); 3555 return; 3556 } 3557 3558 /* Copy out parameters */ 3559 3560 /* Copy result */ 3561 state->orig.out.result = state->tmp.out.result; 3562 3563 /* Reset temporary structure */ 3564 ZERO_STRUCT(state->tmp); 3565 3566 tevent_req_done(req); 3567} 3568 3569NTSTATUS rpccli_wkssvc_NetrJoinDomain2_recv(struct tevent_req *req, 3570 TALLOC_CTX *mem_ctx, 3571 WERROR *result) 3572{ 3573 struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data( 3574 req, struct rpccli_wkssvc_NetrJoinDomain2_state); 3575 NTSTATUS status; 3576 3577 if (tevent_req_is_nterror(req, &status)) { 3578 tevent_req_received(req); 3579 return status; 3580 } 3581 3582 /* Steal possbile out parameters to the callers context */ 3583 talloc_steal(mem_ctx, state->out_mem_ctx); 3584 3585 /* Return result */ 3586 *result = state->orig.out.result; 3587 3588 tevent_req_received(req); 3589 return NT_STATUS_OK; 3590} 3591 3592NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli, 3593 TALLOC_CTX *mem_ctx, 3594 const char *server_name /* [in] [unique,charset(UTF16)] */, 3595 const char *domain_name /* [in] [ref,charset(UTF16)] */, 3596 const char *account_ou /* [in] [unique,charset(UTF16)] */, 3597 const char *admin_account /* [in] [unique,charset(UTF16)] */, 3598 struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */, 3599 uint32_t join_flags /* [in] */, 3600 WERROR *werror) 3601{ 3602 struct wkssvc_NetrJoinDomain2 r; 3603 NTSTATUS status; 3604 3605 /* In parameters */ 3606 r.in.server_name = server_name; 3607 r.in.domain_name = domain_name; 3608 r.in.account_ou = account_ou; 3609 r.in.admin_account = admin_account; 3610 r.in.encrypted_password = encrypted_password; 3611 r.in.join_flags = join_flags; 3612 3613 status = cli->dispatch(cli, 3614 mem_ctx, 3615 &ndr_table_wkssvc, 3616 NDR_WKSSVC_NETRJOINDOMAIN2, 3617 &r); 3618 3619 if (!NT_STATUS_IS_OK(status)) { 3620 return status; 3621 } 3622 3623 if (NT_STATUS_IS_ERR(status)) { 3624 return status; 3625 } 3626 3627 /* Return variables */ 3628 3629 /* Return result */ 3630 if (werror) { 3631 *werror = r.out.result; 3632 } 3633 3634 return werror_to_ntstatus(r.out.result); 3635} 3636 3637struct rpccli_wkssvc_NetrUnjoinDomain2_state { 3638 struct wkssvc_NetrUnjoinDomain2 orig; 3639 struct wkssvc_NetrUnjoinDomain2 tmp; 3640 TALLOC_CTX *out_mem_ctx; 3641 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3642}; 3643 3644static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq); 3645 3646struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain2_send(TALLOC_CTX *mem_ctx, 3647 struct tevent_context *ev, 3648 struct rpc_pipe_client *cli, 3649 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3650 const char *_account /* [in] [unique,charset(UTF16)] */, 3651 struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */, 3652 uint32_t _unjoin_flags /* [in] */) 3653{ 3654 struct tevent_req *req; 3655 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state; 3656 struct tevent_req *subreq; 3657 3658 req = tevent_req_create(mem_ctx, &state, 3659 struct rpccli_wkssvc_NetrUnjoinDomain2_state); 3660 if (req == NULL) { 3661 return NULL; 3662 } 3663 state->out_mem_ctx = NULL; 3664 state->dispatch_recv = cli->dispatch_recv; 3665 3666 /* In parameters */ 3667 state->orig.in.server_name = _server_name; 3668 state->orig.in.account = _account; 3669 state->orig.in.encrypted_password = _encrypted_password; 3670 state->orig.in.unjoin_flags = _unjoin_flags; 3671 3672 /* Out parameters */ 3673 3674 /* Result */ 3675 ZERO_STRUCT(state->orig.out.result); 3676 3677 /* make a temporary copy, that we pass to the dispatch function */ 3678 state->tmp = state->orig; 3679 3680 subreq = cli->dispatch_send(state, ev, cli, 3681 &ndr_table_wkssvc, 3682 NDR_WKSSVC_NETRUNJOINDOMAIN2, 3683 &state->tmp); 3684 if (tevent_req_nomem(subreq, req)) { 3685 return tevent_req_post(req, ev); 3686 } 3687 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain2_done, req); 3688 return req; 3689} 3690 3691static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq) 3692{ 3693 struct tevent_req *req = tevent_req_callback_data( 3694 subreq, struct tevent_req); 3695 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data( 3696 req, struct rpccli_wkssvc_NetrUnjoinDomain2_state); 3697 NTSTATUS status; 3698 TALLOC_CTX *mem_ctx; 3699 3700 if (state->out_mem_ctx) { 3701 mem_ctx = state->out_mem_ctx; 3702 } else { 3703 mem_ctx = state; 3704 } 3705 3706 status = state->dispatch_recv(subreq, mem_ctx); 3707 TALLOC_FREE(subreq); 3708 if (!NT_STATUS_IS_OK(status)) { 3709 tevent_req_nterror(req, status); 3710 return; 3711 } 3712 3713 /* Copy out parameters */ 3714 3715 /* Copy result */ 3716 state->orig.out.result = state->tmp.out.result; 3717 3718 /* Reset temporary structure */ 3719 ZERO_STRUCT(state->tmp); 3720 3721 tevent_req_done(req); 3722} 3723 3724NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2_recv(struct tevent_req *req, 3725 TALLOC_CTX *mem_ctx, 3726 WERROR *result) 3727{ 3728 struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data( 3729 req, struct rpccli_wkssvc_NetrUnjoinDomain2_state); 3730 NTSTATUS status; 3731 3732 if (tevent_req_is_nterror(req, &status)) { 3733 tevent_req_received(req); 3734 return status; 3735 } 3736 3737 /* Steal possbile out parameters to the callers context */ 3738 talloc_steal(mem_ctx, state->out_mem_ctx); 3739 3740 /* Return result */ 3741 *result = state->orig.out.result; 3742 3743 tevent_req_received(req); 3744 return NT_STATUS_OK; 3745} 3746 3747NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2(struct rpc_pipe_client *cli, 3748 TALLOC_CTX *mem_ctx, 3749 const char *server_name /* [in] [unique,charset(UTF16)] */, 3750 const char *account /* [in] [unique,charset(UTF16)] */, 3751 struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */, 3752 uint32_t unjoin_flags /* [in] */, 3753 WERROR *werror) 3754{ 3755 struct wkssvc_NetrUnjoinDomain2 r; 3756 NTSTATUS status; 3757 3758 /* In parameters */ 3759 r.in.server_name = server_name; 3760 r.in.account = account; 3761 r.in.encrypted_password = encrypted_password; 3762 r.in.unjoin_flags = unjoin_flags; 3763 3764 status = cli->dispatch(cli, 3765 mem_ctx, 3766 &ndr_table_wkssvc, 3767 NDR_WKSSVC_NETRUNJOINDOMAIN2, 3768 &r); 3769 3770 if (!NT_STATUS_IS_OK(status)) { 3771 return status; 3772 } 3773 3774 if (NT_STATUS_IS_ERR(status)) { 3775 return status; 3776 } 3777 3778 /* Return variables */ 3779 3780 /* Return result */ 3781 if (werror) { 3782 *werror = r.out.result; 3783 } 3784 3785 return werror_to_ntstatus(r.out.result); 3786} 3787 3788struct rpccli_wkssvc_NetrRenameMachineInDomain2_state { 3789 struct wkssvc_NetrRenameMachineInDomain2 orig; 3790 struct wkssvc_NetrRenameMachineInDomain2 tmp; 3791 TALLOC_CTX *out_mem_ctx; 3792 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3793}; 3794 3795static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq); 3796 3797struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain2_send(TALLOC_CTX *mem_ctx, 3798 struct tevent_context *ev, 3799 struct rpc_pipe_client *cli, 3800 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3801 const char *_NewMachineName /* [in] [unique,charset(UTF16)] */, 3802 const char *_Account /* [in] [unique,charset(UTF16)] */, 3803 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 3804 uint32_t _RenameOptions /* [in] */) 3805{ 3806 struct tevent_req *req; 3807 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state; 3808 struct tevent_req *subreq; 3809 3810 req = tevent_req_create(mem_ctx, &state, 3811 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); 3812 if (req == NULL) { 3813 return NULL; 3814 } 3815 state->out_mem_ctx = NULL; 3816 state->dispatch_recv = cli->dispatch_recv; 3817 3818 /* In parameters */ 3819 state->orig.in.server_name = _server_name; 3820 state->orig.in.NewMachineName = _NewMachineName; 3821 state->orig.in.Account = _Account; 3822 state->orig.in.EncryptedPassword = _EncryptedPassword; 3823 state->orig.in.RenameOptions = _RenameOptions; 3824 3825 /* Out parameters */ 3826 3827 /* Result */ 3828 ZERO_STRUCT(state->orig.out.result); 3829 3830 /* make a temporary copy, that we pass to the dispatch function */ 3831 state->tmp = state->orig; 3832 3833 subreq = cli->dispatch_send(state, ev, cli, 3834 &ndr_table_wkssvc, 3835 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, 3836 &state->tmp); 3837 if (tevent_req_nomem(subreq, req)) { 3838 return tevent_req_post(req, ev); 3839 } 3840 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain2_done, req); 3841 return req; 3842} 3843 3844static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq) 3845{ 3846 struct tevent_req *req = tevent_req_callback_data( 3847 subreq, struct tevent_req); 3848 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data( 3849 req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); 3850 NTSTATUS status; 3851 TALLOC_CTX *mem_ctx; 3852 3853 if (state->out_mem_ctx) { 3854 mem_ctx = state->out_mem_ctx; 3855 } else { 3856 mem_ctx = state; 3857 } 3858 3859 status = state->dispatch_recv(subreq, mem_ctx); 3860 TALLOC_FREE(subreq); 3861 if (!NT_STATUS_IS_OK(status)) { 3862 tevent_req_nterror(req, status); 3863 return; 3864 } 3865 3866 /* Copy out parameters */ 3867 3868 /* Copy result */ 3869 state->orig.out.result = state->tmp.out.result; 3870 3871 /* Reset temporary structure */ 3872 ZERO_STRUCT(state->tmp); 3873 3874 tevent_req_done(req); 3875} 3876 3877NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2_recv(struct tevent_req *req, 3878 TALLOC_CTX *mem_ctx, 3879 WERROR *result) 3880{ 3881 struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data( 3882 req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); 3883 NTSTATUS status; 3884 3885 if (tevent_req_is_nterror(req, &status)) { 3886 tevent_req_received(req); 3887 return status; 3888 } 3889 3890 /* Steal possbile out parameters to the callers context */ 3891 talloc_steal(mem_ctx, state->out_mem_ctx); 3892 3893 /* Return result */ 3894 *result = state->orig.out.result; 3895 3896 tevent_req_received(req); 3897 return NT_STATUS_OK; 3898} 3899 3900NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2(struct rpc_pipe_client *cli, 3901 TALLOC_CTX *mem_ctx, 3902 const char *server_name /* [in] [unique,charset(UTF16)] */, 3903 const char *NewMachineName /* [in] [unique,charset(UTF16)] */, 3904 const char *Account /* [in] [unique,charset(UTF16)] */, 3905 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 3906 uint32_t RenameOptions /* [in] */, 3907 WERROR *werror) 3908{ 3909 struct wkssvc_NetrRenameMachineInDomain2 r; 3910 NTSTATUS status; 3911 3912 /* In parameters */ 3913 r.in.server_name = server_name; 3914 r.in.NewMachineName = NewMachineName; 3915 r.in.Account = Account; 3916 r.in.EncryptedPassword = EncryptedPassword; 3917 r.in.RenameOptions = RenameOptions; 3918 3919 status = cli->dispatch(cli, 3920 mem_ctx, 3921 &ndr_table_wkssvc, 3922 NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, 3923 &r); 3924 3925 if (!NT_STATUS_IS_OK(status)) { 3926 return status; 3927 } 3928 3929 if (NT_STATUS_IS_ERR(status)) { 3930 return status; 3931 } 3932 3933 /* Return variables */ 3934 3935 /* Return result */ 3936 if (werror) { 3937 *werror = r.out.result; 3938 } 3939 3940 return werror_to_ntstatus(r.out.result); 3941} 3942 3943struct rpccli_wkssvc_NetrValidateName2_state { 3944 struct wkssvc_NetrValidateName2 orig; 3945 struct wkssvc_NetrValidateName2 tmp; 3946 TALLOC_CTX *out_mem_ctx; 3947 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 3948}; 3949 3950static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq); 3951 3952struct tevent_req *rpccli_wkssvc_NetrValidateName2_send(TALLOC_CTX *mem_ctx, 3953 struct tevent_context *ev, 3954 struct rpc_pipe_client *cli, 3955 const char *_server_name /* [in] [unique,charset(UTF16)] */, 3956 const char *_name /* [in] [ref,charset(UTF16)] */, 3957 const char *_Account /* [in] [unique,charset(UTF16)] */, 3958 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 3959 enum wkssvc_NetValidateNameType _name_type /* [in] */) 3960{ 3961 struct tevent_req *req; 3962 struct rpccli_wkssvc_NetrValidateName2_state *state; 3963 struct tevent_req *subreq; 3964 3965 req = tevent_req_create(mem_ctx, &state, 3966 struct rpccli_wkssvc_NetrValidateName2_state); 3967 if (req == NULL) { 3968 return NULL; 3969 } 3970 state->out_mem_ctx = NULL; 3971 state->dispatch_recv = cli->dispatch_recv; 3972 3973 /* In parameters */ 3974 state->orig.in.server_name = _server_name; 3975 state->orig.in.name = _name; 3976 state->orig.in.Account = _Account; 3977 state->orig.in.EncryptedPassword = _EncryptedPassword; 3978 state->orig.in.name_type = _name_type; 3979 3980 /* Out parameters */ 3981 3982 /* Result */ 3983 ZERO_STRUCT(state->orig.out.result); 3984 3985 /* make a temporary copy, that we pass to the dispatch function */ 3986 state->tmp = state->orig; 3987 3988 subreq = cli->dispatch_send(state, ev, cli, 3989 &ndr_table_wkssvc, 3990 NDR_WKSSVC_NETRVALIDATENAME2, 3991 &state->tmp); 3992 if (tevent_req_nomem(subreq, req)) { 3993 return tevent_req_post(req, ev); 3994 } 3995 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName2_done, req); 3996 return req; 3997} 3998 3999static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq) 4000{ 4001 struct tevent_req *req = tevent_req_callback_data( 4002 subreq, struct tevent_req); 4003 struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data( 4004 req, struct rpccli_wkssvc_NetrValidateName2_state); 4005 NTSTATUS status; 4006 TALLOC_CTX *mem_ctx; 4007 4008 if (state->out_mem_ctx) { 4009 mem_ctx = state->out_mem_ctx; 4010 } else { 4011 mem_ctx = state; 4012 } 4013 4014 status = state->dispatch_recv(subreq, mem_ctx); 4015 TALLOC_FREE(subreq); 4016 if (!NT_STATUS_IS_OK(status)) { 4017 tevent_req_nterror(req, status); 4018 return; 4019 } 4020 4021 /* Copy out parameters */ 4022 4023 /* Copy result */ 4024 state->orig.out.result = state->tmp.out.result; 4025 4026 /* Reset temporary structure */ 4027 ZERO_STRUCT(state->tmp); 4028 4029 tevent_req_done(req); 4030} 4031 4032NTSTATUS rpccli_wkssvc_NetrValidateName2_recv(struct tevent_req *req, 4033 TALLOC_CTX *mem_ctx, 4034 WERROR *result) 4035{ 4036 struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data( 4037 req, struct rpccli_wkssvc_NetrValidateName2_state); 4038 NTSTATUS status; 4039 4040 if (tevent_req_is_nterror(req, &status)) { 4041 tevent_req_received(req); 4042 return status; 4043 } 4044 4045 /* Steal possbile out parameters to the callers context */ 4046 talloc_steal(mem_ctx, state->out_mem_ctx); 4047 4048 /* Return result */ 4049 *result = state->orig.out.result; 4050 4051 tevent_req_received(req); 4052 return NT_STATUS_OK; 4053} 4054 4055NTSTATUS rpccli_wkssvc_NetrValidateName2(struct rpc_pipe_client *cli, 4056 TALLOC_CTX *mem_ctx, 4057 const char *server_name /* [in] [unique,charset(UTF16)] */, 4058 const char *name /* [in] [ref,charset(UTF16)] */, 4059 const char *Account /* [in] [unique,charset(UTF16)] */, 4060 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 4061 enum wkssvc_NetValidateNameType name_type /* [in] */, 4062 WERROR *werror) 4063{ 4064 struct wkssvc_NetrValidateName2 r; 4065 NTSTATUS status; 4066 4067 /* In parameters */ 4068 r.in.server_name = server_name; 4069 r.in.name = name; 4070 r.in.Account = Account; 4071 r.in.EncryptedPassword = EncryptedPassword; 4072 r.in.name_type = name_type; 4073 4074 status = cli->dispatch(cli, 4075 mem_ctx, 4076 &ndr_table_wkssvc, 4077 NDR_WKSSVC_NETRVALIDATENAME2, 4078 &r); 4079 4080 if (!NT_STATUS_IS_OK(status)) { 4081 return status; 4082 } 4083 4084 if (NT_STATUS_IS_ERR(status)) { 4085 return status; 4086 } 4087 4088 /* Return variables */ 4089 4090 /* Return result */ 4091 if (werror) { 4092 *werror = r.out.result; 4093 } 4094 4095 return werror_to_ntstatus(r.out.result); 4096} 4097 4098struct rpccli_wkssvc_NetrGetJoinableOus2_state { 4099 struct wkssvc_NetrGetJoinableOus2 orig; 4100 struct wkssvc_NetrGetJoinableOus2 tmp; 4101 TALLOC_CTX *out_mem_ctx; 4102 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 4103}; 4104 4105static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq); 4106 4107struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus2_send(TALLOC_CTX *mem_ctx, 4108 struct tevent_context *ev, 4109 struct rpc_pipe_client *cli, 4110 const char *_server_name /* [in] [unique,charset(UTF16)] */, 4111 const char *_domain_name /* [in] [ref,charset(UTF16)] */, 4112 const char *_Account /* [in] [unique,charset(UTF16)] */, 4113 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 4114 uint32_t *_num_ous /* [in,out] [ref] */, 4115 const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */) 4116{ 4117 struct tevent_req *req; 4118 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state; 4119 struct tevent_req *subreq; 4120 4121 req = tevent_req_create(mem_ctx, &state, 4122 struct rpccli_wkssvc_NetrGetJoinableOus2_state); 4123 if (req == NULL) { 4124 return NULL; 4125 } 4126 state->out_mem_ctx = NULL; 4127 state->dispatch_recv = cli->dispatch_recv; 4128 4129 /* In parameters */ 4130 state->orig.in.server_name = _server_name; 4131 state->orig.in.domain_name = _domain_name; 4132 state->orig.in.Account = _Account; 4133 state->orig.in.EncryptedPassword = _EncryptedPassword; 4134 state->orig.in.num_ous = _num_ous; 4135 4136 /* Out parameters */ 4137 state->orig.out.num_ous = _num_ous; 4138 state->orig.out.ous = _ous; 4139 4140 /* Result */ 4141 ZERO_STRUCT(state->orig.out.result); 4142 4143 state->out_mem_ctx = talloc_named_const(state, 0, 4144 "rpccli_wkssvc_NetrGetJoinableOus2_out_memory"); 4145 if (tevent_req_nomem(state->out_mem_ctx, req)) { 4146 return tevent_req_post(req, ev); 4147 } 4148 4149 /* make a temporary copy, that we pass to the dispatch function */ 4150 state->tmp = state->orig; 4151 4152 subreq = cli->dispatch_send(state, ev, cli, 4153 &ndr_table_wkssvc, 4154 NDR_WKSSVC_NETRGETJOINABLEOUS2, 4155 &state->tmp); 4156 if (tevent_req_nomem(subreq, req)) { 4157 return tevent_req_post(req, ev); 4158 } 4159 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus2_done, req); 4160 return req; 4161} 4162 4163static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq) 4164{ 4165 struct tevent_req *req = tevent_req_callback_data( 4166 subreq, struct tevent_req); 4167 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data( 4168 req, struct rpccli_wkssvc_NetrGetJoinableOus2_state); 4169 NTSTATUS status; 4170 TALLOC_CTX *mem_ctx; 4171 4172 if (state->out_mem_ctx) { 4173 mem_ctx = state->out_mem_ctx; 4174 } else { 4175 mem_ctx = state; 4176 } 4177 4178 status = state->dispatch_recv(subreq, mem_ctx); 4179 TALLOC_FREE(subreq); 4180 if (!NT_STATUS_IS_OK(status)) { 4181 tevent_req_nterror(req, status); 4182 return; 4183 } 4184 4185 /* Copy out parameters */ 4186 *state->orig.out.num_ous = *state->tmp.out.num_ous; 4187 *state->orig.out.ous = *state->tmp.out.ous; 4188 4189 /* Copy result */ 4190 state->orig.out.result = state->tmp.out.result; 4191 4192 /* Reset temporary structure */ 4193 ZERO_STRUCT(state->tmp); 4194 4195 tevent_req_done(req); 4196} 4197 4198NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2_recv(struct tevent_req *req, 4199 TALLOC_CTX *mem_ctx, 4200 WERROR *result) 4201{ 4202 struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data( 4203 req, struct rpccli_wkssvc_NetrGetJoinableOus2_state); 4204 NTSTATUS status; 4205 4206 if (tevent_req_is_nterror(req, &status)) { 4207 tevent_req_received(req); 4208 return status; 4209 } 4210 4211 /* Steal possbile out parameters to the callers context */ 4212 talloc_steal(mem_ctx, state->out_mem_ctx); 4213 4214 /* Return result */ 4215 *result = state->orig.out.result; 4216 4217 tevent_req_received(req); 4218 return NT_STATUS_OK; 4219} 4220 4221NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2(struct rpc_pipe_client *cli, 4222 TALLOC_CTX *mem_ctx, 4223 const char *server_name /* [in] [unique,charset(UTF16)] */, 4224 const char *domain_name /* [in] [ref,charset(UTF16)] */, 4225 const char *Account /* [in] [unique,charset(UTF16)] */, 4226 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 4227 uint32_t *num_ous /* [in,out] [ref] */, 4228 const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */, 4229 WERROR *werror) 4230{ 4231 struct wkssvc_NetrGetJoinableOus2 r; 4232 NTSTATUS status; 4233 4234 /* In parameters */ 4235 r.in.server_name = server_name; 4236 r.in.domain_name = domain_name; 4237 r.in.Account = Account; 4238 r.in.EncryptedPassword = EncryptedPassword; 4239 r.in.num_ous = num_ous; 4240 4241 status = cli->dispatch(cli, 4242 mem_ctx, 4243 &ndr_table_wkssvc, 4244 NDR_WKSSVC_NETRGETJOINABLEOUS2, 4245 &r); 4246 4247 if (!NT_STATUS_IS_OK(status)) { 4248 return status; 4249 } 4250 4251 if (NT_STATUS_IS_ERR(status)) { 4252 return status; 4253 } 4254 4255 /* Return variables */ 4256 *num_ous = *r.out.num_ous; 4257 *ous = *r.out.ous; 4258 4259 /* Return result */ 4260 if (werror) { 4261 *werror = r.out.result; 4262 } 4263 4264 return werror_to_ntstatus(r.out.result); 4265} 4266 4267struct rpccli_wkssvc_NetrAddAlternateComputerName_state { 4268 struct wkssvc_NetrAddAlternateComputerName orig; 4269 struct wkssvc_NetrAddAlternateComputerName tmp; 4270 TALLOC_CTX *out_mem_ctx; 4271 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 4272}; 4273 4274static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq); 4275 4276struct tevent_req *rpccli_wkssvc_NetrAddAlternateComputerName_send(TALLOC_CTX *mem_ctx, 4277 struct tevent_context *ev, 4278 struct rpc_pipe_client *cli, 4279 const char *_server_name /* [in] [unique,charset(UTF16)] */, 4280 const char *_NewAlternateMachineName /* [in] [unique,charset(UTF16)] */, 4281 const char *_Account /* [in] [unique,charset(UTF16)] */, 4282 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 4283 uint32_t _Reserved /* [in] */) 4284{ 4285 struct tevent_req *req; 4286 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state; 4287 struct tevent_req *subreq; 4288 4289 req = tevent_req_create(mem_ctx, &state, 4290 struct rpccli_wkssvc_NetrAddAlternateComputerName_state); 4291 if (req == NULL) { 4292 return NULL; 4293 } 4294 state->out_mem_ctx = NULL; 4295 state->dispatch_recv = cli->dispatch_recv; 4296 4297 /* In parameters */ 4298 state->orig.in.server_name = _server_name; 4299 state->orig.in.NewAlternateMachineName = _NewAlternateMachineName; 4300 state->orig.in.Account = _Account; 4301 state->orig.in.EncryptedPassword = _EncryptedPassword; 4302 state->orig.in.Reserved = _Reserved; 4303 4304 /* Out parameters */ 4305 4306 /* Result */ 4307 ZERO_STRUCT(state->orig.out.result); 4308 4309 /* make a temporary copy, that we pass to the dispatch function */ 4310 state->tmp = state->orig; 4311 4312 subreq = cli->dispatch_send(state, ev, cli, 4313 &ndr_table_wkssvc, 4314 NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME, 4315 &state->tmp); 4316 if (tevent_req_nomem(subreq, req)) { 4317 return tevent_req_post(req, ev); 4318 } 4319 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrAddAlternateComputerName_done, req); 4320 return req; 4321} 4322 4323static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq) 4324{ 4325 struct tevent_req *req = tevent_req_callback_data( 4326 subreq, struct tevent_req); 4327 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data( 4328 req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state); 4329 NTSTATUS status; 4330 TALLOC_CTX *mem_ctx; 4331 4332 if (state->out_mem_ctx) { 4333 mem_ctx = state->out_mem_ctx; 4334 } else { 4335 mem_ctx = state; 4336 } 4337 4338 status = state->dispatch_recv(subreq, mem_ctx); 4339 TALLOC_FREE(subreq); 4340 if (!NT_STATUS_IS_OK(status)) { 4341 tevent_req_nterror(req, status); 4342 return; 4343 } 4344 4345 /* Copy out parameters */ 4346 4347 /* Copy result */ 4348 state->orig.out.result = state->tmp.out.result; 4349 4350 /* Reset temporary structure */ 4351 ZERO_STRUCT(state->tmp); 4352 4353 tevent_req_done(req); 4354} 4355 4356NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName_recv(struct tevent_req *req, 4357 TALLOC_CTX *mem_ctx, 4358 WERROR *result) 4359{ 4360 struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data( 4361 req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state); 4362 NTSTATUS status; 4363 4364 if (tevent_req_is_nterror(req, &status)) { 4365 tevent_req_received(req); 4366 return status; 4367 } 4368 4369 /* Steal possbile out parameters to the callers context */ 4370 talloc_steal(mem_ctx, state->out_mem_ctx); 4371 4372 /* Return result */ 4373 *result = state->orig.out.result; 4374 4375 tevent_req_received(req); 4376 return NT_STATUS_OK; 4377} 4378 4379NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName(struct rpc_pipe_client *cli, 4380 TALLOC_CTX *mem_ctx, 4381 const char *server_name /* [in] [unique,charset(UTF16)] */, 4382 const char *NewAlternateMachineName /* [in] [unique,charset(UTF16)] */, 4383 const char *Account /* [in] [unique,charset(UTF16)] */, 4384 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 4385 uint32_t Reserved /* [in] */, 4386 WERROR *werror) 4387{ 4388 struct wkssvc_NetrAddAlternateComputerName r; 4389 NTSTATUS status; 4390 4391 /* In parameters */ 4392 r.in.server_name = server_name; 4393 r.in.NewAlternateMachineName = NewAlternateMachineName; 4394 r.in.Account = Account; 4395 r.in.EncryptedPassword = EncryptedPassword; 4396 r.in.Reserved = Reserved; 4397 4398 status = cli->dispatch(cli, 4399 mem_ctx, 4400 &ndr_table_wkssvc, 4401 NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME, 4402 &r); 4403 4404 if (!NT_STATUS_IS_OK(status)) { 4405 return status; 4406 } 4407 4408 if (NT_STATUS_IS_ERR(status)) { 4409 return status; 4410 } 4411 4412 /* Return variables */ 4413 4414 /* Return result */ 4415 if (werror) { 4416 *werror = r.out.result; 4417 } 4418 4419 return werror_to_ntstatus(r.out.result); 4420} 4421 4422struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state { 4423 struct wkssvc_NetrRemoveAlternateComputerName orig; 4424 struct wkssvc_NetrRemoveAlternateComputerName tmp; 4425 TALLOC_CTX *out_mem_ctx; 4426 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 4427}; 4428 4429static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq); 4430 4431struct tevent_req *rpccli_wkssvc_NetrRemoveAlternateComputerName_send(TALLOC_CTX *mem_ctx, 4432 struct tevent_context *ev, 4433 struct rpc_pipe_client *cli, 4434 const char *_server_name /* [in] [unique,charset(UTF16)] */, 4435 const char *_AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */, 4436 const char *_Account /* [in] [unique,charset(UTF16)] */, 4437 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 4438 uint32_t _Reserved /* [in] */) 4439{ 4440 struct tevent_req *req; 4441 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state; 4442 struct tevent_req *subreq; 4443 4444 req = tevent_req_create(mem_ctx, &state, 4445 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); 4446 if (req == NULL) { 4447 return NULL; 4448 } 4449 state->out_mem_ctx = NULL; 4450 state->dispatch_recv = cli->dispatch_recv; 4451 4452 /* In parameters */ 4453 state->orig.in.server_name = _server_name; 4454 state->orig.in.AlternateMachineNameToRemove = _AlternateMachineNameToRemove; 4455 state->orig.in.Account = _Account; 4456 state->orig.in.EncryptedPassword = _EncryptedPassword; 4457 state->orig.in.Reserved = _Reserved; 4458 4459 /* Out parameters */ 4460 4461 /* Result */ 4462 ZERO_STRUCT(state->orig.out.result); 4463 4464 /* make a temporary copy, that we pass to the dispatch function */ 4465 state->tmp = state->orig; 4466 4467 subreq = cli->dispatch_send(state, ev, cli, 4468 &ndr_table_wkssvc, 4469 NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, 4470 &state->tmp); 4471 if (tevent_req_nomem(subreq, req)) { 4472 return tevent_req_post(req, ev); 4473 } 4474 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRemoveAlternateComputerName_done, req); 4475 return req; 4476} 4477 4478static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq) 4479{ 4480 struct tevent_req *req = tevent_req_callback_data( 4481 subreq, struct tevent_req); 4482 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data( 4483 req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); 4484 NTSTATUS status; 4485 TALLOC_CTX *mem_ctx; 4486 4487 if (state->out_mem_ctx) { 4488 mem_ctx = state->out_mem_ctx; 4489 } else { 4490 mem_ctx = state; 4491 } 4492 4493 status = state->dispatch_recv(subreq, mem_ctx); 4494 TALLOC_FREE(subreq); 4495 if (!NT_STATUS_IS_OK(status)) { 4496 tevent_req_nterror(req, status); 4497 return; 4498 } 4499 4500 /* Copy out parameters */ 4501 4502 /* Copy result */ 4503 state->orig.out.result = state->tmp.out.result; 4504 4505 /* Reset temporary structure */ 4506 ZERO_STRUCT(state->tmp); 4507 4508 tevent_req_done(req); 4509} 4510 4511NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName_recv(struct tevent_req *req, 4512 TALLOC_CTX *mem_ctx, 4513 WERROR *result) 4514{ 4515 struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data( 4516 req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); 4517 NTSTATUS status; 4518 4519 if (tevent_req_is_nterror(req, &status)) { 4520 tevent_req_received(req); 4521 return status; 4522 } 4523 4524 /* Steal possbile out parameters to the callers context */ 4525 talloc_steal(mem_ctx, state->out_mem_ctx); 4526 4527 /* Return result */ 4528 *result = state->orig.out.result; 4529 4530 tevent_req_received(req); 4531 return NT_STATUS_OK; 4532} 4533 4534NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName(struct rpc_pipe_client *cli, 4535 TALLOC_CTX *mem_ctx, 4536 const char *server_name /* [in] [unique,charset(UTF16)] */, 4537 const char *AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */, 4538 const char *Account /* [in] [unique,charset(UTF16)] */, 4539 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 4540 uint32_t Reserved /* [in] */, 4541 WERROR *werror) 4542{ 4543 struct wkssvc_NetrRemoveAlternateComputerName r; 4544 NTSTATUS status; 4545 4546 /* In parameters */ 4547 r.in.server_name = server_name; 4548 r.in.AlternateMachineNameToRemove = AlternateMachineNameToRemove; 4549 r.in.Account = Account; 4550 r.in.EncryptedPassword = EncryptedPassword; 4551 r.in.Reserved = Reserved; 4552 4553 status = cli->dispatch(cli, 4554 mem_ctx, 4555 &ndr_table_wkssvc, 4556 NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, 4557 &r); 4558 4559 if (!NT_STATUS_IS_OK(status)) { 4560 return status; 4561 } 4562 4563 if (NT_STATUS_IS_ERR(status)) { 4564 return status; 4565 } 4566 4567 /* Return variables */ 4568 4569 /* Return result */ 4570 if (werror) { 4571 *werror = r.out.result; 4572 } 4573 4574 return werror_to_ntstatus(r.out.result); 4575} 4576 4577struct rpccli_wkssvc_NetrSetPrimaryComputername_state { 4578 struct wkssvc_NetrSetPrimaryComputername orig; 4579 struct wkssvc_NetrSetPrimaryComputername tmp; 4580 TALLOC_CTX *out_mem_ctx; 4581 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 4582}; 4583 4584static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq); 4585 4586struct tevent_req *rpccli_wkssvc_NetrSetPrimaryComputername_send(TALLOC_CTX *mem_ctx, 4587 struct tevent_context *ev, 4588 struct rpc_pipe_client *cli, 4589 const char *_server_name /* [in] [unique,charset(UTF16)] */, 4590 const char *_primary_name /* [in] [unique,charset(UTF16)] */, 4591 const char *_Account /* [in] [unique,charset(UTF16)] */, 4592 struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, 4593 uint32_t _Reserved /* [in] */) 4594{ 4595 struct tevent_req *req; 4596 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state; 4597 struct tevent_req *subreq; 4598 4599 req = tevent_req_create(mem_ctx, &state, 4600 struct rpccli_wkssvc_NetrSetPrimaryComputername_state); 4601 if (req == NULL) { 4602 return NULL; 4603 } 4604 state->out_mem_ctx = NULL; 4605 state->dispatch_recv = cli->dispatch_recv; 4606 4607 /* In parameters */ 4608 state->orig.in.server_name = _server_name; 4609 state->orig.in.primary_name = _primary_name; 4610 state->orig.in.Account = _Account; 4611 state->orig.in.EncryptedPassword = _EncryptedPassword; 4612 state->orig.in.Reserved = _Reserved; 4613 4614 /* Out parameters */ 4615 4616 /* Result */ 4617 ZERO_STRUCT(state->orig.out.result); 4618 4619 /* make a temporary copy, that we pass to the dispatch function */ 4620 state->tmp = state->orig; 4621 4622 subreq = cli->dispatch_send(state, ev, cli, 4623 &ndr_table_wkssvc, 4624 NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, 4625 &state->tmp); 4626 if (tevent_req_nomem(subreq, req)) { 4627 return tevent_req_post(req, ev); 4628 } 4629 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrSetPrimaryComputername_done, req); 4630 return req; 4631} 4632 4633static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq) 4634{ 4635 struct tevent_req *req = tevent_req_callback_data( 4636 subreq, struct tevent_req); 4637 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data( 4638 req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state); 4639 NTSTATUS status; 4640 TALLOC_CTX *mem_ctx; 4641 4642 if (state->out_mem_ctx) { 4643 mem_ctx = state->out_mem_ctx; 4644 } else { 4645 mem_ctx = state; 4646 } 4647 4648 status = state->dispatch_recv(subreq, mem_ctx); 4649 TALLOC_FREE(subreq); 4650 if (!NT_STATUS_IS_OK(status)) { 4651 tevent_req_nterror(req, status); 4652 return; 4653 } 4654 4655 /* Copy out parameters */ 4656 4657 /* Copy result */ 4658 state->orig.out.result = state->tmp.out.result; 4659 4660 /* Reset temporary structure */ 4661 ZERO_STRUCT(state->tmp); 4662 4663 tevent_req_done(req); 4664} 4665 4666NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername_recv(struct tevent_req *req, 4667 TALLOC_CTX *mem_ctx, 4668 WERROR *result) 4669{ 4670 struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data( 4671 req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state); 4672 NTSTATUS status; 4673 4674 if (tevent_req_is_nterror(req, &status)) { 4675 tevent_req_received(req); 4676 return status; 4677 } 4678 4679 /* Steal possbile out parameters to the callers context */ 4680 talloc_steal(mem_ctx, state->out_mem_ctx); 4681 4682 /* Return result */ 4683 *result = state->orig.out.result; 4684 4685 tevent_req_received(req); 4686 return NT_STATUS_OK; 4687} 4688 4689NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername(struct rpc_pipe_client *cli, 4690 TALLOC_CTX *mem_ctx, 4691 const char *server_name /* [in] [unique,charset(UTF16)] */, 4692 const char *primary_name /* [in] [unique,charset(UTF16)] */, 4693 const char *Account /* [in] [unique,charset(UTF16)] */, 4694 struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */, 4695 uint32_t Reserved /* [in] */, 4696 WERROR *werror) 4697{ 4698 struct wkssvc_NetrSetPrimaryComputername r; 4699 NTSTATUS status; 4700 4701 /* In parameters */ 4702 r.in.server_name = server_name; 4703 r.in.primary_name = primary_name; 4704 r.in.Account = Account; 4705 r.in.EncryptedPassword = EncryptedPassword; 4706 r.in.Reserved = Reserved; 4707 4708 status = cli->dispatch(cli, 4709 mem_ctx, 4710 &ndr_table_wkssvc, 4711 NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, 4712 &r); 4713 4714 if (!NT_STATUS_IS_OK(status)) { 4715 return status; 4716 } 4717 4718 if (NT_STATUS_IS_ERR(status)) { 4719 return status; 4720 } 4721 4722 /* Return variables */ 4723 4724 /* Return result */ 4725 if (werror) { 4726 *werror = r.out.result; 4727 } 4728 4729 return werror_to_ntstatus(r.out.result); 4730} 4731 4732struct rpccli_wkssvc_NetrEnumerateComputerNames_state { 4733 struct wkssvc_NetrEnumerateComputerNames orig; 4734 struct wkssvc_NetrEnumerateComputerNames tmp; 4735 TALLOC_CTX *out_mem_ctx; 4736 NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); 4737}; 4738 4739static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq); 4740 4741struct tevent_req *rpccli_wkssvc_NetrEnumerateComputerNames_send(TALLOC_CTX *mem_ctx, 4742 struct tevent_context *ev, 4743 struct rpc_pipe_client *cli, 4744 const char *_server_name /* [in] [unique,charset(UTF16)] */, 4745 enum wkssvc_ComputerNameType _name_type /* [in] */, 4746 uint32_t _Reserved /* [in] */, 4747 struct wkssvc_ComputerNamesCtr **_ctr /* [out] [ref] */) 4748{ 4749 struct tevent_req *req; 4750 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state; 4751 struct tevent_req *subreq; 4752 4753 req = tevent_req_create(mem_ctx, &state, 4754 struct rpccli_wkssvc_NetrEnumerateComputerNames_state); 4755 if (req == NULL) { 4756 return NULL; 4757 } 4758 state->out_mem_ctx = NULL; 4759 state->dispatch_recv = cli->dispatch_recv; 4760 4761 /* In parameters */ 4762 state->orig.in.server_name = _server_name; 4763 state->orig.in.name_type = _name_type; 4764 state->orig.in.Reserved = _Reserved; 4765 4766 /* Out parameters */ 4767 state->orig.out.ctr = _ctr; 4768 4769 /* Result */ 4770 ZERO_STRUCT(state->orig.out.result); 4771 4772 state->out_mem_ctx = talloc_named_const(state, 0, 4773 "rpccli_wkssvc_NetrEnumerateComputerNames_out_memory"); 4774 if (tevent_req_nomem(state->out_mem_ctx, req)) { 4775 return tevent_req_post(req, ev); 4776 } 4777 4778 /* make a temporary copy, that we pass to the dispatch function */ 4779 state->tmp = state->orig; 4780 4781 subreq = cli->dispatch_send(state, ev, cli, 4782 &ndr_table_wkssvc, 4783 NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES, 4784 &state->tmp); 4785 if (tevent_req_nomem(subreq, req)) { 4786 return tevent_req_post(req, ev); 4787 } 4788 tevent_req_set_callback(subreq, rpccli_wkssvc_NetrEnumerateComputerNames_done, req); 4789 return req; 4790} 4791 4792static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq) 4793{ 4794 struct tevent_req *req = tevent_req_callback_data( 4795 subreq, struct tevent_req); 4796 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data( 4797 req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state); 4798 NTSTATUS status; 4799 TALLOC_CTX *mem_ctx; 4800 4801 if (state->out_mem_ctx) { 4802 mem_ctx = state->out_mem_ctx; 4803 } else { 4804 mem_ctx = state; 4805 } 4806 4807 status = state->dispatch_recv(subreq, mem_ctx); 4808 TALLOC_FREE(subreq); 4809 if (!NT_STATUS_IS_OK(status)) { 4810 tevent_req_nterror(req, status); 4811 return; 4812 } 4813 4814 /* Copy out parameters */ 4815 *state->orig.out.ctr = *state->tmp.out.ctr; 4816 4817 /* Copy result */ 4818 state->orig.out.result = state->tmp.out.result; 4819 4820 /* Reset temporary structure */ 4821 ZERO_STRUCT(state->tmp); 4822 4823 tevent_req_done(req); 4824} 4825 4826NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames_recv(struct tevent_req *req, 4827 TALLOC_CTX *mem_ctx, 4828 WERROR *result) 4829{ 4830 struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data( 4831 req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state); 4832 NTSTATUS status; 4833 4834 if (tevent_req_is_nterror(req, &status)) { 4835 tevent_req_received(req); 4836 return status; 4837 } 4838 4839 /* Steal possbile out parameters to the callers context */ 4840 talloc_steal(mem_ctx, state->out_mem_ctx); 4841 4842 /* Return result */ 4843 *result = state->orig.out.result; 4844 4845 tevent_req_received(req); 4846 return NT_STATUS_OK; 4847} 4848 4849NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames(struct rpc_pipe_client *cli, 4850 TALLOC_CTX *mem_ctx, 4851 const char *server_name /* [in] [unique,charset(UTF16)] */, 4852 enum wkssvc_ComputerNameType name_type /* [in] */, 4853 uint32_t Reserved /* [in] */, 4854 struct wkssvc_ComputerNamesCtr **ctr /* [out] [ref] */, 4855 WERROR *werror) 4856{ 4857 struct wkssvc_NetrEnumerateComputerNames r; 4858 NTSTATUS status; 4859 4860 /* In parameters */ 4861 r.in.server_name = server_name; 4862 r.in.name_type = name_type; 4863 r.in.Reserved = Reserved; 4864 4865 status = cli->dispatch(cli, 4866 mem_ctx, 4867 &ndr_table_wkssvc, 4868 NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES, 4869 &r); 4870 4871 if (!NT_STATUS_IS_OK(status)) { 4872 return status; 4873 } 4874 4875 if (NT_STATUS_IS_ERR(status)) { 4876 return status; 4877 } 4878 4879 /* Return variables */ 4880 *ctr = *r.out.ctr; 4881 4882 /* Return result */ 4883 if (werror) { 4884 *werror = r.out.result; 4885 } 4886 4887 return werror_to_ntstatus(r.out.result); 4888} 4889 4890