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