source: mainline/uspace/srv/tcp/sock.c@ c6533a7

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

Remove network stack under uspace/srv/net (except TCP).
  • Property mode set to 100644
File size: 20.2 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 <io/log.h>
41#include <ip_client.h>
42#include <ipc/socket.h>
43#include <net/modules.h>
44#include <net/socket.h>
45
46#include "sock.h"
47#include "std.h"
48#include "tcp.h"
49#include "tcp_type.h"
50#include "ucall.h"
51
52#define FRAGMENT_SIZE 1024
53
54#define MAX_BACKLOG 128
55
56/** Free ports pool start. */
57#define TCP_FREE_PORTS_START 1025
58
59/** Free ports pool end. */
60#define TCP_FREE_PORTS_END 65535
61
62static int last_used_port = TCP_FREE_PORTS_START - 1;
63static socket_ports_t gsock;
64
65static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
66
67void tcp_sock_init(void)
68{
69 socket_ports_initialize(&gsock);
70}
71
72static void tcp_free_sock_data(socket_core_t *sock_core)
73{
74 tcp_sockdata_t *socket;
75
76 socket = (tcp_sockdata_t *)sock_core->specific_data;
77 (void)socket;
78}
79
80static void tcp_sock_notify_data(socket_core_t *sock_core)
81{
82 log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
83 async_exch_t *exch = async_exchange_begin(sock_core->sess);
84 async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
85 FRAGMENT_SIZE, 0, 0, 1);
86 async_exchange_end(exch);
87}
88
89static void tcp_sock_notify_aconn(socket_core_t *lsock_core)
90{
91 log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
92 async_exch_t *exch = async_exchange_begin(lsock_core->sess);
93 async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
94 FRAGMENT_SIZE, 0, 0, 0);
95 async_exchange_end(exch);
96}
97
98static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
99{
100 tcp_sockdata_t *sock;
101 socket_core_t *sock_core;
102 int sock_id;
103 int rc;
104 ipc_call_t answer;
105
106 log_msg(LVL_DEBUG, "tcp_sock_socket()");
107 sock = calloc(sizeof(tcp_sockdata_t), 1);
108 if (sock == NULL) {
109 async_answer_0(callid, ENOMEM);
110 return;
111 }
112
113 fibril_mutex_initialize(&sock->lock);
114 sock->client = client;
115 sock->laddr.ipv4 = TCP_IPV4_ANY;
116 sock->lconn = NULL;
117 sock->backlog = 0;
118 list_initialize(&sock->ready);
119
120 sock_id = SOCKET_GET_SOCKET_ID(call);
121 rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
122 if (rc != EOK) {
123 async_answer_0(callid, rc);
124 return;
125 }
126
127 sock_core = socket_cores_find(&client->sockets, sock_id);
128 assert(sock_core != NULL);
129 sock->sock_core = sock_core;
130
131 refresh_answer(&answer, NULL);
132 SOCKET_SET_SOCKET_ID(answer, sock_id);
133
134 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
135 SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
136 answer_call(callid, EOK, &answer, 3);
137}
138
139static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
140{
141 int rc;
142 struct sockaddr *addr;
143 size_t addr_len;
144 socket_core_t *sock_core;
145 tcp_sockdata_t *socket;
146
147 log_msg(LVL_DEBUG, "tcp_sock_bind()");
148 log_msg(LVL_DEBUG, " - async_data_write_accept");
149 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
150 if (rc != EOK) {
151 async_answer_0(callid, rc);
152 return;
153 }
154
155 log_msg(LVL_DEBUG, " - call socket_bind");
156 rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
157 addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
158 last_used_port);
159 if (rc != EOK) {
160 async_answer_0(callid, rc);
161 return;
162 }
163
164 log_msg(LVL_DEBUG, " - call socket_cores_find");
165 sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
166 if (sock_core != NULL) {
167 socket = (tcp_sockdata_t *)sock_core->specific_data;
168 /* XXX Anything to do? */
169 (void) socket;
170 }
171
172 log_msg(LVL_DEBUG, " - success");
173 async_answer_0(callid, EOK);
174}
175
176static void tcp_sock_listen(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
177{
178 int socket_id;
179 int backlog;
180 socket_core_t *sock_core;
181 tcp_sockdata_t *socket;
182 tcp_error_t trc;
183 tcp_sock_t lsocket;
184 tcp_sock_t fsocket;
185 tcp_conn_t *conn;
186 tcp_sock_lconn_t *lconn;
187 int i;
188
189 log_msg(LVL_DEBUG, "tcp_sock_listen()");
190
191 socket_id = SOCKET_GET_SOCKET_ID(call);
192 backlog = SOCKET_GET_BACKLOG(call);
193
194 if (backlog < 0) {
195 async_answer_0(callid, EINVAL);
196 return;
197 }
198
199 if (backlog > MAX_BACKLOG)
200 backlog = MAX_BACKLOG;
201
202 sock_core = socket_cores_find(&client->sockets, socket_id);
203 if (sock_core == NULL) {
204 async_answer_0(callid, ENOTSOCK);
205 return;
206 }
207
208 socket = (tcp_sockdata_t *)sock_core->specific_data;
209
210 /*
211 * Prepare @c backlog listening connections.
212 */
213 fibril_mutex_lock(&socket->lock);
214
215 socket->backlog = backlog;
216 socket->lconn = calloc(sizeof(tcp_conn_t *), backlog);
217 if (socket->lconn == NULL) {
218 fibril_mutex_unlock(&socket->lock);
219 async_answer_0(callid, ENOMEM);
220 return;
221 }
222
223 log_msg(LVL_DEBUG, " - open connections");
224
225 lsocket.addr.ipv4 = TCP_IPV4_ANY;
226 lsocket.port = sock_core->port;
227 fsocket.addr.ipv4 = TCP_IPV4_ANY;
228 fsocket.port = TCP_PORT_ANY;
229
230 for (i = 0; i < backlog; i++) {
231
232 lconn = calloc(sizeof(tcp_sock_lconn_t), 1);
233 if (lconn == NULL) {
234 /* XXX Clean up */
235 fibril_mutex_unlock(&socket->lock);
236 async_answer_0(callid, ENOMEM);
237 return;
238 }
239
240 trc = tcp_uc_open(&lsocket, &fsocket, ap_passive,
241 tcp_open_nonblock, &conn);
242 if (conn == NULL) {
243 /* XXX Clean up */
244 fibril_mutex_unlock(&socket->lock);
245 async_answer_0(callid, ENOMEM);
246 return;
247 }
248
249 tcp_uc_set_cstate_cb(conn, tcp_sock_cstate_cb, lconn);
250
251 assert(trc == TCP_EOK);
252 conn->name = (char *)"S";
253
254 lconn->conn = conn;
255 lconn->socket = socket;
256 link_initialize(&lconn->ready_list);
257 socket->lconn[i] = lconn;
258 }
259
260 fibril_mutex_unlock(&socket->lock);
261 async_answer_0(callid, EOK);
262}
263
264static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
265{
266 int rc;
267 struct sockaddr_in *addr;
268 int socket_id;
269 size_t addr_len;
270 socket_core_t *sock_core;
271 tcp_sockdata_t *socket;
272 tcp_error_t trc;
273 tcp_sock_t lsocket;
274 tcp_sock_t fsocket;
275 nic_device_id_t dev_id;
276 tcp_phdr_t *phdr;
277 size_t phdr_len;
278
279 log_msg(LVL_DEBUG, "tcp_sock_connect()");
280
281 rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
282 if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
283 async_answer_0(callid, rc);
284 return;
285 }
286
287 socket_id = SOCKET_GET_SOCKET_ID(call);
288
289 sock_core = socket_cores_find(&client->sockets, socket_id);
290 if (sock_core == NULL) {
291 async_answer_0(callid, ENOTSOCK);
292 return;
293 }
294
295 socket = (tcp_sockdata_t *)sock_core->specific_data;
296 if (sock_core->port <= 0) {
297 rc = socket_bind_free_port(&gsock, sock_core,
298 TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
299 last_used_port);
300 if (rc != EOK) {
301 async_answer_0(callid, rc);
302 return;
303 }
304
305 last_used_port = sock_core->port;
306 }
307
308 fibril_mutex_lock(&socket->lock);
309
310 if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
311 /* Find route to determine local IP address. */
312 rc = ip_get_route_req(ip_sess, IPPROTO_TCP,
313 (struct sockaddr *)addr, sizeof(*addr), &dev_id,
314 (void **)&phdr, &phdr_len);
315 if (rc != EOK) {
316 fibril_mutex_unlock(&socket->lock);
317 async_answer_0(callid, rc);
318 log_msg(LVL_DEBUG, "tcp_transmit_connect: Failed to find route.");
319 return;
320 }
321
322 socket->laddr.ipv4 = uint32_t_be2host(phdr->src_addr);
323 log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
324 free(phdr);
325 }
326
327 lsocket.addr.ipv4 = socket->laddr.ipv4;
328 lsocket.port = sock_core->port;
329 fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
330 fsocket.port = uint16_t_be2host(addr->sin_port);
331
332 trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
333
334 if (socket->conn != NULL)
335 socket->conn->name = (char *)"C";
336
337 fibril_mutex_unlock(&socket->lock);
338
339 switch (trc) {
340 case TCP_EOK:
341 rc = EOK;
342 break;
343 case TCP_ERESET:
344 rc = ECONNREFUSED;
345 break;
346 default:
347 assert(false);
348 }
349
350 async_answer_0(callid, rc);
351
352 /* Push one fragment notification to client's queue */
353 tcp_sock_notify_data(sock_core);
354 log_msg(LVL_DEBUG, "tcp_sock_connect(): notify conn\n");
355}
356
357static void tcp_sock_accept(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
358{
359 ipc_call_t answer;
360 int socket_id;
361 int asock_id;
362 socket_core_t *sock_core;
363 socket_core_t *asock_core;
364 tcp_sockdata_t *socket;
365 tcp_sockdata_t *asocket;
366 tcp_error_t trc;
367 tcp_sock_t lsocket;
368 tcp_sock_t fsocket;
369 tcp_conn_t *conn;
370 tcp_conn_t *rconn;
371 tcp_sock_lconn_t *lconn;
372 int rc;
373
374 log_msg(LVL_DEBUG, "tcp_sock_accept()");
375
376 socket_id = SOCKET_GET_SOCKET_ID(call);
377 asock_id = SOCKET_GET_NEW_SOCKET_ID(call);
378
379 sock_core = socket_cores_find(&client->sockets, socket_id);
380 if (sock_core == NULL) {
381 async_answer_0(callid, ENOTSOCK);
382 return;
383 }
384
385 socket = (tcp_sockdata_t *)sock_core->specific_data;
386 fibril_mutex_lock(&socket->lock);
387
388 log_msg(LVL_DEBUG, " - verify socket->conn");
389 if (socket->conn != NULL) {
390 fibril_mutex_unlock(&socket->lock);
391 async_answer_0(callid, EINVAL);
392 return;
393 }
394
395 if (list_empty(&socket->ready)) {
396 fibril_mutex_unlock(&socket->lock);
397 async_answer_0(callid, ENOENT);
398 return;
399 }
400
401 lconn = list_get_instance(list_first(&socket->ready),
402 tcp_sock_lconn_t, ready_list);
403 list_remove(&lconn->ready_list);
404
405 conn = lconn->conn;
406 tcp_uc_set_cstate_cb(conn, NULL, NULL);
407
408 /* Replenish listening connection */
409
410 lsocket.addr.ipv4 = TCP_IPV4_ANY;
411 lsocket.port = sock_core->port;
412 fsocket.addr.ipv4 = TCP_IPV4_ANY;
413 fsocket.port = TCP_PORT_ANY;
414
415 trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, tcp_open_nonblock,
416 &rconn);
417 if (rconn == NULL) {
418 /* XXX Clean up */
419 fibril_mutex_unlock(&socket->lock);
420 async_answer_0(callid, ENOMEM);
421 return;
422 }
423
424 tcp_uc_set_cstate_cb(rconn, tcp_sock_cstate_cb, lconn);
425
426 assert(trc == TCP_EOK);
427 rconn->name = (char *)"S";
428
429 lconn->conn = rconn;
430
431 /* Allocate socket for accepted connection */
432
433 log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
434 asocket = calloc(sizeof(tcp_sockdata_t), 1);
435 if (asocket == NULL) {
436 fibril_mutex_unlock(&socket->lock);
437 async_answer_0(callid, ENOMEM);
438 return;
439 }
440
441 fibril_mutex_initialize(&asocket->lock);
442 asocket->client = client;
443 asocket->conn = conn;
444 log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
445
446 rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
447 if (rc != EOK) {
448 fibril_mutex_unlock(&socket->lock);
449 async_answer_0(callid, rc);
450 return;
451 }
452 log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
453
454 asock_core = socket_cores_find(&client->sockets, asock_id);
455 assert(asock_core != NULL);
456
457 refresh_answer(&answer, NULL);
458
459 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
460 SOCKET_SET_SOCKET_ID(answer, asock_id);
461 SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
462
463 answer_call(callid, asock_core->socket_id, &answer, 3);
464
465 /* Push one fragment notification to client's queue */
466 log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
467 tcp_sock_notify_data(asock_core);
468 fibril_mutex_unlock(&socket->lock);
469}
470
471static void tcp_sock_send(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
472{
473 int socket_id;
474 int fragments;
475 int index;
476 socket_core_t *sock_core;
477 tcp_sockdata_t *socket;
478 ipc_call_t answer;
479 ipc_callid_t wcallid;
480 size_t length;
481 uint8_t buffer[FRAGMENT_SIZE];
482 tcp_error_t trc;
483 int rc;
484
485 log_msg(LVL_DEBUG, "tcp_sock_send()");
486 socket_id = SOCKET_GET_SOCKET_ID(call);
487 fragments = SOCKET_GET_DATA_FRAGMENTS(call);
488 SOCKET_GET_FLAGS(call);
489
490 sock_core = socket_cores_find(&client->sockets, socket_id);
491 if (sock_core == NULL) {
492 async_answer_0(callid, ENOTSOCK);
493 return;
494 }
495
496 socket = (tcp_sockdata_t *)sock_core->specific_data;
497 fibril_mutex_lock(&socket->lock);
498
499 if (socket->conn == NULL) {
500 fibril_mutex_unlock(&socket->lock);
501 async_answer_0(callid, ENOTCONN);
502 return;
503 }
504
505 for (index = 0; index < fragments; index++) {
506 if (!async_data_write_receive(&wcallid, &length)) {
507 fibril_mutex_unlock(&socket->lock);
508 async_answer_0(callid, EINVAL);
509 return;
510 }
511
512 if (length > FRAGMENT_SIZE)
513 length = FRAGMENT_SIZE;
514
515 rc = async_data_write_finalize(wcallid, buffer, length);
516 if (rc != EOK) {
517 fibril_mutex_unlock(&socket->lock);
518 async_answer_0(callid, rc);
519 return;
520 }
521
522 trc = tcp_uc_send(socket->conn, buffer, length, 0);
523
524 switch (trc) {
525 case TCP_EOK:
526 rc = EOK;
527 break;
528 case TCP_ENOTEXIST:
529 rc = ENOTCONN;
530 break;
531 case TCP_ECLOSING:
532 rc = ENOTCONN;
533 break;
534 case TCP_ERESET:
535 rc = ECONNABORTED;
536 break;
537 default:
538 assert(false);
539 }
540
541 if (rc != EOK) {
542 fibril_mutex_unlock(&socket->lock);
543 async_answer_0(callid, rc);
544 return;
545 }
546 }
547
548 refresh_answer(&answer, NULL);
549 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
550 answer_call(callid, EOK, &answer, 2);
551 fibril_mutex_unlock(&socket->lock);
552}
553
554static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
555{
556 log_msg(LVL_DEBUG, "tcp_sock_sendto()");
557 async_answer_0(callid, ENOTSUP);
558}
559
560static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
561{
562 int socket_id;
563 int flags;
564 size_t addr_length, length;
565 socket_core_t *sock_core;
566 tcp_sockdata_t *socket;
567 ipc_call_t answer;
568 ipc_callid_t rcallid;
569 uint8_t buffer[FRAGMENT_SIZE];
570 size_t data_len;
571 xflags_t xflags;
572 tcp_error_t trc;
573 struct sockaddr_in addr;
574 tcp_sock_t *rsock;
575 int rc;
576
577 log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
578
579 socket_id = SOCKET_GET_SOCKET_ID(call);
580 flags = SOCKET_GET_FLAGS(call);
581
582 sock_core = socket_cores_find(&client->sockets, socket_id);
583 if (sock_core == NULL) {
584 async_answer_0(callid, ENOTSOCK);
585 return;
586 }
587
588 socket = (tcp_sockdata_t *)sock_core->specific_data;
589 fibril_mutex_lock(&socket->lock);
590
591 if (socket->conn == NULL) {
592 fibril_mutex_unlock(&socket->lock);
593 async_answer_0(callid, ENOTCONN);
594 return;
595 }
596
597 (void)flags;
598
599 trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len,
600 &xflags);
601 log_msg(LVL_DEBUG, "**** tcp_uc_receive done");
602
603 switch (trc) {
604 case TCP_EOK:
605 rc = EOK;
606 break;
607 case TCP_ENOTEXIST:
608 case TCP_ECLOSING:
609 rc = ENOTCONN;
610 break;
611 case TCP_ERESET:
612 rc = ECONNABORTED;
613 break;
614 default:
615 assert(false);
616 }
617
618 log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
619 if (rc != EOK) {
620 fibril_mutex_unlock(&socket->lock);
621 async_answer_0(callid, rc);
622 return;
623 }
624
625 if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
626 /* Fill addr */
627 rsock = &socket->conn->ident.foreign;
628 addr.sin_family = AF_INET;
629 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
630 addr.sin_port = host2uint16_t_be(rsock->port);
631
632 log_msg(LVL_DEBUG, "addr read receive");
633 if (!async_data_read_receive(&rcallid, &addr_length)) {
634 fibril_mutex_unlock(&socket->lock);
635 async_answer_0(callid, EINVAL);
636 return;
637 }
638
639 if (addr_length > sizeof(addr))
640 addr_length = sizeof(addr);
641
642 log_msg(LVL_DEBUG, "addr read finalize");
643 rc = async_data_read_finalize(rcallid, &addr, addr_length);
644 if (rc != EOK) {
645 fibril_mutex_unlock(&socket->lock);
646 async_answer_0(callid, EINVAL);
647 return;
648 }
649 }
650
651 log_msg(LVL_DEBUG, "data read receive");
652 if (!async_data_read_receive(&rcallid, &length)) {
653 fibril_mutex_unlock(&socket->lock);
654 async_answer_0(callid, EINVAL);
655 return;
656 }
657
658 if (length > data_len)
659 length = data_len;
660
661 log_msg(LVL_DEBUG, "data read finalize");
662 rc = async_data_read_finalize(rcallid, buffer, length);
663
664 if (length < data_len && rc == EOK)
665 rc = EOVERFLOW;
666
667 SOCKET_SET_READ_DATA_LENGTH(answer, length);
668 answer_call(callid, EOK, &answer, 1);
669
670 /* Push one fragment notification to client's queue */
671 tcp_sock_notify_data(sock_core);
672 fibril_mutex_unlock(&socket->lock);
673}
674
675static void tcp_sock_close(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
676{
677 int socket_id;
678 socket_core_t *sock_core;
679 tcp_sockdata_t *socket;
680 tcp_error_t trc;
681 int rc;
682 uint8_t buffer[FRAGMENT_SIZE];
683 size_t data_len;
684 xflags_t xflags;
685
686 log_msg(LVL_DEBUG, "tcp_sock_close()");
687 socket_id = SOCKET_GET_SOCKET_ID(call);
688
689 sock_core = socket_cores_find(&client->sockets, socket_id);
690 if (sock_core == NULL) {
691 async_answer_0(callid, ENOTSOCK);
692 return;
693 }
694
695 socket = (tcp_sockdata_t *)sock_core->specific_data;
696 fibril_mutex_lock(&socket->lock);
697
698 if (socket->conn != NULL) {
699 trc = tcp_uc_close(socket->conn);
700 if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
701 fibril_mutex_unlock(&socket->lock);
702 async_answer_0(callid, EBADF);
703 return;
704 }
705
706 /* Drain incoming data. This should really be done in the background. */
707 do {
708 trc = tcp_uc_receive(socket->conn, buffer,
709 FRAGMENT_SIZE, &data_len, &xflags);
710 } while (trc == TCP_EOK);
711
712 tcp_uc_delete(socket->conn);
713 }
714
715 rc = socket_destroy(net_sess, socket_id, &client->sockets, &gsock,
716 tcp_free_sock_data);
717 if (rc != EOK) {
718 fibril_mutex_unlock(&socket->lock);
719 async_answer_0(callid, rc);
720 return;
721 }
722
723 fibril_mutex_unlock(&socket->lock);
724 async_answer_0(callid, EOK);
725}
726
727static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
728{
729 log_msg(LVL_DEBUG, "tcp_sock_getsockopt()");
730 async_answer_0(callid, ENOTSUP);
731}
732
733static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
734{
735 log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
736 async_answer_0(callid, ENOTSUP);
737}
738
739/** Called when connection state changes. */
740static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg)
741{
742 tcp_conn_status_t cstatus;
743 tcp_sock_lconn_t *lconn = (tcp_sock_lconn_t *)arg;
744 tcp_sockdata_t *socket = lconn->socket;
745
746 log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
747 fibril_mutex_lock(&socket->lock);
748 assert(conn == lconn->conn);
749
750 tcp_uc_status(conn, &cstatus);
751 if (cstatus.cstate != st_established) {
752 fibril_mutex_unlock(&socket->lock);
753 return;
754 }
755
756 assert_link_not_used(&lconn->ready_list);
757 list_append(&lconn->ready_list, &socket->ready);
758
759 log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
760
761 /* Push one accept notification to client's queue */
762 tcp_sock_notify_aconn(socket->sock_core);
763 fibril_mutex_unlock(&socket->lock);
764}
765
766int tcp_sock_connection(async_sess_t *sess, ipc_callid_t iid, ipc_call_t icall)
767{
768 ipc_callid_t callid;
769 ipc_call_t call;
770 tcp_client_t client;
771
772 /* Accept the connection */
773 async_answer_0(iid, EOK);
774
775 client.sess = sess;
776 socket_cores_initialize(&client.sockets);
777
778 while (true) {
779 callid = async_get_call(&call);
780 if (!IPC_GET_IMETHOD(call))
781 break;
782
783 log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
784 (int)IPC_GET_IMETHOD(call));
785
786 switch (IPC_GET_IMETHOD(call)) {
787 case NET_SOCKET:
788 tcp_sock_socket(&client, callid, call);
789 break;
790 case NET_SOCKET_BIND:
791 tcp_sock_bind(&client, callid, call);
792 break;
793 case NET_SOCKET_LISTEN:
794 tcp_sock_listen(&client, callid, call);
795 break;
796 case NET_SOCKET_CONNECT:
797 tcp_sock_connect(&client, callid, call);
798 break;
799 case NET_SOCKET_ACCEPT:
800 tcp_sock_accept(&client, callid, call);
801 break;
802 case NET_SOCKET_SEND:
803 tcp_sock_send(&client, callid, call);
804 break;
805 case NET_SOCKET_SENDTO:
806 tcp_sock_sendto(&client, callid, call);
807 break;
808 case NET_SOCKET_RECV:
809 case NET_SOCKET_RECVFROM:
810 tcp_sock_recvfrom(&client, callid, call);
811 break;
812 case NET_SOCKET_CLOSE:
813 tcp_sock_close(&client, callid, call);
814 break;
815 case NET_SOCKET_GETSOCKOPT:
816 tcp_sock_getsockopt(&client, callid, call);
817 break;
818 case NET_SOCKET_SETSOCKOPT:
819 tcp_sock_setsockopt(&client, callid, call);
820 break;
821 default:
822 async_answer_0(callid, ENOTSUP);
823 break;
824 }
825 }
826
827 return EOK;
828}
829
830/**
831 * @}
832 */
Note: See TracBrowser for help on using the repository browser.