source: mainline/uspace/srv/net/tcp/service.c@ 1433ecda

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1433ecda was 1433ecda, checked in by Jiri Svoboda <jiri@…>, 7 years ago

Fix cstyle: make ccheck-fix and commit only files where all the changes are good.
  • Property mode set to 100644
File size: 29.8 KB
Line 
1/*
2 * Copyright (c) 2015 Jiri Svoboda
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup tcp
30 * @{
31 */
32
33/**
34 * @file HelenOS service implementation
35 */
36
37#include <async.h>
38#include <errno.h>
39#include <str_error.h>
40#include <inet/endpoint.h>
41#include <inet/inet.h>
42#include <io/log.h>
43#include <ipc/services.h>
44#include <ipc/tcp.h>
45#include <loc.h>
46#include <macros.h>
47#include <mem.h>
48#include <stdlib.h>
49
50#include "conn.h"
51#include "service.h"
52#include "tcp_type.h"
53#include "ucall.h"
54
55#define NAME "tcp"
56
57/** Maximum amount of data transferred in one send call */
58#define MAX_MSG_SIZE DATA_XFER_LIMIT
59
60static void tcp_ev_data(tcp_cconn_t *);
61static void tcp_ev_connected(tcp_cconn_t *);
62static void tcp_ev_conn_failed(tcp_cconn_t *);
63static void tcp_ev_conn_reset(tcp_cconn_t *);
64static void tcp_ev_new_conn(tcp_clst_t *, tcp_cconn_t *);
65
66static void tcp_service_cstate_change(tcp_conn_t *, void *, tcp_cstate_t);
67static void tcp_service_recv_data(tcp_conn_t *, void *);
68static void tcp_service_lst_cstate_change(tcp_conn_t *, void *, tcp_cstate_t);
69
70static errno_t tcp_cconn_create(tcp_client_t *, tcp_conn_t *, tcp_cconn_t **);
71
72/** Connection callbacks to tie us to lower layer */
73static tcp_cb_t tcp_service_cb = {
74 .cstate_change = tcp_service_cstate_change,
75 .recv_data = tcp_service_recv_data
76};
77
78/** Sentinel connection callbacks to tie us to lower layer */
79static tcp_cb_t tcp_service_lst_cb = {
80 .cstate_change = tcp_service_lst_cstate_change,
81 .recv_data = NULL
82};
83
84/** Connection state has changed.
85 *
86 * @param conn Connection
87 * @param arg Argument (not used)
88 * @param old_state Previous connection state
89 */
90static void tcp_service_cstate_change(tcp_conn_t *conn, void *arg,
91 tcp_cstate_t old_state)
92{
93 tcp_cstate_t nstate;
94 tcp_cconn_t *cconn;
95
96 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_service_cstate_change()");
97 nstate = conn->cstate;
98 cconn = tcp_uc_get_userptr(conn);
99
100 if ((old_state == st_syn_sent || old_state == st_syn_received) &&
101 (nstate == st_established)) {
102 /* Connection established */
103 tcp_ev_connected(cconn);
104 }
105
106 if (old_state != st_closed && nstate == st_closed && conn->reset) {
107 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_service_cstate_change: "
108 "Connection reset");
109 /* Connection reset */
110 tcp_ev_conn_reset(cconn);
111 } else {
112 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_service_cstate_change: "
113 "old_state=%d nstate=%d conn->reset=%d",
114 old_state, nstate, conn->reset);
115 }
116
117 /* XXX Failed to establish connection */
118 if (0)
119 tcp_ev_conn_failed(cconn);
120}
121
122/** Sentinel connection state has changed.
123 *
124 * @param conn Connection
125 * @param arg Argument (not used)
126 * @param old_state Previous connection state
127 */
128static void tcp_service_lst_cstate_change(tcp_conn_t *conn, void *arg,
129 tcp_cstate_t old_state)
130{
131 tcp_cstate_t nstate;
132 tcp_clst_t *clst;
133 tcp_cconn_t *cconn;
134 inet_ep2_t epp;
135 errno_t rc;
136 tcp_error_t trc;
137
138 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_service_lst_cstate_change()");
139 nstate = conn->cstate;
140 clst = tcp_uc_get_userptr(conn);
141
142 if ((old_state == st_syn_sent || old_state == st_syn_received) &&
143 (nstate == st_established)) {
144 /* Connection established */
145 clst->conn = NULL;
146
147 rc = tcp_cconn_create(clst->client, conn, &cconn);
148 if (rc != EOK) {
149 /* XXX Could not create client connection */
150 return;
151 }
152
153 /* XXX Is there a race here (i.e. the connection is already active)? */
154 tcp_uc_set_cb(conn, &tcp_service_cb, cconn);
155
156 /* New incoming connection */
157 tcp_ev_new_conn(clst, cconn);
158 }
159
160 if (old_state != st_closed && nstate == st_closed && conn->reset) {
161 /* Connection reset */
162 /* XXX */
163 }
164
165 /* XXX Failed to establish connection */
166 if (0) {
167 /* XXX */
168 }
169
170 /* Replenish sentinel connection */
171
172 inet_ep2_init(&epp);
173 epp.local = clst->elocal;
174
175 trc = tcp_uc_open(&epp, ap_passive, tcp_open_nonblock,
176 &conn);
177 if (trc != TCP_EOK) {
178 /* XXX Could not replenish connection */
179 return;
180 }
181
182 conn->name = (char *) "s";
183 clst->conn = conn;
184
185 /* XXX Is there a race here (i.e. the connection is already active)? */
186 tcp_uc_set_cb(conn, &tcp_service_lst_cb, clst);
187}
188
189/** Received data became available on connection.
190 *
191 * @param conn Connection
192 * @param arg Client connection
193 */
194static void tcp_service_recv_data(tcp_conn_t *conn, void *arg)
195{
196 tcp_cconn_t *cconn = (tcp_cconn_t *)arg;
197
198 tcp_ev_data(cconn);
199}
200
201/** Send 'data' event to client.
202 *
203 * @param cconn Client connection
204 */
205static void tcp_ev_data(tcp_cconn_t *cconn)
206{
207 async_exch_t *exch;
208
209 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ev_data()");
210
211 log_msg(LOG_DEFAULT, LVL_DEBUG, "client=%p\n", cconn->client);
212 log_msg(LOG_DEFAULT, LVL_DEBUG, "sess=%p\n", cconn->client->sess);
213
214 exch = async_exchange_begin(cconn->client->sess);
215 aid_t req = async_send_1(exch, TCP_EV_DATA, cconn->id, NULL);
216 async_exchange_end(exch);
217
218 async_forget(req);
219}
220
221/** Send 'connected' event to client.
222 *
223 * @param cconn Client connection
224 */
225static void tcp_ev_connected(tcp_cconn_t *cconn)
226{
227 async_exch_t *exch;
228
229 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ev_connected()");
230
231 exch = async_exchange_begin(cconn->client->sess);
232 aid_t req = async_send_1(exch, TCP_EV_CONNECTED, cconn->id, NULL);
233 async_exchange_end(exch);
234
235 async_forget(req);
236}
237
238/** Send 'conn_failed' event to client.
239 *
240 * @param cconn Client connection
241 */
242static void tcp_ev_conn_failed(tcp_cconn_t *cconn)
243{
244 async_exch_t *exch;
245
246 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ev_conn_failed()");
247
248 exch = async_exchange_begin(cconn->client->sess);
249 aid_t req = async_send_1(exch, TCP_EV_CONN_FAILED, cconn->id, NULL);
250 async_exchange_end(exch);
251
252 async_forget(req);
253}
254
255/** Send 'conn_reset' event to client.
256 *
257 * @param cconn Client connection
258 */
259static void tcp_ev_conn_reset(tcp_cconn_t *cconn)
260{
261 async_exch_t *exch;
262
263 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ev_conn_reset()");
264
265 exch = async_exchange_begin(cconn->client->sess);
266 aid_t req = async_send_1(exch, TCP_EV_CONN_RESET, cconn->id, NULL);
267 async_exchange_end(exch);
268
269 async_forget(req);
270}
271
272/** Send 'new_conn' event to client.
273 *
274 * @param clst Client listener that received the connection
275 * @param cconn New client connection
276 */
277static void tcp_ev_new_conn(tcp_clst_t *clst, tcp_cconn_t *cconn)
278{
279 async_exch_t *exch;
280
281 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ev_new_conn()");
282
283 exch = async_exchange_begin(clst->client->sess);
284 aid_t req = async_send_2(exch, TCP_EV_NEW_CONN, clst->id, cconn->id,
285 NULL);
286 async_exchange_end(exch);
287
288 async_forget(req);
289}
290
291/** Create client connection.
292 *
293 * This effectively adds a connection into a client's namespace.
294 *
295 * @param client TCP client
296 * @param conn Connection
297 * @param rcconn Place to store pointer to new client connection
298 *
299 * @return EOK on success or ENOMEM if out of memory
300 */
301static errno_t tcp_cconn_create(tcp_client_t *client, tcp_conn_t *conn,
302 tcp_cconn_t **rcconn)
303{
304 tcp_cconn_t *cconn;
305 sysarg_t id;
306
307 cconn = calloc(1, sizeof(tcp_cconn_t));
308 if (cconn == NULL)
309 return ENOMEM;
310
311 /* Allocate new ID */
312 id = 0;
313 list_foreach (client->cconn, lclient, tcp_cconn_t, cconn) {
314 if (cconn->id >= id)
315 id = cconn->id + 1;
316 }
317
318 cconn->id = id;
319 cconn->client = client;
320 cconn->conn = conn;
321
322 list_append(&cconn->lclient, &client->cconn);
323 *rcconn = cconn;
324 return EOK;
325}
326
327/** Destroy client connection.
328 *
329 * @param cconn Client connection
330 */
331static void tcp_cconn_destroy(tcp_cconn_t *cconn)
332{
333 list_remove(&cconn->lclient);
334 free(cconn);
335}
336
337/** Create client listener.
338 *
339 * Create client listener based on sentinel connection.
340 * XXX Implement actual listener in protocol core
341 *
342 * @param client TCP client
343 * @param conn Sentinel connection
344 * @param rclst Place to store pointer to new client listener
345 *
346 * @return EOK on success or ENOMEM if out of memory
347 */
348static errno_t tcp_clistener_create(tcp_client_t *client, tcp_conn_t *conn,
349 tcp_clst_t **rclst)
350{
351 tcp_clst_t *clst;
352 sysarg_t id;
353
354 clst = calloc(1, sizeof(tcp_clst_t));
355 if (clst == NULL)
356 return ENOMEM;
357
358 /* Allocate new ID */
359 id = 0;
360 list_foreach (client->clst, lclient, tcp_clst_t, clst) {
361 if (clst->id >= id)
362 id = clst->id + 1;
363 }
364
365 clst->id = id;
366 clst->client = client;
367 clst->conn = conn;
368
369 list_append(&clst->lclient, &client->clst);
370 *rclst = clst;
371 return EOK;
372}
373
374/** Destroy client listener.
375 *
376 * @param clst Client listener
377 */
378static void tcp_clistener_destroy(tcp_clst_t *clst)
379{
380 list_remove(&clst->lclient);
381 free(clst);
382}
383
384/** Get client connection by ID.
385 *
386 * @param client Client
387 * @param id Client connection ID
388 * @param rcconn Place to store pointer to client connection
389 *
390 * @return EOK on success, ENOENT if no client connection with the given ID
391 * is found.
392 */
393static errno_t tcp_cconn_get(tcp_client_t *client, sysarg_t id,
394 tcp_cconn_t **rcconn)
395{
396 list_foreach (client->cconn, lclient, tcp_cconn_t, cconn) {
397 if (cconn->id == id) {
398 *rcconn = cconn;
399 return EOK;
400 }
401 }
402
403 return ENOENT;
404}
405
406/** Get client listener by ID.
407 *
408 * @param client Client
409 * @param id Client connection ID
410 * @param rclst Place to store pointer to client listener
411 *
412 * @return EOK on success, ENOENT if no client listener with the given ID
413 * is found.
414 */
415static errno_t tcp_clistener_get(tcp_client_t *client, sysarg_t id,
416 tcp_clst_t **rclst)
417{
418 list_foreach (client->clst, lclient, tcp_clst_t, clst) {
419 if (clst->id == id) {
420 *rclst = clst;
421 return EOK;
422 }
423 }
424
425 return ENOENT;
426}
427
428/** Create connection.
429 *
430 * Handle client request to create connection (with parameters unmarshalled).
431 *
432 * @param client TCP client
433 * @param epp Endpoint pair
434 * @param rconn_id Place to store ID of new connection
435 *
436 * @return EOK on success or an error code
437 */
438static errno_t tcp_conn_create_impl(tcp_client_t *client, inet_ep2_t *epp,
439 sysarg_t *rconn_id)
440{
441 tcp_conn_t *conn;
442 tcp_cconn_t *cconn;
443 errno_t rc;
444 tcp_error_t trc;
445 char *slocal;
446 char *sremote;
447
448 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_impl");
449
450 inet_addr_format(&epp->local.addr, &slocal);
451 inet_addr_format(&epp->remote.addr, &sremote);
452 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create: local=%s remote=%s",
453 slocal, sremote);
454 free(slocal);
455 free(sremote);
456
457 trc = tcp_uc_open(epp, ap_active, tcp_open_nonblock, &conn);
458 if (trc != TCP_EOK)
459 return EIO;
460
461 conn->name = (char *) "c";
462
463 rc = tcp_cconn_create(client, conn, &cconn);
464 if (rc != EOK) {
465 assert(rc == ENOMEM);
466 tcp_conn_delete(conn);
467 return ENOMEM;
468 }
469
470 /* XXX Is there a race here (i.e. the connection is already active)? */
471 tcp_uc_set_cb(conn, &tcp_service_cb, cconn);
472
473 *rconn_id = cconn->id;
474 return EOK;
475}
476
477/** Destroy connection.
478 *
479 * Handle client request to destroy connection (with parameters unmarshalled).
480 *
481 * @param client TCP client
482 * @param conn_id Connection ID
483 * @return EOK on success, ENOENT if no such connection is found
484 */
485static errno_t tcp_conn_destroy_impl(tcp_client_t *client, sysarg_t conn_id)
486{
487 tcp_cconn_t *cconn;
488 errno_t rc;
489
490 rc = tcp_cconn_get(client, conn_id, &cconn);
491 if (rc != EOK) {
492 assert(rc == ENOENT);
493 return ENOENT;
494 }
495
496 tcp_uc_close(cconn->conn);
497 tcp_uc_delete(cconn->conn);
498 tcp_cconn_destroy(cconn);
499 return EOK;
500}
501
502/** Create listener.
503 *
504 * Handle client request to create listener (with parameters unmarshalled).
505 *
506 * @param client TCP client
507 * @param ep Endpoint
508 * @param rlst_id Place to store ID of new listener
509 *
510 * @return EOK on success or an error code
511*/
512static errno_t tcp_listener_create_impl(tcp_client_t *client, inet_ep_t *ep,
513 sysarg_t *rlst_id)
514{
515 tcp_conn_t *conn;
516 tcp_clst_t *clst;
517 inet_ep2_t epp;
518 errno_t rc;
519 tcp_error_t trc;
520
521 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_impl");
522
523 inet_ep2_init(&epp);
524 epp.local.addr = ep->addr;
525 epp.local.port = ep->port;
526
527 trc = tcp_uc_open(&epp, ap_passive, tcp_open_nonblock, &conn);
528 if (trc != TCP_EOK)
529 return EIO;
530
531 conn->name = (char *) "s";
532
533 rc = tcp_clistener_create(client, conn, &clst);
534 if (rc != EOK) {
535 assert(rc == ENOMEM);
536 tcp_conn_delete(conn);
537 return ENOMEM;
538 }
539
540 clst->elocal = epp.local;
541
542 /* XXX Is there a race here (i.e. the connection is already active)? */
543 tcp_uc_set_cb(conn, &tcp_service_lst_cb, clst);
544
545 *rlst_id = clst->id;
546 return EOK;
547}
548
549/** Destroy listener.
550 *
551 * Handle client request to destroy listener (with parameters unmarshalled).
552 *
553 * @param client TCP client
554 * @param lst_id Listener ID
555 *
556 * @return EOK on success, ENOENT if no such listener is found
557 */
558static errno_t tcp_listener_destroy_impl(tcp_client_t *client, sysarg_t lst_id)
559{
560 tcp_clst_t *clst;
561 errno_t rc;
562
563 rc = tcp_clistener_get(client, lst_id, &clst);
564 if (rc != EOK) {
565 assert(rc == ENOENT);
566 return ENOENT;
567 }
568
569// tcp_uc_close(cconn->conn);
570 tcp_clistener_destroy(clst);
571 return EOK;
572}
573
574/** Send FIN.
575 *
576 * Handle client request to send FIN (with parameters unmarshalled).
577 *
578 * @param client TCP client
579 * @param conn_id Connection ID
580 *
581 * @return EOK on success or an error code
582 */
583static errno_t tcp_conn_send_fin_impl(tcp_client_t *client, sysarg_t conn_id)
584{
585 tcp_cconn_t *cconn;
586 errno_t rc;
587
588 rc = tcp_cconn_get(client, conn_id, &cconn);
589 if (rc != EOK) {
590 assert(rc == ENOENT);
591 return ENOENT;
592 }
593
594 (void) cconn;
595 /* XXX TODO */
596 return EOK;
597}
598
599/** Push connection.
600 *
601 * Handle client request to push connection (with parameters unmarshalled).
602 *
603 * @param client TCP client
604 * @param conn_id Connection ID
605 *
606 * @return EOK on success or an error code
607 */
608static errno_t tcp_conn_push_impl(tcp_client_t *client, sysarg_t conn_id)
609{
610 tcp_cconn_t *cconn;
611 errno_t rc;
612
613 rc = tcp_cconn_get(client, conn_id, &cconn);
614 if (rc != EOK) {
615 assert(rc == ENOENT);
616 return ENOENT;
617 }
618
619 (void) cconn;
620 /* XXX TODO */
621 return EOK;
622}
623
624/** Reset connection.
625 *
626 * Handle client request to reset connection (with parameters unmarshalled).
627 *
628 * @param client TCP client
629 * @param conn_id Connection ID
630 *
631 * @return EOK on success or an error code
632 */
633static errno_t tcp_conn_reset_impl(tcp_client_t *client, sysarg_t conn_id)
634{
635 tcp_cconn_t *cconn;
636 errno_t rc;
637
638 rc = tcp_cconn_get(client, conn_id, &cconn);
639 if (rc != EOK) {
640 assert(rc == ENOENT);
641 return ENOENT;
642 }
643
644 tcp_uc_abort(cconn->conn);
645 return EOK;
646}
647
648/** Send data over connection..
649 *
650 * Handle client request to send data (with parameters unmarshalled).
651 *
652 * @param client TCP client
653 * @param conn_id Connection ID
654 * @param data Data buffer
655 * @param size Data size in bytes
656 *
657 * @return EOK on success or an error code
658 */
659static errno_t tcp_conn_send_impl(tcp_client_t *client, sysarg_t conn_id,
660 void *data, size_t size)
661{
662 tcp_cconn_t *cconn;
663 errno_t rc;
664 tcp_error_t trc;
665
666 rc = tcp_cconn_get(client, conn_id, &cconn);
667 if (rc != EOK)
668 return rc;
669
670 trc = tcp_uc_send(cconn->conn, data, size, 0);
671 if (trc != TCP_EOK)
672 return EIO;
673
674 return EOK;
675}
676
677/** Receive data from connection.
678 *
679 * Handle client request to receive data (with parameters unmarshalled).
680 *
681 * @param client TCP client
682 * @param conn_id Connection ID
683 * @param data Data buffer
684 * @param size Buffer size in bytes
685 * @param nrecv Place to store actual number of bytes received
686 *
687 * @return EOK on success or an error code
688 */
689static errno_t tcp_conn_recv_impl(tcp_client_t *client, sysarg_t conn_id,
690 void *data, size_t size, size_t *nrecv)
691{
692 tcp_cconn_t *cconn;
693 xflags_t xflags;
694 errno_t rc;
695 tcp_error_t trc;
696
697 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_impl()");
698
699 rc = tcp_cconn_get(client, conn_id, &cconn);
700 if (rc != EOK) {
701 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_impl() - conn not found");
702 return rc;
703 }
704
705 trc = tcp_uc_receive(cconn->conn, data, size, nrecv, &xflags);
706 if (trc != TCP_EOK) {
707 switch (trc) {
708 case TCP_EAGAIN:
709 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_impl() - EAGAIN");
710 return EAGAIN;
711 case TCP_ECLOSING:
712 *nrecv = 0;
713 return EOK;
714 default:
715 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_impl() - trc=%d", trc);
716 return EIO;
717 }
718 }
719
720 return EOK;
721}
722
723/** Create client callback session.
724 *
725 * Handle client request to create callback session.
726 *
727 * @param client TCP client
728 * @param icall_handle Async request call handle
729 * @param icall Async request data
730 */
731static void tcp_callback_create_srv(tcp_client_t *client,
732 cap_call_handle_t icall_handle, ipc_call_t *icall)
733{
734 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
735
736 async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
737 if (sess == NULL) {
738 async_answer_0(icall_handle, ENOMEM);
739 return;
740 }
741
742 client->sess = sess;
743 async_answer_0(icall_handle, EOK);
744}
745
746/** Create connection.
747 *
748 * Handle client request to create connection.
749 *
750 * @param client TCP client
751 * @param icall_handle Async request call handle
752 * @param icall Async request data
753 */
754static void tcp_conn_create_srv(tcp_client_t *client,
755 cap_call_handle_t icall_handle, ipc_call_t *icall)
756{
757 cap_call_handle_t chandle;
758 size_t size;
759 inet_ep2_t epp;
760 sysarg_t conn_id;
761 errno_t rc;
762
763 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
764
765 if (!async_data_write_receive(&chandle, &size)) {
766 async_answer_0(chandle, EREFUSED);
767 async_answer_0(icall_handle, EREFUSED);
768 return;
769 }
770
771 if (size != sizeof(inet_ep2_t)) {
772 async_answer_0(chandle, EINVAL);
773 async_answer_0(icall_handle, EINVAL);
774 return;
775 }
776
777 rc = async_data_write_finalize(chandle, &epp, size);
778 if (rc != EOK) {
779 async_answer_0(chandle, rc);
780 async_answer_0(icall_handle, rc);
781 return;
782 }
783
784 rc = tcp_conn_create_impl(client, &epp, &conn_id);
785 if (rc != EOK) {
786 async_answer_0(icall_handle, rc);
787 return;
788 }
789
790 async_answer_1(icall_handle, EOK, conn_id);
791}
792
793/** Destroy connection.
794 *
795 * Handle client request to destroy connection.
796 *
797 * @param client TCP client
798 * @param icall_handle Async request call handle
799 * @param icall Async request data
800 */
801static void tcp_conn_destroy_srv(tcp_client_t *client,
802 cap_call_handle_t icall_handle, ipc_call_t *icall)
803{
804 sysarg_t conn_id;
805 errno_t rc;
806
807 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_destroy_srv()");
808
809 conn_id = IPC_GET_ARG1(*icall);
810 rc = tcp_conn_destroy_impl(client, conn_id);
811 async_answer_0(icall_handle, rc);
812}
813
814/** Create listener.
815 *
816 * Handle client request to create listener.
817 *
818 * @param client TCP client
819 * @param icall_handle Async request call handle
820 * @param icall Async request data
821 */
822static void tcp_listener_create_srv(tcp_client_t *client,
823 cap_call_handle_t icall_handle, ipc_call_t *icall)
824{
825 cap_call_handle_t chandle;
826 size_t size;
827 inet_ep_t ep;
828 sysarg_t lst_id;
829 errno_t rc;
830
831 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
832
833 if (!async_data_write_receive(&chandle, &size)) {
834 async_answer_0(chandle, EREFUSED);
835 async_answer_0(icall_handle, EREFUSED);
836 return;
837 }
838
839 if (size != sizeof(inet_ep_t)) {
840 async_answer_0(chandle, EINVAL);
841 async_answer_0(icall_handle, EINVAL);
842 return;
843 }
844
845 rc = async_data_write_finalize(chandle, &ep, size);
846 if (rc != EOK) {
847 async_answer_0(chandle, rc);
848 async_answer_0(icall_handle, rc);
849 return;
850 }
851
852 rc = tcp_listener_create_impl(client, &ep, &lst_id);
853 if (rc != EOK) {
854 async_answer_0(icall_handle, rc);
855 return;
856 }
857
858 async_answer_1(icall_handle, EOK, lst_id);
859}
860
861/** Destroy listener.
862 *
863 * Handle client request to destroy listener.
864 *
865 * @param client TCP client
866 * @param icall_handle Async request call handle
867 * @param icall Async request data
868 */
869static void tcp_listener_destroy_srv(tcp_client_t *client,
870 cap_call_handle_t icall_handle, ipc_call_t *icall)
871{
872 sysarg_t lst_id;
873 errno_t rc;
874
875 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_destroy_srv()");
876
877 lst_id = IPC_GET_ARG1(*icall);
878 rc = tcp_listener_destroy_impl(client, lst_id);
879 async_answer_0(icall_handle, rc);
880}
881
882/** Send FIN.
883 *
884 * Handle client request to send FIN.
885 *
886 * @param client TCP client
887 * @param icall_handle Async request call handle
888 * @param icall Async request data
889 */
890static void tcp_conn_send_fin_srv(tcp_client_t *client,
891 cap_call_handle_t icall_handle, ipc_call_t *icall)
892{
893 sysarg_t conn_id;
894 errno_t rc;
895
896 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_send_fin_srv()");
897
898 conn_id = IPC_GET_ARG1(*icall);
899 rc = tcp_conn_send_fin_impl(client, conn_id);
900 async_answer_0(icall_handle, rc);
901}
902
903/** Push connection.
904 *
905 * Handle client request to push connection.
906 *
907 * @param client TCP client
908 * @param icall_handle Async request call handle
909 * @param icall Async request data
910 */
911static void tcp_conn_push_srv(tcp_client_t *client,
912 cap_call_handle_t icall_handle, ipc_call_t *icall)
913{
914 sysarg_t conn_id;
915 errno_t rc;
916
917 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_push_srv()");
918
919 conn_id = IPC_GET_ARG1(*icall);
920 rc = tcp_conn_push_impl(client, conn_id);
921 async_answer_0(icall_handle, rc);
922}
923
924/** Reset connection.
925 *
926 * Handle client request to reset connection.
927 *
928 * @param client TCP client
929 * @param icall_handle Async request call handle
930 * @param icall Async request data
931 */
932static void tcp_conn_reset_srv(tcp_client_t *client,
933 cap_call_handle_t icall_handle, ipc_call_t *icall)
934{
935 sysarg_t conn_id;
936 errno_t rc;
937
938 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_reset_srv()");
939
940 conn_id = IPC_GET_ARG1(*icall);
941 rc = tcp_conn_reset_impl(client, conn_id);
942 async_answer_0(icall_handle, rc);
943}
944
945/** Send data via connection..
946 *
947 * Handle client request to send data via connection.
948 *
949 * @param client TCP client
950 * @param icall_handle Async request call handle
951 * @param icall Async request data
952 */
953static void tcp_conn_send_srv(tcp_client_t *client,
954 cap_call_handle_t icall_handle, ipc_call_t *icall)
955{
956 cap_call_handle_t chandle;
957 size_t size;
958 sysarg_t conn_id;
959 void *data;
960 errno_t rc;
961
962 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_send_srv())");
963
964 /* Receive message data */
965
966 if (!async_data_write_receive(&chandle, &size)) {
967 async_answer_0(chandle, EREFUSED);
968 async_answer_0(icall_handle, EREFUSED);
969 return;
970 }
971
972 if (size > MAX_MSG_SIZE) {
973 async_answer_0(chandle, EINVAL);
974 async_answer_0(icall_handle, EINVAL);
975 return;
976 }
977
978 data = malloc(size);
979 if (data == NULL) {
980 async_answer_0(chandle, ENOMEM);
981 async_answer_0(icall_handle, ENOMEM);
982 return;
983 }
984
985 rc = async_data_write_finalize(chandle, data, size);
986 if (rc != EOK) {
987 async_answer_0(chandle, rc);
988 async_answer_0(icall_handle, rc);
989 free(data);
990 return;
991 }
992
993 conn_id = IPC_GET_ARG1(*icall);
994
995 rc = tcp_conn_send_impl(client, conn_id, data, size);
996 if (rc != EOK) {
997 async_answer_0(icall_handle, rc);
998 free(data);
999 return;
1000 }
1001
1002 async_answer_0(icall_handle, EOK);
1003 free(data);
1004}
1005
1006/** Read received data from connection without blocking.
1007 *
1008 * Handle client request to read received data via connection without blocking.
1009 *
1010 * @param client TCP client
1011 * @param icall_handle Async request call handle
1012 * @param icall Async request data
1013 */
1014static void tcp_conn_recv_srv(tcp_client_t *client,
1015 cap_call_handle_t icall_handle, ipc_call_t *icall)
1016{
1017 cap_call_handle_t chandle;
1018 sysarg_t conn_id;
1019 size_t size, rsize;
1020 void *data;
1021 errno_t rc;
1022
1023 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_srv()");
1024
1025 conn_id = IPC_GET_ARG1(*icall);
1026
1027 if (!async_data_read_receive(&chandle, &size)) {
1028 async_answer_0(chandle, EREFUSED);
1029 async_answer_0(icall_handle, EREFUSED);
1030 return;
1031 }
1032
1033 size = min(size, 16384);
1034 data = malloc(size);
1035 if (data == NULL) {
1036 async_answer_0(chandle, ENOMEM);
1037 async_answer_0(icall_handle, ENOMEM);
1038 return;
1039 }
1040
1041 rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
1042 if (rc != EOK) {
1043 async_answer_0(chandle, rc);
1044 async_answer_0(icall_handle, rc);
1045 free(data);
1046 return;
1047 }
1048
1049 rc = async_data_read_finalize(chandle, data, size);
1050 if (rc != EOK) {
1051 async_answer_0(icall_handle, rc);
1052 free(data);
1053 return;
1054 }
1055
1056 async_answer_1(icall_handle, EOK, rsize);
1057 free(data);
1058
1059 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_srv(): OK");
1060}
1061
1062/** Read received data from connection with blocking.
1063 *
1064 * Handle client request to read received data via connection with blocking.
1065 *
1066 * @param client TCP client
1067 * @param icall_handle Async request call handle
1068 * @param icall Async request data
1069 */
1070static void tcp_conn_recv_wait_srv(tcp_client_t *client,
1071 cap_call_handle_t icall_handle, ipc_call_t *icall)
1072{
1073 cap_call_handle_t chandle;
1074 sysarg_t conn_id;
1075 size_t size, rsize;
1076 void *data;
1077 errno_t rc;
1078
1079 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv()");
1080
1081 conn_id = IPC_GET_ARG1(*icall);
1082
1083 if (!async_data_read_receive(&chandle, &size)) {
1084 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
1085 async_answer_0(chandle, EREFUSED);
1086 async_answer_0(icall_handle, EREFUSED);
1087 return;
1088 }
1089
1090 size = min(size, 16384);
1091 data = malloc(size);
1092 if (data == NULL) {
1093 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
1094 async_answer_0(chandle, ENOMEM);
1095 async_answer_0(icall_handle, ENOMEM);
1096 return;
1097 }
1098
1099 rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
1100 if (rc != EOK) {
1101 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
1102 async_answer_0(chandle, rc);
1103 async_answer_0(icall_handle, rc);
1104 free(data);
1105 return;
1106 }
1107
1108 rc = async_data_read_finalize(chandle, data, size);
1109 if (rc != EOK) {
1110 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
1111 async_answer_0(icall_handle, rc);
1112 free(data);
1113 return;
1114 }
1115
1116 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
1117 async_answer_1(icall_handle, EOK, rsize);
1118 free(data);
1119
1120 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): OK");
1121}
1122
1123/** Initialize TCP client structure.
1124 *
1125 * @param client TCP client
1126 */
1127static void tcp_client_init(tcp_client_t *client)
1128{
1129 memset(client, 0, sizeof(tcp_client_t));
1130 client->sess = NULL;
1131 list_initialize(&client->cconn);
1132 list_initialize(&client->clst);
1133}
1134
1135/** Finalize TCP client structure.
1136 *
1137 * @param client TCP client
1138 */
1139static void tcp_client_fini(tcp_client_t *client)
1140{
1141 tcp_cconn_t *cconn;
1142 unsigned long n;
1143
1144 n = list_count(&client->cconn);
1145 if (n != 0) {
1146 log_msg(LOG_DEFAULT, LVL_WARN, "Client with %lu active "
1147 "connections closed session", n);
1148
1149 while (!list_empty(&client->cconn)) {
1150 cconn = list_get_instance(list_first(&client->cconn),
1151 tcp_cconn_t, lclient);
1152 tcp_uc_close(cconn->conn);
1153 tcp_uc_delete(cconn->conn);
1154 tcp_cconn_destroy(cconn);
1155 }
1156 }
1157
1158 n = list_count(&client->clst);
1159 if (n != 0) {
1160 log_msg(LOG_DEFAULT, LVL_WARN, "Client with %lu active "
1161 "listeners closed session", n);
1162 /* XXX Destroy listeners */
1163 }
1164
1165 if (client->sess != NULL)
1166 async_hangup(client->sess);
1167}
1168
1169/** Handle TCP client connection.
1170 *
1171 * @param icall_handle Connect call handle
1172 * @param icall Connect call data
1173 * @param arg Connection argument
1174 */
1175static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
1176 void *arg)
1177{
1178 tcp_client_t client;
1179
1180 /* Accept the connection */
1181 async_answer_0(icall_handle, EOK);
1182
1183 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
1184 &client);
1185
1186 tcp_client_init(&client);
1187
1188 while (true) {
1189 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
1190 ipc_call_t call;
1191 cap_call_handle_t chandle = async_get_call(&call);
1192 sysarg_t method = IPC_GET_IMETHOD(call);
1193
1194 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: method=%d",
1195 (int)method);
1196 if (!method) {
1197 /* The other side has hung up */
1198 async_answer_0(chandle, EOK);
1199 break;
1200 }
1201
1202 switch (method) {
1203 case TCP_CALLBACK_CREATE:
1204 tcp_callback_create_srv(&client, chandle, &call);
1205 break;
1206 case TCP_CONN_CREATE:
1207 tcp_conn_create_srv(&client, chandle, &call);
1208 break;
1209 case TCP_CONN_DESTROY:
1210 tcp_conn_destroy_srv(&client, chandle, &call);
1211 break;
1212 case TCP_LISTENER_CREATE:
1213 tcp_listener_create_srv(&client, chandle, &call);
1214 break;
1215 case TCP_LISTENER_DESTROY:
1216 tcp_listener_destroy_srv(&client, chandle, &call);
1217 break;
1218 case TCP_CONN_SEND_FIN:
1219 tcp_conn_send_fin_srv(&client, chandle, &call);
1220 break;
1221 case TCP_CONN_PUSH:
1222 tcp_conn_push_srv(&client, chandle, &call);
1223 break;
1224 case TCP_CONN_RESET:
1225 tcp_conn_reset_srv(&client, chandle, &call);
1226 break;
1227 case TCP_CONN_SEND:
1228 tcp_conn_send_srv(&client, chandle, &call);
1229 break;
1230 case TCP_CONN_RECV:
1231 tcp_conn_recv_srv(&client, chandle, &call);
1232 break;
1233 case TCP_CONN_RECV_WAIT:
1234 tcp_conn_recv_wait_srv(&client, chandle, &call);
1235 break;
1236 default:
1237 async_answer_0(chandle, ENOTSUP);
1238 break;
1239 }
1240 }
1241
1242 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn TERMINATED");
1243 tcp_client_fini(&client);
1244}
1245
1246/** Initialize TCP service.
1247 *
1248 * @return EOK on success or an error code.
1249 */
1250errno_t tcp_service_init(void)
1251{
1252 errno_t rc;
1253 service_id_t sid;
1254
1255 async_set_fallback_port_handler(tcp_client_conn, NULL);
1256
1257 rc = loc_server_register(NAME);
1258 if (rc != EOK) {
1259 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
1260 return EIO;
1261 }
1262
1263 rc = loc_service_register(SERVICE_NAME_TCP, &sid);
1264 if (rc != EOK) {
1265 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service.");
1266 return EIO;
1267 }
1268
1269 return EOK;
1270}
1271
1272/**
1273 * @}
1274 */
Note: See TracBrowser for help on using the repository browser.