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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "ntvfs/ntvfs.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 "rpc_server/common/proto.h"
  28 #include "auth/auth.h"
  29 #include "libcli/security/security.h"
  30 #include "system/time.h"
  31 #include "rpc_server/srvsvc/proto.h"
  32 #include "param/param.h"
  33
  34 #define SRVSVC_CHECK_ADMIN_ACCESS do { \
  35         struct security_token *t = dce_call->conn->auth_state.session_info->security_token; \
  36         if (!security_token_has_builtin_administrators(t) && \
  37             !security_token_has_sid_string(t, SID_BUILTIN_SERVER_OPERATORS)) { \
  38                 return WERR_ACCESS_DENIED; \
  39         } \
  40 } while (0)
  41
  42 /*
  43   srvsvc_NetCharDevEnum
  44 */
  45 static WERROR dcesrv_srvsvc_NetCharDevEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  46                                       struct srvsvc_NetCharDevEnum *r)
  47 {
  48         *r->out.totalentries = 0;
  49
  50         switch (r->in.info_ctr->level) {
  51         case 0:
  52                 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr0);
  53                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
  54
  55                 r->out.info_ctr->ctr.ctr0->count = 0;
  56                 r->out.info_ctr->ctr.ctr0->array = NULL;
  57
  58                 return WERR_NOT_SUPPORTED;
  59
  60         case 1:
  61                 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr1);
  62                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
  63
  64                 r->out.info_ctr->ctr.ctr1->count = 0;
  65                 r->out.info_ctr->ctr.ctr1->array = NULL;
  66
  67                 return WERR_NOT_SUPPORTED;
  68
  69         default:
  70                 return WERR_UNKNOWN_LEVEL;
  71         }
  72
  73         return WERR_OK;
  74 }
  75
  76
  77 /*
  78   srvsvc_NetCharDevGetInfo
  79 */
  80 static WERROR dcesrv_srvsvc_NetCharDevGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  81                        struct srvsvc_NetCharDevGetInfo *r)
  82 {
  83         ZERO_STRUCTP(r->out.info);
  84
  85         switch (r->in.level) {
  86         case 0:
  87         {
  88                 return WERR_NOT_SUPPORTED;
  89         }
  90         case 1:
  91         {
  92                 return WERR_NOT_SUPPORTED;
  93         }
  94         default:
  95                 return WERR_UNKNOWN_LEVEL;
  96         }
  97
  98         return WERR_UNKNOWN_LEVEL;
  99 }
 100
 101
 102 /*
 103   srvsvc_NetCharDevControl
 104 */
 105 static WERROR dcesrv_srvsvc_NetCharDevControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 106                        struct srvsvc_NetCharDevControl *r)
 107 {
 108         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 109 }
 110
 111
 112 /*
 113   srvsvc_NetCharDevQEnum
 114 */
 115 static WERROR dcesrv_srvsvc_NetCharDevQEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 116                                      struct srvsvc_NetCharDevQEnum *r)
 117 {
 118         *r->out.totalentries = 0;
 119
 120         switch (r->in.info_ctr->level) {
 121         case 0:
 122         {
 123                 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr0);
 124                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
 125
 126                 r->out.info_ctr->ctr.ctr0->count = 0;
 127                 r->out.info_ctr->ctr.ctr0->array = NULL;
 128
 129                 return WERR_NOT_SUPPORTED;
 130         }
 131         case 1:
 132         {
 133                 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr1);
 134                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
 135
 136                 r->out.info_ctr->ctr.ctr1->count = 0;
 137                 r->out.info_ctr->ctr.ctr1->array = NULL;
 138
 139                 return WERR_NOT_SUPPORTED;
 140         }
 141         default:
 142                 return WERR_UNKNOWN_LEVEL;
 143         }
 144
 145         return WERR_UNKNOWN_LEVEL;
 146 }
 147
 148
 149 /*
 150   srvsvc_NetCharDevQGetInfo
 151 */
 152 static WERROR dcesrv_srvsvc_NetCharDevQGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 153                                         struct srvsvc_NetCharDevQGetInfo *r)
 154 {
 155         ZERO_STRUCTP(r->out.info);
 156
 157         switch (r->in.level) {
 158         case 0:
 159         {
 160                 return WERR_NOT_SUPPORTED;
 161         }
 162         case 1:
 163         {
 164                 return WERR_NOT_SUPPORTED;
 165         }
 166         default:
 167                 return WERR_UNKNOWN_LEVEL;
 168         }
 169
 170         return WERR_UNKNOWN_LEVEL;
 171 }
 172
 173
 174 /*
 175   srvsvc_NetCharDevQSetInfo
 176 */
 177 static WERROR dcesrv_srvsvc_NetCharDevQSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 178                        struct srvsvc_NetCharDevQSetInfo *r)
 179 {
 180         switch (r->in.level) {
 181         case 0:
 182         {
 183                 if (r->in.parm_error) {
 184                         r->out.parm_error = r->in.parm_error;
 185                 }
 186                 return WERR_NOT_SUPPORTED;
 187         }
 188         case 1:
 189         {
 190                 if (r->in.parm_error) {
 191                         r->out.parm_error = r->in.parm_error;
 192                 }
 193                 return WERR_NOT_SUPPORTED;
 194         }
 195         default:
 196                 return WERR_UNKNOWN_LEVEL;
 197         }
 198
 199         return WERR_UNKNOWN_LEVEL;
 200 }
 201
 202
 203 /*
 204   srvsvc_NetCharDevQPurge
 205 */
 206 static WERROR dcesrv_srvsvc_NetCharDevQPurge(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 207                        struct srvsvc_NetCharDevQPurge *r)
 208 {
 209         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 210 }
 211
 212
 213 /*
 214   srvsvc_NetCharDevQPurgeSelf
 215 */
 216 static WERROR dcesrv_srvsvc_NetCharDevQPurgeSelf(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 217                                           struct srvsvc_NetCharDevQPurgeSelf *r)
 218 {
 219         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 220 }
 221
 222
 223 /*
 224   srvsvc_NetConnEnum
 225 */
 226 static WERROR dcesrv_srvsvc_NetConnEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 227                        struct srvsvc_NetConnEnum *r)
 228 {
 229         *r->out.totalentries = 0;
 230
 231         switch (r->in.info_ctr->level) {
 232         case 0:
 233         {
 234                 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetConnCtr0);
 235                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
 236
 237                 r->out.info_ctr->ctr.ctr0->count = 0;
 238                 r->out.info_ctr->ctr.ctr0->array = NULL;
 239
 240                 return WERR_NOT_SUPPORTED;
 241         }
 242         case 1:
 243         {
 244                 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetConnCtr1);
 245                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
 246
 247                 r->out.info_ctr->ctr.ctr1->count = 0;
 248                 r->out.info_ctr->ctr.ctr1->array = NULL;
 249
 250                 return WERR_NOT_SUPPORTED;
 251         }
 252         default:
 253                 return WERR_UNKNOWN_LEVEL;
 254         }
 255
 256         return WERR_UNKNOWN_LEVEL;
 257 }
 258
 259
 260 /*
 261   srvsvc_NetFileEnum
 262 */
 263 static WERROR dcesrv_srvsvc_NetFileEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 264                                  struct srvsvc_NetFileEnum *r)
 265 {
 266         *r->out.totalentries = 0;
 267
 268         switch (r->in.info_ctr->level) {
 269         case 2:
 270         {
 271                 r->out.info_ctr->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetFileCtr2);
 272                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr2);
 273
 274                 r->out.info_ctr->ctr.ctr2->count = 0;
 275                 r->out.info_ctr->ctr.ctr2->array = NULL;
 276
 277                 return WERR_NOT_SUPPORTED;
 278         }
 279         case 3:
 280         {
 281                 r->out.info_ctr->ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetFileCtr3);
 282                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr3);
 283
 284                 r->out.info_ctr->ctr.ctr3->count = 0;
 285                 r->out.info_ctr->ctr.ctr3->array = NULL;
 286
 287                 return WERR_NOT_SUPPORTED;
 288         }
 289         default:
 290                 return WERR_UNKNOWN_LEVEL;
 291         }
 292
 293         return WERR_UNKNOWN_LEVEL;
 294 }
 295
 296
 297 /*
 298   srvsvc_NetFileGetInfo
 299 */
 300 static WERROR dcesrv_srvsvc_NetFileGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 301                                     struct srvsvc_NetFileGetInfo *r)
 302 {
 303         ZERO_STRUCTP(r->out.info);
 304
 305         switch (r->in.level) {
 306         case 2:
 307         {
 308                 return WERR_NOT_SUPPORTED;
 309         }
 310         case 3:
 311         {
 312                 return WERR_NOT_SUPPORTED;
 313         }
 314         default:
 315                 return WERR_UNKNOWN_LEVEL;
 316         }
 317
 318         return WERR_UNKNOWN_LEVEL;
 319 }
 320
 321
 322 /*
 323   srvsvc_NetFileClose
 324 */
 325 static WERROR dcesrv_srvsvc_NetFileClose(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 326                        struct srvsvc_NetFileClose *r)
 327 {
 328         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 329 }
 330
 331
 332 /*
 333   srvsvc_NetSessEnum
 334 */
 335 static WERROR dcesrv_srvsvc_NetSessEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 336                        struct srvsvc_NetSessEnum *r)
 337 {
 338         *r->out.totalentries = 0;
 339
 340         switch (r->in.info_ctr->level) {
 341         case 0:
 342         {
 343                 r->out.info_ctr->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetSessCtr0);
 344                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr0);
 345
 346                 r->out.info_ctr->ctr.ctr0->count = 0;
 347                 r->out.info_ctr->ctr.ctr0->array = NULL;
 348
 349                 return WERR_NOT_SUPPORTED;
 350         }
 351         case 1:
 352         {
 353                 r->out.info_ctr->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetSessCtr1);
 354                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr1);
 355
 356                 r->out.info_ctr->ctr.ctr1->count = 0;
 357                 r->out.info_ctr->ctr.ctr1->array = NULL;
 358
 359                 return WERR_NOT_SUPPORTED;
 360         }
 361         case 2:
 362         {
 363                 r->out.info_ctr->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetSessCtr2);
 364                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr2);
 365
 366                 r->out.info_ctr->ctr.ctr2->count = 0;
 367                 r->out.info_ctr->ctr.ctr2->array = NULL;
 368
 369                 return WERR_NOT_SUPPORTED;
 370         }
 371         case 10:
 372         {
 373                 r->out.info_ctr->ctr.ctr10 = talloc(mem_ctx, struct srvsvc_NetSessCtr10);
 374                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr10);
 375
 376                 r->out.info_ctr->ctr.ctr10->count = 0;
 377                 r->out.info_ctr->ctr.ctr10->array = NULL;
 378
 379                 return WERR_NOT_SUPPORTED;
 380         }
 381         case 502:
 382         {
 383                 r->out.info_ctr->ctr.ctr502 = talloc(mem_ctx, struct srvsvc_NetSessCtr502);
 384                 W_ERROR_HAVE_NO_MEMORY(r->out.info_ctr->ctr.ctr502);
 385
 386                 r->out.info_ctr->ctr.ctr502->count = 0;
 387                 r->out.info_ctr->ctr.ctr502->array = NULL;
 388
 389                 return WERR_NOT_SUPPORTED;
 390         }
 391         default:
 392                 return WERR_UNKNOWN_LEVEL;
 393         }
 394
 395         return WERR_UNKNOWN_LEVEL;
 396 }
 397
 398
 399 /*
 400   srvsvc_NetSessDel
 401 */
 402 static WERROR dcesrv_srvsvc_NetSessDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 403                        struct srvsvc_NetSessDel *r)
 404 {
 405         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 406 }
 407
 408
 409 /*
 410   srvsvc_NetShareAdd
 411 */
 412 static WERROR dcesrv_srvsvc_NetShareAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 413                        struct srvsvc_NetShareAdd *r)
 414 {
 415         switch (r->in.level) {
 416         case 0:
 417         {
 418                 if (r->in.parm_error) {
 419                         r->out.parm_error = r->in.parm_error;
 420                 }
 421                 return WERR_NOT_SUPPORTED;
 422         }
 423         case 1:
 424         {
 425                 if (r->in.parm_error) {
 426                         r->out.parm_error = r->in.parm_error;
 427                 }
 428                 return WERR_NOT_SUPPORTED;
 429         }
 430         case 2:
 431         {
 432                 NTSTATUS nterr;
 433                 struct share_info *info;
 434                 struct share_context *sctx;
 435                 int count = 8;
 436                 int i;
 437
 438                 nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
 439                 if (!NT_STATUS_IS_OK(nterr)) {
 440                         return ntstatus_to_werror(nterr);
 441                 }
 442
 443                 /* there are no more than 8 options in struct srvsvc_NetShareInfo2 */
 444                 info = talloc_array(mem_ctx, struct share_info, count);
 445                 W_ERROR_HAVE_NO_MEMORY(info);
 446
 447                 i = 0;
 448
 449                 info[i].name = SHARE_TYPE;
 450                 info[i].type = SHARE_INFO_STRING;
 451                 switch (r->in.info->info2->type) {
 452                 case 0x00:
 453                         info[i].value = talloc_strdup(info, "DISK");
 454                         break;
 455                 case 0x01:
 456                         info[i].value = talloc_strdup(info, "PRINTER");
 457                         break;
 458                 case 0x03:
 459                         info[i].value = talloc_strdup(info, "IPC");
 460                         break;
 461                 default:
 462                         return WERR_INVALID_PARAM;
 463                 }
 464                 W_ERROR_HAVE_NO_MEMORY(info[i].value);
 465                 i++;
 466
 467                 if (r->in.info->info2->path && r->in.info->info2->path[0]) {
 468                         info[i].name = SHARE_PATH;
 469                         info[i].type = SHARE_INFO_STRING;
 470
 471                         /* Windows will send a path in a form of C:\example\path */
 472                         if (r->in.info->info2->path[1] == ':') {
 473                                 info[i].value = talloc_strdup(info, &r->in.info->info2->path[2]);
 474                         } else {
 475                                 /* very strange let's try to set as is */
 476                                 info[i].value = talloc_strdup(info, r->in.info->info2->path);
 477                         }
 478                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 479                         all_string_sub((char *)info[i].value, "\\", "/", 0);
 480
 481                         i++;
 482                 }
 483
 484                 if (r->in.info->info2->comment && r->in.info->info2->comment[0]) {
 485                         info[i].name = SHARE_COMMENT;
 486                         info[i].type = SHARE_INFO_STRING;
 487                         info[i].value = talloc_strdup(info, r->in.info->info2->comment);
 488                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 489
 490                         i++;
 491                 }
 492
 493                 if (r->in.info->info2->password && r->in.info->info2->password[0]) {
 494                         info[i].name = SHARE_PASSWORD;
 495                         info[i].type = SHARE_INFO_STRING;
 496                         info[i].value = talloc_strdup(info, r->in.info->info2->password);
 497                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 498
 499                         i++;
 500                 }
 501
 502                 info[i].name = SHARE_MAX_CONNECTIONS;
 503                 info[i].type = SHARE_INFO_INT;
 504                 info[i].value = talloc(info, int);
 505                 *((int *)info[i].value) = r->in.info->info2->max_users;
 506                 i++;
 507
 508                 /* TODO: security descriptor */
 509
 510                 nterr = share_create(sctx, r->in.info->info2->name, info, i);
 511                 if (!NT_STATUS_IS_OK(nterr)) {
 512                         return ntstatus_to_werror(nterr);
 513                 }
 514
 515                 if (r->in.parm_error) {
 516                         r->out.parm_error = r->in.parm_error;
 517                 }
 518
 519                 return WERR_OK;
 520         }
 521         case 501:
 522         {
 523                 if (r->in.parm_error) {
 524                         r->out.parm_error = r->in.parm_error;
 525                 }
 526                 return WERR_NOT_SUPPORTED;
 527         }
 528         case 502:
 529         {
 530                 NTSTATUS nterr;
 531                 struct share_info *info;
 532                 struct share_context *sctx;
 533                 int count = 10;
 534                 int i;
 535
 536                 nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
 537                 if (!NT_STATUS_IS_OK(nterr)) {
 538                         return ntstatus_to_werror(nterr);
 539                 }
 540
 541                 /* there are no more than 10 options in struct srvsvc_NetShareInfo502 */
 542                 info = talloc_array(mem_ctx, struct share_info, count);
 543                 W_ERROR_HAVE_NO_MEMORY(info);
 544
 545                 i = 0;
 546
 547                 info[i].name = SHARE_TYPE;
 548                 info[i].type = SHARE_INFO_STRING;
 549                 switch (r->in.info->info502->type) {
 550                 case 0x00:
 551                         info[i].value = talloc_strdup(info, "DISK");
 552                         break;
 553                 case 0x01:
 554                         info[i].value = talloc_strdup(info, "PRINTER");
 555                         break;
 556                 case 0x03:
 557                         info[i].value = talloc_strdup(info, "IPC");
 558                         break;
 559                 default:
 560                         return WERR_INVALID_PARAM;
 561                 }
 562                 W_ERROR_HAVE_NO_MEMORY(info[i].value);
 563                 i++;
 564
 565                 if (r->in.info->info502->path && r->in.info->info502->path[0]) {
 566                         info[i].name = SHARE_PATH;
 567                         info[i].type = SHARE_INFO_STRING;
 568
 569                         /* Windows will send a path in a form of C:\example\path */
 570                         if (r->in.info->info502->path[1] == ':') {
 571                                 info[i].value = talloc_strdup(info, &r->in.info->info502->path[2]);
 572                         } else {
 573                                 /* very strange let's try to set as is */
 574                                 info[i].value = talloc_strdup(info, r->in.info->info502->path);
 575                         }
 576                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 577                         all_string_sub((char *)info[i].value, "\\", "/", 0);
 578
 579                         i++;
 580                 }
 581
 582                 if (r->in.info->info502->comment && r->in.info->info502->comment[0]) {
 583                         info[i].name = SHARE_COMMENT;
 584                         info[i].type = SHARE_INFO_STRING;
 585                         info[i].value = talloc_strdup(info, r->in.info->info502->comment);
 586                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 587
 588                         i++;
 589                 }
 590
 591                 if (r->in.info->info502->password && r->in.info->info502->password[0]) {
 592                         info[i].name = SHARE_PASSWORD;
 593                         info[i].type = SHARE_INFO_STRING;
 594                         info[i].value = talloc_strdup(info, r->in.info->info502->password);
 595                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
 596
 597                         i++;
 598                 }
 599
 600                 info[i].name = SHARE_MAX_CONNECTIONS;
 601                 info[i].type = SHARE_INFO_INT;
 602                 info[i].value = talloc(info, int);
 603                 *((int *)info[i].value) = r->in.info->info502->max_users;
 604                 i++;
 605
 606                 /* TODO: security descriptor */
 607
 608                 nterr = share_create(sctx, r->in.info->info502->name, info, i);
 609                 if (!NT_STATUS_IS_OK(nterr)) {
 610                         return ntstatus_to_werror(nterr);
 611                 }
 612
 613                 if (r->in.parm_error) {
 614                         r->out.parm_error = r->in.parm_error;
 615                 }
 616
 617                 return WERR_OK;
 618         }
 619         default:
 620                 return WERR_UNKNOWN_LEVEL;
 621         }
 622
 623         return WERR_UNKNOWN_LEVEL;
 624 }
 625
 626 static WERROR dcesrv_srvsvc_fiel_ShareInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 627                                     struct share_config *scfg, uint32_t level,
 628                                     union srvsvc_NetShareInfo *info)
 629 {
 630         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
 631
 632         switch (level) {
 633         case 0:
 634         {
 635                 info->info0->name       = talloc_strdup(mem_ctx, scfg->name);
 636                 W_ERROR_HAVE_NO_MEMORY(info->info0->name);
 637
 638                 return WERR_OK;
 639         }
 640         case 1:
 641         {
 642                 info->info1->name       = talloc_strdup(mem_ctx, scfg->name);
 643                 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
 644                 info->info1->type       = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 645                 info->info1->comment    = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 646                 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
 647
 648                 return WERR_OK;
 649         }
 650         case 2:
 651         {
 652                 info->info2->name               = talloc_strdup(mem_ctx, scfg->name);
 653                 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
 654                 info->info2->type               = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 655                 info->info2->comment            = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 656                 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
 657                 info->info2->permissions        = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 658                 info->info2->max_users          = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 659                 info->info2->current_users      = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 660                 info->info2->path               = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 661                 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
 662                 info->info2->password           = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 663
 664                 return WERR_OK;
 665         }
 666         case 501:
 667         {
 668                 info->info501->name             = talloc_strdup(mem_ctx, scfg->name);
 669                 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
 670                 info->info501->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 671                 info->info501->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 672                 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
 673                 info->info501->csc_policy       = share_int_option(scfg, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT);
 674
 675                 return WERR_OK;
 676         }
 677         case 502:
 678         {
 679                 info->info502->name             = talloc_strdup(mem_ctx, scfg->name);
 680                 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
 681                 info->info502->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
 682                 info->info502->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
 683                 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
 684                 info->info502->permissions      = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 685                 info->info502->max_users        = share_int_option(scfg, SHARE_MAX_CONNECTIONS, SHARE_MAX_CONNECTIONS_DEFAULT);
 686                 info->info502->current_users    = dcesrv_common_get_share_current_users(mem_ctx, dce_ctx, scfg);
 687                 info->info502->path             = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
 688                 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
 689                 info->info502->password         = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
 690                 info->info502->sd_buf.sd        = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, scfg);
 691
 692                 return WERR_OK;
 693         }
 694         case 1005:
 695         {
 696                 info->info1005->dfs_flags       = dcesrv_common_get_share_dfs_flags(mem_ctx, dce_ctx, scfg);
 697
 698                 return WERR_OK;
 699         }
 700         default:
 701                 return WERR_UNKNOWN_LEVEL;
 702         }
 703
 704         return WERR_UNKNOWN_LEVEL;
 705 }
 706
 707 /*
 708   srvsvc_NetShareEnumAll
 709 */
 710 static WERROR dcesrv_srvsvc_NetShareEnumAll(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 711                                      struct srvsvc_NetShareEnumAll *r)
 712 {
 713         NTSTATUS nterr;
 714         int numshares = 0;
 715         const char **snames;
 716         struct share_context *sctx;
 717         struct share_config *scfg;
 718
 719         r->out.level = r->in.level;
 720         ZERO_STRUCT(r->out.ctr);
 721         r->out.totalentries = 0;
 722         r->out.resume_handle = NULL;
 723
 724         /* TODO: - paging of results
 725          */
 726
 727         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
 728         if (!NT_STATUS_IS_OK(nterr)) {
 729                 return ntstatus_to_werror(nterr);
 730         }
 731
 732         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
 733         if (!NT_STATUS_IS_OK(nterr)) {
 734                 return ntstatus_to_werror(nterr);
 735         }
 736
 737         switch (r->in.level) {
 738         case 0:
 739         {
 740                 int i;
 741                 struct srvsvc_NetShareCtr0 *ctr0;
 742
 743                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
 744                 W_ERROR_HAVE_NO_MEMORY(ctr0);
 745
 746                 ctr0->count = numshares;
 747                 ctr0->array = NULL;
 748
 749                 if (ctr0->count == 0) {
 750                         r->out.ctr.ctr0 = ctr0;
 751                         return WERR_OK;
 752                 }
 753
 754                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
 755                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
 756
 757                 for (i = 0; i < ctr0->count; i++) {
 758                         WERROR status;
 759                         union srvsvc_NetShareInfo info;
 760
 761                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 762                         if (!NT_STATUS_IS_OK(nterr)) {
 763                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 764                                 return WERR_GENERAL_FAILURE;
 765                         }
 766                         info.info0 = &ctr0->array[i];
 767                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 768                         if (!W_ERROR_IS_OK(status)) {
 769                                 return status;
 770                         }
 771                         talloc_free(scfg);
 772                 }
 773                 talloc_free(snames);
 774
 775                 r->out.ctr.ctr0         = ctr0;
 776                 r->out.totalentries     = r->out.ctr.ctr0->count;
 777                 return WERR_OK;
 778         }
 779         case 1:
 780         {
 781                 int i;
 782                 struct srvsvc_NetShareCtr1 *ctr1;
 783
 784                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
 785                 W_ERROR_HAVE_NO_MEMORY(ctr1);
 786
 787                 ctr1->count = numshares;
 788                 ctr1->array = NULL;
 789
 790                 if (ctr1->count == 0) {
 791                         r->out.ctr.ctr1 = ctr1;
 792                         return WERR_OK;
 793                 }
 794
 795                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
 796                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
 797
 798                 for (i=0; i < ctr1->count; i++) {
 799                         WERROR status;
 800                         union srvsvc_NetShareInfo info;
 801
 802                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 803                         if (!NT_STATUS_IS_OK(nterr)) {
 804                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 805                                 return WERR_GENERAL_FAILURE;
 806                         }
 807                         info.info1 = &ctr1->array[i];
 808                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 809                         if (!W_ERROR_IS_OK(status)) {
 810                                 return status;
 811                         }
 812                         talloc_free(scfg);
 813                 }
 814                 talloc_free(snames);
 815
 816                 r->out.ctr.ctr1         = ctr1;
 817                 r->out.totalentries     = r->out.ctr.ctr1->count;
 818                 return WERR_OK;
 819         }
 820         case 2:
 821         {
 822                 int i;
 823                 struct srvsvc_NetShareCtr2 *ctr2;
 824
 825                 SRVSVC_CHECK_ADMIN_ACCESS;
 826
 827                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
 828                 W_ERROR_HAVE_NO_MEMORY(ctr2);
 829
 830                 ctr2->count = numshares;
 831                 ctr2->array = NULL;
 832
 833                 if (ctr2->count == 0) {
 834                         r->out.ctr.ctr2 = ctr2;
 835                         return WERR_OK;
 836                 }
 837
 838                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
 839                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
 840
 841                 for (i=0; i < ctr2->count; i++) {
 842                         WERROR status;
 843                         union srvsvc_NetShareInfo info;
 844
 845                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 846                         if (!NT_STATUS_IS_OK(nterr)) {
 847                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 848                                 return WERR_GENERAL_FAILURE;
 849                         }
 850                         info.info2 = &ctr2->array[i];
 851                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 852                         if (!W_ERROR_IS_OK(status)) {
 853                                 return status;
 854                         }
 855                         talloc_free(scfg);
 856                 }
 857                 talloc_free(snames);
 858
 859                 r->out.ctr.ctr2         = ctr2;
 860                 r->out.totalentries     = r->out.ctr.ctr2->count;
 861                 return WERR_OK;
 862         }
 863         case 501:
 864         {
 865                 int i;
 866                 struct srvsvc_NetShareCtr501 *ctr501;
 867
 868                 SRVSVC_CHECK_ADMIN_ACCESS;
 869
 870                 ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
 871                 W_ERROR_HAVE_NO_MEMORY(ctr501);
 872
 873                 ctr501->count = numshares;
 874                 ctr501->array = NULL;
 875
 876                 if (ctr501->count == 0) {
 877                         r->out.ctr.ctr501 = ctr501;
 878                         return WERR_OK;
 879                 }
 880
 881                 ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
 882                 W_ERROR_HAVE_NO_MEMORY(ctr501->array);
 883
 884                 for (i=0; i < ctr501->count; i++) {
 885                         WERROR status;
 886                         union srvsvc_NetShareInfo info;
 887
 888                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 889                         if (!NT_STATUS_IS_OK(nterr)) {
 890                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 891                                 return WERR_GENERAL_FAILURE;
 892                         }
 893                         info.info501 = &ctr501->array[i];
 894                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 895                         if (!W_ERROR_IS_OK(status)) {
 896                                 return status;
 897                         }
 898                         talloc_free(scfg);
 899                 }
 900                 talloc_free(snames);
 901
 902                 r->out.ctr.ctr501       = ctr501;
 903                 r->out.totalentries     = r->out.ctr.ctr501->count;
 904                 return WERR_OK;
 905         }
 906         case 502:
 907         {
 908                 int i;
 909                 struct srvsvc_NetShareCtr502 *ctr502;
 910
 911                 SRVSVC_CHECK_ADMIN_ACCESS;
 912
 913                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
 914                 W_ERROR_HAVE_NO_MEMORY(ctr502);
 915
 916                 ctr502->count = numshares;
 917                 ctr502->array = NULL;
 918
 919                 if (ctr502->count == 0) {
 920                         r->out.ctr.ctr502 = ctr502;
 921                         return WERR_OK;
 922                 }
 923
 924                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
 925                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
 926
 927                 for (i=0; i < ctr502->count; i++) {
 928                         WERROR status;
 929                         union srvsvc_NetShareInfo info;
 930
 931                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
 932                         if (!NT_STATUS_IS_OK(nterr)) {
 933                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
 934                                 return WERR_GENERAL_FAILURE;
 935                         }
 936                         info.info502 = &ctr502->array[i];
 937                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 938                         if (!W_ERROR_IS_OK(status)) {
 939                                 return status;
 940                         }
 941                         talloc_free(scfg);
 942                 }
 943                 talloc_free(snames);
 944
 945                 r->out.ctr.ctr502       = ctr502;
 946                 r->out.totalentries     = r->out.ctr.ctr502->count;
 947                 return WERR_OK;
 948         }
 949         default:
 950                 return WERR_UNKNOWN_LEVEL;
 951         }
 952
 953         return WERR_UNKNOWN_LEVEL;
 954 }
 955
 956
 957 /*
 958   srvsvc_NetShareGetInfo
 959 */
 960 static WERROR dcesrv_srvsvc_NetShareGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 961                                      struct srvsvc_NetShareGetInfo *r)
 962 {
 963         NTSTATUS nterr;
 964         struct share_context *sctx = NULL;
 965         struct share_config *scfg = NULL;
 966
 967         ZERO_STRUCTP(r->out.info);
 968
 969         /* TODO: - access check
 970          */
 971
 972         if (strcmp("", r->in.share_name) == 0) {
 973                 return WERR_INVALID_PARAM;
 974         }
 975
 976         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
 977         if (!NT_STATUS_IS_OK(nterr)) {
 978                 return ntstatus_to_werror(nterr);
 979         }
 980
 981         nterr = share_get_config(mem_ctx, sctx, r->in.share_name, &scfg);
 982         if (!NT_STATUS_IS_OK(nterr)) {
 983                 return ntstatus_to_werror(nterr);
 984         }
 985
 986         switch (r->in.level) {
 987         case 0:
 988         {
 989                 WERROR status;
 990                 union srvsvc_NetShareInfo info;
 991
 992                 info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
 993                 W_ERROR_HAVE_NO_MEMORY(info.info0);
 994
 995                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
 996                 if (!W_ERROR_IS_OK(status)) {
 997                         return status;
 998                 }
 999
1000                 r->out.info->info0 = info.info0;
1001                 return WERR_OK;
1002         }
1003         case 1:
1004         {
1005                 WERROR status;
1006                 union srvsvc_NetShareInfo info;
1007
1008                 info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
1009                 W_ERROR_HAVE_NO_MEMORY(info.info1);
1010
1011                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1012                 if (!W_ERROR_IS_OK(status)) {
1013                         return status;
1014                 }
1015
1016                 r->out.info->info1 = info.info1;
1017                 return WERR_OK;
1018         }
1019         case 2:
1020         {
1021                 WERROR status;
1022                 union srvsvc_NetShareInfo info;
1023
1024                 SRVSVC_CHECK_ADMIN_ACCESS;
1025
1026                 info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
1027                 W_ERROR_HAVE_NO_MEMORY(info.info2);
1028
1029                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1030                 if (!W_ERROR_IS_OK(status)) {
1031                         return status;
1032                 }
1033
1034                 r->out.info->info2 = info.info2;
1035                 return WERR_OK;
1036         }
1037         case 501:
1038         {
1039                 WERROR status;
1040                 union srvsvc_NetShareInfo info;
1041
1042                 info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
1043                 W_ERROR_HAVE_NO_MEMORY(info.info501);
1044
1045                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1046                 if (!W_ERROR_IS_OK(status)) {
1047                         return status;
1048                 }
1049
1050                 r->out.info->info501 = info.info501;
1051                 return WERR_OK;
1052         }
1053         case 502:
1054         {
1055                 WERROR status;
1056                 union srvsvc_NetShareInfo info;
1057
1058                 SRVSVC_CHECK_ADMIN_ACCESS;
1059
1060                 info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
1061                 W_ERROR_HAVE_NO_MEMORY(info.info502);
1062
1063                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1064                 if (!W_ERROR_IS_OK(status)) {
1065                         return status;
1066                 }
1067
1068                 r->out.info->info502 = info.info502;
1069                 return WERR_OK;
1070         }
1071         case 1005:
1072         {
1073                 WERROR status;
1074                 union srvsvc_NetShareInfo info;
1075
1076                 info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
1077                 W_ERROR_HAVE_NO_MEMORY(info.info1005);
1078
1079                 status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1080                 if (!W_ERROR_IS_OK(status)) {
1081                         return status;
1082                 }
1083
1084                 r->out.info->info1005 = info.info1005;
1085                 return WERR_OK;
1086         }
1087         default:
1088                 return WERR_UNKNOWN_LEVEL;
1089         }
1090
1091         return WERR_UNKNOWN_LEVEL;
1092 }
1093
1094 static WERROR dcesrv_srvsvc_fill_share_info(struct share_info *info, int *count,
1095                                         const char *share_name, int level,
1096                                         const char *name,
1097                                         const char *path,
1098                                         const char *comment,
1099                                         const char *password,
1100                                         enum srvsvc_ShareType type,
1101                                         int32_t max_users,
1102                                         uint32_t csc_policy,
1103                                         struct security_descriptor *sd)
1104 {
1105         int i = 0;
1106
1107         if (level == 501) {
1108                 info[i].name = SHARE_CSC_POLICY;
1109                 info[i].type = SHARE_INFO_INT;
1110                 info[i].value = talloc(info, int);
1111                 *((int *)info[i].value) = csc_policy;
1112                 i++;
1113         }
1114
1115         switch(level) {
1116
1117         case 502:
1118                 /* TODO: check if unknown is csc_policy */
1119
1120                 /* TODO: security descriptor */
1121
1122         case 2:
1123                 if (path && path[0]) {
1124                         info[i].name = SHARE_PATH;
1125                         info[i].type = SHARE_INFO_STRING;
1126
1127                         /* Windows will send a path in a form of C:\example\path */
1128                         if (path[1] == ':') {
1129                                 info[i].value = talloc_strdup(info, &path[2]);
1130                         } else {
1131                                 /* very strange let's try to set as is */
1132                                 info[i].value = talloc_strdup(info, path);
1133                         }
1134                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
1135                         all_string_sub((char *)info[i].value, "\\", "/", 0);
1136
1137                         i++;
1138                 }
1139
1140                 if (password && password[0]) {
1141                         info[i].name = SHARE_PASSWORD;
1142                         info[i].type = SHARE_INFO_STRING;
1143                         info[i].value = talloc_strdup(info, password);
1144                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
1145
1146                         i++;
1147                 }
1148
1149                 info[i].name = SHARE_MAX_CONNECTIONS;
1150                 info[i].type = SHARE_INFO_INT;
1151                 info[i].value = talloc(info, int);
1152                 *((int *)info[i].value) = max_users;
1153                 i++;
1154
1155         case 501:
1156         case 1:
1157                 info[i].name = SHARE_TYPE;
1158                 info[i].type = SHARE_INFO_STRING;
1159                 switch (type) {
1160                 case 0x00:
1161                         info[i].value = talloc_strdup(info, "DISK");
1162                         break;
1163                 case 0x01:
1164                         info[i].value = talloc_strdup(info, "PRINTER");
1165                         break;
1166                 case 0x03:
1167                         info[i].value = talloc_strdup(info, "IPC");
1168                         break;
1169                 default:
1170                         return WERR_INVALID_PARAM;
1171                 }
1172                 W_ERROR_HAVE_NO_MEMORY(info[i].value);
1173                 i++;
1174
1175         case 1004:
1176                 if (comment) {
1177                         info[i].name = SHARE_COMMENT;
1178                         info[i].type = SHARE_INFO_STRING;
1179                         info[i].value = talloc_strdup(info, comment);
1180                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
1181
1182                         i++;
1183                 }
1184         case 0:
1185                 if (name &&
1186                     strcasecmp(share_name, name) != 0) {
1187                         info[i].name = SHARE_NAME;
1188                         info[i].type = SHARE_INFO_STRING;
1189                         info[i].value = talloc_strdup(info, name);
1190                         W_ERROR_HAVE_NO_MEMORY(info[i].value);
1191                         i++;
1192                 }
1193
1194                 break;
1195
1196         default:
1197                 return WERR_UNKNOWN_LEVEL;
1198         }
1199
1200         *count = i;
1201
1202         return WERR_OK;
1203 }
1204
1205 /*
1206   srvsvc_NetShareSetInfo
1207 */
1208 static WERROR dcesrv_srvsvc_NetShareSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1209                        struct srvsvc_NetShareSetInfo *r)
1210 {
1211         NTSTATUS nterr;
1212         WERROR status;
1213         struct share_context *sctx = NULL;
1214         struct share_info *info;
1215         int count;
1216
1217         /* TODO: - access check
1218          */
1219
1220         /* there are no more than 10 options in all struct srvsvc_NetShareInfoXXX */
1221         info = talloc_array(mem_ctx, struct share_info, 10);
1222         W_ERROR_HAVE_NO_MEMORY(info);
1223
1224         ZERO_STRUCT(r->out);
1225
1226         if (strcmp("", r->in.share_name) == 0) {
1227                 return WERR_INVALID_PARAM;
1228         }
1229
1230         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1231         if (!NT_STATUS_IS_OK(nterr)) {
1232                 return ntstatus_to_werror(nterr);
1233         }
1234
1235         switch (r->in.level) {
1236         case 0:
1237         {
1238                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1239                                         r->in.share_name, r->in.level,
1240                                         r->in.info->info0->name,
1241                                         NULL,
1242                                         NULL,
1243                                         NULL,
1244                                         0,
1245                                         0,
1246                                         0,
1247                                         NULL);
1248                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1249                         return status;
1250                 }
1251                 break;
1252         }
1253         case 1:
1254         {
1255                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1256                                         r->in.share_name, r->in.level,
1257                                         r->in.info->info1->name,
1258                                         NULL,
1259                                         r->in.info->info1->comment,
1260                                         NULL,
1261                                         r->in.info->info1->type,
1262                                         0,
1263                                         0,
1264                                         NULL);
1265                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1266                         return status;
1267                 }
1268                 break;
1269         }
1270         case 2:
1271         {
1272                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1273                                         r->in.share_name, r->in.level,
1274                                         r->in.info->info2->name,
1275                                         r->in.info->info2->path,
1276                                         r->in.info->info2->comment,
1277                                         r->in.info->info2->password,
1278                                         r->in.info->info2->type,
1279                                         r->in.info->info2->max_users,
1280                                         0,
1281                                         NULL);
1282                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1283                         return status;
1284                 }
1285                 break;
1286         }
1287         case 501:
1288         {
1289                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1290                                         r->in.share_name, r->in.level,
1291                                         r->in.info->info501->name,
1292                                         NULL,
1293                                         r->in.info->info501->comment,
1294                                         NULL,
1295                                         r->in.info->info501->type,
1296                                         0,
1297                                         r->in.info->info501->csc_policy,
1298                                         NULL);
1299                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1300                         return status;
1301                 }
1302                 break;
1303         }
1304         case 502:
1305         {
1306                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1307                                         r->in.share_name, r->in.level,
1308                                         r->in.info->info502->name,
1309                                         r->in.info->info502->path,
1310                                         r->in.info->info502->comment,
1311                                         r->in.info->info502->password,
1312                                         r->in.info->info502->type,
1313                                         r->in.info->info502->max_users,
1314                                         0,
1315                                         r->in.info->info502->sd_buf.sd);
1316                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1317                         return status;
1318                 }
1319                 break;
1320         }
1321         case 1004:
1322         {
1323                 status = dcesrv_srvsvc_fill_share_info(info, &count,
1324                                         r->in.share_name, r->in.level,
1325                                         NULL,
1326                                         NULL,
1327                                         r->in.info->info1004->comment,
1328                                         NULL,
1329                                         0,
1330                                         0,
1331                                         0,
1332                                         NULL);
1333                 if (W_ERROR_EQUAL(status, WERR_OK)) {
1334                         return status;
1335                 }
1336                 break;
1337         }
1338         case 1005:
1339         {
1340                 /* r->in.info.dfs_flags; */
1341
1342                 if (r->in.parm_error) {
1343                         r->out.parm_error = r->in.parm_error;
1344                 }
1345
1346                 return WERR_OK;
1347         }
1348         default:
1349                 return WERR_UNKNOWN_LEVEL;
1350         }
1351
1352         nterr = share_set(sctx, r->in.share_name, info, count);
1353         if (!NT_STATUS_IS_OK(nterr)) {
1354                 return ntstatus_to_werror(nterr);
1355         }
1356
1357         if (r->in.parm_error) {
1358                 r->out.parm_error = r->in.parm_error;
1359         }
1360
1361         return WERR_OK;
1362 }
1363
1364
1365 /*
1366   srvsvc_NetShareDelSticky
1367 */
1368 static WERROR dcesrv_srvsvc_NetShareDelSticky(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1369                        struct srvsvc_NetShareDelSticky *r)
1370 {
1371         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1372 }
1373
1374
1375 /*
1376   srvsvc_NetShareCheck
1377 */
1378 static WERROR dcesrv_srvsvc_NetShareCheck(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1379                        struct srvsvc_NetShareCheck *r)
1380 {
1381         NTSTATUS nterr;
1382         struct share_context *sctx = NULL;
1383         struct share_config *scfg = NULL;
1384         char *device;
1385         const char **names;
1386         int count, i;
1387
1388         *r->out.type = 0;
1389
1390         /* TODO: - access check
1391          */
1392
1393         if (strcmp("", r->in.device_name) == 0) {
1394                 *r->out.type = STYPE_IPC;
1395                 return WERR_OK;
1396         }
1397
1398         /* copy the path skipping C:\ */
1399         if (strncasecmp(r->in.device_name, "C:", 2) == 0) {
1400                 device = talloc_strdup(mem_ctx, &r->in.device_name[2]);
1401         } else {
1402                 /* no chance we have a share that doesn't start with C:\ */
1403                 return WERR_DEVICE_NOT_SHARED;
1404         }
1405         all_string_sub(device, "\\", "/", 0);
1406
1407         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1408         if (!NT_STATUS_IS_OK(nterr)) {
1409                 return ntstatus_to_werror(nterr);
1410         }
1411
1412         nterr = share_list_all(mem_ctx, sctx, &count, &names);
1413         if (!NT_STATUS_IS_OK(nterr)) {
1414                 return ntstatus_to_werror(nterr);
1415         }
1416
1417         for (i = 0; i < count; i++) {
1418                 const char *path;
1419                 const char *type;
1420
1421                 nterr = share_get_config(mem_ctx, sctx, names[i], &scfg);
1422                 if (!NT_STATUS_IS_OK(nterr)) {
1423                         return ntstatus_to_werror(nterr);
1424                 }
1425                 path = share_string_option(scfg, SHARE_PATH, NULL);
1426                 if (!path) continue;
1427
1428                 if (strcmp(device, path) == 0) {
1429                         type = share_string_option(scfg, SHARE_TYPE, NULL);
1430                         if (!type) continue;
1431
1432                         if (strcmp(type, "DISK") == 0) {
1433                                 *r->out.type = STYPE_DISKTREE;
1434                                 return WERR_OK;
1435                         }
1436
1437                         if (strcmp(type, "IPC") == 0) {
1438                                 *r->out.type = STYPE_IPC;
1439                                 return WERR_OK;
1440                         }
1441
1442                         if (strcmp(type, "PRINTER") == 0) {
1443                                 *r->out.type = STYPE_PRINTQ;
1444                                 return WERR_OK;
1445                         }
1446                 }
1447         }
1448
1449         return WERR_DEVICE_NOT_SHARED;
1450 }
1451
1452
1453 /*
1454   srvsvc_NetSrvGetInfo
1455 */
1456 static WERROR dcesrv_srvsvc_NetSrvGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1457                        struct srvsvc_NetSrvGetInfo *r)
1458 {
1459         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1460
1461         ZERO_STRUCTP(r->out.info);
1462
1463         switch (r->in.level) {
1464         case 100:
1465         {
1466                 struct srvsvc_NetSrvInfo100 *info100;
1467
1468                 info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
1469                 W_ERROR_HAVE_NO_MEMORY(info100);
1470
1471                 info100->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1472                 info100->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1473                 W_ERROR_HAVE_NO_MEMORY(info100->server_name);
1474
1475                 r->out.info->info100 = info100;
1476                 return WERR_OK;
1477         }
1478         case 101:
1479         {
1480                 struct srvsvc_NetSrvInfo101 *info101;
1481
1482                 info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
1483                 W_ERROR_HAVE_NO_MEMORY(info101);
1484
1485                 info101->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1486                 info101->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1487                 W_ERROR_HAVE_NO_MEMORY(info101->server_name);
1488
1489                 info101->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx->lp_ctx);
1490                 info101->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx->lp_ctx);
1491                 info101->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
1492                 info101->comment        = talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
1493                 W_ERROR_HAVE_NO_MEMORY(info101->comment);
1494
1495                 r->out.info->info101 = info101;
1496                 return WERR_OK;
1497         }
1498         case 102:
1499         {
1500                 struct srvsvc_NetSrvInfo102 *info102;
1501
1502                 info102 = talloc(mem_ctx, struct srvsvc_NetSrvInfo102);
1503                 W_ERROR_HAVE_NO_MEMORY(info102);
1504
1505                 info102->platform_id    = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
1506                 info102->server_name    = dcesrv_common_get_server_name(mem_ctx, dce_ctx, r->in.server_unc);
1507                 W_ERROR_HAVE_NO_MEMORY(info102->server_name);
1508
1509                 info102->version_major  = dcesrv_common_get_version_major(mem_ctx, dce_ctx->lp_ctx);
1510                 info102->version_minor  = dcesrv_common_get_version_minor(mem_ctx, dce_ctx->lp_ctx);
1511                 info102->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
1512                 info102->comment        = talloc_strdup(mem_ctx, lp_serverstring(dce_ctx->lp_ctx));
1513                 W_ERROR_HAVE_NO_MEMORY(info102->comment);
1514
1515                 info102->users          = dcesrv_common_get_users(mem_ctx, dce_ctx);
1516                 info102->disc           = dcesrv_common_get_disc(mem_ctx, dce_ctx);
1517                 info102->hidden         = dcesrv_common_get_hidden(mem_ctx, dce_ctx);
1518                 info102->announce       = dcesrv_common_get_announce(mem_ctx, dce_ctx);
1519                 info102->anndelta       = dcesrv_common_get_anndelta(mem_ctx, dce_ctx);
1520                 info102->licenses       = dcesrv_common_get_licenses(mem_ctx, dce_ctx);
1521                 info102->userpath       = dcesrv_common_get_userpath(mem_ctx, dce_ctx);
1522                 W_ERROR_HAVE_NO_MEMORY(info102->userpath);
1523
1524                 r->out.info->info102 = info102;
1525                 return WERR_OK;
1526         }
1527         default:
1528                 return WERR_UNKNOWN_LEVEL;
1529         }
1530
1531         return WERR_UNKNOWN_LEVEL;
1532 }
1533
1534
1535 /*
1536   srvsvc_NetSrvSetInfo
1537 */
1538 static WERROR dcesrv_srvsvc_NetSrvSetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1539                        struct srvsvc_NetSrvSetInfo *r)
1540 {
1541         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1542 }
1543
1544
1545 /*
1546   srvsvc_NetDiskEnum
1547 */
1548 static WERROR dcesrv_srvsvc_NetDiskEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1549                        struct srvsvc_NetDiskEnum *r)
1550 {
1551         r->out.info->disks = NULL;
1552         r->out.info->count = 0;
1553         *r->out.totalentries = 0;
1554
1555         switch (r->in.level) {
1556         case 0:
1557         {
1558                 /* we can safely hardcode the reply and report we have only one disk (C:) */
1559                 /* for some reason Windows wants 2 entries with the second being empty */
1560                 r->out.info->disks = talloc_array(mem_ctx, struct srvsvc_NetDiskInfo0, 2);
1561                 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks);
1562                 r->out.info->count = 2;
1563
1564                 r->out.info->disks[0].disk = talloc_strdup(mem_ctx, "C:");
1565                 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[0].disk);
1566
1567                 r->out.info->disks[1].disk = talloc_strdup(mem_ctx, "");
1568                 W_ERROR_HAVE_NO_MEMORY(r->out.info->disks[1].disk);
1569
1570                 *r->out.totalentries = 1;
1571                 r->out.resume_handle = r->in.resume_handle;
1572
1573                 return WERR_OK;
1574         }
1575         default:
1576                 return WERR_UNKNOWN_LEVEL;
1577         }
1578
1579         return WERR_UNKNOWN_LEVEL;
1580 }
1581
1582
1583 /*
1584   srvsvc_NetServerStatisticsGet
1585 */
1586 static WERROR dcesrv_srvsvc_NetServerStatisticsGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1587                        struct srvsvc_NetServerStatisticsGet *r)
1588 {
1589         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1590 }
1591
1592
1593 /*
1594   srvsvc_NetTransportAdd
1595 */
1596 static WERROR dcesrv_srvsvc_NetTransportAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1597                        struct srvsvc_NetTransportAdd *r)
1598 {
1599         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1600 }
1601
1602
1603 /*
1604   srvsvc_NetTransportEnum
1605 */
1606 static WERROR dcesrv_srvsvc_NetTransportEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1607                        struct srvsvc_NetTransportEnum *r)
1608 {
1609         r->out.transports->level = r->in.transports->level;
1610         *r->out.totalentries = 0;
1611         if (r->out.resume_handle) {
1612                 *r->out.resume_handle = 0;
1613         }
1614
1615         switch (r->in.transports->level) {
1616         case 0:
1617         {
1618                 r->out.transports->ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
1619                 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr0);
1620
1621                 r->out.transports->ctr.ctr0->count = 0;
1622                 r->out.transports->ctr.ctr0->array = NULL;
1623
1624                 return WERR_NOT_SUPPORTED;
1625         }
1626         case 1:
1627         {
1628                 r->out.transports->ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
1629                 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr1);
1630
1631                 r->out.transports->ctr.ctr1->count = 0;
1632                 r->out.transports->ctr.ctr1->array = NULL;
1633
1634                 return WERR_NOT_SUPPORTED;
1635         }
1636         case 2:
1637         {
1638                 r->out.transports->ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
1639                 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr2);
1640
1641                 r->out.transports->ctr.ctr2->count = 0;
1642                 r->out.transports->ctr.ctr2->array = NULL;
1643
1644                 return WERR_NOT_SUPPORTED;
1645         }
1646         case 3:
1647         {
1648                 r->out.transports->ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
1649                 W_ERROR_HAVE_NO_MEMORY(r->out.transports->ctr.ctr3);
1650
1651                 r->out.transports->ctr.ctr3->count = 0;
1652                 r->out.transports->ctr.ctr3->array = NULL;
1653
1654                 return WERR_NOT_SUPPORTED;
1655         }
1656         default:
1657                 return WERR_UNKNOWN_LEVEL;
1658         }
1659
1660         return WERR_UNKNOWN_LEVEL;
1661 }
1662
1663 /*
1664   srvsvc_NetTransportDel
1665 */
1666 static WERROR dcesrv_srvsvc_NetTransportDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1667                        struct srvsvc_NetTransportDel *r)
1668 {
1669         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1670 }
1671
1672
1673 /*
1674   srvsvc_NetRemoteTOD
1675 */
1676 static WERROR dcesrv_srvsvc_NetRemoteTOD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1677                        struct srvsvc_NetRemoteTOD *r)
1678 {
1679         struct timeval tval;
1680         time_t t;
1681         struct tm tm;
1682         struct srvsvc_NetRemoteTODInfo *info;
1683
1684         info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
1685         W_ERROR_HAVE_NO_MEMORY(info);
1686
1687         GetTimeOfDay(&tval);
1688         t = tval.tv_sec;
1689
1690         gmtime_r(&t, &tm);
1691
1692         info->elapsed   = t;
1693         /* TODO: fake the uptime: just return the milliseconds till 0:00:00 today */
1694         info->msecs     = (tm.tm_hour*60*60*1000)
1695                         + (tm.tm_min*60*1000)
1696                         + (tm.tm_sec*1000)
1697                         + (tval.tv_usec/1000);
1698         info->hours     = tm.tm_hour;
1699         info->mins      = tm.tm_min;
1700         info->secs      = tm.tm_sec;
1701         info->hunds     = tval.tv_usec/10000;
1702         info->timezone  = get_time_zone(t)/60;
1703         info->tinterval = 310; /* just return the same as windows */
1704         info->day       = tm.tm_mday;
1705         info->month     = tm.tm_mon + 1;
1706         info->year      = tm.tm_year + 1900;
1707         info->weekday   = tm.tm_wday;
1708
1709         *r->out.info = info;
1710
1711         return WERR_OK;
1712 }
1713
1714 /*
1715   srvsvc_NetPathType
1716 */
1717 static WERROR dcesrv_srvsvc_NetPathType(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1718                        struct srvsvc_NetPathType *r)
1719 {
1720         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1721 }
1722
1723
1724 /*
1725   srvsvc_NetPathCanonicalize
1726 */
1727 static WERROR dcesrv_srvsvc_NetPathCanonicalize(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1728                        struct srvsvc_NetPathCanonicalize *r)
1729 {
1730         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1731 }
1732
1733
1734 /*
1735   srvsvc_NetPathCompare
1736 */
1737 static WERROR dcesrv_srvsvc_NetPathCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1738                        struct srvsvc_NetPathCompare *r)
1739 {
1740         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1741 }
1742
1743
1744 /*
1745   srvsvc_NetNameValidate
1746 */
1747 static WERROR dcesrv_srvsvc_NetNameValidate(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1748                        struct srvsvc_NetNameValidate *r)
1749 {
1750         int len;
1751
1752         if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
1753                 return WERR_INVALID_NAME;
1754         }
1755
1756         switch (r->in.name_type) {
1757         case 1:
1758         case 2:
1759         case 3:
1760         case 4:
1761         case 5:
1762         case 6:
1763         case 7:
1764         case 8:
1765                 return WERR_NOT_SUPPORTED;
1766
1767         case 9: /* validate share name */
1768
1769                 len = strlen_m(r->in.name);
1770                 if ((r->in.flags == 0x0) && (len > 81)) {
1771                         return WERR_INVALID_NAME;
1772                 }
1773                 if ((r->in.flags == 0x80000000) && (len > 13)) {
1774                         return WERR_INVALID_NAME;
1775                 }
1776                 if (! dcesrv_common_validate_share_name(mem_ctx, r->in.name)) {
1777                         return WERR_INVALID_NAME;
1778                 }
1779                 return WERR_OK;
1780
1781         case 10:
1782         case 11:
1783         case 12:
1784         case 13:
1785                 return WERR_NOT_SUPPORTED;
1786         default:
1787                 return WERR_INVALID_PARAM;
1788         }
1789
1790         return WERR_INVALID_PARAM;
1791 }
1792
1793
1794 /*
1795   srvsvc_NetPRNameCompare
1796 */
1797 static WERROR dcesrv_srvsvc_NetPRNameCompare(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1798                        struct srvsvc_NetPRNameCompare *r)
1799 {
1800         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1801 }
1802
1803
1804 /*
1805   srvsvc_NetShareEnum
1806 */
1807 static WERROR dcesrv_srvsvc_NetShareEnum(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1808                        struct srvsvc_NetShareEnum *r)
1809 {
1810         NTSTATUS nterr;
1811         int numshares = 0;
1812         const char **snames;
1813         struct share_context *sctx;
1814         struct share_config *scfg;
1815         struct dcesrv_context *dce_ctx = dce_call->conn->dce_ctx;
1816
1817         r->out.level = r->in.level;
1818         ZERO_STRUCT(r->out.ctr);
1819         r->out.totalentries = 0;
1820         r->out.resume_handle = NULL;
1821
1822         /* TODO: - paging of results
1823          */
1824
1825         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
1826         if (!NT_STATUS_IS_OK(nterr)) {
1827                 return ntstatus_to_werror(nterr);
1828         }
1829
1830         nterr = share_list_all(mem_ctx, sctx, &numshares, &snames);
1831         if (!NT_STATUS_IS_OK(nterr)) {
1832                 return ntstatus_to_werror(nterr);
1833         }
1834
1835         switch (r->in.level) {
1836         case 0:
1837         {
1838                 int i, y = 0;
1839                 int count;
1840                 struct srvsvc_NetShareCtr0 *ctr0;
1841
1842                 ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
1843                 W_ERROR_HAVE_NO_MEMORY(ctr0);
1844
1845                 count = numshares;
1846                 ctr0->count = count;
1847                 ctr0->array = NULL;
1848
1849                 if (ctr0->count == 0) {
1850                         r->out.ctr.ctr0 = ctr0;
1851                         return WERR_OK;
1852                 }
1853
1854                 ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, count);
1855                 W_ERROR_HAVE_NO_MEMORY(ctr0->array);
1856
1857                 for (i=0; i < count; i++) {
1858                         WERROR status;
1859                         union srvsvc_NetShareInfo info;
1860                         enum srvsvc_ShareType type;
1861
1862                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1863                         if (!NT_STATUS_IS_OK(nterr)) {
1864                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1865                                 return WERR_GENERAL_FAILURE;
1866                         }
1867
1868                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1869                         if (type & STYPE_HIDDEN) {
1870                                 ctr0->count--;
1871                                 talloc_free(scfg);
1872                                 continue;
1873                         }
1874
1875                         info.info0 = &ctr0->array[y];
1876                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1877                         W_ERROR_NOT_OK_RETURN(status);
1878                         talloc_free(scfg);
1879                         y++;
1880                 }
1881                 talloc_free(snames);
1882
1883                 r->out.ctr.ctr0         = ctr0;
1884                 r->out.totalentries     = r->out.ctr.ctr0->count;
1885                 return WERR_OK;
1886         }
1887         case 1:
1888         {
1889                 int i, y = 0;
1890                 int count;
1891                 struct srvsvc_NetShareCtr1 *ctr1;
1892
1893                 ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
1894                 W_ERROR_HAVE_NO_MEMORY(ctr1);
1895
1896                 count = numshares;
1897                 ctr1->count = count;
1898                 ctr1->array = NULL;
1899
1900                 if (ctr1->count == 0) {
1901                         r->out.ctr.ctr1 = ctr1;
1902                         return WERR_OK;
1903                 }
1904
1905                 ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, count);
1906                 W_ERROR_HAVE_NO_MEMORY(ctr1->array);
1907
1908                 for (i=0; i < count; i++) {
1909                         WERROR status;
1910                         union srvsvc_NetShareInfo info;
1911                         enum srvsvc_ShareType type;
1912
1913                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1914                         if (!NT_STATUS_IS_OK(nterr)) {
1915                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1916                                 return WERR_GENERAL_FAILURE;
1917                         }
1918
1919                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1920                         if (type & STYPE_HIDDEN) {
1921                                 ctr1->count--;
1922                                 talloc_free(scfg);
1923                                 continue;
1924                         }
1925
1926                         info.info1 = &ctr1->array[y];
1927                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1928                         W_ERROR_NOT_OK_RETURN(status);
1929                         talloc_free(scfg);
1930                         y++;
1931                 }
1932                 talloc_free(snames);
1933
1934                 r->out.ctr.ctr1         = ctr1;
1935                 r->out.totalentries     = r->out.ctr.ctr1->count;
1936                 return WERR_OK;
1937         }
1938         case 2:
1939         {
1940                 int i, y = 0;
1941                 int count;
1942                 struct srvsvc_NetShareCtr2 *ctr2;
1943
1944                 SRVSVC_CHECK_ADMIN_ACCESS;
1945
1946                 ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
1947                 W_ERROR_HAVE_NO_MEMORY(ctr2);
1948
1949                 count = numshares;
1950                 ctr2->count = count;
1951                 ctr2->array = NULL;
1952
1953                 if (ctr2->count == 0) {
1954                         r->out.ctr.ctr2 = ctr2;
1955                         return WERR_OK;
1956                 }
1957
1958                 ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, count);
1959                 W_ERROR_HAVE_NO_MEMORY(ctr2->array);
1960
1961                 for (i=0; i < count; i++) {
1962                         WERROR status;
1963                         union srvsvc_NetShareInfo info;
1964                         enum srvsvc_ShareType type;
1965
1966                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
1967                         if (!NT_STATUS_IS_OK(nterr)) {
1968                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
1969                                 return WERR_GENERAL_FAILURE;
1970                         }
1971
1972                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
1973                         if (type & STYPE_HIDDEN) {
1974                                 ctr2->count--;
1975                                 talloc_free(scfg);
1976                                 continue;
1977                         }
1978
1979                         info.info2 = &ctr2->array[y];
1980                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
1981                         W_ERROR_NOT_OK_RETURN(status);
1982                         talloc_free(scfg);
1983                         y++;
1984                 }
1985                 talloc_free(snames);
1986
1987                 r->out.ctr.ctr2         = ctr2;
1988                 r->out.totalentries     = r->out.ctr.ctr2->count;
1989                 return WERR_OK;
1990         }
1991         case 502:
1992         {
1993                 int i, y = 0;
1994                 int count;
1995                 struct srvsvc_NetShareCtr502 *ctr502;
1996
1997                 SRVSVC_CHECK_ADMIN_ACCESS;
1998
1999                 ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
2000                 W_ERROR_HAVE_NO_MEMORY(ctr502);
2001
2002                 count = numshares;
2003                 ctr502->count = count;
2004                 ctr502->array = NULL;
2005
2006                 if (ctr502->count == 0) {
2007                         r->out.ctr.ctr502 = ctr502;
2008                         return WERR_OK;
2009                 }
2010
2011                 ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, count);
2012                 W_ERROR_HAVE_NO_MEMORY(ctr502->array);
2013
2014                 for (i=0; i < count; i++) {
2015                         WERROR status;
2016                         union srvsvc_NetShareInfo info;
2017                         enum srvsvc_ShareType type;
2018
2019                         nterr = share_get_config(mem_ctx, sctx, snames[i], &scfg);
2020                         if (!NT_STATUS_IS_OK(nterr)) {
2021                                 DEBUG(1, ("ERROR: Service [%s] disappeared after enumeration", snames[i]));
2022                                 return WERR_GENERAL_FAILURE;
2023                         }
2024
2025                         type = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
2026                         if (type & STYPE_HIDDEN) {
2027                                 ctr502->count--;
2028                                 talloc_free(scfg);
2029                                 continue;
2030                         }
2031
2032                         info.info502 = &ctr502->array[y];
2033                         status = dcesrv_srvsvc_fiel_ShareInfo(dce_call, mem_ctx, scfg, r->in.level, &info);
2034                         W_ERROR_NOT_OK_RETURN(status);
2035                         talloc_free(scfg);
2036                         y++;
2037                 }
2038                 talloc_free(snames);
2039
2040                 r->out.ctr.ctr502       = ctr502;
2041                 r->out.totalentries     = r->out.ctr.ctr502->count;
2042                 return WERR_OK;
2043         }
2044         default:
2045                 return WERR_UNKNOWN_LEVEL;
2046         }
2047
2048         return WERR_UNKNOWN_LEVEL;
2049 }
2050
2051
2052 /*
2053   srvsvc_NetShareDelStart
2054 */
2055 static WERROR dcesrv_srvsvc_NetShareDelStart(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2056                        struct srvsvc_NetShareDelStart *r)
2057 {
2058         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2059 }
2060
2061
2062 /*
2063   srvsvc_NetShareDelCommit
2064 */
2065 static WERROR dcesrv_srvsvc_NetShareDelCommit(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2066                        struct srvsvc_NetShareDelCommit *r)
2067 {
2068         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2069 }
2070
2071
2072 /*
2073   srvsvc_NetGetFileSecurity
2074 */
2075 static WERROR dcesrv_srvsvc_NetGetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2076                        struct srvsvc_NetGetFileSecurity *r)
2077 {
2078         struct sec_desc_buf *sd_buf;
2079         struct ntvfs_context *ntvfs_ctx = NULL;
2080         struct ntvfs_request *ntvfs_req;
2081         union smb_fileinfo *io;
2082         NTSTATUS nt_status;
2083
2084         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
2085         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2086
2087         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
2088                                          dce_call->conn->auth_state.session_info,
2089                                          0,
2090                                          dce_call->time,
2091                                          NULL, NULL, 0);
2092         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
2093
2094         sd_buf = talloc(mem_ctx, struct sec_desc_buf);
2095         W_ERROR_HAVE_NO_MEMORY(sd_buf);
2096
2097         io = talloc(mem_ctx, union smb_fileinfo);
2098         W_ERROR_HAVE_NO_MEMORY(io);
2099
2100         io->query_secdesc.level                 = RAW_FILEINFO_SEC_DESC;
2101         io->query_secdesc.in.file.path          = r->in.file;
2102         io->query_secdesc.in.secinfo_flags      = r->in.securityinformation;
2103
2104         nt_status = ntvfs_qpathinfo(ntvfs_req, io);
2105         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2106
2107         sd_buf->sd = io->query_secdesc.out.sd;
2108
2109         *r->out.sd_buf = sd_buf;
2110         return WERR_OK;
2111 }
2112
2113
2114 /*
2115   srvsvc_NetSetFileSecurity
2116 */
2117 static WERROR dcesrv_srvsvc_NetSetFileSecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2118                        struct srvsvc_NetSetFileSecurity *r)
2119 {
2120         struct ntvfs_context *ntvfs_ctx;
2121         struct ntvfs_request *ntvfs_req;
2122         union smb_setfileinfo *io;
2123         NTSTATUS nt_status;
2124
2125         nt_status = srvsvc_create_ntvfs_context(dce_call, mem_ctx, r->in.share, &ntvfs_ctx);
2126         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2127
2128         ntvfs_req = ntvfs_request_create(ntvfs_ctx, mem_ctx,
2129                                          dce_call->conn->auth_state.session_info,
2130                                          0,
2131                                          dce_call->time,
2132                                          NULL, NULL, 0);
2133         W_ERROR_HAVE_NO_MEMORY(ntvfs_req);
2134
2135         io = talloc(mem_ctx, union smb_setfileinfo);
2136         W_ERROR_HAVE_NO_MEMORY(io);
2137
2138         io->set_secdesc.level                   = RAW_FILEINFO_SEC_DESC;
2139         io->set_secdesc.in.file.path            = r->in.file;
2140         io->set_secdesc.in.secinfo_flags        = r->in.securityinformation;
2141         io->set_secdesc.in.sd                   = r->in.sd_buf->sd;
2142
2143         nt_status = ntvfs_setpathinfo(ntvfs_req, io);
2144         if (!NT_STATUS_IS_OK(nt_status)) return ntstatus_to_werror(nt_status);
2145
2146         return WERR_OK;
2147 }
2148
2149
2150 /*
2151   srvsvc_NetServerTransportAddEx
2152 */
2153 static WERROR dcesrv_srvsvc_NetServerTransportAddEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2154                        struct srvsvc_NetServerTransportAddEx *r)
2155 {
2156         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2157 }
2158
2159
2160 /*
2161   srvsvc_NetServerSetServiceBitsEx
2162 */
2163 static WERROR dcesrv_srvsvc_NetServerSetServiceBitsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2164                        struct srvsvc_NetServerSetServiceBitsEx *r)
2165 {
2166         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2167 }
2168
2169
2170 /*
2171   srvsvc_NETRDFSGETVERSION
2172 */
2173 static WERROR dcesrv_srvsvc_NETRDFSGETVERSION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2174                        struct srvsvc_NETRDFSGETVERSION *r)
2175 {
2176         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2177 }
2178
2179
2180 /*
2181   srvsvc_NETRDFSCREATELOCALPARTITION
2182 */
2183 static WERROR dcesrv_srvsvc_NETRDFSCREATELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2184                        struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
2185 {
2186         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2187 }
2188
2189
2190 /*
2191   srvsvc_NETRDFSDELETELOCALPARTITION
2192 */
2193 static WERROR dcesrv_srvsvc_NETRDFSDELETELOCALPARTITION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2194                        struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
2195 {
2196         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2197 }
2198
2199
2200 /*
2201   srvsvc_NETRDFSSETLOCALVOLUMESTATE
2202 */
2203 static WERROR dcesrv_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2204                        struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r)
2205 {
2206         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2207 }
2208
2209
2210 /*
2211   srvsvc_NETRDFSSETSERVERINFO
2212 */
2213 static WERROR dcesrv_srvsvc_NETRDFSSETSERVERINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2214                        struct srvsvc_NETRDFSSETSERVERINFO *r)
2215 {
2216         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2217 }
2218
2219
2220 /*
2221   srvsvc_NETRDFSCREATEEXITPOINT
2222 */
2223 static WERROR dcesrv_srvsvc_NETRDFSCREATEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2224                        struct srvsvc_NETRDFSCREATEEXITPOINT *r)
2225 {
2226         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2227 }
2228
2229
2230 /*
2231   srvsvc_NETRDFSDELETEEXITPOINT
2232 */
2233 static WERROR dcesrv_srvsvc_NETRDFSDELETEEXITPOINT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2234                        struct srvsvc_NETRDFSDELETEEXITPOINT *r)
2235 {
2236         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2237 }
2238
2239
2240 /*
2241   srvsvc_NETRDFSMODIFYPREFIX
2242 */
2243 static WERROR dcesrv_srvsvc_NETRDFSMODIFYPREFIX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2244                        struct srvsvc_NETRDFSMODIFYPREFIX *r)
2245 {
2246         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2247 }
2248
2249
2250 /*
2251   srvsvc_NETRDFSFIXLOCALVOLUME
2252 */
2253 static WERROR dcesrv_srvsvc_NETRDFSFIXLOCALVOLUME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2254                        struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
2255 {
2256         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2257 }
2258
2259
2260 /*
2261   srvsvc_NETRDFSMANAGERREPORTSITEINFO
2262 */
2263 static WERROR dcesrv_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2264                        struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
2265 {
2266         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2267 }
2268
2269
2270 /*
2271   srvsvc_NETRSERVERTRANSPORTDELEX
2272 */
2273 static WERROR dcesrv_srvsvc_NETRSERVERTRANSPORTDELEX(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2274                        struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
2275 {
2276         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2277 }
2278
2279 /*
2280   srvsvc_NetShareDel
2281 */
2282 static WERROR dcesrv_srvsvc_NetShareDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2283                        struct srvsvc_NetShareDel *r)
2284 {
2285         NTSTATUS nterr;
2286         struct share_context *sctx;
2287
2288         nterr = share_get_context_by_name(mem_ctx, lp_share_backend(dce_call->conn->dce_ctx->lp_ctx), dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, &sctx);
2289         if (!NT_STATUS_IS_OK(nterr)) {
2290                 return ntstatus_to_werror(nterr);
2291         }
2292
2293         nterr = share_remove(sctx, r->in.share_name);
2294         if (!NT_STATUS_IS_OK(nterr)) {
2295                 return ntstatus_to_werror(nterr);
2296         }
2297
2298         return WERR_OK;
2299 }
2300
2301 /*
2302   srvsvc_NetSetServiceBits
2303 */
2304 static WERROR dcesrv_srvsvc_NetSetServiceBits(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2305                        struct srvsvc_NetSetServiceBits *r)
2306 {
2307         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2308 }
2309
2310 /*
2311   srvsvc_NETRPRNAMECANONICALIZE
2312 */
2313 static WERROR dcesrv_srvsvc_NETRPRNAMECANONICALIZE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2314                        struct srvsvc_NETRPRNAMECANONICALIZE *r)
2315 {
2316         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2317 }
2318
2319 /* include the generated boilerplate */
2320 #include "librpc/gen_ndr/ndr_srvsvc_s.c"