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