?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ctdb-server: Clean up connection tracking functions
[samba4-gss.git] / source3 / lib / netapi / libnetapi.c
blob29073168ef81f4c3cdcaa6610f46efb533e3846f
1 /*
2 * Unix SMB/CIFS implementation.
3 * NetApi Support
4 * Copyright (C) Guenther Deschner 2007-2008
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "librpc/gen_ndr/libnetapi.h"
22 #include "lib/netapi/netapi.h"
23 #include "lib/netapi/netapi_private.h"
24 #include "lib/netapi/libnetapi.h"
25 #include "librpc/gen_ndr/ndr_libnetapi.h"
26
27 /****************************************************************
28 NetJoinDomain
29 ****************************************************************/
30
31 NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
32 const char * domain /* [in] [ref] */,
33 const char * account_ou /* [in] [unique] */,
34 const char * account /* [in] [unique] */,
35 const char * password /* [in] [unique] */,
36 uint32_t join_flags /* [in] */)
37 {
38 struct NetJoinDomain r;
39 struct libnetapi_ctx *ctx = NULL;
40 NET_API_STATUS status;
41 WERROR werr;
42 TALLOC_CTX *frame = talloc_stackframe();
43
44 ZERO_STRUCT(r);
45
46 status = libnetapi_getctx(&ctx);
47 if (status != 0) {
48 TALLOC_FREE(frame);
49 return status;
50 }
51
52 /* In parameters */
53 r.in.server = server;
54 r.in.domain = domain;
55 r.in.account_ou = account_ou;
56 r.in.account = account;
57 r.in.password = password;
58 r.in.join_flags = join_flags;
59
60 /* Out parameters */
61
62 if (DEBUGLEVEL >= 10) {
63 NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
64 }
65
66 if (LIBNETAPI_LOCAL_SERVER(server)) {
67 werr = NetJoinDomain_l(ctx, &r);
68 } else {
69 werr = NetJoinDomain_r(ctx, &r);
70 }
71
72 r.out.result = W_ERROR_V(werr);
73
74 if (DEBUGLEVEL >= 10) {
75 NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
76 }
77
78 TALLOC_FREE(frame);
79 return (NET_API_STATUS)r.out.result;
80 }
81
82 /****************************************************************
83 NetUnjoinDomain
84 ****************************************************************/
85
86 NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
87 const char * account /* [in] [unique] */,
88 const char * password /* [in] [unique] */,
89 uint32_t unjoin_flags /* [in] */)
90 {
91 struct NetUnjoinDomain r;
92 struct libnetapi_ctx *ctx = NULL;
93 NET_API_STATUS status;
94 WERROR werr;
95 TALLOC_CTX *frame = talloc_stackframe();
96
97 ZERO_STRUCT(r);
98
99 status = libnetapi_getctx(&ctx);
100 if (status != 0) {
101 TALLOC_FREE(frame);
102 return status;
103 }
104
105 /* In parameters */
106 r.in.server_name = server_name;
107 r.in.account = account;
108 r.in.password = password;
109 r.in.unjoin_flags = unjoin_flags;
110
111 /* Out parameters */
112
113 if (DEBUGLEVEL >= 10) {
114 NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
115 }
116
117 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
118 werr = NetUnjoinDomain_l(ctx, &r);
119 } else {
120 werr = NetUnjoinDomain_r(ctx, &r);
121 }
122
123 r.out.result = W_ERROR_V(werr);
124
125 if (DEBUGLEVEL >= 10) {
126 NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
127 }
128
129 TALLOC_FREE(frame);
130 return (NET_API_STATUS)r.out.result;
131 }
132
133 /****************************************************************
134 NetGetJoinInformation
135 ****************************************************************/
136
137 NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
138 const char * *name_buffer /* [out] [ref] */,
139 uint16_t *name_type /* [out] [ref] */)
140 {
141 struct NetGetJoinInformation r;
142 struct libnetapi_ctx *ctx = NULL;
143 NET_API_STATUS status;
144 WERROR werr;
145 TALLOC_CTX *frame = talloc_stackframe();
146
147 ZERO_STRUCT(r);
148
149 status = libnetapi_getctx(&ctx);
150 if (status != 0) {
151 TALLOC_FREE(frame);
152 return status;
153 }
154
155 /* In parameters */
156 r.in.server_name = server_name;
157
158 /* Out parameters */
159 r.out.name_buffer = name_buffer;
160 r.out.name_type = name_type;
161
162 if (DEBUGLEVEL >= 10) {
163 NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
164 }
165
166 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
167 werr = NetGetJoinInformation_l(ctx, &r);
168 } else {
169 werr = NetGetJoinInformation_r(ctx, &r);
170 }
171
172 r.out.result = W_ERROR_V(werr);
173
174 if (DEBUGLEVEL >= 10) {
175 NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
176 }
177
178 TALLOC_FREE(frame);
179 return (NET_API_STATUS)r.out.result;
180 }
181
182 /****************************************************************
183 NetGetJoinableOUs
184 ****************************************************************/
185
186 NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
187 const char * domain /* [in] [ref] */,
188 const char * account /* [in] [unique] */,
189 const char * password /* [in] [unique] */,
190 uint32_t *ou_count /* [out] [ref] */,
191 const char * **ous /* [out] [ref] */)
192 {
193 struct NetGetJoinableOUs r;
194 struct libnetapi_ctx *ctx = NULL;
195 NET_API_STATUS status;
196 WERROR werr;
197 TALLOC_CTX *frame = talloc_stackframe();
198
199 ZERO_STRUCT(r);
200
201 status = libnetapi_getctx(&ctx);
202 if (status != 0) {
203 TALLOC_FREE(frame);
204 return status;
205 }
206
207 /* In parameters */
208 r.in.server_name = server_name;
209 r.in.domain = domain;
210 r.in.account = account;
211 r.in.password = password;
212
213 /* Out parameters */
214 r.out.ou_count = ou_count;
215 r.out.ous = ous;
216
217 if (DEBUGLEVEL >= 10) {
218 NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
219 }
220
221 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
222 werr = NetGetJoinableOUs_l(ctx, &r);
223 } else {
224 werr = NetGetJoinableOUs_r(ctx, &r);
225 }
226
227 r.out.result = W_ERROR_V(werr);
228
229 if (DEBUGLEVEL >= 10) {
230 NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
231 }
232
233 TALLOC_FREE(frame);
234 return (NET_API_STATUS)r.out.result;
235 }
236
237 /****************************************************************
238 NetRenameMachineInDomain
239 ****************************************************************/
240
241 NET_API_STATUS NetRenameMachineInDomain(const char * server_name /* [in] */,
242 const char * new_machine_name /* [in] */,
243 const char * account /* [in] */,
244 const char * password /* [in] */,
245 uint32_t rename_options /* [in] */)
246 {
247 struct NetRenameMachineInDomain r;
248 struct libnetapi_ctx *ctx = NULL;
249 NET_API_STATUS status;
250 WERROR werr;
251 TALLOC_CTX *frame = talloc_stackframe();
252
253 ZERO_STRUCT(r);
254
255 status = libnetapi_getctx(&ctx);
256 if (status != 0) {
257 TALLOC_FREE(frame);
258 return status;
259 }
260
261 /* In parameters */
262 r.in.server_name = server_name;
263 r.in.new_machine_name = new_machine_name;
264 r.in.account = account;
265 r.in.password = password;
266 r.in.rename_options = rename_options;
267
268 /* Out parameters */
269
270 if (DEBUGLEVEL >= 10) {
271 NDR_PRINT_IN_DEBUG(NetRenameMachineInDomain, &r);
272 }
273
274 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
275 werr = NetRenameMachineInDomain_l(ctx, &r);
276 } else {
277 werr = NetRenameMachineInDomain_r(ctx, &r);
278 }
279
280 r.out.result = W_ERROR_V(werr);
281
282 if (DEBUGLEVEL >= 10) {
283 NDR_PRINT_OUT_DEBUG(NetRenameMachineInDomain, &r);
284 }
285
286 TALLOC_FREE(frame);
287 return (NET_API_STATUS)r.out.result;
288 }
289
290 /****************************************************************
291 NetProvisionComputerAccount
292 ****************************************************************/
293
294 NET_API_STATUS NetProvisionComputerAccount(const char * domain /* [in] [ref] */,
295 const char * machine_name /* [in] [ref] */,
296 const char * machine_account_ou /* [in] [unique] */,
297 const char * dcname /* [in] [unique] */,
298 uint32_t options /* [in] */,
299 uint8_t **provision_bin_data /* [in,out] [unique] */,
300 uint32_t *provision_bin_data_size /* [in,out] [unique] */,
301 const char * *provision_text_data /* [in,out] [unique] */)
302 {
303 struct NetProvisionComputerAccount r;
304 struct libnetapi_ctx *ctx = NULL;
305 NET_API_STATUS status;
306 WERROR werr;
307 TALLOC_CTX *frame = talloc_stackframe();
308
309 ZERO_STRUCT(r);
310
311 status = libnetapi_getctx(&ctx);
312 if (status != 0) {
313 TALLOC_FREE(frame);
314 return status;
315 }
316
317 /* In parameters */
318 r.in.domain = domain;
319 r.in.machine_name = machine_name;
320 r.in.machine_account_ou = machine_account_ou;
321 r.in.dcname = dcname;
322 r.in.options = options;
323 r.in.provision_bin_data = provision_bin_data;
324 r.in.provision_bin_data_size = provision_bin_data_size;
325 r.in.provision_text_data = provision_text_data;
326
327 /* Out parameters */
328 r.out.provision_bin_data = provision_bin_data;
329 r.out.provision_bin_data_size = provision_bin_data_size;
330 r.out.provision_text_data = provision_text_data;
331
332 if (DEBUGLEVEL >= 10) {
333 NDR_PRINT_IN_DEBUG(NetProvisionComputerAccount, &r);
334 }
335
336 werr = NetProvisionComputerAccount_l(ctx, &r);
337
338 r.out.result = W_ERROR_V(werr);
339
340 if (DEBUGLEVEL >= 10) {
341 NDR_PRINT_OUT_DEBUG(NetProvisionComputerAccount, &r);
342 }
343
344 TALLOC_FREE(frame);
345 return (NET_API_STATUS)r.out.result;
346 }
347
348 /****************************************************************
349 NetRequestOfflineDomainJoin
350 ****************************************************************/
351
352 NET_API_STATUS NetRequestOfflineDomainJoin(uint8_t *provision_bin_data /* [in] [unique] */,
353 uint32_t provision_bin_data_size /* [in] */,
354 uint32_t options /* [in] */,
355 const char * windows_path /* [in] [unique] */)
356 {
357 struct NetRequestOfflineDomainJoin r;
358 struct libnetapi_ctx *ctx = NULL;
359 NET_API_STATUS status;
360 WERROR werr;
361 TALLOC_CTX *frame = talloc_stackframe();
362
363 ZERO_STRUCT(r);
364
365 status = libnetapi_getctx(&ctx);
366 if (status != 0) {
367 TALLOC_FREE(frame);
368 return status;
369 }
370
371 /* In parameters */
372 r.in.provision_bin_data = provision_bin_data;
373 r.in.provision_bin_data_size = provision_bin_data_size;
374 r.in.options = options;
375 r.in.windows_path = windows_path;
376
377 /* Out parameters */
378
379 if (DEBUGLEVEL >= 10) {
380 NDR_PRINT_IN_DEBUG(NetRequestOfflineDomainJoin, &r);
381 }
382
383 werr = NetRequestOfflineDomainJoin_l(ctx, &r);
384
385 r.out.result = W_ERROR_V(werr);
386
387 if (DEBUGLEVEL >= 10) {
388 NDR_PRINT_OUT_DEBUG(NetRequestOfflineDomainJoin, &r);
389 }
390
391 TALLOC_FREE(frame);
392 return (NET_API_STATUS)r.out.result;
393 }
394
395 /****************************************************************
396 NetComposeOfflineDomainJoin
397 ****************************************************************/
398 NET_API_STATUS NetComposeOfflineDomainJoin(const char *dns_domain_name /* [in] [ref] */,
399 const char *netbios_domain_name /* [in] [ref] */,
400 struct domsid *domain_sid /* [in] [ref] */,
401 struct GUID *domain_guid /* [in] [ref] */,
402 const char *forest_name /* [in] [ref] */,
403 const char *machine_account_name /* [in] [ref] */,
404 const char *machine_account_password /* [in] [ref] */,
405 const char *dc_name /* [in] [unique] */,
406 const char *dc_address /* [in] [unique] */,
407 int domain_is_ad /* [in] */,
408 uint8_t **compose_bin_data /* [in,out] [unique] */,
409 uint32_t *compose_bin_data_size /* [in,out] [unique] */,
410 const char * *compose_text_data /* [in,out] [unique] */)
411 {
412 struct NetComposeOfflineDomainJoin r;
413 struct libnetapi_ctx *ctx = NULL;
414 NET_API_STATUS status;
415 WERROR werr;
416 TALLOC_CTX *frame = talloc_stackframe();
417
418 ZERO_STRUCT(r);
419
420 status = libnetapi_getctx(&ctx);
421 if (status != 0) {
422 TALLOC_FREE(frame);
423 return status;
424 }
425
426 /* In parameters */
427 r.in.dns_domain_name = dns_domain_name;
428 r.in.netbios_domain_name = netbios_domain_name;
429 r.in.domain_sid = domain_sid;
430 r.in.domain_guid = domain_guid;
431 r.in.forest_name = forest_name;
432 r.in.machine_account_name = machine_account_name;
433 r.in.machine_account_password = machine_account_password;
434 r.in.dc_name = dc_name;
435 r.in.dc_address = dc_address;
436 r.in.domain_is_ad = domain_is_ad;
437 r.in.compose_bin_data = compose_bin_data;
438 r.in.compose_bin_data_size = compose_bin_data_size;
439 r.in.compose_text_data = compose_text_data;
440
441 /* Out parameters */
442 r.out.compose_bin_data = compose_bin_data;
443 r.out.compose_bin_data_size = compose_bin_data_size;
444 r.out.compose_text_data = compose_text_data;
445
446 if (DEBUGLEVEL >= 10) {
447 NDR_PRINT_IN_DEBUG(NetComposeOfflineDomainJoin, &r);
448 }
449
450 werr = NetComposeOfflineDomainJoin_l(ctx, &r);
451
452 r.out.result = W_ERROR_V(werr);
453
454 if (DEBUGLEVEL >= 10) {
455 NDR_PRINT_OUT_DEBUG(NetComposeOfflineDomainJoin, &r);
456 }
457
458 TALLOC_FREE(frame);
459 return (NET_API_STATUS)r.out.result;
460 }
461
462 /****************************************************************
463 NetServerGetInfo
464 ****************************************************************/
465
466 NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
467 uint32_t level /* [in] */,
468 uint8_t **buffer /* [out] [ref] */)
469 {
470 struct NetServerGetInfo r;
471 struct libnetapi_ctx *ctx = NULL;
472 NET_API_STATUS status;
473 WERROR werr;
474 TALLOC_CTX *frame = talloc_stackframe();
475
476 ZERO_STRUCT(r);
477
478 status = libnetapi_getctx(&ctx);
479 if (status != 0) {
480 TALLOC_FREE(frame);
481 return status;
482 }
483
484 /* In parameters */
485 r.in.server_name = server_name;
486 r.in.level = level;
487
488 /* Out parameters */
489 r.out.buffer = buffer;
490
491 if (DEBUGLEVEL >= 10) {
492 NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
493 }
494
495 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
496 werr = NetServerGetInfo_l(ctx, &r);
497 } else {
498 werr = NetServerGetInfo_r(ctx, &r);
499 }
500
501 r.out.result = W_ERROR_V(werr);
502
503 if (DEBUGLEVEL >= 10) {
504 NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
505 }
506
507 TALLOC_FREE(frame);
508 return (NET_API_STATUS)r.out.result;
509 }
510
511 /****************************************************************
512 NetServerSetInfo
513 ****************************************************************/
514
515 NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
516 uint32_t level /* [in] */,
517 uint8_t *buffer /* [in] [ref] */,
518 uint32_t *parm_error /* [out] [ref] */)
519 {
520 struct NetServerSetInfo r;
521 struct libnetapi_ctx *ctx = NULL;
522 NET_API_STATUS status;
523 WERROR werr;
524 TALLOC_CTX *frame = talloc_stackframe();
525
526 ZERO_STRUCT(r);
527
528 status = libnetapi_getctx(&ctx);
529 if (status != 0) {
530 TALLOC_FREE(frame);
531 return status;
532 }
533
534 /* In parameters */
535 r.in.server_name = server_name;
536 r.in.level = level;
537 r.in.buffer = buffer;
538
539 /* Out parameters */
540 r.out.parm_error = parm_error;
541
542 if (DEBUGLEVEL >= 10) {
543 NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
544 }
545
546 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
547 werr = NetServerSetInfo_l(ctx, &r);
548 } else {
549 werr = NetServerSetInfo_r(ctx, &r);
550 }
551
552 r.out.result = W_ERROR_V(werr);
553
554 if (DEBUGLEVEL >= 10) {
555 NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
556 }
557
558 TALLOC_FREE(frame);
559 return (NET_API_STATUS)r.out.result;
560 }
561
562 /****************************************************************
563 NetWkstaGetInfo
564 ****************************************************************/
565
566 NET_API_STATUS NetWkstaGetInfo(const char * server_name /* [in] [unique] */,
567 uint32_t level /* [in] */,
568 uint8_t **buffer /* [out] [ref] */)
569 {
570 struct NetWkstaGetInfo r;
571 struct libnetapi_ctx *ctx = NULL;
572 NET_API_STATUS status;
573 WERROR werr;
574 TALLOC_CTX *frame = talloc_stackframe();
575
576 ZERO_STRUCT(r);
577
578 status = libnetapi_getctx(&ctx);
579 if (status != 0) {
580 TALLOC_FREE(frame);
581 return status;
582 }
583
584 /* In parameters */
585 r.in.server_name = server_name;
586 r.in.level = level;
587
588 /* Out parameters */
589 r.out.buffer = buffer;
590
591 if (DEBUGLEVEL >= 10) {
592 NDR_PRINT_IN_DEBUG(NetWkstaGetInfo, &r);
593 }
594
595 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
596 werr = NetWkstaGetInfo_l(ctx, &r);
597 } else {
598 werr = NetWkstaGetInfo_r(ctx, &r);
599 }
600
601 r.out.result = W_ERROR_V(werr);
602
603 if (DEBUGLEVEL >= 10) {
604 NDR_PRINT_OUT_DEBUG(NetWkstaGetInfo, &r);
605 }
606
607 TALLOC_FREE(frame);
608 return (NET_API_STATUS)r.out.result;
609 }
610
611 /****************************************************************
612 NetGetDCName
613 ****************************************************************/
614
615 NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
616 const char * domain_name /* [in] [unique] */,
617 uint8_t **buffer /* [out] [ref] */)
618 {
619 struct NetGetDCName r;
620 struct libnetapi_ctx *ctx = NULL;
621 NET_API_STATUS status;
622 WERROR werr;
623 TALLOC_CTX *frame = talloc_stackframe();
624
625 ZERO_STRUCT(r);
626
627 status = libnetapi_getctx(&ctx);
628 if (status != 0) {
629 TALLOC_FREE(frame);
630 return status;
631 }
632
633 /* In parameters */
634 r.in.server_name = server_name;
635 r.in.domain_name = domain_name;
636
637 /* Out parameters */
638 r.out.buffer = buffer;
639
640 if (DEBUGLEVEL >= 10) {
641 NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
642 }
643
644 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
645 werr = NetGetDCName_l(ctx, &r);
646 } else {
647 werr = NetGetDCName_r(ctx, &r);
648 }
649
650 r.out.result = W_ERROR_V(werr);
651
652 if (DEBUGLEVEL >= 10) {
653 NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
654 }
655
656 TALLOC_FREE(frame);
657 return (NET_API_STATUS)r.out.result;
658 }
659
660 /****************************************************************
661 NetGetAnyDCName
662 ****************************************************************/
663
664 NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
665 const char * domain_name /* [in] [unique] */,
666 uint8_t **buffer /* [out] [ref] */)
667 {
668 struct NetGetAnyDCName r;
669 struct libnetapi_ctx *ctx = NULL;
670 NET_API_STATUS status;
671 WERROR werr;
672 TALLOC_CTX *frame = talloc_stackframe();
673
674 ZERO_STRUCT(r);
675
676 status = libnetapi_getctx(&ctx);
677 if (status != 0) {
678 TALLOC_FREE(frame);
679 return status;
680 }
681
682 /* In parameters */
683 r.in.server_name = server_name;
684 r.in.domain_name = domain_name;
685
686 /* Out parameters */
687 r.out.buffer = buffer;
688
689 if (DEBUGLEVEL >= 10) {
690 NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
691 }
692
693 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
694 werr = NetGetAnyDCName_l(ctx, &r);
695 } else {
696 werr = NetGetAnyDCName_r(ctx, &r);
697 }
698
699 r.out.result = W_ERROR_V(werr);
700
701 if (DEBUGLEVEL >= 10) {
702 NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
703 }
704
705 TALLOC_FREE(frame);
706 return (NET_API_STATUS)r.out.result;
707 }
708
709 /****************************************************************
710 DsGetDcName
711 ****************************************************************/
712
713 NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */,
714 const char * domain_name /* [in] [ref] */,
715 struct GUID *domain_guid /* [in] [unique] */,
716 const char * site_name /* [in] [unique] */,
717 uint32_t flags /* [in] */,
718 struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */)
719 {
720 struct DsGetDcName r;
721 struct libnetapi_ctx *ctx = NULL;
722 NET_API_STATUS status;
723 WERROR werr;
724 TALLOC_CTX *frame = talloc_stackframe();
725
726 ZERO_STRUCT(r);
727
728 status = libnetapi_getctx(&ctx);
729 if (status != 0) {
730 TALLOC_FREE(frame);
731 return status;
732 }
733
734 /* In parameters */
735 r.in.server_name = server_name;
736 r.in.domain_name = domain_name;
737 r.in.domain_guid = domain_guid;
738 r.in.site_name = site_name;
739 r.in.flags = flags;
740
741 /* Out parameters */
742 r.out.dc_info = dc_info;
743
744 if (DEBUGLEVEL >= 10) {
745 NDR_PRINT_IN_DEBUG(DsGetDcName, &r);
746 }
747
748 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
749 werr = DsGetDcName_l(ctx, &r);
750 } else {
751 werr = DsGetDcName_r(ctx, &r);
752 }
753
754 r.out.result = W_ERROR_V(werr);
755
756 if (DEBUGLEVEL >= 10) {
757 NDR_PRINT_OUT_DEBUG(DsGetDcName, &r);
758 }
759
760 TALLOC_FREE(frame);
761 return (NET_API_STATUS)r.out.result;
762 }
763
764 /****************************************************************
765 NetUserAdd
766 ****************************************************************/
767
768 NET_API_STATUS NetUserAdd(const char * server_name /* [in] [unique] */,
769 uint32_t level /* [in] */,
770 uint8_t *buffer /* [in] [ref] */,
771 uint32_t *parm_error /* [out] [ref] */)
772 {
773 struct NetUserAdd r;
774 struct libnetapi_ctx *ctx = NULL;
775 NET_API_STATUS status;
776 WERROR werr;
777 TALLOC_CTX *frame = talloc_stackframe();
778
779 ZERO_STRUCT(r);
780
781 status = libnetapi_getctx(&ctx);
782 if (status != 0) {
783 TALLOC_FREE(frame);
784 return status;
785 }
786
787 /* In parameters */
788 r.in.server_name = server_name;
789 r.in.level = level;
790 r.in.buffer = buffer;
791
792 /* Out parameters */
793 r.out.parm_error = parm_error;
794
795 if (DEBUGLEVEL >= 10) {
796 NDR_PRINT_IN_DEBUG(NetUserAdd, &r);
797 }
798
799 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
800 werr = NetUserAdd_l(ctx, &r);
801 } else {
802 werr = NetUserAdd_r(ctx, &r);
803 }
804
805 r.out.result = W_ERROR_V(werr);
806
807 if (DEBUGLEVEL >= 10) {
808 NDR_PRINT_OUT_DEBUG(NetUserAdd, &r);
809 }
810
811 TALLOC_FREE(frame);
812 return (NET_API_STATUS)r.out.result;
813 }
814
815 /****************************************************************
816 NetUserDel
817 ****************************************************************/
818
819 NET_API_STATUS NetUserDel(const char * server_name /* [in] [unique] */,
820 const char * user_name /* [in] [ref] */)
821 {
822 struct NetUserDel r;
823 struct libnetapi_ctx *ctx = NULL;
824 NET_API_STATUS status;
825 WERROR werr;
826 TALLOC_CTX *frame = talloc_stackframe();
827
828 ZERO_STRUCT(r);
829
830 status = libnetapi_getctx(&ctx);
831 if (status != 0) {
832 TALLOC_FREE(frame);
833 return status;
834 }
835
836 /* In parameters */
837 r.in.server_name = server_name;
838 r.in.user_name = user_name;
839
840 /* Out parameters */
841
842 if (DEBUGLEVEL >= 10) {
843 NDR_PRINT_IN_DEBUG(NetUserDel, &r);
844 }
845
846 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
847 werr = NetUserDel_l(ctx, &r);
848 } else {
849 werr = NetUserDel_r(ctx, &r);
850 }
851
852 r.out.result = W_ERROR_V(werr);
853
854 if (DEBUGLEVEL >= 10) {
855 NDR_PRINT_OUT_DEBUG(NetUserDel, &r);
856 }
857
858 TALLOC_FREE(frame);
859 return (NET_API_STATUS)r.out.result;
860 }
861
862 /****************************************************************
863 NetUserEnum
864 ****************************************************************/
865
866 NET_API_STATUS NetUserEnum(const char * server_name /* [in] [unique] */,
867 uint32_t level /* [in] */,
868 uint32_t filter /* [in] */,
869 uint8_t **buffer /* [out] [ref] */,
870 uint32_t prefmaxlen /* [in] */,
871 uint32_t *entries_read /* [out] [ref] */,
872 uint32_t *total_entries /* [out] [ref] */,
873 uint32_t *resume_handle /* [in,out] [ref] */)
874 {
875 struct NetUserEnum r;
876 struct libnetapi_ctx *ctx = NULL;
877 NET_API_STATUS status;
878 WERROR werr;
879 TALLOC_CTX *frame = talloc_stackframe();
880
881 ZERO_STRUCT(r);
882
883 status = libnetapi_getctx(&ctx);
884 if (status != 0) {
885 TALLOC_FREE(frame);
886 return status;
887 }
888
889 /* In parameters */
890 r.in.server_name = server_name;
891 r.in.level = level;
892 r.in.filter = filter;
893 r.in.prefmaxlen = prefmaxlen;
894 r.in.resume_handle = resume_handle;
895
896 /* Out parameters */
897 r.out.buffer = buffer;
898 r.out.entries_read = entries_read;
899 r.out.total_entries = total_entries;
900 r.out.resume_handle = resume_handle;
901
902 if (DEBUGLEVEL >= 10) {
903 NDR_PRINT_IN_DEBUG(NetUserEnum, &r);
904 }
905
906 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
907 werr = NetUserEnum_l(ctx, &r);
908 } else {
909 werr = NetUserEnum_r(ctx, &r);
910 }
911
912 r.out.result = W_ERROR_V(werr);
913
914 if (DEBUGLEVEL >= 10) {
915 NDR_PRINT_OUT_DEBUG(NetUserEnum, &r);
916 }
917
918 TALLOC_FREE(frame);
919 return (NET_API_STATUS)r.out.result;
920 }
921
922 /****************************************************************
923 NetUserChangePassword
924 ****************************************************************/
925
926 NET_API_STATUS NetUserChangePassword(const char * domain_name /* [in] */,
927 const char * user_name /* [in] */,
928 const char * old_password /* [in] */,
929 const char * new_password /* [in] */)
930 {
931 struct NetUserChangePassword r;
932 struct libnetapi_ctx *ctx = NULL;
933 NET_API_STATUS status;
934 WERROR werr;
935 TALLOC_CTX *frame = talloc_stackframe();
936
937 ZERO_STRUCT(r);
938
939 status = libnetapi_getctx(&ctx);
940 if (status != 0) {
941 TALLOC_FREE(frame);
942 return status;
943 }
944
945 /* In parameters */
946 r.in.domain_name = domain_name;
947 r.in.user_name = user_name;
948 r.in.old_password = old_password;
949 r.in.new_password = new_password;
950
951 /* Out parameters */
952
953 if (DEBUGLEVEL >= 10) {
954 NDR_PRINT_IN_DEBUG(NetUserChangePassword, &r);
955 }
956
957 werr = NetUserChangePassword_l(ctx, &r);
958
959 r.out.result = W_ERROR_V(werr);
960
961 if (DEBUGLEVEL >= 10) {
962 NDR_PRINT_OUT_DEBUG(NetUserChangePassword, &r);
963 }
964
965 TALLOC_FREE(frame);
966 return (NET_API_STATUS)r.out.result;
967 }
968
969 /****************************************************************
970 NetUserGetInfo
971 ****************************************************************/
972
973 NET_API_STATUS NetUserGetInfo(const char * server_name /* [in] */,
974 const char * user_name /* [in] */,
975 uint32_t level /* [in] */,
976 uint8_t **buffer /* [out] [ref] */)
977 {
978 struct NetUserGetInfo r;
979 struct libnetapi_ctx *ctx = NULL;
980 NET_API_STATUS status;
981 WERROR werr;
982 TALLOC_CTX *frame = talloc_stackframe();
983
984 ZERO_STRUCT(r);
985
986 status = libnetapi_getctx(&ctx);
987 if (status != 0) {
988 TALLOC_FREE(frame);
989 return status;
990 }
991
992 /* In parameters */
993 r.in.server_name = server_name;
994 r.in.user_name = user_name;
995 r.in.level = level;
996
997 /* Out parameters */
998 r.out.buffer = buffer;
999
1000 if (DEBUGLEVEL >= 10) {
1001 NDR_PRINT_IN_DEBUG(NetUserGetInfo, &r);
1002 }
1003
1004 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1005 werr = NetUserGetInfo_l(ctx, &r);
1006 } else {
1007 werr = NetUserGetInfo_r(ctx, &r);
1008 }
1009
1010 r.out.result = W_ERROR_V(werr);
1011
1012 if (DEBUGLEVEL >= 10) {
1013 NDR_PRINT_OUT_DEBUG(NetUserGetInfo, &r);
1014 }
1015
1016 TALLOC_FREE(frame);
1017 return (NET_API_STATUS)r.out.result;
1018 }
1019
1020 /****************************************************************
1021 NetUserSetInfo
1022 ****************************************************************/
1023
1024 NET_API_STATUS NetUserSetInfo(const char * server_name /* [in] */,
1025 const char * user_name /* [in] */,
1026 uint32_t level /* [in] */,
1027 uint8_t *buffer /* [in] [ref] */,
1028 uint32_t *parm_err /* [out] [ref] */)
1029 {
1030 struct NetUserSetInfo r;
1031 struct libnetapi_ctx *ctx = NULL;
1032 NET_API_STATUS status;
1033 WERROR werr;
1034 TALLOC_CTX *frame = talloc_stackframe();
1035
1036 ZERO_STRUCT(r);
1037
1038 status = libnetapi_getctx(&ctx);
1039 if (status != 0) {
1040 TALLOC_FREE(frame);
1041 return status;
1042 }
1043
1044 /* In parameters */
1045 r.in.server_name = server_name;
1046 r.in.user_name = user_name;
1047 r.in.level = level;
1048 r.in.buffer = buffer;
1049
1050 /* Out parameters */
1051 r.out.parm_err = parm_err;
1052
1053 if (DEBUGLEVEL >= 10) {
1054 NDR_PRINT_IN_DEBUG(NetUserSetInfo, &r);
1055 }
1056
1057 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1058 werr = NetUserSetInfo_l(ctx, &r);
1059 } else {
1060 werr = NetUserSetInfo_r(ctx, &r);
1061 }
1062
1063 r.out.result = W_ERROR_V(werr);
1064
1065 if (DEBUGLEVEL >= 10) {
1066 NDR_PRINT_OUT_DEBUG(NetUserSetInfo, &r);
1067 }
1068
1069 TALLOC_FREE(frame);
1070 return (NET_API_STATUS)r.out.result;
1071 }
1072
1073 /****************************************************************
1074 NetUserGetGroups
1075 ****************************************************************/
1076
1077 NET_API_STATUS NetUserGetGroups(const char * server_name /* [in] */,
1078 const char * user_name /* [in] */,
1079 uint32_t level /* [in] */,
1080 uint8_t **buffer /* [out] [ref] */,
1081 uint32_t prefmaxlen /* [in] */,
1082 uint32_t *entries_read /* [out] [ref] */,
1083 uint32_t *total_entries /* [out] [ref] */)
1084 {
1085 struct NetUserGetGroups r;
1086 struct libnetapi_ctx *ctx = NULL;
1087 NET_API_STATUS status;
1088 WERROR werr;
1089 TALLOC_CTX *frame = talloc_stackframe();
1090
1091 ZERO_STRUCT(r);
1092
1093 status = libnetapi_getctx(&ctx);
1094 if (status != 0) {
1095 TALLOC_FREE(frame);
1096 return status;
1097 }
1098
1099 /* In parameters */
1100 r.in.server_name = server_name;
1101 r.in.user_name = user_name;
1102 r.in.level = level;
1103 r.in.prefmaxlen = prefmaxlen;
1104
1105 /* Out parameters */
1106 r.out.buffer = buffer;
1107 r.out.entries_read = entries_read;
1108 r.out.total_entries = total_entries;
1109
1110 if (DEBUGLEVEL >= 10) {
1111 NDR_PRINT_IN_DEBUG(NetUserGetGroups, &r);
1112 }
1113
1114 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1115 werr = NetUserGetGroups_l(ctx, &r);
1116 } else {
1117 werr = NetUserGetGroups_r(ctx, &r);
1118 }
1119
1120 r.out.result = W_ERROR_V(werr);
1121
1122 if (DEBUGLEVEL >= 10) {
1123 NDR_PRINT_OUT_DEBUG(NetUserGetGroups, &r);
1124 }
1125
1126 TALLOC_FREE(frame);
1127 return (NET_API_STATUS)r.out.result;
1128 }
1129
1130 /****************************************************************
1131 NetUserSetGroups
1132 ****************************************************************/
1133
1134 NET_API_STATUS NetUserSetGroups(const char * server_name /* [in] */,
1135 const char * user_name /* [in] */,
1136 uint32_t level /* [in] */,
1137 uint8_t *buffer /* [in] [ref] */,
1138 uint32_t num_entries /* [in] */)
1139 {
1140 struct NetUserSetGroups r;
1141 struct libnetapi_ctx *ctx = NULL;
1142 NET_API_STATUS status;
1143 WERROR werr;
1144 TALLOC_CTX *frame = talloc_stackframe();
1145
1146 ZERO_STRUCT(r);
1147
1148 status = libnetapi_getctx(&ctx);
1149 if (status != 0) {
1150 TALLOC_FREE(frame);
1151 return status;
1152 }
1153
1154 /* In parameters */
1155 r.in.server_name = server_name;
1156 r.in.user_name = user_name;
1157 r.in.level = level;
1158 r.in.buffer = buffer;
1159 r.in.num_entries = num_entries;
1160
1161 /* Out parameters */
1162
1163 if (DEBUGLEVEL >= 10) {
1164 NDR_PRINT_IN_DEBUG(NetUserSetGroups, &r);
1165 }
1166
1167 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1168 werr = NetUserSetGroups_l(ctx, &r);
1169 } else {
1170 werr = NetUserSetGroups_r(ctx, &r);
1171 }
1172
1173 r.out.result = W_ERROR_V(werr);
1174
1175 if (DEBUGLEVEL >= 10) {
1176 NDR_PRINT_OUT_DEBUG(NetUserSetGroups, &r);
1177 }
1178
1179 TALLOC_FREE(frame);
1180 return (NET_API_STATUS)r.out.result;
1181 }
1182
1183 /****************************************************************
1184 NetUserGetLocalGroups
1185 ****************************************************************/
1186
1187 NET_API_STATUS NetUserGetLocalGroups(const char * server_name /* [in] */,
1188 const char * user_name /* [in] */,
1189 uint32_t level /* [in] */,
1190 uint32_t flags /* [in] */,
1191 uint8_t **buffer /* [out] [ref] */,
1192 uint32_t prefmaxlen /* [in] */,
1193 uint32_t *entries_read /* [out] [ref] */,
1194 uint32_t *total_entries /* [out] [ref] */)
1195 {
1196 struct NetUserGetLocalGroups r;
1197 struct libnetapi_ctx *ctx = NULL;
1198 NET_API_STATUS status;
1199 WERROR werr;
1200 TALLOC_CTX *frame = talloc_stackframe();
1201
1202 ZERO_STRUCT(r);
1203
1204 status = libnetapi_getctx(&ctx);
1205 if (status != 0) {
1206 TALLOC_FREE(frame);
1207 return status;
1208 }
1209
1210 /* In parameters */
1211 r.in.server_name = server_name;
1212 r.in.user_name = user_name;
1213 r.in.level = level;
1214 r.in.flags = flags;
1215 r.in.prefmaxlen = prefmaxlen;
1216
1217 /* Out parameters */
1218 r.out.buffer = buffer;
1219 r.out.entries_read = entries_read;
1220 r.out.total_entries = total_entries;
1221
1222 if (DEBUGLEVEL >= 10) {
1223 NDR_PRINT_IN_DEBUG(NetUserGetLocalGroups, &r);
1224 }
1225
1226 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1227 werr = NetUserGetLocalGroups_l(ctx, &r);
1228 } else {
1229 werr = NetUserGetLocalGroups_r(ctx, &r);
1230 }
1231
1232 r.out.result = W_ERROR_V(werr);
1233
1234 if (DEBUGLEVEL >= 10) {
1235 NDR_PRINT_OUT_DEBUG(NetUserGetLocalGroups, &r);
1236 }
1237
1238 TALLOC_FREE(frame);
1239 return (NET_API_STATUS)r.out.result;
1240 }
1241
1242 /****************************************************************
1243 NetUserModalsGet
1244 ****************************************************************/
1245
1246 NET_API_STATUS NetUserModalsGet(const char * server_name /* [in] */,
1247 uint32_t level /* [in] */,
1248 uint8_t **buffer /* [out] [ref] */)
1249 {
1250 struct NetUserModalsGet r;
1251 struct libnetapi_ctx *ctx = NULL;
1252 NET_API_STATUS status;
1253 WERROR werr;
1254 TALLOC_CTX *frame = talloc_stackframe();
1255
1256 ZERO_STRUCT(r);
1257
1258 status = libnetapi_getctx(&ctx);
1259 if (status != 0) {
1260 TALLOC_FREE(frame);
1261 return status;
1262 }
1263
1264 /* In parameters */
1265 r.in.server_name = server_name;
1266 r.in.level = level;
1267
1268 /* Out parameters */
1269 r.out.buffer = buffer;
1270
1271 if (DEBUGLEVEL >= 10) {
1272 NDR_PRINT_IN_DEBUG(NetUserModalsGet, &r);
1273 }
1274
1275 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1276 werr = NetUserModalsGet_l(ctx, &r);
1277 } else {
1278 werr = NetUserModalsGet_r(ctx, &r);
1279 }
1280
1281 r.out.result = W_ERROR_V(werr);
1282
1283 if (DEBUGLEVEL >= 10) {
1284 NDR_PRINT_OUT_DEBUG(NetUserModalsGet, &r);
1285 }
1286
1287 TALLOC_FREE(frame);
1288 return (NET_API_STATUS)r.out.result;
1289 }
1290
1291 /****************************************************************
1292 NetUserModalsSet
1293 ****************************************************************/
1294
1295 NET_API_STATUS NetUserModalsSet(const char * server_name /* [in] */,
1296 uint32_t level /* [in] */,
1297 uint8_t *buffer /* [in] [ref] */,
1298 uint32_t *parm_err /* [out] [ref] */)
1299 {
1300 struct NetUserModalsSet r;
1301 struct libnetapi_ctx *ctx = NULL;
1302 NET_API_STATUS status;
1303 WERROR werr;
1304 TALLOC_CTX *frame = talloc_stackframe();
1305
1306 ZERO_STRUCT(r);
1307
1308 status = libnetapi_getctx(&ctx);
1309 if (status != 0) {
1310 TALLOC_FREE(frame);
1311 return status;
1312 }
1313
1314 /* In parameters */
1315 r.in.server_name = server_name;
1316 r.in.level = level;
1317 r.in.buffer = buffer;
1318
1319 /* Out parameters */
1320 r.out.parm_err = parm_err;
1321
1322 if (DEBUGLEVEL >= 10) {
1323 NDR_PRINT_IN_DEBUG(NetUserModalsSet, &r);
1324 }
1325
1326 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1327 werr = NetUserModalsSet_l(ctx, &r);
1328 } else {
1329 werr = NetUserModalsSet_r(ctx, &r);
1330 }
1331
1332 r.out.result = W_ERROR_V(werr);
1333
1334 if (DEBUGLEVEL >= 10) {
1335 NDR_PRINT_OUT_DEBUG(NetUserModalsSet, &r);
1336 }
1337
1338 TALLOC_FREE(frame);
1339 return (NET_API_STATUS)r.out.result;
1340 }
1341
1342 /****************************************************************
1343 NetQueryDisplayInformation
1344 ****************************************************************/
1345
1346 NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */,
1347 uint32_t level /* [in] */,
1348 uint32_t idx /* [in] */,
1349 uint32_t entries_requested /* [in] */,
1350 uint32_t prefmaxlen /* [in] */,
1351 uint32_t *entries_read /* [out] [ref] */,
1352 void **buffer /* [out] [noprint,ref] */)
1353 {
1354 struct NetQueryDisplayInformation r;
1355 struct libnetapi_ctx *ctx = NULL;
1356 NET_API_STATUS status;
1357 WERROR werr;
1358 TALLOC_CTX *frame = talloc_stackframe();
1359
1360 ZERO_STRUCT(r);
1361
1362 status = libnetapi_getctx(&ctx);
1363 if (status != 0) {
1364 TALLOC_FREE(frame);
1365 return status;
1366 }
1367
1368 /* In parameters */
1369 r.in.server_name = server_name;
1370 r.in.level = level;
1371 r.in.idx = idx;
1372 r.in.entries_requested = entries_requested;
1373 r.in.prefmaxlen = prefmaxlen;
1374
1375 /* Out parameters */
1376 r.out.entries_read = entries_read;
1377 r.out.buffer = buffer;
1378
1379 if (DEBUGLEVEL >= 10) {
1380 NDR_PRINT_IN_DEBUG(NetQueryDisplayInformation, &r);
1381 }
1382
1383 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1384 werr = NetQueryDisplayInformation_l(ctx, &r);
1385 } else {
1386 werr = NetQueryDisplayInformation_r(ctx, &r);
1387 }
1388
1389 r.out.result = W_ERROR_V(werr);
1390
1391 if (DEBUGLEVEL >= 10) {
1392 NDR_PRINT_OUT_DEBUG(NetQueryDisplayInformation, &r);
1393 }
1394
1395 TALLOC_FREE(frame);
1396 return (NET_API_STATUS)r.out.result;
1397 }
1398
1399 /****************************************************************
1400 NetGroupAdd
1401 ****************************************************************/
1402
1403 NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */,
1404 uint32_t level /* [in] */,
1405 uint8_t *buffer /* [in] [ref] */,
1406 uint32_t *parm_err /* [out] [ref] */)
1407 {
1408 struct NetGroupAdd r;
1409 struct libnetapi_ctx *ctx = NULL;
1410 NET_API_STATUS status;
1411 WERROR werr;
1412 TALLOC_CTX *frame = talloc_stackframe();
1413
1414 ZERO_STRUCT(r);
1415
1416 status = libnetapi_getctx(&ctx);
1417 if (status != 0) {
1418 TALLOC_FREE(frame);
1419 return status;
1420 }
1421
1422 /* In parameters */
1423 r.in.server_name = server_name;
1424 r.in.level = level;
1425 r.in.buffer = buffer;
1426
1427 /* Out parameters */
1428 r.out.parm_err = parm_err;
1429
1430 if (DEBUGLEVEL >= 10) {
1431 NDR_PRINT_IN_DEBUG(NetGroupAdd, &r);
1432 }
1433
1434 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1435 werr = NetGroupAdd_l(ctx, &r);
1436 } else {
1437 werr = NetGroupAdd_r(ctx, &r);
1438 }
1439
1440 r.out.result = W_ERROR_V(werr);
1441
1442 if (DEBUGLEVEL >= 10) {
1443 NDR_PRINT_OUT_DEBUG(NetGroupAdd, &r);
1444 }
1445
1446 TALLOC_FREE(frame);
1447 return (NET_API_STATUS)r.out.result;
1448 }
1449
1450 /****************************************************************
1451 NetGroupDel
1452 ****************************************************************/
1453
1454 NET_API_STATUS NetGroupDel(const char * server_name /* [in] */,
1455 const char * group_name /* [in] */)
1456 {
1457 struct NetGroupDel r;
1458 struct libnetapi_ctx *ctx = NULL;
1459 NET_API_STATUS status;
1460 WERROR werr;
1461 TALLOC_CTX *frame = talloc_stackframe();
1462
1463 ZERO_STRUCT(r);
1464
1465 status = libnetapi_getctx(&ctx);
1466 if (status != 0) {
1467 TALLOC_FREE(frame);
1468 return status;
1469 }
1470
1471 /* In parameters */
1472 r.in.server_name = server_name;
1473 r.in.group_name = group_name;
1474
1475 /* Out parameters */
1476
1477 if (DEBUGLEVEL >= 10) {
1478 NDR_PRINT_IN_DEBUG(NetGroupDel, &r);
1479 }
1480
1481 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1482 werr = NetGroupDel_l(ctx, &r);
1483 } else {
1484 werr = NetGroupDel_r(ctx, &r);
1485 }
1486
1487 r.out.result = W_ERROR_V(werr);
1488
1489 if (DEBUGLEVEL >= 10) {
1490 NDR_PRINT_OUT_DEBUG(NetGroupDel, &r);
1491 }
1492
1493 TALLOC_FREE(frame);
1494 return (NET_API_STATUS)r.out.result;
1495 }
1496
1497 /****************************************************************
1498 NetGroupEnum
1499 ****************************************************************/
1500
1501 NET_API_STATUS NetGroupEnum(const char * server_name /* [in] */,
1502 uint32_t level /* [in] */,
1503 uint8_t **buffer /* [out] [ref] */,
1504 uint32_t prefmaxlen /* [in] */,
1505 uint32_t *entries_read /* [out] [ref] */,
1506 uint32_t *total_entries /* [out] [ref] */,
1507 uint32_t *resume_handle /* [in,out] [ref] */)
1508 {
1509 struct NetGroupEnum r;
1510 struct libnetapi_ctx *ctx = NULL;
1511 NET_API_STATUS status;
1512 WERROR werr;
1513 TALLOC_CTX *frame = talloc_stackframe();
1514
1515 ZERO_STRUCT(r);
1516
1517 status = libnetapi_getctx(&ctx);
1518 if (status != 0) {
1519 TALLOC_FREE(frame);
1520 return status;
1521 }
1522
1523 /* In parameters */
1524 r.in.server_name = server_name;
1525 r.in.level = level;
1526 r.in.prefmaxlen = prefmaxlen;
1527 r.in.resume_handle = resume_handle;
1528
1529 /* Out parameters */
1530 r.out.buffer = buffer;
1531 r.out.entries_read = entries_read;
1532 r.out.total_entries = total_entries;
1533 r.out.resume_handle = resume_handle;
1534
1535 if (DEBUGLEVEL >= 10) {
1536 NDR_PRINT_IN_DEBUG(NetGroupEnum, &r);
1537 }
1538
1539 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1540 werr = NetGroupEnum_l(ctx, &r);
1541 } else {
1542 werr = NetGroupEnum_r(ctx, &r);
1543 }
1544
1545 r.out.result = W_ERROR_V(werr);
1546
1547 if (DEBUGLEVEL >= 10) {
1548 NDR_PRINT_OUT_DEBUG(NetGroupEnum, &r);
1549 }
1550
1551 TALLOC_FREE(frame);
1552 return (NET_API_STATUS)r.out.result;
1553 }
1554
1555 /****************************************************************
1556 NetGroupSetInfo
1557 ****************************************************************/
1558
1559 NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */,
1560 const char * group_name /* [in] */,
1561 uint32_t level /* [in] */,
1562 uint8_t *buffer /* [in] [ref] */,
1563 uint32_t *parm_err /* [out] [ref] */)
1564 {
1565 struct NetGroupSetInfo r;
1566 struct libnetapi_ctx *ctx = NULL;
1567 NET_API_STATUS status;
1568 WERROR werr;
1569 TALLOC_CTX *frame = talloc_stackframe();
1570
1571 ZERO_STRUCT(r);
1572
1573 status = libnetapi_getctx(&ctx);
1574 if (status != 0) {
1575 TALLOC_FREE(frame);
1576 return status;
1577 }
1578
1579 /* In parameters */
1580 r.in.server_name = server_name;
1581 r.in.group_name = group_name;
1582 r.in.level = level;
1583 r.in.buffer = buffer;
1584
1585 /* Out parameters */
1586 r.out.parm_err = parm_err;
1587
1588 if (DEBUGLEVEL >= 10) {
1589 NDR_PRINT_IN_DEBUG(NetGroupSetInfo, &r);
1590 }
1591
1592 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1593 werr = NetGroupSetInfo_l(ctx, &r);
1594 } else {
1595 werr = NetGroupSetInfo_r(ctx, &r);
1596 }
1597
1598 r.out.result = W_ERROR_V(werr);
1599
1600 if (DEBUGLEVEL >= 10) {
1601 NDR_PRINT_OUT_DEBUG(NetGroupSetInfo, &r);
1602 }
1603
1604 TALLOC_FREE(frame);
1605 return (NET_API_STATUS)r.out.result;
1606 }
1607
1608 /****************************************************************
1609 NetGroupGetInfo
1610 ****************************************************************/
1611
1612 NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */,
1613 const char * group_name /* [in] */,
1614 uint32_t level /* [in] */,
1615 uint8_t **buffer /* [out] [ref] */)
1616 {
1617 struct NetGroupGetInfo r;
1618 struct libnetapi_ctx *ctx = NULL;
1619 NET_API_STATUS status;
1620 WERROR werr;
1621 TALLOC_CTX *frame = talloc_stackframe();
1622
1623 ZERO_STRUCT(r);
1624
1625 status = libnetapi_getctx(&ctx);
1626 if (status != 0) {
1627 TALLOC_FREE(frame);
1628 return status;
1629 }
1630
1631 /* In parameters */
1632 r.in.server_name = server_name;
1633 r.in.group_name = group_name;
1634 r.in.level = level;
1635
1636 /* Out parameters */
1637 r.out.buffer = buffer;
1638
1639 if (DEBUGLEVEL >= 10) {
1640 NDR_PRINT_IN_DEBUG(NetGroupGetInfo, &r);
1641 }
1642
1643 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1644 werr = NetGroupGetInfo_l(ctx, &r);
1645 } else {
1646 werr = NetGroupGetInfo_r(ctx, &r);
1647 }
1648
1649 r.out.result = W_ERROR_V(werr);
1650
1651 if (DEBUGLEVEL >= 10) {
1652 NDR_PRINT_OUT_DEBUG(NetGroupGetInfo, &r);
1653 }
1654
1655 TALLOC_FREE(frame);
1656 return (NET_API_STATUS)r.out.result;
1657 }
1658
1659 /****************************************************************
1660 NetGroupAddUser
1661 ****************************************************************/
1662
1663 NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */,
1664 const char * group_name /* [in] */,
1665 const char * user_name /* [in] */)
1666 {
1667 struct NetGroupAddUser r;
1668 struct libnetapi_ctx *ctx = NULL;
1669 NET_API_STATUS status;
1670 WERROR werr;
1671 TALLOC_CTX *frame = talloc_stackframe();
1672
1673 ZERO_STRUCT(r);
1674
1675 status = libnetapi_getctx(&ctx);
1676 if (status != 0) {
1677 TALLOC_FREE(frame);
1678 return status;
1679 }
1680
1681 /* In parameters */
1682 r.in.server_name = server_name;
1683 r.in.group_name = group_name;
1684 r.in.user_name = user_name;
1685
1686 /* Out parameters */
1687
1688 if (DEBUGLEVEL >= 10) {
1689 NDR_PRINT_IN_DEBUG(NetGroupAddUser, &r);
1690 }
1691
1692 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1693 werr = NetGroupAddUser_l(ctx, &r);
1694 } else {
1695 werr = NetGroupAddUser_r(ctx, &r);
1696 }
1697
1698 r.out.result = W_ERROR_V(werr);
1699
1700 if (DEBUGLEVEL >= 10) {
1701 NDR_PRINT_OUT_DEBUG(NetGroupAddUser, &r);
1702 }
1703
1704 TALLOC_FREE(frame);
1705 return (NET_API_STATUS)r.out.result;
1706 }
1707
1708 /****************************************************************
1709 NetGroupDelUser
1710 ****************************************************************/
1711
1712 NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */,
1713 const char * group_name /* [in] */,
1714 const char * user_name /* [in] */)
1715 {
1716 struct NetGroupDelUser r;
1717 struct libnetapi_ctx *ctx = NULL;
1718 NET_API_STATUS status;
1719 WERROR werr;
1720 TALLOC_CTX *frame = talloc_stackframe();
1721
1722 ZERO_STRUCT(r);
1723
1724 status = libnetapi_getctx(&ctx);
1725 if (status != 0) {
1726 TALLOC_FREE(frame);
1727 return status;
1728 }
1729
1730 /* In parameters */
1731 r.in.server_name = server_name;
1732 r.in.group_name = group_name;
1733 r.in.user_name = user_name;
1734
1735 /* Out parameters */
1736
1737 if (DEBUGLEVEL >= 10) {
1738 NDR_PRINT_IN_DEBUG(NetGroupDelUser, &r);
1739 }
1740
1741 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1742 werr = NetGroupDelUser_l(ctx, &r);
1743 } else {
1744 werr = NetGroupDelUser_r(ctx, &r);
1745 }
1746
1747 r.out.result = W_ERROR_V(werr);
1748
1749 if (DEBUGLEVEL >= 10) {
1750 NDR_PRINT_OUT_DEBUG(NetGroupDelUser, &r);
1751 }
1752
1753 TALLOC_FREE(frame);
1754 return (NET_API_STATUS)r.out.result;
1755 }
1756
1757 /****************************************************************
1758 NetGroupGetUsers
1759 ****************************************************************/
1760
1761 NET_API_STATUS NetGroupGetUsers(const char * server_name /* [in] */,
1762 const char * group_name /* [in] */,
1763 uint32_t level /* [in] */,
1764 uint8_t **buffer /* [out] [ref] */,
1765 uint32_t prefmaxlen /* [in] */,
1766 uint32_t *entries_read /* [out] [ref] */,
1767 uint32_t *total_entries /* [out] [ref] */,
1768 uint32_t *resume_handle /* [in,out] [ref] */)
1769 {
1770 struct NetGroupGetUsers r;
1771 struct libnetapi_ctx *ctx = NULL;
1772 NET_API_STATUS status;
1773 WERROR werr;
1774 TALLOC_CTX *frame = talloc_stackframe();
1775
1776 ZERO_STRUCT(r);
1777
1778 status = libnetapi_getctx(&ctx);
1779 if (status != 0) {
1780 TALLOC_FREE(frame);
1781 return status;
1782 }
1783
1784 /* In parameters */
1785 r.in.server_name = server_name;
1786 r.in.group_name = group_name;
1787 r.in.level = level;
1788 r.in.prefmaxlen = prefmaxlen;
1789 r.in.resume_handle = resume_handle;
1790
1791 /* Out parameters */
1792 r.out.buffer = buffer;
1793 r.out.entries_read = entries_read;
1794 r.out.total_entries = total_entries;
1795 r.out.resume_handle = resume_handle;
1796
1797 if (DEBUGLEVEL >= 10) {
1798 NDR_PRINT_IN_DEBUG(NetGroupGetUsers, &r);
1799 }
1800
1801 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1802 werr = NetGroupGetUsers_l(ctx, &r);
1803 } else {
1804 werr = NetGroupGetUsers_r(ctx, &r);
1805 }
1806
1807 r.out.result = W_ERROR_V(werr);
1808
1809 if (DEBUGLEVEL >= 10) {
1810 NDR_PRINT_OUT_DEBUG(NetGroupGetUsers, &r);
1811 }
1812
1813 TALLOC_FREE(frame);
1814 return (NET_API_STATUS)r.out.result;
1815 }
1816
1817 /****************************************************************
1818 NetGroupSetUsers
1819 ****************************************************************/
1820
1821 NET_API_STATUS NetGroupSetUsers(const char * server_name /* [in] */,
1822 const char * group_name /* [in] */,
1823 uint32_t level /* [in] */,
1824 uint8_t *buffer /* [in] [ref] */,
1825 uint32_t num_entries /* [in] */)
1826 {
1827 struct NetGroupSetUsers r;
1828 struct libnetapi_ctx *ctx = NULL;
1829 NET_API_STATUS status;
1830 WERROR werr;
1831 TALLOC_CTX *frame = talloc_stackframe();
1832
1833 ZERO_STRUCT(r);
1834
1835 status = libnetapi_getctx(&ctx);
1836 if (status != 0) {
1837 TALLOC_FREE(frame);
1838 return status;
1839 }
1840
1841 /* In parameters */
1842 r.in.server_name = server_name;
1843 r.in.group_name = group_name;
1844 r.in.level = level;
1845 r.in.buffer = buffer;
1846 r.in.num_entries = num_entries;
1847
1848 /* Out parameters */
1849
1850 if (DEBUGLEVEL >= 10) {
1851 NDR_PRINT_IN_DEBUG(NetGroupSetUsers, &r);
1852 }
1853
1854 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1855 werr = NetGroupSetUsers_l(ctx, &r);
1856 } else {
1857 werr = NetGroupSetUsers_r(ctx, &r);
1858 }
1859
1860 r.out.result = W_ERROR_V(werr);
1861
1862 if (DEBUGLEVEL >= 10) {
1863 NDR_PRINT_OUT_DEBUG(NetGroupSetUsers, &r);
1864 }
1865
1866 TALLOC_FREE(frame);
1867 return (NET_API_STATUS)r.out.result;
1868 }
1869
1870 /****************************************************************
1871 NetLocalGroupAdd
1872 ****************************************************************/
1873
1874 NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */,
1875 uint32_t level /* [in] */,
1876 uint8_t *buffer /* [in] [ref] */,
1877 uint32_t *parm_err /* [out] [ref] */)
1878 {
1879 struct NetLocalGroupAdd r;
1880 struct libnetapi_ctx *ctx = NULL;
1881 NET_API_STATUS status;
1882 WERROR werr;
1883 TALLOC_CTX *frame = talloc_stackframe();
1884
1885 ZERO_STRUCT(r);
1886
1887 status = libnetapi_getctx(&ctx);
1888 if (status != 0) {
1889 TALLOC_FREE(frame);
1890 return status;
1891 }
1892
1893 /* In parameters */
1894 r.in.server_name = server_name;
1895 r.in.level = level;
1896 r.in.buffer = buffer;
1897
1898 /* Out parameters */
1899 r.out.parm_err = parm_err;
1900
1901 if (DEBUGLEVEL >= 10) {
1902 NDR_PRINT_IN_DEBUG(NetLocalGroupAdd, &r);
1903 }
1904
1905 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1906 werr = NetLocalGroupAdd_l(ctx, &r);
1907 } else {
1908 werr = NetLocalGroupAdd_r(ctx, &r);
1909 }
1910
1911 r.out.result = W_ERROR_V(werr);
1912
1913 if (DEBUGLEVEL >= 10) {
1914 NDR_PRINT_OUT_DEBUG(NetLocalGroupAdd, &r);
1915 }
1916
1917 TALLOC_FREE(frame);
1918 return (NET_API_STATUS)r.out.result;
1919 }
1920
1921 /****************************************************************
1922 NetLocalGroupDel
1923 ****************************************************************/
1924
1925 NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */,
1926 const char * group_name /* [in] */)
1927 {
1928 struct NetLocalGroupDel r;
1929 struct libnetapi_ctx *ctx = NULL;
1930 NET_API_STATUS status;
1931 WERROR werr;
1932 TALLOC_CTX *frame = talloc_stackframe();
1933
1934 ZERO_STRUCT(r);
1935
1936 status = libnetapi_getctx(&ctx);
1937 if (status != 0) {
1938 TALLOC_FREE(frame);
1939 return status;
1940 }
1941
1942 /* In parameters */
1943 r.in.server_name = server_name;
1944 r.in.group_name = group_name;
1945
1946 /* Out parameters */
1947
1948 if (DEBUGLEVEL >= 10) {
1949 NDR_PRINT_IN_DEBUG(NetLocalGroupDel, &r);
1950 }
1951
1952 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1953 werr = NetLocalGroupDel_l(ctx, &r);
1954 } else {
1955 werr = NetLocalGroupDel_r(ctx, &r);
1956 }
1957
1958 r.out.result = W_ERROR_V(werr);
1959
1960 if (DEBUGLEVEL >= 10) {
1961 NDR_PRINT_OUT_DEBUG(NetLocalGroupDel, &r);
1962 }
1963
1964 TALLOC_FREE(frame);
1965 return (NET_API_STATUS)r.out.result;
1966 }
1967
1968 /****************************************************************
1969 NetLocalGroupGetInfo
1970 ****************************************************************/
1971
1972 NET_API_STATUS NetLocalGroupGetInfo(const char * server_name /* [in] */,
1973 const char * group_name /* [in] */,
1974 uint32_t level /* [in] */,
1975 uint8_t **buffer /* [out] [ref] */)
1976 {
1977 struct NetLocalGroupGetInfo r;
1978 struct libnetapi_ctx *ctx = NULL;
1979 NET_API_STATUS status;
1980 WERROR werr;
1981 TALLOC_CTX *frame = talloc_stackframe();
1982
1983 ZERO_STRUCT(r);
1984
1985 status = libnetapi_getctx(&ctx);
1986 if (status != 0) {
1987 TALLOC_FREE(frame);
1988 return status;
1989 }
1990
1991 /* In parameters */
1992 r.in.server_name = server_name;
1993 r.in.group_name = group_name;
1994 r.in.level = level;
1995
1996 /* Out parameters */
1997 r.out.buffer = buffer;
1998
1999 if (DEBUGLEVEL >= 10) {
2000 NDR_PRINT_IN_DEBUG(NetLocalGroupGetInfo, &r);
2001 }
2002
2003 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2004 werr = NetLocalGroupGetInfo_l(ctx, &r);
2005 } else {
2006 werr = NetLocalGroupGetInfo_r(ctx, &r);
2007 }
2008
2009 r.out.result = W_ERROR_V(werr);
2010
2011 if (DEBUGLEVEL >= 10) {
2012 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetInfo, &r);
2013 }
2014
2015 TALLOC_FREE(frame);
2016 return (NET_API_STATUS)r.out.result;
2017 }
2018
2019 /****************************************************************
2020 NetLocalGroupSetInfo
2021 ****************************************************************/
2022
2023 NET_API_STATUS NetLocalGroupSetInfo(const char * server_name /* [in] */,
2024 const char * group_name /* [in] */,
2025 uint32_t level /* [in] */,
2026 uint8_t *buffer /* [in] [ref] */,
2027 uint32_t *parm_err /* [out] [ref] */)
2028 {
2029 struct NetLocalGroupSetInfo r;
2030 struct libnetapi_ctx *ctx = NULL;
2031 NET_API_STATUS status;
2032 WERROR werr;
2033 TALLOC_CTX *frame = talloc_stackframe();
2034
2035 ZERO_STRUCT(r);
2036
2037 status = libnetapi_getctx(&ctx);
2038 if (status != 0) {
2039 TALLOC_FREE(frame);
2040 return status;
2041 }
2042
2043 /* In parameters */
2044 r.in.server_name = server_name;
2045 r.in.group_name = group_name;
2046 r.in.level = level;
2047 r.in.buffer = buffer;
2048
2049 /* Out parameters */
2050 r.out.parm_err = parm_err;
2051
2052 if (DEBUGLEVEL >= 10) {
2053 NDR_PRINT_IN_DEBUG(NetLocalGroupSetInfo, &r);
2054 }
2055
2056 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2057 werr = NetLocalGroupSetInfo_l(ctx, &r);
2058 } else {
2059 werr = NetLocalGroupSetInfo_r(ctx, &r);
2060 }
2061
2062 r.out.result = W_ERROR_V(werr);
2063
2064 if (DEBUGLEVEL >= 10) {
2065 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetInfo, &r);
2066 }
2067
2068 TALLOC_FREE(frame);
2069 return (NET_API_STATUS)r.out.result;
2070 }
2071
2072 /****************************************************************
2073 NetLocalGroupEnum
2074 ****************************************************************/
2075
2076 NET_API_STATUS NetLocalGroupEnum(const char * server_name /* [in] */,
2077 uint32_t level /* [in] */,
2078 uint8_t **buffer /* [out] [ref] */,
2079 uint32_t prefmaxlen /* [in] */,
2080 uint32_t *entries_read /* [out] [ref] */,
2081 uint32_t *total_entries /* [out] [ref] */,
2082 uint32_t *resume_handle /* [in,out] [ref] */)
2083 {
2084 struct NetLocalGroupEnum r;
2085 struct libnetapi_ctx *ctx = NULL;
2086 NET_API_STATUS status;
2087 WERROR werr;
2088 TALLOC_CTX *frame = talloc_stackframe();
2089
2090 ZERO_STRUCT(r);
2091
2092 status = libnetapi_getctx(&ctx);
2093 if (status != 0) {
2094 TALLOC_FREE(frame);
2095 return status;
2096 }
2097
2098 /* In parameters */
2099 r.in.server_name = server_name;
2100 r.in.level = level;
2101 r.in.prefmaxlen = prefmaxlen;
2102 r.in.resume_handle = resume_handle;
2103
2104 /* Out parameters */
2105 r.out.buffer = buffer;
2106 r.out.entries_read = entries_read;
2107 r.out.total_entries = total_entries;
2108 r.out.resume_handle = resume_handle;
2109
2110 if (DEBUGLEVEL >= 10) {
2111 NDR_PRINT_IN_DEBUG(NetLocalGroupEnum, &r);
2112 }
2113
2114 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2115 werr = NetLocalGroupEnum_l(ctx, &r);
2116 } else {
2117 werr = NetLocalGroupEnum_r(ctx, &r);
2118 }
2119
2120 r.out.result = W_ERROR_V(werr);
2121
2122 if (DEBUGLEVEL >= 10) {
2123 NDR_PRINT_OUT_DEBUG(NetLocalGroupEnum, &r);
2124 }
2125
2126 TALLOC_FREE(frame);
2127 return (NET_API_STATUS)r.out.result;
2128 }
2129
2130 /****************************************************************
2131 NetLocalGroupAddMembers
2132 ****************************************************************/
2133
2134 NET_API_STATUS NetLocalGroupAddMembers(const char * server_name /* [in] */,
2135 const char * group_name /* [in] */,
2136 uint32_t level /* [in] */,
2137 uint8_t *buffer /* [in] [ref] */,
2138 uint32_t total_entries /* [in] */)
2139 {
2140 struct NetLocalGroupAddMembers r;
2141 struct libnetapi_ctx *ctx = NULL;
2142 NET_API_STATUS status;
2143 WERROR werr;
2144 TALLOC_CTX *frame = talloc_stackframe();
2145
2146 ZERO_STRUCT(r);
2147
2148 status = libnetapi_getctx(&ctx);
2149 if (status != 0) {
2150 TALLOC_FREE(frame);
2151 return status;
2152 }
2153
2154 /* In parameters */
2155 r.in.server_name = server_name;
2156 r.in.group_name = group_name;
2157 r.in.level = level;
2158 r.in.buffer = buffer;
2159 r.in.total_entries = total_entries;
2160
2161 /* Out parameters */
2162
2163 if (DEBUGLEVEL >= 10) {
2164 NDR_PRINT_IN_DEBUG(NetLocalGroupAddMembers, &r);
2165 }
2166
2167 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2168 werr = NetLocalGroupAddMembers_l(ctx, &r);
2169 } else {
2170 werr = NetLocalGroupAddMembers_r(ctx, &r);
2171 }
2172
2173 r.out.result = W_ERROR_V(werr);
2174
2175 if (DEBUGLEVEL >= 10) {
2176 NDR_PRINT_OUT_DEBUG(NetLocalGroupAddMembers, &r);
2177 }
2178
2179 TALLOC_FREE(frame);
2180 return (NET_API_STATUS)r.out.result;
2181 }
2182
2183 /****************************************************************
2184 NetLocalGroupDelMembers
2185 ****************************************************************/
2186
2187 NET_API_STATUS NetLocalGroupDelMembers(const char * server_name /* [in] */,
2188 const char * group_name /* [in] */,
2189 uint32_t level /* [in] */,
2190 uint8_t *buffer /* [in] [ref] */,
2191 uint32_t total_entries /* [in] */)
2192 {
2193 struct NetLocalGroupDelMembers r;
2194 struct libnetapi_ctx *ctx = NULL;
2195 NET_API_STATUS status;
2196 WERROR werr;
2197 TALLOC_CTX *frame = talloc_stackframe();
2198
2199 ZERO_STRUCT(r);
2200
2201 status = libnetapi_getctx(&ctx);
2202 if (status != 0) {
2203 TALLOC_FREE(frame);
2204 return status;
2205 }
2206
2207 /* In parameters */
2208 r.in.server_name = server_name;
2209 r.in.group_name = group_name;
2210 r.in.level = level;
2211 r.in.buffer = buffer;
2212 r.in.total_entries = total_entries;
2213
2214 /* Out parameters */
2215
2216 if (DEBUGLEVEL >= 10) {
2217 NDR_PRINT_IN_DEBUG(NetLocalGroupDelMembers, &r);
2218 }
2219
2220 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2221 werr = NetLocalGroupDelMembers_l(ctx, &r);
2222 } else {
2223 werr = NetLocalGroupDelMembers_r(ctx, &r);
2224 }
2225
2226 r.out.result = W_ERROR_V(werr);
2227
2228 if (DEBUGLEVEL >= 10) {
2229 NDR_PRINT_OUT_DEBUG(NetLocalGroupDelMembers, &r);
2230 }
2231
2232 TALLOC_FREE(frame);
2233 return (NET_API_STATUS)r.out.result;
2234 }
2235
2236 /****************************************************************
2237 NetLocalGroupGetMembers
2238 ****************************************************************/
2239
2240 NET_API_STATUS NetLocalGroupGetMembers(const char * server_name /* [in] */,
2241 const char * local_group_name /* [in] */,
2242 uint32_t level /* [in] */,
2243 uint8_t **buffer /* [out] [ref] */,
2244 uint32_t prefmaxlen /* [in] */,
2245 uint32_t *entries_read /* [out] [ref] */,
2246 uint32_t *total_entries /* [out] [ref] */,
2247 uint32_t *resume_handle /* [in,out] [ref] */)
2248 {
2249 struct NetLocalGroupGetMembers r;
2250 struct libnetapi_ctx *ctx = NULL;
2251 NET_API_STATUS status;
2252 WERROR werr;
2253 TALLOC_CTX *frame = talloc_stackframe();
2254
2255 ZERO_STRUCT(r);
2256
2257 status = libnetapi_getctx(&ctx);
2258 if (status != 0) {
2259 TALLOC_FREE(frame);
2260 return status;
2261 }
2262
2263 /* In parameters */
2264 r.in.server_name = server_name;
2265 r.in.local_group_name = local_group_name;
2266 r.in.level = level;
2267 r.in.prefmaxlen = prefmaxlen;
2268 r.in.resume_handle = resume_handle;
2269
2270 /* Out parameters */
2271 r.out.buffer = buffer;
2272 r.out.entries_read = entries_read;
2273 r.out.total_entries = total_entries;
2274 r.out.resume_handle = resume_handle;
2275
2276 if (DEBUGLEVEL >= 10) {
2277 NDR_PRINT_IN_DEBUG(NetLocalGroupGetMembers, &r);
2278 }
2279
2280 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2281 werr = NetLocalGroupGetMembers_l(ctx, &r);
2282 } else {
2283 werr = NetLocalGroupGetMembers_r(ctx, &r);
2284 }
2285
2286 r.out.result = W_ERROR_V(werr);
2287
2288 if (DEBUGLEVEL >= 10) {
2289 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetMembers, &r);
2290 }
2291
2292 TALLOC_FREE(frame);
2293 return (NET_API_STATUS)r.out.result;
2294 }
2295
2296 /****************************************************************
2297 NetLocalGroupSetMembers
2298 ****************************************************************/
2299
2300 NET_API_STATUS NetLocalGroupSetMembers(const char * server_name /* [in] */,
2301 const char * group_name /* [in] */,
2302 uint32_t level /* [in] */,
2303 uint8_t *buffer /* [in] [ref] */,
2304 uint32_t total_entries /* [in] */)
2305 {
2306 struct NetLocalGroupSetMembers r;
2307 struct libnetapi_ctx *ctx = NULL;
2308 NET_API_STATUS status;
2309 WERROR werr;
2310 TALLOC_CTX *frame = talloc_stackframe();
2311
2312 ZERO_STRUCT(r);
2313
2314 status = libnetapi_getctx(&ctx);
2315 if (status != 0) {
2316 TALLOC_FREE(frame);
2317 return status;
2318 }
2319
2320 /* In parameters */
2321 r.in.server_name = server_name;
2322 r.in.group_name = group_name;
2323 r.in.level = level;
2324 r.in.buffer = buffer;
2325 r.in.total_entries = total_entries;
2326
2327 /* Out parameters */
2328
2329 if (DEBUGLEVEL >= 10) {
2330 NDR_PRINT_IN_DEBUG(NetLocalGroupSetMembers, &r);
2331 }
2332
2333 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2334 werr = NetLocalGroupSetMembers_l(ctx, &r);
2335 } else {
2336 werr = NetLocalGroupSetMembers_r(ctx, &r);
2337 }
2338
2339 r.out.result = W_ERROR_V(werr);
2340
2341 if (DEBUGLEVEL >= 10) {
2342 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetMembers, &r);
2343 }
2344
2345 TALLOC_FREE(frame);
2346 return (NET_API_STATUS)r.out.result;
2347 }
2348
2349 /****************************************************************
2350 NetRemoteTOD
2351 ****************************************************************/
2352
2353 NET_API_STATUS NetRemoteTOD(const char * server_name /* [in] */,
2354 uint8_t **buffer /* [out] [ref] */)
2355 {
2356 struct NetRemoteTOD r;
2357 struct libnetapi_ctx *ctx = NULL;
2358 NET_API_STATUS status;
2359 WERROR werr;
2360 TALLOC_CTX *frame = talloc_stackframe();
2361
2362 ZERO_STRUCT(r);
2363
2364 status = libnetapi_getctx(&ctx);
2365 if (status != 0) {
2366 TALLOC_FREE(frame);
2367 return status;
2368 }
2369
2370 /* In parameters */
2371 r.in.server_name = server_name;
2372
2373 /* Out parameters */
2374 r.out.buffer = buffer;
2375
2376 if (DEBUGLEVEL >= 10) {
2377 NDR_PRINT_IN_DEBUG(NetRemoteTOD, &r);
2378 }
2379
2380 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2381 werr = NetRemoteTOD_l(ctx, &r);
2382 } else {
2383 werr = NetRemoteTOD_r(ctx, &r);
2384 }
2385
2386 r.out.result = W_ERROR_V(werr);
2387
2388 if (DEBUGLEVEL >= 10) {
2389 NDR_PRINT_OUT_DEBUG(NetRemoteTOD, &r);
2390 }
2391
2392 TALLOC_FREE(frame);
2393 return (NET_API_STATUS)r.out.result;
2394 }
2395
2396 /****************************************************************
2397 NetShareAdd
2398 ****************************************************************/
2399
2400 NET_API_STATUS NetShareAdd(const char * server_name /* [in] */,
2401 uint32_t level /* [in] */,
2402 uint8_t *buffer /* [in] [ref] */,
2403 uint32_t *parm_err /* [out] [ref] */)
2404 {
2405 struct NetShareAdd r;
2406 struct libnetapi_ctx *ctx = NULL;
2407 NET_API_STATUS status;
2408 WERROR werr;
2409 TALLOC_CTX *frame = talloc_stackframe();
2410
2411 ZERO_STRUCT(r);
2412
2413 status = libnetapi_getctx(&ctx);
2414 if (status != 0) {
2415 TALLOC_FREE(frame);
2416 return status;
2417 }
2418
2419 /* In parameters */
2420 r.in.server_name = server_name;
2421 r.in.level = level;
2422 r.in.buffer = buffer;
2423
2424 /* Out parameters */
2425 r.out.parm_err = parm_err;
2426
2427 if (DEBUGLEVEL >= 10) {
2428 NDR_PRINT_IN_DEBUG(NetShareAdd, &r);
2429 }
2430
2431 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2432 werr = NetShareAdd_l(ctx, &r);
2433 } else {
2434 werr = NetShareAdd_r(ctx, &r);
2435 }
2436
2437 r.out.result = W_ERROR_V(werr);
2438
2439 if (DEBUGLEVEL >= 10) {
2440 NDR_PRINT_OUT_DEBUG(NetShareAdd, &r);
2441 }
2442
2443 TALLOC_FREE(frame);
2444 return (NET_API_STATUS)r.out.result;
2445 }
2446
2447 /****************************************************************
2448 NetShareDel
2449 ****************************************************************/
2450
2451 NET_API_STATUS NetShareDel(const char * server_name /* [in] */,
2452 const char * net_name /* [in] */,
2453 uint32_t reserved /* [in] */)
2454 {
2455 struct NetShareDel r;
2456 struct libnetapi_ctx *ctx = NULL;
2457 NET_API_STATUS status;
2458 WERROR werr;
2459 TALLOC_CTX *frame = talloc_stackframe();
2460
2461 ZERO_STRUCT(r);
2462
2463 status = libnetapi_getctx(&ctx);
2464 if (status != 0) {
2465 TALLOC_FREE(frame);
2466 return status;
2467 }
2468
2469 /* In parameters */
2470 r.in.server_name = server_name;
2471 r.in.net_name = net_name;
2472 r.in.reserved = reserved;
2473
2474 /* Out parameters */
2475
2476 if (DEBUGLEVEL >= 10) {
2477 NDR_PRINT_IN_DEBUG(NetShareDel, &r);
2478 }
2479
2480 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2481 werr = NetShareDel_l(ctx, &r);
2482 } else {
2483 werr = NetShareDel_r(ctx, &r);
2484 }
2485
2486 r.out.result = W_ERROR_V(werr);
2487
2488 if (DEBUGLEVEL >= 10) {
2489 NDR_PRINT_OUT_DEBUG(NetShareDel, &r);
2490 }
2491
2492 TALLOC_FREE(frame);
2493 return (NET_API_STATUS)r.out.result;
2494 }
2495
2496 /****************************************************************
2497 NetShareEnum
2498 ****************************************************************/
2499
2500 NET_API_STATUS NetShareEnum(const char * server_name /* [in] */,
2501 uint32_t level /* [in] */,
2502 uint8_t **buffer /* [out] [ref] */,
2503 uint32_t prefmaxlen /* [in] */,
2504 uint32_t *entries_read /* [out] [ref] */,
2505 uint32_t *total_entries /* [out] [ref] */,
2506 uint32_t *resume_handle /* [in,out] [ref] */)
2507 {
2508 struct NetShareEnum r;
2509 struct libnetapi_ctx *ctx = NULL;
2510 NET_API_STATUS status;
2511 WERROR werr;
2512 TALLOC_CTX *frame = talloc_stackframe();
2513
2514 ZERO_STRUCT(r);
2515
2516 status = libnetapi_getctx(&ctx);
2517 if (status != 0) {
2518 TALLOC_FREE(frame);
2519 return status;
2520 }
2521
2522 /* In parameters */
2523 r.in.server_name = server_name;
2524 r.in.level = level;
2525 r.in.prefmaxlen = prefmaxlen;
2526 r.in.resume_handle = resume_handle;
2527
2528 /* Out parameters */
2529 r.out.buffer = buffer;
2530 r.out.entries_read = entries_read;
2531 r.out.total_entries = total_entries;
2532 r.out.resume_handle = resume_handle;
2533
2534 if (DEBUGLEVEL >= 10) {
2535 NDR_PRINT_IN_DEBUG(NetShareEnum, &r);
2536 }
2537
2538 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2539 werr = NetShareEnum_l(ctx, &r);
2540 } else {
2541 werr = NetShareEnum_r(ctx, &r);
2542 }
2543
2544 r.out.result = W_ERROR_V(werr);
2545
2546 if (DEBUGLEVEL >= 10) {
2547 NDR_PRINT_OUT_DEBUG(NetShareEnum, &r);
2548 }
2549
2550 TALLOC_FREE(frame);
2551 return (NET_API_STATUS)r.out.result;
2552 }
2553
2554 /****************************************************************
2555 NetShareGetInfo
2556 ****************************************************************/
2557
2558 NET_API_STATUS NetShareGetInfo(const char * server_name /* [in] */,
2559 const char * net_name /* [in] */,
2560 uint32_t level /* [in] */,
2561 uint8_t **buffer /* [out] [ref] */)
2562 {
2563 struct NetShareGetInfo r;
2564 struct libnetapi_ctx *ctx = NULL;
2565 NET_API_STATUS status;
2566 WERROR werr;
2567 TALLOC_CTX *frame = talloc_stackframe();
2568
2569 ZERO_STRUCT(r);
2570
2571 status = libnetapi_getctx(&ctx);
2572 if (status != 0) {
2573 TALLOC_FREE(frame);
2574 return status;
2575 }
2576
2577 /* In parameters */
2578 r.in.server_name = server_name;
2579 r.in.net_name = net_name;
2580 r.in.level = level;
2581
2582 /* Out parameters */
2583 r.out.buffer = buffer;
2584
2585 if (DEBUGLEVEL >= 10) {
2586 NDR_PRINT_IN_DEBUG(NetShareGetInfo, &r);
2587 }
2588
2589 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2590 werr = NetShareGetInfo_l(ctx, &r);
2591 } else {
2592 werr = NetShareGetInfo_r(ctx, &r);
2593 }
2594
2595 r.out.result = W_ERROR_V(werr);
2596
2597 if (DEBUGLEVEL >= 10) {
2598 NDR_PRINT_OUT_DEBUG(NetShareGetInfo, &r);
2599 }
2600
2601 TALLOC_FREE(frame);
2602 return (NET_API_STATUS)r.out.result;
2603 }
2604
2605 /****************************************************************
2606 NetShareSetInfo
2607 ****************************************************************/
2608
2609 NET_API_STATUS NetShareSetInfo(const char * server_name /* [in] */,
2610 const char * net_name /* [in] */,
2611 uint32_t level /* [in] */,
2612 uint8_t *buffer /* [in] [ref] */,
2613 uint32_t *parm_err /* [out] [ref] */)
2614 {
2615 struct NetShareSetInfo r;
2616 struct libnetapi_ctx *ctx = NULL;
2617 NET_API_STATUS status;
2618 WERROR werr;
2619 TALLOC_CTX *frame = talloc_stackframe();
2620
2621 ZERO_STRUCT(r);
2622
2623 status = libnetapi_getctx(&ctx);
2624 if (status != 0) {
2625 TALLOC_FREE(frame);
2626 return status;
2627 }
2628
2629 /* In parameters */
2630 r.in.server_name = server_name;
2631 r.in.net_name = net_name;
2632 r.in.level = level;
2633 r.in.buffer = buffer;
2634
2635 /* Out parameters */
2636 r.out.parm_err = parm_err;
2637
2638 if (DEBUGLEVEL >= 10) {
2639 NDR_PRINT_IN_DEBUG(NetShareSetInfo, &r);
2640 }
2641
2642 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2643 werr = NetShareSetInfo_l(ctx, &r);
2644 } else {
2645 werr = NetShareSetInfo_r(ctx, &r);
2646 }
2647
2648 r.out.result = W_ERROR_V(werr);
2649
2650 if (DEBUGLEVEL >= 10) {
2651 NDR_PRINT_OUT_DEBUG(NetShareSetInfo, &r);
2652 }
2653
2654 TALLOC_FREE(frame);
2655 return (NET_API_STATUS)r.out.result;
2656 }
2657
2658 /****************************************************************
2659 NetFileClose
2660 ****************************************************************/
2661
2662 NET_API_STATUS NetFileClose(const char * server_name /* [in] */,
2663 uint32_t fileid /* [in] */)
2664 {
2665 struct NetFileClose r;
2666 struct libnetapi_ctx *ctx = NULL;
2667 NET_API_STATUS status;
2668 WERROR werr;
2669 TALLOC_CTX *frame = talloc_stackframe();
2670
2671 ZERO_STRUCT(r);
2672
2673 status = libnetapi_getctx(&ctx);
2674 if (status != 0) {
2675 TALLOC_FREE(frame);
2676 return status;
2677 }
2678
2679 /* In parameters */
2680 r.in.server_name = server_name;
2681 r.in.fileid = fileid;
2682
2683 /* Out parameters */
2684
2685 if (DEBUGLEVEL >= 10) {
2686 NDR_PRINT_IN_DEBUG(NetFileClose, &r);
2687 }
2688
2689 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2690 werr = NetFileClose_l(ctx, &r);
2691 } else {
2692 werr = NetFileClose_r(ctx, &r);
2693 }
2694
2695 r.out.result = W_ERROR_V(werr);
2696
2697 if (DEBUGLEVEL >= 10) {
2698 NDR_PRINT_OUT_DEBUG(NetFileClose, &r);
2699 }
2700
2701 TALLOC_FREE(frame);
2702 return (NET_API_STATUS)r.out.result;
2703 }
2704
2705 /****************************************************************
2706 NetFileGetInfo
2707 ****************************************************************/
2708
2709 NET_API_STATUS NetFileGetInfo(const char * server_name /* [in] */,
2710 uint32_t fileid /* [in] */,
2711 uint32_t level /* [in] */,
2712 uint8_t **buffer /* [out] [ref] */)
2713 {
2714 struct NetFileGetInfo r;
2715 struct libnetapi_ctx *ctx = NULL;
2716 NET_API_STATUS status;
2717 WERROR werr;
2718 TALLOC_CTX *frame = talloc_stackframe();
2719
2720 ZERO_STRUCT(r);
2721
2722 status = libnetapi_getctx(&ctx);
2723 if (status != 0) {
2724 TALLOC_FREE(frame);
2725 return status;
2726 }
2727
2728 /* In parameters */
2729 r.in.server_name = server_name;
2730 r.in.fileid = fileid;
2731 r.in.level = level;
2732
2733 /* Out parameters */
2734 r.out.buffer = buffer;
2735
2736 if (DEBUGLEVEL >= 10) {
2737 NDR_PRINT_IN_DEBUG(NetFileGetInfo, &r);
2738 }
2739
2740 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2741 werr = NetFileGetInfo_l(ctx, &r);
2742 } else {
2743 werr = NetFileGetInfo_r(ctx, &r);
2744 }
2745
2746 r.out.result = W_ERROR_V(werr);
2747
2748 if (DEBUGLEVEL >= 10) {
2749 NDR_PRINT_OUT_DEBUG(NetFileGetInfo, &r);
2750 }
2751
2752 TALLOC_FREE(frame);
2753 return (NET_API_STATUS)r.out.result;
2754 }
2755
2756 /****************************************************************
2757 NetFileEnum
2758 ****************************************************************/
2759
2760 NET_API_STATUS NetFileEnum(const char * server_name /* [in] */,
2761 const char * base_path /* [in] */,
2762 const char * user_name /* [in] */,
2763 uint32_t level /* [in] */,
2764 uint8_t **buffer /* [out] [ref] */,
2765 uint32_t prefmaxlen /* [in] */,
2766 uint32_t *entries_read /* [out] [ref] */,
2767 uint32_t *total_entries /* [out] [ref] */,
2768 uint32_t *resume_handle /* [in,out] [ref] */)
2769 {
2770 struct NetFileEnum r;
2771 struct libnetapi_ctx *ctx = NULL;
2772 NET_API_STATUS status;
2773 WERROR werr;
2774 TALLOC_CTX *frame = talloc_stackframe();
2775
2776 ZERO_STRUCT(r);
2777
2778 status = libnetapi_getctx(&ctx);
2779 if (status != 0) {
2780 TALLOC_FREE(frame);
2781 return status;
2782 }
2783
2784 /* In parameters */
2785 r.in.server_name = server_name;
2786 r.in.base_path = base_path;
2787 r.in.user_name = user_name;
2788 r.in.level = level;
2789 r.in.prefmaxlen = prefmaxlen;
2790 r.in.resume_handle = resume_handle;
2791
2792 /* Out parameters */
2793 r.out.buffer = buffer;
2794 r.out.entries_read = entries_read;
2795 r.out.total_entries = total_entries;
2796 r.out.resume_handle = resume_handle;
2797
2798 if (DEBUGLEVEL >= 10) {
2799 NDR_PRINT_IN_DEBUG(NetFileEnum, &r);
2800 }
2801
2802 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2803 werr = NetFileEnum_l(ctx, &r);
2804 } else {
2805 werr = NetFileEnum_r(ctx, &r);
2806 }
2807
2808 r.out.result = W_ERROR_V(werr);
2809
2810 if (DEBUGLEVEL >= 10) {
2811 NDR_PRINT_OUT_DEBUG(NetFileEnum, &r);
2812 }
2813
2814 TALLOC_FREE(frame);
2815 return (NET_API_STATUS)r.out.result;
2816 }
2817
2818 /****************************************************************
2819 NetShutdownInit
2820 ****************************************************************/
2821
2822 NET_API_STATUS NetShutdownInit(const char * server_name /* [in] */,
2823 const char * message /* [in] */,
2824 uint32_t timeout /* [in] */,
2825 uint8_t force_apps /* [in] */,
2826 uint8_t do_reboot /* [in] */)
2827 {
2828 struct NetShutdownInit r;
2829 struct libnetapi_ctx *ctx = NULL;
2830 NET_API_STATUS status;
2831 WERROR werr;
2832 TALLOC_CTX *frame = talloc_stackframe();
2833
2834 ZERO_STRUCT(r);
2835
2836 status = libnetapi_getctx(&ctx);
2837 if (status != 0) {
2838 TALLOC_FREE(frame);
2839 return status;
2840 }
2841
2842 /* In parameters */
2843 r.in.server_name = server_name;
2844 r.in.message = message;
2845 r.in.timeout = timeout;
2846 r.in.force_apps = force_apps;
2847 r.in.do_reboot = do_reboot;
2848
2849 /* Out parameters */
2850
2851 if (DEBUGLEVEL >= 10) {
2852 NDR_PRINT_IN_DEBUG(NetShutdownInit, &r);
2853 }
2854
2855 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2856 werr = NetShutdownInit_l(ctx, &r);
2857 } else {
2858 werr = NetShutdownInit_r(ctx, &r);
2859 }
2860
2861 r.out.result = W_ERROR_V(werr);
2862
2863 if (DEBUGLEVEL >= 10) {
2864 NDR_PRINT_OUT_DEBUG(NetShutdownInit, &r);
2865 }
2866
2867 TALLOC_FREE(frame);
2868 return (NET_API_STATUS)r.out.result;
2869 }
2870
2871 /****************************************************************
2872 NetShutdownAbort
2873 ****************************************************************/
2874
2875 NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */)
2876 {
2877 struct NetShutdownAbort r;
2878 struct libnetapi_ctx *ctx = NULL;
2879 NET_API_STATUS status;
2880 WERROR werr;
2881 TALLOC_CTX *frame = talloc_stackframe();
2882
2883 ZERO_STRUCT(r);
2884
2885 status = libnetapi_getctx(&ctx);
2886 if (status != 0) {
2887 TALLOC_FREE(frame);
2888 return status;
2889 }
2890
2891 /* In parameters */
2892 r.in.server_name = server_name;
2893
2894 /* Out parameters */
2895
2896 if (DEBUGLEVEL >= 10) {
2897 NDR_PRINT_IN_DEBUG(NetShutdownAbort, &r);
2898 }
2899
2900 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2901 werr = NetShutdownAbort_l(ctx, &r);
2902 } else {
2903 werr = NetShutdownAbort_r(ctx, &r);
2904 }
2905
2906 r.out.result = W_ERROR_V(werr);
2907
2908 if (DEBUGLEVEL >= 10) {
2909 NDR_PRINT_OUT_DEBUG(NetShutdownAbort, &r);
2910 }
2911
2912 TALLOC_FREE(frame);
2913 return (NET_API_STATUS)r.out.result;
2914 }
2915
2916 /****************************************************************
2917 I_NetLogonControl
2918 ****************************************************************/
2919
2920 NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
2921 uint32_t function_code /* [in] */,
2922 uint32_t query_level /* [in] */,
2923 uint8_t **buffer /* [out] [ref] */)
2924 {
2925 struct I_NetLogonControl r;
2926 struct libnetapi_ctx *ctx = NULL;
2927 NET_API_STATUS status;
2928 WERROR werr;
2929 TALLOC_CTX *frame = talloc_stackframe();
2930
2931 ZERO_STRUCT(r);
2932
2933 status = libnetapi_getctx(&ctx);
2934 if (status != 0) {
2935 TALLOC_FREE(frame);
2936 return status;
2937 }
2938
2939 /* In parameters */
2940 r.in.server_name = server_name;
2941 r.in.function_code = function_code;
2942 r.in.query_level = query_level;
2943
2944 /* Out parameters */
2945 r.out.buffer = buffer;
2946
2947 if (DEBUGLEVEL >= 10) {
2948 NDR_PRINT_IN_DEBUG(I_NetLogonControl, &r);
2949 }
2950
2951 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2952 werr = I_NetLogonControl_l(ctx, &r);
2953 } else {
2954 werr = I_NetLogonControl_r(ctx, &r);
2955 }
2956
2957 r.out.result = W_ERROR_V(werr);
2958
2959 if (DEBUGLEVEL >= 10) {
2960 NDR_PRINT_OUT_DEBUG(I_NetLogonControl, &r);
2961 }
2962
2963 TALLOC_FREE(frame);
2964 return (NET_API_STATUS)r.out.result;
2965 }
2966
2967 /****************************************************************
2968 I_NetLogonControl2
2969 ****************************************************************/
2970
2971 NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
2972 uint32_t function_code /* [in] */,
2973 uint32_t query_level /* [in] */,
2974 uint8_t *data /* [in] [unique] */,
2975 uint8_t **buffer /* [out] [ref] */)
2976 {
2977 struct I_NetLogonControl2 r;
2978 struct libnetapi_ctx *ctx = NULL;
2979 NET_API_STATUS status;
2980 WERROR werr;
2981 TALLOC_CTX *frame = talloc_stackframe();
2982
2983 ZERO_STRUCT(r);
2984
2985 status = libnetapi_getctx(&ctx);
2986 if (status != 0) {
2987 TALLOC_FREE(frame);
2988 return status;
2989 }
2990
2991 /* In parameters */
2992 r.in.server_name = server_name;
2993 r.in.function_code = function_code;
2994 r.in.query_level = query_level;
2995 r.in.data = data;
2996
2997 /* Out parameters */
2998 r.out.buffer = buffer;
2999
3000 if (DEBUGLEVEL >= 10) {
3001 NDR_PRINT_IN_DEBUG(I_NetLogonControl2, &r);
3002 }
3003
3004 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
3005 werr = I_NetLogonControl2_l(ctx, &r);
3006 } else {
3007 werr = I_NetLogonControl2_r(ctx, &r);
3008 }
3009
3010 r.out.result = W_ERROR_V(werr);
3011
3012 if (DEBUGLEVEL >= 10) {
3013 NDR_PRINT_OUT_DEBUG(I_NetLogonControl2, &r);
3014 }
3015
3016 TALLOC_FREE(frame);
3017 return (NET_API_STATUS)r.out.result;
3018 }
3019
GSS-enabled samba4