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