?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: rpc_server/srvsvc: count open files in NetConnEnum
[Samba.git] / source3 / rpc_server / srvsvc / srv_srvsvc_nt.c
blob39d5e05bfec937a3f7caaea9634cda530fe22391
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 * Copyright (C) Guenther Deschner 2008.
9 *
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.
14 *
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.
19 *
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/>.
22 */
23
24 /* This is the implementation of the srvsvc pipe. */
25
26 #include "includes.h"
27 #include "system/passwd.h"
28 #include "ntdomain.h"
29 #include "../librpc/gen_ndr/srv_srvsvc.h"
30 #include "../libcli/security/security.h"
31 #include "../librpc/gen_ndr/ndr_security.h"
32 #include "../librpc/gen_ndr/open_files.h"
33 #include "dbwrap/dbwrap.h"
34 #include "session.h"
35 #include "../lib/util/util_pw.h"
36 #include "smbd/smbd.h"
37 #include "smbd/globals.h"
38 #include "auth.h"
39 #include "messages.h"
40 #include "lib/conn_tdb.h"
41
42 extern const struct generic_mapping file_generic_mapping;
43
44 #undef DBGC_CLASS
45 #define DBGC_CLASS DBGC_RPC_SRV
46
47 #define MAX_SERVER_DISK_ENTRIES 15
48
49 /* Use for enumerating connections, pipes, & files */
50
51 struct file_enum_count {
52 TALLOC_CTX *ctx;
53 const char *username;
54 struct srvsvc_NetFileCtr3 *ctr3;
55 };
56
57 struct sess_file_info {
58 struct srvsvc_NetSessCtr1 *ctr;
59 struct sessionid *session_list;
60 uint32_t resume_handle;
61 uint32_t num_entries;
62 };
63
64 struct share_file_stat {
65 struct srvsvc_NetConnInfo1 *netconn_arr;
66 struct server_id *svrid_arr;
67 const char *in_sharepath;
68 uint32_t resp_entries;
69 uint32_t total_entries;
70 };
71
72 struct share_conn_stat {
73 TALLOC_CTX *ctx;
74 const char *sharename;
75 struct server_id *svrid_arr;
76 int count;
77 };
78
79 /*******************************************************************
80 ********************************************************************/
81
82 static void enum_file_fn( const struct share_mode_entry *e,
83 const char *sharepath, const char *fname,
84 void *private_data )
85 {
86 struct file_enum_count *fenum =
87 (struct file_enum_count *)private_data;
88
89 struct srvsvc_NetFileInfo3 *f;
90 int i = fenum->ctr3->count;
91 files_struct fsp;
92 struct byte_range_lock *brl;
93 int num_locks = 0;
94 char *fullpath = NULL;
95 uint32 permissions;
96 const char *username;
97
98 /* If the pid was not found delete the entry from connections.tdb */
99
100 if ( !process_exists(e->pid) ) {
101 return;
102 }
103
104 username = uidtoname(e->uid);
105
106 if ((fenum->username != NULL)
107 && !strequal(username, fenum->username)) {
108 return;
109 }
110
111 f = talloc_realloc(fenum->ctx, fenum->ctr3->array,
112 struct srvsvc_NetFileInfo3, i+1);
113 if ( !f ) {
114 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
115 return;
116 }
117 fenum->ctr3->array = f;
118
119 /* need to count the number of locks on a file */
120
121 ZERO_STRUCT( fsp );
122 fsp.file_id = e->id;
123
124 if ( (brl = brl_get_locks(talloc_tos(), &fsp)) != NULL ) {
125 num_locks = brl_num_locks(brl);
126 TALLOC_FREE(brl);
127 }
128
129 if ( strcmp( fname, "." ) == 0 ) {
130 fullpath = talloc_asprintf(fenum->ctx, "C:%s", sharepath );
131 } else {
132 fullpath = talloc_asprintf(fenum->ctx, "C:%s/%s",
133 sharepath, fname );
134 }
135 if (!fullpath) {
136 return;
137 }
138 string_replace( fullpath, '/', '\\' );
139
140 /* mask out create (what ever that is) */
141 permissions = e->access_mask & (FILE_READ_DATA|FILE_WRITE_DATA);
142
143 /* now fill in the srvsvc_NetFileInfo3 struct */
144
145 fenum->ctr3->array[i].fid =
146 (((uint32_t)(procid_to_pid(&e->pid))<<16) | e->share_file_id);
147 fenum->ctr3->array[i].permissions = permissions;
148 fenum->ctr3->array[i].num_locks = num_locks;
149 fenum->ctr3->array[i].path = fullpath;
150 fenum->ctr3->array[i].user = username;
151
152 fenum->ctr3->count++;
153 }
154
155 /*******************************************************************
156 ********************************************************************/
157
158 static WERROR net_enum_files(TALLOC_CTX *ctx,
159 const char *username,
160 struct srvsvc_NetFileCtr3 **ctr3,
161 uint32_t resume)
162 {
163 struct file_enum_count f_enum_cnt;
164
165 f_enum_cnt.ctx = ctx;
166 f_enum_cnt.username = username;
167 f_enum_cnt.ctr3 = *ctr3;
168
169 share_mode_forall( enum_file_fn, (void *)&f_enum_cnt );
170
171 *ctr3 = f_enum_cnt.ctr3;
172
173 return WERR_OK;
174 }
175
176 /*******************************************************************
177 Utility function to get the 'type' of a share from an snum.
178 ********************************************************************/
179 static enum srvsvc_ShareType get_share_type(int snum)
180 {
181 /* work out the share type */
182 enum srvsvc_ShareType type = STYPE_DISKTREE;
183
184 if (lp_printable(snum)) {
185 type = lp_administrative_share(snum)
186 ? STYPE_PRINTQ_HIDDEN : STYPE_PRINTQ;
187 }
188 if (strequal(lp_fstype(snum), "IPC")) {
189 type = lp_administrative_share(snum)
190 ? STYPE_IPC_HIDDEN : STYPE_IPC;
191 }
192 return type;
193 }
194
195 /*******************************************************************
196 Fill in a share info level 0 structure.
197 ********************************************************************/
198
199 static void init_srv_share_info_0(struct pipes_struct *p,
200 struct srvsvc_NetShareInfo0 *r, int snum)
201 {
202 r->name = lp_servicename(talloc_tos(), snum);
203 }
204
205 /*******************************************************************
206 Fill in a share info level 1 structure.
207 ********************************************************************/
208
209 static void init_srv_share_info_1(struct pipes_struct *p,
210 struct srvsvc_NetShareInfo1 *r,
211 int snum)
212 {
213 char *net_name = lp_servicename(talloc_tos(), snum);
214 char *remark = lp_comment(p->mem_ctx, snum);
215
216 if (remark) {
217 remark = talloc_sub_advanced(
218 p->mem_ctx, lp_servicename(talloc_tos(), snum),
219 get_current_username(), lp_path(talloc_tos(), snum),
220 p->session_info->unix_token->uid, get_current_username(),
221 "", remark);
222 }
223
224 r->name = net_name;
225 r->type = get_share_type(snum);
226 r->comment = remark ? remark : "";
227 }
228
229 /*******************************************************************
230 Fill in a share info level 2 structure.
231 ********************************************************************/
232
233 static void init_srv_share_info_2(struct pipes_struct *p,
234 struct srvsvc_NetShareInfo2 *r,
235 int snum)
236 {
237 char *remark = NULL;
238 char *path = NULL;
239 int max_connections = lp_max_connections(snum);
240 uint32_t max_uses = max_connections!=0 ? max_connections : (uint32_t)-1;
241 char *net_name = lp_servicename(talloc_tos(), snum);
242
243 remark = lp_comment(p->mem_ctx, snum);
244 if (remark) {
245 remark = talloc_sub_advanced(
246 p->mem_ctx, lp_servicename(talloc_tos(), snum),
247 get_current_username(), lp_path(talloc_tos(), snum),
248 p->session_info->unix_token->uid, get_current_username(),
249 "", remark);
250 }
251 path = talloc_asprintf(p->mem_ctx,
252 "C:%s", lp_path(talloc_tos(), snum));
253
254 if (path) {
255 /*
256 * Change / to \\ so that win2k will see it as a valid path.
257 * This was added to enable use of browsing in win2k add
258 * share dialog.
259 */
260
261 string_replace(path, '/', '\\');
262 }
263
264 r->name = net_name;
265 r->type = get_share_type(snum);
266 r->comment = remark ? remark : "";
267 r->permissions = 0;
268 r->max_users = max_uses;
269 r->current_users = 0; /* computed later */
270 r->path = path ? path : "";
271 r->password = "";
272 }
273
274 /*******************************************************************
275 Map any generic bits to file specific bits.
276 ********************************************************************/
277
278 static void map_generic_share_sd_bits(struct security_descriptor *psd)
279 {
280 int i;
281 struct security_acl *ps_dacl = NULL;
282
283 if (!psd)
284 return;
285
286 ps_dacl = psd->dacl;
287 if (!ps_dacl)
288 return;
289
290 for (i = 0; i < ps_dacl->num_aces; i++) {
291 struct security_ace *psa = &ps_dacl->aces[i];
292 uint32 orig_mask = psa->access_mask;
293
294 se_map_generic(&psa->access_mask, &file_generic_mapping);
295 psa->access_mask |= orig_mask;
296 }
297 }
298
299 /*******************************************************************
300 Fill in a share info level 501 structure.
301 ********************************************************************/
302
303 static void init_srv_share_info_501(struct pipes_struct *p,
304 struct srvsvc_NetShareInfo501 *r, int snum)
305 {
306 const char *net_name = lp_servicename(talloc_tos(), snum);
307 char *remark = lp_comment(p->mem_ctx, snum);
308
309 if (remark) {
310 remark = talloc_sub_advanced(
311 p->mem_ctx, lp_servicename(talloc_tos(), snum),
312 get_current_username(), lp_path(talloc_tos(), snum),
313 p->session_info->unix_token->uid, get_current_username(),
314 "", remark);
315 }
316
317 r->name = net_name;
318 r->type = get_share_type(snum);
319 r->comment = remark ? remark : "";
320
321 /*
322 * According to [MS-SRVS] 2.2.4.25, the flags field is the same as in
323 * level 1005.
324 */
325 r->csc_policy = (lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT);
326 }
327
328 /*******************************************************************
329 Fill in a share info level 502 structure.
330 ********************************************************************/
331
332 static void init_srv_share_info_502(struct pipes_struct *p,
333 struct srvsvc_NetShareInfo502 *r, int snum)
334 {
335 const char *net_name = lp_servicename(talloc_tos(), snum);
336 char *path = NULL;
337 struct security_descriptor *sd = NULL;
338 struct sec_desc_buf *sd_buf = NULL;
339 size_t sd_size = 0;
340 TALLOC_CTX *ctx = p->mem_ctx;
341 char *remark = lp_comment(ctx, snum);
342
343 if (remark) {
344 remark = talloc_sub_advanced(
345 p->mem_ctx, lp_servicename(talloc_tos(), snum),
346 get_current_username(), lp_path(talloc_tos(), snum),
347 p->session_info->unix_token->uid, get_current_username(),
348 "", remark);
349 }
350 path = talloc_asprintf(ctx, "C:%s", lp_path(talloc_tos(), snum));
351 if (path) {
352 /*
353 * Change / to \\ so that win2k will see it as a valid path. This was added to
354 * enable use of browsing in win2k add share dialog.
355 */
356 string_replace(path, '/', '\\');
357 }
358
359 sd = get_share_security(ctx, lp_servicename(talloc_tos(), snum), &sd_size);
360
361 sd_buf = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
362
363 r->name = net_name;
364 r->type = get_share_type(snum);
365 r->comment = remark ? remark : "";
366 r->permissions = 0;
367 r->max_users = (uint32_t)-1;
368 r->current_users = 1; /* ??? */
369 r->path = path ? path : "";
370 r->password = "";
371 r->sd_buf = *sd_buf;
372 }
373
374 /***************************************************************************
375 Fill in a share info level 1004 structure.
376 ***************************************************************************/
377
378 static void init_srv_share_info_1004(struct pipes_struct *p,
379 struct srvsvc_NetShareInfo1004 *r,
380 int snum)
381 {
382 char *remark = lp_comment(p->mem_ctx, snum);
383
384 if (remark) {
385 remark = talloc_sub_advanced(
386 p->mem_ctx, lp_servicename(talloc_tos(), snum),
387 get_current_username(), lp_path(talloc_tos(), snum),
388 p->session_info->unix_token->uid, get_current_username(),
389 "", remark);
390 }
391
392 r->comment = remark ? remark : "";
393 }
394
395 /***************************************************************************
396 Fill in a share info level 1005 structure.
397 ***************************************************************************/
398
399 static void init_srv_share_info_1005(struct pipes_struct *p,
400 struct srvsvc_NetShareInfo1005 *r,
401 int snum)
402 {
403 uint32_t dfs_flags = 0;
404
405 if (lp_host_msdfs() && lp_msdfs_root(snum)) {
406 dfs_flags |= SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
407 }
408
409 dfs_flags |= lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
410
411 r->dfs_flags = dfs_flags;
412 }
413
414 /***************************************************************************
415 Fill in a share info level 1006 structure.
416 ***************************************************************************/
417
418 static void init_srv_share_info_1006(struct pipes_struct *p,
419 struct srvsvc_NetShareInfo1006 *r,
420 int snum)
421 {
422 r->max_users = (uint32_t)-1;
423 }
424
425 /***************************************************************************
426 Fill in a share info level 1007 structure.
427 ***************************************************************************/
428
429 static void init_srv_share_info_1007(struct pipes_struct *p,
430 struct srvsvc_NetShareInfo1007 *r,
431 int snum)
432 {
433 r->flags = 0;
434 r->alternate_directory_name = "";
435 }
436
437 /*******************************************************************
438 Fill in a share info level 1501 structure.
439 ********************************************************************/
440
441 static void init_srv_share_info_1501(struct pipes_struct *p,
442 struct sec_desc_buf **r,
443 int snum)
444 {
445 struct security_descriptor *sd;
446 struct sec_desc_buf *sd_buf = NULL;
447 size_t sd_size;
448 TALLOC_CTX *ctx = p->mem_ctx;
449
450 sd = get_share_security(ctx, lp_servicename(talloc_tos(), snum), &sd_size);
451 if (sd) {
452 sd_buf = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
453 }
454
455 *r = sd_buf;
456 }
457
458 /*******************************************************************
459 True if it ends in '$'.
460 ********************************************************************/
461
462 static bool is_hidden_share(int snum)
463 {
464 const char *net_name = lp_servicename(talloc_tos(), snum);
465
466 return (net_name[strlen(net_name) - 1] == '$') ? True : False;
467 }
468
469 /*******************************************************************
470 Verify user is allowed to view share, access based enumeration
471 ********************************************************************/
472 static bool is_enumeration_allowed(struct pipes_struct *p,
473 int snum)
474 {
475 if (!lp_access_based_share_enum(snum))
476 return true;
477
478 return share_access_check(p->session_info->security_token,
479 lp_servicename(talloc_tos(), snum),
480 FILE_READ_DATA, NULL);
481 }
482
483 /****************************************************************************
484 Count an entry against the respective service.
485 ****************************************************************************/
486
487 static int count_for_all_fn(struct smbXsrv_tcon_global0 *tcon, void *udp)
488 {
489 union srvsvc_NetShareCtr *ctr = NULL;
490 struct srvsvc_NetShareInfo2 *info2 = NULL;
491 int share_entries = 0;
492 int i = 0;
493
494 ctr = (union srvsvc_NetShareCtr *) udp;
495
496 /* for level 2 */
497 share_entries = ctr->ctr2->count;
498 info2 = &ctr->ctr2->array[0];
499
500 for (i = 0; i < share_entries; i++, info2++) {
501 if (strequal(tcon->share_name, info2->name)) {
502 info2->current_users++;
503 break;
504 }
505 }
506
507 return 0;
508 }
509
510 /****************************************************************************
511 Count the entries belonging to all services in the connection db.
512 ****************************************************************************/
513
514 static void count_connections_for_all_shares(union srvsvc_NetShareCtr *ctr)
515 {
516 NTSTATUS status;
517 status = smbXsrv_tcon_global_traverse(count_for_all_fn, ctr);
518
519 if (!NT_STATUS_IS_OK(status)) {
520 DEBUG(0,("count_connections_for_all_shares: traverse of "
521 "smbXsrv_tcon_global.tdb failed - %s\n",
522 nt_errstr(status)));
523 }
524 }
525
526 /*******************************************************************
527 Fill in a share info structure.
528 ********************************************************************/
529
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,
534 bool all_shares)
535 {
536 int num_entries = 0;
537 int alloc_entries = 0;
538 int num_services = 0;
539 int snum;
540 TALLOC_CTX *ctx = p->mem_ctx;
541 int i = 0;
542 int valid_share_count = 0;
543 bool *allowed = 0;
544 union srvsvc_NetShareCtr ctr;
545 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
546
547 DEBUG(5,("init_srv_share_info_ctr\n"));
548
549 /* Ensure all the usershares are loaded. */
550 become_root();
551 load_usershare_shares(NULL, connections_snum_used);
552 load_registry_shares();
553 num_services = lp_numservices();
554 unbecome_root();
555
556 allowed = talloc_zero_array(ctx, bool, num_services);
557 W_ERROR_HAVE_NO_MEMORY(allowed);
558
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(talloc_tos(), snum) ? lp_servicename(talloc_tos(), snum) : "(null)"));
566 allowed[snum] = true;
567 num_entries++;
568 } else {
569 DEBUG(10, ("NOT counting service %s\n",
570 lp_servicename(talloc_tos(), snum) ? lp_servicename(talloc_tos(), snum) : "(null)"));
571 }
572 }
573
574 if (!num_entries || (resume_handle >= num_entries)) {
575 return WERR_OK;
576 }
577
578 /* Calculate alloc entries. */
579 alloc_entries = num_entries - resume_handle;
580 switch (info_ctr->level) {
581 case 0:
582 ctr.ctr0 = talloc_zero(ctx, struct srvsvc_NetShareCtr0);
583 W_ERROR_HAVE_NO_MEMORY(ctr.ctr0);
584
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);
588
589 for (snum = 0; snum < num_services; snum++) {
590 if (allowed[snum] &&
591 (resume_handle <= (i + valid_share_count++)) ) {
592 init_srv_share_info_0(p, &ctr.ctr0->array[i++], snum);
593 }
594 }
595
596 break;
597
598 case 1:
599 ctr.ctr1 = talloc_zero(ctx, struct srvsvc_NetShareCtr1);
600 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1);
601
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);
605
606 for (snum = 0; snum < num_services; snum++) {
607 if (allowed[snum] &&
608 (resume_handle <= (i + valid_share_count++)) ) {
609 init_srv_share_info_1(p, &ctr.ctr1->array[i++], snum);
610 }
611 }
612
613 break;
614
615 case 2:
616 ctr.ctr2 = talloc_zero(ctx, struct srvsvc_NetShareCtr2);
617 W_ERROR_HAVE_NO_MEMORY(ctr.ctr2);
618
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);
622
623 for (snum = 0; snum < num_services; snum++) {
624 if (allowed[snum] &&
625 (resume_handle <= (i + valid_share_count++)) ) {
626 init_srv_share_info_2(p, &ctr.ctr2->array[i++], snum);
627 }
628 }
629
630 count_connections_for_all_shares(&ctr);
631 break;
632
633 case 501:
634 ctr.ctr501 = talloc_zero(ctx, struct srvsvc_NetShareCtr501);
635 W_ERROR_HAVE_NO_MEMORY(ctr.ctr501);
636
637 ctr.ctr501->count = alloc_entries;
638 ctr.ctr501->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo501, alloc_entries);
639 W_ERROR_HAVE_NO_MEMORY(ctr.ctr501->array);
640
641 for (snum = 0; snum < num_services; snum++) {
642 if (allowed[snum] &&
643 (resume_handle <= (i + valid_share_count++)) ) {
644 init_srv_share_info_501(p, &ctr.ctr501->array[i++], snum);
645 }
646 }
647
648 break;
649
650 case 502:
651 ctr.ctr502 = talloc_zero(ctx, struct srvsvc_NetShareCtr502);
652 W_ERROR_HAVE_NO_MEMORY(ctr.ctr502);
653
654 ctr.ctr502->count = alloc_entries;
655 ctr.ctr502->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo502, alloc_entries);
656 W_ERROR_HAVE_NO_MEMORY(ctr.ctr502->array);
657
658 for (snum = 0; snum < num_services; snum++) {
659 if (allowed[snum] &&
660 (resume_handle <= (i + valid_share_count++)) ) {
661 init_srv_share_info_502(p, &ctr.ctr502->array[i++], snum);
662 }
663 }
664
665 break;
666
667 case 1004:
668 ctr.ctr1004 = talloc_zero(ctx, struct srvsvc_NetShareCtr1004);
669 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004);
670
671 ctr.ctr1004->count = alloc_entries;
672 ctr.ctr1004->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo1004, alloc_entries);
673 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004->array);
674
675 for (snum = 0; snum < num_services; snum++) {
676 if (allowed[snum] &&
677 (resume_handle <= (i + valid_share_count++)) ) {
678 init_srv_share_info_1004(p, &ctr.ctr1004->array[i++], snum);
679 }
680 }
681
682 break;
683
684 case 1005:
685 ctr.ctr1005 = talloc_zero(ctx, struct srvsvc_NetShareCtr1005);
686 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005);
687
688 ctr.ctr1005->count = alloc_entries;
689 ctr.ctr1005->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo1005, alloc_entries);
690 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005->array);
691
692 for (snum = 0; snum < num_services; snum++) {
693 if (allowed[snum] &&
694 (resume_handle <= (i + valid_share_count++)) ) {
695 init_srv_share_info_1005(p, &ctr.ctr1005->array[i++], snum);
696 }
697 }
698
699 break;
700
701 case 1006:
702 ctr.ctr1006 = talloc_zero(ctx, struct srvsvc_NetShareCtr1006);
703 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006);
704
705 ctr.ctr1006->count = alloc_entries;
706 ctr.ctr1006->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo1006, alloc_entries);
707 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006->array);
708
709 for (snum = 0; snum < num_services; snum++) {
710 if (allowed[snum] &&
711 (resume_handle <= (i + valid_share_count++)) ) {
712 init_srv_share_info_1006(p, &ctr.ctr1006->array[i++], snum);
713 }
714 }
715
716 break;
717
718 case 1007:
719 ctr.ctr1007 = talloc_zero(ctx, struct srvsvc_NetShareCtr1007);
720 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007);
721
722 ctr.ctr1007->count = alloc_entries;
723 ctr.ctr1007->array = talloc_zero_array(ctx, struct srvsvc_NetShareInfo1007, alloc_entries);
724 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007->array);
725
726 for (snum = 0; snum < num_services; snum++) {
727 if (allowed[snum] &&
728 (resume_handle <= (i + valid_share_count++)) ) {
729 init_srv_share_info_1007(p, &ctr.ctr1007->array[i++], snum);
730 }
731 }
732
733 break;
734
735 case 1501:
736 ctr.ctr1501 = talloc_zero(ctx, struct srvsvc_NetShareCtr1501);
737 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501);
738
739 ctr.ctr1501->count = alloc_entries;
740 ctr.ctr1501->array = talloc_zero_array(ctx, struct sec_desc_buf, alloc_entries);
741 W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501->array);
742
743 for (snum = 0; snum < num_services; snum++) {
744 if (allowed[snum] &&
745 (resume_handle <= (i + valid_share_count++)) ) {
746 struct sec_desc_buf *sd_buf = NULL;
747 init_srv_share_info_1501(p, &sd_buf, snum);
748 ctr.ctr1501->array[i++] = *sd_buf;
749 }
750 }
751
752 break;
753
754 default:
755 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n",
756 info_ctr->level));
757 return WERR_UNKNOWN_LEVEL;
758 }
759
760 *total_entries = alloc_entries;
761 if (resume_handle_p) {
762 if (all_shares) {
763 *resume_handle_p = (num_entries == 0) ? *resume_handle_p : 0;
764 } else {
765 *resume_handle_p = num_entries;
766 }
767 }
768
769 info_ctr->ctr = ctr;
770
771 return WERR_OK;
772 }
773
774 /*******************************************************************
775 fill in a sess info level 0 structure.
776 ********************************************************************/
777
778 static WERROR init_srv_sess_info_0(struct pipes_struct *p,
779 struct srvsvc_NetSessCtr0 *ctr0,
780 uint32_t *resume_handle_p,
781 uint32_t *total_entries)
782 {
783 struct sessionid *session_list;
784 uint32_t num_entries = 0;
785 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
786 *total_entries = list_sessions(p->mem_ctx, &session_list);
787
788 DEBUG(5,("init_srv_sess_info_0\n"));
789
790 if (ctr0 == NULL) {
791 if (resume_handle_p) {
792 *resume_handle_p = 0;
793 }
794 return WERR_OK;
795 }
796
797 for (; resume_handle < *total_entries; resume_handle++) {
798
799 ctr0->array = talloc_realloc(p->mem_ctx,
800 ctr0->array,
801 struct srvsvc_NetSessInfo0,
802 num_entries+1);
803 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
804
805 ctr0->array[num_entries].client =
806 session_list[resume_handle].remote_machine;
807
808 num_entries++;
809 }
810
811 ctr0->count = num_entries;
812
813 if (resume_handle_p) {
814 if (*resume_handle_p >= *total_entries) {
815 *resume_handle_p = 0;
816 } else {
817 *resume_handle_p = resume_handle;
818 }
819 }
820
821 return WERR_OK;
822 }
823
824 /***********************************************************************
825 * find out the session on which this file is open and bump up its count
826 **********************************************************************/
827
828 static void count_sess_files_fn(const struct share_mode_entry *e,
829 const char *sharepath, const char *fname,
830 void *data)
831 {
832 struct sess_file_info *info = data;
833 uint32_t rh = info->resume_handle;
834 int i;
835
836 for (i=0; i < info->num_entries; i++) {
837 /* rh+info->num_entries is safe, as we've
838 ensured that:
839 *total_entries > resume_handle &&
840 info->num_entries = *total_entries - resume_handle;
841 inside init_srv_sess_info_1() below.
842 */
843 struct sessionid *sess = &info->session_list[rh + i];
844 if ((e->uid == sess->uid) &&
845 serverid_equal(&e->pid, &sess->pid)) {
846
847 info->ctr->array[i].num_open++;
848 return;
849 }
850 }
851 }
852
853 /*******************************************************************
854 * count the num of open files on all sessions
855 *******************************************************************/
856
857 static void net_count_files_for_all_sess(struct srvsvc_NetSessCtr1 *ctr1,
858 struct sessionid *session_list,
859 uint32_t resume_handle,
860 uint32_t num_entries)
861 {
862 struct sess_file_info s_file_info;
863
864 s_file_info.ctr = ctr1;
865 s_file_info.session_list = session_list;
866 s_file_info.resume_handle = resume_handle;
867 s_file_info.num_entries = num_entries;
868
869 share_mode_forall(count_sess_files_fn, &s_file_info);
870 }
871
872 /*******************************************************************
873 fill in a sess info level 1 structure.
874 ********************************************************************/
875
876 static WERROR init_srv_sess_info_1(struct pipes_struct *p,
877 struct srvsvc_NetSessCtr1 *ctr1,
878 uint32_t *resume_handle_p,
879 uint32_t *total_entries)
880 {
881 struct sessionid *session_list;
882 uint32_t num_entries = 0;
883 time_t now = time(NULL);
884 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
885
886 ZERO_STRUCTP(ctr1);
887
888 if (ctr1 == NULL) {
889 if (resume_handle_p) {
890 *resume_handle_p = 0;
891 }
892 return WERR_OK;
893 }
894
895 *total_entries = list_sessions(p->mem_ctx, &session_list);
896
897 if (resume_handle >= *total_entries) {
898 if (resume_handle_p) {
899 *resume_handle_p = 0;
900 }
901 return WERR_OK;
902 }
903
904 /* We know num_entries must be positive, due to
905 the check resume_handle >= *total_entries above. */
906
907 num_entries = *total_entries - resume_handle;
908
909 ctr1->array = talloc_zero_array(p->mem_ctx,
910 struct srvsvc_NetSessInfo1,
911 num_entries);
912
913 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
914
915 for (num_entries = 0; resume_handle < *total_entries; num_entries++, resume_handle++) {
916 uint32 connect_time;
917 bool guest;
918
919 connect_time = (uint32_t)(now - session_list[resume_handle].connect_start);
920 guest = strequal( session_list[resume_handle].username, lp_guest_account() );
921
922 ctr1->array[num_entries].client = session_list[resume_handle].remote_machine;
923 ctr1->array[num_entries].user = session_list[resume_handle].username;
924 ctr1->array[num_entries].num_open = 0;/* computed later */
925 ctr1->array[num_entries].time = connect_time;
926 ctr1->array[num_entries].idle_time = 0;
927 ctr1->array[num_entries].user_flags = guest;
928 }
929
930 ctr1->count = num_entries;
931
932 /* count open files on all sessions in single tdb traversal */
933 net_count_files_for_all_sess(ctr1, session_list,
934 resume_handle_p ? *resume_handle_p : 0,
935 num_entries);
936
937 if (resume_handle_p) {
938 if (*resume_handle_p >= *total_entries) {
939 *resume_handle_p = 0;
940 } else {
941 *resume_handle_p = resume_handle;
942 }
943 }
944
945 return WERR_OK;
946 }
947
948 /*******************************************************************
949 find the share connection on which this open exists.
950 ********************************************************************/
951
952 static void share_file_fn(const struct share_mode_entry *e,
953 const char *sharepath, const char *fname,
954 void *data)
955 {
956 struct share_file_stat *sfs = data;
957 uint32_t i;
958 uint32_t offset = sfs->total_entries - sfs->resp_entries;
959
960 if (strequal(sharepath, sfs->in_sharepath)) {
961 for (i=0; i < sfs->resp_entries; i++) {
962 if (serverid_equal(&e->pid, &sfs->svrid_arr[offset + i])) {
963 sfs->netconn_arr[i].num_open ++;
964 return;
965 }
966 }
967 }
968 }
969
970 /*******************************************************************
971 count number of open files on given share connections.
972 ********************************************************************/
973
974 static void count_share_opens(struct srvsvc_NetConnInfo1 *arr,
975 struct server_id *svrid_arr, char *sharepath,
976 uint32_t resp_entries, uint32_t total_entries)
977 {
978 struct share_file_stat sfs;
979
980 sfs.netconn_arr = arr;
981 sfs.svrid_arr = svrid_arr;
982 sfs.in_sharepath = sharepath;
983 sfs.resp_entries = resp_entries;
984 sfs.total_entries = total_entries;
985
986 share_mode_forall(share_file_fn, &sfs);
987 }
988
989 /****************************************************************************
990 process an entry from the connection db.
991 ****************************************************************************/
992
993 static int share_conn_fn(struct smbXsrv_tcon_global0 *tcon,
994 void *data)
995 {
996 struct share_conn_stat *scs = data;
997
998 if (!process_exists(tcon->server_id)) {
999 return 0;
1000 }
1001
1002 if (strequal(tcon->share_name, scs->sharename)) {
1003 scs->svrid_arr = talloc_realloc(scs->ctx, scs->svrid_arr,
1004 struct server_id,
1005 scs->count + 1);
1006 if (!scs->svrid_arr) {
1007 return 0;
1008 }
1009
1010 scs->svrid_arr[scs->count] = tcon->server_id;
1011 scs->count++;
1012 }
1013
1014 return 0;
1015 }
1016
1017 /****************************************************************************
1018 Count the connections to a share. Build an array of serverid's owning these
1019 connections.
1020 ****************************************************************************/
1021
1022 static uint32_t count_share_conns(TALLOC_CTX *ctx, const char *sharename,
1023 struct server_id **arr)
1024 {
1025 struct share_conn_stat scs;
1026 NTSTATUS status;
1027
1028 scs.ctx = ctx;
1029 scs.sharename = sharename;
1030 scs.svrid_arr = NULL;
1031 scs.count = 0;
1032
1033 status = smbXsrv_tcon_global_traverse(share_conn_fn, &scs);
1034
1035 if (!NT_STATUS_IS_OK(status)) {
1036 DEBUG(0,("count_share_conns: traverse of "
1037 "smbXsrv_tcon_global.tdb failed - %s\n",
1038 nt_errstr(status)));
1039 return 0;
1040 }
1041
1042 *arr = scs.svrid_arr;
1043 return scs.count;
1044 }
1045
1046 /*******************************************************************
1047 fill in a conn info level 0 structure.
1048 ********************************************************************/
1049
1050 static WERROR init_srv_conn_info_0(struct srvsvc_NetConnCtr0 *ctr0,
1051 uint32_t *resume_handle_p,
1052 uint32_t *total_entries)
1053 {
1054 uint32_t num_entries = 0;
1055 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
1056
1057 DEBUG(5,("init_srv_conn_info_0\n"));
1058
1059 if (ctr0 == NULL) {
1060 if (resume_handle_p) {
1061 *resume_handle_p = 0;
1062 }
1063 return WERR_OK;
1064 }
1065
1066 *total_entries = 1;
1067
1068 ZERO_STRUCTP(ctr0);
1069
1070 for (; resume_handle < *total_entries; resume_handle++) {
1071
1072 ctr0->array = talloc_realloc(talloc_tos(),
1073 ctr0->array,
1074 struct srvsvc_NetConnInfo0,
1075 num_entries+1);
1076 if (!ctr0->array) {
1077 return WERR_NOMEM;
1078 }
1079
1080 ctr0->array[num_entries].conn_id = *total_entries;
1081
1082 /* move on to creating next connection */
1083 num_entries++;
1084 }
1085
1086 ctr0->count = num_entries;
1087 *total_entries = num_entries;
1088
1089 if (resume_handle_p) {
1090 if (*resume_handle_p >= *total_entries) {
1091 *resume_handle_p = 0;
1092 } else {
1093 *resume_handle_p = resume_handle;
1094 }
1095 }
1096
1097 return WERR_OK;
1098 }
1099
1100 /*******************************************************************
1101 fill in a conn info level 1 structure.
1102 ********************************************************************/
1103
1104 static WERROR init_srv_conn_info_1(const char *name,
1105 struct srvsvc_NetConnCtr1 *ctr1,
1106 uint32_t *resume_handle_p,
1107 uint32_t *total_entries)
1108 {
1109 uint32_t num_entries = 0, snum = 0;
1110 uint32_t resume_handle = resume_handle_p ? *resume_handle_p : 0;
1111 char *share_name = NULL;
1112 struct server_id *svrid_arr = NULL;
1113
1114 DEBUG(5,("init_srv_conn_info_1\n"));
1115
1116 if (ctr1 == NULL) {
1117 if (resume_handle_p) {
1118 *resume_handle_p = 0;
1119 }
1120 return WERR_OK;
1121 }
1122
1123 /* check if this is a server name or a share name */
1124 if (name && (strlen(name) > 2) && (name[0] == '\\') &&
1125 (name[1] == '\\')) {
1126
1127 /* 'name' is a server name - this part is unimplemented */
1128 *total_entries = 1;
1129 } else {
1130 /* 'name' is a share name */
1131 snum = find_service(talloc_tos(), name, &share_name);
1132
1133 if (!share_name) {
1134 return WERR_NOMEM;
1135 }
1136
1137 if (snum < 0) {
1138 return WERR_INVALID_NAME;
1139 }
1140
1141 /*
1142 * count the num of connections to this share. Also,
1143 * build a list of serverid's that own these
1144 * connections. The serverid list is used later to
1145 * identify the share connection on which an open exists.
1146 */
1147
1148 *total_entries = count_share_conns(talloc_tos(),
1149 share_name,
1150 &svrid_arr);
1151 }
1152
1153 if (resume_handle >= *total_entries) {
1154 if (resume_handle_p) {
1155 *resume_handle_p = 0;
1156 }
1157 return WERR_OK;
1158 }
1159
1160 /*
1161 * We know num_entries must be positive, due to
1162 * the check resume_handle >= *total_entries above.
1163 */
1164
1165 num_entries = *total_entries - resume_handle;
1166
1167 ZERO_STRUCTP(ctr1);
1168
1169 ctr1->array = talloc_zero_array(talloc_tos(),
1170 struct srvsvc_NetConnInfo1,
1171 num_entries);
1172
1173 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1174
1175 for (num_entries = 0; resume_handle < *total_entries;
1176 num_entries++, resume_handle++) {
1177
1178 ctr1->array[num_entries].conn_id = *total_entries;
1179 ctr1->array[num_entries].conn_type = 0x3;
1180
1181 /*
1182 * if these are connections to a share, we are going to
1183 * compute the opens on them later. If it's for the server,
1184 * it's unimplemented.
1185 */
1186
1187 if (!share_name) {
1188 ctr1->array[num_entries].num_open = 1;
1189 }
1190
1191 ctr1->array[num_entries].num_users = 1;
1192 ctr1->array[num_entries].conn_time = 3;
1193 ctr1->array[num_entries].user = "dummy_user";
1194 ctr1->array[num_entries].share = "IPC$";
1195 }
1196
1197 /* now compute open files on the share connections */
1198
1199 if (share_name) {
1200
1201 /*
1202 * the locking tdb, which has the open files information,
1203 * does not store share name or share (service) number, but
1204 * just the share path. So, we can compute open files only
1205 * on the share path. If more than one shares are defined
1206 * on a share path, open files on all of them are included
1207 * in the count.
1208 *
1209 * To have the correct behavior in case multiple shares
1210 * are defined on the same path, changes to tdb records
1211 * would be required. That would be lot more effort, so
1212 * this seems a good stopgap fix.
1213 */
1214
1215 count_share_opens(ctr1->array, svrid_arr,
1216 lp_path(talloc_tos(), snum),
1217 num_entries, *total_entries);
1218
1219 }
1220
1221 ctr1->count = num_entries;
1222 *total_entries = num_entries;
1223
1224 if (resume_handle_p) {
1225 *resume_handle_p = resume_handle;
1226 }
1227
1228 return WERR_OK;
1229 }
1230
1231 /*******************************************************************
1232 _srvsvc_NetFileEnum
1233 *******************************************************************/
1234
1235 WERROR _srvsvc_NetFileEnum(struct pipes_struct *p,
1236 struct srvsvc_NetFileEnum *r)
1237 {
1238 TALLOC_CTX *ctx = NULL;
1239 struct srvsvc_NetFileCtr3 *ctr3;
1240 uint32_t resume_hnd = 0;
1241 WERROR werr;
1242
1243 switch (r->in.info_ctr->level) {
1244 case 3:
1245 break;
1246 default:
1247 return WERR_UNKNOWN_LEVEL;
1248 }
1249
1250 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1251 p->session_info->security_token)) {
1252 DEBUG(1, ("Enumerating files only allowed for "
1253 "administrators\n"));
1254 return WERR_ACCESS_DENIED;
1255 }
1256
1257 ctx = talloc_tos();
1258 ctr3 = r->in.info_ctr->ctr.ctr3;
1259 if (!ctr3) {
1260 werr = WERR_INVALID_PARAM;
1261 goto done;
1262 }
1263
1264 /* TODO -- Windows enumerates
1265 (b) active pipes
1266 (c) open directories and files */
1267
1268 werr = net_enum_files(ctx, r->in.user, &ctr3, resume_hnd);
1269 if (!W_ERROR_IS_OK(werr)) {
1270 goto done;
1271 }
1272
1273 *r->out.totalentries = ctr3->count;
1274 r->out.info_ctr->ctr.ctr3->array = ctr3->array;
1275 r->out.info_ctr->ctr.ctr3->count = ctr3->count;
1276
1277 werr = WERR_OK;
1278
1279 done:
1280 return werr;
1281 }
1282
1283 /*******************************************************************
1284 _srvsvc_NetSrvGetInfo
1285 ********************************************************************/
1286
1287 WERROR _srvsvc_NetSrvGetInfo(struct pipes_struct *p,
1288 struct srvsvc_NetSrvGetInfo *r)
1289 {
1290 WERROR status = WERR_OK;
1291
1292 DEBUG(5,("_srvsvc_NetSrvGetInfo: %d\n", __LINE__));
1293
1294 if (!pipe_access_check(p)) {
1295 DEBUG(3, ("access denied to _srvsvc_NetSrvGetInfo\n"));
1296 return WERR_ACCESS_DENIED;
1297 }
1298
1299 switch (r->in.level) {
1300
1301 /* Technically level 102 should only be available to
1302 Administrators but there isn't anything super-secret
1303 here, as most of it is made up. */
1304
1305 case 102: {
1306 struct srvsvc_NetSrvInfo102 *info102;
1307
1308 info102 = talloc(p->mem_ctx, struct srvsvc_NetSrvInfo102);
1309 if (!info102) {
1310 return WERR_NOMEM;
1311 }
1312
1313 info102->platform_id = PLATFORM_ID_NT;
1314 info102->server_name = lp_netbios_name();
1315 info102->version_major = SAMBA_MAJOR_NBT_ANNOUNCE_VERSION;
1316 info102->version_minor = SAMBA_MINOR_NBT_ANNOUNCE_VERSION;
1317 info102->server_type = lp_default_server_announce();
1318 info102->comment = string_truncate(lp_server_string(talloc_tos()),
1319 MAX_SERVER_STRING_LENGTH);
1320 info102->users = 0xffffffff;
1321 info102->disc = 0xf;
1322 info102->hidden = 0;
1323 info102->announce = 240;
1324 info102->anndelta = 3000;
1325 info102->licenses = 100000;
1326 info102->userpath = "C:\\";
1327
1328 r->out.info->info102 = info102;
1329 break;
1330 }
1331 case 101: {
1332 struct srvsvc_NetSrvInfo101 *info101;
1333
1334 info101 = talloc(p->mem_ctx, struct srvsvc_NetSrvInfo101);
1335 if (!info101) {
1336 return WERR_NOMEM;
1337 }
1338
1339 info101->platform_id = PLATFORM_ID_NT;
1340 info101->server_name = lp_netbios_name();
1341 info101->version_major = SAMBA_MAJOR_NBT_ANNOUNCE_VERSION;
1342 info101->version_minor = SAMBA_MINOR_NBT_ANNOUNCE_VERSION;
1343 info101->server_type = lp_default_server_announce();
1344 info101->comment = string_truncate(lp_server_string(talloc_tos()),
1345 MAX_SERVER_STRING_LENGTH);
1346
1347 r->out.info->info101 = info101;
1348 break;
1349 }
1350 case 100: {
1351 struct srvsvc_NetSrvInfo100 *info100;
1352
1353 info100 = talloc(p->mem_ctx, struct srvsvc_NetSrvInfo100);
1354 if (!info100) {
1355 return WERR_NOMEM;
1356 }
1357
1358 info100->platform_id = PLATFORM_ID_NT;
1359 info100->server_name = lp_netbios_name();
1360
1361 r->out.info->info100 = info100;
1362
1363 break;
1364 }
1365 default:
1366 status = WERR_UNKNOWN_LEVEL;
1367 break;
1368 }
1369
1370 DEBUG(5,("_srvsvc_NetSrvGetInfo: %d\n", __LINE__));
1371
1372 return status;
1373 }
1374
1375 /*******************************************************************
1376 _srvsvc_NetSrvSetInfo
1377 ********************************************************************/
1378
1379 WERROR _srvsvc_NetSrvSetInfo(struct pipes_struct *p,
1380 struct srvsvc_NetSrvSetInfo *r)
1381 {
1382 WERROR status = WERR_OK;
1383
1384 DEBUG(5,("_srvsvc_NetSrvSetInfo: %d\n", __LINE__));
1385
1386 /* Set up the net server set info structure. */
1387
1388 DEBUG(5,("_srvsvc_NetSrvSetInfo: %d\n", __LINE__));
1389
1390 return status;
1391 }
1392
1393 /*******************************************************************
1394 _srvsvc_NetConnEnum
1395 ********************************************************************/
1396
1397 WERROR _srvsvc_NetConnEnum(struct pipes_struct *p,
1398 struct srvsvc_NetConnEnum *r)
1399 {
1400 WERROR werr;
1401
1402 DEBUG(5,("_srvsvc_NetConnEnum: %d\n", __LINE__));
1403
1404 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1405 p->session_info->security_token)) {
1406 DEBUG(1, ("Enumerating connections only allowed for "
1407 "administrators\n"));
1408 return WERR_ACCESS_DENIED;
1409 }
1410
1411 switch (r->in.info_ctr->level) {
1412 case 0:
1413 werr = init_srv_conn_info_0(r->in.info_ctr->ctr.ctr0,
1414 r->in.resume_handle,
1415 r->out.totalentries);
1416 break;
1417 case 1:
1418 werr = init_srv_conn_info_1(r->in.path,
1419 r->in.info_ctr->ctr.ctr1,
1420 r->in.resume_handle,
1421 r->out.totalentries);
1422 break;
1423 default:
1424 return WERR_UNKNOWN_LEVEL;
1425 }
1426
1427 DEBUG(5,("_srvsvc_NetConnEnum: %d\n", __LINE__));
1428
1429 return werr;
1430 }
1431
1432 /*******************************************************************
1433 _srvsvc_NetSessEnum
1434 ********************************************************************/
1435
1436 WERROR _srvsvc_NetSessEnum(struct pipes_struct *p,
1437 struct srvsvc_NetSessEnum *r)
1438 {
1439 WERROR werr;
1440
1441 DEBUG(5,("_srvsvc_NetSessEnum: %d\n", __LINE__));
1442
1443 if (!nt_token_check_sid(&global_sid_Builtin_Administrators,
1444 p->session_info->security_token)) {
1445 DEBUG(1, ("Enumerating sessions only allowed for "
1446 "administrators\n"));
1447 return WERR_ACCESS_DENIED;
1448 }
1449
1450 switch (r->in.info_ctr->level) {
1451 case 0:
1452 werr = init_srv_sess_info_0(p,
1453 r->in.info_ctr->ctr.ctr0,
1454 r->in.resume_handle,
1455 r->out.totalentries);
1456 break;
1457 case 1:
1458 werr = init_srv_sess_info_1(p,
1459 r->in.info_ctr->ctr.ctr1,
1460 r->in.resume_handle,
1461 r->out.totalentries);
1462 break;
1463 default:
1464 return WERR_UNKNOWN_LEVEL;
1465 }
1466
1467 DEBUG(5,("_srvsvc_NetSessEnum: %d\n", __LINE__));
1468
1469 return werr;
1470 }
1471
1472 /*******************************************************************
1473 _srvsvc_NetSessDel
1474 ********************************************************************/
1475
1476 WERROR _srvsvc_NetSessDel(struct pipes_struct *p,
1477 struct srvsvc_NetSessDel *r)
1478 {
1479 struct sessionid *session_list;
1480 int num_sessions, snum;
1481 const char *username;
1482 const char *machine;
1483 bool not_root = False;
1484 WERROR werr;
1485
1486 DEBUG(5,("_srvsvc_NetSessDel: %d\n", __LINE__));
1487
1488 werr = WERR_ACCESS_DENIED;
1489
1490 /* fail out now if you are not root or not a domain admin */
1491
1492 if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
1493 ( ! nt_token_check_domain_rid(p->session_info->security_token,
1494 DOMAIN_RID_ADMINS))) {
1495
1496 goto done;
1497 }
1498
1499 username = r->in.user;
1500 machine = r->in.client;
1501
1502 /* strip leading backslashes if any */
1503 if (machine && machine[0] == '\\' && machine[1] == '\\') {
1504 machine += 2;
1505 }
1506
1507 num_sessions = find_sessions(p->mem_ctx, username, machine,
1508 &session_list);
1509
1510 for (snum = 0; snum < num_sessions; snum++) {
1511
1512 NTSTATUS ntstat;
1513
1514 if (p->session_info->unix_token->uid != sec_initial_uid()) {
1515 not_root = True;
1516 become_root();
1517 }
1518
1519 ntstat = messaging_send(p->msg_ctx,
1520 session_list[snum].pid,
1521 MSG_SHUTDOWN, &data_blob_null);
1522
1523 if (NT_STATUS_IS_OK(ntstat))
1524 werr = WERR_OK;
1525
1526 if (not_root)
1527 unbecome_root();
1528 }
1529
1530 DEBUG(5,("_srvsvc_NetSessDel: %d\n", __LINE__));
1531
1532 done:
1533
1534 return werr;
1535 }
1536
1537 /*******************************************************************
1538 _srvsvc_NetShareEnumAll
1539 ********************************************************************/
1540
1541 WERROR _srvsvc_NetShareEnumAll(struct pipes_struct *p,
1542 struct srvsvc_NetShareEnumAll *r)
1543 {
1544 WERROR werr;
1545
1546 DEBUG(5,("_srvsvc_NetShareEnumAll: %d\n", __LINE__));
1547
1548 if (!pipe_access_check(p)) {
1549 DEBUG(3, ("access denied to _srvsvc_NetShareEnumAll\n"));
1550 return WERR_ACCESS_DENIED;
1551 }
1552
1553 /* Create the list of shares for the response. */
1554 werr = init_srv_share_info_ctr(p,
1555 r->in.info_ctr,
1556 r->in.resume_handle,
1557 r->out.totalentries,
1558 true);
1559
1560 DEBUG(5,("_srvsvc_NetShareEnumAll: %d\n", __LINE__));
1561
1562 return werr;
1563 }
1564
1565 /*******************************************************************
1566 _srvsvc_NetShareEnum
1567 ********************************************************************/
1568
1569 WERROR _srvsvc_NetShareEnum(struct pipes_struct *p,
1570 struct srvsvc_NetShareEnum *r)
1571 {
1572 WERROR werr;
1573
1574 DEBUG(5,("_srvsvc_NetShareEnum: %d\n", __LINE__));
1575
1576 if (!pipe_access_check(p)) {
1577 DEBUG(3, ("access denied to _srvsvc_NetShareEnum\n"));
1578 return WERR_ACCESS_DENIED;
1579 }
1580
1581 /* Create the list of shares for the response. */
1582 werr = init_srv_share_info_ctr(p,
1583 r->in.info_ctr,
1584 r->in.resume_handle,
1585 r->out.totalentries,
1586 false);
1587
1588 DEBUG(5,("_srvsvc_NetShareEnum: %d\n", __LINE__));
1589
1590 return werr;
1591 }
1592
1593 /*******************************************************************
1594 _srvsvc_NetShareGetInfo
1595 ********************************************************************/
1596
1597 WERROR _srvsvc_NetShareGetInfo(struct pipes_struct *p,
1598 struct srvsvc_NetShareGetInfo *r)
1599 {
1600 WERROR status = WERR_OK;
1601 char *share_name = NULL;
1602 int snum;
1603 union srvsvc_NetShareInfo *info = r->out.info;
1604
1605 DEBUG(5,("_srvsvc_NetShareGetInfo: %d\n", __LINE__));
1606
1607 if (!r->in.share_name) {
1608 return WERR_INVALID_NAME;
1609 }
1610
1611 snum = find_service(talloc_tos(), r->in.share_name, &share_name);
1612 if (!share_name) {
1613 return WERR_NOMEM;
1614 }
1615 if (snum < 0) {
1616 return WERR_INVALID_NAME;
1617 }
1618
1619 switch (r->in.level) {
1620 case 0:
1621 info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
1622 W_ERROR_HAVE_NO_MEMORY(info->info0);
1623 init_srv_share_info_0(p, info->info0, snum);
1624 break;
1625 case 1:
1626 info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
1627 W_ERROR_HAVE_NO_MEMORY(info->info1);
1628 init_srv_share_info_1(p, info->info1, snum);
1629 break;
1630 case 2:
1631 info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
1632 W_ERROR_HAVE_NO_MEMORY(info->info2);
1633 init_srv_share_info_2(p, info->info2, snum);
1634 info->info2->current_users =
1635 count_current_connections(info->info2->name, false);
1636 break;
1637 case 501:
1638 info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
1639 W_ERROR_HAVE_NO_MEMORY(info->info501);
1640 init_srv_share_info_501(p, info->info501, snum);
1641 break;
1642 case 502:
1643 info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
1644 W_ERROR_HAVE_NO_MEMORY(info->info502);
1645 init_srv_share_info_502(p, info->info502, snum);
1646 break;
1647 case 1004:
1648 info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
1649 W_ERROR_HAVE_NO_MEMORY(info->info1004);
1650 init_srv_share_info_1004(p, info->info1004, snum);
1651 break;
1652 case 1005:
1653 info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
1654 W_ERROR_HAVE_NO_MEMORY(info->info1005);
1655 init_srv_share_info_1005(p, info->info1005, snum);
1656 break;
1657 case 1006:
1658 info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
1659 W_ERROR_HAVE_NO_MEMORY(info->info1006);
1660 init_srv_share_info_1006(p, info->info1006, snum);
1661 break;
1662 case 1007:
1663 info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
1664 W_ERROR_HAVE_NO_MEMORY(info->info1007);
1665 init_srv_share_info_1007(p, info->info1007, snum);
1666 break;
1667 case 1501:
1668 init_srv_share_info_1501(p, &info->info1501, snum);
1669 break;
1670 default:
1671 DEBUG(5,("_srvsvc_NetShareGetInfo: unsupported switch value %d\n",
1672 r->in.level));
1673 status = WERR_UNKNOWN_LEVEL;
1674 break;
1675 }
1676
1677 DEBUG(5,("_srvsvc_NetShareGetInfo: %d\n", __LINE__));
1678
1679 return status;
1680 }
1681
1682 /*******************************************************************
1683 _srvsvc_NetShareSetInfo. Modify share details.
1684 ********************************************************************/
1685
1686 WERROR _srvsvc_NetShareSetInfo(struct pipes_struct *p,
1687 struct srvsvc_NetShareSetInfo *r)
1688 {
1689 char *command = NULL;
1690 char *share_name = NULL;
1691 char *comment = NULL;
1692 const char *pathname = NULL;
1693 int type;
1694 int snum;
1695 int ret;
1696 char *path = NULL;
1697 struct security_descriptor *psd = NULL;
1698 bool is_disk_op = False;
1699 const char *csc_policy = NULL;
1700 bool csc_policy_changed = false;
1701 const char *csc_policies[] = {"manual", "documents", "programs",
1702 "disable"};
1703 uint32_t client_csc_policy;
1704 int max_connections = 0;
1705 TALLOC_CTX *ctx = p->mem_ctx;
1706 union srvsvc_NetShareInfo *info = r->in.info;
1707
1708 DEBUG(5,("_srvsvc_NetShareSetInfo: %d\n", __LINE__));
1709
1710 if (!r->in.share_name) {
1711 return WERR_INVALID_NAME;
1712 }
1713
1714 if (r->out.parm_error) {
1715 *r->out.parm_error = 0;
1716 }
1717
1718 if ( strequal(r->in.share_name,"IPC$")
1719 || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
1720 || strequal(r->in.share_name,"global") )
1721 {
1722 DEBUG(5,("_srvsvc_NetShareSetInfo: share %s cannot be "
1723 "modified by a remote user.\n",
1724 r->in.share_name ));
1725 return WERR_ACCESS_DENIED;
1726 }
1727
1728 snum = find_service(talloc_tos(), r->in.share_name, &share_name);
1729 if (!share_name) {
1730 return WERR_NOMEM;
1731 }
1732
1733 /* Does this share exist ? */
1734 if (snum < 0)
1735 return WERR_NET_NAME_NOT_FOUND;
1736
1737 /* No change to printer shares. */
1738 if (lp_printable(snum))
1739 return WERR_ACCESS_DENIED;
1740
1741 is_disk_op = security_token_has_privilege(p->session_info->security_token, SEC_PRIV_DISK_OPERATOR);
1742
1743 /* fail out now if you are not root and not a disk op */
1744
1745 if ( p->session_info->unix_token->uid != sec_initial_uid() && !is_disk_op ) {
1746 DEBUG(2,("_srvsvc_NetShareSetInfo: uid %u doesn't have the "
1747 "SeDiskOperatorPrivilege privilege needed to modify "
1748 "share %s\n",
1749 (unsigned int)p->session_info->unix_token->uid,
1750 share_name ));
1751 return WERR_ACCESS_DENIED;
1752 }
1753
1754 max_connections = lp_max_connections(snum);
1755 csc_policy = csc_policies[lp_csc_policy(snum)];
1756
1757 switch (r->in.level) {
1758 case 1:
1759 pathname = lp_path(ctx, snum);
1760 comment = talloc_strdup(ctx, info->info1->comment);
1761 type = info->info1->type;
1762 psd = NULL;
1763 break;
1764 case 2:
1765 comment = talloc_strdup(ctx, info->info2->comment);
1766 pathname = info->info2->path;
1767 type = info->info2->type;
1768 max_connections = (info->info2->max_users == (uint32_t)-1) ?
1769 0 : info->info2->max_users;
1770 psd = NULL;
1771 break;
1772 #if 0
1773 /* not supported on set but here for completeness */
1774 case 501:
1775 comment = talloc_strdup(ctx, info->info501->comment);
1776 type = info->info501->type;
1777 psd = NULL;
1778 break;
1779 #endif
1780 case 502:
1781 comment = talloc_strdup(ctx, info->info502->comment);
1782 pathname = info->info502->path;
1783 type = info->info502->type;
1784 psd = info->info502->sd_buf.sd;
1785 map_generic_share_sd_bits(psd);
1786 break;
1787 case 1004:
1788 pathname = lp_path(ctx, snum);
1789 comment = talloc_strdup(ctx, info->info1004->comment);
1790 type = STYPE_DISKTREE;
1791 break;
1792 case 1005:
1793 /* XP re-sets the csc policy even if it wasn't changed by the
1794 user, so we must compare it to see if it's what is set in
1795 smb.conf, so that we can contine other ops like setting
1796 ACLs on a share */
1797 client_csc_policy = (info->info1005->dfs_flags &
1798 SHARE_1005_CSC_POLICY_MASK) >>
1799 SHARE_1005_CSC_POLICY_SHIFT;
1800
1801 if (client_csc_policy == lp_csc_policy(snum))
1802 return WERR_OK;
1803 else {
1804 csc_policy = csc_policies[client_csc_policy];
1805 csc_policy_changed = true;
1806 }
1807
1808 pathname = lp_path(ctx, snum);
1809 comment = lp_comment(ctx, snum);
1810 type = STYPE_DISKTREE;
1811 break;
1812 case 1006:
1813 case 1007:
1814 return WERR_ACCESS_DENIED;
1815 case 1501:
1816 pathname = lp_path(ctx, snum);
1817 comment = lp_comment(ctx, snum);
1818 psd = info->info1501->sd;
1819 map_generic_share_sd_bits(psd);
1820 type = STYPE_DISKTREE;
1821 break;
1822 default:
1823 DEBUG(5,("_srvsvc_NetShareSetInfo: unsupported switch value %d\n",
1824 r->in.level));
1825 return WERR_UNKNOWN_LEVEL;
1826 }
1827
1828 /* We can only modify disk shares. */
1829 if (type != STYPE_DISKTREE) {
1830 DEBUG(5,("_srvsvc_NetShareSetInfo: share %s is not a "
1831 "disk share\n",
1832 share_name ));
1833 return WERR_ACCESS_DENIED;
1834 }
1835
1836 if (comment == NULL) {
1837 return WERR_NOMEM;
1838 }
1839
1840 /* Check if the pathname is valid. */
1841 if (!(path = valid_share_pathname(p->mem_ctx, pathname ))) {
1842 DEBUG(5,("_srvsvc_NetShareSetInfo: invalid pathname %s\n",
1843 pathname ));
1844 return WERR_OBJECT_PATH_INVALID;
1845 }
1846
1847 /* Ensure share name, pathname and comment don't contain '"' characters. */
1848 string_replace(share_name, '"', ' ');
1849 string_replace(path, '"', ' ');
1850 string_replace(comment, '"', ' ');
1851
1852 DEBUG(10,("_srvsvc_NetShareSetInfo: change share command = %s\n",
1853 lp_change_share_command(talloc_tos()) ? lp_change_share_command(talloc_tos()) : "NULL" ));
1854
1855 /* Only call modify function if something changed. */
1856
1857 if (strcmp(path, lp_path(talloc_tos(), snum)) || strcmp(comment, lp_comment(talloc_tos(), snum))
1858 || (lp_max_connections(snum) != max_connections)
1859 || csc_policy_changed) {
1860
1861 if (!lp_change_share_command(talloc_tos()) || !*lp_change_share_command(talloc_tos())) {
1862 DEBUG(10,("_srvsvc_NetShareSetInfo: No change share command\n"));
1863 return WERR_ACCESS_DENIED;
1864 }
1865
1866 command = talloc_asprintf(p->mem_ctx,
1867 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d \"%s\"",
1868 lp_change_share_command(talloc_tos()),
1869 get_dyn_CONFIGFILE(),
1870 share_name,
1871 path,
1872 comment ? comment : "",
1873 max_connections,
1874 csc_policy);
1875 if (!command) {
1876 return WERR_NOMEM;
1877 }
1878
1879 DEBUG(10,("_srvsvc_NetShareSetInfo: Running [%s]\n", command ));
1880
1881 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1882
1883 if (is_disk_op)
1884 become_root();
1885
1886 if ( (ret = smbrun(command, NULL)) == 0 ) {
1887 /* Tell everyone we updated smb.conf. */
1888 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED,
1889 NULL, 0, NULL);
1890 }
1891
1892 if ( is_disk_op )
1893 unbecome_root();
1894
1895 /********* END SeDiskOperatorPrivilege BLOCK *********/
1896
1897 DEBUG(3,("_srvsvc_NetShareSetInfo: Running [%s] returned (%d)\n",
1898 command, ret ));
1899
1900 TALLOC_FREE(command);
1901
1902 if ( ret != 0 )
1903 return WERR_ACCESS_DENIED;
1904 } else {
1905 DEBUG(10,("_srvsvc_NetShareSetInfo: No change to share name (%s)\n",
1906 share_name ));
1907 }
1908
1909 /* Replace SD if changed. */
1910 if (psd) {
1911 struct security_descriptor *old_sd;
1912 size_t sd_size;
1913
1914 old_sd = get_share_security(p->mem_ctx, lp_servicename(talloc_tos(), snum), &sd_size);
1915
1916 if (old_sd && !security_descriptor_equal(old_sd, psd)) {
1917 if (!set_share_security(share_name, psd))
1918 DEBUG(0,("_srvsvc_NetShareSetInfo: Failed to change security info in share %s.\n",
1919 share_name ));
1920 }
1921 }
1922
1923 DEBUG(5,("_srvsvc_NetShareSetInfo: %d\n", __LINE__));
1924
1925 return WERR_OK;
1926 }
1927
1928 /*******************************************************************
1929 _srvsvc_NetShareAdd.
1930 Call 'add_share_command "sharename" "pathname"
1931 "comment" "max connections = "
1932 ********************************************************************/
1933
1934 WERROR _srvsvc_NetShareAdd(struct pipes_struct *p,
1935 struct srvsvc_NetShareAdd *r)
1936 {
1937 char *command = NULL;
1938 char *share_name_in = NULL;
1939 char *share_name = NULL;
1940 char *comment = NULL;
1941 char *pathname = NULL;
1942 int type;
1943 int snum;
1944 int ret;
1945 char *path;
1946 struct security_descriptor *psd = NULL;
1947 bool is_disk_op;
1948 int max_connections = 0;
1949 TALLOC_CTX *ctx = p->mem_ctx;
1950
1951 DEBUG(5,("_srvsvc_NetShareAdd: %d\n", __LINE__));
1952
1953 if (r->out.parm_error) {
1954 *r->out.parm_error = 0;
1955 }
1956
1957 is_disk_op = security_token_has_privilege(p->session_info->security_token, SEC_PRIV_DISK_OPERATOR);
1958
1959 if (p->session_info->unix_token->uid != sec_initial_uid() && !is_disk_op )
1960 return WERR_ACCESS_DENIED;
1961
1962 if (!lp_add_share_command(talloc_tos()) || !*lp_add_share_command(talloc_tos())) {
1963 DEBUG(10,("_srvsvc_NetShareAdd: No add share command\n"));
1964 return WERR_ACCESS_DENIED;
1965 }
1966
1967 switch (r->in.level) {
1968 case 0:
1969 /* No path. Not enough info in a level 0 to do anything. */
1970 return WERR_ACCESS_DENIED;
1971 case 1:
1972 /* Not enough info in a level 1 to do anything. */
1973 return WERR_ACCESS_DENIED;
1974 case 2:
1975 share_name_in = talloc_strdup(ctx, r->in.info->info2->name);
1976 comment = talloc_strdup(ctx, r->in.info->info2->comment);
1977 pathname = talloc_strdup(ctx, r->in.info->info2->path);
1978 max_connections = (r->in.info->info2->max_users == (uint32_t)-1) ?
1979 0 : r->in.info->info2->max_users;
1980 type = r->in.info->info2->type;
1981 break;
1982 case 501:
1983 /* No path. Not enough info in a level 501 to do anything. */
1984 return WERR_ACCESS_DENIED;
1985 case 502:
1986 share_name_in = talloc_strdup(ctx, r->in.info->info502->name);
1987 comment = talloc_strdup(ctx, r->in.info->info502->comment);
1988 pathname = talloc_strdup(ctx, r->in.info->info502->path);
1989 max_connections = (r->in.info->info502->max_users == (uint32_t)-1) ?
1990 0 : r->in.info->info502->max_users;
1991 type = r->in.info->info502->type;
1992 psd = r->in.info->info502->sd_buf.sd;
1993 map_generic_share_sd_bits(psd);
1994 break;
1995
1996 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
1997
1998 case 1004:
1999 case 1005:
2000 case 1006:
2001 case 1007:
2002 return WERR_ACCESS_DENIED;
2003 case 1501:
2004 /* DFS only level. */
2005 return WERR_ACCESS_DENIED;
2006 default:
2007 DEBUG(5,("_srvsvc_NetShareAdd: unsupported switch value %d\n",
2008 r->in.level));
2009 return WERR_UNKNOWN_LEVEL;
2010 }
2011
2012 /* check for invalid share names */
2013
2014 if (!share_name_in || !validate_net_name(share_name_in,
2015 INVALID_SHARENAME_CHARS,
2016 strlen(share_name_in))) {
2017 DEBUG(5,("_srvsvc_NetShareAdd: Bad sharename \"%s\"\n",
2018 share_name_in ? share_name_in : ""));
2019 return WERR_INVALID_NAME;
2020 }
2021
2022 if (strequal(share_name_in,"IPC$") || strequal(share_name_in,"global")
2023 || (lp_enable_asu_support() &&
2024 strequal(share_name_in,"ADMIN$"))) {
2025 return WERR_ACCESS_DENIED;
2026 }
2027
2028 snum = find_service(ctx, share_name_in, &share_name);
2029 if (!share_name) {
2030 return WERR_NOMEM;
2031 }
2032
2033 /* Share already exists. */
2034 if (snum >= 0) {
2035 return WERR_FILE_EXISTS;
2036 }
2037
2038 /* We can only add disk shares. */
2039 if (type != STYPE_DISKTREE) {
2040 return WERR_ACCESS_DENIED;
2041 }
2042
2043 /* Check if the pathname is valid. */
2044 if (!(path = valid_share_pathname(p->mem_ctx, pathname))) {
2045 return WERR_OBJECT_PATH_INVALID;
2046 }
2047
2048 /* Ensure share name, pathname and comment don't contain '"' characters. */
2049 string_replace(share_name_in, '"', ' ');
2050 string_replace(share_name, '"', ' ');
2051 string_replace(path, '"', ' ');
2052 if (comment) {
2053 string_replace(comment, '"', ' ');
2054 }
2055
2056 command = talloc_asprintf(ctx,
2057 "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
2058 lp_add_share_command(talloc_tos()),
2059 get_dyn_CONFIGFILE(),
2060 share_name_in,
2061 path,
2062 comment ? comment : "",
2063 max_connections);
2064 if (!command) {
2065 return WERR_NOMEM;
2066 }
2067
2068 DEBUG(10,("_srvsvc_NetShareAdd: Running [%s]\n", command ));
2069
2070 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
2071
2072 if ( is_disk_op )
2073 become_root();
2074
2075 /* FIXME: use libnetconf here - gd */
2076
2077 if ( (ret = smbrun(command, NULL)) == 0 ) {
2078 /* Tell everyone we updated smb.conf. */
2079 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0,
2080 NULL);
2081 }
2082
2083 if ( is_disk_op )
2084 unbecome_root();
2085
2086 /********* END SeDiskOperatorPrivilege BLOCK *********/
2087
2088 DEBUG(3,("_srvsvc_NetShareAdd: Running [%s] returned (%d)\n",
2089 command, ret ));
2090
2091 TALLOC_FREE(command);
2092
2093 if ( ret != 0 )
2094 return WERR_ACCESS_DENIED;
2095
2096 if (psd) {
2097 /* Note we use share_name here, not share_name_in as
2098 we need a canonicalized name for setting security. */
2099 if (!set_share_security(share_name, psd)) {
2100 DEBUG(0,("_srvsvc_NetShareAdd: Failed to add security info to share %s.\n",
2101 share_name ));
2102 }
2103 }
2104
2105 /*
2106 * We don't call reload_services() here, the message will
2107 * cause this to be done before the next packet is read
2108 * from the client. JRA.
2109 */
2110
2111 DEBUG(5,("_srvsvc_NetShareAdd: %d\n", __LINE__));
2112
2113 return WERR_OK;
2114 }
2115
2116 /*******************************************************************
2117 _srvsvc_NetShareDel
2118 Call "delete share command" with the share name as
2119 a parameter.
2120 ********************************************************************/
2121
2122 WERROR _srvsvc_NetShareDel(struct pipes_struct *p,
2123 struct srvsvc_NetShareDel *r)
2124 {
2125 char *command = NULL;
2126 char *share_name = NULL;
2127 int ret;
2128 int snum;
2129 bool is_disk_op;
2130 struct share_params *params;
2131 TALLOC_CTX *ctx = p->mem_ctx;
2132
2133 DEBUG(5,("_srvsvc_NetShareDel: %d\n", __LINE__));
2134
2135 if (!r->in.share_name) {
2136 return WERR_NET_NAME_NOT_FOUND;
2137 }
2138
2139 if ( strequal(r->in.share_name,"IPC$")
2140 || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
2141 || strequal(r->in.share_name,"global") )
2142 {
2143 return WERR_ACCESS_DENIED;
2144 }
2145
2146 snum = find_service(talloc_tos(), r->in.share_name, &share_name);
2147 if (!share_name) {
2148 return WERR_NOMEM;
2149 }
2150
2151 if (snum < 0) {
2152 return WERR_NO_SUCH_SHARE;
2153 }
2154
2155 if (!(params = get_share_params(p->mem_ctx, share_name))) {
2156 return WERR_NO_SUCH_SHARE;
2157 }
2158
2159 /* No change to printer shares. */
2160 if (lp_printable(snum))
2161 return WERR_ACCESS_DENIED;
2162
2163 is_disk_op = security_token_has_privilege(p->session_info->security_token, SEC_PRIV_DISK_OPERATOR);
2164
2165 if (p->session_info->unix_token->uid != sec_initial_uid() && !is_disk_op )
2166 return WERR_ACCESS_DENIED;
2167
2168 if (!lp_delete_share_command(talloc_tos()) || !*lp_delete_share_command(talloc_tos())) {
2169 DEBUG(10,("_srvsvc_NetShareDel: No delete share command\n"));
2170 return WERR_ACCESS_DENIED;
2171 }
2172
2173 command = talloc_asprintf(ctx,
2174 "%s \"%s\" \"%s\"",
2175 lp_delete_share_command(talloc_tos()),
2176 get_dyn_CONFIGFILE(),
2177 lp_servicename(talloc_tos(), snum));
2178 if (!command) {
2179 return WERR_NOMEM;
2180 }
2181
2182 DEBUG(10,("_srvsvc_NetShareDel: Running [%s]\n", command ));
2183
2184 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
2185
2186 if ( is_disk_op )
2187 become_root();
2188
2189 if ( (ret = smbrun(command, NULL)) == 0 ) {
2190 /* Tell everyone we updated smb.conf. */
2191 message_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0,
2192 NULL);
2193 }
2194
2195 if ( is_disk_op )
2196 unbecome_root();
2197
2198 /********* END SeDiskOperatorPrivilege BLOCK *********/
2199
2200 DEBUG(3,("_srvsvc_NetShareDel: Running [%s] returned (%d)\n", command, ret ));
2201
2202 if ( ret != 0 )
2203 return WERR_ACCESS_DENIED;
2204
2205 /* Delete the SD in the database. */
2206 delete_share_security(lp_servicename(talloc_tos(), params->service));
2207
2208 lp_killservice(params->service);
2209
2210 return WERR_OK;
2211 }
2212
2213 /*******************************************************************
2214 _srvsvc_NetShareDelSticky
2215 ********************************************************************/
2216
2217 WERROR _srvsvc_NetShareDelSticky(struct pipes_struct *p,
2218 struct srvsvc_NetShareDelSticky *r)
2219 {
2220 struct srvsvc_NetShareDel q;
2221
2222 DEBUG(5,("_srvsvc_NetShareDelSticky: %d\n", __LINE__));
2223
2224 q.in.server_unc = r->in.server_unc;
2225 q.in.share_name = r->in.share_name;
2226 q.in.reserved = r->in.reserved;
2227
2228 return _srvsvc_NetShareDel(p, &q);
2229 }
2230
2231 /*******************************************************************
2232 _srvsvc_NetRemoteTOD
2233 ********************************************************************/
2234
2235 WERROR _srvsvc_NetRemoteTOD(struct pipes_struct *p,
2236 struct srvsvc_NetRemoteTOD *r)
2237 {
2238 struct srvsvc_NetRemoteTODInfo *tod;
2239 struct tm *t;
2240 time_t unixdate = time(NULL);
2241
2242 /* We do this call first as if we do it *after* the gmtime call
2243 it overwrites the pointed-to values. JRA */
2244
2245 uint32 zone = get_time_zone(unixdate)/60;
2246
2247 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2248
2249 if ( !(tod = talloc_zero(p->mem_ctx, struct srvsvc_NetRemoteTODInfo)) )
2250 return WERR_NOMEM;
2251
2252 *r->out.info = tod;
2253
2254 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2255
2256 t = gmtime(&unixdate);
2257
2258 /* set up the */
2259 tod->elapsed = unixdate;
2260 tod->msecs = 0;
2261 tod->hours = t->tm_hour;
2262 tod->mins = t->tm_min;
2263 tod->secs = t->tm_sec;
2264 tod->hunds = 0;
2265 tod->timezone = zone;
2266 tod->tinterval = 10000;
2267 tod->day = t->tm_mday;
2268 tod->month = t->tm_mon + 1;
2269 tod->year = 1900+t->tm_year;
2270 tod->weekday = t->tm_wday;
2271
2272 DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
2273
2274 return WERR_OK;
2275 }
2276
2277 /***********************************************************************************
2278 _srvsvc_NetGetFileSecurity
2279 Win9x NT tools get security descriptor.
2280 ***********************************************************************************/
2281
2282 WERROR _srvsvc_NetGetFileSecurity(struct pipes_struct *p,
2283 struct srvsvc_NetGetFileSecurity *r)
2284 {
2285 struct smb_filename *smb_fname = NULL;
2286 size_t sd_size;
2287 char *servicename = NULL;
2288 SMB_STRUCT_STAT st;
2289 NTSTATUS nt_status;
2290 WERROR werr;
2291 connection_struct *conn = NULL;
2292 struct sec_desc_buf *sd_buf = NULL;
2293 files_struct *fsp = NULL;
2294 int snum;
2295 char *oldcwd = NULL;
2296
2297 ZERO_STRUCT(st);
2298
2299 if (!r->in.share) {
2300 werr = WERR_NET_NAME_NOT_FOUND;
2301 goto error_exit;
2302 }
2303 snum = find_service(talloc_tos(), r->in.share, &servicename);
2304 if (!servicename) {
2305 werr = WERR_NOMEM;
2306 goto error_exit;
2307 }
2308 if (snum == -1) {
2309 DEBUG(10, ("Could not find service %s\n", servicename));
2310 werr = WERR_NET_NAME_NOT_FOUND;
2311 goto error_exit;
2312 }
2313
2314 nt_status = create_conn_struct_cwd(talloc_tos(),
2315 server_event_context(),
2316 server_messaging_context(),
2317 &conn,
2318 snum, lp_path(talloc_tos(), snum),
2319 p->session_info, &oldcwd);
2320 if (!NT_STATUS_IS_OK(nt_status)) {
2321 DEBUG(10, ("create_conn_struct failed: %s\n",
2322 nt_errstr(nt_status)));
2323 werr = ntstatus_to_werror(nt_status);
2324 goto error_exit;
2325 }
2326
2327 nt_status = filename_convert(talloc_tos(),
2328 conn,
2329 false,
2330 r->in.file,
2331 0,
2332 NULL,
2333 &smb_fname);
2334 if (!NT_STATUS_IS_OK(nt_status)) {
2335 werr = ntstatus_to_werror(nt_status);
2336 goto error_exit;
2337 }
2338
2339 nt_status = SMB_VFS_CREATE_FILE(
2340 conn, /* conn */
2341 NULL, /* req */
2342 0, /* root_dir_fid */
2343 smb_fname, /* fname */
2344 FILE_READ_ATTRIBUTES, /* access_mask */
2345 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
2346 FILE_OPEN, /* create_disposition*/
2347 0, /* create_options */
2348 0, /* file_attributes */
2349 INTERNAL_OPEN_ONLY, /* oplock_request */
2350 0, /* allocation_size */
2351 0, /* private_flags */
2352 NULL, /* sd */
2353 NULL, /* ea_list */
2354 &fsp, /* result */
2355 NULL); /* pinfo */
2356
2357 if (!NT_STATUS_IS_OK(nt_status)) {
2358 DEBUG(3,("_srvsvc_NetGetFileSecurity: can't open %s\n",
2359 smb_fname_str_dbg(smb_fname)));
2360 werr = ntstatus_to_werror(nt_status);
2361 goto error_exit;
2362 }
2363
2364 sd_buf = talloc_zero(p->mem_ctx, struct sec_desc_buf);
2365 if (!sd_buf) {
2366 werr = WERR_NOMEM;
2367 goto error_exit;
2368 }
2369
2370 nt_status = SMB_VFS_FGET_NT_ACL(fsp,
2371 (SECINFO_OWNER
2372 |SECINFO_GROUP
2373 |SECINFO_DACL), sd_buf, &sd_buf->sd);
2374
2375 if (!NT_STATUS_IS_OK(nt_status)) {
2376 DEBUG(3,("_srvsvc_NetGetFileSecurity: Unable to get NT ACL "
2377 "for file %s\n", smb_fname_str_dbg(smb_fname)));
2378 werr = ntstatus_to_werror(nt_status);
2379 TALLOC_FREE(sd_buf);
2380 goto error_exit;
2381 }
2382
2383 if (sd_buf->sd->dacl) {
2384 sd_buf->sd->dacl->revision = NT4_ACL_REVISION;
2385 }
2386
2387 sd_size = ndr_size_security_descriptor(sd_buf->sd, 0);
2388
2389 sd_buf->sd_size = sd_size;
2390
2391 *r->out.sd_buf = sd_buf;
2392
2393 close_file(NULL, fsp, NORMAL_CLOSE);
2394 vfs_ChDir(conn, oldcwd);
2395 SMB_VFS_DISCONNECT(conn);
2396 conn_free(conn);
2397 werr = WERR_OK;
2398 goto done;
2399
2400 error_exit:
2401
2402 if (fsp) {
2403 close_file(NULL, fsp, NORMAL_CLOSE);
2404 }
2405
2406 if (oldcwd) {
2407 vfs_ChDir(conn, oldcwd);
2408 }
2409
2410 if (conn) {
2411 SMB_VFS_DISCONNECT(conn);
2412 conn_free(conn);
2413 }
2414
2415 done:
2416
2417 TALLOC_FREE(smb_fname);
2418
2419 return werr;
2420 }
2421
2422 /***********************************************************************************
2423 _srvsvc_NetSetFileSecurity
2424 Win9x NT tools set security descriptor.
2425 ***********************************************************************************/
2426
2427 WERROR _srvsvc_NetSetFileSecurity(struct pipes_struct *p,
2428 struct srvsvc_NetSetFileSecurity *r)
2429 {
2430 struct smb_filename *smb_fname = NULL;
2431 char *servicename = NULL;
2432 files_struct *fsp = NULL;
2433 SMB_STRUCT_STAT st;
2434 NTSTATUS nt_status;
2435 WERROR werr;
2436 connection_struct *conn = NULL;
2437 int snum;
2438 char *oldcwd = NULL;
2439 struct security_descriptor *psd = NULL;
2440 uint32_t security_info_sent = 0;
2441
2442 ZERO_STRUCT(st);
2443
2444 if (!r->in.share) {
2445 werr = WERR_NET_NAME_NOT_FOUND;
2446 goto error_exit;
2447 }
2448
2449 snum = find_service(talloc_tos(), r->in.share, &servicename);
2450 if (!servicename) {
2451 werr = WERR_NOMEM;
2452 goto error_exit;
2453 }
2454
2455 if (snum == -1) {
2456 DEBUG(10, ("Could not find service %s\n", servicename));
2457 werr = WERR_NET_NAME_NOT_FOUND;
2458 goto error_exit;
2459 }
2460
2461 nt_status = create_conn_struct_cwd(talloc_tos(),
2462 server_event_context(),
2463 server_messaging_context(),
2464 &conn,
2465 snum, lp_path(talloc_tos(), snum),
2466 p->session_info, &oldcwd);
2467 if (!NT_STATUS_IS_OK(nt_status)) {
2468 DEBUG(10, ("create_conn_struct failed: %s\n",
2469 nt_errstr(nt_status)));
2470 werr = ntstatus_to_werror(nt_status);
2471 goto error_exit;
2472 }
2473
2474 nt_status = filename_convert(talloc_tos(),
2475 conn,
2476 false,
2477 r->in.file,
2478 0,
2479 NULL,
2480 &smb_fname);
2481 if (!NT_STATUS_IS_OK(nt_status)) {
2482 werr = ntstatus_to_werror(nt_status);
2483 goto error_exit;
2484 }
2485
2486 nt_status = SMB_VFS_CREATE_FILE(
2487 conn, /* conn */
2488 NULL, /* req */
2489 0, /* root_dir_fid */
2490 smb_fname, /* fname */
2491 FILE_WRITE_ATTRIBUTES, /* access_mask */
2492 FILE_SHARE_READ|FILE_SHARE_WRITE, /* share_access */
2493 FILE_OPEN, /* create_disposition*/
2494 0, /* create_options */
2495 0, /* file_attributes */
2496 INTERNAL_OPEN_ONLY, /* oplock_request */
2497 0, /* allocation_size */
2498 0, /* private_flags */
2499 NULL, /* sd */
2500 NULL, /* ea_list */
2501 &fsp, /* result */
2502 NULL); /* pinfo */
2503
2504 if (!NT_STATUS_IS_OK(nt_status)) {
2505 DEBUG(3,("_srvsvc_NetSetFileSecurity: can't open %s\n",
2506 smb_fname_str_dbg(smb_fname)));
2507 werr = ntstatus_to_werror(nt_status);
2508 goto error_exit;
2509 }
2510
2511 psd = r->in.sd_buf->sd;
2512 security_info_sent = r->in.securityinformation;
2513
2514 nt_status = set_sd(fsp, psd, security_info_sent);
2515
2516 if (!NT_STATUS_IS_OK(nt_status) ) {
2517 DEBUG(3,("_srvsvc_NetSetFileSecurity: Unable to set NT ACL "
2518 "on file %s\n", r->in.share));
2519 werr = WERR_ACCESS_DENIED;
2520 goto error_exit;
2521 }
2522
2523 close_file(NULL, fsp, NORMAL_CLOSE);
2524 vfs_ChDir(conn, oldcwd);
2525 SMB_VFS_DISCONNECT(conn);
2526 conn_free(conn);
2527 werr = WERR_OK;
2528 goto done;
2529
2530 error_exit:
2531
2532 if (fsp) {
2533 close_file(NULL, fsp, NORMAL_CLOSE);
2534 }
2535
2536 if (oldcwd) {
2537 vfs_ChDir(conn, oldcwd);
2538 }
2539
2540 if (conn) {
2541 SMB_VFS_DISCONNECT(conn);
2542 conn_free(conn);
2543 }
2544
2545 done:
2546 TALLOC_FREE(smb_fname);
2547
2548 return werr;
2549 }
2550
2551 /***********************************************************************************
2552 It may be that we want to limit users to creating shares on certain areas of the UNIX file area.
2553 We could define areas by mapping Windows style disks to points on the UNIX directory hierarchy.
2554 These disks would the disks listed by this function.
2555 Users could then create shares relative to these disks. Watch out for moving these disks around.
2556 "Nigel Williams" <nigel@veritas.com>.
2557 ***********************************************************************************/
2558
2559 static const char *server_disks[] = {"C:"};
2560
2561 static uint32 get_server_disk_count(void)
2562 {
2563 return sizeof(server_disks)/sizeof(server_disks[0]);
2564 }
2565
2566 static uint32 init_server_disk_enum(uint32 *resume)
2567 {
2568 uint32 server_disk_count = get_server_disk_count();
2569
2570 /*resume can be an offset into the list for now*/
2571
2572 if(*resume & 0x80000000)
2573 *resume = 0;
2574
2575 if(*resume > server_disk_count)
2576 *resume = server_disk_count;
2577
2578 return server_disk_count - *resume;
2579 }
2580
2581 static const char *next_server_disk_enum(uint32 *resume)
2582 {
2583 const char *disk;
2584
2585 if(init_server_disk_enum(resume) == 0)
2586 return NULL;
2587
2588 disk = server_disks[*resume];
2589
2590 (*resume)++;
2591
2592 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2593
2594 return disk;
2595 }
2596
2597 /********************************************************************
2598 _srvsvc_NetDiskEnum
2599 ********************************************************************/
2600
2601 WERROR _srvsvc_NetDiskEnum(struct pipes_struct *p,
2602 struct srvsvc_NetDiskEnum *r)
2603 {
2604 uint32 i;
2605 const char *disk_name;
2606 TALLOC_CTX *ctx = p->mem_ctx;
2607 WERROR werr;
2608 uint32_t resume = r->in.resume_handle ? *r->in.resume_handle : 0;
2609
2610 werr = WERR_OK;
2611
2612 *r->out.totalentries = init_server_disk_enum(&resume);
2613
2614 r->out.info->disks = talloc_zero_array(ctx, struct srvsvc_NetDiskInfo0,
2615 MAX_SERVER_DISK_ENTRIES);
2616 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks);
2617
2618 /*allow one struct srvsvc_NetDiskInfo0 for null terminator*/
2619
2620 r->out.info->count = 0;
2621
2622 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2623
2624 r->out.info->count++;
2625
2626 /*copy disk name into a unicode string*/
2627
2628 r->out.info->disks[i].disk = talloc_strdup(ctx, disk_name);
2629 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[i].disk);
2630 }
2631
2632 /* add a terminating null string. Is this there if there is more data to come? */
2633
2634 r->out.info->count++;
2635
2636 r->out.info->disks[i].disk = talloc_strdup(ctx, "");
2637 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[i].disk);
2638
2639 if (r->out.resume_handle) {
2640 *r->out.resume_handle = resume;
2641 }
2642
2643 return werr;
2644 }
2645
2646 /********************************************************************
2647 _srvsvc_NetNameValidate
2648 ********************************************************************/
2649
2650 WERROR _srvsvc_NetNameValidate(struct pipes_struct *p,
2651 struct srvsvc_NetNameValidate *r)
2652 {
2653 switch (r->in.name_type) {
2654 case 0x9:
2655 if (!validate_net_name(r->in.name, INVALID_SHARENAME_CHARS,
2656 strlen_m(r->in.name)))
2657 {
2658 DEBUG(5,("_srvsvc_NetNameValidate: Bad sharename \"%s\"\n",
2659 r->in.name));
2660 return WERR_INVALID_NAME;
2661 }
2662 break;
2663
2664 default:
2665 return WERR_UNKNOWN_LEVEL;
2666 }
2667
2668 return WERR_OK;
2669 }
2670
2671 /*******************************************************************
2672 ********************************************************************/
2673
2674 struct enum_file_close_state {
2675 struct srvsvc_NetFileClose *r;
2676 struct messaging_context *msg_ctx;
2677 };
2678
2679 static void enum_file_close_fn( const struct share_mode_entry *e,
2680 const char *sharepath, const char *fname,
2681 void *private_data )
2682 {
2683 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
2684 struct enum_file_close_state *state =
2685 (struct enum_file_close_state *)private_data;
2686 uint32_t fid = (((uint32_t)(procid_to_pid(&e->pid))<<16) | e->share_file_id);
2687
2688 if (fid != state->r->in.fid) {
2689 return; /* Not this file. */
2690 }
2691
2692 if (!process_exists(e->pid) ) {
2693 return;
2694 }
2695
2696 /* Ok - send the close message. */
2697 DEBUG(10,("enum_file_close_fn: request to close file %s, %s\n",
2698 sharepath,
2699 share_mode_str(talloc_tos(), 0, e) ));
2700
2701 share_mode_entry_to_message(msg, e);
2702
2703 state->r->out.result = ntstatus_to_werror(
2704 messaging_send_buf(state->msg_ctx,
2705 e->pid, MSG_SMB_CLOSE_FILE,
2706 (uint8 *)msg, sizeof(msg)));
2707 }
2708
2709 /********************************************************************
2710 Close a file given a 32-bit file id.
2711 ********************************************************************/
2712
2713 WERROR _srvsvc_NetFileClose(struct pipes_struct *p,
2714 struct srvsvc_NetFileClose *r)
2715 {
2716 struct enum_file_close_state state;
2717 bool is_disk_op;
2718
2719 DEBUG(5,("_srvsvc_NetFileClose: %d\n", __LINE__));
2720
2721 is_disk_op = security_token_has_privilege(p->session_info->security_token, SEC_PRIV_DISK_OPERATOR);
2722
2723 if (p->session_info->unix_token->uid != sec_initial_uid() && !is_disk_op) {
2724 return WERR_ACCESS_DENIED;
2725 }
2726
2727 /* enum_file_close_fn sends the close message to
2728 * the relevant smbd process. */
2729
2730 r->out.result = WERR_BADFILE;
2731 state.r = r;
2732 state.msg_ctx = p->msg_ctx;
2733 share_mode_forall(enum_file_close_fn, &state);
2734 return r->out.result;
2735 }
2736
2737 /********************************************************************
2738 ********************************************************************/
2739
2740 WERROR _srvsvc_NetCharDevEnum(struct pipes_struct *p,
2741 struct srvsvc_NetCharDevEnum *r)
2742 {
2743 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2744 return WERR_NOT_SUPPORTED;
2745 }
2746
2747 WERROR _srvsvc_NetCharDevGetInfo(struct pipes_struct *p,
2748 struct srvsvc_NetCharDevGetInfo *r)
2749 {
2750 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2751 return WERR_NOT_SUPPORTED;
2752 }
2753
2754 WERROR _srvsvc_NetCharDevControl(struct pipes_struct *p,
2755 struct srvsvc_NetCharDevControl *r)
2756 {
2757 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2758 return WERR_NOT_SUPPORTED;
2759 }
2760
2761 WERROR _srvsvc_NetCharDevQEnum(struct pipes_struct *p,
2762 struct srvsvc_NetCharDevQEnum *r)
2763 {
2764 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2765 return WERR_NOT_SUPPORTED;
2766 }
2767
2768 WERROR _srvsvc_NetCharDevQGetInfo(struct pipes_struct *p,
2769 struct srvsvc_NetCharDevQGetInfo *r)
2770 {
2771 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2772 return WERR_NOT_SUPPORTED;
2773 }
2774
2775 WERROR _srvsvc_NetCharDevQSetInfo(struct pipes_struct *p,
2776 struct srvsvc_NetCharDevQSetInfo *r)
2777 {
2778 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2779 return WERR_NOT_SUPPORTED;
2780 }
2781
2782 WERROR _srvsvc_NetCharDevQPurge(struct pipes_struct *p,
2783 struct srvsvc_NetCharDevQPurge *r)
2784 {
2785 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2786 return WERR_NOT_SUPPORTED;
2787 }
2788
2789 WERROR _srvsvc_NetCharDevQPurgeSelf(struct pipes_struct *p,
2790 struct srvsvc_NetCharDevQPurgeSelf *r)
2791 {
2792 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2793 return WERR_NOT_SUPPORTED;
2794 }
2795
2796 WERROR _srvsvc_NetFileGetInfo(struct pipes_struct *p,
2797 struct srvsvc_NetFileGetInfo *r)
2798 {
2799 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2800 return WERR_NOT_SUPPORTED;
2801 }
2802
2803 WERROR _srvsvc_NetShareCheck(struct pipes_struct *p,
2804 struct srvsvc_NetShareCheck *r)
2805 {
2806 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2807 return WERR_NOT_SUPPORTED;
2808 }
2809
2810 WERROR _srvsvc_NetServerStatisticsGet(struct pipes_struct *p,
2811 struct srvsvc_NetServerStatisticsGet *r)
2812 {
2813 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2814 return WERR_NOT_SUPPORTED;
2815 }
2816
2817 WERROR _srvsvc_NetTransportAdd(struct pipes_struct *p,
2818 struct srvsvc_NetTransportAdd *r)
2819 {
2820 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2821 return WERR_NOT_SUPPORTED;
2822 }
2823
2824 WERROR _srvsvc_NetTransportEnum(struct pipes_struct *p,
2825 struct srvsvc_NetTransportEnum *r)
2826 {
2827 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2828 return WERR_NOT_SUPPORTED;
2829 }
2830
2831 WERROR _srvsvc_NetTransportDel(struct pipes_struct *p,
2832 struct srvsvc_NetTransportDel *r)
2833 {
2834 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2835 return WERR_NOT_SUPPORTED;
2836 }
2837
2838 WERROR _srvsvc_NetSetServiceBits(struct pipes_struct *p,
2839 struct srvsvc_NetSetServiceBits *r)
2840 {
2841 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2842 return WERR_NOT_SUPPORTED;
2843 }
2844
2845 WERROR _srvsvc_NetPathType(struct pipes_struct *p,
2846 struct srvsvc_NetPathType *r)
2847 {
2848 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2849 return WERR_NOT_SUPPORTED;
2850 }
2851
2852 WERROR _srvsvc_NetPathCanonicalize(struct pipes_struct *p,
2853 struct srvsvc_NetPathCanonicalize *r)
2854 {
2855 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2856 return WERR_NOT_SUPPORTED;
2857 }
2858
2859 WERROR _srvsvc_NetPathCompare(struct pipes_struct *p,
2860 struct srvsvc_NetPathCompare *r)
2861 {
2862 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2863 return WERR_NOT_SUPPORTED;
2864 }
2865
2866 WERROR _srvsvc_NETRPRNAMECANONICALIZE(struct pipes_struct *p,
2867 struct srvsvc_NETRPRNAMECANONICALIZE *r)
2868 {
2869 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2870 return WERR_NOT_SUPPORTED;
2871 }
2872
2873 WERROR _srvsvc_NetPRNameCompare(struct pipes_struct *p,
2874 struct srvsvc_NetPRNameCompare *r)
2875 {
2876 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2877 return WERR_NOT_SUPPORTED;
2878 }
2879
2880 WERROR _srvsvc_NetShareDelStart(struct pipes_struct *p,
2881 struct srvsvc_NetShareDelStart *r)
2882 {
2883 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2884 return WERR_NOT_SUPPORTED;
2885 }
2886
2887 WERROR _srvsvc_NetShareDelCommit(struct pipes_struct *p,
2888 struct srvsvc_NetShareDelCommit *r)
2889 {
2890 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2891 return WERR_NOT_SUPPORTED;
2892 }
2893
2894 WERROR _srvsvc_NetServerTransportAddEx(struct pipes_struct *p,
2895 struct srvsvc_NetServerTransportAddEx *r)
2896 {
2897 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2898 return WERR_NOT_SUPPORTED;
2899 }
2900
2901 WERROR _srvsvc_NetServerSetServiceBitsEx(struct pipes_struct *p,
2902 struct srvsvc_NetServerSetServiceBitsEx *r)
2903 {
2904 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2905 return WERR_NOT_SUPPORTED;
2906 }
2907
2908 WERROR _srvsvc_NETRDFSGETVERSION(struct pipes_struct *p,
2909 struct srvsvc_NETRDFSGETVERSION *r)
2910 {
2911 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2912 return WERR_NOT_SUPPORTED;
2913 }
2914
2915 WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(struct pipes_struct *p,
2916 struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2917 {
2918 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2919 return WERR_NOT_SUPPORTED;
2920 }
2921
2922 WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(struct pipes_struct *p,
2923 struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2924 {
2925 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2926 return WERR_NOT_SUPPORTED;
2927 }
2928
2929 WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct pipes_struct *p,
2930 struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2931 {
2932 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2933 return WERR_NOT_SUPPORTED;
2934 }
2935
2936 WERROR _srvsvc_NETRDFSSETSERVERINFO(struct pipes_struct *p,
2937 struct srvsvc_NETRDFSSETSERVERINFO *r)
2938 {
2939 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2940 return WERR_NOT_SUPPORTED;
2941 }
2942
2943 WERROR _srvsvc_NETRDFSCREATEEXITPOINT(struct pipes_struct *p,
2944 struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2945 {
2946 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2947 return WERR_NOT_SUPPORTED;
2948 }
2949
2950 WERROR _srvsvc_NETRDFSDELETEEXITPOINT(struct pipes_struct *p,
2951 struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2952 {
2953 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2954 return WERR_NOT_SUPPORTED;
2955 }
2956
2957 WERROR _srvsvc_NETRDFSMODIFYPREFIX(struct pipes_struct *p,
2958 struct srvsvc_NETRDFSMODIFYPREFIX *r)
2959 {
2960 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2961 return WERR_NOT_SUPPORTED;
2962 }
2963
2964 WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(struct pipes_struct *p,
2965 struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2966 {
2967 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2968 return WERR_NOT_SUPPORTED;
2969 }
2970
2971 WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct pipes_struct *p,
2972 struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2973 {
2974 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2975 return WERR_NOT_SUPPORTED;
2976 }
2977
2978 WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(struct pipes_struct *p,
2979 struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2980 {
2981 p->fault_state = DCERPC_FAULT_OP_RNG_ERROR;
2982 return WERR_NOT_SUPPORTED;
2983 }
Samba GIT mirror