source/rpc_server/srv_srvsvc_nt.c

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