source3/lib/async_sock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    async socket syscalls
   4    Copyright (C) Volker Lendecke 2008
   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 /**
  23  * Discriminator for async_syscall_state
  24  */
  25 enum async_syscall_type {
  26         ASYNC_SYSCALL_SEND,
  27         ASYNC_SYSCALL_SENDALL,
  28         ASYNC_SYSCALL_RECV,
  29         ASYNC_SYSCALL_RECVALL,
  30         ASYNC_SYSCALL_CONNECT
  31 };
  32
  33 /**
  34  * Holder for syscall arguments and the result
  35  */
  36
  37 struct async_syscall_state {
  38         enum async_syscall_type syscall_type;
  39         struct fd_event *fde;
  40
  41         union {
  42                 struct param_send {
  43                         int fd;
  44                         const void *buffer;
  45                         size_t length;
  46                         int flags;
  47                 } param_send;
  48                 struct param_sendall {
  49                         int fd;
  50                         const void *buffer;
  51                         size_t length;
  52                         int flags;
  53                         size_t sent;
  54                 } param_sendall;
  55                 struct param_recv {
  56                         int fd;
  57                         void *buffer;
  58                         size_t length;
  59                         int flags;
  60                 } param_recv;
  61                 struct param_recvall {
  62                         int fd;
  63                         void *buffer;
  64                         size_t length;
  65                         int flags;
  66                         size_t received;
  67                 } param_recvall;
  68                 struct param_connect {
  69                         /**
  70                          * connect needs to be done on a nonblocking
  71                          * socket. Keep the old flags around
  72                          */
  73                         long old_sockflags;
  74                         int fd;
  75                         const struct sockaddr *address;
  76                         socklen_t address_len;
  77                 } param_connect;
  78         } param;
  79
  80         union {
  81                 ssize_t result_ssize_t;
  82                 size_t result_size_t;
  83                 int result_int;
  84         } result;
  85         int sys_errno;
  86 };
  87
  88 /**
  89  * @brief Create a new async syscall req
  90  * @param[in] mem_ctx   The memory context to hang the result off
  91  * @param[in] ev        The event context to work from
  92  * @param[in] type      Which syscall will this be
  93  * @param[in] pstate    Where to put the newly created private_data state
  94  * @retval The new request
  95  *
  96  * This is a helper function to prepare a new struct async_req with an
  97  * associated struct async_syscall_state. The async_syscall_state will be put
  98  * into the async_req as private_data.
  99  */
 100
 101 static struct async_req *async_syscall_new(TALLOC_CTX *mem_ctx,
 102                                            struct event_context *ev,
 103                                            enum async_syscall_type type,
 104                                            struct async_syscall_state **pstate)
 105 {
 106         struct async_req *result;
 107         struct async_syscall_state *state;
 108
 109         result = async_req_new(mem_ctx, ev);
 110         if (result == NULL) {
 111                 return NULL;
 112         }
 113
 114         state = talloc(result, struct async_syscall_state);
 115         if (state == NULL) {
 116                 TALLOC_FREE(result);
 117                 return NULL;
 118         }
 119
 120         state->syscall_type = type;
 121
 122         result->private_data = state;
 123
 124         *pstate = state;
 125
 126         return result;
 127 }
 128
 129 /**
 130  * @brief Create a new async syscall req based on a fd
 131  * @param[in] mem_ctx   The memory context to hang the result off
 132  * @param[in] ev        The event context to work from
 133  * @param[in] type      Which syscall will this be
 134  * @param[in] fd        The file descriptor we work on
 135  * @param[in] fde_flags EVENT_FD_READ/WRITE -- what are we interested in?
 136  * @param[in] fde_cb    The callback function for the file descriptor event
 137  * @param[in] pstate    Where to put the newly created private_data state
 138  * @retval The new request
 139  *
 140  * This is a helper function to prepare a new struct async_req with an
 141  * associated struct async_syscall_state and an associated file descriptor
 142  * event.
 143  */
 144
 145 static struct async_req *async_fde_syscall_new(
 146         TALLOC_CTX *mem_ctx,
 147         struct event_context *ev,
 148         enum async_syscall_type type,
 149         int fd,
 150         uint16_t fde_flags,
 151         void (*fde_cb)(struct event_context *ev,
 152                        struct fd_event *fde, uint16_t flags,
 153                        void *priv),
 154         struct async_syscall_state **pstate)
 155 {
 156         struct async_req *result;
 157         struct async_syscall_state *state;
 158
 159         result = async_syscall_new(mem_ctx, ev, type, &state);
 160         if (result == NULL) {
 161                 return NULL;
 162         }
 163
 164         state->fde = event_add_fd(ev, state, fd, fde_flags, fde_cb, result);
 165         if (state->fde == NULL) {
 166                 TALLOC_FREE(result);
 167                 return NULL;
 168         }
 169         *pstate = state;
 170         return result;
 171 }
 172
 173 /**
 174  * Retrieve a ssize_t typed result from an async syscall
 175  * @param[in] req       The syscall that has just finished
 176  * @param[out] perrno   Where to put the syscall's errno
 177  * @retval The return value from the asynchronously called syscall
 178  */
 179
 180 ssize_t async_syscall_result_ssize_t(struct async_req *req, int *perrno)
 181 {
 182         struct async_syscall_state *state = talloc_get_type_abort(
 183                 req->private_data, struct async_syscall_state);
 184
 185         *perrno = state->sys_errno;
 186         return state->result.result_ssize_t;
 187 }
 188
 189 /**
 190  * Retrieve a size_t typed result from an async syscall
 191  * @param[in] req       The syscall that has just finished
 192  * @param[out] perrno   Where to put the syscall's errno
 193  * @retval The return value from the asynchronously called syscall
 194  */
 195
 196 size_t async_syscall_result_size_t(struct async_req *req, int *perrno)
 197 {
 198         struct async_syscall_state *state = talloc_get_type_abort(
 199                 req->private_data, struct async_syscall_state);
 200
 201         *perrno = state->sys_errno;
 202         return state->result.result_size_t;
 203 }
 204
 205 /**
 206  * Retrieve a int typed result from an async syscall
 207  * @param[in] req       The syscall that has just finished
 208  * @param[out] perrno   Where to put the syscall's errno
 209  * @retval The return value from the asynchronously called syscall
 210  */
 211
 212 ssize_t async_syscall_result_int(struct async_req *req, int *perrno)
 213 {
 214         struct async_syscall_state *state = talloc_get_type_abort(
 215                 req->private_data, struct async_syscall_state);
 216
 217         *perrno = state->sys_errno;
 218         return state->result.result_int;
 219 }
 220
 221 /**
 222  * fde event handler for the "send" syscall
 223  * @param[in] ev        The event context that sent us here
 224  * @param[in] fde       The file descriptor event associated with the send
 225  * @param[in] flags     Can only be EVENT_FD_WRITE here
 226  * @param[in] priv      private data, "struct async_req *" in this case
 227  */
 228
 229 static void async_send_callback(struct event_context *ev,
 230                                 struct fd_event *fde, uint16_t flags,
 231                                 void *priv)
 232 {
 233         struct async_req *req = talloc_get_type_abort(
 234                 priv, struct async_req);
 235         struct async_syscall_state *state = talloc_get_type_abort(
 236                 req->private_data, struct async_syscall_state);
 237         struct param_send *p = &state->param.param_send;
 238
 239         SMB_ASSERT(state->syscall_type == ASYNC_SYSCALL_SEND);
 240
 241         state->result.result_ssize_t = send(p->fd, p->buffer, p->length,
 242                                             p->flags);
 243         state->sys_errno = errno;
 244
 245         TALLOC_FREE(state->fde);
 246
 247         async_req_done(req);
 248 }
 249
 250 /**
 251  * Async version of send(2)
 252  * @param[in] mem_ctx   The memory context to hang the result off
 253  * @param[in] ev        The event context to work from
 254  * @param[in] fd        The socket to send to
 255  * @param[in] buffer    The buffer to send
 256  * @param[in] length    How many bytes to send
 257  * @param[in] flags     flags passed to send(2)
 258  *
 259  * This function is a direct counterpart of send(2)
 260  */
 261
 262 struct async_req *async_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
 263                              int fd, const void *buffer, size_t length,
 264                              int flags)
 265 {
 266         struct async_req *result;
 267         struct async_syscall_state *state;
 268
 269         result = async_fde_syscall_new(
 270                 mem_ctx, ev, ASYNC_SYSCALL_SEND,
 271                 fd, EVENT_FD_WRITE, async_send_callback,
 272                 &state);
 273         if (result == NULL) {
 274                 return NULL;
 275         }
 276
 277         state->param.param_send.fd = fd;
 278         state->param.param_send.buffer = buffer;
 279         state->param.param_send.length = length;
 280         state->param.param_send.flags = flags;
 281
 282         return result;
 283 }
 284
 285 /**
 286  * fde event handler for the "sendall" syscall group
 287  * @param[in] ev        The event context that sent us here
 288  * @param[in] fde       The file descriptor event associated with the send
 289  * @param[in] flags     Can only be EVENT_FD_WRITE here
 290  * @param[in] priv      private data, "struct async_req *" in this case
 291  */
 292
 293 static void async_sendall_callback(struct event_context *ev,
 294                                    struct fd_event *fde, uint16_t flags,
 295                                    void *priv)
 296 {
 297         struct async_req *req = talloc_get_type_abort(
 298                 priv, struct async_req);
 299         struct async_syscall_state *state = talloc_get_type_abort(
 300                 req->private_data, struct async_syscall_state);
 301         struct param_sendall *p = &state->param.param_sendall;
 302
 303         SMB_ASSERT(state->syscall_type == ASYNC_SYSCALL_SENDALL);
 304
 305         state->result.result_ssize_t = send(p->fd, (char *)p->buffer + p->sent,
 306                                             p->length - p->sent, p->flags);
 307         state->sys_errno = errno;
 308
 309         if (state->result.result_ssize_t == -1) {
 310                 async_req_error(req, map_nt_error_from_unix(state->sys_errno));
 311                 return;
 312         }
 313
 314         if (state->result.result_ssize_t == 0) {
 315                 async_req_error(req, NT_STATUS_END_OF_FILE);
 316                 return;
 317         }
 318
 319         p->sent += state->result.result_ssize_t;
 320         SMB_ASSERT(p->sent <= p->length);
 321
 322         if (p->sent == p->length) {
 323                 TALLOC_FREE(state->fde);
 324                 async_req_done(req);
 325         }
 326 }
 327
 328 /**
 329  * @brief Send all bytes to a socket
 330  * @param[in] mem_ctx   The memory context to hang the result off
 331  * @param[in] ev        The event context to work from
 332  * @param[in] fd        The socket to send to
 333  * @param[in] buffer    The buffer to send
 334  * @param[in] length    How many bytes to send
 335  * @param[in] flags     flags passed to send(2)
 336  *
 337  * async_sendall calls send(2) as long as it is necessary to send all of the
 338  * "length" bytes
 339  */
 340
 341 struct async_req *sendall_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
 342                                int fd, const void *buffer, size_t length,
 343                                int flags)
 344 {
 345         struct async_req *result;
 346         struct async_syscall_state *state;
 347
 348         result = async_fde_syscall_new(
 349                 mem_ctx, ev, ASYNC_SYSCALL_SENDALL,
 350                 fd, EVENT_FD_WRITE, async_sendall_callback,
 351                 &state);
 352         if (result == NULL) {
 353                 return NULL;
 354         }
 355
 356         state->param.param_sendall.fd = fd;
 357         state->param.param_sendall.buffer = buffer;
 358         state->param.param_sendall.length = length;
 359         state->param.param_sendall.flags = flags;
 360         state->param.param_sendall.sent = 0;
 361
 362         return result;
 363 }
 364
 365 NTSTATUS sendall_recv(struct async_req *req)
 366 {
 367         SMB_ASSERT(req->state >= ASYNC_REQ_DONE);
 368         if (req->state == ASYNC_REQ_ERROR) {
 369                 return req->status;
 370         }
 371         return NT_STATUS_OK;
 372 }
 373
 374 /**
 375  * fde event handler for the "recv" syscall
 376  * @param[in] ev        The event context that sent us here
 377  * @param[in] fde       The file descriptor event associated with the recv
 378  * @param[in] flags     Can only be EVENT_FD_READ here
 379  * @param[in] priv      private data, "struct async_req *" in this case
 380  */
 381
 382 static void async_recv_callback(struct event_context *ev,
 383                                 struct fd_event *fde, uint16_t flags,
 384                                 void *priv)
 385 {
 386         struct async_req *req = talloc_get_type_abort(
 387                 priv, struct async_req);
 388         struct async_syscall_state *state = talloc_get_type_abort(
 389                 req->private_data, struct async_syscall_state);
 390         struct param_recv *p = &state->param.param_recv;
 391
 392         SMB_ASSERT(state->syscall_type == ASYNC_SYSCALL_RECV);
 393
 394         state->result.result_ssize_t = recv(p->fd, p->buffer, p->length,
 395                                             p->flags);
 396         state->sys_errno = errno;
 397
 398         TALLOC_FREE(state->fde);
 399
 400         async_req_done(req);
 401 }
 402
 403 /**
 404  * Async version of recv(2)
 405  * @param[in] mem_ctx   The memory context to hang the result off
 406  * @param[in] ev        The event context to work from
 407  * @param[in] fd        The socket to recv from
 408  * @param[in] buffer    The buffer to recv into
 409  * @param[in] length    How many bytes to recv
 410  * @param[in] flags     flags passed to recv(2)
 411  *
 412  * This function is a direct counterpart of recv(2)
 413  */
 414
 415 struct async_req *async_recv(TALLOC_CTX *mem_ctx, struct event_context *ev,
 416                              int fd, void *buffer, size_t length,
 417                              int flags)
 418 {
 419         struct async_req *result;
 420         struct async_syscall_state *state;
 421
 422         result = async_fde_syscall_new(
 423                 mem_ctx, ev, ASYNC_SYSCALL_RECV,
 424                 fd, EVENT_FD_READ, async_recv_callback,
 425                 &state);
 426
 427         if (result == NULL) {
 428                 return NULL;
 429         }
 430
 431         state->param.param_recv.fd = fd;
 432         state->param.param_recv.buffer = buffer;
 433         state->param.param_recv.length = length;
 434         state->param.param_recv.flags = flags;
 435
 436         return result;
 437 }
 438
 439 /**
 440  * fde event handler for the "recvall" syscall group
 441  * @param[in] ev        The event context that sent us here
 442  * @param[in] fde       The file descriptor event associated with the recv
 443  * @param[in] flags     Can only be EVENT_FD_READ here
 444  * @param[in] priv      private data, "struct async_req *" in this case
 445  */
 446
 447 static void async_recvall_callback(struct event_context *ev,
 448                                    struct fd_event *fde, uint16_t flags,
 449                                    void *priv)
 450 {
 451         struct async_req *req = talloc_get_type_abort(
 452                 priv, struct async_req);
 453         struct async_syscall_state *state = talloc_get_type_abort(
 454                 req->private_data, struct async_syscall_state);
 455         struct param_recvall *p = &state->param.param_recvall;
 456
 457         SMB_ASSERT(state->syscall_type == ASYNC_SYSCALL_RECVALL);
 458
 459         state->result.result_ssize_t = recv(p->fd,
 460                                             (char *)p->buffer + p->received,
 461                                             p->length - p->received, p->flags);
 462         state->sys_errno = errno;
 463
 464         if (state->result.result_ssize_t == -1) {
 465                 async_req_error(req, map_nt_error_from_unix(state->sys_errno));
 466                 return;
 467         }
 468
 469         if (state->result.result_ssize_t == 0) {
 470                 async_req_error(req, NT_STATUS_END_OF_FILE);
 471                 return;
 472         }
 473
 474         p->received += state->result.result_ssize_t;
 475         SMB_ASSERT(p->received <= p->length);
 476
 477         if (p->received == p->length) {
 478                 TALLOC_FREE(state->fde);
 479                 async_req_done(req);
 480         }
 481 }
 482
 483 /**
 484  * Receive a specified number of bytes from a socket
 485  * @param[in] mem_ctx   The memory context to hang the result off
 486  * @param[in] ev        The event context to work from
 487  * @param[in] fd        The socket to recv from
 488  * @param[in] buffer    The buffer to recv into
 489  * @param[in] length    How many bytes to recv
 490  * @param[in] flags     flags passed to recv(2)
 491  *
 492  * async_recvall will call recv(2) until "length" bytes are received
 493  */
 494
 495 struct async_req *recvall_send(TALLOC_CTX *mem_ctx, struct event_context *ev,
 496                                int fd, void *buffer, size_t length,
 497                                int flags)
 498 {
 499         struct async_req *result;
 500         struct async_syscall_state *state;
 501
 502         result = async_fde_syscall_new(
 503                 mem_ctx, ev, ASYNC_SYSCALL_RECVALL,
 504                 fd, EVENT_FD_READ, async_recvall_callback,
 505                 &state);
 506         if (result == NULL) {
 507                 return NULL;
 508         }
 509
 510         state->param.param_recvall.fd = fd;
 511         state->param.param_recvall.buffer = buffer;
 512         state->param.param_recvall.length = length;
 513         state->param.param_recvall.flags = flags;
 514         state->param.param_recvall.received = 0;
 515
 516         return result;
 517 }
 518
 519 NTSTATUS recvall_recv(struct async_req *req)
 520 {
 521         SMB_ASSERT(req->state >= ASYNC_REQ_DONE);
 522         if (req->state == ASYNC_REQ_ERROR) {
 523                 return req->status;
 524         }
 525         return NT_STATUS_OK;
 526 }
 527
 528 /**
 529  * fde event handler for connect(2)
 530  * @param[in] ev        The event context that sent us here
 531  * @param[in] fde       The file descriptor event associated with the connect
 532  * @param[in] flags     Indicate read/writeability of the socket
 533  * @param[in] priv      private data, "struct async_req *" in this case
 534  */
 535
 536 static void async_connect_callback(struct event_context *ev,
 537                                    struct fd_event *fde, uint16_t flags,
 538                                    void *priv)
 539 {
 540         struct async_req *req = talloc_get_type_abort(
 541                 priv, struct async_req);
 542         struct async_syscall_state *state = talloc_get_type_abort(
 543                 req->private_data, struct async_syscall_state);
 544         struct param_connect *p = &state->param.param_connect;
 545
 546         SMB_ASSERT(state->syscall_type == ASYNC_SYSCALL_CONNECT);
 547
 548         TALLOC_FREE(state->fde);
 549
 550         /*
 551          * Stevens, Network Programming says that if there's a
 552          * successful connect, the socket is only writable. Upon an
 553          * error, it's both readable and writable.
 554          */
 555         if ((flags & (EVENT_FD_READ|EVENT_FD_WRITE))
 556             == (EVENT_FD_READ|EVENT_FD_WRITE)) {
 557                 int sockerr;
 558                 socklen_t err_len = sizeof(sockerr);
 559
 560                 if (getsockopt(p->fd, SOL_SOCKET, SO_ERROR,
 561                                (void *)&sockerr, &err_len) == 0) {
 562                         errno = sockerr;
 563                 }
 564
 565                 state->sys_errno = errno;
 566
 567                 DEBUG(10, ("connect returned %s\n", strerror(errno)));
 568
 569                 sys_fcntl_long(p->fd, F_SETFL, p->old_sockflags);
 570
 571                 async_req_error(req, map_nt_error_from_unix(state->sys_errno));
 572                 return;
 573         }
 574
 575         sys_fcntl_long(p->fd, F_SETFL, p->old_sockflags);
 576
 577         state->result.result_int = 0;
 578         state->sys_errno = 0;
 579
 580         async_req_done(req);
 581 }
 582
 583 /**
 584  * @brief async version of connect(2)
 585  * @param[in] mem_ctx   The memory context to hang the result off
 586  * @param[in] ev        The event context to work from
 587  * @param[in] fd        The socket to recv from
 588  * @param[in] address   Where to connect?
 589  * @param[in] address_len Length of *address
 590  * @retval The async request
 591  *
 592  * This function sets the socket into non-blocking state to be able to call
 593  * connect in an async state. This will be reset when the request is finished.
 594  */
 595
 596 struct async_req *async_connect(TALLOC_CTX *mem_ctx, struct event_context *ev,
 597                                 int fd, const struct sockaddr *address,
 598                                 socklen_t address_len)
 599 {
 600         struct async_req *result;
 601         struct async_syscall_state *state;
 602         struct param_connect *p;
 603
 604         result = async_syscall_new(mem_ctx, ev, ASYNC_SYSCALL_CONNECT, &state);
 605         if (result == NULL) {
 606                 return NULL;
 607         }
 608         p = &state->param.param_connect;
 609
 610         /**
 611          * We have to set the socket to nonblocking for async connect(2). Keep
 612          * the old sockflags around.
 613          */
 614
 615         p->old_sockflags = sys_fcntl_long(fd, F_GETFL, 0);
 616
 617         if (p->old_sockflags == -1) {
 618                 if (async_post_status(result, map_nt_error_from_unix(errno))) {
 619                         return result;
 620                 }
 621                 TALLOC_FREE(result);
 622                 return NULL;
 623         }
 624
 625         set_blocking(fd, true);
 626
 627         state->result.result_int = connect(fd, address, address_len);
 628
 629         if (state->result.result_int == 0) {
 630                 state->sys_errno = 0;
 631                 if (async_post_status(result, NT_STATUS_OK)) {
 632                         return result;
 633                 }
 634                 sys_fcntl_long(fd, F_SETFL, p->old_sockflags);
 635                 TALLOC_FREE(result);
 636                 return NULL;
 637         }
 638
 639         /**
 640          * A number of error messages show that something good is progressing
 641          * and that we have to wait for readability.
 642          *
 643          * If none of them are present, bail out.
 644          */
 645
 646         if (!(errno == EINPROGRESS || errno == EALREADY ||
 647 #ifdef EISCONN
 648               errno == EISCONN ||
 649 #endif
 650               errno == EAGAIN || errno == EINTR)) {
 651
 652                 state->sys_errno = errno;
 653
 654                 if (async_post_status(result, map_nt_error_from_unix(errno))) {
 655                         return result;
 656                 }
 657                 sys_fcntl_long(fd, F_SETFL, p->old_sockflags);
 658                 TALLOC_FREE(result);
 659                 return NULL;
 660         }
 661
 662         state->fde = event_add_fd(ev, state, fd,
 663                                   EVENT_FD_READ | EVENT_FD_WRITE,
 664                                   async_connect_callback, result);
 665         if (state->fde == NULL) {
 666                 sys_fcntl_long(fd, F_SETFL, p->old_sockflags);
 667                 TALLOC_FREE(result);
 668                 return NULL;
 669         }
 670         result->private_data = state;
 671
 672         state->param.param_connect.fd = fd;
 673         state->param.param_connect.address = address;
 674         state->param.param_connect.address_len = address_len;
 675
 676         return result;
 677 }
 678