source4/ntvfs/ipc/ipc_rap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RAP handlers
   4
   5    Copyright (C) Volker Lendecke 2004
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 #define NERR_Success 0
  25 #define NERR_badpass 86
  26 #define NERR_notsupported 50
  27
  28 struct rap_string_heap {
  29         TALLOC_CTX *mem_ctx;
  30         int offset;
  31         int num_strings;
  32         const char **strings;
  33 };
  34
  35 struct rap_heap_save {
  36         int offset, num_strings;
  37 };
  38
  39 static void rap_heap_save(struct rap_string_heap *heap,
  40                           struct rap_heap_save *save)
  41 {
  42         save->offset = heap->offset;
  43         save->num_strings = heap->num_strings;
  44 }
  45
  46 static void rap_heap_restore(struct rap_string_heap *heap,
  47                              struct rap_heap_save *save)
  48 {
  49         heap->offset = save->offset;
  50         heap->num_strings = save->num_strings;
  51 }
  52
  53 struct rap_call {
  54         TALLOC_CTX *mem_ctx;
  55         uint16 callno;
  56         const char *paramdesc;
  57         const char *datadesc;
  58
  59         uint16 status;
  60         uint16 convert;
  61
  62         uint16 rcv_paramlen, rcv_datalen;
  63
  64         struct ndr_push *ndr_push_param;
  65         struct ndr_push *ndr_push_data;
  66         struct rap_string_heap *heap;
  67
  68         struct ndr_pull *ndr_pull_param;
  69         struct ndr_pull *ndr_pull_data;
  70 };
  71
  72 #define RAPNDR_FLAGS (LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
  73
  74 static struct rap_call *new_rap_srv_call(TALLOC_CTX *mem_ctx,
  75                                          struct smb_trans2 *trans)
  76 {
  77         struct rap_call *call;
  78
  79         call = talloc_p(mem_ctx, struct rap_call);
  80
  81         if (call == NULL)
  82                 return NULL;
  83
  84         ZERO_STRUCTP(call);
  85
  86         call->mem_ctx = mem_ctx;
  87
  88         call->ndr_pull_param = ndr_pull_init_blob(&trans->in.params, mem_ctx);
  89         call->ndr_pull_param->flags = RAPNDR_FLAGS;
  90
  91         call->ndr_pull_data = ndr_pull_init_blob(&trans->in.data, mem_ctx);
  92         call->ndr_pull_data->flags = RAPNDR_FLAGS;
  93
  94         call->heap = talloc_p(mem_ctx, struct rap_string_heap);
  95
  96         if (call->heap == NULL)
  97                 return NULL;
  98
  99         ZERO_STRUCTP(call->heap);
 100
 101         call->heap->mem_ctx = mem_ctx;
 102
 103         return call;
 104 }
 105
 106 static NTSTATUS rap_srv_pull_word(struct rap_call *call, uint16 *result)
 107 {
 108         if (*call->paramdesc++ != 'W')
 109                 return NT_STATUS_INVALID_PARAMETER;
 110
 111         return ndr_pull_uint16(call->ndr_pull_param, result);
 112 }
 113
 114 static NTSTATUS rap_srv_pull_dword(struct rap_call *call, uint32 *result)
 115 {
 116         if (*call->paramdesc++ != 'D')
 117                 return NT_STATUS_INVALID_PARAMETER;
 118
 119         return ndr_pull_uint32(call->ndr_pull_param, result);
 120 }
 121
 122 static NTSTATUS rap_srv_pull_string(struct rap_call *call, const char **result)
 123 {
 124         char paramdesc = *call->paramdesc++;
 125
 126         if (paramdesc == 'O') {
 127                 *result = NULL;
 128                 return NT_STATUS_OK;
 129         }
 130
 131         if (paramdesc != 'z')
 132                 return NT_STATUS_INVALID_PARAMETER;
 133
 134         return ndr_pull_string(call->ndr_pull_param, NDR_SCALARS, result);
 135 }
 136
 137 static NTSTATUS rap_srv_pull_bufsize(struct rap_call *call, uint16 *bufsize)
 138 {
 139         NTSTATUS result;
 140
 141         if ( (*call->paramdesc++ != 'r') || (*call->paramdesc++ != 'L') )
 142                 return NT_STATUS_INVALID_PARAMETER;
 143
 144         result = ndr_pull_uint16(call->ndr_pull_param, bufsize);
 145
 146         if (!NT_STATUS_IS_OK(result))
 147                 return result;
 148
 149         call->heap->offset = *bufsize;
 150
 151         return NT_STATUS_OK;
 152 }
 153
 154 static NTSTATUS rap_srv_pull_expect_multiple(struct rap_call *call)
 155 {
 156         if ( (*call->paramdesc++ != 'e') || (*call->paramdesc++ != 'h') )
 157                 return NT_STATUS_INVALID_PARAMETER;
 158
 159         return NT_STATUS_OK;
 160 }
 161
 162 static NTSTATUS rap_push_string(struct ndr_push *data_push,
 163                                 struct rap_string_heap *heap,
 164                                 const char *str)
 165 {
 166         size_t space;
 167
 168         if (str == NULL)
 169                 str = "";
 170
 171         space = strlen(str)+1;
 172
 173         if (heap->offset < space)
 174                 return NT_STATUS_BUFFER_TOO_SMALL;
 175
 176         heap->offset -= space;
 177
 178         NDR_CHECK(ndr_push_uint16(data_push, heap->offset));
 179         NDR_CHECK(ndr_push_uint16(data_push, 0));
 180
 181         heap->strings = talloc_realloc(heap->strings,
 182                                        sizeof(*heap->strings) *
 183                                        (heap->num_strings + 1));
 184
 185         if (heap->strings == NULL)
 186                 return NT_STATUS_NO_MEMORY;
 187
 188         heap->strings[heap->num_strings] = str;
 189         heap->num_strings += 1;
 190
 191         return NT_STATUS_OK;
 192 }
 193
 194 #define NDR_OK(call) do { result = call; \
 195                              if (NT_STATUS_EQUAL(result, NT_STATUS_BUFFER_TOO_SMALL)) \
 196                                 goto buffer_overflow; \
 197                              if (!NT_STATUS_IS_OK(result)) \
 198                                 goto done; \
 199                         } while (0)
 200
 201 static NTSTATUS _rap_netshareenum(struct smbsrv_request *req,
 202                                   struct rap_call *call)
 203 {
 204         struct rap_NetShareEnum r;
 205         NTSTATUS result;
 206
 207         NDR_OK(rap_srv_pull_word(call, &r.in.level));
 208         NDR_OK(rap_srv_pull_bufsize(call, &r.in.bufsize));
 209         NDR_OK(rap_srv_pull_expect_multiple(call));
 210
 211         switch(r.in.level) {
 212         case 0:
 213                 if (strcmp(call->datadesc, "B13") != 0)
 214                         return NT_STATUS_INVALID_PARAMETER;
 215                 break;
 216         case 1:
 217                 if (strcmp(call->datadesc, "B13BWz") != 0)
 218                         return NT_STATUS_INVALID_PARAMETER;
 219                 break;
 220         default:
 221                 return NT_STATUS_INVALID_PARAMETER;
 222                 break;
 223         }
 224
 225         result = rap_netshareenum(req, &r);
 226
 227         if (!NT_STATUS_IS_OK(result))
 228                 return result;
 229
 230         for (r.out.count = 0; r.out.count < r.out.available; r.out.count++) {
 231
 232                 int i = r.out.count;
 233                 struct ndr_push_save data_save;
 234                 struct rap_heap_save heap_save;
 235
 236                 ndr_push_save(call->ndr_push_data, &data_save);
 237                 rap_heap_save(call->heap, &heap_save);
 238
 239                 switch(r.in.level) {
 240                 case 0:
 241                         NDR_OK(ndr_push_bytes(call->ndr_push_data,
 242                                               r.out.info[i].info0.name,
 243                                               sizeof(r.out.info[i].info0.name)));
 244                         break;
 245                 case 1:
 246                         NDR_OK(ndr_push_bytes(call->ndr_push_data,
 247                                               r.out.info[i].info1.name,
 248                                               sizeof(r.out.info[i].info1.name)));
 249                         NDR_OK(ndr_push_uint8(call->ndr_push_data,
 250                                               r.out.info[i].info1.pad));
 251                         NDR_OK(ndr_push_uint16(call->ndr_push_data,
 252                                                r.out.info[i].info1.type));
 253
 254                         NDR_OK(rap_push_string(call->ndr_push_data,
 255                                                call->heap,
 256                                                r.out.info[i].info1.comment));
 257
 258                         break;
 259                 }
 260
 261                 if (call->ndr_push_data->offset > call->heap->offset) {
 262
 263         buffer_overflow:
 264
 265                         ndr_push_restore(call->ndr_push_data, &data_save);
 266                         rap_heap_restore(call->heap, &heap_save);
 267                         break;
 268                 }
 269         }
 270
 271         call->status = r.out.status;
 272
 273         NDR_CHECK(ndr_push_uint16(call->ndr_push_param, r.out.count));
 274         NDR_CHECK(ndr_push_uint16(call->ndr_push_param, r.out.available));
 275
 276         result = NT_STATUS_OK;
 277
 278  done:
 279         return result;
 280 }
 281
 282 static NTSTATUS _rap_netserverenum2(struct smbsrv_request *req,
 283                                     struct rap_call *call)
 284 {
 285         struct rap_NetServerEnum2 r;
 286         NTSTATUS result;
 287
 288         NDR_OK(rap_srv_pull_word(call, &r.in.level));
 289         NDR_OK(rap_srv_pull_bufsize(call, &r.in.bufsize));
 290         NDR_OK(rap_srv_pull_expect_multiple(call));
 291         NDR_OK(rap_srv_pull_dword(call, &r.in.servertype));
 292         NDR_OK(rap_srv_pull_string(call, &r.in.domain));
 293
 294         switch(r.in.level) {
 295         case 0:
 296                 if (strcmp(call->datadesc, "B16") != 0)
 297                         return NT_STATUS_INVALID_PARAMETER;
 298                 break;
 299         case 1:
 300                 if (strcmp(call->datadesc, "B16BBDz") != 0)
 301                         return NT_STATUS_INVALID_PARAMETER;
 302                 break;
 303         default:
 304                 return NT_STATUS_INVALID_PARAMETER;
 305                 break;
 306         }
 307
 308         result = rap_netserverenum2(req, &r);
 309
 310         if (!NT_STATUS_IS_OK(result))
 311                 return result;
 312
 313         for (r.out.count = 0; r.out.count < r.out.available; r.out.count++) {
 314
 315                 int i = r.out.count;
 316                 struct ndr_push_save data_save;
 317                 struct rap_heap_save heap_save;
 318
 319                 ndr_push_save(call->ndr_push_data, &data_save);
 320                 rap_heap_save(call->heap, &heap_save);
 321
 322                 switch(r.in.level) {
 323                 case 0:
 324                         NDR_OK(ndr_push_bytes(call->ndr_push_data,
 325                                               r.out.info[i].info0.name,
 326                                               sizeof(r.out.info[i].info0.name)));
 327                         break;
 328                 case 1:
 329                         NDR_OK(ndr_push_bytes(call->ndr_push_data,
 330                                               r.out.info[i].info1.name,
 331                                               sizeof(r.out.info[i].info1.name)));
 332                         NDR_OK(ndr_push_uint8(call->ndr_push_data,
 333                                               r.out.info[i].info1.version_major));
 334                         NDR_OK(ndr_push_uint8(call->ndr_push_data,
 335                                               r.out.info[i].info1.version_minor));
 336                         NDR_OK(ndr_push_uint32(call->ndr_push_data,
 337                                                r.out.info[i].info1.servertype));
 338
 339                         NDR_OK(rap_push_string(call->ndr_push_data,
 340                                                call->heap,
 341                                                r.out.info[i].info1.comment));
 342
 343                         break;
 344                 }
 345
 346                 if (call->ndr_push_data->offset > call->heap->offset) {
 347
 348         buffer_overflow:
 349
 350                         ndr_push_restore(call->ndr_push_data, &data_save);
 351                         rap_heap_restore(call->heap, &heap_save);
 352                         break;
 353                 }
 354         }
 355
 356         call->status = r.out.status;
 357
 358         NDR_CHECK(ndr_push_uint16(call->ndr_push_param, r.out.count));
 359         NDR_CHECK(ndr_push_uint16(call->ndr_push_param, r.out.available));
 360
 361         result = NT_STATUS_OK;
 362
 363  done:
 364         return result;
 365 }
 366
 367 static NTSTATUS api_Unsupported(struct smbsrv_request *req,
 368                                 struct rap_call *call)
 369 {
 370         call->status = NERR_notsupported;
 371         call->convert = 0;
 372         return NT_STATUS_OK;
 373 }
 374
 375 #define RAP_NetShareEnum 0
 376 #define RAP_NetServerEnum2 104
 377
 378 static const struct
 379 {
 380         const char *name;
 381         int id;
 382         NTSTATUS (*fn)(struct smbsrv_request *req, struct rap_call *call);
 383 } api_commands[] = {
 384         {"NetShareEnum", RAP_NetShareEnum, _rap_netshareenum },
 385         {"NetServerEnum2", RAP_NetServerEnum2, _rap_netserverenum2 },
 386         {NULL, -1, api_Unsupported}
 387 };
 388
 389 NTSTATUS ipc_rap_call(struct smbsrv_request *req, struct smb_trans2 *trans)
 390 {
 391         int i;
 392         NTSTATUS result;
 393         struct rap_call *call;
 394         DATA_BLOB result_param, result_data;
 395         struct ndr_push *final_param;
 396         struct ndr_push *final_data;
 397
 398         call = new_rap_srv_call(req->mem_ctx, trans);
 399
 400         if (call == NULL)
 401                 return NT_STATUS_NO_MEMORY;
 402
 403         NDR_CHECK(ndr_pull_uint16(call->ndr_pull_param, &call->callno));
 404         NDR_CHECK(ndr_pull_string(call->ndr_pull_param, NDR_SCALARS,
 405                                   &call->paramdesc));
 406         NDR_CHECK(ndr_pull_string(call->ndr_pull_param, NDR_SCALARS,
 407                                   &call->datadesc));
 408
 409         call->ndr_push_param = ndr_push_init_ctx(req->mem_ctx);
 410         call->ndr_push_data = ndr_push_init_ctx(req->mem_ctx);
 411
 412         if ((call->ndr_push_param == NULL) || (call->ndr_push_data == NULL))
 413                 return NT_STATUS_NO_MEMORY;
 414
 415         call->ndr_push_param->flags = RAPNDR_FLAGS;
 416         call->ndr_push_data->flags = RAPNDR_FLAGS;
 417
 418         result = NT_STATUS_NOT_IMPLEMENTED;
 419
 420         for (i=0; api_commands[i].name != NULL; i++) {
 421                 if (api_commands[i].id == call->callno) {
 422                         DEBUG(5, ("Running RAP call %s\n",
 423                                   api_commands[i].name));
 424                         result = api_commands[i].fn(req, call);
 425                         break;
 426                 }
 427         }
 428
 429         if (!NT_STATUS_IS_OK(result))
 430                 return result;
 431
 432         result_param = ndr_push_blob(call->ndr_push_param);
 433         result_data = ndr_push_blob(call->ndr_push_data);
 434
 435         final_param = ndr_push_init_ctx(req->mem_ctx);
 436         final_data = ndr_push_init_ctx(req->mem_ctx);
 437
 438         if ((final_param == NULL) || (final_data == NULL))
 439                 return NT_STATUS_NO_MEMORY;
 440
 441         final_param->flags = RAPNDR_FLAGS;
 442         final_data->flags = RAPNDR_FLAGS;
 443
 444         NDR_CHECK(ndr_push_uint16(final_param, call->status));
 445         NDR_CHECK(ndr_push_uint16(final_param,
 446                                   call->heap->offset - result_data.length));
 447         NDR_CHECK(ndr_push_bytes(final_param, result_param.data,
 448                                  result_param.length));
 449
 450         NDR_CHECK(ndr_push_bytes(final_data, result_data.data,
 451                                  result_data.length));
 452
 453         for (i=call->heap->num_strings-1; i>=0; i--)
 454                 NDR_CHECK(ndr_push_string(final_data, NDR_SCALARS,
 455                                           call->heap->strings[i]));
 456
 457         trans->out.setup_count = 0;
 458         trans->out.setup = NULL;
 459         trans->out.params = ndr_push_blob(final_param);
 460         trans->out.data = ndr_push_blob(final_data);
 461
 462         return result;
 463 }