ShuriZma
/
flycast
mirror of https://github.com/flyinghead/flycast.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
flycast/core/deps/picotcp/modules/pico_fragments.c

574 lines
15 KiB
C
Raw Blame History

/*********************************************************************
PicoTCP. Copyright (c) 2012 TASS Belgium NV. Some rights reserved.
See COPYING, LICENSE.GPLv2 and LICENSE.GPLv3 for usage.
Authors: Laurens Miers, Daniele Lacamera
*********************************************************************/
#include "pico_config.h"
#ifdef PICO_SUPPORT_IPV6
#include "pico_ipv6.h"
#include "pico_icmp6.h"
#endif
#ifdef PICO_SUPPORT_IPV4
#include "pico_ipv4.h"
#include "pico_icmp4.h"
#endif
#include "pico_stack.h"
#include "pico_eth.h"
#include "pico_udp.h"
#include "pico_tcp.h"
#include "pico_socket.h"
#include "pico_device.h"
#include "pico_tree.h"
#include "pico_constants.h"
#include "pico_fragments.h"
#ifdef DEBUG_FRAG
#define frag_dbg dbg
#else
#define frag_dbg(...) do {} while(0)
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
#define IP6_FRAG_OFF(x) ((x & 0xFFF8u))
#define IP6_FRAG_MORE(x) ((x & 0x0001))
#define IP6_FRAG_ID(x) ((uint32_t)(((uint32_t)x->ext.frag.id[0] << 24) + ((uint32_t)x->ext.frag.id[1] << 16) + \
((uint32_t)x->ext.frag.id[2] << 8) + (uint32_t)x->ext.frag.id[3]))
#else
#define IP6_FRAG_OFF(x) (0)
#define IP6_FRAG_MORE(x) (0)
#define IP6_FRAG_ID(x) (0)
#endif
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
#define IP4_FRAG_OFF(frag) (((uint32_t)frag & PICO_IPV4_FRAG_MASK) << 3ul)
#define IP4_FRAG_MORE(frag) ((frag & PICO_IPV4_MOREFRAG) ? 1 : 0)
#define IP4_FRAG_ID(hdr) (hdr->id)
#else
#define IP4_FRAG_OFF(frag) (0)
#define IP4_FRAG_MORE(frag) (0)
#define IP4_FRAG_ID(hdr) (0)
#endif
#define PICO_IPV6_FRAG_TIMEOUT 60000
#define PICO_IPV4_FRAG_TIMEOUT 15000
static void pico_frag_expire(pico_time now, void *arg);
static void pico_fragments_complete(unsigned int bookmark, uint8_t proto, uint8_t net);
static int pico_fragments_check_complete(struct pico_tree *tree, uint8_t proto, uint8_t net);
static int pico_fragments_reassemble(struct pico_tree *tree, unsigned int len, uint8_t proto, uint8_t net);
static int pico_fragments_get_more_flag(struct pico_frame *frame, uint8_t net);
static uint32_t pico_fragments_get_offset(struct pico_frame *frame, uint8_t net);
static void pico_fragments_send_notify(struct pico_frame *first);
static uint16_t pico_fragments_get_header_length(uint8_t net);
static void pico_fragments_empty_tree(struct pico_tree *tree);
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
static uint32_t ipv6_cur_frag_id = 0u;
static uint32_t ipv6_fragments_timer = 0u;
static int pico_ipv6_frag_compare(void *ka, void *kb)
{
struct pico_frame *a = ka, *b = kb;
if (IP6_FRAG_OFF(a->frag) > IP6_FRAG_OFF(b->frag))
return 1;
if (IP6_FRAG_OFF(a->frag) < IP6_FRAG_OFF(b->frag))
return -1;
return 0;
}
static PICO_TREE_DECLARE(ipv6_fragments, pico_ipv6_frag_compare);
static void pico_ipv6_fragments_complete(unsigned int len, uint8_t proto)
{
if (pico_fragments_reassemble(&ipv6_fragments, len, proto, PICO_PROTO_IPV6) == 0)
{
pico_timer_cancel(ipv6_fragments_timer);
ipv6_fragments_timer = 0;
}
}
static void pico_ipv6_frag_timer_on(void)
{
ipv6_fragments_timer = pico_timer_add(PICO_IPV6_FRAG_TIMEOUT, pico_frag_expire, &ipv6_fragments);
if (!ipv6_fragments_timer) {
frag_dbg("FRAG: Failed to start IPv6 expiration timer\n");
pico_fragments_empty_tree(&ipv6_fragments);
}
}
static int pico_ipv6_frag_match(struct pico_frame *a, struct pico_frame *b)
{
struct pico_ipv6_hdr *ha = NULL, *hb = NULL;
if (!a || !b)
return -1;
ha = (struct pico_ipv6_hdr *)a->net_hdr;
hb = (struct pico_ipv6_hdr *)b->net_hdr;
if (!ha || !hb)
return -2;
if (memcmp(ha->src.addr, hb->src.addr, PICO_SIZE_IP6) != 0)
return 1;
if (memcmp(ha->dst.addr, hb->dst.addr, PICO_SIZE_IP6) != 0)
return 2;
return 0;
}
#endif
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
static uint32_t ipv4_cur_frag_id = 0u;
static uint32_t ipv4_fragments_timer = 0u;
static int pico_ipv4_frag_compare(void *ka, void *kb)
{
struct pico_frame *a = ka, *b = kb;
if (IP4_FRAG_OFF(a->frag) > IP4_FRAG_OFF(b->frag))
return 1;
if (IP4_FRAG_OFF(a->frag) < IP4_FRAG_OFF(b->frag))
return -1;
return 0;
}
static PICO_TREE_DECLARE(ipv4_fragments, pico_ipv4_frag_compare);
static void pico_ipv4_fragments_complete(unsigned int len, uint8_t proto)
{
if (pico_fragments_reassemble(&ipv4_fragments, len, proto, PICO_PROTO_IPV4) == 0)
{
pico_timer_cancel(ipv4_fragments_timer);
ipv4_fragments_timer = 0;
}
}
static void pico_ipv4_frag_timer_on(void)
{
ipv4_fragments_timer = pico_timer_add( PICO_IPV4_FRAG_TIMEOUT, pico_frag_expire, &ipv4_fragments);
if (!ipv4_fragments_timer) {
frag_dbg("FRAG: Failed to start IPv4 expiration timer\n");
pico_fragments_empty_tree(&ipv4_fragments);
}
}
static int pico_ipv4_frag_match(struct pico_frame *a, struct pico_frame *b)
{
struct pico_ipv4_hdr *ha, *hb;
if (!a || !b)
return -1;
ha = (struct pico_ipv4_hdr *)a->net_hdr;
hb = (struct pico_ipv4_hdr *)b->net_hdr;
if (!ha || !hb)
return -2;
if (memcmp(&(ha->src.addr), &(hb->src.addr), PICO_SIZE_IP4) != 0)
return 1;
if (memcmp(&(ha->dst.addr), &(hb->dst.addr), PICO_SIZE_IP4) != 0)
return 2;
return 0;
}
#endif
static void pico_fragments_complete(unsigned int bookmark, uint8_t proto, uint8_t net)
{
if (0) {}
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
else if (net == PICO_PROTO_IPV4)
{
pico_ipv4_fragments_complete(bookmark, proto);
}
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
else if (net == PICO_PROTO_IPV6)
{
pico_ipv6_fragments_complete(bookmark, proto);
}
#endif
}
static void pico_fragments_empty_tree(struct pico_tree *tree)
{
struct pico_tree_node *index, *tmp;
if (!tree)
{
return;
}
pico_tree_foreach_safe(index, tree, tmp) {
struct pico_frame * old = index->keyValue;
pico_tree_delete(tree, old);
pico_frame_discard(old);
}
}
static int pico_fragments_check_complete(struct pico_tree *tree, uint8_t proto, uint8_t net)
{
struct pico_tree_node *index, *temp;
struct pico_frame *cur;
unsigned int bookmark = 0;
if (!tree)
return 0;
pico_tree_foreach_safe(index, tree, temp) {
cur = index->keyValue;
if (cur) {
if (pico_fragments_get_offset(cur, net) != bookmark)
return -1;
bookmark += cur->transport_len;
if (!pico_fragments_get_more_flag(cur, net)) {
pico_fragments_complete(bookmark, proto, net);
return 0;
}
}
}
return 1;
}
static void pico_frag_expire(pico_time now, void *arg)
{
struct pico_tree *tree = (struct pico_tree *) arg;
struct pico_frame *first = NULL;
IGNORE_PARAMETER(now);
if (!tree)
{
frag_dbg("Expired packet but no tree supplied!\n");
return;
}
first = pico_tree_first(tree);
if (!first) {
frag_dbg("Empty tree - not sending notify\n");
return;
}
pico_fragments_send_notify(first);
pico_fragments_empty_tree(tree);
}
static void pico_fragments_send_notify(struct pico_frame *first)
{
uint8_t net = 0;
if (!first)
{
return;
}
if (0) {}
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
else if (IS_IPV4(first))
{
net = PICO_PROTO_IPV4;
frag_dbg("Packet expired! ID:%hu\n", ipv4_cur_frag_id);
}
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
else if (IS_IPV6(first))
{
net = PICO_PROTO_IPV6;
frag_dbg("Packet expired! ID:%hu\n", ipv6_cur_frag_id);
}
#endif
if (((pico_fragments_get_offset(first, net) == 0) && (pico_frame_dst_is_unicast(first))))
{
frag_dbg("sending notify\n");
pico_notify_frag_expired(first);
}
else
{
frag_dbg("Not first packet or not unicast address, not sending notify");
}
}
static int pico_fragments_reassemble(struct pico_tree *tree, unsigned int len, uint8_t proto, uint8_t net)
{
struct pico_tree_node *index, *tmp;
struct pico_frame *f;
uint16_t header_length = 0;
unsigned int bookmark = 0;
struct pico_frame *full = NULL;
struct pico_frame *first = NULL;
if (!tree)
{
frag_dbg("Cannot reassemble packet, no tree supplied!\n");
return -1;
}
first = pico_tree_first(tree);
if (!first)
{
frag_dbg("Cannot reassemble packet, empty tree supplied!\n");
return -2;
}
header_length = pico_fragments_get_header_length(net);
if (!header_length)
{
return -3;
}
full = pico_frame_alloc((uint16_t)(header_length + len));
if (full) {
full->net_hdr = full->buffer;
full->net_len = header_length;
memcpy(full->net_hdr, first->net_hdr, full->net_len);
full->transport_hdr = full->net_hdr + full->net_len;
full->transport_len = (uint16_t)len;
full->dev = first->dev;
pico_tree_foreach_safe(index, tree, tmp) {
f = index->keyValue;
memcpy(full->transport_hdr + bookmark, f->transport_hdr, f->transport_len);
bookmark += f->transport_len;
pico_tree_delete(tree, f);
pico_frame_discard(f);
}
if (pico_transport_receive(full, proto) == -1)
{
pico_frame_discard(full);
}
return 0;
}
return 1;
}
static uint16_t pico_fragments_get_header_length(uint8_t net)
{
if (0) {}
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
else if (net == PICO_PROTO_IPV4)
{
return PICO_SIZE_IP4HDR;
}
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
else if (net == PICO_PROTO_IPV6)
{
return PICO_SIZE_IP6HDR;
}
#endif
return 0;
}
static int pico_fragments_get_more_flag(struct pico_frame *frame, uint8_t net)
{
if (!frame)
{
frag_dbg("no frame given to determine more flag\n");
return 0;
}
if (0) {}
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
else if (net == PICO_PROTO_IPV4)
{
return IP4_FRAG_MORE(frame->frag);
}
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
else if (net == PICO_PROTO_IPV6)
{
return IP6_FRAG_MORE(frame->frag);
}
#endif
return 0;
}
static uint32_t pico_fragments_get_offset(struct pico_frame *frame, uint8_t net)
{
if (!frame)
{
frag_dbg("no frame given to determine offset\n");
return 0;
}
if (0) {}
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
else if (net == PICO_PROTO_IPV4)
{
return IP4_FRAG_OFF(frame->frag);
}
#endif
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
else if (net == PICO_PROTO_IPV6)
{
return IP6_FRAG_OFF(frame->frag);
}
#endif
return 0;
}
void pico_ipv6_process_frag(struct pico_ipv6_exthdr *frag, struct pico_frame *f, uint8_t proto)
{
#if defined(PICO_SUPPORT_IPV6) && defined(PICO_SUPPORT_IPV6FRAG)
struct pico_frame *first = NULL;
if (!f || !frag)
{
frag_dbg("Bad arguments provided to pico_ipv6_process_frag\n");
return;
}
first = pico_tree_first(&ipv6_fragments);
if (first)
{
if ((pico_ipv6_frag_match(f, first) == 0 && (IP6_FRAG_ID(frag) == ipv6_cur_frag_id))) {
struct pico_frame *temp = NULL;
temp = pico_frame_copy(f);
if (!temp) {
frag_dbg("Could not allocate memory to continue reassembly of IPV6 fragmented packet (id: %hu)\n", ipv6_cur_frag_id);
return;
}
if (pico_tree_insert(&ipv6_fragments, temp)) {
frag_dbg("FRAG: Could not insert picoframe in tree\n");
pico_frame_discard(temp);
return;
}
}
}
else
{
struct pico_frame *temp = NULL;
if (ipv6_cur_frag_id && (IP6_FRAG_ID(frag) == ipv6_cur_frag_id)) {
/* Discard late arrivals, without firing the timer. */
frag_dbg("discarded late arrival, exp:%hu found:%hu\n", ipv6_cur_frag_id, IP6_FRAG_ID(frag));
return;
}
temp = pico_frame_copy(f);
if (!temp) {
frag_dbg("Could not allocate memory to start reassembly of fragmented packet\n");
return;
}
pico_ipv6_frag_timer_on();
ipv6_cur_frag_id = IP6_FRAG_ID(frag);
frag_dbg("Started new reassembly, ID:%hu\n", ipv6_cur_frag_id);
if (pico_tree_insert(&ipv6_fragments, temp)) {
frag_dbg("FRAG: Could not insert picoframe in tree\n");
pico_frame_discard(temp);
return;
}
}
pico_fragments_check_complete(&ipv6_fragments, proto, PICO_PROTO_IPV6);
#else
IGNORE_PARAMETER(frag);
IGNORE_PARAMETER(f);
IGNORE_PARAMETER(proto);
#endif
}
void pico_ipv4_process_frag(struct pico_ipv4_hdr *hdr, struct pico_frame *f, uint8_t proto)
{
#if defined(PICO_SUPPORT_IPV4) && defined(PICO_SUPPORT_IPV4FRAG)
struct pico_frame *first = NULL;
if (!f || !hdr)
{
frag_dbg("Bad arguments provided to pico_ipv4_process_frag\n");
return;
}
first = pico_tree_first(&ipv4_fragments);
if (first)
{
/* fragments from old packets still in tree, and new first fragment ? */
if ((IP4_FRAG_ID(hdr) != ipv4_cur_frag_id) && (IP4_FRAG_OFF(f->frag) == 0)) {
pico_fragments_empty_tree(&ipv4_fragments);
first = NULL;
ipv4_cur_frag_id = 0;
}
if ((pico_ipv4_frag_match(f, first) == 0 && (IP4_FRAG_ID(hdr) == ipv4_cur_frag_id))) {
struct pico_frame *temp = NULL;
temp = pico_frame_copy(f);
if (!temp) {
frag_dbg("Could not allocate memory to continue reassembly of IPV4 fragmented packet (id: %hu)\n", ipv4_cur_frag_id);
return;
}
if (pico_tree_insert(&ipv4_fragments, temp)) {
frag_dbg("FRAG: Could not insert picoframe in tree\n");
pico_frame_discard(temp);
return;
}
}
}
else
{
struct pico_frame *temp = NULL;
if (ipv4_cur_frag_id && (IP4_FRAG_ID(hdr) == ipv4_cur_frag_id)) {
/* Discard late arrivals, without firing the timer */
return;
}
temp = pico_frame_copy(f);
if (!temp) {
frag_dbg("Could not allocate memory to start reassembly fragmented packet\n");
return;
}
pico_ipv4_frag_timer_on();
ipv4_cur_frag_id = IP4_FRAG_ID(hdr);
frag_dbg("Started new reassembly, ID:%hu\n", ipv4_cur_frag_id);
if (pico_tree_insert(&ipv4_fragments, temp)) {
frag_dbg("FRAG: Could not insert picoframe in tree\n");
pico_frame_discard(temp);
return;
}
}
pico_fragments_check_complete(&ipv4_fragments, proto, PICO_PROTO_IPV4);
#else
IGNORE_PARAMETER(hdr);
IGNORE_PARAMETER(f);
IGNORE_PARAMETER(proto);
#endif
}
Reference in New Issue View Git Blame Copy Permalink