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