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