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