source3/rpc_server/rpc_ep_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
  24 #include "../librpc/gen_ndr/srv_epmapper.h"
  25 #include "../librpc/gen_ndr/srv_srvsvc.h"
  26 #include "../librpc/gen_ndr/srv_winreg.h"
  27 #include "../librpc/gen_ndr/srv_dfs.h"
  28 #include "../librpc/gen_ndr/srv_dssetup.h"
  29 #include "../librpc/gen_ndr/srv_echo.h"
  30 #include "../librpc/gen_ndr/srv_eventlog.h"
  31 #include "../librpc/gen_ndr/srv_initshutdown.h"
  32 #include "../librpc/gen_ndr/srv_lsa.h"
  33 #include "../librpc/gen_ndr/srv_netlogon.h"
  34 #include "../librpc/gen_ndr/srv_ntsvcs.h"
  35 #include "../librpc/gen_ndr/srv_samr.h"
  36 #include "../librpc/gen_ndr/srv_spoolss.h"
  37 #include "../librpc/gen_ndr/srv_svcctl.h"
  38 #include "../librpc/gen_ndr/srv_wkssvc.h"
  39
  40 #include "printing/nt_printing_migrate.h"
  41 #include "rpc_server/eventlog/srv_eventlog_reg.h"
  42 #include "rpc_server/svcctl/srv_svcctl_reg.h"
  43
  44 #include "librpc/rpc/dcerpc_ep.h"
  45
  46 #include "rpc_server/rpc_ep_setup.h"
  47
  48 struct dcesrv_ep_context {
  49         struct tevent_context *ev_ctx;
  50         struct messaging_context *msg_ctx;
  51 };
  52
  53 static NTSTATUS _rpc_ep_register(const struct ndr_interface_table *iface,
  54                                  const char *name)
  55 {
  56         struct dcerpc_binding_vector *v = NULL;
  57         NTSTATUS status;
  58         const char *rpcsrv_type;
  59
  60         /* start endpoint mapper only if enabled */
  61         rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
  62                                            "rpc_server", "epmapper",
  63                                            "none");
  64         if (StrCaseCmp(rpcsrv_type, "none") == 0) {
  65                 return NT_STATUS_OK;
  66         }
  67
  68         status = dcerpc_binding_vector_create(talloc_tos(),
  69                                               iface,
  70                                               &v);
  71         if (!NT_STATUS_IS_OK(status)) {
  72                 return status;
  73         }
  74
  75         status = dcerpc_ep_register(iface,
  76                                     v,
  77                                     &iface->syntax_id.uuid,
  78                                     name);
  79         if (!NT_STATUS_IS_OK(status)) {
  80                 return status;
  81         }
  82
  83         return status;
  84 }
  85
  86 static NTSTATUS _rpc_ep_unregister(const struct ndr_interface_table *iface)
  87 {
  88         struct dcerpc_binding_vector *v = NULL;
  89         NTSTATUS status;
  90         const char *rpcsrv_type;
  91
  92         /* start endpoint mapper only if enabled */
  93         rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
  94                                            "rpc_server", "epmapper",
  95                                            "none");
  96         if (StrCaseCmp(rpcsrv_type, "none") == 0) {
  97                 return NT_STATUS_OK;
  98         }
  99
 100         status = dcerpc_binding_vector_create(talloc_tos(),
 101                                               iface,
 102                                               &v);
 103         if (!NT_STATUS_IS_OK(status)) {
 104                 return status;
 105         }
 106
 107         status = dcerpc_ep_unregister(iface,
 108                                       v,
 109                                       &iface->syntax_id.uuid);
 110         if (!NT_STATUS_IS_OK(status)) {
 111                 return status;
 112         }
 113
 114         return status;
 115 }
 116
 117 static bool winreg_init_cb(void *ptr)
 118 {
 119         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_winreg, "winreg"));
 120 }
 121
 122 static bool winreg_shutdown_cb(void *ptr)
 123 {
 124         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_winreg));
 125 }
 126
 127 static bool srvsvc_init_cb(void *ptr)
 128 {
 129         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_srvsvc, "srvsvc"));
 130 }
 131
 132 static bool srvsvc_shutdown_cb(void *ptr)
 133 {
 134         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_srvsvc));
 135 }
 136
 137 static bool lsarpc_init_cb(void *ptr)
 138 {
 139         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_lsarpc, "lsarpc"));
 140 }
 141
 142 static bool lsarpc_shutdown_cb(void *ptr)
 143 {
 144         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_lsarpc));
 145 }
 146
 147 static bool samr_init_cb(void *ptr)
 148 {
 149         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_samr, "samr"));
 150 }
 151
 152 static bool samr_shutdown_cb(void *ptr)
 153 {
 154         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_samr));
 155 }
 156
 157 static bool netlogon_init_cb(void *ptr)
 158 {
 159         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_netlogon, "netlogon"));
 160 }
 161
 162 static bool netlogon_shutdown_cb(void *ptr)
 163 {
 164         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_netlogon));
 165 }
 166
 167 static bool spoolss_init_cb(void *ptr)
 168 {
 169         struct dcesrv_ep_context *ep_ctx =
 170                 talloc_get_type_abort(ptr, struct dcesrv_ep_context);
 171         NTSTATUS status;
 172         bool ok;
 173
 174         /*
 175          * Migrate the printers first.
 176          */
 177         ok = nt_printing_tdb_migrate(ep_ctx->msg_ctx);
 178         if (!ok) {
 179                 return false;
 180         }
 181
 182         status =_rpc_ep_register(&ndr_table_spoolss, "spoolss");
 183         if (!NT_STATUS_IS_OK(status)) {
 184                 return false;
 185         }
 186
 187         return true;
 188 }
 189
 190
 191
 192 static bool spoolss_shutdown_cb(void *ptr)
 193 {
 194         srv_spoolss_cleanup();
 195
 196         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_spoolss));
 197 }
 198
 199 static bool svcctl_init_cb(void *ptr)
 200 {
 201         struct dcesrv_ep_context *ep_ctx =
 202                 talloc_get_type_abort(ptr, struct dcesrv_ep_context);
 203         bool ok;
 204
 205         ok = svcctl_init_winreg(ep_ctx->msg_ctx);
 206         if (!ok) {
 207                 return false;
 208         }
 209
 210         /* initialize the control hooks */
 211         init_service_op_table();
 212
 213         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_svcctl, "svcctl"));
 214 }
 215
 216 static bool svcctl_shutdown_cb(void *ptr)
 217 {
 218         shutdown_service_op_table();
 219
 220         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_svcctl));
 221 }
 222
 223 static bool ntsvcs_init_cb(void *ptr)
 224 {
 225         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_ntsvcs, "ntsvcs"));
 226 }
 227
 228 static bool ntsvcs_shutdown_cb(void *ptr)
 229 {
 230         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_ntsvcs));
 231 }
 232
 233 static bool eventlog_init_cb(void *ptr)
 234 {
 235         struct dcesrv_ep_context *ep_ctx =
 236                 talloc_get_type_abort(ptr, struct dcesrv_ep_context);
 237         NTSTATUS status;
 238
 239         status =_rpc_ep_register(&ndr_table_eventlog,
 240                                  "eventlog");
 241         if (!NT_STATUS_IS_OK(status)) {
 242                 return false;
 243         }
 244
 245         return eventlog_init_winreg(ep_ctx->msg_ctx);
 246 }
 247
 248 static bool eventlog_shutdown_cb(void *ptr)
 249 {
 250         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_eventlog));
 251 }
 252
 253 static bool initshutdown_init_cb(void *ptr)
 254 {
 255         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_initshutdown,
 256                                                 "initshutdown"));
 257 }
 258
 259 static bool initshutdown_shutdown_cb(void *ptr)
 260 {
 261         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_initshutdown));
 262 }
 263 #ifdef DEVELOPER
 264 static bool rpcecho_init_cb(void *ptr) {
 265         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_rpcecho, "rpcecho"));
 266 }
 267
 268 static bool rpcecho_shutdown_cb(void *ptr)
 269 {
 270         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_rpcecho));
 271 }
 272 #endif
 273 static bool netdfs_init_cb(void *ptr)
 274 {
 275         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_netdfs, "netdfs"));
 276 }
 277
 278 static bool netdfs_shutdown_cb(void *ptr) {
 279         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_netdfs));
 280 }
 281
 282 static bool dssetup_init_cb(void *ptr) {
 283         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_dssetup, "dssetup"));
 284 }
 285
 286 static bool dssetup_shutdown_cb(void *ptr) {
 287         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_dssetup));
 288 }
 289
 290 static bool wkssvc_init_cb(void *ptr) {
 291         return NT_STATUS_IS_OK(_rpc_ep_register(&ndr_table_wkssvc, "wkssvc"));
 292 }
 293
 294 static bool wkssvc_shutdown_cb(void *ptr) {
 295         return NT_STATUS_IS_OK(_rpc_ep_unregister(&ndr_table_wkssvc));
 296 }
 297
 298 bool dcesrv_ep_setup(struct tevent_context *ev_ctx,
 299                      struct messaging_context *msg_ctx)
 300 {
 301         struct dcesrv_ep_context *ep_ctx;
 302
 303         struct rpc_srv_callbacks winreg_cb;
 304         struct rpc_srv_callbacks srvsvc_cb;
 305
 306         struct rpc_srv_callbacks lsarpc_cb;
 307         struct rpc_srv_callbacks samr_cb;
 308         struct rpc_srv_callbacks netlogon_cb;
 309
 310         struct rpc_srv_callbacks spoolss_cb;
 311         struct rpc_srv_callbacks svcctl_cb;
 312         struct rpc_srv_callbacks ntsvcs_cb;
 313         struct rpc_srv_callbacks eventlog_cb;
 314         struct rpc_srv_callbacks initshutdown_cb;
 315         struct rpc_srv_callbacks netdfs_cb;
 316 #ifdef DEVELOPER
 317         struct rpc_srv_callbacks rpcecho_cb;
 318 #endif
 319         struct rpc_srv_callbacks dssetup_cb;
 320         struct rpc_srv_callbacks wkssvc_cb;
 321
 322         const char *rpcsrv_type;
 323
 324         ep_ctx = talloc(ev_ctx, struct dcesrv_ep_context);
 325         if (ep_ctx == NULL) {
 326                 return false;
 327         }
 328
 329         ep_ctx->ev_ctx = ev_ctx;
 330         ep_ctx->msg_ctx = msg_ctx;
 331
 332         /* start endpoint mapper only if enabled */
 333         rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
 334                                            "rpc_server", "epmapper",
 335                                            "none");
 336         if (StrCaseCmp(rpcsrv_type, "embedded") == 0) {
 337                 if (!NT_STATUS_IS_OK(rpc_epmapper_init(NULL))) {
 338                         return false;
 339                 }
 340         }
 341
 342         winreg_cb.init         = winreg_init_cb;
 343         winreg_cb.shutdown     = winreg_shutdown_cb;
 344         winreg_cb.private_data = ep_ctx;
 345         if (!NT_STATUS_IS_OK(rpc_winreg_init(&winreg_cb))) {
 346                 return false;
 347         }
 348
 349         srvsvc_cb.init         = srvsvc_init_cb;
 350         srvsvc_cb.shutdown     = srvsvc_shutdown_cb;
 351         srvsvc_cb.private_data = ep_ctx;
 352         if (!NT_STATUS_IS_OK(rpc_srvsvc_init(&srvsvc_cb))) {
 353                 return false;
 354         }
 355
 356
 357         lsarpc_cb.init         = lsarpc_init_cb;
 358         lsarpc_cb.shutdown     = lsarpc_shutdown_cb;
 359         lsarpc_cb.private_data = ep_ctx;
 360         if (!NT_STATUS_IS_OK(rpc_lsarpc_init(&lsarpc_cb))) {
 361                 return false;
 362         }
 363
 364         samr_cb.init         = samr_init_cb;
 365         samr_cb.shutdown     = samr_shutdown_cb;
 366         samr_cb.private_data = ep_ctx;
 367         if (!NT_STATUS_IS_OK(rpc_samr_init(&samr_cb))) {
 368                 return false;
 369         }
 370
 371         netlogon_cb.init         = netlogon_init_cb;
 372         netlogon_cb.shutdown     = netlogon_shutdown_cb;
 373         netlogon_cb.private_data = ep_ctx;
 374         if (!NT_STATUS_IS_OK(rpc_netlogon_init(&netlogon_cb))) {
 375                 return false;
 376         }
 377
 378         spoolss_cb.init         = spoolss_init_cb;
 379         spoolss_cb.shutdown     = spoolss_shutdown_cb;
 380         spoolss_cb.private_data = ep_ctx;
 381         if (!NT_STATUS_IS_OK(rpc_spoolss_init(&spoolss_cb))) {
 382                 return false;
 383         }
 384
 385
 386         svcctl_cb.init         = svcctl_init_cb;
 387         svcctl_cb.shutdown     = svcctl_shutdown_cb;
 388         svcctl_cb.private_data = ep_ctx;
 389         if (!NT_STATUS_IS_OK(rpc_svcctl_init(&svcctl_cb))) {
 390                 return false;
 391         }
 392
 393         ntsvcs_cb.init         = ntsvcs_init_cb;
 394         ntsvcs_cb.shutdown     = ntsvcs_shutdown_cb;
 395         ntsvcs_cb.private_data = ep_ctx;
 396         if (!NT_STATUS_IS_OK(rpc_ntsvcs_init(&ntsvcs_cb))) {
 397                 return false;
 398         }
 399
 400         eventlog_cb.init         = eventlog_init_cb;
 401         eventlog_cb.shutdown     = eventlog_shutdown_cb;
 402         eventlog_cb.private_data = ep_ctx;
 403         if (!NT_STATUS_IS_OK(rpc_eventlog_init(&eventlog_cb))) {
 404                 return false;
 405         }
 406
 407         initshutdown_cb.init         = initshutdown_init_cb;
 408         initshutdown_cb.shutdown     = initshutdown_shutdown_cb;
 409         initshutdown_cb.private_data = ep_ctx;
 410         if (!NT_STATUS_IS_OK(rpc_initshutdown_init(&initshutdown_cb))) {
 411                 return false;
 412         }
 413
 414         netdfs_cb.init         = netdfs_init_cb;
 415         netdfs_cb.shutdown     = netdfs_shutdown_cb;
 416         netdfs_cb.private_data = ep_ctx;
 417         if (!NT_STATUS_IS_OK(rpc_netdfs_init(&netdfs_cb))) {
 418                 return false;
 419         }
 420 #ifdef DEVELOPER
 421
 422         rpcecho_cb.init         = rpcecho_init_cb;
 423         rpcecho_cb.shutdown     = rpcecho_shutdown_cb;
 424         rpcecho_cb.private_data = ep_ctx;
 425         if (!NT_STATUS_IS_OK(rpc_rpcecho_init(&rpcecho_cb))) {
 426                 return false;
 427         }
 428 #endif
 429
 430         dssetup_cb.init         = dssetup_init_cb;
 431         dssetup_cb.shutdown     = dssetup_shutdown_cb;
 432         dssetup_cb.private_data = ep_ctx;
 433         if (!NT_STATUS_IS_OK(rpc_dssetup_init(&dssetup_cb))) {
 434                 return false;
 435         }
 436
 437         wkssvc_cb.init         = wkssvc_init_cb;
 438         wkssvc_cb.shutdown     = wkssvc_shutdown_cb;
 439         wkssvc_cb.private_data = ep_ctx;
 440         if (!NT_STATUS_IS_OK(rpc_wkssvc_init(&wkssvc_cb))) {
 441                 return false;
 442         }
 443
 444         return true;
 445 }
 446
 447 /* vim: set ts=8 sw=8 noet cindent ft=c.doxygen: */