• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /asuswrt-rt-n18u-9.0.0.4.380.2695/release/src-rt/router/samba-3.5.8/source3/lib/netapi/
1/*
2 *  Unix SMB/CIFS implementation.
3 *  NetApi Share Support
4 *  Copyright (C) Guenther Deschner 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
22#include "librpc/gen_ndr/libnetapi.h"
23#include "lib/netapi/netapi.h"
24#include "lib/netapi/netapi_private.h"
25#include "lib/netapi/libnetapi.h"
26#include "../librpc/gen_ndr/cli_srvsvc.h"
27
28/****************************************************************
29****************************************************************/
30
31static NTSTATUS map_srvsvc_share_info_to_SHARE_INFO_buffer(TALLOC_CTX *mem_ctx,
32							   uint32_t level,
33							   union srvsvc_NetShareInfo *info,
34							   uint8_t **buffer,
35							   uint32_t *num_shares)
36{
37	struct SHARE_INFO_0 i0;
38	struct SHARE_INFO_1 i1;
39	struct SHARE_INFO_2 i2;
40	struct SHARE_INFO_501 i501;
41	struct SHARE_INFO_1005 i1005;
42
43	struct srvsvc_NetShareInfo0 *s0;
44	struct srvsvc_NetShareInfo1 *s1;
45	struct srvsvc_NetShareInfo2 *s2;
46	struct srvsvc_NetShareInfo501 *s501;
47	struct srvsvc_NetShareInfo1005 *s1005;
48
49	if (!buffer) {
50		return NT_STATUS_INVALID_PARAMETER;
51	}
52
53	switch (level) {
54		case 0:
55			s0 = info->info0;
56
57			i0.shi0_netname		= talloc_strdup(mem_ctx, s0->name);
58
59			ADD_TO_ARRAY(mem_ctx, struct SHARE_INFO_0, i0,
60				     (struct SHARE_INFO_0 **)buffer,
61				     num_shares);
62			break;
63
64		case 1:
65			s1 = info->info1;
66
67			i1.shi1_netname		= talloc_strdup(mem_ctx, s1->name);
68			i1.shi1_type		= s1->type;
69			i1.shi1_remark		= talloc_strdup(mem_ctx, s1->comment);
70
71			ADD_TO_ARRAY(mem_ctx, struct SHARE_INFO_1, i1,
72				     (struct SHARE_INFO_1 **)buffer,
73				     num_shares);
74			break;
75
76		case 2:
77			s2 = info->info2;
78
79			i2.shi2_netname		= talloc_strdup(mem_ctx, s2->name);
80			i2.shi2_type		= s2->type;
81			i2.shi2_remark		= talloc_strdup(mem_ctx, s2->comment);
82			i2.shi2_permissions	= s2->permissions;
83			i2.shi2_max_uses	= s2->max_users;
84			i2.shi2_current_uses	= s2->current_users;
85			i2.shi2_path		= talloc_strdup(mem_ctx, s2->path);
86			i2.shi2_passwd		= talloc_strdup(mem_ctx, s2->password);
87
88			ADD_TO_ARRAY(mem_ctx, struct SHARE_INFO_2, i2,
89				     (struct SHARE_INFO_2 **)buffer,
90				     num_shares);
91			break;
92
93		case 501:
94			s501 = info->info501;
95
96			i501.shi501_netname		= talloc_strdup(mem_ctx, s501->name);
97			i501.shi501_type		= s501->type;
98			i501.shi501_remark		= talloc_strdup(mem_ctx, s501->comment);
99			i501.shi501_flags		= s501->csc_policy;
100
101			ADD_TO_ARRAY(mem_ctx, struct SHARE_INFO_501, i501,
102				     (struct SHARE_INFO_501 **)buffer,
103				     num_shares);
104			break;
105
106		case 1005:
107			s1005 = info->info1005;
108
109			i1005.shi1005_flags		= s1005->dfs_flags;
110
111			ADD_TO_ARRAY(mem_ctx, struct SHARE_INFO_1005, i1005,
112				     (struct SHARE_INFO_1005 **)buffer,
113				     num_shares);
114			break;
115
116		default:
117			return NT_STATUS_INVALID_PARAMETER;
118	}
119
120	return NT_STATUS_OK;
121}
122
123/****************************************************************
124****************************************************************/
125
126static NTSTATUS map_SHARE_INFO_buffer_to_srvsvc_share_info(TALLOC_CTX *mem_ctx,
127							   uint8_t *buffer,
128							   uint32_t level,
129							   union srvsvc_NetShareInfo *info)
130{
131	struct SHARE_INFO_2 *i2 = NULL;
132	struct SHARE_INFO_1004 *i1004 = NULL;
133	struct srvsvc_NetShareInfo2 *s2 = NULL;
134	struct srvsvc_NetShareInfo1004 *s1004 = NULL;
135
136	if (!buffer) {
137		return NT_STATUS_INVALID_PARAMETER;
138	}
139
140	switch (level) {
141		case 2:
142			i2 = (struct SHARE_INFO_2 *)buffer;
143
144			s2 = TALLOC_P(mem_ctx, struct srvsvc_NetShareInfo2);
145			NT_STATUS_HAVE_NO_MEMORY(s2);
146
147			s2->name		= i2->shi2_netname;
148			s2->type		= i2->shi2_type;
149			s2->comment		= i2->shi2_remark;
150			s2->permissions		= i2->shi2_permissions;
151			s2->max_users		= i2->shi2_max_uses;
152			s2->current_users	= i2->shi2_current_uses;
153			s2->path		= i2->shi2_path;
154			s2->password		= i2->shi2_passwd;
155
156			info->info2 = s2;
157
158			break;
159		case 1004:
160			i1004 = (struct SHARE_INFO_1004 *)buffer;
161
162			s1004 = TALLOC_P(mem_ctx, struct srvsvc_NetShareInfo1004);
163			NT_STATUS_HAVE_NO_MEMORY(s1004);
164
165			s1004->comment		= i1004->shi1004_remark;
166
167			info->info1004 = s1004;
168
169			break;
170		default:
171			return NT_STATUS_INVALID_PARAMETER;
172	}
173
174	return NT_STATUS_OK;
175}
176
177/****************************************************************
178****************************************************************/
179
180WERROR NetShareAdd_r(struct libnetapi_ctx *ctx,
181		     struct NetShareAdd *r)
182{
183	WERROR werr;
184	NTSTATUS status;
185	struct rpc_pipe_client *pipe_cli = NULL;
186	union srvsvc_NetShareInfo info;
187
188	if (!r->in.buffer) {
189		return WERR_INVALID_PARAM;
190	}
191
192	switch (r->in.level) {
193		case 2:
194			break;
195		case 502:
196		case 503:
197			return WERR_NOT_SUPPORTED;
198		default:
199			return WERR_UNKNOWN_LEVEL;
200	}
201
202	werr = libnetapi_open_pipe(ctx, r->in.server_name,
203				   &ndr_table_srvsvc.syntax_id,
204				   &pipe_cli);
205	if (!W_ERROR_IS_OK(werr)) {
206		goto done;
207	}
208
209	status = map_SHARE_INFO_buffer_to_srvsvc_share_info(ctx,
210							    r->in.buffer,
211							    r->in.level,
212							    &info);
213	if (!NT_STATUS_IS_OK(status)) {
214		werr = ntstatus_to_werror(status);
215		goto done;
216	}
217
218	status = rpccli_srvsvc_NetShareAdd(pipe_cli, talloc_tos(),
219					   r->in.server_name,
220					   r->in.level,
221					   &info,
222					   r->out.parm_err,
223					   &werr);
224	if (!W_ERROR_IS_OK(werr)) {
225		goto done;
226	}
227
228 done:
229	return werr;
230}
231
232/****************************************************************
233****************************************************************/
234
235WERROR NetShareAdd_l(struct libnetapi_ctx *ctx,
236		     struct NetShareAdd *r)
237{
238	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetShareAdd);
239}
240
241/****************************************************************
242****************************************************************/
243
244WERROR NetShareDel_r(struct libnetapi_ctx *ctx,
245		     struct NetShareDel *r)
246{
247	WERROR werr;
248	NTSTATUS status;
249	struct rpc_pipe_client *pipe_cli = NULL;
250
251	if (!r->in.net_name) {
252		return WERR_INVALID_PARAM;
253	}
254
255	werr = libnetapi_open_pipe(ctx, r->in.server_name,
256				   &ndr_table_srvsvc.syntax_id,
257				   &pipe_cli);
258	if (!W_ERROR_IS_OK(werr)) {
259		goto done;
260	}
261
262	status = rpccli_srvsvc_NetShareDel(pipe_cli, talloc_tos(),
263					   r->in.server_name,
264					   r->in.net_name,
265					   r->in.reserved,
266					   &werr);
267	if (!NT_STATUS_IS_OK(status)) {
268		werr = ntstatus_to_werror(status);
269		goto done;
270	}
271
272 done:
273	return werr;
274}
275
276/****************************************************************
277****************************************************************/
278
279WERROR NetShareDel_l(struct libnetapi_ctx *ctx,
280		     struct NetShareDel *r)
281{
282	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetShareDel);
283}
284
285/****************************************************************
286****************************************************************/
287
288WERROR NetShareEnum_r(struct libnetapi_ctx *ctx,
289		      struct NetShareEnum *r)
290{
291	WERROR werr;
292	NTSTATUS status;
293	struct rpc_pipe_client *pipe_cli = NULL;
294	struct srvsvc_NetShareInfoCtr info_ctr;
295	struct srvsvc_NetShareCtr0 ctr0;
296	struct srvsvc_NetShareCtr1 ctr1;
297	struct srvsvc_NetShareCtr2 ctr2;
298	uint32_t i;
299
300	if (!r->out.buffer) {
301		return WERR_INVALID_PARAM;
302	}
303
304	switch (r->in.level) {
305		case 0:
306		case 1:
307		case 2:
308			break;
309		case 502:
310		case 503:
311			return WERR_NOT_SUPPORTED;
312		default:
313			return WERR_UNKNOWN_LEVEL;
314	}
315
316	ZERO_STRUCT(info_ctr);
317
318	werr = libnetapi_open_pipe(ctx, r->in.server_name,
319				   &ndr_table_srvsvc.syntax_id,
320				   &pipe_cli);
321	if (!W_ERROR_IS_OK(werr)) {
322		goto done;
323	}
324
325	info_ctr.level = r->in.level;
326	switch (r->in.level) {
327		case 0:
328			ZERO_STRUCT(ctr0);
329			info_ctr.ctr.ctr0 = &ctr0;
330			break;
331		case 1:
332			ZERO_STRUCT(ctr1);
333			info_ctr.ctr.ctr1 = &ctr1;
334			break;
335		case 2:
336			ZERO_STRUCT(ctr2);
337			info_ctr.ctr.ctr2 = &ctr2;
338			break;
339	}
340
341	status = rpccli_srvsvc_NetShareEnumAll(pipe_cli, talloc_tos(),
342					       r->in.server_name,
343					       &info_ctr,
344					       r->in.prefmaxlen,
345					       r->out.total_entries,
346					       r->out.resume_handle,
347					       &werr);
348	if (NT_STATUS_IS_ERR(status)) {
349		goto done;
350	}
351
352	for (i=0; i < info_ctr.ctr.ctr1->count; i++) {
353		union srvsvc_NetShareInfo _i;
354		switch (r->in.level) {
355			case 0:
356				_i.info0 = &info_ctr.ctr.ctr0->array[i];
357				break;
358			case 1:
359				_i.info1 = &info_ctr.ctr.ctr1->array[i];
360				break;
361			case 2:
362				_i.info2 = &info_ctr.ctr.ctr2->array[i];
363				break;
364		}
365
366		status = map_srvsvc_share_info_to_SHARE_INFO_buffer(ctx,
367								    r->in.level,
368								    &_i,
369								    r->out.buffer,
370								    r->out.entries_read);
371		if (!NT_STATUS_IS_OK(status)) {
372			werr = ntstatus_to_werror(status);
373		}
374	}
375
376 done:
377	return werr;
378}
379
380/****************************************************************
381****************************************************************/
382
383WERROR NetShareEnum_l(struct libnetapi_ctx *ctx,
384		      struct NetShareEnum *r)
385{
386	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetShareEnum);
387}
388
389/****************************************************************
390****************************************************************/
391
392WERROR NetShareGetInfo_r(struct libnetapi_ctx *ctx,
393			 struct NetShareGetInfo *r)
394{
395	WERROR werr;
396	NTSTATUS status;
397	struct rpc_pipe_client *pipe_cli = NULL;
398	union srvsvc_NetShareInfo info;
399	uint32_t num_entries = 0;
400
401	if (!r->in.net_name || !r->out.buffer) {
402		return WERR_INVALID_PARAM;
403	}
404
405	switch (r->in.level) {
406		case 0:
407		case 1:
408		case 2:
409		case 501:
410		case 1005:
411			break;
412		case 502:
413		case 503:
414			return WERR_NOT_SUPPORTED;
415		default:
416			return WERR_UNKNOWN_LEVEL;
417	}
418
419	werr = libnetapi_open_pipe(ctx, r->in.server_name,
420				   &ndr_table_srvsvc.syntax_id,
421				   &pipe_cli);
422	if (!W_ERROR_IS_OK(werr)) {
423		goto done;
424	}
425
426	status = rpccli_srvsvc_NetShareGetInfo(pipe_cli, talloc_tos(),
427					       r->in.server_name,
428					       r->in.net_name,
429					       r->in.level,
430					       &info,
431					       &werr);
432
433	if (!W_ERROR_IS_OK(werr)) {
434		goto done;
435	}
436
437	status = map_srvsvc_share_info_to_SHARE_INFO_buffer(ctx,
438							    r->in.level,
439							    &info,
440							    r->out.buffer,
441							    &num_entries);
442	if (!NT_STATUS_IS_OK(status)) {
443		werr = ntstatus_to_werror(status);
444	}
445
446 done:
447	return werr;
448}
449
450/****************************************************************
451****************************************************************/
452
453WERROR NetShareGetInfo_l(struct libnetapi_ctx *ctx,
454			 struct NetShareGetInfo *r)
455{
456	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetShareGetInfo);
457}
458
459/****************************************************************
460****************************************************************/
461
462WERROR NetShareSetInfo_r(struct libnetapi_ctx *ctx,
463			 struct NetShareSetInfo *r)
464{
465	WERROR werr;
466	NTSTATUS status;
467	struct rpc_pipe_client *pipe_cli = NULL;
468	union srvsvc_NetShareInfo info;
469
470	if (!r->in.buffer) {
471		return WERR_INVALID_PARAM;
472	}
473
474	switch (r->in.level) {
475		case 2:
476		case 1004:
477			break;
478		case 1:
479		case 502:
480		case 503:
481		case 1005:
482		case 1006:
483		case 1501:
484			return WERR_NOT_SUPPORTED;
485		default:
486			return WERR_UNKNOWN_LEVEL;
487	}
488
489	werr = libnetapi_open_pipe(ctx, r->in.server_name,
490				   &ndr_table_srvsvc.syntax_id,
491				   &pipe_cli);
492	if (!W_ERROR_IS_OK(werr)) {
493		goto done;
494	}
495
496	status = map_SHARE_INFO_buffer_to_srvsvc_share_info(ctx,
497							    r->in.buffer,
498							    r->in.level,
499							    &info);
500	if (!NT_STATUS_IS_OK(status)) {
501		werr = ntstatus_to_werror(status);
502		goto done;
503	}
504
505	status = rpccli_srvsvc_NetShareSetInfo(pipe_cli, talloc_tos(),
506					       r->in.server_name,
507					       r->in.net_name,
508					       r->in.level,
509					       &info,
510					       r->out.parm_err,
511					       &werr);
512	if (!W_ERROR_IS_OK(werr)) {
513		goto done;
514	}
515
516 done:
517	return werr;
518}
519
520/****************************************************************
521****************************************************************/
522
523WERROR NetShareSetInfo_l(struct libnetapi_ctx *ctx,
524			 struct NetShareSetInfo *r)
525{
526	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetShareSetInfo);
527}
528