Index: uspace/srv/net/tl/tcp/conn.c
===================================================================
--- uspace/srv/net/tl/tcp/conn.c	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/conn.c	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -56,4 +56,5 @@
 
 LIST_INITIALIZE(conn_list);
+FIBRIL_MUTEX_INITIALIZE(conn_list_lock);
 
 static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg);
@@ -61,9 +62,9 @@
 static void tcp_conn_tw_timer_clear(tcp_conn_t *conn);
 
-/** Create new segment structure.
+/** Create new connection structure.
  *
  * @param lsock		Local socket (will be deeply copied)
  * @param fsock		Foreign socket (will be deeply copied)
- * @return		New segment or NULL
+ * @return		New connection or NULL
  */
 tcp_conn_t *tcp_conn_new(tcp_sock_t *lsock, tcp_sock_t *fsock)
@@ -81,6 +82,10 @@
 		goto error;
 
+	fibril_mutex_initialize(&conn->lock);
+
+	/* One for the user, one for not being in closed state */
+	atomic_set(&conn->refcnt, 2);
+
 	/* Allocate receive buffer */
-	fibril_mutex_initialize(&conn->rcv_buf_lock);
 	fibril_condvar_initialize(&conn->rcv_buf_cv);
 	conn->rcv_buf_size = RCV_BUF_SIZE;
@@ -93,4 +98,5 @@
 
 	/** Allocate send buffer */
+	fibril_condvar_initialize(&conn->snd_buf_cv);
 	conn->snd_buf_size = SND_BUF_SIZE;
 	conn->snd_buf_used = 0;
@@ -113,9 +119,9 @@
 
 	/* Connection state change signalling */
-	fibril_mutex_initialize(&conn->cstate_lock);
 	fibril_condvar_initialize(&conn->cstate_cv);
 
 	conn->cstate = st_listen;
 	conn->reset = false;
+	conn->deleted = false;
 	conn->ap = ap_passive;
 	conn->fin_is_acked = false;
@@ -141,4 +147,72 @@
 }
 
+/** Destroy connection structure.
+ *
+ * Connection structure should be destroyed when the folowing condtitions
+ * are met:
+ * (1) user has deleted the connection
+ * (2) the connection has entered closed state
+ * (3) nobody is holding references to the connection
+ *
+ * This happens when @a conn->refcnt is zero as we count (1) and (2)
+ * as special references.
+ *
+ * @param conn		Connection
+ */
+static void tcp_conn_free(tcp_conn_t *conn)
+{
+	log_msg(LVL_DEBUG, "%s: tcp_conn_free(%p)", conn->name, conn);
+	tcp_tqueue_fini(&conn->retransmit);
+
+	if (conn->rcv_buf != NULL)
+		free(conn->rcv_buf);
+	if (conn->snd_buf != NULL)
+		free(conn->snd_buf);
+	if (conn->tw_timer != NULL)
+		fibril_timer_destroy(conn->tw_timer);
+	free(conn);
+}
+
+/** Add reference to connection.
+ *
+ * Increase connection reference count by one.
+ *
+ * @param conn		Connection
+ */
+void tcp_conn_addref(tcp_conn_t *conn)
+{
+	log_msg(LVL_DEBUG, "%s: tcp_conn_addref(%p)", conn->name, conn);
+	atomic_inc(&conn->refcnt);
+}
+
+/** Remove reference from connection.
+ *
+ * Decrease connection reference count by one.
+ *
+ * @param conn		Connection
+ */
+void tcp_conn_delref(tcp_conn_t *conn)
+{
+	log_msg(LVL_DEBUG, "%s: tcp_conn_delref(%p)", conn->name, conn);
+
+	if (atomic_predec(&conn->refcnt) == 0)
+		tcp_conn_free(conn);
+}
+
+/** Delete connection.
+ *
+ * The caller promises not make no further references to @a conn.
+ * TCP will free @a conn eventually.
+ *
+ * @param conn		Connection
+ */
+void tcp_conn_delete(tcp_conn_t *conn)
+{
+	log_msg(LVL_DEBUG, "%s: tcp_conn_delete(%p)", conn->name, conn);
+
+	assert(conn->deleted == false);
+	tcp_conn_delref(conn);
+}
+
 /** Enlist connection.
  *
@@ -147,5 +221,8 @@
 void tcp_conn_add(tcp_conn_t *conn)
 {
+	tcp_conn_addref(conn);
+	fibril_mutex_lock(&conn_list_lock);
 	list_append(&conn->link, &conn_list);
+	fibril_mutex_unlock(&conn_list_lock);
 }
 
@@ -156,13 +233,23 @@
 void tcp_conn_remove(tcp_conn_t *conn)
 {
+	fibril_mutex_lock(&conn_list_lock);
 	list_remove(&conn->link);
+	fibril_mutex_unlock(&conn_list_lock);
+	tcp_conn_delref(conn);
 }
 
 static void tcp_conn_state_set(tcp_conn_t *conn, tcp_cstate_t nstate)
 {
-	fibril_mutex_lock(&conn->cstate_lock);
+	tcp_cstate_t old_state;
+
+	old_state = conn->cstate;
 	conn->cstate = nstate;
 	fibril_condvar_broadcast(&conn->cstate_cv);
-	fibril_mutex_unlock(&conn->cstate_lock);
+
+	assert(old_state != st_closed);
+	if (nstate == st_closed) {
+		/* Drop one reference for now being in closed state */
+		tcp_conn_delref(conn);
+	}
 }
 
@@ -251,11 +338,14 @@
  * A connection is uniquely identified by a socket pair. Look up our
  * connection map and return connection structure based on socket pair.
+ * The connection reference count is bumped by one.
  *
  * @param sp	Socket pair
  * @return	Connection structure or NULL if not found.
  */
-tcp_conn_t *tcp_conn_find(tcp_sockpair_t *sp)
+tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
 {
 	log_msg(LVL_DEBUG, "tcp_conn_find(%p)", sp);
+
+	fibril_mutex_lock(&conn_list_lock);
 
 	list_foreach(conn_list, link) {
@@ -266,8 +356,11 @@
 		    csp->local.addr.ipv4, csp->local.port);
 		if (tcp_sockpair_match(sp, csp)) {
+			tcp_conn_addref(conn);
+			fibril_mutex_unlock(&conn_list_lock);
 			return conn;
 		}
 	}
 
+	fibril_mutex_unlock(&conn_list_lock);
 	return NULL;
 }
@@ -287,4 +380,5 @@
 
 	fibril_condvar_broadcast(&conn->rcv_buf_cv);
+	fibril_condvar_broadcast(&conn->snd_buf_cv);
 }
 
@@ -858,6 +952,4 @@
 	tcp_conn_trim_seg_to_wnd(conn, seg);
 
-	fibril_mutex_lock(&conn->rcv_buf_lock);
-
 	/* Determine how many bytes to copy */
 	text_size = tcp_segment_text_size(seg);
@@ -871,5 +963,4 @@
 	/* Signal to the receive function that new data has arrived */
 	fibril_condvar_broadcast(&conn->rcv_buf_cv);
-	fibril_mutex_unlock(&conn->rcv_buf_lock);
 
 	log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size);
@@ -961,8 +1052,6 @@
 
 		/* Add FIN to the receive buffer */
-		fibril_mutex_lock(&conn->rcv_buf_lock);
 		conn->rcv_buf_fin = true;
 		fibril_condvar_broadcast(&conn->rcv_buf_cv);
-		fibril_mutex_unlock(&conn->rcv_buf_lock);
 
 		tcp_segment_delete(seg);
@@ -1073,6 +1162,10 @@
 	log_msg(LVL_DEBUG, "tw_timeout_func(%p)", conn);
 
+	fibril_mutex_lock(&conn->lock);
+
 	if (conn->cstate == st_closed) {
 		log_msg(LVL_DEBUG, "Connection already closed.");
+		fibril_mutex_unlock(&conn->lock);
+		tcp_conn_delref(conn);
 		return;
 	}
@@ -1081,4 +1174,7 @@
 	tcp_conn_remove(conn);
 	tcp_conn_state_set(conn, st_closed);
+
+	fibril_mutex_unlock(&conn->lock);
+	tcp_conn_delref(conn);
 }
 
@@ -1089,4 +1185,5 @@
 void tcp_conn_tw_timer_set(tcp_conn_t *conn)
 {
+	tcp_conn_addref(conn);
 	fibril_timer_set(conn->tw_timer, TIME_WAIT_TIMEOUT, tw_timeout_func,
 	    (void *)conn);
@@ -1099,5 +1196,6 @@
 void tcp_conn_tw_timer_clear(tcp_conn_t *conn)
 {
-	fibril_timer_clear(conn->tw_timer);
+	if (fibril_timer_clear(conn->tw_timer) == fts_active)
+		tcp_conn_delref(conn);
 }
 
Index: uspace/srv/net/tl/tcp/conn.h
===================================================================
--- uspace/srv/net/tl/tcp/conn.h	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/conn.h	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -40,4 +40,5 @@
 
 extern tcp_conn_t *tcp_conn_new(tcp_sock_t *, tcp_sock_t *);
+extern void tcp_conn_delete(tcp_conn_t *);
 extern void tcp_conn_add(tcp_conn_t *);
 extern void tcp_conn_remove(tcp_conn_t *);
@@ -45,5 +46,7 @@
 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(tcp_sockpair_t *);
+extern tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *);
+extern void tcp_conn_addref(tcp_conn_t *);
+extern void tcp_conn_delref(tcp_conn_t *);
 extern bool tcp_conn_got_syn(tcp_conn_t *);
 extern void tcp_conn_segment_arrived(tcp_conn_t *, tcp_segment_t *);
Index: uspace/srv/net/tl/tcp/sock.c
===================================================================
--- uspace/srv/net/tl/tcp/sock.c	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/sock.c	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -603,15 +603,20 @@
 
 	socket = (tcp_sockdata_t *)sock_core->specific_data;
-	rc = tcp_uc_close(socket->conn);
-	if (rc != EOK) {
-		async_answer_0(callid, rc);
-		return;
-	}
-
-	/* Drain incoming data. This should really be done in the background. */
-	do {
-		trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE,
-		    &data_len, &xflags);
-	} while (trc == TCP_EOK);
+
+	if (socket->conn != NULL) {
+		trc = tcp_uc_close(socket->conn);
+		if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
+			async_answer_0(callid, EBADF);
+			return;
+		}
+
+		/* Drain incoming data. This should really be done in the background. */
+		do {
+			trc = tcp_uc_receive(socket->conn, buffer,
+			    FRAGMENT_SIZE, &data_len, &xflags);
+		} while (trc == TCP_EOK);
+
+		tcp_uc_delete(socket->conn);
+	}
 
 	rc = socket_destroy(net_sess, socket_id, &client->sockets, &gsock,
Index: uspace/srv/net/tl/tcp/tcp_type.h
===================================================================
--- uspace/srv/net/tl/tcp/tcp_type.h	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/tcp_type.h	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -162,10 +162,15 @@
 	acpass_t ap;
 
+	/** Protects access to connection structure */
+	fibril_mutex_t lock;
+	/** Reference count */
+	atomic_t refcnt;
+
 	/** Connection state */
 	tcp_cstate_t cstate;
 	/** True if connection was reset */
 	bool reset;
-	/** Protects @c cstate */
-	fibril_mutex_t cstate_lock;
+	/** True if connection was deleted by user */
+	bool deleted;
 	/** Signalled when @c cstate changes */
 	fibril_condvar_t cstate_cv;
@@ -191,6 +196,4 @@
 	/** Receive buffer contains FIN */
 	bool rcv_buf_fin;
-	/** Receive buffer lock */
-	fibril_mutex_t rcv_buf_lock;
 	/** Receive buffer CV. Broadcast when new data is inserted */
 	fibril_condvar_t rcv_buf_cv;
@@ -204,4 +207,6 @@
 	/** Send buffer contains FIN */
 	bool snd_buf_fin;
+	/** Send buffer CV. Broadcast when space is made available in buffer */
+	fibril_condvar_t snd_buf_cv;
 
 	/** Send unacknowledged */
Index: uspace/srv/net/tl/tcp/tqueue.c
===================================================================
--- uspace/srv/net/tl/tcp/tqueue.c	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/tqueue.c	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -188,5 +188,4 @@
 		/* We are sending out FIN */
 		ctrl = CTL_FIN;
-		tcp_conn_fin_sent(conn);
 	} else {
 		ctrl = 0;
@@ -206,4 +205,9 @@
 	if (send_fin)
 		conn->snd_buf_fin = false;
+
+	fibril_condvar_broadcast(&conn->snd_buf_cv);
+
+	if (send_fin)
+		tcp_conn_fin_sent(conn);
 
 	tcp_tqueue_seg(conn, seg);
@@ -313,6 +317,10 @@
 	log_msg(LVL_DEBUG, "### %s: retransmit_timeout_func(%p)", conn->name, conn);
 
+	fibril_mutex_lock(&conn->lock);
+
 	if (conn->cstate == st_closed) {
 		log_msg(LVL_DEBUG, "Connection already closed.");
+		fibril_mutex_unlock(&conn->lock);
+		tcp_conn_delref(conn);
 		return;
 	}
@@ -321,4 +329,6 @@
 	if (link == NULL) {
 		log_msg(LVL_DEBUG, "Nothing to retransmit");
+		fibril_mutex_unlock(&conn->lock);
+		tcp_conn_delref(conn);
 		return;
 	}
@@ -329,4 +339,6 @@
 	if (rt_seg == NULL) {
 		log_msg(LVL_ERROR, "Memory allocation failed.");
+		fibril_mutex_unlock(&conn->lock);
+		tcp_conn_delref(conn);
 		/* XXX Handle properly */
 		return;
@@ -338,4 +350,7 @@
 	/* Reset retransmission timer */
 	tcp_tqueue_timer_set(tqe->conn);
+
+	fibril_mutex_unlock(&conn->lock);
+	tcp_conn_delref(conn);
 }
 
@@ -345,5 +360,8 @@
 	log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name);
 
-	(void) retransmit_timeout_func;
+	/* Clear first to make sure we update refcnt correctly */
+	tcp_tqueue_timer_clear(conn);
+
+	tcp_conn_addref(conn);
 	fibril_timer_set(conn->retransmit.timer, RETRANSMIT_TIMEOUT,
 	    retransmit_timeout_func, (void *) conn);
@@ -355,5 +373,6 @@
 	log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name);
 
-	fibril_timer_clear(conn->retransmit.timer);
+	if (fibril_timer_clear(conn->retransmit.timer) == fts_active)
+		tcp_conn_delref(conn);
 }
 
Index: uspace/srv/net/tl/tcp/ucall.c
===================================================================
--- uspace/srv/net/tl/tcp/ucall.c	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/ucall.c	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -83,9 +83,9 @@
 	/* Wait for connection to be established or reset */
 	log_msg(LVL_DEBUG, "tcp_uc_open: Wait for connection.");
-	fibril_mutex_lock(&nconn->cstate_lock);
+	fibril_mutex_lock(&nconn->lock);
 	while (nconn->cstate == st_listen ||
 	    nconn->cstate == st_syn_sent ||
 	    nconn->cstate == st_syn_received) {
-		fibril_condvar_wait(&nconn->cstate_cv, &nconn->cstate_lock);
+		fibril_condvar_wait(&nconn->cstate_cv, &nconn->lock);
 	}
 
@@ -93,9 +93,9 @@
 		log_msg(LVL_DEBUG, "tcp_uc_open: Connection was reset.");
 		assert(nconn->cstate == st_closed);
-		fibril_mutex_unlock(&nconn->cstate_lock);
+		fibril_mutex_unlock(&nconn->lock);
 		return TCP_ERESET;
 	}
 
-	fibril_mutex_unlock(&nconn->cstate_lock);
+	fibril_mutex_unlock(&nconn->lock);
 	log_msg(LVL_DEBUG, "tcp_uc_open: Connection was established.");
 
@@ -113,6 +113,10 @@
 	log_msg(LVL_DEBUG, "%s: tcp_uc_send()", conn->name);
 
-	if (conn->cstate == st_closed)
+	fibril_mutex_lock(&conn->lock);
+
+	if (conn->cstate == st_closed) {
+		fibril_mutex_unlock(&conn->lock);
 		return TCP_ENOTEXIST;
+	}
 
 	if (conn->cstate == st_listen) {
@@ -121,14 +125,23 @@
 	}
 
-	if (conn->snd_buf_fin)
+
+	if (conn->snd_buf_fin) {
+		fibril_mutex_unlock(&conn->lock);
 		return TCP_ECLOSING;
+	}
 
 	while (size > 0) {
 		buf_free = conn->snd_buf_size - conn->snd_buf_used;
-		while (buf_free == 0 && !conn->reset)
-			tcp_tqueue_new_data(conn);
-
-		if (conn->reset)
+		while (buf_free == 0 && !conn->reset) {
+			log_msg(LVL_DEBUG, "%s: buf_free == 0, waiting.",
+			    conn->name);
+			fibril_condvar_wait(&conn->snd_buf_cv, &conn->lock);
+			buf_free = conn->snd_buf_size - conn->snd_buf_used;
+		}
+
+		if (conn->reset) {
+			fibril_mutex_unlock(&conn->lock);
 			return TCP_ERESET;
+		}
 
 		xfer_size = min(size, buf_free);
@@ -139,7 +152,10 @@
 		conn->snd_buf_used += xfer_size;
 		size -= xfer_size;
+
+		tcp_tqueue_new_data(conn);
 	}
 
 	tcp_tqueue_new_data(conn);
+	fibril_mutex_unlock(&conn->lock);
 
 	return TCP_EOK;
@@ -154,18 +170,18 @@
 	log_msg(LVL_DEBUG, "%s: tcp_uc_receive()", conn->name);
 
-	if (conn->cstate == st_closed)
+	fibril_mutex_lock(&conn->lock);
+
+	if (conn->cstate == st_closed) {
+		fibril_mutex_unlock(&conn->lock);
 		return TCP_ENOTEXIST;
-
-	fibril_mutex_lock(&conn->rcv_buf_lock);
+	}
 
 	/* Wait for data to become available */
 	while (conn->rcv_buf_used == 0 && !conn->rcv_buf_fin && !conn->reset) {
 		log_msg(LVL_DEBUG, "tcp_uc_receive() - wait for data");
-		fibril_condvar_wait(&conn->rcv_buf_cv, &conn->rcv_buf_lock);
+		fibril_condvar_wait(&conn->rcv_buf_cv, &conn->lock);
 	}
 
 	if (conn->rcv_buf_used == 0) {
-		fibril_mutex_unlock(&conn->rcv_buf_lock);
-
 		*rcvd = 0;
 		*xflags = 0;
@@ -173,8 +189,10 @@
 		if (conn->rcv_buf_fin) {
 			/* End of data, peer closed connection */
+			fibril_mutex_unlock(&conn->lock);
 			return TCP_ECLOSING;
 		} else {
 			/* Connection was reset */
 			assert(conn->reset);
+			fibril_mutex_unlock(&conn->lock);
 			return TCP_ERESET;
 		}
@@ -192,6 +210,4 @@
 	conn->rcv_wnd += xfer_size;
 
-	fibril_mutex_unlock(&conn->rcv_buf_lock);
-
 	/* TODO */
 	*xflags = 0;
@@ -203,4 +219,6 @@
 	    conn->name, xfer_size);
 
+	fibril_mutex_unlock(&conn->lock);
+
 	return TCP_EOK;
 }
@@ -211,13 +229,20 @@
 	log_msg(LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
 
-	if (conn->cstate == st_closed)
+	fibril_mutex_lock(&conn->lock);
+
+	if (conn->cstate == st_closed) {
+		fibril_mutex_unlock(&conn->lock);
 		return TCP_ENOTEXIST;
-
-	if (conn->snd_buf_fin)
+	}
+
+	if (conn->snd_buf_fin) {
+		fibril_mutex_unlock(&conn->lock);
 		return TCP_ECLOSING;
+	}
 
 	conn->snd_buf_fin = true;
 	tcp_tqueue_new_data(conn);
 
+	fibril_mutex_unlock(&conn->lock);
 	return TCP_EOK;
 }
@@ -235,4 +260,15 @@
 }
 
+/** Delete connection user call.
+ *
+ * (Not in spec.) Inform TCP that the user is done with this connection
+ * and will not make any further calls/references to it. TCP can deallocate
+ * the connection from now on.
+ */
+void tcp_uc_delete(tcp_conn_t *conn)
+{
+	log_msg(LVL_DEBUG, "tcp_uc_delete()");
+	tcp_conn_delete(conn);
+}
 
 /*
@@ -249,21 +285,32 @@
 	    sp->local.addr.ipv4, sp->local.port);
 
-	conn = tcp_conn_find(sp);
-	if (conn != NULL && conn->cstate != st_closed) {
-		if (conn->ident.foreign.addr.ipv4 == TCP_IPV4_ANY)
-			conn->ident.foreign.addr.ipv4 = sp->foreign.addr.ipv4;
-		if (conn->ident.foreign.port == TCP_PORT_ANY)
-			conn->ident.foreign.port = sp->foreign.port;
-		if (conn->ident.local.addr.ipv4 == TCP_IPV4_ANY)
-			conn->ident.local.addr.ipv4 = sp->local.addr.ipv4;
-
-		tcp_conn_segment_arrived(conn, seg);
-	} else {
-		if (conn == NULL)
-			log_msg(LVL_WARN, "No connection found.");
-		else
-			log_msg(LVL_WARN, "Connection is closed.");
+	conn = tcp_conn_find_ref(sp);
+	if (conn == NULL) {
+		log_msg(LVL_WARN, "No connection found.");
 		tcp_unexpected_segment(sp, seg);
-	}
+		return;
+	}
+
+	fibril_mutex_lock(&conn->lock);
+
+	if (conn->cstate == st_closed) {
+		log_msg(LVL_WARN, "Connection is closed.");
+		tcp_unexpected_segment(sp, seg);
+		fibril_mutex_unlock(&conn->lock);
+		tcp_conn_delref(conn);
+		return;
+	}
+
+	if (conn->ident.foreign.addr.ipv4 == TCP_IPV4_ANY)
+		conn->ident.foreign.addr.ipv4 = sp->foreign.addr.ipv4;
+	if (conn->ident.foreign.port == TCP_PORT_ANY)
+		conn->ident.foreign.port = sp->foreign.port;
+	if (conn->ident.local.addr.ipv4 == TCP_IPV4_ANY)
+		conn->ident.local.addr.ipv4 = sp->local.addr.ipv4;
+
+	tcp_conn_segment_arrived(conn, seg);
+
+	fibril_mutex_unlock(&conn->lock);
+	tcp_conn_delref(conn);
 }
 
Index: uspace/srv/net/tl/tcp/ucall.h
===================================================================
--- uspace/srv/net/tl/tcp/ucall.h	(revision 58f6229bb7083e2b5e220b8659cb3f600db5c217)
+++ uspace/srv/net/tl/tcp/ucall.h	(revision d9cf684a06c89943fd883b794b0b10a3a95d4bd9)
@@ -48,4 +48,5 @@
 extern void tcp_uc_abort(tcp_conn_t *);
 extern void tcp_uc_status(tcp_conn_t *, tcp_conn_status_t *);
+extern void tcp_uc_delete(tcp_conn_t *);
 
 /*