?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r5168: more merges from 3_0
[Samba.git] / source / rpc_server / srv_srvsvc_nt.c
blob13e1971925aa818904a5c14a6aa0e820ad02641c
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 if ( (ret = smbrun(command, NULL)) == 0 ) {
1584 /* Tell everyone we updated smb.conf. */
1585 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1586 }
1587
1588 if ( is_disk_op )
1589 unbecome_root();
1590
1591 /********* END SeDiskOperatorPrivilege BLOCK *********/
1592
1593 DEBUG(3,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
1594
1595 if ( ret != 0 )
1596 return WERR_ACCESS_DENIED;
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 if ( (ret = smbrun(command, NULL)) == 0 ) {
1729 /* Tell everyone we updated smb.conf. */
1730 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1731 }
1732
1733 if ( is_disk_op )
1734 unbecome_root();
1735
1736 /********* END SeDiskOperatorPrivilege BLOCK *********/
1737
1738 DEBUG(3,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
1739
1740 if ( ret != 0 )
1741 return WERR_ACCESS_DENIED;
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 if ( (ret = smbrun(command, NULL)) == 0 ) {
1812 /* Tell everyone we updated smb.conf. */
1813 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1814 }
1815
1816 if ( is_disk_op )
1817 unbecome_root();
1818
1819 /********* END SeDiskOperatorPrivilege BLOCK *********/
1820
1821 DEBUG(3,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
1822
1823 if ( ret != 0 )
1824 return WERR_ACCESS_DENIED;
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 }
Samba GIT mirror