Changeset fb4d788 in mainline for uspace/srv

Timestamp:

2015-07-28T11:28:14Z (10 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

6accc5cf

Parents:

df2bce32 (diff), 47726b5e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from the mainline

Location:

uspace/srv

Files:

• bd/sata_bd/sata_bd.c (modified) (1 diff)
• hid/remcons/remcons.c (modified) (7 diffs)
• hid/remcons/remcons.h (modified) (1 diff)
• hid/remcons/user.c (modified) (5 diffs)
• hid/remcons/user.h (modified) (3 diffs)
• hid/rfb/main.c (modified) (2 diffs)
• hid/rfb/rfb.c (modified) (21 diffs)
• hid/rfb/rfb.h (modified) (3 diffs)
• klog/klog.c (modified) (2 diffs)
• net/dhcp/dhcp.c (modified) (1 diff)
• net/dhcp/transport.c (modified) (8 diffs)
• net/dhcp/transport.h (modified) (2 diffs)
• net/dnsrsrv/transport.c (modified) (8 diffs)
• net/inetsrv/inet_link.c (modified) (4 diffs)
• net/inetsrv/inetsrv.c (modified) (5 diffs)
• net/inetsrv/inetsrv.h (modified) (1 diff)
• net/inetsrv/pdu.c (modified) (6 diffs)
• net/inetsrv/pdu.h (modified) (2 diffs)
• net/inetsrv/reass.c (modified) (1 diff)
• net/tcp/Makefile (modified) (2 diffs)
• net/tcp/conn.c (modified) (22 diffs)
• net/tcp/conn.h (modified) (4 diffs)
• net/tcp/ncsim.c (modified) (6 diffs)
• net/tcp/ncsim.h (modified) (2 diffs)
• net/tcp/pdu.c (modified) (9 diffs)
• net/tcp/pdu.h (modified) (3 diffs)
• net/tcp/rqueue.c (modified) (7 diffs)
• net/tcp/rqueue.h (modified) (2 diffs)
• net/tcp/service.c (added)
• net/tcp/service.h (moved) (moved from uspace/srv/net/tcp/sock.h ) (2 diffs)
• net/tcp/sock.c (deleted)
• net/tcp/tcp.c (modified) (5 diffs)
• net/tcp/tcp_type.h (modified) (10 diffs)
• net/tcp/test.c (modified) (4 diffs)
• net/tcp/tqueue.c (modified) (4 diffs)
• net/tcp/tqueue.h (modified) (3 diffs)
• net/tcp/ucall.c (modified) (9 diffs)
• net/tcp/ucall.h (modified) (4 diffs)
• net/udp/Makefile (modified) (2 diffs)
• net/udp/assoc.c (modified) (17 diffs)
• net/udp/assoc.h (modified) (2 diffs)
• net/udp/msg.c (modified) (1 diff)
• net/udp/pdu.c (modified) (8 diffs)
• net/udp/pdu.h (modified) (3 diffs)
• net/udp/service.c (added)
• net/udp/service.h (moved) (moved from uspace/srv/net/udp/sock.h ) (2 diffs)
• net/udp/sock.c (deleted)
• net/udp/ucall.c (deleted)
• net/udp/ucall.h (deleted)
• net/udp/udp.c (modified) (3 diffs)
• net/udp/udp_inet.c (modified) (3 diffs)
• net/udp/udp_type.h (modified) (9 diffs)

uspace/srv/bd/sata_bd/sata_bd.c

@@ -147 +147 @@
  *
  */
-static int get_sata_disks()
+static int get_sata_disks(void)
 {
         devman_handle_t root_fun;

uspace/srv/hid/remcons/remcons.c

@@ -44 +44 @@
 #include <fibril_synch.h>
 #include <task.h>
-#include <net/in.h>
-#include <net/inet.h>
-#include <net/socket.h>
+#include <inet/addr.h>
+#include <inet/endpoint.h>
+#include <inet/tcp.h>
 #include <io/console.h>
 #include <inttypes.h>
@@ -99 +99 @@
 };
 
+static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn);
+
+static tcp_listen_cb_t listen_cb = {
+        .new_conn = remcons_new_conn
+};
+
+static tcp_cb_t conn_cb = {
+        .connected = NULL
+};
+
 static telnet_user_t *srv_to_user(con_srv_t *srv)
 {
@@ -111 +121 @@
 
         /* Force character mode. */
-        send(user->socket, (void *)telnet_force_character_mode_command,
-            telnet_force_character_mode_command_count, 0);
+        (void) tcp_conn_send(user->conn, (void *)telnet_force_character_mode_command,
+            telnet_force_character_mode_command_count);
 
         return EOK;
@@ -272 +282 @@
 }
 
-/** Fibril for each accepted socket.
- *
- * @param arg Corresponding @c telnet_user_t structure.
- */
-static int network_user_fibril(void *arg)
-{
-        telnet_user_t *user = arg;
+/** Handle network connection.
+ *
+ * @param lst  Listener
+ * @param conn Connection
+ */
+static void remcons_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
+{
+        telnet_user_t *user = telnet_user_create(conn);
+        assert(user);
+
+        con_srvs_init(&user->srvs);
+        user->srvs.ops = &con_ops;
+        user->srvs.sarg = user;
+        user->srvs.abort_timeout = 1000;
+
+        telnet_user_add(user);
 
         int rc = loc_service_register(user->service_name, &user->service_id);
@@ -284 +303 @@
                 telnet_user_error(user, "Unable to register %s with loc: %s.",
                     user->service_name, str_error(rc));
-                return EOK;
+                return;
         }
 
         telnet_user_log(user, "Service %s registerd with id %" PRIun ".",
             user->service_name, user->service_id);
-        
+
         fid_t spawn_fibril = fibril_create(spawn_task_fibril, user);
         assert(spawn_fibril);
         fibril_add_ready(spawn_fibril);
-        
+
         /* Wait for all clients to exit. */
         fibril_mutex_lock(&user->guard);
         while (!user_can_be_destroyed_no_lock(user)) {
                 if (user->task_finished) {
-                        closesocket(user->socket);
+                        user->conn = NULL;
                         user->socket_closed = true;
                         user->srvs.aborted = true;
@@ -310 +329 @@
         }
         fibril_mutex_unlock(&user->guard);
-        
+
         rc = loc_service_unregister(user->service_id);
         if (rc != EOK) {
@@ -320 +339 @@
         telnet_user_log(user, "Destroying...");
         telnet_user_destroy(user);
-
-        return EOK;
 }
 
 int main(int argc, char *argv[])
 {
-        int port = 2223;
-        
+        int rc;
+        tcp_listener_t *lst;
+        tcp_t *tcp;
+        inet_ep_t ep;
+
         async_set_client_connection(client_connection);
-        int rc = loc_server_register(NAME);
+        rc = loc_server_register(NAME);
         if (rc != EOK) {
                 fprintf(stderr, "%s: Unable to register server\n", NAME);
                 return rc;
         }
-        
-        struct sockaddr_in addr;
-        
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons(port);
-        
-        rc = inet_pton(AF_INET, "127.0.0.1", (void *)
-            &addr.sin_addr.s_addr);
-        if (rc != EOK) {
-                fprintf(stderr, "Error parsing network address: %s.\n",
-                    str_error(rc));
-                return 2;
-        }
-
-        int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
-        if (listen_sd < 0) {
-                fprintf(stderr, "Error creating listening socket: %s.\n",
-                    str_error(listen_sd));
-                return 3;
-        }
-
-        rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
-        if (rc != EOK) {
-                fprintf(stderr, "Error binding socket: %s.\n",
-                    str_error(rc));
-                return 4;
-        }
-
-        rc = listen(listen_sd, BACKLOG_SIZE);
-        if (rc != EOK) {
-                fprintf(stderr, "listen() failed: %s.\n", str_error(rc));
-                return 5;
+
+        rc = tcp_create(&tcp);
+        if (rc != EOK) {
+                fprintf(stderr, "%s: Error initializing TCP.\n", NAME);
+                return rc;
+        }
+
+        inet_ep_init(&ep);
+        ep.port = 2223;
+
+        rc = tcp_listener_create(tcp, &ep, &listen_cb, NULL, &conn_cb, NULL,
+            &lst);
+        if (rc != EOK) {
+                fprintf(stderr, "%s: Error creating listener.\n", NAME);
+                return rc;
         }
 
         printf("%s: HelenOS Remote console service\n", NAME);
         task_retval(0);
-
-        while (true) {
-                struct sockaddr_in raddr;
-                socklen_t raddr_len = sizeof(raddr);
-                int conn_sd = accept(listen_sd, (struct sockaddr *) &raddr,
-                    &raddr_len);
-
-                if (conn_sd < 0) {
-                        fprintf(stderr, "accept() failed: %s.\n",
-                            str_error(rc));
-                        continue;
-                }
-
-                telnet_user_t *user = telnet_user_create(conn_sd);
-                assert(user);
-
-                con_srvs_init(&user->srvs);
-                user->srvs.ops = &con_ops;
-                user->srvs.sarg = user;
-                user->srvs.abort_timeout = 1000;
-
-                telnet_user_add(user);
-
-                fid_t fid = fibril_create(network_user_fibril, user);
-                assert(fid);
-                fibril_add_ready(fid);
-        }
-
+        async_manager();
+
+        /* Not reached */
         return 0;
 }

uspace/srv/hid/remcons/remcons.h

@@ -38 +38 @@
 #define NAME       "remcons"
 #define NAMESPACE  "term"
-#define BACKLOG_SIZE  5
 
 #endif

uspace/srv/hid/remcons/user.c

@@ -44 +44 @@
 #include <fibril_synch.h>
 #include <task.h>
-#include <net/in.h>
-#include <net/inet.h>
-#include <net/socket.h>
+#include <inet/tcp.h>
 #include <io/console.h>
 #include <inttypes.h>
@@ -58 +56 @@
 /** Create new telnet user.
  *
- * @param socket Socket the user communicates through.
+ * @param conn Incoming connection.
  * @return New telnet user or NULL when out of memory.
  */
-telnet_user_t *telnet_user_create(int socket)
+telnet_user_t *telnet_user_create(tcp_conn_t *conn)
 {
         static int telnet_user_id_counter = 0;
@@ -78 +76 @@
         }
 
-        user->socket = socket;
+        user->conn = conn;
         user->service_id = (service_id_t) -1;
         prodcons_initialize(&user->in_events);
@@ -193 +191 @@
         /* No more buffered data? */
         if (user->socket_buffer_len <= user->socket_buffer_pos) {
-                int recv_length = recv(user->socket, user->socket_buffer, BUFFER_SIZE, 0);
-                if ((recv_length == 0) || (recv_length == ENOTCONN)) {
+                int rc;
+                size_t recv_length;
+
+                rc = tcp_conn_recv_wait(user->conn, user->socket_buffer,
+                    BUFFER_SIZE, &recv_length);
+                if (rc != EOK)
+                        return rc;
+
+                if (recv_length == 0) {
                         user->socket_closed = true;
                         user->srvs.aborted = true;
                         return ENOENT;
                 }
-                if (recv_length < 0) {
-                        return recv_length;
-                }
+
                 user->socket_buffer_len = recv_length;
                 user->socket_buffer_pos = 0;
@@ -359 +362 @@
 
 
-        int rc = send(user->socket, converted, converted_size, 0);
+        int rc = tcp_conn_send(user->conn, converted, converted_size);
         free(converted);
 

uspace/srv/hid/remcons/user.h

@@ -38 +38 @@
 #include <adt/prodcons.h>
 #include <fibril_synch.h>
+#include <inet/tcp.h>
 #include <inttypes.h>
 #include <io/con_srv.h>
@@ -51 +52 @@
         /** Internal id, used for creating locfs entries. */
         int id;
-        /** Associated socket. */
-        int socket;
+        /** Associated connection. */
+        tcp_conn_t *conn;
         /** Location service id assigned to the virtual terminal. */
         service_id_t service_id;
@@ -80 +81 @@
 } telnet_user_t;
 
-extern telnet_user_t *telnet_user_create(int);
+extern telnet_user_t *telnet_user_create(tcp_conn_t *);
 extern void telnet_user_add(telnet_user_t *);
 extern void telnet_user_destroy(telnet_user_t *);

uspace/srv/hid/rfb/main.c

@@ -150 +150 @@
 }
 
-static int socket_fibril(void *unused)
-{
-        rfb_accept(&rfb);
-        
-        /* Not reached */
-        return EOK;
-}
-
 int main(int argc, char **argv)
 {
@@ -267 +259 @@
         }
         
-        fid_t fib = fibril_create(socket_fibril, NULL);
-        if (!fib) {
-                fprintf(stderr, NAME ": Unable to create socket fibril.\n");
-                return 2;
-        }
-        
-        fibril_add_ready(fib);
-        
         printf("%s: Accepting connections\n", NAME);
         task_retval(0);

uspace/srv/hid/rfb/rfb.c

@@ -31 +31 @@
 #include <stdlib.h>
 #include <fibril_synch.h>
+#include <inet/addr.h>
+#include <inet/endpoint.h>
+#include <inet/tcp.h>
 #include <inttypes.h>
 #include <str.h>
@@ -38 +41 @@
 #include <io/log.h>
 
-#include <net/in.h>
-#include <net/inet.h>
-#include <net/socket.h>
-
 #include "rfb.h"
+
+static void rfb_new_conn(tcp_listener_t *, tcp_conn_t *);
+
+static tcp_listen_cb_t listen_cb = {
+        .new_conn = rfb_new_conn
+};
+
+static tcp_cb_t conn_cb = {
+        .connected = NULL
+};
 
 /** Buffer for receiving the request. */
@@ -53 +62 @@
 
 /** Receive one character (with buffering) */
-static int recv_char(int fd, char *c)
-{
+static int recv_char(tcp_conn_t *conn, char *c)
+{
+        size_t nrecv;
+        int rc;
+
         if (rbuf_out == rbuf_in) {
                 rbuf_out = 0;
                 rbuf_in = 0;
                 
-                ssize_t rc = recv(fd, rbuf, BUFFER_SIZE, 0);
-                if (rc <= 0)
+                rc = tcp_conn_recv_wait(conn, rbuf, BUFFER_SIZE, &nrecv);
+                if (rc != EOK)
                         return rc;
                 
-                rbuf_in = rc;
+                rbuf_in = nrecv;
         }
         
@@ -71 +83 @@
 
 /** Receive count characters (with buffering) */
-static int recv_chars(int fd, char *c, size_t count)
+static int recv_chars(tcp_conn_t *conn, char *c, size_t count)
 {
         for (size_t i = 0; i < count; i++) {
-                int rc = recv_char(fd, c);
+                int rc = recv_char(conn, c);
                 if (rc != EOK)
                         return rc;
@@ -82 +94 @@
 }
 
-static int recv_skip_chars(int fd, size_t count)
+static int recv_skip_chars(tcp_conn_t *conn, size_t count)
 {
         for (size_t i = 0; i < count; i++) {
                 char c;
-                int rc = recv_char(fd, &c);
+                int rc = recv_char(conn, &c);
                 if (rc != EOK)
                         return rc;
@@ -204 +216 @@
 }
 
-static int recv_message(int conn_sd, char type, void *buf, size_t size)
+static int recv_message(tcp_conn_t *conn, char type, void *buf, size_t size)
 {
         memcpy(buf, &type, 1);
-        return recv_chars(conn_sd, ((char *) buf) + 1, size -1);
+        return recv_chars(conn, ((char *) buf) + 1, size -1);
 }
 
@@ -477 +489 @@
 }
 
-static int rfb_send_framebuffer_update(rfb_t *rfb, int conn_sd, bool incremental)
+static int rfb_send_framebuffer_update(rfb_t *rfb, tcp_conn_t *conn,
+    bool incremental)
 {
         fibril_mutex_lock(&rfb->lock);
@@ -540 +553 @@
         
         if (!rfb->pixel_format.true_color) {
-                int rc = send(conn_sd, send_palette, send_palette_size, 0);
+                int rc = tcp_conn_send(conn, send_palette, send_palette_size);
                 if (rc != EOK) {
                         free(buf);
@@ -547 +560 @@
         }
         
-        int rc = send(conn_sd, buf, buf_size, 0);
+        int rc = tcp_conn_send(conn, buf, buf_size);
         free(buf);
         
@@ -580 +593 @@
 }
 
-static void rfb_socket_connection(rfb_t *rfb, int conn_sd)
+static void rfb_socket_connection(rfb_t *rfb, tcp_conn_t *conn)
 {
         /* Version handshake */
-        int rc = send(conn_sd, "RFB 003.008\n", 12, 0);
+        int rc = tcp_conn_send(conn, "RFB 003.008\n", 12);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server version %d", rc);
@@ -590 +603 @@
         
         char client_version[12];
-        rc = recv_chars(conn_sd, client_version, 12);
+        rc = recv_chars(conn, client_version, 12);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client version: %d", rc);
@@ -607 +620 @@
         sec_types[0] = 1; /* length */
         sec_types[1] = RFB_SECURITY_NONE;
-        rc = send(conn_sd, sec_types, 2, 0);
+        rc = tcp_conn_send(conn, sec_types, 2);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN,
@@ -615 +628 @@
         
         char selected_sec_type = 0;
-        rc = recv_char(conn_sd, &selected_sec_type);
+        rc = recv_char(conn, &selected_sec_type);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving security type: %d", rc);
@@ -626 +639 @@
         }
         uint32_t security_result = RFB_SECURITY_HANDSHAKE_OK;
-        rc = send(conn_sd, &security_result, sizeof(uint32_t), 0);
+        rc = tcp_conn_send(conn, &security_result, sizeof(uint32_t));
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending security result: %d", rc);
@@ -634 +647 @@
         /* Client init */
         char shared_flag;
-        rc = recv_char(conn_sd, &shared_flag);
+        rc = recv_char(conn, &shared_flag);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed receiving client init: %d", rc);
@@ -657 +670 @@
         memcpy(server_init->name, rfb->name, name_length);
         fibril_mutex_unlock(&rfb->lock);
-        rc = send(conn_sd, server_init, msg_length, 0);
+        rc = tcp_conn_send(conn, server_init, msg_length);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Failed sending server init: %d", rc);
@@ -665 +678 @@
         while (true) {
                 char message_type = 0;
-                rc = recv_char(conn_sd, &message_type);
+                rc = recv_char(conn, &message_type);
                 if (rc != EOK) {
                         log_msg(LOG_DEFAULT, LVL_WARN,
@@ -680 +693 @@
                 switch (message_type) {
                 case RFB_CMSG_SET_PIXEL_FORMAT:
-                        recv_message(conn_sd, message_type, &spf, sizeof(spf));
+                        recv_message(conn, message_type, &spf, sizeof(spf));
                         rfb_pixel_format_to_host(&spf.pixel_format, &spf.pixel_format);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetPixelFormat message");
@@ -690 +703 @@
                         break;
                 case RFB_CMSG_SET_ENCODINGS:
-                        recv_message(conn_sd, message_type, &se, sizeof(se));
+                        recv_message(conn, message_type, &se, sizeof(se));
                         rfb_set_encodings_to_host(&se, &se);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received SetEncodings message");
                         for (uint16_t i = 0; i < se.count; i++) {
                                 int32_t encoding = 0;
-                                rc = recv_chars(conn_sd, (char *) &encoding, sizeof(int32_t));
+                                rc = recv_chars(conn, (char *) &encoding, sizeof(int32_t));
                                 if (rc != EOK)
                                         return;
@@ -707 +720 @@
                         break;
                 case RFB_CMSG_FRAMEBUFFER_UPDATE_REQUEST:
-                        recv_message(conn_sd, message_type, &fbur, sizeof(fbur));
+                        recv_message(conn, message_type, &fbur, sizeof(fbur));
                         rfb_framebuffer_update_request_to_host(&fbur, &fbur);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2,
                             "Received FramebufferUpdateRequest message");
-                        rfb_send_framebuffer_update(rfb, conn_sd, fbur.incremental);
+                        rfb_send_framebuffer_update(rfb, conn, fbur.incremental);
                         break;
                 case RFB_CMSG_KEY_EVENT:
-                        recv_message(conn_sd, message_type, &ke, sizeof(ke));
+                        recv_message(conn, message_type, &ke, sizeof(ke));
                         rfb_key_event_to_host(&ke, &ke);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received KeyEvent message");
                         break;
                 case RFB_CMSG_POINTER_EVENT:
-                        recv_message(conn_sd, message_type, &pe, sizeof(pe));
+                        recv_message(conn, message_type, &pe, sizeof(pe));
                         rfb_pointer_event_to_host(&pe, &pe);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received PointerEvent message");
                         break;
                 case RFB_CMSG_CLIENT_CUT_TEXT:
-                        recv_message(conn_sd, message_type, &cct, sizeof(cct));
+                        recv_message(conn, message_type, &cct, sizeof(cct));
                         rfb_client_cut_text_to_host(&cct, &cct);
                         log_msg(LOG_DEFAULT, LVL_DEBUG2, "Received ClientCutText message");
-                        recv_skip_chars(conn_sd, cct.length);
+                        recv_skip_chars(conn, cct.length);
                         break;
                 default:
@@ -737 +750 @@
 }
 
-int rfb_listen(rfb_t *rfb, uint16_t port) {
-        struct sockaddr_in addr;
-        
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons(port);
-        
-        int rc = inet_pton(AF_INET, "127.0.0.1", (void *)
-            &addr.sin_addr.s_addr);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Error parsing network address (%s)",
-                    str_error(rc));
-                return rc;
-        }
-
-        int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
-        if (listen_sd < 0) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating listening socket (%s)",
-                    str_error(listen_sd));
-                return rc;
-        }
-        
-        rc = bind(listen_sd, (struct sockaddr *) &addr, sizeof(addr));
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Error binding socket (%s)",
-                    str_error(rc));
-                return rc;
-        }
-        
-        rc = listen(listen_sd, 2);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "listen() failed (%s)", str_error(rc));
-                return rc;
-        }
-        
-        rfb->listen_sd = listen_sd;
+int rfb_listen(rfb_t *rfb, uint16_t port)
+{
+        tcp_t *tcp = NULL;
+        tcp_listener_t *lst = NULL;
+        inet_ep_t ep;
+        int rc;
+        
+        rc = tcp_create(&tcp);
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Error initializing TCP.");
+                goto error;
+        }
+        
+        inet_ep_init(&ep);
+        ep.port = port;
+        
+        rc = tcp_listener_create(tcp, &ep, &listen_cb, rfb, &conn_cb, rfb,
+            &lst);
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating listener.");
+                goto error;
+        }
+        
+        rfb->tcp = tcp;
+        rfb->lst = lst;
         
         return EOK;
-}
-
-void rfb_accept(rfb_t *rfb)
-{
-        while (true) {
-                struct sockaddr_in raddr;
-                socklen_t raddr_len = sizeof(raddr);
-                int conn_sd = accept(rfb->listen_sd, (struct sockaddr *) &raddr,
-                    &raddr_len);
-                
-                if (conn_sd < 0) {
-                        log_msg(LOG_DEFAULT, LVL_WARN, "accept() failed (%s)",
-                            str_error(conn_sd));
-                        continue;
-                }
-                
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection accepted");
-                
-                rbuf_out = 0;
-                rbuf_in = 0;
-                
-                rfb_socket_connection(rfb, conn_sd);
-                closesocket(conn_sd);
-        }
-}
+error:
+        tcp_listener_destroy(lst);
+        tcp_destroy(tcp);
+        return rc;
+}
+
+static void rfb_new_conn(tcp_listener_t *lst, tcp_conn_t *conn)
+{
+        rfb_t *rfb = (rfb_t *)tcp_listener_userptr(lst);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Connection accepted");
+
+        rbuf_out = 0;
+        rbuf_in = 0;
+
+        rfb_socket_connection(rfb, conn);
+}

uspace/srv/hid/rfb/rfb.h

@@ -30 +30 @@
 #define RFB_H__
 
+#include <inet/tcp.h>
 #include <io/pixelmap.h>
 #include <fibril_synch.h>
@@ -151 +152 @@
         rfb_pixel_format_t pixel_format;
         const char *name;
-        int listen_sd;
+        tcp_t *tcp;
+        tcp_listener_t *lst;
         pixelmap_t framebuffer;
         rfb_rectangle_t damage_rect;
@@ -165 +167 @@
 extern int rfb_set_size(rfb_t *, uint16_t, uint16_t);
 extern int rfb_listen(rfb_t *, uint16_t);
-extern void rfb_accept(rfb_t *);
 
 #endif

uspace/srv/klog/klog.c

@@ -51 +51 @@
 #include <io/logctl.h>
 
-#define NAME       "klog"
+#define NAME  "klog"
 
 typedef size_t __attribute__ ((aligned(1))) unaligned_size_t;
@@ -98 +98 @@
  *
  */
-static void producer()
+static void producer(void)
 {
         int read = klog_read(buffer, BUFFER_SIZE);

uspace/srv/net/dhcp/dhcp.c

@@ -37 +37 @@
 #include <adt/list.h>
 #include <bitops.h>
+#include <byteorder.h>
 #include <errno.h>
 #include <fibril_synch.h>

uspace/srv/net/dhcp/transport.c

@@ -36 +36 @@
 
 #include <bitops.h>
+#include <errno.h>
 #include <inet/addr.h>
 #include <inet/dnsr.h>
@@ -41 +42 @@
 #include <io/log.h>
 #include <loc.h>
-#include <net/in.h>
-#include <net/inet.h>
-#include <net/socket.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -67 +65 @@
 } dhcp_offer_t;
 
-static int dhcp_recv_fibril(void *);
+static void dhcp_recv_msg(udp_assoc_t *, udp_rmsg_t *);
+static void dhcp_recv_err(udp_assoc_t *, udp_rerr_t *);
+static void dhcp_link_state(udp_assoc_t *, udp_link_state_t);
+
+static udp_cb_t dhcp_transport_cb = {
+        .recv_msg = dhcp_recv_msg,
+        .recv_err = dhcp_recv_err,
+        .link_state = dhcp_link_state
+};
 
 int dhcp_send(dhcp_transport_t *dt, void *msg, size_t size)
 {
-        struct sockaddr_in addr;
+        inet_ep_t ep;
         int rc;
 
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons(dhcp_server_port);
-        addr.sin_addr.s_addr = htonl(addr32_broadcast_all_hosts);
+        inet_ep_init(&ep);
+        ep.port = dhcp_server_port;
+        inet_addr_set(addr32_broadcast_all_hosts, &ep.addr);
 
-        rc = sendto(dt->fd, msg, size, 0,
-            (struct sockaddr *)&addr, sizeof(addr));
+        rc = udp_assoc_send_msg(dt->assoc, &ep, msg, size);
         if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Sending failed");
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed sending message");
                 return rc;
         }
@@ -88 +93 @@
 }
 
-static int dhcp_recv_msg(dhcp_transport_t *dt, void **rmsg, size_t *rsize)
+static void dhcp_recv_msg(udp_assoc_t *assoc, udp_rmsg_t *rmsg)
 {
-        struct sockaddr_in src_addr;
-        socklen_t src_addr_size;
-        size_t recv_size;
+        dhcp_transport_t *dt;
+        size_t s;
         int rc;
 
-        src_addr_size = sizeof(src_addr);
-        rc = recvfrom(dt->fd, msgbuf, MAX_MSG_SIZE, 0,
-            (struct sockaddr *)&src_addr, &src_addr_size);
-        if (rc < 0) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "recvfrom failed (%d)", rc);
-                return rc;
+        log_msg(LOG_DEFAULT, LVL_NOTE, "dhcp_recv_msg()");
+
+        dt = (dhcp_transport_t *)udp_assoc_userptr(assoc);
+        s = udp_rmsg_size(rmsg);
+        if (s > MAX_MSG_SIZE)
+                s = MAX_MSG_SIZE; /* XXX */
+
+        rc = udp_rmsg_read(rmsg, 0, msgbuf, s);
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Error receiving message.");
+                return;
         }
 
-        recv_size = (size_t)rc;
-        *rmsg = msgbuf;
-        *rsize = recv_size;
+        log_msg(LOG_DEFAULT, LVL_NOTE, "dhcp_recv_msg() - call recv_cb");
+        dt->recv_cb(dt->cb_arg, msgbuf, s);
+}
 
-        return EOK;
+static void dhcp_recv_err(udp_assoc_t *assoc, udp_rerr_t *rerr)
+{
+        log_msg(LOG_DEFAULT, LVL_WARN, "Ignoring ICMP error");
+}
+
+static void dhcp_link_state(udp_assoc_t *assoc, udp_link_state_t ls)
+{
+        log_msg(LOG_DEFAULT, LVL_NOTE, "Link state change");
 }
 
@@ -113 +129 @@
     dhcp_recv_cb_t recv_cb, void *arg)
 {
-        int fd;
-        struct sockaddr_in laddr;
-        int fid;
+        udp_t *udp = NULL;
+        udp_assoc_t *assoc = NULL;
+        inet_ep2_t epp;
         int rc;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcptransport_init()");
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcp_transport_init()");
 
-        laddr.sin_family = AF_INET;
-        laddr.sin_port = htons(dhcp_client_port);
-        laddr.sin_addr.s_addr = INADDR_ANY;
+        inet_ep2_init(&epp);
+        epp.local.addr.version = ip_v4;
+        epp.local.port = dhcp_client_port;
+        epp.local_link = link_id;
 
-        fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
-        if (fd < 0) {
-                rc = EIO;
-                goto error;
-        }
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Bind socket.");
-        rc = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
+        rc = udp_create(&udp);
         if (rc != EOK) {
                 rc = EIO;
@@ -137 +147 @@
         }
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Set socket options");
-        rc = setsockopt(fd, SOL_SOCKET, SO_IPLINK, &link_id, sizeof(link_id));
+        rc = udp_assoc_create(udp, &epp, &dhcp_transport_cb, dt, &assoc);
         if (rc != EOK) {
                 rc = EIO;
@@ -144 +153 @@
         }
 
-        dt->fd = fd;
+        dt->udp = udp;
+        dt->assoc = assoc;
         dt->recv_cb = recv_cb;
         dt->cb_arg = arg;
 
-        fid = fibril_create(dhcp_recv_fibril, dt);
-        if (fid == 0) {
-                rc = ENOMEM;
-                goto error;
-        }
-
-        dt->recv_fid = fid;
-        fibril_add_ready(fid);
-
         return EOK;
 error:
-        closesocket(fd);
+        udp_assoc_destroy(assoc);
+        udp_destroy(udp);
         return rc;
 }
@@ -165 +167 @@
 void dhcp_transport_fini(dhcp_transport_t *dt)
 {
-        closesocket(dt->fd);
-}
-
-static int dhcp_recv_fibril(void *arg)
-{
-        dhcp_transport_t *dt = (dhcp_transport_t *)arg;
-        void *msg;
-        size_t size = (size_t) -1;
-        int rc;
-
-        while (true) {
-                rc = dhcp_recv_msg(dt, &msg, &size);
-                if (rc != EOK)
-                        break;
-
-                assert(size != (size_t) -1);
-
-                dt->recv_cb(dt->cb_arg, msg, size);
-        }
-
-        return EOK;
+        udp_assoc_destroy(dt->assoc);
+        udp_destroy(dt->udp);
 }
 

uspace/srv/net/dhcp/transport.h

@@ -38 +38 @@
 #define TRANSPORT_H
 
+#include <inet/udp.h>
 #include <ipc/loc.h>
 #include <sys/types.h>
@@ -47 +48 @@
 
 struct dhcp_transport {
-        /** Transport socket */
-        int fd;
+        /** UDP */
+        udp_t *udp;
+        /** UDP association */
+        udp_assoc_t *assoc;
         /** Receive callback */
         dhcp_recv_cb_t recv_cb;
         /** Callback argument */
         void *cb_arg;
-        /** Receive fibril ID */
-        int recv_fid;
 };
 

uspace/srv/net/dnsrsrv/transport.c

@@ -37 +37 @@
 #include <errno.h>
 #include <fibril_synch.h>
+#include <inet/addr.h>
+#include <inet/endpoint.h>
+#include <inet/udp.h>
 #include <io/log.h>
-#include <net/in.h>
-#include <net/inet.h>
-#include <net/socket.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -72 +72 @@
 
 static uint8_t recv_buf[RECV_BUF_SIZE];
-static fid_t recv_fid;
-static int transport_fd = -1;
+static udp_t *transport_udp;
+static udp_assoc_t *transport_assoc;
 
 /** Outstanding requests */
@@ -79 +79 @@
 static FIBRIL_MUTEX_INITIALIZE(treq_lock);
 
-static int transport_recv_fibril(void *arg);
+static void transport_recv_msg(udp_assoc_t *, udp_rmsg_t *);
+static void transport_recv_err(udp_assoc_t *, udp_rerr_t *);
+static void transport_link_state(udp_assoc_t *, udp_link_state_t);
+
+static udp_cb_t transport_cb = {
+        .recv_msg = transport_recv_msg,
+        .recv_err = transport_recv_err,
+        .link_state = transport_link_state
+};
 
 int transport_init(void)
 {
-        struct sockaddr_in laddr;
-        int fd;
-        fid_t fid;
+        inet_ep2_t epp;
         int rc;
 
-        laddr.sin_family = AF_INET;
-        laddr.sin_port = htons(12345);
-        laddr.sin_addr.s_addr = INADDR_ANY;
-
-        fd = -1;
-
-        fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
-        if (fd < 0) {
+        inet_ep2_init(&epp);
+
+        rc = udp_create(&transport_udp);
+        if (rc != EOK) {
                 rc = EIO;
                 goto error;
         }
 
-        rc = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
-        if (rc != EOK)
-                goto error;
-
-        transport_fd = fd;
-
-        fid = fibril_create(transport_recv_fibril, NULL);
-        if (fid == 0)
-                goto error;
-
-        fibril_add_ready(fid);
-        recv_fid = fid;
+        rc = udp_assoc_create(transport_udp, &epp, &transport_cb, NULL,
+            &transport_assoc);
+        if (rc != EOK) {
+                rc = EIO;
+                goto error;
+        }
+
         return EOK;
 error:
-        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing network socket.");
-        if (fd >= 0)
-                closesocket(fd);
+        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing network.");
+        udp_assoc_destroy(transport_assoc);
+        udp_destroy(transport_udp);
         return rc;
 }
@@ -122 +119 @@
 void transport_fini(void)
 {
-        if (transport_fd >= 0)
-                closesocket(transport_fd);
+        udp_assoc_destroy(transport_assoc);
+        udp_destroy(transport_udp);
 }
 
@@ -182 +179 @@
 {
         trans_req_t *treq = NULL;
-        struct sockaddr *saddr = NULL;
-        socklen_t saddrlen;
-        
+        inet_ep_t ep;
+
         void *req_data;
         size_t req_size;
@@ -190 +186 @@
         if (rc != EOK)
                 goto error;
-        
-        rc = inet_addr_sockaddr(&dns_server_addr, DNS_SERVER_PORT,
-            &saddr, &saddrlen);
-        if (rc != EOK) {
-                assert(rc == ENOMEM);
-                goto error;
-        }
-        
+
+        inet_ep_init(&ep);
+        ep.addr = dns_server_addr;
+        ep.port = DNS_SERVER_PORT;
+
         size_t ntry = 0;
-        
+
         while (ntry < REQ_RETRY_MAX) {
-                rc = sendto(transport_fd, req_data, req_size, 0,
-                    saddr, saddrlen);
+                rc = udp_assoc_send_msg(transport_assoc, &ep, req_data,
+                    req_size);
                 if (rc != EOK)
                         goto error;
-                
+
                 treq = treq_create(req);
                 if (treq == NULL) {
@@ -211 +204 @@
                         goto error;
                 }
-                
+
                 fibril_mutex_lock(&treq->done_lock);
                 while (treq->done != true) {
@@ -221 +214 @@
                         }
                 }
-                
+
                 fibril_mutex_unlock(&treq->done_lock);
-                
+
                 if (rc != ETIMEOUT)
                         break;
         }
-        
+
         if (ntry >= REQ_RETRY_MAX) {
                 rc = EIO;
                 goto error;
         }
-        
+
         if (treq->status != EOK) {
                 rc = treq->status;
                 goto error;
         }
-        
+
         *rresp = treq->resp;
         treq_destroy(treq);
         free(req_data);
-        free(saddr);
         return EOK;
-        
+
 error:
         if (treq != NULL)
                 treq_destroy(treq);
-        
+
         free(req_data);
-        free(saddr);
         return rc;
 }
 
-static int transport_recv_msg(dns_message_t **rresp)
-{
-        struct sockaddr_in src_addr;
-        socklen_t src_addr_size;
-        size_t recv_size;
-        dns_message_t *resp;
-        int rc;
-
-        src_addr_size = sizeof(src_addr);
-        rc = recvfrom(transport_fd, recv_buf, RECV_BUF_SIZE, 0,
-            (struct sockaddr *)&src_addr, &src_addr_size);
-        if (rc < 0) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "recvfrom returns error - %d", rc);
-                goto error;
-        }
-
-        recv_size = (size_t)rc;
-
-        rc = dns_message_decode(recv_buf, recv_size, &resp);
-        if (rc != EOK) {
-                rc = EIO;
-                goto error;
-        }
-
-        *rresp = resp;
-        return EOK;
-
-error:
-        return rc;
-}
-
-static int transport_recv_fibril(void *arg)
+static void transport_recv_msg(udp_assoc_t *assoc, udp_rmsg_t *rmsg)
 {
         dns_message_t *resp = NULL;
         trans_req_t *treq;
+        size_t size;
+        inet_ep_t remote_ep;
         int rc;
 
-        while (true) {
-                rc = transport_recv_msg(&resp);
-                if (rc != EOK)
-                        continue;
-
-                assert(resp != NULL);
-
-                fibril_mutex_lock(&treq_lock);
-                treq = treq_match_resp(resp);
-                if (treq == NULL) {
-                        fibril_mutex_unlock(&treq_lock);
-                        continue;
-                }
-
-                list_remove(&treq->lreq);
+        size = udp_rmsg_size(rmsg);
+        if (size > RECV_BUF_SIZE)
+                size = RECV_BUF_SIZE; /* XXX */
+
+        rc = udp_rmsg_read(rmsg, 0, recv_buf, size);
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Error reading message.");
+                return;
+        }
+
+        udp_rmsg_remote_ep(rmsg, &remote_ep);
+        /* XXX */
+
+        rc = dns_message_decode(recv_buf, size, &resp);
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Error decoding message.");
+                return;
+        }
+
+        assert(resp != NULL);
+
+        fibril_mutex_lock(&treq_lock);
+        treq = treq_match_resp(resp);
+        if (treq == NULL) {
                 fibril_mutex_unlock(&treq_lock);
-
-                treq_complete(treq, resp);
-        }
-
-        return 0;
-}
+                return;
+        }
+
+        list_remove(&treq->lreq);
+        fibril_mutex_unlock(&treq_lock);
+
+        treq_complete(treq, resp);
+}
+
+static void transport_recv_err(udp_assoc_t *assoc, udp_rerr_t *rerr)
+{
+        log_msg(LOG_DEFAULT, LVL_WARN, "Ignoring ICMP error");
+}
+
+static void transport_link_state(udp_assoc_t *assoc, udp_link_state_t ls)
+{
+        log_msg(LOG_DEFAULT, LVL_NOTE, "Link state change");
+}
+
 
 /** @}

uspace/srv/net/inetsrv/inet_link.c

@@ -73 +73 @@
 {
         memcpy(ip_addr, link_local_node_ip, 16);
-        
+
         ip_addr[8] = mac_addr[0] ^ 0x02;
         ip_addr[9] = mac_addr[1];
@@ -85 +85 @@
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
-        
+
         int rc;
         inet_packet_t packet;
-        
+        inet_link_t *ilink;
+
+        ilink = (inet_link_t *)iplink_get_userptr(iplink);
+
         switch (ver) {
         case ip_v4:
-                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
+                rc = inet_pdu_decode(sdu->data, sdu->size, ilink->svc_id,
+                    &packet);
                 break;
         case ip_v6:
-                rc = inet_pdu_decode6(sdu->data, sdu->size, &packet);
+                rc = inet_pdu_decode6(sdu->data, sdu->size, ilink->svc_id,
+                    &packet);
                 break;
         default:
@@ -100 +105 @@
                 return EINVAL;
         }
-        
+
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
                 return rc;
         }
-        
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "inet_iplink_recv: link_id=%zu", packet.link_id);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()");
         rc = inet_recv_packet(&packet);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc);
         free(packet.data);
-        
+
         return rc;
 }
@@ -177 +183 @@
         }
 
-        rc = iplink_open(ilink->sess, &inet_iplink_ev_ops, &ilink->iplink);
+        rc = iplink_open(ilink->sess, &inet_iplink_ev_ops, ilink, &ilink->iplink);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed opening IP link '%s'",

uspace/srv/net/inetsrv/inetsrv.c

@@ -469 +469 @@
 {
         async_exch_t *exch = async_exchange_begin(client->sess);
-        
+
         ipc_call_t answer;
-        aid_t req = async_send_1(exch, INET_EV_RECV, dgram->tos, &answer);
-        
+
+        log_msg(LOG_DEFAULT, LVL_NOTE, "inet_ev_recv: iplink=%zu",
+            dgram->iplink);
+
+        aid_t req = async_send_2(exch, INET_EV_RECV, dgram->tos,
+            dgram->iplink, &answer);
+
         int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
         if (rc != EOK) {
@@ -479 +484 @@
                 return rc;
         }
-        
+
         rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
         if (rc != EOK) {
@@ -486 +491 @@
                 return rc;
         }
-        
+
         rc = async_data_write_start(exch, dgram->data, dgram->size);
-        
+
         async_exchange_end(exch);
-        
+
         if (rc != EOK) {
                 async_forget(req);
                 return rc;
         }
-        
+
         sysarg_t retval;
         async_wait_for(req, &retval);
-        
+
         return (int) retval;
 }
@@ -511 +516 @@
         if (proto == IP_PROTO_ICMP)
                 return icmp_recv(dgram);
-        
+
         if (proto == IP_PROTO_ICMPV6)
                 return icmpv6_recv(dgram);
@@ -540 +545 @@
                 if (packet->offs == 0 && !packet->mf) {
                         /* It is complete deliver it immediately */
+                        dgram.iplink = packet->link_id;
                         dgram.src = packet->src;
                         dgram.dest = packet->dest;

uspace/srv/net/inetsrv/inetsrv.h

@@ -75 +75 @@
 
 typedef struct {
+        /** Local link ID */
+        service_id_t link_id;
         /** Source address */
         inet_addr_t src;

uspace/srv/net/inetsrv/pdu.c

@@ -298 +298 @@
 /** Decode IPv4 datagram
  *
- * @param data   Serialized IPv4 datagram
- * @param size   Length of serialized IPv4 datagram
- * @param packet IP datagram structure to be filled
+ * @param data    Serialized IPv4 datagram
+ * @param size    Length of serialized IPv4 datagram
+ * @param link_id Link on which PDU was received
+ * @param packet  IP datagram structure to be filled
  *
  * @return EOK on success
@@ -307 +308 @@
  *
  */
-int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
+int inet_pdu_decode(void *data, size_t size, service_id_t link_id,
+    inet_packet_t *packet)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
@@ -366 +368 @@
         
         memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
+        packet->link_id = link_id;
         
         return EOK;
@@ -372 +375 @@
 /** Decode IPv6 datagram
  *
- * @param data   Serialized IPv6 datagram
- * @param size   Length of serialized IPv6 datagram
- * @param packet IP datagram structure to be filled
+ * @param data    Serialized IPv6 datagram
+ * @param size    Length of serialized IPv6 datagram
+ * @param link_id Link on which PDU was received
+ * @param packet  IP datagram structure to be filled
  *
  * @return EOK on success
@@ -381 +385 @@
  *
  */
-int inet_pdu_decode6(void *data, size_t size, inet_packet_t *packet)
+int inet_pdu_decode6(void *data, size_t size, service_id_t link_id,
+    inet_packet_t *packet)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode6()");
@@ -457 +462 @@
         
         memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
-        
+        packet->link_id = link_id;
         return EOK;
 }

uspace/srv/net/inetsrv/pdu.h

@@ -38 +38 @@
 #define INET_PDU_H_
 
+#include <loc.h>
 #include <sys/types.h>
 #include "inetsrv.h"
@@ -50 +51 @@
 extern int inet_pdu_encode6(inet_packet_t *, addr128_t, addr128_t, size_t,
     size_t, void **, size_t *, size_t *);
-extern int inet_pdu_decode(void *, size_t, inet_packet_t *);
-extern int inet_pdu_decode6(void *, size_t, inet_packet_t *);
+extern int inet_pdu_decode(void *, size_t, service_id_t, inet_packet_t *);
+extern int inet_pdu_decode6(void *, size_t, service_id_t, inet_packet_t *);
 
 extern int ndp_pdu_decode(inet_dgram_t *, ndp_packet_t *);

uspace/srv/net/inetsrv/reass.c

@@ -325 +325 @@
                 return ENOMEM;
 
+        /* XXX What if different fragments came from different link? */
+        dgram.iplink = frag->packet.link_id;
         dgram.size = dgram_size;
         dgram.src = frag->packet.src;

uspace/srv/net/tcp/Makefile

@@ -28 +28 @@
 
 USPACE_PREFIX = ../../..
-LIBS = $(LIBNET_PREFIX)/libnet.a
-EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
+
+LIBS = \
+        $(LIBNETTL_PREFIX)/libnettl.a
+
+EXTRA_CFLAGS += \
+        -I$(LIBNETTL_PREFIX)/include
+
 BINARY = tcp
 
@@ -39 +44 @@
         rqueue.c \
         segment.c \
+        service.c \
         seq_no.c \
-        sock.c \
         tcp.c \
         test.c \

uspace/srv/net/tcp/conn.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 
 #include <adt/list.h>
-#include <stdbool.h>
 #include <errno.h>
+#include <inet/endpoint.h>
 #include <io/log.h>
 #include <macros.h>
+#include <nettl/amap.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include "conn.h"
@@ -55 +57 @@
 #define TIME_WAIT_TIMEOUT       (2*MAX_SEGMENT_LIFETIME)
 
-LIST_INITIALIZE(conn_list);
-FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
+static LIST_INITIALIZE(conn_list);
+/** Taken after tcp_conn_t lock */
+static FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
+static amap_t *amap;
 
 static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg);
@@ -62 +66 @@
 static void tcp_conn_tw_timer_clear(tcp_conn_t *conn);
 
+/** Initialize connections. */
+int tcp_conns_init(void)
+{
+        int rc;
+
+        rc = amap_create(&amap);
+        if (rc != EOK) {
+                assert(rc == ENOMEM);
+                return ENOMEM;
+        }
+
+        return EOK;
+}
+
 /** Create new connection structure.
  *
- * @param lsock         Local socket (will be deeply copied)
- * @param fsock         Foreign socket (will be deeply copied)
+ * @param epp           Endpoint pair (will be deeply copied)
  * @return              New connection or NULL
  */
-tcp_conn_t *tcp_conn_new(tcp_sock_t *lsock, tcp_sock_t *fsock)
+tcp_conn_t *tcp_conn_new(inet_ep2_t *epp)
 {
         tcp_conn_t *conn = NULL;
@@ -121 +138 @@
         fibril_condvar_initialize(&conn->cstate_cv);
 
-        conn->cstate_cb = NULL;
+        conn->cb = NULL;
 
         conn->cstate = st_listen;
@@ -128 +145 @@
         conn->ap = ap_passive;
         conn->fin_is_acked = false;
-        conn->ident.local = *lsock;
-        if (fsock != NULL)
-                conn->ident.foreign = *fsock;
+        if (epp != NULL)
+                conn->ident = *epp;
 
         return conn;
@@ -184 +200 @@
 void tcp_conn_addref(tcp_conn_t *conn)
 {
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_addref(%p) before=%zu",
+            conn->name, conn, atomic_get(&conn->refcnt));
         atomic_inc(&conn->refcnt);
 }
@@ -196 +213 @@
 void tcp_conn_delref(tcp_conn_t *conn)
 {
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
+        log_msg(LOG_DEFAULT, LVL_DEBUG2, "%s: tcp_conn_delref(%p) before=%zu",
+            conn->name, conn, atomic_get(&conn->refcnt));
 
         if (atomic_predec(&conn->refcnt) == 0)
@@ -237 +255 @@
 
         assert(conn->deleted == false);
+        conn->deleted = true;
+        conn->cb = NULL;
+        conn->cb_arg = NULL;
         tcp_conn_delref(conn);
 }
@@ -244 +265 @@
  * Add connection to the connection map.
  */
-void tcp_conn_add(tcp_conn_t *conn)
-{
+int tcp_conn_add(tcp_conn_t *conn)
+{
+        inet_ep2_t aepp;
+        int rc;
+
         tcp_conn_addref(conn);
         fibril_mutex_lock(&conn_list_lock);
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_add: conn=%p", conn);
+
+        rc = amap_insert(amap, &conn->ident, conn, af_allow_system, &aepp);
+        if (rc != EOK) {
+                tcp_conn_delref(conn);
+                fibril_mutex_unlock(&conn_list_lock);
+                return rc;
+        }
+
+        conn->ident = aepp;
         list_append(&conn->link, &conn_list);
         fibril_mutex_unlock(&conn_list_lock);
+
+        return EOK;
 }
 
@@ -259 +296 @@
 {
         fibril_mutex_lock(&conn_list_lock);
+        amap_remove(amap, &conn->ident);
         list_remove(&conn->link);
         fibril_mutex_unlock(&conn_list_lock);
@@ -275 +313 @@
 
         /* Run user callback function */
-        if (conn->cstate_cb != NULL) {
+        if (conn->cb != NULL && conn->cb->cstate_change != NULL) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - run user CB");
-                conn->cstate_cb(conn, conn->cstate_cb_arg);
+                conn->cb->cstate_change(conn, conn->cb_arg, old_state);
         } else {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_state_set() - no user CB");
@@ -284 +322 @@
         assert(old_state != st_closed);
         if (nstate == st_closed) {
+                tcp_conn_remove(conn);
                 /* Drop one reference for now being in closed state */
                 tcp_conn_delref(conn);
@@ -332 +371 @@
 }
 
-/** Match socket with pattern. */
-static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG2,
-            "tcp_socket_match(sock=(%u), pat=(%u))", sock->port, patt->port);
-        
-        if ((!inet_addr_is_any(&patt->addr)) &&
-            (!inet_addr_compare(&patt->addr, &sock->addr)))
-                return false;
-
-        if ((patt->port != TCP_PORT_ANY) &&
-            (patt->port != sock->port))
-                return false;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, " -> match");
-
-        return true;
-}
-
-/** Match socket pair with pattern. */
-static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
-
-        if (!tcp_socket_match(&sp->local, &pattern->local))
-                return false;
-
-        if (!tcp_socket_match(&sp->foreign, &pattern->foreign))
-                return false;
-
-        return true;
-}
-
-/** Find connection structure for specified socket pair.
- *
- * A connection is uniquely identified by a socket pair. Look up our
- * connection map and return connection structure based on socket pair.
+/** Find connection structure for specified endpoint pair.
+ *
+ * A connection is uniquely identified by a endpoint pair. Look up our
+ * connection map and return connection structure based on endpoint pair.
  * The connection reference count is bumped by one.
  *
- * @param sp    Socket pair
+ * @param epp   Endpoint pair
  * @return      Connection structure or NULL if not found.
  */
-tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
-        
-        log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%u), l:(%u))",
-            sp->foreign.port, sp->local.port);
-        
+tcp_conn_t *tcp_conn_find_ref(inet_ep2_t *epp)
+{
+        int rc;
+        void *arg;
+        tcp_conn_t *conn;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", epp);
+
         fibril_mutex_lock(&conn_list_lock);
-        
-        list_foreach(conn_list, link, tcp_conn_t, conn) {
-                tcp_sockpair_t *csp = &conn->ident;
-                
-                log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%u), l:(%u))",
-                    csp->foreign.port, csp->local.port);
-                
-                if (tcp_sockpair_match(sp, csp)) {
-                        tcp_conn_addref(conn);
-                        fibril_mutex_unlock(&conn_list_lock);
-                        return conn;
-                }
-        }
-        
+
+        rc = amap_find_match(amap, epp, &arg);
+        if (rc != EOK) {
+                assert(rc == ENOENT);
+                fibril_mutex_unlock(&conn_list_lock);
+                return NULL;
+        }
+
+        conn = (tcp_conn_t *)arg;
+        tcp_conn_addref(conn);
+
         fibril_mutex_unlock(&conn_list_lock);
-        return NULL;
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref: got conn=%p",
+            conn);
+        return conn;
 }
 
@@ -407 +413 @@
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);
+        conn->reset = true;
         tcp_conn_state_set(conn, st_closed);
-        conn->reset = true;
 
         tcp_conn_tw_timer_clear(conn);
@@ -877 +883 @@
         if (conn->fin_is_acked) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: FIN acked -> Closed", conn->name);
-                tcp_conn_remove(conn);
                 tcp_conn_state_set(conn, st_closed);
                 return cp_done;
@@ -1006 +1011 @@
 
         /* Signal to the receive function that new data has arrived */
-        fibril_condvar_broadcast(&conn->rcv_buf_cv);
+        if (xfer_size > 0) {
+                fibril_condvar_broadcast(&conn->rcv_buf_cv);
+                if (conn->cb != NULL && conn->cb->recv_data != NULL)
+                        conn->cb->recv_data(conn, conn->cb_arg);
+        }
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
@@ -1098 +1107 @@
                 conn->rcv_buf_fin = true;
                 fibril_condvar_broadcast(&conn->rcv_buf_cv);
+                if (conn->cb != NULL && conn->cb->recv_data != NULL)
+                        conn->cb->recv_data(conn, conn->cb_arg);
 
                 tcp_segment_delete(seg);
@@ -1168 +1179 @@
  *
  * @param conn          Connection
- * @param seg           Segment
- */
-void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg)
-{
+ * @param epp           Endpoint pair on which segment was received
+ * @param seg           Segment
+ */
+void tcp_conn_segment_arrived(tcp_conn_t *conn, inet_ep2_t *epp,
+    tcp_segment_t *seg)
+{
+        inet_ep2_t aepp;
+        inet_ep2_t oldepp;
+        int rc;
+
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_segment_arrived(%p)",
             conn->name, seg);
 
+        tcp_conn_lock(conn);
+
+        if (conn->cstate == st_closed) {
+                log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed.");
+                tcp_unexpected_segment(epp, seg);
+                tcp_conn_unlock(conn);
+                return;
+        }
+
+        if (inet_addr_is_any(&conn->ident.remote.addr) ||
+            conn->ident.remote.port == inet_port_any ||
+            inet_addr_is_any(&conn->ident.local.addr)) {
+
+                log_msg(LOG_DEFAULT, LVL_DEBUG2, "tcp_conn_segment_arrived: "
+                    "Changing connection ID, updating amap.");
+                oldepp = conn->ident;
+
+                /* Need to remove and re-insert connection with new identity */
+                fibril_mutex_lock(&conn_list_lock);
+
+                if (inet_addr_is_any(&conn->ident.remote.addr))
+                        conn->ident.remote.addr = epp->remote.addr;
+
+                if (conn->ident.remote.port == inet_port_any)
+                        conn->ident.remote.port = epp->remote.port;
+
+                if (inet_addr_is_any(&conn->ident.local.addr))
+                        conn->ident.local.addr = epp->local.addr;
+
+                rc = amap_insert(amap, &conn->ident, conn, af_allow_system, &aepp);
+                if (rc != EOK) {
+                        assert(rc != EEXISTS);
+                        assert(rc == ENOMEM);
+                        log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory.");
+                        fibril_mutex_unlock(&conn_list_lock);
+                        tcp_conn_unlock(conn);
+                        return;
+                }
+
+                amap_remove(amap, &oldepp);
+                fibril_mutex_unlock(&conn_list_lock);
+
+                conn->name = (char *) "a";
+        }
+
         switch (conn->cstate) {
         case st_listen:
-                tcp_conn_sa_listen(conn, seg); break;
+                tcp_conn_sa_listen(conn, seg);
+                break;
         case st_syn_sent:
-                tcp_conn_sa_syn_sent(conn, seg); break;
+                tcp_conn_sa_syn_sent(conn, seg);
+                break;
         case st_syn_received:
         case st_established:
@@ -1189 +1253 @@
         case st_time_wait:
                 /* Process segments in order of sequence number */
-                tcp_conn_sa_queue(conn, seg); break;
+                tcp_conn_sa_queue(conn, seg);
+                break;
         case st_closed:
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "state=%d", (int) conn->cstate);
                 assert(false);
         }
+
+        tcp_conn_unlock(conn);
 }
 
@@ -1216 +1283 @@
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name);
-        tcp_conn_remove(conn);
         tcp_conn_state_set(conn, st_closed);
 
@@ -1263 +1329 @@
 }
 
-/** Handle unexpected segment received on a socket pair.
+/** Handle unexpected segment received on an endpoint pair.
  *
  * We reply with an RST unless the received segment has RST.
  *
- * @param sp            Socket pair which received the segment
+ * @param sp            Endpoint pair which received the segment
  * @param seg           Unexpected segment
  */
-void tcp_unexpected_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, seg);
+void tcp_unexpected_segment(inet_ep2_t *epp, tcp_segment_t *seg)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", epp,
+            seg);
 
         if ((seg->ctrl & CTL_RST) == 0)
-                tcp_reply_rst(sp, seg);
-}
-
-/** Compute flipped socket pair for response.
- *
- * Flipped socket pair has local and foreign sockets exchanged.
- *
- * @param sp            Socket pair
- * @param fsp           Place to store flipped socket pair
- */
-void tcp_sockpair_flipped(tcp_sockpair_t *sp, tcp_sockpair_t *fsp)
-{
-        fsp->local = sp->foreign;
-        fsp->foreign = sp->local;
+                tcp_reply_rst(epp, seg);
+}
+
+/** Compute flipped endpoint pair for response.
+ *
+ * Flipped endpoint pair has local and remote endpoints exchanged.
+ *
+ * @param epp           Endpoint pair
+ * @param fepp          Place to store flipped endpoint pair
+ */
+void tcp_ep2_flipped(inet_ep2_t *epp, inet_ep2_t *fepp)
+{
+        fepp->local = epp->remote;
+        fepp->remote = epp->local;
 }
 
 /** Send RST in response to an incoming segment.
  *
- * @param sp            Socket pair which received the segment
+ * @param epp           Endpoint pair which received the segment
  * @param seg           Incoming segment
  */
-void tcp_reply_rst(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_reply_rst(inet_ep2_t *epp, tcp_segment_t *seg)
 {
         tcp_segment_t *rseg;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_reply_rst(%p, %p)", epp, seg);
 
         rseg = tcp_segment_make_rst(seg);
-        tcp_transmit_segment(sp, rseg);
+        tcp_transmit_segment(epp, rseg);
 }
 

uspace/srv/net/tcp/conn.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define CONN_H
 
+#include <inet/endpoint.h>
 #include <stdbool.h>
 #include "tcp_type.h"
 
-extern tcp_conn_t *tcp_conn_new(tcp_sock_t *, tcp_sock_t *);
+extern int tcp_conns_init(void);
+extern tcp_conn_t *tcp_conn_new(inet_ep2_t *);
 extern void tcp_conn_delete(tcp_conn_t *);
-extern void tcp_conn_add(tcp_conn_t *);
+extern int tcp_conn_add(tcp_conn_t *);
 extern void tcp_conn_remove(tcp_conn_t *);
 extern void tcp_conn_reset(tcp_conn_t *conn);
@@ -47 +49 @@
 extern void tcp_conn_fin_sent(tcp_conn_t *);
 extern void tcp_conn_ack_of_fin_rcvd(tcp_conn_t *);
-extern tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *);
+extern tcp_conn_t *tcp_conn_find_ref(inet_ep2_t *);
 extern void tcp_conn_addref(tcp_conn_t *);
 extern void tcp_conn_delref(tcp_conn_t *);
@@ -53 +55 @@
 extern void tcp_conn_unlock(tcp_conn_t *);
 extern bool tcp_conn_got_syn(tcp_conn_t *);
-extern void tcp_conn_segment_arrived(tcp_conn_t *, tcp_segment_t *);
+extern void tcp_conn_segment_arrived(tcp_conn_t *, inet_ep2_t *,
+    tcp_segment_t *);
 extern void tcp_conn_trim_seg_to_wnd(tcp_conn_t *, tcp_segment_t *);
-extern void tcp_unexpected_segment(tcp_sockpair_t *, tcp_segment_t *);
-extern void tcp_sockpair_flipped(tcp_sockpair_t *, tcp_sockpair_t *);
-extern void tcp_reply_rst(tcp_sockpair_t *, tcp_segment_t *);
+extern void tcp_unexpected_segment(inet_ep2_t *, tcp_segment_t *);
+extern void tcp_ep2_flipped(inet_ep2_t *, inet_ep2_t *);
+extern void tcp_reply_rst(inet_ep2_t *, tcp_segment_t *);
 
 #endif

uspace/srv/net/tcp/ncsim.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -42 +42 @@
 #include <async.h>
 #include <errno.h>
+#include <inet/endpoint.h>
 #include <io/log.h>
 #include <stdlib.h>
@@ -65 +66 @@
 /** Bounce segment through simulator into receive queue.
  *
- * @param sp    Socket pair, oriented for transmission
+ * @param epp   Endpoint pair, oriented for transmission
  * @param seg   Segment
  */
-void tcp_ncsim_bounce_seg(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_ncsim_bounce_seg(inet_ep2_t *epp, tcp_segment_t *seg)
 {
         tcp_squeue_entry_t *sqe;
@@ -75 +76 @@
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_ncsim_bounce_seg()");
-        tcp_rqueue_bounce_seg(sp, seg);
+        tcp_rqueue_bounce_seg(epp, seg);
         return;
 
@@ -92 +93 @@
 
         sqe->delay = random() % (1000 * 1000);
-        sqe->sp = *sp;
+        sqe->epp = *epp;
         sqe->seg = seg;
 
@@ -147 +148 @@
 
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "NCSim - End Sleep");
-                tcp_rqueue_bounce_seg(&sqe->sp, sqe->seg);
+                tcp_rqueue_bounce_seg(&sqe->epp, sqe->seg);
                 free(sqe);
         }

uspace/srv/net/tcp/ncsim.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define NCSIM_H
 
+#include <inet/endpoint.h>
 #include "tcp_type.h"
 
 extern void tcp_ncsim_init(void);
-extern void tcp_ncsim_bounce_seg(tcp_sockpair_t *, tcp_segment_t *);
+extern void tcp_ncsim_bounce_seg(inet_ep2_t *, tcp_segment_t *);
 extern void tcp_ncsim_fibril_start(void);
 

uspace/srv/net/tcp/pdu.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -38 +38 @@
 #include <byteorder.h>
 #include <errno.h>
+#include <inet/endpoint.h>
 #include <mem.h>
 #include <stdlib.h>
@@ -125 +126 @@
 }
 
-static void tcp_header_setup(tcp_sockpair_t *sp, tcp_segment_t *seg, tcp_header_t *hdr)
+static void tcp_header_setup(inet_ep2_t *epp, tcp_segment_t *seg, tcp_header_t *hdr)
 {
         uint16_t doff_flags;
         uint16_t doff;
 
-        hdr->src_port = host2uint16_t_be(sp->local.port);
-        hdr->dest_port = host2uint16_t_be(sp->foreign.port);
+        hdr->src_port = host2uint16_t_be(epp->local.port);
+        hdr->dest_port = host2uint16_t_be(epp->remote.port);
         hdr->seq = host2uint32_t_be(seg->seq);
         hdr->ack = host2uint32_t_be(seg->ack);
@@ -190 +191 @@
 }
 
-static int tcp_header_encode(tcp_sockpair_t *sp, tcp_segment_t *seg,
+static int tcp_header_encode(inet_ep2_t *epp, tcp_segment_t *seg,
     void **header, size_t *size)
 {
@@ -199 +200 @@
                 return ENOMEM;
 
-        tcp_header_setup(sp, seg, hdr);
+        tcp_header_setup(epp, seg, hdr);
         *header = hdr;
         *size = sizeof(tcp_header_t);
@@ -293 +294 @@
 
 /** Decode incoming PDU */
-int tcp_pdu_decode(tcp_pdu_t *pdu, tcp_sockpair_t *sp, tcp_segment_t **seg)
+int tcp_pdu_decode(tcp_pdu_t *pdu, inet_ep2_t *epp, tcp_segment_t **seg)
 {
         tcp_segment_t *nseg;
@@ -307 +308 @@
         hdr = (tcp_header_t *)pdu->header;
 
-        sp->local.port = uint16_t_be2host(hdr->dest_port);
-        sp->local.addr = pdu->dest;
-        sp->foreign.port = uint16_t_be2host(hdr->src_port);
-        sp->foreign.addr = pdu->src;
+        epp->local.port = uint16_t_be2host(hdr->dest_port);
+        epp->local.addr = pdu->dest;
+        epp->remote.port = uint16_t_be2host(hdr->src_port);
+        epp->remote.addr = pdu->src;
 
         *seg = nseg;
@@ -317 +318 @@
 
 /** Encode outgoing PDU */
-int tcp_pdu_encode(tcp_sockpair_t *sp, tcp_segment_t *seg, tcp_pdu_t **pdu)
+int tcp_pdu_encode(inet_ep2_t *epp, tcp_segment_t *seg, tcp_pdu_t **pdu)
 {
         tcp_pdu_t *npdu;
@@ -327 +328 @@
                 return ENOMEM;
 
-        npdu->src = sp->local.addr;
-        npdu->dest = sp->foreign.addr;
-        tcp_header_encode(sp, seg, &npdu->header, &npdu->header_size);
+        npdu->src = epp->local.addr;
+        npdu->dest = epp->remote.addr;
+        tcp_header_encode(epp, seg, &npdu->header, &npdu->header_size);
 
         text_size = tcp_segment_text_size(seg);

uspace/srv/net/tcp/pdu.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define PDU_H
 
+#include <inet/endpoint.h>
 #include <sys/types.h>
 #include "std.h"
@@ -42 +43 @@
 extern tcp_pdu_t *tcp_pdu_create(void *, size_t, void *, size_t);
 extern void tcp_pdu_delete(tcp_pdu_t *);
-extern int tcp_pdu_decode(tcp_pdu_t *, tcp_sockpair_t *, tcp_segment_t **);
-extern int tcp_pdu_encode(tcp_sockpair_t *, tcp_segment_t *, tcp_pdu_t **);
+extern int tcp_pdu_decode(tcp_pdu_t *, inet_ep2_t *, tcp_segment_t **);
+extern int tcp_pdu_encode(inet_ep2_t *, tcp_segment_t *, tcp_pdu_t **);
 
 #endif

uspace/srv/net/tcp/rqueue.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -67 +67 @@
  * This is for testing purposes only.
  *
- * @param sp    Socket pair, oriented for transmission
+ * @param sp    Endpoint pair, oriented for transmission
  * @param seg   Segment
  */
-void tcp_rqueue_bounce_seg(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_rqueue_bounce_seg(inet_ep2_t *epp, tcp_segment_t *seg)
 {
-        tcp_sockpair_t rident;
+        inet_ep2_t rident;
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_rqueue_bounce_seg()");
@@ -80 +80 @@
         tcp_segment_t *dseg;
 
-        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
+        if (tcp_pdu_encode(epp, seg, &pdu) != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
                 return;
@@ -97 +97 @@
 #else
         /* Reverse the identification */
-        tcp_sockpair_flipped(sp, &rident);
+        tcp_ep2_flipped(epp, &rident);
 
         /* Insert segment back into rqueue */
@@ -106 +106 @@
 /** Insert segment into receive queue.
  *
- * @param sp    Socket pair, oriented for reception
+ * @param epp   Endpoint pair, oriented for reception
  * @param seg   Segment
  */
-void tcp_rqueue_insert_seg(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_rqueue_insert_seg(inet_ep2_t *epp, tcp_segment_t *seg)
 {
         tcp_rqueue_entry_t *rqe;
@@ -122 +122 @@
         }
 
-        rqe->sp = *sp;
+        rqe->epp = *epp;
         rqe->seg = seg;
 
@@ -140 +140 @@
                 rqe = list_get_instance(link, tcp_rqueue_entry_t, link);
 
-                tcp_as_segment_arrived(&rqe->sp, rqe->seg);
+                tcp_as_segment_arrived(&rqe->epp, rqe->seg);
                 free(rqe);
         }

uspace/srv/net/tcp/rqueue.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define RQUEUE_H
 
+#include <inet/endpoint.h>
 #include "tcp_type.h"
 
 extern void tcp_rqueue_init(void);
-extern void tcp_rqueue_bounce_seg(tcp_sockpair_t *, tcp_segment_t *);
-extern void tcp_rqueue_insert_seg(tcp_sockpair_t *, tcp_segment_t *);
+extern void tcp_rqueue_bounce_seg(inet_ep2_t *, tcp_segment_t *);
+extern void tcp_rqueue_insert_seg(inet_ep2_t *, tcp_segment_t *);
 extern void tcp_rqueue_handler(void *);
 extern void tcp_rqueue_fibril_start(void);

uspace/srv/net/tcp/service.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -30 +30 @@
  * @{
  */
-/** @file Socket provider
+/** @file HelenOS service implementation
  */
 
-#ifndef SOCK_H
-#define SOCK_H
+#ifndef SERVICE_H
+#define SERVICE_H
 
-#include <async.h>
-
-extern int tcp_sock_init(void);
+extern int tcp_service_init(void);
 
 #endif

uspace/srv/net/tcp/tcp.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -42 +42 @@
 #include <io/log.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <task.h>
 
+#include "conn.h"
 #include "ncsim.h"
 #include "pdu.h"
 #include "rqueue.h"
-#include "sock.h"
+#include "service.h"
 #include "std.h"
 #include "tcp.h"
@@ -159 +161 @@
 {
         tcp_segment_t *dseg;
-        tcp_sockpair_t rident;
+        inet_ep2_t rident;
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_received_pdu()");
@@ -178 +180 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_init()");
 
+        rc = tcp_conns_init();
+        if (rc != EOK) {
+                assert(rc == ENOMEM);
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing connections");
+                return ENOMEM;
+        }
+
         tcp_rqueue_init();
         tcp_rqueue_fibril_start();
@@ -192 +201 @@
         }
 
-        rc = tcp_sock_init();
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
+        rc = tcp_service_init();
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing service.");
                 return ENOENT;
         }

uspace/srv/net/tcp/tcp_type.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <fibril.h>
 #include <fibril_synch.h>
-#include <socket_core.h>
 #include <sys/types.h>
 #include <inet/addr.h>
+#include <inet/endpoint.h>
 
 struct tcp_conn;
@@ -90 +90 @@
         /* Connection reset */
         TCP_ERESET,
-        /* Foreign socket unspecified */
+        /* Remote endpoint unspecified */
         TCP_EUNSPEC,
         /* Insufficient resources */
@@ -97 +97 @@
         TCP_EINVPREC,
         /* Security/compartment not allowed */
-        TCP_EINVCOMP
+        TCP_EINVCOMP,
+        TCP_EAGAIN
 } tcp_error_t;
 
@@ -112 +113 @@
 } tcp_control_t;
 
-typedef struct {
-        inet_addr_t addr;
-        uint16_t port;
-} tcp_sock_t;
-
-enum tcp_port {
-        TCP_PORT_ANY = 0
-};
-
-typedef struct {
-        tcp_sock_t local;
-        tcp_sock_t foreign;
-} tcp_sockpair_t;
-
 /** Connection incoming segments queue */
 typedef struct {
@@ -155 +142 @@
 typedef void (*tcp_cstate_cb_t)(tcp_conn_t *, void *);
 
+/** Connection callbacks */
+typedef struct {
+        void (*cstate_change)(tcp_conn_t *, void *, tcp_cstate_t);
+        void (*recv_data)(tcp_conn_t *, void *);
+} tcp_cb_t;
+
 /** Connection */
 struct tcp_conn {
@@ -160 +153 @@
         link_t link;
 
-        /** Connection state change callback function */
-        tcp_cstate_cb_t cstate_cb;
+        /** Connection callbacks function */
+        tcp_cb_t *cb;
         /** Argument to @c cstate_cb */
-        void *cstate_cb_arg;
-
-        /** Connection identification (local and foreign socket) */
-        tcp_sockpair_t ident;
+        void *cb_arg;
+
+        /** Connection identification (local and remote endpoint) */
+        inet_ep2_t ident;
 
         /** Active or passive connection */
@@ -274 +267 @@
 typedef struct {
         link_t link;
-        tcp_sockpair_t sp;
+        inet_ep2_t epp;
         tcp_segment_t *seg;
 } tcp_rqueue_entry_t;
@@ -282 +275 @@
         link_t link;
         suseconds_t delay;
-        tcp_sockpair_t sp;
+        inet_ep2_t epp;
         tcp_segment_t *seg;
 } tcp_squeue_entry_t;
@@ -319 +312 @@
 } tcp_pdu_t;
 
-typedef struct {
-        async_sess_t *sess;
-        socket_cores_t sockets;
-} tcp_client_t;
-
-#define TCP_SOCK_FRAGMENT_SIZE 1024
-
-typedef struct tcp_sockdata {
-        /** Lock */
-        fibril_mutex_t lock;
-        /** Socket core */
-        socket_core_t *sock_core;
-        /** Client */
-        tcp_client_t *client;
+/** TCP client connection */
+typedef struct tcp_cconn {
         /** Connection */
         tcp_conn_t *conn;
-        /** Local address */
-        inet_addr_t laddr;
-        /** Backlog size */
-        int backlog;
-        /** Array of listening connections, @c backlog elements */
-        struct tcp_sock_lconn **lconn;
-        /** List of connections (from lconn) that are ready to be accepted */
-        list_t ready;
-        /** Receiving fibril */
-        fid_t recv_fibril;
-        uint8_t recv_buffer[TCP_SOCK_FRAGMENT_SIZE];
-        size_t recv_buffer_used;
-        fibril_mutex_t recv_buffer_lock;
-        fibril_condvar_t recv_buffer_cv;
-        tcp_error_t recv_error;
-} tcp_sockdata_t;
-
-typedef struct tcp_sock_lconn {
+        /** Connection ID for the client */
+        sysarg_t id;
+        /** Client */
+        struct tcp_client *client;
+        link_t lclient;
+} tcp_cconn_t;
+
+/** TCP client listener */
+typedef struct tcp_clst {
+        /** Local endpoint */
+        inet_ep_t elocal;
+        /** Connection */
         tcp_conn_t *conn;
-        tcp_sockdata_t *socket;
-        int index;
-        link_t ready_list;
-} tcp_sock_lconn_t;
-
+        /** Listener ID for the client */
+        sysarg_t id;
+        /** Client */
+        struct tcp_client *client;
+        /** Link to tcp_client_t.clst */
+        link_t lclient;
+} tcp_clst_t;
+
+/** TCP client */
+typedef struct tcp_client {
+        /** Client callbac session */
+        async_sess_t *sess;
+        /** Client's connections */
+        list_t cconn; /* of tcp_cconn_t */
+        /** Client's listeners */
+        list_t clst;
+} tcp_client_t;
 
 #endif

uspace/srv/net/tcp/test.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -50 +50 @@
 {
         tcp_conn_t *conn;
-        tcp_sock_t lsock;
-        tcp_sock_t fsock;
+        inet_ep2_t epp;
         char rcv_buf[RCV_BUF_SIZE + 1];
         size_t rcvd;
@@ -57 +56 @@
 
         printf("test_srv()\n");
-        
-        inet_addr(&lsock.addr, 127, 0, 0, 1);
-        lsock.port = 80;
-        
-        inet_addr(&fsock.addr, 127, 0, 0, 1);
-        fsock.port = 1024;
-        
+
+        inet_ep2_init(&epp);
+
+        inet_addr(&epp.local.addr, 127, 0, 0, 1);
+        epp.local.port = 80;
+
+        inet_addr(&epp.remote.addr, 127, 0, 0, 1);
+        epp.remote.port = 1024;
+
         printf("S: User open...\n");
-        tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn);
+        tcp_uc_open(&epp, ap_passive, 0, &conn);
         conn->name = (char *) "S";
 
@@ -93 +94 @@
 {
         tcp_conn_t *conn;
-        tcp_sock_t lsock;
-        tcp_sock_t fsock;
+        inet_ep2_t epp;
         const char *msg = "Hello World!";
 
         printf("test_cli()\n");
-        
-        inet_addr(&lsock.addr, 127, 0, 0, 1);
-        lsock.port = 1024;
-        
-        inet_addr(&fsock.addr, 127, 0, 0, 1);
-        fsock.port = 80;
+
+        inet_ep2_init(&epp);
+
+        inet_addr(&epp.local.addr, 127, 0, 0, 1);
+        epp.local.port = 1024;
+
+        inet_addr(&epp.remote.addr, 127, 0, 0, 1);
+        epp.remote.port = 80;
 
         async_usleep(1000*1000*3);
         printf("C: User open...\n");
-        tcp_uc_open(&lsock, &fsock, ap_active, 0, &conn);
+        tcp_uc_open(&epp, ap_active, 0, &conn);
         conn->name = (char *) "C";
 

uspace/srv/net/tcp/tqueue.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -282 +282 @@
 }
 
-void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_transmit_segment(inet_ep2_t *epp, tcp_segment_t *seg)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG,
-            "tcp_transmit_segment(f:(%u),l:(%u), %p)",
-            sp->local.port, sp->foreign.port, seg);
-        
+            "tcp_transmit_segment(l:(%u),f:(%u), %p)",
+            epp->local.port, epp->remote.port, seg);
+
         log_msg(LOG_DEFAULT, LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32,
             seg->seq, seg->wnd);
@@ -301 +301 @@
         tcp_pdu_t *pdu;
 
-        if (tcp_pdu_encode(sp, seg, &pdu) != EOK) {
+        if (tcp_pdu_encode(epp, seg, &pdu) != EOK) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "Not enough memory. Segment dropped.");
                 return;
@@ -351 +351 @@
 
         /* Reset retransmission timer */
-        tcp_tqueue_timer_set(tqe->conn);
+        fibril_timer_set_locked(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
+            retransmit_timeout_func, (void *) conn);
 
         tcp_conn_unlock(conn);
-        tcp_conn_delref(conn);
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "### %s: retransmit_timeout_func(%p) end", conn->name, conn);

uspace/srv/net/tcp/tqueue.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define TQUEUE_H
 
+#include <inet/endpoint.h>
 #include "std.h"
 #include "tcp_type.h"
@@ -48 +49 @@
 extern void tcp_prepare_transmit_segment(tcp_conn_t *, tcp_segment_t *);
 extern void tcp_conn_transmit_segment(tcp_conn_t *, tcp_segment_t *);
-extern void tcp_transmit_segment(tcp_sockpair_t *, tcp_segment_t *);
+extern void tcp_transmit_segment(inet_ep2_t *, tcp_segment_t *);
 extern void tcp_header_setup(tcp_conn_t *, tcp_segment_t *, tcp_header_t *);
 extern void tcp_phdr_setup(tcp_conn_t *, tcp_segment_t *, tcp_phdr_t *);

uspace/srv/net/tcp/ucall.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -35 +35 @@
  */
 
+#include <errno.h>
 #include <fibril_synch.h>
 #include <io/log.h>
@@ -50 +51 @@
 /** OPEN user call
  *
- * @param lsock         Local socket
- * @param fsock         Foreign socket
+ * @param epp           Endpoint pair
  * @param acpass        Active/passive
  * @param oflags        Open flags
@@ -65 +65 @@
  * establishment.
  */
-tcp_error_t tcp_uc_open(tcp_sock_t *lsock, tcp_sock_t *fsock, acpass_t acpass,
+tcp_error_t tcp_uc_open(inet_ep2_t *epp, acpass_t acpass,
     tcp_open_flags_t oflags, tcp_conn_t **conn)
 {
         tcp_conn_t *nconn;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)",
-            lsock, fsock, acpass == ap_active ? "active" : "passive",
+        int rc;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open(%p, %s, %s, %p)",
+            epp, acpass == ap_active ? "active" : "passive",
             oflags == tcp_open_nonblock ? "nonblock" : "none", conn);
 
-        nconn = tcp_conn_new(lsock, fsock);
-        tcp_conn_add(nconn);
+        nconn = tcp_conn_new(epp);
+        rc = tcp_conn_add(nconn);
+        if (rc != EOK) {
+                tcp_conn_delete(nconn);
+                return TCP_EEXISTS;
+        }
+
         tcp_conn_lock(nconn);
 
@@ -188 +194 @@
         /* Wait for data to become available */
         while (conn->rcv_buf_used == 0 && !conn->rcv_buf_fin && !conn->reset) {
+                tcp_conn_unlock(conn);
+                return TCP_EAGAIN;
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_receive() - wait for data");
                 fibril_condvar_wait(&conn->rcv_buf_cv, &conn->lock);
@@ -250 +258 @@
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - listen/syn_sent");
                 tcp_conn_reset(conn);
-                tcp_conn_remove(conn);
                 tcp_conn_unlock(conn);
                 return TCP_EOK;
@@ -294 +301 @@
 }
 
-void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)",
+void tcp_uc_set_cb(tcp_conn_t *conn, tcp_cb_t *cb, void *arg)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_set_cb(%p, %p, %p)",
             conn, cb, arg);
 
-        conn->cstate_cb = cb;
-        conn->cstate_cb_arg = arg;
+        conn->cb = cb;
+        conn->cb_arg = arg;
+}
+
+void *tcp_uc_get_userptr(tcp_conn_t *conn)
+{
+        return conn->cb_arg;
 }
 
@@ -308 +320 @@
 
 /** Segment arrived */
-void tcp_as_segment_arrived(tcp_sockpair_t *sp, tcp_segment_t *seg)
+void tcp_as_segment_arrived(inet_ep2_t *epp, tcp_segment_t *seg)
 {
         tcp_conn_t *conn;
@@ -314 +326 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG,
             "tcp_as_segment_arrived(f:(%u), l:(%u))",
-            sp->foreign.port, sp->local.port);
-
-        conn = tcp_conn_find_ref(sp);
+            epp->remote.port, epp->local.port);
+
+        conn = tcp_conn_find_ref(epp);
         if (conn == NULL) {
                 log_msg(LOG_DEFAULT, LVL_WARN, "No connection found.");
-                tcp_unexpected_segment(sp, seg);
+                tcp_unexpected_segment(epp, seg);
                 return;
         }
 
-        tcp_conn_lock(conn);
-
-        if (conn->cstate == st_closed) {
-                log_msg(LOG_DEFAULT, LVL_WARN, "Connection is closed.");
-                tcp_unexpected_segment(sp, seg);
-                tcp_conn_unlock(conn);
-                tcp_conn_delref(conn);
-                return;
-        }
-
-        if (inet_addr_is_any(&conn->ident.foreign.addr))
-                conn->ident.foreign.addr = sp->foreign.addr;
-        
-        if (conn->ident.foreign.port == TCP_PORT_ANY)
-                conn->ident.foreign.port = sp->foreign.port;
-        
-        if (inet_addr_is_any(&conn->ident.local.addr))
-                conn->ident.local.addr = sp->local.addr;
-
-        tcp_conn_segment_arrived(conn, seg);
-
-        tcp_conn_unlock(conn);
+        tcp_conn_segment_arrived(conn, epp, seg);
         tcp_conn_delref(conn);
 }

uspace/srv/net/tcp/ucall.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define UCALL_H
 
+#include <inet/endpoint.h>
 #include <sys/types.h>
 #include "tcp_type.h"
@@ -42 +43 @@
  * User calls
  */
-extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_t *, acpass_t,
+extern tcp_error_t tcp_uc_open(inet_ep2_t *, acpass_t,
     tcp_open_flags_t, tcp_conn_t **);
 extern tcp_error_t tcp_uc_send(tcp_conn_t *, void *, size_t, xflags_t);
@@ -50 +51 @@
 extern void tcp_uc_status(tcp_conn_t *, tcp_conn_status_t *);
 extern void tcp_uc_delete(tcp_conn_t *);
-extern void tcp_uc_set_cstate_cb(tcp_conn_t *, tcp_cstate_cb_t, void *);
+extern void tcp_uc_set_cb(tcp_conn_t *, tcp_cb_t *, void *);
+extern void *tcp_uc_get_userptr(tcp_conn_t *);
 
 /*
  * Arriving segments
  */
-extern void tcp_as_segment_arrived(tcp_sockpair_t *, tcp_segment_t *);
+extern void tcp_as_segment_arrived(inet_ep2_t *, tcp_segment_t *);
 
 /*

uspace/srv/net/udp/Makefile

@@ -28 +28 @@
 
 USPACE_PREFIX = ../../..
-LIBS = $(LIBNET_PREFIX)/libnet.a
-EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
+
+LIBS = \
+        $(LIBNETTL_PREFIX)/libnettl.a
+
+EXTRA_CFLAGS += \
+        -I$(LIBNETTL_PREFIX)/include
+
 BINARY = udp
 
@@ -35 +40 @@
         assoc.c \
         msg.c \
-        sock.c \
         pdu.c \
-        ucall.c \
+        service.c \
         udp.c \
         udp_inet.c

uspace/srv/net/udp/assoc.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 
 #include <adt/list.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <fibril_synch.h>
+#include <inet/endpoint.h>
 #include <io/log.h>
+#include <nettl/amap.h>
 #include <stdlib.h>
 
@@ -44 +47 @@
 #include "msg.h"
 #include "pdu.h"
-#include "ucall.h"
 #include "udp_inet.h"
 #include "udp_type.h"
 
-LIST_INITIALIZE(assoc_list);
-FIBRIL_MUTEX_INITIALIZE(assoc_list_lock);
-
-static udp_assoc_t *udp_assoc_find_ref(udp_sockpair_t *);
-static int udp_assoc_queue_msg(udp_assoc_t *, udp_sockpair_t *, udp_msg_t *);
-static bool udp_socket_match(udp_sock_t *, udp_sock_t *);
-static bool udp_sockpair_match(udp_sockpair_t *, udp_sockpair_t *);
+static LIST_INITIALIZE(assoc_list);
+static FIBRIL_MUTEX_INITIALIZE(assoc_list_lock);
+static amap_t *amap;
+
+static udp_assoc_t *udp_assoc_find_ref(inet_ep2_t *);
+static int udp_assoc_queue_msg(udp_assoc_t *, inet_ep2_t *, udp_msg_t *);
+
+/** Initialize associations. */
+int udp_assocs_init(void)
+{
+        int rc;
+
+        rc = amap_create(&amap);
+        if (rc != EOK) {
+                assert(rc == ENOMEM);
+                return ENOMEM;
+        }
+
+        return EOK;
+}
 
 /** Create new association structure.
  *
- * @param lsock         Local socket (will be deeply copied)
- * @param fsock         Foreign socket (will be deeply copied)
+ * @param epp           Endpoint pair (will be copied)
+ * @param cb            Callbacks
+ * @param cb_arg        Callback argument
  * @return              New association or NULL
  */
-udp_assoc_t *udp_assoc_new(udp_sock_t *lsock, udp_sock_t *fsock)
+udp_assoc_t *udp_assoc_new(inet_ep2_t *epp, udp_assoc_cb_t *cb, void *cb_arg)
 {
         udp_assoc_t *assoc = NULL;
@@ -80 +96 @@
         fibril_condvar_initialize(&assoc->rcv_queue_cv);
 
-        if (lsock != NULL)
-                assoc->ident.local = *lsock;
-        
-        if (fsock != NULL)
-                assoc->ident.foreign = *fsock;
-
+        if (epp != NULL)
+                assoc->ident = *epp;
+
+        assoc->cb = cb;
+        assoc->cb_arg = cb_arg;
         return assoc;
 error:
@@ -166 +181 @@
  * Add association to the association map.
  */
-void udp_assoc_add(udp_assoc_t *assoc)
-{
+int udp_assoc_add(udp_assoc_t *assoc)
+{
+        inet_ep2_t aepp;
+        int rc;
+
         udp_assoc_addref(assoc);
         fibril_mutex_lock(&assoc_list_lock);
+
+        rc = amap_insert(amap, &assoc->ident, assoc, af_allow_system, &aepp);
+        if (rc != EOK) {
+                udp_assoc_delref(assoc);
+                fibril_mutex_unlock(&assoc_list_lock);
+                return rc;
+        }
+
+        assoc->ident = aepp;
         list_append(&assoc->link, &assoc_list);
         fibril_mutex_unlock(&assoc_list_lock);
+
+        return EOK;
 }
 
@@ -181 +210 @@
 {
         fibril_mutex_lock(&assoc_list_lock);
+        amap_remove(amap, &assoc->ident);
         list_remove(&assoc->link);
         fibril_mutex_unlock(&assoc_list_lock);
@@ -196 +226 @@
             assoc, iplink);
         fibril_mutex_lock(&assoc->lock);
-        assoc->ident.iplink = iplink;
+        assoc->ident.local_link = iplink;
         fibril_mutex_unlock(&assoc->lock);
 }
 
-/** Set foreign socket in association.
- *
- * @param assoc         Association
- * @param fsock         Foreign socket (deeply copied)
- */
-void udp_assoc_set_foreign(udp_assoc_t *assoc, udp_sock_t *fsock)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_foreign(%p, %p)", assoc, fsock);
-        fibril_mutex_lock(&assoc->lock);
-        assoc->ident.foreign = *fsock;
-        fibril_mutex_unlock(&assoc->lock);
-}
-
-/** Set local socket in association.
- *
- * @param assoc Association
- * @param lsock Local socket (deeply copied)
- *
- */
-void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %p)", assoc, lsock);
-        fibril_mutex_lock(&assoc->lock);
-        assoc->ident.local = *lsock;
-        fibril_mutex_unlock(&assoc->lock);
-}
-
-/** Set local port in association.
- *
- * @param assoc Association
- * @param lport Local port
- *
- */
-void udp_assoc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %" PRIu16 ")", assoc, lport);
-        fibril_mutex_lock(&assoc->lock);
-        assoc->ident.local.port = lport;
-        fibril_mutex_unlock(&assoc->lock);
-}
-
 /** Send message to association.
  *
  * @param assoc         Association
- * @param fsock         Foreign socket or NULL not to override @a assoc
+ * @param remote        Remote endpoint or NULL not to override @a assoc
  * @param msg           Message
  *
  * @return              EOK on success
- *                      EINVAL if foreign socket is not set
+ *                      EINVAL if remote endpoint is not set
  *                      ENOMEM if out of resources
  *                      EIO if no route to destination exists
  */
-int udp_assoc_send(udp_assoc_t *assoc, udp_sock_t *fsock, udp_msg_t *msg)
+int udp_assoc_send(udp_assoc_t *assoc, inet_ep_t *remote, udp_msg_t *msg)
 {
         udp_pdu_t *pdu;
-        udp_sockpair_t sp;
+        inet_ep2_t epp;
         int rc;
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send(%p, %p, %p)",
-            assoc, fsock, msg);
-
-        /* @a fsock can be used to override the foreign socket */
-        sp = assoc->ident;
-        if (fsock != NULL)
-                sp.foreign = *fsock;
-
-        if ((inet_addr_is_any(&sp.foreign.addr)) ||
-            (sp.foreign.port == UDP_PORT_ANY))
+            assoc, remote, msg);
+
+        /* @a remote can be used to override the remote endpoint */
+        epp = assoc->ident;
+        if (remote != NULL)
+                epp.remote = *remote;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send - check addr any");
+
+        if ((inet_addr_is_any(&epp.remote.addr)) ||
+            (epp.remote.port == inet_port_any))
                 return EINVAL;
 
-        rc = udp_pdu_encode(&sp, msg, &pdu);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send - check version");
+
+        if (epp.remote.addr.version != epp.local.addr.version)
+                return EINVAL;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send - encode pdu");
+
+        rc = udp_pdu_encode(&epp, msg, &pdu);
         if (rc != EOK)
                 return ENOMEM;
 
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send - transmit");
+
         rc = udp_transmit_pdu(pdu);
         udp_pdu_delete(pdu);
@@ -280 +280 @@
                 return EIO;
 
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_send - success");
         return EOK;
 }
@@ -287 +288 @@
  * Pull one message from the association's receive queue.
  */
-int udp_assoc_recv(udp_assoc_t *assoc, udp_msg_t **msg, udp_sock_t *fsock)
+int udp_assoc_recv(udp_assoc_t *assoc, udp_msg_t **msg, inet_ep_t *remote)
 {
         link_t *link;
@@ -303 +304 @@
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_recv() - association was reset");
                 fibril_mutex_unlock(&assoc->lock);
-                return ECONNABORTED;
+                return ENXIO;
         }
 
@@ -313 +314 @@
 
         *msg = rqe->msg;
-        *fsock = rqe->sp.foreign;
+        *remote = rqe->epp.remote;
         free(rqe);
 
@@ -323 +324 @@
  * Find the association to which the message belongs and queue it.
  */
-void udp_assoc_received(udp_sockpair_t *rsp, udp_msg_t *msg)
+void udp_assoc_received(inet_ep2_t *repp, udp_msg_t *msg)
 {
         udp_assoc_t *assoc;
         int rc;
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", rsp, msg);
-
-        assoc = udp_assoc_find_ref(rsp);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_received(%p, %p)", repp, msg);
+
+        assoc = udp_assoc_find_ref(repp);
         if (assoc == NULL) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "No association found. Message dropped.");
@@ -339 +340 @@
         }
 
-        rc = udp_assoc_queue_msg(assoc, rsp, msg);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped.");
+        if (0) {
+                rc = udp_assoc_queue_msg(assoc, repp, msg);
+                if (rc != EOK) {
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Out of memory. Message dropped.");
                 /* XXX Generate ICMP error? */
-        }
+                }
+        }
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "call assoc->cb->recv_msg");
+        assoc->cb->recv_msg(assoc->cb_arg, repp, msg);
+        udp_assoc_delref(assoc);
 }
 
@@ -359 +366 @@
 }
 
-static int udp_assoc_queue_msg(udp_assoc_t *assoc, udp_sockpair_t *sp,
+static int udp_assoc_queue_msg(udp_assoc_t *assoc, inet_ep2_t *epp,
     udp_msg_t *msg)
 {
@@ -365 +372 @@
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_queue_msg(%p, %p, %p)",
-            assoc, sp, msg);
+            assoc, epp, msg);
 
         rqe = calloc(1, sizeof(udp_rcv_queue_entry_t));
@@ -372 +379 @@
 
         link_initialize(&rqe->link);
-        rqe->sp = *sp;
+        rqe->epp = *epp;
         rqe->msg = msg;
 
@@ -384 +391 @@
 }
 
-/** Match socket with pattern. */
-static bool udp_socket_match(udp_sock_t *sock, udp_sock_t *patt)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG,
-            "udp_socket_match(sock=(%u), pat=(%u))", sock->port, patt->port);
-        
-        if ((!inet_addr_is_any(&patt->addr)) &&
-            (!inet_addr_compare(&patt->addr, &sock->addr)))
-                return false;
-        
-        if ((patt->port != UDP_PORT_ANY) &&
-            (patt->port != sock->port))
-                return false;
-        
-        log_msg(LOG_DEFAULT, LVL_DEBUG, " -> match");
-        
-        return true;
-}
-
-/** Match socket pair with pattern. */
-static bool udp_sockpair_match(udp_sockpair_t *sp, udp_sockpair_t *pattern)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sockpair_match(%p, %p)", sp, pattern);
-
-        if (!udp_socket_match(&sp->local, &pattern->local))
-                return false;
-
-        if (!udp_socket_match(&sp->foreign, &pattern->foreign))
-                return false;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Socket pair matched.");
-        return true;
-}
-
-
-/** Find association structure for specified socket pair.
- *
- * An association is uniquely identified by a socket pair. Look up our
- * association map and return association structure based on socket pair.
+/** Find association structure for specified endpoint pair.
+ *
+ * An association is uniquely identified by an endpoint pair. Look up our
+ * association map and return association structure based on endpoint pair.
  * The association reference count is bumped by one.
  *
- * @param sp    Socket pair
+ * @param epp   Endpoint pair
  * @return      Association structure or NULL if not found.
  */
-static udp_assoc_t *udp_assoc_find_ref(udp_sockpair_t *sp)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", sp);
-        
+static udp_assoc_t *udp_assoc_find_ref(inet_ep2_t *epp)
+{
+        int rc;
+        void *arg;
+        udp_assoc_t *assoc;
+
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_find_ref(%p)", epp);
         fibril_mutex_lock(&assoc_list_lock);
-        
-        list_foreach(assoc_list, link, udp_assoc_t, assoc) {
-                udp_sockpair_t *asp = &assoc->ident;
-                
-                /* Skip unbound associations */
-                if (asp->local.port == UDP_PORT_ANY)
-                        continue;
-                
-                if (udp_sockpair_match(sp, asp)) {
-                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Returning assoc %p", assoc);
-                        udp_assoc_addref(assoc);
-                        fibril_mutex_unlock(&assoc_list_lock);
-                        return assoc;
-                }
-        }
-        
+
+        rc = amap_find_match(amap, epp, &arg);
+        if (rc != EOK) {
+                assert(rc == ENOMEM);
+                fibril_mutex_unlock(&assoc_list_lock);
+                return NULL;
+        }
+
+        assoc = (udp_assoc_t *)arg;
+        udp_assoc_addref(assoc);
+
         fibril_mutex_unlock(&assoc_list_lock);
-        return NULL;
+        return assoc;
 }
 

uspace/srv/net/udp/assoc.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define ASSOC_H
 
+#include <inet/endpoint.h>
 #include <ipc/loc.h>
 #include <sys/types.h>
 #include "udp_type.h"
 
-extern udp_assoc_t *udp_assoc_new(udp_sock_t *, udp_sock_t *);
+extern int udp_assocs_init(void);
+extern udp_assoc_t *udp_assoc_new(inet_ep2_t *, udp_assoc_cb_t *, void *);
 extern void udp_assoc_delete(udp_assoc_t *);
-extern void udp_assoc_add(udp_assoc_t *);
+extern int udp_assoc_add(udp_assoc_t *);
 extern void udp_assoc_remove(udp_assoc_t *);
 extern void udp_assoc_addref(udp_assoc_t *);
 extern void udp_assoc_delref(udp_assoc_t *);
 extern void udp_assoc_set_iplink(udp_assoc_t *, service_id_t);
-extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
-extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
-extern void udp_assoc_set_local_port(udp_assoc_t *, uint16_t);
-extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
-extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);
-extern void udp_assoc_received(udp_sockpair_t *, udp_msg_t *);
+extern int udp_assoc_send(udp_assoc_t *, inet_ep_t *, udp_msg_t *);
+extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, inet_ep_t *);
+extern void udp_assoc_received(inet_ep2_t *, udp_msg_t *);
 extern void udp_assoc_reset(udp_assoc_t *);
 

uspace/srv/net/udp/msg.c

@@ -50 +50 @@
 void udp_msg_delete(udp_msg_t *msg)
 {
+        free(msg->data);
         free(msg);
 }

uspace/srv/net/udp/pdu.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <stdlib.h>
 #include <inet/addr.h>
-#include <net/socket_codes.h>
 #include "msg.h"
 #include "pdu.h"
@@ -163 +162 @@
 
 /** Decode incoming PDU */
-int udp_pdu_decode(udp_pdu_t *pdu, udp_sockpair_t *sp, udp_msg_t **msg)
+int udp_pdu_decode(udp_pdu_t *pdu, inet_ep2_t *epp, udp_msg_t **msg)
 {
         udp_msg_t *nmsg;
@@ -180 +179 @@
         hdr = (udp_header_t *)pdu->data;
 
-        sp->foreign.port = uint16_t_be2host(hdr->src_port);
-        sp->foreign.addr = pdu->src;
-        sp->local.port = uint16_t_be2host(hdr->dest_port);
-        sp->local.addr = pdu->dest;
+        epp->local_link = pdu->iplink;
+        epp->remote.port = uint16_t_be2host(hdr->src_port);
+        epp->remote.addr = pdu->src;
+        epp->local.port = uint16_t_be2host(hdr->dest_port);
+        epp->local.addr = pdu->dest;
 
         length = uint16_t_be2host(hdr->length);
@@ -197 +197 @@
                 return ENOMEM;
 
-        nmsg->data = text;
         nmsg->data_size = length - sizeof(udp_header_t);
+        nmsg->data = malloc(nmsg->data_size);
+        if (nmsg->data == NULL)
+                return ENOMEM;
+
+        memcpy(nmsg->data, text, nmsg->data_size);
 
         *msg = nmsg;
@@ -205 +209 @@
 
 /** Encode outgoing PDU */
-int udp_pdu_encode(udp_sockpair_t *sp, udp_msg_t *msg, udp_pdu_t **pdu)
+int udp_pdu_encode(inet_ep2_t *epp, udp_msg_t *msg, udp_pdu_t **pdu)
 {
         udp_pdu_t *npdu;
@@ -215 +219 @@
                 return ENOMEM;
 
-        npdu->iplink = sp->iplink;
-        npdu->src = sp->local.addr;
-        npdu->dest = sp->foreign.addr;
+        npdu->iplink = epp->local_link;
+        npdu->src = epp->local.addr;
+        npdu->dest = epp->remote.addr;
 
         npdu->data_size = sizeof(udp_header_t) + msg->data_size;
@@ -227 +231 @@
 
         hdr = (udp_header_t *)npdu->data;
-        hdr->src_port = host2uint16_t_be(sp->local.port);
-        hdr->dest_port = host2uint16_t_be(sp->foreign.port);
+        hdr->src_port = host2uint16_t_be(epp->local.port);
+        hdr->dest_port = host2uint16_t_be(epp->remote.port);
         hdr->length = host2uint16_t_be(npdu->data_size);
         hdr->checksum = 0;

uspace/srv/net/udp/pdu.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define PDU_H
 
+#include <inet/endpoint.h>
 #include <sys/types.h>
 #include "std.h"
@@ -42 +43 @@
 extern udp_pdu_t *udp_pdu_new(void);
 extern void udp_pdu_delete(udp_pdu_t *);
-extern int udp_pdu_decode(udp_pdu_t *, udp_sockpair_t *, udp_msg_t **);
-extern int udp_pdu_encode(udp_sockpair_t *, udp_msg_t *, udp_pdu_t **);
+extern int udp_pdu_decode(udp_pdu_t *, inet_ep2_t *, udp_msg_t **);
+extern int udp_pdu_encode(inet_ep2_t *, udp_msg_t *, udp_pdu_t **);
 
 #endif

uspace/srv/net/udp/service.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -30 +30 @@
  * @{
  */
-/** @file Socket provider
+/** @file HelenOS service implementation
  */
 
-#ifndef SOCK_H
-#define SOCK_H
+#ifndef SERVICE_H
+#define SERVICE_H
 
-#include <async.h>
-
-extern int udp_sock_init(void);
+extern int udp_service_init(void);
 
 #endif

uspace/srv/net/udp/udp.c

@@ -41 +41 @@
 #include <task.h>
 
+#include "assoc.h"
+#include "service.h"
 #include "udp_inet.h"
-#include "sock.h"
 
 #define NAME       "udp"
@@ -52 +53 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_init()");
 
+        rc = udp_assocs_init();
+        if (rc != EOK) {
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing associations.");
+                return ENOMEM;
+        }
+
         rc = udp_inet_init();
         if (rc != EOK) {
@@ -58 +65 @@
         }
 
-        rc = udp_sock_init();
+        rc = udp_service_init();
         if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing socket service.");
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing UDP service.");
                 return ENOENT;
         }

uspace/srv/net/udp/udp_inet.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -64 +64 @@
 
         pdu = udp_pdu_new();
+        pdu->iplink = dgram->iplink;
         pdu->data = dgram->data;
         pdu->data_size = dgram->size;
@@ -105 +106 @@
 {
         udp_msg_t *dmsg;
-        udp_sockpair_t rident;
+        inet_ep2_t rident;
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_received_pdu()");

uspace/srv/net/udp/udp_type.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2015 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #define UDP_TYPE_H
 
+#include <async.h>
 #include <fibril.h>
 #include <fibril_synch.h>
+#include <inet/endpoint.h>
 #include <ipc/loc.h>
-#include <socket_core.h>
 #include <sys/types.h>
 #include <inet/addr.h>
@@ -49 +50 @@
         /* Insufficient resources */
         UDP_ENORES,
-        /* Foreign socket unspecified */
+        /* Remote endpoint unspecified */
         UDP_EUNSPEC,
         /* No route to destination */
@@ -60 +61 @@
         XF_DUMMY = 0x1
 } xflags_t;
-
-enum udp_port {
-        UDP_PORT_ANY = 0
-};
-
-typedef struct {
-        inet_addr_t addr;
-        uint16_t port;
-} udp_sock_t;
-
-typedef struct {
-        service_id_t iplink;
-        udp_sock_t local;
-        udp_sock_t foreign;
-} udp_sockpair_t;
 
 /** Unencoded UDP message (datagram) */
@@ -99 +85 @@
 
 typedef struct {
-        async_sess_t *sess;
-        socket_cores_t sockets;
-} udp_client_t;
+        void (*recv_msg)(void *, inet_ep2_t *, udp_msg_t *);
+} udp_assoc_cb_t;
 
 /** UDP association
@@ -107 +92 @@
  * This is a rough equivalent of a TCP connection endpoint. It allows
  * sending and receiving UDP datagrams and it is uniquely identified
- * by a socket pair.
+ * by an endpoint pair.
  */
 typedef struct {
@@ -113 +98 @@
         link_t link;
 
-        /** Association identification (local and foreign socket) */
-        udp_sockpair_t ident;
+        /** Association identification (endpoint pair) */
+        inet_ep2_t ident;
 
         /** True if association was reset by user */
@@ -131 +116 @@
         /** Receive queue CV. Broadcast when new datagram is inserted */
         fibril_condvar_t rcv_queue_cv;
+
+        udp_assoc_cb_t *cb;
+        void *cb_arg;
 } udp_assoc_t;
 
@@ -136 +124 @@
 } udp_assoc_status_t;
 
-typedef struct udp_sockdata {
-        /** Lock */
-        fibril_mutex_t lock;
-        /** Socket core */
-        socket_core_t *sock_core;
+typedef struct {
+        /** Link to receive queue */
+        link_t link;
+        /** Endpoint pair */
+        inet_ep2_t epp;
+        /** Message */
+        udp_msg_t *msg;
+} udp_rcv_queue_entry_t;
+
+typedef struct udp_cassoc {
+        /** Association */
+        udp_assoc_t *assoc;
+        /** Association ID for the client */
+        sysarg_t id;
         /** Client */
-        udp_client_t *client;
-        /** Connection */
-        udp_assoc_t *assoc;
-        /** User-configured IP link */
-        service_id_t iplink;
-        /** Receiving fibril */
-        fid_t recv_fibril;
-        uint8_t recv_buffer[UDP_FRAGMENT_SIZE];
-        size_t recv_buffer_used;
-        udp_sock_t recv_fsock;
-        fibril_mutex_t recv_buffer_lock;
-        fibril_condvar_t recv_buffer_cv;
-        udp_error_t recv_error;
-} udp_sockdata_t;
+        struct udp_client *client;
+        link_t lclient;
+} udp_cassoc_t;
 
 typedef struct {
         /** Link to receive queue */
         link_t link;
-        /** Socket pair */
-        udp_sockpair_t sp;
+        /** Endpoint pair */
+        inet_ep2_t epp;
         /** Message */
         udp_msg_t *msg;
-} udp_rcv_queue_entry_t;
+        /** Client association */
+        udp_cassoc_t *cassoc;
+} udp_crcv_queue_entry_t;
+
+typedef struct udp_client {
+        /** Client callback session */
+        async_sess_t *sess;
+        /** Client assocations */
+        list_t cassoc; /* of udp_cassoc_t */
+        /** Client receive queue */
+        list_t crcv_queue;
+} udp_client_t;
 
 #endif