tsocket: remove tsocket_context related stuff
[ira/wip.git] / lib / tsocket / tsocket.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Copyright (C) Stefan Metzmacher 2009
5
6      ** NOTE! The following LGPL license applies to the tevent
7      ** library. This does NOT imply that all of Samba is released
8      ** under the LGPL
9
10    This library is free software; you can redistribute it and/or
11    modify it under the terms of the GNU Lesser General Public
12    License as published by the Free Software Foundation; either
13    version 3 of the License, or (at your option) any later version.
14
15    This library is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18    Lesser General Public License for more details.
19
20    You should have received a copy of the GNU Lesser General Public
21    License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "replace.h"
25 #include "system/network.h"
26 #include "tsocket.h"
27 #include "tsocket_internal.h"
28
29 struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,
30                                                 const struct tsocket_address_ops *ops,
31                                                 void *pstate,
32                                                 size_t psize,
33                                                 const char *type,
34                                                 const char *location)
35 {
36         void **ppstate = (void **)pstate;
37         struct tsocket_address *addr;
38
39         addr = talloc_zero(mem_ctx, struct tsocket_address);
40         if (!addr) {
41                 return NULL;
42         }
43         addr->ops = ops;
44         addr->location = location;
45         addr->private_data = talloc_size(addr, psize);
46         if (!addr->private_data) {
47                 talloc_free(addr);
48                 return NULL;
49         }
50         talloc_set_name_const(addr->private_data, type);
51
52         *ppstate = addr->private_data;
53         return addr;
54 }
55
56 char *tsocket_address_string(const struct tsocket_address *addr,
57                              TALLOC_CTX *mem_ctx)
58 {
59         if (!addr) {
60                 return talloc_strdup(mem_ctx, "NULL");
61         }
62         return addr->ops->string(addr, mem_ctx);
63 }
64
65 struct tsocket_address *_tsocket_address_copy(const struct tsocket_address *addr,
66                                               TALLOC_CTX *mem_ctx,
67                                               const char *location)
68 {
69         return addr->ops->copy(addr, mem_ctx, location);
70 }
71
72 struct tdgram_context {
73         const char *location;
74         const struct tdgram_context_ops *ops;
75         void *private_data;
76 };
77
78 struct tdgram_context *_tdgram_context_create(TALLOC_CTX *mem_ctx,
79                                         const struct tdgram_context_ops *ops,
80                                         void *pstate,
81                                         size_t psize,
82                                         const char *type,
83                                         const char *location)
84 {
85         struct tdgram_context *dgram;
86         void **ppstate = (void **)pstate;
87         void *state;
88
89         dgram = talloc(mem_ctx, struct tdgram_context);
90         if (dgram == NULL) {
91                 return NULL;
92         }
93         dgram->location = location;
94         dgram->ops      = ops;
95
96         state = talloc_size(dgram, psize);
97         if (state == NULL) {
98                 talloc_free(dgram);
99                 return NULL;
100         }
101         talloc_set_name_const(state, type);
102
103         dgram->private_data = state;
104
105         *ppstate = state;
106         return dgram;
107 }
108
109 void *_tdgram_context_data(struct tdgram_context *dgram)
110 {
111         return dgram->private_data;
112 }
113
114 struct tdgram_recvfrom_state {
115         const struct tdgram_context_ops *ops;
116         uint8_t *buf;
117         size_t len;
118         struct tsocket_address *src;
119 };
120
121 static void tdgram_recvfrom_done(struct tevent_req *subreq);
122
123 struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
124                                         struct tevent_context *ev,
125                                         struct tdgram_context *dgram)
126 {
127         struct tevent_req *req;
128         struct tdgram_recvfrom_state *state;
129         struct tevent_req *subreq;
130
131         req = tevent_req_create(mem_ctx, &state,
132                                 struct tdgram_recvfrom_state);
133         if (req == NULL) {
134                 return NULL;
135         }
136
137         state->ops = dgram->ops;
138
139         subreq = state->ops->recvfrom_send(state, ev, dgram);
140         if (tevent_req_nomem(subreq, req)) {
141                 goto post;
142         }
143         tevent_req_set_callback(subreq, tdgram_recvfrom_done, req);
144
145         return req;
146
147  post:
148         tevent_req_post(req, ev);
149         return req;
150 }
151
152 static void tdgram_recvfrom_done(struct tevent_req *subreq)
153 {
154         struct tevent_req *req = tevent_req_callback_data(subreq,
155                                  struct tevent_req);
156         struct tdgram_recvfrom_state *state = tevent_req_data(req,
157                                               struct tdgram_recvfrom_state);
158         ssize_t ret;
159         int sys_errno;
160
161         ret = state->ops->recvfrom_recv(subreq, &sys_errno, state,
162                                         &state->buf, &state->src);
163         if (ret == -1) {
164                 tevent_req_error(req, sys_errno);
165                 return;
166         }
167
168         state->len = ret;
169
170         tevent_req_done(req);
171 }
172
173 ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
174                              int *perrno,
175                              TALLOC_CTX *mem_ctx,
176                              uint8_t **buf,
177                              struct tsocket_address **src)
178 {
179         struct tdgram_recvfrom_state *state = tevent_req_data(req,
180                                               struct tdgram_recvfrom_state);
181         ssize_t ret;
182
183         ret = tsocket_simple_int_recv(req, perrno);
184         if (ret == 0) {
185                 *buf = talloc_move(mem_ctx, &state->buf);
186                 ret = state->len;
187                 if (src) {
188                         *src = talloc_move(mem_ctx, &state->src);
189                 }
190         }
191
192         tevent_req_received(req);
193         return ret;
194 }
195
196 struct tdgram_sendto_state {
197         const struct tdgram_context_ops *ops;
198         ssize_t ret;
199 };
200
201 static void tdgram_sendto_done(struct tevent_req *subreq);
202
203 struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
204                                       struct tevent_context *ev,
205                                       struct tdgram_context *dgram,
206                                       const uint8_t *buf, size_t len,
207                                       const struct tsocket_address *dst)
208 {
209         struct tevent_req *req;
210         struct tdgram_sendto_state *state;
211         struct tevent_req *subreq;
212
213         req = tevent_req_create(mem_ctx, &state,
214                                 struct tdgram_sendto_state);
215         if (req == NULL) {
216                 return NULL;
217         }
218
219         state->ops = dgram->ops;
220         state->ret = -1;
221
222         subreq = state->ops->sendto_send(state, ev, dgram,
223                                          buf, len, dst);
224         if (tevent_req_nomem(subreq, req)) {
225                 goto post;
226         }
227         tevent_req_set_callback(subreq, tdgram_sendto_done, req);
228
229         return req;
230
231  post:
232         tevent_req_post(req, ev);
233         return req;
234 }
235
236 static void tdgram_sendto_done(struct tevent_req *subreq)
237 {
238         struct tevent_req *req = tevent_req_callback_data(subreq,
239                                  struct tevent_req);
240         struct tdgram_sendto_state *state = tevent_req_data(req,
241                                             struct tdgram_sendto_state);
242         ssize_t ret;
243         int sys_errno;
244
245         ret = state->ops->sendto_recv(subreq, &sys_errno);
246         if (ret == -1) {
247                 tevent_req_error(req, sys_errno);
248                 return;
249         }
250
251         state->ret = ret;
252
253         tevent_req_done(req);
254 }
255
256 ssize_t tdgram_sendto_recv(struct tevent_req *req,
257                            int *perrno)
258 {
259         struct tdgram_sendto_state *state = tevent_req_data(req,
260                                             struct tdgram_sendto_state);
261         ssize_t ret;
262
263         ret = tsocket_simple_int_recv(req, perrno);
264         if (ret == 0) {
265                 ret = state->ret;
266         }
267
268         tevent_req_received(req);
269         return ret;
270 }
271
272 struct tdgram_disconnect_state {
273         const struct tdgram_context_ops *ops;
274 };
275
276 static void tdgram_disconnect_done(struct tevent_req *subreq);
277
278 struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
279                                           struct tevent_context *ev,
280                                           struct tdgram_context *dgram)
281 {
282         struct tevent_req *req;
283         struct tdgram_disconnect_state *state;
284         struct tevent_req *subreq;
285
286         req = tevent_req_create(mem_ctx, &state,
287                                 struct tdgram_disconnect_state);
288         if (req == NULL) {
289                 return NULL;
290         }
291
292         state->ops = dgram->ops;
293
294         subreq = state->ops->disconnect_send(state, ev, dgram);
295         if (tevent_req_nomem(subreq, req)) {
296                 goto post;
297         }
298         tevent_req_set_callback(subreq, tdgram_disconnect_done, req);
299
300         return req;
301
302  post:
303         tevent_req_post(req, ev);
304         return req;
305 }
306
307 static void tdgram_disconnect_done(struct tevent_req *subreq)
308 {
309         struct tevent_req *req = tevent_req_callback_data(subreq,
310                                  struct tevent_req);
311         struct tdgram_disconnect_state *state = tevent_req_data(req,
312                                                 struct tdgram_disconnect_state);
313         int ret;
314         int sys_errno;
315
316         ret = state->ops->disconnect_recv(subreq, &sys_errno);
317         if (ret == -1) {
318                 tevent_req_error(req, sys_errno);
319                 return;
320         }
321
322         tevent_req_done(req);
323 }
324
325 int tdgram_disconnect_recv(struct tevent_req *req,
326                            int *perrno)
327 {
328         int ret;
329
330         ret = tsocket_simple_int_recv(req, perrno);
331
332         tevent_req_received(req);
333         return ret;
334 }
335
336 struct tdgram_sendto_queue_state {
337         /* this structs are owned by the caller */
338         struct {
339                 struct tevent_context *ev;
340                 struct tdgram_context *dgram;
341                 const uint8_t *buf;
342                 size_t len;
343                 const struct tsocket_address *dst;
344         } caller;
345         ssize_t ret;
346 };
347
348 static void tdgram_sendto_queue_trigger(struct tevent_req *req,
349                                          void *private_data);
350 static void tdgram_sendto_queue_done(struct tevent_req *subreq);
351
352 /**
353  * @brief Queue a dgram blob for sending through the socket
354  * @param[in] mem_ctx   The memory context for the result
355  * @param[in] ev        The event context the operation should work on
356  * @param[in] dgram     The tdgram_context to send the message buffer
357  * @param[in] queue     The existing dgram queue
358  * @param[in] buf       The message buffer
359  * @param[in] len       The message length
360  * @param[in] dst       The destination socket address
361  * @retval              The async request handle
362  *
363  * This function queues a blob for sending to destination through an existing
364  * dgram socket. The async callback is triggered when the whole blob is
365  * delivered to the underlying system socket.
366  *
367  * The caller needs to make sure that all non-scalar input parameters hang
368  * arround for the whole lifetime of the request.
369  */
370 struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
371                                             struct tevent_context *ev,
372                                             struct tdgram_context *dgram,
373                                             struct tevent_queue *queue,
374                                             const uint8_t *buf,
375                                             size_t len,
376                                             struct tsocket_address *dst)
377 {
378         struct tevent_req *req;
379         struct tdgram_sendto_queue_state *state;
380         bool ok;
381
382         req = tevent_req_create(mem_ctx, &state,
383                                 struct tdgram_sendto_queue_state);
384         if (!req) {
385                 return NULL;
386         }
387
388         state->caller.ev        = ev;
389         state->caller.dgram     = dgram;
390         state->caller.buf       = buf;
391         state->caller.len       = len;
392         state->caller.dst       = dst;
393         state->ret              = -1;
394
395         ok = tevent_queue_add(queue,
396                               ev,
397                               req,
398                               tdgram_sendto_queue_trigger,
399                               NULL);
400         if (!ok) {
401                 tevent_req_nomem(NULL, req);
402                 goto post;
403         }
404
405         return req;
406
407  post:
408         tevent_req_post(req, ev);
409         return req;
410 }
411
412 static void tdgram_sendto_queue_trigger(struct tevent_req *req,
413                                          void *private_data)
414 {
415         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
416                                         struct tdgram_sendto_queue_state);
417         struct tevent_req *subreq;
418
419         subreq = tdgram_sendto_send(state,
420                                     state->caller.ev,
421                                     state->caller.dgram,
422                                     state->caller.buf,
423                                     state->caller.len,
424                                     state->caller.dst);
425         if (tevent_req_nomem(subreq, req)) {
426                 return;
427         }
428         tevent_req_set_callback(subreq, tdgram_sendto_queue_done, req);
429 }
430
431 static void tdgram_sendto_queue_done(struct tevent_req *subreq)
432 {
433         struct tevent_req *req = tevent_req_callback_data(subreq,
434                                  struct tevent_req);
435         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
436                                         struct tdgram_sendto_queue_state);
437         ssize_t ret;
438         int sys_errno;
439
440         ret = tdgram_sendto_recv(subreq, &sys_errno);
441         talloc_free(subreq);
442         if (ret == -1) {
443                 tevent_req_error(req, sys_errno);
444                 return;
445         }
446         state->ret = ret;
447
448         tevent_req_done(req);
449 }
450
451 ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno)
452 {
453         struct tdgram_sendto_queue_state *state = tevent_req_data(req,
454                                         struct tdgram_sendto_queue_state);
455         ssize_t ret;
456
457         ret = tsocket_simple_int_recv(req, perrno);
458         if (ret == 0) {
459                 ret = state->ret;
460         }
461
462         tevent_req_received(req);
463         return ret;
464 }
465