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