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