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