Index: uspace/srv/tcp/Makefile =================================================================== --- uspace/srv/tcp/Makefile (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/Makefile (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,48 @@ +# +# Copyright (c) 2011 Jiri Svoboda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +USPACE_PREFIX = ../../../.. +LIBS = $(LIBNET_PREFIX)/libnet.a +EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include +BINARY = tcp + +SOURCES = \ + conn.c \ + iqueue.c \ + ncsim.c \ + pdu.c \ + rqueue.c \ + segment.c \ + seq_no.c \ + sock.c \ + tcp.c \ + test.c \ + tqueue.c \ + ucall.c + +include $(USPACE_PREFIX)/Makefile.common Index: uspace/srv/tcp/conn.c =================================================================== --- uspace/srv/tcp/conn.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/conn.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,1282 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file TCP connection processing and state machine + */ + +#include +#include +#include +#include +#include +#include +#include "conn.h" +#include "iqueue.h" +#include "segment.h" +#include "seq_no.h" +#include "tcp_type.h" +#include "tqueue.h" +#include "ucall.h" + +#define RCV_BUF_SIZE 4096/*2*/ +#define SND_BUF_SIZE 4096 + +#define MAX_SEGMENT_LIFETIME (15*1000*1000) //(2*60*1000*1000) +#define TIME_WAIT_TIMEOUT (2*MAX_SEGMENT_LIFETIME) + +LIST_INITIALIZE(conn_list); +FIBRIL_MUTEX_INITIALIZE(conn_list_lock); + +static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg); +static void tcp_conn_tw_timer_set(tcp_conn_t *conn); +static void tcp_conn_tw_timer_clear(tcp_conn_t *conn); + +/** Create new connection structure. + * + * @param lsock Local socket (will be deeply copied) + * @param fsock Foreign socket (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 *conn = NULL; + bool tqueue_inited = false; + + /* Allocate connection structure */ + conn = calloc(1, sizeof(tcp_conn_t)); + if (conn == NULL) + goto error; + + conn->tw_timer = fibril_timer_create(); + if (conn->tw_timer == NULL) + 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_condvar_initialize(&conn->rcv_buf_cv); + conn->rcv_buf_size = RCV_BUF_SIZE; + conn->rcv_buf_used = 0; + conn->rcv_buf_fin = false; + + conn->rcv_buf = calloc(1, conn->rcv_buf_size); + if (conn->rcv_buf == NULL) + goto error; + + /** Allocate send buffer */ + fibril_condvar_initialize(&conn->snd_buf_cv); + conn->snd_buf_size = SND_BUF_SIZE; + conn->snd_buf_used = 0; + conn->snd_buf_fin = false; + conn->snd_buf = calloc(1, conn->snd_buf_size); + if (conn->snd_buf == NULL) + goto error; + + /* Set up receive window. */ + conn->rcv_wnd = conn->rcv_buf_size; + + /* Initialize incoming segment queue */ + tcp_iqueue_init(&conn->incoming, conn); + + /* Initialize retransmission queue */ + if (tcp_tqueue_init(&conn->retransmit, conn) != EOK) + goto error; + + tqueue_inited = true; + + /* Connection state change signalling */ + fibril_condvar_initialize(&conn->cstate_cv); + + conn->cstate_cb = NULL; + + conn->cstate = st_listen; + conn->reset = false; + conn->deleted = false; + conn->ap = ap_passive; + conn->fin_is_acked = false; + conn->ident.local = *lsock; + if (fsock != NULL) + conn->ident.foreign = *fsock; + + return conn; + +error: + if (tqueue_inited) + tcp_tqueue_fini(&conn->retransmit); + if (conn != NULL && conn->rcv_buf != NULL) + free(conn->rcv_buf); + if (conn != NULL && conn->snd_buf != NULL) + free(conn->snd_buf); + if (conn != NULL && conn->tw_timer != NULL) + fibril_timer_destroy(conn->tw_timer); + if (conn != NULL) + free(conn); + + return NULL; +} + +/** 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. + * + * Add connection to the connection map. + */ +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); +} + +/** Delist connection. + * + * Remove connection from the connection map. + */ +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) +{ + tcp_cstate_t old_state; + + log_msg(LVL_DEBUG, "tcp_conn_state_set(%p)", conn); + + old_state = conn->cstate; + conn->cstate = nstate; + fibril_condvar_broadcast(&conn->cstate_cv); + + /* Run user callback function */ + if (conn->cstate_cb != NULL) { + log_msg(LVL_DEBUG, "tcp_conn_state_set() - run user CB"); + conn->cstate_cb(conn, conn->cstate_cb_arg); + } else { + log_msg(LVL_DEBUG, "tcp_conn_state_set() - no user CB"); + } + + assert(old_state != st_closed); + if (nstate == st_closed) { + /* Drop one reference for now being in closed state */ + tcp_conn_delref(conn); + } +} + +/** Synchronize connection. + * + * This is the first step of an active connection attempt, + * sends out SYN and sets up ISS and SND.xxx. + */ +void tcp_conn_sync(tcp_conn_t *conn) +{ + /* XXX select ISS */ + conn->iss = 1; + conn->snd_nxt = conn->iss; + conn->snd_una = conn->iss; + conn->ap = ap_active; + + tcp_tqueue_ctrl_seg(conn, CTL_SYN); + tcp_conn_state_set(conn, st_syn_sent); +} + +/** FIN has been sent. + * + * This function should be called when FIN is sent over the connection, + * as a result the connection state is changed appropriately. + */ +void tcp_conn_fin_sent(tcp_conn_t *conn) +{ + switch (conn->cstate) { + case st_syn_received: + case st_established: + log_msg(LVL_DEBUG, "%s: FIN sent -> Fin-Wait-1", conn->name); + tcp_conn_state_set(conn, st_fin_wait_1); + break; + case st_close_wait: + log_msg(LVL_DEBUG, "%s: FIN sent -> Last-Ack", conn->name); + tcp_conn_state_set(conn, st_last_ack); + break; + default: + log_msg(LVL_ERROR, "%s: Connection state %d", conn->name, + conn->cstate); + assert(false); + } + + conn->fin_is_acked = false; +} + +/** Compare two sockets. + * + * Two sockets are equal if the address is equal and the port number + * is equal. + */ +static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt) +{ + log_msg(LVL_DEBUG, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))", + sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port); + + if (patt->addr.ipv4 != TCP_IPV4_ANY && + patt->addr.ipv4 != sock->addr.ipv4) + return false; + + if (patt->port != TCP_PORT_ANY && + patt->port != sock->port) + return false; + + log_msg(LVL_DEBUG, " -> match"); + + return true; +} + +/** Match socket with pattern. */ +static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern) +{ + log_msg(LVL_DEBUG, "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. + * 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_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) { + tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link); + tcp_sockpair_t *csp = &conn->ident; + log_msg(LVL_DEBUG, "compare with conn (f:(%x,%u), l:(%x,%u))", + csp->foreign.addr.ipv4, csp->foreign.port, + 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; +} + +/** Reset connection. + * + * @param conn Connection + */ +static void tcp_conn_reset(tcp_conn_t *conn) +{ + log_msg(LVL_DEBUG, "%s: tcp_conn_reset()", conn->name); + tcp_conn_state_set(conn, st_closed); + conn->reset = true; + + tcp_conn_tw_timer_clear(conn); + tcp_tqueue_clear(&conn->retransmit); + + fibril_condvar_broadcast(&conn->rcv_buf_cv); + fibril_condvar_broadcast(&conn->snd_buf_cv); +} + +/** Signal to the user that connection has been reset. + * + * Send an out-of-band signal to the user. + */ +static void tcp_reset_signal(tcp_conn_t *conn) +{ + /* TODO */ + log_msg(LVL_DEBUG, "%s: tcp_reset_signal()", conn->name); +} + +/** Determine if SYN has been received. + * + * @param conn Connection + * @return @c true if SYN has been received, @c false otherwise. + */ +bool tcp_conn_got_syn(tcp_conn_t *conn) +{ + switch (conn->cstate) { + case st_listen: + case st_syn_sent: + return false; + case st_syn_received: + case st_established: + case st_fin_wait_1: + case st_fin_wait_2: + case st_close_wait: + case st_closing: + case st_last_ack: + case st_time_wait: + return true; + case st_closed: + log_msg(LVL_WARN, "state=%d", (int) conn->cstate); + assert(false); + } + + assert(false); +} + +/** Segment arrived in Listen state. + * + * @param conn Connection + * @param seg Segment + */ +static void tcp_conn_sa_listen(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_conn_sa_listen(%p, %p)", conn, seg); + + if ((seg->ctrl & CTL_RST) != 0) { + log_msg(LVL_DEBUG, "Ignoring incoming RST."); + return; + } + + if ((seg->ctrl & CTL_ACK) != 0) { + log_msg(LVL_DEBUG, "Incoming ACK, send acceptable RST."); + tcp_reply_rst(&conn->ident, seg); + return; + } + + if ((seg->ctrl & CTL_SYN) == 0) { + log_msg(LVL_DEBUG, "SYN not present. Ignoring segment."); + return; + } + + log_msg(LVL_DEBUG, "Got SYN, sending SYN, ACK."); + + conn->rcv_nxt = seg->seq + 1; + conn->irs = seg->seq; + + + log_msg(LVL_DEBUG, "rcv_nxt=%u", conn->rcv_nxt); + + if (seg->len > 1) + log_msg(LVL_WARN, "SYN combined with data, ignoring data."); + + /* XXX select ISS */ + conn->iss = 1; + conn->snd_nxt = conn->iss; + conn->snd_una = conn->iss; + + /* + * Surprisingly the spec does not deal with initial window setting. + * Set SND.WND = SEG.WND and set SND.WL1 so that next segment + * will always be accepted as new window setting. + */ + conn->snd_wnd = seg->wnd; + conn->snd_wl1 = seg->seq; + conn->snd_wl2 = seg->seq; + + tcp_conn_state_set(conn, st_syn_received); + + tcp_tqueue_ctrl_seg(conn, CTL_SYN | CTL_ACK /* XXX */); + + tcp_segment_delete(seg); +} + +/** Segment arrived in Syn-Sent state. + * + * @param conn Connection + * @param seg Segment + */ +static void tcp_conn_sa_syn_sent(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_conn_sa_syn_sent(%p, %p)", conn, seg); + + if ((seg->ctrl & CTL_ACK) != 0) { + log_msg(LVL_DEBUG, "snd_una=%u, seg.ack=%u, snd_nxt=%u", + conn->snd_una, seg->ack, conn->snd_nxt); + if (!seq_no_ack_acceptable(conn, seg->ack)) { + if ((seg->ctrl & CTL_RST) == 0) { + log_msg(LVL_WARN, "ACK not acceptable, send RST"); + tcp_reply_rst(&conn->ident, seg); + } else { + log_msg(LVL_WARN, "RST,ACK not acceptable, drop"); + } + return; + } + } + + if ((seg->ctrl & CTL_RST) != 0) { + /* If we get here, we have either an acceptable ACK or no ACK */ + if ((seg->ctrl & CTL_ACK) != 0) { + log_msg(LVL_DEBUG, "%s: Connection reset. -> Closed", + conn->name); + /* Reset connection */ + tcp_conn_reset(conn); + return; + } else { + log_msg(LVL_DEBUG, "%s: RST without ACK, drop", + conn->name); + return; + } + } + + /* XXX precedence */ + + if ((seg->ctrl & CTL_SYN) == 0) { + log_msg(LVL_DEBUG, "No SYN bit, ignoring segment."); + return; + } + + conn->rcv_nxt = seg->seq + 1; + conn->irs = seg->seq; + + if ((seg->ctrl & CTL_ACK) != 0) { + conn->snd_una = seg->ack; + + /* + * Prune acked segments from retransmission queue and + * possibly transmit more data. + */ + tcp_tqueue_ack_received(conn); + } + + log_msg(LVL_DEBUG, "Sent SYN, got SYN."); + + /* + * Surprisingly the spec does not deal with initial window setting. + * Set SND.WND = SEG.WND and set SND.WL1 so that next segment + * will always be accepted as new window setting. + */ + log_msg(LVL_DEBUG, "SND.WND := %" PRIu32 ", SND.WL1 := %" PRIu32 ", " + "SND.WL2 = %" PRIu32, seg->wnd, seg->seq, seg->seq); + conn->snd_wnd = seg->wnd; + conn->snd_wl1 = seg->seq; + conn->snd_wl2 = seg->seq; + + if (seq_no_syn_acked(conn)) { + log_msg(LVL_DEBUG, "%s: syn acked -> Established", conn->name); + tcp_conn_state_set(conn, st_established); + tcp_tqueue_ctrl_seg(conn, CTL_ACK /* XXX */); + } else { + log_msg(LVL_DEBUG, "%s: syn not acked -> Syn-Received", + conn->name); + tcp_conn_state_set(conn, st_syn_received); + tcp_tqueue_ctrl_seg(conn, CTL_SYN | CTL_ACK /* XXX */); + } + + tcp_segment_delete(seg); +} + +/** Segment arrived in state where segments are processed in sequence order. + * + * Queue segment in incoming segments queue for processing. + * + * @param conn Connection + * @param seg Segment + */ +static void tcp_conn_sa_queue(tcp_conn_t *conn, tcp_segment_t *seg) +{ + tcp_segment_t *pseg; + + log_msg(LVL_DEBUG, "tcp_conn_sa_seq(%p, %p)", conn, seg); + + /* Discard unacceptable segments ("old duplicates") */ + if (!seq_no_segment_acceptable(conn, seg)) { + log_msg(LVL_DEBUG, "Replying ACK to unacceptable segment."); + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + tcp_segment_delete(seg); + return; + } + + /* Queue for processing */ + tcp_iqueue_insert_seg(&conn->incoming, seg); + + /* + * Process all segments from incoming queue that are ready. + * Unacceptable segments are discarded by tcp_iqueue_get_ready_seg(). + * + * XXX Need to return ACK for unacceptable segments + */ + while (tcp_iqueue_get_ready_seg(&conn->incoming, &pseg) == EOK) + tcp_conn_seg_process(conn, pseg); +} + +/** Process segment RST field. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_rst(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if ((seg->ctrl & CTL_RST) == 0) + return cp_continue; + + switch (conn->cstate) { + case st_syn_received: + /* XXX In case of passive open, revert to Listen state */ + if (conn->ap == ap_passive) { + tcp_conn_state_set(conn, st_listen); + /* XXX Revert conn->ident */ + tcp_conn_tw_timer_clear(conn); + tcp_tqueue_clear(&conn->retransmit); + } else { + tcp_conn_reset(conn); + } + break; + case st_established: + case st_fin_wait_1: + case st_fin_wait_2: + case st_close_wait: + /* General "connection reset" signal */ + tcp_reset_signal(conn); + tcp_conn_reset(conn); + break; + case st_closing: + case st_last_ack: + case st_time_wait: + tcp_conn_reset(conn); + break; + case st_listen: + case st_syn_sent: + case st_closed: + assert(false); + } + + return cp_done; +} + +/** Process segment security and precedence fields. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_sp(tcp_conn_t *conn, tcp_segment_t *seg) +{ + /* TODO */ + return cp_continue; +} + +/** Process segment SYN field. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_syn(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if ((seg->ctrl & CTL_SYN) == 0) + return cp_continue; + + /* + * Assert SYN is in receive window, otherwise this step should not + * be reached. + */ + assert(seq_no_in_rcv_wnd(conn, seg->seq)); + + log_msg(LVL_WARN, "SYN is in receive window, should send reset. XXX"); + + /* + * TODO + * + * Send a reset, resond "reset" to all outstanding RECEIVEs and SEND, + * flush segment queues. Send unsolicited "connection reset" signal + * to user, connection -> closed state, delete TCB, return. + */ + return cp_done; +} + +/** Process segment ACK field in Syn-Received state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_sr(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if (!seq_no_ack_acceptable(conn, seg->ack)) { + /* ACK is not acceptable, send RST. */ + log_msg(LVL_WARN, "Segment ACK not acceptable, sending RST."); + tcp_reply_rst(&conn->ident, seg); + tcp_segment_delete(seg); + return cp_done; + } + + log_msg(LVL_DEBUG, "%s: SYN ACKed -> Established", conn->name); + + tcp_conn_state_set(conn, st_established); + + /* XXX Not mentioned in spec?! */ + conn->snd_una = seg->ack; + + return cp_continue; +} + +/** Process segment ACK field in Established state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_est(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_conn_seg_proc_ack_est(%p, %p)", conn, seg); + + log_msg(LVL_DEBUG, "SEG.ACK=%u, SND.UNA=%u, SND.NXT=%u", + (unsigned)seg->ack, (unsigned)conn->snd_una, + (unsigned)conn->snd_nxt); + + if (!seq_no_ack_acceptable(conn, seg->ack)) { + log_msg(LVL_DEBUG, "ACK not acceptable."); + if (!seq_no_ack_duplicate(conn, seg->ack)) { + log_msg(LVL_WARN, "Not acceptable, not duplicate. " + "Send ACK and drop."); + /* Not acceptable, not duplicate. Send ACK and drop. */ + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + tcp_segment_delete(seg); + return cp_done; + } else { + log_msg(LVL_DEBUG, "Ignoring duplicate ACK."); + } + } else { + /* Update SND.UNA */ + conn->snd_una = seg->ack; + } + + if (seq_no_new_wnd_update(conn, seg)) { + conn->snd_wnd = seg->wnd; + conn->snd_wl1 = seg->seq; + conn->snd_wl2 = seg->ack; + + log_msg(LVL_DEBUG, "Updating send window, SND.WND=%" PRIu32 + ", SND.WL1=%" PRIu32 ", SND.WL2=%" PRIu32, + conn->snd_wnd, conn->snd_wl1, conn->snd_wl2); + } + + /* + * Prune acked segments from retransmission queue and + * possibly transmit more data. + */ + tcp_tqueue_ack_received(conn); + + return cp_continue; +} + +/** Process segment ACK field in Fin-Wait-1 state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_fw1(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if (tcp_conn_seg_proc_ack_est(conn, seg) == cp_done) + return cp_done; + + if (conn->fin_is_acked) { + log_msg(LVL_DEBUG, "%s: FIN acked -> Fin-Wait-2", conn->name); + tcp_conn_state_set(conn, st_fin_wait_2); + } + + return cp_continue; +} + +/** Process segment ACK field in Fin-Wait-2 state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_fw2(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if (tcp_conn_seg_proc_ack_est(conn, seg) == cp_done) + return cp_done; + + /* TODO */ + return cp_continue; +} + +/** Process segment ACK field in Close-Wait state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_cw(tcp_conn_t *conn, tcp_segment_t *seg) +{ + /* The same processing as in Established state */ + return tcp_conn_seg_proc_ack_est(conn, seg); +} + +/** Process segment ACK field in Closing state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_cls(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if (tcp_conn_seg_proc_ack_est(conn, seg) == cp_done) + return cp_done; + + /* TODO */ + return cp_continue; +} + +/** Process segment ACK field in Last-Ack state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_la(tcp_conn_t *conn, tcp_segment_t *seg) +{ + if (tcp_conn_seg_proc_ack_est(conn, seg) == cp_done) + return cp_done; + + if (conn->fin_is_acked) { + log_msg(LVL_DEBUG, "%s: FIN acked -> Closed", conn->name); + tcp_conn_remove(conn); + tcp_conn_state_set(conn, st_closed); + return cp_done; + } + + return cp_continue; +} + +/** Process segment ACK field in Time-Wait state. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack_tw(tcp_conn_t *conn, tcp_segment_t *seg) +{ + /* Nothing to do */ + return cp_continue; +} + +/** Process segment ACK field. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_ack(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_ack(%p, %p)", + conn->name, conn, seg); + + if ((seg->ctrl & CTL_ACK) == 0) { + log_msg(LVL_WARN, "Segment has no ACK. Dropping."); + tcp_segment_delete(seg); + return cp_done; + } + + switch (conn->cstate) { + case st_syn_received: + return tcp_conn_seg_proc_ack_sr(conn, seg); + case st_established: + return tcp_conn_seg_proc_ack_est(conn, seg); + case st_fin_wait_1: + return tcp_conn_seg_proc_ack_fw1(conn, seg); + case st_fin_wait_2: + return tcp_conn_seg_proc_ack_fw2(conn, seg); + case st_close_wait: + return tcp_conn_seg_proc_ack_cw(conn, seg); + case st_closing: + return tcp_conn_seg_proc_ack_cls(conn, seg); + case st_last_ack: + return tcp_conn_seg_proc_ack_la(conn, seg); + case st_time_wait: + return tcp_conn_seg_proc_ack_tw(conn, seg); + case st_listen: + case st_syn_sent: + case st_closed: + assert(false); + } + + assert(false); +} + +/** Process segment URG field. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_urg(tcp_conn_t *conn, tcp_segment_t *seg) +{ + return cp_continue; +} + +/** Process segment text. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_text(tcp_conn_t *conn, tcp_segment_t *seg) +{ + size_t text_size; + size_t xfer_size; + + log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_text(%p, %p)", + conn->name, conn, seg); + + switch (conn->cstate) { + case st_established: + case st_fin_wait_1: + case st_fin_wait_2: + /* OK */ + break; + case st_close_wait: + case st_closing: + case st_last_ack: + case st_time_wait: + /* Invalid since FIN has been received. Ignore text. */ + return cp_continue; + case st_listen: + case st_syn_sent: + case st_syn_received: + case st_closed: + assert(false); + } + + /* + * Process segment text + */ + assert(seq_no_segment_ready(conn, seg)); + + /* Trim anything outside our receive window */ + tcp_conn_trim_seg_to_wnd(conn, seg); + + /* Determine how many bytes to copy */ + text_size = tcp_segment_text_size(seg); + xfer_size = min(text_size, conn->rcv_buf_size - conn->rcv_buf_used); + + /* Copy data to receive buffer */ + tcp_segment_text_copy(seg, conn->rcv_buf + conn->rcv_buf_used, + xfer_size); + conn->rcv_buf_used += xfer_size; + + /* Signal to the receive function that new data has arrived */ + fibril_condvar_broadcast(&conn->rcv_buf_cv); + + log_msg(LVL_DEBUG, "Received %zu bytes of data.", xfer_size); + + /* Advance RCV.NXT */ + conn->rcv_nxt += xfer_size; + + /* Update receive window. XXX Not an efficient strategy. */ + conn->rcv_wnd -= xfer_size; + + /* Send ACK */ + if (xfer_size > 0) + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + + if (xfer_size < seg->len) { + /* Trim part of segment which we just received */ + tcp_conn_trim_seg_to_wnd(conn, seg); + } else { + log_msg(LVL_DEBUG, "%s: Nothing left in segment, dropping " + "(xfer_size=%zu, SEG.LEN=%zu, seg->ctrl=%u)", + conn->name, xfer_size, seg->len, (unsigned)seg->ctrl); + /* Nothing left in segment */ + tcp_segment_delete(seg); + return cp_done; + } + + return cp_continue; +} + +/** Process segment FIN field. + * + * @param conn Connection + * @param seg Segment + * @return cp_done if we are done with this segment, cp_continue + * if not + */ +static cproc_t tcp_conn_seg_proc_fin(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "%s: tcp_conn_seg_proc_fin(%p, %p)", + conn->name, conn, seg); + log_msg(LVL_DEBUG, " seg->len=%zu, seg->ctl=%u", (size_t) seg->len, + (unsigned) seg->ctrl); + + /* Only process FIN if no text is left in segment. */ + if (tcp_segment_text_size(seg) == 0 && (seg->ctrl & CTL_FIN) != 0) { + log_msg(LVL_DEBUG, " - FIN found in segment."); + + /* Send ACK */ + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + + conn->rcv_nxt++; + conn->rcv_wnd--; + + /* Change connection state */ + switch (conn->cstate) { + case st_listen: + case st_syn_sent: + case st_closed: + /* Connection not synchronized */ + assert(false); + case st_syn_received: + case st_established: + log_msg(LVL_DEBUG, "%s: FIN received -> Close-Wait", + conn->name); + tcp_conn_state_set(conn, st_close_wait); + break; + case st_fin_wait_1: + log_msg(LVL_DEBUG, "%s: FIN received -> Closing", + conn->name); + tcp_conn_state_set(conn, st_closing); + break; + case st_fin_wait_2: + log_msg(LVL_DEBUG, "%s: FIN received -> Time-Wait", + conn->name); + tcp_conn_state_set(conn, st_time_wait); + /* Start the Time-Wait timer */ + tcp_conn_tw_timer_set(conn); + break; + case st_close_wait: + case st_closing: + case st_last_ack: + /* Do nothing */ + break; + case st_time_wait: + /* Restart the Time-Wait timer */ + tcp_conn_tw_timer_set(conn); + break; + } + + /* Add FIN to the receive buffer */ + conn->rcv_buf_fin = true; + fibril_condvar_broadcast(&conn->rcv_buf_cv); + + tcp_segment_delete(seg); + return cp_done; + } + + return cp_continue; +} + +/** Process incoming segment. + * + * We are in connection state where segments are processed in order + * of sequence number. This processes one segment taken from the + * connection incoming segments queue. + * + * @param conn Connection + * @param seg Segment + */ +static void tcp_conn_seg_process(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_conn_seg_process(%p, %p)", conn, seg); + tcp_segment_dump(seg); + + /* Check whether segment is acceptable */ + /* XXX Permit valid ACKs, URGs and RSTs */ +/* if (!seq_no_segment_acceptable(conn, seg)) { + log_msg(LVL_WARN, "Segment not acceptable, dropping."); + if ((seg->ctrl & CTL_RST) == 0) { + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + } + return; + } +*/ + + if (tcp_conn_seg_proc_rst(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_sp(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_syn(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_ack(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_urg(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_text(conn, seg) == cp_done) + return; + + if (tcp_conn_seg_proc_fin(conn, seg) == cp_done) + return; + + /* + * If anything is left from the segment, insert it back into the + * incoming segments queue. + */ + if (seg->len > 0) { + log_msg(LVL_DEBUG, "Re-insert segment %p. seg->len=%zu", + seg, (size_t) seg->len); + tcp_iqueue_insert_seg(&conn->incoming, seg); + } else { + tcp_segment_delete(seg); + } +} + +/** Segment arrived on a connection. + * + * @param conn Connection + * @param seg Segment + */ +void tcp_conn_segment_arrived(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "%c: tcp_conn_segment_arrived(%p)", + conn->name, seg); + + switch (conn->cstate) { + case st_listen: + tcp_conn_sa_listen(conn, seg); break; + case st_syn_sent: + tcp_conn_sa_syn_sent(conn, seg); break; + case st_syn_received: + case st_established: + case st_fin_wait_1: + case st_fin_wait_2: + case st_close_wait: + case st_closing: + case st_last_ack: + case st_time_wait: + /* Process segments in order of sequence number */ + tcp_conn_sa_queue(conn, seg); break; + case st_closed: + log_msg(LVL_DEBUG, "state=%d", (int) conn->cstate); + assert(false); + } +} + +/** Time-Wait timeout handler. + * + * @param arg Connection + */ +static void tw_timeout_func(void *arg) +{ + tcp_conn_t *conn = (tcp_conn_t *) arg; + + 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; + } + + log_msg(LVL_DEBUG, "%s: TW Timeout -> Closed", conn->name); + tcp_conn_remove(conn); + tcp_conn_state_set(conn, st_closed); + + fibril_mutex_unlock(&conn->lock); + tcp_conn_delref(conn); +} + +/** Start or restart the Time-Wait timeout. + * + * @param conn Connection + */ +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); +} + +/** Clear the Time-Wait timeout. + * + * @param conn Connection + */ +void tcp_conn_tw_timer_clear(tcp_conn_t *conn) +{ + if (fibril_timer_clear(conn->tw_timer) == fts_active) + tcp_conn_delref(conn); +} + +/** Trim segment to the receive window. + * + * @param conn Connection + * @param seg Segment + */ +void tcp_conn_trim_seg_to_wnd(tcp_conn_t *conn, tcp_segment_t *seg) +{ + uint32_t left, right; + + seq_no_seg_trim_calc(conn, seg, &left, &right); + tcp_segment_trim(seg, left, right); +} + +/** Handle unexpected segment received on a socket pair. + * + * We reply with an RST unless the received segment has RST. + * + * @param sp Socket pair which received the segment + * @param seg Unexpected segment + */ +void tcp_unexpected_segment(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_unexpected_segment(%p, %p)", sp, 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; +} + +/** Send RST in response to an incoming segment. + * + * @param sp Socket pair which received the segment + * @param seg Incoming segment + */ +void tcp_reply_rst(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + tcp_segment_t *rseg; + + log_msg(LVL_DEBUG, "tcp_reply_rst(%p, %p)", sp, seg); + + rseg = tcp_segment_make_rst(seg); + tcp_transmit_segment(sp, rseg); +} + +/** + * @} + */ Index: uspace/srv/tcp/conn.h =================================================================== --- uspace/srv/tcp/conn.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/conn.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP connection processing and state machine + */ + +#ifndef CONN_H +#define CONN_H + +#include +#include "tcp_type.h" + +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 *); +extern void tcp_conn_sync(tcp_conn_t *); +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 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 *); +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 *); + +#endif + +/** @} + */ Index: uspace/srv/tcp/iqueue.c =================================================================== --- uspace/srv/tcp/iqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/iqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Connection incoming segments queue + * + * Segments are sorted in order of their sequence number. + */ + +#include +#include +#include +#include +#include "iqueue.h" +#include "segment.h" +#include "seq_no.h" +#include "tcp_type.h" + +/** Initialize incoming segments queue. + * + * @param iqueue Incoming queue + * @param conn Connection the queue is associated with + */ +void tcp_iqueue_init(tcp_iqueue_t *iqueue, tcp_conn_t *conn) +{ + list_initialize(&iqueue->list); + iqueue->conn = conn; +} + +/** Insert segment into incoming queue. + * + * @param iqueue Incoming queue + * @param seg Segment + */ +void tcp_iqueue_insert_seg(tcp_iqueue_t *iqueue, tcp_segment_t *seg) +{ + tcp_iqueue_entry_t *iqe; + tcp_iqueue_entry_t *qe; + link_t *link; + log_msg(LVL_DEBUG, "tcp_iqueue_insert_seg()"); + + iqe = calloc(1, sizeof(tcp_iqueue_entry_t)); + if (iqe == NULL) { + log_msg(LVL_ERROR, "Failed allocating IQE."); + return; + } + + iqe->seg = seg; + + /* Sort by sequence number */ + + link = list_first(&iqueue->list); + while (link != NULL) { + qe = list_get_instance(link, + tcp_iqueue_entry_t, link); + + if (seq_no_seg_cmp(iqueue->conn, iqe->seg, qe->seg) >= 0) + break; + } + + if (link != NULL) + list_insert_before(&iqe->link, &qe->link); + else + list_append(&iqe->link, &iqueue->list); +} + +/** Get next ready segment from incoming queue. + * + * Return the segment with the earliest sequence number if it is ready. + * A segment is ready if its SEG.SEQ is earlier or equal to RCV.NXT. + * + * @param iqueue Incoming queue + * @param seg Place to store pointer to segment + * @return EOK on success, ENOENT if no segment is ready + */ +int tcp_iqueue_get_ready_seg(tcp_iqueue_t *iqueue, tcp_segment_t **seg) +{ + tcp_iqueue_entry_t *iqe; + link_t *link; + + log_msg(LVL_DEBUG, "tcp_get_ready_seg()"); + + link = list_first(&iqueue->list); + if (link == NULL) { + log_msg(LVL_DEBUG, "iqueue is empty"); + return ENOENT; + } + + iqe = list_get_instance(link, tcp_iqueue_entry_t, link); + + while (!seq_no_segment_acceptable(iqueue->conn, iqe->seg)) { + log_msg(LVL_DEBUG, "Skipping unacceptable segment (RCV.NXT=%" + PRIu32 ", RCV.NXT+RCV.WND=%" PRIu32 ", SEG.SEQ=%" PRIu32 + ", SEG.LEN=%" PRIu32 ")", iqueue->conn->rcv_nxt, + iqueue->conn->rcv_nxt + iqueue->conn->rcv_wnd, + iqe->seg->seq, iqe->seg->len); + + list_remove(&iqe->link); + tcp_segment_delete(iqe->seg); + + link = list_first(&iqueue->list); + if (link == NULL) { + log_msg(LVL_DEBUG, "iqueue is empty"); + return ENOENT; + } + + iqe = list_get_instance(link, tcp_iqueue_entry_t, link); + } + + /* Do not return segments that are not ready for processing */ + if (!seq_no_segment_ready(iqueue->conn, iqe->seg)) { + log_msg(LVL_DEBUG, "Next segment not ready: SEG.SEQ=%u, " + "RCV.NXT=%u, SEG.LEN=%u", iqe->seg->seq, + iqueue->conn->rcv_nxt, iqe->seg->len); + return ENOENT; + } + + log_msg(LVL_DEBUG, "Returning ready segment %p", iqe->seg); + list_remove(&iqe->link); + *seg = iqe->seg; + + return EOK; +} + +/** + * @} + */ Index: uspace/srv/tcp/iqueue.h =================================================================== --- uspace/srv/tcp/iqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/iqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Connection incoming segments queue + */ + +#ifndef IQUEUE_H +#define IQUEUE_H + +#include "tcp_type.h" + +extern void tcp_iqueue_init(tcp_iqueue_t *, tcp_conn_t *); +extern void tcp_iqueue_insert_seg(tcp_iqueue_t *, tcp_segment_t *); +extern int tcp_iqueue_get_ready_seg(tcp_iqueue_t *, tcp_segment_t **); + +#endif + +/** @} + */ Index: uspace/srv/tcp/ncsim.c =================================================================== --- uspace/srv/tcp/ncsim.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/ncsim.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Network condition simulator + * + * Simulate network conditions for testing the reliability implementation: + * - variable latency + * - frame drop + */ + +#include +#include +#include +#include +#include +#include +#include "conn.h" +#include "ncsim.h" +#include "rqueue.h" +#include "segment.h" +#include "tcp_type.h" + +static list_t sim_queue; +static fibril_mutex_t sim_queue_lock; +static fibril_condvar_t sim_queue_cv; + +/** Initialize segment receive queue. */ +void tcp_ncsim_init(void) +{ + list_initialize(&sim_queue); + fibril_mutex_initialize(&sim_queue_lock); + fibril_condvar_initialize(&sim_queue_cv); +} + +/** Bounce segment through simulator into receive queue. + * + * @param sp Socket pair, oriented for transmission + * @param seg Segment + */ +void tcp_ncsim_bounce_seg(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + tcp_squeue_entry_t *sqe; + tcp_squeue_entry_t *old_qe; + link_t *link; + + log_msg(LVL_DEBUG, "tcp_ncsim_bounce_seg()"); + tcp_rqueue_bounce_seg(sp, seg); + return; + + if (0 /*random() % 4 == 3*/) { + /* Drop segment */ + log_msg(LVL_ERROR, "NCSim dropping segment"); + tcp_segment_delete(seg); + return; + } + + sqe = calloc(1, sizeof(tcp_squeue_entry_t)); + if (sqe == NULL) { + log_msg(LVL_ERROR, "Failed allocating SQE."); + return; + } + + sqe->delay = random() % (1000 * 1000); + sqe->sp = *sp; + sqe->seg = seg; + + fibril_mutex_lock(&sim_queue_lock); + + link = list_first(&sim_queue); + while (link != NULL && sqe->delay > 0) { + old_qe = list_get_instance(link, tcp_squeue_entry_t, link); + if (sqe->delay < old_qe->delay) + break; + + sqe->delay -= old_qe->delay; + + link = link->next; + if (link == &sim_queue.head) + link = NULL; + } + + if (link != NULL) + list_insert_after(&sqe->link, link); + else + list_append(&sqe->link, &sim_queue); + + fibril_condvar_broadcast(&sim_queue_cv); + fibril_mutex_unlock(&sim_queue_lock); +} + +/** Network condition simulator handler thread. */ +static void tcp_ncsim_thread(void *arg) +{ + link_t *link; + tcp_squeue_entry_t *sqe; + int rc; + + log_msg(LVL_DEBUG, "tcp_ncsim_thread()"); + + + while (true) { + fibril_mutex_lock(&sim_queue_lock); + + while (list_empty(&sim_queue)) + fibril_condvar_wait(&sim_queue_cv, &sim_queue_lock); + + do { + link = list_first(&sim_queue); + sqe = list_get_instance(link, tcp_squeue_entry_t, link); + + log_msg(LVL_DEBUG, "NCSim - Sleep"); + rc = fibril_condvar_wait_timeout(&sim_queue_cv, + &sim_queue_lock, sqe->delay); + } while (rc != ETIMEOUT); + + list_remove(link); + fibril_mutex_unlock(&sim_queue_lock); + + log_msg(LVL_DEBUG, "NCSim - End Sleep"); + tcp_rqueue_bounce_seg(&sqe->sp, sqe->seg); + free(sqe); + } +} + +/** Start simulator handler thread. */ +void tcp_ncsim_thread_start(void) +{ + thread_id_t tid; + int rc; + + log_msg(LVL_DEBUG, "tcp_ncsim_thread_start()"); + + rc = thread_create(tcp_ncsim_thread, NULL, "ncsim", &tid); + if (rc != EOK) { + log_msg(LVL_ERROR, "Failed creating ncsim thread."); + return; + } +} + +/** + * @} + */ Index: uspace/srv/tcp/ncsim.h =================================================================== --- uspace/srv/tcp/ncsim.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/ncsim.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Network condition simulator + */ + +#ifndef NCSIM_H +#define NCSIM_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_thread_start(void); + + +#endif + +/** @} + */ Index: uspace/srv/tcp/pdu.c =================================================================== --- uspace/srv/tcp/pdu.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/pdu.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,314 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file TCP header encoding and decoding + */ + +#include +#include +#include +#include +#include +#include "pdu.h" +#include "segment.h" +#include "seq_no.h" +#include "std.h" +#include "tcp_type.h" + +#define TCP_CHECKSUM_INIT 0xffff + +/** One's complement addition. + * + * Result is a + b + carry. + */ +static uint16_t tcp_ocadd16(uint16_t a, uint16_t b) +{ + uint32_t s; + + s = (uint32_t)a + (uint32_t)b; + return (s & 0xffff) + (s >> 16); +} + +static uint16_t tcp_checksum_calc(uint16_t ivalue, void *data, size_t size) +{ + uint16_t sum; + uint16_t w; + size_t words, i; + uint8_t *bdata; + + sum = ~ivalue; + words = size / 2; + bdata = (uint8_t *)data; + + for (i = 0; i < words; i++) { + w = ((uint16_t)bdata[2*i] << 8) | bdata[2*i + 1]; + sum = tcp_ocadd16(sum, w); + } + + if (size % 2 != 0) { + w = ((uint16_t)bdata[2*words] << 8); + sum = tcp_ocadd16(sum, w); + } + + return ~sum; +} + +static void tcp_header_decode_flags(uint16_t doff_flags, tcp_control_t *rctl) +{ + tcp_control_t ctl; + + ctl = 0; + + if ((doff_flags & BIT_V(uint16_t, DF_URG)) != 0) + ctl |= 0 /* XXX */; + if ((doff_flags & BIT_V(uint16_t, DF_ACK)) != 0) + ctl |= CTL_ACK; + if ((doff_flags & BIT_V(uint16_t, DF_PSH)) != 0) + ctl |= 0 /* XXX */; + if ((doff_flags & BIT_V(uint16_t, DF_RST)) != 0) + ctl |= CTL_RST; + if ((doff_flags & BIT_V(uint16_t, DF_SYN)) != 0) + ctl |= CTL_SYN; + if ((doff_flags & BIT_V(uint16_t, DF_FIN)) != 0) + ctl |= CTL_FIN; + + *rctl = ctl; +} + +static void tcp_header_encode_flags(tcp_control_t ctl, uint16_t doff_flags0, + uint16_t *rdoff_flags) +{ + uint16_t doff_flags; + + doff_flags = doff_flags0; + + if ((ctl & CTL_ACK) != 0) + doff_flags |= BIT_V(uint16_t, DF_ACK); + if ((ctl & CTL_RST) != 0) + doff_flags |= BIT_V(uint16_t, DF_RST); + if ((ctl & CTL_SYN) != 0) + doff_flags |= BIT_V(uint16_t, DF_SYN); + if ((ctl & CTL_FIN) != 0) + doff_flags |= BIT_V(uint16_t, DF_FIN); + + *rdoff_flags = doff_flags; +} + +static void tcp_header_setup(tcp_sockpair_t *sp, 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->seq = host2uint32_t_be(seg->seq); + hdr->ack = host2uint32_t_be(seg->ack); + + doff = (sizeof(tcp_header_t) / sizeof(uint32_t)) << DF_DATA_OFFSET_l; + tcp_header_encode_flags(seg->ctrl, doff, &doff_flags); + + hdr->doff_flags = host2uint16_t_be(doff_flags); + hdr->window = host2uint16_t_be(seg->wnd); + hdr->checksum = 0; + hdr->urg_ptr = host2uint16_t_be(seg->up); +} + +static void tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr) +{ + phdr->src_addr = host2uint32_t_be(pdu->src_addr.ipv4); + phdr->dest_addr = host2uint32_t_be(pdu->dest_addr.ipv4); + phdr->zero = 0; + phdr->protocol = 6; /* XXX Magic number */ + phdr->tcp_length = host2uint16_t_be(pdu->header_size + pdu->text_size); +} + +static void tcp_header_decode(tcp_header_t *hdr, tcp_segment_t *seg) +{ + tcp_header_decode_flags(uint16_t_be2host(hdr->doff_flags), &seg->ctrl); + seg->seq = uint32_t_be2host(hdr->seq); + seg->ack = uint32_t_be2host(hdr->ack); + seg->wnd = uint16_t_be2host(hdr->window); + seg->up = uint16_t_be2host(hdr->urg_ptr); +} + +static int tcp_header_encode(tcp_sockpair_t *sp, tcp_segment_t *seg, + void **header, size_t *size) +{ + tcp_header_t *hdr; + + hdr = calloc(1, sizeof(tcp_header_t)); + if (hdr == NULL) + return ENOMEM; + + tcp_header_setup(sp, seg, hdr); + *header = hdr; + *size = sizeof(tcp_header_t); + + return EOK; +} + +static tcp_pdu_t *tcp_pdu_new(void) +{ + return calloc(1, sizeof(tcp_pdu_t)); +} + +/** Create PDU with the specified header and text data. + * + * Note that you still need to set addresses in the returned PDU. + * + * @param hdr Header data + * @param hdr_size Header size in bytes + * @param text Text data + * @param text_size Text size in bytes + * @return New PDU + */ +tcp_pdu_t *tcp_pdu_create(void *hdr, size_t hdr_size, void *text, + size_t text_size) +{ + tcp_pdu_t *pdu; + + pdu = tcp_pdu_new(); + if (pdu == NULL) + return NULL; + + pdu->header = malloc(hdr_size); + pdu->text = malloc(text_size); + if (pdu->header == NULL || pdu->text == NULL) + goto error; + + memcpy(pdu->header, hdr, hdr_size); + memcpy(pdu->text, text, text_size); + + pdu->header_size = hdr_size; + pdu->text_size = text_size; + + return pdu; + +error: + if (pdu->header != NULL) + free(pdu->header); + if (pdu->text != NULL) + free(pdu->text); + + return NULL; +} + +void tcp_pdu_delete(tcp_pdu_t *pdu) +{ + free(pdu->header); + free(pdu->text); + free(pdu); +} + +static uint16_t tcp_pdu_checksum_calc(tcp_pdu_t *pdu) +{ + uint16_t cs_phdr; + uint16_t cs_headers; + uint16_t cs_all; + tcp_phdr_t phdr; + + tcp_phdr_setup(pdu, &phdr); + cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *)&phdr, + sizeof(tcp_phdr_t)); + cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size); + cs_all = tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size); + + return cs_all; +} + +static void tcp_pdu_set_checksum(tcp_pdu_t *pdu, uint16_t checksum) +{ + tcp_header_t *hdr; + + hdr = (tcp_header_t *)pdu->header; + hdr->checksum = host2uint16_t_be(checksum); +} + +/** Encode outgoing PDU */ +int tcp_pdu_decode(tcp_pdu_t *pdu, tcp_sockpair_t *sp, tcp_segment_t **seg) +{ + tcp_segment_t *nseg; + tcp_header_t *hdr; + + nseg = tcp_segment_make_data(0, pdu->text, pdu->text_size); + if (nseg == NULL) + return ENOMEM; + + tcp_header_decode(pdu->header, nseg); + nseg->len += seq_no_control_len(nseg->ctrl); + + hdr = (tcp_header_t *)pdu->header; + + sp->local.port = uint16_t_be2host(hdr->dest_port); + sp->local.addr = pdu->dest_addr; + sp->foreign.port = uint16_t_be2host(hdr->src_port); + sp->foreign.addr = pdu->src_addr; + + *seg = nseg; + return EOK; +} + +/** Decode incoming PDU */ +int tcp_pdu_encode(tcp_sockpair_t *sp, tcp_segment_t *seg, tcp_pdu_t **pdu) +{ + tcp_pdu_t *npdu; + size_t text_size; + uint16_t checksum; + + npdu = tcp_pdu_new(); + if (npdu == NULL) + return ENOMEM; + + npdu->src_addr = sp->local.addr; + npdu->dest_addr = sp->foreign.addr; + tcp_header_encode(sp, seg, &npdu->header, &npdu->header_size); + + text_size = tcp_segment_text_size(seg); + npdu->text = calloc(1, text_size); + if (npdu->text == NULL) + return ENOMEM; + + npdu->text_size = text_size; + memcpy(npdu->text, seg->data, text_size); + + /* Checksum calculation */ + checksum = tcp_pdu_checksum_calc(npdu); + tcp_pdu_set_checksum(npdu, checksum); + + *pdu = npdu; + return EOK; +} + +/** + * @} + */ Index: uspace/srv/tcp/pdu.h =================================================================== --- uspace/srv/tcp/pdu.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/pdu.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP PDU (encoded Protocol Data Unit) handling + */ + +#ifndef PDU_H +#define PDU_H + +#include +#include "std.h" +#include "tcp_type.h" + +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 **); + +#endif + +/** @} + */ Index: uspace/srv/tcp/rqueue.c =================================================================== --- uspace/srv/tcp/rqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/rqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Global segment receive queue + */ + +#include +#include +#include +#include +#include +#include "conn.h" +#include "pdu.h" +#include "rqueue.h" +#include "segment.h" +#include "tcp_type.h" +#include "ucall.h" + +/** Transcode bounced segments. + * + * If defined, segments bounced via the internal debugging loopback will + * be encoded to a PDU and the decoded. Otherwise they will be bounced back + * directly without passing the encoder-decoder. + */ +#define BOUNCE_TRANSCODE + +static prodcons_t rqueue; + +/** Initialize segment receive queue. */ +void tcp_rqueue_init(void) +{ + prodcons_initialize(&rqueue); +} + +/** Bounce segment directy into receive queue without constructing the PDU. + * + * This is for testing purposes only. + * + * @param sp Socket pair, oriented for transmission + * @param seg Segment + */ +void tcp_rqueue_bounce_seg(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + tcp_sockpair_t rident; + + log_msg(LVL_DEBUG, "tcp_rqueue_bounce_seg()"); + +#ifdef BOUNCE_TRANSCODE + tcp_pdu_t *pdu; + tcp_segment_t *dseg; + + if (tcp_pdu_encode(sp, seg, &pdu) != EOK) { + log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + return; + } + + if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) { + log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + return; + } + + tcp_pdu_delete(pdu); + + /** Insert decoded segment into rqueue */ + tcp_rqueue_insert_seg(&rident, dseg); + tcp_segment_delete(seg); +#else + /* Reverse the identification */ + tcp_sockpair_flipped(sp, &rident); + + /* Insert segment back into rqueue */ + tcp_rqueue_insert_seg(&rident, seg); +#endif +} + +/** Insert segment into receive queue. + * + * @param sp Socket pair, oriented for reception + * @param seg Segment + */ +void tcp_rqueue_insert_seg(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + tcp_rqueue_entry_t *rqe; + log_msg(LVL_DEBUG, "tcp_rqueue_insert_seg()"); + + tcp_segment_dump(seg); + + rqe = calloc(1, sizeof(tcp_rqueue_entry_t)); + if (rqe == NULL) { + log_msg(LVL_ERROR, "Failed allocating RQE."); + return; + } + + rqe->sp = *sp; + rqe->seg = seg; + + prodcons_produce(&rqueue, &rqe->link); +} + +/** Receive queue handler thread. */ +static void tcp_rqueue_thread(void *arg) +{ + link_t *link; + tcp_rqueue_entry_t *rqe; + + log_msg(LVL_DEBUG, "tcp_rqueue_thread()"); + + while (true) { + link = prodcons_consume(&rqueue); + rqe = list_get_instance(link, tcp_rqueue_entry_t, link); + + tcp_as_segment_arrived(&rqe->sp, rqe->seg); + } +} + +/** Start receive queue handler thread. */ +void tcp_rqueue_thread_start(void) +{ + thread_id_t tid; + int rc; + + log_msg(LVL_DEBUG, "tcp_rqueue_thread_start()"); + + rc = thread_create(tcp_rqueue_thread, NULL, "rqueue", &tid); + if (rc != EOK) { + log_msg(LVL_ERROR, "Failed creating rqueue thread."); + return; + } +} + +/** + * @} + */ Index: uspace/srv/tcp/rqueue.h =================================================================== --- uspace/srv/tcp/rqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/rqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Global segment receive queue + */ + +#ifndef RQUEUE_H +#define RQUEUE_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_handler(void *); +extern void tcp_rqueue_thread_start(void); + + +#endif + +/** @} + */ Index: uspace/srv/tcp/segment.c =================================================================== --- uspace/srv/tcp/segment.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/segment.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Segment processing + */ + +#include +#include +#include +#include "segment.h" +#include "seq_no.h" +#include "tcp_type.h" + +/** Alocate new segment structure. */ +tcp_segment_t *tcp_segment_new(void) +{ + return calloc(1, sizeof(tcp_segment_t)); +} + +/** Delete segment. */ +void tcp_segment_delete(tcp_segment_t *seg) +{ + free(seg); +} + +/** Create duplicate of segment. + * + * @param seg Segment + * @return Duplicate segment + */ +tcp_segment_t *tcp_segment_dup(tcp_segment_t *seg) +{ + tcp_segment_t *scopy; + size_t tsize; + + scopy = tcp_segment_new(); + if (scopy == NULL) + return NULL; + + scopy->ctrl = seg->ctrl; + scopy->seq = seg->seq; + scopy->ack = seg->ack; + scopy->len = seg->len; + scopy->wnd = seg->wnd; + scopy->up = seg->up; + + tsize = tcp_segment_text_size(seg); + scopy->data = calloc(tsize, 1); + if (scopy->data == NULL) { + free(scopy); + return NULL; + } + + memcpy(scopy->data, seg->data, tsize); + scopy->dfptr = scopy->data; + + return scopy; +} + +/** Create a control-only segment. + * + * @return Segment + */ +tcp_segment_t *tcp_segment_make_ctrl(tcp_control_t ctrl) +{ + tcp_segment_t *seg; + + seg = tcp_segment_new(); + if (seg == NULL) + return NULL; + + seg->ctrl = ctrl; + seg->len = seq_no_control_len(ctrl); + + return seg; +} + +/** Create an RST segment. + * + * @param seg Segment we are replying to + * @return RST segment + */ +tcp_segment_t *tcp_segment_make_rst(tcp_segment_t *seg) +{ + tcp_segment_t *rseg; + + rseg = tcp_segment_new(); + if (rseg == NULL) + return NULL; + + if ((seg->ctrl & CTL_ACK) == 0) { + rseg->ctrl = CTL_RST | CTL_ACK; + rseg->seq = 0; + rseg->ack = seg->seq + seg->len; + } else { + rseg->ctrl = CTL_RST; + rseg->seq = seg->ack; + } + + return rseg; +} + +/** Create a control segment. + * + * @return Segment + */ +tcp_segment_t *tcp_segment_make_data(tcp_control_t ctrl, void *data, + size_t size) +{ + tcp_segment_t *seg; + + seg = tcp_segment_new(); + if (seg == NULL) + return NULL; + + seg->ctrl = ctrl; + seg->len = seq_no_control_len(ctrl) + size; + + seg->dfptr = seg->data = malloc(size); + if (seg->dfptr == NULL) { + free(seg); + return NULL; + } + + memcpy(seg->data, data, size); + + return seg; +} + + +/** Trim segment from left and right by the specified amount. + * + * Trim any text or control to remove the specified amount of sequence + * numbers from the left (lower sequence numbers) and right side + * (higher sequence numbers) of the segment. + * + * @param seg Segment, will be modified in place + * @param left Amount of sequence numbers to trim from the left + * @param right Amount of sequence numbers to trim from the right + */ +void tcp_segment_trim(tcp_segment_t *seg, uint32_t left, uint32_t right) +{ + uint32_t t_size; + + assert(left + right <= seg->len); + + /* Special case, entire segment trimmed from left */ + if (left == seg->len) { + seg->seq = seg->seq + seg->len; + seg->len = 0; + return; + } + + /* Special case, entire segment trimmed from right */ + if (right == seg->len) { + seg->len = 0; + return; + } + + /* General case */ + + t_size = tcp_segment_text_size(seg); + + if (left > 0 && (seg->ctrl & CTL_SYN) != 0) { + /* Trim SYN */ + seg->ctrl &= ~CTL_SYN; + seg->seq++; + seg->len--; + left--; + } + + if (right > 0 && (seg->ctrl & CTL_FIN) != 0) { + /* Trim FIN */ + seg->ctrl &= ~CTL_FIN; + seg->len--; + right--; + } + + if (left > 0 || right > 0) { + /* Trim segment text */ + assert(left + right <= t_size); + + seg->data += left; + seg->len -= left + right; + } +} + +/** Copy out text data from segment. + * + * Data is copied from the beginning of the segment text up to @a size bytes. + * @a size must not be greater than the size of the segment text, but + * it can be less. + * + * @param seg Segment + * @param buf Destination buffer + * @param size Size of destination buffer + */ +void tcp_segment_text_copy(tcp_segment_t *seg, void *buf, size_t size) +{ + assert(size <= tcp_segment_text_size(seg)); + memcpy(buf, seg->data, size); +} + +/** Return number of bytes in segment text. + * + * @param seg Segment + * @return Number of bytes in segment text + */ +size_t tcp_segment_text_size(tcp_segment_t *seg) +{ + return seg->len - seq_no_control_len(seg->ctrl); +} + +/** Dump segment contents to log. + * + * @param seg Segment + */ +void tcp_segment_dump(tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "Segment dump:"); + log_msg(LVL_DEBUG, " - ctrl = %u", (unsigned)seg->ctrl); + log_msg(LVL_DEBUG, " - seq = % " PRIu32, seg->seq); + log_msg(LVL_DEBUG, " - ack = % " PRIu32, seg->ack); + log_msg(LVL_DEBUG, " - len = % " PRIu32, seg->len); + log_msg(LVL_DEBUG, " - wnd = % " PRIu32, seg->wnd); + log_msg(LVL_DEBUG, " - up = % " PRIu32, seg->up); +} + +/** + * @} + */ Index: uspace/srv/tcp/segment.h =================================================================== --- uspace/srv/tcp/segment.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/segment.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Segment processing + */ + +#ifndef SEGMENT_H +#define SEGMENT_H + +#include +#include "tcp_type.h" + +extern tcp_segment_t *tcp_segment_new(void); +extern void tcp_segment_delete(tcp_segment_t *); +extern tcp_segment_t *tcp_segment_dup(tcp_segment_t *); +extern tcp_segment_t *tcp_segment_make_ctrl(tcp_control_t); +extern tcp_segment_t *tcp_segment_make_rst(tcp_segment_t *); +extern tcp_segment_t *tcp_segment_make_data(tcp_control_t, void *, size_t); +extern void tcp_segment_trim(tcp_segment_t *, uint32_t, uint32_t); +extern void tcp_segment_text_copy(tcp_segment_t *, void *, size_t); +extern size_t tcp_segment_text_size(tcp_segment_t *); +extern void tcp_segment_dump(tcp_segment_t *); + + + +#endif + +/** @} + */ Index: uspace/srv/tcp/seq_no.c =================================================================== --- uspace/srv/tcp/seq_no.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/seq_no.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,243 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Sequence number computations + */ + +#include +#include +#include +#include "seq_no.h" +#include "tcp_type.h" + +/** a <= b < c modulo sequence space */ +static bool seq_no_le_lt(uint32_t a, uint32_t b, uint32_t c) +{ + if (a <= c) { + return (a <= b) && (b < c); + } else { + return (b < c) || (a <= b); + } +} + +/** a < b <= c modulo sequence space */ +static bool seq_no_lt_le(uint32_t a, uint32_t b, uint32_t c) +{ + if (a <= c) { + return (a < b) && (b <= c); + } else { + return (b <= c) || (a < b); + } +} + +/** Determine wheter ack is acceptable (new acknowledgement) */ +bool seq_no_ack_acceptable(tcp_conn_t *conn, uint32_t seg_ack) +{ + /* SND.UNA < SEG.ACK <= SND.NXT */ + return seq_no_lt_le(conn->snd_una, seg_ack, conn->snd_nxt); +} + +/** Determine wheter ack is duplicate. + * + * ACK is duplicate if it refers to a sequence number that has + * aleady been acked (SEG.ACK <= SND.UNA). + */ +bool seq_no_ack_duplicate(tcp_conn_t *conn, uint32_t seg_ack) +{ + uint32_t diff; + + /* + * There does not seem to be a three-point comparison + * equivalent of SEG.ACK < SND.UNA. Thus we do it + * on a best-effort basis, based on the difference. + * [-2^31, 0) means less-than, 0 means equal, [0, 2^31) + * means greater-than. Less-than or equal means duplicate. + */ + diff = seg_ack - conn->snd_una; + return diff == 0 || (diff & (0x1 << 31)) != 0; +} + +/** Determine if sequence number is in receive window. */ +bool seq_no_in_rcv_wnd(tcp_conn_t *conn, uint32_t sn) +{ + return seq_no_le_lt(conn->rcv_nxt, sn, conn->rcv_nxt + conn->rcv_wnd); +} + +/** Determine segment has new window update. + * + * Window update is new if either SND.WL1 < SEG.SEQ or + * (SND.WL1 = SEG.SEQ and SND.WL2 <= SEG.ACK). + */ +bool seq_no_new_wnd_update(tcp_conn_t *conn, tcp_segment_t *seg) +{ + bool n_seq, n_ack; + + assert(seq_no_segment_acceptable(conn, seg)); + + /* + * We make use of the fact that the peer should not ACK anything + * beyond our send window (we surely haven't sent that yet) + * as we should have filtered those acks out. + * We use SND.UNA+SND.WND as the third point of comparison. + */ + + n_seq = seq_no_lt_le(conn->snd_wl1, seg->seq, + conn->snd_una + conn->snd_wnd); + + n_ack = conn->snd_wl1 == seg->seq && + seq_no_le_lt(conn->snd_wl2, seg->ack, + conn->snd_una + conn->snd_wnd + 1); + + return n_seq || n_ack; +} + +/** Determine if segment is ready for processing. + * + * Assuming segment is acceptable, a segment is ready if it intersects + * RCV.NXT, that is we can process it immediately. + */ +bool seq_no_segment_ready(tcp_conn_t *conn, tcp_segment_t *seg) +{ + assert(seq_no_segment_acceptable(conn, seg)); + + return seq_no_le_lt(seg->seq, conn->rcv_nxt, seg->seq + seg->len + 1); +} + +/** Determine whether segment is fully acked */ +bool seq_no_segment_acked(tcp_conn_t *conn, tcp_segment_t *seg, uint32_t ack) +{ + assert(seg->len > 0); + return seq_no_lt_le(seg->seq, seg->seq + seg->len, ack); +} + +/** Determine whether initial SYN is acked */ +bool seq_no_syn_acked(tcp_conn_t *conn) +{ + return seq_no_lt_le(conn->iss, conn->snd_una, conn->snd_nxt); +} + +/** Determine whether segment overlaps the receive window */ +bool seq_no_segment_acceptable(tcp_conn_t *conn, tcp_segment_t *seg) +{ + bool b_in, e_in; + + b_in = seq_no_le_lt(conn->rcv_nxt, seg->seq, conn->rcv_nxt + + conn->rcv_wnd); + + e_in = seq_no_le_lt(conn->rcv_nxt, seg->seq + seg->len - 1, + conn->rcv_nxt + conn->rcv_wnd); + + if (seg->len == 0 && conn->rcv_wnd == 0) { + return seg->seq == conn->rcv_nxt; + } else if (seg->len == 0 && conn->rcv_wnd != 0) { + return b_in; + } else if (seg->len > 0 && conn->rcv_wnd == 0) { + return false; + } else { + return b_in || e_in; + } +} + +/** Determine size that control bits occupy in sequence space. */ +uint32_t seq_no_control_len(tcp_control_t ctrl) +{ + uint32_t len = 0; + + if ((ctrl & CTL_SYN) != 0) + ++len; + + if ((ctrl & CTL_FIN) != 0) + ++len; + + return len; +} + +/** Calculate the amount of trim needed to fit segment in receive window. */ +void seq_no_seg_trim_calc(tcp_conn_t *conn, tcp_segment_t *seg, + uint32_t *left, uint32_t *right) +{ + assert(seq_no_segment_acceptable(conn, seg)); + + /* + * If RCV.NXT is between SEG.SEQ and RCV.NXT+RCV.WND, then + * left trim amount is positive + */ + if (seq_no_lt_le(seg->seq, conn->rcv_nxt, + conn->rcv_nxt + conn->rcv_wnd)) { + *left = conn->rcv_nxt - seg->seq; + } else { + *left = 0; + } + + /* + * If SEG.SEQ+SEG.LEN is between SEG.SEQ and RCV.NXT+RCV.WND, + * then right trim is zero. + */ + if (seq_no_lt_le(seg->seq - 1, seg->seq + seg->len, + conn->rcv_nxt + conn->rcv_wnd)) { + *right = 0; + } else { + *right = (seg->seq + seg->len) - + (conn->rcv_nxt + conn->rcv_wnd); + } +} + +/** Segment order comparison. + * + * Compare sequence order of two acceptable segments. + * + * @param conn Connection + * @param sa Segment A + * @param sb Segment B + * + * @return -1, 0, 1, resp. if A < B, A == B, A > B in terms + * of sequence order of the beginning of the segment. + */ +int seq_no_seg_cmp(tcp_conn_t *conn, tcp_segment_t *sa, tcp_segment_t *sb) +{ + assert(seq_no_segment_acceptable(conn, sa)); + assert(seq_no_segment_acceptable(conn, sb)); + + if (seq_no_lt_le(sa->seq, sb->seq, conn->rcv_nxt + conn->rcv_wnd)) + return -1; + + if (seq_no_lt_le(sb->seq, sa->seq, conn->rcv_nxt + conn->rcv_wnd)) + return +1; + + assert(sa->seq == sb->seq); + return 0; +} + +/** + * @} + */ Index: uspace/srv/tcp/seq_no.h =================================================================== --- uspace/srv/tcp/seq_no.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/seq_no.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Sequence number computations + */ + +#ifndef SEQ_NO_H +#define SEQ_NO_H + +#include +#include "tcp_type.h" + +extern bool seq_no_ack_acceptable(tcp_conn_t *, uint32_t); +extern bool seq_no_ack_duplicate(tcp_conn_t *, uint32_t); +extern bool seq_no_in_rcv_wnd(tcp_conn_t *, uint32_t); +extern bool seq_no_new_wnd_update(tcp_conn_t *, tcp_segment_t *); +extern bool seq_no_segment_acked(tcp_conn_t *, tcp_segment_t *, uint32_t); +extern bool seq_no_syn_acked(tcp_conn_t *); +extern bool seq_no_segment_ready(tcp_conn_t *, tcp_segment_t *); +extern bool seq_no_segment_acceptable(tcp_conn_t *, tcp_segment_t *); +extern void seq_no_seg_trim_calc(tcp_conn_t *, tcp_segment_t *, uint32_t *, + uint32_t *); +extern int seq_no_seg_cmp(tcp_conn_t *, tcp_segment_t *, tcp_segment_t *); + +extern uint32_t seq_no_control_len(tcp_control_t); + +#endif + +/** @} + */ Index: uspace/srv/tcp/sock.c =================================================================== --- uspace/srv/tcp/sock.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/sock.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,832 @@ +/* + * Copyright (c) 2008 Lukas Mejdrech + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Socket provider + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "sock.h" +#include "std.h" +#include "tcp.h" +#include "tcp_type.h" +#include "ucall.h" + +#define FRAGMENT_SIZE 1024 + +#define MAX_BACKLOG 128 + +/** Free ports pool start. */ +#define TCP_FREE_PORTS_START 1025 + +/** Free ports pool end. */ +#define TCP_FREE_PORTS_END 65535 + +static int last_used_port = TCP_FREE_PORTS_START - 1; +static socket_ports_t gsock; + +static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg); + +void tcp_sock_init(void) +{ + socket_ports_initialize(&gsock); +} + +static void tcp_free_sock_data(socket_core_t *sock_core) +{ + tcp_sockdata_t *socket; + + socket = (tcp_sockdata_t *)sock_core->specific_data; + (void)socket; +} + +static void tcp_sock_notify_data(socket_core_t *sock_core) +{ + log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id); + async_exch_t *exch = async_exchange_begin(sock_core->sess); + async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id, + FRAGMENT_SIZE, 0, 0, 1); + async_exchange_end(exch); +} + +static void tcp_sock_notify_aconn(socket_core_t *lsock_core) +{ + log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id); + async_exch_t *exch = async_exchange_begin(lsock_core->sess); + async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id, + FRAGMENT_SIZE, 0, 0, 0); + async_exchange_end(exch); +} + +static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + tcp_sockdata_t *sock; + socket_core_t *sock_core; + int sock_id; + int rc; + ipc_call_t answer; + + log_msg(LVL_DEBUG, "tcp_sock_socket()"); + sock = calloc(sizeof(tcp_sockdata_t), 1); + if (sock == NULL) { + async_answer_0(callid, ENOMEM); + return; + } + + fibril_mutex_initialize(&sock->lock); + sock->client = client; + sock->laddr.ipv4 = TCP_IPV4_ANY; + sock->lconn = NULL; + sock->backlog = 0; + list_initialize(&sock->ready); + + sock_id = SOCKET_GET_SOCKET_ID(call); + rc = socket_create(&client->sockets, client->sess, sock, &sock_id); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + sock_core = socket_cores_find(&client->sockets, sock_id); + assert(sock_core != NULL); + sock->sock_core = sock_core; + + refresh_answer(&answer, NULL); + SOCKET_SET_SOCKET_ID(answer, sock_id); + + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE); + SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t)); + answer_call(callid, EOK, &answer, 3); +} + +static void tcp_sock_bind(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int rc; + struct sockaddr *addr; + size_t addr_len; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + + log_msg(LVL_DEBUG, "tcp_sock_bind()"); + log_msg(LVL_DEBUG, " - async_data_write_accept"); + rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + log_msg(LVL_DEBUG, " - call socket_bind"); + rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call), + addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, + last_used_port); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + log_msg(LVL_DEBUG, " - call socket_cores_find"); + sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call)); + if (sock_core != NULL) { + socket = (tcp_sockdata_t *)sock_core->specific_data; + /* XXX Anything to do? */ + (void) socket; + } + + log_msg(LVL_DEBUG, " - success"); + async_answer_0(callid, EOK); +} + +static void tcp_sock_listen(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int socket_id; + int backlog; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + tcp_error_t trc; + tcp_sock_t lsocket; + tcp_sock_t fsocket; + tcp_conn_t *conn; + tcp_sock_lconn_t *lconn; + int i; + + log_msg(LVL_DEBUG, "tcp_sock_listen()"); + + socket_id = SOCKET_GET_SOCKET_ID(call); + backlog = SOCKET_GET_BACKLOG(call); + + if (backlog < 0) { + async_answer_0(callid, EINVAL); + return; + } + + if (backlog > MAX_BACKLOG) + backlog = MAX_BACKLOG; + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + + /* + * Prepare @c backlog listening connections. + */ + fibril_mutex_lock(&socket->lock); + + socket->backlog = backlog; + socket->lconn = calloc(sizeof(tcp_conn_t *), backlog); + if (socket->lconn == NULL) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOMEM); + return; + } + + log_msg(LVL_DEBUG, " - open connections"); + + lsocket.addr.ipv4 = TCP_IPV4_ANY; + lsocket.port = sock_core->port; + fsocket.addr.ipv4 = TCP_IPV4_ANY; + fsocket.port = TCP_PORT_ANY; + + for (i = 0; i < backlog; i++) { + + lconn = calloc(sizeof(tcp_sock_lconn_t), 1); + if (lconn == NULL) { + /* XXX Clean up */ + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOMEM); + return; + } + + trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, + tcp_open_nonblock, &conn); + if (conn == NULL) { + /* XXX Clean up */ + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOMEM); + return; + } + + tcp_uc_set_cstate_cb(conn, tcp_sock_cstate_cb, lconn); + + assert(trc == TCP_EOK); + conn->name = (char *)"S"; + + lconn->conn = conn; + lconn->socket = socket; + link_initialize(&lconn->ready_list); + socket->lconn[i] = lconn; + } + + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EOK); +} + +static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int rc; + struct sockaddr_in *addr; + int socket_id; + size_t addr_len; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + tcp_error_t trc; + tcp_sock_t lsocket; + tcp_sock_t fsocket; + nic_device_id_t dev_id; + tcp_phdr_t *phdr; + size_t phdr_len; + + log_msg(LVL_DEBUG, "tcp_sock_connect()"); + + rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len); + if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) { + async_answer_0(callid, rc); + return; + } + + socket_id = SOCKET_GET_SOCKET_ID(call); + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + if (sock_core->port <= 0) { + rc = socket_bind_free_port(&gsock, sock_core, + TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, + last_used_port); + if (rc != EOK) { + async_answer_0(callid, rc); + return; + } + + last_used_port = sock_core->port; + } + + fibril_mutex_lock(&socket->lock); + + if (socket->laddr.ipv4 == TCP_IPV4_ANY) { + /* Find route to determine local IP address. */ + rc = ip_get_route_req(ip_sess, IPPROTO_TCP, + (struct sockaddr *)addr, sizeof(*addr), &dev_id, + (void **)&phdr, &phdr_len); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + log_msg(LVL_DEBUG, "tcp_transmit_connect: Failed to find route."); + return; + } + + socket->laddr.ipv4 = uint32_t_be2host(phdr->src_addr); + log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4); + free(phdr); + } + + lsocket.addr.ipv4 = socket->laddr.ipv4; + lsocket.port = sock_core->port; + fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr); + fsocket.port = uint16_t_be2host(addr->sin_port); + + trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn); + + if (socket->conn != NULL) + socket->conn->name = (char *)"C"; + + fibril_mutex_unlock(&socket->lock); + + switch (trc) { + case TCP_EOK: + rc = EOK; + break; + case TCP_ERESET: + rc = ECONNREFUSED; + break; + default: + assert(false); + } + + async_answer_0(callid, rc); + + /* Push one fragment notification to client's queue */ + tcp_sock_notify_data(sock_core); + log_msg(LVL_DEBUG, "tcp_sock_connect(): notify conn\n"); +} + +static void tcp_sock_accept(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + ipc_call_t answer; + int socket_id; + int asock_id; + socket_core_t *sock_core; + socket_core_t *asock_core; + tcp_sockdata_t *socket; + tcp_sockdata_t *asocket; + tcp_error_t trc; + tcp_sock_t lsocket; + tcp_sock_t fsocket; + tcp_conn_t *conn; + tcp_conn_t *rconn; + tcp_sock_lconn_t *lconn; + int rc; + + log_msg(LVL_DEBUG, "tcp_sock_accept()"); + + socket_id = SOCKET_GET_SOCKET_ID(call); + asock_id = SOCKET_GET_NEW_SOCKET_ID(call); + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + fibril_mutex_lock(&socket->lock); + + log_msg(LVL_DEBUG, " - verify socket->conn"); + if (socket->conn != NULL) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EINVAL); + return; + } + + if (list_empty(&socket->ready)) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOENT); + return; + } + + lconn = list_get_instance(list_first(&socket->ready), + tcp_sock_lconn_t, ready_list); + list_remove(&lconn->ready_list); + + conn = lconn->conn; + tcp_uc_set_cstate_cb(conn, NULL, NULL); + + /* Replenish listening connection */ + + lsocket.addr.ipv4 = TCP_IPV4_ANY; + lsocket.port = sock_core->port; + fsocket.addr.ipv4 = TCP_IPV4_ANY; + fsocket.port = TCP_PORT_ANY; + + trc = tcp_uc_open(&lsocket, &fsocket, ap_passive, tcp_open_nonblock, + &rconn); + if (rconn == NULL) { + /* XXX Clean up */ + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOMEM); + return; + } + + tcp_uc_set_cstate_cb(rconn, tcp_sock_cstate_cb, lconn); + + assert(trc == TCP_EOK); + rconn->name = (char *)"S"; + + lconn->conn = rconn; + + /* Allocate socket for accepted connection */ + + log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n"); + asocket = calloc(sizeof(tcp_sockdata_t), 1); + if (asocket == NULL) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOMEM); + return; + } + + fibril_mutex_initialize(&asocket->lock); + asocket->client = client; + asocket->conn = conn; + log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n"); + + rc = socket_create(&client->sockets, client->sess, asocket, &asock_id); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + return; + } + log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n"); + + asock_core = socket_cores_find(&client->sockets, asock_id); + assert(asock_core != NULL); + + refresh_answer(&answer, NULL); + + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE); + SOCKET_SET_SOCKET_ID(answer, asock_id); + SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in)); + + answer_call(callid, asock_core->socket_id, &answer, 3); + + /* Push one fragment notification to client's queue */ + log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n"); + tcp_sock_notify_data(asock_core); + fibril_mutex_unlock(&socket->lock); +} + +static void tcp_sock_send(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int socket_id; + int fragments; + int index; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + ipc_call_t answer; + ipc_callid_t wcallid; + size_t length; + uint8_t buffer[FRAGMENT_SIZE]; + tcp_error_t trc; + int rc; + + log_msg(LVL_DEBUG, "tcp_sock_send()"); + socket_id = SOCKET_GET_SOCKET_ID(call); + fragments = SOCKET_GET_DATA_FRAGMENTS(call); + SOCKET_GET_FLAGS(call); + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + fibril_mutex_lock(&socket->lock); + + if (socket->conn == NULL) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOTCONN); + return; + } + + for (index = 0; index < fragments; index++) { + if (!async_data_write_receive(&wcallid, &length)) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EINVAL); + return; + } + + if (length > FRAGMENT_SIZE) + length = FRAGMENT_SIZE; + + rc = async_data_write_finalize(wcallid, buffer, length); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + return; + } + + trc = tcp_uc_send(socket->conn, buffer, length, 0); + + switch (trc) { + case TCP_EOK: + rc = EOK; + break; + case TCP_ENOTEXIST: + rc = ENOTCONN; + break; + case TCP_ECLOSING: + rc = ENOTCONN; + break; + case TCP_ERESET: + rc = ECONNABORTED; + break; + default: + assert(false); + } + + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + return; + } + } + + refresh_answer(&answer, NULL); + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE); + answer_call(callid, EOK, &answer, 2); + fibril_mutex_unlock(&socket->lock); +} + +static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + log_msg(LVL_DEBUG, "tcp_sock_sendto()"); + async_answer_0(callid, ENOTSUP); +} + +static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int socket_id; + int flags; + size_t addr_length, length; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + ipc_call_t answer; + ipc_callid_t rcallid; + uint8_t buffer[FRAGMENT_SIZE]; + size_t data_len; + xflags_t xflags; + tcp_error_t trc; + struct sockaddr_in addr; + tcp_sock_t *rsock; + int rc; + + log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client); + + socket_id = SOCKET_GET_SOCKET_ID(call); + flags = SOCKET_GET_FLAGS(call); + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + fibril_mutex_lock(&socket->lock); + + if (socket->conn == NULL) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, ENOTCONN); + return; + } + + (void)flags; + + trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len, + &xflags); + log_msg(LVL_DEBUG, "**** tcp_uc_receive done"); + + switch (trc) { + case TCP_EOK: + rc = EOK; + break; + case TCP_ENOTEXIST: + case TCP_ECLOSING: + rc = ENOTCONN; + break; + case TCP_ERESET: + rc = ECONNABORTED; + break; + default: + assert(false); + } + + log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + return; + } + + if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) { + /* Fill addr */ + rsock = &socket->conn->ident.foreign; + addr.sin_family = AF_INET; + addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4); + addr.sin_port = host2uint16_t_be(rsock->port); + + log_msg(LVL_DEBUG, "addr read receive"); + if (!async_data_read_receive(&rcallid, &addr_length)) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EINVAL); + return; + } + + if (addr_length > sizeof(addr)) + addr_length = sizeof(addr); + + log_msg(LVL_DEBUG, "addr read finalize"); + rc = async_data_read_finalize(rcallid, &addr, addr_length); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EINVAL); + return; + } + } + + log_msg(LVL_DEBUG, "data read receive"); + if (!async_data_read_receive(&rcallid, &length)) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EINVAL); + return; + } + + if (length > data_len) + length = data_len; + + log_msg(LVL_DEBUG, "data read finalize"); + rc = async_data_read_finalize(rcallid, buffer, length); + + if (length < data_len && rc == EOK) + rc = EOVERFLOW; + + SOCKET_SET_READ_DATA_LENGTH(answer, length); + answer_call(callid, EOK, &answer, 1); + + /* Push one fragment notification to client's queue */ + tcp_sock_notify_data(sock_core); + fibril_mutex_unlock(&socket->lock); +} + +static void tcp_sock_close(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + int socket_id; + socket_core_t *sock_core; + tcp_sockdata_t *socket; + tcp_error_t trc; + int rc; + uint8_t buffer[FRAGMENT_SIZE]; + size_t data_len; + xflags_t xflags; + + log_msg(LVL_DEBUG, "tcp_sock_close()"); + socket_id = SOCKET_GET_SOCKET_ID(call); + + sock_core = socket_cores_find(&client->sockets, socket_id); + if (sock_core == NULL) { + async_answer_0(callid, ENOTSOCK); + return; + } + + socket = (tcp_sockdata_t *)sock_core->specific_data; + fibril_mutex_lock(&socket->lock); + + if (socket->conn != NULL) { + trc = tcp_uc_close(socket->conn); + if (trc != TCP_EOK && trc != TCP_ENOTEXIST) { + fibril_mutex_unlock(&socket->lock); + 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, + tcp_free_sock_data); + if (rc != EOK) { + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, rc); + return; + } + + fibril_mutex_unlock(&socket->lock); + async_answer_0(callid, EOK); +} + +static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + log_msg(LVL_DEBUG, "tcp_sock_getsockopt()"); + async_answer_0(callid, ENOTSUP); +} + +static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call) +{ + log_msg(LVL_DEBUG, "tcp_sock_setsockopt()"); + async_answer_0(callid, ENOTSUP); +} + +/** Called when connection state changes. */ +static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg) +{ + tcp_conn_status_t cstatus; + tcp_sock_lconn_t *lconn = (tcp_sock_lconn_t *)arg; + tcp_sockdata_t *socket = lconn->socket; + + log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()"); + fibril_mutex_lock(&socket->lock); + assert(conn == lconn->conn); + + tcp_uc_status(conn, &cstatus); + if (cstatus.cstate != st_established) { + fibril_mutex_unlock(&socket->lock); + return; + } + + assert_link_not_used(&lconn->ready_list); + list_append(&lconn->ready_list, &socket->ready); + + log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept"); + + /* Push one accept notification to client's queue */ + tcp_sock_notify_aconn(socket->sock_core); + fibril_mutex_unlock(&socket->lock); +} + +int tcp_sock_connection(async_sess_t *sess, ipc_callid_t iid, ipc_call_t icall) +{ + ipc_callid_t callid; + ipc_call_t call; + tcp_client_t client; + + /* Accept the connection */ + async_answer_0(iid, EOK); + + client.sess = sess; + socket_cores_initialize(&client.sockets); + + while (true) { + callid = async_get_call(&call); + if (!IPC_GET_IMETHOD(call)) + break; + + log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n", + (int)IPC_GET_IMETHOD(call)); + + switch (IPC_GET_IMETHOD(call)) { + case NET_SOCKET: + tcp_sock_socket(&client, callid, call); + break; + case NET_SOCKET_BIND: + tcp_sock_bind(&client, callid, call); + break; + case NET_SOCKET_LISTEN: + tcp_sock_listen(&client, callid, call); + break; + case NET_SOCKET_CONNECT: + tcp_sock_connect(&client, callid, call); + break; + case NET_SOCKET_ACCEPT: + tcp_sock_accept(&client, callid, call); + break; + case NET_SOCKET_SEND: + tcp_sock_send(&client, callid, call); + break; + case NET_SOCKET_SENDTO: + tcp_sock_sendto(&client, callid, call); + break; + case NET_SOCKET_RECV: + case NET_SOCKET_RECVFROM: + tcp_sock_recvfrom(&client, callid, call); + break; + case NET_SOCKET_CLOSE: + tcp_sock_close(&client, callid, call); + break; + case NET_SOCKET_GETSOCKOPT: + tcp_sock_getsockopt(&client, callid, call); + break; + case NET_SOCKET_SETSOCKOPT: + tcp_sock_setsockopt(&client, callid, call); + break; + default: + async_answer_0(callid, ENOTSUP); + break; + } + } + + return EOK; +} + +/** + * @} + */ Index: uspace/srv/tcp/sock.h =================================================================== --- uspace/srv/tcp/sock.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/sock.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Socket provider + */ + +#ifndef SOCK_H +#define SOCK_H + +#include + +extern void tcp_sock_init(void); +extern int tcp_sock_connection(async_sess_t *, ipc_callid_t, ipc_call_t); + +#endif + +/** @} + */ Index: uspace/srv/tcp/std.h =================================================================== --- uspace/srv/tcp/std.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/std.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP header definitions + * + * Based on IETF RFC 793 + */ + +#ifndef STD_H +#define STD_H + +#include + +/** TCP Header (fixed part) */ +typedef struct { + /** Source port */ + uint16_t src_port; + /** Destination port */ + uint16_t dest_port; + /** Sequence number */ + uint32_t seq; + /** Acknowledgement number */ + uint32_t ack; + /** Data Offset, Reserved, Flags */ + uint16_t doff_flags; + /** Window */ + uint16_t window; + /* Checksum */ + uint16_t checksum; + /** Urgent pointer */ + uint16_t urg_ptr; +} tcp_header_t; + +/** Bits in tcp_header_t.doff_flags */ +enum doff_flags_bits { + DF_DATA_OFFSET_h = 15, + DF_DATA_OFFSET_l = 12, + DF_URG = 5, + DF_ACK = 4, + DF_PSH = 3, + DF_RST = 2, + DF_SYN = 1, + DF_FIN = 0 +}; + +/** TCP pseudo header */ +typedef struct { + /** Source address */ + uint32_t src_addr; + /** Destination address */ + uint32_t dest_addr; + /** Zero */ + uint8_t zero; + /** Protocol */ + uint8_t protocol; + /** TCP length */ + uint16_t tcp_length; +} tcp_phdr_t; + +/** Option kind */ +enum opt_kind { + /** End of option list */ + OPT_END_LIST = 0, + /** No-operation */ + OPT_NOP = 1, + /** Maximum segment size */ + OPT_MAX_SEG_SIZE = 2 +}; + +#endif + +/** @} + */ Index: uspace/srv/tcp/tcp.c =================================================================== --- uspace/srv/tcp/tcp.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/tcp.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,446 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file TCP (Transmission Control Protocol) network module + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ncsim.h" +#include "pdu.h" +#include "rqueue.h" +#include "sock.h" +#include "std.h" +#include "tcp.h" +#include "test.h" + +#define NAME "tcp" + +async_sess_t *net_sess; +static async_sess_t *icmp_sess; +async_sess_t *ip_sess; +packet_dimensions_t pkt_dims; + +static void tcp_received_pdu(tcp_pdu_t *pdu); + +/* Pull up packets into a single memory block. */ +static int pq_pullup(packet_t *packet, void **data, size_t *dsize) +{ + packet_t *npacket; + size_t tot_len; + int length; + + npacket = packet; + tot_len = 0; + do { + length = packet_get_data_length(packet); + if (length <= 0) + return EINVAL; + + tot_len += length; + } while ((npacket = pq_next(npacket)) != NULL); + + uint8_t *buf; + uint8_t *dp; + + buf = calloc(tot_len, 1); + if (buf == NULL) { + free(buf); + return ENOMEM; + } + + npacket = packet; + dp = buf; + do { + length = packet_get_data_length(packet); + if (length <= 0) { + free(buf); + return EINVAL; + } + + memcpy(dp, packet_get_data(packet), length); + dp += length; + } while ((npacket = pq_next(npacket)) != NULL); + + *data = buf; + *dsize = tot_len; + return EOK; +} + +/** Process packet received from network layer. */ +static int tcp_received_msg(nic_device_id_t device_id, packet_t *packet, + services_t error) +{ + int rc; + size_t offset; + int length; + struct sockaddr_in *src_addr; + struct sockaddr_in *dest_addr; + size_t addr_len; + + log_msg(LVL_DEBUG, "tcp_received_msg()"); + + switch (error) { + case SERVICE_NONE: + break; + case SERVICE_ICMP: + default: + log_msg(LVL_WARN, "Unsupported service number %u", + (unsigned)error); + pq_release_remote(net_sess, packet_get_id(packet)); + return ENOTSUP; + } + + /* Process and trim off IP header */ + log_msg(LVL_DEBUG, "tcp_received_msg() - IP header"); + + rc = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL); + if (rc < 0) { + log_msg(LVL_WARN, "ip_client_process_packet() failed"); + pq_release_remote(net_sess, packet_get_id(packet)); + return rc; + } + + offset = (size_t)rc; + length = packet_get_data_length(packet); + + if (length < 0 || (size_t)length < offset) { + log_msg(LVL_WARN, "length=%d, dropping.", length); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + addr_len = packet_get_addr(packet, (uint8_t **)&src_addr, + (uint8_t **)&dest_addr); + if (addr_len <= 0) { + log_msg(LVL_WARN, "Failed to get packet address."); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + if (addr_len != sizeof(struct sockaddr_in)) { + log_msg(LVL_WARN, "Unsupported address size %zu (!= %zu)", + addr_len, sizeof(struct sockaddr_in)); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + rc = packet_trim(packet, offset, 0); + if (rc != EOK) { + log_msg(LVL_WARN, "Failed to trim packet."); + pq_release_remote(net_sess, packet_get_id(packet)); + return rc; + } + + /* Pull up packets into a single memory block, pdu_raw. */ + log_msg(LVL_DEBUG, "tcp_received_msg() - pull up"); + uint8_t *pdu_raw; + size_t pdu_raw_size = 0; + + pq_pullup(packet, (void **)&pdu_raw, &pdu_raw_size); + + /* Split into header and payload. */ + + log_msg(LVL_DEBUG, "tcp_received_msg() - split header/payload"); + + tcp_pdu_t *pdu; + size_t hdr_size; + tcp_header_t *hdr; + uint32_t data_offset; + + if (pdu_raw_size < sizeof(tcp_header_t)) { + log_msg(LVL_WARN, "pdu_raw_size = %zu < sizeof(tcp_header_t) = %zu", + pdu_raw_size, sizeof(tcp_header_t)); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + hdr = (tcp_header_t *)pdu_raw; + data_offset = BIT_RANGE_EXTRACT(uint32_t, DF_DATA_OFFSET_h, DF_DATA_OFFSET_l, + uint16_t_be2host(hdr->doff_flags)); + + hdr_size = sizeof(uint32_t) * data_offset; + + if (pdu_raw_size < hdr_size) { + log_msg(LVL_WARN, "pdu_raw_size = %zu < hdr_size = %zu", + pdu_raw_size, hdr_size); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + if (hdr_size < sizeof(tcp_header_t)) { + log_msg(LVL_WARN, "hdr_size = %zu < sizeof(tcp_header_t) = %zu", + hdr_size, sizeof(tcp_header_t)); + pq_release_remote(net_sess, packet_get_id(packet)); + return EINVAL; + } + + log_msg(LVL_DEBUG, "pdu_raw_size=%zu, hdr_size=%zu", + pdu_raw_size, hdr_size); + pdu = tcp_pdu_create(pdu_raw, hdr_size, pdu_raw + hdr_size, + pdu_raw_size - hdr_size); + if (pdu == NULL) { + log_msg(LVL_WARN, "Failed creating PDU. Dropped."); + return ENOMEM; + } + + free(pdu_raw); + + pdu->src_addr.ipv4 = uint32_t_be2host(src_addr->sin_addr.s_addr); + pdu->dest_addr.ipv4 = uint32_t_be2host(dest_addr->sin_addr.s_addr); + log_msg(LVL_DEBUG, "src: 0x%08x, dest: 0x%08x", + pdu->src_addr.ipv4, pdu->dest_addr.ipv4); + + tcp_received_pdu(pdu); + tcp_pdu_delete(pdu); + + return EOK; +} + +/** Receive packets from network layer. */ +static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg) +{ + packet_t *packet; + int rc; + + log_msg(LVL_DEBUG, "tcp_receiver()"); + + while (true) { + switch (IPC_GET_IMETHOD(*icall)) { + case NET_TL_RECEIVED: + log_msg(LVL_DEBUG, "method = NET_TL_RECEIVED"); + rc = packet_translate_remote(net_sess, &packet, + IPC_GET_PACKET(*icall)); + if (rc != EOK) { + log_msg(LVL_DEBUG, "Error %d translating packet.", rc); + async_answer_0(iid, (sysarg_t)rc); + break; + } + rc = tcp_received_msg(IPC_GET_DEVICE(*icall), packet, + IPC_GET_ERROR(*icall)); + async_answer_0(iid, (sysarg_t)rc); + break; + default: + log_msg(LVL_DEBUG, "method = %u", + (unsigned)IPC_GET_IMETHOD(*icall)); + async_answer_0(iid, ENOTSUP); + break; + } + + iid = async_get_call(icall); + } +} + +/** Transmit PDU over network layer. */ +void tcp_transmit_pdu(tcp_pdu_t *pdu) +{ + struct sockaddr_in dest; + nic_device_id_t dev_id; + void *phdr; + size_t phdr_len; + packet_dimension_t *pkt_dim; + int rc; + packet_t *packet; + void *pkt_data; + size_t pdu_size; + + dest.sin_family = AF_INET; + dest.sin_port = 0; /* not needed */ + dest.sin_addr.s_addr = host2uint32_t_be(pdu->dest_addr.ipv4); + + /* Find route. Obtained pseudo-header is not used. */ + rc = ip_get_route_req(ip_sess, IPPROTO_TCP, (struct sockaddr *)&dest, + sizeof(dest), &dev_id, &phdr, &phdr_len); + if (rc != EOK) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to find route."); + return; + } + + rc = tl_get_ip_packet_dimension(ip_sess, &pkt_dims, dev_id, &pkt_dim); + if (rc != EOK) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to get dimension."); + return; + } + + pdu_size = pdu->header_size + pdu->text_size; + + packet = packet_get_4_remote(net_sess, pdu_size, pkt_dim->addr_len, + pkt_dim->prefix, pkt_dim->suffix); + if (!packet) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to get packet."); + return; + } + + pkt_data = packet_suffix(packet, pdu_size); + if (!pkt_data) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to get pkt_data ptr."); + pq_release_remote(net_sess, packet_get_id(packet)); + return; + } + + rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0); + if (rc != EOK) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to prepare IP packet part."); + pq_release_remote(net_sess, packet_get_id(packet)); + return; + } + + rc = packet_set_addr(packet, NULL, (uint8_t *)&dest, sizeof(dest)); + if (rc != EOK) { + log_msg(LVL_DEBUG, "tcp_transmit_pdu: Failed to set packet address."); + pq_release_remote(net_sess, packet_get_id(packet)); + return; + } + + /* Copy PDU data to packet */ + memcpy(pkt_data, pdu->header, pdu->header_size); + memcpy((uint8_t *)pkt_data + pdu->header_size, pdu->text, + pdu->text_size); + + /* Transmit packet. XXX Transfers packet ownership to IP? */ + ip_send_msg(ip_sess, dev_id, packet, SERVICE_TCP, 0); +} + +/** Process received PDU. */ +static void tcp_received_pdu(tcp_pdu_t *pdu) +{ + tcp_segment_t *dseg; + tcp_sockpair_t rident; + + log_msg(LVL_DEBUG, "tcp_received_pdu()"); + + if (tcp_pdu_decode(pdu, &rident, &dseg) != EOK) { + log_msg(LVL_WARN, "Not enough memory. PDU dropped."); + return; + } + + /* Insert decoded segment into rqueue */ + tcp_rqueue_insert_seg(&rident, dseg); +} + +/* Called from libnet */ +void tl_connection(void) +{ + log_msg(LVL_DEBUG, "tl_connection()"); +} + +/* Called from libnet */ +int tl_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer, + size_t *answer_count) +{ + async_sess_t *callback; + + log_msg(LVL_DEBUG, "tl_message()"); + + *answer_count = 0; + callback = async_callback_receive_start(EXCHANGE_SERIALIZE, call); + if (callback) + return tcp_sock_connection(callback, callid, *call); + + return ENOTSUP; +} + +/* Called from libnet */ +int tl_initialize(async_sess_t *sess) +{ + int rc; + + net_sess = sess; + icmp_sess = icmp_connect_module(); + + log_msg(LVL_DEBUG, "tl_initialize()"); + + tcp_sock_init(); + + ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, + tcp_receiver); + if (ip_sess == NULL) + return ENOENT; + + rc = packet_dimensions_initialize(&pkt_dims); + if (rc != EOK) + return rc; + + return EOK; +} + +int main(int argc, char **argv) +{ + int rc; + + printf(NAME ": TCP (Transmission Control Protocol) network module\n"); + + rc = log_init(NAME, LVL_ERROR); + if (rc != EOK) { + printf(NAME ": Failed to initialize log.\n"); + return 1; + } + +// printf(NAME ": Accepting connections\n"); +// task_retval(0); + + tcp_rqueue_init(); + tcp_rqueue_thread_start(); + + tcp_ncsim_init(); + tcp_ncsim_thread_start(); + + if (0) tcp_test(); +/* + async_manager(); +*/ + tl_module_start(SERVICE_TCP); + + /* Not reached */ + return 0; +} + +/** + * @} + */ Index: uspace/srv/tcp/tcp.h =================================================================== --- uspace/srv/tcp/tcp.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/tcp.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP (Transmission Control Protocol) network module + */ + +#ifndef TCP_H +#define TCP_H + +#include +#include +#include "tcp_type.h" + +extern async_sess_t *net_sess; +extern async_sess_t *ip_sess; +extern void tcp_transmit_pdu(tcp_pdu_t *); + +#endif + +/** @} + */ Index: uspace/srv/tcp/tcp_type.h =================================================================== --- uspace/srv/tcp/tcp_type.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/tcp_type.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,363 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP type definitions + */ + +#ifndef TCP_TYPE_H +#define TCP_TYPE_H + +#include +#include +#include +#include +#include +#include + +struct tcp_conn; + +typedef enum { + /** Listen */ + st_listen, + /** Syn-sent */ + st_syn_sent, + /** Syn-received */ + st_syn_received, + /** Established */ + st_established, + /** Fin-wait-1 */ + st_fin_wait_1, + /** Fin-wait-2 */ + st_fin_wait_2, + /** Close-wait */ + st_close_wait, + /** Closing */ + st_closing, + /** Last-ack */ + st_last_ack, + /** Time-wait */ + st_time_wait, + /** Closed */ + st_closed +} tcp_cstate_t; + +/** Error codes returned by TCP user calls (per the spec). */ +typedef enum { + /* OK */ + TCP_EOK, + /* Connection aborted due to user timeout */ + TCP_EABORTED, + /* Connection already exists */ + TCP_EEXISTS, + /* Connection closing */ + TCP_ECLOSING, + /* Connection does not exist */ + TCP_ENOTEXIST, + /* Connection illegal for this process */ + TCP_EILLEGAL, + /* Connection not open */ + TCP_ENOTOPEN, + /* Connection reset */ + TCP_ERESET, + /* Foreign socket unspecified */ + TCP_EUNSPEC, + /* Insufficient resources */ + TCP_ENORES, + /* Precedence not allowed */ + TCP_EINVPREC, + /* Security/compartment not allowed */ + TCP_EINVCOMP +} tcp_error_t; + +typedef enum { + XF_PUSH = 0x1, + XF_URGENT = 0x2 +} xflags_t; + +typedef enum { + CTL_SYN = 0x1, + CTL_FIN = 0x2, + CTL_RST = 0x4, + CTL_ACK = 0x8 +} tcp_control_t; + +typedef struct { + uint32_t ipv4; +} netaddr_t; + +typedef struct { + netaddr_t addr; + uint16_t port; +} tcp_sock_t; + +enum netaddr { + TCP_IPV4_ANY = 0 +}; + +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 { + struct tcp_conn *conn; + list_t list; +} tcp_iqueue_t; + +/** Retransmission queue */ +typedef struct { + struct tcp_conn *conn; + list_t list; + + /** Retransmission timer */ + fibril_timer_t *timer; +} tcp_tqueue_t; + +typedef enum { + ap_active, + ap_passive +} acpass_t; + +typedef enum { + tcp_open_nonblock = 1 +} tcp_open_flags_t; + +typedef struct tcp_conn tcp_conn_t; + +/** Connection state change callback function */ +typedef void (*tcp_cstate_cb_t)(tcp_conn_t *, void *); + +/** Connection */ +struct tcp_conn { + char *name; + link_t link; + + /** Connection state change callback function */ + tcp_cstate_cb_t cstate_cb; + /** Argument to @c cstate_cb */ + void *cstate_cb_arg; + + /** Connection identification (local and foreign socket) */ + tcp_sockpair_t ident; + + /** Active or passive connection */ + 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; + /** True if connection was deleted by user */ + bool deleted; + /** Signalled when @c cstate changes */ + fibril_condvar_t cstate_cv; + + /** Set when FIN is removed from the retransmission queue */ + bool fin_is_acked; + + /** Queue of incoming segments */ + tcp_iqueue_t incoming; + + /** Retransmission queue */ + tcp_tqueue_t retransmit; + + /** Time-Wait timeout timer */ + fibril_timer_t *tw_timer; + + /** Receive buffer */ + uint8_t *rcv_buf; + /** Receive buffer size */ + size_t rcv_buf_size; + /** Receive buffer number of bytes used */ + size_t rcv_buf_used; + /** Receive buffer contains FIN */ + bool rcv_buf_fin; + /** Receive buffer CV. Broadcast when new data is inserted */ + fibril_condvar_t rcv_buf_cv; + + /** Send buffer */ + uint8_t *snd_buf; + /** Send buffer size */ + size_t snd_buf_size; + /** Send buffer number of bytes used */ + size_t snd_buf_used; + /** 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 */ + uint32_t snd_una; + /** Send next */ + uint32_t snd_nxt; + /** Send window */ + uint32_t snd_wnd; + /** Send urgent pointer */ + uint32_t snd_up; + /** Segment sequence number used for last window update */ + uint32_t snd_wl1; + /** Segment acknowledgement number used for last window update */ + uint32_t snd_wl2; + /** Initial send sequence number */ + uint32_t iss; + + /** Receive next */ + uint32_t rcv_nxt; + /** Receive window */ + uint32_t rcv_wnd; + /** Receive urgent pointer */ + uint32_t rcv_up; + /** Initial receive sequence number */ + uint32_t irs; +}; + +/** Data returned by Status user call */ +typedef struct { + /** Connection state */ + tcp_cstate_t cstate; +} tcp_conn_status_t; + +typedef struct { + /** SYN, FIN */ + tcp_control_t ctrl; + + /** Segment sequence number */ + uint32_t seq; + /** Segment acknowledgement number */ + uint32_t ack; + /** Segment length in sequence space */ + uint32_t len; + /** Segment window */ + uint32_t wnd; + /** Segment urgent pointer */ + uint32_t up; + + /** Segment data, may be moved when trimming segment */ + void *data; + /** Segment data, original pointer used to free data */ + void *dfptr; +} tcp_segment_t; + + +typedef struct { + link_t link; + tcp_sockpair_t sp; + tcp_segment_t *seg; +} tcp_rqueue_entry_t; + +/** NCSim queue entry */ +typedef struct { + link_t link; + suseconds_t delay; + tcp_sockpair_t sp; + tcp_segment_t *seg; +} tcp_squeue_entry_t; + +typedef struct { + link_t link; + tcp_segment_t *seg; +} tcp_iqueue_entry_t; + +/** Retransmission queue entry */ +typedef struct { + link_t link; + tcp_conn_t *conn; + tcp_segment_t *seg; +} tcp_tqueue_entry_t; + +typedef enum { + cp_continue, + cp_done +} cproc_t; + +/** Encoded PDU */ +typedef struct { + /** Source address */ + netaddr_t src_addr; + /** Destination address */ + netaddr_t dest_addr; + + /** Encoded header */ + void *header; + /** Encoded header size */ + size_t header_size; + /** Text */ + void *text; + /** Text size */ + size_t text_size; +} tcp_pdu_t; + +typedef struct { + async_sess_t *sess; + socket_cores_t sockets; +} tcp_client_t; + +typedef struct tcp_sockdata { + /** Lock */ + fibril_mutex_t lock; + /** Socket core */ + socket_core_t *sock_core; + /** Client */ + tcp_client_t *client; + /** Connection */ + tcp_conn_t *conn; + /** Local address */ + netaddr_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; +} tcp_sockdata_t; + +typedef struct tcp_sock_lconn { + tcp_conn_t *conn; + tcp_sockdata_t *socket; + int index; + link_t ready_list; +} tcp_sock_lconn_t; + + +#endif + +/** @} + */ Index: uspace/srv/tcp/test.c =================================================================== --- uspace/srv/tcp/test.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/test.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file Internal TCP test + */ + +#include +#include +#include +#include +#include +#include "tcp_type.h" +#include "ucall.h" + +#include "test.h" + +#define RCV_BUF_SIZE 64 + +static void test_srv(void *arg) +{ + tcp_conn_t *conn; + tcp_sock_t lsock; + tcp_sock_t fsock; + char rcv_buf[RCV_BUF_SIZE + 1]; + size_t rcvd; + xflags_t xflags; + + printf("test_srv()\n"); + lsock.port = 80; + lsock.addr.ipv4 = 0x7f000001; + fsock.port = 1024; + fsock.addr.ipv4 = 0x7f000001; + printf("S: User open...\n"); + tcp_uc_open(&lsock, &fsock, ap_passive, 0, &conn); + conn->name = (char *) "S"; + + while (true) { + printf("S: User receive...\n"); + tcp_uc_receive(conn, rcv_buf, RCV_BUF_SIZE, &rcvd, &xflags); + if (rcvd == 0) { + printf("S: End of data reached.\n"); + break; + } + rcv_buf[rcvd] = '\0'; + printf("S: User received %zu bytes '%s'.\n", rcvd, rcv_buf); + + async_usleep(1000*1000*2); + } + + async_usleep(/*10**/1000*1000); + + printf("S: User close...\n"); + tcp_uc_close(conn); + + printf("test_srv() terminating\n"); +} + +static void test_cli(void *arg) +{ + tcp_conn_t *conn; + tcp_sock_t lsock; + tcp_sock_t fsock; + const char *msg = "Hello World!"; + + printf("test_cli()\n"); + + lsock.port = 1024; + lsock.addr.ipv4 = 0x7f000001; + fsock.port = 80; + fsock.addr.ipv4 = 0x7f000001; + + async_usleep(1000*1000*3); + printf("C: User open...\n"); + tcp_uc_open(&lsock, &fsock, ap_active, 0, &conn); + conn->name = (char *) "C"; + + async_usleep(1000*1000*10); + printf("C: User send...\n"); + tcp_uc_send(conn, (void *)msg, str_size(msg), 0); + + async_usleep(1000*1000*20/**20*2*/); + printf("C: User close...\n"); + tcp_uc_close(conn); +} + +void tcp_test(void) +{ + thread_id_t srv_tid; + thread_id_t cli_tid; + int rc; + + printf("tcp_test()\n"); + + async_usleep(1000*1000); + + if (0) { + rc = thread_create(test_srv, NULL, "test_srv", &srv_tid); + if (rc != EOK) { + printf("Failed to create server thread.\n"); + return; + } + } + + if (0) { + rc = thread_create(test_cli, NULL, "test_cli", &cli_tid); + if (rc != EOK) { + printf("Failed to create client thread.\n"); + return; + } + } +} + +/** + * @} + */ Index: uspace/srv/tcp/test.h =================================================================== --- uspace/srv/tcp/test.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/test.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file Internal TCP test + */ + +#ifndef TEST_H +#define TEST_H + +extern void tcp_test(void); + +#endif + +/** @} + */ Index: uspace/srv/tcp/tqueue.c =================================================================== --- uspace/srv/tcp/tqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/tqueue.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,381 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file TCP transmission queue + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "conn.h" +#include "ncsim.h" +#include "pdu.h" +#include "rqueue.h" +#include "segment.h" +#include "seq_no.h" +#include "tqueue.h" +#include "tcp.h" +#include "tcp_type.h" + +#define RETRANSMIT_TIMEOUT (2*1000*1000) + +static void retransmit_timeout_func(void *arg); +static void tcp_tqueue_timer_set(tcp_conn_t *conn); +static void tcp_tqueue_timer_clear(tcp_conn_t *conn); + +int tcp_tqueue_init(tcp_tqueue_t *tqueue, tcp_conn_t *conn) +{ + tqueue->conn = conn; + tqueue->timer = fibril_timer_create(); + if (tqueue->timer == NULL) + return ENOMEM; + + list_initialize(&tqueue->list); + + return EOK; +} + +void tcp_tqueue_clear(tcp_tqueue_t *tqueue) +{ + tcp_tqueue_timer_clear(tqueue->conn); +} + +void tcp_tqueue_fini(tcp_tqueue_t *tqueue) +{ + if (tqueue->timer != NULL) { + fibril_timer_destroy(tqueue->timer); + tqueue->timer = NULL; + } +} + +void tcp_tqueue_ctrl_seg(tcp_conn_t *conn, tcp_control_t ctrl) +{ + tcp_segment_t *seg; + + log_msg(LVL_DEBUG, "tcp_tqueue_ctrl_seg(%p, %u)", conn, ctrl); + + seg = tcp_segment_make_ctrl(ctrl); + tcp_tqueue_seg(conn, seg); +} + +void tcp_tqueue_seg(tcp_conn_t *conn, tcp_segment_t *seg) +{ + tcp_segment_t *rt_seg; + tcp_tqueue_entry_t *tqe; + + log_msg(LVL_DEBUG, "%s: tcp_tqueue_seg(%p, %p)", conn->name, conn, + seg); + + /* + * Add segment to retransmission queue + */ + + if (seg->len > 0) { + rt_seg = tcp_segment_dup(seg); + if (rt_seg == NULL) { + log_msg(LVL_ERROR, "Memory allocation failed."); + /* XXX Handle properly */ + return; + } + + tqe = calloc(1, sizeof(tcp_tqueue_entry_t)); + if (tqe == NULL) { + log_msg(LVL_ERROR, "Memory allocation failed."); + /* XXX Handle properly */ + return; + } + + tqe->conn = conn; + tqe->seg = rt_seg; + rt_seg->seq = conn->snd_nxt; + + list_append(&tqe->link, &conn->retransmit.list); + + /* Set retransmission timer */ + tcp_tqueue_timer_set(conn); + } + + tcp_prepare_transmit_segment(conn, seg); +} + +void tcp_prepare_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg) +{ + /* + * Always send ACK once we have received SYN, except for RST segments. + * (Spec says we should always send ACK once connection has been + * established.) + */ + if (tcp_conn_got_syn(conn) && (seg->ctrl & CTL_RST) == 0) + seg->ctrl |= CTL_ACK; + + seg->seq = conn->snd_nxt; + conn->snd_nxt += seg->len; + + tcp_conn_transmit_segment(conn, seg); +} + +/** Transmit data from the send buffer. + * + * @param conn Connection + */ +void tcp_tqueue_new_data(tcp_conn_t *conn) +{ + size_t avail_wnd; + size_t xfer_seqlen; + size_t snd_buf_seqlen; + size_t data_size; + tcp_control_t ctrl; + bool send_fin; + + tcp_segment_t *seg; + + log_msg(LVL_DEBUG, "%s: tcp_tqueue_new_data()", conn->name); + + /* Number of free sequence numbers in send window */ + avail_wnd = (conn->snd_una + conn->snd_wnd) - conn->snd_nxt; + snd_buf_seqlen = conn->snd_buf_used + (conn->snd_buf_fin ? 1 : 0); + + xfer_seqlen = min(snd_buf_seqlen, avail_wnd); + log_msg(LVL_DEBUG, "%s: snd_buf_seqlen = %zu, SND.WND = %zu, " + "xfer_seqlen = %zu", conn->name, snd_buf_seqlen, conn->snd_wnd, + xfer_seqlen); + + if (xfer_seqlen == 0) + return; + + /* XXX Do not always send immediately */ + + send_fin = conn->snd_buf_fin && xfer_seqlen == snd_buf_seqlen; + data_size = xfer_seqlen - (send_fin ? 1 : 0); + + if (send_fin) { + log_msg(LVL_DEBUG, "%s: Sending out FIN.", conn->name); + /* We are sending out FIN */ + ctrl = CTL_FIN; + } else { + ctrl = 0; + } + + seg = tcp_segment_make_data(ctrl, conn->snd_buf, data_size); + if (seg == NULL) { + log_msg(LVL_ERROR, "Memory allocation failure."); + return; + } + + /* Remove data from send buffer */ + memmove(conn->snd_buf, conn->snd_buf + data_size, + conn->snd_buf_used - data_size); + conn->snd_buf_used -= data_size; + + 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); +} + +/** Remove ACKed segments from retransmission queue and possibly transmit + * more data. + * + * This should be called when SND.UNA is updated due to incoming ACK. + */ +void tcp_tqueue_ack_received(tcp_conn_t *conn) +{ + link_t *cur, *next; + + log_msg(LVL_DEBUG, "%s: tcp_tqueue_ack_received(%p)", conn->name, + conn); + + cur = conn->retransmit.list.head.next; + + while (cur != &conn->retransmit.list.head) { + next = cur->next; + + tcp_tqueue_entry_t *tqe = list_get_instance(cur, + tcp_tqueue_entry_t, link); + + if (seq_no_segment_acked(conn, tqe->seg, conn->snd_una)) { + /* Remove acknowledged segment */ + list_remove(cur); + + if ((tqe->seg->ctrl & CTL_FIN) != 0) { + log_msg(LVL_DEBUG, "Fin has been acked"); + log_msg(LVL_DEBUG, "SND.UNA=%" PRIu32 + " SEG.SEQ=%" PRIu32 " SEG.LEN=%" PRIu32, + conn->snd_una, tqe->seg->seq, tqe->seg->len); + /* Our FIN has been acked */ + conn->fin_is_acked = true; + } + + tcp_segment_delete(tqe->seg); + free(tqe); + + /* Reset retransmission timer */ + tcp_tqueue_timer_set(conn); + } + + cur = next; + } + + /* Clear retransmission timer if the queue is empty. */ + if (list_empty(&conn->retransmit.list)) + tcp_tqueue_timer_clear(conn); + + /* Possibly transmit more data */ + tcp_tqueue_new_data(conn); +} + +void tcp_conn_transmit_segment(tcp_conn_t *conn, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "%s: tcp_conn_transmit_segment(%p, %p)", + conn->name, conn, seg); + + seg->wnd = conn->rcv_wnd; + + if ((seg->ctrl & CTL_ACK) != 0) + seg->ack = conn->rcv_nxt; + else + seg->ack = 0; + + tcp_transmit_segment(&conn->ident, seg); +} + +void tcp_transmit_segment(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + log_msg(LVL_DEBUG, "tcp_transmit_segment(f:(%x,%u),l:(%x,%u), %p)", + sp->foreign.addr.ipv4, sp->foreign.port, + sp->local.addr.ipv4, sp->local.port, seg); + + log_msg(LVL_DEBUG, "SEG.SEQ=%" PRIu32 ", SEG.WND=%" PRIu32, + seg->seq, seg->wnd); + + tcp_segment_dump(seg); +/* + tcp_pdu_prepare(conn, seg, &data, &len); + tcp_pdu_transmit(data, len); +*/ +// tcp_rqueue_bounce_seg(sp, seg); +// tcp_ncsim_bounce_seg(sp, seg); + + tcp_pdu_t *pdu; + + if (tcp_pdu_encode(sp, seg, &pdu) != EOK) { + log_msg(LVL_WARN, "Not enough memory. Segment dropped."); + return; + } + + tcp_transmit_pdu(pdu); + tcp_pdu_delete(pdu); +} + +static void retransmit_timeout_func(void *arg) +{ + tcp_conn_t *conn = (tcp_conn_t *) arg; + tcp_tqueue_entry_t *tqe; + tcp_segment_t *rt_seg; + link_t *link; + + 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; + } + + link = list_first(&conn->retransmit.list); + if (link == NULL) { + log_msg(LVL_DEBUG, "Nothing to retransmit"); + fibril_mutex_unlock(&conn->lock); + tcp_conn_delref(conn); + return; + } + + tqe = list_get_instance(link, tcp_tqueue_entry_t, link); + + rt_seg = tcp_segment_dup(tqe->seg); + if (rt_seg == NULL) { + log_msg(LVL_ERROR, "Memory allocation failed."); + fibril_mutex_unlock(&conn->lock); + tcp_conn_delref(conn); + /* XXX Handle properly */ + return; + } + + log_msg(LVL_DEBUG, "### %s: retransmitting segment", conn->name); + tcp_conn_transmit_segment(tqe->conn, rt_seg); + + /* Reset retransmission timer */ + tcp_tqueue_timer_set(tqe->conn); + + fibril_mutex_unlock(&conn->lock); + tcp_conn_delref(conn); +} + +/** Set or re-set retransmission timer */ +static void tcp_tqueue_timer_set(tcp_conn_t *conn) +{ + log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_set()", conn->name); + + /* 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); +} + +/** Clear retransmission timer */ +static void tcp_tqueue_timer_clear(tcp_conn_t *conn) +{ + log_msg(LVL_DEBUG, "### %s: tcp_tqueue_timer_clear()", conn->name); + + if (fibril_timer_clear(conn->retransmit.timer) == fts_active) + tcp_conn_delref(conn); +} + +/** + * @} + */ Index: uspace/srv/tcp/tqueue.h =================================================================== --- uspace/srv/tcp/tqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/tqueue.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP transmission queue + */ + +#ifndef TQUEUE_H +#define TQUEUE_H + +#include "std.h" +#include "tcp_type.h" + +extern int tcp_tqueue_init(tcp_tqueue_t *, tcp_conn_t *); +extern void tcp_tqueue_clear(tcp_tqueue_t *); +extern void tcp_tqueue_fini(tcp_tqueue_t *); +extern void tcp_tqueue_ctrl_seg(tcp_conn_t *, tcp_control_t); +extern void tcp_tqueue_seg(tcp_conn_t *, tcp_segment_t *); +extern void tcp_tqueue_new_data(tcp_conn_t *); +extern void tcp_tqueue_ack_received(tcp_conn_t *); +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_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 *); + +#endif + +/** @} + */ Index: uspace/srv/tcp/ucall.c =================================================================== --- uspace/srv/tcp/ucall.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/ucall.c (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,346 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ + +/** + * @file TCP entry points (close to those defined in the RFC) + */ + +#include +#include +#include +#include +#include "conn.h" +#include "tcp_type.h" +#include "tqueue.h" +#include "ucall.h" + +/* + * User calls + */ + +/** OPEN user call + * + * @param lsock Local socket + * @param fsock Foreign socket + * @param acpass Active/passive + * @param oflags Open flags + * @param conn Connection + * + * Unlike in the spec we allow specifying the local address. This means + * the implementation does not need to magically guess it, especially + * considering there can be more than one local address. + * + * XXX We should be able to call active open on an existing listening + * connection. + * XXX We should be able to get connection structure immediately, before + * establishment. + */ +tcp_error_t tcp_uc_open(tcp_sock_t *lsock, tcp_sock_t *fsock, acpass_t acpass, + tcp_open_flags_t oflags, tcp_conn_t **conn) +{ + tcp_conn_t *nconn; + + log_msg(LVL_DEBUG, "tcp_uc_open(%p, %p, %s, %s, %p)", + lsock, fsock, acpass == ap_active ? "active" : "passive", + oflags == tcp_open_nonblock ? "nonblock" : "none", conn); + + nconn = tcp_conn_new(lsock, fsock); + tcp_conn_add(nconn); + + if (acpass == ap_active) { + /* Synchronize (initiate) connection */ + tcp_conn_sync(nconn); + } + + if (oflags == tcp_open_nonblock) { + *conn = nconn; + return TCP_EOK; + } + + /* Wait for connection to be established or reset */ + log_msg(LVL_DEBUG, "tcp_uc_open: Wait for connection."); + 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->lock); + } + + if (nconn->cstate != st_established) { + log_msg(LVL_DEBUG, "tcp_uc_open: Connection was reset."); + assert(nconn->cstate == st_closed); + fibril_mutex_unlock(&nconn->lock); + return TCP_ERESET; + } + + fibril_mutex_unlock(&nconn->lock); + log_msg(LVL_DEBUG, "tcp_uc_open: Connection was established."); + + *conn = nconn; + log_msg(LVL_DEBUG, "tcp_uc_open -> %p", nconn); + return TCP_EOK; +} + +/** SEND user call */ +tcp_error_t tcp_uc_send(tcp_conn_t *conn, void *data, size_t size, + xflags_t flags) +{ + size_t buf_free; + size_t xfer_size; + + log_msg(LVL_DEBUG, "%s: tcp_uc_send()", conn->name); + + fibril_mutex_lock(&conn->lock); + + if (conn->cstate == st_closed) { + fibril_mutex_unlock(&conn->lock); + return TCP_ENOTEXIST; + } + + if (conn->cstate == st_listen) { + /* Change connection to active */ + tcp_conn_sync(conn); + } + + + 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) { + 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); + + /* Copy data to buffer */ + memcpy(conn->snd_buf + conn->snd_buf_used, data, xfer_size); + data += xfer_size; + 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; +} + +/** RECEIVE user call */ +tcp_error_t tcp_uc_receive(tcp_conn_t *conn, void *buf, size_t size, + size_t *rcvd, xflags_t *xflags) +{ + size_t xfer_size; + + log_msg(LVL_DEBUG, "%s: tcp_uc_receive()", conn->name); + + fibril_mutex_lock(&conn->lock); + + if (conn->cstate == st_closed) { + fibril_mutex_unlock(&conn->lock); + return TCP_ENOTEXIST; + } + + /* 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->lock); + } + + if (conn->rcv_buf_used == 0) { + *rcvd = 0; + *xflags = 0; + + 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; + } + } + + /* Copy data from receive buffer to user buffer */ + xfer_size = min(size, conn->rcv_buf_used); + memcpy(buf, conn->rcv_buf, xfer_size); + *rcvd = xfer_size; + + /* Remove data from receive buffer */ + memmove(conn->rcv_buf, conn->rcv_buf + xfer_size, conn->rcv_buf_used - + xfer_size); + conn->rcv_buf_used -= xfer_size; + conn->rcv_wnd += xfer_size; + + /* TODO */ + *xflags = 0; + + /* Send new size of receive window */ + tcp_tqueue_ctrl_seg(conn, CTL_ACK); + + log_msg(LVL_DEBUG, "%s: tcp_uc_receive() - returning %zu bytes", + conn->name, xfer_size); + + fibril_mutex_unlock(&conn->lock); + + return TCP_EOK; +} + +/** CLOSE user call */ +tcp_error_t tcp_uc_close(tcp_conn_t *conn) +{ + log_msg(LVL_DEBUG, "%s: tcp_uc_close()", conn->name); + + fibril_mutex_lock(&conn->lock); + + if (conn->cstate == st_closed) { + fibril_mutex_unlock(&conn->lock); + return TCP_ENOTEXIST; + } + + 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; +} + +/** ABORT user call */ +void tcp_uc_abort(tcp_conn_t *conn) +{ + log_msg(LVL_DEBUG, "tcp_uc_abort()"); +} + +/** STATUS user call */ +void tcp_uc_status(tcp_conn_t *conn, tcp_conn_status_t *cstatus) +{ + log_msg(LVL_DEBUG, "tcp_uc_status()"); + cstatus->cstate = conn->cstate; +} + +/** 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); +} + +void tcp_uc_set_cstate_cb(tcp_conn_t *conn, tcp_cstate_cb_t cb, void *arg) +{ + log_msg(LVL_DEBUG, "tcp_uc_set_ctate_cb(%p, %p, %p)", + conn, cb, arg); + + conn->cstate_cb = cb; + conn->cstate_cb_arg = arg; +} + +/* + * Arriving segments + */ + +/** Segment arrived */ +void tcp_as_segment_arrived(tcp_sockpair_t *sp, tcp_segment_t *seg) +{ + tcp_conn_t *conn; + + log_msg(LVL_DEBUG, "tcp_as_segment_arrived(f:(%x,%u), l:(%x,%u))", + sp->foreign.addr.ipv4, sp->foreign.port, + sp->local.addr.ipv4, sp->local.port); + + 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); +} + +/* + * Timeouts + */ + +/** User timeout */ +void tcp_to_user(void) +{ + log_msg(LVL_DEBUG, "tcp_to_user()"); +} + +/** + * @} + */ Index: uspace/srv/tcp/ucall.h =================================================================== --- uspace/srv/tcp/ucall.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) +++ uspace/srv/tcp/ucall.h (revision 4d9fe7b307128cbbbd04d982fef935c842053872) @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2011 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup tcp + * @{ + */ +/** @file TCP user calls (close to those defined in the RFC) + */ + +#ifndef UCALL_H +#define UCALL_H + +#include +#include "tcp_type.h" + +/* + * User calls + */ +extern tcp_error_t tcp_uc_open(tcp_sock_t *, tcp_sock_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); +extern tcp_error_t tcp_uc_receive(tcp_conn_t *, void *, size_t, size_t *, xflags_t *); +extern tcp_error_t tcp_uc_close(tcp_conn_t *); +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 *); +extern void tcp_uc_set_cstate_cb(tcp_conn_t *, tcp_cstate_cb_t, void *); + +/* + * Arriving segments + */ +extern void tcp_as_segment_arrived(tcp_sockpair_t *, tcp_segment_t *); + +/* + * Timeouts + */ +extern void tcp_to_user(void); + +#endif + +/** @} + */