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