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                 if (r->in.parm_error) {
 456                         r->out.parm_error = r->in.parm_error;
 457                 }
 458                 return WERR_NOT_SUPPORTED;
 459         }
 460         default:
 461                 return WERR_UNKNOWN_LEVEL;
 462         }
 463
 464         return WERR_UNKNOWN_LEVEL;
 465 }
 466
 467 static WERROR srvsvc_fiel_ShareInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 468                                     struct share_config *scfg, uint32_t level,
 469                                     union srvsvc_NetShareInfo *info)
 470 {
 471         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 472
 473         switch (level) {
 474         case 0:
 475         {
 476                 info->info0->name       = talloc_strdup(mem_ctx, scfg->name);
 477                 W_ERROR_HAVE_NO_MEMORY(info->info0->name);
 478
 479                 return WERR_OK;
 480         }
 481         case 1:
 482         {
 483                 info->info1->name       = talloc_strdup(mem_ctx, scfg->name);
 484                 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
 485                 info->info1->type       = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 486                 info->info1->comment    = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 487                 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
 488
 489                 return WERR_OK;
 490         }
 491         case 2:
 492         {
 493                 info->info2->name               = talloc_strdup(mem_ctx, scfg->name);
 494                 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
 495                 info->info2->type               = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 496                 info->info2->comment            = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 497                 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
 498                 info->info2->permissions        = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 499                 info->info2->max_users          = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 500                 info->info2->current_users      = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 501                 info->info2->path               = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 502                 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
 503                 info->info2->password           = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 504
 505                 return WERR_OK;
 506         }
 507         case 501:
 508         {
 509                 info->info501->name             = talloc_strdup(mem_ctx, scfg->name);
 510                 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
 511                 info->info501->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 512                 info->info501->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 513                 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
 514                 info->info501->csc_policy       = share_int_option(scfg, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT);
 515
 516                 return WERR_OK;
 517         }
 518         case 502:
 519         {
 520                 info->info502->name             = talloc_strdup(mem_ctx, scfg->name);
 521                 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
 522                 info->info502->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 523                 info->info502->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 524                 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
 525                 info->info502->permissions      = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 526                 info->info502->max_users        = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 527                 info->info502->current_users    = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 528                 info->info502->path             = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 529                 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
 530                 info->info502->password         = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 531                 info->info502->unknown          = dcesrv_common_get_share_unknown(mem_ctx, dce_ctx, scfg);
 532                 info->info502->sd               = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, scfg);
 533
 534                 return WERR_OK;
 535         }
 536         case 1005:
 537         {
 538                 info->info1005->dfs_flags       = dcesrv_common_get_share_dfs_flags(mem_ctx, dce_ctx, scfg);
 539
 540                 return WERR_OK;
 541         }
 542         default:
 543                 return WERR_UNKNOWN_LEVEL;
 544         }
 545
 546         return WERR_UNKNOWN_LEVEL;
 547 }
 548
 549 /*
 550   srvsvc_NetShareEnumAll
 551 */
 552 static WERROR srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 553                                      struct srvsvc_NetShareEnumAll *r)
 554 {
 555         NTSTATUS nterr;
 556         int numshares = 0;
 557         const char **snames;
 558         struct share_context *sctx;
 559         struct share_config *scfg;
 560
 561         r->out.level = r->in.level;
 562         ZERO_STRUCT(r->out.ctr);
 563         r->out.totalentries = 0;
 564         r->out.resume_handle = NULL;
 565
 566         /* TODO: - paging of results
 567          */
 568
 569         nterr = share_get_context(mem_ctx, &sctx);
 570         if (!NT_STATUS_IS_OK(nterr)) {
 571                 return ntstatus_to_werror(nterr);
 572         }
 573
 574         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
 575         if (!NT_STATUS_IS_OK(nterr)) {
 576                 return ntstatus_to_werror(nterr);
 577         }
 578
 579         switch (r->in.level) {
 580         case 0:
 581         {
 582                 int i;
 583                 struct srvsvc_NetShareCtr0 *ctr0;
 584
 585                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
 586                 W_ERROR_HAVE_NO_MEMORY(ctr0);
 587
 588                 ctr0->count = numshares;
 589                 ctr0->array = NULL;
 590
 591                 if (ctr0->count == 0) {
 592                         r->out.ctr.ctr0 = ctr0;
 593                         return WERR_OK;
 594                 }
 595
 596                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
 597                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
 598
 599                 for (i = 0; i < ctr0->count; i++) {
 600                         WERROR status;
 601                         union srvsvc_NetShareInfo info;
 602
 603                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 604                         if (!NT_STATUS_IS_OK(nterr)) {
 605                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 606                                 return WERR_GENERAL_FAILURE;
 607                         }
 608                         info.info0 = &ctr0->array[i];
 609                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 610                         if (!W_ERROR_IS_OK(status)) {
 611                                 return status;
 612                         }
 613                         talloc_free(scfg);
 614                 }
 615                 talloc_free(snames);
 616
 617                 r->out.ctr.ctr0         = ctr0;
 618                 r->out.totalentries     = r->out.ctr.ctr0->count;
 619                 return WERR_OK;
 620         }
 621         case 1:
 622         {
 623                 int i;
 624                 struct srvsvc_NetShareCtr1 *ctr1;
 625
 626                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
 627                 W_ERROR_HAVE_NO_MEMORY(ctr1);
 628
 629                 ctr1->count = numshares;
 630                 ctr1->array = NULL;
 631
 632                 if (ctr1->count == 0) {
 633                         r->out.ctr.ctr1 = ctr1;
 634                         return WERR_OK;
 635                 }
 636
 637                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
 638                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
 639
 640                 for (i=0; i < ctr1->count; i++) {
 641                         WERROR status;
 642                         union srvsvc_NetShareInfo info;
 643
 644                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 645                         if (!NT_STATUS_IS_OK(nterr)) {
 646                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 647                                 return WERR_GENERAL_FAILURE;
 648                         }
 649                         info.info1 = &ctr1->array[i];
 650                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 651                         if (!W_ERROR_IS_OK(status)) {
 652                                 return status;
 653                         }
 654                         talloc_free(scfg);
 655                 }
 656                 talloc_free(snames);
 657
 658                 r->out.ctr.ctr1         = ctr1;
 659                 r->out.totalentries     = r->out.ctr.ctr1->count;
 660                 return WERR_OK;
 661         }
 662         case 2:
 663         {
 664                 int i;
 665                 struct srvsvc_NetShareCtr2 *ctr2;
 666
 667                 SRVSVC_CHECK_ADMIN_ACCESS;
 668
 669                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
 670                 W_ERROR_HAVE_NO_MEMORY(ctr2);
 671
 672                 ctr2->count = numshares;
 673                 ctr2->array = NULL;
 674
 675                 if (ctr2->count == 0) {
 676                         r->out.ctr.ctr2 = ctr2;
 677                         return WERR_OK;
 678                 }
 679
 680                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
 681                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
 682
 683                 for (i=0; i < ctr2->count; i++) {
 684                         WERROR status;
 685                         union srvsvc_NetShareInfo info;
 686
 687                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 688                         if (!NT_STATUS_IS_OK(nterr)) {
 689                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 690                                 return WERR_GENERAL_FAILURE;
 691                         }
 692                         info.info2 = &ctr2->array[i];
 693                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 694                         if (!W_ERROR_IS_OK(status)) {
 695                                 return status;
 696                         }
 697                         talloc_free(scfg);
 698                 }
 699                 talloc_free(snames);
 700
 701                 r->out.ctr.ctr2         = ctr2;
 702                 r->out.totalentries     = r->out.ctr.ctr2->count;
 703                 return WERR_OK;
 704         }
 705         case 501:
 706         {
 707                 int i;
 708                 struct srvsvc_NetShareCtr501 *ctr501;
 709
 710                 SRVSVC_CHECK_ADMIN_ACCESS;
 711
 712                 ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
 713                 W_ERROR_HAVE_NO_MEMORY(ctr501);
 714
 715                 ctr501->count = numshares;
 716                 ctr501->array = NULL;
 717
 718                 if (ctr501->count == 0) {
 719                         r->out.ctr.ctr501 = ctr501;
 720                         return WERR_OK;
 721                 }
 722
 723                 ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
 724                 W_ERROR_HAVE_NO_MEMORY(ctr501->array);
 725
 726                 for (i=0; i < ctr501->count; i++) {
 727                         WERROR status;
 728                         union srvsvc_NetShareInfo info;
 729
 730                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 731                         if (!NT_STATUS_IS_OK(nterr)) {
 732                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 733                                 return WERR_GENERAL_FAILURE;
 734                         }
 735                         info.info501 = &ctr501->array[i];
 736                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 737                         if (!W_ERROR_IS_OK(status)) {
 738                                 return status;
 739                         }
 740                         talloc_free(scfg);
 741                 }
 742                 talloc_free(snames);
 743
 744                 r->out.ctr.ctr501       = ctr501;
 745                 r->out.totalentries     = r->out.ctr.ctr501->count;
 746                 return WERR_OK;
 747         }
 748         case 502:
 749         {
 750                 int i;
 751                 struct srvsvc_NetShareCtr502 *ctr502;
 752
 753                 SRVSVC_CHECK_ADMIN_ACCESS;
 754
 755                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
 756                 W_ERROR_HAVE_NO_MEMORY(ctr502);
 757
 758                 ctr502->count = numshares;
 759                 ctr502->array = NULL;
 760
 761                 if (ctr502->count == 0) {
 762                         r->out.ctr.ctr502 = ctr502;
 763                         return WERR_OK;
 764                 }
 765
 766                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
 767                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
 768
 769                 for (i=0; i < ctr502->count; i++) {
 770                         WERROR status;
 771                         union srvsvc_NetShareInfo info;
 772
 773                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 774                         if (!NT_STATUS_IS_OK(nterr)) {
 775                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 776                                 return WERR_GENERAL_FAILURE;
 777                         }
 778                         info.info502 = &ctr502->array[i];
 779                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 780                         if (!W_ERROR_IS_OK(status)) {
 781                                 return status;
 782                         }
 783                         talloc_free(scfg);
 784                 }
 785                 talloc_free(snames);
 786
 787                 r->out.ctr.ctr502       = ctr502;
 788                 r->out.totalentries     = r->out.ctr.ctr502->count;
 789                 return WERR_OK;
 790         }
 791         default:
 792                 return WERR_UNKNOWN_LEVEL;
 793         }
 794
 795         return WERR_UNKNOWN_LEVEL;
 796 }
 797
 798
 799 /*
 800   srvsvc_NetShareGetInfo
 801 */
 802 static WERROR srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 803                                      struct srvsvc_NetShareGetInfo *r)
 804 {
 805         NTSTATUS nterr;
 806         struct share_context *sctx = NULL;
 807         struct share_config *scfg = NULL;
 808
 809         ZERO_STRUCT(r->out);
 810
 811         /* TODO: - access check
 812          */
 813
 814         if (strcmp("", r->in.share_name) == 0) {
 815                 return WERR_INVALID_PARAM;
 816         }
 817
 818         nterr = share_get_context(mem_ctx, &sctx);
 819         if (!NT_STATUS_IS_OK(nterr)) {
 820                 return ntstatus_to_werror(nterr);
 821         }
 822
 823         nterr = share_get_config(mem_ctx, sctx, r->in.share_name, &scfg);
 824         if (!NT_STATUS_IS_OK(nterr)) {
 825                 return ntstatus_to_werror(nterr);
 826         }
 827
 828         switch (r->in.level) {
 829         case 0:
 830         {
 831                 WERROR status;
 832                 union srvsvc_NetShareInfo info;
 833
 834                 info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
 835                 W_ERROR_HAVE_NO_MEMORY(info.info0);
 836
 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
 842                 r->out.info.info0 = info.info0;
 843                 return WERR_OK;
 844         }
 845         case 1:
 846         {
 847                 WERROR status;
 848                 union srvsvc_NetShareInfo info;
 849
 850                 info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
 851                 W_ERROR_HAVE_NO_MEMORY(info.info1);
 852
 853                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 854                 if (!W_ERROR_IS_OK(status)) {
 855                         return status;
 856                 }
 857
 858                 r->out.info.info1 = info.info1;
 859                 return WERR_OK;
 860         }
 861         case 2:
 862         {
 863                 WERROR status;
 864                 union srvsvc_NetShareInfo info;
 865
 866                 SRVSVC_CHECK_ADMIN_ACCESS;
 867
 868                 info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
 869                 W_ERROR_HAVE_NO_MEMORY(info.info2);
 870
 871                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 872                 if (!W_ERROR_IS_OK(status)) {
 873                         return status;
 874                 }
 875
 876                 r->out.info.info2 = info.info2;
 877                 return WERR_OK;
 878         }
 879         case 501:
 880         {
 881                 WERROR status;
 882                 union srvsvc_NetShareInfo info;
 883
 884                 info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
 885                 W_ERROR_HAVE_NO_MEMORY(info.info501);
 886
 887                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 888                 if (!W_ERROR_IS_OK(status)) {
 889                         return status;
 890                 }
 891
 892                 r->out.info.info501 = info.info501;
 893                 return WERR_OK;
 894         }
 895         case 502:
 896         {
 897                 WERROR status;
 898                 union srvsvc_NetShareInfo info;
 899
 900                 SRVSVC_CHECK_ADMIN_ACCESS;
 901
 902                 info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
 903                 W_ERROR_HAVE_NO_MEMORY(info.info502);
 904
 905                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 906                 if (!W_ERROR_IS_OK(status)) {
 907                         return status;
 908                 }
 909
 910                 r->out.info.info502 = info.info502;
 911                 return WERR_OK;
 912         }
 913         case 1005:
 914         {
 915                 WERROR status;
 916                 union srvsvc_NetShareInfo info;
 917
 918                 info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
 919                 W_ERROR_HAVE_NO_MEMORY(info.info1005);
 920
 921                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 922                 if (!W_ERROR_IS_OK(status)) {
 923                         return status;
 924                 }
 925
 926                 r->out.info.info1005 = info.info1005;
 927                 return WERR_OK;
 928         }
 929         default:
 930                 return WERR_UNKNOWN_LEVEL;
 931         }
 932
 933         return WERR_UNKNOWN_LEVEL;
 934 }
 935
 936
 937 /*
 938   srvsvc_NetShareSetInfo
 939 */
 940 static WERROR srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 941                        struct srvsvc_NetShareSetInfo *r)
 942 {
 943         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 944 }
 945
 946
 947 /*
 948   srvsvc_NetShareDelSticky
 949 */
 950 static WERROR srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 951                        struct srvsvc_NetShareDelSticky *r)
 952 {
 953         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 954 }
 955
 956
 957 /*
 958   srvsvc_NetShareCheck
 959 */
 960 static WERROR srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 961                        struct srvsvc_NetShareCheck *r)
 962 {
 963         ZERO_STRUCT(r->out);
 964
 965         /* TODO: - access check
 966          */
 967
 968         if (strcmp("", r->in.device_name) == 0) {
 969                 r->out.type = STYPE_IPC;
 970                 return WERR_OK;
 971         }
 972
 973         if (strcmp("C:\\", r->in.device_name) == 0) {
 974                 r->out.type = STYPE_DISKTREE;
 975                 return WERR_OK;
 976         }
 977
 978         /* TODO: - lookup the share be devicename (path) */
 979         return WERR_DEVICE_NOT_SHARED;
 980 }
 981
 982
 983 /*
 984   srvsvc_NetSrvGetInfo
 985 */
 986 static WERROR srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 987                        struct srvsvc_NetSrvGetInfo *r)
 988 {
 989         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 990
 991         ZERO_STRUCT(r->out);
 992
 993         switch (r->in.level) {
 994         case 100:
 995         {
 996                 struct srvsvc_NetSrvInfo100 *info100;
 997
 998                 info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
 999                 W_ERROR_HAVE_NO_MEMORY(info100);
1000
1001                 info100->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1002                 info100->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1003                 W_ERROR_HAVE_NO_MEMORY(info100->server_name);
1004
1005                 r->out.info.info100 = info100;
1006                 return WERR_OK;
1007         }
1008         case 101:
1009         {
1010                 struct srvsvc_NetSrvInfo101 *info101;
1011
1012                 info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
1013                 W_ERROR_HAVE_NO_MEMORY(info101);
1014
1015                 info101->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1016                 info101->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1017                 W_ERROR_HAVE_NO_MEMORY(info101->server_name);
1018
1019                 info101->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
1020                 info101->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
1021                 info101->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
1022                 info101->comment        = talloc_strdup(mem_ctx, lp_serverstring());
1023                 W_ERROR_HAVE_NO_MEMORY(info101->comment);
1024
1025                 r->out.info.info101 = info101;
1026                 return WERR_OK;
1027         }
1028         case 102:
1029         {
1030                 struct srvsvc_NetSrvInfo102 *info102;
1031
1032                 info102 = talloc(mem_ctx, struct srvsvc_NetSrvInfo102);
1033                 W_ERROR_HAVE_NO_MEMORY(info102);
1034
1035                 info102->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1036                 info102->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1037                 W_ERROR_HAVE_NO_MEMORY(info102->server_name);
1038
1039                 info102->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
1040                 info102->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
1041                 info102->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
1042                 info102->comment        = talloc_strdup(mem_ctx, lp_serverstring());
1043                 W_ERROR_HAVE_NO_MEMORY(info102->comment);
1044
1045                 info102->users          = dcesrv_common_get_users(mem_ctx, dce_ctx);
1046                 info102->disc           = dcesrv_common_get_disc(mem_ctx, dce_ctx);
1047                 info102->hidden         = dcesrv_common_get_hidden(mem_ctx, dce_ctx);
1048                 info102->announce       = dcesrv_common_get_announce(mem_ctx, dce_ctx);
1049                 info102->anndelta       = dcesrv_common_get_anndelta(mem_ctx, dce_ctx);
1050                 info102->licenses       = dcesrv_common_get_licenses(mem_ctx, dce_ctx);
1051                 info102->userpath       = dcesrv_common_get_userpath(mem_ctx, dce_ctx);
1052                 W_ERROR_HAVE_NO_MEMORY(info102->userpath);
1053
1054                 r->out.info.info102 = info102;
1055                 return WERR_OK;
1056         }
1057         default:
1058                 return WERR_UNKNOWN_LEVEL;
1059         }
1060
1061         return WERR_UNKNOWN_LEVEL;
1062 }
1063
1064
1065 /*
1066   srvsvc_NetSrvSetInfo
1067 */
1068 static WERROR srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1069                        struct srvsvc_NetSrvSetInfo *r)
1070 {
1071         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1072 }
1073
1074
1075 /*
1076   srvsvc_NetDiskEnum
1077 */
1078 static WERROR srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1079                        struct srvsvc_NetDiskEnum *r)
1080 {
1081         r->out.info.disks = NULL;
1082         r->out.info.count = 0;
1083         r->out.totalentries = 0;
1084         r->out.resume_handle = NULL;
1085
1086         switch (r->in.level) {
1087         case 0:
1088         {
1089                 /* we can safely hardcode the reply and report we have only one disk (C:) */
1090                 /* for some reason Windows wants 2 entries with the second being empty */
1091                 r->out.info.disks = talloc_array(mem_ctx, struct srvsvc_NetDiskInfo0, 2);
1092                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks);
1093                 r->out.info.count = 2;
1094
1095                 r->out.info.disks[0].disk = talloc_strdup(mem_ctx, "C:");
1096                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[0].disk);
1097
1098                 r->out.info.disks[1].disk = talloc_strdup(mem_ctx, "");
1099                 W_ERROR_HAVE_NO_MEMORY(r->out.info.disks[1].disk);
1100
1101                 r->out.totalentries = 1;
1102                 r->out.resume_handle = r->in.resume_handle;
1103
1104                 return WERR_OK;
1105         }
1106         default:
1107                 return WERR_UNKNOWN_LEVEL;
1108         }
1109
1110         return WERR_UNKNOWN_LEVEL;
1111 }
1112
1113
1114 /*
1115   srvsvc_NetServerStatisticsGet
1116 */
1117 static WERROR srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1118                        struct srvsvc_NetServerStatisticsGet *r)
1119 {
1120         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1121 }
1122
1123
1124 /*
1125   srvsvc_NetTransportAdd
1126 */
1127 static WERROR srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1128                        struct srvsvc_NetTransportAdd *r)
1129 {
1130         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1131 }
1132
1133
1134 /*
1135   srvsvc_NetTransportEnum
1136 */
1137 static WERROR srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1138                        struct srvsvc_NetTransportEnum *r)
1139 {
1140         r->out.level = r->in.level;
1141         r->out.totalentries = 0;
1142         r->out.resume_handle = NULL;
1143
1144         switch (r->in.level) {
1145         case 0:
1146         {
1147                 r->out.transports.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
1148                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr0);
1149
1150                 r->out.transports.ctr0->count = 0;
1151                 r->out.transports.ctr0->array = NULL;
1152
1153                 return WERR_NOT_SUPPORTED;
1154         }
1155         case 1:
1156         {
1157                 r->out.transports.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
1158                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr1);
1159
1160                 r->out.transports.ctr1->count = 0;
1161                 r->out.transports.ctr1->array = NULL;
1162
1163                 return WERR_NOT_SUPPORTED;
1164         }
1165         case 2:
1166         {
1167                 r->out.transports.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
1168                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr2);
1169
1170                 r->out.transports.ctr2->count = 0;
1171                 r->out.transports.ctr2->array = NULL;
1172
1173                 return WERR_NOT_SUPPORTED;
1174         }
1175         case 3:
1176         {
1177                 r->out.transports.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
1178                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr3);
1179
1180                 r->out.transports.ctr3->count = 0;
1181                 r->out.transports.ctr3->array = NULL;
1182
1183                 return WERR_NOT_SUPPORTED;
1184         }
1185         default:
1186                 return WERR_UNKNOWN_LEVEL;
1187         }
1188
1189         return WERR_UNKNOWN_LEVEL;
1190 }
1191
1192 /*
1193   srvsvc_NetTransportDel
1194 */
1195 static WERROR srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1196                        struct srvsvc_NetTransportDel *r)
1197 {
1198         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1199 }
1200
1201
1202 /*
1203   srvsvc_NetRemoteTOD
1204 */
1205 static WERROR srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1206                        struct srvsvc_NetRemoteTOD *r)
1207 {
1208         struct timeval tval;
1209         time_t t;
1210         struct tm tm;
1211
1212         r->out.info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
1213         W_ERROR_HAVE_NO_MEMORY(r->out.info);
1214
1215         GetTimeOfDay(&tval);
1216         t = tval.tv_sec;
1217
1218         gmtime_r(&t, &tm);
1219
1220         r->out.info->elapsed    = t;
1221         /* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
1222         r->out.info->msecs      = (tm.tm_hour*60*60*1000)
1223                                 + (tm.tm_min*60*1000)
1224                                 + (tm.tm_sec*1000)
1225                                 + (tval.tv_usec/1000);
1226         r->out.info->hours      = tm.tm_hour;
1227         r->out.info->mins       = tm.tm_min;
1228         r->out.info->secs       = tm.tm_sec;
1229         r->out.info->hunds      = tval.tv_usec/10000;
1230         r->out.info->timezone   = get_time_zone(t)/60;
1231         r->out.info->tinterval  = 310; /* just return the same as windows */
1232         r->out.info->day        = tm.tm_mday;
1233         r->out.info->month      = tm.tm_mon + 1;
1234         r->out.info->year       = tm.tm_year + 1900;
1235         r->out.info->weekday    = tm.tm_wday;
1236
1237         return WERR_OK;
1238 }
1239
1240 /*
1241   srvsvc_NetPathType
1242 */
1243 static WERROR srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1244                        struct srvsvc_NetPathType *r)
1245 {
1246         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1247 }
1248
1249
1250 /*
1251   srvsvc_NetPathCanonicalize
1252 */
1253 static WERROR srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1254                        struct srvsvc_NetPathCanonicalize *r)
1255 {
1256         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1257 }
1258
1259
1260 /*
1261   srvsvc_NetPathCompare
1262 */
1263 static WERROR srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1264                        struct srvsvc_NetPathCompare *r)
1265 {
1266         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1267 }
1268
1269
1270 /*
1271   srvsvc_NetNameValidate
1272 */
1273 static WERROR srvsvc_NetNameValidate(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1274                        struct srvsvc_NetNameValidate *r)
1275 {
1276         int len;
1277
1278         if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
1279                 return WERR_INVALID_NAME;
1280         }
1281
1282         switch (r->in.name_type) {
1283         case 1:
1284         case 2:
1285         case 3:
1286         case 4:
1287         case 5:
1288         case 6:
1289         case 7:
1290         case 8:
1291                 return WERR_NOT_SUPPORTED;
1292
1293         case 9: /* validate share name */
1294
1295                 len = strlen_m(r->in.name);
1296                 if ((r->in.flags == 0x0) && (len > 81)) {
1297                         return WERR_INVALID_NAME;
1298                 }
1299                 if ((r->in.flags == 0x80000000) && (len > 13)) {
1300                         return WERR_INVALID_NAME;
1301                 }
1302                 if (! dcesrv_common_validate_share_name(mem_ctx, r->in.name)) {
1303                         return WERR_INVALID_NAME;
1304                 }
1305                 return WERR_OK;
1306
1307         case 10:
1308         case 11:
1309         case 12:
1310         case 13:
1311                 return WERR_NOT_SUPPORTED;
1312         default:
1313                 return WERR_INVALID_PARAM;
1314         }
1315
1316         return WERR_INVALID_PARAM;
1317 }
1318
1319
1320 /*
1321   srvsvc_NetPRNameCompare
1322 */
1323 static WERROR srvsvc_NetPRNameCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1324                        struct srvsvc_NetPRNameCompare *r)
1325 {
1326         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1327 }
1328
1329
1330 /*
1331   srvsvc_NetShareEnum
1332 */
1333 static WERROR srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1334                        struct srvsvc_NetShareEnum *r)
1335 {
1336         NTSTATUS nterr;
1337         int numshares = 0;
1338         const char **snames;
1339         struct share_context *sctx;
1340         struct share_config *scfg;
1341         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1342
1343         r->out.level = r->in.level;
1344         ZERO_STRUCT(r->out.ctr);
1345         r->out.totalentries = 0;
1346         r->out.resume_handle = NULL;
1347
1348         /* TODO: - paging of results
1349          */
1350
1351         nterr = share_get_context(mem_ctx, &sctx);
1352         if (!NT_STATUS_IS_OK(nterr)) {
1353                 return ntstatus_to_werror(nterr);
1354         }
1355
1356         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
1357         if (!NT_STATUS_IS_OK(nterr)) {
1358                 return ntstatus_to_werror(nterr);
1359         }
1360
1361         switch (r->in.level) {
1362         case 0:
1363         {
1364                 int i, y = 0;
1365                 int count;
1366                 struct srvsvc_NetShareCtr0 *ctr0;
1367
1368                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
1369                 W_ERROR_HAVE_NO_MEMORY(ctr0);
1370
1371                 count = numshares;
1372                 ctr0->count = count;
1373                 ctr0->array = NULL;
1374
1375                 if (ctr0->count == 0) {
1376                         r->out.ctr.ctr0 = ctr0;
1377                         return WERR_OK;
1378                 }
1379
1380                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, count);
1381                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
1382
1383                 for (i=0; i < count; i++) {
1384                         WERROR status;
1385                         union srvsvc_NetShareInfo info;
1386                         enum srvsvc_ShareType type;
1387
1388                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1389                         if (!NT_STATUS_IS_OK(nterr)) {
1390                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1391                                 return WERR_GENERAL_FAILURE;
1392                         }
1393
1394                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1395                         if (type & STYPE_HIDDEN) {
1396                                 ctr0->count--;
1397                                 talloc_free(scfg);
1398                                 continue;
1399                         }
1400
1401                         info.info0 = &ctr0->array[y];
1402                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1403                         W_ERROR_NOT_OK_RETURN(status);
1404                         talloc_free(scfg);
1405                         y++;
1406                 }
1407                 talloc_free(snames);
1408
1409                 r->out.ctr.ctr0         = ctr0;
1410                 r->out.totalentries     = r->out.ctr.ctr0->count;
1411                 return WERR_OK;
1412         }
1413         case 1:
1414         {
1415                 int i, y = 0;
1416                 int count;
1417                 struct srvsvc_NetShareCtr1 *ctr1;
1418
1419                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
1420                 W_ERROR_HAVE_NO_MEMORY(ctr1);
1421
1422                 count = numshares;
1423                 ctr1->count = count;
1424                 ctr1->array = NULL;
1425
1426                 if (ctr1->count == 0) {
1427                         r->out.ctr.ctr1 = ctr1;
1428                         return WERR_OK;
1429                 }
1430
1431                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, count);
1432                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1433
1434                 for (i=0; i < count; i++) {
1435                         WERROR status;
1436                         union srvsvc_NetShareInfo info;
1437                         enum srvsvc_ShareType type;
1438
1439                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1440                         if (!NT_STATUS_IS_OK(nterr)) {
1441                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1442                                 return WERR_GENERAL_FAILURE;
1443                         }
1444
1445                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1446                         if (type & STYPE_HIDDEN) {
1447                                 ctr1->count--;
1448                                 talloc_free(scfg);
1449                                 continue;
1450                         }
1451
1452                         info.info1 = &ctr1->array[y];
1453                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1454                         W_ERROR_NOT_OK_RETURN(status);
1455                         talloc_free(scfg);
1456                         y++;
1457                 }
1458                 talloc_free(snames);
1459
1460                 r->out.ctr.ctr1         = ctr1;
1461                 r->out.totalentries     = r->out.ctr.ctr1->count;
1462                 return WERR_OK;
1463         }
1464         case 2:
1465         {
1466                 int i, y = 0;
1467                 int count;
1468                 struct srvsvc_NetShareCtr2 *ctr2;
1469
1470                 SRVSVC_CHECK_ADMIN_ACCESS;
1471
1472                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
1473                 W_ERROR_HAVE_NO_MEMORY(ctr2);
1474
1475                 count = numshares;
1476                 ctr2->count = count;
1477                 ctr2->array = NULL;
1478
1479                 if (ctr2->count == 0) {
1480                         r->out.ctr.ctr2 = ctr2;
1481                         return WERR_OK;
1482                 }
1483
1484                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, count);
1485                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
1486
1487                 for (i=0; i < count; i++) {
1488                         WERROR status;
1489                         union srvsvc_NetShareInfo info;
1490                         enum srvsvc_ShareType type;
1491
1492                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1493                         if (!NT_STATUS_IS_OK(nterr)) {
1494                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1495                                 return WERR_GENERAL_FAILURE;
1496                         }
1497
1498                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1499                         if (type & STYPE_HIDDEN) {
1500                                 ctr2->count--;
1501                                 talloc_free(scfg);
1502                                 continue;
1503                         }
1504
1505                         info.info2 = &ctr2->array[y];
1506                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1507                         W_ERROR_NOT_OK_RETURN(status);
1508                         talloc_free(scfg);
1509                         y++;
1510                 }
1511                 talloc_free(snames);
1512
1513                 r->out.ctr.ctr2         = ctr2;
1514                 r->out.totalentries     = r->out.ctr.ctr2->count;
1515                 return WERR_OK;
1516         }
1517         case 502:
1518         {
1519                 int i, y = 0;
1520                 int count;
1521                 struct srvsvc_NetShareCtr502 *ctr502;
1522
1523                 SRVSVC_CHECK_ADMIN_ACCESS;
1524
1525                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
1526                 W_ERROR_HAVE_NO_MEMORY(ctr502);
1527
1528                 count = numshares;
1529                 ctr502->count = count;
1530                 ctr502->array = NULL;
1531
1532                 if (ctr502->count == 0) {
1533                         r->out.ctr.ctr502 = ctr502;
1534                         return WERR_OK;
1535                 }
1536
1537                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, count);
1538                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
1539
1540                 for (i=0; i < count; i++) {
1541                         WERROR status;
1542                         union srvsvc_NetShareInfo info;
1543                         enum srvsvc_ShareType type;
1544
1545                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1546                         if (!NT_STATUS_IS_OK(nterr)) {
1547                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1548                                 return WERR_GENERAL_FAILURE;
1549                         }
1550
1551                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1552                         if (type & STYPE_HIDDEN) {
1553                                 ctr502->count--;
1554                                 talloc_free(scfg);
1555                                 continue;
1556                         }
1557
1558                         info.info502 = &ctr502->array[y];
1559                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1560                         W_ERROR_NOT_OK_RETURN(status);
1561                         talloc_free(scfg);
1562                         y++;
1563                 }
1564                 talloc_free(snames);
1565
1566                 r->out.ctr.ctr502       = ctr502;
1567                 r->out.totalentries     = r->out.ctr.ctr502->count;
1568                 return WERR_OK;
1569         }
1570         default:
1571                 return WERR_UNKNOWN_LEVEL;
1572         }
1573
1574         return WERR_UNKNOWN_LEVEL;
1575 }
1576
1577
1578 /*
1579   srvsvc_NetShareDelStart
1580 */
1581 static WERROR srvsvc_NetShareDelStart(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1582                        struct srvsvc_NetShareDelStart *r)
1583 {
1584         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1585 }
1586
1587
1588 /*
1589   srvsvc_NetShareDelCommit
1590 */
1591 static WERROR srvsvc_NetShareDelCommit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1592                        struct srvsvc_NetShareDelCommit *r)
1593 {
1594         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1595 }
1596
1597
1598 /*
1599   srvsvc_NetGetFileSecurity
1600 */
1601 static WERROR srvsvc_NetGetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1602                        struct srvsvc_NetGetFileSecurity *r)
1603 {
1604         struct sec_desc_buf *sd_buf;
1605         struct ntvfs_context *ntvfs_ctx = NULL;
1606         struct ntvfs_request *ntvfs_req;
1607         union smb_fileinfo *io;
1608         NTSTATUS nt_status;
1609
1610         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
1611         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1612
1613         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
1614                                          dce_call->conn->auth_state.session_info,
1615                                          0,
1616                                          dce_call->time,
1617                                          NULL, NULL, 0);
1618         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
1619
1620         sd_buf = talloc(mem_ctx, struct sec_desc_buf);
1621         W_ERROR_HAVE_NO_MEMORY(sd_buf);
1622
1623         io = talloc(mem_ctx, union smb_fileinfo);
1624         W_ERROR_HAVE_NO_MEMORY(io);
1625
1626         io->query_secdesc.level                 = RAW_FILEINFO_SEC_DESC;
1627         io->query_secdesc.in.file.path          = r->in.file;
1628         io->query_secdesc.in.secinfo_flags      = r->in.securityinformation;
1629
1630         nt_status = ntvfs_qpathinfo(ntvfs_req, io);
1631         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1632
1633         sd_buf->sd = io->query_secdesc.out.sd;
1634
1635         r->out.sd_buf = sd_buf;
1636         return WERR_OK;
1637 }
1638
1639
1640 /*
1641   srvsvc_NetSetFileSecurity
1642 */
1643 static WERROR srvsvc_NetSetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1644                        struct srvsvc_NetSetFileSecurity *r)
1645 {
1646         struct ntvfs_context *ntvfs_ctx;
1647         struct ntvfs_request *ntvfs_req;
1648         union smb_setfileinfo *io;
1649         NTSTATUS nt_status;
1650
1651         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
1652         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1653
1654         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
1655                                          dce_call->conn->auth_state.session_info,
1656                                          0,
1657                                          dce_call->time,
1658                                          NULL, NULL, 0);
1659         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
1660
1661         io = talloc(mem_ctx, union smb_setfileinfo);
1662         W_ERROR_HAVE_NO_MEMORY(io);
1663
1664         io->set_secdesc.level                   = RAW_FILEINFO_SEC_DESC;
1665         io->set_secdesc.in.file.path            = r->in.file;
1666         io->set_secdesc.in.secinfo_flags        = r->in.securityinformation;
1667         io->set_secdesc.in.sd                   = r->in.sd_buf.sd;
1668
1669         nt_status = ntvfs_setpathinfo(ntvfs_req, io);
1670         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
1671
1672         return WERR_OK;
1673 }
1674
1675
1676 /*
1677   srvsvc_NetServerTransportAddEx
1678 */
1679 static WERROR srvsvc_NetServerTransportAddEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1680                        struct srvsvc_NetServerTransportAddEx *r)
1681 {
1682         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1683 }
1684
1685
1686 /*
1687   srvsvc_NetServerSetServiceBitsEx
1688 */
1689 static WERROR srvsvc_NetServerSetServiceBitsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1690                        struct srvsvc_NetServerSetServiceBitsEx *r)
1691 {
1692         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1693 }
1694
1695
1696 /*
1697   srvsvc_NETRDFSGETVERSION
1698 */
1699 static WERROR srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1700                        struct srvsvc_NETRDFSGETVERSION *r)
1701 {
1702         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1703 }
1704
1705
1706 /*
1707   srvsvc_NETRDFSCREATELOCALPARTITION
1708 */
1709 static WERROR srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1710                        struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
1711 {
1712         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1713 }
1714
1715
1716 /*
1717   srvsvc_NETRDFSDELETELOCALPARTITION
1718 */
1719 static WERROR srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1720                        struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
1721 {
1722         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1723 }
1724
1725
1726 /*
1727   srvsvc_NETRDFSSETLOCALVOLUMESTATE
1728 */
1729 static WERROR srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1730                        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
1731 {
1732         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1733 }
1734
1735
1736 /*
1737   srvsvc_NETRDFSSETSERVERINFO
1738 */
1739 static WERROR srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1740                        struct srvsvc_NETRDFSSETSERVERINFO *r)
1741 {
1742         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1743 }
1744
1745
1746 /*
1747   srvsvc_NETRDFSCREATEEXITPOINT
1748 */
1749 static WERROR srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1750                        struct srvsvc_NETRDFSCREATEEXITPOINT *r)
1751 {
1752         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1753 }
1754
1755
1756 /*
1757   srvsvc_NETRDFSDELETEEXITPOINT
1758 */
1759 static WERROR srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1760                        struct srvsvc_NETRDFSDELETEEXITPOINT *r)
1761 {
1762         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1763 }
1764
1765
1766 /*
1767   srvsvc_NETRDFSMODIFYPREFIX
1768 */
1769 static WERROR srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1770                        struct srvsvc_NETRDFSMODIFYPREFIX *r)
1771 {
1772         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1773 }
1774
1775
1776 /*
1777   srvsvc_NETRDFSFIXLOCALVOLUME
1778 */
1779 static WERROR srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1780                        struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
1781 {
1782         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1783 }
1784
1785
1786 /*
1787   srvsvc_NETRDFSMANAGERREPORTSITEINFO
1788 */
1789 static WERROR srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1790                        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
1791 {
1792         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1793 }
1794
1795
1796 /*
1797   srvsvc_NETRSERVERTRANSPORTDELEX
1798 */
1799 static WERROR srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1800                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
1801 {
1802         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1803 }
1804
1805 /*
1806   srvsvc_NetShareDel
1807 */
1808 static WERROR srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1809                        struct srvsvc_NetShareDel *r)
1810 {
1811         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1812 }
1813
1814 /*
1815   srvsvc_NetSetServiceBits
1816 */
1817 static WERROR srvsvc_NetSetServiceBits(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1818                        struct srvsvc_NetSetServiceBits *r)
1819 {
1820         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1821 }
1822
1823 /*
1824   srvsvc_NETRPRNAMECANONICALIZE
1825 */
1826 static WERROR srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1827                        struct srvsvc_NETRPRNAMECANONICALIZE *r)
1828 {
1829         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1830 }
1831
1832 /* include the generated boilerplate */
1833 #include "librpc/gen_ndr/ndr_srvsvc_s.c"