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         struct tevent_context *ev;
  31         size_t max_extra_data;
  32         int fd;
  33 };
  34
  35 bool async_req_is_wbcerr(struct async_req *req, wbcErr *pwbc_err)
  36 {
  37         enum async_req_state state;
  38         uint64_t error;
  39         if (!async_req_is_error(req, &state, &error)) {
  40                 *pwbc_err = WBC_ERR_SUCCESS;
  41                 return false;
  42         }
  43
  44         switch (state) {
  45         case ASYNC_REQ_USER_ERROR:
  46                 *pwbc_err = error;
  47                 break;
  48         case ASYNC_REQ_TIMED_OUT:
  49                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
  50                 break;
  51         case ASYNC_REQ_NO_MEMORY:
  52                 *pwbc_err = WBC_ERR_NO_MEMORY;
  53                 break;
  54         default:
  55                 *pwbc_err = WBC_ERR_UNKNOWN_FAILURE;
  56                 break;
  57         }
  58         return true;
  59 }
  60
  61 wbcErr map_wbc_err_from_errno(int error)
  62 {
  63         switch(error) {
  64         case EPERM:
  65         case EACCES:
  66                 return WBC_ERR_AUTH_ERROR;
  67         case ENOMEM:
  68                 return WBC_ERR_NO_MEMORY;
  69         case EIO:
  70         default:
  71                 return WBC_ERR_UNKNOWN_FAILURE;
  72         }
  73 }
  74
  75 wbcErr async_req_simple_recv_wbcerr(struct async_req *req)
  76 {
  77         wbcErr wbc_err;
  78
  79         if (async_req_is_wbcerr(req, &wbc_err)) {
  80                 return wbc_err;
  81         }
  82
  83         return WBC_ERR_SUCCESS;
  84 }
  85
  86 static void wb_req_read_len(struct async_req *subreq);
  87 static void wb_req_read_main(struct async_req *subreq);
  88 static void wb_req_read_extra(struct async_req *subreq);
  89
  90 struct async_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
  91                                    struct tevent_context *ev,
  92                                    int fd, size_t max_extra_data)
  93 {
  94         struct async_req *result, *subreq;
  95         struct req_read_state *state;
  96
  97         if (!async_req_setup(mem_ctx, &result, &state,
  98                              struct req_read_state)) {
  99                 return NULL;
 100         }
 101         state->fd = fd;
 102         state->ev = ev;
 103         state->max_extra_data = max_extra_data;
 104         state->wb_req = talloc(state, struct winbindd_request);
 105         if (state->wb_req == NULL) {
 106                 goto nomem;
 107         }
 108
 109         subreq = recvall_send(state, ev, state->fd, &(state->wb_req->length),
 110                               sizeof(state->wb_req->length), 0);
 111         if (subreq == NULL) {
 112                 goto nomem;
 113         }
 114
 115         subreq->async.fn = wb_req_read_len;
 116         subreq->async.priv = result;
 117         return result;
 118
 119  nomem:
 120         TALLOC_FREE(result);
 121         return NULL;
 122 }
 123
 124 static void wb_req_read_len(struct async_req *subreq)
 125 {
 126         struct async_req *req = talloc_get_type_abort(
 127                 subreq->async.priv, struct async_req);
 128         struct req_read_state *state = talloc_get_type_abort(
 129                 req->private_data, struct req_read_state);
 130         int err;
 131         ssize_t ret;
 132
 133         ret = recvall_recv(subreq, &err);
 134         TALLOC_FREE(subreq);
 135         if (ret < 0) {
 136                 async_req_error(req, map_wbc_err_from_errno(err));
 137                 return;
 138         }
 139
 140         if (state->wb_req->length != sizeof(struct winbindd_request)) {
 141                 DEBUG(0, ("wb_req_read_len: Invalid request size received: "
 142                           "%d (expected %d)\n", (int)state->wb_req->length,
 143                           (int)sizeof(struct winbindd_request)));
 144                 async_req_error(req, WBC_ERR_INVALID_RESPONSE);
 145                 return;
 146         }
 147
 148         subreq = recvall_send(
 149                 req, state->ev, state->fd, (uint32 *)(state->wb_req)+1,
 150                 sizeof(struct winbindd_request) - sizeof(uint32), 0);
 151         if (async_req_nomem(subreq, req)) {
 152                 return;
 153         }
 154
 155         subreq->async.fn = wb_req_read_main;
 156         subreq->async.priv = req;
 157 }
 158
 159 static void wb_req_read_main(struct async_req *subreq)
 160 {
 161         struct async_req *req = talloc_get_type_abort(
 162                 subreq->async.priv, struct async_req);
 163         struct req_read_state *state = talloc_get_type_abort(
 164                 req->private_data, struct req_read_state);
 165         int err;
 166         ssize_t ret;
 167
 168         ret = recvall_recv(subreq, &err);
 169         TALLOC_FREE(subreq);
 170         if (ret < 0) {
 171                 async_req_error(req, map_wbc_err_from_errno(err));
 172                 return;
 173         }
 174
 175         if ((state->max_extra_data != 0)
 176             && (state->wb_req->extra_len > state->max_extra_data)) {
 177                 DEBUG(3, ("Got request with %d bytes extra data on "
 178                           "unprivileged socket\n",
 179                           (int)state->wb_req->extra_len));
 180                 async_req_error(req, WBC_ERR_INVALID_RESPONSE);
 181                 return;
 182         }
 183
 184         if (state->wb_req->extra_len == 0) {
 185                 async_req_done(req);
 186                 return;
 187         }
 188
 189         state->wb_req->extra_data.data = TALLOC_ARRAY(
 190                 state->wb_req, char, state->wb_req->extra_len + 1);
 191         if (async_req_nomem(state->wb_req->extra_data.data, req)) {
 192                 return;
 193         }
 194
 195         state->wb_req->extra_data.data[state->wb_req->extra_len] = 0;
 196
 197         subreq = recvall_send(
 198                 req, state->ev, state->fd, state->wb_req->extra_data.data,
 199                 state->wb_req->extra_len, 0);
 200         if (async_req_nomem(subreq, req)) {
 201                 return;
 202         }
 203
 204         subreq->async.fn = wb_req_read_extra;
 205         subreq->async.priv = req;
 206 }
 207
 208 static void wb_req_read_extra(struct async_req *subreq)
 209 {
 210         struct async_req *req = talloc_get_type_abort(
 211                 subreq->async.priv, struct async_req);
 212         int err;
 213         ssize_t ret;
 214
 215         ret = recvall_recv(subreq, &err);
 216         TALLOC_FREE(subreq);
 217         if (ret < 0) {
 218                 async_req_error(req, map_wbc_err_from_errno(err));
 219                 return;
 220         }
 221         async_req_done(req);
 222 }
 223
 224
 225 wbcErr wb_req_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 226                         struct winbindd_request **preq)
 227 {
 228         struct req_read_state *state = talloc_get_type_abort(
 229                 req->private_data, struct req_read_state);
 230         wbcErr wbc_err;
 231
 232         if (async_req_is_wbcerr(req, &wbc_err)) {
 233                 return wbc_err;
 234         }
 235         *preq = talloc_move(mem_ctx, &state->wb_req);
 236         return WBC_ERR_SUCCESS;
 237 }
 238
 239 struct req_write_state {
 240         struct winbindd_request *wb_req;
 241         struct tevent_context *ev;
 242         int fd;
 243 };
 244
 245 static void wb_req_write_main(struct async_req *subreq);
 246 static void wb_req_write_extra(struct async_req *subreq);
 247
 248 struct async_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 249                                     struct tevent_context *ev, int fd,
 250                                     struct winbindd_request *wb_req)
 251 {
 252         struct async_req *result, *subreq;
 253         struct req_write_state *state;
 254
 255         if (!async_req_setup(mem_ctx, &result, &state,
 256                              struct req_write_state)) {
 257                 return NULL;
 258         }
 259         state->fd = fd;
 260         state->ev = ev;
 261         state->wb_req = wb_req;
 262
 263         subreq = sendall_send(state, state->ev, state->fd, state->wb_req,
 264                               sizeof(struct winbindd_request), 0);
 265         if (subreq == NULL) {
 266                 goto nomem;
 267         }
 268
 269         subreq->async.fn = wb_req_write_main;
 270         subreq->async.priv = result;
 271         return result;
 272
 273  nomem:
 274         TALLOC_FREE(result);
 275         return NULL;
 276 }
 277
 278 static void wb_req_write_main(struct async_req *subreq)
 279 {
 280         struct async_req *req = talloc_get_type_abort(
 281                 subreq->async.priv, struct async_req);
 282         struct req_write_state *state = talloc_get_type_abort(
 283                 req->private_data, struct req_write_state);
 284         int err;
 285         ssize_t ret;
 286
 287         ret = sendall_recv(subreq, &err);
 288         TALLOC_FREE(subreq);
 289         if (ret < 0) {
 290                 async_req_error(req, map_wbc_err_from_errno(err));
 291                 return;
 292         }
 293
 294         if (state->wb_req->extra_len == 0) {
 295                 async_req_done(req);
 296                 return;
 297         }
 298
 299         subreq = sendall_send(state, state->ev, state->fd,
 300                               state->wb_req->extra_data.data,
 301                               state->wb_req->extra_len, 0);
 302         if (async_req_nomem(subreq, req)) {
 303                 return;
 304         }
 305
 306         subreq->async.fn = wb_req_write_extra;
 307         subreq->async.priv = req;
 308 }
 309
 310 static void wb_req_write_extra(struct async_req *subreq)
 311 {
 312         struct async_req *req = talloc_get_type_abort(
 313                 subreq->async.priv, struct async_req);
 314         int err;
 315         ssize_t ret;
 316
 317         ret = sendall_recv(subreq, &err);
 318         TALLOC_FREE(subreq);
 319         if (ret < 0) {
 320                 async_req_error(req, map_wbc_err_from_errno(err));
 321                 return;
 322         }
 323
 324         async_req_done(req);
 325 }
 326
 327 wbcErr wb_req_write_recv(struct async_req *req)
 328 {
 329         return async_req_simple_recv_wbcerr(req);
 330 }
 331
 332 struct resp_read_state {
 333         struct winbindd_response *wb_resp;
 334         struct tevent_context *ev;
 335         size_t max_extra_data;
 336         int fd;
 337 };
 338
 339 static void wb_resp_read_len(struct async_req *subreq);
 340 static void wb_resp_read_main(struct async_req *subreq);
 341 static void wb_resp_read_extra(struct async_req *subreq);
 342
 343 struct async_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
 344                                     struct tevent_context *ev, int fd)
 345 {
 346         struct async_req *result, *subreq;
 347         struct resp_read_state *state;
 348
 349         if (!async_req_setup(mem_ctx, &result, &state,
 350                              struct resp_read_state)) {
 351                 return NULL;
 352         }
 353         state->fd = fd;
 354         state->ev = ev;
 355         state->wb_resp = talloc(state, struct winbindd_response);
 356         if (state->wb_resp == NULL) {
 357                 goto nomem;
 358         }
 359
 360         subreq = recvall_send(state, ev, state->fd, &(state->wb_resp->length),
 361                               sizeof(state->wb_resp->length), 0);
 362         if (subreq == NULL) {
 363                 goto nomem;
 364         }
 365
 366         subreq->async.fn = wb_resp_read_len;
 367         subreq->async.priv = result;
 368         return result;
 369
 370  nomem:
 371         TALLOC_FREE(result);
 372         return NULL;
 373 }
 374
 375 static void wb_resp_read_len(struct async_req *subreq)
 376 {
 377         struct async_req *req = talloc_get_type_abort(
 378                 subreq->async.priv, struct async_req);
 379         struct resp_read_state *state = talloc_get_type_abort(
 380                 req->private_data, struct resp_read_state);
 381         int err;
 382         ssize_t ret;
 383
 384         ret = recvall_recv(subreq, &err);
 385         TALLOC_FREE(subreq);
 386         if (ret < 0) {
 387                 async_req_error(req, map_wbc_err_from_errno(err));
 388                 return;
 389         }
 390
 391         if (state->wb_resp->length < sizeof(struct winbindd_response)) {
 392                 DEBUG(0, ("wb_resp_read_len: Invalid response size received: "
 393                           "%d (expected at least%d)\n",
 394                           (int)state->wb_resp->length,
 395                           (int)sizeof(struct winbindd_response)));
 396                 async_req_error(req, WBC_ERR_INVALID_RESPONSE);
 397                 return;
 398         }
 399
 400         subreq = recvall_send(
 401                 req, state->ev, state->fd, (uint32 *)(state->wb_resp)+1,
 402                 sizeof(struct winbindd_response) - sizeof(uint32), 0);
 403         if (async_req_nomem(subreq, req)) {
 404                 return;
 405         }
 406
 407         subreq->async.fn = wb_resp_read_main;
 408         subreq->async.priv = req;
 409 }
 410
 411 static void wb_resp_read_main(struct async_req *subreq)
 412 {
 413         struct async_req *req = talloc_get_type_abort(
 414                 subreq->async.priv, struct async_req);
 415         struct resp_read_state *state = talloc_get_type_abort(
 416                 req->private_data, struct resp_read_state);
 417         int err;
 418         ssize_t ret;
 419         size_t extra_len;
 420
 421         ret = recvall_recv(subreq, &err);
 422         TALLOC_FREE(subreq);
 423         if (ret < 0) {
 424                 async_req_error(req, map_wbc_err_from_errno(err));
 425                 return;
 426         }
 427
 428         extra_len = state->wb_resp->length - sizeof(struct winbindd_response);
 429         if (extra_len == 0) {
 430                 async_req_done(req);
 431                 return;
 432         }
 433
 434         state->wb_resp->extra_data.data = TALLOC_ARRAY(
 435                 state->wb_resp, char, extra_len+1);
 436         if (async_req_nomem(state->wb_resp->extra_data.data, req)) {
 437                 return;
 438         }
 439         ((char *)state->wb_resp->extra_data.data)[extra_len] = 0;
 440
 441         subreq = recvall_send(
 442                 req, state->ev, state->fd, state->wb_resp->extra_data.data,
 443                 extra_len, 0);
 444         if (async_req_nomem(subreq, req)) {
 445                 return;
 446         }
 447
 448         subreq->async.fn = wb_resp_read_extra;
 449         subreq->async.priv = req;
 450 }
 451
 452 static void wb_resp_read_extra(struct async_req *subreq)
 453 {
 454         struct async_req *req = talloc_get_type_abort(
 455                 subreq->async.priv, struct async_req);
 456         int err;
 457         ssize_t ret;
 458
 459         ret = recvall_recv(subreq, &err);
 460         TALLOC_FREE(subreq);
 461         if (ret < 0) {
 462                 async_req_error(req, map_wbc_err_from_errno(err));
 463                 return;
 464         }
 465         async_req_done(req);
 466 }
 467
 468
 469 wbcErr wb_resp_read_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 470                          struct winbindd_response **presp)
 471 {
 472         struct resp_read_state *state = talloc_get_type_abort(
 473                 req->private_data, struct resp_read_state);
 474         wbcErr wbc_err;
 475
 476         if (async_req_is_wbcerr(req, &wbc_err)) {
 477                 return wbc_err;
 478         }
 479         *presp = talloc_move(mem_ctx, &state->wb_resp);
 480         return WBC_ERR_SUCCESS;
 481 }
 482
 483 struct resp_write_state {
 484         struct winbindd_response *wb_resp;
 485         struct tevent_context *ev;
 486         int fd;
 487 };
 488
 489 static void wb_resp_write_main(struct async_req *subreq);
 490 static void wb_resp_write_extra(struct async_req *subreq);
 491
 492 struct async_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 493                                     struct tevent_context *ev, int fd,
 494                                     struct winbindd_response *wb_resp)
 495 {
 496         struct async_req *result, *subreq;
 497         struct resp_write_state *state;
 498
 499         if (!async_req_setup(mem_ctx, &result, &state,
 500                              struct resp_write_state)) {
 501                 return NULL;
 502         }
 503         state->fd = fd;
 504         state->ev = ev;
 505         state->wb_resp = wb_resp;
 506
 507         subreq = sendall_send(state, state->ev, state->fd, state->wb_resp,
 508                               sizeof(struct winbindd_response), 0);
 509         if (subreq == NULL) {
 510                 goto nomem;
 511         }
 512
 513         subreq->async.fn = wb_resp_write_main;
 514         subreq->async.priv = result;
 515         return result;
 516
 517  nomem:
 518         TALLOC_FREE(result);
 519         return NULL;
 520 }
 521
 522 static void wb_resp_write_main(struct async_req *subreq)
 523 {
 524         struct async_req *req = talloc_get_type_abort(
 525                 subreq->async.priv, struct async_req);
 526         struct resp_write_state *state = talloc_get_type_abort(
 527                 req->private_data, struct resp_write_state);
 528         int err;
 529         ssize_t ret;
 530
 531         ret = sendall_recv(subreq, &err);
 532         TALLOC_FREE(subreq);
 533         if (ret < 0) {
 534                 async_req_error(req, map_wbc_err_from_errno(err));
 535                 return;
 536         }
 537
 538         if (state->wb_resp->length == sizeof(struct winbindd_response)) {
 539                 async_req_done(req);
 540                 return;
 541         }
 542
 543         subreq = sendall_send(
 544                 state, state->ev, state->fd,
 545                 state->wb_resp->extra_data.data,
 546                 state->wb_resp->length - sizeof(struct winbindd_response), 0);
 547         if (async_req_nomem(subreq, req)) {
 548                 return;
 549         }
 550
 551         subreq->async.fn = wb_resp_write_extra;
 552         subreq->async.priv = req;
 553 }
 554
 555 static void wb_resp_write_extra(struct async_req *subreq)
 556 {
 557         struct async_req *req = talloc_get_type_abort(
 558                 subreq->async.priv, struct async_req);
 559         int err;
 560         ssize_t ret;
 561
 562         ret = sendall_recv(subreq, &err);
 563         TALLOC_FREE(subreq);
 564         if (err < 0) {
 565                 async_req_error(req, map_wbc_err_from_errno(err));
 566                 return;
 567         }
 568
 569         async_req_done(req);
 570 }
 571
 572 wbcErr wb_resp_write_recv(struct async_req *req)
 573 {
 574         return async_req_simple_recv_wbcerr(req);
 575 }