?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First round of merging various UUID structures.
[Samba/gebeck_regimport.git] / source3 / rpc_server / srv_srvsvc_nt.c
blob4d1cf9bddcb84cd268a1a96c15b8f380d8b4ae10
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 int len_net_name;
360 pstring remark;
361
362 char *net_name = lp_servicename(snum);
363 pstrcpy(remark, lp_comment(snum));
364 standard_sub_conn(p->conn, remark, sizeof(remark));
365
366 len_net_name = strlen(net_name);
367
368 init_srv_share_info501(&sh501->info_501, net_name, get_share_type(snum), remark, (lp_csc_policy(snum) << 4));
369 init_srv_share_info501_str(&sh501->info_501_str, net_name, remark);
370 }
371
372 /*******************************************************************
373 Fill in a share info level 502 structure.
374 ********************************************************************/
375
376 static void init_srv_share_info_502(pipes_struct *p, SRV_SHARE_INFO_502 *sh502, int snum)
377 {
378 int len_net_name;
379 pstring net_name;
380 pstring remark;
381 pstring path;
382 pstring passwd;
383 SEC_DESC *sd;
384 size_t sd_size;
385 TALLOC_CTX *ctx = p->mem_ctx;
386
387
388 ZERO_STRUCTP(sh502);
389
390 pstrcpy(net_name, lp_servicename(snum));
391 pstrcpy(remark, lp_comment(snum));
392 standard_sub_conn(p->conn, remark,sizeof(remark));
393 pstrcpy(path, "C:");
394 pstrcat(path, lp_pathname(snum));
395
396 /*
397 * Change / to \\ so that win2k will see it as a valid path. This was added to
398 * enable use of browsing in win2k add share dialog.
399 */
400
401 string_replace(path, '/', '\\');
402
403 pstrcpy(passwd, "");
404 len_net_name = strlen(net_name);
405
406 sd = get_share_security(ctx, snum, &sd_size);
407
408 init_srv_share_info502(&sh502->info_502, net_name, get_share_type(snum), remark, 0, 0xffffffff, 1, path, passwd, sd, sd_size);
409 init_srv_share_info502_str(&sh502->info_502_str, net_name, remark, path, passwd, sd, sd_size);
410 }
411
412 /***************************************************************************
413 Fill in a share info level 1004 structure.
414 ***************************************************************************/
415
416 static void init_srv_share_info_1004(pipes_struct *p, SRV_SHARE_INFO_1004* sh1004, int snum)
417 {
418 pstring remark;
419
420 pstrcpy(remark, lp_comment(snum));
421 standard_sub_conn(p->conn, remark, sizeof(remark));
422
423 ZERO_STRUCTP(sh1004);
424
425 init_srv_share_info1004(&sh1004->info_1004, remark);
426 init_srv_share_info1004_str(&sh1004->info_1004_str, remark);
427 }
428
429 /***************************************************************************
430 Fill in a share info level 1005 structure.
431 ***************************************************************************/
432
433 static void init_srv_share_info_1005(pipes_struct *p, SRV_SHARE_INFO_1005* sh1005, int snum)
434 {
435 sh1005->share_info_flags = 0;
436
437 if(lp_host_msdfs() && lp_msdfs_root(snum))
438 sh1005->share_info_flags |=
439 SHARE_1005_IN_DFS | SHARE_1005_DFS_ROOT;
440 sh1005->share_info_flags |=
441 lp_csc_policy(snum) << SHARE_1005_CSC_POLICY_SHIFT;
442 }
443 /***************************************************************************
444 Fill in a share info level 1006 structure.
445 ***************************************************************************/
446
447 static void init_srv_share_info_1006(pipes_struct *p, SRV_SHARE_INFO_1006* sh1006, int snum)
448 {
449 sh1006->max_uses = -1;
450 }
451
452 /***************************************************************************
453 Fill in a share info level 1007 structure.
454 ***************************************************************************/
455
456 static void init_srv_share_info_1007(pipes_struct *p, SRV_SHARE_INFO_1007* sh1007, int snum)
457 {
458 pstring alternate_directory_name = "";
459 uint32 flags = 0;
460
461 ZERO_STRUCTP(sh1007);
462
463 init_srv_share_info1007(&sh1007->info_1007, flags, alternate_directory_name);
464 init_srv_share_info1007_str(&sh1007->info_1007_str, alternate_directory_name);
465 }
466
467 /*******************************************************************
468 Fill in a share info level 1501 structure.
469 ********************************************************************/
470
471 static void init_srv_share_info_1501(pipes_struct *p, SRV_SHARE_INFO_1501 *sh1501, int snum)
472 {
473 SEC_DESC *sd;
474 size_t sd_size;
475 TALLOC_CTX *ctx = p->mem_ctx;
476
477 ZERO_STRUCTP(sh1501);
478
479 sd = get_share_security(ctx, snum, &sd_size);
480
481 sh1501->sdb = make_sec_desc_buf(p->mem_ctx, sd_size, sd);
482 }
483
484 /*******************************************************************
485 True if it ends in '$'.
486 ********************************************************************/
487
488 static BOOL is_hidden_share(int snum)
489 {
490 pstring net_name;
491
492 pstrcpy(net_name, lp_servicename(snum));
493 return (net_name[strlen(net_name)] == '$') ? True : False;
494 }
495
496 /*******************************************************************
497 Fill in a share info structure.
498 ********************************************************************/
499
500 static BOOL init_srv_share_info_ctr(pipes_struct *p, SRV_SHARE_INFO_CTR *ctr,
501 uint32 info_level, uint32 *resume_hnd, uint32 *total_entries, BOOL all_shares)
502 {
503 int num_entries = 0;
504 int num_services = lp_numservices();
505 int snum;
506 TALLOC_CTX *ctx = p->mem_ctx;
507
508 DEBUG(5,("init_srv_share_info_ctr\n"));
509
510 ZERO_STRUCTPN(ctr);
511
512 ctr->info_level = ctr->switch_value = info_level;
513 *resume_hnd = 0;
514
515 /* Count the number of entries. */
516 for (snum = 0; snum < num_services; snum++) {
517 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) )
518 num_entries++;
519 }
520
521 *total_entries = num_entries;
522 ctr->num_entries2 = ctr->num_entries = num_entries;
523 ctr->ptr_share_info = ctr->ptr_entries = 1;
524
525 if (!num_entries)
526 return True;
527
528 switch (info_level) {
529 case 0:
530 {
531 SRV_SHARE_INFO_0 *info0;
532 int i = 0;
533
534 info0 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_0));
535
536 for (snum = *resume_hnd; snum < num_services; snum++) {
537 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
538 init_srv_share_info_0(p, &info0[i++], snum);
539 }
540 }
541
542 ctr->share.info0 = info0;
543 break;
544
545 }
546
547 case 1:
548 {
549 SRV_SHARE_INFO_1 *info1;
550 int i = 0;
551
552 info1 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1));
553
554 for (snum = *resume_hnd; snum < num_services; snum++) {
555 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
556 init_srv_share_info_1(p, &info1[i++], snum);
557 }
558 }
559
560 ctr->share.info1 = info1;
561 break;
562 }
563
564 case 2:
565 {
566 SRV_SHARE_INFO_2 *info2;
567 int i = 0;
568
569 info2 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_2));
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;
584 int i = 0;
585
586 info501 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_501));
587
588 for (snum = *resume_hnd; snum < num_services; snum++) {
589 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
590 init_srv_share_info_501(p, &info501[i++], snum);
591 }
592 }
593
594 ctr->share.info501 = info501;
595 break;
596 }
597
598 case 502:
599 {
600 SRV_SHARE_INFO_502 *info502;
601 int i = 0;
602
603 info502 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_502));
604
605 for (snum = *resume_hnd; snum < num_services; snum++) {
606 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
607 init_srv_share_info_502(p, &info502[i++], snum);
608 }
609 }
610
611 ctr->share.info502 = info502;
612 break;
613 }
614
615 /* here for completeness but not currently used with enum (1004 - 1501)*/
616
617 case 1004:
618 {
619 SRV_SHARE_INFO_1004 *info1004;
620 int i = 0;
621
622 info1004 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1004));
623
624 for (snum = *resume_hnd; snum < num_services; snum++) {
625 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
626 init_srv_share_info_1004(p, &info1004[i++], snum);
627 }
628 }
629
630 ctr->share.info1004 = info1004;
631 break;
632 }
633
634 case 1005:
635 {
636 SRV_SHARE_INFO_1005 *info1005;
637 int i = 0;
638
639 info1005 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1005));
640
641 for (snum = *resume_hnd; snum < num_services; snum++) {
642 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
643 init_srv_share_info_1005(p, &info1005[i++], snum);
644 }
645 }
646
647 ctr->share.info1005 = info1005;
648 break;
649 }
650
651 case 1006:
652 {
653 SRV_SHARE_INFO_1006 *info1006;
654 int i = 0;
655
656 info1006 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1006));
657
658 for (snum = *resume_hnd; snum < num_services; snum++) {
659 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
660 init_srv_share_info_1006(p, &info1006[i++], snum);
661 }
662 }
663
664 ctr->share.info1006 = info1006;
665 break;
666 }
667
668 case 1007:
669 {
670 SRV_SHARE_INFO_1007 *info1007;
671 int i = 0;
672
673 info1007 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1007));
674
675 for (snum = *resume_hnd; snum < num_services; snum++) {
676 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
677 init_srv_share_info_1007(p, &info1007[i++], snum);
678 }
679 }
680
681 ctr->share.info1007 = info1007;
682 break;
683 }
684
685 case 1501:
686 {
687 SRV_SHARE_INFO_1501 *info1501;
688 int i = 0;
689
690 info1501 = talloc(ctx, num_entries * sizeof(SRV_SHARE_INFO_1501));
691
692 for (snum = *resume_hnd; snum < num_services; snum++) {
693 if (lp_browseable(snum) && lp_snum_ok(snum) && (all_shares || !is_hidden_share(snum)) ) {
694 init_srv_share_info_1501(p, &info1501[i++], snum);
695 }
696 }
697
698 ctr->share.info1501 = info1501;
699 break;
700 }
701 default:
702 DEBUG(5,("init_srv_share_info_ctr: unsupported switch value %d\n", info_level));
703 return False;
704 }
705
706 return True;
707 }
708
709 /*******************************************************************
710 Inits a SRV_R_NET_SHARE_ENUM structure.
711 ********************************************************************/
712
713 static void init_srv_r_net_share_enum(pipes_struct *p, SRV_R_NET_SHARE_ENUM *r_n,
714 uint32 info_level, uint32 resume_hnd, BOOL all)
715 {
716 DEBUG(5,("init_srv_r_net_share_enum: %d\n", __LINE__));
717
718 if (init_srv_share_info_ctr(p, &r_n->ctr, info_level,
719 &resume_hnd, &r_n->total_entries, all)) {
720 r_n->status = WERR_OK;
721 } else {
722 r_n->status = WERR_UNKNOWN_LEVEL;
723 }
724
725 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
726 }
727
728 /*******************************************************************
729 Inits a SRV_R_NET_SHARE_GET_INFO structure.
730 ********************************************************************/
731
732 static void init_srv_r_net_share_get_info(pipes_struct *p, SRV_R_NET_SHARE_GET_INFO *r_n,
733 char *share_name, uint32 info_level)
734 {
735 WERROR status = WERR_OK;
736 int snum;
737
738 DEBUG(5,("init_srv_r_net_share_get_info: %d\n", __LINE__));
739
740 r_n->info.switch_value = info_level;
741
742 snum = find_service(share_name);
743
744 if (snum >= 0) {
745 switch (info_level) {
746 case 0:
747 init_srv_share_info_0(p, &r_n->info.share.info0, snum);
748 break;
749 case 1:
750 init_srv_share_info_1(p, &r_n->info.share.info1, snum);
751 break;
752 case 2:
753 init_srv_share_info_2(p, &r_n->info.share.info2, snum);
754 break;
755 case 501:
756 init_srv_share_info_501(p, &r_n->info.share.info501, snum);
757 break;
758 case 502:
759 init_srv_share_info_502(p, &r_n->info.share.info502, snum);
760 break;
761
762 /* here for completeness */
763 case 1004:
764 init_srv_share_info_1004(p, &r_n->info.share.info1004, snum);
765 break;
766 case 1005:
767 init_srv_share_info_1005(p, &r_n->info.share.info1005, snum);
768 break;
769
770 /* here for completeness 1006 - 1501 */
771 case 1006:
772 init_srv_share_info_1006(p, &r_n->info.share.info1006, snum);
773 break;
774 case 1007:
775 init_srv_share_info_1007(p, &r_n->info.share.info1007, snum);
776 break;
777 case 1501:
778 init_srv_share_info_1501(p, &r_n->info.share.info1501, snum);
779 break;
780 default:
781 DEBUG(5,("init_srv_net_share_get_info: unsupported switch value %d\n", info_level));
782 status = WERR_UNKNOWN_LEVEL;
783 break;
784 }
785 } else {
786 status = WERR_INVALID_NAME;
787 }
788
789 r_n->info.ptr_share_ctr = W_ERROR_IS_OK(status) ? 1 : 0;
790 r_n->status = status;
791 }
792
793 /*******************************************************************
794 fill in a sess info level 1 structure.
795 ********************************************************************/
796
797 static void init_srv_sess_0_info(SESS_INFO_0 *se0, SESS_INFO_0_STR *str0, char *name)
798 {
799 init_srv_sess_info0(se0, name);
800 init_srv_sess_info0_str(str0, name);
801 }
802
803 /*******************************************************************
804 fill in a sess info level 0 structure.
805 ********************************************************************/
806
807 static void init_srv_sess_info_0(SRV_SESS_INFO_0 *ss0, uint32 *snum, uint32 *stot)
808 {
809 struct sessionid *session_list;
810 uint32 num_entries = 0;
811 (*stot) = list_sessions(&session_list);
812
813 if (ss0 == NULL) {
814 (*snum) = 0;
815 SAFE_FREE(session_list);
816 return;
817 }
818
819 DEBUG(5,("init_srv_sess_0_ss0\n"));
820
821 if (snum) {
822 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
823 init_srv_sess_0_info(&ss0->info_0[num_entries],
824 &ss0->info_0_str[num_entries], session_list[(*snum)].remote_machine);
825
826 /* move on to creating next session */
827 /* move on to creating next sess */
828 num_entries++;
829 }
830
831 ss0->num_entries_read = num_entries;
832 ss0->ptr_sess_info = num_entries > 0 ? 1 : 0;
833 ss0->num_entries_read2 = num_entries;
834
835 if ((*snum) >= (*stot)) {
836 (*snum) = 0;
837 }
838
839 } else {
840 ss0->num_entries_read = 0;
841 ss0->ptr_sess_info = 0;
842 ss0->num_entries_read2 = 0;
843 }
844 SAFE_FREE(session_list);
845 }
846
847 /*******************************************************************
848 fill in a sess info level 1 structure.
849 ********************************************************************/
850
851 static void init_srv_sess_1_info(SESS_INFO_1 *se1, SESS_INFO_1_STR *str1,
852 char *name, char *user,
853 uint32 num_opens,
854 uint32 open_time, uint32 idle_time,
855 uint32 usr_flgs)
856 {
857 init_srv_sess_info1(se1 , name, user, num_opens, open_time, idle_time, usr_flgs);
858 init_srv_sess_info1_str(str1, name, user);
859 }
860
861 /*******************************************************************
862 fill in a sess info level 1 structure.
863 ********************************************************************/
864
865 static void init_srv_sess_info_1(SRV_SESS_INFO_1 *ss1, uint32 *snum, uint32 *stot)
866 {
867 struct sessionid *session_list;
868 uint32 num_entries = 0;
869 (*stot) = list_sessions(&session_list);
870
871 if (ss1 == NULL) {
872 (*snum) = 0;
873 SAFE_FREE(session_list);
874 return;
875 }
876
877 DEBUG(5,("init_srv_sess_1_ss1\n"));
878
879 if (snum) {
880 for (; (*snum) < (*stot) && num_entries < MAX_SESS_ENTRIES; (*snum)++) {
881 init_srv_sess_1_info(&ss1->info_1[num_entries],
882 &ss1->info_1_str[num_entries],
883 session_list[*snum].remote_machine,
884 session_list[*snum].username,
885 1, 10, 5, 0);
886
887 /* move on to creating next session */
888 /* move on to creating next sess */
889 num_entries++;
890 }
891
892 ss1->num_entries_read = num_entries;
893 ss1->ptr_sess_info = num_entries > 0 ? 1 : 0;
894 ss1->num_entries_read2 = num_entries;
895
896 if ((*snum) >= (*stot)) {
897 (*snum) = 0;
898 }
899
900 } else {
901 ss1->num_entries_read = 0;
902 ss1->ptr_sess_info = 0;
903 ss1->num_entries_read2 = 0;
904
905 (*stot) = 0;
906 }
907 }
908
909 /*******************************************************************
910 makes a SRV_R_NET_SESS_ENUM structure.
911 ********************************************************************/
912
913 static WERROR init_srv_sess_info_ctr(SRV_SESS_INFO_CTR *ctr,
914 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
915 {
916 WERROR status = WERR_OK;
917 DEBUG(5,("init_srv_sess_info_ctr: %d\n", __LINE__));
918
919 ctr->switch_value = switch_value;
920
921 switch (switch_value) {
922 case 0:
923 init_srv_sess_info_0(&(ctr->sess.info0), resume_hnd, total_entries);
924 ctr->ptr_sess_ctr = 1;
925 break;
926 case 1:
927 init_srv_sess_info_1(&(ctr->sess.info1), resume_hnd, total_entries);
928 ctr->ptr_sess_ctr = 1;
929 break;
930 default:
931 DEBUG(5,("init_srv_sess_info_ctr: unsupported switch value %d\n", switch_value));
932 (*resume_hnd) = 0;
933 (*total_entries) = 0;
934 ctr->ptr_sess_ctr = 0;
935 status = WERR_UNKNOWN_LEVEL;
936 break;
937 }
938
939 return status;
940 }
941
942 /*******************************************************************
943 makes a SRV_R_NET_SESS_ENUM structure.
944 ********************************************************************/
945
946 static void init_srv_r_net_sess_enum(SRV_R_NET_SESS_ENUM *r_n,
947 uint32 resume_hnd, int sess_level, int switch_value)
948 {
949 DEBUG(5,("init_srv_r_net_sess_enum: %d\n", __LINE__));
950
951 r_n->sess_level = sess_level;
952
953 if (sess_level == -1)
954 r_n->status = WERR_UNKNOWN_LEVEL;
955 else
956 r_n->status = init_srv_sess_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
957
958 if (!W_ERROR_IS_OK(r_n->status))
959 resume_hnd = 0;
960
961 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
962 }
963
964 /*******************************************************************
965 fill in a conn info level 0 structure.
966 ********************************************************************/
967
968 static void init_srv_conn_info_0(SRV_CONN_INFO_0 *ss0, uint32 *snum, uint32 *stot)
969 {
970 uint32 num_entries = 0;
971 (*stot) = 1;
972
973 if (ss0 == NULL) {
974 (*snum) = 0;
975 return;
976 }
977
978 DEBUG(5,("init_srv_conn_0_ss0\n"));
979
980 if (snum) {
981 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
982
983 init_srv_conn_info0(&ss0->info_0[num_entries], (*stot));
984
985 /* move on to creating next connection */
986 /* move on to creating next conn */
987 num_entries++;
988 }
989
990 ss0->num_entries_read = num_entries;
991 ss0->ptr_conn_info = num_entries > 0 ? 1 : 0;
992 ss0->num_entries_read2 = num_entries;
993
994 if ((*snum) >= (*stot)) {
995 (*snum) = 0;
996 }
997
998 } else {
999 ss0->num_entries_read = 0;
1000 ss0->ptr_conn_info = 0;
1001 ss0->num_entries_read2 = 0;
1002
1003 (*stot) = 0;
1004 }
1005 }
1006
1007 /*******************************************************************
1008 fill in a conn info level 1 structure.
1009 ********************************************************************/
1010
1011 static void init_srv_conn_1_info(CONN_INFO_1 *se1, CONN_INFO_1_STR *str1,
1012 uint32 id, uint32 type,
1013 uint32 num_opens, uint32 num_users, uint32 open_time,
1014 const char *usr_name, const char *net_name)
1015 {
1016 init_srv_conn_info1(se1 , id, type, num_opens, num_users, open_time, usr_name, net_name);
1017 init_srv_conn_info1_str(str1, usr_name, net_name);
1018 }
1019
1020 /*******************************************************************
1021 fill in a conn info level 1 structure.
1022 ********************************************************************/
1023
1024 static void init_srv_conn_info_1(SRV_CONN_INFO_1 *ss1, uint32 *snum, uint32 *stot)
1025 {
1026 uint32 num_entries = 0;
1027 (*stot) = 1;
1028
1029 if (ss1 == NULL) {
1030 (*snum) = 0;
1031 return;
1032 }
1033
1034 DEBUG(5,("init_srv_conn_1_ss1\n"));
1035
1036 if (snum) {
1037 for (; (*snum) < (*stot) && num_entries < MAX_CONN_ENTRIES; (*snum)++) {
1038 init_srv_conn_1_info(&ss1->info_1[num_entries],
1039 &ss1->info_1_str[num_entries],
1040 (*stot), 0x3, 1, 1, 3,"dummy_user", "IPC$");
1041
1042 /* move on to creating next connection */
1043 /* move on to creating next conn */
1044 num_entries++;
1045 }
1046
1047 ss1->num_entries_read = num_entries;
1048 ss1->ptr_conn_info = num_entries > 0 ? 1 : 0;
1049 ss1->num_entries_read2 = num_entries;
1050
1051
1052 if ((*snum) >= (*stot)) {
1053 (*snum) = 0;
1054 }
1055
1056 } else {
1057 ss1->num_entries_read = 0;
1058 ss1->ptr_conn_info = 0;
1059 ss1->num_entries_read2 = 0;
1060
1061 (*stot) = 0;
1062 }
1063 }
1064
1065 /*******************************************************************
1066 makes a SRV_R_NET_CONN_ENUM structure.
1067 ********************************************************************/
1068
1069 static WERROR init_srv_conn_info_ctr(SRV_CONN_INFO_CTR *ctr,
1070 int switch_value, uint32 *resume_hnd, uint32 *total_entries)
1071 {
1072 WERROR status = WERR_OK;
1073 DEBUG(5,("init_srv_conn_info_ctr: %d\n", __LINE__));
1074
1075 ctr->switch_value = switch_value;
1076
1077 switch (switch_value) {
1078 case 0:
1079 init_srv_conn_info_0(&ctr->conn.info0, resume_hnd, total_entries);
1080 ctr->ptr_conn_ctr = 1;
1081 break;
1082 case 1:
1083 init_srv_conn_info_1(&ctr->conn.info1, resume_hnd, total_entries);
1084 ctr->ptr_conn_ctr = 1;
1085 break;
1086 default:
1087 DEBUG(5,("init_srv_conn_info_ctr: unsupported switch value %d\n", switch_value));
1088 (*resume_hnd = 0);
1089 (*total_entries) = 0;
1090 ctr->ptr_conn_ctr = 0;
1091 status = WERR_UNKNOWN_LEVEL;
1092 break;
1093 }
1094
1095 return status;
1096 }
1097
1098 /*******************************************************************
1099 makes a SRV_R_NET_CONN_ENUM structure.
1100 ********************************************************************/
1101
1102 static void init_srv_r_net_conn_enum(SRV_R_NET_CONN_ENUM *r_n,
1103 uint32 resume_hnd, int conn_level, int switch_value)
1104 {
1105 DEBUG(5,("init_srv_r_net_conn_enum: %d\n", __LINE__));
1106
1107 r_n->conn_level = conn_level;
1108 if (conn_level == -1)
1109 r_n->status = WERR_UNKNOWN_LEVEL;
1110 else
1111 r_n->status = init_srv_conn_info_ctr(r_n->ctr, switch_value, &resume_hnd, &r_n->total_entries);
1112
1113 if (!W_ERROR_IS_OK(r_n->status))
1114 resume_hnd = 0;
1115
1116 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1117 }
1118
1119 /*******************************************************************
1120 makes a SRV_R_NET_FILE_ENUM structure.
1121 ********************************************************************/
1122
1123 static WERROR init_srv_file_info_ctr(pipes_struct *p, SRV_FILE_INFO_CTR *ctr,
1124 int switch_value, uint32 *resume_hnd,
1125 uint32 *total_entries)
1126 {
1127 WERROR status = WERR_OK;
1128 TALLOC_CTX *ctx = p->mem_ctx;
1129 DEBUG(5,("init_srv_file_info_ctr: %d\n", __LINE__));
1130 *total_entries = 1; /* dummy entries only, for */
1131
1132 ctr->switch_value = switch_value;
1133 ctr->num_entries = *total_entries - *resume_hnd;
1134 ctr->num_entries2 = ctr->num_entries;
1135
1136 switch (switch_value) {
1137 case 3: {
1138 int i;
1139 if (*total_entries > 0) {
1140 ctr->ptr_entries = 1;
1141 ctr->file.info3 = talloc(ctx, ctr->num_entries *
1142 sizeof(SRV_FILE_INFO_3));
1143 }
1144 for (i=0 ;i<ctr->num_entries;i++) {
1145 init_srv_file_info3(&ctr->file.info3[i].info_3, i+*resume_hnd, 0x35, 0, "\\PIPE\\samr", "dummy user");
1146 init_srv_file_info3_str(&ctr->file.info3[i].info_3_str, "\\PIPE\\samr", "dummy user");
1147
1148 }
1149 ctr->ptr_file_info = 1;
1150 *resume_hnd = 0;
1151 break;
1152 }
1153 default:
1154 DEBUG(5,("init_srv_file_info_ctr: unsupported switch value %d\n", switch_value));
1155 (*resume_hnd = 0);
1156 (*total_entries) = 0;
1157 ctr->ptr_entries = 0;
1158 status = WERR_UNKNOWN_LEVEL;
1159 break;
1160 }
1161
1162 return status;
1163 }
1164
1165 /*******************************************************************
1166 makes a SRV_R_NET_FILE_ENUM structure.
1167 ********************************************************************/
1168
1169 static void init_srv_r_net_file_enum(pipes_struct *p, SRV_R_NET_FILE_ENUM *r_n,
1170 uint32 resume_hnd, int file_level, int switch_value)
1171 {
1172 DEBUG(5,("init_srv_r_net_file_enum: %d\n", __LINE__));
1173
1174 r_n->file_level = file_level;
1175 if (file_level == 0)
1176 r_n->status = WERR_UNKNOWN_LEVEL;
1177 else
1178 r_n->status = init_srv_file_info_ctr(p, &r_n->ctr, switch_value, &resume_hnd, &(r_n->total_entries));
1179
1180 if (!W_ERROR_IS_OK(r_n->status))
1181 resume_hnd = 0;
1182
1183 init_enum_hnd(&r_n->enum_hnd, resume_hnd);
1184 }
1185
1186 /*******************************************************************
1187 net server get info
1188 ********************************************************************/
1189
1190 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)
1191 {
1192 WERROR status = WERR_OK;
1193 SRV_INFO_CTR *ctr = (SRV_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_INFO_CTR));
1194
1195 if (!ctr)
1196 return WERR_NOMEM;
1197
1198 ZERO_STRUCTP(ctr);
1199
1200 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1201
1202 if (!pipe_access_check(p)) {
1203 DEBUG(3, ("access denied to srv_net_srv_get_info\n"));
1204 return WERR_ACCESS_DENIED;
1205 }
1206
1207 switch (q_u->switch_value) {
1208
1209 /* Technically level 102 should only be available to
1210 Administrators but there isn't anything super-secret
1211 here, as most of it is made up. */
1212
1213 case 102:
1214 init_srv_info_102(&ctr->srv.sv102,
1215 500, global_myname(),
1216 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH),
1217 lp_major_announce_version(), lp_minor_announce_version(),
1218 lp_default_server_announce(),
1219 0xffffffff, /* users */
1220 0xf, /* disc */
1221 0, /* hidden */
1222 240, /* announce */
1223 3000, /* announce delta */
1224 100000, /* licenses */
1225 "c:\\"); /* user path */
1226 break;
1227 case 101:
1228 init_srv_info_101(&ctr->srv.sv101,
1229 500, global_myname(),
1230 lp_major_announce_version(), lp_minor_announce_version(),
1231 lp_default_server_announce(),
1232 string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH));
1233 break;
1234 case 100:
1235 init_srv_info_100(&ctr->srv.sv100, 500, global_myname());
1236 break;
1237 default:
1238 status = WERR_UNKNOWN_LEVEL;
1239 break;
1240 }
1241
1242 /* set up the net server get info structure */
1243 init_srv_r_net_srv_get_info(r_u, q_u->switch_value, ctr, status);
1244
1245 DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
1246
1247 return r_u->status;
1248 }
1249
1250 /*******************************************************************
1251 net server set info
1252 ********************************************************************/
1253
1254 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)
1255 {
1256 WERROR status = WERR_OK;
1257
1258 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1259
1260 /* Set up the net server set info structure. */
1261
1262 init_srv_r_net_srv_set_info(r_u, 0x0, status);
1263
1264 DEBUG(5,("srv_net_srv_set_info: %d\n", __LINE__));
1265
1266 return r_u->status;
1267 }
1268
1269 /*******************************************************************
1270 net file enum
1271 ********************************************************************/
1272
1273 WERROR _srv_net_file_enum(pipes_struct *p, SRV_Q_NET_FILE_ENUM *q_u, SRV_R_NET_FILE_ENUM *r_u)
1274 {
1275 DEBUG(5,("srv_net_file_enum: %d\n", __LINE__));
1276
1277 /* set up the */
1278 init_srv_r_net_file_enum(p, r_u,
1279 get_enum_hnd(&q_u->enum_hnd),
1280 q_u->file_level,
1281 q_u->ctr.switch_value);
1282
1283 DEBUG(5,("srv_net_file_enum: %d\n", __LINE__));
1284
1285 return r_u->status;
1286 }
1287
1288 /*******************************************************************
1289 net conn enum
1290 ********************************************************************/
1291
1292 WERROR _srv_net_conn_enum(pipes_struct *p, SRV_Q_NET_CONN_ENUM *q_u, SRV_R_NET_CONN_ENUM *r_u)
1293 {
1294 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1295
1296 r_u->ctr = (SRV_CONN_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_CONN_INFO_CTR));
1297 if (!r_u->ctr)
1298 return WERR_NOMEM;
1299
1300 ZERO_STRUCTP(r_u->ctr);
1301
1302 /* set up the */
1303 init_srv_r_net_conn_enum(r_u,
1304 get_enum_hnd(&q_u->enum_hnd),
1305 q_u->conn_level,
1306 q_u->ctr->switch_value);
1307
1308 DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
1309
1310 return r_u->status;
1311 }
1312
1313 /*******************************************************************
1314 net sess enum
1315 ********************************************************************/
1316
1317 WERROR _srv_net_sess_enum(pipes_struct *p, SRV_Q_NET_SESS_ENUM *q_u, SRV_R_NET_SESS_ENUM *r_u)
1318 {
1319 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1320
1321 r_u->ctr = (SRV_SESS_INFO_CTR *)talloc(p->mem_ctx, sizeof(SRV_SESS_INFO_CTR));
1322 if (!r_u->ctr)
1323 return WERR_NOMEM;
1324
1325 ZERO_STRUCTP(r_u->ctr);
1326
1327 /* set up the */
1328 init_srv_r_net_sess_enum(r_u,
1329 get_enum_hnd(&q_u->enum_hnd),
1330 q_u->sess_level,
1331 q_u->ctr->switch_value);
1332
1333 DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
1334
1335 return r_u->status;
1336 }
1337
1338 /*******************************************************************
1339 Net share enum all.
1340 ********************************************************************/
1341
1342 WERROR _srv_net_share_enum_all(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1343 {
1344 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1345
1346 if (!pipe_access_check(p)) {
1347 DEBUG(3, ("access denied to srv_net_share_enum_all\n"));
1348 return WERR_ACCESS_DENIED;
1349 }
1350
1351 /* Create the list of shares for the response. */
1352 init_srv_r_net_share_enum(p, r_u,
1353 q_u->ctr.info_level,
1354 get_enum_hnd(&q_u->enum_hnd), True);
1355
1356 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1357
1358 return r_u->status;
1359 }
1360
1361 /*******************************************************************
1362 Net share enum.
1363 ********************************************************************/
1364
1365 WERROR _srv_net_share_enum(pipes_struct *p, SRV_Q_NET_SHARE_ENUM *q_u, SRV_R_NET_SHARE_ENUM *r_u)
1366 {
1367 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1368
1369 if (!pipe_access_check(p)) {
1370 DEBUG(3, ("access denied to srv_net_share_enum\n"));
1371 return WERR_ACCESS_DENIED;
1372 }
1373
1374 /* Create the list of shares for the response. */
1375 init_srv_r_net_share_enum(p, r_u,
1376 q_u->ctr.info_level,
1377 get_enum_hnd(&q_u->enum_hnd), False);
1378
1379 DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
1380
1381 return r_u->status;
1382 }
1383
1384 /*******************************************************************
1385 Net share get info.
1386 ********************************************************************/
1387
1388 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)
1389 {
1390 fstring share_name;
1391
1392 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1393
1394 /* Create the list of shares for the response. */
1395 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1396 init_srv_r_net_share_get_info(p, r_u, share_name, q_u->info_level);
1397
1398 DEBUG(5,("_srv_net_share_get_info: %d\n", __LINE__));
1399
1400 return r_u->status;
1401 }
1402
1403 /*******************************************************************
1404 Check a given DOS pathname is valid for a share.
1405 ********************************************************************/
1406
1407 static char *valid_share_pathname(char *dos_pathname)
1408 {
1409 pstring saved_pathname;
1410 pstring unix_pathname;
1411 char *ptr;
1412 int ret;
1413
1414 /* Convert any '\' paths to '/' */
1415 unix_format(dos_pathname);
1416 unix_clean_name(dos_pathname);
1417
1418 /* NT is braindead - it wants a C: prefix to a pathname ! So strip it. */
1419 ptr = dos_pathname;
1420 if (strlen(dos_pathname) > 2 && ptr[1] == ':' && ptr[0] != '/')
1421 ptr += 2;
1422
1423 /* Only abolute paths allowed. */
1424 if (*ptr != '/')
1425 return NULL;
1426
1427 /* Can we cd to it ? */
1428
1429 /* First save our current directory. */
1430 if (getcwd(saved_pathname, sizeof(saved_pathname)) == NULL)
1431 return False;
1432
1433 pstrcpy(unix_pathname, ptr);
1434
1435 ret = chdir(unix_pathname);
1436
1437 /* We *MUST* be able to chdir back. Abort if we can't. */
1438 if (chdir(saved_pathname) == -1)
1439 smb_panic("valid_share_pathname: Unable to restore current directory.\n");
1440
1441 return (ret != -1) ? ptr : NULL;
1442 }
1443
1444 /*******************************************************************
1445 Net share set info. Modify share details.
1446 ********************************************************************/
1447
1448 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)
1449 {
1450 struct current_user user;
1451 pstring command;
1452 fstring share_name;
1453 fstring comment;
1454 pstring pathname;
1455 int type;
1456 int snum;
1457 int ret;
1458 char *ptr;
1459 SEC_DESC *psd = NULL;
1460
1461 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1462
1463 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1464
1465 r_u->parm_error = 0;
1466
1467 if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
1468 return WERR_ACCESS_DENIED;
1469
1470 snum = find_service(share_name);
1471
1472 /* Does this share exist ? */
1473 if (snum < 0)
1474 return WERR_INVALID_NAME;
1475
1476 /* No change to printer shares. */
1477 if (lp_print_ok(snum))
1478 return WERR_ACCESS_DENIED;
1479
1480 get_current_user(&user,p);
1481
1482 if (user.uid != sec_initial_uid())
1483 return WERR_ACCESS_DENIED;
1484
1485 switch (q_u->info_level) {
1486 case 1:
1487 pstrcpy(pathname, lp_pathname(snum));
1488 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
1489 type = q_u->info.share.info2.info_2.type;
1490 psd = NULL;
1491 break;
1492 case 2:
1493 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(comment));
1494 unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(pathname));
1495 type = q_u->info.share.info2.info_2.type;
1496 psd = NULL;
1497 break;
1498 #if 0
1499 /* not supported on set but here for completeness */
1500 case 501:
1501 unistr2_to_ascii(comment, &q_u->info.share.info501.info_501_str.uni_remark, sizeof(comment));
1502 type = q_u->info.share.info501.info_501.type;
1503 psd = NULL;
1504 break;
1505 #endif
1506 case 502:
1507 unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(comment));
1508 unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(pathname));
1509 type = q_u->info.share.info502.info_502.type;
1510 psd = q_u->info.share.info502.info_502_str.sd;
1511 map_generic_share_sd_bits(psd);
1512 break;
1513 case 1004:
1514 pstrcpy(pathname, lp_pathname(snum));
1515 unistr2_to_ascii(comment, &q_u->info.share.info1004.info_1004_str.uni_remark, sizeof(comment));
1516 type = STYPE_DISKTREE;
1517 break;
1518 case 1005:
1519 /* XP re-sets the csc policy even if it wasn't changed by the
1520 user, so we must compare it to see if it's what is set in
1521 smb.conf, so that we can contine other ops like setting
1522 ACLs on a share */
1523 if (((q_u->info.share.info1005.share_info_flags &
1524 SHARE_1005_CSC_POLICY_MASK) >>
1525 SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
1526 return WERR_OK;
1527 else {
1528 DEBUG(3, ("_srv_net_share_set_info: client is trying to change csc policy from the network; must be done with smb.conf\n"));
1529 return WERR_ACCESS_DENIED;
1530 }
1531 break;
1532 case 1006:
1533 case 1007:
1534 return WERR_ACCESS_DENIED;
1535 break;
1536 case 1501:
1537 pstrcpy(pathname, lp_pathname(snum));
1538 fstrcpy(comment, lp_comment(snum));
1539 psd = q_u->info.share.info1501.sdb->sec;
1540 map_generic_share_sd_bits(psd);
1541 type = STYPE_DISKTREE;
1542 break;
1543 default:
1544 DEBUG(5,("_srv_net_share_set_info: unsupported switch value %d\n", q_u->info_level));
1545 return WERR_UNKNOWN_LEVEL;
1546 }
1547
1548 /* We can only modify disk shares. */
1549 if (type != STYPE_DISKTREE)
1550 return WERR_ACCESS_DENIED;
1551
1552 /* Check if the pathname is valid. */
1553 if (!(ptr = valid_share_pathname( pathname )))
1554 return WERR_OBJECT_PATH_INVALID;
1555
1556 /* Ensure share name, pathname and comment don't contain '"' characters. */
1557 string_replace(share_name, '"', ' ');
1558 string_replace(ptr, '"', ' ');
1559 string_replace(comment, '"', ' ');
1560
1561 DEBUG(10,("_srv_net_share_set_info: change share command = %s\n",
1562 lp_change_share_cmd() ? lp_change_share_cmd() : "NULL" ));
1563
1564 /* Only call modify function if something changed. */
1565
1566 if (strcmp(ptr, lp_pathname(snum)) || strcmp(comment, lp_comment(snum)) ) {
1567 if (!lp_change_share_cmd() || !*lp_change_share_cmd())
1568 return WERR_ACCESS_DENIED;
1569
1570 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
1571 lp_change_share_cmd(), dyn_CONFIGFILE, share_name, ptr, comment);
1572
1573 DEBUG(10,("_srv_net_share_set_info: Running [%s]\n", command ));
1574 if ((ret = smbrun(command, NULL)) != 0) {
1575 DEBUG(0,("_srv_net_share_set_info: Running [%s] returned (%d)\n", command, ret ));
1576 return WERR_ACCESS_DENIED;
1577 }
1578
1579 /* Tell everyone we updated smb.conf. */
1580 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1581
1582 } else {
1583 DEBUG(10,("_srv_net_share_set_info: No change to share name (%s)\n", share_name ));
1584 }
1585
1586 /* Replace SD if changed. */
1587 if (psd) {
1588 SEC_DESC *old_sd;
1589 size_t sd_size;
1590
1591 old_sd = get_share_security(p->mem_ctx, snum, &sd_size);
1592
1593 if (old_sd && !sec_desc_equal(old_sd, psd)) {
1594 if (!set_share_security(p->mem_ctx, share_name, psd))
1595 DEBUG(0,("_srv_net_share_set_info: Failed to change security info in share %s.\n",
1596 share_name ));
1597 }
1598 }
1599
1600 DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
1601
1602 return WERR_OK;
1603 }
1604
1605 /*******************************************************************
1606 Net share add. Call 'add_share_command "sharename" "pathname" "comment" "read only = xxx"'
1607 ********************************************************************/
1608
1609 WERROR _srv_net_share_add(pipes_struct *p, SRV_Q_NET_SHARE_ADD *q_u, SRV_R_NET_SHARE_ADD *r_u)
1610 {
1611 struct current_user user;
1612 pstring command;
1613 fstring share_name;
1614 fstring comment;
1615 pstring pathname;
1616 int type;
1617 int snum;
1618 int ret;
1619 char *ptr;
1620 SEC_DESC *psd = NULL;
1621
1622 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1623
1624 r_u->parm_error = 0;
1625
1626 get_current_user(&user,p);
1627
1628 if (user.uid != sec_initial_uid()) {
1629 DEBUG(10,("_srv_net_share_add: uid != sec_initial_uid(). Access denied.\n"));
1630 return WERR_ACCESS_DENIED;
1631 }
1632
1633 if (!lp_add_share_cmd() || !*lp_add_share_cmd()) {
1634 DEBUG(10,("_srv_net_share_add: No add share command\n"));
1635 return WERR_ACCESS_DENIED;
1636 }
1637
1638 switch (q_u->info_level) {
1639 case 0:
1640 /* No path. Not enough info in a level 0 to do anything. */
1641 return WERR_ACCESS_DENIED;
1642 case 1:
1643 /* Not enough info in a level 1 to do anything. */
1644 return WERR_ACCESS_DENIED;
1645 case 2:
1646 unistr2_to_ascii(share_name, &q_u->info.share.info2.info_2_str.uni_netname, sizeof(share_name));
1647 unistr2_to_ascii(comment, &q_u->info.share.info2.info_2_str.uni_remark, sizeof(share_name));
1648 unistr2_to_ascii(pathname, &q_u->info.share.info2.info_2_str.uni_path, sizeof(share_name));
1649 type = q_u->info.share.info2.info_2.type;
1650 break;
1651 case 501:
1652 /* No path. Not enough info in a level 501 to do anything. */
1653 return WERR_ACCESS_DENIED;
1654 case 502:
1655 unistr2_to_ascii(share_name, &q_u->info.share.info502.info_502_str.uni_netname, sizeof(share_name));
1656 unistr2_to_ascii(comment, &q_u->info.share.info502.info_502_str.uni_remark, sizeof(share_name));
1657 unistr2_to_ascii(pathname, &q_u->info.share.info502.info_502_str.uni_path, sizeof(share_name));
1658 type = q_u->info.share.info502.info_502.type;
1659 psd = q_u->info.share.info502.info_502_str.sd;
1660 map_generic_share_sd_bits(psd);
1661 break;
1662
1663 /* none of the following contain share names. NetShareAdd does not have a separate parameter for the share name */
1664
1665 case 1004:
1666 case 1005:
1667 case 1006:
1668 case 1007:
1669 return WERR_ACCESS_DENIED;
1670 break;
1671 case 1501:
1672 /* DFS only level. */
1673 return WERR_ACCESS_DENIED;
1674 default:
1675 DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n", q_u->info_level));
1676 return WERR_UNKNOWN_LEVEL;
1677 }
1678
1679 if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
1680 return WERR_ACCESS_DENIED;
1681
1682 snum = find_service(share_name);
1683
1684 /* Share already exists. */
1685 if (snum >= 0)
1686 return WERR_ALREADY_EXISTS;
1687
1688 /* We can only add disk shares. */
1689 if (type != STYPE_DISKTREE)
1690 return WERR_ACCESS_DENIED;
1691
1692 /* Check if the pathname is valid. */
1693 if (!(ptr = valid_share_pathname( pathname )))
1694 return WERR_OBJECT_PATH_INVALID;
1695
1696 /* Ensure share name, pathname and comment don't contain '"' characters. */
1697 string_replace(share_name, '"', ' ');
1698 string_replace(ptr, '"', ' ');
1699 string_replace(comment, '"', ' ');
1700
1701 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\"",
1702 lp_add_share_cmd(), dyn_CONFIGFILE, share_name, ptr, comment);
1703
1704 DEBUG(10,("_srv_net_share_add: Running [%s]\n", command ));
1705 if ((ret = smbrun(command, NULL)) != 0) {
1706 DEBUG(0,("_srv_net_share_add: Running [%s] returned (%d)\n", command, ret ));
1707 return WERR_ACCESS_DENIED;
1708 }
1709
1710 if (psd) {
1711 if (!set_share_security(p->mem_ctx, share_name, psd))
1712 DEBUG(0,("_srv_net_share_add: Failed to add security info to share %s.\n",
1713 share_name ));
1714 }
1715
1716 /* Tell everyone we updated smb.conf. */
1717 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1718
1719 /*
1720 * We don't call reload_services() here, the message will
1721 * cause this to be done before the next packet is read
1722 * from the client. JRA.
1723 */
1724
1725 DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
1726
1727 return WERR_OK;
1728 }
1729
1730 /*******************************************************************
1731 Net share delete. Call "delete share command" with the share name as
1732 a parameter.
1733 ********************************************************************/
1734
1735 WERROR _srv_net_share_del(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
1736 {
1737 struct current_user user;
1738 pstring command;
1739 fstring share_name;
1740 int ret;
1741 int snum;
1742
1743 DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
1744
1745 unistr2_to_ascii(share_name, &q_u->uni_share_name, sizeof(share_name));
1746
1747 if (strequal(share_name,"IPC$") || strequal(share_name,"ADMIN$") || strequal(share_name,"global"))
1748 return WERR_ACCESS_DENIED;
1749
1750 snum = find_service(share_name);
1751
1752 if (snum < 0)
1753 return WERR_NO_SUCH_SHARE;
1754
1755 /* No change to printer shares. */
1756 if (lp_print_ok(snum))
1757 return WERR_ACCESS_DENIED;
1758
1759 get_current_user(&user,p);
1760
1761 if (user.uid != sec_initial_uid())
1762 return WERR_ACCESS_DENIED;
1763
1764 if (!lp_delete_share_cmd() || !*lp_delete_share_cmd())
1765 return WERR_ACCESS_DENIED;
1766
1767 slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"",
1768 lp_delete_share_cmd(), dyn_CONFIGFILE, lp_servicename(snum));
1769
1770 DEBUG(10,("_srv_net_share_del: Running [%s]\n", command ));
1771 if ((ret = smbrun(command, NULL)) != 0) {
1772 DEBUG(0,("_srv_net_share_del: Running [%s] returned (%d)\n", command, ret ));
1773 return WERR_ACCESS_DENIED;
1774 }
1775
1776 /* Delete the SD in the database. */
1777 delete_share_security(snum);
1778
1779 /* Tell everyone we updated smb.conf. */
1780 message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
1781
1782 lp_killservice(snum);
1783
1784 return WERR_OK;
1785 }
1786
1787 WERROR _srv_net_share_del_sticky(pipes_struct *p, SRV_Q_NET_SHARE_DEL *q_u, SRV_R_NET_SHARE_DEL *r_u)
1788 {
1789 DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
1790
1791 return _srv_net_share_del(p, q_u, r_u);
1792 }
1793
1794 /*******************************************************************
1795 time of day
1796 ********************************************************************/
1797
1798 WERROR _srv_net_remote_tod(pipes_struct *p, SRV_Q_NET_REMOTE_TOD *q_u, SRV_R_NET_REMOTE_TOD *r_u)
1799 {
1800 TIME_OF_DAY_INFO *tod;
1801 struct tm *t;
1802 time_t unixdate = time(NULL);
1803
1804 tod = (TIME_OF_DAY_INFO *)talloc(p->mem_ctx, sizeof(TIME_OF_DAY_INFO));
1805 if (!tod)
1806 return WERR_NOMEM;
1807
1808 ZERO_STRUCTP(tod);
1809
1810 r_u->tod = tod;
1811 r_u->ptr_srv_tod = 0x1;
1812 r_u->status = WERR_OK;
1813
1814 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
1815
1816 t = gmtime(&unixdate);
1817
1818 /* set up the */
1819 init_time_of_day_info(tod,
1820 unixdate,
1821 0,
1822 t->tm_hour,
1823 t->tm_min,
1824 t->tm_sec,
1825 0,
1826 TimeDiff(unixdate)/60,
1827 10000,
1828 t->tm_mday,
1829 t->tm_mon + 1,
1830 1900+t->tm_year,
1831 t->tm_wday);
1832
1833 DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
1834
1835 return r_u->status;
1836 }
1837
1838 /***********************************************************************************
1839 Win9x NT tools get security descriptor.
1840 ***********************************************************************************/
1841
1842 WERROR _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC *q_u,
1843 SRV_R_NET_FILE_QUERY_SECDESC *r_u)
1844 {
1845 SEC_DESC *psd = NULL;
1846 size_t sd_size;
1847 DATA_BLOB null_pw;
1848 pstring filename;
1849 pstring qualname;
1850 files_struct *fsp = NULL;
1851 SMB_STRUCT_STAT st;
1852 BOOL bad_path;
1853 int access_mode;
1854 int action;
1855 NTSTATUS nt_status;
1856 struct current_user user;
1857 connection_struct *conn = NULL;
1858 BOOL became_user = False;
1859
1860 ZERO_STRUCT(st);
1861
1862 r_u->status = WERR_OK;
1863
1864 unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
1865
1866 /* Null password is ok - we are already an authenticated user... */
1867 null_pw = data_blob(NULL, 0);
1868
1869 get_current_user(&user, p);
1870
1871 become_root();
1872 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
1873 unbecome_root();
1874
1875 if (conn == NULL) {
1876 DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", qualname));
1877 r_u->status = ntstatus_to_werror(nt_status);
1878 goto error_exit;
1879 }
1880
1881 if (!become_user(conn, conn->vuid)) {
1882 DEBUG(0,("_srv_net_file_query_secdesc: Can't become connected user!\n"));
1883 r_u->status = WERR_ACCESS_DENIED;
1884 goto error_exit;
1885 }
1886 became_user = True;
1887
1888 unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
1889 unix_convert(filename, conn, NULL, &bad_path, &st);
1890 fsp = open_file_shared(conn, filename, &st, SET_OPEN_MODE(DOS_OPEN_RDONLY),
1891 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, 0, &access_mode, &action);
1892
1893 if (!fsp) {
1894 /* Perhaps it is a directory */
1895 if (errno == EISDIR)
1896 fsp = open_directory(conn, filename, &st,FILE_READ_ATTRIBUTES,0,
1897 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, &action);
1898
1899 if (!fsp) {
1900 DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", filename));
1901 r_u->status = WERR_ACCESS_DENIED;
1902 goto error_exit;
1903 }
1904 }
1905
1906 sd_size = SMB_VFS_GET_NT_ACL(fsp, fsp->fsp_name, (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
1907
1908 if (sd_size == 0) {
1909 DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
1910 r_u->status = WERR_ACCESS_DENIED;
1911 goto error_exit;
1912 }
1913
1914 r_u->ptr_response = 1;
1915 r_u->size_response = sd_size;
1916 r_u->ptr_secdesc = 1;
1917 r_u->size_secdesc = sd_size;
1918 r_u->sec_desc = psd;
1919
1920 psd->dacl->revision = (uint16) NT4_ACL_REVISION;
1921
1922 close_file(fsp, True);
1923 unbecome_user();
1924 close_cnum(conn, user.vuid);
1925 return r_u->status;
1926
1927 error_exit:
1928
1929 if(fsp) {
1930 close_file(fsp, True);
1931 }
1932
1933 if (became_user)
1934 unbecome_user();
1935
1936 if (conn)
1937 close_cnum(conn, user.vuid);
1938
1939 return r_u->status;
1940 }
1941
1942 /***********************************************************************************
1943 Win9x NT tools set security descriptor.
1944 ***********************************************************************************/
1945
1946 WERROR _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_u,
1947 SRV_R_NET_FILE_SET_SECDESC *r_u)
1948 {
1949 BOOL ret;
1950 pstring filename;
1951 pstring qualname;
1952 DATA_BLOB null_pw;
1953 files_struct *fsp = NULL;
1954 SMB_STRUCT_STAT st;
1955 BOOL bad_path;
1956 int access_mode;
1957 int action;
1958 NTSTATUS nt_status;
1959 struct current_user user;
1960 connection_struct *conn = NULL;
1961 BOOL became_user = False;
1962
1963 ZERO_STRUCT(st);
1964
1965 r_u->status = WERR_OK;
1966
1967 unistr2_to_ascii(qualname, &q_u->uni_qual_name, sizeof(qualname));
1968
1969 /* Null password is ok - we are already an authenticated user... */
1970 null_pw = data_blob(NULL, 0);
1971
1972 get_current_user(&user, p);
1973
1974 become_root();
1975 conn = make_connection(qualname, null_pw, "A:", user.vuid, &nt_status);
1976 unbecome_root();
1977
1978 if (conn == NULL) {
1979 DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", qualname));
1980 r_u->status = ntstatus_to_werror(nt_status);
1981 goto error_exit;
1982 }
1983
1984 if (!become_user(conn, conn->vuid)) {
1985 DEBUG(0,("_srv_net_file_set_secdesc: Can't become connected user!\n"));
1986 r_u->status = WERR_ACCESS_DENIED;
1987 goto error_exit;
1988 }
1989 became_user = True;
1990
1991 unistr2_to_ascii(filename, &q_u->uni_file_name, sizeof(filename));
1992 unix_convert(filename, conn, NULL, &bad_path, &st);
1993
1994 fsp = open_file_shared(conn, filename, &st, SET_OPEN_MODE(DOS_OPEN_RDWR),
1995 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, 0, &access_mode, &action);
1996
1997 if (!fsp) {
1998 /* Perhaps it is a directory */
1999 if (errno == EISDIR)
2000 fsp = open_directory(conn, filename, &st,FILE_READ_ATTRIBUTES,0,
2001 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), 0, &action);
2002
2003 if (!fsp) {
2004 DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", filename));
2005 r_u->status = WERR_ACCESS_DENIED;
2006 goto error_exit;
2007 }
2008 }
2009
2010 ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
2011
2012 if (ret == False) {
2013 DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
2014 r_u->status = WERR_ACCESS_DENIED;
2015 goto error_exit;
2016 }
2017
2018 close_file(fsp, True);
2019 unbecome_user();
2020 close_cnum(conn, user.vuid);
2021 return r_u->status;
2022
2023 error_exit:
2024
2025 if(fsp) {
2026 close_file(fsp, True);
2027 }
2028
2029 if (became_user)
2030 unbecome_user();
2031
2032 if (conn)
2033 close_cnum(conn, user.vuid);
2034
2035 return r_u->status;
2036 }
2037
2038 /***********************************************************************************
2039 It may be that we want to limit users to creating shares on certain areas of the UNIX file area.
2040 We could define areas by mapping Windows style disks to points on the UNIX directory hierarchy.
2041 These disks would the disks listed by this function.
2042 Users could then create shares relative to these disks. Watch out for moving these disks around.
2043 "Nigel Williams" <nigel@veritas.com>.
2044 ***********************************************************************************/
2045
2046 static const char *server_disks[] = {"C:"};
2047
2048 static uint32 get_server_disk_count(void)
2049 {
2050 return sizeof(server_disks)/sizeof(server_disks[0]);
2051 }
2052
2053 static uint32 init_server_disk_enum(uint32 *resume)
2054 {
2055 uint32 server_disk_count = get_server_disk_count();
2056
2057 /*resume can be an offset into the list for now*/
2058
2059 if(*resume & 0x80000000)
2060 *resume = 0;
2061
2062 if(*resume > server_disk_count)
2063 *resume = server_disk_count;
2064
2065 return server_disk_count - *resume;
2066 }
2067
2068 static const char *next_server_disk_enum(uint32 *resume)
2069 {
2070 const char *disk;
2071
2072 if(init_server_disk_enum(resume) == 0)
2073 return NULL;
2074
2075 disk = server_disks[*resume];
2076
2077 (*resume)++;
2078
2079 DEBUG(10, ("next_server_disk_enum: reporting disk %s. resume handle %d.\n", disk, *resume));
2080
2081 return disk;
2082 }
2083
2084 WERROR _srv_net_disk_enum(pipes_struct *p, SRV_Q_NET_DISK_ENUM *q_u, SRV_R_NET_DISK_ENUM *r_u)
2085 {
2086 uint32 i;
2087 const char *disk_name;
2088 TALLOC_CTX *ctx = p->mem_ctx;
2089 uint32 resume=get_enum_hnd(&q_u->enum_hnd);
2090
2091 r_u->status=WERR_OK;
2092
2093 r_u->total_entries = init_server_disk_enum(&resume);
2094
2095 r_u->disk_enum_ctr.unknown = 0;
2096
2097 {
2098 DISK_INFO *dinfo;
2099
2100 int dinfo_size = MAX_SERVER_DISK_ENTRIES * sizeof(*dinfo);
2101
2102 if(!(dinfo = talloc(ctx, dinfo_size))) {
2103 return WERR_NOMEM;
2104 }
2105
2106 r_u->disk_enum_ctr.disk_info = dinfo;
2107 }
2108
2109 r_u->disk_enum_ctr.disk_info_ptr = r_u->disk_enum_ctr.disk_info ? 1 : 0;
2110
2111 /*allow one DISK_INFO for null terminator*/
2112
2113 for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(&resume)); i++) {
2114
2115 r_u->disk_enum_ctr.entries_read++;
2116
2117 /*copy disk name into a unicode string*/
2118
2119 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, disk_name);
2120 }
2121
2122 /* add a terminating null string. Is this there if there is more data to come? */
2123
2124 r_u->disk_enum_ctr.entries_read++;
2125
2126 init_unistr3(&r_u->disk_enum_ctr.disk_info[i].disk_name, "");
2127
2128 init_enum_hnd(&r_u->enum_hnd, resume);
2129
2130 return r_u->status;
2131 }
2132
2133 WERROR _srv_net_name_validate(pipes_struct *p, SRV_Q_NET_NAME_VALIDATE *q_u, SRV_R_NET_NAME_VALIDATE *r_u)
2134 {
2135 int snum;
2136 fstring share_name;
2137
2138 r_u->status=WERR_OK;
2139
2140 switch(q_u->type) {
2141
2142 case 0x9:
2143
2144 /*check if share name is ok*/
2145 /*also check if we already have a share with this name*/
2146
2147 unistr2_to_ascii(share_name, &q_u->uni_name, sizeof(share_name));
2148 snum = find_service(share_name);
2149
2150 /* Share already exists. */
2151 if (snum >= 0)
2152 r_u->status = WERR_ALREADY_EXISTS;
2153 break;
2154
2155 default:
2156 /*unsupported type*/
2157 r_u->status = WERR_UNKNOWN_LEVEL;
2158 break;
2159 }
2160
2161 return r_u->status;
2162 }
reg import