source4/rpc_server/srvsvc/dcesrv_srvsvc.c

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