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      ** NOTE! The following LGPL license applies to the wbclient
   9      ** library. This does NOT imply that all of Samba is released
  10      ** under the LGPL
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 3 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Library General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "includes.h"
  27 #include "wbc_async.h"
  28
  29 #undef DBGC_CLASS
  30 #define DBGC_CLASS DBGC_WINBIND
  31
  32 struct req_read_state {
  33         struct winbindd_request *wb_req;
  34         size_t max_extra_data;
  35         ssize_t ret;
  36 };
  37
  38 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data);
  39 static void wb_req_read_done(struct tevent_req *subreq);
  40
  41 struct tevent_req *wb_req_read_send(TALLOC_CTX *mem_ctx,
  42                                     struct tevent_context *ev,
  43                                     int fd, size_t max_extra_data)
  44 {
  45         struct tevent_req *req, *subreq;
  46         struct req_read_state *state;
  47
  48         req = tevent_req_create(mem_ctx, &state, struct req_read_state);
  49         if (req == NULL) {
  50                 return NULL;
  51         }
  52         state->max_extra_data = max_extra_data;
  53
  54         subreq = read_packet_send(state, ev, fd, 4, wb_req_more, state);
  55         if (tevent_req_nomem(subreq, req)) {
  56                 return tevent_req_post(req, ev);
  57         }
  58         tevent_req_set_callback(subreq, wb_req_read_done, req);
  59         return req;
  60 }
  61
  62 static ssize_t wb_req_more(uint8_t *buf, size_t buflen, void *private_data)
  63 {
  64         struct req_read_state *state = talloc_get_type_abort(
  65                 private_data, struct req_read_state);
  66         struct winbindd_request *req = (struct winbindd_request *)buf;
  67
  68         if (buflen == 4) {
  69                 if (req->length != sizeof(struct winbindd_request)) {
  70                         DEBUG(0, ("wb_req_read_len: Invalid request size "
  71                                   "received: %d (expected %d)\n",
  72                                   (int)req->length,
  73                                   (int)sizeof(struct winbindd_request)));
  74                         return -1;
  75                 }
  76                 return sizeof(struct winbindd_request) - 4;
  77         }
  78
  79         if ((state->max_extra_data != 0)
  80             && (req->extra_len > state->max_extra_data)) {
  81                 DEBUG(3, ("Got request with %d bytes extra data on "
  82                           "unprivileged socket\n", (int)req->extra_len));
  83                 return -1;
  84         }
  85
  86         return req->extra_len;
  87 }
  88
  89 static void wb_req_read_done(struct tevent_req *subreq)
  90 {
  91         struct tevent_req *req = tevent_req_callback_data(
  92                 subreq, struct tevent_req);
  93         struct req_read_state *state = tevent_req_data(
  94                 req, struct req_read_state);
  95         int err;
  96         uint8_t *buf;
  97
  98         state->ret = read_packet_recv(subreq, state, &buf, &err);
  99         TALLOC_FREE(subreq);
 100         if (state->ret == -1) {
 101                 tevent_req_error(req, err);
 102                 return;
 103         }
 104
 105         state->wb_req = (struct winbindd_request *)buf;
 106
 107         if (state->wb_req->extra_len != 0) {
 108                 state->wb_req->extra_data.data =
 109                         (char *)buf + sizeof(struct winbindd_request);
 110         } else {
 111                 state->wb_req->extra_data.data = NULL;
 112         }
 113         tevent_req_done(req);
 114 }
 115
 116 ssize_t wb_req_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 117                          struct winbindd_request **preq, int *err)
 118 {
 119         struct req_read_state *state = tevent_req_data(
 120                 req, struct req_read_state);
 121
 122         if (tevent_req_is_unix_error(req, err)) {
 123                 return -1;
 124         }
 125         *preq = talloc_move(mem_ctx, &state->wb_req);
 126         return state->ret;
 127 }
 128
 129 struct req_write_state {
 130         struct iovec iov[2];
 131         ssize_t ret;
 132 };
 133
 134 static void wb_req_write_done(struct tevent_req *subreq);
 135
 136 struct tevent_req *wb_req_write_send(TALLOC_CTX *mem_ctx,
 137                                      struct tevent_context *ev,
 138                                      struct tevent_queue *queue, int fd,
 139                                      struct winbindd_request *wb_req)
 140 {
 141         struct tevent_req *req, *subreq;
 142         struct req_write_state *state;
 143         int count = 1;
 144
 145         req = tevent_req_create(mem_ctx, &state, struct req_write_state);
 146         if (req == NULL) {
 147                 return NULL;
 148         }
 149
 150         state->iov[0].iov_base = (void *)wb_req;
 151         state->iov[0].iov_len = sizeof(struct winbindd_request);
 152
 153         if (wb_req->extra_len != 0) {
 154                 state->iov[1].iov_base = (void *)wb_req->extra_data.data;
 155                 state->iov[1].iov_len = wb_req->extra_len;
 156                 count = 2;
 157         }
 158
 159         subreq = writev_send(state, ev, queue, fd, true, state->iov, count);
 160         if (tevent_req_nomem(subreq, req)) {
 161                 return tevent_req_post(req, ev);
 162         }
 163         tevent_req_set_callback(subreq, wb_req_write_done, req);
 164         return req;
 165 }
 166
 167 static void wb_req_write_done(struct tevent_req *subreq)
 168 {
 169         struct tevent_req *req = tevent_req_callback_data(
 170                 subreq, struct tevent_req);
 171         struct req_write_state *state = tevent_req_data(
 172                 req, struct req_write_state);
 173         int err;
 174
 175         state->ret = writev_recv(subreq, &err);
 176         TALLOC_FREE(subreq);
 177         if (state->ret < 0) {
 178                 tevent_req_error(req, err);
 179                 return;
 180         }
 181         tevent_req_done(req);
 182 }
 183
 184 ssize_t wb_req_write_recv(struct tevent_req *req, int *err)
 185 {
 186         struct req_write_state *state = tevent_req_data(
 187                 req, struct req_write_state);
 188
 189         if (tevent_req_is_unix_error(req, err)) {
 190                 return -1;
 191         }
 192         return state->ret;
 193 }
 194
 195 struct resp_read_state {
 196         struct winbindd_response *wb_resp;
 197         ssize_t ret;
 198 };
 199
 200 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data);
 201 static void wb_resp_read_done(struct tevent_req *subreq);
 202
 203 struct tevent_req *wb_resp_read_send(TALLOC_CTX *mem_ctx,
 204                                      struct tevent_context *ev, int fd)
 205 {
 206         struct tevent_req *req, *subreq;
 207         struct resp_read_state *state;
 208
 209         req = tevent_req_create(mem_ctx, &state, struct resp_read_state);
 210         if (req == NULL) {
 211                 return NULL;
 212         }
 213
 214         subreq = read_packet_send(state, ev, fd, 4, wb_resp_more, state);
 215         if (tevent_req_nomem(subreq, req)) {
 216                 return tevent_req_post(req, ev);
 217         }
 218         tevent_req_set_callback(subreq, wb_resp_read_done, req);
 219         return req;
 220 }
 221
 222 static ssize_t wb_resp_more(uint8_t *buf, size_t buflen, void *private_data)
 223 {
 224         struct winbindd_response *resp = (struct winbindd_response *)buf;
 225
 226         if (buflen == 4) {
 227                 if (resp->length < sizeof(struct winbindd_response)) {
 228                         DEBUG(0, ("wb_resp_read_len: Invalid response size "
 229                                   "received: %d (expected at least%d)\n",
 230                                   (int)resp->length,
 231                                   (int)sizeof(struct winbindd_response)));
 232                         return -1;
 233                 }
 234         }
 235         return resp->length - buflen;
 236 }
 237
 238 static void wb_resp_read_done(struct tevent_req *subreq)
 239 {
 240         struct tevent_req *req = tevent_req_callback_data(
 241                 subreq, struct tevent_req);
 242         struct resp_read_state *state = tevent_req_data(
 243                 req, struct resp_read_state);
 244         uint8_t *buf;
 245         int err;
 246
 247         state->ret = read_packet_recv(subreq, state, &buf, &err);
 248         TALLOC_FREE(subreq);
 249         if (state->ret == -1) {
 250                 tevent_req_error(req, err);
 251                 return;
 252         }
 253
 254         state->wb_resp = (struct winbindd_response *)buf;
 255
 256         if (state->wb_resp->length > sizeof(struct winbindd_response)) {
 257                 state->wb_resp->extra_data.data =
 258                         (char *)buf + sizeof(struct winbindd_response);
 259         } else {
 260                 state->wb_resp->extra_data.data = NULL;
 261         }
 262         tevent_req_done(req);
 263 }
 264
 265 ssize_t wb_resp_read_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 266                           struct winbindd_response **presp, int *err)
 267 {
 268         struct resp_read_state *state = tevent_req_data(
 269                 req, struct resp_read_state);
 270
 271         if (tevent_req_is_unix_error(req, err)) {
 272                 return -1;
 273         }
 274         *presp = talloc_move(mem_ctx, &state->wb_resp);
 275         return state->ret;
 276 }
 277
 278 struct resp_write_state {
 279         struct iovec iov[2];
 280         ssize_t ret;
 281 };
 282
 283 static void wb_resp_write_done(struct tevent_req *subreq);
 284
 285 struct tevent_req *wb_resp_write_send(TALLOC_CTX *mem_ctx,
 286                                       struct tevent_context *ev,
 287                                       struct tevent_queue *queue, int fd,
 288                                       struct winbindd_response *wb_resp)
 289 {
 290         struct tevent_req *req, *subreq;
 291         struct resp_write_state *state;
 292         int count = 1;
 293
 294         req = tevent_req_create(mem_ctx, &state, struct resp_write_state);
 295         if (req == NULL) {
 296                 return NULL;
 297         }
 298
 299         state->iov[0].iov_base = (void *)wb_resp;
 300         state->iov[0].iov_len = sizeof(struct winbindd_response);
 301
 302         if (wb_resp->length > sizeof(struct winbindd_response)) {
 303                 state->iov[1].iov_base = (void *)wb_resp->extra_data.data;
 304                 state->iov[1].iov_len =
 305                         wb_resp->length - sizeof(struct winbindd_response);
 306                 count = 2;
 307         }
 308
 309         subreq = writev_send(state, ev, queue, fd, true, state->iov, count);
 310         if (tevent_req_nomem(subreq, req)) {
 311                 return tevent_req_post(req, ev);
 312         }
 313         tevent_req_set_callback(subreq, wb_resp_write_done, req);
 314         return req;
 315 }
 316
 317 static void wb_resp_write_done(struct tevent_req *subreq)
 318 {
 319         struct tevent_req *req = tevent_req_callback_data(
 320                 subreq, struct tevent_req);
 321         struct resp_write_state *state = tevent_req_data(
 322                 req, struct resp_write_state);
 323         int err;
 324
 325         state->ret = writev_recv(subreq, &err);
 326         TALLOC_FREE(subreq);
 327         if (state->ret < 0) {
 328                 tevent_req_error(req, err);
 329                 return;
 330         }
 331         tevent_req_done(req);
 332 }
 333
 334 ssize_t wb_resp_write_recv(struct tevent_req *req, int *err)
 335 {
 336         struct resp_write_state *state = tevent_req_data(
 337                 req, struct resp_write_state);
 338
 339         if (tevent_req_is_unix_error(req, err)) {
 340                 return -1;
 341         }
 342         return state->ret;
 343 }
 344
 345 struct wb_simple_trans_state {
 346         struct tevent_context *ev;
 347         int fd;
 348         struct winbindd_response *wb_resp;
 349 };
 350
 351 static void wb_simple_trans_write_done(struct tevent_req *subreq);
 352 static void wb_simple_trans_read_done(struct tevent_req *subreq);
 353
 354 struct tevent_req *wb_simple_trans_send(TALLOC_CTX *mem_ctx,
 355                                         struct tevent_context *ev,
 356                                         struct tevent_queue *queue, int fd,
 357                                         struct winbindd_request *wb_req)
 358 {
 359         struct tevent_req *req, *subreq;
 360         struct wb_simple_trans_state *state;
 361
 362         req = tevent_req_create(mem_ctx, &state, struct wb_simple_trans_state);
 363         if (req == NULL) {
 364                 return NULL;
 365         }
 366
 367         wb_req->length = sizeof(struct winbindd_request);
 368
 369         state->ev = ev;
 370         state->fd = fd;
 371
 372         subreq = wb_req_write_send(state, ev, queue, fd, wb_req);
 373         if (tevent_req_nomem(subreq, req)) {
 374                 return tevent_req_post(req, ev);
 375         }
 376         tevent_req_set_callback(subreq, wb_simple_trans_write_done, req);
 377
 378         return req;
 379 }
 380
 381 static void wb_simple_trans_write_done(struct tevent_req *subreq)
 382 {
 383         struct tevent_req *req = tevent_req_callback_data(
 384                 subreq, struct tevent_req);
 385         struct wb_simple_trans_state *state = tevent_req_data(
 386                 req, struct wb_simple_trans_state);
 387         ssize_t ret;
 388         int err;
 389
 390         ret = wb_req_write_recv(subreq, &err);
 391         TALLOC_FREE(subreq);
 392         if (ret == -1) {
 393                 tevent_req_error(req, err);
 394                 return;
 395         }
 396         subreq = wb_resp_read_send(state, state->ev, state->fd);
 397         if (tevent_req_nomem(subreq, req)) {
 398                 return;
 399         }
 400         tevent_req_set_callback(subreq, wb_simple_trans_read_done, req);
 401 }
 402
 403 static void wb_simple_trans_read_done(struct tevent_req *subreq)
 404 {
 405         struct tevent_req *req = tevent_req_callback_data(
 406                 subreq, struct tevent_req);
 407         struct wb_simple_trans_state *state = tevent_req_data(
 408                 req, struct wb_simple_trans_state);
 409         ssize_t ret;
 410         int err;
 411
 412         ret = wb_resp_read_recv(subreq, state, &state->wb_resp, &err);
 413         TALLOC_FREE(subreq);
 414         if (ret == -1) {
 415                 tevent_req_error(req, err);
 416                 return;
 417         }
 418
 419         tevent_req_done(req);
 420 }
 421
 422 int wb_simple_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 423                          struct winbindd_response **presponse, int *err)
 424 {
 425         struct wb_simple_trans_state *state = tevent_req_data(
 426                 req, struct wb_simple_trans_state);
 427
 428         if (tevent_req_is_unix_error(req, err)) {
 429                 return -1;
 430         }
 431         *presponse = talloc_move(mem_ctx, &state->wb_resp);
 432         return 0;
 433 }