?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rename the 'hidden' variable to 'administrative share'.
[Samba/nascimento.git] / source3 / rpc_server / srv_srvsvc_nt.c
blob8a25b6cfd5134555ec31d3fe1950e2695c0cdddc
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Jeremy Allison 2001.
6 * Copyright (C) Nigel Williams 2001.
7 * Copyright (C) Gerald (Jerry) Carter 2006.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 */
22
23 /* This is the implementation of the srvsvc pipe. */
24
25 #include "includes.h"
26
27 extern const struct generic_mapping file_generic_mapping;
28
29 #undef DBGC_CLASS
30 #define DBGC_CLASS DBGC_RPC_SRV
31
32 /* Use for enumerating connections, pipes, & files */
33
34 struct file_enum_count {
35 TALLOC_CTX *ctx;
36 const char *username;
37 int count;
38 FILE_INFO_3 *info;
39 };
40
41 struct sess_file_count {
42 struct server_id pid;
43 uid_t uid;
44 int count;
45 };
46
47 /****************************************************************************
48 Count the entries belonging to a service in the connection db.
49 ****************************************************************************/
50
51 static int pipe_enum_fn( struct db_record *rec, void *p)
52 {
53 struct pipe_open_rec prec;
54 struct file_enum_count *fenum = (struct file_enum_count *)p;
55 FILE_INFO_3 *f;
56 int i = fenum->count;
57 char *fullpath = NULL;
58 const char *username;
59
60 if (rec->value.dsize != sizeof(struct pipe_open_rec))
61 return 0;
62
63 memcpy(&prec, rec->value.dptr, sizeof(struct pipe_open_rec));
64
65 if ( !process_exists(prec.pid) ) {
66 return 0;
67 }
68
69 username = uidtoname(prec.uid);
70
71 if ((fenum->username != NULL)
72 && !strequal(username, fenum->username)) {
73 return 0;
74 }
75
76 fullpath = talloc_asprintf(fenum->ctx, "\\PIPE\\%s", prec.name );
77 if (!fullpath) {
78 return 1;
79 }
80
81 f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, FILE_INFO_3, i+1 );
82 if ( !f ) {
83 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
84 return 1;
85 }
86 fenum->info = f;
87
88 init_srv_file_info3(
89 &fenum->info[i],
90 (uint32)((procid_to_pid(&prec.pid)<<16) & prec.pnum),
91 (FILE_READ_DATA|FILE_WRITE_DATA),
92 0, username, fullpath);
93
94 TALLOC_FREE(fullpath);
95 fenum->count++;
96
97 return 0;
98 }
99
100 /*******************************************************************
101 ********************************************************************/
102
103 static WERROR net_enum_pipes( TALLOC_CTX *ctx, const char *username,
104 FILE_INFO_3 **info,
105 uint32 *count, uint32 resume )
106 {
107 struct file_enum_count fenum;
108
109 fenum.ctx = ctx;
110 fenum.username = username;
111 fenum.count = *count;
112 fenum.info = *info;
113
114 if (connections_traverse(pipe_enum_fn, &fenum) == -1) {
115 DEBUG(0,("net_enum_pipes: traverse of connections.tdb "
116 "failed\n"));
117 return WERR_NOMEM;
118 }
119
120 *info = fenum.info;
121 *count = fenum.count;
122
123 return WERR_OK;
124 }
125
126 /*******************************************************************
127 ********************************************************************/
128
129 static void enum_file_fn( const struct share_mode_entry *e,
130 const char *sharepath, const char *fname,
131 void *private_data )
132 {
133 struct file_enum_count *fenum =
134 (struct file_enum_count *)private_data;
135
136 FILE_INFO_3 *f;
137 int i = fenum->count;
138 files_struct fsp;
139 struct byte_range_lock *brl;
140 int num_locks = 0;
141 char *fullpath = NULL;
142 uint32 permissions;
143 const char *username;
144
145 /* If the pid was not found delete the entry from connections.tdb */
146
147 if ( !process_exists(e->pid) ) {
148 return;
149 }
150
151 username = uidtoname(e->uid);
152
153 if ((fenum->username != NULL)
154 && !strequal(username, fenum->username)) {
155 return;
156 }
157
158 f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, FILE_INFO_3, i+1 );
159 if ( !f ) {
160 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
161 return;
162 }
163 fenum->info = f;
164
165 /* need to count the number of locks on a file */
166
167 ZERO_STRUCT( fsp );
168 fsp.file_id = e->id;
169
170 if ( (brl = brl_get_locks(talloc_tos(), &fsp)) != NULL ) {
171 num_locks = brl->num_locks;
172 TALLOC_FREE(brl);
173 }
174
175 if ( strcmp( fname, "." ) == 0 ) {
176 fullpath = talloc_asprintf(fenum->ctx, "C:%s", sharepath );
177 } else {
178 fullpath = talloc_asprintf(fenum->ctx, "C:%s/%s",
179 sharepath, fname );
180 }
181 if (!fullpath) {
182 return;
183 }
184 string_replace( fullpath, '/', '\\' );
185
186 /* mask out create (what ever that is) */
187 permissions = e->share_access & (FILE_READ_DATA|FILE_WRITE_DATA);
188
189 /* now fill in the FILE_INFO_3 struct */
190 init_srv_file_info3( &fenum->info[i],
191 e->share_file_id,
192 permissions,
193 num_locks,
194 username,
195 fullpath );
196
197 TALLOC_FREE(fullpath);
198 fenum->count++;
199 }
200
201 /*******************************************************************
202 ********************************************************************/
203
204 static WERROR net_enum_files( TALLOC_CTX *ctx, const char *username,
205 FILE_INFO_3 **info,
206 uint32 *count, uint32 resume )
207 {
208 struct file_enum_count f_enum_cnt;
209
210 f_enum_cnt.ctx = ctx;
211 f_enum_cnt.username = username;
212 f_enum_cnt.count = *count;
213 f_enum_cnt.info = *info;
214
215 share_mode_forall( enum_file_fn, (void *)&f_enum_cnt );
216
217 *info = f_enum_cnt.info;
218 *count = f_enum_cnt.count;
219
220 return WERR_OK;
221 }
222
223 /*******************************************************************
224 Utility function to get the 'type' of a share from an snum.
225 ********************************************************************/
226 static uint32 get_share_type(int snum)
227 {
228 /* work out the share type */
229 uint32 type = STYPE_DISKTREE;
230
231 if (lp_print_ok(snum))
232 type = STYPE_PRINTQ;
233 if (strequal(lp_fstype(snum), "IPC"))
234 type = STYPE_IPC;
235 if (lp_administrative_share(snum))
236 type |= STYPE_HIDDEN;
237
238 return type;
239 }
240
241 /*******************************************************************
242 Fill in a share info level 0 structure.
243 ********************************************************************/
244
245 static void init_srv_share_info_0(pipes_struct *p, SRV_SHARE_INFO_0 *sh0, int snum)
246 {
247 const char *net_name = lp_servicename(snum);
248
249 init_srv_share_info0(&sh0->info_0, net_name);
250 init_srv_share_info0_str(&sh0->info_0_str, net_name);
251 }
252
253 /*******************************************************************
254 Fill in a share info level 1 structure.
255 ********************************************************************/
256
257 static void init_srv_share_info_1(pipes_struct *p, SRV_SHARE_INFO_1 *sh1, int snum)
258 {
259 char *net_name = lp_servicename(snum);
260 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
261
262 if (remark) {
263 remark = standard_sub_conn(p->mem_ctx,
264 p->conn,
265 remark);
266 }
267
268 init_srv_share_info1(&sh1->info_1,
269 net_name,
270 get_share_type(snum),
271 remark ? remark: "");
272 init_srv_share_info1_str(&sh1->info_1_str,
273 net_name,
274 remark ? remark: "");
275 }
276
277 /*******************************************************************
278 Fill in a share info level 2 structure.
279 ********************************************************************/
280
281 static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int snum)
282 {
283 char *remark = NULL;
284 char *path = NULL;
285 int max_connections = lp_max_connections(snum);
286 uint32 max_uses = max_connections!=0 ? max_connections : 0xffffffff;
287 int count = 0;
288 char *net_name = lp_servicename(snum);
289
290 remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
291 if (remark) {
292 remark = standard_sub_conn(p->mem_ctx,
293 p->conn,
294 remark);
295 }
296 path = talloc_asprintf(p->mem_ctx,
297 "C:%s", lp_pathname(snum));
298
299 if (path) {
300 /*
301 * Change / to \\ so that win2k will see it as a valid path.
302 * This was added to enable use of browsing in win2k add
303 * share dialog.
304 */
305
306 string_replace(path, '/', '\\');
307 }
308
309 count = count_current_connections(net_name, false);
310 init_srv_share_info2(&sh2->info_2,
311 net_name,
312 get_share_type(snum),
313 remark ? remark : "",
314 0,
315 max_uses,
316 count,
317 path ? path : "",
318 "");
319
320 init_srv_share_info2_str(&sh2->info_2_str,
321 net_name,
322 remark ? remark : "",
323 path ? path : "",
324 "");
325 }
326
327 /*******************************************************************
328 Map any generic bits to file specific bits.
329 ********************************************************************/
330
331 static void map_generic_share_sd_bits(SEC_DESC *psd)
332 {
333 int i;
334 SEC_ACL *ps_dacl = NULL;
335
336 if (!psd)
337 return;
338
339 ps_dacl = psd->dacl;
340 if (!ps_dacl)
341 return;
342
343 for (i = 0; i < ps_dacl->num_aces; i++) {
344 SEC_ACE *psa = &ps_dacl->aces[i];
345 uint32 orig_mask = psa->access_mask;
346
347 se_map_generic(&psa->access_mask, &file_generic_mapping);
348 psa->access_mask |= orig_mask;
349 }
350 }
351
352 /*******************************************************************
353 Fill in a share info level 501 structure.
354 ********************************************************************/
355
356 static void init_srv_share_info_501(pipes_struct *p, SRV_SHARE_INFO_501 *sh501, int snum)
357 {
358 const char *net_name = lp_servicename(snum);
359 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
360
361 if (remark) {
362 remark = standard_sub_conn(p->mem_ctx, p->conn, remark);
363 }
364
365 init_srv_share_info501(&sh501->info_501, net_name, get_share_type(snum),
366 remark ? remark : "", (lp_csc_policy(snum) << 4));
367 init_srv_share_info501_str(&sh501->info_501_str,
368 net_name, remark ? remark : "");
369 }
370
371 /*******************************************************************
372 Fill in a share info level 502 structure.
373 ********************************************************************/
374
375 static void init_srv_share_info_502(pipes_struct *p, SRV_SHARE_INFO_502 *sh502, int snum)
376 {
377 const char *net_name = lp_servicename(snum);
378 char *path = NULL;
379 SEC_DESC *sd = NULL;
380 size_t sd_size = 0;
381 TALLOC_CTX *ctx = p->mem_ctx;
382 char *remark = talloc_strdup(ctx, lp_comment(snum));;
383
384 ZERO_STRUCTP(sh502);
385
386 if (remark) {
387 remark = standard_sub_conn(ctx, p->conn, remark);
388 }
389 path = talloc_asprintf(ctx, "C:%s", lp_pathname(snum));
390 if (path) {
391 /*
392 * Change / to \\ so that win2k will see it as a valid path. This was added to
393 * enable use of browsing in win2k add share dialog.
394 */
395 string_replace(path, '/', '\\');
396 }
397
398 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
399
400 init_srv_share_info502(&sh502->info_502,
401 net_name,
402 get_share_type(snum),
403 remark ? remark : "",
404 0,
405 0xffffffff,
406 1,
407 path ? path : "",
408 "",
409 sd,
410 sd_size);
411 init_srv_share_info502_str(&sh502->info_502_str,
412 net_name,
413 remark ? remark : "",
414 path ? path : "",
415 "",
416 sd,
417 sd_size);
418 }
419
420 /***************************************************************************
421 Fill in a share info level 1004 structure.
422 ***************************************************************************/
423
424 static void init_srv_share_info_1004(pipes_struct *p, SRV_SHARE_INFO_1004* sh1004, int snum)
425 {
426 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
427
428 if (remark) {
429 remark = standard_sub_conn(p->mem_ctx, p->conn, remark);
430 }
431
432 ZERO_STRUCTP(sh1004);
433
434 init_srv_share_info1004(&sh1004->info_1004, remark ? remark : "");
435 init_srv_share_info1004_str(&sh1004->info_1004_str,
436 remark ? remark : "");
437 }
438
439 /***************************************************************************
440 Fill in a share info level 1005 structure.
441 ***************************************************************************/
442
443 static void init_srv_share_info_1005(pipes_struct *p, SRV_SHARE_INFO_1005* sh1005, int snum)
444 {
445 sh1005->share_info_flags = 0;
446
447 if(lp_host_msdfs() && lp_msdfs_root(snum))
448 sh1005->share_info_flags |=
449 SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
450 sh1005->share_info_flags |=
451 lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
452 }
453 /***************************************************************************
454 Fill in a share info level 1006 structure.
455 ***************************************************************************/
456
457 static void init_srv_share_info_1006(pipes_struct *p, SRV_SHARE_INFO_1006* sh1006, int snum)
458 {
459 sh1006->max_uses = -1;
460 }
461
462 /***************************************************************************
463 Fill in a share info level 1007 structure.
464 ***************************************************************************/
465
466 static void init_srv_share_info_1007(pipes_struct *p, SRV_SHARE_INFO_1007* sh1007, int snum)
467 {
468 uint32 flags = 0;
469
470 ZERO_STRUCTP(sh1007);
471
472 init_srv_share_info1007(&sh1007->info_1007, flags, "");
473 init_srv_share_info1007_str(&sh1007->info_1007_str, "");
474 }
475
476 /*******************************************************************
477 Fill in a share info level 1501 structure.
478 ********************************************************************/
479
480 static void init_srv_share_info_1501(pipes_struct *p, SRV_SHARE_INFO_1501 *sh1501, int snum)
481 {
482 SEC_DESC *sd;
483 size_t sd_size;
484 TALLOC_CTX *ctx = p->mem_ctx;
485
486 ZERO_STRUCTP(sh1501);
487
488 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
489
490 sh1501->sdb = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
491 }
492
493 /*******************************************************************
494 True if it ends in '$'.
495 ********************************************************************/
496
497 static bool is_hidden_share(int snum)
498 {
499 const char *net_name = lp_servicename(snum);
500
501 return (net_name[strlen(net_name) - 1] == '$') ? True : False;
502 }
503
504 /*******************************************************************
505 Fill in a share info structure.
506 ********************************************************************/
507
508 static bool init_srv_share_info_ctr(pipes_struct *p, SRV_SHARE_INFO_CTR *ctr,
509 uint32 info_level, uint32 *resume_hnd, uint32 *total_entries, bool all_shares)
510 {
511 int num_entries = 0;
512 int num_services = 0;
513 int snum;
514 TALLOC_CTX *ctx = p->mem_ctx;
515
516 DEBUG(5,("init_srv_share_info_ctr\n"));
517
518 ZERO_STRUCTPN(ctr);
519
520 ctr->info_level = ctr->switch_value = info_level;
521 *resume_hnd = 0;
522
523 /* Ensure all the usershares are loaded. */
524 become_root();
525 num_services = load_usershare_shares();
526 load_registry_shares();
527 unbecome_root();
528
529 /* Count the number of entries. */
530 for (snum = 0; snum < num_services; snum++) {
531 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) )
532 num_entries++;
533 }
534
535 *total_entries = num_entries;
536 ctr->num_entries2 = ctr->num_entries = num_entries;
537 ctr->ptr_share_info = ctr->ptr_entries = 1;
538
539 if (!num_entries)
540 return True;
541
542 switch (info_level) {
543 case 0:
544 {
545 SRV_SHARE_INFO_0 *info0 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_0, num_entries);
546 int i = 0;
547
548 if (!info0) {
549 return False;
550 }
551
552 for (snum = *resume_hnd; snum < num_services; snum++) {
553 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
554 init_srv_share_info_0(p, &info0[i++], snum);
555 }
556 }
557
558 ctr->share.info0 = info0;
559 break;
560
561 }
562
563 case 1:
564 {
565 SRV_SHARE_INFO_1 *info1 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1, num_entries);
566 int i = 0;
567
568 if (!info1) {
569 return False;
570 }
571
572 for (snum = *resume_hnd; snum < num_services; snum++) {
573 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
574 init_srv_share_info_1(p, &info1[i++], snum);
575 }
576 }
577
578 ctr->share.info1 = info1;
579 break;
580 }
581
582 case 2:
583 {
584 SRV_SHARE_INFO_2 *info2 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_2, num_entries);
585 int i = 0;
586
587 if (!info2) {
588 return False;
589 }
590
591 for (snum = *resume_hnd; snum < num_services; snum++) {
592 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
593 init_srv_share_info_2(p, &info2[i++], snum);
594 }
595 }
596
597 ctr->share.info2 = info2;
598 break;
599 }
600
601 case 501:
602 {
603 SRV_SHARE_INFO_501 *info501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_501, num_entries);
604 int i = 0;
605
606 if (!info501) {
607 return False;
608 }
609
610 for (snum = *resume_hnd; snum < num_services; snum++) {
611 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
612 init_srv_share_info_501(p, &info501[i++], snum);
613 }
614 }
615
616 ctr->share.info501 = info501;
617 break;
618 }
619
620 case 502:
621 {
622 SRV_SHARE_INFO_502 *info502 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_502, num_entries);
623 int i = 0;
624
625 if (!info502) {
626 return False;
627 }
628
629 for (snum = *resume_hnd; snum < num_services; snum++) {
630 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
631 init_srv_share_info_502(p, &info502[i++], snum);
632 }
633 }
634
635 ctr->share.info502 = info502;
636 break;
637 }
638
639 /* here for completeness but not currently used with enum (1004 - 1501)*/
640
641 case 1004:
642 {
643 SRV_SHARE_INFO_1004 *info1004 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1004, num_entries);
644 int i = 0;
645
646 if (!info1004) {
647 return False;
648 }
649
650 for (snum = *resume_hnd; snum < num_services; snum++) {
651 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
652 init_srv_share_info_1004(p, &info1004[i++], snum);
653 }
654 }
655
656 ctr->share.info1004 = info1004;
657 break;
658 }
659
660 case 1005:
661 {
662 SRV_SHARE_INFO_1005 *info1005 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1005, num_entries);
663 int i = 0;
664
665 if (!info1005) {
666 return False;
667 }
668
669 for (snum = *resume_hnd; snum < num_services; snum++) {
670 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
671 init_srv_share_info_1005(p, &info1005[i++], snum);
672 }
673 }
674
675 ctr->share.info1005 = info1005;
676 break;
677 }
678
679 case 1006:
680 {
681 SRV_SHARE_INFO_1006 *info1006 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1006, num_entries);
682 int i = 0;
683
684 if (!info1006) {
685 return False;
686 }
687
688 for (snum = *resume_hnd; snum < num_services; snum++) {
689 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
690 init_srv_share_info_1006(p, &info1006[i++], snum);
691 }
692 }
693
694 ctr->share.info1006 = info1006;
695 break;
696 }
697
698 case 1007:
699 {
700 SRV_SHARE_INFO_1007 *info1007 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1007, num_entries);
701 int i = 0;
702
703 if (!info1007) {
704 return False;
705 }
706
707 for (snum = *resume_hnd; snum < num_services; snum++) {
708 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
709 init_srv_share_info_1007(p, &info1007[i++], snum);
710 }
711 }
712
713 ctr->share.info1007 = info1007;
714 break;
715 }
716
717 case 1501:
718 {
719 SRV_SHARE_INFO_1501 *info1501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1501, num_entries);
720 int i = 0;
721
722 if (!info1501) {
723 return False;
724 }
725
726 for (snum = *resume_hnd; snum < num_services; snum++) {
727 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
728 init_srv_share_info_1501(p, &info1501[i++], snum);
729 }
730 }
731
732 ctr->share.info1501 = info1501;
733 break;
734 }
735 default:
736 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n", info_level));
737 return False;
738 }
739
740 return True;
741 }
742
743 /*******************************************************************
744 Inits a SRV_R_NET_SHARE_ENUM structure.
745 ********************************************************************/
746
747 static void init_srv_r_net_share_enum(pipes_struct *p, SRV_R_NET_SHARE_ENUM *r_n,
748 uint32 info_level, uint32 resume_hnd, bool all)
749 {
750 DEBUG(5,("init_srv_r_net_share_enum: %d\n", __LINE__));
751
752 if (init_srv_share_info_ctr(p, &r_n->ctr, info_level,
753 &resume_hnd, &r_n->total_entries, all)) {
754 r_n->status = WERR_OK;
755 } else {
756 r_n->status = WERR_UNKNOWN_LEVEL;
757 }
758
759 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
760 }
761
762 /*******************************************************************
763 Inits a SRV_R_NET_SHARE_GET_INFO structure.
764 ********************************************************************/
765
766 static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_INFO *r_n,
767 char *share_name, uint32 info_level)
768 {
769 WERROR status = WERR_OK;
770 int snum;
771
772 DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
773
774 r_n->info.switch_value = info_level;
775
776 snum = find_service(share_name);
777
778 if (snum >= 0) {
779 switch (info_level) {
780 case 0:
781 init_srv_share_info_0(p, &r_n->info.share.info0, snum);
782 break;
783 case 1:
784 init_srv_share_info_1(p, &r_n->info.share.info1, snum);
785 break;
786 case 2:
787 init_srv_share_info_2(p, &r_n->info.share.info2, snum);
788 break;
789 case 501:
790 init_srv_share_info_501(p, &r_n->info.share.info501, snum);
791 break;
792 case 502:
793 init_srv_share_info_502(p, &r_n->info.share.info502, snum);
794 break;
795
796 /* here for completeness */
797 case 1004:
798 init_srv_share_info_1004(p, &r_n->info.share.info1004, snum);
799 break;
800 case 1005:
801 init_srv_share_info_1005(p, &r_n->info.share.info1005, snum);
802 break;
803
804 /* here for completeness 1006 - 1501 */
805 case 1006:
806 init_srv_share_info_1006(p, &r_n->info.share.info1006, snum);
807 break;
808 case 1007:
809 init_srv_share_info_1007(p, &r_n->info.share.info1007, snum);
810 break;
811 case 1501:
812 init_srv_share_info_1501(p, &r_n->info.share.info1501, snum);
813 break;
814 default:
815 DEBUG(5,("init_srv_net_share_get_info: unsupported switch value %d\n", info_level));
816 status = WERR_UNKNOWN_LEVEL;
817 break;
818 }
819 } else {
820 status = WERR_INVALID_NAME;
821 }
822
823 r_n->info.ptr_share_ctr = W_ERROR_IS_OK(status) ? 1 : 0;
824 r_n->status = status;
825 }
826
827 /*******************************************************************
828 fill in a sess info level 0 structure.
829 ********************************************************************/
830
831 static void init_srv_sess_info_0(pipes_struct *p, SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *stot)
832 {
833 struct sessionid *session_list;
834 uint32 num_entries = 0;
835 (*stot) = list_sessions(p->mem_ctx, &session_list);
836
837 if (ss0 == NULL) {
838 if (snum) {
839 (*snum) = 0;
840 }
841 return;
842 }
843
844 DEBUG(5,("init_srv_sess_0_ss0\n"));
845
846 if (snum) {
847 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
848 init_srv_sess_info0( &ss0->info_0[num_entries], session_list[(*snum)].remote_machine);
849 num_entries++;
850 }
851
852 ss0->num_entries_read = num_entries;
853 ss0->ptr_sess_info = num_entries > 0 ? 1 : 0;
854 ss0->num_entries_read2 = num_entries;
855
856 if ((*snum) >= (*stot)) {
857 (*snum) = 0;
858 }
859
860 } else {
861 ss0->num_entries_read = 0;
862 ss0->ptr_sess_info = 0;
863 ss0->num_entries_read2 = 0;
864 }
865 }
866
867 /*******************************************************************
868 ********************************************************************/
869
870 static void sess_file_fn( const struct share_mode_entry *e,
871 const char *sharepath, const char *fname,
872 void *data )
873 {
874 struct sess_file_count *sess = (struct sess_file_count *)data;
875
876 if ( procid_equal(&e->pid, &sess->pid) && (sess->uid == e->uid) ) {
877 sess->count++;
878 }
879
880 return;
881 }
882
883 /*******************************************************************
884 ********************************************************************/
885
886 static int net_count_files( uid_t uid, struct server_id pid )
887 {
888 struct sess_file_count s_file_cnt;
889
890 s_file_cnt.count = 0;
891 s_file_cnt.uid = uid;
892 s_file_cnt.pid = pid;
893
894 share_mode_forall( sess_file_fn, &s_file_cnt );
895
896 return s_file_cnt.count;
897 }
898
899 /*******************************************************************
900 fill in a sess info level 1 structure.
901 ********************************************************************/
902
903 static void init_srv_sess_info_1(pipes_struct *p, SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *stot)
904 {
905 struct sessionid *session_list;
906 uint32 num_entries = 0;
907 time_t now = time(NULL);
908
909 if ( !snum ) {
910 ss1->num_entries_read = 0;
911 ss1->ptr_sess_info = 0;
912 ss1->num_entries_read2 = 0;
913
914 (*stot) = 0;
915
916 return;
917 }
918
919 if (ss1 == NULL) {
920 (*snum) = 0;
921 return;
922 }
923
924 (*stot) = list_sessions(p->mem_ctx, &session_list);
925
926
927 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
928 uint32 num_files;
929 uint32 connect_time;
930 struct passwd *pw = sys_getpwnam(session_list[*snum].username);
931 bool guest;
932
933 if ( !pw ) {
934 DEBUG(10,("init_srv_sess_info_1: failed to find owner: %s\n",
935 session_list[*snum].username));
936 continue;
937 }
938
939 connect_time = (uint32)(now - session_list[*snum].connect_start);
940 num_files = net_count_files(pw->pw_uid, session_list[*snum].pid);
941 guest = strequal( session_list[*snum].username, lp_guestaccount() );
942
943 init_srv_sess_info1( &ss1->info_1[num_entries],
944 session_list[*snum].remote_machine,
945 session_list[*snum].username,
946 num_files,
947 connect_time,
948 0,
949 guest);
950 num_entries++;
951 }
952
953 ss1->num_entries_read = num_entries;
954 ss1->ptr_sess_info = num_entries > 0 ? 1 : 0;
955 ss1->num_entries_read2 = num_entries;
956
957 if ((*snum) >= (*stot)) {
958 (*snum) = 0;
959 }
960
961 }
962
963 /*******************************************************************
964 makes a SRV_R_NET_SESS_ENUM structure.
965 ********************************************************************/
966
967 static WERROR init_srv_sess_info_ctr(pipes_struct *p, SRV_SESS_INFO_CTR *ctr,
968 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
969 {
970 WERROR status = WERR_OK;
971 DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
972
973 ctr->switch_value = switch_value;
974
975 switch (switch_value) {
976 case 0:
977 init_srv_sess_info_0(p, &(ctr->sess.info0), resume_hnd, total_entries);
978 ctr->ptr_sess_ctr = 1;
979 break;
980 case 1:
981 init_srv_sess_info_1(p, &(ctr->sess.info1), resume_hnd, total_entries);
982 ctr->ptr_sess_ctr = 1;
983 break;
984 default:
985 DEBUG(5,("init_srv_sess_info_ctr: unsupported switch value %d\n", switch_value));
986 (*resume_hnd) = 0;
987 (*total_entries) = 0;
988 ctr->ptr_sess_ctr = 0;
989 status = WERR_UNKNOWN_LEVEL;
990 break;
991 }
992
993 return status;
994 }
995
996 /*******************************************************************
997 makes a SRV_R_NET_SESS_ENUM structure.
998 ********************************************************************/
999
1000 static void init_srv_r_net_sess_enum(pipes_struct *p, SRV_R_NET_SESS_ENUM *r_n,
1001 uint32 resume_hnd, int sess_level, int switch_value)
1002 {
1003 DEBUG(5,("init_srv_r_net_sess_enum: %d\n", __LINE__));
1004
1005 r_n->sess_level = sess_level;
1006
1007 if (sess_level == -1)
1008 r_n->status = WERR_UNKNOWN_LEVEL;
1009 else
1010 r_n->status = init_srv_sess_info_ctr(p, r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
1011
1012 if (!W_ERROR_IS_OK(r_n->status))
1013 resume_hnd = 0;
1014
1015 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1016 }
1017
1018 /*******************************************************************
1019 fill in a conn info level 0 structure.
1020 ********************************************************************/
1021
1022 static void init_srv_conn_info_0(SRV_CONN_INFO_0 *ss0, uint32 *snum, uint32 *stot)
1023 {
1024 uint32 num_entries = 0;
1025 (*stot) = 1;
1026
1027 if (ss0 == NULL) {
1028 (*snum) = 0;
1029 return;
1030 }
1031
1032 DEBUG(5,("init_srv_conn_0_ss0\n"));
1033
1034 if (snum) {
1035 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
1036
1037 init_srv_conn_info0(&ss0->info_0[num_entries], (*stot));
1038
1039 /* move on to creating next connection */
1040 /* move on to creating next conn */
1041 num_entries++;
1042 }
1043
1044 ss0->num_entries_read = num_entries;
1045 ss0->ptr_conn_info = num_entries > 0 ? 1 : 0;
1046 ss0->num_entries_read2 = num_entries;
1047
1048 if ((*snum) >= (*stot)) {
1049 (*snum) = 0;
1050 }
1051
1052 } else {
1053 ss0->num_entries_read = 0;
1054 ss0->ptr_conn_info = 0;
1055 ss0->num_entries_read2 = 0;
1056
1057 (*stot) = 0;
1058 }
1059 }
1060
1061 /*******************************************************************
1062 fill in a conn info level 1 structure.
1063 ********************************************************************/
1064
1065 static void init_srv_conn_1_info(CONN_INFO_1 *se1, CONN_INFO_1_STR *str1,
1066 uint32 id, uint32 type,
1067 uint32 num_opens, uint32 num_users, uint32 open_time,
1068 const char *usr_name, const char *net_name)
1069 {
1070 init_srv_conn_info1(se1 , id, type, num_opens, num_users, open_time, usr_name, net_name);
1071 init_srv_conn_info1_str(str1, usr_name, net_name);
1072 }
1073
1074 /*******************************************************************
1075 fill in a conn info level 1 structure.
1076 ********************************************************************/
1077
1078 static void init_srv_conn_info_1(SRV_CONN_INFO_1 *ss1, uint32 *snum, uint32 *stot)
1079 {
1080 uint32 num_entries = 0;
1081 (*stot) = 1;
1082
1083 if (ss1 == NULL) {
1084 (*snum) = 0;
1085 return;
1086 }
1087
1088 DEBUG(5,("init_srv_conn_1_ss1\n"));
1089
1090 if (snum) {
1091 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
1092 init_srv_conn_1_info(&ss1->info_1[num_entries],
1093 &ss1->info_1_str[num_entries],
1094 (*stot), 0x3, 1, 1, 3,"dummy_user", "IPC$");
1095
1096 /* move on to creating next connection */
1097 /* move on to creating next conn */
1098 num_entries++;
1099 }
1100
1101 ss1->num_entries_read = num_entries;
1102 ss1->ptr_conn_info = num_entries > 0 ? 1 : 0;
1103 ss1->num_entries_read2 = num_entries;
1104
1105
1106 if ((*snum) >= (*stot)) {
1107 (*snum) = 0;
1108 }
1109
1110 } else {
1111 ss1->num_entries_read = 0;
1112 ss1->ptr_conn_info = 0;
1113 ss1->num_entries_read2 = 0;
1114
1115 (*stot) = 0;
1116 }
1117 }
1118
1119 /*******************************************************************
1120 makes a SRV_R_NET_CONN_ENUM structure.
1121 ********************************************************************/
1122
1123 static WERROR init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
1124 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
1125 {
1126 WERROR status = WERR_OK;
1127 DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
1128
1129 ctr->switch_value = switch_value;
1130
1131 switch (switch_value) {
1132 case 0:
1133 init_srv_conn_info_0(&ctr->conn.info0, resume_hnd, total_entries);
1134 ctr->ptr_conn_ctr = 1;
1135 break;
1136 case 1:
1137 init_srv_conn_info_1(&ctr->conn.info1, resume_hnd, total_entries);
1138 ctr->ptr_conn_ctr = 1;
1139 break;
1140 default:
1141 DEBUG(5,("init_srv_conn_info_ctr: unsupported switch value %d\n", switch_value));
1142 (*resume_hnd = 0);
1143 (*total_entries) = 0;
1144 ctr->ptr_conn_ctr = 0;
1145 status = WERR_UNKNOWN_LEVEL;
1146 break;
1147 }
1148
1149 return status;
1150 }
1151
1152 /*******************************************************************
1153 makes a SRV_R_NET_CONN_ENUM structure.
1154 ********************************************************************/
1155
1156 static void init_srv_r_net_conn_enum(SRV_R_NET_CONN_ENUM *r_n,
1157 uint32 resume_hnd, int conn_level, int switch_value)
1158 {
1159 DEBUG(5,("init_srv_r_net_conn_enum: %d\n", __LINE__));
1160
1161 r_n->conn_level = conn_level;
1162 if (conn_level == -1)
1163 r_n->status = WERR_UNKNOWN_LEVEL;
1164 else
1165 r_n->status = init_srv_conn_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
1166
1167 if (!W_ERROR_IS_OK(r_n->status))
1168 resume_hnd = 0;
1169
1170 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1171 }
1172
1173 /*******************************************************************
1174 makes a SRV_R_NET_FILE_ENUM structure.
1175 ********************************************************************/
1176
1177 static WERROR net_file_enum_3( const char *username, SRV_R_NET_FILE_ENUM *r,
1178 uint32 resume_hnd )
1179 {
1180 TALLOC_CTX *ctx = talloc_tos();
1181 SRV_FILE_INFO_CTR *ctr = &r->ctr;
1182
1183 /* TODO -- Windows enumerates
1184 (b) active pipes
1185 (c) open directories and files */
1186
1187 r->status = net_enum_files( ctx, username, &ctr->file.info3,
1188 &ctr->num_entries, resume_hnd );
1189 if ( !W_ERROR_IS_OK(r->status))
1190 goto done;
1191
1192 r->status = net_enum_pipes( ctx, username, &ctr->file.info3,
1193 &ctr->num_entries, resume_hnd );
1194 if ( !W_ERROR_IS_OK(r->status))
1195 goto done;
1196
1197 r->level = ctr->level = 3;
1198 r->total_entries = ctr->num_entries;
1199 /* ctr->num_entries = r->total_entries - resume_hnd; */
1200 ctr->num_entries2 = ctr->num_entries;
1201 ctr->ptr_file_info = 1;
1202
1203 r->status = WERR_OK;
1204
1205 done:
1206 if ( ctr->num_entries > 0 )
1207 ctr->ptr_entries = 1;
1208
1209 init_enum_hnd(&r->enum_hnd, 0);
1210
1211 return r->status;
1212 }
1213
1214 /*******************************************************************
1215 *******************************************************************/
1216
1217 WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
1218 {
1219 const char *username = NULL;
1220
1221 switch ( q_u->level ) {
1222 case 3:
1223 if (q_u->username) {
1224 username = rpcstr_pull_unistr2_talloc(
1225 p->mem_ctx, q_u->username);
1226 if (!username) {
1227 return WERR_NOMEM;
1228 }
1229 }
1230
1231 return net_file_enum_3(username, r_u,
1232 get_enum_hnd(&q_u->enum_hnd));
1233 default:
1234 return WERR_UNKNOWN_LEVEL;
1235 }
1236
1237 return WERR_OK;
1238 }
1239
1240 /*******************************************************************
1241 net server get info
1242 ********************************************************************/
1243
1244 WERROR _srv_net_srv_get_info(pipes_struct *p, SRV_Q_NET_SRV_GET_INFO *q_u, SRV_R_NET_SRV_GET_INFO *r_u)
1245 {
1246 WERROR status = WERR_OK;
1247 SRV_INFO_CTR *ctr = TALLOC_P(p->mem_ctx, SRV_INFO_CTR);
1248
1249 if (!ctr)
1250 return WERR_NOMEM;
1251
1252 ZERO_STRUCTP(ctr);
1253
1254 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1255
1256 if (!pipe_access_check(p)) {
1257 DEBUG(3, ("access denied to srv_net_srv_get_info\n"));
1258 return WERR_ACCESS_DENIED;
1259 }
1260
1261 switch (q_u->switch_value) {
1262
1263 /* Technically level 102 should only be available to
1264 Administrators but there isn't anything super-secret
1265 here, as most of it is made up. */
1266
1267 case 102:
1268 init_srv_info_102(&ctr->srv.sv102,
1269 500, global_myname(),
1270 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH),
1271 lp_major_announce_version(), lp_minor_announce_version(),
1272 lp_default_server_announce(),
1273 0xffffffff, /* users */
1274 0xf, /* disc */
1275 0, /* hidden */
1276 240, /* announce */
1277 3000, /* announce delta */
1278 100000, /* licenses */
1279 "c:\\"); /* user path */
1280 break;
1281 case 101:
1282 init_srv_info_101(&ctr->srv.sv101,
1283 500, global_myname(),
1284 lp_major_announce_version(), lp_minor_announce_version(),
1285 lp_default_server_announce(),
1286 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH));
1287 break;
1288 case 100:
1289 init_srv_info_100(&ctr->srv.sv100, 500, global_myname());
1290 break;
1291 default:
1292 status = WERR_UNKNOWN_LEVEL;
1293 break;
1294 }
1295
1296 /* set up the net server get info structure */
1297 init_srv_r_net_srv_get_info(r_u, q_u->switch_value, ctr, status);
1298
1299 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1300
1301 return r_u->status;
1302 }
1303
1304 /*******************************************************************
1305 net server set info
1306 ********************************************************************/
1307
1308 WERROR _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R_NET_SRV_SET_INFO *r_u)
1309 {
1310 WERROR status = WERR_OK;
1311
1312 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1313
1314 /* Set up the net server set info structure. */
1315
1316 init_srv_r_net_srv_set_info(r_u, 0x0, status);
1317
1318 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1319
1320 return r_u->status;
1321 }
1322
1323 /*******************************************************************
1324 net conn enum
1325 ********************************************************************/
1326
1327 WERROR _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
1328 {
1329 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1330
1331 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_CONN_INFO_CTR);
1332 if (!r_u->ctr)
1333 return WERR_NOMEM;
1334
1335 ZERO_STRUCTP(r_u->ctr);
1336
1337 /* set up the */
1338 init_srv_r_net_conn_enum(r_u,
1339 get_enum_hnd(&q_u->enum_hnd),
1340 q_u->conn_level,
1341 q_u->ctr->switch_value);
1342
1343 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1344
1345 return r_u->status;
1346 }
1347
1348 /*******************************************************************
1349 net sess enum
1350 ********************************************************************/
1351
1352 WERROR _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
1353 {
1354 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1355
1356 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_SESS_INFO_CTR);
1357 if (!r_u->ctr)
1358 return WERR_NOMEM;
1359
1360 ZERO_STRUCTP(r_u->ctr);
1361
1362 /* set up the */
1363 init_srv_r_net_sess_enum(p, r_u,
1364 get_enum_hnd(&q_u->enum_hnd),
1365 q_u->sess_level,
1366 q_u->ctr->switch_value);
1367
1368 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1369
1370 return r_u->status;
1371 }
1372
1373 /*******************************************************************
1374 net sess del
1375 ********************************************************************/
1376
1377 WERROR _srv_net_sess_del(pipes_struct *p, SRV_Q_NET_SESS_DEL *q_u, SRV_R_NET_SESS_DEL *r_u)
1378 {
1379 struct sessionid *session_list;
1380 struct current_user user;
1381 int num_sessions, snum;
1382 fstring username;
1383 fstring machine;
1384 bool not_root = False;
1385
1386 rpcstr_pull_unistr2_fstring(username, &q_u->uni_user_name);
1387 rpcstr_pull_unistr2_fstring(machine, &q_u->uni_cli_name);
1388
1389 /* strip leading backslashes if any */
1390 while (machine[0] == '\\') {
1391 memmove(machine, &machine[1], strlen(machine));
1392 }
1393
1394 num_sessions = list_sessions(p->mem_ctx, &session_list);
1395
1396 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1397
1398 r_u->status = WERR_ACCESS_DENIED;
1399
1400 get_current_user(&user, p);
1401
1402 /* fail out now if you are not root or not a domain admin */
1403
1404 if ((user.ut.uid != sec_initial_uid()) &&
1405 ( ! nt_token_check_domain_rid(p->pipe_user.nt_user_token, DOMAIN_GROUP_RID_ADMINS))) {
1406
1407 goto done;
1408 }
1409
1410 for (snum = 0; snum < num_sessions; snum++) {
1411
1412 if ((strequal(session_list[snum].username, username) || username[0] == '\0' ) &&
1413 strequal(session_list[snum].remote_machine, machine)) {
1414
1415 NTSTATUS ntstat;
1416
1417 if (user.ut.uid != sec_initial_uid()) {
1418 not_root = True;
1419 become_root();
1420 }
1421
1422 ntstat = messaging_send(smbd_messaging_context(),
1423 session_list[snum].pid,
1424 MSG_SHUTDOWN, &data_blob_null);
1425
1426 if (NT_STATUS_IS_OK(ntstat))
1427 r_u->status = WERR_OK;
1428
1429 if (not_root)
1430 unbecome_root();
1431 }
1432 }
1433
1434 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1435
1436
1437 done:
1438
1439 return r_u->status;
1440 }
1441
1442 /*******************************************************************
1443 Net share enum all.
1444 ********************************************************************/
1445
1446 WERROR _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1447 {
1448 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1449
1450 if (!pipe_access_check(p)) {
1451 DEBUG(3, ("access denied to srv_net_share_enum_all\n"));
1452 return WERR_ACCESS_DENIED;
1453 }
1454
1455 /* Create the list of shares for the response. */
1456 init_srv_r_net_share_enum(p, r_u,
1457 q_u->ctr.info_level,
1458 get_enum_hnd(&q_u->enum_hnd), True);
1459
1460 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1461
1462 return r_u->status;
1463 }
1464
1465 /*******************************************************************
1466 Net share enum.
1467 ********************************************************************/
1468
1469 WERROR _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1470 {
1471 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1472
1473 if (!pipe_access_check(p)) {
1474 DEBUG(3, ("access denied to srv_net_share_enum\n"));
1475 return WERR_ACCESS_DENIED;
1476 }
1477
1478 /* Create the list of shares for the response. */
1479 init_srv_r_net_share_enum(p, r_u,
1480 q_u->ctr.info_level,
1481 get_enum_hnd(&q_u->enum_hnd), False);
1482
1483 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1484
1485 return r_u->status;
1486 }
1487
1488 /*******************************************************************
1489 Net share get info.
1490 ********************************************************************/
1491
1492 WERROR _srv_net_share_get_info(pipes_struct *p, SRV_Q_NET_SHARE_GET_INFO *q_u, SRV_R_NET_SHARE_GET_INFO *r_u)
1493 {
1494 fstring share_name;
1495
1496 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1497
1498 /* Create the list of shares for the response. */
1499 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1500 init_srv_r_net_share_get_info(p, r_u, share_name, q_u->info_level);
1501
1502 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1503
1504 return r_u->status;
1505 }
1506
1507 /*******************************************************************
1508 Check a given DOS pathname is valid for a share.
1509 ********************************************************************/
1510
1511 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
1512 {
1513 char *ptr = NULL;
1514
1515 if (!dos_pathname) {
1516 return NULL;
1517 }
1518
1519 ptr = talloc_strdup(ctx, dos_pathname);
1520 if (!ptr) {
1521 return NULL;
1522 }
1523 /* Convert any '\' paths to '/' */
1524 unix_format(ptr);
1525 ptr = unix_clean_name(ctx, ptr);
1526 if (!ptr) {
1527 return NULL;
1528 }
1529
1530 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
1531 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
1532 ptr += 2;
1533
1534 /* Only absolute paths allowed. */
1535 if (*ptr != '/')
1536 return NULL;
1537
1538 return ptr;
1539 }
1540
1541 /*******************************************************************
1542 Net share set info. Modify share details.
1543 ********************************************************************/
1544
1545 WERROR _srv_net_share_set_info(pipes_struct *p, SRV_Q_NET_SHARE_SET_INFO *q_u, SRV_R_NET_SHARE_SET_INFO *r_u)
1546 {
1547 struct current_user user;
1548 char *command = NULL;
1549 char *share_name = NULL;
1550 char *comment = NULL;
1551 char *pathname = NULL;
1552 int type;
1553 int snum;
1554 int ret;
1555 char *path = NULL;
1556 SEC_DESC *psd = NULL;
1557 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1558 bool is_disk_op = False;
1559 int max_connections = 0;
1560 TALLOC_CTX *ctx = p->mem_ctx;
1561
1562 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1563
1564 share_name = unistr2_to_ascii_talloc(ctx, &q_u->uni_share_name);
1565 if (!share_name) {
1566 return WERR_NET_NAME_NOT_FOUND;
1567 }
1568
1569 r_u->parm_error = 0;
1570
1571 if ( strequal(share_name,"IPC$")
1572 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1573 || strequal(share_name,"global") )
1574 {
1575 return WERR_ACCESS_DENIED;
1576 }
1577
1578 snum = find_service(share_name);
1579
1580 /* Does this share exist ? */
1581 if (snum < 0)
1582 return WERR_NET_NAME_NOT_FOUND;
1583
1584 /* No change to printer shares. */
1585 if (lp_print_ok(snum))
1586 return WERR_ACCESS_DENIED;
1587
1588 get_current_user(&user,p);
1589
1590 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1591
1592 /* fail out now if you are not root and not a disk op */
1593
1594 if ( user.ut.uid != sec_initial_uid() && !is_disk_op )
1595 return WERR_ACCESS_DENIED;
1596
1597 switch (q_u->info_level) {
1598 case 1:
1599 pathname = talloc_strdup(ctx, lp_pathname(snum));
1600 comment = unistr2_to_ascii_talloc(ctx,
1601 &q_u->info.share.info2.info_2_str.uni_remark);
1602 type = q_u->info.share.info2.info_2.type;
1603 psd = NULL;
1604 break;
1605 case 2:
1606 comment = unistr2_to_ascii_talloc(ctx,
1607 &q_u->info.share.info2.info_2_str.uni_remark);
1608 pathname = unistr2_to_ascii_talloc(ctx,
1609 &q_u->info.share.info2.info_2_str.uni_path);
1610 type = q_u->info.share.info2.info_2.type;
1611 max_connections = (q_u->info.share.info2.info_2.max_uses == 0xffffffff) ? 0 : q_u->info.share.info2.info_2.max_uses;
1612 psd = NULL;
1613 break;
1614 #if 0
1615 /* not supported on set but here for completeness */
1616 case 501:
1617 unistr2_to_ascii(comment, &q_u->info.share.info501.info_501_str.uni_remark, sizeof(comment));
1618 type = q_u->info.share.info501.info_501.type;
1619 psd = NULL;
1620 break;
1621 #endif
1622 case 502:
1623 comment = unistr2_to_ascii_talloc(ctx,
1624 &q_u->info.share.info502.info_502_str.uni_remark);
1625 pathname = unistr2_to_ascii_talloc(ctx,
1626 &q_u->info.share.info502.info_502_str.uni_path);
1627 type = q_u->info.share.info502.info_502.type;
1628 psd = q_u->info.share.info502.info_502_str.sd;
1629 map_generic_share_sd_bits(psd);
1630 break;
1631 case 1004:
1632 pathname = talloc_strdup(ctx, lp_pathname(snum));
1633 comment = unistr2_to_ascii_talloc(ctx,
1634 &q_u->info.share.info1004.info_1004_str.uni_remark);
1635 type = STYPE_DISKTREE;
1636 break;
1637 case 1005:
1638 /* XP re-sets the csc policy even if it wasn't changed by the
1639 user, so we must compare it to see if it's what is set in
1640 smb.conf, so that we can contine other ops like setting
1641 ACLs on a share */
1642 if (((q_u->info.share.info1005.share_info_flags &
1643 SHARE_1005_CSC_POLICY_MASK) >>
1644 SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
1645 return WERR_OK;
1646 else {
1647 DEBUG(3, ("_srv_net_share_set_info: client is trying to change csc policy from the network; must be done with smb.conf\n"));
1648 return WERR_ACCESS_DENIED;
1649 }
1650 case 1006:
1651 case 1007:
1652 return WERR_ACCESS_DENIED;
1653 case 1501:
1654 pathname = talloc_strdup(ctx, lp_pathname(snum));
1655 comment = talloc_strdup(ctx, lp_comment(snum));
1656 psd = q_u->info.share.info1501.sdb->sd;
1657 map_generic_share_sd_bits(psd);
1658 type = STYPE_DISKTREE;
1659 break;
1660 default:
1661 DEBUG(5,("_srv_net_share_set_info: unsupported switch value %d\n", q_u->info_level));
1662 return WERR_UNKNOWN_LEVEL;
1663 }
1664
1665 /* We can only modify disk shares. */
1666 if (type != STYPE_DISKTREE)
1667 return WERR_ACCESS_DENIED;
1668
1669 /* Check if the pathname is valid. */
1670 if (!(path = valid_share_pathname(p->mem_ctx, pathname )))
1671 return WERR_OBJECT_PATH_INVALID;
1672
1673 /* Ensure share name, pathname and comment don't contain '"' characters. */
1674 string_replace(share_name, '"', ' ');
1675 string_replace(path, '"', ' ');
1676 if (comment) {
1677 string_replace(comment, '"', ' ');
1678 }
1679
1680 DEBUG(10,("_srv_net_share_set_info: change share command = %s\n",
1681 lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
1682
1683 /* Only call modify function if something changed. */
1684
1685 if (strcmp(path, lp_pathname(snum)) || strcmp(comment, lp_comment(snum))
1686 || (lp_max_connections(snum) != max_connections)) {
1687 if (!lp_change_share_cmd() || !*lp_change_share_cmd()) {
1688 DEBUG(10,("_srv_net_share_set_info: No change share command\n"));
1689 return WERR_ACCESS_DENIED;
1690 }
1691
1692 command = talloc_asprintf(p->mem_ctx,
1693 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1694 lp_change_share_cmd(),
1695 get_dyn_CONFIGFILE(),
1696 share_name,
1697 path,
1698 comment ? comment : "",
1699 max_connections);
1700 if (!command) {
1701 return WERR_NOMEM;
1702 }
1703
1704 DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
1705
1706 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1707
1708 if (is_disk_op)
1709 become_root();
1710
1711 if ( (ret = smbrun(command, NULL)) == 0 ) {
1712 /* Tell everyone we updated smb.conf. */
1713 message_send_all(smbd_messaging_context(),
1714 MSG_SMB_CONF_UPDATED, NULL, 0,
1715 NULL);
1716 }
1717
1718 if ( is_disk_op )
1719 unbecome_root();
1720
1721 /********* END SeDiskOperatorPrivilege BLOCK *********/
1722
1723 DEBUG(3,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
1724
1725 TALLOC_FREE(command);
1726
1727 if ( ret != 0 )
1728 return WERR_ACCESS_DENIED;
1729 } else {
1730 DEBUG(10,("_srv_net_share_set_info: No change to share name (%s)\n", share_name ));
1731 }
1732
1733 /* Replace SD if changed. */
1734 if (psd) {
1735 SEC_DESC *old_sd;
1736 size_t sd_size;
1737
1738 old_sd = get_share_security(p->mem_ctx, lp_servicename(snum), &sd_size);
1739
1740 if (old_sd && !sec_desc_equal(old_sd, psd)) {
1741 if (!set_share_security(share_name, psd))
1742 DEBUG(0,("_srv_net_share_set_info: Failed to change security info in share %s.\n",
1743 share_name ));
1744 }
1745 }
1746
1747 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1748
1749 return WERR_OK;
1750 }
1751
1752 /*******************************************************************
1753 Net share add. Call 'add_share_command "sharename" "pathname"
1754 "comment" "max connections = "
1755 ********************************************************************/
1756
1757 WERROR _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
1758 {
1759 struct current_user user;
1760 char *command = NULL;
1761 char *share_name = NULL;
1762 char *comment = NULL;
1763 char *pathname = NULL;
1764 int type;
1765 int snum;
1766 int ret;
1767 char *path;
1768 SEC_DESC *psd = NULL;
1769 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1770 bool is_disk_op;
1771 int max_connections = 0;
1772 TALLOC_CTX *ctx = p->mem_ctx;
1773
1774 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1775
1776 r_u->parm_error = 0;
1777
1778 get_current_user(&user,p);
1779
1780 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1781
1782 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1783 return WERR_ACCESS_DENIED;
1784
1785 if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
1786 DEBUG(10,("_srv_net_share_add: No add share command\n"));
1787 return WERR_ACCESS_DENIED;
1788 }
1789
1790 switch (q_u->info_level) {
1791 case 0:
1792 /* No path. Not enough info in a level 0 to do anything. */
1793 return WERR_ACCESS_DENIED;
1794 case 1:
1795 /* Not enough info in a level 1 to do anything. */
1796 return WERR_ACCESS_DENIED;
1797 case 2:
1798 share_name = unistr2_to_ascii_talloc(ctx,
1799 &q_u->info.share.info2.info_2_str.uni_netname);
1800 comment = unistr2_to_ascii_talloc(ctx,
1801 &q_u->info.share.info2.info_2_str.uni_remark);
1802 pathname = unistr2_to_ascii_talloc(ctx,
1803 &q_u->info.share.info2.info_2_str.uni_path);
1804 max_connections = (q_u->info.share.info2.info_2.max_uses == 0xffffffff) ? 0 : q_u->info.share.info2.info_2.max_uses;
1805 type = q_u->info.share.info2.info_2.type;
1806 break;
1807 case 501:
1808 /* No path. Not enough info in a level 501 to do anything. */
1809 return WERR_ACCESS_DENIED;
1810 case 502:
1811 share_name = unistr2_to_ascii_talloc(ctx,
1812 &q_u->info.share.info502.info_502_str.uni_netname);
1813 comment = unistr2_to_ascii_talloc(ctx,
1814 &q_u->info.share.info502.info_502_str.uni_remark);
1815 pathname = unistr2_to_ascii_talloc(ctx,
1816 &q_u->info.share.info502.info_502_str.uni_path);
1817 type = q_u->info.share.info502.info_502.type;
1818 psd = q_u->info.share.info502.info_502_str.sd;
1819 map_generic_share_sd_bits(psd);
1820 break;
1821
1822 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
1823
1824 case 1004:
1825 case 1005:
1826 case 1006:
1827 case 1007:
1828 return WERR_ACCESS_DENIED;
1829 case 1501:
1830 /* DFS only level. */
1831 return WERR_ACCESS_DENIED;
1832 default:
1833 DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n", q_u->info_level));
1834 return WERR_UNKNOWN_LEVEL;
1835 }
1836
1837 /* check for invalid share names */
1838
1839 if (!share_name || !validate_net_name(share_name,
1840 INVALID_SHARENAME_CHARS,
1841 strlen(share_name))) {
1842 DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n",
1843 share_name ? share_name : ""));
1844 return WERR_INVALID_NAME;
1845 }
1846
1847 if (strequal(share_name,"IPC$") || strequal(share_name,"global")
1848 || (lp_enable_asu_support() &&
1849 strequal(share_name,"ADMIN$"))) {
1850 return WERR_ACCESS_DENIED;
1851 }
1852
1853 snum = find_service(share_name);
1854
1855 /* Share already exists. */
1856 if (snum >= 0) {
1857 return WERR_ALREADY_EXISTS;
1858 }
1859
1860 /* We can only add disk shares. */
1861 if (type != STYPE_DISKTREE) {
1862 return WERR_ACCESS_DENIED;
1863 }
1864
1865 /* Check if the pathname is valid. */
1866 if (!(path = valid_share_pathname(p->mem_ctx, pathname))) {
1867 return WERR_OBJECT_PATH_INVALID;
1868 }
1869
1870 /* Ensure share name, pathname and comment don't contain '"' characters. */
1871 string_replace(share_name, '"', ' ');
1872 string_replace(path, '"', ' ');
1873 if (comment) {
1874 string_replace(comment, '"', ' ');
1875 }
1876
1877 command = talloc_asprintf(ctx,
1878 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1879 lp_add_share_cmd(),
1880 get_dyn_CONFIGFILE(),
1881 share_name,
1882 path,
1883 comment ? comment : "",
1884 max_connections);
1885 if (!command) {
1886 return WERR_NOMEM;
1887 }
1888
1889 DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
1890
1891 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1892
1893 if ( is_disk_op )
1894 become_root();
1895
1896 if ( (ret = smbrun(command, NULL)) == 0 ) {
1897 /* Tell everyone we updated smb.conf. */
1898 message_send_all(smbd_messaging_context(),
1899 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
1900 }
1901
1902 if ( is_disk_op )
1903 unbecome_root();
1904
1905 /********* END SeDiskOperatorPrivilege BLOCK *********/
1906
1907 DEBUG(3,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
1908
1909 TALLOC_FREE(command);
1910
1911 if ( ret != 0 )
1912 return WERR_ACCESS_DENIED;
1913
1914 if (psd) {
1915 if (!set_share_security(share_name, psd)) {
1916 DEBUG(0,("_srv_net_share_add: Failed to add security info to share %s.\n", share_name ));
1917 }
1918 }
1919
1920 /*
1921 * We don't call reload_services() here, the message will
1922 * cause this to be done before the next packet is read
1923 * from the client. JRA.
1924 */
1925
1926 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1927
1928 return WERR_OK;
1929 }
1930
1931 /*******************************************************************
1932 Net share delete. Call "delete share command" with the share name as
1933 a parameter.
1934 ********************************************************************/
1935
1936 WERROR _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
1937 {
1938 struct current_user user;
1939 char *command = NULL;
1940 char *share_name = NULL;
1941 int ret;
1942 int snum;
1943 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1944 bool is_disk_op;
1945 struct share_params *params;
1946 TALLOC_CTX *ctx = p->mem_ctx;
1947
1948 DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
1949
1950 share_name = unistr2_to_ascii_talloc(ctx, &q_u->uni_share_name);
1951
1952 if (!share_name) {
1953 return WERR_NET_NAME_NOT_FOUND;
1954 }
1955 if ( strequal(share_name,"IPC$")
1956 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1957 || strequal(share_name,"global") )
1958 {
1959 return WERR_ACCESS_DENIED;
1960 }
1961
1962 if (!(params = get_share_params(p->mem_ctx, share_name))) {
1963 return WERR_NO_SUCH_SHARE;
1964 }
1965
1966 snum = find_service(share_name);
1967
1968 /* No change to printer shares. */
1969 if (lp_print_ok(snum))
1970 return WERR_ACCESS_DENIED;
1971
1972 get_current_user(&user,p);
1973
1974 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1975
1976 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1977 return WERR_ACCESS_DENIED;
1978
1979 if (!lp_delete_share_cmd() || !*lp_delete_share_cmd()) {
1980 DEBUG(10,("_srv_net_share_del: No delete share command\n"));
1981 return WERR_ACCESS_DENIED;
1982 }
1983
1984 command = talloc_asprintf(ctx,
1985 "%s \"%s\" \"%s\"",
1986 lp_delete_share_cmd(),
1987 get_dyn_CONFIGFILE(),
1988 lp_servicename(snum));
1989 if (!command) {
1990 return WERR_NOMEM;
1991 }
1992
1993 DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
1994
1995 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1996
1997 if ( is_disk_op )
1998 become_root();
1999
2000 if ( (ret = smbrun(command, NULL)) == 0 ) {
2001 /* Tell everyone we updated smb.conf. */
2002 message_send_all(smbd_messaging_context(),
2003 MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
2004 }
2005
2006 if ( is_disk_op )
2007 unbecome_root();
2008
2009 /********* END SeDiskOperatorPrivilege BLOCK *********/
2010
2011 DEBUG(3,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
2012
2013 if ( ret != 0 )
2014 return WERR_ACCESS_DENIED;
2015
2016 /* Delete the SD in the database. */
2017 delete_share_security(lp_servicename(params->service));
2018
2019 lp_killservice(params->service);
2020
2021 return WERR_OK;
2022 }
2023
2024 WERROR _srv_net_share_del_sticky(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
2025 {
2026 DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
2027
2028 return _srv_net_share_del(p, q_u, r_u);
2029 }
2030
2031 /*******************************************************************
2032 time of day
2033 ********************************************************************/
2034
2035 WERROR _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
2036 {
2037 TIME_OF_DAY_INFO *tod;
2038 struct tm *t;
2039 time_t unixdate = time(NULL);
2040
2041 /* We do this call first as if we do it *after* the gmtime call
2042 it overwrites the pointed-to values. JRA */
2043
2044 uint32 zone = get_time_zone(unixdate)/60;
2045
2046 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2047
2048 if ( !(tod = TALLOC_ZERO_P(p->mem_ctx, TIME_OF_DAY_INFO)) )
2049 return WERR_NOMEM;
2050
2051 r_u->tod = tod;
2052 r_u->ptr_srv_tod = 0x1;
2053 r_u->status = WERR_OK;
2054
2055 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2056
2057 t = gmtime(&unixdate);
2058
2059 /* set up the */
2060 init_time_of_day_info(tod,
2061 unixdate,
2062 0,
2063 t->tm_hour,
2064 t->tm_min,
2065 t->tm_sec,
2066 0,
2067 zone,
2068 10000,
2069 t->tm_mday,
2070 t->tm_mon + 1,
2071 1900+t->tm_year,
2072 t->tm_wday);
2073
2074 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2075
2076 return r_u->status;
2077 }
2078
2079 /***********************************************************************************
2080 Win9x NT tools get security descriptor.
2081 ***********************************************************************************/
2082
2083 WERROR _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
2084 SRV_R_NET_FILE_QUERY_SECDESC *r_u)
2085 {
2086 SEC_DESC *psd = NULL;
2087 size_t sd_size;
2088 DATA_BLOB null_pw;
2089 char *filename_in = NULL;
2090 char *filename = NULL;
2091 char *qualname = NULL;
2092 SMB_STRUCT_STAT st;
2093 NTSTATUS nt_status;
2094 struct current_user user;
2095 connection_struct *conn = NULL;
2096 bool became_user = False;
2097 TALLOC_CTX *ctx = p->mem_ctx;
2098
2099 ZERO_STRUCT(st);
2100
2101 r_u->status = WERR_OK;
2102
2103 qualname = unistr2_to_ascii_talloc(ctx, &q_u->uni_qual_name);
2104 if (!qualname) {
2105 r_u->status = WERR_ACCESS_DENIED;
2106 goto error_exit;
2107 }
2108
2109 /* Null password is ok - we are already an authenticated user... */
2110 null_pw = data_blob_null;
2111
2112 get_current_user(&user, p);
2113
2114 become_root();
2115 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
2116 unbecome_root();
2117
2118 if (conn == NULL) {
2119 DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", qualname));
2120 r_u->status = ntstatus_to_werror(nt_status);
2121 goto error_exit;
2122 }
2123
2124 if (!become_user(conn, conn->vuid)) {
2125 DEBUG(0,("_srv_net_file_query_secdesc: Can't become connected user!\n"));
2126 r_u->status = WERR_ACCESS_DENIED;
2127 goto error_exit;
2128 }
2129 became_user = True;
2130
2131 filename_in = unistr2_to_ascii_talloc(ctx, &q_u->uni_file_name);
2132 if (!filename_in) {
2133 r_u->status = WERR_ACCESS_DENIED;
2134 goto error_exit;
2135 }
2136
2137 nt_status = unix_convert(ctx, conn, filename_in, False, &filename, NULL, &st);
2138 if (!NT_STATUS_IS_OK(nt_status)) {
2139 DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", filename));
2140 r_u->status = WERR_ACCESS_DENIED;
2141 goto error_exit;
2142 }
2143
2144 nt_status = check_name(conn, filename);
2145 if (!NT_STATUS_IS_OK(nt_status)) {
2146 DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", filename));
2147 r_u->status = WERR_ACCESS_DENIED;
2148 goto error_exit;
2149 }
2150
2151 nt_status = SMB_VFS_GET_NT_ACL(conn, filename,
2152 (OWNER_SECURITY_INFORMATION
2153 |GROUP_SECURITY_INFORMATION
2154 |DACL_SECURITY_INFORMATION), &psd);
2155
2156 if (!NT_STATUS_IS_OK(nt_status)) {
2157 DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
2158 r_u->status = ntstatus_to_werror(nt_status);
2159 goto error_exit;
2160 }
2161
2162 sd_size = ndr_size_security_descriptor(psd, 0);
2163
2164 r_u->ptr_response = 1;
2165 r_u->size_response = sd_size;
2166 r_u->ptr_secdesc = 1;
2167 r_u->size_secdesc = sd_size;
2168 r_u->sec_desc = psd;
2169
2170 psd->dacl->revision = NT4_ACL_REVISION;
2171
2172 unbecome_user();
2173 close_cnum(conn, user.vuid);
2174 return r_u->status;
2175
2176 error_exit:
2177
2178 if (became_user)
2179 unbecome_user();
2180
2181 if (conn)
2182 close_cnum(conn, user.vuid);
2183
2184 return r_u->status;
2185 }
2186
2187 /***********************************************************************************
2188 Win9x NT tools set security descriptor.
2189 ***********************************************************************************/
2190
2191 WERROR _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
2192 SRV_R_NET_FILE_SET_SECDESC *r_u)
2193 {
2194 char *filename_in = NULL;
2195 char *filename = NULL;
2196 char *qualname = NULL;
2197 DATA_BLOB null_pw;
2198 files_struct *fsp = NULL;
2199 SMB_STRUCT_STAT st;
2200 NTSTATUS nt_status;
2201 struct current_user user;
2202 connection_struct *conn = NULL;
2203 bool became_user = False;
2204 TALLOC_CTX *ctx = p->mem_ctx;
2205
2206 ZERO_STRUCT(st);
2207
2208 r_u->status = WERR_OK;
2209
2210 qualname = unistr2_to_ascii_talloc(ctx, &q_u->uni_qual_name);
2211 if (!qualname) {
2212 r_u->status = WERR_ACCESS_DENIED;
2213 goto error_exit;
2214 }
2215
2216 /* Null password is ok - we are already an authenticated user... */
2217 null_pw = data_blob_null;
2218
2219 get_current_user(&user, p);
2220
2221 become_root();
2222 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
2223 unbecome_root();
2224
2225 if (conn == NULL) {
2226 DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", qualname));
2227 r_u->status = ntstatus_to_werror(nt_status);
2228 goto error_exit;
2229 }
2230
2231 if (!become_user(conn, conn->vuid)) {
2232 DEBUG(0,("_srv_net_file_set_secdesc: Can't become connected user!\n"));
2233 r_u->status = WERR_ACCESS_DENIED;
2234 goto error_exit;
2235 }
2236 became_user = True;
2237
2238 filename_in= unistr2_to_ascii_talloc(ctx, &q_u->uni_file_name);
2239 if (!filename_in) {
2240 r_u->status = WERR_ACCESS_DENIED;
2241 goto error_exit;
2242 }
2243
2244 nt_status = unix_convert(ctx, conn, filename, False, &filename, NULL, &st);
2245 if (!NT_STATUS_IS_OK(nt_status)) {
2246 DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", filename));
2247 r_u->status = WERR_ACCESS_DENIED;
2248 goto error_exit;
2249 }
2250
2251 nt_status = check_name(conn, filename);
2252 if (!NT_STATUS_IS_OK(nt_status)) {
2253 DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", filename));
2254 r_u->status = WERR_ACCESS_DENIED;
2255 goto error_exit;
2256 }
2257
2258 nt_status = open_file_stat(conn, NULL, filename, &st, &fsp);
2259
2260 if ( !NT_STATUS_IS_OK(nt_status) ) {
2261 /* Perhaps it is a directory */
2262 if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
2263 nt_status = open_directory(conn, NULL, filename, &st,
2264 FILE_READ_ATTRIBUTES,
2265 FILE_SHARE_READ|FILE_SHARE_WRITE,
2266 FILE_OPEN,
2267 0,
2268 FILE_ATTRIBUTE_DIRECTORY,
2269 NULL, &fsp);
2270
2271 if ( !NT_STATUS_IS_OK(nt_status) ) {
2272 DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", filename));
2273 r_u->status = ntstatus_to_werror(nt_status);
2274 goto error_exit;
2275 }
2276 }
2277
2278 nt_status = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
2279
2280 if (!NT_STATUS_IS_OK(nt_status) ) {
2281 DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
2282 r_u->status = WERR_ACCESS_DENIED;
2283 goto error_exit;
2284 }
2285
2286 close_file(fsp, NORMAL_CLOSE);
2287 unbecome_user();
2288 close_cnum(conn, user.vuid);
2289 return r_u->status;
2290
2291 error_exit:
2292
2293 if(fsp) {
2294 close_file(fsp, NORMAL_CLOSE);
2295 }
2296
2297 if (became_user) {
2298 unbecome_user();
2299 }
2300
2301 if (conn) {
2302 close_cnum(conn, user.vuid);
2303 }
2304
2305 return r_u->status;
2306 }
2307
2308 /***********************************************************************************
2309 It may be that we want to limit users to creating shares on certain areas of the UNIX file area.
2310 We could define areas by mapping Windows style disks to points on the UNIX directory hierarchy.
2311 These disks would the disks listed by this function.
2312 Users could then create shares relative to these disks. Watch out for moving these disks around.
2313 "Nigel Williams" <nigel@veritas.com>.
2314 ***********************************************************************************/
2315
2316 static const char *server_disks[] = {"C:"};
2317
2318 static uint32 get_server_disk_count(void)
2319 {
2320 return sizeof(server_disks)/sizeof(server_disks[0]);
2321 }
2322
2323 static uint32 init_server_disk_enum(uint32 *resume)
2324 {
2325 uint32 server_disk_count = get_server_disk_count();
2326
2327 /*resume can be an offset into the list for now*/
2328
2329 if(*resume & 0x80000000)
2330 *resume = 0;
2331
2332 if(*resume > server_disk_count)
2333 *resume = server_disk_count;
2334
2335 return server_disk_count - *resume;
2336 }
2337
2338 static const char *next_server_disk_enum(uint32 *resume)
2339 {
2340 const char *disk;
2341
2342 if(init_server_disk_enum(resume) == 0)
2343 return NULL;
2344
2345 disk = server_disks[*resume];
2346
2347 (*resume)++;
2348
2349 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2350
2351 return disk;
2352 }
2353
2354 WERROR _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
2355 {
2356 uint32 i;
2357 const char *disk_name;
2358 TALLOC_CTX *ctx = p->mem_ctx;
2359 uint32 resume=get_enum_hnd(&q_u->enum_hnd);
2360
2361 r_u->status=WERR_OK;
2362
2363 r_u->total_entries = init_server_disk_enum(&resume);
2364
2365 r_u->disk_enum_ctr.unknown = 0;
2366
2367 if(!(r_u->disk_enum_ctr.disk_info = TALLOC_ARRAY(ctx, DISK_INFO, MAX_SERVER_DISK_ENTRIES))) {
2368 return WERR_NOMEM;
2369 }
2370
2371 r_u->disk_enum_ctr.disk_info_ptr = r_u->disk_enum_ctr.disk_info ? 1 : 0;
2372
2373 /*allow one DISK_INFO for null terminator*/
2374
2375 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2376
2377 r_u->disk_enum_ctr.entries_read++;
2378
2379 /*copy disk name into a unicode string*/
2380
2381 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, disk_name);
2382 }
2383
2384 /* add a terminating null string. Is this there if there is more data to come? */
2385
2386 r_u->disk_enum_ctr.entries_read++;
2387
2388 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, "");
2389
2390 init_enum_hnd(&r_u->enum_hnd, resume);
2391
2392 return r_u->status;
2393 }
2394
2395 /********************************************************************
2396 ********************************************************************/
2397
2398 WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
2399 {
2400 fstring sharename;
2401
2402 switch ( q_u->type ) {
2403 case 0x9:
2404 rpcstr_pull(sharename, q_u->sharename.buffer, sizeof(sharename), q_u->sharename.uni_str_len*2, 0);
2405 if ( !validate_net_name( sharename, INVALID_SHARENAME_CHARS, sizeof(sharename) ) ) {
2406 DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", sharename));
2407 return WERR_INVALID_NAME;
2408 }
2409 break;
2410
2411 default:
2412 return WERR_UNKNOWN_LEVEL;
2413 }
2414
2415 return WERR_OK;
2416 }
2417
2418
2419 /********************************************************************
2420 ********************************************************************/
2421
2422 WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r)
2423 {
2424 return WERR_ACCESS_DENIED;
2425 }
2426
2427
2428 /********************************************************************
2429 ********************************************************************/
2430
2431 WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r)
2432 {
2433 p->rng_fault_state = True;
2434 return WERR_NOT_SUPPORTED;
2435 }
2436
2437 WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r)
2438 {
2439 p->rng_fault_state = True;
2440 return WERR_NOT_SUPPORTED;
2441 }
2442
2443 WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r)
2444 {
2445 p->rng_fault_state = True;
2446 return WERR_NOT_SUPPORTED;
2447 }
2448
2449 WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r)
2450 {
2451 p->rng_fault_state = True;
2452 return WERR_NOT_SUPPORTED;
2453 }
2454
2455 WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r)
2456 {
2457 p->rng_fault_state = True;
2458 return WERR_NOT_SUPPORTED;
2459 }
2460
2461 WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r)
2462 {
2463 p->rng_fault_state = True;
2464 return WERR_NOT_SUPPORTED;
2465 }
2466
2467 WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r)
2468 {
2469 p->rng_fault_state = True;
2470 return WERR_NOT_SUPPORTED;
2471 }
2472
2473 WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r)
2474 {
2475 p->rng_fault_state = True;
2476 return WERR_NOT_SUPPORTED;
2477 }
2478
2479 WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r)
2480 {
2481 p->rng_fault_state = True;
2482 return WERR_NOT_SUPPORTED;
2483 }
2484
2485 WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r)
2486 {
2487 p->rng_fault_state = True;
2488 return WERR_NOT_SUPPORTED;
2489 }
2490
2491 WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r)
2492 {
2493 p->rng_fault_state = True;
2494 return WERR_NOT_SUPPORTED;
2495 }
2496
2497 WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r)
2498 {
2499 p->rng_fault_state = True;
2500 return WERR_NOT_SUPPORTED;
2501 }
2502
2503 WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r)
2504 {
2505 p->rng_fault_state = True;
2506 return WERR_NOT_SUPPORTED;
2507 }
2508
2509 WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r)
2510 {
2511 p->rng_fault_state = True;
2512 return WERR_NOT_SUPPORTED;
2513 }
2514
2515 WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r)
2516 {
2517 p->rng_fault_state = True;
2518 return WERR_NOT_SUPPORTED;
2519 }
2520
2521 WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r)
2522 {
2523 p->rng_fault_state = True;
2524 return WERR_NOT_SUPPORTED;
2525 }
2526
2527 WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r)
2528 {
2529 p->rng_fault_state = True;
2530 return WERR_NOT_SUPPORTED;
2531 }
2532
2533 WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r)
2534 {
2535 p->rng_fault_state = True;
2536 return WERR_NOT_SUPPORTED;
2537 }
2538
2539 WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r)
2540 {
2541 p->rng_fault_state = True;
2542 return WERR_NOT_SUPPORTED;
2543 }
2544
2545 WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r)
2546 {
2547 p->rng_fault_state = True;
2548 return WERR_NOT_SUPPORTED;
2549 }
2550
2551 WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r)
2552 {
2553 p->rng_fault_state = True;
2554 return WERR_NOT_SUPPORTED;
2555 }
2556
2557 WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r)
2558 {
2559 p->rng_fault_state = True;
2560 return WERR_NOT_SUPPORTED;
2561 }
2562
2563 WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r)
2564 {
2565 p->rng_fault_state = True;
2566 return WERR_NOT_SUPPORTED;
2567 }
2568
2569 WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r)
2570 {
2571 p->rng_fault_state = True;
2572 return WERR_NOT_SUPPORTED;
2573 }
2574
2575 WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r)
2576 {
2577 p->rng_fault_state = True;
2578 return WERR_NOT_SUPPORTED;
2579 }
2580
2581 WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r)
2582 {
2583 p->rng_fault_state = True;
2584 return WERR_NOT_SUPPORTED;
2585 }
2586
2587 WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r)
2588 {
2589 p->rng_fault_state = True;
2590 return WERR_NOT_SUPPORTED;
2591 }
2592
2593 WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r)
2594 {
2595 p->rng_fault_state = True;
2596 return WERR_NOT_SUPPORTED;
2597 }
2598
2599 WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r)
2600 {
2601 p->rng_fault_state = True;
2602 return WERR_NOT_SUPPORTED;
2603 }
2604
2605 WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r)
2606 {
2607 p->rng_fault_state = True;
2608 return WERR_NOT_SUPPORTED;
2609 }
2610
2611 WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r)
2612 {
2613 p->rng_fault_state = True;
2614 return WERR_NOT_SUPPORTED;
2615 }
2616
2617 WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r)
2618 {
2619 p->rng_fault_state = True;
2620 return WERR_NOT_SUPPORTED;
2621 }
2622
2623 WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r)
2624 {
2625 p->rng_fault_state = True;
2626 return WERR_NOT_SUPPORTED;
2627 }
2628
2629 WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r)
2630 {
2631 p->rng_fault_state = True;
2632 return WERR_NOT_SUPPORTED;
2633 }
2634
2635 WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r)
2636 {
2637 p->rng_fault_state = True;
2638 return WERR_NOT_SUPPORTED;
2639 }
2640
2641 WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r)
2642 {
2643 p->rng_fault_state = True;
2644 return WERR_NOT_SUPPORTED;
2645 }
2646
2647 WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r)
2648 {
2649 p->rng_fault_state = True;
2650 return WERR_NOT_SUPPORTED;
2651 }
2652
2653 WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r)
2654 {
2655 p->rng_fault_state = True;
2656 return WERR_NOT_SUPPORTED;
2657 }
2658
2659 WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r)
2660 {
2661 p->rng_fault_state = True;
2662 return WERR_NOT_SUPPORTED;
2663 }
2664
2665 WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r)
2666 {
2667 p->rng_fault_state = True;
2668 return WERR_NOT_SUPPORTED;
2669 }
2670
2671 WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r)
2672 {
2673 p->rng_fault_state = True;
2674 return WERR_NOT_SUPPORTED;
2675 }
2676
2677 WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r)
2678 {
2679 p->rng_fault_state = True;
2680 return WERR_NOT_SUPPORTED;
2681 }
2682
2683 WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r)
2684 {
2685 p->rng_fault_state = True;
2686 return WERR_NOT_SUPPORTED;
2687 }
2688
2689 WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2690 {
2691 p->rng_fault_state = True;
2692 return WERR_NOT_SUPPORTED;
2693 }
2694
2695 WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2696 {
2697 p->rng_fault_state = True;
2698 return WERR_NOT_SUPPORTED;
2699 }
2700
2701 WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2702 {
2703 p->rng_fault_state = True;
2704 return WERR_NOT_SUPPORTED;
2705 }
2706
2707 WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r)
2708 {
2709 p->rng_fault_state = True;
2710 return WERR_NOT_SUPPORTED;
2711 }
2712
2713 WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2714 {
2715 p->rng_fault_state = True;
2716 return WERR_NOT_SUPPORTED;
2717 }
2718
2719 WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2720 {
2721 p->rng_fault_state = True;
2722 return WERR_NOT_SUPPORTED;
2723 }
2724
2725 WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r)
2726 {
2727 p->rng_fault_state = True;
2728 return WERR_NOT_SUPPORTED;
2729 }
2730
2731 WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2732 {
2733 p->rng_fault_state = True;
2734 return WERR_NOT_SUPPORTED;
2735 }
2736
2737 WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2738 {
2739 p->rng_fault_state = True;
2740 return WERR_NOT_SUPPORTED;
2741 }
2742
2743 WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2744 {
2745 p->rng_fault_state = True;
2746 return WERR_NOT_SUPPORTED;
2747 }
2748