source3/lib/wb_reqtrans.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Async transfer of winbindd_request and _response structs
   5
   6    Copyright (C) Volker Lendecke 2008
   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 #include "wbc_async.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_WINBIND
  27
  28 struct req_read_state {
  29         struct winbindd_request *wb_req;
  30         size_t max_extra_data;
  31 };
  32
  33 bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
  34 {
  35         enum async_req_state state;
  36         uint64_t error;
  37         if (!async_req_is_error(req, &state, &error)) {
  38                 *pwbc_err = WBC_ERR_SUCCESS;
  39                 return false;
  40         }
  41
  42         switch (state) {
  43         case ASYNC_REQ_USER_ERROR:
  44                 *pwbc_err = error;
  45                 break;
  46         case ASYNC_REQ_TIMED_OUT:
  47                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
  48                 break;
  49         case ASYNC_REQ_NO_MEMORY:
  50                 *pwbc_err = WBC_ERR_NO_MEMORY;
  51                 break;
  52         default:
  53                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
  54                 break;
  55         }
  56         return true;
  57 }
  58
  59 wbcErr map_wbc_err_from_errno(int error)
  60 {
  61         switch(error) {
  62         case EPERM:
  63         case EACCES:
  64                 return WBC_ERR_AUTH_ERROR;
  65         case ENOMEM:
  66                 return WBC_ERR_NO_MEMORY;
  67         case EIO:
  68         default:
  69                 return WBC_ERR_UNKNOWN_FAILURE;
  70         }
  71 }
  72
  73 wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
  74 {
  75         wbcErr wbc_err;
  76
  77         if (async_req_is_wbcerr(req, &wbc_err)) {
  78                 return wbc_err;
  79         }
  80
  81         return WBC_ERR_SUCCESS;
  82 }
  83
  84 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
  85 static void wb_req_read_done(struct tevent_req *subreq);
  86
  87 struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
  88                                    struct tevent_context *ev,
  89                                    int fd, size_t max_extra_data)
  90 {
  91         struct async_req *result;
  92         struct tevent_req *subreq;
  93         struct req_read_state *state;
  94
  95         if (!async_req_setup(mem_ctx, &result, &state,
  96                              struct req_read_state)) {
  97                 return NULL;
  98         }
  99         state->max_extra_data = max_extra_data;
 100
 101         subreq = read_packet_send(state, ev, fd, 4, wb_req_more, state);
 102         if (subreq == NULL) {
 103                 goto nomem;
 104         }
 105
 106         subreq->async.fn = wb_req_read_done;
 107         subreq->async.private_data = result;
 108         return result;
 109  nomem:
 110         TALLOC_FREE(result);
 111         return NULL;
 112 }
 113
 114 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
 115 {
 116         struct req_read_state *state = talloc_get_type_abort(
 117                 private_data, struct req_read_state);
 118         struct winbindd_request *req = (struct winbindd_request *)buf;
 119
 120         if (buflen == 4) {
 121                 if (req->length != sizeof(struct winbindd_request)) {
 122                         DEBUG(0, ("wb_req_read_len: Invalid request size "
 123                                   "received: %d (expected %d)\n",
 124                                   (int)req->length,
 125                                   (int)sizeof(struct winbindd_request)));
 126                         return -1;
 127                 }
 128                 return sizeof(struct winbindd_request) - 4;
 129         }
 130
 131         if ((state->max_extra_data != 0)
 132             && (req->extra_len > state->max_extra_data)) {
 133                 DEBUG(3, ("Got request with %d bytes extra data on "
 134                           "unprivileged socket\n", (int)req->extra_len));
 135                 return -1;
 136         }
 137
 138         return req->extra_len;
 139 }
 140
 141 static void wb_req_read_done(struct tevent_req *subreq)
 142 {
 143         struct async_req *req = talloc_get_type_abort(
 144                 subreq->async.private_data, struct async_req);
 145         struct req_read_state *state = talloc_get_type_abort(
 146                 req->private_data, struct req_read_state);
 147         int err;
 148         ssize_t ret;
 149         uint8_t *buf;
 150
 151         ret = read_packet_recv(subreq, state, &buf, &err);
 152         TALLOC_FREE(subreq);
 153         if (ret == -1) {
 154                 async_req_error(req, map_wbc_err_from_errno(err));
 155                 return;
 156         }
 157
 158         state->wb_req = (struct winbindd_request *)buf;
 159
 160         if (state->wb_req->extra_len != 0) {
 161                 state->wb_req->extra_data.data =
 162                         (char *)buf + sizeof(struct winbindd_request);
 163         } else {
 164                 state->wb_req->extra_data.data = NULL;
 165         }
 166         async_req_done(req);
 167 }
 168
 169 wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 170                         struct winbindd_request **preq)
 171 {
 172         struct req_read_state *state = talloc_get_type_abort(
 173                 req->private_data, struct req_read_state);
 174         wbcErr wbc_err;
 175
 176         if (async_req_is_wbcerr(req, &wbc_err)) {
 177                 return wbc_err;
 178         }
 179         *preq = talloc_move(mem_ctx, &state->wb_req);
 180         return WBC_ERR_SUCCESS;
 181 }
 182
 183 struct req_write_state {
 184         struct iovec iov[2];
 185 };
 186
 187 static void wb_req_write_done(struct tevent_req *subreq);
 188
 189 struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 190                                     struct tevent_context *ev, int fd,
 191                                     struct winbindd_request *wb_req)
 192 {
 193         struct async_req *result;
 194         struct tevent_req *subreq;
 195         struct req_write_state *state;
 196         int count = 1;
 197
 198         if (!async_req_setup(mem_ctx, &result, &state,
 199                              struct req_write_state)) {
 200                 return NULL;
 201         }
 202
 203         state->iov[0].iov_base = wb_req;
 204         state->iov[0].iov_len = sizeof(struct winbindd_request);
 205
 206         if (wb_req->extra_len != 0) {
 207                 state->iov[1].iov_base = wb_req->extra_data.data;
 208                 state->iov[1].iov_len = wb_req->extra_len;
 209                 count = 2;
 210         }
 211
 212         subreq = writev_send(state, ev, fd, state->iov, count);
 213         if (subreq == NULL) {
 214                 goto fail;
 215         }
 216         subreq->async.fn = wb_req_write_done;
 217         subreq->async.private_data = result;
 218         return result;
 219
 220  fail:
 221         TALLOC_FREE(result);
 222         return NULL;
 223 }
 224
 225 static void wb_req_write_done(struct tevent_req *subreq)
 226 {
 227         struct async_req *req = talloc_get_type_abort(
 228                 subreq->async.private_data, struct async_req);
 229         int err;
 230         ssize_t ret;
 231
 232         ret = writev_recv(subreq, &err);
 233         TALLOC_FREE(subreq);
 234         if (ret < 0) {
 235                 async_req_error(req, map_wbc_err_from_errno(err));
 236                 return;
 237         }
 238         async_req_done(req);
 239 }
 240
 241 wbcErr wb_req_write_recv(struct async_req *req)
 242 {
 243         return async_req_simple_recv_wbcerr(req);
 244 }
 245
 246 struct resp_read_state {
 247         struct winbindd_response *wb_resp;
 248 };
 249
 250 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
 251 static void wb_resp_read_done(struct tevent_req *subreq);
 252
 253 struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
 254                                     struct tevent_context *ev, int fd)
 255 {
 256         struct async_req *result;
 257         struct tevent_req *subreq;
 258         struct resp_read_state *state;
 259
 260         if (!async_req_setup(mem_ctx, &result, &state,
 261                              struct resp_read_state)) {
 262                 return NULL;
 263         }
 264
 265         subreq = read_packet_send(state, ev, fd, 4, wb_resp_more, state);
 266         if (subreq == NULL) {
 267                 goto nomem;
 268         }
 269         subreq->async.fn = wb_resp_read_done;
 270         subreq->async.private_data = result;
 271         return result;
 272
 273  nomem:
 274         TALLOC_FREE(result);
 275         return NULL;
 276 }
 277
 278 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
 279 {
 280         struct winbindd_response *resp = (struct winbindd_response *)buf;
 281
 282         if (buflen == 4) {
 283                 if (resp->length < sizeof(struct winbindd_response)) {
 284                         DEBUG(0, ("wb_resp_read_len: Invalid response size "
 285                                   "received: %d (expected at least%d)\n",
 286                                   (int)resp->length,
 287                                   (int)sizeof(struct winbindd_response)));
 288                         return -1;
 289                 }
 290         }
 291         return resp->length - buflen;
 292 }
 293
 294 static void wb_resp_read_done(struct tevent_req *subreq)
 295 {
 296         struct async_req *req = talloc_get_type_abort(
 297                 subreq->async.private_data, struct async_req);
 298         struct resp_read_state *state = talloc_get_type_abort(
 299                 req->private_data, struct resp_read_state);
 300         uint8_t *buf;
 301         int err;
 302         ssize_t ret;
 303
 304         ret = read_packet_recv(subreq, state, &buf, &err);
 305         TALLOC_FREE(subreq);
 306         if (ret == -1) {
 307                 async_req_error(req, map_wbc_err_from_errno(err));
 308                 return;
 309         }
 310
 311         state->wb_resp = (struct winbindd_response *)buf;
 312
 313         if (state->wb_resp->length > sizeof(struct winbindd_response)) {
 314                 state->wb_resp->extra_data.data =
 315                         (char *)buf + sizeof(struct winbindd_response);
 316         } else {
 317                 state->wb_resp->extra_data.data = NULL;
 318         }
 319         async_req_done(req);
 320 }
 321
 322 wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 323                          struct winbindd_response **presp)
 324 {
 325         struct resp_read_state *state = talloc_get_type_abort(
 326                 req->private_data, struct resp_read_state);
 327         wbcErr wbc_err;
 328
 329         if (async_req_is_wbcerr(req, &wbc_err)) {
 330                 return wbc_err;
 331         }
 332         *presp = talloc_move(mem_ctx, &state->wb_resp);
 333         return WBC_ERR_SUCCESS;
 334 }
 335
 336 struct resp_write_state {
 337         struct iovec iov[2];
 338 };
 339
 340 static void wb_resp_write_done(struct tevent_req *subreq);
 341
 342 struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 343                                     struct tevent_context *ev, int fd,
 344                                     struct winbindd_response *wb_resp)
 345 {
 346         struct async_req *result;
 347         struct tevent_req *subreq;
 348         struct resp_write_state *state;
 349         int count = 1;
 350
 351         if (!async_req_setup(mem_ctx, &result, &state,
 352                              struct resp_write_state)) {
 353                 return NULL;
 354         }
 355
 356         state->iov[0].iov_base = wb_resp;
 357         state->iov[0].iov_len = sizeof(struct winbindd_response);
 358
 359         if (wb_resp->length > sizeof(struct winbindd_response)) {
 360                 state->iov[1].iov_base = wb_resp->extra_data.data;
 361                 state->iov[1].iov_len =
 362                         wb_resp->length - sizeof(struct winbindd_response);
 363                 count = 2;
 364         }
 365
 366         subreq = writev_send(state, ev, fd, state->iov, count);
 367         if (subreq == NULL) {
 368                 goto fail;
 369         }
 370         subreq->async.fn = wb_resp_write_done;
 371         subreq->async.private_data = result;
 372         return result;
 373
 374  fail:
 375         TALLOC_FREE(result);
 376         return NULL;
 377 }
 378
 379 static void wb_resp_write_done(struct tevent_req *subreq)
 380 {
 381         struct async_req *req = talloc_get_type_abort(
 382                 subreq->async.private_data, struct async_req);
 383         int err;
 384         ssize_t ret;
 385
 386         ret = writev_recv(subreq, &err);
 387         TALLOC_FREE(subreq);
 388         if (ret < 0) {
 389                 async_req_error(req, map_wbc_err_from_errno(err));
 390                 return;
 391         }
 392         async_req_done(req);
 393 }
 394
 395 wbcErr wb_resp_write_recv(struct async_req *req)
 396 {
 397         return async_req_simple_recv_wbcerr(req);
 398 }