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