source4/rpc_server/srvsvc/dcesrv_srvsvc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the srvsvc pipe
   5
   6    Copyright (C) Stefan (metze) Metzmacher 2004-2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "ntvfs/ntvfs.h"
  25 #include "rpc_server/dcerpc_server.h"
  26 #include "librpc/gen_ndr/ndr_srvsvc.h"
  27 #include "rpc_server/common/common.h"
  28 #include "auth/auth.h"
  29 #include "libcli/security/security.h"
  30 #include "system/time.h"
  31 #include "rpc_server/srvsvc/proto.h"
  32
  33 #define SRVSVC_CHECK_ADMIN_ACCESS do { \
  34         struct security_token *t = dce_call->conn->auth_state.session_info->security_token; \
  35         if (!security_token_has_builtin_administrators(t) && \
  36             !security_token_has_sid_string(t, SID_BUILTIN_SERVER_OPERATORS)) { \
  37                 return WERR_ACCESS_DENIED; \
  38         } \
  39 } while (0)
  40
  41 /*
  42   srvsvc_NetCharDevEnum
  43 */
  44 static WERROR srvsvc_NetCharDevEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  45                                       struct srvsvc_NetCharDevEnum *r)
  46 {
  47         r->out.level = r->in.level;
  48         r->out.totalentries = 0;
  49         r->out.resume_handle = NULL;
  50
  51         switch (r->in.level) {
  52         case 0:
  53                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr0);
  54                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
  55
  56                 r->out.ctr.ctr0->count = 0;
  57                 r->out.ctr.ctr0->array = NULL;
  58
  59                 return WERR_NOT_SUPPORTED;
  60
  61         case 1:
  62                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr1);
  63                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
  64
  65                 r->out.ctr.ctr1->count = 0;
  66                 r->out.ctr.ctr1->array = NULL;
  67
  68                 return WERR_NOT_SUPPORTED;
  69
  70         default:
  71                 return WERR_UNKNOWN_LEVEL;
  72         }
  73
  74         return WERR_OK;
  75 }
  76
  77
  78 /*
  79   srvsvc_NetCharDevGetInfo
  80 */
  81 static WERROR srvsvc_NetCharDevGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  82                        struct srvsvc_NetCharDevGetInfo *r)
  83 {
  84         ZERO_STRUCT(r->out);
  85
  86         switch (r->in.level) {
  87         case 0:
  88         {
  89                 return WERR_NOT_SUPPORTED;
  90         }
  91         case 1:
  92         {
  93                 return WERR_NOT_SUPPORTED;
  94         }
  95         default:
  96                 return WERR_UNKNOWN_LEVEL;
  97         }
  98
  99         return WERR_UNKNOWN_LEVEL;
 100 }
 101
 102
 103 /*
 104   srvsvc_NetCharDevControl
 105 */
 106 static WERROR srvsvc_NetCharDevControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 107                        struct srvsvc_NetCharDevControl *r)
 108 {
 109         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 110 }
 111
 112
 113 /*
 114   srvsvc_NetCharDevQEnum
 115 */
 116 static WERROR srvsvc_NetCharDevQEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 117                                      struct srvsvc_NetCharDevQEnum *r)
 118 {
 119         r->out.level = r->in.level;
 120         r->out.totalentries = 0;
 121         r->out.resume_handle = NULL;
 122
 123         switch (r->in.level) {
 124         case 0:
 125         {
 126                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr0);
 127                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 128
 129                 r->out.ctr.ctr0->count = 0;
 130                 r->out.ctr.ctr0->array = NULL;
 131
 132                 return WERR_NOT_SUPPORTED;
 133         }
 134         case 1:
 135         {
 136                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr1);
 137                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 138
 139                 r->out.ctr.ctr1->count = 0;
 140                 r->out.ctr.ctr1->array = NULL;
 141
 142                 return WERR_NOT_SUPPORTED;
 143         }
 144         default:
 145                 return WERR_UNKNOWN_LEVEL;
 146         }
 147
 148         return WERR_UNKNOWN_LEVEL;
 149 }
 150
 151
 152 /*
 153   srvsvc_NetCharDevQGetInfo
 154 */
 155 static WERROR srvsvc_NetCharDevQGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 156                                         struct srvsvc_NetCharDevQGetInfo *r)
 157 {
 158         ZERO_STRUCT(r->out);
 159
 160         switch (r->in.level) {
 161         case 0:
 162         {
 163                 return WERR_NOT_SUPPORTED;
 164         }
 165         case 1:
 166         {
 167                 return WERR_NOT_SUPPORTED;
 168         }
 169         default:
 170                 return WERR_UNKNOWN_LEVEL;
 171         }
 172
 173         return WERR_UNKNOWN_LEVEL;
 174 }
 175
 176
 177 /*
 178   srvsvc_NetCharDevQSetInfo
 179 */
 180 static WERROR srvsvc_NetCharDevQSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 181                        struct srvsvc_NetCharDevQSetInfo *r)
 182 {
 183         switch (r->in.level) {
 184         case 0:
 185         {
 186                 if (r->in.parm_error) {
 187                         r->out.parm_error = r->in.parm_error;
 188                 }
 189                 return WERR_NOT_SUPPORTED;
 190         }
 191         case 1:
 192         {
 193                 if (r->in.parm_error) {
 194                         r->out.parm_error = r->in.parm_error;
 195                 }
 196                 return WERR_NOT_SUPPORTED;
 197         }
 198         default:
 199                 return WERR_UNKNOWN_LEVEL;
 200         }
 201
 202         return WERR_UNKNOWN_LEVEL;
 203 }
 204
 205
 206 /*
 207   srvsvc_NetCharDevQPurge
 208 */
 209 static WERROR srvsvc_NetCharDevQPurge(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 210                        struct srvsvc_NetCharDevQPurge *r)
 211 {
 212         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 213 }
 214
 215
 216 /*
 217   srvsvc_NetCharDevQPurgeSelf
 218 */
 219 static WERROR srvsvc_NetCharDevQPurgeSelf(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 220                                           struct srvsvc_NetCharDevQPurgeSelf *r)
 221 {
 222         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 223 }
 224
 225
 226 /*
 227   srvsvc_NetConnEnum
 228 */
 229 static WERROR srvsvc_NetConnEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 230                        struct srvsvc_NetConnEnum *r)
 231 {
 232         r->out.level = r->in.level;
 233         r->out.totalentries = 0;
 234         r->out.resume_handle = NULL;
 235
 236         switch (r->in.level) {
 237         case 0:
 238         {
 239                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetConnCtr0);
 240                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 241
 242                 r->out.ctr.ctr0->count = 0;
 243                 r->out.ctr.ctr0->array = NULL;
 244
 245                 return WERR_NOT_SUPPORTED;
 246         }
 247         case 1:
 248         {
 249                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetConnCtr1);
 250                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 251
 252                 r->out.ctr.ctr1->count = 0;
 253                 r->out.ctr.ctr1->array = NULL;
 254
 255                 return WERR_NOT_SUPPORTED;
 256         }
 257         default:
 258                 return WERR_UNKNOWN_LEVEL;
 259         }
 260
 261         return WERR_UNKNOWN_LEVEL;
 262 }
 263
 264
 265 /*
 266   srvsvc_NetFileEnum
 267 */
 268 static WERROR srvsvc_NetFileEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 269                                  struct srvsvc_NetFileEnum *r)
 270 {
 271         r->out.level = r->in.level;
 272         r->out.totalentries = 0;
 273         r->out.resume_handle = NULL;
 274
 275         switch (r->in.level) {
 276         case 2:
 277         {
 278                 r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetFileCtr2);
 279                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
 280
 281                 r->out.ctr.ctr2->count = 0;
 282                 r->out.ctr.ctr2->array = NULL;
 283
 284                 return WERR_NOT_SUPPORTED;
 285         }
 286         case 3:
 287         {
 288                 r->out.ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetFileCtr3);
 289                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr3);
 290
 291                 r->out.ctr.ctr3->count = 0;
 292                 r->out.ctr.ctr3->array = NULL;
 293
 294                 return WERR_NOT_SUPPORTED;
 295         }
 296         default:
 297                 return WERR_UNKNOWN_LEVEL;
 298         }
 299
 300         return WERR_UNKNOWN_LEVEL;
 301 }
 302
 303
 304 /*
 305   srvsvc_NetFileGetInfo
 306 */
 307 static WERROR srvsvc_NetFileGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 308                                     struct srvsvc_NetFileGetInfo *r)
 309 {
 310         ZERO_STRUCT(r->out);
 311
 312         switch (r->in.level) {
 313         case 2:
 314         {
 315                 return WERR_NOT_SUPPORTED;
 316         }
 317         case 3:
 318         {
 319                 return WERR_NOT_SUPPORTED;
 320         }
 321         default:
 322                 return WERR_UNKNOWN_LEVEL;
 323         }
 324
 325         return WERR_UNKNOWN_LEVEL;
 326 }
 327
 328
 329 /*
 330   srvsvc_NetFileClose
 331 */
 332 static WERROR srvsvc_NetFileClose(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 333                        struct srvsvc_NetFileClose *r)
 334 {
 335         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 336 }
 337
 338
 339 /*
 340   srvsvc_NetSessEnum
 341 */
 342 static WERROR srvsvc_NetSessEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 343                        struct srvsvc_NetSessEnum *r)
 344 {
 345         r->out.level = r->in.level;
 346         r->out.totalentries = 0;
 347         r->out.resume_handle = NULL;
 348
 349         switch (r->in.level) {
 350         case 0:
 351         {
 352                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetSessCtr0);
 353                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 354
 355                 r->out.ctr.ctr0->count = 0;
 356                 r->out.ctr.ctr0->array = NULL;
 357
 358                 return WERR_NOT_SUPPORTED;
 359         }
 360         case 1:
 361         {
 362                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetSessCtr1);
 363                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 364
 365                 r->out.ctr.ctr1->count = 0;
 366                 r->out.ctr.ctr1->array = NULL;
 367
 368                 return WERR_NOT_SUPPORTED;
 369         }
 370         case 2:
 371         {
 372                 r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetSessCtr2);
 373                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
 374
 375                 r->out.ctr.ctr2->count = 0;
 376                 r->out.ctr.ctr2->array = NULL;
 377
 378                 return WERR_NOT_SUPPORTED;
 379         }
 380         case 10:
 381         {
 382                 r->out.ctr.ctr10 = talloc(mem_ctx, struct srvsvc_NetSessCtr10);
 383                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr10);
 384
 385                 r->out.ctr.ctr2->count = 0;
 386                 r->out.ctr.ctr2->array = NULL;
 387
 388                 return WERR_NOT_SUPPORTED;
 389         }
 390         case 502:
 391         {
 392                 r->out.ctr.ctr502 = talloc(mem_ctx, struct srvsvc_NetSessCtr502);
 393                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr502);
 394
 395                 r->out.ctr.ctr2->count = 0;
 396                 r->out.ctr.ctr2->array = NULL;
 397
 398                 return WERR_NOT_SUPPORTED;
 399         }
 400         default:
 401                 return WERR_UNKNOWN_LEVEL;
 402         }
 403
 404         return WERR_UNKNOWN_LEVEL;
 405 }
 406
 407
 408 /*
 409   srvsvc_NetSessDel
 410 */
 411 static WERROR srvsvc_NetSessDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 412                        struct srvsvc_NetSessDel *r)
 413 {
 414         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 415 }
 416
 417
 418 /*
 419   srvsvc_NetShareAdd
 420 */
 421 static WERROR srvsvc_NetShareAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 422                        struct srvsvc_NetShareAdd *r)
 423 {
 424         switch (r->in.level) {
 425         case 0:
 426         {
 427                 if (r->in.parm_error) {
 428                         r->out.parm_error = r->in.parm_error;
 429                 }
 430                 return WERR_NOT_SUPPORTED;
 431         }
 432         case 1:
 433         {
 434                 if (r->in.parm_error) {
 435                         r->out.parm_error = r->in.parm_error;
 436                 }
 437                 return WERR_NOT_SUPPORTED;
 438         }
 439         case 2:
 440         {
 441                 if (r->in.parm_error) {
 442                         r->out.parm_error = r->in.parm_error;
 443                 }
 444                 return WERR_NOT_SUPPORTED;
 445         }
 446         case 501:
 447         {
 448                 if (r->in.parm_error) {
 449                         r->out.parm_error = r->in.parm_error;
 450                 }
 451                 return WERR_NOT_SUPPORTED;
 452         }
 453         case 502:
 454         {
 455                 NTSTATUS nterr;
 456                 struct share_info *info;
 457                 struct share_context *sctx;
 458
 459                 nterr = share_get_context(mem_ctx, &sctx);
 460                 if (!NT_STATUS_IS_OK(nterr)) {
 461                         return ntstatus_to_werror(nterr);
 462                 }
 463
 464                 info = talloc_zero(mem_ctx, struct share_info);
 465                 W_ERROR_HAVE_NO_MEMORY(info);
 466
 467                 info->name = talloc_strdup(info, r->in.info.info502->name);
 468                 W_ERROR_HAVE_NO_MEMORY(info->name);
 469                 switch (r->in.info.info502->type) {
 470                 case 0x00:
 471                         info->type = talloc_strdup(mem_ctx, "DISK");
 472                         break;
 473                 case 0x01:
 474                         info->type = talloc_strdup(mem_ctx, "PRINTER");
 475                         break;
 476                 case 0x03:
 477                         info->type = talloc_strdup(mem_ctx, "IPC");
 478                         break;
 479                 default:
 480                         return WERR_INVALID_PARAM;
 481                 }
 482                 W_ERROR_HAVE_NO_MEMORY(info->type);
 483
 484                 /* Windows will send a path in a form of C:\example\path */
 485                 if (r->in.info.info502->path[1] == ':') {
 486                         info->path = talloc_strdup(info, &r->in.info.info502->path[2]);
 487                 } else {
 488                         info->path = talloc_strdup(info, r->in.info.info502->path);
 489                 }
 490                 W_ERROR_HAVE_NO_MEMORY(info->path);
 491                 all_string_sub(info->path, "\\", "/", 0);
 492
 493                 if (r->in.info.info502->comment && r->in.info.info502->comment[0]) {
 494                         info->comment = talloc_strdup(info, r->in.info.info502->comment);
 495                         W_ERROR_HAVE_NO_MEMORY(info->comment);
 496                 }
 497
 498                 if (r->in.info.info502->password && r->in.info.info502->password[0]) {
 499                         info->password = talloc_strdup(info, r->in.info.info502->password);
 500                         W_ERROR_HAVE_NO_MEMORY(info->password);
 501                 }
 502
 503                 info->max_users = r->in.info.info502->max_users;
 504                 /* TODO: security descriptor */
 505
 506
 507                 nterr = share_create(sctx, info);
 508                 if (!NT_STATUS_IS_OK(nterr)) {
 509                         return ntstatus_to_werror(nterr);
 510                 }
 511
 512                 if (r->in.parm_error) {
 513                         r->out.parm_error = r->in.parm_error;
 514                 }
 515
 516                 return WERR_OK;
 517         }
 518         default:
 519                 return WERR_UNKNOWN_LEVEL;
 520         }
 521
 522         return WERR_UNKNOWN_LEVEL;
 523 }
 524
 525 static WERROR srvsvc_fiel_ShareInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 526                                     struct share_config *scfg, uint32_t level,
 527                                     union srvsvc_NetShareInfo *info)
 528 {
 529         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 530
 531         switch (level) {
 532         case 0:
 533         {
 534                 info->info0->name       = talloc_strdup(mem_ctx, scfg->name);
 535                 W_ERROR_HAVE_NO_MEMORY(info->info0->name);
 536
 537                 return WERR_OK;
 538         }
 539         case 1:
 540         {
 541                 info->info1->name       = talloc_strdup(mem_ctx, scfg->name);
 542                 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
 543                 info->info1->type       = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 544                 info->info1->comment    = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 545                 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
 546
 547                 return WERR_OK;
 548         }
 549         case 2:
 550         {
 551                 info->info2->name               = talloc_strdup(mem_ctx, scfg->name);
 552                 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
 553                 info->info2->type               = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 554                 info->info2->comment            = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 555                 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
 556                 info->info2->permissions        = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 557                 info->info2->max_users          = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 558                 info->info2->current_users      = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 559                 info->info2->path               = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 560                 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
 561                 info->info2->password           = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 562
 563                 return WERR_OK;
 564         }
 565         case 501:
 566         {
 567                 info->info501->name             = talloc_strdup(mem_ctx, scfg->name);
 568                 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
 569                 info->info501->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 570                 info->info501->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 571                 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
 572                 info->info501->csc_policy       = share_int_option(scfg, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT);
 573
 574                 return WERR_OK;
 575         }
 576         case 502:
 577         {
 578                 info->info502->name             = talloc_strdup(mem_ctx, scfg->name);
 579                 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
 580                 info->info502->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 581                 info->info502->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 582                 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
 583                 info->info502->permissions      = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 584                 info->info502->max_users        = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 585                 info->info502->current_users    = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 586                 info->info502->path             = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 587                 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
 588                 info->info502->password         = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 589                 info->info502->unknown          = dcesrv_common_get_share_unknown(mem_ctx, dce_ctx, scfg);
 590                 info->info502->sd               = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, scfg);
 591
 592                 return WERR_OK;
 593         }
 594         case 1005:
 595         {
 596                 info->info1005->dfs_flags       = dcesrv_common_get_share_dfs_flags(mem_ctx, dce_ctx, scfg);
 597
 598                 return WERR_OK;
 599         }
 600         default:
 601                 return WERR_UNKNOWN_LEVEL;
 602         }
 603
 604         return WERR_UNKNOWN_LEVEL;
 605 }
 606
 607 /*
 608   srvsvc_NetShareEnumAll
 609 */
 610 static WERROR srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 611                                      struct srvsvc_NetShareEnumAll *r)
 612 {
 613         NTSTATUS nterr;
 614         int numshares = 0;
 615         const char **snames;
 616         struct share_context *sctx;
 617         struct share_config *scfg;
 618
 619         r->out.level = r->in.level;
 620         ZERO_STRUCT(r->out.ctr);
 621         r->out.totalentries = 0;
 622         r->out.resume_handle = NULL;
 623
 624         /* TODO: - paging of results
 625          */
 626
 627         nterr = share_get_context(mem_ctx, &sctx);
 628         if (!NT_STATUS_IS_OK(nterr)) {
 629                 return ntstatus_to_werror(nterr);
 630         }
 631
 632         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
 633         if (!NT_STATUS_IS_OK(nterr)) {
 634                 return ntstatus_to_werror(nterr);
 635         }
 636
 637         switch (r->in.level) {
 638         case 0:
 639         {
 640                 int i;
 641                 struct srvsvc_NetShareCtr0 *ctr0;
 642
 643                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
 644                 W_ERROR_HAVE_NO_MEMORY(ctr0);
 645
 646                 ctr0->count = numshares;
 647                 ctr0->array = NULL;
 648
 649                 if (ctr0->count == 0) {
 650                         r->out.ctr.ctr0 = ctr0;
 651                         return WERR_OK;
 652                 }
 653
 654                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
 655                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
 656
 657                 for (i = 0; i < ctr0->count; i++) {
 658                         WERROR status;
 659                         union srvsvc_NetShareInfo info;
 660
 661                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 662                         if (!NT_STATUS_IS_OK(nterr)) {
 663                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 664                                 return WERR_GENERAL_FAILURE;
 665                         }
 666                         info.info0 = &ctr0->array[i];
 667                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 668                         if (!W_ERROR_IS_OK(status)) {
 669                                 return status;
 670                         }
 671                         talloc_free(scfg);
 672                 }
 673                 talloc_free(snames);
 674
 675                 r->out.ctr.ctr0         = ctr0;
 676                 r->out.totalentries     = r->out.ctr.ctr0->count;
 677                 return WERR_OK;
 678         }
 679         case 1:
 680         {
 681                 int i;
 682                 struct srvsvc_NetShareCtr1 *ctr1;
 683
 684                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
 685                 W_ERROR_HAVE_NO_MEMORY(ctr1);
 686
 687                 ctr1->count = numshares;
 688                 ctr1->array = NULL;
 689
 690                 if (ctr1->count == 0) {
 691                         r->out.ctr.ctr1 = ctr1;
 692                         return WERR_OK;
 693                 }
 694
 695                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
 696                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
 697
 698                 for (i=0; i < ctr1->count; i++) {
 699                         WERROR status;
 700                         union srvsvc_NetShareInfo info;
 701
 702                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 703                         if (!NT_STATUS_IS_OK(nterr)) {
 704                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 705                                 return WERR_GENERAL_FAILURE;
 706                         }
 707                         info.info1 = &ctr1->array[i];
 708                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 709                         if (!W_ERROR_IS_OK(status)) {
 710                                 return status;
 711                         }
 712                         talloc_free(scfg);
 713                 }
 714                 talloc_free(snames);
 715
 716                 r->out.ctr.ctr1         = ctr1;
 717                 r->out.totalentries     = r->out.ctr.ctr1->count;
 718                 return WERR_OK;
 719         }
 720         case 2:
 721         {
 722                 int i;
 723                 struct srvsvc_NetShareCtr2 *ctr2;
 724
 725                 SRVSVC_CHECK_ADMIN_ACCESS;
 726
 727                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
 728                 W_ERROR_HAVE_NO_MEMORY(ctr2);
 729
 730                 ctr2->count = numshares;
 731                 ctr2->array = NULL;
 732
 733                 if (ctr2->count == 0) {
 734                         r->out.ctr.ctr2 = ctr2;
 735                         return WERR_OK;
 736                 }
 737
 738                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
 739                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
 740
 741                 for (i=0; i < ctr2->count; i++) {
 742                         WERROR status;
 743                         union srvsvc_NetShareInfo info;
 744
 745                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 746                         if (!NT_STATUS_IS_OK(nterr)) {
 747                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 748                                 return WERR_GENERAL_FAILURE;
 749                         }
 750                         info.info2 = &ctr2->array[i];
 751                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 752                         if (!W_ERROR_IS_OK(status)) {
 753                                 return status;
 754                         }
 755                         talloc_free(scfg);
 756                 }
 757                 talloc_free(snames);
 758
 759                 r->out.ctr.ctr2         = ctr2;
 760                 r->out.totalentries     = r->out.ctr.ctr2->count;
 761                 return WERR_OK;
 762         }
 763         case 501:
 764         {
 765                 int i;
 766                 struct srvsvc_NetShareCtr501 *ctr501;
 767
 768                 SRVSVC_CHECK_ADMIN_ACCESS;
 769
 770                 ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
 771                 W_ERROR_HAVE_NO_MEMORY(ctr501);
 772
 773                 ctr501->count = numshares;
 774                 ctr501->array = NULL;
 775
 776                 if (ctr501->count == 0) {
 777                         r->out.ctr.ctr501 = ctr501;
 778                         return WERR_OK;
 779                 }
 780
 781                 ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
 782                 W_ERROR_HAVE_NO_MEMORY(ctr501->array);
 783
 784                 for (i=0; i < ctr501->count; i++) {
 785                         WERROR status;
 786                         union srvsvc_NetShareInfo info;
 787
 788                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 789                         if (!NT_STATUS_IS_OK(nterr)) {
 790                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 791                                 return WERR_GENERAL_FAILURE;
 792                         }
 793                         info.info501 = &ctr501->array[i];
 794                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 795                         if (!W_ERROR_IS_OK(status)) {
 796                                 return status;
 797                         }
 798                         talloc_free(scfg);
 799                 }
 800                 talloc_free(snames);
 801
 802                 r->out.ctr.ctr501       = ctr501;
 803                 r->out.totalentries     = r->out.ctr.ctr501->count;
 804                 return WERR_OK;
 805         }
 806         case 502:
 807         {
 808                 int i;
 809                 struct srvsvc_NetShareCtr502 *ctr502;
 810
 811                 SRVSVC_CHECK_ADMIN_ACCESS;
 812
 813                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
 814                 W_ERROR_HAVE_NO_MEMORY(ctr502);
 815
 816                 ctr502->count = numshares;
 817                 ctr502->array = NULL;
 818
 819                 if (ctr502->count == 0) {
 820                         r->out.ctr.ctr502 = ctr502;
 821                         return WERR_OK;
 822                 }
 823
 824                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
 825                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
 826
 827                 for (i=0; i < ctr502->count; i++) {
 828                         WERROR status;
 829                         union srvsvc_NetShareInfo info;
 830
 831                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 832                         if (!NT_STATUS_IS_OK(nterr)) {
 833                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 834                                 return WERR_GENERAL_FAILURE;
 835                         }
 836                         info.info502 = &ctr502->array[i];
 837                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 838                         if (!W_ERROR_IS_OK(status)) {
 839                                 return status;
 840                         }
 841                         talloc_free(scfg);
 842                 }
 843                 talloc_free(snames);
 844
 845                 r->out.ctr.ctr502       = ctr502;
 846                 r->out.totalentries     = r->out.ctr.ctr502->count;
 847                 return WERR_OK;
 848         }
 849         default:
 850                 return WERR_UNKNOWN_LEVEL;
 851         }
 852
 853         return WERR_UNKNOWN_LEVEL;
 854 }
 855
 856
 857 /*
 858   srvsvc_NetShareGetInfo
 859 */
 860 static WERROR srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 861                                      struct srvsvc_NetShareGetInfo *r)
 862 {
 863         NTSTATUS nterr;
 864         struct share_context *sctx = NULL;
 865         struct share_config *scfg = NULL;
 866
 867         ZERO_STRUCT(r->out);
 868
 869         /* TODO: - access check
 870          */
 871
 872         if (strcmp("", r->in.share_name) == 0) {
 873                 return WERR_INVALID_PARAM;
 874         }
 875
 876         nterr = share_get_context(mem_ctx, &sctx);
 877         if (!NT_STATUS_IS_OK(nterr)) {
 878                 return ntstatus_to_werror(nterr);
 879         }
 880
 881         nterr = share_get_config(mem_ctx, sctx, r->in.share_name, &scfg);
 882         if (!NT_STATUS_IS_OK(nterr)) {
 883                 return ntstatus_to_werror(nterr);
 884         }
 885
 886         switch (r->in.level) {
 887         case 0:
 888         {
 889                 WERROR status;
 890                 union srvsvc_NetShareInfo info;
 891
 892                 info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
 893                 W_ERROR_HAVE_NO_MEMORY(info.info0);
 894
 895                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 896                 if (!W_ERROR_IS_OK(status)) {
 897                         return status;
 898                 }
 899
 900                 r->out.info.info0 = info.info0;
 901                 return WERR_OK;
 902         }
 903         case 1:
 904         {
 905                 WERROR status;
 906                 union srvsvc_NetShareInfo info;
 907
 908                 info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
 909                 W_ERROR_HAVE_NO_MEMORY(info.info1);
 910
 911                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 912                 if (!W_ERROR_IS_OK(status)) {
 913                         return status;
 914                 }
 915
 916                 r->out.info.info1 = info.info1;
 917                 return WERR_OK;
 918         }
 919         case 2:
 920         {
 921                 WERROR status;
 922                 union srvsvc_NetShareInfo info;
 923
 924                 SRVSVC_CHECK_ADMIN_ACCESS;
 925
 926                 info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
 927                 W_ERROR_HAVE_NO_MEMORY(info.info2);
 928
 929                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 930                 if (!W_ERROR_IS_OK(status)) {
 931                         return status;
 932                 }
 933
 934                 r->out.info.info2 = info.info2;
 935                 return WERR_OK;
 936         }
 937         case 501:
 938         {
 939                 WERROR status;
 940                 union srvsvc_NetShareInfo info;
 941
 942                 info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
 943                 W_ERROR_HAVE_NO_MEMORY(info.info501);
 944
 945                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 946                 if (!W_ERROR_IS_OK(status)) {
 947                         return status;
 948                 }
 949
 950                 r->out.info.info501 = info.info501;
 951                 return WERR_OK;
 952         }
 953         case 502:
 954         {
 955                 WERROR status;
 956                 union srvsvc_NetShareInfo info;
 957
 958                 SRVSVC_CHECK_ADMIN_ACCESS;
 959
 960                 info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
 961                 W_ERROR_HAVE_NO_MEMORY(info.info502);
 962
 963                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 964                 if (!W_ERROR_IS_OK(status)) {
 965                         return status;
 966                 }
 967
 968                 r->out.info.info502 = info.info502;
 969                 return WERR_OK;
 970         }
 971         case 1005:
 972         {
 973                 WERROR status;
 974                 union srvsvc_NetShareInfo info;
 975
 976                 info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
 977                 W_ERROR_HAVE_NO_MEMORY(info.info1005);
 978
 979                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 980                 if (!W_ERROR_IS_OK(status)) {
 981                         return status;
 982                 }
 983
 984                 r->out.info.info1005 = info.info1005;
 985                 return WERR_OK;
 986         }
 987         default:
 988                 return WERR_UNKNOWN_LEVEL;
 989         }
 990
 991         return WERR_UNKNOWN_LEVEL;
 992 }
 993
 994
 995 /*
 996   srvsvc_NetShareSetInfo
 997 */
 998 static WERROR srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 999                        struct srvsvc_NetShareSetInfo *r)
1000 {
1001         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1002 }
1003
1004
1005 /*
1006   srvsvc_NetShareDelSticky
1007 */
1008 static WERROR srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1009                        struct srvsvc_NetShareDelSticky *r)
1010 {
1011         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1012 }
1013
1014
1015 /*
1016   srvsvc_NetShareCheck
1017 */
1018 static WERROR srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1019                        struct srvsvc_NetShareCheck *r)
1020 {
1021         ZERO_STRUCT(r->out);
1022
1023         /* TODO: - access check
1024          */
1025
1026         if (strcmp("", r->in.device_name) == 0) {
1027                 r->out.type = STYPE_IPC;
1028                 return WERR_OK;
1029         }
1030
1031         if (strcmp("C:\\", r->in.device_name) == 0) {
1032                 r->out.type = STYPE_DISKTREE;
1033                 return WERR_OK;
1034         }
1035
1036         /* TODO: - lookup the share be devicename (path) */
1037         return WERR_DEVICE_NOT_SHARED;
1038 }
1039
1040
1041 /*
1042   srvsvc_NetSrvGetInfo
1043 */
1044 static WERROR srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1045                        struct srvsvc_NetSrvGetInfo *r)
1046 {
1047         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1048
1049         ZERO_STRUCT(r->out);
1050
1051         switch (r->in.level) {
1052         case 100:
1053         {
1054                 struct srvsvc_NetSrvInfo100 *info100;
1055
1056                 info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
1057                 W_ERROR_HAVE_NO_MEMORY(info100);
1058
1059                 info100->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1060                 info100->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1061                 W_ERROR_HAVE_NO_MEMORY(info100->server_name);
1062
1063                 r->out.info.info100 = info100;
1064                 return WERR_OK;
1065         }
1066         case 101:
1067         {
1068                 struct srvsvc_NetSrvInfo101 *info101;
1069
1070                 info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
1071                 W_ERROR_HAVE_NO_MEMORY(info101);
1072
1073                 info101->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1074                 info101->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1075                 W_ERROR_HAVE_NO_MEMORY(info101->server_name);
1076
1077                 info101->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
1078                 info101->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
1079                 info101->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
1080                 info101->comment        = talloc_strdup(mem_ctx, lp_serverstring());
1081                 W_ERROR_HAVE_NO_MEMORY(info101->comment);
1082
1083                 r->out.info.info101 = info101;
1084                 return WERR_OK;
1085         }
1086         case 102:
1087         {
1088                 struct srvsvc_NetSrvInfo102 *info102;
1089
1090                 info102 = talloc(mem_ctx, struct srvsvc_NetSrvInfo102);
1091                 W_ERROR_HAVE_NO_MEMORY(info102);
1092
1093                 info102->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1094                 info102->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1095                 W_ERROR_HAVE_NO_MEMORY(info102->server_name);
1096
1097                 info102->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
1098                 info102->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
1099                 info102->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
1100                 info102->comment        = talloc_strdup(mem_ctx, lp_serverstring());
1101                 W_ERROR_HAVE_NO_MEMORY(info102->comment);
1102
1103                 info102->users          = dcesrv_common_get_users(mem_ctx, dce_ctx);
1104                 info102->disc           = dcesrv_common_get_disc(mem_ctx, dce_ctx);
1105                 info102->hidden         = dcesrv_common_get_hidden(mem_ctx, dce_ctx);
1106                 info102->announce       = dcesrv_common_get_announce(mem_ctx, dce_ctx);
1107                 info102->anndelta       = dcesrv_common_get_anndelta(mem_ctx, dce_ctx);
1108                 info102->licenses       = dcesrv_common_get_licenses(mem_ctx, dce_ctx);
1109                 info102->userpath       = dcesrv_common_get_userpath(mem_ctx, dce_ctx);
1110                 W_ERROR_HAVE_NO_MEMORY(info102->userpath);
1111
1112                 r->out.info.info102 = info102;
1113                 return WERR_OK;
1114         }
1115         default:
1116                 return WERR_UNKNOWN_LEVEL;
1117         }
1118
1119         return WERR_UNKNOWN_LEVEL;
1120 }
1121
1122
1123 /*
1124   srvsvc_NetSrvSetInfo
1125 */
1126 static WERROR srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1127                        struct srvsvc_NetSrvSetInfo *r)
1128 {
1129         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1130 }
1131
1132
1133 /*
1134   srvsvc_NetDiskEnum
1135 */
1136 static WERROR srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1137                        struct srvsvc_NetDiskEnum *r)
1138 {
1139         r->out.info.disks = NULL;
1140         r->out.info.count = 0;
1141         r->out.totalentries = 0;
1142         r->out.resume_handle = NULL;
1143
1144         switch (r->in.level) {
1145         case 0:
1146         {
1147                 /* we can safely hardcode the reply and report we have only one disk (C:) */
1148                 /* for some reason Windows wants 2 entries with the second being empty */
1149                 r->out.info.disks = talloc_array(mem_ctx, struct srvsvc_NetDiskInfo0, 2);
1150                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks);
1151                 r->out.info.count = 2;
1152
1153                 r->out.info.disks[0].disk = talloc_strdup(mem_ctx, "C:");
1154                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[0].disk);
1155
1156                 r->out.info.disks[1].disk = talloc_strdup(mem_ctx, "");
1157                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[1].disk);
1158
1159                 r->out.totalentries = 1;
1160                 r->out.resume_handle = r->in.resume_handle;
1161
1162                 return WERR_OK;
1163         }
1164         default:
1165                 return WERR_UNKNOWN_LEVEL;
1166         }
1167
1168         return WERR_UNKNOWN_LEVEL;
1169 }
1170
1171
1172 /*
1173   srvsvc_NetServerStatisticsGet
1174 */
1175 static WERROR srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1176                        struct srvsvc_NetServerStatisticsGet *r)
1177 {
1178         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1179 }
1180
1181
1182 /*
1183   srvsvc_NetTransportAdd
1184 */
1185 static WERROR srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1186                        struct srvsvc_NetTransportAdd *r)
1187 {
1188         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1189 }
1190
1191
1192 /*
1193   srvsvc_NetTransportEnum
1194 */
1195 static WERROR srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1196                        struct srvsvc_NetTransportEnum *r)
1197 {
1198         r->out.level = r->in.level;
1199         r->out.totalentries = 0;
1200         r->out.resume_handle = NULL;
1201
1202         switch (r->in.level) {
1203         case 0:
1204         {
1205                 r->out.transports.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
1206                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr0);
1207
1208                 r->out.transports.ctr0->count = 0;
1209                 r->out.transports.ctr0->array = NULL;
1210
1211                 return WERR_NOT_SUPPORTED;
1212         }
1213         case 1:
1214         {
1215                 r->out.transports.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
1216                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr1);
1217
1218                 r->out.transports.ctr1->count = 0;
1219                 r->out.transports.ctr1->array = NULL;
1220
1221                 return WERR_NOT_SUPPORTED;
1222         }
1223         case 2:
1224         {
1225                 r->out.transports.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
1226                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr2);
1227
1228                 r->out.transports.ctr2->count = 0;
1229                 r->out.transports.ctr2->array = NULL;
1230
1231                 return WERR_NOT_SUPPORTED;
1232         }
1233         case 3:
1234         {
1235                 r->out.transports.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
1236                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr3);
1237
1238                 r->out.transports.ctr3->count = 0;
1239                 r->out.transports.ctr3->array = NULL;
1240
1241                 return WERR_NOT_SUPPORTED;
1242         }
1243         default:
1244                 return WERR_UNKNOWN_LEVEL;
1245         }
1246
1247         return WERR_UNKNOWN_LEVEL;
1248 }
1249
1250 /*
1251   srvsvc_NetTransportDel
1252 */
1253 static WERROR srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1254                        struct srvsvc_NetTransportDel *r)
1255 {
1256         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1257 }
1258
1259
1260 /*
1261   srvsvc_NetRemoteTOD
1262 */
1263 static WERROR srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1264                        struct srvsvc_NetRemoteTOD *r)
1265 {
1266         struct timeval tval;
1267         time_t t;
1268         struct tm tm;
1269
1270         r->out.info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
1271         W_ERROR_HAVE_NO_MEMORY(r->out.info);
1272
1273         GetTimeOfDay(&tval);
1274         t = tval.tv_sec;
1275
1276         gmtime_r(&t, &tm);
1277
1278         r->out.info->elapsed    = t;
1279         /* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
1280         r->out.info->msecs      = (tm.tm_hour*60*60*1000)
1281                                 + (tm.tm_min*60*1000)
1282                                 + (tm.tm_sec*1000)
1283                                 + (tval.tv_usec/1000);
1284         r->out.info->hours      = tm.tm_hour;
1285         r->out.info->mins       = tm.tm_min;
1286         r->out.info->secs       = tm.tm_sec;
1287         r->out.info->hunds      = tval.tv_usec/10000;
1288         r->out.info->timezone   = get_time_zone(t)/60;
1289         r->out.info->tinterval  = 310; /* just return the same as windows */
1290         r->out.info->day        = tm.tm_mday;
1291         r->out.info->month      = tm.tm_mon + 1;
1292         r->out.info->year       = tm.tm_year + 1900;
1293         r->out.info->weekday    = tm.tm_wday;
1294
1295         return WERR_OK;
1296 }
1297
1298 /*
1299   srvsvc_NetPathType
1300 */
1301 static WERROR srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1302                        struct srvsvc_NetPathType *r)
1303 {
1304         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1305 }
1306
1307
1308 /*
1309   srvsvc_NetPathCanonicalize
1310 */
1311 static WERROR srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1312                        struct srvsvc_NetPathCanonicalize *r)
1313 {
1314         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1315 }
1316
1317
1318 /*
1319   srvsvc_NetPathCompare
1320 */
1321 static WERROR srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1322                        struct srvsvc_NetPathCompare *r)
1323 {
1324         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1325 }
1326
1327
1328 /*
1329   srvsvc_NetNameValidate
1330 */
1331 static WERROR srvsvc_NetNameValidate(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1332                        struct srvsvc_NetNameValidate *r)
1333 {
1334         int len;
1335
1336         if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
1337                 return WERR_INVALID_NAME;
1338         }
1339
1340         switch (r->in.name_type) {
1341         case 1:
1342         case 2:
1343         case 3:
1344         case 4:
1345         case 5:
1346         case 6:
1347         case 7:
1348         case 8:
1349                 return WERR_NOT_SUPPORTED;
1350
1351         case 9: /* validate share name */
1352
1353                 len = strlen_m(r->in.name);
1354                 if ((r->in.flags == 0x0) && (len > 81)) {
1355                         return WERR_INVALID_NAME;
1356                 }
1357                 if ((r->in.flags == 0x80000000) && (len > 13)) {
1358                         return WERR_INVALID_NAME;
1359                 }
1360                 if (! dcesrv_common_validate_share_name(mem_ctx, r->in.name)) {
1361                         return WERR_INVALID_NAME;
1362                 }
1363                 return WERR_OK;
1364
1365         case 10:
1366         case 11:
1367         case 12:
1368         case 13:
1369                 return WERR_NOT_SUPPORTED;
1370         default:
1371                 return WERR_INVALID_PARAM;
1372         }
1373
1374         return WERR_INVALID_PARAM;
1375 }
1376
1377
1378 /*
1379   srvsvc_NetPRNameCompare
1380 */
1381 static WERROR srvsvc_NetPRNameCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1382                        struct srvsvc_NetPRNameCompare *r)
1383 {
1384         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1385 }
1386
1387
1388 /*
1389   srvsvc_NetShareEnum
1390 */
1391 static WERROR srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1392                        struct srvsvc_NetShareEnum *r)
1393 {
1394         NTSTATUS nterr;
1395         int numshares = 0;
1396         const char **snames;
1397         struct share_context *sctx;
1398         struct share_config *scfg;
1399         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1400
1401         r->out.level = r->in.level;
1402         ZERO_STRUCT(r->out.ctr);
1403         r->out.totalentries = 0;
1404         r->out.resume_handle = NULL;
1405
1406         /* TODO: - paging of results
1407          */
1408
1409         nterr = share_get_context(mem_ctx, &sctx);
1410         if (!NT_STATUS_IS_OK(nterr)) {
1411                 return ntstatus_to_werror(nterr);
1412         }
1413
1414         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
1415         if (!NT_STATUS_IS_OK(nterr)) {
1416                 return ntstatus_to_werror(nterr);
1417         }
1418
1419         switch (r->in.level) {
1420         case 0:
1421         {
1422                 int i, y = 0;
1423                 int count;
1424                 struct srvsvc_NetShareCtr0 *ctr0;
1425
1426                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
1427                 W_ERROR_HAVE_NO_MEMORY(ctr0);
1428
1429                 count = numshares;
1430                 ctr0->count = count;
1431                 ctr0->array = NULL;
1432
1433                 if (ctr0->count == 0) {
1434                         r->out.ctr.ctr0 = ctr0;
1435                         return WERR_OK;
1436                 }
1437
1438                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, count);
1439                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
1440
1441                 for (i=0; i < count; i++) {
1442                         WERROR status;
1443                         union srvsvc_NetShareInfo info;
1444                         enum srvsvc_ShareType type;
1445
1446                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1447                         if (!NT_STATUS_IS_OK(nterr)) {
1448                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1449                                 return WERR_GENERAL_FAILURE;
1450                         }
1451
1452                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1453                         if (type & STYPE_HIDDEN) {
1454                                 ctr0->count--;
1455                                 talloc_free(scfg);
1456                                 continue;
1457                         }
1458
1459                         info.info0 = &ctr0->array[y];
1460                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1461                         W_ERROR_NOT_OK_RETURN(status);
1462                         talloc_free(scfg);
1463                         y++;
1464                 }
1465                 talloc_free(snames);
1466
1467                 r->out.ctr.ctr0         = ctr0;
1468                 r->out.totalentries     = r->out.ctr.ctr0->count;
1469                 return WERR_OK;
1470         }
1471         case 1:
1472         {
1473                 int i, y = 0;
1474                 int count;
1475                 struct srvsvc_NetShareCtr1 *ctr1;
1476
1477                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
1478                 W_ERROR_HAVE_NO_MEMORY(ctr1);
1479
1480                 count = numshares;
1481                 ctr1->count = count;
1482                 ctr1->array = NULL;
1483
1484                 if (ctr1->count == 0) {
1485                         r->out.ctr.ctr1 = ctr1;
1486                         return WERR_OK;
1487                 }
1488
1489                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, count);
1490                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1491
1492                 for (i=0; i < count; i++) {
1493                         WERROR status;
1494                         union srvsvc_NetShareInfo info;
1495                         enum srvsvc_ShareType type;
1496
1497                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1498                         if (!NT_STATUS_IS_OK(nterr)) {
1499                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1500                                 return WERR_GENERAL_FAILURE;
1501                         }
1502
1503                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1504                         if (type & STYPE_HIDDEN) {
1505                                 ctr1->count--;
1506                                 talloc_free(scfg);
1507                                 continue;
1508                         }
1509
1510                         info.info1 = &ctr1->array[y];
1511                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1512                         W_ERROR_NOT_OK_RETURN(status);
1513                         talloc_free(scfg);
1514                         y++;
1515                 }
1516                 talloc_free(snames);
1517
1518                 r->out.ctr.ctr1         = ctr1;
1519                 r->out.totalentries     = r->out.ctr.ctr1->count;
1520                 return WERR_OK;
1521         }
1522         case 2:
1523         {
1524                 int i, y = 0;
1525                 int count;
1526                 struct srvsvc_NetShareCtr2 *ctr2;
1527
1528                 SRVSVC_CHECK_ADMIN_ACCESS;
1529
1530                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
1531                 W_ERROR_HAVE_NO_MEMORY(ctr2);
1532
1533                 count = numshares;
1534                 ctr2->count = count;
1535                 ctr2->array = NULL;
1536
1537                 if (ctr2->count == 0) {
1538                         r->out.ctr.ctr2 = ctr2;
1539                         return WERR_OK;
1540                 }
1541
1542                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, count);
1543                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
1544
1545                 for (i=0; i < count; i++) {
1546                         WERROR status;
1547                         union srvsvc_NetShareInfo info;
1548                         enum srvsvc_ShareType type;
1549
1550                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1551                         if (!NT_STATUS_IS_OK(nterr)) {
1552                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1553                                 return WERR_GENERAL_FAILURE;
1554                         }
1555
1556                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1557                         if (type & STYPE_HIDDEN) {
1558                                 ctr2->count--;
1559                                 talloc_free(scfg);
1560                                 continue;
1561                         }
1562
1563                         info.info2 = &ctr2->array[y];
1564                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1565                         W_ERROR_NOT_OK_RETURN(status);
1566                         talloc_free(scfg);
1567                         y++;
1568                 }
1569                 talloc_free(snames);
1570
1571                 r->out.ctr.ctr2         = ctr2;
1572                 r->out.totalentries     = r->out.ctr.ctr2->count;
1573                 return WERR_OK;
1574         }
1575         case 502:
1576         {
1577                 int i, y = 0;
1578                 int count;
1579                 struct srvsvc_NetShareCtr502 *ctr502;
1580
1581                 SRVSVC_CHECK_ADMIN_ACCESS;
1582
1583                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
1584                 W_ERROR_HAVE_NO_MEMORY(ctr502);
1585
1586                 count = numshares;
1587                 ctr502->count = count;
1588                 ctr502->array = NULL;
1589
1590                 if (ctr502->count == 0) {
1591                         r->out.ctr.ctr502 = ctr502;
1592                         return WERR_OK;
1593                 }
1594
1595                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, count);
1596                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
1597
1598                 for (i=0; i < count; i++) {
1599                         WERROR status;
1600                         union srvsvc_NetShareInfo info;
1601                         enum srvsvc_ShareType type;
1602
1603                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1604                         if (!NT_STATUS_IS_OK(nterr)) {
1605                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1606                                 return WERR_GENERAL_FAILURE;
1607                         }
1608
1609                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1610                         if (type & STYPE_HIDDEN) {
1611                                 ctr502->count--;
1612                                 talloc_free(scfg);
1613                                 continue;
1614                         }
1615
1616                         info.info502 = &ctr502->array[y];
1617                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1618                         W_ERROR_NOT_OK_RETURN(status);
1619                         talloc_free(scfg);
1620                         y++;
1621                 }
1622                 talloc_free(snames);
1623
1624                 r->out.ctr.ctr502       = ctr502;
1625                 r->out.totalentries     = r->out.ctr.ctr502->count;
1626                 return WERR_OK;
1627         }
1628         default:
1629                 return WERR_UNKNOWN_LEVEL;
1630         }
1631
1632         return WERR_UNKNOWN_LEVEL;
1633 }
1634
1635
1636 /*
1637   srvsvc_NetShareDelStart
1638 */
1639 static WERROR srvsvc_NetShareDelStart(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1640                        struct srvsvc_NetShareDelStart *r)
1641 {
1642         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1643 }
1644
1645
1646 /*
1647   srvsvc_NetShareDelCommit
1648 */
1649 static WERROR srvsvc_NetShareDelCommit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1650                        struct srvsvc_NetShareDelCommit *r)
1651 {
1652         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1653 }
1654
1655
1656 /*
1657   srvsvc_NetGetFileSecurity
1658 */
1659 static WERROR srvsvc_NetGetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1660                        struct srvsvc_NetGetFileSecurity *r)
1661 {
1662         struct sec_desc_buf *sd_buf;
1663         struct ntvfs_context *ntvfs_ctx = NULL;
1664         struct ntvfs_request *ntvfs_req;
1665         union smb_fileinfo *io;
1666         NTSTATUS nt_status;
1667
1668         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
1669         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1670
1671         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
1672                                          dce_call->conn->auth_state.session_info,
1673                                          0,
1674                                          dce_call->time,
1675                                          NULL, NULL, 0);
1676         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
1677
1678         sd_buf = talloc(mem_ctx, struct sec_desc_buf);
1679         W_ERROR_HAVE_NO_MEMORY(sd_buf);
1680
1681         io = talloc(mem_ctx, union smb_fileinfo);
1682         W_ERROR_HAVE_NO_MEMORY(io);
1683
1684         io->query_secdesc.level                 = RAW_FILEINFO_SEC_DESC;
1685         io->query_secdesc.in.file.path          = r->in.file;
1686         io->query_secdesc.in.secinfo_flags      = r->in.securityinformation;
1687
1688         nt_status = ntvfs_qpathinfo(ntvfs_req, io);
1689         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1690
1691         sd_buf->sd = io->query_secdesc.out.sd;
1692
1693         r->out.sd_buf = sd_buf;
1694         return WERR_OK;
1695 }
1696
1697
1698 /*
1699   srvsvc_NetSetFileSecurity
1700 */
1701 static WERROR srvsvc_NetSetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1702                        struct srvsvc_NetSetFileSecurity *r)
1703 {
1704         struct ntvfs_context *ntvfs_ctx;
1705         struct ntvfs_request *ntvfs_req;
1706         union smb_setfileinfo *io;
1707         NTSTATUS nt_status;
1708
1709         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
1710         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1711
1712         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
1713                                          dce_call->conn->auth_state.session_info,
1714                                          0,
1715                                          dce_call->time,
1716                                          NULL, NULL, 0);
1717         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
1718
1719         io = talloc(mem_ctx, union smb_setfileinfo);
1720         W_ERROR_HAVE_NO_MEMORY(io);
1721
1722         io->set_secdesc.level                   = RAW_FILEINFO_SEC_DESC;
1723         io->set_secdesc.in.file.path            = r->in.file;
1724         io->set_secdesc.in.secinfo_flags        = r->in.securityinformation;
1725         io->set_secdesc.in.sd                   = r->in.sd_buf.sd;
1726
1727         nt_status = ntvfs_setpathinfo(ntvfs_req, io);
1728         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1729
1730         return WERR_OK;
1731 }
1732
1733
1734 /*
1735   srvsvc_NetServerTransportAddEx
1736 */
1737 static WERROR srvsvc_NetServerTransportAddEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1738                        struct srvsvc_NetServerTransportAddEx *r)
1739 {
1740         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1741 }
1742
1743
1744 /*
1745   srvsvc_NetServerSetServiceBitsEx
1746 */
1747 static WERROR srvsvc_NetServerSetServiceBitsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1748                        struct srvsvc_NetServerSetServiceBitsEx *r)
1749 {
1750         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1751 }
1752
1753
1754 /*
1755   srvsvc_NETRDFSGETVERSION
1756 */
1757 static WERROR srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1758                        struct srvsvc_NETRDFSGETVERSION *r)
1759 {
1760         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1761 }
1762
1763
1764 /*
1765   srvsvc_NETRDFSCREATELOCALPARTITION
1766 */
1767 static WERROR srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1768                        struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
1769 {
1770         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1771 }
1772
1773
1774 /*
1775   srvsvc_NETRDFSDELETELOCALPARTITION
1776 */
1777 static WERROR srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1778                        struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
1779 {
1780         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1781 }
1782
1783
1784 /*
1785   srvsvc_NETRDFSSETLOCALVOLUMESTATE
1786 */
1787 static WERROR srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1788                        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
1789 {
1790         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1791 }
1792
1793
1794 /*
1795   srvsvc_NETRDFSSETSERVERINFO
1796 */
1797 static WERROR srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1798                        struct srvsvc_NETRDFSSETSERVERINFO *r)
1799 {
1800         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1801 }
1802
1803
1804 /*
1805   srvsvc_NETRDFSCREATEEXITPOINT
1806 */
1807 static WERROR srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1808                        struct srvsvc_NETRDFSCREATEEXITPOINT *r)
1809 {
1810         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1811 }
1812
1813
1814 /*
1815   srvsvc_NETRDFSDELETEEXITPOINT
1816 */
1817 static WERROR srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1818                        struct srvsvc_NETRDFSDELETEEXITPOINT *r)
1819 {
1820         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1821 }
1822
1823
1824 /*
1825   srvsvc_NETRDFSMODIFYPREFIX
1826 */
1827 static WERROR srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1828                        struct srvsvc_NETRDFSMODIFYPREFIX *r)
1829 {
1830         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1831 }
1832
1833
1834 /*
1835   srvsvc_NETRDFSFIXLOCALVOLUME
1836 */
1837 static WERROR srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1838                        struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
1839 {
1840         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1841 }
1842
1843
1844 /*
1845   srvsvc_NETRDFSMANAGERREPORTSITEINFO
1846 */
1847 static WERROR srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1848                        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
1849 {
1850         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1851 }
1852
1853
1854 /*
1855   srvsvc_NETRSERVERTRANSPORTDELEX
1856 */
1857 static WERROR srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1858                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
1859 {
1860         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1861 }
1862
1863 /*
1864   srvsvc_NetShareDel
1865 */
1866 static WERROR srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1867                        struct srvsvc_NetShareDel *r)
1868 {
1869         NTSTATUS nterr;
1870         struct share_context *sctx;
1871
1872         nterr = share_get_context(mem_ctx, &sctx);
1873         if (!NT_STATUS_IS_OK(nterr)) {
1874                 return ntstatus_to_werror(nterr);
1875         }
1876
1877         nterr = share_remove(sctx, r->in.share_name);
1878         if (!NT_STATUS_IS_OK(nterr)) {
1879                 return ntstatus_to_werror(nterr);
1880         }
1881
1882         return WERR_OK;
1883 }
1884
1885 /*
1886   srvsvc_NetSetServiceBits
1887 */
1888 static WERROR srvsvc_NetSetServiceBits(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1889                        struct srvsvc_NetSetServiceBits *r)
1890 {
1891         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1892 }
1893
1894 /*
1895   srvsvc_NETRPRNAMECANONICALIZE
1896 */
1897 static WERROR srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1898                        struct srvsvc_NETRPRNAMECANONICALIZE *r)
1899 {
1900         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1901 }
1902
1903 /* include the generated boilerplate */
1904 #include "librpc/gen_ndr/ndr_srvsvc_s.c"