00001
00002
00003
00004
00005
00006 #include "includes.h"
00007 #include "librpc/gen_ndr/srv_wkssvc.h"
00008
00009 static BOOL api_wkssvc_NetWkstaGetInfo(pipes_struct *p)
00010 {
00011 struct ndr_pull *pull;
00012 struct ndr_push *push;
00013 NTSTATUS status;
00014 DATA_BLOB blob;
00015 struct wkssvc_NetWkstaGetInfo r;
00016 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaGetInfo");
00017
00018 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00019 talloc_free(mem_ctx);
00020 return False;
00021 }
00022
00023 pull = ndr_pull_init_blob(&blob, mem_ctx);
00024 if (pull == NULL) {
00025 talloc_free(mem_ctx);
00026 return False;
00027 }
00028
00029 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00030 status = ndr_pull_wkssvc_NetWkstaGetInfo(pull, NDR_IN, &r);
00031 if (NT_STATUS_IS_ERR(status)) {
00032 talloc_free(mem_ctx);
00033 return False;
00034 }
00035
00036 if (DEBUGLEVEL >= 10)
00037 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, &r);
00038
00039 ZERO_STRUCT(r.out);
00040 r.out.info = talloc_zero(mem_ctx, union wkssvc_NetWkstaInfo);
00041 if (r.out.info == NULL) {
00042 talloc_free(mem_ctx);
00043 return False;
00044 }
00045
00046 r.out.result = _wkssvc_NetWkstaGetInfo(p, &r);
00047
00048 if (p->rng_fault_state) {
00049 talloc_free(mem_ctx);
00050
00051 return True;
00052 }
00053
00054 if (DEBUGLEVEL >= 10)
00055 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, &r);
00056
00057 push = ndr_push_init_ctx(mem_ctx);
00058 if (push == NULL) {
00059 talloc_free(mem_ctx);
00060 return False;
00061 }
00062
00063 status = ndr_push_wkssvc_NetWkstaGetInfo(push, NDR_OUT, &r);
00064 if (NT_STATUS_IS_ERR(status)) {
00065 talloc_free(mem_ctx);
00066 return False;
00067 }
00068
00069 blob = ndr_push_blob(push);
00070 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00071 talloc_free(mem_ctx);
00072 return False;
00073 }
00074
00075 talloc_free(mem_ctx);
00076
00077 return True;
00078 }
00079
00080 static BOOL api_wkssvc_NetWkstaSetInfo(pipes_struct *p)
00081 {
00082 struct ndr_pull *pull;
00083 struct ndr_push *push;
00084 NTSTATUS status;
00085 DATA_BLOB blob;
00086 struct wkssvc_NetWkstaSetInfo r;
00087 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaSetInfo");
00088
00089 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00090 talloc_free(mem_ctx);
00091 return False;
00092 }
00093
00094 pull = ndr_pull_init_blob(&blob, mem_ctx);
00095 if (pull == NULL) {
00096 talloc_free(mem_ctx);
00097 return False;
00098 }
00099
00100 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00101 status = ndr_pull_wkssvc_NetWkstaSetInfo(pull, NDR_IN, &r);
00102 if (NT_STATUS_IS_ERR(status)) {
00103 talloc_free(mem_ctx);
00104 return False;
00105 }
00106
00107 if (DEBUGLEVEL >= 10)
00108 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, &r);
00109
00110 ZERO_STRUCT(r.out);
00111 r.out.parm_error = r.in.parm_error;
00112 r.out.result = _wkssvc_NetWkstaSetInfo(p, &r);
00113
00114 if (p->rng_fault_state) {
00115 talloc_free(mem_ctx);
00116
00117 return True;
00118 }
00119
00120 if (DEBUGLEVEL >= 10)
00121 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &r);
00122
00123 push = ndr_push_init_ctx(mem_ctx);
00124 if (push == NULL) {
00125 talloc_free(mem_ctx);
00126 return False;
00127 }
00128
00129 status = ndr_push_wkssvc_NetWkstaSetInfo(push, NDR_OUT, &r);
00130 if (NT_STATUS_IS_ERR(status)) {
00131 talloc_free(mem_ctx);
00132 return False;
00133 }
00134
00135 blob = ndr_push_blob(push);
00136 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00137 talloc_free(mem_ctx);
00138 return False;
00139 }
00140
00141 talloc_free(mem_ctx);
00142
00143 return True;
00144 }
00145
00146 static BOOL api_wkssvc_NetWkstaEnumUsers(pipes_struct *p)
00147 {
00148 struct ndr_pull *pull;
00149 struct ndr_push *push;
00150 NTSTATUS status;
00151 DATA_BLOB blob;
00152 struct wkssvc_NetWkstaEnumUsers r;
00153 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaEnumUsers");
00154
00155 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00156 talloc_free(mem_ctx);
00157 return False;
00158 }
00159
00160 pull = ndr_pull_init_blob(&blob, mem_ctx);
00161 if (pull == NULL) {
00162 talloc_free(mem_ctx);
00163 return False;
00164 }
00165
00166 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00167 status = ndr_pull_wkssvc_NetWkstaEnumUsers(pull, NDR_IN, &r);
00168 if (NT_STATUS_IS_ERR(status)) {
00169 talloc_free(mem_ctx);
00170 return False;
00171 }
00172
00173 if (DEBUGLEVEL >= 10)
00174 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
00175
00176 ZERO_STRUCT(r.out);
00177 r.out.users = r.in.users;
00178 r.out.entriesread = talloc_zero(mem_ctx, uint32_t);
00179 if (r.out.entriesread == NULL) {
00180 talloc_free(mem_ctx);
00181 return False;
00182 }
00183
00184 r.out.totalentries = talloc_zero(mem_ctx, uint32_t);
00185 if (r.out.totalentries == NULL) {
00186 talloc_free(mem_ctx);
00187 return False;
00188 }
00189
00190 r.out.resumehandle = r.in.resumehandle;
00191 r.out.result = _wkssvc_NetWkstaEnumUsers(p, &r);
00192
00193 if (p->rng_fault_state) {
00194 talloc_free(mem_ctx);
00195
00196 return True;
00197 }
00198
00199 if (DEBUGLEVEL >= 10)
00200 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
00201
00202 push = ndr_push_init_ctx(mem_ctx);
00203 if (push == NULL) {
00204 talloc_free(mem_ctx);
00205 return False;
00206 }
00207
00208 status = ndr_push_wkssvc_NetWkstaEnumUsers(push, NDR_OUT, &r);
00209 if (NT_STATUS_IS_ERR(status)) {
00210 talloc_free(mem_ctx);
00211 return False;
00212 }
00213
00214 blob = ndr_push_blob(push);
00215 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00216 talloc_free(mem_ctx);
00217 return False;
00218 }
00219
00220 talloc_free(mem_ctx);
00221
00222 return True;
00223 }
00224
00225 static BOOL api_WKSSVC_NETRWKSTAUSERGETINFO(pipes_struct *p)
00226 {
00227 struct ndr_pull *pull;
00228 struct ndr_push *push;
00229 NTSTATUS status;
00230 DATA_BLOB blob;
00231 struct WKSSVC_NETRWKSTAUSERGETINFO r;
00232 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTAUSERGETINFO");
00233
00234 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00235 talloc_free(mem_ctx);
00236 return False;
00237 }
00238
00239 pull = ndr_pull_init_blob(&blob, mem_ctx);
00240 if (pull == NULL) {
00241 talloc_free(mem_ctx);
00242 return False;
00243 }
00244
00245 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00246 status = ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO(pull, NDR_IN, &r);
00247 if (NT_STATUS_IS_ERR(status)) {
00248 talloc_free(mem_ctx);
00249 return False;
00250 }
00251
00252 if (DEBUGLEVEL >= 10)
00253 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
00254
00255 r.out.result = _WKSSVC_NETRWKSTAUSERGETINFO(p, &r);
00256
00257 if (p->rng_fault_state) {
00258 talloc_free(mem_ctx);
00259
00260 return True;
00261 }
00262
00263 if (DEBUGLEVEL >= 10)
00264 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
00265
00266 push = ndr_push_init_ctx(mem_ctx);
00267 if (push == NULL) {
00268 talloc_free(mem_ctx);
00269 return False;
00270 }
00271
00272 status = ndr_push_WKSSVC_NETRWKSTAUSERGETINFO(push, NDR_OUT, &r);
00273 if (NT_STATUS_IS_ERR(status)) {
00274 talloc_free(mem_ctx);
00275 return False;
00276 }
00277
00278 blob = ndr_push_blob(push);
00279 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00280 talloc_free(mem_ctx);
00281 return False;
00282 }
00283
00284 talloc_free(mem_ctx);
00285
00286 return True;
00287 }
00288
00289 static BOOL api_WKSSVC_NETRWKSTAUSERSETINFO(pipes_struct *p)
00290 {
00291 struct ndr_pull *pull;
00292 struct ndr_push *push;
00293 NTSTATUS status;
00294 DATA_BLOB blob;
00295 struct WKSSVC_NETRWKSTAUSERSETINFO r;
00296 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTAUSERSETINFO");
00297
00298 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00299 talloc_free(mem_ctx);
00300 return False;
00301 }
00302
00303 pull = ndr_pull_init_blob(&blob, mem_ctx);
00304 if (pull == NULL) {
00305 talloc_free(mem_ctx);
00306 return False;
00307 }
00308
00309 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00310 status = ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO(pull, NDR_IN, &r);
00311 if (NT_STATUS_IS_ERR(status)) {
00312 talloc_free(mem_ctx);
00313 return False;
00314 }
00315
00316 if (DEBUGLEVEL >= 10)
00317 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
00318
00319 r.out.result = _WKSSVC_NETRWKSTAUSERSETINFO(p, &r);
00320
00321 if (p->rng_fault_state) {
00322 talloc_free(mem_ctx);
00323
00324 return True;
00325 }
00326
00327 if (DEBUGLEVEL >= 10)
00328 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
00329
00330 push = ndr_push_init_ctx(mem_ctx);
00331 if (push == NULL) {
00332 talloc_free(mem_ctx);
00333 return False;
00334 }
00335
00336 status = ndr_push_WKSSVC_NETRWKSTAUSERSETINFO(push, NDR_OUT, &r);
00337 if (NT_STATUS_IS_ERR(status)) {
00338 talloc_free(mem_ctx);
00339 return False;
00340 }
00341
00342 blob = ndr_push_blob(push);
00343 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00344 talloc_free(mem_ctx);
00345 return False;
00346 }
00347
00348 talloc_free(mem_ctx);
00349
00350 return True;
00351 }
00352
00353 static BOOL api_wkssvc_NetWkstaTransportEnum(pipes_struct *p)
00354 {
00355 struct ndr_pull *pull;
00356 struct ndr_push *push;
00357 NTSTATUS status;
00358 DATA_BLOB blob;
00359 struct wkssvc_NetWkstaTransportEnum r;
00360 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetWkstaTransportEnum");
00361
00362 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00363 talloc_free(mem_ctx);
00364 return False;
00365 }
00366
00367 pull = ndr_pull_init_blob(&blob, mem_ctx);
00368 if (pull == NULL) {
00369 talloc_free(mem_ctx);
00370 return False;
00371 }
00372
00373 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00374 status = ndr_pull_wkssvc_NetWkstaTransportEnum(pull, NDR_IN, &r);
00375 if (NT_STATUS_IS_ERR(status)) {
00376 talloc_free(mem_ctx);
00377 return False;
00378 }
00379
00380 if (DEBUGLEVEL >= 10)
00381 NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
00382
00383 ZERO_STRUCT(r.out);
00384 r.out.level = r.in.level;
00385 r.out.ctr = r.in.ctr;
00386 r.out.totalentries = talloc_zero(mem_ctx, uint32_t);
00387 if (r.out.totalentries == NULL) {
00388 talloc_free(mem_ctx);
00389 return False;
00390 }
00391
00392 r.out.resume_handle = r.in.resume_handle;
00393 r.out.result = _wkssvc_NetWkstaTransportEnum(p, &r);
00394
00395 if (p->rng_fault_state) {
00396 talloc_free(mem_ctx);
00397
00398 return True;
00399 }
00400
00401 if (DEBUGLEVEL >= 10)
00402 NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
00403
00404 push = ndr_push_init_ctx(mem_ctx);
00405 if (push == NULL) {
00406 talloc_free(mem_ctx);
00407 return False;
00408 }
00409
00410 status = ndr_push_wkssvc_NetWkstaTransportEnum(push, NDR_OUT, &r);
00411 if (NT_STATUS_IS_ERR(status)) {
00412 talloc_free(mem_ctx);
00413 return False;
00414 }
00415
00416 blob = ndr_push_blob(push);
00417 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00418 talloc_free(mem_ctx);
00419 return False;
00420 }
00421
00422 talloc_free(mem_ctx);
00423
00424 return True;
00425 }
00426
00427 static BOOL api_WKSSVC_NETRWKSTATRANSPORTADD(pipes_struct *p)
00428 {
00429 struct ndr_pull *pull;
00430 struct ndr_push *push;
00431 NTSTATUS status;
00432 DATA_BLOB blob;
00433 struct WKSSVC_NETRWKSTATRANSPORTADD r;
00434 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTATRANSPORTADD");
00435
00436 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00437 talloc_free(mem_ctx);
00438 return False;
00439 }
00440
00441 pull = ndr_pull_init_blob(&blob, mem_ctx);
00442 if (pull == NULL) {
00443 talloc_free(mem_ctx);
00444 return False;
00445 }
00446
00447 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00448 status = ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD(pull, NDR_IN, &r);
00449 if (NT_STATUS_IS_ERR(status)) {
00450 talloc_free(mem_ctx);
00451 return False;
00452 }
00453
00454 if (DEBUGLEVEL >= 10)
00455 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
00456
00457 r.out.result = _WKSSVC_NETRWKSTATRANSPORTADD(p, &r);
00458
00459 if (p->rng_fault_state) {
00460 talloc_free(mem_ctx);
00461
00462 return True;
00463 }
00464
00465 if (DEBUGLEVEL >= 10)
00466 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
00467
00468 push = ndr_push_init_ctx(mem_ctx);
00469 if (push == NULL) {
00470 talloc_free(mem_ctx);
00471 return False;
00472 }
00473
00474 status = ndr_push_WKSSVC_NETRWKSTATRANSPORTADD(push, NDR_OUT, &r);
00475 if (NT_STATUS_IS_ERR(status)) {
00476 talloc_free(mem_ctx);
00477 return False;
00478 }
00479
00480 blob = ndr_push_blob(push);
00481 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00482 talloc_free(mem_ctx);
00483 return False;
00484 }
00485
00486 talloc_free(mem_ctx);
00487
00488 return True;
00489 }
00490
00491 static BOOL api_WKSSVC_NETRWKSTATRANSPORTDEL(pipes_struct *p)
00492 {
00493 struct ndr_pull *pull;
00494 struct ndr_push *push;
00495 NTSTATUS status;
00496 DATA_BLOB blob;
00497 struct WKSSVC_NETRWKSTATRANSPORTDEL r;
00498 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWKSTATRANSPORTDEL");
00499
00500 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00501 talloc_free(mem_ctx);
00502 return False;
00503 }
00504
00505 pull = ndr_pull_init_blob(&blob, mem_ctx);
00506 if (pull == NULL) {
00507 talloc_free(mem_ctx);
00508 return False;
00509 }
00510
00511 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00512 status = ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL(pull, NDR_IN, &r);
00513 if (NT_STATUS_IS_ERR(status)) {
00514 talloc_free(mem_ctx);
00515 return False;
00516 }
00517
00518 if (DEBUGLEVEL >= 10)
00519 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
00520
00521 r.out.result = _WKSSVC_NETRWKSTATRANSPORTDEL(p, &r);
00522
00523 if (p->rng_fault_state) {
00524 talloc_free(mem_ctx);
00525
00526 return True;
00527 }
00528
00529 if (DEBUGLEVEL >= 10)
00530 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
00531
00532 push = ndr_push_init_ctx(mem_ctx);
00533 if (push == NULL) {
00534 talloc_free(mem_ctx);
00535 return False;
00536 }
00537
00538 status = ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL(push, NDR_OUT, &r);
00539 if (NT_STATUS_IS_ERR(status)) {
00540 talloc_free(mem_ctx);
00541 return False;
00542 }
00543
00544 blob = ndr_push_blob(push);
00545 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00546 talloc_free(mem_ctx);
00547 return False;
00548 }
00549
00550 talloc_free(mem_ctx);
00551
00552 return True;
00553 }
00554
00555 static BOOL api_WKSSVC_NETRUSEADD(pipes_struct *p)
00556 {
00557 struct ndr_pull *pull;
00558 struct ndr_push *push;
00559 NTSTATUS status;
00560 DATA_BLOB blob;
00561 struct WKSSVC_NETRUSEADD r;
00562 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEADD");
00563
00564 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00565 talloc_free(mem_ctx);
00566 return False;
00567 }
00568
00569 pull = ndr_pull_init_blob(&blob, mem_ctx);
00570 if (pull == NULL) {
00571 talloc_free(mem_ctx);
00572 return False;
00573 }
00574
00575 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00576 status = ndr_pull_WKSSVC_NETRUSEADD(pull, NDR_IN, &r);
00577 if (NT_STATUS_IS_ERR(status)) {
00578 talloc_free(mem_ctx);
00579 return False;
00580 }
00581
00582 if (DEBUGLEVEL >= 10)
00583 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEADD, &r);
00584
00585 r.out.result = _WKSSVC_NETRUSEADD(p, &r);
00586
00587 if (p->rng_fault_state) {
00588 talloc_free(mem_ctx);
00589
00590 return True;
00591 }
00592
00593 if (DEBUGLEVEL >= 10)
00594 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEADD, &r);
00595
00596 push = ndr_push_init_ctx(mem_ctx);
00597 if (push == NULL) {
00598 talloc_free(mem_ctx);
00599 return False;
00600 }
00601
00602 status = ndr_push_WKSSVC_NETRUSEADD(push, NDR_OUT, &r);
00603 if (NT_STATUS_IS_ERR(status)) {
00604 talloc_free(mem_ctx);
00605 return False;
00606 }
00607
00608 blob = ndr_push_blob(push);
00609 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00610 talloc_free(mem_ctx);
00611 return False;
00612 }
00613
00614 talloc_free(mem_ctx);
00615
00616 return True;
00617 }
00618
00619 static BOOL api_WKSSVC_NETRUSEGETINFO(pipes_struct *p)
00620 {
00621 struct ndr_pull *pull;
00622 struct ndr_push *push;
00623 NTSTATUS status;
00624 DATA_BLOB blob;
00625 struct WKSSVC_NETRUSEGETINFO r;
00626 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEGETINFO");
00627
00628 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00629 talloc_free(mem_ctx);
00630 return False;
00631 }
00632
00633 pull = ndr_pull_init_blob(&blob, mem_ctx);
00634 if (pull == NULL) {
00635 talloc_free(mem_ctx);
00636 return False;
00637 }
00638
00639 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00640 status = ndr_pull_WKSSVC_NETRUSEGETINFO(pull, NDR_IN, &r);
00641 if (NT_STATUS_IS_ERR(status)) {
00642 talloc_free(mem_ctx);
00643 return False;
00644 }
00645
00646 if (DEBUGLEVEL >= 10)
00647 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
00648
00649 r.out.result = _WKSSVC_NETRUSEGETINFO(p, &r);
00650
00651 if (p->rng_fault_state) {
00652 talloc_free(mem_ctx);
00653
00654 return True;
00655 }
00656
00657 if (DEBUGLEVEL >= 10)
00658 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
00659
00660 push = ndr_push_init_ctx(mem_ctx);
00661 if (push == NULL) {
00662 talloc_free(mem_ctx);
00663 return False;
00664 }
00665
00666 status = ndr_push_WKSSVC_NETRUSEGETINFO(push, NDR_OUT, &r);
00667 if (NT_STATUS_IS_ERR(status)) {
00668 talloc_free(mem_ctx);
00669 return False;
00670 }
00671
00672 blob = ndr_push_blob(push);
00673 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00674 talloc_free(mem_ctx);
00675 return False;
00676 }
00677
00678 talloc_free(mem_ctx);
00679
00680 return True;
00681 }
00682
00683 static BOOL api_WKSSVC_NETRUSEDEL(pipes_struct *p)
00684 {
00685 struct ndr_pull *pull;
00686 struct ndr_push *push;
00687 NTSTATUS status;
00688 DATA_BLOB blob;
00689 struct WKSSVC_NETRUSEDEL r;
00690 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEDEL");
00691
00692 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00693 talloc_free(mem_ctx);
00694 return False;
00695 }
00696
00697 pull = ndr_pull_init_blob(&blob, mem_ctx);
00698 if (pull == NULL) {
00699 talloc_free(mem_ctx);
00700 return False;
00701 }
00702
00703 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00704 status = ndr_pull_WKSSVC_NETRUSEDEL(pull, NDR_IN, &r);
00705 if (NT_STATUS_IS_ERR(status)) {
00706 talloc_free(mem_ctx);
00707 return False;
00708 }
00709
00710 if (DEBUGLEVEL >= 10)
00711 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEDEL, &r);
00712
00713 r.out.result = _WKSSVC_NETRUSEDEL(p, &r);
00714
00715 if (p->rng_fault_state) {
00716 talloc_free(mem_ctx);
00717
00718 return True;
00719 }
00720
00721 if (DEBUGLEVEL >= 10)
00722 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEDEL, &r);
00723
00724 push = ndr_push_init_ctx(mem_ctx);
00725 if (push == NULL) {
00726 talloc_free(mem_ctx);
00727 return False;
00728 }
00729
00730 status = ndr_push_WKSSVC_NETRUSEDEL(push, NDR_OUT, &r);
00731 if (NT_STATUS_IS_ERR(status)) {
00732 talloc_free(mem_ctx);
00733 return False;
00734 }
00735
00736 blob = ndr_push_blob(push);
00737 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00738 talloc_free(mem_ctx);
00739 return False;
00740 }
00741
00742 talloc_free(mem_ctx);
00743
00744 return True;
00745 }
00746
00747 static BOOL api_WKSSVC_NETRUSEENUM(pipes_struct *p)
00748 {
00749 struct ndr_pull *pull;
00750 struct ndr_push *push;
00751 NTSTATUS status;
00752 DATA_BLOB blob;
00753 struct WKSSVC_NETRUSEENUM r;
00754 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUSEENUM");
00755
00756 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00757 talloc_free(mem_ctx);
00758 return False;
00759 }
00760
00761 pull = ndr_pull_init_blob(&blob, mem_ctx);
00762 if (pull == NULL) {
00763 talloc_free(mem_ctx);
00764 return False;
00765 }
00766
00767 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00768 status = ndr_pull_WKSSVC_NETRUSEENUM(pull, NDR_IN, &r);
00769 if (NT_STATUS_IS_ERR(status)) {
00770 talloc_free(mem_ctx);
00771 return False;
00772 }
00773
00774 if (DEBUGLEVEL >= 10)
00775 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEENUM, &r);
00776
00777 r.out.result = _WKSSVC_NETRUSEENUM(p, &r);
00778
00779 if (p->rng_fault_state) {
00780 talloc_free(mem_ctx);
00781
00782 return True;
00783 }
00784
00785 if (DEBUGLEVEL >= 10)
00786 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEENUM, &r);
00787
00788 push = ndr_push_init_ctx(mem_ctx);
00789 if (push == NULL) {
00790 talloc_free(mem_ctx);
00791 return False;
00792 }
00793
00794 status = ndr_push_WKSSVC_NETRUSEENUM(push, NDR_OUT, &r);
00795 if (NT_STATUS_IS_ERR(status)) {
00796 talloc_free(mem_ctx);
00797 return False;
00798 }
00799
00800 blob = ndr_push_blob(push);
00801 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00802 talloc_free(mem_ctx);
00803 return False;
00804 }
00805
00806 talloc_free(mem_ctx);
00807
00808 return True;
00809 }
00810
00811 static BOOL api_WKSSVC_NETRMESSAGEBUFFERSEND(pipes_struct *p)
00812 {
00813 struct ndr_pull *pull;
00814 struct ndr_push *push;
00815 NTSTATUS status;
00816 DATA_BLOB blob;
00817 struct WKSSVC_NETRMESSAGEBUFFERSEND r;
00818 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRMESSAGEBUFFERSEND");
00819
00820 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00821 talloc_free(mem_ctx);
00822 return False;
00823 }
00824
00825 pull = ndr_pull_init_blob(&blob, mem_ctx);
00826 if (pull == NULL) {
00827 talloc_free(mem_ctx);
00828 return False;
00829 }
00830
00831 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00832 status = ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND(pull, NDR_IN, &r);
00833 if (NT_STATUS_IS_ERR(status)) {
00834 talloc_free(mem_ctx);
00835 return False;
00836 }
00837
00838 if (DEBUGLEVEL >= 10)
00839 NDR_PRINT_IN_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
00840
00841 r.out.result = _WKSSVC_NETRMESSAGEBUFFERSEND(p, &r);
00842
00843 if (p->rng_fault_state) {
00844 talloc_free(mem_ctx);
00845
00846 return True;
00847 }
00848
00849 if (DEBUGLEVEL >= 10)
00850 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
00851
00852 push = ndr_push_init_ctx(mem_ctx);
00853 if (push == NULL) {
00854 talloc_free(mem_ctx);
00855 return False;
00856 }
00857
00858 status = ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND(push, NDR_OUT, &r);
00859 if (NT_STATUS_IS_ERR(status)) {
00860 talloc_free(mem_ctx);
00861 return False;
00862 }
00863
00864 blob = ndr_push_blob(push);
00865 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00866 talloc_free(mem_ctx);
00867 return False;
00868 }
00869
00870 talloc_free(mem_ctx);
00871
00872 return True;
00873 }
00874
00875 static BOOL api_WKSSVC_NETRWORKSTATIONSTATISTICSGET(pipes_struct *p)
00876 {
00877 struct ndr_pull *pull;
00878 struct ndr_push *push;
00879 NTSTATUS status;
00880 DATA_BLOB blob;
00881 struct WKSSVC_NETRWORKSTATIONSTATISTICSGET r;
00882 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRWORKSTATIONSTATISTICSGET");
00883
00884 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00885 talloc_free(mem_ctx);
00886 return False;
00887 }
00888
00889 pull = ndr_pull_init_blob(&blob, mem_ctx);
00890 if (pull == NULL) {
00891 talloc_free(mem_ctx);
00892 return False;
00893 }
00894
00895 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00896 status = ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET(pull, NDR_IN, &r);
00897 if (NT_STATUS_IS_ERR(status)) {
00898 talloc_free(mem_ctx);
00899 return False;
00900 }
00901
00902 if (DEBUGLEVEL >= 10)
00903 NDR_PRINT_IN_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
00904
00905 r.out.result = _WKSSVC_NETRWORKSTATIONSTATISTICSGET(p, &r);
00906
00907 if (p->rng_fault_state) {
00908 talloc_free(mem_ctx);
00909
00910 return True;
00911 }
00912
00913 if (DEBUGLEVEL >= 10)
00914 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
00915
00916 push = ndr_push_init_ctx(mem_ctx);
00917 if (push == NULL) {
00918 talloc_free(mem_ctx);
00919 return False;
00920 }
00921
00922 status = ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET(push, NDR_OUT, &r);
00923 if (NT_STATUS_IS_ERR(status)) {
00924 talloc_free(mem_ctx);
00925 return False;
00926 }
00927
00928 blob = ndr_push_blob(push);
00929 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00930 talloc_free(mem_ctx);
00931 return False;
00932 }
00933
00934 talloc_free(mem_ctx);
00935
00936 return True;
00937 }
00938
00939 static BOOL api_WKSSVC_NETRLOGONDOMAINNAMEADD(pipes_struct *p)
00940 {
00941 struct ndr_pull *pull;
00942 struct ndr_push *push;
00943 NTSTATUS status;
00944 DATA_BLOB blob;
00945 struct WKSSVC_NETRLOGONDOMAINNAMEADD r;
00946 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRLOGONDOMAINNAMEADD");
00947
00948 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
00949 talloc_free(mem_ctx);
00950 return False;
00951 }
00952
00953 pull = ndr_pull_init_blob(&blob, mem_ctx);
00954 if (pull == NULL) {
00955 talloc_free(mem_ctx);
00956 return False;
00957 }
00958
00959 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
00960 status = ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD(pull, NDR_IN, &r);
00961 if (NT_STATUS_IS_ERR(status)) {
00962 talloc_free(mem_ctx);
00963 return False;
00964 }
00965
00966 if (DEBUGLEVEL >= 10)
00967 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
00968
00969 r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEADD(p, &r);
00970
00971 if (p->rng_fault_state) {
00972 talloc_free(mem_ctx);
00973
00974 return True;
00975 }
00976
00977 if (DEBUGLEVEL >= 10)
00978 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
00979
00980 push = ndr_push_init_ctx(mem_ctx);
00981 if (push == NULL) {
00982 talloc_free(mem_ctx);
00983 return False;
00984 }
00985
00986 status = ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD(push, NDR_OUT, &r);
00987 if (NT_STATUS_IS_ERR(status)) {
00988 talloc_free(mem_ctx);
00989 return False;
00990 }
00991
00992 blob = ndr_push_blob(push);
00993 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
00994 talloc_free(mem_ctx);
00995 return False;
00996 }
00997
00998 talloc_free(mem_ctx);
00999
01000 return True;
01001 }
01002
01003 static BOOL api_WKSSVC_NETRLOGONDOMAINNAMEDEL(pipes_struct *p)
01004 {
01005 struct ndr_pull *pull;
01006 struct ndr_push *push;
01007 NTSTATUS status;
01008 DATA_BLOB blob;
01009 struct WKSSVC_NETRLOGONDOMAINNAMEDEL r;
01010 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRLOGONDOMAINNAMEDEL");
01011
01012 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01013 talloc_free(mem_ctx);
01014 return False;
01015 }
01016
01017 pull = ndr_pull_init_blob(&blob, mem_ctx);
01018 if (pull == NULL) {
01019 talloc_free(mem_ctx);
01020 return False;
01021 }
01022
01023 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01024 status = ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL(pull, NDR_IN, &r);
01025 if (NT_STATUS_IS_ERR(status)) {
01026 talloc_free(mem_ctx);
01027 return False;
01028 }
01029
01030 if (DEBUGLEVEL >= 10)
01031 NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
01032
01033 r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEDEL(p, &r);
01034
01035 if (p->rng_fault_state) {
01036 talloc_free(mem_ctx);
01037
01038 return True;
01039 }
01040
01041 if (DEBUGLEVEL >= 10)
01042 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
01043
01044 push = ndr_push_init_ctx(mem_ctx);
01045 if (push == NULL) {
01046 talloc_free(mem_ctx);
01047 return False;
01048 }
01049
01050 status = ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL(push, NDR_OUT, &r);
01051 if (NT_STATUS_IS_ERR(status)) {
01052 talloc_free(mem_ctx);
01053 return False;
01054 }
01055
01056 blob = ndr_push_blob(push);
01057 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01058 talloc_free(mem_ctx);
01059 return False;
01060 }
01061
01062 talloc_free(mem_ctx);
01063
01064 return True;
01065 }
01066
01067 static BOOL api_WKSSVC_NETRJOINDOMAIN(pipes_struct *p)
01068 {
01069 struct ndr_pull *pull;
01070 struct ndr_push *push;
01071 NTSTATUS status;
01072 DATA_BLOB blob;
01073 struct WKSSVC_NETRJOINDOMAIN r;
01074 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRJOINDOMAIN");
01075
01076 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01077 talloc_free(mem_ctx);
01078 return False;
01079 }
01080
01081 pull = ndr_pull_init_blob(&blob, mem_ctx);
01082 if (pull == NULL) {
01083 talloc_free(mem_ctx);
01084 return False;
01085 }
01086
01087 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01088 status = ndr_pull_WKSSVC_NETRJOINDOMAIN(pull, NDR_IN, &r);
01089 if (NT_STATUS_IS_ERR(status)) {
01090 talloc_free(mem_ctx);
01091 return False;
01092 }
01093
01094 if (DEBUGLEVEL >= 10)
01095 NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
01096
01097 r.out.result = _WKSSVC_NETRJOINDOMAIN(p, &r);
01098
01099 if (p->rng_fault_state) {
01100 talloc_free(mem_ctx);
01101
01102 return True;
01103 }
01104
01105 if (DEBUGLEVEL >= 10)
01106 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
01107
01108 push = ndr_push_init_ctx(mem_ctx);
01109 if (push == NULL) {
01110 talloc_free(mem_ctx);
01111 return False;
01112 }
01113
01114 status = ndr_push_WKSSVC_NETRJOINDOMAIN(push, NDR_OUT, &r);
01115 if (NT_STATUS_IS_ERR(status)) {
01116 talloc_free(mem_ctx);
01117 return False;
01118 }
01119
01120 blob = ndr_push_blob(push);
01121 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01122 talloc_free(mem_ctx);
01123 return False;
01124 }
01125
01126 talloc_free(mem_ctx);
01127
01128 return True;
01129 }
01130
01131 static BOOL api_WKSSVC_NETRUNJOINDOMAIN(pipes_struct *p)
01132 {
01133 struct ndr_pull *pull;
01134 struct ndr_push *push;
01135 NTSTATUS status;
01136 DATA_BLOB blob;
01137 struct WKSSVC_NETRUNJOINDOMAIN r;
01138 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRUNJOINDOMAIN");
01139
01140 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01141 talloc_free(mem_ctx);
01142 return False;
01143 }
01144
01145 pull = ndr_pull_init_blob(&blob, mem_ctx);
01146 if (pull == NULL) {
01147 talloc_free(mem_ctx);
01148 return False;
01149 }
01150
01151 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01152 status = ndr_pull_WKSSVC_NETRUNJOINDOMAIN(pull, NDR_IN, &r);
01153 if (NT_STATUS_IS_ERR(status)) {
01154 talloc_free(mem_ctx);
01155 return False;
01156 }
01157
01158 if (DEBUGLEVEL >= 10)
01159 NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
01160
01161 r.out.result = _WKSSVC_NETRUNJOINDOMAIN(p, &r);
01162
01163 if (p->rng_fault_state) {
01164 talloc_free(mem_ctx);
01165
01166 return True;
01167 }
01168
01169 if (DEBUGLEVEL >= 10)
01170 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
01171
01172 push = ndr_push_init_ctx(mem_ctx);
01173 if (push == NULL) {
01174 talloc_free(mem_ctx);
01175 return False;
01176 }
01177
01178 status = ndr_push_WKSSVC_NETRUNJOINDOMAIN(push, NDR_OUT, &r);
01179 if (NT_STATUS_IS_ERR(status)) {
01180 talloc_free(mem_ctx);
01181 return False;
01182 }
01183
01184 blob = ndr_push_blob(push);
01185 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01186 talloc_free(mem_ctx);
01187 return False;
01188 }
01189
01190 talloc_free(mem_ctx);
01191
01192 return True;
01193 }
01194
01195 static BOOL api_WKSSVC_NETRRENAMEMACHINEINDOMAIN(pipes_struct *p)
01196 {
01197 struct ndr_pull *pull;
01198 struct ndr_push *push;
01199 NTSTATUS status;
01200 DATA_BLOB blob;
01201 struct WKSSVC_NETRRENAMEMACHINEINDOMAIN r;
01202 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRRENAMEMACHINEINDOMAIN");
01203
01204 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01205 talloc_free(mem_ctx);
01206 return False;
01207 }
01208
01209 pull = ndr_pull_init_blob(&blob, mem_ctx);
01210 if (pull == NULL) {
01211 talloc_free(mem_ctx);
01212 return False;
01213 }
01214
01215 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01216 status = ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN(pull, NDR_IN, &r);
01217 if (NT_STATUS_IS_ERR(status)) {
01218 talloc_free(mem_ctx);
01219 return False;
01220 }
01221
01222 if (DEBUGLEVEL >= 10)
01223 NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
01224
01225 r.out.result = _WKSSVC_NETRRENAMEMACHINEINDOMAIN(p, &r);
01226
01227 if (p->rng_fault_state) {
01228 talloc_free(mem_ctx);
01229
01230 return True;
01231 }
01232
01233 if (DEBUGLEVEL >= 10)
01234 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
01235
01236 push = ndr_push_init_ctx(mem_ctx);
01237 if (push == NULL) {
01238 talloc_free(mem_ctx);
01239 return False;
01240 }
01241
01242 status = ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN(push, NDR_OUT, &r);
01243 if (NT_STATUS_IS_ERR(status)) {
01244 talloc_free(mem_ctx);
01245 return False;
01246 }
01247
01248 blob = ndr_push_blob(push);
01249 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01250 talloc_free(mem_ctx);
01251 return False;
01252 }
01253
01254 talloc_free(mem_ctx);
01255
01256 return True;
01257 }
01258
01259 static BOOL api_WKSSVC_NETRVALIDATENAME(pipes_struct *p)
01260 {
01261 struct ndr_pull *pull;
01262 struct ndr_push *push;
01263 NTSTATUS status;
01264 DATA_BLOB blob;
01265 struct WKSSVC_NETRVALIDATENAME r;
01266 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRVALIDATENAME");
01267
01268 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01269 talloc_free(mem_ctx);
01270 return False;
01271 }
01272
01273 pull = ndr_pull_init_blob(&blob, mem_ctx);
01274 if (pull == NULL) {
01275 talloc_free(mem_ctx);
01276 return False;
01277 }
01278
01279 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01280 status = ndr_pull_WKSSVC_NETRVALIDATENAME(pull, NDR_IN, &r);
01281 if (NT_STATUS_IS_ERR(status)) {
01282 talloc_free(mem_ctx);
01283 return False;
01284 }
01285
01286 if (DEBUGLEVEL >= 10)
01287 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
01288
01289 r.out.result = _WKSSVC_NETRVALIDATENAME(p, &r);
01290
01291 if (p->rng_fault_state) {
01292 talloc_free(mem_ctx);
01293
01294 return True;
01295 }
01296
01297 if (DEBUGLEVEL >= 10)
01298 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
01299
01300 push = ndr_push_init_ctx(mem_ctx);
01301 if (push == NULL) {
01302 talloc_free(mem_ctx);
01303 return False;
01304 }
01305
01306 status = ndr_push_WKSSVC_NETRVALIDATENAME(push, NDR_OUT, &r);
01307 if (NT_STATUS_IS_ERR(status)) {
01308 talloc_free(mem_ctx);
01309 return False;
01310 }
01311
01312 blob = ndr_push_blob(push);
01313 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01314 talloc_free(mem_ctx);
01315 return False;
01316 }
01317
01318 talloc_free(mem_ctx);
01319
01320 return True;
01321 }
01322
01323 static BOOL api_WKSSVC_NETRGETJOININFORMATION(pipes_struct *p)
01324 {
01325 struct ndr_pull *pull;
01326 struct ndr_push *push;
01327 NTSTATUS status;
01328 DATA_BLOB blob;
01329 struct WKSSVC_NETRGETJOININFORMATION r;
01330 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOININFORMATION");
01331
01332 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01333 talloc_free(mem_ctx);
01334 return False;
01335 }
01336
01337 pull = ndr_pull_init_blob(&blob, mem_ctx);
01338 if (pull == NULL) {
01339 talloc_free(mem_ctx);
01340 return False;
01341 }
01342
01343 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01344 status = ndr_pull_WKSSVC_NETRGETJOININFORMATION(pull, NDR_IN, &r);
01345 if (NT_STATUS_IS_ERR(status)) {
01346 talloc_free(mem_ctx);
01347 return False;
01348 }
01349
01350 if (DEBUGLEVEL >= 10)
01351 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
01352
01353 r.out.result = _WKSSVC_NETRGETJOININFORMATION(p, &r);
01354
01355 if (p->rng_fault_state) {
01356 talloc_free(mem_ctx);
01357
01358 return True;
01359 }
01360
01361 if (DEBUGLEVEL >= 10)
01362 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
01363
01364 push = ndr_push_init_ctx(mem_ctx);
01365 if (push == NULL) {
01366 talloc_free(mem_ctx);
01367 return False;
01368 }
01369
01370 status = ndr_push_WKSSVC_NETRGETJOININFORMATION(push, NDR_OUT, &r);
01371 if (NT_STATUS_IS_ERR(status)) {
01372 talloc_free(mem_ctx);
01373 return False;
01374 }
01375
01376 blob = ndr_push_blob(push);
01377 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01378 talloc_free(mem_ctx);
01379 return False;
01380 }
01381
01382 talloc_free(mem_ctx);
01383
01384 return True;
01385 }
01386
01387 static BOOL api_WKSSVC_NETRGETJOINABLEOUS(pipes_struct *p)
01388 {
01389 struct ndr_pull *pull;
01390 struct ndr_push *push;
01391 NTSTATUS status;
01392 DATA_BLOB blob;
01393 struct WKSSVC_NETRGETJOINABLEOUS r;
01394 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOINABLEOUS");
01395
01396 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01397 talloc_free(mem_ctx);
01398 return False;
01399 }
01400
01401 pull = ndr_pull_init_blob(&blob, mem_ctx);
01402 if (pull == NULL) {
01403 talloc_free(mem_ctx);
01404 return False;
01405 }
01406
01407 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01408 status = ndr_pull_WKSSVC_NETRGETJOINABLEOUS(pull, NDR_IN, &r);
01409 if (NT_STATUS_IS_ERR(status)) {
01410 talloc_free(mem_ctx);
01411 return False;
01412 }
01413
01414 if (DEBUGLEVEL >= 10)
01415 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
01416
01417 r.out.result = _WKSSVC_NETRGETJOINABLEOUS(p, &r);
01418
01419 if (p->rng_fault_state) {
01420 talloc_free(mem_ctx);
01421
01422 return True;
01423 }
01424
01425 if (DEBUGLEVEL >= 10)
01426 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
01427
01428 push = ndr_push_init_ctx(mem_ctx);
01429 if (push == NULL) {
01430 talloc_free(mem_ctx);
01431 return False;
01432 }
01433
01434 status = ndr_push_WKSSVC_NETRGETJOINABLEOUS(push, NDR_OUT, &r);
01435 if (NT_STATUS_IS_ERR(status)) {
01436 talloc_free(mem_ctx);
01437 return False;
01438 }
01439
01440 blob = ndr_push_blob(push);
01441 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01442 talloc_free(mem_ctx);
01443 return False;
01444 }
01445
01446 talloc_free(mem_ctx);
01447
01448 return True;
01449 }
01450
01451 static BOOL api_wkssvc_NetrJoinDomain2(pipes_struct *p)
01452 {
01453 struct ndr_pull *pull;
01454 struct ndr_push *push;
01455 NTSTATUS status;
01456 DATA_BLOB blob;
01457 struct wkssvc_NetrJoinDomain2 r;
01458 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrJoinDomain2");
01459
01460 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01461 talloc_free(mem_ctx);
01462 return False;
01463 }
01464
01465 pull = ndr_pull_init_blob(&blob, mem_ctx);
01466 if (pull == NULL) {
01467 talloc_free(mem_ctx);
01468 return False;
01469 }
01470
01471 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01472 status = ndr_pull_wkssvc_NetrJoinDomain2(pull, NDR_IN, &r);
01473 if (NT_STATUS_IS_ERR(status)) {
01474 talloc_free(mem_ctx);
01475 return False;
01476 }
01477
01478 if (DEBUGLEVEL >= 10)
01479 NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &r);
01480
01481 r.out.result = _wkssvc_NetrJoinDomain2(p, &r);
01482
01483 if (p->rng_fault_state) {
01484 talloc_free(mem_ctx);
01485
01486 return True;
01487 }
01488
01489 if (DEBUGLEVEL >= 10)
01490 NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &r);
01491
01492 push = ndr_push_init_ctx(mem_ctx);
01493 if (push == NULL) {
01494 talloc_free(mem_ctx);
01495 return False;
01496 }
01497
01498 status = ndr_push_wkssvc_NetrJoinDomain2(push, NDR_OUT, &r);
01499 if (NT_STATUS_IS_ERR(status)) {
01500 talloc_free(mem_ctx);
01501 return False;
01502 }
01503
01504 blob = ndr_push_blob(push);
01505 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01506 talloc_free(mem_ctx);
01507 return False;
01508 }
01509
01510 talloc_free(mem_ctx);
01511
01512 return True;
01513 }
01514
01515 static BOOL api_wkssvc_NetrUnjoinDomain2(pipes_struct *p)
01516 {
01517 struct ndr_pull *pull;
01518 struct ndr_push *push;
01519 NTSTATUS status;
01520 DATA_BLOB blob;
01521 struct wkssvc_NetrUnjoinDomain2 r;
01522 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrUnjoinDomain2");
01523
01524 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01525 talloc_free(mem_ctx);
01526 return False;
01527 }
01528
01529 pull = ndr_pull_init_blob(&blob, mem_ctx);
01530 if (pull == NULL) {
01531 talloc_free(mem_ctx);
01532 return False;
01533 }
01534
01535 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01536 status = ndr_pull_wkssvc_NetrUnjoinDomain2(pull, NDR_IN, &r);
01537 if (NT_STATUS_IS_ERR(status)) {
01538 talloc_free(mem_ctx);
01539 return False;
01540 }
01541
01542 if (DEBUGLEVEL >= 10)
01543 NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
01544
01545 r.out.result = _wkssvc_NetrUnjoinDomain2(p, &r);
01546
01547 if (p->rng_fault_state) {
01548 talloc_free(mem_ctx);
01549
01550 return True;
01551 }
01552
01553 if (DEBUGLEVEL >= 10)
01554 NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
01555
01556 push = ndr_push_init_ctx(mem_ctx);
01557 if (push == NULL) {
01558 talloc_free(mem_ctx);
01559 return False;
01560 }
01561
01562 status = ndr_push_wkssvc_NetrUnjoinDomain2(push, NDR_OUT, &r);
01563 if (NT_STATUS_IS_ERR(status)) {
01564 talloc_free(mem_ctx);
01565 return False;
01566 }
01567
01568 blob = ndr_push_blob(push);
01569 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01570 talloc_free(mem_ctx);
01571 return False;
01572 }
01573
01574 talloc_free(mem_ctx);
01575
01576 return True;
01577 }
01578
01579 static BOOL api_wkssvc_NetrRenameMachineInDomain2(pipes_struct *p)
01580 {
01581 struct ndr_pull *pull;
01582 struct ndr_push *push;
01583 NTSTATUS status;
01584 DATA_BLOB blob;
01585 struct wkssvc_NetrRenameMachineInDomain2 r;
01586 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrRenameMachineInDomain2");
01587
01588 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01589 talloc_free(mem_ctx);
01590 return False;
01591 }
01592
01593 pull = ndr_pull_init_blob(&blob, mem_ctx);
01594 if (pull == NULL) {
01595 talloc_free(mem_ctx);
01596 return False;
01597 }
01598
01599 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01600 status = ndr_pull_wkssvc_NetrRenameMachineInDomain2(pull, NDR_IN, &r);
01601 if (NT_STATUS_IS_ERR(status)) {
01602 talloc_free(mem_ctx);
01603 return False;
01604 }
01605
01606 if (DEBUGLEVEL >= 10)
01607 NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
01608
01609 r.out.result = _wkssvc_NetrRenameMachineInDomain2(p, &r);
01610
01611 if (p->rng_fault_state) {
01612 talloc_free(mem_ctx);
01613
01614 return True;
01615 }
01616
01617 if (DEBUGLEVEL >= 10)
01618 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
01619
01620 push = ndr_push_init_ctx(mem_ctx);
01621 if (push == NULL) {
01622 talloc_free(mem_ctx);
01623 return False;
01624 }
01625
01626 status = ndr_push_wkssvc_NetrRenameMachineInDomain2(push, NDR_OUT, &r);
01627 if (NT_STATUS_IS_ERR(status)) {
01628 talloc_free(mem_ctx);
01629 return False;
01630 }
01631
01632 blob = ndr_push_blob(push);
01633 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01634 talloc_free(mem_ctx);
01635 return False;
01636 }
01637
01638 talloc_free(mem_ctx);
01639
01640 return True;
01641 }
01642
01643 static BOOL api_WKSSVC_NETRVALIDATENAME2(pipes_struct *p)
01644 {
01645 struct ndr_pull *pull;
01646 struct ndr_push *push;
01647 NTSTATUS status;
01648 DATA_BLOB blob;
01649 struct WKSSVC_NETRVALIDATENAME2 r;
01650 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRVALIDATENAME2");
01651
01652 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01653 talloc_free(mem_ctx);
01654 return False;
01655 }
01656
01657 pull = ndr_pull_init_blob(&blob, mem_ctx);
01658 if (pull == NULL) {
01659 talloc_free(mem_ctx);
01660 return False;
01661 }
01662
01663 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01664 status = ndr_pull_WKSSVC_NETRVALIDATENAME2(pull, NDR_IN, &r);
01665 if (NT_STATUS_IS_ERR(status)) {
01666 talloc_free(mem_ctx);
01667 return False;
01668 }
01669
01670 if (DEBUGLEVEL >= 10)
01671 NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
01672
01673 r.out.result = _WKSSVC_NETRVALIDATENAME2(p, &r);
01674
01675 if (p->rng_fault_state) {
01676 talloc_free(mem_ctx);
01677
01678 return True;
01679 }
01680
01681 if (DEBUGLEVEL >= 10)
01682 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
01683
01684 push = ndr_push_init_ctx(mem_ctx);
01685 if (push == NULL) {
01686 talloc_free(mem_ctx);
01687 return False;
01688 }
01689
01690 status = ndr_push_WKSSVC_NETRVALIDATENAME2(push, NDR_OUT, &r);
01691 if (NT_STATUS_IS_ERR(status)) {
01692 talloc_free(mem_ctx);
01693 return False;
01694 }
01695
01696 blob = ndr_push_blob(push);
01697 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01698 talloc_free(mem_ctx);
01699 return False;
01700 }
01701
01702 talloc_free(mem_ctx);
01703
01704 return True;
01705 }
01706
01707 static BOOL api_WKSSVC_NETRGETJOINABLEOUS2(pipes_struct *p)
01708 {
01709 struct ndr_pull *pull;
01710 struct ndr_push *push;
01711 NTSTATUS status;
01712 DATA_BLOB blob;
01713 struct WKSSVC_NETRGETJOINABLEOUS2 r;
01714 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRGETJOINABLEOUS2");
01715
01716 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01717 talloc_free(mem_ctx);
01718 return False;
01719 }
01720
01721 pull = ndr_pull_init_blob(&blob, mem_ctx);
01722 if (pull == NULL) {
01723 talloc_free(mem_ctx);
01724 return False;
01725 }
01726
01727 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01728 status = ndr_pull_WKSSVC_NETRGETJOINABLEOUS2(pull, NDR_IN, &r);
01729 if (NT_STATUS_IS_ERR(status)) {
01730 talloc_free(mem_ctx);
01731 return False;
01732 }
01733
01734 if (DEBUGLEVEL >= 10)
01735 NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
01736
01737 r.out.result = _WKSSVC_NETRGETJOINABLEOUS2(p, &r);
01738
01739 if (p->rng_fault_state) {
01740 talloc_free(mem_ctx);
01741
01742 return True;
01743 }
01744
01745 if (DEBUGLEVEL >= 10)
01746 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
01747
01748 push = ndr_push_init_ctx(mem_ctx);
01749 if (push == NULL) {
01750 talloc_free(mem_ctx);
01751 return False;
01752 }
01753
01754 status = ndr_push_WKSSVC_NETRGETJOINABLEOUS2(push, NDR_OUT, &r);
01755 if (NT_STATUS_IS_ERR(status)) {
01756 talloc_free(mem_ctx);
01757 return False;
01758 }
01759
01760 blob = ndr_push_blob(push);
01761 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01762 talloc_free(mem_ctx);
01763 return False;
01764 }
01765
01766 talloc_free(mem_ctx);
01767
01768 return True;
01769 }
01770
01771 static BOOL api_wkssvc_NetrAddAlternateComputerName(pipes_struct *p)
01772 {
01773 struct ndr_pull *pull;
01774 struct ndr_push *push;
01775 NTSTATUS status;
01776 DATA_BLOB blob;
01777 struct wkssvc_NetrAddAlternateComputerName r;
01778 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrAddAlternateComputerName");
01779
01780 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01781 talloc_free(mem_ctx);
01782 return False;
01783 }
01784
01785 pull = ndr_pull_init_blob(&blob, mem_ctx);
01786 if (pull == NULL) {
01787 talloc_free(mem_ctx);
01788 return False;
01789 }
01790
01791 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01792 status = ndr_pull_wkssvc_NetrAddAlternateComputerName(pull, NDR_IN, &r);
01793 if (NT_STATUS_IS_ERR(status)) {
01794 talloc_free(mem_ctx);
01795 return False;
01796 }
01797
01798 if (DEBUGLEVEL >= 10)
01799 NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
01800
01801 r.out.result = _wkssvc_NetrAddAlternateComputerName(p, &r);
01802
01803 if (p->rng_fault_state) {
01804 talloc_free(mem_ctx);
01805
01806 return True;
01807 }
01808
01809 if (DEBUGLEVEL >= 10)
01810 NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
01811
01812 push = ndr_push_init_ctx(mem_ctx);
01813 if (push == NULL) {
01814 talloc_free(mem_ctx);
01815 return False;
01816 }
01817
01818 status = ndr_push_wkssvc_NetrAddAlternateComputerName(push, NDR_OUT, &r);
01819 if (NT_STATUS_IS_ERR(status)) {
01820 talloc_free(mem_ctx);
01821 return False;
01822 }
01823
01824 blob = ndr_push_blob(push);
01825 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01826 talloc_free(mem_ctx);
01827 return False;
01828 }
01829
01830 talloc_free(mem_ctx);
01831
01832 return True;
01833 }
01834
01835 static BOOL api_wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p)
01836 {
01837 struct ndr_pull *pull;
01838 struct ndr_push *push;
01839 NTSTATUS status;
01840 DATA_BLOB blob;
01841 struct wkssvc_NetrRemoveAlternateComputerName r;
01842 TALLOC_CTX *mem_ctx = talloc_init("api_wkssvc_NetrRemoveAlternateComputerName");
01843
01844 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01845 talloc_free(mem_ctx);
01846 return False;
01847 }
01848
01849 pull = ndr_pull_init_blob(&blob, mem_ctx);
01850 if (pull == NULL) {
01851 talloc_free(mem_ctx);
01852 return False;
01853 }
01854
01855 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01856 status = ndr_pull_wkssvc_NetrRemoveAlternateComputerName(pull, NDR_IN, &r);
01857 if (NT_STATUS_IS_ERR(status)) {
01858 talloc_free(mem_ctx);
01859 return False;
01860 }
01861
01862 if (DEBUGLEVEL >= 10)
01863 NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
01864
01865 r.out.result = _wkssvc_NetrRemoveAlternateComputerName(p, &r);
01866
01867 if (p->rng_fault_state) {
01868 talloc_free(mem_ctx);
01869
01870 return True;
01871 }
01872
01873 if (DEBUGLEVEL >= 10)
01874 NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
01875
01876 push = ndr_push_init_ctx(mem_ctx);
01877 if (push == NULL) {
01878 talloc_free(mem_ctx);
01879 return False;
01880 }
01881
01882 status = ndr_push_wkssvc_NetrRemoveAlternateComputerName(push, NDR_OUT, &r);
01883 if (NT_STATUS_IS_ERR(status)) {
01884 talloc_free(mem_ctx);
01885 return False;
01886 }
01887
01888 blob = ndr_push_blob(push);
01889 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01890 talloc_free(mem_ctx);
01891 return False;
01892 }
01893
01894 talloc_free(mem_ctx);
01895
01896 return True;
01897 }
01898
01899 static BOOL api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pipes_struct *p)
01900 {
01901 struct ndr_pull *pull;
01902 struct ndr_push *push;
01903 NTSTATUS status;
01904 DATA_BLOB blob;
01905 struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME r;
01906 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME");
01907
01908 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01909 talloc_free(mem_ctx);
01910 return False;
01911 }
01912
01913 pull = ndr_pull_init_blob(&blob, mem_ctx);
01914 if (pull == NULL) {
01915 talloc_free(mem_ctx);
01916 return False;
01917 }
01918
01919 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01920 status = ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pull, NDR_IN, &r);
01921 if (NT_STATUS_IS_ERR(status)) {
01922 talloc_free(mem_ctx);
01923 return False;
01924 }
01925
01926 if (DEBUGLEVEL >= 10)
01927 NDR_PRINT_IN_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
01928
01929 r.out.result = _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(p, &r);
01930
01931 if (p->rng_fault_state) {
01932 talloc_free(mem_ctx);
01933
01934 return True;
01935 }
01936
01937 if (DEBUGLEVEL >= 10)
01938 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
01939
01940 push = ndr_push_init_ctx(mem_ctx);
01941 if (push == NULL) {
01942 talloc_free(mem_ctx);
01943 return False;
01944 }
01945
01946 status = ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(push, NDR_OUT, &r);
01947 if (NT_STATUS_IS_ERR(status)) {
01948 talloc_free(mem_ctx);
01949 return False;
01950 }
01951
01952 blob = ndr_push_blob(push);
01953 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
01954 talloc_free(mem_ctx);
01955 return False;
01956 }
01957
01958 talloc_free(mem_ctx);
01959
01960 return True;
01961 }
01962
01963 static BOOL api_WKSSVC_NETRENUMERATECOMPUTERNAMES(pipes_struct *p)
01964 {
01965 struct ndr_pull *pull;
01966 struct ndr_push *push;
01967 NTSTATUS status;
01968 DATA_BLOB blob;
01969 struct WKSSVC_NETRENUMERATECOMPUTERNAMES r;
01970 TALLOC_CTX *mem_ctx = talloc_init("api_WKSSVC_NETRENUMERATECOMPUTERNAMES");
01971
01972 if (!prs_data_blob(&p->in_data.data, &blob, mem_ctx)) {
01973 talloc_free(mem_ctx);
01974 return False;
01975 }
01976
01977 pull = ndr_pull_init_blob(&blob, mem_ctx);
01978 if (pull == NULL) {
01979 talloc_free(mem_ctx);
01980 return False;
01981 }
01982
01983 pull->flags |= LIBNDR_FLAG_REF_ALLOC;
01984 status = ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES(pull, NDR_IN, &r);
01985 if (NT_STATUS_IS_ERR(status)) {
01986 talloc_free(mem_ctx);
01987 return False;
01988 }
01989
01990 if (DEBUGLEVEL >= 10)
01991 NDR_PRINT_IN_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
01992
01993 r.out.result = _WKSSVC_NETRENUMERATECOMPUTERNAMES(p, &r);
01994
01995 if (p->rng_fault_state) {
01996 talloc_free(mem_ctx);
01997
01998 return True;
01999 }
02000
02001 if (DEBUGLEVEL >= 10)
02002 NDR_PRINT_OUT_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
02003
02004 push = ndr_push_init_ctx(mem_ctx);
02005 if (push == NULL) {
02006 talloc_free(mem_ctx);
02007 return False;
02008 }
02009
02010 status = ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES(push, NDR_OUT, &r);
02011 if (NT_STATUS_IS_ERR(status)) {
02012 talloc_free(mem_ctx);
02013 return False;
02014 }
02015
02016 blob = ndr_push_blob(push);
02017 if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32)blob.length)) {
02018 talloc_free(mem_ctx);
02019 return False;
02020 }
02021
02022 talloc_free(mem_ctx);
02023
02024 return True;
02025 }
02026
02027
02028
02029 static struct api_struct api_wkssvc_cmds[] =
02030 {
02031 {"WKSSVC_NETWKSTAGETINFO", DCERPC_WKSSVC_NETWKSTAGETINFO, api_wkssvc_NetWkstaGetInfo},
02032 {"WKSSVC_NETWKSTASETINFO", DCERPC_WKSSVC_NETWKSTASETINFO, api_wkssvc_NetWkstaSetInfo},
02033 {"WKSSVC_NETWKSTAENUMUSERS", DCERPC_WKSSVC_NETWKSTAENUMUSERS, api_wkssvc_NetWkstaEnumUsers},
02034 {"WKSSVC_NETRWKSTAUSERGETINFO", DCERPC_WKSSVC_NETRWKSTAUSERGETINFO, api_WKSSVC_NETRWKSTAUSERGETINFO},
02035 {"WKSSVC_NETRWKSTAUSERSETINFO", DCERPC_WKSSVC_NETRWKSTAUSERSETINFO, api_WKSSVC_NETRWKSTAUSERSETINFO},
02036 {"WKSSVC_NETWKSTATRANSPORTENUM", DCERPC_WKSSVC_NETWKSTATRANSPORTENUM, api_wkssvc_NetWkstaTransportEnum},
02037 {"WKSSVC_NETRWKSTATRANSPORTADD", DCERPC_WKSSVC_NETRWKSTATRANSPORTADD, api_WKSSVC_NETRWKSTATRANSPORTADD},
02038 {"WKSSVC_NETRWKSTATRANSPORTDEL", DCERPC_WKSSVC_NETRWKSTATRANSPORTDEL, api_WKSSVC_NETRWKSTATRANSPORTDEL},
02039 {"WKSSVC_NETRUSEADD", DCERPC_WKSSVC_NETRUSEADD, api_WKSSVC_NETRUSEADD},
02040 {"WKSSVC_NETRUSEGETINFO", DCERPC_WKSSVC_NETRUSEGETINFO, api_WKSSVC_NETRUSEGETINFO},
02041 {"WKSSVC_NETRUSEDEL", DCERPC_WKSSVC_NETRUSEDEL, api_WKSSVC_NETRUSEDEL},
02042 {"WKSSVC_NETRUSEENUM", DCERPC_WKSSVC_NETRUSEENUM, api_WKSSVC_NETRUSEENUM},
02043 {"WKSSVC_NETRMESSAGEBUFFERSEND", DCERPC_WKSSVC_NETRMESSAGEBUFFERSEND, api_WKSSVC_NETRMESSAGEBUFFERSEND},
02044 {"WKSSVC_NETRWORKSTATIONSTATISTICSGET", DCERPC_WKSSVC_NETRWORKSTATIONSTATISTICSGET, api_WKSSVC_NETRWORKSTATIONSTATISTICSGET},
02045 {"WKSSVC_NETRLOGONDOMAINNAMEADD", DCERPC_WKSSVC_NETRLOGONDOMAINNAMEADD, api_WKSSVC_NETRLOGONDOMAINNAMEADD},
02046 {"WKSSVC_NETRLOGONDOMAINNAMEDEL", DCERPC_WKSSVC_NETRLOGONDOMAINNAMEDEL, api_WKSSVC_NETRLOGONDOMAINNAMEDEL},
02047 {"WKSSVC_NETRJOINDOMAIN", DCERPC_WKSSVC_NETRJOINDOMAIN, api_WKSSVC_NETRJOINDOMAIN},
02048 {"WKSSVC_NETRUNJOINDOMAIN", DCERPC_WKSSVC_NETRUNJOINDOMAIN, api_WKSSVC_NETRUNJOINDOMAIN},
02049 {"WKSSVC_NETRRENAMEMACHINEINDOMAIN", DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN, api_WKSSVC_NETRRENAMEMACHINEINDOMAIN},
02050 {"WKSSVC_NETRVALIDATENAME", DCERPC_WKSSVC_NETRVALIDATENAME, api_WKSSVC_NETRVALIDATENAME},
02051 {"WKSSVC_NETRGETJOININFORMATION", DCERPC_WKSSVC_NETRGETJOININFORMATION, api_WKSSVC_NETRGETJOININFORMATION},
02052 {"WKSSVC_NETRGETJOINABLEOUS", DCERPC_WKSSVC_NETRGETJOINABLEOUS, api_WKSSVC_NETRGETJOINABLEOUS},
02053 {"WKSSVC_NETRJOINDOMAIN2", DCERPC_WKSSVC_NETRJOINDOMAIN2, api_wkssvc_NetrJoinDomain2},
02054 {"WKSSVC_NETRUNJOINDOMAIN2", DCERPC_WKSSVC_NETRUNJOINDOMAIN2, api_wkssvc_NetrUnjoinDomain2},
02055 {"WKSSVC_NETRRENAMEMACHINEINDOMAIN2", DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, api_wkssvc_NetrRenameMachineInDomain2},
02056 {"WKSSVC_NETRVALIDATENAME2", DCERPC_WKSSVC_NETRVALIDATENAME2, api_WKSSVC_NETRVALIDATENAME2},
02057 {"WKSSVC_NETRGETJOINABLEOUS2", DCERPC_WKSSVC_NETRGETJOINABLEOUS2, api_WKSSVC_NETRGETJOINABLEOUS2},
02058 {"WKSSVC_NETRADDALTERNATECOMPUTERNAME", DCERPC_WKSSVC_NETRADDALTERNATECOMPUTERNAME, api_wkssvc_NetrAddAlternateComputerName},
02059 {"WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME", DCERPC_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, api_wkssvc_NetrRemoveAlternateComputerName},
02060 {"WKSSVC_NETRSETPRIMARYCOMPUTERNAME", DCERPC_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, api_WKSSVC_NETRSETPRIMARYCOMPUTERNAME},
02061 {"WKSSVC_NETRENUMERATECOMPUTERNAMES", DCERPC_WKSSVC_NETRENUMERATECOMPUTERNAMES, api_WKSSVC_NETRENUMERATECOMPUTERNAMES},
02062 };
02063
02064 void wkssvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
02065 {
02066 *fns = api_wkssvc_cmds;
02067 *n_fns = sizeof(api_wkssvc_cmds) / sizeof(struct api_struct);
02068 }
02069
02070 NTSTATUS rpc_wkssvc_init(void)
02071 {
02072 return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "wkssvc", "wkssvc", api_wkssvc_cmds, sizeof(api_wkssvc_cmds) / sizeof(struct api_struct));
02073 }