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
   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 "rpc_server/dcerpc_server.h"
  25 #include "librpc/gen_ndr/ndr_srvsvc.h"
  26 #include "rpc_server/common/common.h"
  27 #include "auth/auth.h"
  28 #include "libcli/security/security.h"
  29 #include "system/time.h"
  30
  31 #define SRVSVC_CHECK_ADMIN_ACCESS do { \
  32         struct security_token *t = dce_call->conn->auth_state.session_info->security_token; \
  33         if (!security_token_has_builtin_administrators(t) && \
  34             !security_token_has_sid_string(t, SID_BUILTIN_SERVER_OPERATORS)) { \
  35                 return WERR_ACCESS_DENIED; \
  36         } \
  37 } while (0)
  38
  39 /*
  40   srvsvc_NetCharDevEnum
  41 */
  42 static WERROR srvsvc_NetCharDevEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  43                                       struct srvsvc_NetCharDevEnum *r)
  44 {
  45         r->out.level = r->in.level;
  46         r->out.totalentries = 0;
  47         r->out.resume_handle = NULL;
  48
  49         switch (r->in.level) {
  50         case 0:
  51                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr0);
  52                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
  53
  54                 r->out.ctr.ctr0->count = 0;
  55                 r->out.ctr.ctr0->array = NULL;
  56
  57                 return WERR_NOT_SUPPORTED;
  58
  59         case 1:
  60                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr1);
  61                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
  62
  63                 r->out.ctr.ctr1->count = 0;
  64                 r->out.ctr.ctr1->array = NULL;
  65
  66                 return WERR_NOT_SUPPORTED;
  67
  68         default:
  69                 return WERR_UNKNOWN_LEVEL;
  70         }
  71
  72         return WERR_OK;
  73 }
  74
  75
  76 /*
  77   srvsvc_NetCharDevGetInfo
  78 */
  79 static WERROR srvsvc_NetCharDevGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  80                        struct srvsvc_NetCharDevGetInfo *r)
  81 {
  82         ZERO_STRUCT(r->out);
  83
  84         switch (r->in.level) {
  85         case 0:
  86         {
  87                 return WERR_NOT_SUPPORTED;
  88         }
  89         case 1:
  90         {
  91                 return WERR_NOT_SUPPORTED;
  92         }
  93         default:
  94                 return WERR_UNKNOWN_LEVEL;
  95         }
  96
  97         return WERR_UNKNOWN_LEVEL;
  98 }
  99
 100
 101 /*
 102   srvsvc_NetCharDevControl
 103 */
 104 static WERROR srvsvc_NetCharDevControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 105                        struct srvsvc_NetCharDevControl *r)
 106 {
 107         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 108 }
 109
 110
 111 /*
 112   srvsvc_NetCharDevQEnum
 113 */
 114 static WERROR srvsvc_NetCharDevQEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 115                                      struct srvsvc_NetCharDevQEnum *r)
 116 {
 117         r->out.level = r->in.level;
 118         r->out.totalentries = 0;
 119         r->out.resume_handle = NULL;
 120
 121         switch (r->in.level) {
 122         case 0:
 123         {
 124                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr0);
 125                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 126
 127                 r->out.ctr.ctr0->count = 0;
 128                 r->out.ctr.ctr0->array = NULL;
 129
 130                 return WERR_NOT_SUPPORTED;
 131         }
 132         case 1:
 133         {
 134                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr1);
 135                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 136
 137                 r->out.ctr.ctr1->count = 0;
 138                 r->out.ctr.ctr1->array = NULL;
 139
 140                 return WERR_NOT_SUPPORTED;
 141         }
 142         default:
 143                 return WERR_UNKNOWN_LEVEL;
 144         }
 145
 146         return WERR_UNKNOWN_LEVEL;
 147 }
 148
 149
 150 /*
 151   srvsvc_NetCharDevQGetInfo
 152 */
 153 static WERROR srvsvc_NetCharDevQGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 154                                         struct srvsvc_NetCharDevQGetInfo *r)
 155 {
 156         ZERO_STRUCT(r->out);
 157
 158         switch (r->in.level) {
 159         case 0:
 160         {
 161                 return WERR_NOT_SUPPORTED;
 162         }
 163         case 1:
 164         {
 165                 return WERR_NOT_SUPPORTED;
 166         }
 167         default:
 168                 return WERR_UNKNOWN_LEVEL;
 169         }
 170
 171         return WERR_UNKNOWN_LEVEL;
 172 }
 173
 174
 175 /*
 176   srvsvc_NetCharDevQSetInfo
 177 */
 178 static WERROR srvsvc_NetCharDevQSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 179                        struct srvsvc_NetCharDevQSetInfo *r)
 180 {
 181         switch (r->in.level) {
 182         case 0:
 183         {
 184                 if (r->in.parm_error) {
 185                         r->out.parm_error = r->in.parm_error;
 186                 }
 187                 return WERR_NOT_SUPPORTED;
 188         }
 189         case 1:
 190         {
 191                 if (r->in.parm_error) {
 192                         r->out.parm_error = r->in.parm_error;
 193                 }
 194                 return WERR_NOT_SUPPORTED;
 195         }
 196         default:
 197                 return WERR_UNKNOWN_LEVEL;
 198         }
 199
 200         return WERR_UNKNOWN_LEVEL;
 201 }
 202
 203
 204 /*
 205   srvsvc_NetCharDevQPurge
 206 */
 207 static WERROR srvsvc_NetCharDevQPurge(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 208                        struct srvsvc_NetCharDevQPurge *r)
 209 {
 210         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 211 }
 212
 213
 214 /*
 215   srvsvc_NetCharDevQPurgeSelf
 216 */
 217 static WERROR srvsvc_NetCharDevQPurgeSelf(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 218                                           struct srvsvc_NetCharDevQPurgeSelf *r)
 219 {
 220         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 221 }
 222
 223
 224 /*
 225   srvsvc_NetConnEnum
 226 */
 227 static WERROR srvsvc_NetConnEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 228                        struct srvsvc_NetConnEnum *r)
 229 {
 230         r->out.level = r->in.level;
 231         r->out.totalentries = 0;
 232         r->out.resume_handle = NULL;
 233
 234         switch (r->in.level) {
 235         case 0:
 236         {
 237                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetConnCtr0);
 238                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 239
 240                 r->out.ctr.ctr0->count = 0;
 241                 r->out.ctr.ctr0->array = NULL;
 242
 243                 return WERR_NOT_SUPPORTED;
 244         }
 245         case 1:
 246         {
 247                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetConnCtr1);
 248                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 249
 250                 r->out.ctr.ctr1->count = 0;
 251                 r->out.ctr.ctr1->array = NULL;
 252
 253                 return WERR_NOT_SUPPORTED;
 254         }
 255         default:
 256                 return WERR_UNKNOWN_LEVEL;
 257         }
 258
 259         return WERR_UNKNOWN_LEVEL;
 260 }
 261
 262
 263 /*
 264   srvsvc_NetFileEnum
 265 */
 266 static WERROR srvsvc_NetFileEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 267                                  struct srvsvc_NetFileEnum *r)
 268 {
 269         r->out.level = r->in.level;
 270         r->out.totalentries = 0;
 271         r->out.resume_handle = NULL;
 272
 273         switch (r->in.level) {
 274         case 2:
 275         {
 276                 r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetFileCtr2);
 277                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
 278
 279                 r->out.ctr.ctr2->count = 0;
 280                 r->out.ctr.ctr2->array = NULL;
 281
 282                 return WERR_NOT_SUPPORTED;
 283         }
 284         case 3:
 285         {
 286                 r->out.ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetFileCtr3);
 287                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr3);
 288
 289                 r->out.ctr.ctr3->count = 0;
 290                 r->out.ctr.ctr3->array = NULL;
 291
 292                 return WERR_NOT_SUPPORTED;
 293         }
 294         default:
 295                 return WERR_UNKNOWN_LEVEL;
 296         }
 297
 298         return WERR_UNKNOWN_LEVEL;
 299 }
 300
 301
 302 /*
 303   srvsvc_NetFileGetInfo
 304 */
 305 static WERROR srvsvc_NetFileGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 306                                     struct srvsvc_NetFileGetInfo *r)
 307 {
 308         ZERO_STRUCT(r->out);
 309
 310         switch (r->in.level) {
 311         case 2:
 312         {
 313                 return WERR_NOT_SUPPORTED;
 314         }
 315         case 3:
 316         {
 317                 return WERR_NOT_SUPPORTED;
 318         }
 319         default:
 320                 return WERR_UNKNOWN_LEVEL;
 321         }
 322
 323         return WERR_UNKNOWN_LEVEL;
 324 }
 325
 326
 327 /*
 328   srvsvc_NetFileClose
 329 */
 330 static WERROR srvsvc_NetFileClose(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 331                        struct srvsvc_NetFileClose *r)
 332 {
 333         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 334 }
 335
 336
 337 /*
 338   srvsvc_NetSessEnum
 339 */
 340 static WERROR srvsvc_NetSessEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 341                        struct srvsvc_NetSessEnum *r)
 342 {
 343         r->out.level = r->in.level;
 344         r->out.totalentries = 0;
 345         r->out.resume_handle = NULL;
 346
 347         switch (r->in.level) {
 348         case 0:
 349         {
 350                 r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetSessCtr0);
 351                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
 352
 353                 r->out.ctr.ctr0->count = 0;
 354                 r->out.ctr.ctr0->array = NULL;
 355
 356                 return WERR_NOT_SUPPORTED;
 357         }
 358         case 1:
 359         {
 360                 r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetSessCtr1);
 361                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
 362
 363                 r->out.ctr.ctr1->count = 0;
 364                 r->out.ctr.ctr1->array = NULL;
 365
 366                 return WERR_NOT_SUPPORTED;
 367         }
 368         case 2:
 369         {
 370                 r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetSessCtr2);
 371                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
 372
 373                 r->out.ctr.ctr2->count = 0;
 374                 r->out.ctr.ctr2->array = NULL;
 375
 376                 return WERR_NOT_SUPPORTED;
 377         }
 378         case 10:
 379         {
 380                 r->out.ctr.ctr10 = talloc(mem_ctx, struct srvsvc_NetSessCtr10);
 381                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr10);
 382
 383                 r->out.ctr.ctr2->count = 0;
 384                 r->out.ctr.ctr2->array = NULL;
 385
 386                 return WERR_NOT_SUPPORTED;
 387         }
 388         case 502:
 389         {
 390                 r->out.ctr.ctr502 = talloc(mem_ctx, struct srvsvc_NetSessCtr502);
 391                 W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr502);
 392
 393                 r->out.ctr.ctr2->count = 0;
 394                 r->out.ctr.ctr2->array = NULL;
 395
 396                 return WERR_NOT_SUPPORTED;
 397         }
 398         default:
 399                 return WERR_UNKNOWN_LEVEL;
 400         }
 401
 402         return WERR_UNKNOWN_LEVEL;
 403 }
 404
 405
 406 /*
 407   srvsvc_NetSessDel
 408 */
 409 static WERROR srvsvc_NetSessDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 410                        struct srvsvc_NetSessDel *r)
 411 {
 412         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 413 }
 414
 415
 416 /*
 417   srvsvc_NetShareAdd
 418 */
 419 static WERROR srvsvc_NetShareAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 420                        struct srvsvc_NetShareAdd *r)
 421 {
 422         switch (r->in.level) {
 423         case 0:
 424         {
 425                 if (r->in.parm_error) {
 426                         r->out.parm_error = r->in.parm_error;
 427                 }
 428                 return WERR_NOT_SUPPORTED;
 429         }
 430         case 1:
 431         {
 432                 if (r->in.parm_error) {
 433                         r->out.parm_error = r->in.parm_error;
 434                 }
 435                 return WERR_NOT_SUPPORTED;
 436         }
 437         case 2:
 438         {
 439                 if (r->in.parm_error) {
 440                         r->out.parm_error = r->in.parm_error;
 441                 }
 442                 return WERR_NOT_SUPPORTED;
 443         }
 444         case 501:
 445         {
 446                 if (r->in.parm_error) {
 447                         r->out.parm_error = r->in.parm_error;
 448                 }
 449                 return WERR_NOT_SUPPORTED;
 450         }
 451         case 502:
 452         {
 453                 if (r->in.parm_error) {
 454                         r->out.parm_error = r->in.parm_error;
 455                 }
 456                 return WERR_NOT_SUPPORTED;
 457         }
 458         default:
 459                 return WERR_UNKNOWN_LEVEL;
 460         }
 461
 462         return WERR_UNKNOWN_LEVEL;
 463 }
 464
 465 static WERROR srvsvc_fiel_ShareInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 466                                    int snum, uint32_t level, union srvsvc_NetShareInfo *info)
 467 {
 468         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 469
 470         switch (level) {
 471         case 0:
 472         {
 473                 info->info0->name       = dcesrv_common_get_share_name(mem_ctx, dce_ctx, snum);
 474                 W_ERROR_HAVE_NO_MEMORY(info->info0->name);
 475
 476                 return WERR_OK;
 477         }
 478         case 1:
 479         {
 480                 info->info1->name       = dcesrv_common_get_share_name(mem_ctx, dce_ctx, snum);
 481                 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
 482                 info->info1->type       = dcesrv_common_get_share_type(mem_ctx, dce_ctx, snum);
 483                 info->info1->comment    = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, snum);
 484                 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
 485
 486                 return WERR_OK;
 487         }
 488         case 2:
 489         {
 490                 info->info2->name               = dcesrv_common_get_share_name(mem_ctx, dce_ctx, snum);
 491                 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
 492                 info->info2->type               = dcesrv_common_get_share_type(mem_ctx, dce_ctx, snum);
 493                 info->info2->comment            = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, snum);
 494                 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
 495                 info->info2->permissions        = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, snum);
 496                 info->info2->max_users  = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, snum);
 497                 info->info2->current_users      = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, snum);
 498                 info->info2->path               = dcesrv_common_get_share_path(mem_ctx, dce_ctx, snum);
 499                 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
 500                 info->info2->password           = dcesrv_common_get_share_password(mem_ctx, dce_ctx, snum);
 501
 502                 return WERR_OK;
 503         }
 504         case 501:
 505         {
 506                 info->info501->name             = dcesrv_common_get_share_name(mem_ctx, dce_ctx, snum);
 507                 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
 508                 info->info501->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, snum);
 509                 info->info501->comment          = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, snum);
 510                 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
 511                 info->info501->csc_policy       = dcesrv_common_get_share_csc_policy(mem_ctx, dce_ctx, snum);
 512
 513                 return WERR_OK;
 514         }
 515         case 502:
 516         {
 517                 info->info502->name             = dcesrv_common_get_share_name(mem_ctx, dce_ctx, snum);
 518                 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
 519                 info->info502->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, snum);
 520                 info->info502->comment          = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, snum);
 521                 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
 522                 info->info502->permissions      = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, snum);
 523                 info->info502->max_users        = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, snum);
 524                 info->info502->current_users    = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, snum);
 525                 info->info502->path             = dcesrv_common_get_share_path(mem_ctx, dce_ctx, snum);
 526                 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
 527                 info->info502->password         = dcesrv_common_get_share_password(mem_ctx, dce_ctx, snum);
 528                 info->info502->unknown          = dcesrv_common_get_share_unknown(mem_ctx, dce_ctx, snum);
 529                 info->info502->sd               = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, snum);
 530
 531                 return WERR_OK;
 532         }
 533         case 1005:
 534         {
 535                 info->info1005->dfs_flags       = dcesrv_common_get_share_dfs_flags(mem_ctx, dce_ctx, snum);
 536
 537                 return WERR_OK;
 538         }
 539         default:
 540                 return WERR_UNKNOWN_LEVEL;
 541         }
 542
 543         return WERR_UNKNOWN_LEVEL;
 544 }
 545
 546 /*
 547   srvsvc_NetShareEnumAll
 548 */
 549 static WERROR srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 550                                      struct srvsvc_NetShareEnumAll *r)
 551 {
 552         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 553
 554         r->out.level = r->in.level;
 555         ZERO_STRUCT(r->out.ctr);
 556         r->out.totalentries = 0;
 557         r->out.resume_handle = NULL;
 558
 559         /* TODO: - paging of results
 560          */
 561
 562         switch (r->in.level) {
 563         case 0:
 564         {
 565                 int i;
 566                 struct srvsvc_NetShareCtr0 *ctr0;
 567
 568                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
 569                 W_ERROR_HAVE_NO_MEMORY(ctr0);
 570
 571                 ctr0->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 572                 ctr0->array = NULL;
 573
 574                 if (ctr0->count == 0) {
 575                         r->out.ctr.ctr0 = ctr0;
 576                         return WERR_OK;
 577                 }
 578
 579                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
 580                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
 581
 582                 for (i=0; i < ctr0->count; i++) {
 583                         WERROR status;
 584                         union srvsvc_NetShareInfo info;
 585
 586                         info.info0 = &ctr0->array[i];
 587                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
 588                         if (!W_ERROR_IS_OK(status)) {
 589                                 return status;
 590                         }
 591                 }
 592
 593                 r->out.ctr.ctr0         = ctr0;
 594                 r->out.totalentries     = r->out.ctr.ctr0->count;
 595                 return WERR_OK;
 596         }
 597         case 1:
 598         {
 599                 int i;
 600                 struct srvsvc_NetShareCtr1 *ctr1;
 601
 602                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
 603                 W_ERROR_HAVE_NO_MEMORY(ctr1);
 604
 605                 ctr1->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 606                 ctr1->array = NULL;
 607
 608                 if (ctr1->count == 0) {
 609                         r->out.ctr.ctr1 = ctr1;
 610                         return WERR_OK;
 611                 }
 612
 613                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
 614                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
 615
 616                 for (i=0; i < ctr1->count; i++) {
 617                         WERROR status;
 618                         union srvsvc_NetShareInfo info;
 619
 620                         info.info1 = &ctr1->array[i];
 621                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
 622                         if (!W_ERROR_IS_OK(status)) {
 623                                 return status;
 624                         }
 625                 }
 626
 627                 r->out.ctr.ctr1         = ctr1;
 628                 r->out.totalentries     = r->out.ctr.ctr1->count;
 629                 return WERR_OK;
 630         }
 631         case 2:
 632         {
 633                 int i;
 634                 struct srvsvc_NetShareCtr2 *ctr2;
 635
 636                 SRVSVC_CHECK_ADMIN_ACCESS;
 637
 638                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
 639                 W_ERROR_HAVE_NO_MEMORY(ctr2);
 640
 641                 ctr2->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 642                 ctr2->array = NULL;
 643
 644                 if (ctr2->count == 0) {
 645                         r->out.ctr.ctr2 = ctr2;
 646                         return WERR_OK;
 647                 }
 648
 649                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
 650                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
 651
 652                 for (i=0; i < ctr2->count; i++) {
 653                         WERROR status;
 654                         union srvsvc_NetShareInfo info;
 655
 656                         info.info2 = &ctr2->array[i];
 657                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
 658                         if (!W_ERROR_IS_OK(status)) {
 659                                 return status;
 660                         }
 661                 }
 662
 663                 r->out.ctr.ctr2         = ctr2;
 664                 r->out.totalentries     = r->out.ctr.ctr2->count;
 665                 return WERR_OK;
 666         }
 667         case 501:
 668         {
 669                 int i;
 670                 struct srvsvc_NetShareCtr501 *ctr501;
 671
 672                 SRVSVC_CHECK_ADMIN_ACCESS;
 673
 674                 ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
 675                 W_ERROR_HAVE_NO_MEMORY(ctr501);
 676
 677                 ctr501->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 678                 ctr501->array = NULL;
 679
 680                 if (ctr501->count == 0) {
 681                         r->out.ctr.ctr501 = ctr501;
 682                         return WERR_OK;
 683                 }
 684
 685                 ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
 686                 W_ERROR_HAVE_NO_MEMORY(ctr501->array);
 687
 688                 for (i=0; i < ctr501->count; i++) {
 689                         WERROR status;
 690                         union srvsvc_NetShareInfo info;
 691
 692                         info.info501 = &ctr501->array[i];
 693                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
 694                         if (!W_ERROR_IS_OK(status)) {
 695                                 return status;
 696                         }
 697                 }
 698
 699                 r->out.ctr.ctr501       = ctr501;
 700                 r->out.totalentries     = r->out.ctr.ctr501->count;
 701                 return WERR_OK;
 702         }
 703         case 502:
 704         {
 705                 int i;
 706                 struct srvsvc_NetShareCtr502 *ctr502;
 707
 708                 SRVSVC_CHECK_ADMIN_ACCESS;
 709
 710                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
 711                 W_ERROR_HAVE_NO_MEMORY(ctr502);
 712
 713                 ctr502->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 714                 ctr502->array = NULL;
 715
 716                 if (ctr502->count == 0) {
 717                         r->out.ctr.ctr502 = ctr502;
 718                         return WERR_OK;
 719                 }
 720
 721                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
 722                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
 723
 724                 for (i=0; i < ctr502->count; i++) {
 725                         WERROR status;
 726                         union srvsvc_NetShareInfo info;
 727
 728                         info.info502 = &ctr502->array[i];
 729                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
 730                         if (!W_ERROR_IS_OK(status)) {
 731                                 return status;
 732                         }
 733                 }
 734
 735                 r->out.ctr.ctr502       = ctr502;
 736                 r->out.totalentries     = r->out.ctr.ctr502->count;
 737                 return WERR_OK;
 738         }
 739         default:
 740                 return WERR_UNKNOWN_LEVEL;
 741         }
 742
 743         return WERR_UNKNOWN_LEVEL;
 744 }
 745
 746
 747 /*
 748   srvsvc_NetShareGetInfo
 749 */
 750 static WERROR srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 751                                      struct srvsvc_NetShareGetInfo *r)
 752 {
 753         int snum;
 754
 755         ZERO_STRUCT(r->out);
 756
 757         /* TODO: - access check
 758          */
 759
 760         if (strcmp("", r->in.share_name) == 0) {
 761                 return WERR_INVALID_PARAM;
 762         }
 763
 764         snum = lp_servicenumber(r->in.share_name);
 765         if (snum < 0) {
 766                 return WERR_NET_NAME_NOT_FOUND;
 767         }
 768
 769         switch (r->in.level) {
 770         case 0:
 771         {
 772                 WERROR status;
 773                 union srvsvc_NetShareInfo info;
 774
 775                 info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
 776                 W_ERROR_HAVE_NO_MEMORY(info.info0);
 777
 778                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 779                 if (!W_ERROR_IS_OK(status)) {
 780                         return status;
 781                 }
 782
 783                 r->out.info.info0 = info.info0;
 784                 return WERR_OK;
 785         }
 786         case 1:
 787         {
 788                 WERROR status;
 789                 union srvsvc_NetShareInfo info;
 790
 791                 info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
 792                 W_ERROR_HAVE_NO_MEMORY(info.info1);
 793
 794                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 795                 if (!W_ERROR_IS_OK(status)) {
 796                         return status;
 797                 }
 798
 799                 r->out.info.info1 = info.info1;
 800                 return WERR_OK;
 801         }
 802         case 2:
 803         {
 804                 WERROR status;
 805                 union srvsvc_NetShareInfo info;
 806
 807                 SRVSVC_CHECK_ADMIN_ACCESS;
 808
 809                 info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
 810                 W_ERROR_HAVE_NO_MEMORY(info.info2);
 811
 812                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 813                 if (!W_ERROR_IS_OK(status)) {
 814                         return status;
 815                 }
 816
 817                 r->out.info.info2 = info.info2;
 818                 return WERR_OK;
 819         }
 820         case 501:
 821         {
 822                 WERROR status;
 823                 union srvsvc_NetShareInfo info;
 824
 825                 info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
 826                 W_ERROR_HAVE_NO_MEMORY(info.info501);
 827
 828                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 829                 if (!W_ERROR_IS_OK(status)) {
 830                         return status;
 831                 }
 832
 833                 r->out.info.info501 = info.info501;
 834                 return WERR_OK;
 835         }
 836         case 502:
 837         {
 838                 WERROR status;
 839                 union srvsvc_NetShareInfo info;
 840
 841                 SRVSVC_CHECK_ADMIN_ACCESS;
 842
 843                 info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
 844                 W_ERROR_HAVE_NO_MEMORY(info.info502);
 845
 846                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 847                 if (!W_ERROR_IS_OK(status)) {
 848                         return status;
 849                 }
 850
 851                 r->out.info.info502 = info.info502;
 852                 return WERR_OK;
 853         }
 854         case 1005:
 855         {
 856                 WERROR status;
 857                 union srvsvc_NetShareInfo info;
 858
 859                 info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
 860                 W_ERROR_HAVE_NO_MEMORY(info.info1005);
 861
 862                 status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
 863                 if (!W_ERROR_IS_OK(status)) {
 864                         return status;
 865                 }
 866
 867                 r->out.info.info1005 = info.info1005;
 868                 return WERR_OK;
 869         }
 870         default:
 871                 return WERR_UNKNOWN_LEVEL;
 872         }
 873
 874         return WERR_UNKNOWN_LEVEL;
 875 }
 876
 877
 878 /*
 879   srvsvc_NetShareSetInfo
 880 */
 881 static WERROR srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 882                        struct srvsvc_NetShareSetInfo *r)
 883 {
 884         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 885 }
 886
 887
 888 /*
 889   srvsvc_NetShareDelSticky
 890 */
 891 static WERROR srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 892                        struct srvsvc_NetShareDelSticky *r)
 893 {
 894         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 895 }
 896
 897
 898 /*
 899   srvsvc_NetShareCheck
 900 */
 901 static WERROR srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 902                        struct srvsvc_NetShareCheck *r)
 903 {
 904         ZERO_STRUCT(r->out);
 905
 906         /* TODO: - access check
 907          */
 908
 909         if (strcmp("", r->in.device_name) == 0) {
 910                 r->out.type = STYPE_IPC;
 911                 return WERR_OK;
 912         }
 913
 914         if (strcmp("C:\\", r->in.device_name) == 0) {
 915                 r->out.type = STYPE_DISKTREE;
 916                 return WERR_OK;
 917         }
 918
 919         /* TODO: - lookup the share be devicename (path) */
 920         return WERR_DEVICE_NOT_SHARED;
 921 }
 922
 923
 924 /*
 925   srvsvc_NetSrvGetInfo
 926 */
 927 static WERROR srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 928                        struct srvsvc_NetSrvGetInfo *r)
 929 {
 930         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 931
 932         ZERO_STRUCT(r->out);
 933
 934         switch (r->in.level) {
 935         case 100:
 936         {
 937                 struct srvsvc_NetSrvInfo100 *info100;
 938
 939                 info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
 940                 W_ERROR_HAVE_NO_MEMORY(info100);
 941
 942                 info100->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
 943                 info100->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
 944                 W_ERROR_HAVE_NO_MEMORY(info100->server_name);
 945
 946                 r->out.info.info100 = info100;
 947                 return WERR_OK;
 948         }
 949         case 101:
 950         {
 951                 struct srvsvc_NetSrvInfo101 *info101;
 952
 953                 info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
 954                 W_ERROR_HAVE_NO_MEMORY(info101);
 955
 956                 info101->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
 957                 info101->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
 958                 W_ERROR_HAVE_NO_MEMORY(info101->server_name);
 959
 960                 info101->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx);
 961                 info101->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx);
 962                 info101->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_ctx);
 963                 info101->comment        = talloc_strdup(mem_ctx, lp_serverstring());
 964                 W_ERROR_HAVE_NO_MEMORY(info101->comment);
 965
 966                 r->out.info.info101 = info101;
 967                 return WERR_OK;
 968         }
 969         default:
 970                 return WERR_UNKNOWN_LEVEL;
 971         }
 972
 973         return WERR_UNKNOWN_LEVEL;
 974 }
 975
 976
 977 /*
 978   srvsvc_NetSrvSetInfo
 979 */
 980 static WERROR srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 981                        struct srvsvc_NetSrvSetInfo *r)
 982 {
 983         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 984 }
 985
 986
 987 /*
 988   srvsvc_NetDiskEnum
 989 */
 990 static WERROR srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 991                        struct srvsvc_NetDiskEnum *r)
 992 {
 993         r->out.disks.discs = NULL;
 994         r->out.disks.count = 0;
 995         r->out.totalentries = 0;
 996         r->out.resume_handle = NULL;
 997
 998         switch (r->in.level) {
 999         case 0:
1000         {
1001                 return WERR_NOT_SUPPORTED;
1002         }
1003         default:
1004                 return WERR_UNKNOWN_LEVEL;
1005         }
1006
1007         return WERR_UNKNOWN_LEVEL;
1008 }
1009
1010
1011 /*
1012   srvsvc_NetServerStatisticsGet
1013 */
1014 static WERROR srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1015                        struct srvsvc_NetServerStatisticsGet *r)
1016 {
1017         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1018 }
1019
1020
1021 /*
1022   srvsvc_NetTransportAdd
1023 */
1024 static WERROR srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1025                        struct srvsvc_NetTransportAdd *r)
1026 {
1027         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1028 }
1029
1030
1031 /*
1032   srvsvc_NetTransportEnum
1033 */
1034 static WERROR srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1035                        struct srvsvc_NetTransportEnum *r)
1036 {
1037         r->out.level = r->in.level;
1038         r->out.totalentries = 0;
1039         r->out.resume_handle = NULL;
1040
1041         switch (r->in.level) {
1042         case 0:
1043         {
1044                 r->out.transports.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
1045                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr0);
1046
1047                 r->out.transports.ctr0->count = 0;
1048                 r->out.transports.ctr0->array = NULL;
1049
1050                 return WERR_NOT_SUPPORTED;
1051         }
1052         case 1:
1053         {
1054                 r->out.transports.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
1055                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr1);
1056
1057                 r->out.transports.ctr1->count = 0;
1058                 r->out.transports.ctr1->array = NULL;
1059
1060                 return WERR_NOT_SUPPORTED;
1061         }
1062         case 2:
1063         {
1064                 r->out.transports.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
1065                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr2);
1066
1067                 r->out.transports.ctr2->count = 0;
1068                 r->out.transports.ctr2->array = NULL;
1069
1070                 return WERR_NOT_SUPPORTED;
1071         }
1072         case 3:
1073         {
1074                 r->out.transports.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
1075                 W_ERROR_HAVE_NO_MEMORY(r->out.transports.ctr3);
1076
1077                 r->out.transports.ctr3->count = 0;
1078                 r->out.transports.ctr3->array = NULL;
1079
1080                 return WERR_NOT_SUPPORTED;
1081         }
1082         default:
1083                 return WERR_UNKNOWN_LEVEL;
1084         }
1085
1086         return WERR_UNKNOWN_LEVEL;
1087 }
1088
1089 /*
1090   srvsvc_NetTransportDel
1091 */
1092 static WERROR srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1093                        struct srvsvc_NetTransportDel *r)
1094 {
1095         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1096 }
1097
1098
1099 /*
1100   srvsvc_NetRemoteTOD
1101 */
1102 static WERROR srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1103                        struct srvsvc_NetRemoteTOD *r)
1104 {
1105         struct timeval tval;
1106         time_t t;
1107         struct tm tm;
1108
1109         r->out.info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
1110         W_ERROR_HAVE_NO_MEMORY(r->out.info);
1111
1112         GetTimeOfDay(&tval);
1113         t = tval.tv_sec;
1114
1115         gmtime_r(&t, &tm);
1116
1117         r->out.info->elapsed    = t;
1118         /* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
1119         r->out.info->msecs      = (tm.tm_hour*60*60*1000)
1120                                 + (tm.tm_min*60*1000)
1121                                 + (tm.tm_sec*1000)
1122                                 + (tval.tv_usec/1000);
1123         r->out.info->hours      = tm.tm_hour;
1124         r->out.info->mins       = tm.tm_min;
1125         r->out.info->secs       = tm.tm_sec;
1126         r->out.info->hunds      = tval.tv_usec/10000;
1127         r->out.info->timezone   = get_time_zone(t)/60;
1128         r->out.info->tinterval  = 310; /* just return the same as windows */
1129         r->out.info->day        = tm.tm_mday;
1130         r->out.info->month      = tm.tm_mon + 1;
1131         r->out.info->year       = tm.tm_year + 1900;
1132         r->out.info->weekday    = tm.tm_wday;
1133
1134         return WERR_OK;
1135 }
1136
1137 /*
1138   srvsvc_NetPathType
1139 */
1140 static WERROR srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1141                        struct srvsvc_NetPathType *r)
1142 {
1143         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1144 }
1145
1146
1147 /*
1148   srvsvc_NetPathCanonicalize
1149 */
1150 static WERROR srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1151                        struct srvsvc_NetPathCanonicalize *r)
1152 {
1153         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1154 }
1155
1156
1157 /*
1158   srvsvc_NetPathCompare
1159 */
1160 static WERROR srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1161                        struct srvsvc_NetPathCompare *r)
1162 {
1163         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1164 }
1165
1166
1167 /*
1168   srvsvc_NetNameValidate
1169 */
1170 static WERROR srvsvc_NetNameValidate(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1171                        struct srvsvc_NetNameValidate *r)
1172 {
1173         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1174 }
1175
1176
1177 /*
1178   srvsvc_NetPRNameCompare
1179 */
1180 static WERROR srvsvc_NetPRNameCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1181                        struct srvsvc_NetPRNameCompare *r)
1182 {
1183         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1184 }
1185
1186
1187 /*
1188   srvsvc_NetShareEnum
1189 */
1190 static WERROR srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1191                        struct srvsvc_NetShareEnum *r)
1192 {
1193         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1194
1195         r->out.level = r->in.level;
1196         ZERO_STRUCT(r->out.ctr);
1197         r->out.totalentries = 0;
1198         r->out.resume_handle = NULL;
1199
1200         /* TODO: - paging of results
1201          */
1202
1203         switch (r->in.level) {
1204         case 0:
1205         {
1206                 int i, y = 0;
1207                 int count;
1208                 struct srvsvc_NetShareCtr0 *ctr0;
1209
1210                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
1211                 W_ERROR_HAVE_NO_MEMORY(ctr0);
1212
1213                 count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
1214                 ctr0->count = count;
1215                 ctr0->array = NULL;
1216
1217                 if (ctr0->count == 0) {
1218                         r->out.ctr.ctr0 = ctr0;
1219                         return WERR_OK;
1220                 }
1221
1222                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, count);
1223                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
1224
1225                 for (i=0; i < count; i++) {
1226                         WERROR status;
1227                         union srvsvc_NetShareInfo info;
1228                         enum srvsvc_ShareType type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
1229
1230                         if (type & STYPE_HIDDEN) {
1231                                 ctr0->count--;
1232                                 continue;
1233                         }
1234
1235                         info.info0 = &ctr0->array[y];
1236                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
1237                         W_ERROR_NOT_OK_RETURN(status);
1238                         y++;
1239                 }
1240
1241                 r->out.ctr.ctr0         = ctr0;
1242                 r->out.totalentries     = r->out.ctr.ctr0->count;
1243                 return WERR_OK;
1244         }
1245         case 1:
1246         {
1247                 int i, y = 0;
1248                 int count;
1249                 struct srvsvc_NetShareCtr1 *ctr1;
1250
1251                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
1252                 W_ERROR_HAVE_NO_MEMORY(ctr1);
1253
1254                 count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
1255                 ctr1->count = count;
1256                 ctr1->array = NULL;
1257
1258                 if (ctr1->count == 0) {
1259                         r->out.ctr.ctr1 = ctr1;
1260                         return WERR_OK;
1261                 }
1262
1263                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, count);
1264                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1265
1266                 for (i=0; i < count; i++) {
1267                         WERROR status;
1268                         union srvsvc_NetShareInfo info;
1269                         enum srvsvc_ShareType type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
1270
1271                         if (type & STYPE_HIDDEN) {
1272                                 ctr1->count--;
1273                                 continue;
1274                         }
1275
1276                         info.info1 = &ctr1->array[y];
1277                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
1278                         W_ERROR_NOT_OK_RETURN(status);
1279                         y++;
1280                 }
1281
1282                 r->out.ctr.ctr1         = ctr1;
1283                 r->out.totalentries     = r->out.ctr.ctr1->count;
1284                 return WERR_OK;
1285         }
1286         case 2:
1287         {
1288                 int i, y = 0;
1289                 int count;
1290                 struct srvsvc_NetShareCtr2 *ctr2;
1291
1292                 SRVSVC_CHECK_ADMIN_ACCESS;
1293
1294                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
1295                 W_ERROR_HAVE_NO_MEMORY(ctr2);
1296
1297                 count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
1298                 ctr2->count = count;
1299                 ctr2->array = NULL;
1300
1301                 if (ctr2->count == 0) {
1302                         r->out.ctr.ctr2 = ctr2;
1303                         return WERR_OK;
1304                 }
1305
1306                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, count);
1307                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
1308
1309                 for (i=0; i < count; i++) {
1310                         WERROR status;
1311                         union srvsvc_NetShareInfo info;
1312                         enum srvsvc_ShareType type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
1313
1314                         if (type & STYPE_HIDDEN) {
1315                                 ctr2->count--;
1316                                 continue;
1317                         }
1318
1319                         info.info2 = &ctr2->array[y];
1320                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
1321                         W_ERROR_NOT_OK_RETURN(status);
1322                         y++;
1323                 }
1324
1325                 r->out.ctr.ctr2         = ctr2;
1326                 r->out.totalentries     = r->out.ctr.ctr2->count;
1327                 return WERR_OK;
1328         }
1329         case 502:
1330         {
1331                 int i, y = 0;
1332                 int count;
1333                 struct srvsvc_NetShareCtr502 *ctr502;
1334
1335                 SRVSVC_CHECK_ADMIN_ACCESS;
1336
1337                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
1338                 W_ERROR_HAVE_NO_MEMORY(ctr502);
1339
1340                 count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
1341                 ctr502->count = count;
1342                 ctr502->array = NULL;
1343
1344                 if (ctr502->count == 0) {
1345                         r->out.ctr.ctr502 = ctr502;
1346                         return WERR_OK;
1347                 }
1348
1349                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, count);
1350                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
1351
1352                 for (i=0; i < count; i++) {
1353                         WERROR status;
1354                         union srvsvc_NetShareInfo info;
1355                         enum srvsvc_ShareType type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
1356
1357                         if (type & STYPE_HIDDEN) {
1358                                 ctr502->count--;
1359                                 continue;
1360                         }
1361
1362                         info.info502 = &ctr502->array[y];
1363                         status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, i, r->in.level, &info);
1364                         W_ERROR_NOT_OK_RETURN(status);
1365                         y++;
1366                 }
1367
1368                 r->out.ctr.ctr502       = ctr502;
1369                 r->out.totalentries     = r->out.ctr.ctr502->count;
1370                 return WERR_OK;
1371         }
1372         default:
1373                 return WERR_UNKNOWN_LEVEL;
1374         }
1375
1376         return WERR_UNKNOWN_LEVEL;
1377 }
1378
1379
1380 /*
1381   srvsvc_NetShareDelStart
1382 */
1383 static WERROR srvsvc_NetShareDelStart(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1384                        struct srvsvc_NetShareDelStart *r)
1385 {
1386         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1387 }
1388
1389
1390 /*
1391   srvsvc_NetShareDelCommit
1392 */
1393 static WERROR srvsvc_NetShareDelCommit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1394                        struct srvsvc_NetShareDelCommit *r)
1395 {
1396         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1397 }
1398
1399
1400 /*
1401   srvsvc_NetGetFileSecurity
1402 */
1403 static WERROR srvsvc_NetGetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1404                        struct srvsvc_NetGetFileSecurity *r)
1405 {
1406         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1407 }
1408
1409
1410 /*
1411   srvsvc_NetSetFileSecurity
1412 */
1413 static WERROR srvsvc_NetSetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1414                        struct srvsvc_NetSetFileSecurity *r)
1415 {
1416         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1417 }
1418
1419
1420 /*
1421   srvsvc_NetServerTransportAddEx
1422 */
1423 static WERROR srvsvc_NetServerTransportAddEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1424                        struct srvsvc_NetServerTransportAddEx *r)
1425 {
1426         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1427 }
1428
1429
1430 /*
1431   srvsvc_NetServerSetServiceBitsEx
1432 */
1433 static WERROR srvsvc_NetServerSetServiceBitsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1434                        struct srvsvc_NetServerSetServiceBitsEx *r)
1435 {
1436         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1437 }
1438
1439
1440 /*
1441   srvsvc_NETRDFSGETVERSION
1442 */
1443 static WERROR srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1444                        struct srvsvc_NETRDFSGETVERSION *r)
1445 {
1446         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1447 }
1448
1449
1450 /*
1451   srvsvc_NETRDFSCREATELOCALPARTITION
1452 */
1453 static WERROR srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1454                        struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
1455 {
1456         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1457 }
1458
1459
1460 /*
1461   srvsvc_NETRDFSDELETELOCALPARTITION
1462 */
1463 static WERROR srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1464                        struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
1465 {
1466         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1467 }
1468
1469
1470 /*
1471   srvsvc_NETRDFSSETLOCALVOLUMESTATE
1472 */
1473 static WERROR srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1474                        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
1475 {
1476         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1477 }
1478
1479
1480 /*
1481   srvsvc_NETRDFSSETSERVERINFO
1482 */
1483 static WERROR srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1484                        struct srvsvc_NETRDFSSETSERVERINFO *r)
1485 {
1486         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1487 }
1488
1489
1490 /*
1491   srvsvc_NETRDFSCREATEEXITPOINT
1492 */
1493 static WERROR srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1494                        struct srvsvc_NETRDFSCREATEEXITPOINT *r)
1495 {
1496         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1497 }
1498
1499
1500 /*
1501   srvsvc_NETRDFSDELETEEXITPOINT
1502 */
1503 static WERROR srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1504                        struct srvsvc_NETRDFSDELETEEXITPOINT *r)
1505 {
1506         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1507 }
1508
1509
1510 /*
1511   srvsvc_NETRDFSMODIFYPREFIX
1512 */
1513 static WERROR srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1514                        struct srvsvc_NETRDFSMODIFYPREFIX *r)
1515 {
1516         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1517 }
1518
1519
1520 /*
1521   srvsvc_NETRDFSFIXLOCALVOLUME
1522 */
1523 static WERROR srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1524                        struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
1525 {
1526         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1527 }
1528
1529
1530 /*
1531   srvsvc_NETRDFSMANAGERREPORTSITEINFO
1532 */
1533 static WERROR srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1534                        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
1535 {
1536         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1537 }
1538
1539
1540 /*
1541   srvsvc_NETRSERVERTRANSPORTDELEX
1542 */
1543 static WERROR srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1544                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
1545 {
1546         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1547 }
1548
1549 /*
1550   srvsvc_NetShareDel
1551 */
1552 static WERROR srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1553                        struct srvsvc_NetShareDel *r)
1554 {
1555         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1556 }
1557
1558 /*
1559   srvsvc_NetSetServiceBits
1560 */
1561 static WERROR srvsvc_NetSetServiceBits(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1562                        struct srvsvc_NetSetServiceBits *r)
1563 {
1564         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1565 }
1566
1567 /*
1568   srvsvc_NETRPRNAMECANONICALIZE
1569 */
1570 static WERROR srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1571                        struct srvsvc_NETRPRNAMECANONICALIZE *r)
1572 {
1573         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1574 }
1575
1576 /* include the generated boilerplate */
1577 #include "librpc/gen_ndr/ndr_srvsvc_s.c"