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