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