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 "librpc/gen_ndr/ndr_srvsvc.h"
  25 #include "rpc_server/common/common.h"
  26
  27 /*
  28   srvsvc_NetCharDevEnum
  29 */
  30 static WERROR srvsvc_NetCharDevEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  31                                       struct srvsvc_NetCharDevEnum *r)
  32 {
  33         r->out.level = r->in.level;
  34         r->out.totalentries = 0;
  35         r->out.resume_handle = NULL;
  36
  37         switch (r->in.level) {
  38         case 0:
  39                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetCharDevCtr0);
  40                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
  41
  42                 r->out.ctr.ctr0->count = 0;
  43                 r->out.ctr.ctr0->array = NULL;
  44
  45                 return WERR_NOT_SUPPORTED;
  46
  47         case 1:
  48                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetCharDevCtr1);
  49                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
  50
  51                 r->out.ctr.ctr1->count = 0;
  52                 r->out.ctr.ctr1->array = NULL;
  53
  54                 return WERR_NOT_SUPPORTED;
  55
  56         default:
  57                 return WERR_UNKNOWN_LEVEL;
  58         }
  59
  60         return WERR_OK;
  61 }
  62
  63
  64 /*
  65   srvsvc_NetCharDevGetInfo
  66 */
  67 static WERROR srvsvc_NetCharDevGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  68                        struct srvsvc_NetCharDevGetInfo *r)
  69 {
  70         switch (r->in.level) {
  71         case 0:
  72                 r->out.info.info0 = NULL;
  73
  74                 return WERR_NOT_SUPPORTED;
  75
  76         case 1:
  77                 r->out.info.info1 = NULL;
  78
  79                 return WERR_NOT_SUPPORTED;
  80
  81         default:
  82                 return WERR_UNKNOWN_LEVEL;
  83         }
  84
  85         return WERR_OK;
  86 }
  87
  88
  89 /*
  90   srvsvc_NetCharDevControl
  91 */
  92 static WERROR srvsvc_NetCharDevControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  93                        struct srvsvc_NetCharDevControl *r)
  94 {
  95         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
  96 }
  97
  98
  99 /*
 100   srvsvc_NetCharDevQEnum
 101 */
 102 static WERROR srvsvc_NetCharDevQEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 103                                      struct srvsvc_NetCharDevQEnum *r)
 104 {
 105         r->out.level = r->in.level;
 106         r->out.totalentries = 0;
 107         r->out.resume_handle = NULL;
 108
 109         switch (r->in.level) {
 110         case 0:
 111                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQCtr0);
 112                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 113
 114                 r->out.ctr.ctr0->count = 0;
 115                 r->out.ctr.ctr0->array = NULL;
 116
 117                 return WERR_NOT_SUPPORTED;
 118
 119         case 1:
 120                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQCtr1);
 121                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 122
 123                 r->out.ctr.ctr1->count = 0;
 124                 r->out.ctr.ctr1->array = NULL;
 125
 126                 return WERR_NOT_SUPPORTED;
 127
 128         default:
 129                 return WERR_UNKNOWN_LEVEL;
 130         }
 131
 132         return WERR_OK;
 133 }
 134
 135
 136 /*
 137   srvsvc_NetCharDevQGetInfo
 138 */
 139 static WERROR srvsvc_NetCharDevQGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 140                                         struct srvsvc_NetCharDevQGetInfo *r)
 141 {
 142         switch (r->in.level) {
 143         case 0:
 144                 r->out.info.info0 = NULL;
 145
 146                 return WERR_NOT_SUPPORTED;
 147
 148         case 1:
 149                 r->out.info.info1 = NULL;
 150
 151                 return WERR_NOT_SUPPORTED;
 152
 153         default:
 154                 return WERR_UNKNOWN_LEVEL;
 155         }
 156
 157         return WERR_OK;
 158 }
 159
 160
 161 /*
 162   srvsvc_NetCharDevQSetInfo
 163 */
 164 static WERROR srvsvc_NetCharDevQSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 165                        struct srvsvc_NetCharDevQSetInfo *r)
 166 {
 167         switch (r->in.level) {
 168         case 0:
 169                 if (r->in.parm_error) {
 170                         r->out.parm_error = r->in.parm_error;
 171                 }
 172                 return WERR_NOT_SUPPORTED;
 173         case 1:
 174                 if (r->in.parm_error) {
 175                         r->out.parm_error = r->in.parm_error;
 176                 }
 177                 return WERR_NOT_SUPPORTED;
 178         default:
 179                 return WERR_UNKNOWN_LEVEL;
 180         }
 181
 182         return WERR_OK;
 183 }
 184
 185
 186 /*
 187   srvsvc_NetCharDevQPurge
 188 */
 189 static WERROR srvsvc_NetCharDevQPurge(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 190                        struct srvsvc_NetCharDevQPurge *r)
 191 {
 192         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 193 }
 194
 195
 196 /*
 197   srvsvc_NetCharDevQPurgeSelf
 198 */
 199 static WERROR srvsvc_NetCharDevQPurgeSelf(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 200                                           struct srvsvc_NetCharDevQPurgeSelf *r)
 201 {
 202         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 203 }
 204
 205
 206 /*
 207   srvsvc_NetConnEnum
 208 */
 209 static WERROR srvsvc_NetConnEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 210                        struct srvsvc_NetConnEnum *r)
 211 {
 212         r->out.level = r->in.level;
 213         r->out.totalentries = 0;
 214         r->out.resume_handle = NULL;
 215
 216         switch (r->in.level) {
 217         case 0:
 218                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetConnCtr0);
 219                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 220
 221                 r->out.ctr.ctr0->count = 0;
 222                 r->out.ctr.ctr0->array = NULL;
 223
 224                 return WERR_NOT_SUPPORTED;
 225
 226         case 1:
 227                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetConnCtr1);
 228                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 229
 230                 r->out.ctr.ctr1->count = 0;
 231                 r->out.ctr.ctr1->array = NULL;
 232
 233                 return WERR_NOT_SUPPORTED;
 234
 235         default:
 236                 return WERR_UNKNOWN_LEVEL;
 237         }
 238
 239         return WERR_OK;
 240 }
 241
 242
 243 /*
 244   srvsvc_NetFileEnum
 245 */
 246 static WERROR srvsvc_NetFileEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 247                                  struct srvsvc_NetFileEnum *r)
 248 {
 249         r->out.level = r->in.level;
 250         r->out.totalentries = 0;
 251         r->out.resume_handle = NULL;
 252
 253         switch (r->in.level) {
 254         case 2:
 255                 r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetFileCtr2);
 256                 WERR_TALLOC_CHECK(r->out.ctr.ctr2);
 257
 258                 r->out.ctr.ctr2->count = 0;
 259                 r->out.ctr.ctr2->array = NULL;
 260
 261                 return WERR_NOT_SUPPORTED;
 262
 263         case 3:
 264                 r->out.ctr.ctr3 = talloc_p(mem_ctx, struct srvsvc_NetFileCtr3);
 265                 WERR_TALLOC_CHECK(r->out.ctr.ctr3);
 266
 267                 r->out.ctr.ctr3->count = 0;
 268                 r->out.ctr.ctr3->array = NULL;
 269
 270                 return WERR_NOT_SUPPORTED;
 271
 272         default:
 273                 return WERR_UNKNOWN_LEVEL;
 274         }
 275
 276         return WERR_OK;
 277 }
 278
 279
 280 /*
 281   srvsvc_NetFileGetInfo
 282 */
 283 static WERROR srvsvc_NetFileGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 284                                     struct srvsvc_NetFileGetInfo *r)
 285 {
 286         switch (r->in.level) {
 287         case 2:
 288                 r->out.info.info2 = NULL;
 289                 return WERR_NOT_SUPPORTED;
 290
 291         case 3:
 292                 r->out.info.info3 = NULL;
 293                 return WERR_NOT_SUPPORTED;
 294
 295         default:
 296                 return WERR_UNKNOWN_LEVEL;
 297         }
 298
 299         return WERR_OK;
 300 }
 301
 302
 303 /*
 304   srvsvc_NetFileClose
 305 */
 306 static WERROR srvsvc_NetFileClose(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 307                        struct srvsvc_NetFileClose *r)
 308 {
 309         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 310 }
 311
 312
 313 /*
 314   srvsvc_NetSessEnum
 315 */
 316 static WERROR srvsvc_NetSessEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 317                        struct srvsvc_NetSessEnum *r)
 318 {
 319         r->out.level = r->in.level;
 320         r->out.totalentries = 0;
 321         r->out.resume_handle = NULL;
 322
 323         switch (r->in.level) {
 324         case 0:
 325                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr0);
 326                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 327
 328                 r->out.ctr.ctr0->count = 0;
 329                 r->out.ctr.ctr0->array = NULL;
 330
 331                 return WERR_NOT_SUPPORTED;
 332
 333         case 1:
 334                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr1);
 335                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 336
 337                 r->out.ctr.ctr1->count = 0;
 338                 r->out.ctr.ctr1->array = NULL;
 339
 340                 return WERR_NOT_SUPPORTED;
 341
 342         case 2:
 343                 r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr2);
 344                 WERR_TALLOC_CHECK(r->out.ctr.ctr2);
 345
 346                 r->out.ctr.ctr2->count = 0;
 347                 r->out.ctr.ctr2->array = NULL;
 348
 349                 return WERR_NOT_SUPPORTED;
 350
 351         case 10:
 352                 r->out.ctr.ctr10 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr10);
 353                 WERR_TALLOC_CHECK(r->out.ctr.ctr10);
 354
 355                 r->out.ctr.ctr2->count = 0;
 356                 r->out.ctr.ctr2->array = NULL;
 357
 358                 return WERR_NOT_SUPPORTED;
 359
 360         case 502:
 361                 r->out.ctr.ctr502 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr502);
 362                 WERR_TALLOC_CHECK(r->out.ctr.ctr502);
 363
 364                 r->out.ctr.ctr2->count = 0;
 365                 r->out.ctr.ctr2->array = NULL;
 366
 367                 return WERR_NOT_SUPPORTED;
 368
 369         default:
 370                 return WERR_UNKNOWN_LEVEL;
 371         }
 372
 373         return WERR_OK;
 374 }
 375
 376
 377 /*
 378   srvsvc_NetSessDel
 379 */
 380 static WERROR srvsvc_NetSessDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 381                        struct srvsvc_NetSessDel *r)
 382 {
 383         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 384 }
 385
 386
 387 /*
 388   srvsvc_NetShareAdd
 389 */
 390 static WERROR srvsvc_NetShareAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 391                        struct srvsvc_NetShareAdd *r)
 392 {
 393         switch (r->in.level) {
 394         case 0:
 395                 if (r->in.parm_error) {
 396                         r->out.parm_error = r->in.parm_error;
 397                 }
 398                 return WERR_NOT_SUPPORTED;
 399
 400         case 1:
 401                 if (r->in.parm_error) {
 402                         r->out.parm_error = r->in.parm_error;
 403                 }
 404                 return WERR_NOT_SUPPORTED;
 405
 406         case 2:
 407                 if (r->in.parm_error) {
 408                         r->out.parm_error = r->in.parm_error;
 409                 }
 410                 return WERR_NOT_SUPPORTED;
 411
 412         case 501:
 413                 if (r->in.parm_error) {
 414                         r->out.parm_error = r->in.parm_error;
 415                 }
 416                 return WERR_NOT_SUPPORTED;
 417
 418         case 502:
 419                 if (r->in.parm_error) {
 420                         r->out.parm_error = r->in.parm_error;
 421                 }
 422                 return WERR_NOT_SUPPORTED;
 423
 424         default:
 425                 return WERR_UNKNOWN_LEVEL;
 426         }
 427
 428         return WERR_OK;
 429 }
 430
 431
 432 /*
 433   srvsvc_NetShareEnumAll
 434 */
 435 static WERROR srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 436                        struct srvsvc_NetShareEnumAll *r)
 437 {
 438         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 439         r->out.level = r->in.level;
 440         r->out.totalentries = 0;
 441         r->out.resume_handle = NULL;
 442
 443         switch (r->in.level) {
 444         case 0: {
 445                 int i;
 446
 447                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr0);
 448                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 449
 450                 r->out.ctr.ctr0->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 451                 r->out.ctr.ctr0->array = NULL;
 452
 453                 if (r->out.ctr.ctr0->count == 0) break;
 454
 455                 r->out.ctr.ctr0->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo0, r->out.ctr.ctr0->count);
 456                 WERR_TALLOC_CHECK(r->out.ctr.ctr0->array);
 457
 458                 for (i=0;i<r->out.ctr.ctr0->count;i++) {
 459                         r->out.ctr.ctr0->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 460                         WERR_TALLOC_CHECK(r->out.ctr.ctr0->array[i].name);
 461                 }
 462
 463                 r->out.totalentries = r->out.ctr.ctr0->count;
 464
 465                 break;
 466                 }
 467         case 1: {
 468                 int i;
 469                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr1);
 470                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 471
 472                 r->out.ctr.ctr1->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 473                 r->out.ctr.ctr1->array = NULL;
 474
 475                 if (r->out.ctr.ctr1->count == 0) break;
 476
 477                 r->out.ctr.ctr1->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo1, r->out.ctr.ctr1->count);
 478                 WERR_TALLOC_CHECK(r->out.ctr.ctr1->array);
 479
 480                 for (i=0;i<r->out.ctr.ctr1->count;i++) {
 481                         r->out.ctr.ctr1->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 482                         r->out.ctr.ctr1->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 483                         r->out.ctr.ctr1->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 484                 }
 485
 486                 r->out.totalentries = r->out.ctr.ctr1->count;
 487
 488                 break;
 489                 }
 490         case 2: {
 491                 int i;
 492                 r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr2);
 493                 WERR_TALLOC_CHECK(r->out.ctr.ctr2);
 494
 495                 r->out.ctr.ctr2->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 496                 r->out.ctr.ctr2->array = NULL;
 497
 498                 if (r->out.ctr.ctr2->count == 0) break;
 499
 500                 r->out.ctr.ctr2->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo2, r->out.ctr.ctr2->count);
 501                 WERR_TALLOC_CHECK(r->out.ctr.ctr2->array);
 502
 503                 for (i=0;i<r->out.ctr.ctr2->count;i++) {
 504                         r->out.ctr.ctr2->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 505                         r->out.ctr.ctr2->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 506                         r->out.ctr.ctr2->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 507                         r->out.ctr.ctr2->array[i].permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, i);
 508                         r->out.ctr.ctr2->array[i].max_users = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, i);
 509                         r->out.ctr.ctr2->array[i].current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, i);
 510                         r->out.ctr.ctr2->array[i].path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, i);
 511                         r->out.ctr.ctr2->array[i].password = dcesrv_common_get_share_password(mem_ctx, dce_ctx, i);
 512                 }
 513
 514                 r->out.totalentries = r->out.ctr.ctr2->count;
 515
 516                 break;
 517                 }
 518         case 501:{
 519                 int i;
 520                 r->out.ctr.ctr501 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr501);
 521                 WERR_TALLOC_CHECK(r->out.ctr.ctr501);
 522
 523                 r->out.ctr.ctr501->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 524                 r->out.ctr.ctr501->array = NULL;
 525
 526                 if (r->out.ctr.ctr501->count == 0) break;
 527
 528                 r->out.ctr.ctr501->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo501, r->out.ctr.ctr501->count);
 529                 WERR_TALLOC_CHECK(r->out.ctr.ctr501->array);
 530
 531                 for (i=0;i<r->out.ctr.ctr501->count;i++) {
 532                         r->out.ctr.ctr501->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 533                         r->out.ctr.ctr501->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 534                         r->out.ctr.ctr501->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 535                         r->out.ctr.ctr501->array[i].csc_policy = dcesrv_common_get_share_csc_policy(mem_ctx, dce_ctx, i);
 536                 }
 537
 538                 r->out.totalentries = r->out.ctr.ctr501->count;
 539
 540                 break;
 541                 }
 542         case 502:{
 543                 int i;
 544                 r->out.ctr.ctr502 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr502);
 545                 WERR_TALLOC_CHECK(r->out.ctr.ctr502);
 546
 547                 r->out.ctr.ctr502->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 548                 r->out.ctr.ctr502->array = NULL;
 549
 550                 if (r->out.ctr.ctr502->count == 0) break;
 551
 552                 r->out.ctr.ctr502->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo502, r->out.ctr.ctr502->count);
 553                 WERR_TALLOC_CHECK(r->out.ctr.ctr502->array);
 554
 555                 for (i=0;i<r->out.ctr.ctr502->count;i++) {
 556                         r->out.ctr.ctr502->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 557                         r->out.ctr.ctr502->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 558                         r->out.ctr.ctr502->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 559                         r->out.ctr.ctr502->array[i].permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, i);
 560                         r->out.ctr.ctr502->array[i].max_users = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, i);
 561                         r->out.ctr.ctr502->array[i].current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, i);
 562                         r->out.ctr.ctr502->array[i].path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, i);
 563                         r->out.ctr.ctr502->array[i].password = dcesrv_common_get_share_password(mem_ctx, dce_ctx, i);
 564                         r->out.ctr.ctr502->array[i].unknown = dcesrv_common_get_share_unknown(mem_ctx, dce_ctx, i);
 565                         r->out.ctr.ctr502->array[i].sd = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, i);
 566                 }
 567
 568                 r->out.totalentries = r->out.ctr.ctr502->count;
 569
 570                 break;
 571                 }
 572         default:
 573                 return WERR_UNKNOWN_LEVEL;
 574         }
 575
 576         return WERR_OK;
 577 }
 578
 579
 580 /*
 581   srvsvc_NetShareGetInfo
 582 */
 583 static WERROR srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 584                        struct srvsvc_NetShareGetInfo *r)
 585 {
 586         switch (r->in.level) {
 587         case 0:
 588                 r->out.info.info0 = NULL;
 589
 590                 return WERR_NOT_SUPPORTED;
 591
 592         case 1:
 593                 r->out.info.info0 = NULL;
 594
 595                 return WERR_NOT_SUPPORTED;
 596
 597         case 2:
 598                 r->out.info.info0 = NULL;
 599
 600                 return WERR_NOT_SUPPORTED;
 601
 602         case 501:
 603                 r->out.info.info0 = NULL;
 604
 605                 return WERR_NOT_SUPPORTED;
 606
 607         case 502:
 608                 r->out.info.info0 = NULL;
 609
 610                 return WERR_NOT_SUPPORTED;
 611
 612         default:
 613                 return WERR_UNKNOWN_LEVEL;
 614                 break;
 615         }
 616
 617         return WERR_OK;
 618 }
 619
 620
 621 /*
 622   srvsvc_NetShareSetInfo
 623 */
 624 static WERROR srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 625                        struct srvsvc_NetShareSetInfo *r)
 626 {
 627         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 628 }
 629
 630
 631 /*
 632   srvsvc_NetShareDel
 633 */
 634 static WERROR srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 635                        struct srvsvc_NetShareDel *r)
 636 {
 637         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 638 }
 639
 640
 641 /*
 642   srvsvc_NetShareDelSticky
 643 */
 644 static WERROR srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 645                        struct srvsvc_NetShareDelSticky *r)
 646 {
 647         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 648 }
 649
 650
 651 /*
 652   srvsvc_NetShareCheck
 653 */
 654 static WERROR srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 655                        struct srvsvc_NetShareCheck *r)
 656 {
 657         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 658 }
 659
 660
 661 /*
 662   srvsvc_NetSrvGetInfo
 663 */
 664 static WERROR srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 665                        struct srvsvc_NetSrvGetInfo *r)
 666 {
 667         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 668 }
 669
 670
 671 /*
 672   srvsvc_NetSrvSetInfo
 673 */
 674 static WERROR srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 675                        struct srvsvc_NetSrvSetInfo *r)
 676 {
 677         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 678 }
 679
 680
 681 /*
 682   srvsvc_NetDiskEnum
 683 */
 684 static WERROR srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 685                        struct srvsvc_NetDiskEnum *r)
 686 {
 687         r->out.count = 0;
 688         r->out.ctr0 = NULL;
 689         r->out.totalentries = 0;
 690         r->out.resume_handle = NULL;
 691
 692         switch (r->in.level) {
 693         case 0: {
 694                 r->out.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetDiskCtr0);
 695                 WERR_TALLOC_CHECK(r->out.ctr0);
 696
 697                 r->out.ctr0->unknown = 0x1;
 698                 r->out.ctr0->count = 0;
 699                 r->out.ctr0->array = NULL;
 700
 701                 return WERR_NOT_SUPPORTED;
 702                 break;
 703                 }
 704         default:
 705                 return WERR_UNKNOWN_LEVEL;
 706                 break;
 707         }
 708
 709         return WERR_OK;
 710 }
 711
 712
 713 /*
 714   srvsvc_NETRSERVERSTATISTICSGET
 715 */
 716 static WERROR srvsvc_NETRSERVERSTATISTICSGET(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 717                                              struct srvsvc_NETRSERVERSTATISTICSGET *r)
 718 {
 719         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 720 }
 721
 722
 723 /*
 724   srvsvc_NETRSERVERTRANSPORTADD
 725 */
 726 static WERROR srvsvc_NETRSERVERTRANSPORTADD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 727                        struct srvsvc_NETRSERVERTRANSPORTADD *r)
 728 {
 729         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 730 }
 731
 732
 733 /*
 734   srvsvc_NetTransportEnum
 735 */
 736 static WERROR srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 737                        struct srvsvc_NetTransportEnum *r)
 738 {
 739         r->out.level = r->in.level;
 740         r->out.totalentries = 0;
 741         r->out.resume_handle = NULL;
 742
 743         switch (r->in.level) {
 744         case 0: {
 745                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr0);
 746                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 747
 748                 r->out.ctr.ctr0->count = 0;
 749                 r->out.ctr.ctr0->array = NULL;
 750
 751                 return WERR_NOT_SUPPORTED;
 752                 break;
 753                 }
 754         case 1: {
 755                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr1);
 756                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 757
 758                 r->out.ctr.ctr1->count = 0;
 759                 r->out.ctr.ctr1->array = NULL;
 760
 761                 return WERR_NOT_SUPPORTED;
 762                 break;
 763                 }
 764         case 2: {
 765                 r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr2);
 766                 WERR_TALLOC_CHECK(r->out.ctr.ctr2);
 767
 768                 r->out.ctr.ctr2->count = 0;
 769                 r->out.ctr.ctr2->array = NULL;
 770
 771                 return WERR_NOT_SUPPORTED;
 772                 break;
 773                 }
 774         case 3: {
 775                 r->out.ctr.ctr3 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr3);
 776                 WERR_TALLOC_CHECK(r->out.ctr.ctr3);
 777
 778                 r->out.ctr.ctr3->count = 0;
 779                 r->out.ctr.ctr3->array = NULL;
 780
 781                 return WERR_NOT_SUPPORTED;
 782                 break;
 783                 }
 784         default:
 785                 return WERR_UNKNOWN_LEVEL;
 786                 break;
 787         }
 788
 789         return WERR_OK;
 790 }
 791
 792
 793 /*
 794   srvsvc_NETRSERVERTRANSPORTDEL
 795 */
 796 static WERROR srvsvc_NETRSERVERTRANSPORTDEL(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 797                        struct srvsvc_NETRSERVERTRANSPORTDEL *r)
 798 {
 799         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 800 }
 801
 802
 803 /*
 804   srvsvc_NetRemoteTOD
 805 */
 806 static WERROR srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 807                        struct srvsvc_NetRemoteTOD *r)
 808 {
 809         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 810 }
 811
 812
 813 /*
 814   srvsvc_NETRSERVERSETSERVICEBITS
 815 */
 816 static WERROR srvsvc_NETRSERVERSETSERVICEBITS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 817                        struct srvsvc_NETRSERVERSETSERVICEBITS *r)
 818 {
 819         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 820 }
 821
 822
 823 /*
 824   srvsvc_NETRPRPATHTYPE
 825 */
 826 static WERROR srvsvc_NETRPRPATHTYPE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 827                        struct srvsvc_NETRPRPATHTYPE *r)
 828 {
 829         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 830 }
 831
 832
 833 /*
 834   srvsvc_NETRPRPATHCANONICALIZE
 835 */
 836 static WERROR srvsvc_NETRPRPATHCANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 837                        struct srvsvc_NETRPRPATHCANONICALIZE *r)
 838 {
 839         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 840 }
 841
 842
 843 /*
 844   srvsvc_NETRPRPATHCOMPARE
 845 */
 846 static WERROR srvsvc_NETRPRPATHCOMPARE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 847                        struct srvsvc_NETRPRPATHCOMPARE *r)
 848 {
 849         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 850 }
 851
 852
 853 /*
 854   srvsvc_NET_NAME_VALIDATE
 855 */
 856 static WERROR srvsvc_NET_NAME_VALIDATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 857                        struct srvsvc_NET_NAME_VALIDATE *r)
 858 {
 859         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 860 }
 861
 862
 863 /*
 864   srvsvc_NETRPRNAMECANONICALIZE
 865 */
 866 static WERROR srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 867                        struct srvsvc_NETRPRNAMECANONICALIZE *r)
 868 {
 869         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 870 }
 871
 872
 873 /*
 874   srvsvc_NETRPRNAMECOMPARE
 875 */
 876 static WERROR srvsvc_NETRPRNAMECOMPARE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 877                        struct srvsvc_NETRPRNAMECOMPARE *r)
 878 {
 879         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 880 }
 881
 882
 883 /*
 884   srvsvc_NetShareEnum
 885 */
 886 static WERROR srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 887                        struct srvsvc_NetShareEnum *r)
 888 {
 889         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 890         r->out.level = r->in.level;
 891         r->out.totalentries = 0;
 892         r->out.resume_handle = NULL;
 893
 894         switch (r->in.level) {
 895         case 0: {
 896                 int i;
 897
 898                 r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr0);
 899                 WERR_TALLOC_CHECK(r->out.ctr.ctr0);
 900
 901                 r->out.ctr.ctr0->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 902                 r->out.ctr.ctr0->array = NULL;
 903
 904                 if (r->out.ctr.ctr0->count == 0) break;
 905
 906                 r->out.ctr.ctr0->array = talloc(mem_ctx, r->out.ctr.ctr0->count*sizeof(struct srvsvc_NetShareInfo0));
 907                 WERR_TALLOC_CHECK(r->out.ctr.ctr0->array);
 908
 909                 for (i=0;i<r->out.ctr.ctr0->count;i++) {
 910                         r->out.ctr.ctr0->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 911                         WERR_TALLOC_CHECK(r->out.ctr.ctr0->array[i].name);
 912                 }
 913
 914                 r->out.totalentries = r->out.ctr.ctr0->count;
 915
 916                 break;
 917                 }
 918         case 1: {
 919                 int i;
 920                 r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr1);
 921                 WERR_TALLOC_CHECK(r->out.ctr.ctr1);
 922
 923                 r->out.ctr.ctr1->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 924                 r->out.ctr.ctr1->array = NULL;
 925
 926                 if (r->out.ctr.ctr1->count == 0) break;
 927
 928                 r->out.ctr.ctr1->array = talloc(mem_ctx, r->out.ctr.ctr1->count*sizeof(struct srvsvc_NetShareInfo1));
 929                 WERR_TALLOC_CHECK(r->out.ctr.ctr1->array);
 930
 931                 for (i=0;i<r->out.ctr.ctr1->count;i++) {
 932                         r->out.ctr.ctr1->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 933                         r->out.ctr.ctr1->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 934                         r->out.ctr.ctr1->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 935                 }
 936
 937                 r->out.totalentries = r->out.ctr.ctr1->count;
 938
 939                 break;
 940                 }
 941         case 2: {
 942                 int i;
 943                 r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr2);
 944                 WERR_TALLOC_CHECK(r->out.ctr.ctr2);
 945
 946                 r->out.ctr.ctr2->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 947                 r->out.ctr.ctr2->array = NULL;
 948
 949                 if (r->out.ctr.ctr2->count == 0) break;
 950
 951                 r->out.ctr.ctr2->array = talloc(mem_ctx, r->out.ctr.ctr2->count*sizeof(struct srvsvc_NetShareInfo2));
 952                 WERR_TALLOC_CHECK(r->out.ctr.ctr2->array);
 953
 954                 for (i=0;i<r->out.ctr.ctr2->count;i++) {
 955                         r->out.ctr.ctr2->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 956                         r->out.ctr.ctr2->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 957                         r->out.ctr.ctr2->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 958                         r->out.ctr.ctr2->array[i].permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, i);
 959                         r->out.ctr.ctr2->array[i].max_users = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, i);
 960                         r->out.ctr.ctr2->array[i].current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, i);
 961                         r->out.ctr.ctr2->array[i].path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, i);
 962                         r->out.ctr.ctr2->array[i].password = dcesrv_common_get_share_password(mem_ctx, dce_ctx, i);
 963                 }
 964
 965                 r->out.totalentries = r->out.ctr.ctr2->count;
 966
 967                 break;
 968                 }
 969         case 501:{
 970                 int i;
 971                 r->out.ctr.ctr501 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr501);
 972                 WERR_TALLOC_CHECK(r->out.ctr.ctr501);
 973
 974                 r->out.ctr.ctr501->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 975                 r->out.ctr.ctr501->array = NULL;
 976
 977                 if (r->out.ctr.ctr501->count == 0) break;
 978
 979                 r->out.ctr.ctr501->array = talloc(mem_ctx, r->out.ctr.ctr501->count*sizeof(struct srvsvc_NetShareInfo501));
 980                 WERR_TALLOC_CHECK(r->out.ctr.ctr501->array);
 981
 982                 for (i=0;i<r->out.ctr.ctr501->count;i++) {
 983                         r->out.ctr.ctr501->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
 984                         r->out.ctr.ctr501->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
 985                         r->out.ctr.ctr501->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
 986                         r->out.ctr.ctr501->array[i].csc_policy = dcesrv_common_get_share_csc_policy(mem_ctx, dce_ctx, i);
 987                 }
 988
 989                 r->out.totalentries = r->out.ctr.ctr501->count;
 990
 991                 break;
 992                 }
 993         case 502:{
 994                 int i;
 995                 r->out.ctr.ctr502 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr502);
 996                 WERR_TALLOC_CHECK(r->out.ctr.ctr502);
 997
 998                 r->out.ctr.ctr502->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
 999                 r->out.ctr.ctr502->array = NULL;
1000
1001                 if (r->out.ctr.ctr502->count == 0) break;
1002
1003                 r->out.ctr.ctr502->array = talloc(mem_ctx, r->out.ctr.ctr502->count*sizeof(struct srvsvc_NetShareInfo502));
1004                 WERR_TALLOC_CHECK(r->out.ctr.ctr502->array);
1005
1006                 for (i=0;i<r->out.ctr.ctr502->count;i++) {
1007                         r->out.ctr.ctr502->array[i].name = dcesrv_common_get_share_name(mem_ctx, dce_ctx, i);
1008                         r->out.ctr.ctr502->array[i].type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, i);
1009                         r->out.ctr.ctr502->array[i].comment = dcesrv_common_get_share_comment(mem_ctx, dce_ctx, i);
1010                         r->out.ctr.ctr502->array[i].permissions = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, i);
1011                         r->out.ctr.ctr502->array[i].max_users = dcesrv_common_get_share_max_users(mem_ctx, dce_ctx, i);
1012                         r->out.ctr.ctr502->array[i].current_users = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, i);
1013                         r->out.ctr.ctr502->array[i].path = dcesrv_common_get_share_path(mem_ctx, dce_ctx, i);
1014                         r->out.ctr.ctr502->array[i].password = dcesrv_common_get_share_password(mem_ctx, dce_ctx, i);
1015                         r->out.ctr.ctr502->array[i].unknown = dcesrv_common_get_share_unknown(mem_ctx, dce_ctx, i);
1016                         r->out.ctr.ctr502->array[i].sd = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, i);
1017                 }
1018
1019                 r->out.totalentries = r->out.ctr.ctr502->count;
1020
1021                 break;
1022                 }
1023         default:
1024                 return WERR_UNKNOWN_LEVEL;
1025                 break;
1026         }
1027
1028         return WERR_OK;
1029 }
1030
1031
1032 /*
1033   srvsvc_NETRSHAREDELSTART
1034 */
1035 static WERROR srvsvc_NETRSHAREDELSTART(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1036                        struct srvsvc_NETRSHAREDELSTART *r)
1037 {
1038         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1039 }
1040
1041
1042 /*
1043   srvsvc_NETRSHAREDELCOMMIT
1044 */
1045 static WERROR srvsvc_NETRSHAREDELCOMMIT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1046                        struct srvsvc_NETRSHAREDELCOMMIT *r)
1047 {
1048         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1049 }
1050
1051
1052 /*
1053   srvsvc_NET_FILE_QUERY_SECDESC
1054 */
1055 static WERROR srvsvc_NET_FILE_QUERY_SECDESC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1056                        struct srvsvc_NET_FILE_QUERY_SECDESC *r)
1057 {
1058         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1059 }
1060
1061
1062 /*
1063   srvsvc_NET_FILE_SET_SECDESC
1064 */
1065 static WERROR srvsvc_NET_FILE_SET_SECDESC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1066                        struct srvsvc_NET_FILE_SET_SECDESC *r)
1067 {
1068         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1069 }
1070
1071
1072 /*
1073   srvsvc_NETRSERVERTRANSPORTADDEX
1074 */
1075 static WERROR srvsvc_NETRSERVERTRANSPORTADDEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1076                        struct srvsvc_NETRSERVERTRANSPORTADDEX *r)
1077 {
1078         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1079 }
1080
1081
1082 /*
1083   srvsvc_NETRSERVERSETSERVICEBITSEX
1084 */
1085 static WERROR srvsvc_NETRSERVERSETSERVICEBITSEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1086                        struct srvsvc_NETRSERVERSETSERVICEBITSEX *r)
1087 {
1088         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1089 }
1090
1091
1092 /*
1093   srvsvc_NETRDFSGETVERSION
1094 */
1095 static WERROR srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1096                        struct srvsvc_NETRDFSGETVERSION *r)
1097 {
1098         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1099 }
1100
1101
1102 /*
1103   srvsvc_NETRDFSCREATELOCALPARTITION
1104 */
1105 static WERROR srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1106                        struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
1107 {
1108         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1109 }
1110
1111
1112 /*
1113   srvsvc_NETRDFSDELETELOCALPARTITION
1114 */
1115 static WERROR srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1116                        struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
1117 {
1118         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1119 }
1120
1121
1122 /*
1123   srvsvc_NETRDFSSETLOCALVOLUMESTATE
1124 */
1125 static WERROR srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1126                        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
1127 {
1128         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1129 }
1130
1131
1132 /*
1133   srvsvc_NETRDFSSETSERVERINFO
1134 */
1135 static WERROR srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1136                        struct srvsvc_NETRDFSSETSERVERINFO *r)
1137 {
1138         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1139 }
1140
1141
1142 /*
1143   srvsvc_NETRDFSCREATEEXITPOINT
1144 */
1145 static WERROR srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1146                        struct srvsvc_NETRDFSCREATEEXITPOINT *r)
1147 {
1148         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1149 }
1150
1151
1152 /*
1153   srvsvc_NETRDFSDELETEEXITPOINT
1154 */
1155 static WERROR srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1156                        struct srvsvc_NETRDFSDELETEEXITPOINT *r)
1157 {
1158         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1159 }
1160
1161
1162 /*
1163   srvsvc_NETRDFSMODIFYPREFIX
1164 */
1165 static WERROR srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1166                        struct srvsvc_NETRDFSMODIFYPREFIX *r)
1167 {
1168         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1169 }
1170
1171
1172 /*
1173   srvsvc_NETRDFSFIXLOCALVOLUME
1174 */
1175 static WERROR srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1176                        struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
1177 {
1178         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1179 }
1180
1181
1182 /*
1183   srvsvc_NETRDFSMANAGERREPORTSITEINFO
1184 */
1185 static WERROR srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1186                        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
1187 {
1188         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1189 }
1190
1191
1192 /*
1193   srvsvc_NETRSERVERTRANSPORTDELEX
1194 */
1195 static WERROR srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1196                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
1197 {
1198         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1199 }
1200
1201
1202 /* include the generated boilerplate */
1203 #include "librpc/gen_ndr/ndr_srvsvc_s.c"