source: branches/samba-3.0/source/rpc_server/srv_srvsvc_nt.c@ 168

Last change on this file since 168 was 168, checked in by Herwig Bauernfeind, 16 years ago

Final fix for Ticket #78
File size: 62.1 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Jeremy Allison 2001.
6 * Copyright (C) Nigel Williams 2001.
7 * Copyright (C) Gerald (Jerry) Carter 2006.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24/* This is the implementation of the srvsvc pipe. */
25
26#include "includes.h"
27
28extern struct generic_mapping file_generic_mapping;
29
30#undef DBGC_CLASS
31#define DBGC_CLASS DBGC_RPC_SRV
32
33/* Use for enumerating connections, pipes, & files */
34
35struct file_enum_count {
36 TALLOC_CTX *ctx;
37 int count;
38 FILE_INFO_3 *info;
39};
40
41struct sess_file_count {
42 pid_t pid;
43 uid_t uid;
44 int count;
45};
46
47/****************************************************************************
48 Count the entries belonging to a service in the connection db.
49****************************************************************************/
50
51static int pipe_enum_fn( TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *p)
52{
53 struct pipe_open_rec prec;
54 struct file_enum_count *fenum = (struct file_enum_count *)p;
55
56 if (dbuf.dsize != sizeof(struct pipe_open_rec))
57 return 0;
58
59 memcpy(&prec, dbuf.dptr, sizeof(struct pipe_open_rec));
60
61 if ( process_exists(prec.pid) ) {
62 FILE_INFO_3 *f;
63 int i = fenum->count;
64 pstring fullpath;
65
66 snprintf( fullpath, sizeof(fullpath), "\\PIPE\\%s", prec.name );
67
68 f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, FILE_INFO_3, i+1 );
69 if ( !f ) {
70 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
71 return 1;
72 }
73 fenum->info = f;
74
75
76 init_srv_file_info3( &fenum->info[i],
77 (uint32)((procid_to_pid(&prec.pid)<<16) & prec.pnum),
78 (FILE_READ_DATA|FILE_WRITE_DATA),
79 0,
80 uidtoname( prec.uid ),
81 fullpath );
82
83 fenum->count++;
84 }
85
86 return 0;
87}
88
89/*******************************************************************
90********************************************************************/
91
92static WERROR net_enum_pipes( TALLOC_CTX *ctx, FILE_INFO_3 **info,
93 uint32 *count, uint32 resume )
94{
95 struct file_enum_count fenum;
96 TDB_CONTEXT *conn_tdb = conn_tdb_ctx();
97
98 if ( !conn_tdb ) {
99 DEBUG(0,("net_enum_pipes: Failed to retrieve the connections tdb handle!\n"));
100 return WERR_ACCESS_DENIED;
101 }
102
103 fenum.ctx = ctx;
104 fenum.count = *count;
105 fenum.info = *info;
106
107 if (tdb_traverse(conn_tdb, pipe_enum_fn, &fenum) == -1) {
108 DEBUG(0,("net_enum_pipes: traverse of connections.tdb failed with error %s.\n",
109 tdb_errorstr(conn_tdb) ));
110 return WERR_NOMEM;
111 }
112
113 *info = fenum.info;
114 *count = fenum.count;
115
116 return WERR_OK;}
117
118/*******************************************************************
119********************************************************************/
120
121/* global needed to make use of the share_mode_forall() callback */
122static struct file_enum_count f_enum_cnt;
123
124static void enum_file_fn( const struct share_mode_entry *e,
125 const char *sharepath, const char *fname, void *state )
126{
127 struct file_enum_count *fenum = &f_enum_cnt;
128
129 /* If the pid was not found delete the entry from connections.tdb */
130
131 if ( process_exists(e->pid) ) {
132 FILE_INFO_3 *f;
133 int i = fenum->count;
134 files_struct fsp;
135 struct byte_range_lock *brl;
136 int num_locks = 0;
137 pstring fullpath;
138 uint32 permissions;
139
140 f = TALLOC_REALLOC_ARRAY( fenum->ctx, fenum->info, FILE_INFO_3, i+1 );
141 if ( !f ) {
142 DEBUG(0,("conn_enum_fn: realloc failed for %d items\n", i+1));
143 return;
144 }
145 fenum->info = f;
146
147 /* need to count the number of locks on a file */
148
149 ZERO_STRUCT( fsp );
150 fsp.dev = e->dev;
151 fsp.inode = e->inode;
152
153 if ( (brl = brl_get_locks(NULL,&fsp)) != NULL ) {
154 num_locks = brl->num_locks;
155 TALLOC_FREE( brl );
156 }
157
158 if ( strcmp( fname, "." ) == 0 ) {
159 pstr_sprintf( fullpath, "%s%s",
160 (strchr( sharepath,':')) ? "" : "C:", sharepath );
161 } else {
162 pstr_sprintf( fullpath, "%s%s%s",
163 (strchr( sharepath,':')) ? "" : "C:", sharepath, fname );
164 }
165 string_replace( fullpath, '/', '\\' );
166
167 /* mask out create (what ever that is) */
168 permissions = e->share_access & (FILE_READ_DATA|FILE_WRITE_DATA);
169
170 /* now fill in the FILE_INFO_3 struct */
171 init_srv_file_info3( &fenum->info[i],
172 e->share_file_id,
173 permissions,
174 num_locks,
175 uidtoname(e->uid),
176 fullpath );
177
178 fenum->count++;
179 }
180
181 return;
182
183}
184
185/*******************************************************************
186********************************************************************/
187
188static WERROR net_enum_files( TALLOC_CTX *ctx, FILE_INFO_3 **info,
189 uint32 *count, uint32 resume )
190{
191 f_enum_cnt.ctx = ctx;
192 f_enum_cnt.count = *count;
193 f_enum_cnt.info = *info;
194
195 share_mode_forall( enum_file_fn, NULL );
196
197 *info = f_enum_cnt.info;
198 *count = f_enum_cnt.count;
199
200 return WERR_OK;
201}
202
203/*******************************************************************
204 Utility function to get the 'type' of a share from an snum.
205 ********************************************************************/
206static uint32 get_share_type(int snum)
207{
208 /* work out the share type */
209 uint32 type = STYPE_DISKTREE;
210
211 if (lp_print_ok(snum))
212 type = STYPE_PRINTQ;
213 if (strequal(lp_fstype(snum), "IPC"))
214 type = STYPE_IPC;
215 if (lp_administrative_share(snum))
216 type |= STYPE_HIDDEN;
217
218 return type;
219}
220
221/*******************************************************************
222 Fill in a share info level 0 structure.
223 ********************************************************************/
224
225static void init_srv_share_info_0(pipes_struct *p, SRV_SHARE_INFO_0 *sh0, int snum)
226{
227 pstring net_name;
228
229 pstrcpy(net_name, lp_servicename(snum));
230
231 init_srv_share_info0(&sh0->info_0, net_name);
232 init_srv_share_info0_str(&sh0->info_0_str, net_name);
233}
234
235/*******************************************************************
236 Fill in a share info level 1 structure.
237 ********************************************************************/
238
239static void init_srv_share_info_1(pipes_struct *p, SRV_SHARE_INFO_1 *sh1, int snum)
240{
241 pstring remark;
242
243 char *net_name = lp_servicename(snum);
244 pstrcpy(remark, lp_comment(snum));
245 standard_sub_conn(p->conn, remark,sizeof(remark));
246
247 init_srv_share_info1(&sh1->info_1, net_name, get_share_type(snum), remark);
248 init_srv_share_info1_str(&sh1->info_1_str, net_name, remark);
249}
250
251/*******************************************************************
252 Fill in a share info level 2 structure.
253 ********************************************************************/
254
255static void init_srv_share_info_2(pipes_struct *p, SRV_SHARE_INFO_2 *sh2, int snum)
256{
257 pstring remark;
258 pstring path;
259 pstring passwd;
260 int max_connections = lp_max_connections(snum);
261 uint32 max_uses = max_connections!=0 ? max_connections : 0xffffffff;
262 int count = 0;
263 char *net_name = lp_servicename(snum);
264
265 pstrcpy(remark, lp_comment(snum));
266 standard_sub_conn(p->conn, remark,sizeof(remark));
267 if (strchr( lp_pathname(snum), ':'))
268 pstrcpy(path, "");
269 else
270 pstrcpy(path, "C:");
271 pstrcat(path, lp_pathname(snum));
272
273 /*
274 * Change / to \\ so that win2k will see it as a valid path. This was added to
275 * enable use of browsing in win2k add share dialog.
276 */
277
278 string_replace(path, '/', '\\');
279
280 pstrcpy(passwd, "");
281
282 count = count_current_connections( net_name, False );
283 init_srv_share_info2(&sh2->info_2, net_name, get_share_type(snum),
284 remark, 0, max_uses, count, path, passwd);
285
286 init_srv_share_info2_str(&sh2->info_2_str, net_name, remark, path, passwd);
287}
288
289/*******************************************************************
290 Map any generic bits to file specific bits.
291********************************************************************/
292
293static void map_generic_share_sd_bits(SEC_DESC *psd)
294{
295 int i;
296 SEC_ACL *ps_dacl = NULL;
297
298 if (!psd)
299 return;
300
301 ps_dacl = psd->dacl;
302 if (!ps_dacl)
303 return;
304
305 for (i = 0; i < ps_dacl->num_aces; i++) {
306 SEC_ACE *psa = &ps_dacl->aces[i];
307 uint32 orig_mask = psa->access_mask;
308
309 se_map_generic(&psa->access_mask, &file_generic_mapping);
310 psa->access_mask |= orig_mask;
311 }
312}
313
314/*******************************************************************
315 Fill in a share info level 501 structure.
316********************************************************************/
317
318static void init_srv_share_info_501(pipes_struct *p, SRV_SHARE_INFO_501 *sh501, int snum)
319{
320 pstring remark;
321
322 const char *net_name = lp_servicename(snum);
323 pstrcpy(remark, lp_comment(snum));
324 standard_sub_conn(p->conn, remark, sizeof(remark));
325
326 init_srv_share_info501(&sh501->info_501, net_name, get_share_type(snum), remark, (lp_csc_policy(snum) << 4));
327 init_srv_share_info501_str(&sh501->info_501_str, net_name, remark);
328}
329
330/*******************************************************************
331 Fill in a share info level 502 structure.
332 ********************************************************************/
333
334static void init_srv_share_info_502(pipes_struct *p, SRV_SHARE_INFO_502 *sh502, int snum)
335{
336 pstring net_name;
337 pstring remark;
338 pstring path;
339 pstring passwd;
340 SEC_DESC *sd;
341 size_t sd_size;
342 TALLOC_CTX *ctx = p->mem_ctx;
343
344
345 ZERO_STRUCTP(sh502);
346
347 pstrcpy(net_name, lp_servicename(snum));
348 pstrcpy(remark, lp_comment(snum));
349 standard_sub_conn(p->conn, remark,sizeof(remark));
350 if (strchr( lp_pathname(snum), ':'))
351 pstrcpy(path, "");
352 else
353 pstrcpy(path, "C:");
354 pstrcat(path, lp_pathname(snum));
355
356 /*
357 * Change / to \\ so that win2k will see it as a valid path. This was added to
358 * enable use of browsing in win2k add share dialog.
359 */
360
361 string_replace(path, '/', '\\');
362
363 pstrcpy(passwd, "");
364
365 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
366
367 init_srv_share_info502(&sh502->info_502, net_name, get_share_type(snum), remark, 0, 0xffffffff, 1, path, passwd, sd, sd_size);
368 init_srv_share_info502_str(&sh502->info_502_str, net_name, remark, path, passwd, sd, sd_size);
369}
370
371/***************************************************************************
372 Fill in a share info level 1004 structure.
373 ***************************************************************************/
374
375static void init_srv_share_info_1004(pipes_struct *p, SRV_SHARE_INFO_1004* sh1004, int snum)
376{
377 pstring remark;
378
379 pstrcpy(remark, lp_comment(snum));
380 standard_sub_conn(p->conn, remark, sizeof(remark));
381
382 ZERO_STRUCTP(sh1004);
383
384 init_srv_share_info1004(&sh1004->info_1004, remark);
385 init_srv_share_info1004_str(&sh1004->info_1004_str, remark);
386}
387
388/***************************************************************************
389 Fill in a share info level 1005 structure.
390 ***************************************************************************/
391
392static void init_srv_share_info_1005(pipes_struct *p, SRV_SHARE_INFO_1005* sh1005, int snum)
393{
394 sh1005->share_info_flags = 0;
395
396 if(lp_host_msdfs() && lp_msdfs_root(snum))
397 sh1005->share_info_flags |=
398 SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
399 sh1005->share_info_flags |=
400 lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
401}
402/***************************************************************************
403 Fill in a share info level 1006 structure.
404 ***************************************************************************/
405
406static void init_srv_share_info_1006(pipes_struct *p, SRV_SHARE_INFO_1006* sh1006, int snum)
407{
408 sh1006->max_uses = -1;
409}
410
411/***************************************************************************
412 Fill in a share info level 1007 structure.
413 ***************************************************************************/
414
415static void init_srv_share_info_1007(pipes_struct *p, SRV_SHARE_INFO_1007* sh1007, int snum)
416{
417 pstring alternate_directory_name = "";
418 uint32 flags = 0;
419
420 ZERO_STRUCTP(sh1007);
421
422 init_srv_share_info1007(&sh1007->info_1007, flags, alternate_directory_name);
423 init_srv_share_info1007_str(&sh1007->info_1007_str, alternate_directory_name);
424}
425
426/*******************************************************************
427 Fill in a share info level 1501 structure.
428 ********************************************************************/
429
430static void init_srv_share_info_1501(pipes_struct *p, SRV_SHARE_INFO_1501 *sh1501, int snum)
431{
432 SEC_DESC *sd;
433 size_t sd_size;
434 TALLOC_CTX *ctx = p->mem_ctx;
435
436 ZERO_STRUCTP(sh1501);
437
438 sd = get_share_security(ctx, lp_servicename(snum), &sd_size);
439
440 sh1501->sdb = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
441}
442
443/*******************************************************************
444 True if it ends in '$'.
445 ********************************************************************/
446
447static BOOL is_hidden_share(int snum)
448{
449 const char *net_name = lp_servicename(snum);
450
451 return (net_name[strlen(net_name) - 1] == '$') ? True : False;
452}
453
454/*******************************************************************
455 Fill in a share info structure.
456 ********************************************************************/
457
458static BOOL init_srv_share_info_ctr(pipes_struct *p, SRV_SHARE_INFO_CTR *ctr,
459 uint32 info_level, uint32 *resume_hnd, uint32 *total_entries, BOOL all_shares)
460{
461 int num_entries = 0;
462 int num_services = 0;
463 int snum;
464 TALLOC_CTX *ctx = p->mem_ctx;
465
466 DEBUG(5,("init_srv_share_info_ctr\n"));
467
468 ZERO_STRUCTPN(ctr);
469
470 ctr->info_level = ctr->switch_value = info_level;
471 *resume_hnd = 0;
472
473 /* Ensure all the usershares are loaded. */
474 become_root();
475 num_services = load_usershare_shares();
476 unbecome_root();
477
478 /* Count the number of entries. */
479 for (snum = 0; snum < num_services; snum++) {
480 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) )
481 num_entries++;
482 }
483
484 *total_entries = num_entries;
485 ctr->num_entries2 = ctr->num_entries = num_entries;
486 ctr->ptr_share_info = ctr->ptr_entries = 1;
487
488 if (!num_entries)
489 return True;
490
491 switch (info_level) {
492 case 0:
493 {
494 SRV_SHARE_INFO_0 *info0 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_0, num_entries);
495 int i = 0;
496
497 if (!info0) {
498 return False;
499 }
500
501 for (snum = *resume_hnd; snum < num_services; snum++) {
502 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
503 init_srv_share_info_0(p, &info0[i++], snum);
504 }
505 }
506
507 ctr->share.info0 = info0;
508 break;
509
510 }
511
512 case 1:
513 {
514 SRV_SHARE_INFO_1 *info1 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1, num_entries);
515 int i = 0;
516
517 if (!info1) {
518 return False;
519 }
520
521 for (snum = *resume_hnd; snum < num_services; snum++) {
522 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
523 init_srv_share_info_1(p, &info1[i++], snum);
524 }
525 }
526
527 ctr->share.info1 = info1;
528 break;
529 }
530
531 case 2:
532 {
533 SRV_SHARE_INFO_2 *info2 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_2, num_entries);
534 int i = 0;
535
536 if (!info2) {
537 return False;
538 }
539
540 for (snum = *resume_hnd; snum < num_services; snum++) {
541 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
542 init_srv_share_info_2(p, &info2[i++], snum);
543 }
544 }
545
546 ctr->share.info2 = info2;
547 break;
548 }
549
550 case 501:
551 {
552 SRV_SHARE_INFO_501 *info501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_501, num_entries);
553 int i = 0;
554
555 if (!info501) {
556 return False;
557 }
558
559 for (snum = *resume_hnd; snum < num_services; snum++) {
560 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
561 init_srv_share_info_501(p, &info501[i++], snum);
562 }
563 }
564
565 ctr->share.info501 = info501;
566 break;
567 }
568
569 case 502:
570 {
571 SRV_SHARE_INFO_502 *info502 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_502, num_entries);
572 int i = 0;
573
574 if (!info502) {
575 return False;
576 }
577
578 for (snum = *resume_hnd; snum < num_services; snum++) {
579 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
580 init_srv_share_info_502(p, &info502[i++], snum);
581 }
582 }
583
584 ctr->share.info502 = info502;
585 break;
586 }
587
588 /* here for completeness but not currently used with enum (1004 - 1501)*/
589
590 case 1004:
591 {
592 SRV_SHARE_INFO_1004 *info1004 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1004, num_entries);
593 int i = 0;
594
595 if (!info1004) {
596 return False;
597 }
598
599 for (snum = *resume_hnd; snum < num_services; snum++) {
600 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
601 init_srv_share_info_1004(p, &info1004[i++], snum);
602 }
603 }
604
605 ctr->share.info1004 = info1004;
606 break;
607 }
608
609 case 1005:
610 {
611 SRV_SHARE_INFO_1005 *info1005 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1005, num_entries);
612 int i = 0;
613
614 if (!info1005) {
615 return False;
616 }
617
618 for (snum = *resume_hnd; snum < num_services; snum++) {
619 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
620 init_srv_share_info_1005(p, &info1005[i++], snum);
621 }
622 }
623
624 ctr->share.info1005 = info1005;
625 break;
626 }
627
628 case 1006:
629 {
630 SRV_SHARE_INFO_1006 *info1006 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1006, num_entries);
631 int i = 0;
632
633 if (!info1006) {
634 return False;
635 }
636
637 for (snum = *resume_hnd; snum < num_services; snum++) {
638 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
639 init_srv_share_info_1006(p, &info1006[i++], snum);
640 }
641 }
642
643 ctr->share.info1006 = info1006;
644 break;
645 }
646
647 case 1007:
648 {
649 SRV_SHARE_INFO_1007 *info1007 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1007, num_entries);
650 int i = 0;
651
652 if (!info1007) {
653 return False;
654 }
655
656 for (snum = *resume_hnd; snum < num_services; snum++) {
657 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
658 init_srv_share_info_1007(p, &info1007[i++], snum);
659 }
660 }
661
662 ctr->share.info1007 = info1007;
663 break;
664 }
665
666 case 1501:
667 {
668 SRV_SHARE_INFO_1501 *info1501 = TALLOC_ARRAY(ctx, SRV_SHARE_INFO_1501, num_entries);
669 int i = 0;
670
671 if (!info1501) {
672 return False;
673 }
674
675 for (snum = *resume_hnd; snum < num_services; snum++) {
676 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
677 init_srv_share_info_1501(p, &info1501[i++], snum);
678 }
679 }
680
681 ctr->share.info1501 = info1501;
682 break;
683 }
684 default:
685 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n", info_level));
686 return False;
687 }
688
689 return True;
690}
691
692/*******************************************************************
693 Inits a SRV_R_NET_SHARE_ENUM structure.
694********************************************************************/
695
696static void init_srv_r_net_share_enum(pipes_struct *p, SRV_R_NET_SHARE_ENUM *r_n,
697 uint32 info_level, uint32 resume_hnd, BOOL all)
698{
699 DEBUG(5,("init_srv_r_net_share_enum: %d\n", __LINE__));
700
701 if (init_srv_share_info_ctr(p, &r_n->ctr, info_level,
702 &resume_hnd, &r_n->total_entries, all)) {
703 r_n->status = WERR_OK;
704 } else {
705 r_n->status = WERR_UNKNOWN_LEVEL;
706 }
707
708 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
709}
710
711/*******************************************************************
712 Inits a SRV_R_NET_SHARE_GET_INFO structure.
713********************************************************************/
714
715static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_INFO *r_n,
716 char *share_name, uint32 info_level)
717{
718 WERROR status = WERR_OK;
719 int snum;
720
721 DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
722
723 r_n->info.switch_value = info_level;
724
725 snum = find_service(share_name);
726
727 if (snum >= 0) {
728 switch (info_level) {
729 case 0:
730 init_srv_share_info_0(p, &r_n->info.share.info0, snum);
731 break;
732 case 1:
733 init_srv_share_info_1(p, &r_n->info.share.info1, snum);
734 break;
735 case 2:
736 init_srv_share_info_2(p, &r_n->info.share.info2, snum);
737 break;
738 case 501:
739 init_srv_share_info_501(p, &r_n->info.share.info501, snum);
740 break;
741 case 502:
742 init_srv_share_info_502(p, &r_n->info.share.info502, snum);
743 break;
744
745 /* here for completeness */
746 case 1004:
747 init_srv_share_info_1004(p, &r_n->info.share.info1004, snum);
748 break;
749 case 1005:
750 init_srv_share_info_1005(p, &r_n->info.share.info1005, snum);
751 break;
752
753 /* here for completeness 1006 - 1501 */
754 case 1006:
755 init_srv_share_info_1006(p, &r_n->info.share.info1006, snum);
756 break;
757 case 1007:
758 init_srv_share_info_1007(p, &r_n->info.share.info1007, snum);
759 break;
760 case 1501:
761 init_srv_share_info_1501(p, &r_n->info.share.info1501, snum);
762 break;
763 default:
764 DEBUG(5,("init_srv_net_share_get_info: unsupported switch value %d\n", info_level));
765 status = WERR_UNKNOWN_LEVEL;
766 break;
767 }
768 } else {
769 status = WERR_INVALID_NAME;
770 }
771
772 r_n->info.ptr_share_ctr = W_ERROR_IS_OK(status) ? 1 : 0;
773 r_n->status = status;
774}
775
776/*******************************************************************
777 fill in a sess info level 0 structure.
778 ********************************************************************/
779
780static void init_srv_sess_info_0(SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *stot)
781{
782 struct sessionid *session_list;
783 uint32 num_entries = 0;
784 (*stot) = list_sessions(&session_list);
785
786 if (ss0 == NULL) {
787 if (snum) {
788 (*snum) = 0;
789 }
790 SAFE_FREE(session_list);
791 return;
792 }
793
794 DEBUG(5,("init_srv_sess_0_ss0\n"));
795
796 if (snum) {
797 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
798 init_srv_sess_info0( &ss0->info_0[num_entries], session_list[(*snum)].remote_machine);
799 num_entries++;
800 }
801
802 ss0->num_entries_read = num_entries;
803 ss0->ptr_sess_info = num_entries > 0 ? 1 : 0;
804 ss0->num_entries_read2 = num_entries;
805
806 if ((*snum) >= (*stot)) {
807 (*snum) = 0;
808 }
809
810 } else {
811 ss0->num_entries_read = 0;
812 ss0->ptr_sess_info = 0;
813 ss0->num_entries_read2 = 0;
814 }
815 SAFE_FREE(session_list);
816}
817
818/*******************************************************************
819********************************************************************/
820
821/* global needed to make use of the share_mode_forall() callback */
822static struct sess_file_count s_file_cnt;
823
824static void sess_file_fn( const struct share_mode_entry *e,
825 const char *sharepath, const char *fname, void *state )
826{
827 struct sess_file_count *sess = &s_file_cnt;
828
829 if ( (procid_to_pid(&e->pid) == sess->pid) && (sess->uid == e->uid) ) {
830 sess->count++;
831 }
832
833 return;
834}
835
836/*******************************************************************
837********************************************************************/
838
839static int net_count_files( uid_t uid, pid_t pid )
840{
841 s_file_cnt.count = 0;
842 s_file_cnt.uid = uid;
843 s_file_cnt.pid = pid;
844
845 share_mode_forall( sess_file_fn, NULL );
846
847 return s_file_cnt.count;
848}
849
850/*******************************************************************
851 fill in a sess info level 1 structure.
852 ********************************************************************/
853
854static void init_srv_sess_info_1(SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *stot)
855{
856 struct sessionid *session_list;
857 uint32 num_entries = 0;
858 time_t now = time(NULL);
859
860 if ( !snum ) {
861 ss1->num_entries_read = 0;
862 ss1->ptr_sess_info = 0;
863 ss1->num_entries_read2 = 0;
864
865 (*stot) = 0;
866
867 return;
868 }
869
870 if (ss1 == NULL) {
871 (*snum) = 0;
872 return;
873 }
874
875 (*stot) = list_sessions(&session_list);
876
877
878 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
879 uint32 num_files;
880 uint32 connect_time;
881 struct passwd *pw = sys_getpwnam(session_list[*snum].username);
882 BOOL guest;
883
884 if ( !pw ) {
885 DEBUG(10,("init_srv_sess_info_1: failed to find owner: %s\n",
886 session_list[*snum].username));
887 continue;
888 }
889
890 connect_time = (uint32)(now - session_list[*snum].connect_start);
891 num_files = net_count_files(pw->pw_uid, session_list[*snum].pid);
892 guest = strequal( session_list[*snum].username, lp_guestaccount() );
893
894 init_srv_sess_info1( &ss1->info_1[num_entries],
895 session_list[*snum].remote_machine,
896 session_list[*snum].username,
897 num_files,
898 connect_time,
899 0,
900 guest);
901 num_entries++;
902 }
903
904 ss1->num_entries_read = num_entries;
905 ss1->ptr_sess_info = num_entries > 0 ? 1 : 0;
906 ss1->num_entries_read2 = num_entries;
907
908 if ((*snum) >= (*stot)) {
909 (*snum) = 0;
910 }
911
912 SAFE_FREE(session_list);
913}
914
915/*******************************************************************
916 makes a SRV_R_NET_SESS_ENUM structure.
917********************************************************************/
918
919static WERROR init_srv_sess_info_ctr(SRV_SESS_INFO_CTR *ctr,
920 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
921{
922 WERROR status = WERR_OK;
923 DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
924
925 ctr->switch_value = switch_value;
926
927 switch (switch_value) {
928 case 0:
929 init_srv_sess_info_0(&(ctr->sess.info0), resume_hnd, total_entries);
930 ctr->ptr_sess_ctr = 1;
931 break;
932 case 1:
933 init_srv_sess_info_1(&(ctr->sess.info1), resume_hnd, total_entries);
934 ctr->ptr_sess_ctr = 1;
935 break;
936 default:
937 DEBUG(5,("init_srv_sess_info_ctr: unsupported switch value %d\n", switch_value));
938 (*resume_hnd) = 0;
939 (*total_entries) = 0;
940 ctr->ptr_sess_ctr = 0;
941 status = WERR_UNKNOWN_LEVEL;
942 break;
943 }
944
945 return status;
946}
947
948/*******************************************************************
949 makes a SRV_R_NET_SESS_ENUM structure.
950********************************************************************/
951
952static void init_srv_r_net_sess_enum(SRV_R_NET_SESS_ENUM *r_n,
953 uint32 resume_hnd, int sess_level, int switch_value)
954{
955 DEBUG(5,("init_srv_r_net_sess_enum: %d\n", __LINE__));
956
957 r_n->sess_level = sess_level;
958
959 if (sess_level == -1)
960 r_n->status = WERR_UNKNOWN_LEVEL;
961 else
962 r_n->status = init_srv_sess_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
963
964 if (!W_ERROR_IS_OK(r_n->status))
965 resume_hnd = 0;
966
967 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
968}
969
970/*******************************************************************
971 fill in a conn info level 0 structure.
972 ********************************************************************/
973
974static void init_srv_conn_info_0(SRV_CONN_INFO_0 *ss0, uint32 *snum, uint32 *stot)
975{
976 uint32 num_entries = 0;
977 (*stot) = 1;
978
979 if (ss0 == NULL) {
980 (*snum) = 0;
981 return;
982 }
983
984 DEBUG(5,("init_srv_conn_0_ss0\n"));
985
986 if (snum) {
987 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
988
989 init_srv_conn_info0(&ss0->info_0[num_entries], (*stot));
990
991 /* move on to creating next connection */
992 /* move on to creating next conn */
993 num_entries++;
994 }
995
996 ss0->num_entries_read = num_entries;
997 ss0->ptr_conn_info = num_entries > 0 ? 1 : 0;
998 ss0->num_entries_read2 = num_entries;
999
1000 if ((*snum) >= (*stot)) {
1001 (*snum) = 0;
1002 }
1003
1004 } else {
1005 ss0->num_entries_read = 0;
1006 ss0->ptr_conn_info = 0;
1007 ss0->num_entries_read2 = 0;
1008
1009 (*stot) = 0;
1010 }
1011}
1012
1013/*******************************************************************
1014 fill in a conn info level 1 structure.
1015 ********************************************************************/
1016
1017static void init_srv_conn_1_info(CONN_INFO_1 *se1, CONN_INFO_1_STR *str1,
1018 uint32 id, uint32 type,
1019 uint32 num_opens, uint32 num_users, uint32 open_time,
1020 const char *usr_name, const char *net_name)
1021{
1022 init_srv_conn_info1(se1 , id, type, num_opens, num_users, open_time, usr_name, net_name);
1023 init_srv_conn_info1_str(str1, usr_name, net_name);
1024}
1025
1026/*******************************************************************
1027 fill in a conn info level 1 structure.
1028 ********************************************************************/
1029
1030static void init_srv_conn_info_1(SRV_CONN_INFO_1 *ss1, uint32 *snum, uint32 *stot)
1031{
1032 uint32 num_entries = 0;
1033 (*stot) = 1;
1034
1035 if (ss1 == NULL) {
1036 (*snum) = 0;
1037 return;
1038 }
1039
1040 DEBUG(5,("init_srv_conn_1_ss1\n"));
1041
1042 if (snum) {
1043 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
1044 init_srv_conn_1_info(&ss1->info_1[num_entries],
1045 &ss1->info_1_str[num_entries],
1046 (*stot), 0x3, 1, 1, 3,"dummy_user", "IPC$");
1047
1048 /* move on to creating next connection */
1049 /* move on to creating next conn */
1050 num_entries++;
1051 }
1052
1053 ss1->num_entries_read = num_entries;
1054 ss1->ptr_conn_info = num_entries > 0 ? 1 : 0;
1055 ss1->num_entries_read2 = num_entries;
1056
1057
1058 if ((*snum) >= (*stot)) {
1059 (*snum) = 0;
1060 }
1061
1062 } else {
1063 ss1->num_entries_read = 0;
1064 ss1->ptr_conn_info = 0;
1065 ss1->num_entries_read2 = 0;
1066
1067 (*stot) = 0;
1068 }
1069}
1070
1071/*******************************************************************
1072 makes a SRV_R_NET_CONN_ENUM structure.
1073********************************************************************/
1074
1075static WERROR init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
1076 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
1077{
1078 WERROR status = WERR_OK;
1079 DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
1080
1081 ctr->switch_value = switch_value;
1082
1083 switch (switch_value) {
1084 case 0:
1085 init_srv_conn_info_0(&ctr->conn.info0, resume_hnd, total_entries);
1086 ctr->ptr_conn_ctr = 1;
1087 break;
1088 case 1:
1089 init_srv_conn_info_1(&ctr->conn.info1, resume_hnd, total_entries);
1090 ctr->ptr_conn_ctr = 1;
1091 break;
1092 default:
1093 DEBUG(5,("init_srv_conn_info_ctr: unsupported switch value %d\n", switch_value));
1094 (*resume_hnd = 0);
1095 (*total_entries) = 0;
1096 ctr->ptr_conn_ctr = 0;
1097 status = WERR_UNKNOWN_LEVEL;
1098 break;
1099 }
1100
1101 return status;
1102}
1103
1104/*******************************************************************
1105 makes a SRV_R_NET_CONN_ENUM structure.
1106********************************************************************/
1107
1108static void init_srv_r_net_conn_enum(SRV_R_NET_CONN_ENUM *r_n,
1109 uint32 resume_hnd, int conn_level, int switch_value)
1110{
1111 DEBUG(5,("init_srv_r_net_conn_enum: %d\n", __LINE__));
1112
1113 r_n->conn_level = conn_level;
1114 if (conn_level == -1)
1115 r_n->status = WERR_UNKNOWN_LEVEL;
1116 else
1117 r_n->status = init_srv_conn_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
1118
1119 if (!W_ERROR_IS_OK(r_n->status))
1120 resume_hnd = 0;
1121
1122 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1123}
1124
1125/*******************************************************************
1126 makes a SRV_R_NET_FILE_ENUM structure.
1127********************************************************************/
1128
1129static WERROR net_file_enum_3( SRV_R_NET_FILE_ENUM *r, uint32 resume_hnd )
1130{
1131 TALLOC_CTX *ctx = get_talloc_ctx();
1132 SRV_FILE_INFO_CTR *ctr = &r->ctr;
1133
1134 /* TODO -- Windows enumerates
1135 (b) active pipes
1136 (c) open directories and files */
1137
1138 r->status = net_enum_files( ctx, &ctr->file.info3, &ctr->num_entries, resume_hnd );
1139 if ( !W_ERROR_IS_OK(r->status))
1140 goto done;
1141
1142 r->status = net_enum_pipes( ctx, &ctr->file.info3, &ctr->num_entries, resume_hnd );
1143 if ( !W_ERROR_IS_OK(r->status))
1144 goto done;
1145
1146 r->level = ctr->level = 3;
1147 r->total_entries = ctr->num_entries;
1148 /* ctr->num_entries = r->total_entries - resume_hnd; */
1149 ctr->num_entries2 = ctr->num_entries;
1150 ctr->ptr_file_info = 1;
1151
1152 r->status = WERR_OK;
1153
1154done:
1155 if ( ctr->num_entries > 0 )
1156 ctr->ptr_entries = 1;
1157
1158 init_enum_hnd(&r->enum_hnd, 0);
1159
1160 return r->status;
1161}
1162
1163/*******************************************************************
1164*******************************************************************/
1165
1166WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
1167{
1168 switch ( q_u->level ) {
1169 case 3:
1170 return net_file_enum_3( r_u, get_enum_hnd(&q_u->enum_hnd) );
1171 default:
1172 return WERR_UNKNOWN_LEVEL;
1173 }
1174
1175 return WERR_OK;
1176}
1177
1178/*******************************************************************
1179net server get info
1180********************************************************************/
1181
1182WERROR _srv_net_srv_get_info(pipes_struct *p, SRV_Q_NET_SRV_GET_INFO *q_u, SRV_R_NET_SRV_GET_INFO *r_u)
1183{
1184 WERROR status = WERR_OK;
1185 SRV_INFO_CTR *ctr = TALLOC_P(p->mem_ctx, SRV_INFO_CTR);
1186
1187 if (!ctr)
1188 return WERR_NOMEM;
1189
1190 ZERO_STRUCTP(ctr);
1191
1192 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1193
1194 if (!pipe_access_check(p)) {
1195 DEBUG(3, ("access denied to srv_net_srv_get_info\n"));
1196 return WERR_ACCESS_DENIED;
1197 }
1198
1199 switch (q_u->switch_value) {
1200
1201 /* Technically level 102 should only be available to
1202 Administrators but there isn't anything super-secret
1203 here, as most of it is made up. */
1204
1205 case 102:
1206 init_srv_info_102(&ctr->srv.sv102,
1207 500, global_myname(),
1208 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH),
1209 lp_major_announce_version(), lp_minor_announce_version(),
1210 lp_default_server_announce(),
1211 0xffffffff, /* users */
1212 0xf, /* disc */
1213 0, /* hidden */
1214 240, /* announce */
1215 3000, /* announce delta */
1216 100000, /* licenses */
1217 "c:\\"); /* user path */
1218 break;
1219 case 101:
1220 init_srv_info_101(&ctr->srv.sv101,
1221 500, global_myname(),
1222 lp_major_announce_version(), lp_minor_announce_version(),
1223 lp_default_server_announce(),
1224 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH));
1225 break;
1226 case 100:
1227 init_srv_info_100(&ctr->srv.sv100, 500, global_myname());
1228 break;
1229 default:
1230 status = WERR_UNKNOWN_LEVEL;
1231 break;
1232 }
1233
1234 /* set up the net server get info structure */
1235 init_srv_r_net_srv_get_info(r_u, q_u->switch_value, ctr, status);
1236
1237 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1238
1239 return r_u->status;
1240}
1241
1242/*******************************************************************
1243net server set info
1244********************************************************************/
1245
1246WERROR _srv_net_srv_set_info(pipes_struct *p, SRV_Q_NET_SRV_SET_INFO *q_u, SRV_R_NET_SRV_SET_INFO *r_u)
1247{
1248 WERROR status = WERR_OK;
1249
1250 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1251
1252 /* Set up the net server set info structure. */
1253
1254 init_srv_r_net_srv_set_info(r_u, 0x0, status);
1255
1256 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1257
1258 return r_u->status;
1259}
1260
1261/*******************************************************************
1262net conn enum
1263********************************************************************/
1264
1265WERROR _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
1266{
1267 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1268
1269 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_CONN_INFO_CTR);
1270 if (!r_u->ctr)
1271 return WERR_NOMEM;
1272
1273 ZERO_STRUCTP(r_u->ctr);
1274
1275 /* set up the */
1276 init_srv_r_net_conn_enum(r_u,
1277 get_enum_hnd(&q_u->enum_hnd),
1278 q_u->conn_level,
1279 q_u->ctr->switch_value);
1280
1281 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1282
1283 return r_u->status;
1284}
1285
1286/*******************************************************************
1287net sess enum
1288********************************************************************/
1289
1290WERROR _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
1291{
1292 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1293
1294 r_u->ctr = TALLOC_P(p->mem_ctx, SRV_SESS_INFO_CTR);
1295 if (!r_u->ctr)
1296 return WERR_NOMEM;
1297
1298 ZERO_STRUCTP(r_u->ctr);
1299
1300 /* set up the */
1301 init_srv_r_net_sess_enum(r_u,
1302 get_enum_hnd(&q_u->enum_hnd),
1303 q_u->sess_level,
1304 q_u->ctr->switch_value);
1305
1306 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1307
1308 return r_u->status;
1309}
1310
1311/*******************************************************************
1312net sess del
1313********************************************************************/
1314
1315WERROR _srv_net_sess_del(pipes_struct *p, SRV_Q_NET_SESS_DEL *q_u, SRV_R_NET_SESS_DEL *r_u)
1316{
1317 struct sessionid *session_list;
1318 struct current_user user;
1319 int num_sessions, snum;
1320 fstring username;
1321 fstring machine;
1322 BOOL not_root = False;
1323
1324 rpcstr_pull_unistr2_fstring(username, &q_u->uni_user_name);
1325 rpcstr_pull_unistr2_fstring(machine, &q_u->uni_cli_name);
1326
1327 /* strip leading backslashes if any */
1328 while (machine[0] == '\\') {
1329 memmove(machine, &machine[1], strlen(machine));
1330 }
1331
1332 num_sessions = list_sessions(&session_list);
1333
1334 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1335
1336 r_u->status = WERR_ACCESS_DENIED;
1337
1338 get_current_user(&user, p);
1339
1340 /* fail out now if you are not root or not a domain admin */
1341
1342 if ((user.ut.uid != sec_initial_uid()) &&
1343 ( ! nt_token_check_domain_rid(p->pipe_user.nt_user_token, DOMAIN_GROUP_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 if (user.ut.uid != sec_initial_uid()) {
1354 not_root = True;
1355 become_root();
1356 }
1357
1358 if (NT_STATUS_IS_OK(message_send_pid(pid_to_procid(session_list[snum].pid), MSG_SHUTDOWN, NULL, 0, False)))
1359 r_u->status = WERR_OK;
1360
1361 if (not_root)
1362 unbecome_root();
1363 }
1364 }
1365
1366 DEBUG(5,("_srv_net_sess_del: %d\n", __LINE__));
1367
1368
1369done:
1370 SAFE_FREE(session_list);
1371
1372 return r_u->status;
1373}
1374
1375/*******************************************************************
1376 Net share enum all.
1377********************************************************************/
1378
1379WERROR _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1380{
1381 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1382
1383 if (!pipe_access_check(p)) {
1384 DEBUG(3, ("access denied to srv_net_share_enum_all\n"));
1385 return WERR_ACCESS_DENIED;
1386 }
1387
1388 /* Create the list of shares for the response. */
1389 init_srv_r_net_share_enum(p, r_u,
1390 q_u->ctr.info_level,
1391 get_enum_hnd(&q_u->enum_hnd), True);
1392
1393 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1394
1395 return r_u->status;
1396}
1397
1398/*******************************************************************
1399 Net share enum.
1400********************************************************************/
1401
1402WERROR _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1403{
1404 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1405
1406 if (!pipe_access_check(p)) {
1407 DEBUG(3, ("access denied to srv_net_share_enum\n"));
1408 return WERR_ACCESS_DENIED;
1409 }
1410
1411 /* Create the list of shares for the response. */
1412 init_srv_r_net_share_enum(p, r_u,
1413 q_u->ctr.info_level,
1414 get_enum_hnd(&q_u->enum_hnd), False);
1415
1416 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1417
1418 return r_u->status;
1419}
1420
1421/*******************************************************************
1422 Net share get info.
1423********************************************************************/
1424
1425WERROR _srv_net_share_get_info(pipes_struct *p, SRV_Q_NET_SHARE_GET_INFO *q_u, SRV_R_NET_SHARE_GET_INFO *r_u)
1426{
1427 fstring share_name;
1428
1429 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1430
1431 /* Create the list of shares for the response. */
1432 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1433 init_srv_r_net_share_get_info(p, r_u, share_name, q_u->info_level);
1434
1435 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1436
1437 return r_u->status;
1438}
1439
1440/*******************************************************************
1441 Check a given DOS pathname is valid for a share.
1442********************************************************************/
1443
1444char *valid_share_pathname(char *dos_pathname)
1445{
1446 char *ptr;
1447
1448 /* Convert any '\' paths to '/' */
1449 unix_format(dos_pathname);
1450 unix_clean_name(dos_pathname);
1451
1452 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
1453 ptr = dos_pathname;
1454#ifdef __OS2__
1455 /* Only absolute paths allowed. */
1456 if (strlen(dos_pathname) < 2 || ptr[1] != ':')
1457 return NULL;
1458#else
1459 if (strlen(dos_pathname) > 2 && ptr[1] == ':' && ptr[0] != '/')
1460 ptr += 2;
1461
1462 /* Only absolute paths allowed. */
1463 if (*ptr != '/')
1464 return NULL;
1465#endif
1466 return ptr;
1467}
1468
1469/*******************************************************************
1470 Net share set info. Modify share details.
1471********************************************************************/
1472
1473WERROR _srv_net_share_set_info(pipes_struct *p, SRV_Q_NET_SHARE_SET_INFO *q_u, SRV_R_NET_SHARE_SET_INFO *r_u)
1474{
1475 struct current_user user;
1476 pstring command;
1477 fstring share_name;
1478 fstring comment;
1479 pstring pathname;
1480 int type;
1481 int snum;
1482 int ret;
1483 char *path;
1484 SEC_DESC *psd = NULL;
1485 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1486 BOOL is_disk_op = False;
1487 int max_connections = 0;
1488
1489 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1490
1491 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1492
1493 r_u->parm_error = 0;
1494
1495 if ( strequal(share_name,"IPC$")
1496 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1497 || strequal(share_name,"global") )
1498 {
1499 return WERR_ACCESS_DENIED;
1500 }
1501
1502 snum = find_service(share_name);
1503
1504 /* Does this share exist ? */
1505 if (snum < 0)
1506 return WERR_NET_NAME_NOT_FOUND;
1507
1508 /* No change to printer shares. */
1509 if (lp_print_ok(snum))
1510 return WERR_ACCESS_DENIED;
1511
1512 get_current_user(&user,p);
1513
1514 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1515
1516 /* fail out now if you are not root and not a disk op */
1517
1518 if ( user.ut.uid != sec_initial_uid() && !is_disk_op )
1519 return WERR_ACCESS_DENIED;
1520
1521 switch (q_u->info_level) {
1522 case 1:
1523 pstrcpy(pathname, lp_pathname(snum));
1524 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
1525 type = q_u->info.share.info2.info_2.type;
1526 psd = NULL;
1527 break;
1528 case 2:
1529 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
1530 unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(pathname));
1531 type = q_u->info.share.info2.info_2.type;
1532 max_connections = (q_u->info.share.info2.info_2.max_uses == 0xffffffff) ? 0 : q_u->info.share.info2.info_2.max_uses;
1533 psd = NULL;
1534 break;
1535#if 0
1536 /* not supported on set but here for completeness */
1537 case 501:
1538 unistr2_to_ascii(comment, &q_u->info.share.info501.info_501_str.uni_remark, sizeof(comment));
1539 type = q_u->info.share.info501.info_501.type;
1540 psd = NULL;
1541 break;
1542#endif
1543 case 502:
1544 unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(comment));
1545 unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(pathname));
1546 type = q_u->info.share.info502.info_502.type;
1547 psd = q_u->info.share.info502.info_502_str.sd;
1548 map_generic_share_sd_bits(psd);
1549 break;
1550 case 1004:
1551 pstrcpy(pathname, lp_pathname(snum));
1552 unistr2_to_ascii(comment, &q_u->info.share.info1004.info_1004_str.uni_remark, sizeof(comment));
1553 type = STYPE_DISKTREE;
1554 break;
1555 case 1005:
1556 /* XP re-sets the csc policy even if it wasn't changed by the
1557 user, so we must compare it to see if it's what is set in
1558 smb.conf, so that we can contine other ops like setting
1559 ACLs on a share */
1560 if (((q_u->info.share.info1005.share_info_flags &
1561 SHARE_1005_CSC_POLICY_MASK) >>
1562 SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
1563 return WERR_OK;
1564 else {
1565 DEBUG(3, ("_srv_net_share_set_info: client is trying to change csc policy from the network; must be done with smb.conf\n"));
1566 return WERR_ACCESS_DENIED;
1567 }
1568 case 1006:
1569 case 1007:
1570 return WERR_ACCESS_DENIED;
1571 case 1501:
1572 pstrcpy(pathname, lp_pathname(snum));
1573 fstrcpy(comment, lp_comment(snum));
1574 psd = q_u->info.share.info1501.sdb->sec;
1575 map_generic_share_sd_bits(psd);
1576 type = STYPE_DISKTREE;
1577 break;
1578 default:
1579 DEBUG(5,("_srv_net_share_set_info: unsupported switch value %d\n", q_u->info_level));
1580 return WERR_UNKNOWN_LEVEL;
1581 }
1582
1583 /* We can only modify disk shares. */
1584 if (type != STYPE_DISKTREE)
1585 return WERR_ACCESS_DENIED;
1586
1587 /* Check if the pathname is valid. */
1588 if (!(path = valid_share_pathname( pathname )))
1589 return WERR_OBJECT_PATH_INVALID;
1590
1591 /* Ensure share name, pathname and comment don't contain '"' characters. */
1592 string_replace(share_name, '"', ' ');
1593 string_replace(path, '"', ' ');
1594 string_replace(comment, '"', ' ');
1595
1596 DEBUG(10,("_srv_net_share_set_info: change share command = %s\n",
1597 lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
1598
1599 /* Only call modify function if something changed. */
1600
1601 if (strcmp(path, lp_pathname(snum)) || strcmp(comment, lp_comment(snum))
1602 || (lp_max_connections(snum) != max_connections) )
1603 {
1604 if (!lp_change_share_cmd() || !*lp_change_share_cmd()) {
1605 DEBUG(10,("_srv_net_share_set_info: No change share command\n"));
1606 return WERR_ACCESS_DENIED;
1607 }
1608
1609 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1610 lp_change_share_cmd(), dyn_CONFIGFILE, share_name, path, comment, max_connections );
1611
1612 DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
1613
1614 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1615
1616 if ( is_disk_op )
1617 become_root();
1618
1619 if ( (ret = smbrun(command, NULL)) == 0 ) {
1620 /* Tell everyone we updated smb.conf. */
1621 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1622 }
1623
1624 if ( is_disk_op )
1625 unbecome_root();
1626
1627 /********* END SeDiskOperatorPrivilege BLOCK *********/
1628
1629 DEBUG(3,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
1630
1631 if ( ret != 0 )
1632 return WERR_ACCESS_DENIED;
1633 } else {
1634 DEBUG(10,("_srv_net_share_set_info: No change to share name (%s)\n", share_name ));
1635 }
1636
1637 /* Replace SD if changed. */
1638 if (psd) {
1639 SEC_DESC *old_sd;
1640 size_t sd_size;
1641
1642 old_sd = get_share_security(p->mem_ctx, lp_servicename(snum), &sd_size);
1643
1644 if (old_sd && !sec_desc_equal(old_sd, psd)) {
1645 if (!set_share_security(share_name, psd))
1646 DEBUG(0,("_srv_net_share_set_info: Failed to change security info in share %s.\n",
1647 share_name ));
1648 }
1649 }
1650
1651 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1652
1653 return WERR_OK;
1654}
1655
1656/*******************************************************************
1657 Net share add. Call 'add_share_command "sharename" "pathname"
1658 "comment" "max connections = "
1659********************************************************************/
1660
1661WERROR _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
1662{
1663 struct current_user user;
1664 pstring command;
1665 fstring share_name;
1666 fstring comment;
1667 pstring pathname;
1668 int type;
1669 int snum;
1670 int ret;
1671 char *path;
1672 SEC_DESC *psd = NULL;
1673 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1674 BOOL is_disk_op;
1675 int max_connections = 0;
1676
1677 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1678
1679 r_u->parm_error = 0;
1680
1681 get_current_user(&user,p);
1682
1683 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1684
1685 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1686 return WERR_ACCESS_DENIED;
1687
1688 if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
1689 DEBUG(10,("_srv_net_share_add: No add share command\n"));
1690 return WERR_ACCESS_DENIED;
1691 }
1692
1693 switch (q_u->info_level) {
1694 case 0:
1695 /* No path. Not enough info in a level 0 to do anything. */
1696 return WERR_ACCESS_DENIED;
1697 case 1:
1698 /* Not enough info in a level 1 to do anything. */
1699 return WERR_ACCESS_DENIED;
1700 case 2:
1701 unistr2_to_ascii(share_name, &q_u->info.share.info2.info_2_str.uni_netname, sizeof(share_name));
1702 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(share_name));
1703 unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(share_name));
1704 max_connections = (q_u->info.share.info2.info_2.max_uses == 0xffffffff) ? 0 : q_u->info.share.info2.info_2.max_uses;
1705 type = q_u->info.share.info2.info_2.type;
1706 break;
1707 case 501:
1708 /* No path. Not enough info in a level 501 to do anything. */
1709 return WERR_ACCESS_DENIED;
1710 case 502:
1711 unistr2_to_ascii(share_name, &q_u->info.share.info502.info_502_str.uni_netname, sizeof(share_name));
1712 unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(share_name));
1713 unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(share_name));
1714 type = q_u->info.share.info502.info_502.type;
1715 psd = q_u->info.share.info502.info_502_str.sd;
1716 map_generic_share_sd_bits(psd);
1717 break;
1718
1719 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
1720
1721 case 1004:
1722 case 1005:
1723 case 1006:
1724 case 1007:
1725 return WERR_ACCESS_DENIED;
1726 case 1501:
1727 /* DFS only level. */
1728 return WERR_ACCESS_DENIED;
1729 default:
1730 DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n", q_u->info_level));
1731 return WERR_UNKNOWN_LEVEL;
1732 }
1733
1734 /* check for invalid share names */
1735
1736 if ( !validate_net_name( share_name, INVALID_SHARENAME_CHARS, sizeof(share_name) ) ) {
1737 DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", share_name));
1738 return WERR_INVALID_NAME;
1739 }
1740
1741 if ( strequal(share_name,"IPC$") || strequal(share_name,"global")
1742 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") ) )
1743 {
1744 return WERR_ACCESS_DENIED;
1745 }
1746
1747 snum = find_service(share_name);
1748
1749 /* Share already exists. */
1750 if (snum >= 0)
1751 return WERR_ALREADY_EXISTS;
1752
1753 /* We can only add disk shares. */
1754 if (type != STYPE_DISKTREE)
1755 return WERR_ACCESS_DENIED;
1756
1757 /* Check if the pathname is valid. */
1758 if (!(path = valid_share_pathname( pathname )))
1759 return WERR_OBJECT_PATH_INVALID;
1760
1761 /* Ensure share name, pathname and comment don't contain '"' characters. */
1762 string_replace(share_name, '"', ' ');
1763 string_replace(path, '"', ' ');
1764 string_replace(comment, '"', ' ');
1765
1766 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" %d",
1767 lp_add_share_cmd(),
1768 dyn_CONFIGFILE,
1769 share_name,
1770 path,
1771 comment,
1772 max_connections);
1773
1774 DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
1775
1776 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1777
1778 if ( is_disk_op )
1779 become_root();
1780
1781 if ( (ret = smbrun(command, NULL)) == 0 ) {
1782 /* Tell everyone we updated smb.conf. */
1783 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1784 }
1785
1786 if ( is_disk_op )
1787 unbecome_root();
1788
1789 /********* END SeDiskOperatorPrivilege BLOCK *********/
1790
1791 DEBUG(3,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
1792
1793 if ( ret != 0 )
1794 return WERR_ACCESS_DENIED;
1795
1796 if (psd) {
1797 if (!set_share_security(share_name, psd)) {
1798 DEBUG(0,("_srv_net_share_add: Failed to add security info to share %s.\n", share_name ));
1799 }
1800 }
1801
1802 /*
1803 * We don't call reload_services() here, the message will
1804 * cause this to be done before the next packet is read
1805 * from the client. JRA.
1806 */
1807
1808 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1809
1810 return WERR_OK;
1811}
1812
1813/*******************************************************************
1814 Net share delete. Call "delete share command" with the share name as
1815 a parameter.
1816********************************************************************/
1817
1818WERROR _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
1819{
1820 struct current_user user;
1821 pstring command;
1822 fstring share_name;
1823 int ret;
1824 int snum;
1825 SE_PRIV se_diskop = SE_DISK_OPERATOR;
1826 BOOL is_disk_op;
1827 struct share_params *params;
1828
1829 DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
1830
1831 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1832
1833 if ( strequal(share_name,"IPC$")
1834 || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
1835 || strequal(share_name,"global") )
1836 {
1837 return WERR_ACCESS_DENIED;
1838 }
1839
1840 if (!(params = get_share_params(p->mem_ctx, share_name))) {
1841 return WERR_NO_SUCH_SHARE;
1842 }
1843
1844 snum = find_service(share_name);
1845
1846 /* No change to printer shares. */
1847 if (lp_print_ok(snum))
1848 return WERR_ACCESS_DENIED;
1849
1850 get_current_user(&user,p);
1851
1852 is_disk_op = user_has_privileges( p->pipe_user.nt_user_token, &se_diskop );
1853
1854 if (user.ut.uid != sec_initial_uid() && !is_disk_op )
1855 return WERR_ACCESS_DENIED;
1856
1857 if (!lp_delete_share_cmd() || !*lp_delete_share_cmd()) {
1858 DEBUG(10,("_srv_net_share_del: No delete share command\n"));
1859 return WERR_ACCESS_DENIED;
1860 }
1861
1862 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"",
1863 lp_delete_share_cmd(), dyn_CONFIGFILE, lp_servicename(snum));
1864
1865 DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
1866
1867 /********* BEGIN SeDiskOperatorPrivilege BLOCK *********/
1868
1869 if ( is_disk_op )
1870 become_root();
1871
1872 if ( (ret = smbrun(command, NULL)) == 0 ) {
1873 /* Tell everyone we updated smb.conf. */
1874 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1875 }
1876
1877 if ( is_disk_op )
1878 unbecome_root();
1879
1880 /********* END SeDiskOperatorPrivilege BLOCK *********/
1881
1882 DEBUG(3,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
1883
1884 if ( ret != 0 )
1885 return WERR_ACCESS_DENIED;
1886
1887 /* Delete the SD in the database. */
1888 delete_share_security(params);
1889
1890 lp_killservice(params->service);
1891
1892 return WERR_OK;
1893}
1894
1895WERROR _srv_net_share_del_sticky(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
1896{
1897 DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
1898
1899 return _srv_net_share_del(p, q_u, r_u);
1900}
1901
1902/*******************************************************************
1903time of day
1904********************************************************************/
1905
1906WERROR _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
1907{
1908 TIME_OF_DAY_INFO *tod;
1909 struct tm *t;
1910 time_t unixdate = time(NULL);
1911
1912 /* We do this call first as if we do it *after* the gmtime call
1913 it overwrites the pointed-to values. JRA */
1914
1915 uint32 zone = get_time_zone(unixdate)/60;
1916
1917 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
1918
1919 if ( !(tod = TALLOC_ZERO_P(p->mem_ctx, TIME_OF_DAY_INFO)) )
1920 return WERR_NOMEM;
1921
1922 r_u->tod = tod;
1923 r_u->ptr_srv_tod = 0x1;
1924 r_u->status = WERR_OK;
1925
1926 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
1927
1928 t = gmtime(&unixdate);
1929
1930 /* set up the */
1931 init_time_of_day_info(tod,
1932 unixdate,
1933 0,
1934 t->tm_hour,
1935 t->tm_min,
1936 t->tm_sec,
1937 0,
1938 zone,
1939 10000,
1940 t->tm_mday,
1941 t->tm_mon + 1,
1942 1900+t->tm_year,
1943 t->tm_wday);
1944
1945 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
1946
1947 return r_u->status;
1948}
1949
1950/***********************************************************************************
1951 Win9x NT tools get security descriptor.
1952***********************************************************************************/
1953
1954WERROR _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
1955 SRV_R_NET_FILE_QUERY_SECDESC *r_u)
1956{
1957 SEC_DESC *psd = NULL;
1958 size_t sd_size;
1959 DATA_BLOB null_pw;
1960 pstring filename;
1961 pstring qualname;
1962 files_struct *fsp = NULL;
1963 SMB_STRUCT_STAT st;
1964 NTSTATUS nt_status;
1965 struct current_user user;
1966 connection_struct *conn = NULL;
1967 BOOL became_user = False;
1968
1969 ZERO_STRUCT(st);
1970
1971 r_u->status = WERR_OK;
1972
1973 unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
1974
1975 /* Null password is ok - we are already an authenticated user... */
1976 null_pw = data_blob(NULL, 0);
1977
1978 get_current_user(&user, p);
1979
1980 become_root();
1981 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
1982 unbecome_root();
1983
1984 if (conn == NULL) {
1985 DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", qualname));
1986 r_u->status = ntstatus_to_werror(nt_status);
1987 goto error_exit;
1988 }
1989
1990 if (!become_user(conn, conn->vuid)) {
1991 DEBUG(0,("_srv_net_file_query_secdesc: Can't become connected user!\n"));
1992 r_u->status = WERR_ACCESS_DENIED;
1993 goto error_exit;
1994 }
1995 became_user = True;
1996
1997 unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
1998 nt_status = unix_convert(conn, filename, False, NULL, &st);
1999 if (!NT_STATUS_IS_OK(nt_status)) {
2000 DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", filename));
2001 r_u->status = WERR_ACCESS_DENIED;
2002 goto error_exit;
2003 }
2004
2005 nt_status = check_name(conn, filename);
2006 if (!NT_STATUS_IS_OK(nt_status)) {
2007 DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", filename));
2008 r_u->status = WERR_ACCESS_DENIED;
2009 goto error_exit;
2010 }
2011
2012 nt_status = open_file_stat(conn, filename, &st, &fsp);
2013 if ( !NT_STATUS_IS_OK(nt_status)) {
2014 /* Perhaps it is a directory */
2015 if (errno == EISDIR)
2016 nt_status = open_directory(conn, filename, &st,
2017 READ_CONTROL_ACCESS,
2018 FILE_SHARE_READ|FILE_SHARE_WRITE,
2019 FILE_OPEN,
2020 0,
2021 FILE_ATTRIBUTE_DIRECTORY,
2022 NULL, &fsp);
2023
2024 if (!NT_STATUS_IS_OK(nt_status)) {
2025 DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", filename));
2026 r_u->status = ntstatus_to_werror(nt_status);
2027 goto error_exit;
2028 }
2029 }
2030
2031 sd_size = SMB_VFS_GET_NT_ACL(fsp, fsp->fsp_name, (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
2032
2033 if (sd_size == 0) {
2034 DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
2035 r_u->status = WERR_ACCESS_DENIED;
2036 goto error_exit;
2037 }
2038
2039 r_u->ptr_response = 1;
2040 r_u->size_response = sd_size;
2041 r_u->ptr_secdesc = 1;
2042 r_u->size_secdesc = sd_size;
2043 r_u->sec_desc = psd;
2044
2045 psd->dacl->revision = (uint16) NT4_ACL_REVISION;
2046
2047 close_file(fsp, NORMAL_CLOSE);
2048 unbecome_user();
2049 close_cnum(conn, user.vuid);
2050 return r_u->status;
2051
2052error_exit:
2053
2054 if(fsp) {
2055 close_file(fsp, NORMAL_CLOSE);
2056 }
2057
2058 if (became_user)
2059 unbecome_user();
2060
2061 if (conn)
2062 close_cnum(conn, user.vuid);
2063
2064 return r_u->status;
2065}
2066
2067/***********************************************************************************
2068 Win9x NT tools set security descriptor.
2069***********************************************************************************/
2070
2071WERROR _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
2072 SRV_R_NET_FILE_SET_SECDESC *r_u)
2073{
2074 BOOL ret;
2075 pstring filename;
2076 pstring qualname;
2077 DATA_BLOB null_pw;
2078 files_struct *fsp = NULL;
2079 SMB_STRUCT_STAT st;
2080 NTSTATUS nt_status;
2081 struct current_user user;
2082 connection_struct *conn = NULL;
2083 BOOL became_user = False;
2084
2085 ZERO_STRUCT(st);
2086
2087 r_u->status = WERR_OK;
2088
2089 unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
2090
2091 /* Null password is ok - we are already an authenticated user... */
2092 null_pw = data_blob(NULL, 0);
2093
2094 get_current_user(&user, p);
2095
2096 become_root();
2097 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
2098 unbecome_root();
2099
2100 if (conn == NULL) {
2101 DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", qualname));
2102 r_u->status = ntstatus_to_werror(nt_status);
2103 goto error_exit;
2104 }
2105
2106 if (!become_user(conn, conn->vuid)) {
2107 DEBUG(0,("_srv_net_file_set_secdesc: Can't become connected user!\n"));
2108 r_u->status = WERR_ACCESS_DENIED;
2109 goto error_exit;
2110 }
2111 became_user = True;
2112
2113 unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
2114 nt_status = unix_convert(conn, filename, False, NULL, &st);
2115 if (!NT_STATUS_IS_OK(nt_status)) {
2116 DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", filename));
2117 r_u->status = WERR_ACCESS_DENIED;
2118 goto error_exit;
2119 }
2120
2121 nt_status = check_name(conn, filename);
2122 if (!NT_STATUS_IS_OK(nt_status)) {
2123 DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", filename));
2124 r_u->status = WERR_ACCESS_DENIED;
2125 goto error_exit;
2126 }
2127
2128
2129 nt_status = open_file_stat(conn, filename, &st, &fsp);
2130
2131 if ( !NT_STATUS_IS_OK(nt_status) ) {
2132 /* Perhaps it is a directory */
2133 if (errno == EISDIR)
2134 nt_status = open_directory(conn, filename, &st,
2135 FILE_READ_ATTRIBUTES,
2136 FILE_SHARE_READ|FILE_SHARE_WRITE,
2137 FILE_OPEN,
2138 0,
2139 FILE_ATTRIBUTE_DIRECTORY,
2140 NULL, &fsp);
2141
2142 if ( !NT_STATUS_IS_OK(nt_status) ) {
2143 DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", filename));
2144 r_u->status = ntstatus_to_werror(nt_status);
2145 goto error_exit;
2146 }
2147 }
2148
2149 ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
2150
2151 if (ret == False) {
2152 DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
2153 r_u->status = WERR_ACCESS_DENIED;
2154 goto error_exit;
2155 }
2156
2157 close_file(fsp, NORMAL_CLOSE);
2158 unbecome_user();
2159 close_cnum(conn, user.vuid);
2160 return r_u->status;
2161
2162error_exit:
2163
2164 if(fsp) {
2165 close_file(fsp, NORMAL_CLOSE);
2166 }
2167
2168 if (became_user) {
2169 unbecome_user();
2170 }
2171
2172 if (conn) {
2173 close_cnum(conn, user.vuid);
2174 }
2175
2176 return r_u->status;
2177}
2178
2179/***********************************************************************************
2180 It may be that we want to limit users to creating shares on certain areas of the UNIX file area.
2181 We could define areas by mapping Windows style disks to points on the UNIX directory hierarchy.
2182 These disks would the disks listed by this function.
2183 Users could then create shares relative to these disks. Watch out for moving these disks around.
2184 "Nigel Williams" <nigel@veritas.com>.
2185***********************************************************************************/
2186
2187static const char *server_disks[] = {"C:"
2188#ifdef __OS2__
2189 // YD we can use a better implementation (real time scan or above idea)
2190 ,"D:","E:","F:","G:","H:","I:","J:","K:","L:","M:","N:","O:"
2191 ,"P:","Q:","R:","S:","T:","U:","V:","W:","X:","Y:","Z:"
2192#endif
2193};
2194
2195static uint32 get_server_disk_count(void)
2196{
2197 return sizeof(server_disks)/sizeof(server_disks[0]);
2198}
2199
2200static uint32 init_server_disk_enum(uint32 *resume)
2201{
2202 uint32 server_disk_count = get_server_disk_count();
2203
2204 /*resume can be an offset into the list for now*/
2205
2206 if(*resume & 0x80000000)
2207 *resume = 0;
2208
2209 if(*resume > server_disk_count)
2210 *resume = server_disk_count;
2211
2212 return server_disk_count - *resume;
2213}
2214
2215static const char *next_server_disk_enum(uint32 *resume)
2216{
2217 const char *disk;
2218
2219 if(init_server_disk_enum(resume) == 0)
2220 return NULL;
2221
2222 disk = server_disks[*resume];
2223
2224 (*resume)++;
2225
2226 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2227
2228 return disk;
2229}
2230
2231WERROR _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
2232{
2233 uint32 i;
2234 const char *disk_name;
2235 TALLOC_CTX *ctx = p->mem_ctx;
2236 uint32 resume=get_enum_hnd(&q_u->enum_hnd);
2237
2238 r_u->status=WERR_OK;
2239
2240 r_u->total_entries = init_server_disk_enum(&resume);
2241
2242 r_u->disk_enum_ctr.unknown = 0;
2243
2244 if(!(r_u->disk_enum_ctr.disk_info = TALLOC_ARRAY(ctx, DISK_INFO, MAX_SERVER_DISK_ENTRIES))) {
2245 return WERR_NOMEM;
2246 }
2247
2248 r_u->disk_enum_ctr.disk_info_ptr = r_u->disk_enum_ctr.disk_info ? 1 : 0;
2249
2250 /*allow one DISK_INFO for null terminator*/
2251
2252 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2253
2254 r_u->disk_enum_ctr.entries_read++;
2255
2256 /*copy disk name into a unicode string*/
2257
2258 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, disk_name);
2259 }
2260
2261 /* add a terminating null string. Is this there if there is more data to come? */
2262
2263 r_u->disk_enum_ctr.entries_read++;
2264
2265 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, "");
2266
2267 init_enum_hnd(&r_u->enum_hnd, resume);
2268
2269 return r_u->status;
2270}
2271
2272/********************************************************************
2273********************************************************************/
2274
2275WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
2276{
2277 fstring sharename;
2278
2279 switch ( q_u->type ) {
2280 case 0x9:
2281 rpcstr_pull(sharename, q_u->sharename.buffer, sizeof(sharename), q_u->sharename.uni_str_len*2, 0);
2282 if ( !validate_net_name( sharename, INVALID_SHARENAME_CHARS, sizeof(sharename) ) ) {
2283 DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", sharename));
2284 return WERR_INVALID_NAME;
2285 }
2286 break;
2287
2288 default:
2289 return WERR_UNKNOWN_LEVEL;
2290 }
2291
2292 return WERR_OK;
2293}
2294
2295
2296/********************************************************************
2297********************************************************************/
2298
2299WERROR _srv_net_file_close(pipes_struct *p, SRV_Q_NET_FILE_CLOSE *q_u, SRV_R_NET_FILE_CLOSE *r_u)
2300{
2301 return WERR_ACCESS_DENIED;
2302}
2303
Note: See TracBrowser for help on using the repository browser.