source: mainline/uspace/srv/net/tcp/sock.c@ 7b64cf0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 7b64cf0 was 05bfce7, checked in by Martin Decky <martin@…>, 13 years ago

make tcp_sock_bind() structurally similar to udp_sock_bind()
if calling listen() or accept() before bind() then find to a free port
  • Property mode set to 100644
File size: 24.4 KB
Line 
1/*
2 * Copyright (c) 2008 Lukas Mejdrech
3 * Copyright (c) 2011 Jiri Svoboda
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup tcp
31 * @{
32 */
33
34/**
35 * @file Socket provider
36 */
37
38#include <async.h>
39#include <errno.h>
40#include <inet/inet.h>
41#include <io/log.h>
42#include <ipc/services.h>
43#include <ipc/socket.h>
44#include <net/socket.h>
45#include <ns.h>
46
47#include "sock.h"
48#include "std.h"
49#include "tcp.h"
50#include "tcp_type.h"
51#include "ucall.h"
52
53#define MAX_BACKLOG 128
54
55/** Free ports pool start. */
56#define TCP_FREE_PORTS_START 1025
57
58/** Free ports pool end. */
59#define TCP_FREE_PORTS_END 65535
60
61static int last_used_port = TCP_FREE_PORTS_START - 1;
62static socket_ports_t gsock;
63
64static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
65static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
66static int tcp_sock_recv_fibril(void *arg);
67
68int tcp_sock_init(void)
69{
70 socket_ports_initialize(&gsock);
71
72 async_set_client_connection(tcp_sock_connection);
73
74 int rc = service_register(SERVICE_TCP);
75 if (rc != EOK)
76 return EEXIST;
77
78 return EOK;
79}
80
81static void tcp_free_sock_data(socket_core_t *sock_core)
82{
83 tcp_sockdata_t *socket;
84
85 socket = (tcp_sockdata_t *)sock_core->specific_data;
86 (void)socket;
87
88 /* XXX We need to initiate connection cleanup here */
89}
90
91static void tcp_sock_notify_data(socket_core_t *sock_core)
92{
93 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
94 async_exch_t *exch = async_exchange_begin(sock_core->sess);
95 async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
96 TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
97 async_exchange_end(exch);
98}
99
100static void tcp_sock_notify_aconn(socket_core_t *lsock_core)
101{
102 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
103 async_exch_t *exch = async_exchange_begin(lsock_core->sess);
104 async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
105 TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
106 async_exchange_end(exch);
107}
108
109static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
110{
111 tcp_sockdata_t *sock;
112
113 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_create()");
114 *rsock = NULL;
115
116 sock = calloc(1, sizeof(tcp_sockdata_t));
117 if (sock == NULL)
118 return ENOMEM;
119
120 fibril_mutex_initialize(&sock->lock);
121 sock->client = client;
122
123 sock->recv_buffer_used = 0;
124 sock->recv_error = TCP_EOK;
125 fibril_mutex_initialize(&sock->recv_buffer_lock);
126 fibril_condvar_initialize(&sock->recv_buffer_cv);
127 list_initialize(&sock->ready);
128
129 *rsock = sock;
130 return EOK;
131}
132
133static void tcp_sock_uncreate(tcp_sockdata_t *sock)
134{
135 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_uncreate()");
136 free(sock);
137}
138
139static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
140{
141 socket_core_t *sock_core;
142 int rc;
143
144 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_finish_setup()");
145
146 sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
147 if (sock->recv_fibril == 0)
148 return ENOMEM;
149
150 rc = socket_create(&sock->client->sockets, sock->client->sess,
151 sock, sock_id);
152
153 if (rc != EOK) {
154 fibril_destroy(sock->recv_fibril);
155 sock->recv_fibril = 0;
156 return rc;
157 }
158
159 sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
160 assert(sock_core != NULL);
161 sock->sock_core = sock_core;
162
163 return EOK;
164}
165
166static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
167{
168 tcp_sockdata_t *sock;
169 int sock_id;
170 int rc;
171 ipc_call_t answer;
172
173 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_socket()");
174
175 rc = tcp_sock_create(client, &sock);
176 if (rc != EOK) {
177 async_answer_0(callid, rc);
178 return;
179 }
180
181 sock->laddr.ipv4 = TCP_IPV4_ANY;
182 sock->lconn = NULL;
183 sock->backlog = 0;
184
185 sock_id = SOCKET_GET_SOCKET_ID(call);
186 rc = tcp_sock_finish_setup(sock, &sock_id);
187 if (rc != EOK) {
188 tcp_sock_uncreate(sock);
189 async_answer_0(callid, rc);
190 return;
191 }
192
193 SOCKET_SET_SOCKET_ID(answer, sock_id);
194
195 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
196 SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
197
198 async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
199 IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
200}
201
202static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
203{
204 int rc;
205 struct sockaddr_in *addr;
206 size_t addr_size;
207 socket_core_t *sock_core;
208 tcp_sockdata_t *socket;
209
210 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
211 log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
212
213 addr = NULL;
214
215 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
216 if (rc != EOK) {
217 async_answer_0(callid, rc);
218 goto out;
219 }
220
221 if (addr_size != sizeof(struct sockaddr_in)) {
222 async_answer_0(callid, EINVAL);
223 goto out;
224 }
225
226 log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
227 rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
228 addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
229 last_used_port);
230 if (rc != EOK) {
231 async_answer_0(callid, rc);
232 goto out;
233 }
234
235 log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
236 sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
237 if (sock_core == NULL) {
238 async_answer_0(callid, ENOENT);
239 goto out;
240 }
241
242 socket = (tcp_sockdata_t *)sock_core->specific_data;
243 /* XXX Anything to do? */
244 (void) socket;
245
246 log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
247 async_answer_0(callid, EOK);
248
249out:
250 if (addr != NULL)
251 free(addr);
252}
253
254static void tcp_sock_listen(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
255{
256 int socket_id;
257 int backlog;
258 socket_core_t *sock_core;
259 tcp_sockdata_t *socket;
260 tcp_error_t trc;
261 tcp_sock_t lsocket;
262 tcp_sock_t fsocket;
263 tcp_conn_t *conn;
264 tcp_sock_lconn_t *lconn;
265 int i;
266 int rc;
267
268 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
269
270 socket_id = SOCKET_GET_SOCKET_ID(call);
271 backlog = SOCKET_GET_BACKLOG(call);
272
273 if (backlog < 0) {
274 async_answer_0(callid, EINVAL);
275 return;
276 }
277
278 if (backlog > MAX_BACKLOG)
279 backlog = MAX_BACKLOG;
280
281 sock_core = socket_cores_find(&client->sockets, socket_id);
282 if (sock_core == NULL) {
283 async_answer_0(callid, ENOTSOCK);
284 return;
285 }
286
287 if (sock_core->port <= 0) {
288 rc = socket_bind_free_port(&gsock, sock_core,
289 TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
290 last_used_port);
291 if (rc != EOK) {
292 async_answer_0(callid, rc);
293 return;
294 }
295
296 last_used_port = sock_core->port;
297 }
298
299 socket = (tcp_sockdata_t *) sock_core->specific_data;
300
301 /*
302 * Prepare @c backlog listening connections.
303 */
304 fibril_mutex_lock(&socket->lock);
305
306 socket->backlog = backlog;
307 socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
308 if (socket->lconn == NULL) {
309 fibril_mutex_unlock(&socket->lock);
310 async_answer_0(callid, ENOMEM);
311 return;
312 }
313
314 log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
315
316 lsocket.addr.ipv4 = TCP_IPV4_ANY;
317 lsocket.port = sock_core->port;
318 fsocket.addr.ipv4 = TCP_IPV4_ANY;
319 fsocket.port = TCP_PORT_ANY;
320
321 for (i = 0; i < backlog; i++) {
322
323 lconn = calloc(1, sizeof(tcp_sock_lconn_t));
324 if (lconn == NULL) {
325 /* XXX Clean up */
326 fibril_mutex_unlock(&socket->lock);
327 async_answer_0(callid, ENOMEM);
328 return;
329 }
330
331 trc = tcp_uc_open(&lsocket, &fsocket, ap_passive,
332 tcp_open_nonblock, &conn);
333 if (conn == NULL) {
334 /* XXX Clean up */
335 fibril_mutex_unlock(&socket->lock);
336 async_answer_0(callid, ENOMEM);
337 return;
338 }
339
340 tcp_uc_set_cstate_cb(conn, tcp_sock_cstate_cb, lconn);
341
342 assert(trc == TCP_EOK);
343 conn->name = (char *)"S";
344
345 lconn->conn = conn;
346 lconn->socket = socket;
347 link_initialize(&lconn->ready_list);
348 socket->lconn[i] = lconn;
349 }
350
351 fibril_mutex_unlock(&socket->lock);
352 async_answer_0(callid, EOK);
353}
354
355static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
356{
357 int rc;
358 struct sockaddr_in *addr;
359 int socket_id;
360 size_t addr_len;
361 socket_core_t *sock_core;
362 tcp_sockdata_t *socket;
363 tcp_error_t trc;
364 tcp_sock_t lsocket;
365 tcp_sock_t fsocket;
366
367 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
368
369 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
370 if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
371 async_answer_0(callid, rc);
372 return;
373 }
374
375 socket_id = SOCKET_GET_SOCKET_ID(call);
376
377 sock_core = socket_cores_find(&client->sockets, socket_id);
378 if (sock_core == NULL) {
379 async_answer_0(callid, ENOTSOCK);
380 return;
381 }
382
383 socket = (tcp_sockdata_t *)sock_core->specific_data;
384 if (sock_core->port <= 0) {
385 rc = socket_bind_free_port(&gsock, sock_core,
386 TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
387 last_used_port);
388 if (rc != EOK) {
389 async_answer_0(callid, rc);
390 return;
391 }
392
393 last_used_port = sock_core->port;
394 }
395
396 fibril_mutex_lock(&socket->lock);
397
398 if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
399 /* Determine local IP address */
400 inet_addr_t loc_addr, rem_addr;
401
402 rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
403 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
404 if (rc != EOK) {
405 fibril_mutex_unlock(&socket->lock);
406 async_answer_0(callid, rc);
407 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
408 "determine local address.");
409 return;
410 }
411
412 socket->laddr.ipv4 = loc_addr.ipv4;
413 log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
414 }
415
416 lsocket.addr.ipv4 = socket->laddr.ipv4;
417 lsocket.port = sock_core->port;
418 fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
419 fsocket.port = uint16_t_be2host(addr->sin_port);
420
421 trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
422
423 if (socket->conn != NULL)
424 socket->conn->name = (char *)"C";
425
426 fibril_mutex_unlock(&socket->lock);
427
428 switch (trc) {
429 case TCP_EOK:
430 rc = EOK;
431 break;
432 case TCP_ERESET:
433 rc = ECONNREFUSED;
434 break;
435 default:
436 assert(false);
437 }
438
439 if (rc == EOK)
440 fibril_add_ready(socket->recv_fibril);
441
442 async_answer_0(callid, rc);
443}
444
445static void tcp_sock_accept(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
446{
447 ipc_call_t answer;
448 int socket_id;
449 int asock_id;
450 socket_core_t *sock_core;
451 tcp_sockdata_t *socket;
452 tcp_sockdata_t *asocket;
453 tcp_error_t trc;
454 tcp_sock_t lsocket;
455 tcp_sock_t fsocket;
456 tcp_conn_t *conn;
457 tcp_conn_t *rconn;
458 tcp_sock_lconn_t *lconn;
459 int rc;
460
461 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept()");
462
463 socket_id = SOCKET_GET_SOCKET_ID(call);
464 asock_id = SOCKET_GET_NEW_SOCKET_ID(call);
465
466 sock_core = socket_cores_find(&client->sockets, socket_id);
467 if (sock_core == NULL) {
468 async_answer_0(callid, ENOTSOCK);
469 return;
470 }
471
472 if (sock_core->port <= 0) {
473 rc = socket_bind_free_port(&gsock, sock_core,
474 TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
475 last_used_port);
476 if (rc != EOK) {
477 async_answer_0(callid, rc);
478 return;
479 }
480
481 last_used_port = sock_core->port;
482 }
483
484 socket = (tcp_sockdata_t *)sock_core->specific_data;
485 fibril_mutex_lock(&socket->lock);
486
487 log_msg(LOG_DEFAULT, LVL_DEBUG, " - verify socket->conn");
488 if (socket->conn != NULL) {
489 fibril_mutex_unlock(&socket->lock);
490 async_answer_0(callid, EINVAL);
491 return;
492 }
493
494 if (list_empty(&socket->ready)) {
495 fibril_mutex_unlock(&socket->lock);
496 async_answer_0(callid, ENOENT);
497 return;
498 }
499
500 lconn = list_get_instance(list_first(&socket->ready),
501 tcp_sock_lconn_t, ready_list);
502 list_remove(&lconn->ready_list);
503
504 conn = lconn->conn;
505 tcp_uc_set_cstate_cb(conn, NULL, NULL);
506
507 /* Replenish listening connection */
508
509 lsocket.addr.ipv4 = TCP_IPV4_ANY;
510 lsocket.port = sock_core->port;
511 fsocket.addr.ipv4 = TCP_IPV4_ANY;
512 fsocket.port = TCP_PORT_ANY;
513
514 trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, tcp_open_nonblock,
515 &rconn);
516 if (rconn == NULL) {
517 /* XXX Clean up */
518 fibril_mutex_unlock(&socket->lock);
519 async_answer_0(callid, ENOMEM);
520 return;
521 }
522
523 tcp_uc_set_cstate_cb(rconn, tcp_sock_cstate_cb, lconn);
524
525 assert(trc == TCP_EOK);
526 rconn->name = (char *)"S";
527
528 lconn->conn = rconn;
529
530 /* Allocate socket for accepted connection */
531
532 rc = tcp_sock_create(client, &asocket);
533 if (rc != EOK) {
534 fibril_mutex_unlock(&socket->lock);
535 async_answer_0(callid, rc);
536 return;
537 }
538
539 asocket->conn = conn;
540 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept():create asocket\n");
541
542 rc = tcp_sock_finish_setup(asocket, &asock_id);
543 if (rc != EOK) {
544 tcp_sock_uncreate(asocket);
545 fibril_mutex_unlock(&socket->lock);
546 async_answer_0(callid, rc);
547 return;
548 }
549
550 fibril_add_ready(asocket->recv_fibril);
551
552 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): find acore\n");
553
554 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
555 SOCKET_SET_SOCKET_ID(answer, asock_id);
556 SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
557
558 async_answer_3(callid, asocket->sock_core->socket_id,
559 IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
560 IPC_GET_ARG3(answer));
561
562 /* Push one fragment notification to client's queue */
563 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): notify data\n");
564 fibril_mutex_unlock(&socket->lock);
565}
566
567static void tcp_sock_send(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
568{
569 int socket_id;
570 int fragments;
571 int index;
572 socket_core_t *sock_core;
573 tcp_sockdata_t *socket;
574 ipc_call_t answer;
575 ipc_callid_t wcallid;
576 size_t length;
577 uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
578 tcp_error_t trc;
579 int rc;
580
581 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()");
582 socket_id = SOCKET_GET_SOCKET_ID(call);
583 fragments = SOCKET_GET_DATA_FRAGMENTS(call);
584 SOCKET_GET_FLAGS(call);
585
586 sock_core = socket_cores_find(&client->sockets, socket_id);
587 if (sock_core == NULL) {
588 async_answer_0(callid, ENOTSOCK);
589 return;
590 }
591
592 socket = (tcp_sockdata_t *)sock_core->specific_data;
593 fibril_mutex_lock(&socket->lock);
594
595 if (socket->conn == NULL) {
596 fibril_mutex_unlock(&socket->lock);
597 async_answer_0(callid, ENOTCONN);
598 return;
599 }
600
601 for (index = 0; index < fragments; index++) {
602 if (!async_data_write_receive(&wcallid, &length)) {
603 fibril_mutex_unlock(&socket->lock);
604 async_answer_0(callid, EINVAL);
605 return;
606 }
607
608 if (length > TCP_SOCK_FRAGMENT_SIZE)
609 length = TCP_SOCK_FRAGMENT_SIZE;
610
611 rc = async_data_write_finalize(wcallid, buffer, length);
612 if (rc != EOK) {
613 fibril_mutex_unlock(&socket->lock);
614 async_answer_0(callid, rc);
615 return;
616 }
617
618 trc = tcp_uc_send(socket->conn, buffer, length, 0);
619
620 switch (trc) {
621 case TCP_EOK:
622 rc = EOK;
623 break;
624 case TCP_ENOTEXIST:
625 rc = ENOTCONN;
626 break;
627 case TCP_ECLOSING:
628 rc = ENOTCONN;
629 break;
630 case TCP_ERESET:
631 rc = ECONNABORTED;
632 break;
633 default:
634 assert(false);
635 }
636
637 if (rc != EOK) {
638 fibril_mutex_unlock(&socket->lock);
639 async_answer_0(callid, rc);
640 return;
641 }
642 }
643
644 IPC_SET_ARG1(answer, 0);
645 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
646 async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
647 IPC_GET_ARG2(answer));
648 fibril_mutex_unlock(&socket->lock);
649}
650
651static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
652{
653 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_sendto()");
654 async_answer_0(callid, ENOTSUP);
655}
656
657static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
658{
659 int socket_id;
660 int flags;
661 size_t addr_length, length;
662 socket_core_t *sock_core;
663 tcp_sockdata_t *socket;
664 ipc_call_t answer;
665 ipc_callid_t rcallid;
666 size_t data_len;
667 struct sockaddr_in addr;
668 tcp_sock_t *rsock;
669 int rc;
670
671 log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
672
673 socket_id = SOCKET_GET_SOCKET_ID(call);
674 flags = SOCKET_GET_FLAGS(call);
675
676 sock_core = socket_cores_find(&client->sockets, socket_id);
677 if (sock_core == NULL) {
678 async_answer_0(callid, ENOTSOCK);
679 return;
680 }
681
682 socket = (tcp_sockdata_t *)sock_core->specific_data;
683 fibril_mutex_lock(&socket->lock);
684
685 if (socket->conn == NULL) {
686 fibril_mutex_unlock(&socket->lock);
687 async_answer_0(callid, ENOTCONN);
688 return;
689 }
690
691 (void)flags;
692
693 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
694 fibril_mutex_lock(&socket->recv_buffer_lock);
695 while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
696 log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
697 fibril_condvar_wait(&socket->recv_buffer_cv,
698 &socket->recv_buffer_lock);
699 }
700
701 log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
702
703 data_len = socket->recv_buffer_used;
704 rc = socket->recv_error;
705
706 switch (socket->recv_error) {
707 case TCP_EOK:
708 rc = EOK;
709 break;
710 case TCP_ENOTEXIST:
711 case TCP_ECLOSING:
712 rc = ENOTCONN;
713 break;
714 case TCP_ERESET:
715 rc = ECONNABORTED;
716 break;
717 default:
718 assert(false);
719 }
720
721 log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
722 if (rc != EOK) {
723 fibril_mutex_unlock(&socket->recv_buffer_lock);
724 fibril_mutex_unlock(&socket->lock);
725 async_answer_0(callid, rc);
726 return;
727 }
728
729 if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
730 /* Fill addr */
731 rsock = &socket->conn->ident.foreign;
732 addr.sin_family = AF_INET;
733 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
734 addr.sin_port = host2uint16_t_be(rsock->port);
735
736 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
737 if (!async_data_read_receive(&rcallid, &addr_length)) {
738 fibril_mutex_unlock(&socket->recv_buffer_lock);
739 fibril_mutex_unlock(&socket->lock);
740 async_answer_0(callid, EINVAL);
741 return;
742 }
743
744 if (addr_length > sizeof(addr))
745 addr_length = sizeof(addr);
746
747 log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
748 rc = async_data_read_finalize(rcallid, &addr, addr_length);
749 if (rc != EOK) {
750 fibril_mutex_unlock(&socket->recv_buffer_lock);
751 fibril_mutex_unlock(&socket->lock);
752 async_answer_0(callid, EINVAL);
753 return;
754 }
755 }
756
757 log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
758 if (!async_data_read_receive(&rcallid, &length)) {
759 fibril_mutex_unlock(&socket->recv_buffer_lock);
760 fibril_mutex_unlock(&socket->lock);
761 async_answer_0(callid, EINVAL);
762 return;
763 }
764
765 if (length > data_len)
766 length = data_len;
767
768 log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
769 rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
770
771 socket->recv_buffer_used -= length;
772 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
773 socket->recv_buffer_used);
774 if (socket->recv_buffer_used > 0) {
775 memmove(socket->recv_buffer, socket->recv_buffer + length,
776 socket->recv_buffer_used);
777 tcp_sock_notify_data(socket->sock_core);
778 }
779
780 fibril_condvar_broadcast(&socket->recv_buffer_cv);
781
782 if (length < data_len && rc == EOK)
783 rc = EOVERFLOW;
784
785 SOCKET_SET_READ_DATA_LENGTH(answer, length);
786 async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
787
788 fibril_mutex_unlock(&socket->recv_buffer_lock);
789 fibril_mutex_unlock(&socket->lock);
790}
791
792static void tcp_sock_close(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
793{
794 int socket_id;
795 socket_core_t *sock_core;
796 tcp_sockdata_t *socket;
797 tcp_error_t trc;
798 int rc;
799
800 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
801 socket_id = SOCKET_GET_SOCKET_ID(call);
802
803 sock_core = socket_cores_find(&client->sockets, socket_id);
804 if (sock_core == NULL) {
805 async_answer_0(callid, ENOTSOCK);
806 return;
807 }
808
809 socket = (tcp_sockdata_t *)sock_core->specific_data;
810 fibril_mutex_lock(&socket->lock);
811
812 if (socket->conn != NULL) {
813 trc = tcp_uc_close(socket->conn);
814 if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
815 fibril_mutex_unlock(&socket->lock);
816 async_answer_0(callid, EBADF);
817 return;
818 }
819 }
820
821 /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
822 fibril_mutex_lock(&socket->recv_buffer_lock);
823 socket->sock_core = NULL;
824 fibril_mutex_unlock(&socket->recv_buffer_lock);
825
826 rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
827 tcp_free_sock_data);
828 if (rc != EOK) {
829 fibril_mutex_unlock(&socket->lock);
830 async_answer_0(callid, rc);
831 return;
832 }
833
834 fibril_mutex_unlock(&socket->lock);
835 async_answer_0(callid, EOK);
836}
837
838static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
839{
840 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_getsockopt()");
841 async_answer_0(callid, ENOTSUP);
842}
843
844static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
845{
846 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_setsockopt()");
847 async_answer_0(callid, ENOTSUP);
848}
849
850/** Called when connection state changes. */
851static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg)
852{
853 tcp_conn_status_t cstatus;
854 tcp_sock_lconn_t *lconn = (tcp_sock_lconn_t *)arg;
855 tcp_sockdata_t *socket = lconn->socket;
856
857 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb()");
858 fibril_mutex_lock(&socket->lock);
859 assert(conn == lconn->conn);
860
861 tcp_uc_status(conn, &cstatus);
862 if (cstatus.cstate != st_established) {
863 fibril_mutex_unlock(&socket->lock);
864 return;
865 }
866
867 assert_link_not_used(&lconn->ready_list);
868 list_append(&lconn->ready_list, &socket->ready);
869
870 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
871
872 /* Push one accept notification to client's queue */
873 tcp_sock_notify_aconn(socket->sock_core);
874 fibril_mutex_unlock(&socket->lock);
875}
876
877static int tcp_sock_recv_fibril(void *arg)
878{
879 tcp_sockdata_t *sock = (tcp_sockdata_t *)arg;
880 size_t data_len;
881 xflags_t xflags;
882 tcp_error_t trc;
883
884 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recv_fibril()");
885
886 fibril_mutex_lock(&sock->recv_buffer_lock);
887
888 while (true) {
889 log_msg(LOG_DEFAULT, LVL_DEBUG, "call tcp_uc_receive()");
890 while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
891 fibril_condvar_wait(&sock->recv_buffer_cv,
892 &sock->recv_buffer_lock);
893
894 trc = tcp_uc_receive(sock->conn, sock->recv_buffer,
895 TCP_SOCK_FRAGMENT_SIZE, &data_len, &xflags);
896
897 if (trc != TCP_EOK) {
898 sock->recv_error = trc;
899 fibril_condvar_broadcast(&sock->recv_buffer_cv);
900 if (sock->sock_core != NULL)
901 tcp_sock_notify_data(sock->sock_core);
902 break;
903 }
904
905 log_msg(LOG_DEFAULT, LVL_DEBUG, "got data - broadcast recv_buffer_cv");
906
907 sock->recv_buffer_used = data_len;
908 fibril_condvar_broadcast(&sock->recv_buffer_cv);
909 if (sock->sock_core != NULL)
910 tcp_sock_notify_data(sock->sock_core);
911 }
912
913 fibril_mutex_unlock(&sock->recv_buffer_lock);
914
915 tcp_uc_delete(sock->conn);
916
917 return 0;
918}
919
920static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
921{
922 ipc_callid_t callid;
923 ipc_call_t call;
924 tcp_client_t client;
925
926 /* Accept the connection */
927 async_answer_0(iid, EOK);
928
929 client.sess = async_callback_receive(EXCHANGE_SERIALIZE);
930 socket_cores_initialize(&client.sockets);
931
932 while (true) {
933 callid = async_get_call(&call);
934 if (!IPC_GET_IMETHOD(call))
935 break;
936
937 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
938 (int)IPC_GET_IMETHOD(call));
939
940 switch (IPC_GET_IMETHOD(call)) {
941 case NET_SOCKET:
942 tcp_sock_socket(&client, callid, call);
943 break;
944 case NET_SOCKET_BIND:
945 tcp_sock_bind(&client, callid, call);
946 break;
947 case NET_SOCKET_LISTEN:
948 tcp_sock_listen(&client, callid, call);
949 break;
950 case NET_SOCKET_CONNECT:
951 tcp_sock_connect(&client, callid, call);
952 break;
953 case NET_SOCKET_ACCEPT:
954 tcp_sock_accept(&client, callid, call);
955 break;
956 case NET_SOCKET_SEND:
957 tcp_sock_send(&client, callid, call);
958 break;
959 case NET_SOCKET_SENDTO:
960 tcp_sock_sendto(&client, callid, call);
961 break;
962 case NET_SOCKET_RECV:
963 case NET_SOCKET_RECVFROM:
964 tcp_sock_recvfrom(&client, callid, call);
965 break;
966 case NET_SOCKET_CLOSE:
967 tcp_sock_close(&client, callid, call);
968 break;
969 case NET_SOCKET_GETSOCKOPT:
970 tcp_sock_getsockopt(&client, callid, call);
971 break;
972 case NET_SOCKET_SETSOCKOPT:
973 tcp_sock_setsockopt(&client, callid, call);
974 break;
975 default:
976 async_answer_0(callid, ENOTSUP);
977 break;
978 }
979 }
980
981 /* Clean up */
982 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: Clean up");
983 async_hangup(client.sess);
984 socket_cores_release(NULL, &client.sockets, &gsock, tcp_free_sock_data);
985}
986
987/**
988 * @}
989 */
Note: See TracBrowser for help on using the repository browser.