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