source3/rpc_client/rpc_transport_sock.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC client transport over a socket
   4  *  Copyright (C) Volker Lendecke 2009
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21
  22 #undef DBGC_CLASS
  23 #define DBGC_CLASS DBGC_RPC_CLI
  24
  25 struct rpc_transport_sock_state {
  26         int fd;
  27         int timeout;
  28 };
  29
  30 static void rpc_sock_disconnect(struct rpc_transport_sock_state *s)
  31 {
  32         if (s->fd != -1) {
  33                 close(s->fd);
  34                 s->fd = -1;
  35         }
  36 }
  37
  38 static int rpc_transport_sock_state_destructor(struct rpc_transport_sock_state *s)
  39 {
  40         rpc_sock_disconnect(s);
  41         return 0;
  42 }
  43
  44 static bool rpc_sock_is_connected(void *priv)
  45 {
  46         struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort(
  47                 priv, struct rpc_transport_sock_state);
  48
  49         if (sock_transp->fd == -1) {
  50                 return false;
  51         }
  52
  53         return true;
  54 }
  55
  56 struct rpc_sock_read_state {
  57         struct rpc_transport_sock_state *transp;
  58         ssize_t received;
  59 };
  60
  61 static void rpc_sock_read_done(struct tevent_req *subreq);
  62
  63 static struct tevent_req *rpc_sock_read_send(TALLOC_CTX *mem_ctx,
  64                                              struct event_context *ev,
  65                                              uint8_t *data, size_t size,
  66                                              void *priv)
  67 {
  68         struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort(
  69                 priv, struct rpc_transport_sock_state);
  70         struct tevent_req *req, *subreq;
  71         struct rpc_sock_read_state *state;
  72         struct timeval endtime;
  73
  74         req = tevent_req_create(mem_ctx, &state, struct rpc_sock_read_state);
  75         if (req == NULL) {
  76                 return NULL;
  77         }
  78         if (!rpc_sock_is_connected(sock_transp)) {
  79                 tevent_req_nterror(req, NT_STATUS_CONNECTION_INVALID);
  80                 return tevent_req_post(req, ev);
  81         }
  82         state->transp = sock_transp;
  83         endtime = timeval_current_ofs(0, sock_transp->timeout * 1000);
  84         subreq = async_recv_send(state, ev, sock_transp->fd, data, size, 0);
  85         if (subreq == NULL) {
  86                 goto fail;
  87         }
  88
  89         if (!tevent_req_set_endtime(subreq, ev, endtime)) {
  90                 goto fail;
  91         }
  92
  93         tevent_req_set_callback(subreq, rpc_sock_read_done, req);
  94         return req;
  95  fail:
  96         TALLOC_FREE(req);
  97         return NULL;
  98 }
  99
 100 static void rpc_sock_read_done(struct tevent_req *subreq)
 101 {
 102         struct tevent_req *req = tevent_req_callback_data(
 103                 subreq, struct tevent_req);
 104         struct rpc_sock_read_state *state = tevent_req_data(
 105                 req, struct rpc_sock_read_state);
 106         int err;
 107
 108         /* We must free subreq in this function as there is
 109           a timer event attached to it. */
 110
 111         state->received = async_recv_recv(subreq, &err);
 112
 113         if (state->received == -1) {
 114                 TALLOC_FREE(subreq);
 115                 rpc_sock_disconnect(state->transp);
 116                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 117                 return;
 118         }
 119         TALLOC_FREE(subreq);
 120         tevent_req_done(req);
 121 }
 122
 123 static NTSTATUS rpc_sock_read_recv(struct tevent_req *req, ssize_t *preceived)
 124 {
 125         struct rpc_sock_read_state *state = tevent_req_data(
 126                 req, struct rpc_sock_read_state);
 127         NTSTATUS status;
 128
 129         if (tevent_req_is_nterror(req, &status)) {
 130                 return status;
 131         }
 132         *preceived = state->received;
 133         return NT_STATUS_OK;
 134 }
 135
 136 struct rpc_sock_write_state {
 137         struct rpc_transport_sock_state *transp;
 138         ssize_t sent;
 139 };
 140
 141 static void rpc_sock_write_done(struct tevent_req *subreq);
 142
 143 static struct tevent_req *rpc_sock_write_send(TALLOC_CTX *mem_ctx,
 144                                               struct event_context *ev,
 145                                               const uint8_t *data, size_t size,
 146                                               void *priv)
 147 {
 148         struct rpc_transport_sock_state *sock_transp = talloc_get_type_abort(
 149                 priv, struct rpc_transport_sock_state);
 150         struct tevent_req *req, *subreq;
 151         struct rpc_sock_write_state *state;
 152         struct timeval endtime;
 153
 154         req = tevent_req_create(mem_ctx, &state, struct rpc_sock_write_state);
 155         if (req == NULL) {
 156                 return NULL;
 157         }
 158         if (!rpc_sock_is_connected(sock_transp)) {
 159                 tevent_req_nterror(req, NT_STATUS_CONNECTION_INVALID);
 160                 return tevent_req_post(req, ev);
 161         }
 162         state->transp = sock_transp;
 163         endtime = timeval_current_ofs(0, sock_transp->timeout * 1000);
 164         subreq = async_send_send(state, ev, sock_transp->fd, data, size, 0);
 165         if (subreq == NULL) {
 166                 goto fail;
 167         }
 168
 169         if (!tevent_req_set_endtime(subreq, ev, endtime)) {
 170                 goto fail;
 171         }
 172
 173         tevent_req_set_callback(subreq, rpc_sock_write_done, req);
 174         return req;
 175  fail:
 176         TALLOC_FREE(req);
 177         return NULL;
 178 }
 179
 180 static void rpc_sock_write_done(struct tevent_req *subreq)
 181 {
 182         struct tevent_req *req = tevent_req_callback_data(
 183                 subreq, struct tevent_req);
 184         struct rpc_sock_write_state *state = tevent_req_data(
 185                 req, struct rpc_sock_write_state);
 186         int err;
 187
 188         /* We must free subreq in this function as there is
 189           a timer event attached to it. */
 190
 191         state->sent = async_send_recv(subreq, &err);
 192
 193         if (state->sent == -1) {
 194                 TALLOC_FREE(subreq);
 195                 rpc_sock_disconnect(state->transp);
 196                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 197                 return;
 198         }
 199         TALLOC_FREE(subreq);
 200         tevent_req_done(req);
 201 }
 202
 203 static NTSTATUS rpc_sock_write_recv(struct tevent_req *req, ssize_t *psent)
 204 {
 205         struct rpc_sock_write_state *state = tevent_req_data(
 206                 req, struct rpc_sock_write_state);
 207         NTSTATUS status;
 208
 209         if (tevent_req_is_nterror(req, &status)) {
 210                 return status;
 211         }
 212         *psent = state->sent;
 213         return NT_STATUS_OK;
 214 }
 215
 216 NTSTATUS rpc_transport_sock_init(TALLOC_CTX *mem_ctx, int fd,
 217                                  struct rpc_cli_transport **presult)
 218 {
 219         struct rpc_cli_transport *result;
 220         struct rpc_transport_sock_state *state;
 221
 222         result = talloc(mem_ctx, struct rpc_cli_transport);
 223         if (result == NULL) {
 224                 return NT_STATUS_NO_MEMORY;
 225         }
 226         state = talloc(result, struct rpc_transport_sock_state);
 227         if (state == NULL) {
 228                 TALLOC_FREE(result);
 229                 return NT_STATUS_NO_MEMORY;
 230         }
 231         result->priv = state;
 232
 233         state->fd = fd;
 234         state->timeout = 10000; /* 10 seconds. */
 235         talloc_set_destructor(state, rpc_transport_sock_state_destructor);
 236
 237         result->trans_send = NULL;
 238         result->trans_recv = NULL;
 239         result->write_send = rpc_sock_write_send;
 240         result->write_recv = rpc_sock_write_recv;
 241         result->read_send = rpc_sock_read_send;
 242         result->read_recv = rpc_sock_read_recv;
 243         result->is_connected = rpc_sock_is_connected;
 244
 245         *presult = result;
 246         return NT_STATUS_OK;
 247 }
 248
 249 int rpccli_set_sock_timeout(struct rpc_pipe_client *cli, int timeout)
 250 {
 251         struct rpc_transport_sock_state *state = talloc_get_type(cli->transport->priv,
 252                                                         struct rpc_transport_sock_state);
 253         int orig_timeout;
 254         if (!state) {
 255                 return 0;
 256         }
 257         orig_timeout = state->timeout;
 258         state->timeout = timeout;
 259         return orig_timeout;
 260 }
 261
 262 void rpccli_close_sock_fd(struct rpc_pipe_client *cli)
 263 {
 264         struct rpc_transport_sock_state *state = talloc_get_type(cli->transport->priv,
 265                                                         struct rpc_transport_sock_state);
 266         if (state) {
 267                 if (state->fd != -1) {
 268                         close(state->fd);
 269                         state->fd = -1;
 270                 }
 271         }
 272         return;
 273 }
 274
 275 bool rpc_pipe_tcp_connection_ok(struct rpc_pipe_client *cli)
 276 {
 277         struct rpc_transport_sock_state *state = talloc_get_type(cli->transport->priv,
 278                                                         struct rpc_transport_sock_state);
 279         if (state && state->fd != -1) {
 280                 return true;
 281         }
 282
 283         return false;
 284 }