Rename the 'hidden' variable to 'administrative share'.
[Samba/ekacnet.git] / source / 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.
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.
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/>.
23 /* This is the implementation of the srvsvc pipe. */
25 #include "includes.h"
27 extern const struct generic_mapping file_generic_mapping;
29 #undef DBGC_CLASS
30 #define DBGC_CLASS DBGC_RPC_SRV
32 /* Use for enumerating connections, pipes, & files */
34 struct file_enum_count {
35 TALLOC_CTX *ctx;
36 const char *username;
37 int count;
38 FILE_INFO_3 *info;
41 struct sess_file_count {
42 struct server_id pid;
43 uid_t uid;
44 int count;
47 /****************************************************************************
48 Count the entries belonging to a service in the connection db.
49 ****************************************************************************/
51 static int pipe_enum_fn( struct db_record *rec, void *p)
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;
60 if (rec->value.dsize != sizeof(struct pipe_open_rec))
61 return 0;
63 memcpy(&prec, rec->value.dptr, sizeof(struct pipe_open_rec));
65 if ( !process_exists(prec.pid) ) {
66 return 0;
69 username = uidtoname(prec.uid);
71 if ((fenum->username != NULL)
72 && !strequal(username, fenum->username)) {
73 return 0;
76 fullpath = talloc_asprintf(fenum->ctx, "\\PIPE\\%s", prec.name );
77 if (!fullpath) {
78 return 1;
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;
86 fenum->info = f;
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);
94 TALLOC_FREE(fullpath);
95 fenum->count++;
97 return 0;
100 /*******************************************************************
101 ********************************************************************/
103 static WERROR net_enum_pipes( TALLOC_CTX *ctx, const char *username,
104 FILE_INFO_3 **info,
105 uint32 *count, uint32 resume )
107 struct file_enum_count fenum;
109 fenum.ctx = ctx;
110 fenum.username = username;
111 fenum.count = *count;
112 fenum.info = *info;
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;
120 *info = fenum.info;
121 *count = fenum.count;
123 return WERR_OK;
126 /*******************************************************************
127 ********************************************************************/
129 static void enum_file_fn( const struct share_mode_entry *e,
130 const char *sharepath, const char *fname,
131 void *private_data )
133 struct file_enum_count *fenum =
134 (struct file_enum_count *)private_data;
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;
145 /* If the pid was not found delete the entry from connections.tdb */
147 if ( !process_exists(e->pid) ) {
148 return;
151 username = uidtoname(e->uid);
153 if ((fenum->username != NULL)
154 && !strequal(username, fenum->username)) {
155 return;
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;
163 fenum->info = f;
165 /* need to count the number of locks on a file */
167 ZERO_STRUCT( fsp );
168 fsp.file_id = e->id;
170 if ( (brl = brl_get_locks(talloc_tos(), &fsp)) != NULL ) {
171 num_locks = brl->num_locks;
172 TALLOC_FREE(brl);
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 );
181 if (!fullpath) {
182 return;
184 string_replace( fullpath, '/', '\\' );
186 /* mask out create (what ever that is) */
187 permissions = e->share_access & (FILE_READ_DATA|FILE_WRITE_DATA);
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 );
197 TALLOC_FREE(fullpath);
198 fenum->count++;
201 /*******************************************************************
202 ********************************************************************/
204 static WERROR net_enum_files( TALLOC_CTX *ctx, const char *username,
205 FILE_INFO_3 **info,
206 uint32 *count, uint32 resume )
208 struct file_enum_count f_enum_cnt;
210 f_enum_cnt.ctx = ctx;
211 f_enum_cnt.username = username;
212 f_enum_cnt.count = *count;
213 f_enum_cnt.info = *info;
215 share_mode_forall( enum_file_fn, (void *)&f_enum_cnt );
217 *info = f_enum_cnt.info;
218 *count = f_enum_cnt.count;
220 return WERR_OK;
223 /*******************************************************************
224 Utility function to get the 'type' of a share from an snum.
225 ********************************************************************/
226 static uint32 get_share_type(int snum)
228 /* work out the share type */
229 uint32 type = STYPE_DISKTREE;
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;
238 return type;
241 /*******************************************************************
242 Fill in a share info level 0 structure.
243 ********************************************************************/
245 static void init_srv_share_info_0(pipes_struct *p, SRV_SHARE_INFO_0 *sh0, int snum)
247 const char *net_name = lp_servicename(snum);
249 init_srv_share_info0(&sh0->info_0, net_name);
250 init_srv_share_info0_str(&sh0->info_0_str, net_name);
253 /*******************************************************************
254 Fill in a share info level 1 structure.
255 ********************************************************************/
257 static void init_srv_share_info_1(pipes_struct *p, SRV_SHARE_INFO_1 *sh1, int snum)
259 char *net_name = lp_servicename(snum);
260 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
262 if (remark) {
263 remark = standard_sub_conn(p->mem_ctx,
264 p->conn,
265 remark);
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: "");
277 /*******************************************************************
278 Fill in a share info level 2 structure.
279 ********************************************************************/
281 static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int snum)
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);
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);
296 path = talloc_asprintf(p->mem_ctx,
297 "C:%s", lp_pathname(snum));
299 if (path) {
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.
306 string_replace(path, '/', '\\');
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 : "",
315 max_uses,
316 count,
317 path ? path : "",
318 "");
320 init_srv_share_info2_str(&sh2->info_2_str,
321 net_name,
322 remark ? remark : "",
323 path ? path : "",
324 "");
327 /*******************************************************************
328 Map any generic bits to file specific bits.
329 ********************************************************************/
331 static void map_generic_share_sd_bits(SEC_DESC *psd)
333 int i;
334 SEC_ACL *ps_dacl = NULL;
336 if (!psd)
337 return;
339 ps_dacl = psd->dacl;
340 if (!ps_dacl)
341 return;
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;
347 se_map_generic(&psa->access_mask, &file_generic_mapping);
348 psa->access_mask |= orig_mask;
352 /*******************************************************************
353 Fill in a share info level 501 structure.
354 ********************************************************************/
356 static void init_srv_share_info_501(pipes_struct *p, SRV_SHARE_INFO_501 *sh501, int snum)
358 const char *net_name = lp_servicename(snum);
359 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
361 if (remark) {
362 remark = standard_sub_conn(p->mem_ctx, p->conn, remark);
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 : "");
371 /*******************************************************************
372 Fill in a share info level 502 structure.
373 ********************************************************************/
375 static void init_srv_share_info_502(pipes_struct *p, SRV_SHARE_INFO_502 *sh502, int snum)
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));;
384 ZERO_STRUCTP(sh502);
386 if (remark) {
387 remark = standard_sub_conn(ctx, p->conn, remark);
389 path = talloc_asprintf(ctx, "C:%s", lp_pathname(snum));
390 if (path) {
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.
395 string_replace(path, '/', '\\');
398 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
400 init_srv_share_info502(&sh502->info_502,
401 net_name,
402 get_share_type(snum),
403 remark ? remark : "",
405 0xffffffff,
407 path ? path : "",
410 sd_size);
411 init_srv_share_info502_str(&sh502->info_502_str,
412 net_name,
413 remark ? remark : "",
414 path ? path : "",
417 sd_size);
420 /***************************************************************************
421 Fill in a share info level 1004 structure.
422 ***************************************************************************/
424 static void init_srv_share_info_1004(pipes_struct *p, SRV_SHARE_INFO_1004* sh1004, int snum)
426 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
428 if (remark) {
429 remark = standard_sub_conn(p->mem_ctx, p->conn, remark);
432 ZERO_STRUCTP(sh1004);
434 init_srv_share_info1004(&sh1004->info_1004, remark ? remark : "");
435 init_srv_share_info1004_str(&sh1004->info_1004_str,
436 remark ? remark : "");
439 /***************************************************************************
440 Fill in a share info level 1005 structure.
441 ***************************************************************************/
443 static void init_srv_share_info_1005(pipes_struct *p, SRV_SHARE_INFO_1005* sh1005, int snum)
445 sh1005->share_info_flags = 0;
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;
453 /***************************************************************************
454 Fill in a share info level 1006 structure.
455 ***************************************************************************/
457 static void init_srv_share_info_1006(pipes_struct *p, SRV_SHARE_INFO_1006* sh1006, int snum)
459 sh1006->max_uses = -1;
462 /***************************************************************************
463 Fill in a share info level 1007 structure.
464 ***************************************************************************/
466 static void init_srv_share_info_1007(pipes_struct *p, SRV_SHARE_INFO_1007* sh1007, int snum)
468 uint32 flags = 0;
470 ZERO_STRUCTP(sh1007);
472 init_srv_share_info1007(&sh1007->info_1007, flags, "");
473 init_srv_share_info1007_str(&sh1007->info_1007_str, "");
476 /*******************************************************************
477 Fill in a share info level 1501 structure.
478 ********************************************************************/
480 static void init_srv_share_info_1501(pipes_struct *p, SRV_SHARE_INFO_1501 *sh1501, int snum)
482 SEC_DESC *sd;
483 size_t sd_size;
484 TALLOC_CTX *ctx = p->mem_ctx;
486 ZERO_STRUCTP(sh1501);
488 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
490 sh1501->sdb = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
493 /*******************************************************************
494 True if it ends in '$'.
495 ********************************************************************/
497 static bool is_hidden_share(int snum)
499 const char *net_name = lp_servicename(snum);
501 return (net_name[strlen(net_name) - 1] == '$') ? True : False;
504 /*******************************************************************
505 Fill in a share info structure.
506 ********************************************************************/
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)
511 int num_entries = 0;
512 int num_services = 0;
513 int snum;
514 TALLOC_CTX *ctx = p->mem_ctx;
516 DEBUG(5,("init_srv_share_info_ctr\n"));
518 ZERO_STRUCTPN(ctr);
520 ctr->info_level = ctr->switch_value = info_level;
521 *resume_hnd = 0;
523 /* Ensure all the usershares are loaded. */
524 become_root();
525 num_services = load_usershare_shares();
526 load_registry_shares();
527 unbecome_root();
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++;
535 *total_entries = num_entries;
536 ctr->num_entries2 = ctr->num_entries = num_entries;
537 ctr->ptr_share_info = ctr->ptr_entries = 1;
539 if (!num_entries)
540 return True;
542 switch (info_level) {
543 case 0:
545 SRV_SHARE_INFO_0 *info0 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_0, num_entries);
546 int i = 0;
548 if (!info0) {
549 return False;
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);
558 ctr->share.info0 = info0;
559 break;
563 case 1:
565 SRV_SHARE_INFO_1 *info1 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1, num_entries);
566 int i = 0;
568 if (!info1) {
569 return False;
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);
578 ctr->share.info1 = info1;
579 break;
582 case 2:
584 SRV_SHARE_INFO_2 *info2 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_2, num_entries);
585 int i = 0;
587 if (!info2) {
588 return False;
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);
597 ctr->share.info2 = info2;
598 break;
601 case 501:
603 SRV_SHARE_INFO_501 *info501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_501, num_entries);
604 int i = 0;
606 if (!info501) {
607 return False;
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);
616 ctr->share.info501 = info501;
617 break;
620 case 502:
622 SRV_SHARE_INFO_502 *info502 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_502, num_entries);
623 int i = 0;
625 if (!info502) {
626 return False;
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);
635 ctr->share.info502 = info502;
636 break;
639 /* here for completeness but not currently used with enum (1004 - 1501)*/
641 case 1004:
643 SRV_SHARE_INFO_1004 *info1004 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1004, num_entries);
644 int i = 0;
646 if (!info1004) {
647 return False;
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);
656 ctr->share.info1004 = info1004;
657 break;
660 case 1005:
662 SRV_SHARE_INFO_1005 *info1005 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1005, num_entries);
663 int i = 0;
665 if (!info1005) {
666 return False;
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);
675 ctr->share.info1005 = info1005;
676 break;
679 case 1006:
681 SRV_SHARE_INFO_1006 *info1006 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1006, num_entries);
682 int i = 0;
684 if (!info1006) {
685 return False;
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);
694 ctr->share.info1006 = info1006;
695 break;
698 case 1007:
700 SRV_SHARE_INFO_1007 *info1007 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1007, num_entries);
701 int i = 0;
703 if (!info1007) {
704 return False;
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);
713 ctr->share.info1007 = info1007;
714 break;
717 case 1501:
719 SRV_SHARE_INFO_1501 *info1501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1501, num_entries);
720 int i = 0;
722 if (!info1501) {
723 return False;
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);
732 ctr->share.info1501 = info1501;
733 break;
735 default:
736 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n", info_level));
737 return False;
740 return True;
743 /*******************************************************************
744 Inits a SRV_R_NET_SHARE_ENUM structure.
745 ********************************************************************/
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)
750 DEBUG(5,("init_srv_r_net_share_enum: %d\n", __LINE__));
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;
759 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
762 /*******************************************************************
763 Inits a SRV_R_NET_SHARE_GET_INFO structure.
764 ********************************************************************/
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)
769 WERROR status = WERR_OK;
770 int snum;
772 DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
774 r_n->info.switch_value = info_level;
776 snum = find_service(share_name);
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;
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;
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;
819 } else {
820 status = WERR_INVALID_NAME;
823 r_n->info.ptr_share_ctr = W_ERROR_IS_OK(status) ? 1 : 0;
824 r_n->status = status;
827 /*******************************************************************
828 fill in a sess info level 0 structure.
829 ********************************************************************/
831 static void init_srv_sess_info_0(pipes_struct *p, SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *stot)
833 struct sessionid *session_list;
834 uint32 num_entries = 0;
835 (*stot) = list_sessions(p->mem_ctx, &session_list);
837 if (ss0 == NULL) {
838 if (snum) {
839 (*snum) = 0;
841 return;
844 DEBUG(5,("init_srv_sess_0_ss0\n"));
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++;
852 ss0->num_entries_read = num_entries;
853 ss0->ptr_sess_info = num_entries > 0 ? 1 : 0;
854 ss0->num_entries_read2 = num_entries;
856 if ((*snum) >= (*stot)) {
857 (*snum) = 0;
860 } else {
861 ss0->num_entries_read = 0;
862 ss0->ptr_sess_info = 0;
863 ss0->num_entries_read2 = 0;
867 /*******************************************************************
868 ********************************************************************/
870 static void sess_file_fn( const struct share_mode_entry *e,
871 const char *sharepath, const char *fname,
872 void *data )
874 struct sess_file_count *sess = (struct sess_file_count *)data;
876 if ( procid_equal(&e->pid, &sess->pid) && (sess->uid == e->uid) ) {
877 sess->count++;
880 return;
883 /*******************************************************************
884 ********************************************************************/
886 static int net_count_files( uid_t uid, struct server_id pid )
888 struct sess_file_count s_file_cnt;
890 s_file_cnt.count = 0;
891 s_file_cnt.uid = uid;
892 s_file_cnt.pid = pid;
894 share_mode_forall( sess_file_fn, &s_file_cnt );
896 return s_file_cnt.count;
899 /*******************************************************************
900 fill in a sess info level 1 structure.
901 ********************************************************************/
903 static void init_srv_sess_info_1(pipes_struct *p, SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *stot)
905 struct sessionid *session_list;
906 uint32 num_entries = 0;
907 time_t now = time(NULL);
909 if ( !snum ) {
910 ss1->num_entries_read = 0;
911 ss1->ptr_sess_info = 0;
912 ss1->num_entries_read2 = 0;
914 (*stot) = 0;
916 return;
919 if (ss1 == NULL) {
920 (*snum) = 0;
921 return;
924 (*stot) = list_sessions(p->mem_ctx, &session_list);
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;
933 if ( !pw ) {
934 DEBUG(10,("init_srv_sess_info_1: failed to find owner: %s\n",
935 session_list[*snum].username));
936 continue;
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() );
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,
949 guest);
950 num_entries++;
953 ss1->num_entries_read = num_entries;
954 ss1->ptr_sess_info = num_entries > 0 ? 1 : 0;
955 ss1->num_entries_read2 = num_entries;
957 if ((*snum) >= (*stot)) {
958 (*snum) = 0;
963 /*******************************************************************
964 makes a SRV_R_NET_SESS_ENUM structure.
965 ********************************************************************/
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)
970 WERROR status = WERR_OK;
971 DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
973 ctr->switch_value = switch_value;
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;
993 return status;
996 /*******************************************************************
997 makes a SRV_R_NET_SESS_ENUM structure.
998 ********************************************************************/
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)
1003 DEBUG(5,("init_srv_r_net_sess_enum: %d\n", __LINE__));
1005 r_n->sess_level = sess_level;
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);
1012 if (!W_ERROR_IS_OK(r_n->status))
1013 resume_hnd = 0;
1015 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1018 /*******************************************************************
1019 fill in a conn info level 0 structure.
1020 ********************************************************************/
1022 static void init_srv_conn_info_0(SRV_CONN_INFO_0 *ss0, uint32 *snum, uint32 *stot)
1024 uint32 num_entries = 0;
1025 (*stot) = 1;
1027 if (ss0 == NULL) {
1028 (*snum) = 0;
1029 return;
1032 DEBUG(5,("init_srv_conn_0_ss0\n"));
1034 if (snum) {
1035 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
1037 init_srv_conn_info0(&ss0->info_0[num_entries], (*stot));
1039 /* move on to creating next connection */
1040 /* move on to creating next conn */
1041 num_entries++;
1044 ss0->num_entries_read = num_entries;
1045 ss0->ptr_conn_info = num_entries > 0 ? 1 : 0;
1046 ss0->num_entries_read2 = num_entries;
1048 if ((*snum) >= (*stot)) {
1049 (*snum) = 0;
1052 } else {
1053 ss0->num_entries_read = 0;
1054 ss0->ptr_conn_info = 0;
1055 ss0->num_entries_read2 = 0;
1057 (*stot) = 0;
1061 /*******************************************************************
1062 fill in a conn info level 1 structure.
1063 ********************************************************************/
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)
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);
1074 /*******************************************************************
1075 fill in a conn info level 1 structure.
1076 ********************************************************************/
1078 static void init_srv_conn_info_1(SRV_CONN_INFO_1 *ss1, uint32 *snum, uint32 *stot)
1080 uint32 num_entries = 0;
1081 (*stot) = 1;
1083 if (ss1 == NULL) {
1084 (*snum) = 0;
1085 return;
1088 DEBUG(5,("init_srv_conn_1_ss1\n"));
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$");
1096 /* move on to creating next connection */
1097 /* move on to creating next conn */
1098 num_entries++;
1101 ss1->num_entries_read = num_entries;
1102 ss1->ptr_conn_info = num_entries > 0 ? 1 : 0;
1103 ss1->num_entries_read2 = num_entries;
1106 if ((*snum) >= (*stot)) {
1107 (*snum) = 0;
1110 } else {
1111 ss1->num_entries_read = 0;
1112 ss1->ptr_conn_info = 0;
1113 ss1->num_entries_read2 = 0;
1115 (*stot) = 0;
1119 /*******************************************************************
1120 makes a SRV_R_NET_CONN_ENUM structure.
1121 ********************************************************************/
1123 static WERROR init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
1124 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
1126 WERROR status = WERR_OK;
1127 DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
1129 ctr->switch_value = switch_value;
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;
1149 return status;
1152 /*******************************************************************
1153 makes a SRV_R_NET_CONN_ENUM structure.
1154 ********************************************************************/
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)
1159 DEBUG(5,("init_srv_r_net_conn_enum: %d\n", __LINE__));
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);
1167 if (!W_ERROR_IS_OK(r_n->status))
1168 resume_hnd = 0;
1170 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1173 /*******************************************************************
1174 makes a SRV_R_NET_FILE_ENUM structure.
1175 ********************************************************************/
1177 static WERROR net_file_enum_3( const char *username, SRV_R_NET_FILE_ENUM *r,
1178 uint32 resume_hnd )
1180 TALLOC_CTX *ctx = talloc_tos();
1181 SRV_FILE_INFO_CTR *ctr = &r->ctr;
1183 /* TODO -- Windows enumerates
1184 (b) active pipes
1185 (c) open directories and files */
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;
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;
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;
1203 r->status = WERR_OK;
1205 done:
1206 if ( ctr->num_entries > 0 )
1207 ctr->ptr_entries = 1;
1209 init_enum_hnd(&r->enum_hnd, 0);
1211 return r->status;
1214 /*******************************************************************
1215 *******************************************************************/
1217 WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
1219 const char *username = NULL;
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;
1231 return net_file_enum_3(username, r_u,
1232 get_enum_hnd(&q_u->enum_hnd));
1233 default:
1234 return WERR_UNKNOWN_LEVEL;
1237 return WERR_OK;
1240 /*******************************************************************
1241 net server get info
1242 ********************************************************************/
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)
1246 WERROR status = WERR_OK;
1247 SRV_INFO_CTR *ctr = TALLOC_P(p->mem_ctx, SRV_INFO_CTR);
1249 if (!ctr)
1250 return WERR_NOMEM;
1252 ZERO_STRUCTP(ctr);
1254 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1256 if (!pipe_access_check(p)) {
1257 DEBUG(3, ("access denied to srv_net_srv_get_info\n"));
1258 return WERR_ACCESS_DENIED;
1261 switch (q_u->switch_value) {
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. */
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;
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);
1299 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1301 return r_u->status;
1304 /*******************************************************************
1305 net server set info
1306 ********************************************************************/
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)
1310 WERROR status = WERR_OK;
1312 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1314 /* Set up the net server set info structure. */
1316 init_srv_r_net_srv_set_info(r_u, 0x0, status);
1318 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1320 return r_u->status;
1323 /*******************************************************************
1324 net conn enum
1325 ********************************************************************/
1327 WERROR _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
1329 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1331 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_CONN_INFO_CTR);
1332 if (!r_u->ctr)
1333 return WERR_NOMEM;
1335 ZERO_STRUCTP(r_u->ctr);
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);
1343 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1345 return r_u->status;
1348 /*******************************************************************
1349 net sess enum
1350 ********************************************************************/
1352 WERROR _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
1354 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1356 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_SESS_INFO_CTR);
1357 if (!r_u->ctr)
1358 return WERR_NOMEM;
1360 ZERO_STRUCTP(r_u->ctr);
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);
1368 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1370 return r_u->status;
1373 /*******************************************************************
1374 net sess del
1375 ********************************************************************/
1377 WERROR _srv_net_sess_del(pipes_struct *p, SRV_Q_NET_SESS_DEL *q_u, SRV_R_NET_SESS_DEL *r_u)
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;
1386 rpcstr_pull_unistr2_fstring(username, &q_u->uni_user_name);
1387 rpcstr_pull_unistr2_fstring(machine, &q_u->uni_cli_name);
1389 /* strip leading backslashes if any */
1390 while (machine[0] == '\\') {
1391 memmove(machine, &machine[1], strlen(machine));
1394 num_sessions = list_sessions(p->mem_ctx, &session_list);
1396 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1398 r_u->status = WERR_ACCESS_DENIED;
1400 get_current_user(&user, p);
1402 /* fail out now if you are not root or not a domain admin */
1404 if ((user.ut.uid != sec_initial_uid()) &&
1405 ( ! nt_token_check_domain_rid(p->pipe_user.nt_user_token, DOMAIN_GROUP_RID_ADMINS))) {
1407 goto done;
1410 for (snum = 0; snum < num_sessions; snum++) {
1412 if ((strequal(session_list[snum].username, username) || username[0] == '\0' ) &&
1413 strequal(session_list[snum].remote_machine, machine)) {
1415 NTSTATUS ntstat;
1417 if (user.ut.uid != sec_initial_uid()) {
1418 not_root = True;
1419 become_root();
1422 ntstat = messaging_send(smbd_messaging_context(),
1423 session_list[snum].pid,
1424 MSG_SHUTDOWN, &data_blob_null);
1426 if (NT_STATUS_IS_OK(ntstat))
1427 r_u->status = WERR_OK;
1429 if (not_root)
1430 unbecome_root();
1434 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1437 done:
1439 return r_u->status;
1442 /*******************************************************************
1443 Net share enum all.
1444 ********************************************************************/
1446 WERROR _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1448 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1450 if (!pipe_access_check(p)) {
1451 DEBUG(3, ("access denied to srv_net_share_enum_all\n"));
1452 return WERR_ACCESS_DENIED;
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);
1460 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1462 return r_u->status;
1465 /*******************************************************************
1466 Net share enum.
1467 ********************************************************************/
1469 WERROR _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1471 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1473 if (!pipe_access_check(p)) {
1474 DEBUG(3, ("access denied to srv_net_share_enum\n"));
1475 return WERR_ACCESS_DENIED;
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);
1483 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1485 return r_u->status;
1488 /*******************************************************************
1489 Net share get info.
1490 ********************************************************************/
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)
1494 fstring share_name;
1496 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
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);
1502 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1504 return r_u->status;
1507 /*******************************************************************
1508 Check a given DOS pathname is valid for a share.
1509 ********************************************************************/
1511 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
1513 char *ptr = NULL;
1515 if (!dos_pathname) {
1516 return NULL;
1519 ptr = talloc_strdup(ctx, dos_pathname);
1520 if (!ptr) {
1521 return NULL;
1523 /* Convert any '\' paths to '/' */
1524 unix_format(ptr);
1525 ptr = unix_clean_name(ctx, ptr);
1526 if (!ptr) {
1527 return NULL;
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;
1534 /* Only absolute paths allowed. */
1535 if (*ptr != '/')
1536 return NULL;
1538 return ptr;
1541 /*******************************************************************
1542 Net share set info. Modify share details.
1543 ********************************************************************/
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)
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;
1562 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1564 share_name = unistr2_to_ascii_talloc(ctx, &q_u->uni_share_name);
1565 if (!share_name) {
1566 return WERR_NET_NAME_NOT_FOUND;
1569 r_u->parm_error = 0;
1571 if ( strequal(share_name,"IPC$")
1572 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1573 || strequal(share_name,"global") )
1575 return WERR_ACCESS_DENIED;
1578 snum = find_service(share_name);
1580 /* Does this share exist ? */
1581 if (snum < 0)
1582 return WERR_NET_NAME_NOT_FOUND;
1584 /* No change to printer shares. */
1585 if (lp_print_ok(snum))
1586 return WERR_ACCESS_DENIED;
1588 get_current_user(&user,p);
1590 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1592 /* fail out now if you are not root and not a disk op */
1594 if ( user.ut.uid != sec_initial_uid() && !is_disk_op )
1595 return WERR_ACCESS_DENIED;
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;
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;
1665 /* We can only modify disk shares. */
1666 if (type != STYPE_DISKTREE)
1667 return WERR_ACCESS_DENIED;
1669 /* Check if the pathname is valid. */
1670 if (!(path = valid_share_pathname(p->mem_ctx, pathname )))
1671 return WERR_OBJECT_PATH_INVALID;
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, '"', ' ');
1680 DEBUG(10,("_srv_net_share_set_info: change share command = %s\n",
1681 lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
1683 /* Only call modify function if something changed. */
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;
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;
1704 DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
1706 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1708 if (is_disk_op)
1709 become_root();
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);
1718 if ( is_disk_op )
1719 unbecome_root();
1721 /********* END SeDiskOperatorPrivilege BLOCK *********/
1723 DEBUG(3,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
1725 TALLOC_FREE(command);
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 ));
1733 /* Replace SD if changed. */
1734 if (psd) {
1735 SEC_DESC *old_sd;
1736 size_t sd_size;
1738 old_sd = get_share_security(p->mem_ctx, lp_servicename(snum), &sd_size);
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 ));
1747 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1749 return WERR_OK;
1752 /*******************************************************************
1753 Net share add. Call 'add_share_command "sharename" "pathname"
1754 "comment" "max connections = "
1755 ********************************************************************/
1757 WERROR _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
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;
1774 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1776 r_u->parm_error = 0;
1778 get_current_user(&user,p);
1780 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1782 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1783 return WERR_ACCESS_DENIED;
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;
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;
1822 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
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;
1837 /* check for invalid share names */
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;
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;
1853 snum = find_service(share_name);
1855 /* Share already exists. */
1856 if (snum >= 0) {
1857 return WERR_ALREADY_EXISTS;
1860 /* We can only add disk shares. */
1861 if (type != STYPE_DISKTREE) {
1862 return WERR_ACCESS_DENIED;
1865 /* Check if the pathname is valid. */
1866 if (!(path = valid_share_pathname(p->mem_ctx, pathname))) {
1867 return WERR_OBJECT_PATH_INVALID;
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, '"', ' ');
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;
1889 DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
1891 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1893 if ( is_disk_op )
1894 become_root();
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);
1902 if ( is_disk_op )
1903 unbecome_root();
1905 /********* END SeDiskOperatorPrivilege BLOCK *********/
1907 DEBUG(3,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
1909 TALLOC_FREE(command);
1911 if ( ret != 0 )
1912 return WERR_ACCESS_DENIED;
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 ));
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.
1926 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1928 return WERR_OK;
1931 /*******************************************************************
1932 Net share delete. Call "delete share command" with the share name as
1933 a parameter.
1934 ********************************************************************/
1936 WERROR _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
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;
1948 DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
1950 share_name = unistr2_to_ascii_talloc(ctx, &q_u->uni_share_name);
1952 if (!share_name) {
1953 return WERR_NET_NAME_NOT_FOUND;
1955 if ( strequal(share_name,"IPC$")
1956 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1957 || strequal(share_name,"global") )
1959 return WERR_ACCESS_DENIED;
1962 if (!(params = get_share_params(p->mem_ctx, share_name))) {
1963 return WERR_NO_SUCH_SHARE;
1966 snum = find_service(share_name);
1968 /* No change to printer shares. */
1969 if (lp_print_ok(snum))
1970 return WERR_ACCESS_DENIED;
1972 get_current_user(&user,p);
1974 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1976 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1977 return WERR_ACCESS_DENIED;
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;
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;
1993 DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
1995 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1997 if ( is_disk_op )
1998 become_root();
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);
2006 if ( is_disk_op )
2007 unbecome_root();
2009 /********* END SeDiskOperatorPrivilege BLOCK *********/
2011 DEBUG(3,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
2013 if ( ret != 0 )
2014 return WERR_ACCESS_DENIED;
2016 /* Delete the SD in the database. */
2017 delete_share_security(lp_servicename(params->service));
2019 lp_killservice(params->service);
2021 return WERR_OK;
2024 WERROR _srv_net_share_del_sticky(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
2026 DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
2028 return _srv_net_share_del(p, q_u, r_u);
2031 /*******************************************************************
2032 time of day
2033 ********************************************************************/
2035 WERROR _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
2037 TIME_OF_DAY_INFO *tod;
2038 struct tm *t;
2039 time_t unixdate = time(NULL);
2041 /* We do this call first as if we do it *after* the gmtime call
2042 it overwrites the pointed-to values. JRA */
2044 uint32 zone = get_time_zone(unixdate)/60;
2046 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2048 if ( !(tod = TALLOC_ZERO_P(p->mem_ctx, TIME_OF_DAY_INFO)) )
2049 return WERR_NOMEM;
2051 r_u->tod = tod;
2052 r_u->ptr_srv_tod = 0x1;
2053 r_u->status = WERR_OK;
2055 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2057 t = gmtime(&unixdate);
2059 /* set up the */
2060 init_time_of_day_info(tod,
2061 unixdate,
2063 t->tm_hour,
2064 t->tm_min,
2065 t->tm_sec,
2067 zone,
2068 10000,
2069 t->tm_mday,
2070 t->tm_mon + 1,
2071 1900+t->tm_year,
2072 t->tm_wday);
2074 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
2076 return r_u->status;
2079 /***********************************************************************************
2080 Win9x NT tools get security descriptor.
2081 ***********************************************************************************/
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)
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;
2099 ZERO_STRUCT(st);
2101 r_u->status = WERR_OK;
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;
2109 /* Null password is ok - we are already an authenticated user... */
2110 null_pw = data_blob_null;
2112 get_current_user(&user, p);
2114 become_root();
2115 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
2116 unbecome_root();
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;
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;
2129 became_user = True;
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;
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;
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;
2151 nt_status = SMB_VFS_GET_NT_ACL(conn, filename,
2152 (OWNER_SECURITY_INFORMATION
2153 |GROUP_SECURITY_INFORMATION
2154 |DACL_SECURITY_INFORMATION), &psd);
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;
2162 sd_size = ndr_size_security_descriptor(psd, 0);
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;
2170 psd->dacl->revision = NT4_ACL_REVISION;
2172 unbecome_user();
2173 close_cnum(conn, user.vuid);
2174 return r_u->status;
2176 error_exit:
2178 if (became_user)
2179 unbecome_user();
2181 if (conn)
2182 close_cnum(conn, user.vuid);
2184 return r_u->status;
2187 /***********************************************************************************
2188 Win9x NT tools set security descriptor.
2189 ***********************************************************************************/
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)
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;
2206 ZERO_STRUCT(st);
2208 r_u->status = WERR_OK;
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;
2216 /* Null password is ok - we are already an authenticated user... */
2217 null_pw = data_blob_null;
2219 get_current_user(&user, p);
2221 become_root();
2222 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
2223 unbecome_root();
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;
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;
2236 became_user = True;
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;
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;
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;
2258 nt_status = open_file_stat(conn, NULL, filename, &st, &fsp);
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,
2268 FILE_ATTRIBUTE_DIRECTORY,
2269 NULL, &fsp);
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;
2278 nt_status = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
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;
2286 close_file(fsp, NORMAL_CLOSE);
2287 unbecome_user();
2288 close_cnum(conn, user.vuid);
2289 return r_u->status;
2291 error_exit:
2293 if(fsp) {
2294 close_file(fsp, NORMAL_CLOSE);
2297 if (became_user) {
2298 unbecome_user();
2301 if (conn) {
2302 close_cnum(conn, user.vuid);
2305 return r_u->status;
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 ***********************************************************************************/
2316 static const char *server_disks[] = {"C:"};
2318 static uint32 get_server_disk_count(void)
2320 return sizeof(server_disks)/sizeof(server_disks[0]);
2323 static uint32 init_server_disk_enum(uint32 *resume)
2325 uint32 server_disk_count = get_server_disk_count();
2327 /*resume can be an offset into the list for now*/
2329 if(*resume & 0x80000000)
2330 *resume = 0;
2332 if(*resume > server_disk_count)
2333 *resume = server_disk_count;
2335 return server_disk_count - *resume;
2338 static const char *next_server_disk_enum(uint32 *resume)
2340 const char *disk;
2342 if(init_server_disk_enum(resume) == 0)
2343 return NULL;
2345 disk = server_disks[*resume];
2347 (*resume)++;
2349 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2351 return disk;
2354 WERROR _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
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);
2361 r_u->status=WERR_OK;
2363 r_u->total_entries = init_server_disk_enum(&resume);
2365 r_u->disk_enum_ctr.unknown = 0;
2367 if(!(r_u->disk_enum_ctr.disk_info = TALLOC_ARRAY(ctx, DISK_INFO, MAX_SERVER_DISK_ENTRIES))) {
2368 return WERR_NOMEM;
2371 r_u->disk_enum_ctr.disk_info_ptr = r_u->disk_enum_ctr.disk_info ? 1 : 0;
2373 /*allow one DISK_INFO for null terminator*/
2375 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2377 r_u->disk_enum_ctr.entries_read++;
2379 /*copy disk name into a unicode string*/
2381 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, disk_name);
2384 /* add a terminating null string. Is this there if there is more data to come? */
2386 r_u->disk_enum_ctr.entries_read++;
2388 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, "");
2390 init_enum_hnd(&r_u->enum_hnd, resume);
2392 return r_u->status;
2395 /********************************************************************
2396 ********************************************************************/
2398 WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
2400 fstring sharename;
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;
2409 break;
2411 default:
2412 return WERR_UNKNOWN_LEVEL;
2415 return WERR_OK;
2419 /********************************************************************
2420 ********************************************************************/
2422 WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r)
2424 return WERR_ACCESS_DENIED;
2428 /********************************************************************
2429 ********************************************************************/
2431 WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r)
2433 p->rng_fault_state = True;
2434 return WERR_NOT_SUPPORTED;
2437 WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r)
2439 p->rng_fault_state = True;
2440 return WERR_NOT_SUPPORTED;
2443 WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r)
2445 p->rng_fault_state = True;
2446 return WERR_NOT_SUPPORTED;
2449 WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r)
2451 p->rng_fault_state = True;
2452 return WERR_NOT_SUPPORTED;
2455 WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r)
2457 p->rng_fault_state = True;
2458 return WERR_NOT_SUPPORTED;
2461 WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r)
2463 p->rng_fault_state = True;
2464 return WERR_NOT_SUPPORTED;
2467 WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r)
2469 p->rng_fault_state = True;
2470 return WERR_NOT_SUPPORTED;
2473 WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r)
2475 p->rng_fault_state = True;
2476 return WERR_NOT_SUPPORTED;
2479 WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r)
2481 p->rng_fault_state = True;
2482 return WERR_NOT_SUPPORTED;
2485 WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r)
2487 p->rng_fault_state = True;
2488 return WERR_NOT_SUPPORTED;
2491 WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r)
2493 p->rng_fault_state = True;
2494 return WERR_NOT_SUPPORTED;
2497 WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r)
2499 p->rng_fault_state = True;
2500 return WERR_NOT_SUPPORTED;
2503 WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r)
2505 p->rng_fault_state = True;
2506 return WERR_NOT_SUPPORTED;
2509 WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r)
2511 p->rng_fault_state = True;
2512 return WERR_NOT_SUPPORTED;
2515 WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r)
2517 p->rng_fault_state = True;
2518 return WERR_NOT_SUPPORTED;
2521 WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r)
2523 p->rng_fault_state = True;
2524 return WERR_NOT_SUPPORTED;
2527 WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r)
2529 p->rng_fault_state = True;
2530 return WERR_NOT_SUPPORTED;
2533 WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r)
2535 p->rng_fault_state = True;
2536 return WERR_NOT_SUPPORTED;
2539 WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r)
2541 p->rng_fault_state = True;
2542 return WERR_NOT_SUPPORTED;
2545 WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r)
2547 p->rng_fault_state = True;
2548 return WERR_NOT_SUPPORTED;
2551 WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r)
2553 p->rng_fault_state = True;
2554 return WERR_NOT_SUPPORTED;
2557 WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r)
2559 p->rng_fault_state = True;
2560 return WERR_NOT_SUPPORTED;
2563 WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r)
2565 p->rng_fault_state = True;
2566 return WERR_NOT_SUPPORTED;
2569 WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r)
2571 p->rng_fault_state = True;
2572 return WERR_NOT_SUPPORTED;
2575 WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r)
2577 p->rng_fault_state = True;
2578 return WERR_NOT_SUPPORTED;
2581 WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r)
2583 p->rng_fault_state = True;
2584 return WERR_NOT_SUPPORTED;
2587 WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r)
2589 p->rng_fault_state = True;
2590 return WERR_NOT_SUPPORTED;
2593 WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r)
2595 p->rng_fault_state = True;
2596 return WERR_NOT_SUPPORTED;
2599 WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r)
2601 p->rng_fault_state = True;
2602 return WERR_NOT_SUPPORTED;
2605 WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r)
2607 p->rng_fault_state = True;
2608 return WERR_NOT_SUPPORTED;
2611 WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r)
2613 p->rng_fault_state = True;
2614 return WERR_NOT_SUPPORTED;
2617 WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r)
2619 p->rng_fault_state = True;
2620 return WERR_NOT_SUPPORTED;
2623 WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r)
2625 p->rng_fault_state = True;
2626 return WERR_NOT_SUPPORTED;
2629 WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r)
2631 p->rng_fault_state = True;
2632 return WERR_NOT_SUPPORTED;
2635 WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r)
2637 p->rng_fault_state = True;
2638 return WERR_NOT_SUPPORTED;
2641 WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r)
2643 p->rng_fault_state = True;
2644 return WERR_NOT_SUPPORTED;
2647 WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r)
2649 p->rng_fault_state = True;
2650 return WERR_NOT_SUPPORTED;
2653 WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r)
2655 p->rng_fault_state = True;
2656 return WERR_NOT_SUPPORTED;
2659 WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r)
2661 p->rng_fault_state = True;
2662 return WERR_NOT_SUPPORTED;
2665 WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r)
2667 p->rng_fault_state = True;
2668 return WERR_NOT_SUPPORTED;
2671 WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r)
2673 p->rng_fault_state = True;
2674 return WERR_NOT_SUPPORTED;
2677 WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r)
2679 p->rng_fault_state = True;
2680 return WERR_NOT_SUPPORTED;
2683 WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r)
2685 p->rng_fault_state = True;
2686 return WERR_NOT_SUPPORTED;
2689 WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2691 p->rng_fault_state = True;
2692 return WERR_NOT_SUPPORTED;
2695 WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2697 p->rng_fault_state = True;
2698 return WERR_NOT_SUPPORTED;
2701 WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2703 p->rng_fault_state = True;
2704 return WERR_NOT_SUPPORTED;
2707 WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r)
2709 p->rng_fault_state = True;
2710 return WERR_NOT_SUPPORTED;
2713 WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2715 p->rng_fault_state = True;
2716 return WERR_NOT_SUPPORTED;
2719 WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2721 p->rng_fault_state = True;
2722 return WERR_NOT_SUPPORTED;
2725 WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r)
2727 p->rng_fault_state = True;
2728 return WERR_NOT_SUPPORTED;
2731 WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2733 p->rng_fault_state = True;
2734 return WERR_NOT_SUPPORTED;
2737 WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2739 p->rng_fault_state = True;
2740 return WERR_NOT_SUPPORTED;
2743 WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2745 p->rng_fault_state = True;
2746 return WERR_NOT_SUPPORTED;