source3/rpc_server/rpc_service_setup.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *
   4  *  SMBD RPC service callbacks
   5  *
   6  *  Copyright (c) 2011      Andreas Schneider <asn@samba.org>
   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 "ntdomain.h"
  24
  25 #include "../librpc/gen_ndr/ndr_epmapper_c.h"
  26 #include "../librpc/gen_ndr/srv_epmapper.h"
  27 #include "../librpc/gen_ndr/srv_srvsvc.h"
  28 #include "../librpc/gen_ndr/srv_winreg.h"
  29 #include "../librpc/gen_ndr/srv_dfs.h"
  30 #include "../librpc/gen_ndr/srv_dssetup.h"
  31 #include "../librpc/gen_ndr/srv_echo.h"
  32 #include "../librpc/gen_ndr/srv_eventlog.h"
  33 #include "../librpc/gen_ndr/srv_initshutdown.h"
  34 #include "../librpc/gen_ndr/srv_lsa.h"
  35 #include "../librpc/gen_ndr/srv_netlogon.h"
  36 #include "../librpc/gen_ndr/srv_ntsvcs.h"
  37 #include "../librpc/gen_ndr/srv_samr.h"
  38 #include "../librpc/gen_ndr/srv_spoolss.h"
  39 #include "../librpc/gen_ndr/srv_svcctl.h"
  40 #include "../librpc/gen_ndr/srv_wkssvc.h"
  41
  42 #include "printing/nt_printing_migrate_internal.h"
  43 #include "rpc_server/eventlog/srv_eventlog_reg.h"
  44 #include "rpc_server/svcctl/srv_svcctl_reg.h"
  45 #include "rpc_server/spoolss/srv_spoolss_nt.h"
  46 #include "rpc_server/svcctl/srv_svcctl_nt.h"
  47
  48 #include "librpc/rpc/dcerpc_ep.h"
  49 #include "rpc_server/rpc_sock_helper.h"
  50 #include "rpc_server/rpc_service_setup.h"
  51 #include "rpc_server/rpc_ep_register.h"
  52 #include "rpc_server/rpc_server.h"
  53 #include "rpc_server/rpc_config.h"
  54 #include "rpc_server/rpc_modules.h"
  55 #include "rpc_server/epmapper/srv_epmapper.h"
  56
  57 #undef DBGC_CLASS
  58 #define DBGC_CLASS DBGC_RPC_SRV
  59
  60 static_decl_rpc;
  61
  62 /* Common routine for embedded RPC servers */
  63 NTSTATUS rpc_setup_embedded(struct tevent_context *ev_ctx,
  64                             struct messaging_context *msg_ctx,
  65                             const struct ndr_interface_table *t,
  66                             const char *pipe_name)
  67 {
  68         struct dcerpc_binding_vector *v;
  69         enum rpc_service_mode_e epm_mode = rpc_epmapper_mode();
  70         NTSTATUS status;
  71
  72         /* Registration of ncacn_np services is problematic.  The
  73          * ev_ctx passed in here is passed down to all children of the
  74          * smbd process, and if the end point mapper ever goes away,
  75          * they will all attempt to re-register.  But we want to test
  76          * the code for now, so it is enabled in on environment in
  77          * make test */
  78         if (epm_mode != RPC_SERVICE_MODE_DISABLED &&
  79             (lp_parm_bool(-1, "rpc_server", "register_embedded_np", false))) {
  80                 status = dcerpc_binding_vector_new(talloc_tos(), &v);
  81                 if (!NT_STATUS_IS_OK(status)) {
  82                         return status;
  83                 }
  84
  85                 status = dcerpc_binding_vector_add_np_default(t, v);
  86                 if (!NT_STATUS_IS_OK(status)) {
  87                         return status;
  88                 }
  89
  90                 status = rpc_ep_register(ev_ctx,
  91                                          msg_ctx,
  92                                          t,
  93                                          v);
  94                 if (!NT_STATUS_IS_OK(status)) {
  95                         return status;
  96                 }
  97         }
  98
  99         return NT_STATUS_OK;
 100 }
 101
 102 static NTSTATUS rpc_setup_winreg(struct tevent_context *ev_ctx,
 103                                  struct messaging_context *msg_ctx)
 104 {
 105         const struct ndr_interface_table *t = &ndr_table_winreg;
 106         const char *pipe_name = "winreg";
 107         NTSTATUS status;
 108         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 109
 110         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 111                 return NT_STATUS_OK;
 112         }
 113
 114         status = rpc_winreg_init(NULL);
 115         if (!NT_STATUS_IS_OK(status)) {
 116                 return status;
 117         }
 118
 119         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 120         if (!NT_STATUS_IS_OK(status)) {
 121                 return status;
 122         }
 123
 124         return NT_STATUS_OK;
 125 }
 126
 127 static NTSTATUS rpc_setup_srvsvc(struct tevent_context *ev_ctx,
 128                                  struct messaging_context *msg_ctx)
 129 {
 130         const struct ndr_interface_table *t = &ndr_table_srvsvc;
 131         const char *pipe_name = "srvsvc";
 132         NTSTATUS status;
 133         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 134
 135         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 136                 return NT_STATUS_OK;
 137         }
 138
 139         status = rpc_srvsvc_init(NULL);
 140         if (!NT_STATUS_IS_OK(status)) {
 141                 return status;
 142         }
 143
 144         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 145         if (!NT_STATUS_IS_OK(status)) {
 146                 return status;
 147         }
 148
 149         return NT_STATUS_OK;
 150 }
 151
 152 static NTSTATUS rpc_setup_lsarpc(struct tevent_context *ev_ctx,
 153                                  struct messaging_context *msg_ctx)
 154 {
 155         const struct ndr_interface_table *t = &ndr_table_lsarpc;
 156         const char *pipe_name = "lsarpc";
 157         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
 158         NTSTATUS status;
 159
 160         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 161         if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
 162             lsasd_type != RPC_DAEMON_EMBEDDED) {
 163                 return NT_STATUS_OK;
 164         }
 165
 166         status = rpc_lsarpc_init(NULL);
 167         if (!NT_STATUS_IS_OK(status)) {
 168                 return status;
 169         }
 170
 171         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 172         if (!NT_STATUS_IS_OK(status)) {
 173                 return status;
 174         }
 175
 176         return NT_STATUS_OK;
 177 }
 178
 179 static NTSTATUS rpc_setup_samr(struct tevent_context *ev_ctx,
 180                                struct messaging_context *msg_ctx)
 181 {
 182         const struct ndr_interface_table *t = &ndr_table_samr;
 183         const char *pipe_name = "samr";
 184         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
 185         NTSTATUS status;
 186         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 187
 188         if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
 189             lsasd_type != RPC_DAEMON_EMBEDDED) {
 190                 return NT_STATUS_OK;
 191         }
 192
 193         status = rpc_samr_init(NULL);
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 return status;
 196         }
 197
 198         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 199         if (!NT_STATUS_IS_OK(status)) {
 200                 return status;
 201         }
 202
 203         return NT_STATUS_OK;
 204 }
 205
 206 static NTSTATUS rpc_setup_netlogon(struct tevent_context *ev_ctx,
 207                                    struct messaging_context *msg_ctx)
 208 {
 209         const struct ndr_interface_table *t = &ndr_table_netlogon;
 210         const char *pipe_name = "netlogon";
 211         enum rpc_daemon_type_e lsasd_type = rpc_lsasd_daemon();
 212         NTSTATUS status;
 213         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 214
 215         if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
 216             lsasd_type != RPC_DAEMON_EMBEDDED) {
 217                 return NT_STATUS_OK;
 218         }
 219
 220         status = rpc_netlogon_init(NULL);
 221         if (!NT_STATUS_IS_OK(status)) {
 222                 return status;
 223         }
 224
 225         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 226         if (!NT_STATUS_IS_OK(status)) {
 227                 return status;
 228         }
 229
 230         return NT_STATUS_OK;
 231 }
 232
 233 static NTSTATUS rpc_setup_netdfs(struct tevent_context *ev_ctx,
 234                                  struct messaging_context *msg_ctx)
 235 {
 236         const struct ndr_interface_table *t = &ndr_table_netdfs;
 237         const char *pipe_name = "netdfs";
 238         NTSTATUS status;
 239         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 240
 241         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 242                 return NT_STATUS_OK;
 243         }
 244
 245         status = rpc_netdfs_init(NULL);
 246         if (!NT_STATUS_IS_OK(status)) {
 247                 return status;
 248         }
 249
 250         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 251         if (!NT_STATUS_IS_OK(status)) {
 252                 return status;
 253         }
 254
 255         return NT_STATUS_OK;
 256 }
 257
 258 #ifdef DEVELOPER
 259 static NTSTATUS rpc_setup_rpcecho(struct tevent_context *ev_ctx,
 260                                   struct messaging_context *msg_ctx)
 261 {
 262         const struct ndr_interface_table *t = &ndr_table_rpcecho;
 263         const char *pipe_name = "rpcecho";
 264         NTSTATUS status;
 265         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 266
 267         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 268                 return NT_STATUS_OK;
 269         }
 270
 271         status = rpc_rpcecho_init(NULL);
 272         if (!NT_STATUS_IS_OK(status)) {
 273                 return status;
 274         }
 275
 276         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 277         if (!NT_STATUS_IS_OK(status)) {
 278                 return status;
 279         }
 280
 281         return NT_STATUS_OK;
 282 }
 283 #endif
 284
 285 static NTSTATUS rpc_setup_dssetup(struct tevent_context *ev_ctx,
 286                                   struct messaging_context *msg_ctx)
 287 {
 288         const struct ndr_interface_table *t = &ndr_table_dssetup;
 289         const char *pipe_name = "dssetup";
 290         NTSTATUS status;
 291         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 292
 293         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 294                 return NT_STATUS_OK;
 295         }
 296
 297         status = rpc_dssetup_init(NULL);
 298         if (!NT_STATUS_IS_OK(status)) {
 299                 return status;
 300         }
 301
 302         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 303         if (!NT_STATUS_IS_OK(status)) {
 304                 return status;
 305         }
 306
 307         return NT_STATUS_OK;
 308 }
 309
 310 static NTSTATUS rpc_setup_wkssvc(struct tevent_context *ev_ctx,
 311                                  struct messaging_context *msg_ctx)
 312 {
 313         const struct ndr_interface_table *t = &ndr_table_wkssvc;
 314         const char *pipe_name = "wkssvc";
 315         NTSTATUS status;
 316         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 317
 318         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 319                 return NT_STATUS_OK;
 320         }
 321
 322         status = rpc_wkssvc_init(NULL);
 323         if (!NT_STATUS_IS_OK(status)) {
 324                 return status;
 325         }
 326
 327         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 328         if (!NT_STATUS_IS_OK(status)) {
 329                 return status;
 330         }
 331
 332         return NT_STATUS_OK;
 333 }
 334
 335 static bool spoolss_init_cb(void *ptr)
 336 {
 337         struct messaging_context *msg_ctx =
 338                 talloc_get_type_abort(ptr, struct messaging_context);
 339         bool ok;
 340
 341         /*
 342          * Migrate the printers first.
 343          */
 344         ok = nt_printing_tdb_migrate(msg_ctx);
 345         if (!ok) {
 346                 return false;
 347         }
 348
 349         return true;
 350 }
 351
 352 static bool spoolss_shutdown_cb(void *ptr)
 353 {
 354         srv_spoolss_cleanup();
 355
 356         return true;
 357 }
 358
 359 static NTSTATUS rpc_setup_spoolss(struct tevent_context *ev_ctx,
 360                                   struct messaging_context *msg_ctx)
 361 {
 362         const struct ndr_interface_table *t = &ndr_table_spoolss;
 363         struct rpc_srv_callbacks spoolss_cb;
 364         enum rpc_daemon_type_e spoolss_type = rpc_spoolss_daemon();
 365         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 366         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 367
 368         if (lp__disable_spoolss()) {
 369                 return NT_STATUS_OK;
 370         }
 371
 372         if (service_mode != RPC_SERVICE_MODE_EMBEDDED ||
 373             spoolss_type != RPC_DAEMON_EMBEDDED) {
 374                 return NT_STATUS_OK;
 375         }
 376
 377         spoolss_cb.init         = spoolss_init_cb;
 378         spoolss_cb.shutdown     = spoolss_shutdown_cb;
 379         spoolss_cb.private_data = msg_ctx;
 380
 381         status = rpc_spoolss_init(&spoolss_cb);
 382         if (!NT_STATUS_IS_OK(status)) {
 383                 return status;;
 384         }
 385
 386         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
 387         if (!NT_STATUS_IS_OK(status)) {
 388                 return status;
 389         }
 390
 391         return NT_STATUS_OK;
 392 }
 393
 394 static bool svcctl_init_cb(void *ptr)
 395 {
 396         struct messaging_context *msg_ctx =
 397                 talloc_get_type_abort(ptr, struct messaging_context);
 398         bool ok;
 399
 400         /* initialize the control hooks */
 401         init_service_op_table();
 402
 403         ok = svcctl_init_winreg(msg_ctx);
 404         if (!ok) {
 405                 return false;
 406         }
 407
 408         return true;
 409 }
 410
 411 static bool svcctl_shutdown_cb(void *ptr)
 412 {
 413         shutdown_service_op_table();
 414
 415         return true;
 416 }
 417
 418 static NTSTATUS rpc_setup_svcctl(struct tevent_context *ev_ctx,
 419                                  struct messaging_context *msg_ctx)
 420 {
 421         const struct ndr_interface_table *t = &ndr_table_svcctl;
 422         const char *pipe_name = "svcctl";
 423         struct rpc_srv_callbacks svcctl_cb;
 424         NTSTATUS status;
 425         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 426
 427         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 428                 return NT_STATUS_OK;
 429         }
 430
 431         svcctl_cb.init         = svcctl_init_cb;
 432         svcctl_cb.shutdown     = svcctl_shutdown_cb;
 433         svcctl_cb.private_data = msg_ctx;
 434
 435         status = rpc_svcctl_init(&svcctl_cb);
 436         if (!NT_STATUS_IS_OK(status)) {
 437                 return status;
 438         }
 439
 440         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, pipe_name);
 441         if (!NT_STATUS_IS_OK(status)) {
 442                 return status;
 443         }
 444
 445         return NT_STATUS_OK;
 446 }
 447
 448 static NTSTATUS rpc_setup_ntsvcs(struct tevent_context *ev_ctx,
 449                                  struct messaging_context *msg_ctx)
 450 {
 451         const struct ndr_interface_table *t = &ndr_table_ntsvcs;
 452         NTSTATUS status;
 453         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 454
 455         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 456                 return NT_STATUS_OK;
 457         }
 458
 459         status = rpc_ntsvcs_init(NULL);
 460         if (!NT_STATUS_IS_OK(status)) {
 461                 return status;
 462         }
 463
 464         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
 465         if (!NT_STATUS_IS_OK(status)) {
 466                 return status;
 467         }
 468
 469         return NT_STATUS_OK;
 470 }
 471
 472 static bool eventlog_init_cb(void *ptr)
 473 {
 474         struct messaging_context *msg_ctx =
 475                 talloc_get_type_abort(ptr, struct messaging_context);
 476         bool ok;
 477
 478         ok = eventlog_init_winreg(msg_ctx);
 479         if (!ok) {
 480                 return false;
 481         }
 482
 483         return true;
 484 }
 485
 486 static NTSTATUS rpc_setup_eventlog(struct tevent_context *ev_ctx,
 487                                    struct messaging_context *msg_ctx)
 488 {
 489         const struct ndr_interface_table *t = &ndr_table_eventlog;
 490         struct rpc_srv_callbacks eventlog_cb;
 491         NTSTATUS status;
 492         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 493
 494         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 495                 return NT_STATUS_OK;
 496         }
 497
 498         eventlog_cb.init         = eventlog_init_cb;
 499         eventlog_cb.shutdown     = NULL;
 500         eventlog_cb.private_data = msg_ctx;
 501
 502         status = rpc_eventlog_init(&eventlog_cb);
 503         if (!NT_STATUS_IS_OK(status)) {
 504                 return status;
 505         }
 506
 507         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
 508         if (!NT_STATUS_IS_OK(status)) {
 509                 return status;
 510         }
 511
 512         return NT_STATUS_OK;
 513 }
 514
 515 static NTSTATUS rpc_setup_initshutdown(struct tevent_context *ev_ctx,
 516                                        struct messaging_context *msg_ctx)
 517 {
 518         const struct ndr_interface_table *t = &ndr_table_initshutdown;
 519         NTSTATUS status;
 520         enum rpc_service_mode_e service_mode = rpc_service_mode(t->name);
 521
 522         if (service_mode != RPC_SERVICE_MODE_EMBEDDED) {
 523                 return NT_STATUS_OK;
 524         }
 525
 526         status = rpc_initshutdown_init(NULL);
 527         if (!NT_STATUS_IS_OK(status)) {
 528                 return status;
 529         }
 530
 531         status = rpc_setup_embedded(ev_ctx, msg_ctx, t, NULL);
 532         if (!NT_STATUS_IS_OK(status)) {
 533                 return status;
 534         }
 535
 536         return NT_STATUS_OK;
 537 }
 538
 539 NTSTATUS dcesrv_ep_setup(struct tevent_context *ev_ctx,
 540                          struct messaging_context *msg_ctx)
 541 {
 542         TALLOC_CTX *tmp_ctx;
 543         bool ok;
 544         init_module_fn *mod_init_fns = NULL;
 545         NTSTATUS status;
 546
 547         tmp_ctx = talloc_stackframe();
 548         if (tmp_ctx == NULL) {
 549                 return NT_STATUS_NO_MEMORY;
 550         }
 551
 552         status = rpc_setup_winreg(ev_ctx, msg_ctx);
 553         if (!NT_STATUS_IS_OK(status)) {
 554                 goto done;
 555         }
 556
 557         status = rpc_setup_srvsvc(ev_ctx, msg_ctx);
 558         if (!NT_STATUS_IS_OK(status)) {
 559                 goto done;
 560         }
 561
 562         status = rpc_setup_lsarpc(ev_ctx, msg_ctx);
 563         if (!NT_STATUS_IS_OK(status)) {
 564                 goto done;
 565         }
 566
 567         status = rpc_setup_samr(ev_ctx, msg_ctx);
 568         if (!NT_STATUS_IS_OK(status)) {
 569                 goto done;
 570         }
 571
 572         status = rpc_setup_netlogon(ev_ctx, msg_ctx);
 573         if (!NT_STATUS_IS_OK(status)) {
 574                 goto done;
 575         }
 576
 577         status = rpc_setup_netdfs(ev_ctx, msg_ctx);
 578         if (!NT_STATUS_IS_OK(status)) {
 579                 goto done;
 580         }
 581
 582 #ifdef DEVELOPER
 583         status = rpc_setup_rpcecho(ev_ctx, msg_ctx);
 584         if (!NT_STATUS_IS_OK(status)) {
 585                 goto done;
 586         }
 587 #endif
 588
 589         status = rpc_setup_dssetup(ev_ctx, msg_ctx);
 590         if (!NT_STATUS_IS_OK(status)) {
 591                 goto done;
 592         }
 593
 594         status = rpc_setup_wkssvc(ev_ctx, msg_ctx);
 595         if (!NT_STATUS_IS_OK(status)) {
 596                 goto done;
 597         }
 598
 599         status = rpc_setup_spoolss(ev_ctx, msg_ctx);
 600         if (!NT_STATUS_IS_OK(status)) {
 601                 goto done;
 602         }
 603
 604         status = rpc_setup_svcctl(ev_ctx, msg_ctx);
 605         if (!NT_STATUS_IS_OK(status)) {
 606                 goto done;
 607         }
 608
 609         status = rpc_setup_ntsvcs(ev_ctx, msg_ctx);
 610         if (!NT_STATUS_IS_OK(status)) {
 611                 goto done;
 612         }
 613
 614         status = rpc_setup_eventlog(ev_ctx, msg_ctx);
 615         if (!NT_STATUS_IS_OK(status)) {
 616                 goto done;
 617         }
 618
 619         status = rpc_setup_initshutdown(ev_ctx, msg_ctx);
 620         if (!NT_STATUS_IS_OK(status)) {
 621                 goto done;
 622         }
 623
 624         DBG_INFO("Initializing DCE/RPC modules\n");
 625
 626         /* Initialize static subsystems */
 627         static_init_rpc(NULL);
 628
 629         /* Initialize shared modules */
 630         mod_init_fns = load_samba_modules(tmp_ctx, "rpc");
 631         if ((mod_init_fns == NULL) && (errno != ENOENT)) {
 632                 /*
 633                  * ENOENT means the directory doesn't exist which can happen if
 634                  * all modules are static. So ENOENT is ok, everything else is
 635                  * not ok.
 636                  */
 637                 DBG_ERR("Loading shared DCE/RPC modules failed [%s]\n",
 638                         strerror(errno));
 639                 status = NT_STATUS_UNSUCCESSFUL;
 640                 goto done;
 641         }
 642
 643         ok = run_init_functions(NULL, mod_init_fns);
 644         if (!ok) {
 645                 DBG_ERR("Initializing shared DCE/RPC modules failed\n");
 646                 status = NT_STATUS_UNSUCCESSFUL;
 647                 goto done;
 648         }
 649
 650         ok = setup_rpc_modules(ev_ctx, msg_ctx);
 651         if (!ok) {
 652                 DBG_ERR("Shared DCE/RPC modules setup failed\n");
 653                 status = NT_STATUS_UNSUCCESSFUL;
 654                 goto done;
 655         }
 656
 657         status = NT_STATUS_OK;
 658 done:
 659         talloc_free(tmp_ctx);
 660         return status;
 661 }
 662
 663 /* vim: set ts=8 sw=8 noet cindent ft=c.doxygen: */