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