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