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 bool tevent_req_is_wbcerr(struct tevent_req *req, wbcErr *pwbc_err)
  85 {
  86         enum tevent_req_state state;
  87         uint64_t error;
  88         if (!tevent_req_is_error(req, &state, &error)) {
  89                 *pwbc_err = WBC_ERR_SUCCESS;
  90                 return false;
  91         }
  92
  93         switch (state) {
  94         case TEVENT_REQ_USER_ERROR:
  95                 *pwbc_err = error;
  96                 break;
  97         case TEVENT_REQ_TIMED_OUT:
  98                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
  99                 break;
 100         case TEVENT_REQ_NO_MEMORY:
 101                 *pwbc_err = WBC_ERR_NO_MEMORY;
 102                 break;
 103         default:
 104                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
 105                 break;
 106         }
 107         return true;
 108 }
 109
 110 wbcErr tevent_req_simple_recv_wbcerr(struct tevent_req *req)
 111 {
 112         wbcErr wbc_err;
 113
 114         if (tevent_req_is_wbcerr(req, &wbc_err)) {
 115                 return wbc_err;
 116         }
 117
 118         return WBC_ERR_SUCCESS;
 119 }
 120
 121 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
 122 static void wb_req_read_done(struct tevent_req *subreq);
 123
 124 struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
 125                                     struct tevent_context *ev,
 126                                     int fd, size_t max_extra_data)
 127 {
 128         struct tevent_req *result, *subreq;
 129         struct req_read_state *state;
 130
 131         result = tevent_req_create(mem_ctx, &state, struct req_read_state);
 132         if (result == NULL) {
 133                 return NULL;
 134         }
 135         state->max_extra_data = max_extra_data;
 136
 137         subreq = read_packet_send(state, ev, fd, 4, wb_req_more, state);
 138         if (subreq == NULL) {
 139                 goto nomem;
 140         }
 141
 142         tevent_req_set_callback(subreq, wb_req_read_done, result);
 143         return result;
 144  nomem:
 145         TALLOC_FREE(result);
 146         return NULL;
 147 }
 148
 149 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
 150 {
 151         struct req_read_state *state = talloc_get_type_abort(
 152                 private_data, struct req_read_state);
 153         struct winbindd_request *req = (struct winbindd_request *)buf;
 154
 155         if (buflen == 4) {
 156                 if (req->length != sizeof(struct winbindd_request)) {
 157                         DEBUG(0, ("wb_req_read_len: Invalid request size "
 158                                   "received: %d (expected %d)\n",
 159                                   (int)req->length,
 160                                   (int)sizeof(struct winbindd_request)));
 161                         return -1;
 162                 }
 163                 return sizeof(struct winbindd_request) - 4;
 164         }
 165
 166         if ((state->max_extra_data != 0)
 167             && (req->extra_len > state->max_extra_data)) {
 168                 DEBUG(3, ("Got request with %d bytes extra data on "
 169                           "unprivileged socket\n", (int)req->extra_len));
 170                 return -1;
 171         }
 172
 173         return req->extra_len;
 174 }
 175
 176 static void wb_req_read_done(struct tevent_req *subreq)
 177 {
 178         struct tevent_req *req = tevent_req_callback_data(
 179                 subreq, struct tevent_req);
 180         struct req_read_state *state = tevent_req_data(
 181                 req, struct req_read_state);
 182         int err;
 183         ssize_t ret;
 184         uint8_t *buf;
 185
 186         ret = read_packet_recv(subreq, state, &buf, &err);
 187         TALLOC_FREE(subreq);
 188         if (ret == -1) {
 189                 tevent_req_error(req, map_wbc_err_from_errno(err));
 190                 return;
 191         }
 192
 193         state->wb_req = (struct winbindd_request *)buf;
 194
 195         if (state->wb_req->extra_len != 0) {
 196                 state->wb_req->extra_data.data =
 197                         (char *)buf + sizeof(struct winbindd_request);
 198         } else {
 199                 state->wb_req->extra_data.data = NULL;
 200         }
 201         tevent_req_done(req);
 202 }
 203
 204 wbcErr wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 205                         struct winbindd_request **preq)
 206 {
 207         struct req_read_state *state = tevent_req_data(
 208                 req, struct req_read_state);
 209         wbcErr wbc_err;
 210
 211         if (tevent_req_is_wbcerr(req, &wbc_err)) {
 212                 return wbc_err;
 213         }
 214         *preq = talloc_move(mem_ctx, &state->wb_req);
 215         return WBC_ERR_SUCCESS;
 216 }
 217
 218 struct req_write_state {
 219         struct iovec iov[2];
 220 };
 221
 222 static void wb_req_write_done(struct tevent_req *subreq);
 223
 224 struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 225                                      struct tevent_context *ev,
 226                                      struct tevent_queue *queue, int fd,
 227                                      struct winbindd_request *wb_req)
 228 {
 229         struct tevent_req *result, *subreq;
 230         struct req_write_state *state;
 231         int count = 1;
 232
 233         result = tevent_req_create(mem_ctx, &state, struct req_write_state);
 234         if (result == NULL) {
 235                 return NULL;
 236         }
 237
 238         state->iov[0].iov_base = wb_req;
 239         state->iov[0].iov_len = sizeof(struct winbindd_request);
 240
 241         if (wb_req->extra_len != 0) {
 242                 state->iov[1].iov_base = wb_req->extra_data.data;
 243                 state->iov[1].iov_len = wb_req->extra_len;
 244                 count = 2;
 245         }
 246
 247         subreq = writev_send(state, ev, queue, fd, state->iov, count);
 248         if (subreq == NULL) {
 249                 goto fail;
 250         }
 251         tevent_req_set_callback(subreq, wb_req_write_done, result);
 252         return result;
 253
 254  fail:
 255         TALLOC_FREE(result);
 256         return NULL;
 257 }
 258
 259 static void wb_req_write_done(struct tevent_req *subreq)
 260 {
 261         struct tevent_req *req = tevent_req_callback_data(
 262                 subreq, struct tevent_req);
 263         int err;
 264         ssize_t ret;
 265
 266         ret = writev_recv(subreq, &err);
 267         TALLOC_FREE(subreq);
 268         if (ret < 0) {
 269                 tevent_req_error(req, map_wbc_err_from_errno(err));
 270                 return;
 271         }
 272         tevent_req_done(req);
 273 }
 274
 275 wbcErr wb_req_write_recv(struct tevent_req *req)
 276 {
 277         return tevent_req_simple_recv_wbcerr(req);
 278 }
 279
 280 struct resp_read_state {
 281         struct winbindd_response *wb_resp;
 282 };
 283
 284 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
 285 static void wb_resp_read_done(struct tevent_req *subreq);
 286
 287 struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
 288                                      struct tevent_context *ev, int fd)
 289 {
 290         struct tevent_req *result, *subreq;
 291         struct resp_read_state *state;
 292
 293         result = tevent_req_create(mem_ctx, &state, struct resp_read_state);
 294         if (result == NULL) {
 295                 return NULL;
 296         }
 297
 298         subreq = read_packet_send(state, ev, fd, 4, wb_resp_more, state);
 299         if (subreq == NULL) {
 300                 goto nomem;
 301         }
 302         tevent_req_set_callback(subreq, wb_resp_read_done, result);
 303         return result;
 304
 305  nomem:
 306         TALLOC_FREE(result);
 307         return NULL;
 308 }
 309
 310 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
 311 {
 312         struct winbindd_response *resp = (struct winbindd_response *)buf;
 313
 314         if (buflen == 4) {
 315                 if (resp->length < sizeof(struct winbindd_response)) {
 316                         DEBUG(0, ("wb_resp_read_len: Invalid response size "
 317                                   "received: %d (expected at least%d)\n",
 318                                   (int)resp->length,
 319                                   (int)sizeof(struct winbindd_response)));
 320                         return -1;
 321                 }
 322         }
 323         return resp->length - buflen;
 324 }
 325
 326 static void wb_resp_read_done(struct tevent_req *subreq)
 327 {
 328         struct tevent_req *req = tevent_req_callback_data(
 329                 subreq, struct tevent_req);
 330         struct resp_read_state *state = tevent_req_data(
 331                 req, struct resp_read_state);
 332         uint8_t *buf;
 333         int err;
 334         ssize_t ret;
 335
 336         ret = read_packet_recv(subreq, state, &buf, &err);
 337         TALLOC_FREE(subreq);
 338         if (ret == -1) {
 339                 tevent_req_error(req, map_wbc_err_from_errno(err));
 340                 return;
 341         }
 342
 343         state->wb_resp = (struct winbindd_response *)buf;
 344
 345         if (state->wb_resp->length > sizeof(struct winbindd_response)) {
 346                 state->wb_resp->extra_data.data =
 347                         (char *)buf + sizeof(struct winbindd_response);
 348         } else {
 349                 state->wb_resp->extra_data.data = NULL;
 350         }
 351         tevent_req_done(req);
 352 }
 353
 354 wbcErr wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 355                          struct winbindd_response **presp)
 356 {
 357         struct resp_read_state *state = tevent_req_data(
 358                 req, struct resp_read_state);
 359         wbcErr wbc_err;
 360
 361         if (tevent_req_is_wbcerr(req, &wbc_err)) {
 362                 return wbc_err;
 363         }
 364         *presp = talloc_move(mem_ctx, &state->wb_resp);
 365         return WBC_ERR_SUCCESS;
 366 }
 367
 368 struct resp_write_state {
 369         struct iovec iov[2];
 370 };
 371
 372 static void wb_resp_write_done(struct tevent_req *subreq);
 373
 374 struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 375                                       struct tevent_context *ev, int fd,
 376                                       struct winbindd_response *wb_resp)
 377 {
 378         struct tevent_req *result, *subreq;
 379         struct resp_write_state *state;
 380         int count = 1;
 381
 382         result = tevent_req_create(mem_ctx, &state, struct resp_write_state);
 383         if (result == NULL) {
 384                 return NULL;
 385         }
 386
 387         state->iov[0].iov_base = wb_resp;
 388         state->iov[0].iov_len = sizeof(struct winbindd_response);
 389
 390         if (wb_resp->length > sizeof(struct winbindd_response)) {
 391                 state->iov[1].iov_base = wb_resp->extra_data.data;
 392                 state->iov[1].iov_len =
 393                         wb_resp->length - sizeof(struct winbindd_response);
 394                 count = 2;
 395         }
 396
 397         subreq = writev_send(state, ev, NULL, fd, state->iov, count);
 398         if (subreq == NULL) {
 399                 goto fail;
 400         }
 401         tevent_req_set_callback(subreq, wb_resp_write_done, result);
 402         return result;
 403
 404  fail:
 405         TALLOC_FREE(result);
 406         return NULL;
 407 }
 408
 409 static void wb_resp_write_done(struct tevent_req *subreq)
 410 {
 411         struct tevent_req *req = tevent_req_callback_data(
 412                 subreq, struct tevent_req);
 413         int err;
 414         ssize_t ret;
 415
 416         ret = writev_recv(subreq, &err);
 417         TALLOC_FREE(subreq);
 418         if (ret < 0) {
 419                 tevent_req_error(req, map_wbc_err_from_errno(err));
 420                 return;
 421         }
 422         tevent_req_done(req);
 423 }
 424
 425 wbcErr wb_resp_write_recv(struct tevent_req *req)
 426 {
 427         return tevent_req_simple_recv_wbcerr(req);
 428 }