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