Index: uspace/srv/net/tl/tcp/header.c =================================================================== --- uspace/srv/net/tl/tcp/header.c (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/header.c (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -36,4 +36,7 @@ #include +#include +#include +#include #include "header.h" #include "segment.h" @@ -41,25 +44,204 @@ #include "tcp_type.h" -void tcp_header_setup(tcp_conn_t *conn, tcp_segment_t *seg, tcp_header_t *hdr) -{ - hdr->src_port = host2uint16_t_be(conn->ident.local.port); - hdr->dest_port = host2uint16_t_be(conn->ident.foreign.port); - hdr->seq = 0; - hdr->ack = 0; - hdr->doff_flags = 0; - hdr->window = 0; +#define TCP_CHECKSUM_INIT 0xffff + +static uint16_t tcp_checksum_calc(uint16_t ivalue, void *data, size_t size) +{ + uint16_t sum; + size_t words, i; + uint8_t *bdata; + + sum = ~ivalue; + words = size / 2; + bdata = (uint8_t *)data; + + for (i = 0; i < words; i++) { + sum += ~(((uint16_t)bdata[2*i] << 8) + bdata[2*i + 1]); + } + + if (size % 2 != 0) { + sum += ~((uint16_t)bdata[2*words] << 8); + } + + 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 & DF_URG) != 0) + ctl |= 0 /* XXX */; + if ((doff_flags & DF_ACK) != 0) + ctl |= CTL_ACK; + if ((doff_flags & DF_PSH) != 0) + ctl |= 0 /* XXX */; + if ((doff_flags & DF_RST) != 0) + ctl |= CTL_RST; + if ((doff_flags & DF_SYN) != 0) + ctl |= CTL_SYN; + if ((doff_flags & 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 |= DF_ACK; + if ((ctl & CTL_RST) != 0) + doff_flags |= DF_RST; + if ((ctl & CTL_SYN) != 0) + doff_flags |= DF_SYN; + if ((ctl & CTL_FIN) != 0) + doff_flags |= 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; + + 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); + tcp_header_encode_flags(seg->ctrl, 0, &doff_flags); + hdr->doff_flags = host2uint16_t_be(doff_flags); + hdr->window = host2uint16_t_be(seg->wnd); hdr->checksum = 0; - hdr->urg_ptr = 0; -} - -void tcp_phdr_setup(tcp_conn_t *conn, tcp_segment_t *seg, tcp_phdr_t *phdr) -{ - phdr->src_addr = conn->ident.local.addr.ipv4; - phdr->dest_addr = conn->ident.foreign.addr.ipv4; + 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 = 0; /* XXX */ - - /* XXX This will only work as long as we don't have any header options */ - phdr->tcp_length = sizeof(tcp_header_t) + tcp_segment_text_size(seg); + 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)); +} + +void tcp_pdu_delete(tcp_pdu_t *pdu) +{ + 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_le(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); + + 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/net/tl/tcp/header.h =================================================================== --- uspace/srv/net/tl/tcp/header.h (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/header.h (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -39,6 +39,8 @@ #include "tcp_type.h" -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 *); +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/net/tl/tcp/rqueue.c =================================================================== --- uspace/srv/net/tl/tcp/rqueue.c (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/rqueue.c (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -41,7 +41,17 @@ #include #include "conn.h" +#include "header.h" #include "rqueue.h" +#include "segment.h" #include "state.h" #include "tcp_type.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; @@ -66,8 +76,30 @@ 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 } Index: uspace/srv/net/tl/tcp/segment.c =================================================================== --- uspace/srv/net/tl/tcp/segment.c (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/segment.c (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -133,6 +133,4 @@ tcp_segment_t *seg; - assert(ctrl != 0 || size > 0); - seg = tcp_segment_new(); if (seg == NULL) Index: uspace/srv/net/tl/tcp/tcp_type.h =================================================================== --- uspace/srv/net/tl/tcp/tcp_type.h (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/tcp_type.h (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -271,4 +271,21 @@ } 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; + #endif Index: uspace/srv/net/tl/tcp/test.c =================================================================== --- uspace/srv/net/tl/tcp/test.c (revision 004a5fee58a6c541fd63bd94a81a2f3b35735aa9) +++ uspace/srv/net/tl/tcp/test.c (revision eea65f4146296a8ed82333d611ca58de009377b0) @@ -58,9 +58,10 @@ sock.port = 1024; sock.addr.ipv4 = 0x7f000001; + printf("S: User open...\n"); tcp_uc_open(80, &sock, ap_passive, &conn); conn->name = (char *) "S"; while (true) { - printf("User receive...\n"); + printf("S: User receive...\n"); tcp_uc_receive(conn, rcv_buf, RCV_BUF_SIZE, &rcvd, &xflags); if (rcvd == 0) { @@ -69,5 +70,5 @@ } rcv_buf[rcvd] = '\0'; - printf("User received %zu bytes '%s'.\n", rcvd, rcv_buf); + printf("S: User received %zu bytes '%s'.\n", rcvd, rcv_buf); async_usleep(1000*1000*2); @@ -76,5 +77,5 @@ async_usleep(/*10**/1000*1000); - printf("test_srv() close connection\n"); + printf("S: User close...\n"); tcp_uc_close(conn); @@ -94,11 +95,14 @@ async_usleep(1000*1000*3); + printf("C: User open...\n"); tcp_uc_open(1024, &sock, ap_active, &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*3/**20*2*/); + printf("C: User close...\n"); tcp_uc_close(conn); }