root/librpc/gen_ndr/srv_epmapper.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. api_epm_Insert
  2. api_epm_Delete
  3. api_epm_Lookup
  4. api_epm_Map
  5. api_epm_LookupHandleFree
  6. api_epm_InqObject
  7. api_epm_MgmtDelete
  8. api_epm_MapAuth
  9. epmapper_get_pipe_fns
  10. rpc_epmapper_dispatch
  11. rpc_epmapper_init

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5 
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/srv_epmapper.h"
   8 
   9 static bool api_epm_Insert(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct epm_Insert *r;
  17 
  18         call = &ndr_table_epmapper.calls[NDR_EPM_INSERT];
  19 
  20         r = talloc(talloc_tos(), struct epm_Insert);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24 
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29 
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35 
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42 
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(epm_Insert, r);
  45         }
  46 
  47         r->out.result = _epm_Insert(p, r);
  48 
  49         if (p->rng_fault_state) {
  50                 talloc_free(r);
  51                 /* Return true here, srv_pipe_hnd.c will take care */
  52                 return true;
  53         }
  54 
  55         if (DEBUGLEVEL >= 10) {
  56                 NDR_PRINT_OUT_DEBUG(epm_Insert, r);
  57         }
  58 
  59         push = ndr_push_init_ctx(r, NULL);
  60         if (push == NULL) {
  61                 talloc_free(r);
  62                 return false;
  63         }
  64 
  65         ndr_err = call->ndr_push(push, NDR_OUT, r);
  66         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  67                 talloc_free(r);
  68                 return false;
  69         }
  70 
  71         blob = ndr_push_blob(push);
  72         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  73                 talloc_free(r);
  74                 return false;
  75         }
  76 
  77         talloc_free(r);
  78 
  79         return true;
  80 }
  81 
  82 static bool api_epm_Delete(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  83 {
  84         const struct ndr_interface_call *call;
  85         struct ndr_pull *pull;
  86         struct ndr_push *push;
  87         enum ndr_err_code ndr_err;
  88         DATA_BLOB blob;
  89         struct epm_Delete *r;
  90 
  91         call = &ndr_table_epmapper.calls[NDR_EPM_DELETE];
  92 
  93         r = talloc(talloc_tos(), struct epm_Delete);
  94         if (r == NULL) {
  95                 return false;
  96         }
  97 
  98         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  99                 talloc_free(r);
 100                 return false;
 101         }
 102 
 103         pull = ndr_pull_init_blob(&blob, r, NULL);
 104         if (pull == NULL) {
 105                 talloc_free(r);
 106                 return false;
 107         }
 108 
 109         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 110         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 111         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115 
 116         if (DEBUGLEVEL >= 10) {
 117                 NDR_PRINT_IN_DEBUG(epm_Delete, r);
 118         }
 119 
 120         r->out.result = _epm_Delete(p, r);
 121 
 122         if (p->rng_fault_state) {
 123                 talloc_free(r);
 124                 /* Return true here, srv_pipe_hnd.c will take care */
 125                 return true;
 126         }
 127 
 128         if (DEBUGLEVEL >= 10) {
 129                 NDR_PRINT_OUT_DEBUG(epm_Delete, r);
 130         }
 131 
 132         push = ndr_push_init_ctx(r, NULL);
 133         if (push == NULL) {
 134                 talloc_free(r);
 135                 return false;
 136         }
 137 
 138         ndr_err = call->ndr_push(push, NDR_OUT, r);
 139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 140                 talloc_free(r);
 141                 return false;
 142         }
 143 
 144         blob = ndr_push_blob(push);
 145         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 146                 talloc_free(r);
 147                 return false;
 148         }
 149 
 150         talloc_free(r);
 151 
 152         return true;
 153 }
 154 
 155 static bool api_epm_Lookup(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 156 {
 157         const struct ndr_interface_call *call;
 158         struct ndr_pull *pull;
 159         struct ndr_push *push;
 160         enum ndr_err_code ndr_err;
 161         DATA_BLOB blob;
 162         struct epm_Lookup *r;
 163 
 164         call = &ndr_table_epmapper.calls[NDR_EPM_LOOKUP];
 165 
 166         r = talloc(talloc_tos(), struct epm_Lookup);
 167         if (r == NULL) {
 168                 return false;
 169         }
 170 
 171         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 172                 talloc_free(r);
 173                 return false;
 174         }
 175 
 176         pull = ndr_pull_init_blob(&blob, r, NULL);
 177         if (pull == NULL) {
 178                 talloc_free(r);
 179                 return false;
 180         }
 181 
 182         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 183         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 185                 talloc_free(r);
 186                 return false;
 187         }
 188 
 189         if (DEBUGLEVEL >= 10) {
 190                 NDR_PRINT_IN_DEBUG(epm_Lookup, r);
 191         }
 192 
 193         ZERO_STRUCT(r->out);
 194         r->out.entry_handle = r->in.entry_handle;
 195         r->out.num_ents = talloc_zero(r, uint32_t);
 196         if (r->out.num_ents == NULL) {
 197                 talloc_free(r);
 198                 return false;
 199         }
 200 
 201         r->out.entries = talloc_zero_array(r, struct epm_entry_t, r->in.max_ents);
 202         if (r->out.entries == NULL) {
 203                 talloc_free(r);
 204                 return false;
 205         }
 206 
 207         r->out.result = _epm_Lookup(p, r);
 208 
 209         if (p->rng_fault_state) {
 210                 talloc_free(r);
 211                 /* Return true here, srv_pipe_hnd.c will take care */
 212                 return true;
 213         }
 214 
 215         if (DEBUGLEVEL >= 10) {
 216                 NDR_PRINT_OUT_DEBUG(epm_Lookup, r);
 217         }
 218 
 219         push = ndr_push_init_ctx(r, NULL);
 220         if (push == NULL) {
 221                 talloc_free(r);
 222                 return false;
 223         }
 224 
 225         ndr_err = call->ndr_push(push, NDR_OUT, r);
 226         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 227                 talloc_free(r);
 228                 return false;
 229         }
 230 
 231         blob = ndr_push_blob(push);
 232         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 233                 talloc_free(r);
 234                 return false;
 235         }
 236 
 237         talloc_free(r);
 238 
 239         return true;
 240 }
 241 
 242 static bool api_epm_Map(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 243 {
 244         const struct ndr_interface_call *call;
 245         struct ndr_pull *pull;
 246         struct ndr_push *push;
 247         enum ndr_err_code ndr_err;
 248         DATA_BLOB blob;
 249         struct epm_Map *r;
 250 
 251         call = &ndr_table_epmapper.calls[NDR_EPM_MAP];
 252 
 253         r = talloc(talloc_tos(), struct epm_Map);
 254         if (r == NULL) {
 255                 return false;
 256         }
 257 
 258         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 259                 talloc_free(r);
 260                 return false;
 261         }
 262 
 263         pull = ndr_pull_init_blob(&blob, r, NULL);
 264         if (pull == NULL) {
 265                 talloc_free(r);
 266                 return false;
 267         }
 268 
 269         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 270         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 271         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 272                 talloc_free(r);
 273                 return false;
 274         }
 275 
 276         if (DEBUGLEVEL >= 10) {
 277                 NDR_PRINT_IN_DEBUG(epm_Map, r);
 278         }
 279 
 280         ZERO_STRUCT(r->out);
 281         r->out.entry_handle = r->in.entry_handle;
 282         r->out.num_towers = talloc_zero(r, uint32_t);
 283         if (r->out.num_towers == NULL) {
 284                 talloc_free(r);
 285                 return false;
 286         }
 287 
 288         r->out.towers = talloc_zero_array(r, struct epm_twr_p_t, r->in.max_towers);
 289         if (r->out.towers == NULL) {
 290                 talloc_free(r);
 291                 return false;
 292         }
 293 
 294         r->out.result = _epm_Map(p, r);
 295 
 296         if (p->rng_fault_state) {
 297                 talloc_free(r);
 298                 /* Return true here, srv_pipe_hnd.c will take care */
 299                 return true;
 300         }
 301 
 302         if (DEBUGLEVEL >= 10) {
 303                 NDR_PRINT_OUT_DEBUG(epm_Map, r);
 304         }
 305 
 306         push = ndr_push_init_ctx(r, NULL);
 307         if (push == NULL) {
 308                 talloc_free(r);
 309                 return false;
 310         }
 311 
 312         ndr_err = call->ndr_push(push, NDR_OUT, r);
 313         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 314                 talloc_free(r);
 315                 return false;
 316         }
 317 
 318         blob = ndr_push_blob(push);
 319         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 320                 talloc_free(r);
 321                 return false;
 322         }
 323 
 324         talloc_free(r);
 325 
 326         return true;
 327 }
 328 
 329 static bool api_epm_LookupHandleFree(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 330 {
 331         const struct ndr_interface_call *call;
 332         struct ndr_pull *pull;
 333         struct ndr_push *push;
 334         enum ndr_err_code ndr_err;
 335         DATA_BLOB blob;
 336         struct epm_LookupHandleFree *r;
 337 
 338         call = &ndr_table_epmapper.calls[NDR_EPM_LOOKUPHANDLEFREE];
 339 
 340         r = talloc(talloc_tos(), struct epm_LookupHandleFree);
 341         if (r == NULL) {
 342                 return false;
 343         }
 344 
 345         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 346                 talloc_free(r);
 347                 return false;
 348         }
 349 
 350         pull = ndr_pull_init_blob(&blob, r, NULL);
 351         if (pull == NULL) {
 352                 talloc_free(r);
 353                 return false;
 354         }
 355 
 356         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 357         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 358         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 359                 talloc_free(r);
 360                 return false;
 361         }
 362 
 363         if (DEBUGLEVEL >= 10) {
 364                 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, r);
 365         }
 366 
 367         ZERO_STRUCT(r->out);
 368         r->out.entry_handle = r->in.entry_handle;
 369         r->out.result = _epm_LookupHandleFree(p, r);
 370 
 371         if (p->rng_fault_state) {
 372                 talloc_free(r);
 373                 /* Return true here, srv_pipe_hnd.c will take care */
 374                 return true;
 375         }
 376 
 377         if (DEBUGLEVEL >= 10) {
 378                 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, r);
 379         }
 380 
 381         push = ndr_push_init_ctx(r, NULL);
 382         if (push == NULL) {
 383                 talloc_free(r);
 384                 return false;
 385         }
 386 
 387         ndr_err = call->ndr_push(push, NDR_OUT, r);
 388         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 389                 talloc_free(r);
 390                 return false;
 391         }
 392 
 393         blob = ndr_push_blob(push);
 394         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 395                 talloc_free(r);
 396                 return false;
 397         }
 398 
 399         talloc_free(r);
 400 
 401         return true;
 402 }
 403 
 404 static bool api_epm_InqObject(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 405 {
 406         const struct ndr_interface_call *call;
 407         struct ndr_pull *pull;
 408         struct ndr_push *push;
 409         enum ndr_err_code ndr_err;
 410         DATA_BLOB blob;
 411         struct epm_InqObject *r;
 412 
 413         call = &ndr_table_epmapper.calls[NDR_EPM_INQOBJECT];
 414 
 415         r = talloc(talloc_tos(), struct epm_InqObject);
 416         if (r == NULL) {
 417                 return false;
 418         }
 419 
 420         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 421                 talloc_free(r);
 422                 return false;
 423         }
 424 
 425         pull = ndr_pull_init_blob(&blob, r, NULL);
 426         if (pull == NULL) {
 427                 talloc_free(r);
 428                 return false;
 429         }
 430 
 431         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 432         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 433         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 434                 talloc_free(r);
 435                 return false;
 436         }
 437 
 438         if (DEBUGLEVEL >= 10) {
 439                 NDR_PRINT_IN_DEBUG(epm_InqObject, r);
 440         }
 441 
 442         r->out.result = _epm_InqObject(p, r);
 443 
 444         if (p->rng_fault_state) {
 445                 talloc_free(r);
 446                 /* Return true here, srv_pipe_hnd.c will take care */
 447                 return true;
 448         }
 449 
 450         if (DEBUGLEVEL >= 10) {
 451                 NDR_PRINT_OUT_DEBUG(epm_InqObject, r);
 452         }
 453 
 454         push = ndr_push_init_ctx(r, NULL);
 455         if (push == NULL) {
 456                 talloc_free(r);
 457                 return false;
 458         }
 459 
 460         ndr_err = call->ndr_push(push, NDR_OUT, r);
 461         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 462                 talloc_free(r);
 463                 return false;
 464         }
 465 
 466         blob = ndr_push_blob(push);
 467         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 468                 talloc_free(r);
 469                 return false;
 470         }
 471 
 472         talloc_free(r);
 473 
 474         return true;
 475 }
 476 
 477 static bool api_epm_MgmtDelete(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 478 {
 479         const struct ndr_interface_call *call;
 480         struct ndr_pull *pull;
 481         struct ndr_push *push;
 482         enum ndr_err_code ndr_err;
 483         DATA_BLOB blob;
 484         struct epm_MgmtDelete *r;
 485 
 486         call = &ndr_table_epmapper.calls[NDR_EPM_MGMTDELETE];
 487 
 488         r = talloc(talloc_tos(), struct epm_MgmtDelete);
 489         if (r == NULL) {
 490                 return false;
 491         }
 492 
 493         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 494                 talloc_free(r);
 495                 return false;
 496         }
 497 
 498         pull = ndr_pull_init_blob(&blob, r, NULL);
 499         if (pull == NULL) {
 500                 talloc_free(r);
 501                 return false;
 502         }
 503 
 504         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 505         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 506         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 507                 talloc_free(r);
 508                 return false;
 509         }
 510 
 511         if (DEBUGLEVEL >= 10) {
 512                 NDR_PRINT_IN_DEBUG(epm_MgmtDelete, r);
 513         }
 514 
 515         r->out.result = _epm_MgmtDelete(p, r);
 516 
 517         if (p->rng_fault_state) {
 518                 talloc_free(r);
 519                 /* Return true here, srv_pipe_hnd.c will take care */
 520                 return true;
 521         }
 522 
 523         if (DEBUGLEVEL >= 10) {
 524                 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, r);
 525         }
 526 
 527         push = ndr_push_init_ctx(r, NULL);
 528         if (push == NULL) {
 529                 talloc_free(r);
 530                 return false;
 531         }
 532 
 533         ndr_err = call->ndr_push(push, NDR_OUT, r);
 534         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538 
 539         blob = ndr_push_blob(push);
 540         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 541                 talloc_free(r);
 542                 return false;
 543         }
 544 
 545         talloc_free(r);
 546 
 547         return true;
 548 }
 549 
 550 static bool api_epm_MapAuth(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 551 {
 552         const struct ndr_interface_call *call;
 553         struct ndr_pull *pull;
 554         struct ndr_push *push;
 555         enum ndr_err_code ndr_err;
 556         DATA_BLOB blob;
 557         struct epm_MapAuth *r;
 558 
 559         call = &ndr_table_epmapper.calls[NDR_EPM_MAPAUTH];
 560 
 561         r = talloc(talloc_tos(), struct epm_MapAuth);
 562         if (r == NULL) {
 563                 return false;
 564         }
 565 
 566         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 567                 talloc_free(r);
 568                 return false;
 569         }
 570 
 571         pull = ndr_pull_init_blob(&blob, r, NULL);
 572         if (pull == NULL) {
 573                 talloc_free(r);
 574                 return false;
 575         }
 576 
 577         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 578         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 579         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 580                 talloc_free(r);
 581                 return false;
 582         }
 583 
 584         if (DEBUGLEVEL >= 10) {
 585                 NDR_PRINT_IN_DEBUG(epm_MapAuth, r);
 586         }
 587 
 588         r->out.result = _epm_MapAuth(p, r);
 589 
 590         if (p->rng_fault_state) {
 591                 talloc_free(r);
 592                 /* Return true here, srv_pipe_hnd.c will take care */
 593                 return true;
 594         }
 595 
 596         if (DEBUGLEVEL >= 10) {
 597                 NDR_PRINT_OUT_DEBUG(epm_MapAuth, r);
 598         }
 599 
 600         push = ndr_push_init_ctx(r, NULL);
 601         if (push == NULL) {
 602                 talloc_free(r);
 603                 return false;
 604         }
 605 
 606         ndr_err = call->ndr_push(push, NDR_OUT, r);
 607         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 608                 talloc_free(r);
 609                 return false;
 610         }
 611 
 612         blob = ndr_push_blob(push);
 613         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 614                 talloc_free(r);
 615                 return false;
 616         }
 617 
 618         talloc_free(r);
 619 
 620         return true;
 621 }
 622 
 623 
 624 /* Tables */
 625 static struct api_struct api_epmapper_cmds[] = 
 626 {
 627         {"EPM_INSERT", NDR_EPM_INSERT, api_epm_Insert},
 628         {"EPM_DELETE", NDR_EPM_DELETE, api_epm_Delete},
 629         {"EPM_LOOKUP", NDR_EPM_LOOKUP, api_epm_Lookup},
 630         {"EPM_MAP", NDR_EPM_MAP, api_epm_Map},
 631         {"EPM_LOOKUPHANDLEFREE", NDR_EPM_LOOKUPHANDLEFREE, api_epm_LookupHandleFree},
 632         {"EPM_INQOBJECT", NDR_EPM_INQOBJECT, api_epm_InqObject},
 633         {"EPM_MGMTDELETE", NDR_EPM_MGMTDELETE, api_epm_MgmtDelete},
 634         {"EPM_MAPAUTH", NDR_EPM_MAPAUTH, api_epm_MapAuth},
 635 };
 636 
 637 void epmapper_get_pipe_fns(struct api_struct **fns, int *n_fns)
     /* [<][>][^][v][top][bottom][index][help] */
 638 {
 639         *fns = api_epmapper_cmds;
 640         *n_fns = sizeof(api_epmapper_cmds) / sizeof(struct api_struct);
 641 }
 642 
 643 NTSTATUS rpc_epmapper_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
     /* [<][>][^][v][top][bottom][index][help] */
 644 {
 645         if (cli->pipes_struct == NULL) {
 646                 return NT_STATUS_INVALID_PARAMETER;
 647         }
 648 
 649         switch (opnum)
 650         {
 651                 case NDR_EPM_INSERT: {
 652                         struct epm_Insert *r = (struct epm_Insert *)_r;
 653                         r->out.result = _epm_Insert(cli->pipes_struct, r);
 654                         return NT_STATUS_OK;
 655                 }
 656 
 657                 case NDR_EPM_DELETE: {
 658                         struct epm_Delete *r = (struct epm_Delete *)_r;
 659                         r->out.result = _epm_Delete(cli->pipes_struct, r);
 660                         return NT_STATUS_OK;
 661                 }
 662 
 663                 case NDR_EPM_LOOKUP: {
 664                         struct epm_Lookup *r = (struct epm_Lookup *)_r;
 665                         ZERO_STRUCT(r->out);
 666                         r->out.entry_handle = r->in.entry_handle;
 667                         r->out.num_ents = talloc_zero(mem_ctx, uint32_t);
 668                         if (r->out.num_ents == NULL) {
 669                         return NT_STATUS_NO_MEMORY;
 670                         }
 671 
 672                         r->out.entries = talloc_zero_array(mem_ctx, struct epm_entry_t, r->in.max_ents);
 673                         if (r->out.entries == NULL) {
 674                         return NT_STATUS_NO_MEMORY;
 675                         }
 676 
 677                         r->out.result = _epm_Lookup(cli->pipes_struct, r);
 678                         return NT_STATUS_OK;
 679                 }
 680 
 681                 case NDR_EPM_MAP: {
 682                         struct epm_Map *r = (struct epm_Map *)_r;
 683                         ZERO_STRUCT(r->out);
 684                         r->out.entry_handle = r->in.entry_handle;
 685                         r->out.num_towers = talloc_zero(mem_ctx, uint32_t);
 686                         if (r->out.num_towers == NULL) {
 687                         return NT_STATUS_NO_MEMORY;
 688                         }
 689 
 690                         r->out.towers = talloc_zero_array(mem_ctx, struct epm_twr_p_t, r->in.max_towers);
 691                         if (r->out.towers == NULL) {
 692                         return NT_STATUS_NO_MEMORY;
 693                         }
 694 
 695                         r->out.result = _epm_Map(cli->pipes_struct, r);
 696                         return NT_STATUS_OK;
 697                 }
 698 
 699                 case NDR_EPM_LOOKUPHANDLEFREE: {
 700                         struct epm_LookupHandleFree *r = (struct epm_LookupHandleFree *)_r;
 701                         ZERO_STRUCT(r->out);
 702                         r->out.entry_handle = r->in.entry_handle;
 703                         r->out.result = _epm_LookupHandleFree(cli->pipes_struct, r);
 704                         return NT_STATUS_OK;
 705                 }
 706 
 707                 case NDR_EPM_INQOBJECT: {
 708                         struct epm_InqObject *r = (struct epm_InqObject *)_r;
 709                         r->out.result = _epm_InqObject(cli->pipes_struct, r);
 710                         return NT_STATUS_OK;
 711                 }
 712 
 713                 case NDR_EPM_MGMTDELETE: {
 714                         struct epm_MgmtDelete *r = (struct epm_MgmtDelete *)_r;
 715                         r->out.result = _epm_MgmtDelete(cli->pipes_struct, r);
 716                         return NT_STATUS_OK;
 717                 }
 718 
 719                 case NDR_EPM_MAPAUTH: {
 720                         struct epm_MapAuth *r = (struct epm_MapAuth *)_r;
 721                         r->out.result = _epm_MapAuth(cli->pipes_struct, r);
 722                         return NT_STATUS_OK;
 723                 }
 724 
 725                 default:
 726                         return NT_STATUS_NOT_IMPLEMENTED;
 727         }
 728 }
 729 
 730 NTSTATUS rpc_epmapper_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
 731 {
 732         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "epmapper", "epmapper", &ndr_table_epmapper, api_epmapper_cmds, sizeof(api_epmapper_cmds) / sizeof(struct api_struct));
 733 }

/* [<][>][^][v][top][bottom][index][help] */