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