?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture: send the TCONX_FLAG_EXTENDED_RESPONSE flag
[Samba/gebeck_regimport.git] / source4 / rpc_server / srvsvc / dcesrv_srvsvc.c
blob8ccfe6babf5fef6a9fa7b64d97b39cdf6ef021f0
1 /*
2 Unix SMB/CIFS implementation.
3
4 endpoint server for the srvsvc pipe
5
6 Copyright (C) Stefan (metze) Metzmacher 2004-2006
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "ntvfs/ntvfs.h"
24 #include "rpc_server/dcerpc_server.h"
25 #include "librpc/gen_ndr/ndr_srvsvc.h"
26 #include "rpc_server/common/common.h"
27 #include "rpc_server/common/share.h"
28 #include "auth/auth.h"
29 #include "libcli/security/security.h"
30 #include "system/time.h"
31 #include "rpc_server/srvsvc/proto.h"
32 #include "param/param.h"
33
34 #define SRVSVC_CHECK_ADMIN_ACCESS do { \
35 struct security_token *t = dce_call->conn->auth_state.session_info->security_token; \
36 if (!security_token_has_builtin_administrators(t) && \
37 !security_token_has_sid(t, &global_sid_Builtin_Server_Operators)) { \
38 return WERR_ACCESS_DENIED; \
39 } \
40 } while (0)
41
42 /*
43 srvsvc_NetCharDevEnum
44 */
45 static WERROR dcesrv_srvsvc_NetCharDevEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
46 struct srvsvc_NetCharDevEnum *r)
47 {
48 *r->out.totalentries = 0;
49
50 switch (r->in.info_ctr->level) {
51 case 0:
52 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr0);
53 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
54
55 r->out.info_ctr->ctr.ctr0->count = 0;
56 r->out.info_ctr->ctr.ctr0->array = NULL;
57
58 return WERR_NOT_SUPPORTED;
59
60 case 1:
61 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr1);
62 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
63
64 r->out.info_ctr->ctr.ctr1->count = 0;
65 r->out.info_ctr->ctr.ctr1->array = NULL;
66
67 return WERR_NOT_SUPPORTED;
68
69 default:
70 return WERR_UNKNOWN_LEVEL;
71 }
72 }
73
74
75 /*
76 srvsvc_NetCharDevGetInfo
77 */
78 static WERROR dcesrv_srvsvc_NetCharDevGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
79 struct srvsvc_NetCharDevGetInfo *r)
80 {
81 ZERO_STRUCTP(r->out.info);
82
83 switch (r->in.level) {
84 case 0:
85 {
86 return WERR_NOT_SUPPORTED;
87 }
88 case 1:
89 {
90 return WERR_NOT_SUPPORTED;
91 }
92 default:
93 return WERR_UNKNOWN_LEVEL;
94 }
95 }
96
97
98 /*
99 srvsvc_NetCharDevControl
100 */
101 static WERROR dcesrv_srvsvc_NetCharDevControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
102 struct srvsvc_NetCharDevControl *r)
103 {
104 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
105 }
106
107
108 /*
109 srvsvc_NetCharDevQEnum
110 */
111 static WERROR dcesrv_srvsvc_NetCharDevQEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
112 struct srvsvc_NetCharDevQEnum *r)
113 {
114 *r->out.totalentries = 0;
115
116 switch (r->in.info_ctr->level) {
117 case 0:
118 {
119 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr0);
120 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
121
122 r->out.info_ctr->ctr.ctr0->count = 0;
123 r->out.info_ctr->ctr.ctr0->array = NULL;
124
125 return WERR_NOT_SUPPORTED;
126 }
127 case 1:
128 {
129 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr1);
130 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
131
132 r->out.info_ctr->ctr.ctr1->count = 0;
133 r->out.info_ctr->ctr.ctr1->array = NULL;
134
135 return WERR_NOT_SUPPORTED;
136 }
137 default:
138 return WERR_UNKNOWN_LEVEL;
139 }
140 }
141
142
143 /*
144 srvsvc_NetCharDevQGetInfo
145 */
146 static WERROR dcesrv_srvsvc_NetCharDevQGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
147 struct srvsvc_NetCharDevQGetInfo *r)
148 {
149 ZERO_STRUCTP(r->out.info);
150
151 switch (r->in.level) {
152 case 0:
153 {
154 return WERR_NOT_SUPPORTED;
155 }
156 case 1:
157 {
158 return WERR_NOT_SUPPORTED;
159 }
160 default:
161 return WERR_UNKNOWN_LEVEL;
162 }
163 }
164
165
166 /*
167 srvsvc_NetCharDevQSetInfo
168 */
169 static WERROR dcesrv_srvsvc_NetCharDevQSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
170 struct srvsvc_NetCharDevQSetInfo *r)
171 {
172 switch (r->in.level) {
173 case 0:
174 {
175 if (r->in.parm_error) {
176 r->out.parm_error = r->in.parm_error;
177 }
178 return WERR_NOT_SUPPORTED;
179 }
180 case 1:
181 {
182 if (r->in.parm_error) {
183 r->out.parm_error = r->in.parm_error;
184 }
185 return WERR_NOT_SUPPORTED;
186 }
187 default:
188 return WERR_UNKNOWN_LEVEL;
189 }
190 }
191
192
193 /*
194 srvsvc_NetCharDevQPurge
195 */
196 static WERROR dcesrv_srvsvc_NetCharDevQPurge(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
197 struct srvsvc_NetCharDevQPurge *r)
198 {
199 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
200 }
201
202
203 /*
204 srvsvc_NetCharDevQPurgeSelf
205 */
206 static WERROR dcesrv_srvsvc_NetCharDevQPurgeSelf(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
207 struct srvsvc_NetCharDevQPurgeSelf *r)
208 {
209 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
210 }
211
212
213 /*
214 srvsvc_NetConnEnum
215 */
216 static WERROR dcesrv_srvsvc_NetConnEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
217 struct srvsvc_NetConnEnum *r)
218 {
219 *r->out.totalentries = 0;
220
221 switch (r->in.info_ctr->level) {
222 case 0:
223 {
224 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetConnCtr0);
225 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
226
227 r->out.info_ctr->ctr.ctr0->count = 0;
228 r->out.info_ctr->ctr.ctr0->array = NULL;
229
230 return WERR_NOT_SUPPORTED;
231 }
232 case 1:
233 {
234 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetConnCtr1);
235 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
236
237 r->out.info_ctr->ctr.ctr1->count = 0;
238 r->out.info_ctr->ctr.ctr1->array = NULL;
239
240 return WERR_NOT_SUPPORTED;
241 }
242 default:
243 return WERR_UNKNOWN_LEVEL;
244 }
245 }
246
247
248 /*
249 srvsvc_NetFileEnum
250 */
251 static WERROR dcesrv_srvsvc_NetFileEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
252 struct srvsvc_NetFileEnum *r)
253 {
254 *r->out.totalentries = 0;
255
256 switch (r->in.info_ctr->level) {
257 case 2:
258 {
259 r->out.info_ctr->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetFileCtr2);
260 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr2);
261
262 r->out.info_ctr->ctr.ctr2->count = 0;
263 r->out.info_ctr->ctr.ctr2->array = NULL;
264
265 return WERR_NOT_SUPPORTED;
266 }
267 case 3:
268 {
269 r->out.info_ctr->ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetFileCtr3);
270 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr3);
271
272 r->out.info_ctr->ctr.ctr3->count = 0;
273 r->out.info_ctr->ctr.ctr3->array = NULL;
274
275 return WERR_NOT_SUPPORTED;
276 }
277 default:
278 return WERR_UNKNOWN_LEVEL;
279 }
280 }
281
282
283 /*
284 srvsvc_NetFileGetInfo
285 */
286 static WERROR dcesrv_srvsvc_NetFileGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
287 struct srvsvc_NetFileGetInfo *r)
288 {
289 ZERO_STRUCTP(r->out.info);
290
291 switch (r->in.level) {
292 case 2:
293 {
294 return WERR_NOT_SUPPORTED;
295 }
296 case 3:
297 {
298 return WERR_NOT_SUPPORTED;
299 }
300 default:
301 return WERR_UNKNOWN_LEVEL;
302 }
303 }
304
305
306 /*
307 srvsvc_NetFileClose
308 */
309 static WERROR dcesrv_srvsvc_NetFileClose(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
310 struct srvsvc_NetFileClose *r)
311 {
312 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
313 }
314
315
316 /*
317 srvsvc_NetSessEnum
318 */
319 static WERROR dcesrv_srvsvc_NetSessEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
320 struct srvsvc_NetSessEnum *r)
321 {
322 *r->out.totalentries = 0;
323
324 switch (r->in.info_ctr->level) {
325 case 0:
326 {
327 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetSessCtr0);
328 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
329
330 r->out.info_ctr->ctr.ctr0->count = 0;
331 r->out.info_ctr->ctr.ctr0->array = NULL;
332
333 return WERR_NOT_SUPPORTED;
334 }
335 case 1:
336 {
337 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetSessCtr1);
338 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
339
340 r->out.info_ctr->ctr.ctr1->count = 0;
341 r->out.info_ctr->ctr.ctr1->array = NULL;
342
343 return WERR_NOT_SUPPORTED;
344 }
345 case 2:
346 {
347 r->out.info_ctr->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetSessCtr2);
348 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr2);
349
350 r->out.info_ctr->ctr.ctr2->count = 0;
351 r->out.info_ctr->ctr.ctr2->array = NULL;
352
353 return WERR_NOT_SUPPORTED;
354 }
355 case 10:
356 {
357 r->out.info_ctr->ctr.ctr10 = talloc(mem_ctx, struct srvsvc_NetSessCtr10);
358 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr10);
359
360 r->out.info_ctr->ctr.ctr10->count = 0;
361 r->out.info_ctr->ctr.ctr10->array = NULL;
362
363 return WERR_NOT_SUPPORTED;
364 }
365 case 502:
366 {
367 r->out.info_ctr->ctr.ctr502 = talloc(mem_ctx, struct srvsvc_NetSessCtr502);
368 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr502);
369
370 r->out.info_ctr->ctr.ctr502->count = 0;
371 r->out.info_ctr->ctr.ctr502->array = NULL;
372
373 return WERR_NOT_SUPPORTED;
374 }
375 default:
376 return WERR_UNKNOWN_LEVEL;
377 }
378 }
379
380
381 /*
382 srvsvc_NetSessDel
383 */
384 static WERROR dcesrv_srvsvc_NetSessDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
385 struct srvsvc_NetSessDel *r)
386 {
387 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
388 }
389
390
391 /*
392 srvsvc_NetShareAdd
393 */
394 static WERROR dcesrv_srvsvc_NetShareAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
395 struct srvsvc_NetShareAdd *r)
396 {
397 switch (r->in.level) {
398 case 0:
399 {
400 if (r->in.parm_error) {
401 r->out.parm_error = r->in.parm_error;
402 }
403 return WERR_NOT_SUPPORTED;
404 }
405 case 1:
406 {
407 if (r->in.parm_error) {
408 r->out.parm_error = r->in.parm_error;
409 }
410 return WERR_NOT_SUPPORTED;
411 }
412 case 2:
413 {
414 NTSTATUS nterr;
415 struct share_info *info;
416 struct share_context *sctx;
417 unsigned int count = 8;
418 unsigned int i;
419
420 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
421 if (!NT_STATUS_IS_OK(nterr)) {
422 return ntstatus_to_werror(nterr);
423 }
424
425 /* there are no more than 8 options in struct srvsvc_NetShareInfo2 */
426 info = talloc_array(mem_ctx, struct share_info, count);
427 W_ERROR_HAVE_NO_MEMORY(info);
428
429 i = 0;
430
431 info[i].name = SHARE_TYPE;
432 info[i].type = SHARE_INFO_STRING;
433 switch (r->in.info->info2->type) {
434 case STYPE_DISKTREE:
435 info[i].value = talloc_strdup(info, "DISK");
436 break;
437 case STYPE_PRINTQ:
438 info[i].value = talloc_strdup(info, "PRINTER");
439 break;
440 case STYPE_IPC:
441 info[i].value = talloc_strdup(info, "IPC");
442 break;
443 default:
444 return WERR_INVALID_PARAM;
445 }
446 W_ERROR_HAVE_NO_MEMORY(info[i].value);
447 i++;
448
449 if (r->in.info->info2->path && r->in.info->info2->path[0]) {
450 info[i].name = SHARE_PATH;
451 info[i].type = SHARE_INFO_STRING;
452
453 /* Windows will send a path in a form of C:\example\path */
454 if (r->in.info->info2->path[1] == ':') {
455 info[i].value = talloc_strdup(info, &r->in.info->info2->path[2]);
456 } else {
457 /* very strange let's try to set as is */
458 info[i].value = talloc_strdup(info, r->in.info->info2->path);
459 }
460 W_ERROR_HAVE_NO_MEMORY(info[i].value);
461 all_string_sub((char *)info[i].value, "\\", "/", 0);
462
463 i++;
464 }
465
466 if (r->in.info->info2->comment && r->in.info->info2->comment[0]) {
467 info[i].name = SHARE_COMMENT;
468 info[i].type = SHARE_INFO_STRING;
469 info[i].value = talloc_strdup(info, r->in.info->info2->comment);
470 W_ERROR_HAVE_NO_MEMORY(info[i].value);
471
472 i++;
473 }
474
475 if (r->in.info->info2->password && r->in.info->info2->password[0]) {
476 info[i].name = SHARE_PASSWORD;
477 info[i].type = SHARE_INFO_STRING;
478 info[i].value = talloc_strdup(info, r->in.info->info2->password);
479 W_ERROR_HAVE_NO_MEMORY(info[i].value);
480
481 i++;
482 }
483
484 info[i].name = SHARE_MAX_CONNECTIONS;
485 info[i].type = SHARE_INFO_INT;
486 info[i].value = talloc(info, int);
487 *((int *)info[i].value) = r->in.info->info2->max_users;
488 i++;
489
490 /* TODO: security descriptor */
491
492 nterr = share_create(sctx, r->in.info->info2->name, info, i);
493 if (!NT_STATUS_IS_OK(nterr)) {
494 return ntstatus_to_werror(nterr);
495 }
496
497 if (r->in.parm_error) {
498 r->out.parm_error = r->in.parm_error;
499 }
500
501 return WERR_OK;
502 }
503 case 501:
504 {
505 if (r->in.parm_error) {
506 r->out.parm_error = r->in.parm_error;
507 }
508 return WERR_NOT_SUPPORTED;
509 }
510 case 502:
511 {
512 NTSTATUS nterr;
513 struct share_info *info;
514 struct share_context *sctx;
515 unsigned int count = 10;
516 unsigned int i;
517
518 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
519 if (!NT_STATUS_IS_OK(nterr)) {
520 return ntstatus_to_werror(nterr);
521 }
522
523 /* there are no more than 10 options in struct srvsvc_NetShareInfo502 */
524 info = talloc_array(mem_ctx, struct share_info, count);
525 W_ERROR_HAVE_NO_MEMORY(info);
526
527 i = 0;
528
529 info[i].name = SHARE_TYPE;
530 info[i].type = SHARE_INFO_STRING;
531 switch (r->in.info->info502->type) {
532 case 0x00:
533 info[i].value = talloc_strdup(info, "DISK");
534 break;
535 case 0x01:
536 info[i].value = talloc_strdup(info, "PRINTER");
537 break;
538 case 0x03:
539 info[i].value = talloc_strdup(info, "IPC");
540 break;
541 default:
542 return WERR_INVALID_PARAM;
543 }
544 W_ERROR_HAVE_NO_MEMORY(info[i].value);
545 i++;
546
547 if (r->in.info->info502->path && r->in.info->info502->path[0]) {
548 info[i].name = SHARE_PATH;
549 info[i].type = SHARE_INFO_STRING;
550
551 /* Windows will send a path in a form of C:\example\path */
552 if (r->in.info->info502->path[1] == ':') {
553 info[i].value = talloc_strdup(info, &r->in.info->info502->path[2]);
554 } else {
555 /* very strange let's try to set as is */
556 info[i].value = talloc_strdup(info, r->in.info->info502->path);
557 }
558 W_ERROR_HAVE_NO_MEMORY(info[i].value);
559 all_string_sub((char *)info[i].value, "\\", "/", 0);
560
561 i++;
562 }
563
564 if (r->in.info->info502->comment && r->in.info->info502->comment[0]) {
565 info[i].name = SHARE_COMMENT;
566 info[i].type = SHARE_INFO_STRING;
567 info[i].value = talloc_strdup(info, r->in.info->info502->comment);
568 W_ERROR_HAVE_NO_MEMORY(info[i].value);
569
570 i++;
571 }
572
573 if (r->in.info->info502->password && r->in.info->info502->password[0]) {
574 info[i].name = SHARE_PASSWORD;
575 info[i].type = SHARE_INFO_STRING;
576 info[i].value = talloc_strdup(info, r->in.info->info502->password);
577 W_ERROR_HAVE_NO_MEMORY(info[i].value);
578
579 i++;
580 }
581
582 info[i].name = SHARE_MAX_CONNECTIONS;
583 info[i].type = SHARE_INFO_INT;
584 info[i].value = talloc(info, int);
585 *((int *)info[i].value) = r->in.info->info502->max_users;
586 i++;
587
588 /* TODO: security descriptor */
589
590 nterr = share_create(sctx, r->in.info->info502->name, info, i);
591 if (!NT_STATUS_IS_OK(nterr)) {
592 return ntstatus_to_werror(nterr);
593 }
594
595 if (r->in.parm_error) {
596 r->out.parm_error = r->in.parm_error;
597 }
598
599 return WERR_OK;
600 }
601 default:
602 return WERR_UNKNOWN_LEVEL;
603 }
604 }
605
606 static WERROR dcesrv_srvsvc_fiel_ShareInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
607 struct share_config *scfg, uint32_t level,
608 union srvsvc_NetShareInfo *info)
609 {
610 struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
611
612 switch (level) {
613 case 0:
614 {
615 info->info0->name = talloc_strdup(mem_ctx, scfg->name);
616 W_ERROR_HAVE_NO_MEMORY(info->info0->name);
617
618 return WERR_OK;
619 }
620 case 1:
621 {
622 info->info1->name = talloc_strdup(mem_ctx, scfg->name);
623 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
624 info->info1->type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
625 info->info1->comment = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
626 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
627
628 return WERR_OK;
629 }
630 case 2:
631 {
632 info->info2->name = talloc_strdup(mem_ctx, scfg->name);
633 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
634 info->info2->type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
635 info->info2->comment = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
636 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
637 info->info2->permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
638 info->info2->max_users = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
639 info->info2->current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
640 info->info2->path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
641 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
642 info->info2->password = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
643
644 return WERR_OK;
645 }
646 case 501:
647 {
648 info->info501->name = talloc_strdup(mem_ctx, scfg->name);
649 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
650 info->info501->type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
651 info->info501->comment = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
652 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
653 info->info501->csc_policy = share_int_option(scfg, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT);
654
655 return WERR_OK;
656 }
657 case 502:
658 {
659 info->info502->name = talloc_strdup(mem_ctx, scfg->name);
660 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
661 info->info502->type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
662 info->info502->comment = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
663 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
664 info->info502->permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
665 info->info502->max_users = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
666 info->info502->current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
667 info->info502->path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
668 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
669 info->info502->password = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
670 info->info502->sd_buf.sd = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, scfg);
671
672 return WERR_OK;
673 }
674 case 1005:
675 {
676 info->info1005->dfs_flags = dcesrv_common_get_share_dfs_flags(mem_ctx, dce_ctx, scfg);
677
678 return WERR_OK;
679 }
680 default:
681 return WERR_UNKNOWN_LEVEL;
682 }
683 }
684
685 /*
686 srvsvc_NetShareEnumAll
687 */
688 static WERROR dcesrv_srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
689 struct srvsvc_NetShareEnumAll *r)
690 {
691 NTSTATUS nterr;
692 int numshares = 0;
693 const char **snames;
694 struct share_context *sctx;
695 struct share_config *scfg;
696
697 *r->out.totalentries = 0;
698
699 /* TODO: - paging of results
700 */
701
702 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
703 if (!NT_STATUS_IS_OK(nterr)) {
704 return ntstatus_to_werror(nterr);
705 }
706
707 nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
708 if (!NT_STATUS_IS_OK(nterr)) {
709 return ntstatus_to_werror(nterr);
710 }
711
712 switch (r->in.info_ctr->level) {
713 case 0:
714 {
715 unsigned int i;
716 struct srvsvc_NetShareCtr0 *ctr0;
717
718 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
719 W_ERROR_HAVE_NO_MEMORY(ctr0);
720
721 ctr0->count = numshares;
722 ctr0->array = NULL;
723
724 if (ctr0->count == 0) {
725 r->out.info_ctr->ctr.ctr0 = ctr0;
726 return WERR_OK;
727 }
728
729 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
730 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
731
732 for (i = 0; i < ctr0->count; i++) {
733 WERROR status;
734 union srvsvc_NetShareInfo info;
735
736 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
737 if (!NT_STATUS_IS_OK(nterr)) {
738 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
739 return WERR_GENERAL_FAILURE;
740 }
741 info.info0 = &ctr0->array[i];
742 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
743 if (!W_ERROR_IS_OK(status)) {
744 return status;
745 }
746 talloc_free(scfg);
747 }
748 talloc_free(snames);
749
750 r->out.info_ctr->ctr.ctr0 = ctr0;
751 *r->out.totalentries = r->out.info_ctr->ctr.ctr0->count;
752 return WERR_OK;
753 }
754 case 1:
755 {
756 unsigned int i;
757 struct srvsvc_NetShareCtr1 *ctr1;
758
759 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
760 W_ERROR_HAVE_NO_MEMORY(ctr1);
761
762 ctr1->count = numshares;
763 ctr1->array = NULL;
764
765 if (ctr1->count == 0) {
766 r->out.info_ctr->ctr.ctr1 = ctr1;
767 return WERR_OK;
768 }
769
770 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
771 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
772
773 for (i=0; i < ctr1->count; i++) {
774 WERROR status;
775 union srvsvc_NetShareInfo info;
776
777 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
778 if (!NT_STATUS_IS_OK(nterr)) {
779 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
780 return WERR_GENERAL_FAILURE;
781 }
782 info.info1 = &ctr1->array[i];
783 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
784 if (!W_ERROR_IS_OK(status)) {
785 return status;
786 }
787 talloc_free(scfg);
788 }
789 talloc_free(snames);
790
791 r->out.info_ctr->ctr.ctr1 = ctr1;
792 *r->out.totalentries = r->out.info_ctr->ctr.ctr1->count;
793
794 return WERR_OK;
795 }
796 case 2:
797 {
798 unsigned int i;
799 struct srvsvc_NetShareCtr2 *ctr2;
800
801 SRVSVC_CHECK_ADMIN_ACCESS;
802
803 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
804 W_ERROR_HAVE_NO_MEMORY(ctr2);
805
806 ctr2->count = numshares;
807 ctr2->array = NULL;
808
809 if (ctr2->count == 0) {
810 r->out.info_ctr->ctr.ctr2 = ctr2;
811 return WERR_OK;
812 }
813
814 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
815 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
816
817 for (i=0; i < ctr2->count; i++) {
818 WERROR status;
819 union srvsvc_NetShareInfo info;
820
821 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
822 if (!NT_STATUS_IS_OK(nterr)) {
823 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
824 return WERR_GENERAL_FAILURE;
825 }
826 info.info2 = &ctr2->array[i];
827 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
828 if (!W_ERROR_IS_OK(status)) {
829 return status;
830 }
831 talloc_free(scfg);
832 }
833 talloc_free(snames);
834
835 r->out.info_ctr->ctr.ctr2 = ctr2;
836 *r->out.totalentries = r->out.info_ctr->ctr.ctr2->count;
837
838 return WERR_OK;
839 }
840 case 501:
841 {
842 unsigned int i;
843 struct srvsvc_NetShareCtr501 *ctr501;
844
845 SRVSVC_CHECK_ADMIN_ACCESS;
846
847 ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
848 W_ERROR_HAVE_NO_MEMORY(ctr501);
849
850 ctr501->count = numshares;
851 ctr501->array = NULL;
852
853 if (ctr501->count == 0) {
854 r->out.info_ctr->ctr.ctr501 = ctr501;
855 return WERR_OK;
856 }
857
858 ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
859 W_ERROR_HAVE_NO_MEMORY(ctr501->array);
860
861 for (i=0; i < ctr501->count; i++) {
862 WERROR status;
863 union srvsvc_NetShareInfo info;
864
865 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
866 if (!NT_STATUS_IS_OK(nterr)) {
867 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
868 return WERR_GENERAL_FAILURE;
869 }
870 info.info501 = &ctr501->array[i];
871 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
872 if (!W_ERROR_IS_OK(status)) {
873 return status;
874 }
875 talloc_free(scfg);
876 }
877 talloc_free(snames);
878
879 r->out.info_ctr->ctr.ctr501 = ctr501;
880 *r->out.totalentries = r->out.info_ctr->ctr.ctr501->count;
881
882 return WERR_OK;
883 }
884 case 502:
885 {
886 unsigned int i;
887 struct srvsvc_NetShareCtr502 *ctr502;
888
889 SRVSVC_CHECK_ADMIN_ACCESS;
890
891 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
892 W_ERROR_HAVE_NO_MEMORY(ctr502);
893
894 ctr502->count = numshares;
895 ctr502->array = NULL;
896
897 if (ctr502->count == 0) {
898 r->out.info_ctr->ctr.ctr502 = ctr502;
899 return WERR_OK;
900 }
901
902 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
903 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
904
905 for (i=0; i < ctr502->count; i++) {
906 WERROR status;
907 union srvsvc_NetShareInfo info;
908
909 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
910 if (!NT_STATUS_IS_OK(nterr)) {
911 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
912 return WERR_GENERAL_FAILURE;
913 }
914 info.info502 = &ctr502->array[i];
915 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
916 if (!W_ERROR_IS_OK(status)) {
917 return status;
918 }
919 talloc_free(scfg);
920 }
921 talloc_free(snames);
922
923 r->out.info_ctr->ctr.ctr502 = ctr502;
924 *r->out.totalentries = r->out.info_ctr->ctr.ctr502->count;
925
926 return WERR_OK;
927 }
928 default:
929 return WERR_UNKNOWN_LEVEL;
930 }
931 }
932
933
934 /*
935 srvsvc_NetShareGetInfo
936 */
937 static WERROR dcesrv_srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
938 struct srvsvc_NetShareGetInfo *r)
939 {
940 NTSTATUS nterr;
941 struct share_context *sctx = NULL;
942 struct share_config *scfg = NULL;
943
944 ZERO_STRUCTP(r->out.info);
945
946 /* TODO: - access check
947 */
948
949 if (strcmp("", r->in.share_name) == 0) {
950 return WERR_INVALID_PARAM;
951 }
952
953 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
954 if (!NT_STATUS_IS_OK(nterr)) {
955 return ntstatus_to_werror(nterr);
956 }
957
958 nterr = share_get_config(mem_ctx, sctx, r->in.share_name, &scfg);
959 if (!NT_STATUS_IS_OK(nterr)) {
960 return ntstatus_to_werror(nterr);
961 }
962
963 switch (r->in.level) {
964 case 0:
965 {
966 WERROR status;
967 union srvsvc_NetShareInfo info;
968
969 info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
970 W_ERROR_HAVE_NO_MEMORY(info.info0);
971
972 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
973 if (!W_ERROR_IS_OK(status)) {
974 return status;
975 }
976
977 r->out.info->info0 = info.info0;
978 return WERR_OK;
979 }
980 case 1:
981 {
982 WERROR status;
983 union srvsvc_NetShareInfo info;
984
985 info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
986 W_ERROR_HAVE_NO_MEMORY(info.info1);
987
988 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
989 if (!W_ERROR_IS_OK(status)) {
990 return status;
991 }
992
993 r->out.info->info1 = info.info1;
994 return WERR_OK;
995 }
996 case 2:
997 {
998 WERROR status;
999 union srvsvc_NetShareInfo info;
1000
1001 SRVSVC_CHECK_ADMIN_ACCESS;
1002
1003 info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
1004 W_ERROR_HAVE_NO_MEMORY(info.info2);
1005
1006 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1007 if (!W_ERROR_IS_OK(status)) {
1008 return status;
1009 }
1010
1011 r->out.info->info2 = info.info2;
1012 return WERR_OK;
1013 }
1014 case 501:
1015 {
1016 WERROR status;
1017 union srvsvc_NetShareInfo info;
1018
1019 info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
1020 W_ERROR_HAVE_NO_MEMORY(info.info501);
1021
1022 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1023 if (!W_ERROR_IS_OK(status)) {
1024 return status;
1025 }
1026
1027 r->out.info->info501 = info.info501;
1028 return WERR_OK;
1029 }
1030 case 502:
1031 {
1032 WERROR status;
1033 union srvsvc_NetShareInfo info;
1034
1035 SRVSVC_CHECK_ADMIN_ACCESS;
1036
1037 info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
1038 W_ERROR_HAVE_NO_MEMORY(info.info502);
1039
1040 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1041 if (!W_ERROR_IS_OK(status)) {
1042 return status;
1043 }
1044
1045 r->out.info->info502 = info.info502;
1046 return WERR_OK;
1047 }
1048 case 1005:
1049 {
1050 WERROR status;
1051 union srvsvc_NetShareInfo info;
1052
1053 info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
1054 W_ERROR_HAVE_NO_MEMORY(info.info1005);
1055
1056 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1057 if (!W_ERROR_IS_OK(status)) {
1058 return status;
1059 }
1060
1061 r->out.info->info1005 = info.info1005;
1062 return WERR_OK;
1063 }
1064 default:
1065 return WERR_UNKNOWN_LEVEL;
1066 }
1067 }
1068
1069 static WERROR dcesrv_srvsvc_fill_share_info(struct share_info *info, int *count,
1070 const char *share_name, int level,
1071 const char *name,
1072 const char *path,
1073 const char *comment,
1074 const char *password,
1075 enum srvsvc_ShareType type,
1076 int32_t max_users,
1077 uint32_t csc_policy,
1078 struct security_descriptor *sd)
1079 {
1080 unsigned int i = 0;
1081
1082 if (level == 501) {
1083 info[i].name = SHARE_CSC_POLICY;
1084 info[i].type = SHARE_INFO_INT;
1085 info[i].value = talloc(info, int);
1086 *((int *)info[i].value) = csc_policy;
1087 i++;
1088 }
1089
1090 switch(level) {
1091
1092 case 502:
1093 /* TODO: check if unknown is csc_policy */
1094
1095 /* TODO: security descriptor */
1096
1097 case 2:
1098 if (path && path[0]) {
1099 info[i].name = SHARE_PATH;
1100 info[i].type = SHARE_INFO_STRING;
1101
1102 /* Windows will send a path in a form of C:\example\path */
1103 if (path[1] == ':') {
1104 info[i].value = talloc_strdup(info, &path[2]);
1105 } else {
1106 /* very strange let's try to set as is */
1107 info[i].value = talloc_strdup(info, path);
1108 }
1109 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1110 all_string_sub((char *)info[i].value, "\\", "/", 0);
1111
1112 i++;
1113 }
1114
1115 if (password && password[0]) {
1116 info[i].name = SHARE_PASSWORD;
1117 info[i].type = SHARE_INFO_STRING;
1118 info[i].value = talloc_strdup(info, password);
1119 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1120
1121 i++;
1122 }
1123
1124 info[i].name = SHARE_MAX_CONNECTIONS;
1125 info[i].type = SHARE_INFO_INT;
1126 info[i].value = talloc(info, int);
1127 *((int *)info[i].value) = max_users;
1128 i++;
1129
1130 case 501:
1131 case 1:
1132 info[i].name = SHARE_TYPE;
1133 info[i].type = SHARE_INFO_STRING;
1134 switch (type) {
1135 case 0x00:
1136 info[i].value = talloc_strdup(info, "DISK");
1137 break;
1138 case 0x01:
1139 info[i].value = talloc_strdup(info, "PRINTER");
1140 break;
1141 case 0x03:
1142 info[i].value = talloc_strdup(info, "IPC");
1143 break;
1144 default:
1145 return WERR_INVALID_PARAM;
1146 }
1147 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1148 i++;
1149
1150 case 1004:
1151 if (comment) {
1152 info[i].name = SHARE_COMMENT;
1153 info[i].type = SHARE_INFO_STRING;
1154 info[i].value = talloc_strdup(info, comment);
1155 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1156
1157 i++;
1158 }
1159 case 0:
1160 if (name &&
1161 strcasecmp(share_name, name) != 0) {
1162 info[i].name = SHARE_NAME;
1163 info[i].type = SHARE_INFO_STRING;
1164 info[i].value = talloc_strdup(info, name);
1165 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1166 i++;
1167 }
1168
1169 break;
1170
1171 default:
1172 return WERR_UNKNOWN_LEVEL;
1173 }
1174
1175 *count = i;
1176
1177 return WERR_OK;
1178 }
1179
1180 /*
1181 srvsvc_NetShareSetInfo
1182 */
1183 static WERROR dcesrv_srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1184 struct srvsvc_NetShareSetInfo *r)
1185 {
1186 NTSTATUS nterr;
1187 WERROR status;
1188 struct share_context *sctx = NULL;
1189 struct share_info *info;
1190 int count;
1191
1192 /* TODO: - access check
1193 */
1194
1195 /* there are no more than 10 options in all struct srvsvc_NetShareInfoXXX */
1196 info = talloc_array(mem_ctx, struct share_info, 10);
1197 W_ERROR_HAVE_NO_MEMORY(info);
1198
1199 if (strcmp("", r->in.share_name) == 0) {
1200 return WERR_INVALID_PARAM;
1201 }
1202
1203 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1204 if (!NT_STATUS_IS_OK(nterr)) {
1205 return ntstatus_to_werror(nterr);
1206 }
1207
1208 switch (r->in.level) {
1209 case 0:
1210 {
1211 status = dcesrv_srvsvc_fill_share_info(info, &count,
1212 r->in.share_name, r->in.level,
1213 r->in.info->info0->name,
1214 NULL,
1215 NULL,
1216 NULL,
1217 0,
1218 0,
1219 0,
1220 NULL);
1221 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1222 return status;
1223 }
1224 break;
1225 }
1226 case 1:
1227 {
1228 status = dcesrv_srvsvc_fill_share_info(info, &count,
1229 r->in.share_name, r->in.level,
1230 r->in.info->info1->name,
1231 NULL,
1232 r->in.info->info1->comment,
1233 NULL,
1234 r->in.info->info1->type,
1235 0,
1236 0,
1237 NULL);
1238 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1239 return status;
1240 }
1241 break;
1242 }
1243 case 2:
1244 {
1245 status = dcesrv_srvsvc_fill_share_info(info, &count,
1246 r->in.share_name, r->in.level,
1247 r->in.info->info2->name,
1248 r->in.info->info2->path,
1249 r->in.info->info2->comment,
1250 r->in.info->info2->password,
1251 r->in.info->info2->type,
1252 r->in.info->info2->max_users,
1253 0,
1254 NULL);
1255 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1256 return status;
1257 }
1258 break;
1259 }
1260 case 501:
1261 {
1262 status = dcesrv_srvsvc_fill_share_info(info, &count,
1263 r->in.share_name, r->in.level,
1264 r->in.info->info501->name,
1265 NULL,
1266 r->in.info->info501->comment,
1267 NULL,
1268 r->in.info->info501->type,
1269 0,
1270 r->in.info->info501->csc_policy,
1271 NULL);
1272 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1273 return status;
1274 }
1275 break;
1276 }
1277 case 502:
1278 {
1279 status = dcesrv_srvsvc_fill_share_info(info, &count,
1280 r->in.share_name, r->in.level,
1281 r->in.info->info502->name,
1282 r->in.info->info502->path,
1283 r->in.info->info502->comment,
1284 r->in.info->info502->password,
1285 r->in.info->info502->type,
1286 r->in.info->info502->max_users,
1287 0,
1288 r->in.info->info502->sd_buf.sd);
1289 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1290 return status;
1291 }
1292 break;
1293 }
1294 case 1004:
1295 {
1296 status = dcesrv_srvsvc_fill_share_info(info, &count,
1297 r->in.share_name, r->in.level,
1298 NULL,
1299 NULL,
1300 r->in.info->info1004->comment,
1301 NULL,
1302 0,
1303 0,
1304 0,
1305 NULL);
1306 if (!W_ERROR_EQUAL(status, WERR_OK)) {
1307 return status;
1308 }
1309 break;
1310 }
1311 case 1005:
1312 {
1313 /* r->in.info.dfs_flags; */
1314
1315 if (r->in.parm_error) {
1316 r->out.parm_error = r->in.parm_error;
1317 }
1318
1319 return WERR_OK;
1320 }
1321 default:
1322 return WERR_UNKNOWN_LEVEL;
1323 }
1324
1325 nterr = share_set(sctx, r->in.share_name, info, count);
1326 if (!NT_STATUS_IS_OK(nterr)) {
1327 return ntstatus_to_werror(nterr);
1328 }
1329
1330 if (r->in.parm_error) {
1331 r->out.parm_error = r->in.parm_error;
1332 }
1333
1334 return WERR_OK;
1335 }
1336
1337
1338 /*
1339 srvsvc_NetShareDelSticky
1340 */
1341 static WERROR dcesrv_srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1342 struct srvsvc_NetShareDelSticky *r)
1343 {
1344 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1345 }
1346
1347
1348 /*
1349 srvsvc_NetShareCheck
1350 */
1351 static WERROR dcesrv_srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1352 struct srvsvc_NetShareCheck *r)
1353 {
1354 NTSTATUS nterr;
1355 struct share_context *sctx = NULL;
1356 struct share_config *scfg = NULL;
1357 char *device;
1358 const char **names;
1359 int count;
1360 int i;
1361
1362 *r->out.type = 0;
1363
1364 /* TODO: - access check
1365 */
1366
1367 if (strcmp("", r->in.device_name) == 0) {
1368 *r->out.type = STYPE_IPC;
1369 return WERR_OK;
1370 }
1371
1372 /* copy the path skipping C:\ */
1373 if (strncasecmp(r->in.device_name, "C:", 2) == 0) {
1374 device = talloc_strdup(mem_ctx, &r->in.device_name[2]);
1375 } else {
1376 /* no chance we have a share that doesn't start with C:\ */
1377 return WERR_DEVICE_NOT_SHARED;
1378 }
1379 all_string_sub(device, "\\", "/", 0);
1380
1381 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1382 if (!NT_STATUS_IS_OK(nterr)) {
1383 return ntstatus_to_werror(nterr);
1384 }
1385
1386 nterr = share_list_all(mem_ctx, sctx, &count, &names);
1387 if (!NT_STATUS_IS_OK(nterr)) {
1388 return ntstatus_to_werror(nterr);
1389 }
1390
1391 for (i = 0; i < count; i++) {
1392 const char *path;
1393 const char *type;
1394
1395 nterr = share_get_config(mem_ctx, sctx, names[i], &scfg);
1396 if (!NT_STATUS_IS_OK(nterr)) {
1397 return ntstatus_to_werror(nterr);
1398 }
1399 path = share_string_option(scfg, SHARE_PATH, NULL);
1400 if (!path) continue;
1401
1402 if (strcmp(device, path) == 0) {
1403 type = share_string_option(scfg, SHARE_TYPE, NULL);
1404 if (!type) continue;
1405
1406 if (strcmp(type, "DISK") == 0) {
1407 *r->out.type = STYPE_DISKTREE;
1408 return WERR_OK;
1409 }
1410
1411 if (strcmp(type, "IPC") == 0) {
1412 *r->out.type = STYPE_IPC;
1413 return WERR_OK;
1414 }
1415
1416 if (strcmp(type, "PRINTER") == 0) {
1417 *r->out.type = STYPE_PRINTQ;
1418 return WERR_OK;
1419 }
1420 }
1421 }
1422
1423 return WERR_DEVICE_NOT_SHARED;
1424 }
1425
1426
1427 /*
1428 srvsvc_NetSrvGetInfo
1429 */
1430 static WERROR dcesrv_srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1431 struct srvsvc_NetSrvGetInfo *r)
1432 {
1433 struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1434 struct dcerpc_server_info *server_info = lpcfg_dcerpc_server_info(mem_ctx, dce_ctx->lp_ctx);
1435
1436 ZERO_STRUCTP(r->out.info);
1437
1438 switch (r->in.level) {
1439 case 100:
1440 {
1441 struct srvsvc_NetSrvInfo100 *info100;
1442
1443 info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
1444 W_ERROR_HAVE_NO_MEMORY(info100);
1445
1446 info100->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1447 info100->server_name = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1448 W_ERROR_HAVE_NO_MEMORY(info100->server_name);
1449
1450 r->out.info->info100 = info100;
1451 return WERR_OK;
1452 }
1453 case 101:
1454 {
1455 struct srvsvc_NetSrvInfo101 *info101;
1456
1457 info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
1458 W_ERROR_HAVE_NO_MEMORY(info101);
1459
1460 info101->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1461 info101->server_name = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1462 W_ERROR_HAVE_NO_MEMORY(info101->server_name);
1463
1464 info101->version_major = server_info->version_major;
1465 info101->version_minor = server_info->version_minor;
1466 info101->server_type = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
1467 info101->comment = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
1468 W_ERROR_HAVE_NO_MEMORY(info101->comment);
1469
1470 r->out.info->info101 = info101;
1471 return WERR_OK;
1472 }
1473 case 102:
1474 {
1475 struct srvsvc_NetSrvInfo102 *info102;
1476
1477 info102 = talloc(mem_ctx, struct srvsvc_NetSrvInfo102);
1478 W_ERROR_HAVE_NO_MEMORY(info102);
1479
1480 info102->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1481 info102->server_name = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1482 W_ERROR_HAVE_NO_MEMORY(info102->server_name);
1483
1484 info102->version_major = server_info->version_major;
1485 info102->version_minor = server_info->version_minor;
1486 info102->server_type = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
1487 info102->comment = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
1488 W_ERROR_HAVE_NO_MEMORY(info102->comment);
1489
1490 info102->users = dcesrv_common_get_users(mem_ctx, dce_ctx);
1491 info102->disc = dcesrv_common_get_disc(mem_ctx, dce_ctx);
1492 info102->hidden = dcesrv_common_get_hidden(mem_ctx, dce_ctx);
1493 info102->announce = dcesrv_common_get_announce(mem_ctx, dce_ctx);
1494 info102->anndelta = dcesrv_common_get_anndelta(mem_ctx, dce_ctx);
1495 info102->licenses = dcesrv_common_get_licenses(mem_ctx, dce_ctx);
1496 info102->userpath = dcesrv_common_get_userpath(mem_ctx, dce_ctx);
1497 W_ERROR_HAVE_NO_MEMORY(info102->userpath);
1498
1499 r->out.info->info102 = info102;
1500 return WERR_OK;
1501 }
1502 default:
1503 return WERR_UNKNOWN_LEVEL;
1504 }
1505 }
1506
1507
1508 /*
1509 srvsvc_NetSrvSetInfo
1510 */
1511 static WERROR dcesrv_srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1512 struct srvsvc_NetSrvSetInfo *r)
1513 {
1514 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1515 }
1516
1517
1518 /*
1519 srvsvc_NetDiskEnum
1520 */
1521 static WERROR dcesrv_srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1522 struct srvsvc_NetDiskEnum *r)
1523 {
1524 r->out.info->disks = NULL;
1525 r->out.info->count = 0;
1526 *r->out.totalentries = 0;
1527
1528 switch (r->in.level) {
1529 case 0:
1530 {
1531 /* we can safely hardcode the reply and report we have only one disk (C:) */
1532 /* for some reason Windows wants 2 entries with the second being empty */
1533 r->out.info->disks = talloc_array(mem_ctx, struct srvsvc_NetDiskInfo0, 2);
1534 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks);
1535 r->out.info->count = 2;
1536
1537 r->out.info->disks[0].disk = talloc_strdup(mem_ctx, "C:");
1538 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[0].disk);
1539
1540 r->out.info->disks[1].disk = talloc_strdup(mem_ctx, "");
1541 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[1].disk);
1542
1543 *r->out.totalentries = 1;
1544 r->out.resume_handle = r->in.resume_handle;
1545
1546 return WERR_OK;
1547 }
1548 default:
1549 return WERR_UNKNOWN_LEVEL;
1550 }
1551 }
1552
1553
1554 /*
1555 srvsvc_NetServerStatisticsGet
1556 */
1557 static WERROR dcesrv_srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1558 struct srvsvc_NetServerStatisticsGet *r)
1559 {
1560 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1561 }
1562
1563
1564 /*
1565 srvsvc_NetTransportAdd
1566 */
1567 static WERROR dcesrv_srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1568 struct srvsvc_NetTransportAdd *r)
1569 {
1570 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1571 }
1572
1573
1574 /*
1575 srvsvc_NetTransportEnum
1576 */
1577 static WERROR dcesrv_srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1578 struct srvsvc_NetTransportEnum *r)
1579 {
1580 r->out.transports->level = r->in.transports->level;
1581 *r->out.totalentries = 0;
1582 if (r->out.resume_handle) {
1583 *r->out.resume_handle = 0;
1584 }
1585
1586 switch (r->in.transports->level) {
1587 case 0:
1588 {
1589 r->out.transports->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
1590 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr0);
1591
1592 r->out.transports->ctr.ctr0->count = 0;
1593 r->out.transports->ctr.ctr0->array = NULL;
1594
1595 return WERR_NOT_SUPPORTED;
1596 }
1597 case 1:
1598 {
1599 r->out.transports->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
1600 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr1);
1601
1602 r->out.transports->ctr.ctr1->count = 0;
1603 r->out.transports->ctr.ctr1->array = NULL;
1604
1605 return WERR_NOT_SUPPORTED;
1606 }
1607 case 2:
1608 {
1609 r->out.transports->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
1610 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr2);
1611
1612 r->out.transports->ctr.ctr2->count = 0;
1613 r->out.transports->ctr.ctr2->array = NULL;
1614
1615 return WERR_NOT_SUPPORTED;
1616 }
1617 case 3:
1618 {
1619 r->out.transports->ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
1620 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr3);
1621
1622 r->out.transports->ctr.ctr3->count = 0;
1623 r->out.transports->ctr.ctr3->array = NULL;
1624
1625 return WERR_NOT_SUPPORTED;
1626 }
1627 default:
1628 return WERR_UNKNOWN_LEVEL;
1629 }
1630 }
1631
1632 /*
1633 srvsvc_NetTransportDel
1634 */
1635 static WERROR dcesrv_srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1636 struct srvsvc_NetTransportDel *r)
1637 {
1638 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1639 }
1640
1641
1642 /*
1643 srvsvc_NetRemoteTOD
1644 */
1645 static WERROR dcesrv_srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1646 struct srvsvc_NetRemoteTOD *r)
1647 {
1648 struct timeval tval;
1649 time_t t;
1650 struct tm tm;
1651 struct srvsvc_NetRemoteTODInfo *info;
1652
1653 info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
1654 W_ERROR_HAVE_NO_MEMORY(info);
1655
1656 GetTimeOfDay(&tval);
1657 t = tval.tv_sec;
1658
1659 gmtime_r(&t, &tm);
1660
1661 info->elapsed = t;
1662 /* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
1663 info->msecs = (tm.tm_hour*60*60*1000)
1664 + (tm.tm_min*60*1000)
1665 + (tm.tm_sec*1000)
1666 + (tval.tv_usec/1000);
1667 info->hours = tm.tm_hour;
1668 info->mins = tm.tm_min;
1669 info->secs = tm.tm_sec;
1670 info->hunds = tval.tv_usec/10000;
1671 info->timezone = get_time_zone(t)/60;
1672 info->tinterval = 310; /* just return the same as windows */
1673 info->day = tm.tm_mday;
1674 info->month = tm.tm_mon + 1;
1675 info->year = tm.tm_year + 1900;
1676 info->weekday = tm.tm_wday;
1677
1678 *r->out.info = info;
1679
1680 return WERR_OK;
1681 }
1682
1683 /*
1684 srvsvc_NetPathType
1685 */
1686 static WERROR dcesrv_srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1687 struct srvsvc_NetPathType *r)
1688 {
1689 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1690 }
1691
1692
1693 /*
1694 srvsvc_NetPathCanonicalize
1695 */
1696 static WERROR dcesrv_srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1697 struct srvsvc_NetPathCanonicalize *r)
1698 {
1699 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1700 }
1701
1702
1703 /*
1704 srvsvc_NetPathCompare
1705 */
1706 static WERROR dcesrv_srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1707 struct srvsvc_NetPathCompare *r)
1708 {
1709 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1710 }
1711
1712
1713 /*
1714 srvsvc_NetNameValidate
1715 */
1716 static WERROR dcesrv_srvsvc_NetNameValidate(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1717 struct srvsvc_NetNameValidate *r)
1718 {
1719 int len;
1720
1721 if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
1722 return WERR_INVALID_NAME;
1723 }
1724
1725 switch (r->in.name_type) {
1726 case 1:
1727 case 2:
1728 case 3:
1729 case 4:
1730 case 5:
1731 case 6:
1732 case 7:
1733 case 8:
1734 return WERR_NOT_SUPPORTED;
1735
1736 case 9: /* validate share name */
1737
1738 len = strlen_m(r->in.name);
1739 if ((r->in.flags == 0x0) && (len > 81)) {
1740 return WERR_INVALID_NAME;
1741 }
1742 if ((r->in.flags == 0x80000000) && (len > 13)) {
1743 return WERR_INVALID_NAME;
1744 }
1745 if (! dcesrv_common_validate_share_name(mem_ctx, r->in.name)) {
1746 return WERR_INVALID_NAME;
1747 }
1748 return WERR_OK;
1749
1750 case 10:
1751 case 11:
1752 case 12:
1753 case 13:
1754 return WERR_NOT_SUPPORTED;
1755 default:
1756 return WERR_INVALID_PARAM;
1757 }
1758 }
1759
1760
1761 /*
1762 srvsvc_NetPRNameCompare
1763 */
1764 static WERROR dcesrv_srvsvc_NetPRNameCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1765 struct srvsvc_NetPRNameCompare *r)
1766 {
1767 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1768 }
1769
1770
1771 /*
1772 srvsvc_NetShareEnum
1773 */
1774 static WERROR dcesrv_srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1775 struct srvsvc_NetShareEnum *r)
1776 {
1777 NTSTATUS nterr;
1778 int numshares = 0;
1779 const char **snames;
1780 struct share_context *sctx;
1781 struct share_config *scfg;
1782 struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1783
1784 *r->out.totalentries = 0;
1785
1786 /* TODO: - paging of results
1787 */
1788
1789 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1790 if (!NT_STATUS_IS_OK(nterr)) {
1791 return ntstatus_to_werror(nterr);
1792 }
1793
1794 nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
1795 if (!NT_STATUS_IS_OK(nterr)) {
1796 return ntstatus_to_werror(nterr);
1797 }
1798
1799 switch (r->in.info_ctr->level) {
1800 case 0:
1801 {
1802 unsigned int i, y = 0;
1803 unsigned int count;
1804 struct srvsvc_NetShareCtr0 *ctr0;
1805
1806 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
1807 W_ERROR_HAVE_NO_MEMORY(ctr0);
1808
1809 count = numshares;
1810 ctr0->count = count;
1811 ctr0->array = NULL;
1812
1813 if (ctr0->count == 0) {
1814 r->out.info_ctr->ctr.ctr0 = ctr0;
1815 return WERR_OK;
1816 }
1817
1818 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, count);
1819 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
1820
1821 for (i=0; i < count; i++) {
1822 WERROR status;
1823 union srvsvc_NetShareInfo info;
1824 enum srvsvc_ShareType type;
1825
1826 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1827 if (!NT_STATUS_IS_OK(nterr)) {
1828 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1829 return WERR_GENERAL_FAILURE;
1830 }
1831
1832 type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1833 if (type & STYPE_HIDDEN) {
1834 ctr0->count--;
1835 talloc_free(scfg);
1836 continue;
1837 }
1838
1839 info.info0 = &ctr0->array[y];
1840 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
1841 W_ERROR_NOT_OK_RETURN(status);
1842 talloc_free(scfg);
1843 y++;
1844 }
1845 talloc_free(snames);
1846
1847 r->out.info_ctr->ctr.ctr0 = ctr0;
1848 *r->out.totalentries = r->out.info_ctr->ctr.ctr0->count;
1849
1850 return WERR_OK;
1851 }
1852 case 1:
1853 {
1854 unsigned int i, y = 0;
1855 unsigned int count;
1856 struct srvsvc_NetShareCtr1 *ctr1;
1857
1858 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
1859 W_ERROR_HAVE_NO_MEMORY(ctr1);
1860
1861 count = numshares;
1862 ctr1->count = count;
1863 ctr1->array = NULL;
1864
1865 if (ctr1->count == 0) {
1866 r->out.info_ctr->ctr.ctr1 = ctr1;
1867 return WERR_OK;
1868 }
1869
1870 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, count);
1871 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1872
1873 for (i=0; i < count; i++) {
1874 WERROR status;
1875 union srvsvc_NetShareInfo info;
1876 enum srvsvc_ShareType type;
1877
1878 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1879 if (!NT_STATUS_IS_OK(nterr)) {
1880 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1881 return WERR_GENERAL_FAILURE;
1882 }
1883
1884 type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1885 if (type & STYPE_HIDDEN) {
1886 ctr1->count--;
1887 talloc_free(scfg);
1888 continue;
1889 }
1890
1891 info.info1 = &ctr1->array[y];
1892 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
1893 W_ERROR_NOT_OK_RETURN(status);
1894 talloc_free(scfg);
1895 y++;
1896 }
1897 talloc_free(snames);
1898
1899 r->out.info_ctr->ctr.ctr1 = ctr1;
1900 *r->out.totalentries = r->out.info_ctr->ctr.ctr1->count;
1901
1902 return WERR_OK;
1903 }
1904 case 2:
1905 {
1906 unsigned int i, y = 0;
1907 unsigned int count;
1908 struct srvsvc_NetShareCtr2 *ctr2;
1909
1910 SRVSVC_CHECK_ADMIN_ACCESS;
1911
1912 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
1913 W_ERROR_HAVE_NO_MEMORY(ctr2);
1914
1915 count = numshares;
1916 ctr2->count = count;
1917 ctr2->array = NULL;
1918
1919 if (ctr2->count == 0) {
1920 r->out.info_ctr->ctr.ctr2 = ctr2;
1921 return WERR_OK;
1922 }
1923
1924 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, count);
1925 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
1926
1927 for (i=0; i < count; i++) {
1928 WERROR status;
1929 union srvsvc_NetShareInfo info;
1930 enum srvsvc_ShareType type;
1931
1932 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1933 if (!NT_STATUS_IS_OK(nterr)) {
1934 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1935 return WERR_GENERAL_FAILURE;
1936 }
1937
1938 type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1939 if (type & STYPE_HIDDEN) {
1940 ctr2->count--;
1941 talloc_free(scfg);
1942 continue;
1943 }
1944
1945 info.info2 = &ctr2->array[y];
1946 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
1947 W_ERROR_NOT_OK_RETURN(status);
1948 talloc_free(scfg);
1949 y++;
1950 }
1951 talloc_free(snames);
1952
1953 r->out.info_ctr->ctr.ctr2 = ctr2;
1954 *r->out.totalentries = r->out.info_ctr->ctr.ctr2->count;
1955
1956 return WERR_OK;
1957 }
1958 case 502:
1959 {
1960 unsigned int i, y = 0;
1961 unsigned int count;
1962 struct srvsvc_NetShareCtr502 *ctr502;
1963
1964 SRVSVC_CHECK_ADMIN_ACCESS;
1965
1966 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
1967 W_ERROR_HAVE_NO_MEMORY(ctr502);
1968
1969 count = numshares;
1970 ctr502->count = count;
1971 ctr502->array = NULL;
1972
1973 if (ctr502->count == 0) {
1974 r->out.info_ctr->ctr.ctr502 = ctr502;
1975 return WERR_OK;
1976 }
1977
1978 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, count);
1979 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
1980
1981 for (i=0; i < count; i++) {
1982 WERROR status;
1983 union srvsvc_NetShareInfo info;
1984 enum srvsvc_ShareType type;
1985
1986 nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1987 if (!NT_STATUS_IS_OK(nterr)) {
1988 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1989 return WERR_GENERAL_FAILURE;
1990 }
1991
1992 type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1993 if (type & STYPE_HIDDEN) {
1994 ctr502->count--;
1995 talloc_free(scfg);
1996 continue;
1997 }
1998
1999 info.info502 = &ctr502->array[y];
2000 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.info_ctr->level, &info);
2001 W_ERROR_NOT_OK_RETURN(status);
2002 talloc_free(scfg);
2003 y++;
2004 }
2005 talloc_free(snames);
2006
2007 r->out.info_ctr->ctr.ctr502 = ctr502;
2008 *r->out.totalentries = r->out.info_ctr->ctr.ctr502->count;
2009
2010 return WERR_OK;
2011 }
2012 default:
2013 return WERR_UNKNOWN_LEVEL;
2014 }
2015 }
2016
2017
2018 /*
2019 srvsvc_NetShareDelStart
2020 */
2021 static WERROR dcesrv_srvsvc_NetShareDelStart(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2022 struct srvsvc_NetShareDelStart *r)
2023 {
2024 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2025 }
2026
2027
2028 /*
2029 srvsvc_NetShareDelCommit
2030 */
2031 static WERROR dcesrv_srvsvc_NetShareDelCommit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2032 struct srvsvc_NetShareDelCommit *r)
2033 {
2034 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2035 }
2036
2037
2038 /*
2039 srvsvc_NetGetFileSecurity
2040 */
2041 static WERROR dcesrv_srvsvc_NetGetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2042 struct srvsvc_NetGetFileSecurity *r)
2043 {
2044 struct sec_desc_buf *sd_buf;
2045 struct ntvfs_context *ntvfs_ctx = NULL;
2046 struct ntvfs_request *ntvfs_req;
2047 union smb_fileinfo *io;
2048 NTSTATUS nt_status;
2049
2050 nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
2051 if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2052
2053 ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
2054 dce_call->conn->auth_state.session_info,
2055 0,
2056 dce_call->time,
2057 NULL, NULL, 0);
2058 W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
2059
2060 sd_buf = talloc(mem_ctx, struct sec_desc_buf);
2061 W_ERROR_HAVE_NO_MEMORY(sd_buf);
2062
2063 io = talloc(mem_ctx, union smb_fileinfo);
2064 W_ERROR_HAVE_NO_MEMORY(io);
2065
2066 io->query_secdesc.level = RAW_FILEINFO_SEC_DESC;
2067 io->query_secdesc.in.file.path = r->in.file;
2068 io->query_secdesc.in.secinfo_flags = r->in.securityinformation;
2069
2070 nt_status = ntvfs_qpathinfo(ntvfs_req, io);
2071 if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2072
2073 sd_buf->sd = io->query_secdesc.out.sd;
2074
2075 *r->out.sd_buf = sd_buf;
2076 return WERR_OK;
2077 }
2078
2079
2080 /*
2081 srvsvc_NetSetFileSecurity
2082 */
2083 static WERROR dcesrv_srvsvc_NetSetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2084 struct srvsvc_NetSetFileSecurity *r)
2085 {
2086 struct ntvfs_context *ntvfs_ctx;
2087 struct ntvfs_request *ntvfs_req;
2088 union smb_setfileinfo *io;
2089 NTSTATUS nt_status;
2090
2091 nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
2092 if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2093
2094 ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
2095 dce_call->conn->auth_state.session_info,
2096 0,
2097 dce_call->time,
2098 NULL, NULL, 0);
2099 W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
2100
2101 io = talloc(mem_ctx, union smb_setfileinfo);
2102 W_ERROR_HAVE_NO_MEMORY(io);
2103
2104 io->set_secdesc.level = RAW_FILEINFO_SEC_DESC;
2105 io->set_secdesc.in.file.path = r->in.file;
2106 io->set_secdesc.in.secinfo_flags = r->in.securityinformation;
2107 io->set_secdesc.in.sd = r->in.sd_buf->sd;
2108
2109 nt_status = ntvfs_setpathinfo(ntvfs_req, io);
2110 if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2111
2112 return WERR_OK;
2113 }
2114
2115
2116 /*
2117 srvsvc_NetServerTransportAddEx
2118 */
2119 static WERROR dcesrv_srvsvc_NetServerTransportAddEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2120 struct srvsvc_NetServerTransportAddEx *r)
2121 {
2122 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2123 }
2124
2125
2126 /*
2127 srvsvc_NetServerSetServiceBitsEx
2128 */
2129 static WERROR dcesrv_srvsvc_NetServerSetServiceBitsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2130 struct srvsvc_NetServerSetServiceBitsEx *r)
2131 {
2132 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2133 }
2134
2135
2136 /*
2137 srvsvc_NETRDFSGETVERSION
2138 */
2139 static WERROR dcesrv_srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2140 struct srvsvc_NETRDFSGETVERSION *r)
2141 {
2142 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2143 }
2144
2145
2146 /*
2147 srvsvc_NETRDFSCREATELOCALPARTITION
2148 */
2149 static WERROR dcesrv_srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2150 struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2151 {
2152 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2153 }
2154
2155
2156 /*
2157 srvsvc_NETRDFSDELETELOCALPARTITION
2158 */
2159 static WERROR dcesrv_srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2160 struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2161 {
2162 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2163 }
2164
2165
2166 /*
2167 srvsvc_NETRDFSSETLOCALVOLUMESTATE
2168 */
2169 static WERROR dcesrv_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2170 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2171 {
2172 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2173 }
2174
2175
2176 /*
2177 srvsvc_NETRDFSSETSERVERINFO
2178 */
2179 static WERROR dcesrv_srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2180 struct srvsvc_NETRDFSSETSERVERINFO *r)
2181 {
2182 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2183 }
2184
2185
2186 /*
2187 srvsvc_NETRDFSCREATEEXITPOINT
2188 */
2189 static WERROR dcesrv_srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2190 struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2191 {
2192 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2193 }
2194
2195
2196 /*
2197 srvsvc_NETRDFSDELETEEXITPOINT
2198 */
2199 static WERROR dcesrv_srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2200 struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2201 {
2202 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2203 }
2204
2205
2206 /*
2207 srvsvc_NETRDFSMODIFYPREFIX
2208 */
2209 static WERROR dcesrv_srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2210 struct srvsvc_NETRDFSMODIFYPREFIX *r)
2211 {
2212 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2213 }
2214
2215
2216 /*
2217 srvsvc_NETRDFSFIXLOCALVOLUME
2218 */
2219 static WERROR dcesrv_srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2220 struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2221 {
2222 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2223 }
2224
2225
2226 /*
2227 srvsvc_NETRDFSMANAGERREPORTSITEINFO
2228 */
2229 static WERROR dcesrv_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2230 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2231 {
2232 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2233 }
2234
2235
2236 /*
2237 srvsvc_NETRSERVERTRANSPORTDELEX
2238 */
2239 static WERROR dcesrv_srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2240 struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2241 {
2242 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2243 }
2244
2245 /*
2246 srvsvc_NetShareDel
2247 */
2248 static WERROR dcesrv_srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2249 struct srvsvc_NetShareDel *r)
2250 {
2251 NTSTATUS nterr;
2252 struct share_context *sctx;
2253
2254 nterr = share_get_context_by_name(mem_ctx, lpcfg_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
2255 if (!NT_STATUS_IS_OK(nterr)) {
2256 return ntstatus_to_werror(nterr);
2257 }
2258
2259 nterr = share_remove(sctx, r->in.share_name);
2260 if (!NT_STATUS_IS_OK(nterr)) {
2261 return ntstatus_to_werror(nterr);
2262 }
2263
2264 return WERR_OK;
2265 }
2266
2267 /*
2268 srvsvc_NetSetServiceBits
2269 */
2270 static WERROR dcesrv_srvsvc_NetSetServiceBits(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2271 struct srvsvc_NetSetServiceBits *r)
2272 {
2273 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2274 }
2275
2276 /*
2277 srvsvc_NETRPRNAMECANONICALIZE
2278 */
2279 static WERROR dcesrv_srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2280 struct srvsvc_NETRPRNAMECANONICALIZE *r)
2281 {
2282 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2283 }
2284
2285 /* include the generated boilerplate */
2286 #include "librpc/gen_ndr/ndr_srvsvc_s.c"
reg import