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