source3/winbindd/winbindd_dual_ndr.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Provide parent->child communication based on NDR marshalling
   5
   6    Copyright (C) Volker Lendecke 2009
   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 /*
  23  * This file implements an RPC between winbind parent and child processes,
  24  * leveraging the autogenerated marshalling routines for MSRPC. This is not
  25  * MSRPC, as it does not go through the whole DCERPC fragmentation, we just
  26  * leverage much the same infrastructure we already have for it.
  27  */
  28
  29 #include "includes.h"
  30 #include "winbindd/winbindd.h"
  31 #include "winbindd/winbindd_proto.h"
  32 #include "librpc/gen_ndr/srv_wbint.h"
  33
  34 struct wb_ndr_transport_priv {
  35         struct winbindd_domain *domain;
  36         struct winbindd_child *child;
  37 };
  38
  39 struct wb_ndr_dispatch_state {
  40         struct wb_ndr_transport_priv *transport;
  41         uint32_t opnum;
  42         const struct ndr_interface_call *call;
  43         void *r;
  44         DATA_BLOB req_blob, resp_blob;
  45         struct winbindd_request request;
  46         struct winbindd_response *response;
  47 };
  48
  49 static void wb_ndr_dispatch_done(struct tevent_req *subreq);
  50
  51 static struct tevent_req *wb_ndr_dispatch_send(TALLOC_CTX *mem_ctx,
  52                                                struct tevent_context *ev,
  53                                                struct rpc_pipe_client *cli,
  54                                                const struct ndr_interface_table *table,
  55                                                uint32_t opnum,
  56                                                void *r)
  57 {
  58         struct tevent_req *req, *subreq;
  59         struct wb_ndr_dispatch_state *state;
  60         struct wb_ndr_transport_priv *transport = talloc_get_type_abort(
  61                 cli->transport->priv, struct wb_ndr_transport_priv);
  62         struct ndr_push *push;
  63         enum ndr_err_code ndr_err;
  64
  65         req = tevent_req_create(mem_ctx, &state,
  66                                 struct wb_ndr_dispatch_state);
  67         if (req == NULL) {
  68                 return NULL;
  69         }
  70
  71         state->r = r;
  72         state->call = &table->calls[opnum];
  73         state->transport = transport;
  74         state->opnum = opnum;
  75
  76         push = ndr_push_init_ctx(state, NULL);
  77         if (tevent_req_nomem(push, req)) {
  78                 return tevent_req_post(req, ev);
  79         }
  80
  81         ndr_err = state->call->ndr_push(push, NDR_IN, r);
  82         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  83                 tevent_req_nterror(req, ndr_map_error2ntstatus(ndr_err));
  84                 TALLOC_FREE(push);
  85                 return tevent_req_post(req, ev);
  86         }
  87
  88         state->req_blob = ndr_push_blob(push);
  89
  90         if ((transport->domain != NULL)
  91             && wcache_fetch_ndr(state, transport->domain, opnum,
  92                                 &state->req_blob, &state->resp_blob)) {
  93                 tevent_req_done(req);
  94                 return tevent_req_post(req, ev);
  95         }
  96
  97         state->request.cmd = WINBINDD_DUAL_NDRCMD;
  98         state->request.data.ndrcmd = opnum;
  99         state->request.extra_data.data = (char *)state->req_blob.data;
 100         state->request.extra_len = state->req_blob.length;
 101
 102         subreq = wb_child_request_send(state, ev, transport->child,
 103                                        &state->request);
 104         if (tevent_req_nomem(subreq, req)) {
 105                 return tevent_req_post(req, ev);
 106         }
 107         tevent_req_set_callback(subreq, wb_ndr_dispatch_done, req);
 108         return req;
 109 }
 110
 111 static void wb_ndr_dispatch_done(struct tevent_req *subreq)
 112 {
 113         struct tevent_req *req = tevent_req_callback_data(
 114                 subreq, struct tevent_req);
 115         struct wb_ndr_dispatch_state *state = tevent_req_data(
 116                 req, struct wb_ndr_dispatch_state);
 117         int ret, err;
 118
 119         ret = wb_child_request_recv(subreq, state, &state->response, &err);
 120         TALLOC_FREE(subreq);
 121         if (ret == -1) {
 122                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 123                 return;
 124         }
 125
 126         state->resp_blob = data_blob_const(
 127                 state->response->extra_data.data,
 128                 state->response->length - sizeof(struct winbindd_response));
 129
 130         if (state->transport->domain != NULL) {
 131                 wcache_store_ndr(state->transport->domain, state->opnum,
 132                                  &state->req_blob, &state->resp_blob);
 133         }
 134
 135         tevent_req_done(req);
 136 }
 137
 138 static NTSTATUS wb_ndr_dispatch_recv(struct tevent_req *req,
 139                                      TALLOC_CTX *mem_ctx)
 140 {
 141         struct wb_ndr_dispatch_state *state = tevent_req_data(
 142                 req, struct wb_ndr_dispatch_state);
 143         NTSTATUS status;
 144         struct ndr_pull *pull;
 145         enum ndr_err_code ndr_err;
 146
 147         if (tevent_req_is_nterror(req, &status)) {
 148                 return status;
 149         }
 150
 151         pull = ndr_pull_init_blob(&state->resp_blob, mem_ctx, NULL);
 152         if (pull == NULL) {
 153                 return NT_STATUS_NO_MEMORY;
 154         }
 155
 156         /* have the ndr parser alloc memory for us */
 157         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 158         ndr_err = state->call->ndr_pull(pull, NDR_OUT, state->r);
 159         TALLOC_FREE(pull);
 160
 161         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 162                 return ndr_map_error2ntstatus(ndr_err);
 163         }
 164
 165         return NT_STATUS_OK;
 166 }
 167
 168 static NTSTATUS wb_ndr_dispatch(struct rpc_pipe_client *cli,
 169                                 TALLOC_CTX *mem_ctx,
 170                                 const struct ndr_interface_table *table,
 171                                 uint32_t opnum, void *r)
 172 {
 173         TALLOC_CTX *frame = talloc_stackframe();
 174         struct event_context *ev;
 175         struct tevent_req *req;
 176         NTSTATUS status = NT_STATUS_OK;
 177
 178         ev = event_context_init(frame);
 179         if (ev == NULL) {
 180                 status = NT_STATUS_NO_MEMORY;
 181                 goto fail;
 182         }
 183
 184         req = wb_ndr_dispatch_send(frame, ev, cli, table, opnum, r);
 185         if (req == NULL) {
 186                 status = NT_STATUS_NO_MEMORY;
 187                 goto fail;
 188         }
 189
 190         if (!tevent_req_poll(req, ev)) {
 191                 status = map_nt_error_from_unix(errno);
 192                 goto fail;
 193         }
 194
 195         status = wb_ndr_dispatch_recv(req, mem_ctx);
 196  fail:
 197         TALLOC_FREE(frame);
 198         return status;
 199 }
 200
 201 struct rpc_pipe_client *wbint_rpccli_create(TALLOC_CTX *mem_ctx,
 202                                             struct winbindd_domain *domain,
 203                                             struct winbindd_child *child)
 204 {
 205         struct rpc_pipe_client *result;
 206         struct wb_ndr_transport_priv *transp;
 207
 208         result = talloc(mem_ctx, struct rpc_pipe_client);
 209         if (result == NULL) {
 210                 return NULL;
 211         }
 212         result->abstract_syntax = ndr_table_wbint.syntax_id;
 213         result->transfer_syntax = ndr_transfer_syntax;
 214         result->dispatch = wb_ndr_dispatch;
 215         result->dispatch_send = wb_ndr_dispatch_send;
 216         result->dispatch_recv = wb_ndr_dispatch_recv;
 217         result->max_xmit_frag = RPC_MAX_PDU_FRAG_LEN;
 218         result->max_recv_frag = RPC_MAX_PDU_FRAG_LEN;
 219         result->desthost = NULL;
 220         result->srv_name_slash = NULL;
 221
 222         /*
 223          * Initialize a fake transport. Due to our own wb_ndr_dispatch
 224          * function we don't use all the fragmentation engine in
 225          * cli_pipe, which would use all the _read and _write
 226          * functions in rpc_cli_transport. But we need a place to
 227          * store the child struct in, and we're re-using
 228          * result->transport->priv for that.
 229          */
 230
 231         result->transport = talloc_zero(result, struct rpc_cli_transport);
 232         if (result->transport == NULL) {
 233                 TALLOC_FREE(result);
 234                 return NULL;
 235         }
 236         transp = talloc(result->transport, struct wb_ndr_transport_priv);
 237         if (transp == NULL) {
 238                 TALLOC_FREE(result);
 239                 return NULL;
 240         }
 241         transp->domain = domain;
 242         transp->child = child;
 243         result->transport->priv = transp;
 244         return result;
 245 }
 246
 247 enum winbindd_result winbindd_dual_ndrcmd(struct winbindd_domain *domain,
 248                                           struct winbindd_cli_state *state)
 249 {
 250         pipes_struct p;
 251         struct api_struct *fns;
 252         int num_fns;
 253         bool ret;
 254
 255         wbint_get_pipe_fns(&fns, &num_fns);
 256
 257         if (state->request->data.ndrcmd >= num_fns) {
 258                 return WINBINDD_ERROR;
 259         }
 260
 261         DEBUG(10, ("winbindd_dual_ndrcmd: Running command %s (%s)\n",
 262                    fns[state->request->data.ndrcmd].name,
 263                    domain ? domain->name : "no domain"));
 264
 265         ZERO_STRUCT(p);
 266         p.mem_ctx = talloc_stackframe();
 267         p.in_data.data.buffer_size = state->request->extra_len;
 268         p.in_data.data.data_p = state->request->extra_data.data;
 269         prs_init(&p.out_data.rdata, 0, state->mem_ctx, false);
 270
 271         ret = fns[state->request->data.ndrcmd].fn(&p);
 272         TALLOC_FREE(p.mem_ctx);
 273         if (!ret) {
 274                 return WINBINDD_ERROR;
 275         }
 276
 277         state->response->extra_data.data =
 278                 talloc_memdup(state->mem_ctx, p.out_data.rdata.data_p,
 279                               p.out_data.rdata.data_offset);
 280         state->response->length += p.out_data.rdata.data_offset;
 281         prs_mem_free(&p.out_data.rdata);
 282         if (state->response->extra_data.data == NULL) {
 283                 return WINBINDD_ERROR;
 284         }
 285         return WINBINDD_OK;
 286 }
 287
 288 /*
 289  * Just a dummy to make srv_wbint.c happy
 290  */
 291 NTSTATUS rpc_srv_register(int version, const char *clnt, const char *srv,
 292                           const struct ndr_interface_table *iface,
 293                           const struct api_struct *cmds, int size)
 294 {
 295         return NT_STATUS_OK;
 296 }