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 * Copyright (C) Guenther Deschner 2008.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 /* This is the implementation of the srvsvc pipe. */
27 #include "../librpc/gen_ndr/srv_srvsvc.h"
28 #include "librpc/gen_ndr/messaging.h"
29 #include "../librpc/gen_ndr/ndr_security.h"
32 extern const struct generic_mapping file_generic_mapping;
35 #define DBGC_CLASS DBGC_RPC_SRV
37 #define MAX_SERVER_DISK_ENTRIES 15
39 /* Use for enumerating connections, pipes, & files */
41 struct file_enum_count {
44 struct srvsvc_NetFileCtr3 *ctr3;
47 struct sess_file_count {
53 /****************************************************************************
54 Count the entries belonging to a service in the connection db.
55 ****************************************************************************/
57 static int pipe_enum_fn( struct db_record *rec, void *p)
59 struct pipe_open_rec prec;
60 struct file_enum_count *fenum = (struct file_enum_count *)p;
61 struct srvsvc_NetFileInfo3 *f;
62 int i = fenum->ctr3->count;
63 char *fullpath = NULL;
66 if (rec->value.dsize != sizeof(struct pipe_open_rec))
69 memcpy(&prec, rec->value.dptr, sizeof(struct pipe_open_rec));
71 if ( !process_exists(prec.pid) ) {
75 username = uidtoname(prec.uid);
77 if ((fenum->username != NULL)
78 && !strequal(username, fenum->username)) {
82 fullpath = talloc_asprintf(fenum->ctx, "\\PIPE\\%s", prec.name );
87 f = TALLOC_REALLOC_ARRAY(fenum->ctx, fenum->ctr3->array,
88 struct srvsvc_NetFileInfo3, i+1);
90 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
93 fenum->ctr3->array = f;
95 fenum->ctr3->array[i].fid =
96 (((uint32_t)(procid_to_pid(&prec.pid))<<16) | prec.pnum);
97 fenum->ctr3->array[i].permissions =
98 (FILE_READ_DATA|FILE_WRITE_DATA);
99 fenum->ctr3->array[i].num_locks = 0;
100 fenum->ctr3->array[i].path = fullpath;
101 fenum->ctr3->array[i].user = username;
103 fenum->ctr3->count++;
108 /*******************************************************************
109 ********************************************************************/
111 static WERROR net_enum_pipes(TALLOC_CTX *ctx,
112 const char *username,
113 struct srvsvc_NetFileCtr3 **ctr3,
116 struct file_enum_count fenum;
119 fenum.username = username;
122 if (connections_traverse(pipe_enum_fn, &fenum) == -1) {
123 DEBUG(0,("net_enum_pipes: traverse of connections.tdb "
133 /*******************************************************************
134 ********************************************************************/
136 static void enum_file_fn( const struct share_mode_entry *e,
137 const char *sharepath, const char *fname,
140 struct file_enum_count *fenum =
141 (struct file_enum_count *)private_data;
143 struct srvsvc_NetFileInfo3 *f;
144 int i = fenum->ctr3->count;
146 struct byte_range_lock *brl;
148 char *fullpath = NULL;
150 const char *username;
152 /* If the pid was not found delete the entry from connections.tdb */
154 if ( !process_exists(e->pid) ) {
158 username = uidtoname(e->uid);
160 if ((fenum->username != NULL)
161 && !strequal(username, fenum->username)) {
165 f = TALLOC_REALLOC_ARRAY(fenum->ctx, fenum->ctr3->array,
166 struct srvsvc_NetFileInfo3, i+1);
168 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
171 fenum->ctr3->array = f;
173 /* need to count the number of locks on a file */
178 if ( (brl = brl_get_locks(talloc_tos(), &fsp)) != NULL ) {
179 num_locks = brl->num_locks;
183 if ( strcmp( fname, "." ) == 0 ) {
184 fullpath = talloc_asprintf(fenum->ctx, "C:%s", sharepath );
186 fullpath = talloc_asprintf(fenum->ctx, "C:%s/%s",
192 string_replace( fullpath, '/', '\\' );
194 /* mask out create (what ever that is) */
195 permissions = e->access_mask & (FILE_READ_DATA|FILE_WRITE_DATA);
197 /* now fill in the srvsvc_NetFileInfo3 struct */
199 fenum->ctr3->array[i].fid =
200 (((uint32_t)(procid_to_pid(&e->pid))<<16) | e->share_file_id);
201 fenum->ctr3->array[i].permissions = permissions;
202 fenum->ctr3->array[i].num_locks = num_locks;
203 fenum->ctr3->array[i].path = fullpath;
204 fenum->ctr3->array[i].user = username;
206 fenum->ctr3->count++;
209 /*******************************************************************
210 ********************************************************************/
212 static WERROR net_enum_files(TALLOC_CTX *ctx,
213 const char *username,
214 struct srvsvc_NetFileCtr3 **ctr3,
217 struct file_enum_count f_enum_cnt;
219 f_enum_cnt.ctx = ctx;
220 f_enum_cnt.username = username;
221 f_enum_cnt.ctr3 = *ctr3;
223 share_mode_forall( enum_file_fn, (void *)&f_enum_cnt );
225 *ctr3 = f_enum_cnt.ctr3;
230 /*******************************************************************
231 Utility function to get the 'type' of a share from an snum.
232 ********************************************************************/
233 static uint32 get_share_type(int snum)
235 /* work out the share type */
236 uint32 type = STYPE_DISKTREE;
238 if (lp_print_ok(snum))
240 if (strequal(lp_fstype(snum), "IPC"))
242 if (lp_administrative_share(snum))
243 type |= STYPE_HIDDEN;
248 /*******************************************************************
249 Fill in a share info level 0 structure.
250 ********************************************************************/
252 static void init_srv_share_info_0(struct pipes_struct *p,
253 struct srvsvc_NetShareInfo0 *r, int snum)
255 r->name = lp_servicename(snum);
258 /*******************************************************************
259 Fill in a share info level 1 structure.
260 ********************************************************************/
262 static void init_srv_share_info_1(struct pipes_struct *p,
263 struct srvsvc_NetShareInfo1 *r,
266 char *net_name = lp_servicename(snum);
267 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
270 remark = talloc_sub_advanced(
271 p->mem_ctx, lp_servicename(snum),
272 get_current_username(), lp_pathname(snum),
273 p->server_info->utok.uid, get_current_username(),
278 r->type = get_share_type(snum);
279 r->comment = remark ? remark : "";
282 /*******************************************************************
283 Fill in a share info level 2 structure.
284 ********************************************************************/
286 static void init_srv_share_info_2(struct pipes_struct *p,
287 struct srvsvc_NetShareInfo2 *r,
292 int max_connections = lp_max_connections(snum);
293 uint32_t max_uses = max_connections!=0 ? max_connections : (uint32_t)-1;
294 char *net_name = lp_servicename(snum);
296 remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
298 remark = talloc_sub_advanced(
299 p->mem_ctx, lp_servicename(snum),
300 get_current_username(), lp_pathname(snum),
301 p->server_info->utok.uid, get_current_username(),
304 path = talloc_asprintf(p->mem_ctx,
305 "C:%s", lp_pathname(snum));
309 * Change / to \\ so that win2k will see it as a valid path.
310 * This was added to enable use of browsing in win2k add
314 string_replace(path, '/', '\\');
318 r->type = get_share_type(snum);
319 r->comment = remark ? remark : "";
321 r->max_users = max_uses;
322 r->current_users = count_current_connections(net_name, false);
323 r->path = path ? path : "";
327 /*******************************************************************
328 Map any generic bits to file specific bits.
329 ********************************************************************/
331 static void map_generic_share_sd_bits(struct security_descriptor *psd)
334 struct security_acl *ps_dacl = NULL;
343 for (i = 0; i < ps_dacl->num_aces; i++) {
344 struct security_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(struct pipes_struct *p,
357 struct srvsvc_NetShareInfo501 *r, int snum)
359 const char *net_name = lp_servicename(snum);
360 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
363 remark = talloc_sub_advanced(
364 p->mem_ctx, lp_servicename(snum),
365 get_current_username(), lp_pathname(snum),
366 p->server_info->utok.uid, get_current_username(),
371 r->type = get_share_type(snum);
372 r->comment = remark ? remark : "";
373 r->csc_policy = (lp_csc_policy(snum) << 4);
376 /*******************************************************************
377 Fill in a share info level 502 structure.
378 ********************************************************************/
380 static void init_srv_share_info_502(struct pipes_struct *p,
381 struct srvsvc_NetShareInfo502 *r, int snum)
383 const char *net_name = lp_servicename(snum);
385 struct security_descriptor *sd = NULL;
386 struct sec_desc_buf *sd_buf = NULL;
388 TALLOC_CTX *ctx = p->mem_ctx;
389 char *remark = talloc_strdup(ctx, lp_comment(snum));;
392 remark = talloc_sub_advanced(
393 p->mem_ctx, lp_servicename(snum),
394 get_current_username(), lp_pathname(snum),
395 p->server_info->utok.uid, get_current_username(),
398 path = talloc_asprintf(ctx, "C:%s", lp_pathname(snum));
401 * Change / to \\ so that win2k will see it as a valid path. This was added to
402 * enable use of browsing in win2k add share dialog.
404 string_replace(path, '/', '\\');
407 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
409 sd_buf = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
412 r->type = get_share_type(snum);
413 r->comment = remark ? remark : "";
415 r->max_users = (uint32_t)-1;
416 r->current_users = 1; /* ??? */
417 r->path = path ? path : "";
422 /***************************************************************************
423 Fill in a share info level 1004 structure.
424 ***************************************************************************/
426 static void init_srv_share_info_1004(struct pipes_struct *p,
427 struct srvsvc_NetShareInfo1004 *r,
430 char *remark = talloc_strdup(p->mem_ctx, lp_comment(snum));
433 remark = talloc_sub_advanced(
434 p->mem_ctx, lp_servicename(snum),
435 get_current_username(), lp_pathname(snum),
436 p->server_info->utok.uid, get_current_username(),
440 r->comment = remark ? remark : "";
443 /***************************************************************************
444 Fill in a share info level 1005 structure.
445 ***************************************************************************/
447 static void init_srv_share_info_1005(struct pipes_struct *p,
448 struct srvsvc_NetShareInfo1005 *r,
451 uint32_t dfs_flags = 0;
453 if (lp_host_msdfs() && lp_msdfs_root(snum)) {
454 dfs_flags |= SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
457 dfs_flags |= lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
459 r->dfs_flags = dfs_flags;
462 /***************************************************************************
463 Fill in a share info level 1006 structure.
464 ***************************************************************************/
466 static void init_srv_share_info_1006(struct pipes_struct *p,
467 struct srvsvc_NetShareInfo1006 *r,
470 r->max_users = (uint32_t)-1;
473 /***************************************************************************
474 Fill in a share info level 1007 structure.
475 ***************************************************************************/
477 static void init_srv_share_info_1007(struct pipes_struct *p,
478 struct srvsvc_NetShareInfo1007 *r,
482 r->alternate_directory_name = "";
485 /*******************************************************************
486 Fill in a share info level 1501 structure.
487 ********************************************************************/
489 static void init_srv_share_info_1501(struct pipes_struct *p,
490 struct sec_desc_buf *r,
493 struct security_descriptor *sd;
495 TALLOC_CTX *ctx = p->mem_ctx;
497 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
499 r = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
502 /*******************************************************************
503 True if it ends in '$'.
504 ********************************************************************/
506 static bool is_hidden_share(int snum)
508 const char *net_name = lp_servicename(snum);
510 return (net_name[strlen(net_name) - 1] == '$') ? True : False;
513 /*******************************************************************
514 Verify user is allowed to view share, access based enumeration
515 ********************************************************************/
516 static bool is_enumeration_allowed(struct pipes_struct *p,
519 if (!lp_access_based_share_enum(snum))
522 return share_access_check(p->server_info->ptok, lp_servicename(snum),
526 /*******************************************************************
527 Fill in a share info structure.
528 ********************************************************************/
530 static WERROR init_srv_share_info_ctr(struct pipes_struct *p,
531 struct srvsvc_NetShareInfoCtr *info_ctr,
532 uint32_t *resume_handle_p,
533 uint32_t *total_entries,
537 int alloc_entries = 0;
538 int num_services = 0;
540 TALLOC_CTX *ctx = p->mem_ctx;
542 int valid_share_count = 0;
544 union srvsvc_NetShareCtr ctr;
545 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
547 DEBUG(5,("init_srv_share_info_ctr\n"));
549 /* Ensure all the usershares are loaded. */
551 load_usershare_shares();
552 load_registry_shares();
553 num_services = lp_numservices();
556 allowed = TALLOC_ZERO_ARRAY(ctx, bool, num_services);
557 W_ERROR_HAVE_NO_MEMORY(allowed);
559 /* Count the number of entries. */
560 for (snum = 0; snum < num_services; snum++) {
561 if (lp_browseable(snum) && lp_snum_ok(snum) &&
562 is_enumeration_allowed(p, snum) &&
563 (all_shares || !is_hidden_share(snum)) ) {
564 DEBUG(10, ("counting service %s\n",
565 lp_servicename(snum) ? lp_servicename(snum) : "(null)"));
566 allowed[snum] = true;
569 DEBUG(10, ("NOT counting service %s\n",
570 lp_servicename(snum) ? lp_servicename(snum) : "(null)"));
574 if (!num_entries || (resume_handle >= num_entries)) {
578 /* Calculate alloc entries. */
579 alloc_entries = num_entries - resume_handle;
580 switch (info_ctr->level) {
582 ctr.ctr0 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr0);
583 W_ERROR_HAVE_NO_MEMORY(ctr.ctr0);
585 ctr.ctr0->count = alloc_entries;
586 ctr.ctr0->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo0, alloc_entries);
587 W_ERROR_HAVE_NO_MEMORY(ctr.ctr0->array);
589 for (snum = 0; snum < num_services; snum++) {
591 (resume_handle <= (i + valid_share_count++)) ) {
592 init_srv_share_info_0(p, &ctr.ctr0->array[i++], snum);
599 ctr.ctr1 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1);
600 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1);
602 ctr.ctr1->count = alloc_entries;
603 ctr.ctr1->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo1, alloc_entries);
604 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1->array);
606 for (snum = 0; snum < num_services; snum++) {
608 (resume_handle <= (i + valid_share_count++)) ) {
609 init_srv_share_info_1(p, &ctr.ctr1->array[i++], snum);
616 ctr.ctr2 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr2);
617 W_ERROR_HAVE_NO_MEMORY(ctr.ctr2);
619 ctr.ctr2->count = alloc_entries;
620 ctr.ctr2->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo2, alloc_entries);
621 W_ERROR_HAVE_NO_MEMORY(ctr.ctr2->array);
623 for (snum = 0; snum < num_services; snum++) {
625 (resume_handle <= (i + valid_share_count++)) ) {
626 init_srv_share_info_2(p, &ctr.ctr2->array[i++], snum);
633 ctr.ctr501 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr501);
634 W_ERROR_HAVE_NO_MEMORY(ctr.ctr501);
636 ctr.ctr501->count = alloc_entries;
637 ctr.ctr501->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo501, alloc_entries);
638 W_ERROR_HAVE_NO_MEMORY(ctr.ctr501->array);
640 for (snum = 0; snum < num_services; snum++) {
642 (resume_handle <= (i + valid_share_count++)) ) {
643 init_srv_share_info_501(p, &ctr.ctr501->array[i++], snum);
650 ctr.ctr502 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr502);
651 W_ERROR_HAVE_NO_MEMORY(ctr.ctr502);
653 ctr.ctr502->count = alloc_entries;
654 ctr.ctr502->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo502, alloc_entries);
655 W_ERROR_HAVE_NO_MEMORY(ctr.ctr502->array);
657 for (snum = 0; snum < num_services; snum++) {
659 (resume_handle <= (i + valid_share_count++)) ) {
660 init_srv_share_info_502(p, &ctr.ctr502->array[i++], snum);
667 ctr.ctr1004 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1004);
668 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004);
670 ctr.ctr1004->count = alloc_entries;
671 ctr.ctr1004->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo1004, alloc_entries);
672 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004->array);
674 for (snum = 0; snum < num_services; snum++) {
676 (resume_handle <= (i + valid_share_count++)) ) {
677 init_srv_share_info_1004(p, &ctr.ctr1004->array[i++], snum);
684 ctr.ctr1005 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1005);
685 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005);
687 ctr.ctr1005->count = alloc_entries;
688 ctr.ctr1005->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo1005, alloc_entries);
689 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005->array);
691 for (snum = 0; snum < num_services; snum++) {
693 (resume_handle <= (i + valid_share_count++)) ) {
694 init_srv_share_info_1005(p, &ctr.ctr1005->array[i++], snum);
701 ctr.ctr1006 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1006);
702 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006);
704 ctr.ctr1006->count = alloc_entries;
705 ctr.ctr1006->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo1006, alloc_entries);
706 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006->array);
708 for (snum = 0; snum < num_services; snum++) {
710 (resume_handle <= (i + valid_share_count++)) ) {
711 init_srv_share_info_1006(p, &ctr.ctr1006->array[i++], snum);
718 ctr.ctr1007 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1007);
719 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007);
721 ctr.ctr1007->count = alloc_entries;
722 ctr.ctr1007->array = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetShareInfo1007, alloc_entries);
723 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007->array);
725 for (snum = 0; snum < num_services; snum++) {
727 (resume_handle <= (i + valid_share_count++)) ) {
728 init_srv_share_info_1007(p, &ctr.ctr1007->array[i++], snum);
735 ctr.ctr1501 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1501);
736 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501);
738 ctr.ctr1501->count = alloc_entries;
739 ctr.ctr1501->array = TALLOC_ZERO_ARRAY(ctx, struct sec_desc_buf, alloc_entries);
740 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501->array);
742 for (snum = 0; snum < num_services; snum++) {
744 (resume_handle <= (i + valid_share_count++)) ) {
745 init_srv_share_info_1501(p, &ctr.ctr1501->array[i++], snum);
752 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n",
754 return WERR_UNKNOWN_LEVEL;
757 *total_entries = alloc_entries;
758 if (resume_handle_p) {
760 *resume_handle_p = (num_entries == 0) ? *resume_handle_p : 0;
762 *resume_handle_p = num_entries;
771 /*******************************************************************
772 fill in a sess info level 0 structure.
773 ********************************************************************/
775 static WERROR init_srv_sess_info_0(struct pipes_struct *p,
776 struct srvsvc_NetSessCtr0 *ctr0,
777 uint32_t *resume_handle_p,
778 uint32_t *total_entries)
780 struct sessionid *session_list;
781 uint32_t num_entries = 0;
782 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
783 *total_entries = list_sessions(p->mem_ctx, &session_list);
785 DEBUG(5,("init_srv_sess_info_0\n"));
788 if (resume_handle_p) {
789 *resume_handle_p = 0;
794 for (; resume_handle < *total_entries; resume_handle++) {
796 ctr0->array = TALLOC_REALLOC_ARRAY(p->mem_ctx,
798 struct srvsvc_NetSessInfo0,
800 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
802 ctr0->array[num_entries].client =
803 session_list[resume_handle].remote_machine;
808 ctr0->count = num_entries;
810 if (resume_handle_p) {
811 if (*resume_handle_p >= *total_entries) {
812 *resume_handle_p = 0;
814 *resume_handle_p = resume_handle;
821 /*******************************************************************
822 ********************************************************************/
824 static void sess_file_fn( const struct share_mode_entry *e,
825 const char *sharepath, const char *fname,
828 struct sess_file_count *sess = (struct sess_file_count *)data;
830 if ( procid_equal(&e->pid, &sess->pid) && (sess->uid == e->uid) ) {
837 /*******************************************************************
838 ********************************************************************/
840 static int net_count_files( uid_t uid, struct server_id pid )
842 struct sess_file_count s_file_cnt;
844 s_file_cnt.count = 0;
845 s_file_cnt.uid = uid;
846 s_file_cnt.pid = pid;
848 share_mode_forall( sess_file_fn, &s_file_cnt );
850 return s_file_cnt.count;
853 /*******************************************************************
854 fill in a sess info level 1 structure.
855 ********************************************************************/
857 static WERROR init_srv_sess_info_1(struct pipes_struct *p,
858 struct srvsvc_NetSessCtr1 *ctr1,
859 uint32_t *resume_handle_p,
860 uint32_t *total_entries)
862 struct sessionid *session_list;
863 uint32_t num_entries = 0;
864 time_t now = time(NULL);
865 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
870 if (resume_handle_p) {
871 *resume_handle_p = 0;
876 *total_entries = list_sessions(p->mem_ctx, &session_list);
878 for (; resume_handle < *total_entries; resume_handle++) {
881 struct passwd *pw = sys_getpwnam(session_list[resume_handle].username);
885 DEBUG(10,("init_srv_sess_info_1: failed to find owner: %s\n",
886 session_list[resume_handle].username));
890 connect_time = (uint32_t)(now - session_list[resume_handle].connect_start);
891 num_files = net_count_files(pw->pw_uid, session_list[resume_handle].pid);
892 guest = strequal( session_list[resume_handle].username, lp_guestaccount() );
894 ctr1->array = TALLOC_REALLOC_ARRAY(p->mem_ctx,
896 struct srvsvc_NetSessInfo1,
898 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
900 ctr1->array[num_entries].client = session_list[resume_handle].remote_machine;
901 ctr1->array[num_entries].user = session_list[resume_handle].username;
902 ctr1->array[num_entries].num_open = num_files;
903 ctr1->array[num_entries].time = connect_time;
904 ctr1->array[num_entries].idle_time = 0;
905 ctr1->array[num_entries].user_flags = guest;
910 ctr1->count = num_entries;
912 if (resume_handle_p) {
913 if (*resume_handle_p >= *total_entries) {
914 *resume_handle_p = 0;
916 *resume_handle_p = resume_handle;
923 /*******************************************************************
924 fill in a conn info level 0 structure.
925 ********************************************************************/
927 static WERROR init_srv_conn_info_0(struct srvsvc_NetConnCtr0 *ctr0,
928 uint32_t *resume_handle_p,
929 uint32_t *total_entries)
931 uint32_t num_entries = 0;
932 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
934 DEBUG(5,("init_srv_conn_info_0\n"));
937 if (resume_handle_p) {
938 *resume_handle_p = 0;
947 for (; resume_handle < *total_entries; resume_handle++) {
949 ctr0->array = TALLOC_REALLOC_ARRAY(talloc_tos(),
951 struct srvsvc_NetConnInfo0,
957 ctr0->array[num_entries].conn_id = *total_entries;
959 /* move on to creating next connection */
963 ctr0->count = num_entries;
964 *total_entries = num_entries;
966 if (resume_handle_p) {
967 if (*resume_handle_p >= *total_entries) {
968 *resume_handle_p = 0;
970 *resume_handle_p = resume_handle;
977 /*******************************************************************
978 fill in a conn info level 1 structure.
979 ********************************************************************/
981 static WERROR init_srv_conn_info_1(struct srvsvc_NetConnCtr1 *ctr1,
982 uint32_t *resume_handle_p,
983 uint32_t *total_entries)
985 uint32_t num_entries = 0;
986 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
988 DEBUG(5,("init_srv_conn_info_1\n"));
991 if (resume_handle_p) {
992 *resume_handle_p = 0;
1001 for (; resume_handle < *total_entries; resume_handle++) {
1003 ctr1->array = TALLOC_REALLOC_ARRAY(talloc_tos(),
1005 struct srvsvc_NetConnInfo1,
1011 ctr1->array[num_entries].conn_id = *total_entries;
1012 ctr1->array[num_entries].conn_type = 0x3;
1013 ctr1->array[num_entries].num_open = 1;
1014 ctr1->array[num_entries].num_users = 1;
1015 ctr1->array[num_entries].conn_time = 3;
1016 ctr1->array[num_entries].user = "dummy_user";
1017 ctr1->array[num_entries].share = "IPC$";
1019 /* move on to creating next connection */
1023 ctr1->count = num_entries;
1024 *total_entries = num_entries;
1026 if (resume_handle_p) {
1027 if (*resume_handle_p >= *total_entries) {
1028 *resume_handle_p = 0;
1030 *resume_handle_p = resume_handle;
1037 /*******************************************************************
1039 *******************************************************************/
1041 WERROR _srvsvc_NetFileEnum(struct pipes_struct *p,
1042 struct srvsvc_NetFileEnum *r)
1044 TALLOC_CTX *ctx = NULL;
1045 struct srvsvc_NetFileCtr3 *ctr3;
1046 uint32_t resume_hnd = 0;
1049 switch (r->in.info_ctr->level) {
1053 return WERR_UNKNOWN_LEVEL;
1056 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1057 p->server_info->ptok)) {
1058 DEBUG(1, ("Enumerating files only allowed for "
1059 "administrators\n"));
1060 return WERR_ACCESS_DENIED;
1064 ctr3 = r->in.info_ctr->ctr.ctr3;
1066 werr = WERR_INVALID_PARAM;
1070 /* TODO -- Windows enumerates
1072 (c) open directories and files */
1074 werr = net_enum_files(ctx, r->in.user, &ctr3, resume_hnd);
1075 if (!W_ERROR_IS_OK(werr)) {
1079 werr = net_enum_pipes(ctx, r->in.user, &ctr3, resume_hnd);
1080 if (!W_ERROR_IS_OK(werr)) {
1084 *r->out.totalentries = ctr3->count;
1085 r->out.info_ctr->ctr.ctr3->array = ctr3->array;
1086 r->out.info_ctr->ctr.ctr3->count = ctr3->count;
1094 /*******************************************************************
1095 _srvsvc_NetSrvGetInfo
1096 ********************************************************************/
1098 WERROR _srvsvc_NetSrvGetInfo(struct pipes_struct *p,
1099 struct srvsvc_NetSrvGetInfo *r)
1101 WERROR status = WERR_OK;
1103 DEBUG(5,("_srvsvc_NetSrvGetInfo: %d\n", __LINE__));
1105 if (!pipe_access_check(p)) {
1106 DEBUG(3, ("access denied to _srvsvc_NetSrvGetInfo\n"));
1107 return WERR_ACCESS_DENIED;
1110 switch (r->in.level) {
1112 /* Technically level 102 should only be available to
1113 Administrators but there isn't anything super-secret
1114 here, as most of it is made up. */
1117 struct srvsvc_NetSrvInfo102 *info102;
1119 info102 = TALLOC_P(p->mem_ctx, struct srvsvc_NetSrvInfo102);
1124 info102->platform_id = PLATFORM_ID_NT;
1125 info102->server_name = global_myname();
1126 info102->version_major = lp_major_announce_version();
1127 info102->version_minor = lp_minor_announce_version();
1128 info102->server_type = lp_default_server_announce();
1129 info102->comment = string_truncate(lp_serverstring(),
1130 MAX_SERVER_STRING_LENGTH);
1131 info102->users = 0xffffffff;
1132 info102->disc = 0xf;
1133 info102->hidden = 0;
1134 info102->announce = 240;
1135 info102->anndelta = 3000;
1136 info102->licenses = 100000;
1137 info102->userpath = "C:\\";
1139 r->out.info->info102 = info102;
1143 struct srvsvc_NetSrvInfo101 *info101;
1145 info101 = TALLOC_P(p->mem_ctx, struct srvsvc_NetSrvInfo101);
1150 info101->platform_id = PLATFORM_ID_NT;
1151 info101->server_name = global_myname();
1152 info101->version_major = lp_major_announce_version();
1153 info101->version_minor = lp_minor_announce_version();
1154 info101->server_type = lp_default_server_announce();
1155 info101->comment = string_truncate(lp_serverstring(),
1156 MAX_SERVER_STRING_LENGTH);
1158 r->out.info->info101 = info101;
1162 struct srvsvc_NetSrvInfo100 *info100;
1164 info100 = TALLOC_P(p->mem_ctx, struct srvsvc_NetSrvInfo100);
1169 info100->platform_id = PLATFORM_ID_NT;
1170 info100->server_name = global_myname();
1172 r->out.info->info100 = info100;
1177 status = WERR_UNKNOWN_LEVEL;
1181 DEBUG(5,("_srvsvc_NetSrvGetInfo: %d\n", __LINE__));
1186 /*******************************************************************
1187 _srvsvc_NetSrvSetInfo
1188 ********************************************************************/
1190 WERROR _srvsvc_NetSrvSetInfo(struct pipes_struct *p,
1191 struct srvsvc_NetSrvSetInfo *r)
1193 WERROR status = WERR_OK;
1195 DEBUG(5,("_srvsvc_NetSrvSetInfo: %d\n", __LINE__));
1197 /* Set up the net server set info structure. */
1199 DEBUG(5,("_srvsvc_NetSrvSetInfo: %d\n", __LINE__));
1204 /*******************************************************************
1206 ********************************************************************/
1208 WERROR _srvsvc_NetConnEnum(struct pipes_struct *p,
1209 struct srvsvc_NetConnEnum *r)
1213 DEBUG(5,("_srvsvc_NetConnEnum: %d\n", __LINE__));
1215 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1216 p->server_info->ptok)) {
1217 DEBUG(1, ("Enumerating connections only allowed for "
1218 "administrators\n"));
1219 return WERR_ACCESS_DENIED;
1222 switch (r->in.info_ctr->level) {
1224 werr = init_srv_conn_info_0(r->in.info_ctr->ctr.ctr0,
1225 r->in.resume_handle,
1226 r->out.totalentries);
1229 werr = init_srv_conn_info_1(r->in.info_ctr->ctr.ctr1,
1230 r->in.resume_handle,
1231 r->out.totalentries);
1234 return WERR_UNKNOWN_LEVEL;
1237 DEBUG(5,("_srvsvc_NetConnEnum: %d\n", __LINE__));
1242 /*******************************************************************
1244 ********************************************************************/
1246 WERROR _srvsvc_NetSessEnum(struct pipes_struct *p,
1247 struct srvsvc_NetSessEnum *r)
1251 DEBUG(5,("_srvsvc_NetSessEnum: %d\n", __LINE__));
1253 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1254 p->server_info->ptok)) {
1255 DEBUG(1, ("Enumerating sessions only allowed for "
1256 "administrators\n"));
1257 return WERR_ACCESS_DENIED;
1260 switch (r->in.info_ctr->level) {
1262 werr = init_srv_sess_info_0(p,
1263 r->in.info_ctr->ctr.ctr0,
1264 r->in.resume_handle,
1265 r->out.totalentries);
1268 werr = init_srv_sess_info_1(p,
1269 r->in.info_ctr->ctr.ctr1,
1270 r->in.resume_handle,
1271 r->out.totalentries);
1274 return WERR_UNKNOWN_LEVEL;
1277 DEBUG(5,("_srvsvc_NetSessEnum: %d\n", __LINE__));
1282 /*******************************************************************
1284 ********************************************************************/
1286 WERROR _srvsvc_NetSessDel(struct pipes_struct *p,
1287 struct srvsvc_NetSessDel *r)
1289 struct sessionid *session_list;
1290 int num_sessions, snum;
1291 const char *username;
1292 const char *machine;
1293 bool not_root = False;
1296 username = r->in.user;
1297 machine = r->in.client;
1299 /* strip leading backslashes if any */
1300 if (machine && machine[0] == '\\' && machine[1] == '\\') {
1304 num_sessions = list_sessions(p->mem_ctx, &session_list);
1306 DEBUG(5,("_srvsvc_NetSessDel: %d\n", __LINE__));
1308 werr = WERR_ACCESS_DENIED;
1310 /* fail out now if you are not root or not a domain admin */
1312 if ((p->server_info->utok.uid != sec_initial_uid()) &&
1313 ( ! nt_token_check_domain_rid(p->server_info->ptok,
1314 DOMAIN_RID_ADMINS))) {
1319 for (snum = 0; snum < num_sessions; snum++) {
1321 if ((strequal(session_list[snum].username, username) || username[0] == '\0' ) &&
1322 strequal(session_list[snum].remote_machine, machine)) {
1326 if (p->server_info->utok.uid != sec_initial_uid()) {
1331 ntstat = messaging_send(p->msg_ctx,
1332 session_list[snum].pid,
1333 MSG_SHUTDOWN, &data_blob_null);
1335 if (NT_STATUS_IS_OK(ntstat))
1343 DEBUG(5,("_srvsvc_NetSessDel: %d\n", __LINE__));
1350 /*******************************************************************
1351 _srvsvc_NetShareEnumAll
1352 ********************************************************************/
1354 WERROR _srvsvc_NetShareEnumAll(struct pipes_struct *p,
1355 struct srvsvc_NetShareEnumAll *r)
1359 DEBUG(5,("_srvsvc_NetShareEnumAll: %d\n", __LINE__));
1361 if (!pipe_access_check(p)) {
1362 DEBUG(3, ("access denied to _srvsvc_NetShareEnumAll\n"));
1363 return WERR_ACCESS_DENIED;
1366 /* Create the list of shares for the response. */
1367 werr = init_srv_share_info_ctr(p,
1369 r->in.resume_handle,
1370 r->out.totalentries,
1373 DEBUG(5,("_srvsvc_NetShareEnumAll: %d\n", __LINE__));
1378 /*******************************************************************
1379 _srvsvc_NetShareEnum
1380 ********************************************************************/
1382 WERROR _srvsvc_NetShareEnum(struct pipes_struct *p,
1383 struct srvsvc_NetShareEnum *r)
1387 DEBUG(5,("_srvsvc_NetShareEnum: %d\n", __LINE__));
1389 if (!pipe_access_check(p)) {
1390 DEBUG(3, ("access denied to _srvsvc_NetShareEnum\n"));
1391 return WERR_ACCESS_DENIED;
1394 /* Create the list of shares for the response. */
1395 werr = init_srv_share_info_ctr(p,
1397 r->in.resume_handle,
1398 r->out.totalentries,
1401 DEBUG(5,("_srvsvc_NetShareEnum: %d\n", __LINE__));
1406 /*******************************************************************
1407 _srvsvc_NetShareGetInfo
1408 ********************************************************************/
1410 WERROR _srvsvc_NetShareGetInfo(struct pipes_struct *p,
1411 struct srvsvc_NetShareGetInfo *r)
1413 WERROR status = WERR_OK;
1416 union srvsvc_NetShareInfo *info = r->out.info;
1418 DEBUG(5,("_srvsvc_NetShareGetInfo: %d\n", __LINE__));
1420 fstrcpy(share_name, r->in.share_name);
1422 snum = find_service(share_name);
1424 return WERR_INVALID_NAME;
1427 switch (r->in.level) {
1429 info->info0 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo0);
1430 W_ERROR_HAVE_NO_MEMORY(info->info0);
1431 init_srv_share_info_0(p, info->info0, snum);
1434 info->info1 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo1);
1435 W_ERROR_HAVE_NO_MEMORY(info->info1);
1436 init_srv_share_info_1(p, info->info1, snum);
1439 info->info2 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo2);
1440 W_ERROR_HAVE_NO_MEMORY(info->info2);
1441 init_srv_share_info_2(p, info->info2, snum);
1444 info->info501 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo501);
1445 W_ERROR_HAVE_NO_MEMORY(info->info501);
1446 init_srv_share_info_501(p, info->info501, snum);
1449 info->info502 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo502);
1450 W_ERROR_HAVE_NO_MEMORY(info->info502);
1451 init_srv_share_info_502(p, info->info502, snum);
1454 info->info1004 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo1004);
1455 W_ERROR_HAVE_NO_MEMORY(info->info1004);
1456 init_srv_share_info_1004(p, info->info1004, snum);
1459 info->info1005 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo1005);
1460 W_ERROR_HAVE_NO_MEMORY(info->info1005);
1461 init_srv_share_info_1005(p, info->info1005, snum);
1464 info->info1006 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo1006);
1465 W_ERROR_HAVE_NO_MEMORY(info->info1006);
1466 init_srv_share_info_1006(p, info->info1006, snum);
1469 info->info1007 = TALLOC_P(p->mem_ctx, struct srvsvc_NetShareInfo1007);
1470 W_ERROR_HAVE_NO_MEMORY(info->info1007);
1471 init_srv_share_info_1007(p, info->info1007, snum);
1474 init_srv_share_info_1501(p, info->info1501, snum);
1477 DEBUG(5,("_srvsvc_NetShareGetInfo: unsupported switch value %d\n",
1479 status = WERR_UNKNOWN_LEVEL;
1483 DEBUG(5,("_srvsvc_NetShareGetInfo: %d\n", __LINE__));
1488 /*******************************************************************
1489 Check a given DOS pathname is valid for a share.
1490 ********************************************************************/
1492 char *valid_share_pathname(TALLOC_CTX *ctx, const char *dos_pathname)
1496 if (!dos_pathname) {
1500 ptr = talloc_strdup(ctx, dos_pathname);
1504 /* Convert any '\' paths to '/' */
1506 ptr = unix_clean_name(ctx, ptr);
1511 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
1512 if (strlen(ptr) > 2 && ptr[1] == ':' && ptr[0] != '/')
1515 /* Only absolute paths allowed. */
1522 /*******************************************************************
1523 _srvsvc_NetShareSetInfo. Modify share details.
1524 ********************************************************************/
1526 WERROR _srvsvc_NetShareSetInfo(struct pipes_struct *p,
1527 struct srvsvc_NetShareSetInfo *r)
1529 char *command = NULL;
1530 char *share_name = NULL;
1531 char *comment = NULL;
1532 const char *pathname = NULL;
1537 struct security_descriptor *psd = NULL;
1538 bool is_disk_op = False;
1539 int max_connections = 0;
1540 TALLOC_CTX *ctx = p->mem_ctx;
1541 union srvsvc_NetShareInfo *info = r->in.info;
1543 DEBUG(5,("_srvsvc_NetShareSetInfo: %d\n", __LINE__));
1545 share_name = talloc_strdup(p->mem_ctx, r->in.share_name);
1550 if (r->out.parm_error) {
1551 *r->out.parm_error = 0;
1554 if ( strequal(share_name,"IPC$")
1555 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1556 || strequal(share_name,"global") )
1558 DEBUG(5,("_srvsvc_NetShareSetInfo: share %s cannot be "
1559 "modified by a remote user.\n",
1561 return WERR_ACCESS_DENIED;
1564 snum = find_service(share_name);
1566 /* Does this share exist ? */
1568 return WERR_NET_NAME_NOT_FOUND;
1570 /* No change to printer shares. */
1571 if (lp_print_ok(snum))
1572 return WERR_ACCESS_DENIED;
1574 is_disk_op = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_DISK_OPERATOR);
1576 /* fail out now if you are not root and not a disk op */
1578 if ( p->server_info->utok.uid != sec_initial_uid() && !is_disk_op ) {
1579 DEBUG(2,("_srvsvc_NetShareSetInfo: uid %u doesn't have the "
1580 "SeDiskOperatorPrivilege privilege needed to modify "
1582 (unsigned int)p->server_info->utok.uid,
1584 return WERR_ACCESS_DENIED;
1587 switch (r->in.level) {
1589 pathname = talloc_strdup(ctx, lp_pathname(snum));
1590 comment = talloc_strdup(ctx, info->info1->comment);
1591 type = info->info1->type;
1595 comment = talloc_strdup(ctx, info->info2->comment);
1596 pathname = info->info2->path;
1597 type = info->info2->type;
1598 max_connections = (info->info2->max_users == (uint32_t)-1) ?
1599 0 : info->info2->max_users;
1603 /* not supported on set but here for completeness */
1605 comment = talloc_strdup(ctx, info->info501->comment);
1606 type = info->info501->type;
1611 comment = talloc_strdup(ctx, info->info502->comment);
1612 pathname = info->info502->path;
1613 type = info->info502->type;
1614 psd = info->info502->sd_buf.sd;
1615 map_generic_share_sd_bits(psd);
1618 pathname = talloc_strdup(ctx, lp_pathname(snum));
1619 comment = talloc_strdup(ctx, info->info1004->comment);
1620 type = STYPE_DISKTREE;
1623 /* XP re-sets the csc policy even if it wasn't changed by the
1624 user, so we must compare it to see if it's what is set in
1625 smb.conf, so that we can contine other ops like setting
1627 if (((info->info1005->dfs_flags &
1628 SHARE_1005_CSC_POLICY_MASK) >>
1629 SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
1632 DEBUG(3, ("_srvsvc_NetShareSetInfo: client is trying to change csc policy from the network; must be done with smb.conf\n"));
1633 return WERR_ACCESS_DENIED;
1637 return WERR_ACCESS_DENIED;
1639 pathname = talloc_strdup(ctx, lp_pathname(snum));
1640 comment = talloc_strdup(ctx, lp_comment(snum));
1641 psd = info->info1501->sd;
1642 map_generic_share_sd_bits(psd);
1643 type = STYPE_DISKTREE;
1646 DEBUG(5,("_srvsvc_NetShareSetInfo: unsupported switch value %d\n",
1648 return WERR_UNKNOWN_LEVEL;
1651 /* We can only modify disk shares. */
1652 if (type != STYPE_DISKTREE) {
1653 DEBUG(5,("_srvsvc_NetShareSetInfo: share %s is not a "
1656 return WERR_ACCESS_DENIED;
1659 if (comment == NULL) {
1663 /* Check if the pathname is valid. */
1664 if (!(path = valid_share_pathname(p->mem_ctx, pathname ))) {
1665 DEBUG(5,("_srvsvc_NetShareSetInfo: invalid pathname %s\n",
1667 return WERR_OBJECT_PATH_INVALID;
1670 /* Ensure share name, pathname and comment don't contain '"' characters. */
1671 string_replace(share_name, '"', ' ');
1672 string_replace(path, '"', ' ');
1673 string_replace(comment, '"', ' ');
1675 DEBUG(10,("_srvsvc_NetShareSetInfo: change share command = %s\n",
1676 lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
1678 /* Only call modify function if something changed. */
1680 if (strcmp(path, lp_pathname(snum)) || strcmp(comment, lp_comment(snum))
1681 || (lp_max_connections(snum) != max_connections)) {
1682 if (!lp_change_share_cmd() || !*lp_change_share_cmd()) {
1683 DEBUG(10,("_srvsvc_NetShareSetInfo: No change share command\n"));
1684 return WERR_ACCESS_DENIED;
1687 command = talloc_asprintf(p->mem_ctx,
1688 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1689 lp_change_share_cmd(),
1690 get_dyn_CONFIGFILE(),
1693 comment ? comment : "",
1699 DEBUG(10,("_srvsvc_NetShareSetInfo: Running [%s]\n", command ));
1701 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1706 if ( (ret = smbrun(command, NULL)) == 0 ) {
1707 /* Tell everyone we updated smb.conf. */
1708 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED,
1715 /********* END SeDiskOperatorPrivilege BLOCK *********/
1717 DEBUG(3,("_srvsvc_NetShareSetInfo: Running [%s] returned (%d)\n",
1720 TALLOC_FREE(command);
1723 return WERR_ACCESS_DENIED;
1725 DEBUG(10,("_srvsvc_NetShareSetInfo: No change to share name (%s)\n",
1729 /* Replace SD if changed. */
1731 struct security_descriptor *old_sd;
1734 old_sd = get_share_security(p->mem_ctx, lp_servicename(snum), &sd_size);
1736 if (old_sd && !security_descriptor_equal(old_sd, psd)) {
1737 if (!set_share_security(share_name, psd))
1738 DEBUG(0,("_srvsvc_NetShareSetInfo: Failed to change security info in share %s.\n",
1743 DEBUG(5,("_srvsvc_NetShareSetInfo: %d\n", __LINE__));
1748 /*******************************************************************
1749 _srvsvc_NetShareAdd.
1750 Call 'add_share_command "sharename" "pathname"
1751 "comment" "max connections = "
1752 ********************************************************************/
1754 WERROR _srvsvc_NetShareAdd(struct pipes_struct *p,
1755 struct srvsvc_NetShareAdd *r)
1757 char *command = NULL;
1758 char *share_name = NULL;
1759 char *comment = NULL;
1760 char *pathname = NULL;
1765 struct security_descriptor *psd = NULL;
1767 int max_connections = 0;
1768 TALLOC_CTX *ctx = p->mem_ctx;
1770 DEBUG(5,("_srvsvc_NetShareAdd: %d\n", __LINE__));
1772 if (r->out.parm_error) {
1773 *r->out.parm_error = 0;
1776 is_disk_op = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_DISK_OPERATOR);
1778 if (p->server_info->utok.uid != sec_initial_uid() && !is_disk_op )
1779 return WERR_ACCESS_DENIED;
1781 if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
1782 DEBUG(10,("_srvsvc_NetShareAdd: No add share command\n"));
1783 return WERR_ACCESS_DENIED;
1786 switch (r->in.level) {
1788 /* No path. Not enough info in a level 0 to do anything. */
1789 return WERR_ACCESS_DENIED;
1791 /* Not enough info in a level 1 to do anything. */
1792 return WERR_ACCESS_DENIED;
1794 share_name = talloc_strdup(ctx, r->in.info->info2->name);
1795 comment = talloc_strdup(ctx, r->in.info->info2->comment);
1796 pathname = talloc_strdup(ctx, r->in.info->info2->path);
1797 max_connections = (r->in.info->info2->max_users == (uint32_t)-1) ?
1798 0 : r->in.info->info2->max_users;
1799 type = r->in.info->info2->type;
1802 /* No path. Not enough info in a level 501 to do anything. */
1803 return WERR_ACCESS_DENIED;
1805 share_name = talloc_strdup(ctx, r->in.info->info502->name);
1806 comment = talloc_strdup(ctx, r->in.info->info502->comment);
1807 pathname = talloc_strdup(ctx, r->in.info->info502->path);
1808 max_connections = (r->in.info->info502->max_users == (uint32_t)-1) ?
1809 0 : r->in.info->info502->max_users;
1810 type = r->in.info->info502->type;
1811 psd = r->in.info->info502->sd_buf.sd;
1812 map_generic_share_sd_bits(psd);
1815 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
1821 return WERR_ACCESS_DENIED;
1823 /* DFS only level. */
1824 return WERR_ACCESS_DENIED;
1826 DEBUG(5,("_srvsvc_NetShareAdd: unsupported switch value %d\n",
1828 return WERR_UNKNOWN_LEVEL;
1831 /* check for invalid share names */
1833 if (!share_name || !validate_net_name(share_name,
1834 INVALID_SHARENAME_CHARS,
1835 strlen(share_name))) {
1836 DEBUG(5,("_srvsvc_NetShareAdd: Bad sharename \"%s\"\n",
1837 share_name ? share_name : ""));
1838 return WERR_INVALID_NAME;
1841 if (strequal(share_name,"IPC$") || strequal(share_name,"global")
1842 || (lp_enable_asu_support() &&
1843 strequal(share_name,"ADMIN$"))) {
1844 return WERR_ACCESS_DENIED;
1847 snum = find_service(share_name);
1849 /* Share already exists. */
1851 return WERR_FILE_EXISTS;
1854 /* We can only add disk shares. */
1855 if (type != STYPE_DISKTREE) {
1856 return WERR_ACCESS_DENIED;
1859 /* Check if the pathname is valid. */
1860 if (!(path = valid_share_pathname(p->mem_ctx, pathname))) {
1861 return WERR_OBJECT_PATH_INVALID;
1864 /* Ensure share name, pathname and comment don't contain '"' characters. */
1865 string_replace(share_name, '"', ' ');
1866 string_replace(path, '"', ' ');
1868 string_replace(comment, '"', ' ');
1871 command = talloc_asprintf(ctx,
1872 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1874 get_dyn_CONFIGFILE(),
1877 comment ? comment : "",
1883 DEBUG(10,("_srvsvc_NetShareAdd: Running [%s]\n", command ));
1885 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1890 /* FIXME: use libnetconf here - gd */
1892 if ( (ret = smbrun(command, NULL)) == 0 ) {
1893 /* Tell everyone we updated smb.conf. */
1894 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0,
1901 /********* END SeDiskOperatorPrivilege BLOCK *********/
1903 DEBUG(3,("_srvsvc_NetShareAdd: Running [%s] returned (%d)\n",
1906 TALLOC_FREE(command);
1909 return WERR_ACCESS_DENIED;
1912 if (!set_share_security(share_name, psd)) {
1913 DEBUG(0,("_srvsvc_NetShareAdd: Failed to add security info to share %s.\n",
1919 * We don't call reload_services() here, the message will
1920 * cause this to be done before the next packet is read
1921 * from the client. JRA.
1924 DEBUG(5,("_srvsvc_NetShareAdd: %d\n", __LINE__));
1929 /*******************************************************************
1931 Call "delete share command" with the share name as
1933 ********************************************************************/
1935 WERROR _srvsvc_NetShareDel(struct pipes_struct *p,
1936 struct srvsvc_NetShareDel *r)
1938 char *command = NULL;
1939 char *share_name = NULL;
1943 struct share_params *params;
1944 TALLOC_CTX *ctx = p->mem_ctx;
1946 DEBUG(5,("_srvsvc_NetShareDel: %d\n", __LINE__));
1948 share_name = talloc_strdup(p->mem_ctx, r->in.share_name);
1950 return WERR_NET_NAME_NOT_FOUND;
1952 if ( strequal(share_name,"IPC$")
1953 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1954 || strequal(share_name,"global") )
1956 return WERR_ACCESS_DENIED;
1959 if (!(params = get_share_params(p->mem_ctx, share_name))) {
1960 return WERR_NO_SUCH_SHARE;
1963 snum = find_service(share_name);
1965 /* No change to printer shares. */
1966 if (lp_print_ok(snum))
1967 return WERR_ACCESS_DENIED;
1969 is_disk_op = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_DISK_OPERATOR);
1971 if (p->server_info->utok.uid != sec_initial_uid() && !is_disk_op )
1972 return WERR_ACCESS_DENIED;
1974 if (!lp_delete_share_cmd() || !*lp_delete_share_cmd()) {
1975 DEBUG(10,("_srvsvc_NetShareDel: No delete share command\n"));
1976 return WERR_ACCESS_DENIED;
1979 command = talloc_asprintf(ctx,
1981 lp_delete_share_cmd(),
1982 get_dyn_CONFIGFILE(),
1983 lp_servicename(snum));
1988 DEBUG(10,("_srvsvc_NetShareDel: Running [%s]\n", command ));
1990 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1995 if ( (ret = smbrun(command, NULL)) == 0 ) {
1996 /* Tell everyone we updated smb.conf. */
1997 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0,
2004 /********* END SeDiskOperatorPrivilege BLOCK *********/
2006 DEBUG(3,("_srvsvc_NetShareDel: Running [%s] returned (%d)\n", command, ret ));
2009 return WERR_ACCESS_DENIED;
2011 /* Delete the SD in the database. */
2012 delete_share_security(lp_servicename(params->service));
2014 lp_killservice(params->service);
2019 /*******************************************************************
2020 _srvsvc_NetShareDelSticky
2021 ********************************************************************/
2023 WERROR _srvsvc_NetShareDelSticky(struct pipes_struct *p,
2024 struct srvsvc_NetShareDelSticky *r)
2026 struct srvsvc_NetShareDel q;
2028 DEBUG(5,("_srvsvc_NetShareDelSticky: %d\n", __LINE__));
2030 q.in.server_unc = r->in.server_unc;
2031 q.in.share_name = r->in.share_name;
2032 q.in.reserved = r->in.reserved;
2034 return _srvsvc_NetShareDel(p, &q);
2037 /*******************************************************************
2038 _srvsvc_NetRemoteTOD
2039 ********************************************************************/
2041 WERROR _srvsvc_NetRemoteTOD(struct pipes_struct *p,
2042 struct srvsvc_NetRemoteTOD *r)
2044 struct srvsvc_NetRemoteTODInfo *tod;
2046 time_t unixdate = time(NULL);
2048 /* We do this call first as if we do it *after* the gmtime call
2049 it overwrites the pointed-to values. JRA */
2051 uint32 zone = get_time_zone(unixdate)/60;
2053 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2055 if ( !(tod = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetRemoteTODInfo)) )
2060 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2062 t = gmtime(&unixdate);
2065 tod->elapsed = unixdate;
2067 tod->hours = t->tm_hour;
2068 tod->mins = t->tm_min;
2069 tod->secs = t->tm_sec;
2071 tod->timezone = zone;
2072 tod->tinterval = 10000;
2073 tod->day = t->tm_mday;
2074 tod->month = t->tm_mon + 1;
2075 tod->year = 1900+t->tm_year;
2076 tod->weekday = t->tm_wday;
2078 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2083 /***********************************************************************************
2084 _srvsvc_NetGetFileSecurity
2085 Win9x NT tools get security descriptor.
2086 ***********************************************************************************/
2088 WERROR _srvsvc_NetGetFileSecurity(struct pipes_struct *p,
2089 struct srvsvc_NetGetFileSecurity *r)
2091 struct smb_filename *smb_fname = NULL;
2092 struct security_descriptor *psd = NULL;
2094 fstring servicename;
2098 connection_struct *conn = NULL;
2099 struct sec_desc_buf *sd_buf = NULL;
2100 files_struct *fsp = NULL;
2102 char *oldcwd = NULL;
2106 fstrcpy(servicename, r->in.share);
2108 snum = find_service(servicename);
2110 DEBUG(10, ("Could not find service %s\n", servicename));
2111 werr = WERR_NET_NAME_NOT_FOUND;
2115 nt_status = create_conn_struct(talloc_tos(), &conn, snum,
2116 lp_pathname(snum), p->server_info,
2118 if (!NT_STATUS_IS_OK(nt_status)) {
2119 DEBUG(10, ("create_conn_struct failed: %s\n",
2120 nt_errstr(nt_status)));
2121 werr = ntstatus_to_werror(nt_status);
2125 nt_status = filename_convert(talloc_tos(),
2132 if (!NT_STATUS_IS_OK(nt_status)) {
2133 werr = ntstatus_to_werror(nt_status);
2137 nt_status = SMB_VFS_CREATE_FILE(
2140 0, /* root_dir_fid */
2141 smb_fname, /* fname */
2142 FILE_READ_ATTRIBUTES, /* access_mask */
2143 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
2144 FILE_OPEN, /* create_disposition*/
2145 0, /* create_options */
2146 0, /* file_attributes */
2147 INTERNAL_OPEN_ONLY, /* oplock_request */
2148 0, /* allocation_size */
2149 0, /* private_flags */
2155 if (!NT_STATUS_IS_OK(nt_status)) {
2156 DEBUG(3,("_srvsvc_NetGetFileSecurity: can't open %s\n",
2157 smb_fname_str_dbg(smb_fname)));
2158 werr = ntstatus_to_werror(nt_status);
2162 nt_status = SMB_VFS_FGET_NT_ACL(fsp,
2165 |SECINFO_DACL), &psd);
2167 if (!NT_STATUS_IS_OK(nt_status)) {
2168 DEBUG(3,("_srvsvc_NetGetFileSecurity: Unable to get NT ACL "
2169 "for file %s\n", smb_fname_str_dbg(smb_fname)));
2170 werr = ntstatus_to_werror(nt_status);
2174 sd_size = ndr_size_security_descriptor(psd, 0);
2176 sd_buf = TALLOC_ZERO_P(p->mem_ctx, struct sec_desc_buf);
2182 sd_buf->sd_size = sd_size;
2185 *r->out.sd_buf = sd_buf;
2187 psd->dacl->revision = NT4_ACL_REVISION;
2189 close_file(NULL, fsp, NORMAL_CLOSE);
2190 vfs_ChDir(conn, oldcwd);
2198 close_file(NULL, fsp, NORMAL_CLOSE);
2202 vfs_ChDir(conn, oldcwd);
2210 TALLOC_FREE(smb_fname);
2215 /***********************************************************************************
2216 _srvsvc_NetSetFileSecurity
2217 Win9x NT tools set security descriptor.
2218 ***********************************************************************************/
2220 WERROR _srvsvc_NetSetFileSecurity(struct pipes_struct *p,
2221 struct srvsvc_NetSetFileSecurity *r)
2223 struct smb_filename *smb_fname = NULL;
2224 fstring servicename;
2225 files_struct *fsp = NULL;
2229 connection_struct *conn = NULL;
2231 char *oldcwd = NULL;
2232 struct security_descriptor *psd = NULL;
2233 uint32_t security_info_sent = 0;
2237 fstrcpy(servicename, r->in.share);
2239 snum = find_service(servicename);
2241 DEBUG(10, ("Could not find service %s\n", servicename));
2242 werr = WERR_NET_NAME_NOT_FOUND;
2246 nt_status = create_conn_struct(talloc_tos(), &conn, snum,
2247 lp_pathname(snum), p->server_info,
2249 if (!NT_STATUS_IS_OK(nt_status)) {
2250 DEBUG(10, ("create_conn_struct failed: %s\n",
2251 nt_errstr(nt_status)));
2252 werr = ntstatus_to_werror(nt_status);
2256 nt_status = filename_convert(talloc_tos(),
2263 if (!NT_STATUS_IS_OK(nt_status)) {
2264 werr = ntstatus_to_werror(nt_status);
2268 nt_status = SMB_VFS_CREATE_FILE(
2271 0, /* root_dir_fid */
2272 smb_fname, /* fname */
2273 FILE_WRITE_ATTRIBUTES, /* access_mask */
2274 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
2275 FILE_OPEN, /* create_disposition*/
2276 0, /* create_options */
2277 0, /* file_attributes */
2278 INTERNAL_OPEN_ONLY, /* oplock_request */
2279 0, /* allocation_size */
2280 0, /* private_flags */
2286 if (!NT_STATUS_IS_OK(nt_status)) {
2287 DEBUG(3,("_srvsvc_NetSetFileSecurity: can't open %s\n",
2288 smb_fname_str_dbg(smb_fname)));
2289 werr = ntstatus_to_werror(nt_status);
2293 psd = r->in.sd_buf->sd;
2294 security_info_sent = r->in.securityinformation;
2296 if (psd->owner_sid==0) {
2297 security_info_sent &= ~SECINFO_OWNER;
2299 if (psd->group_sid==0) {
2300 security_info_sent &= ~SECINFO_GROUP;
2303 security_info_sent &= ~SECINFO_SACL;
2306 security_info_sent &= ~SECINFO_DACL;
2309 /* Convert all the generic bits. */
2310 security_acl_map_generic(psd->dacl, &file_generic_mapping);
2311 security_acl_map_generic(psd->sacl, &file_generic_mapping);
2313 nt_status = SMB_VFS_FSET_NT_ACL(fsp,
2317 if (!NT_STATUS_IS_OK(nt_status) ) {
2318 DEBUG(3,("_srvsvc_NetSetFileSecurity: Unable to set NT ACL "
2319 "on file %s\n", r->in.share));
2320 werr = WERR_ACCESS_DENIED;
2324 close_file(NULL, fsp, NORMAL_CLOSE);
2325 vfs_ChDir(conn, oldcwd);
2333 close_file(NULL, fsp, NORMAL_CLOSE);
2337 vfs_ChDir(conn, oldcwd);
2345 TALLOC_FREE(smb_fname);
2350 /***********************************************************************************
2351 It may be that we want to limit users to creating shares on certain areas of the UNIX file area.
2352 We could define areas by mapping Windows style disks to points on the UNIX directory hierarchy.
2353 These disks would the disks listed by this function.
2354 Users could then create shares relative to these disks. Watch out for moving these disks around.
2355 "Nigel Williams" <nigel@veritas.com>.
2356 ***********************************************************************************/
2358 static const char *server_disks[] = {"C:"};
2360 static uint32 get_server_disk_count(void)
2362 return sizeof(server_disks)/sizeof(server_disks[0]);
2365 static uint32 init_server_disk_enum(uint32 *resume)
2367 uint32 server_disk_count = get_server_disk_count();
2369 /*resume can be an offset into the list for now*/
2371 if(*resume & 0x80000000)
2374 if(*resume > server_disk_count)
2375 *resume = server_disk_count;
2377 return server_disk_count - *resume;
2380 static const char *next_server_disk_enum(uint32 *resume)
2384 if(init_server_disk_enum(resume) == 0)
2387 disk = server_disks[*resume];
2391 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2396 /********************************************************************
2398 ********************************************************************/
2400 WERROR _srvsvc_NetDiskEnum(struct pipes_struct *p,
2401 struct srvsvc_NetDiskEnum *r)
2404 const char *disk_name;
2405 TALLOC_CTX *ctx = p->mem_ctx;
2407 uint32_t resume = r->in.resume_handle ? *r->in.resume_handle : 0;
2411 *r->out.totalentries = init_server_disk_enum(&resume);
2413 r->out.info->disks = TALLOC_ZERO_ARRAY(ctx, struct srvsvc_NetDiskInfo0,
2414 MAX_SERVER_DISK_ENTRIES);
2415 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks);
2417 /*allow one struct srvsvc_NetDiskInfo0 for null terminator*/
2419 r->out.info->count = 0;
2421 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2423 r->out.info->count++;
2425 /*copy disk name into a unicode string*/
2427 r->out.info->disks[i].disk = talloc_strdup(ctx, disk_name);
2428 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[i].disk);
2431 /* add a terminating null string. Is this there if there is more data to come? */
2433 r->out.info->count++;
2435 r->out.info->disks[i].disk = talloc_strdup(ctx, "");
2436 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[i].disk);
2438 if (r->out.resume_handle) {
2439 *r->out.resume_handle = resume;
2445 /********************************************************************
2446 _srvsvc_NetNameValidate
2447 ********************************************************************/
2449 WERROR _srvsvc_NetNameValidate(struct pipes_struct *p,
2450 struct srvsvc_NetNameValidate *r)
2452 switch (r->in.name_type) {
2454 if (!validate_net_name(r->in.name, INVALID_SHARENAME_CHARS,
2455 strlen_m(r->in.name)))
2457 DEBUG(5,("_srvsvc_NetNameValidate: Bad sharename \"%s\"\n",
2459 return WERR_INVALID_NAME;
2464 return WERR_UNKNOWN_LEVEL;
2470 /*******************************************************************
2471 ********************************************************************/
2473 struct enum_file_close_state {
2474 struct srvsvc_NetFileClose *r;
2475 struct messaging_context *msg_ctx;
2478 static void enum_file_close_fn( const struct share_mode_entry *e,
2479 const char *sharepath, const char *fname,
2480 void *private_data )
2482 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
2483 struct enum_file_close_state *state =
2484 (struct enum_file_close_state *)private_data;
2485 uint32_t fid = (((uint32_t)(procid_to_pid(&e->pid))<<16) | e->share_file_id);
2487 if (fid != state->r->in.fid) {
2488 return; /* Not this file. */
2491 if (!process_exists(e->pid) ) {
2495 /* Ok - send the close message. */
2496 DEBUG(10,("enum_file_close_fn: request to close file %s, %s\n",
2498 share_mode_str(talloc_tos(), 0, e) ));
2500 share_mode_entry_to_message(msg, e);
2502 state->r->out.result = ntstatus_to_werror(
2503 messaging_send_buf(state->msg_ctx,
2504 e->pid, MSG_SMB_CLOSE_FILE,
2506 MSG_SMB_SHARE_MODE_ENTRY_SIZE));
2509 /********************************************************************
2510 Close a file given a 32-bit file id.
2511 ********************************************************************/
2513 WERROR _srvsvc_NetFileClose(struct pipes_struct *p,
2514 struct srvsvc_NetFileClose *r)
2516 struct enum_file_close_state state;
2519 DEBUG(5,("_srvsvc_NetFileClose: %d\n", __LINE__));
2521 is_disk_op = security_token_has_privilege(p->server_info->ptok, SEC_PRIV_DISK_OPERATOR);
2523 if (p->server_info->utok.uid != sec_initial_uid() && !is_disk_op) {
2524 return WERR_ACCESS_DENIED;
2527 /* enum_file_close_fn sends the close message to
2528 * the relevent smbd process. */
2530 r->out.result = WERR_BADFILE;
2532 state.msg_ctx = p->msg_ctx;
2533 share_mode_forall(enum_file_close_fn, &state);
2534 return r->out.result;
2537 /********************************************************************
2538 ********************************************************************/
2540 WERROR _srvsvc_NetCharDevEnum(struct pipes_struct *p,
2541 struct srvsvc_NetCharDevEnum *r)
2543 p->rng_fault_state = True;
2544 return WERR_NOT_SUPPORTED;
2547 WERROR _srvsvc_NetCharDevGetInfo(struct pipes_struct *p,
2548 struct srvsvc_NetCharDevGetInfo *r)
2550 p->rng_fault_state = True;
2551 return WERR_NOT_SUPPORTED;
2554 WERROR _srvsvc_NetCharDevControl(struct pipes_struct *p,
2555 struct srvsvc_NetCharDevControl *r)
2557 p->rng_fault_state = True;
2558 return WERR_NOT_SUPPORTED;
2561 WERROR _srvsvc_NetCharDevQEnum(struct pipes_struct *p,
2562 struct srvsvc_NetCharDevQEnum *r)
2564 p->rng_fault_state = True;
2565 return WERR_NOT_SUPPORTED;
2568 WERROR _srvsvc_NetCharDevQGetInfo(struct pipes_struct *p,
2569 struct srvsvc_NetCharDevQGetInfo *r)
2571 p->rng_fault_state = True;
2572 return WERR_NOT_SUPPORTED;
2575 WERROR _srvsvc_NetCharDevQSetInfo(struct pipes_struct *p,
2576 struct srvsvc_NetCharDevQSetInfo *r)
2578 p->rng_fault_state = True;
2579 return WERR_NOT_SUPPORTED;
2582 WERROR _srvsvc_NetCharDevQPurge(struct pipes_struct *p,
2583 struct srvsvc_NetCharDevQPurge *r)
2585 p->rng_fault_state = True;
2586 return WERR_NOT_SUPPORTED;
2589 WERROR _srvsvc_NetCharDevQPurgeSelf(struct pipes_struct *p,
2590 struct srvsvc_NetCharDevQPurgeSelf *r)
2592 p->rng_fault_state = True;
2593 return WERR_NOT_SUPPORTED;
2596 WERROR _srvsvc_NetFileGetInfo(struct pipes_struct *p,
2597 struct srvsvc_NetFileGetInfo *r)
2599 p->rng_fault_state = True;
2600 return WERR_NOT_SUPPORTED;
2603 WERROR _srvsvc_NetShareCheck(struct pipes_struct *p,
2604 struct srvsvc_NetShareCheck *r)
2606 p->rng_fault_state = True;
2607 return WERR_NOT_SUPPORTED;
2610 WERROR _srvsvc_NetServerStatisticsGet(struct pipes_struct *p,
2611 struct srvsvc_NetServerStatisticsGet *r)
2613 p->rng_fault_state = True;
2614 return WERR_NOT_SUPPORTED;
2617 WERROR _srvsvc_NetTransportAdd(struct pipes_struct *p,
2618 struct srvsvc_NetTransportAdd *r)
2620 p->rng_fault_state = True;
2621 return WERR_NOT_SUPPORTED;
2624 WERROR _srvsvc_NetTransportEnum(struct pipes_struct *p,
2625 struct srvsvc_NetTransportEnum *r)
2627 p->rng_fault_state = True;
2628 return WERR_NOT_SUPPORTED;
2631 WERROR _srvsvc_NetTransportDel(struct pipes_struct *p,
2632 struct srvsvc_NetTransportDel *r)
2634 p->rng_fault_state = True;
2635 return WERR_NOT_SUPPORTED;
2638 WERROR _srvsvc_NetSetServiceBits(struct pipes_struct *p,
2639 struct srvsvc_NetSetServiceBits *r)
2641 p->rng_fault_state = True;
2642 return WERR_NOT_SUPPORTED;
2645 WERROR _srvsvc_NetPathType(struct pipes_struct *p,
2646 struct srvsvc_NetPathType *r)
2648 p->rng_fault_state = True;
2649 return WERR_NOT_SUPPORTED;
2652 WERROR _srvsvc_NetPathCanonicalize(struct pipes_struct *p,
2653 struct srvsvc_NetPathCanonicalize *r)
2655 p->rng_fault_state = True;
2656 return WERR_NOT_SUPPORTED;
2659 WERROR _srvsvc_NetPathCompare(struct pipes_struct *p,
2660 struct srvsvc_NetPathCompare *r)
2662 p->rng_fault_state = True;
2663 return WERR_NOT_SUPPORTED;
2666 WERROR _srvsvc_NETRPRNAMECANONICALIZE(struct pipes_struct *p,
2667 struct srvsvc_NETRPRNAMECANONICALIZE *r)
2669 p->rng_fault_state = True;
2670 return WERR_NOT_SUPPORTED;
2673 WERROR _srvsvc_NetPRNameCompare(struct pipes_struct *p,
2674 struct srvsvc_NetPRNameCompare *r)
2676 p->rng_fault_state = True;
2677 return WERR_NOT_SUPPORTED;
2680 WERROR _srvsvc_NetShareDelStart(struct pipes_struct *p,
2681 struct srvsvc_NetShareDelStart *r)
2683 p->rng_fault_state = True;
2684 return WERR_NOT_SUPPORTED;
2687 WERROR _srvsvc_NetShareDelCommit(struct pipes_struct *p,
2688 struct srvsvc_NetShareDelCommit *r)
2690 p->rng_fault_state = True;
2691 return WERR_NOT_SUPPORTED;
2694 WERROR _srvsvc_NetServerTransportAddEx(struct pipes_struct *p,
2695 struct srvsvc_NetServerTransportAddEx *r)
2697 p->rng_fault_state = True;
2698 return WERR_NOT_SUPPORTED;
2701 WERROR _srvsvc_NetServerSetServiceBitsEx(struct pipes_struct *p,
2702 struct srvsvc_NetServerSetServiceBitsEx *r)
2704 p->rng_fault_state = True;
2705 return WERR_NOT_SUPPORTED;
2708 WERROR _srvsvc_NETRDFSGETVERSION(struct pipes_struct *p,
2709 struct srvsvc_NETRDFSGETVERSION *r)
2711 p->rng_fault_state = True;
2712 return WERR_NOT_SUPPORTED;
2715 WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(struct pipes_struct *p,
2716 struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2718 p->rng_fault_state = True;
2719 return WERR_NOT_SUPPORTED;
2722 WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(struct pipes_struct *p,
2723 struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2725 p->rng_fault_state = True;
2726 return WERR_NOT_SUPPORTED;
2729 WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct pipes_struct *p,
2730 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2732 p->rng_fault_state = True;
2733 return WERR_NOT_SUPPORTED;
2736 WERROR _srvsvc_NETRDFSSETSERVERINFO(struct pipes_struct *p,
2737 struct srvsvc_NETRDFSSETSERVERINFO *r)
2739 p->rng_fault_state = True;
2740 return WERR_NOT_SUPPORTED;
2743 WERROR _srvsvc_NETRDFSCREATEEXITPOINT(struct pipes_struct *p,
2744 struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2746 p->rng_fault_state = True;
2747 return WERR_NOT_SUPPORTED;
2750 WERROR _srvsvc_NETRDFSDELETEEXITPOINT(struct pipes_struct *p,
2751 struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2753 p->rng_fault_state = True;
2754 return WERR_NOT_SUPPORTED;
2757 WERROR _srvsvc_NETRDFSMODIFYPREFIX(struct pipes_struct *p,
2758 struct srvsvc_NETRDFSMODIFYPREFIX *r)
2760 p->rng_fault_state = True;
2761 return WERR_NOT_SUPPORTED;
2764 WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(struct pipes_struct *p,
2765 struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2767 p->rng_fault_state = True;
2768 return WERR_NOT_SUPPORTED;
2771 WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct pipes_struct *p,
2772 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2774 p->rng_fault_state = True;
2775 return WERR_NOT_SUPPORTED;
2778 WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(struct pipes_struct *p,
2779 struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2781 p->rng_fault_state = True;
2782 return WERR_NOT_SUPPORTED;