hero123457/uhd
1
0
Fork 0
mirror of https://github.com/EttusResearch/uhd.git synced 2026-10-25 17:36:10 +00:00
Code Issues Projects Releases Wiki Activity
d9656de88f
uhd/firmware/octoclock/lib/network.c
Nicholas Corgan d9656de88f OctoClock bugfixes 
* Bumped compatibility version to 3
* firmware: Ethernet, clkdist bugfixes
* lib: fixed invalid rev detection
2015-07-09 09:13:41 -07:00

449 lines
14 KiB
C
Raw Blame History

/*
* Copyright 2009-2012,2014 Ettus Research LLC
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <string.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <lwip/ip.h>
#include <lwip/udp.h>
#include <lwip/icmp.h>
#include <debug.h>
#include <octoclock.h>
#include <state.h>
#include <network.h>
#include <net/enc28j60.h>
#include <net/eth_hdr.h>
#include <net/if_arp.h>
#include <net/ethertype.h>
#include <util/delay.h>
#include "arp_cache.h"
/***********************************************************************
* Constants + Globals
**********************************************************************/
static const size_t out_buff_size = ETH_BUF_SIZE;
static const eth_mac_addr_t BCAST_MAC_ADDR = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}};
#define MAX_UDP_LISTENERS 10
/***********************************************************************
* 16-bit one's complement sum
**********************************************************************/
static uint32_t chksum_buffer(
uint16_t *buf, size_t nshorts,
uint32_t initial_chksum
){
uint32_t chksum = initial_chksum;
for (size_t i = 0; i < nshorts; i++) chksum += buf[i];
while (chksum >> 16) chksum = (chksum & 0xffff) + (chksum >> 16);
return chksum;
}
/***********************************************************************
* Listener registry
**********************************************************************/
static eth_mac_addr_t _local_mac_addr;
static struct ip_addr _local_ip_addr;
struct listener_entry {
unsigned short port;
udp_receiver_t rcvr;
};
static struct listener_entry listeners[MAX_UDP_LISTENERS];
void init_udp_listeners(void){
for (int i = 0; i < MAX_UDP_LISTENERS; i++)
listeners[i].rcvr = NULL;
}
static struct listener_entry *
find_listener_by_port(unsigned short port)
{
port = ntohs(port);
for (int i = 0; i < MAX_UDP_LISTENERS; i++){
if (port == listeners[i].port)
return &listeners[i];
}
return 0;
}
static struct listener_entry *
find_free_listener(void)
{
for (int i = 0; i < MAX_UDP_LISTENERS; i++){
if (listeners[i].rcvr == NULL)
return &listeners[i];
}
abort();
}
void
register_udp_listener(int port, udp_receiver_t rcvr)
{
struct listener_entry *lx = find_listener_by_port(port);
if (lx)
lx->rcvr = rcvr;
else {
lx = find_free_listener();
lx->port = port;
lx->rcvr = rcvr;
}
}
/*!
* low level routine to assembly an ethernet frame and send it.
*
* \param dst destination mac address
* \param ethertype ethertype field
* \param buf0 first part of data
* \param len0 length of first part of data
* \param buf1 second part of data
* \param len1 length of second part of data
* \param buf2 third part of data
* \param len2 length of third part of data
*/
static void
send_pkt(
eth_mac_addr_t dst, int ethertype,
const void *buf0, size_t len0,
const void *buf1, size_t len1,
const void *buf2, size_t len2
){
//assemble the ethernet header
eth_hdr_t ehdr;
ehdr.dst = dst;
ehdr.src = _local_mac_addr;
ehdr.ethertype = ethertype;
//grab an out buffer and pointer
//select the output buffer based on type of packet
uint8_t *p;
p = eth_buf;
size_t total_len = 0;
//create a list of all buffers to copy
const void *buffs[] = {&ehdr, buf0, buf1, buf2};
size_t lens[] = {sizeof(ehdr), len0, len1, len2};
//copy each buffer into the out buffer
for (size_t i = 0; i < sizeof(buffs)/sizeof(buffs[0]); i++){
total_len += lens[i]; //use full length (not clipped)
size_t bytes_remaining = out_buff_size - (size_t)(p - (uint8_t*)eth_buf);
if (lens[i] > bytes_remaining) lens[i] = bytes_remaining;
memcpy(p, buffs[i], lens[i]);
p += lens[i];
}
//ensure that minimum length requirements are met
if (total_len < 64) total_len = 64; //60 + ctrl word
//For some reason, the ENC28J60 won't send the CRC
//if you don't tell it to send another byte after
//the given packet
enc28j60_send(eth_buf, total_len);
}
static void
send_ip_pkt(struct ip_addr dst, int protocol,
const void *buf0, uint16_t len0,
const void *buf1, uint16_t len1)
{
struct ip_hdr ip;
_IPH_VHLTOS_SET(&ip, 4, 5, 0);
_IPH_LEN_SET(&ip, (IP_HLEN + len0 + len1));
_IPH_ID_SET(&ip, 0);
_IPH_OFFSET_SET(&ip, htons(IP_DF)); /* don't fragment */
_IPH_TTL_SET(&ip, 64);
_IPH_PROTO_SET(&ip, protocol);
_IPH_CHKSUM_SET(&ip, 0);
ip.src.addr = htonl(_local_ip_addr.addr);
ip.dest = dst;
_IPH_CHKSUM_SET(&ip, ~chksum_buffer(
(uint16_t *) &ip, sizeof(ip)/sizeof(int16_t), 0
));
eth_mac_addr_t dst_mac;
bool found = arp_cache_lookup_mac(&ip.dest, &dst_mac);
if (!found) return;
send_pkt(dst_mac, htons(ETHERTYPE_IPV4),
&ip, sizeof(ip), buf0, len0, buf1, len1);
}
void
send_udp_pkt(int src_port, struct socket_address dst,
const void *buf, size_t len)
{
struct udp_hdr udp _AL2;
udp.src = htons(src_port);
udp.dest = htons(dst.port);
udp.len = htons(UDP_HLEN + len);
udp.chksum = 0;
send_ip_pkt(dst.addr, IP_PROTO_UDP,
&udp, sizeof(udp), buf, len);
}
static void
handle_udp_packet(struct ip_addr src_ip, struct ip_addr dst_ip,
struct udp_hdr *udp, size_t len)
{
unsigned char *payload = ((unsigned char *) udp) + UDP_HLEN;
int payload_len = len - UDP_HLEN;
struct listener_entry *lx = find_listener_by_port(udp->dest);
if (lx){
struct socket_address src = make_socket_address(src_ip, ntohs(udp->src));
struct socket_address dst = make_socket_address(dst_ip, ntohs(udp->dest));
lx->rcvr(src, dst, payload, payload_len);
}
}
static void
handle_icmp_packet(struct ip_addr src, struct ip_addr dst,
struct icmp_echo_hdr *icmp, size_t len)
{
switch (icmp->type){
case ICMP_DUR: // Destination Unreachable
if (icmp->code == ICMP_DUR_PORT){ // port unreachable
//filter out non udp data response
struct ip_hdr *ip = (struct ip_hdr *)(((uint8_t*)icmp) + sizeof(struct icmp_echo_hdr));
struct udp_hdr *udp = (struct udp_hdr *)(((char *)ip) + IP_HLEN);
uint8_t protocol = ntohs(ip->_ttl_proto) & 0xff;
if (protocol != IP_PROTO_UDP) break;
struct listener_entry *lx = find_listener_by_port(udp->src);
if (lx){
struct socket_address src = make_socket_address(ip->src, udp->src);
struct socket_address dst = make_socket_address(ip->dest, udp->dest);
lx->rcvr(src, dst, NULL, 0);
}
}
break;
case ICMP_ECHO:{
const void *icmp_data_buff = ((uint8_t*)icmp) + sizeof(struct icmp_echo_hdr);
uint16_t icmp_data_len = len - sizeof(struct icmp_echo_hdr);
struct icmp_echo_hdr echo_reply;
echo_reply.type = 0;
echo_reply.code = 0;
echo_reply.chksum = 0;
echo_reply.id = icmp->id;
echo_reply.seqno = icmp->seqno;
echo_reply.chksum = ~chksum_buffer( //data checksum
(uint16_t *)icmp_data_buff,
icmp_data_len/sizeof(int16_t),
chksum_buffer( //header checksum
(uint16_t *)&echo_reply,
sizeof(echo_reply)/sizeof(int16_t),
0)
);
send_ip_pkt(
src, IP_PROTO_ICMP,
&echo_reply, sizeof(echo_reply),
icmp_data_buff, icmp_data_len
);
break;
}
default:
break;
}
}
static void
send_arp_reply(struct arp_eth_ipv4 *req, eth_mac_addr_t our_mac)
{
struct arp_eth_ipv4 reply _AL4;
reply.ar_hrd = req->ar_hrd;
reply.ar_pro = req->ar_pro;
reply.ar_hln = req->ar_hln;
reply.ar_pln = req->ar_pln;
reply.ar_op = htons(ARPOP_REPLY);
memcpy(reply.ar_sha, &our_mac, 6);
memcpy(reply.ar_sip, req->ar_tip, 4);
memcpy(reply.ar_tha, req->ar_sha, 6);
memcpy(reply.ar_tip, req->ar_sip, 4);
eth_mac_addr_t t;
memcpy(t.addr, reply.ar_tha, 6);
send_pkt(t, htons(ETHERTYPE_ARP), &reply, sizeof(reply), 0, 0, 0, 0);
}
static void
handle_arp_packet(struct arp_eth_ipv4 *p, size_t size)
{
if (size < sizeof(struct arp_eth_ipv4))
return;
if (ntohs(p->ar_hrd) != ARPHRD_ETHER
|| ntohs(p->ar_pro) != ETHERTYPE_IPV4
|| p->ar_hln != 6
|| p->ar_pln != 4)
return;
if(ntohs(p->ar_op) == ARPOP_REPLY){
struct ip_addr ip_addr;
memcpy(&ip_addr, p->ar_sip, sizeof(ip_addr));
eth_mac_addr_t mac_addr;
memcpy(&mac_addr, p->ar_sha, sizeof(mac_addr));
arp_cache_update(&ip_addr, &mac_addr);
}
if (ntohs(p->ar_op) != ARPOP_REQUEST)
return;
struct ip_addr sip;
struct ip_addr tip;
memcpy(&(sip.addr), &(p->ar_sip), 4);
memcpy(&(tip.addr), &(p->ar_tip), 4);
sip.addr = ntohl(sip.addr);
tip.addr = ntohl(tip.addr);
if(memcmp(&tip, &_local_ip_addr, sizeof(_local_ip_addr)) == 0){ //They're looking for us
send_arp_reply(p, _local_mac_addr);
}
}
void
handle_eth_packet(size_t recv_len)
{
eth_hdr_t *eth_hdr = (eth_hdr_t *)eth_buf;
uint16_t ethertype = htons(eth_hdr->ethertype);
if (ethertype == ETHERTYPE_ARP){
struct arp_eth_ipv4 *arp = (struct arp_eth_ipv4 *)(eth_buf + sizeof(eth_hdr_t));
handle_arp_packet(arp, recv_len-ETH_HLEN);
}
else if (ethertype == ETHERTYPE_IPV4){
struct ip_hdr *ip = (struct ip_hdr *)(eth_buf + sizeof(eth_hdr_t));
if (_IPH_V(ip) != 4 || _IPH_HL(ip) != 5) // ignore pkts w/ bad version or options
return;
if (_IPH_OFFSET(ip) & (IP_MF | IP_OFFMASK)) // ignore fragmented packets
return;
// filter on dest ip addr (should be broadcast or for us)
bool is_bcast = memcmp(&eth_hdr->dst, &BCAST_MAC_ADDR, sizeof(BCAST_MAC_ADDR)) == 0;
struct ip_addr htonl_local_ip_addr;
htonl_local_ip_addr.addr = htonl(_local_ip_addr.addr);
bool is_my_ip = memcmp(&ip->dest, &htonl_local_ip_addr, sizeof(_local_ip_addr)) == 0;
if (!is_bcast && !is_my_ip) return;
arp_cache_update(&ip->src, (eth_mac_addr_t *)(((char *)eth_buf)+6));
switch (_IPH_PROTO(ip)){
case IP_PROTO_UDP:
handle_udp_packet(ip->src, ip->dest, (struct udp_hdr *)(((char *)ip) + IP_HLEN), (recv_len-ETH_HLEN-IP_HLEN));
break;
case IP_PROTO_ICMP:
handle_icmp_packet(ip->src, ip->dest, (struct icmp_echo_hdr *)(((char *)ip) + IP_HLEN), (recv_len-ETH_HLEN-IP_HLEN));
break;
default: // ignore
break;
}
}
else
return; // Not ARP or IPV4, ignore
}
/***********************************************************************
* Timer+GARP stuff
**********************************************************************/
static bool send_garp = false;
static uint32_t num_overflows = 0;
// Six overflows is the closest overflow count to one minute.
ISR(TIMER1_OVF_vect){
num_overflows++;
if(!(num_overflows % 6)) send_garp = true;
}
// Send a GARP packet once per minute.
static void
send_gratuitous_arp(){
send_garp = false;
//Need to htonl IP address
struct ip_addr htonl_ip_addr;
htonl_ip_addr.addr = htonl(_local_ip_addr.addr);
struct arp_eth_ipv4 req _AL4;
req.ar_hrd = htons(ARPHRD_ETHER);
req.ar_pro = htons(ETHERTYPE_IPV4);
req.ar_hln = sizeof(eth_mac_addr_t);
req.ar_pln = sizeof(struct ip_addr);
req.ar_op = htons(ARPOP_REQUEST);
memcpy(req.ar_sha, &_local_mac_addr, sizeof(eth_mac_addr_t));
memcpy(req.ar_sip, &htonl_ip_addr, sizeof(struct ip_addr));
memset(req.ar_tha, 0x00, sizeof(eth_mac_addr_t));
memcpy(req.ar_tip, &htonl_ip_addr, sizeof(struct ip_addr));
//Send the request with the broadcast MAC address
send_pkt(BCAST_MAC_ADDR, htons(ETHERTYPE_ARP), &req, sizeof(req), 0, 0, 0, 0);
}
// Executed every loop
void network_check(void){
size_t recv_len = enc28j60_recv(eth_buf, ETH_BUF_SIZE);
if(recv_len > 0) handle_eth_packet(recv_len);
if(send_garp) send_gratuitous_arp();
}
void network_init(void){
/*
* Read MAC address from EEPROM and initialize Ethernet driver. If EEPROM is blank,
* use default MAC address instead.
*/
eeprom_busy_wait();
if(eeprom_read_byte(0) == 0xFF){
_MAC_ADDR(_local_mac_addr.addr, 0x00,0x80,0x2F,0x11,0x22,0x33);
_local_ip_addr.addr = _IP(192,168,10,3);
using_network_defaults = true;
}
else{
eeprom_read_block((void*)&_local_mac_addr, (void*)OCTOCLOCK_EEPROM_MAC_ADDR, 6);
eeprom_read_block((void*)&_local_ip_addr, (void*)OCTOCLOCK_EEPROM_IP_ADDR, 4);
using_network_defaults = false;
}
enc28j60_init((uint8_t*)&_local_mac_addr);
init_udp_listeners();
send_garp = true;
}
Reference in New Issue View Git Blame Copy Permalink