static struct net_buf *copy_buf(struct net_buf *mbuf)
{
struct net_buf *buf;
buf = ip_buf_get_reserve_rx(0);
if(!buf) {
return NULL;
}
/* Copy from the fragment context info buffer first */
linkaddr_copy(&ip_buf_ll_dest(buf),
packetbuf_addr(mbuf, PACKETBUF_ADDR_RECEIVER));
linkaddr_copy(&ip_buf_ll_src(buf),
packetbuf_addr(mbuf, PACKETBUF_ADDR_SENDER));
PRINTF("%s: mbuf datalen %d dataptr %p buf %p\n", __FUNCTION__,
packetbuf_datalen(mbuf), packetbuf_dataptr(mbuf), uip_buf(buf));
if(packetbuf_datalen(mbuf) > 0 &&
packetbuf_datalen(mbuf) <= UIP_BUFSIZE - UIP_LLH_LEN) {
memcpy(uip_buf(buf), packetbuf_dataptr(mbuf), packetbuf_datalen(mbuf));
uip_len(buf) = packetbuf_datalen(mbuf);
net_buf_add(buf, uip_len(buf));
} else {
ip_buf_unref(buf);
buf = NULL;
}
return buf;
}
/* Copy all the fragments that are associated with a specific context into uip */
static struct net_buf *copy_frags2uip(int context)
{
int i, total_len = 0;
struct net_buf *buf;
buf = ip_buf_get_reserve_rx(0);
if(!buf) {
return NULL;
}
/* Copy from the fragment context info buffer first */
linkaddr_copy(&ip_buf_ll_dest(buf), &frag_info[context].receiver);
linkaddr_copy(&ip_buf_ll_src(buf), &frag_info[context].sender);
for(i = 0; i < SICSLOWPAN_FRAGMENT_BUFFERS; i++) {
/* And also copy all matching fragments */
if(frag_buf[i].len > 0 && frag_buf[i].index == context) {
memcpy(uip_buf(buf) + (uint16_t)(frag_buf[i].offset << 3),
(uint8_t *)frag_buf[i].data, frag_buf[i].len);
total_len += frag_buf[i].len;
}
}
net_buf_add(buf, total_len);
uip_len(buf) = total_len;
/* deallocate all the fragments for this context */
clear_fragments(context);
return buf;
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(udp_socket_process, ev, data, buf, user_data)
{
struct udp_socket *c;
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT();
if(ev == tcpip_event) {
/* An appstate pointer is passed to use from the IP stack
through the 'data' pointer. We registered this appstate when
we did the udp_new() call in udp_socket_register() as the
struct udp_socket pointer. So we extract this
pointer and use it when calling the reception callback. */
c = (struct udp_socket *)data;
/* Defensive coding: although the appstate *should* be non-null
here, we make sure to avoid the program crashing on us. */
if(c != NULL) {
/* If we were called because of incoming data, we should call
the reception callback. */
if(uip_newdata(buf)) {
/* Copy the data from the uIP data buffer into our own
buffer to avoid the uIP buffer being messed with by the
callee. */
#if 0
/* Note that we cannot do this as the stack is suppose to be
* re-entrant.
*/
memcpy(bad_buf, uip_appdata(buf), uip_datalen(buf));
#endif
/* Call the client process. We use the PROCESS_CONTEXT
mechanism to temporarily switch process context to the
client process. */
if(c->input_callback != NULL) {
PROCESS_CONTEXT_BEGIN(c->p);
c->input_callback(c, c->ptr,
&(UIP_IP_BUF(buf)->srcipaddr),
UIP_HTONS(UIP_IP_BUF(buf)->srcport),
&(UIP_IP_BUF(buf)->destipaddr),
UIP_HTONS(UIP_IP_BUF(buf)->destport),
uip_buf(buf), uip_datalen(buf));
PROCESS_CONTEXT_END();
}
}
}
}
}
PROCESS_END();
}
/* @brief Transmit the current Ethernet frame.
*
* This procedure will block indefinitely until the Ethernet device is
* ready to accept a new outgoing frame. It then copies the current
* Ethernet frame from the global uip_buf buffer to the device DMA
* buffer and signals to the device that a new frame is available to be
* transmitted.
*/
static int eth_tx(struct device *port, struct net_buf *buf)
{
struct eth_runtime *context = port->driver_data;
struct eth_config *config = port->config->config_info;
uint32_t base_addr = config->base_addr;
/* Wait until the TX descriptor is no longer owned by the device. */
while (context->tx_desc.own == 1) {
}
#ifdef CONFIG_ETHERNET_DEBUG
/* Check whether an error occurred transmitting the previous frame. */
if (context->tx_desc.err_summary) {
ETH_ERR("Error transmitting frame: TDES0 = %08x, TDES1 = %08x.\n",
context->tx_desc.tdes0, context->tx_desc.tdes1);
}
#endif
/* Transmit the next frame. */
if (uip_len(buf) > UIP_BUFSIZE) {
ETH_ERR("Frame too large to TX: %u\n", uip_len(buf));
return -1;
}
memcpy((void *)context->tx_buf, uip_buf(buf), uip_len(buf));
context->tx_desc.tx_buf1_sz = uip_len(buf);
context->tx_desc.own = 1;
/* Request that the device check for an available TX descriptor, since
* ownership of the descriptor was just transferred to the device.
*/
eth_write(base_addr, REG_ADDR_TX_POLL_DEMAND, 1);
return 1;
}
/* This is called by contiki/ip/tcpip.c:tcpip_uipcall() when packet
* is processed.
*/
PROCESS_THREAD(tcp, ev, data, buf, user_data)
{
PROCESS_BEGIN();
while(1) {
PROCESS_YIELD_UNTIL(ev == tcpip_event);
if (POINTER_TO_INT(data) == TCP_WRITE_EVENT) {
/* We want to send data to peer. */
struct net_context *context = user_data;
if (!context) {
continue;
}
do {
context = user_data;
if (!context || !buf) {
break;
}
if (!context->ps.net_buf ||
context->ps.net_buf != buf) {
NET_DBG("psock init %p buf %p\n",
&context->ps, buf);
PSOCK_INIT(&context->ps, buf);
}
handle_tcp_connection(&context->ps,
POINTER_TO_INT(data),
buf);
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
if (POINTER_TO_INT(data) != TCP_WRITE_EVENT) {
goto read_data;
}
} while(!(uip_closed(buf) ||
uip_aborted(buf) ||
uip_timedout(buf)));
context = user_data;
if (context &&
context->tcp_type == NET_TCP_TYPE_CLIENT) {
NET_DBG("\nConnection closed.\n");
ip_buf_sent_status(buf) = -ECONNRESET;
}
continue;
}
read_data:
/* We are receiving data from peer. */
if (buf && uip_newdata(buf)) {
struct net_buf *clone;
if (!uip_len(buf)) {
continue;
}
/* Note that uIP stack will reuse the buffer when
* sending ACK to peer host. The sending will happen
* right after this function returns. Because of this
* we cannot use the same buffer to pass data to
* application.
*/
clone = net_buf_clone(buf);
if (!clone) {
NET_ERR("No enough RX buffers, "
"packet %p discarded\n", buf);
continue;
}
ip_buf_appdata(clone) = uip_buf(clone) +
(ip_buf_appdata(buf) - (void *)uip_buf(buf));
ip_buf_appdatalen(clone) = uip_len(buf);
ip_buf_len(clone) = ip_buf_len(buf);
ip_buf_context(clone) = user_data;
uip_set_conn(clone) = uip_conn(buf);
uip_flags(clone) = uip_flags(buf);
uip_flags(clone) |= UIP_CONNECTED;
NET_DBG("packet received context %p buf %p len %d "
"appdata %p appdatalen %d\n",
ip_buf_context(clone),
clone,
ip_buf_len(clone),
ip_buf_appdata(clone),
ip_buf_appdatalen(clone));
nano_fifo_put(net_context_get_queue(user_data), clone);
/* We let the application to read the data now */
fiber_yield();
}
}
PROCESS_END();
}
static int fragment(struct net_buf *buf, void *ptr)
{
struct queuebuf *q;
int max_payload;
int framer_hdrlen;
uint16_t frag_tag;
/* Number of bytes processed. */
uint16_t processed_ip_out_len;
struct net_buf *mbuf;
bool last_fragment = false;
#define USE_FRAMER_HDRLEN 0
#if USE_FRAMER_HDRLEN
framer_hdrlen = NETSTACK_FRAMER.length();
if(framer_hdrlen < 0) {
/* Framing failed, we assume the maximum header length */
framer_hdrlen = 21;
}
#else /* USE_FRAMER_HDRLEN */
framer_hdrlen = 21;
#endif /* USE_FRAMER_HDRLEN */
max_payload = MAC_MAX_PAYLOAD - framer_hdrlen - NETSTACK_LLSEC.get_overhead();
PRINTF("max_payload: %d, framer_hdrlen: %d \n",max_payload, framer_hdrlen);
mbuf = l2_buf_get_reserve(0);
if (!mbuf) {
goto fail;
}
uip_last_tx_status(mbuf) = MAC_TX_OK;
/*
* The destination address will be tagged to each outbound
* packet. If the argument localdest is NULL, we are sending a
* broadcast packet.
*/
if((int)uip_len(buf) <= max_payload) {
/* The packet does not need to be fragmented, send buf */
packetbuf_copyfrom(mbuf, uip_buf(buf), uip_len(buf));
send_packet(mbuf, &ip_buf_ll_dest(buf), true, ptr);
ip_buf_unref(buf);
return 1;
}
uip_uncomp_hdr_len(mbuf) = 0;
uip_packetbuf_hdr_len(mbuf) = 0;
packetbuf_clear(mbuf);
uip_packetbuf_ptr(mbuf) = packetbuf_dataptr(mbuf);
packetbuf_set_attr(mbuf, PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS,
SICSLOWPAN_MAX_MAC_TRANSMISSIONS);
PRINTF("fragmentation: total packet len %d\n", uip_len(buf));
/*
* The outbound IPv6 packet is too large to fit into a single 15.4
* packet, so we fragment it into multiple packets and send them.
* The first fragment contains frag1 dispatch, then
* IPv6/HC1/HC06/HC_UDP dispatchs/headers.
* The following fragments contain only the fragn dispatch.
*/
int estimated_fragments = ((int)uip_len(buf)) / ((int)MAC_MAX_PAYLOAD - SICSLOWPAN_FRAGN_HDR_LEN) + 1;
int freebuf = queuebuf_numfree(mbuf) - 1;
PRINTF("uip_len: %d, fragments: %d, free bufs: %d\n", uip_len(buf), estimated_fragments, freebuf);
if(freebuf < estimated_fragments) {
PRINTF("Dropping packet, not enough free bufs\n");
goto fail;
}
/* Create 1st Fragment */
SET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE,
((SICSLOWPAN_DISPATCH_FRAG1 << 8) | uip_len(buf)));
frag_tag = my_tag++;
SET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_TAG, frag_tag);
PRINTF("fragmentation: fragment %d \n", frag_tag);
/* Copy payload and send */
uip_packetbuf_hdr_len(mbuf) += SICSLOWPAN_FRAG1_HDR_LEN;
uip_packetbuf_payload_len(mbuf) = (max_payload - uip_packetbuf_hdr_len(mbuf)) & 0xfffffff8;
PRINTF("(payload len %d, hdr len %d, tag %d)\n",
uip_packetbuf_payload_len(mbuf), uip_packetbuf_hdr_len(mbuf), frag_tag);
memcpy(uip_packetbuf_ptr(mbuf) + uip_packetbuf_hdr_len(mbuf),
uip_buf(buf), uip_packetbuf_payload_len(mbuf));
packetbuf_set_datalen(mbuf, uip_packetbuf_payload_len(mbuf) + uip_packetbuf_hdr_len(mbuf));
q = queuebuf_new_from_packetbuf(mbuf);
if(q == NULL) {
PRINTF("could not allocate queuebuf for first fragment, dropping packet\n");
goto fail;
}
net_buf_ref(mbuf);
send_packet(mbuf, &ip_buf_ll_dest(buf), last_fragment, ptr);
queuebuf_to_packetbuf(mbuf, q);
queuebuf_free(q);
q = NULL;
/* Check tx result. */
if((uip_last_tx_status(mbuf) == MAC_TX_COLLISION) ||
(uip_last_tx_status(mbuf) == MAC_TX_ERR) ||
(uip_last_tx_status(mbuf) == MAC_TX_ERR_FATAL)) {
PRINTF("error in fragment tx, dropping subsequent fragments.\n");
goto fail;
}
/* set processed_ip_out_len to what we already sent from the IP payload*/
processed_ip_out_len = uip_packetbuf_payload_len(mbuf);
/*
* Create following fragments
* Datagram tag is already in the buffer, we need to set the
* FRAGN dispatch and for each fragment, the offset
*/
uip_packetbuf_hdr_len(mbuf) = SICSLOWPAN_FRAGN_HDR_LEN;
SET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE,
((SICSLOWPAN_DISPATCH_FRAGN << 8) | uip_len(buf)));
uip_packetbuf_payload_len(mbuf) = (max_payload - uip_packetbuf_hdr_len(mbuf)) & 0xfffffff8;
while(processed_ip_out_len < uip_len(buf)) {
PRINTF("fragmentation: fragment:%d, processed_ip_out_len:%d \n", my_tag, processed_ip_out_len);
uip_packetbuf_ptr(mbuf)[PACKETBUF_FRAG_OFFSET] = processed_ip_out_len >> 3;
/* Copy payload and send */
if(uip_len(buf) - processed_ip_out_len < uip_packetbuf_payload_len(mbuf)) {
/* last fragment */
last_fragment = true;
uip_packetbuf_payload_len(mbuf) = uip_len(buf) - processed_ip_out_len;
}
PRINTF("(offset %d, len %d, tag %d)\n",
processed_ip_out_len >> 3, uip_packetbuf_payload_len(mbuf), my_tag);
memcpy(uip_packetbuf_ptr(mbuf) + uip_packetbuf_hdr_len(mbuf),
(uint8_t *)UIP_IP_BUF(buf) + processed_ip_out_len, uip_packetbuf_payload_len(mbuf));
packetbuf_set_datalen(mbuf, uip_packetbuf_payload_len(mbuf) + uip_packetbuf_hdr_len(mbuf));
q = queuebuf_new_from_packetbuf(mbuf);
if(q == NULL) {
PRINTF("could not allocate queuebuf, dropping fragment\n");
goto fail;
}
net_buf_ref(mbuf);
send_packet(mbuf, &ip_buf_ll_dest(buf), last_fragment, ptr);
queuebuf_to_packetbuf(mbuf, q);
queuebuf_free(q);
q = NULL;
processed_ip_out_len += uip_packetbuf_payload_len(mbuf);
/* Check tx result. */
if((uip_last_tx_status(mbuf) == MAC_TX_COLLISION) ||
(uip_last_tx_status(mbuf) == MAC_TX_ERR) ||
(uip_last_tx_status(mbuf) == MAC_TX_ERR_FATAL)) {
PRINTF("error in fragment tx, dropping subsequent fragments.\n");
goto fail;
}
}
ip_buf_unref(buf);
l2_buf_unref(mbuf);
return 1;
fail:
if (mbuf) {
l2_buf_unref(mbuf);
}
return 0;
}
/*-----------------------------------------------------------------------------------*/
void
uip_arp_out(struct net_buf *buf)
{
struct arp_entry *tabptr = arp_table;
/* Find the destination IP address in the ARP table and construct
the Ethernet header. If the destination IP addres isn't on the
local network, we use the default router's IP address instead.
If not ARP table entry is found, we overwrite the original IP
packet with an ARP request for the IP address. */
/* First check if destination is a local broadcast. */
if(uip_ipaddr_cmp(&IPBUF(buf)->destipaddr, &uip_broadcast_addr)) {
memcpy(IPBUF(buf)->ethhdr.dest.addr, broadcast_ethaddr.addr, 6);
} else if(IPBUF(buf)->destipaddr.u8[0] == 224) {
/* Multicast. */
IPBUF(buf)->ethhdr.dest.addr[0] = 0x01;
IPBUF(buf)->ethhdr.dest.addr[1] = 0x00;
IPBUF(buf)->ethhdr.dest.addr[2] = 0x5e;
IPBUF(buf)->ethhdr.dest.addr[3] = IPBUF(buf)->destipaddr.u8[1];
IPBUF(buf)->ethhdr.dest.addr[4] = IPBUF(buf)->destipaddr.u8[2];
IPBUF(buf)->ethhdr.dest.addr[5] = IPBUF(buf)->destipaddr.u8[3];
} else {
/* Check if the destination address is on the local network. */
if(!uip_ipaddr_maskcmp(&IPBUF(buf)->destipaddr, &uip_hostaddr, &uip_netmask)) {
/* Destination address was not on the local network, so we need to
use the default router's IP address instead of the destination
address when determining the MAC address. */
uip_ipaddr_copy(&ipaddr, &uip_draddr);
} else {
/* Else, we use the destination IP address. */
uip_ipaddr_copy(&ipaddr, &IPBUF(buf)->destipaddr);
}
for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
if(uip_ipaddr_cmp(&ipaddr, &tabptr->ipaddr)) {
break;
}
tabptr++;
}
if(i == UIP_ARPTAB_SIZE) {
/* The destination address was not in our ARP table, so we
overwrite the IP packet with an ARP request. */
memset(BUF(buf)->ethhdr.dest.addr, 0xff, 6);
memset(BUF(buf)->dhwaddr.addr, 0x00, 6);
memcpy(BUF(buf)->ethhdr.src.addr, uip_lladdr.addr, 6);
memcpy(BUF(buf)->shwaddr.addr, uip_lladdr.addr, 6);
uip_ipaddr_copy(&BUF(buf)->dipaddr, &ipaddr);
uip_ipaddr_copy(&BUF(buf)->sipaddr, &uip_hostaddr);
BUF(buf)->opcode = UIP_HTONS(ARP_REQUEST); /* ARP request. */
BUF(buf)->hwtype = UIP_HTONS(ARP_HWTYPE_ETH);
BUF(buf)->protocol = UIP_HTONS(UIP_ETHTYPE_IP);
BUF(buf)->hwlen = 6;
BUF(buf)->protolen = 4;
BUF(buf)->ethhdr.type = UIP_HTONS(UIP_ETHTYPE_ARP);
uip_appdata(buf) = &uip_buf(buf)[UIP_TCPIP_HLEN + UIP_LLH_LEN];
uip_len(buf) = sizeof(struct arp_hdr);
return;
}
/* Build an ethernet header. */
memcpy(IPBUF(buf)->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
}
memcpy(IPBUF(buf)->ethhdr.src.addr, uip_lladdr.addr, 6);
IPBUF(buf)->ethhdr.type = UIP_HTONS(UIP_ETHTYPE_IP);
uip_len(buf) += sizeof(struct uip_eth_hdr);
}
