Subversion Repositories tcp_socket

////////////////////////////////////////////////////////////////////////////////

//

//  CHIPS-2.0 TCP/IP SERVER

//

//  :Author: Jonathan P Dawson

//  :Date: 17/10/2013

//  :email: chips@jondawson.org.uk

//  :license: MIT

//  :Copyright: Copyright (C) Jonathan P Dawson 2013

//

//  A TCP/IP stack that supports a single socket connection.

//

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

// TCP-IP User Settings

//

const unsigned local_mac_address_hi = 0x0001u;

const unsigned local_mac_address_med = 0x0203u;

const unsigned local_mac_address_lo = 0x0405u;

const unsigned local_ip_address_hi = 0xc0A8u;//192/168

const unsigned local_ip_address_lo = 0x0101u;//1/1

const unsigned local_port = 80u;//http

////////////////////////////////////////////////////////////////////////////////

// TCP-IP GLOBALS

//

unsigned tx_packet[512];

////////////////////////////////////////////////////////////////////////////////

// Checksum calculation routines

//

//store checksum in a global variable

//unsigneds are 16 bits, so use an array of 2 to hold a 32 bit number

long unsigned checksum;

//Reset checksum before calculation

//

void reset_checksum(){

  checksum = 0;

}

//Add 16 bit data value to 32 bit checksum value

//

void add_checksum(unsigned data){

  checksum += data;

  if(checksum & 0x10000ul){

          checksum &= 0xffffu;

          checksum += 1;

  }

}

//Retrieve the calculated checksum

//

unsigned check_checksum(){

  return ~checksum;

}

////////////////////////////////////////////////////////////////////////////////

// UTILITY FUNCTIONS

//

unsigned calc_ack(unsigned ack[], unsigned seq[], unsigned length){

        //given a two word sequence number and a one word length

        //calculate a two word acknowledgement number

        //check whether we have new data or not

        unsigned new_ack_0;

        unsigned new_ack_1;

        unsigned return_value = 0;

        new_ack_0 = seq[0] + length;

        new_ack_1 = seq[1];

        if(new_ack_0 < length) new_ack_1 = new_ack_1 + 1;

        //Is this data we have allready acknowledged?

        if((new_ack_0 != ack[0]) || (new_ack_1 != ack[1])){

                ack[0] = new_ack_0;

                ack[1] = new_ack_1;

                return_value = 1;

        }

        return return_value;

}

////////////////////////////////////////////////////////////////////////////////

// Data Link Layer - Ethernet

//

void put_ethernet_packet(

                unsigned packet[],

                unsigned number_of_bytes,

                unsigned destination_mac_address_hi,

                unsigned destination_mac_address_med,

                unsigned destination_mac_address_lo,

                unsigned protocol){

        unsigned byte, index;

        report(number_of_bytes);

        //set up ethernet header

        packet[0] = destination_mac_address_hi;

        packet[1] = destination_mac_address_med;

        packet[2] = destination_mac_address_lo;

        packet[3] = local_mac_address_hi;

        packet[4] = local_mac_address_med;

        packet[5] = local_mac_address_lo;

        packet[6] = protocol;

        put_eth(number_of_bytes);

        index = 0;

        for(byte=0; byte<number_of_bytes; byte+=2){

                put_eth(packet[index]);

                index ++;

        }

}

//Get a packet from the ethernet interface

//Will reply to arp requests

//returns the number of bytes read which may be 0

unsigned get_ethernet_packet(unsigned packet[]){

        unsigned number_of_bytes, index;

        unsigned byte;

        if(!rdy_eth()) return 0;

        number_of_bytes = get_eth();

        index = 0;

        for(byte=0; byte<number_of_bytes; byte+=2){

                packet[index] = get_eth();

                index ++;

        }

        //Filter out packets not meant for us

        if(packet[0] != local_mac_address_hi && packet[0] != 0xffffu) return 0;

        if(packet[1] != local_mac_address_med && packet[1] != 0xffffu) return 0;

        if(packet[2] != local_mac_address_lo && packet[2] != 0xffffu) return 0;

        //Process ARP requests within the data link layer

        if (packet[6] == 0x0806){ //ARP

                //respond to requests

                if (packet[10] == 0x0001){

                        //construct and send an ARP response

                        tx_packet[7] = 0x0001; //HTYPE ethernet

                        tx_packet[8] = 0x0800; //PTYPE IPV4

                        tx_packet[9] = 0x0604; //HLEN, PLEN

                        tx_packet[10] = 0x0002; //OPER=REPLY

                        tx_packet[11] = local_mac_address_hi; //SENDER_HARDWARE_ADDRESS

                        tx_packet[12] = local_mac_address_med; //SENDER_HARDWARE_ADDRESS

                        tx_packet[13] = local_mac_address_lo; //SENDER_HARDWARE_ADDRESS

                        tx_packet[14] = local_ip_address_hi; //SENDER_PROTOCOL_ADDRESS

                        tx_packet[15] = local_ip_address_lo; //SENDER_PROTOCOL_ADDRESS

                        tx_packet[16] = packet[11]; //TARGET_HARDWARE_ADDRESS

                        tx_packet[17] = packet[12]; //

                        tx_packet[18] = packet[13]; //

                        tx_packet[19] = packet[14]; //TARGET_PROTOCOL_ADDRESS

                        tx_packet[20] = packet[15]; //

                        put_ethernet_packet(

                                tx_packet,

                                64,

                                packet[11],

                                packet[12],

                                packet[13],

                                0x0806);

                }

                return 0;

        }

        return number_of_bytes;

}

unsigned arp_ip_hi[16];

unsigned arp_ip_lo[16];

unsigned arp_mac_0[16];

unsigned arp_mac_1[16];

unsigned arp_mac_2[16];

unsigned arp_pounsigneder = 0;

//return the location of the ip address in the arp cache table

unsigned get_arp_cache(unsigned ip_hi, unsigned ip_lo){

        unsigned number_of_bytes;

        unsigned byte;

        unsigned packet[16];

        unsigned i;

        //Is the requested IP in the ARP cache?

        for(i=0; i<16; i++){

                if(arp_ip_hi[i] == ip_hi && arp_ip_lo[i] == ip_lo){

                        return i;

                }

        }

        //It is not, so send an arp request

        tx_packet[7] = 0x0001u; //HTYPE ethernet

        tx_packet[8] = 0x0800u; //PTYPE IPV4

        tx_packet[9] = 0x0604u; //HLEN, PLEN

        tx_packet[10] = 0x0001u; //OPER=REQUEST

        tx_packet[11] = local_mac_address_hi; //SENDER_HARDWARE_ADDRESS

        tx_packet[12] = local_mac_address_med; //SENDER_HARDWARE_ADDRESS

        tx_packet[13] = local_mac_address_lo; //SENDER_HARDWARE_ADDRESS

        tx_packet[14] = local_ip_address_hi; //SENDER_PROTOCOL_ADDRESS

        tx_packet[15] = local_ip_address_lo; //SENDER_PROTOCOL_ADDRESS

        tx_packet[19] = ip_hi; //TARGET_PROTOCOL_ADDRESS

        tx_packet[20] = ip_lo; //

        put_ethernet_packet(

                tx_packet,

                64u,

                0xffffu, //broadcast via ethernet

                0xffffu,

                0xffffu,

                0x0806u);

        //wait for a response

        while(1){

                number_of_bytes = get_eth();

                i = 0;

                for(byte=0; byte<number_of_bytes; byte+=2){

                        //only keep the part of the packet we care about

                        if(i < 16){

                                packet[i] = get_eth();

                        } else {

                                get_eth();

                        }

                        i++;

                }

                //Process ARP requests within the data link layer

                if (packet[6] == 0x0806 && packet[10] == 0x0002){

                        if (packet[14] == ip_hi && packet[15] == ip_lo){

                                arp_ip_hi[arp_pounsigneder] = ip_hi;

                                arp_ip_lo[arp_pounsigneder] = ip_lo;

                                arp_mac_0[arp_pounsigneder] = packet[11];

                                arp_mac_1[arp_pounsigneder] = packet[12];

                                arp_mac_2[arp_pounsigneder] = packet[13];

                                i = arp_pounsigneder;

                                arp_pounsigneder++;

                                if(arp_pounsigneder == 16) arp_pounsigneder = 0;

                                return i;

                        }

                }

        }

}

////////////////////////////////////////////////////////////////////////////////

// Network Layer - Internet Protocol

//

void put_ip_packet(unsigned packet[], unsigned total_length, unsigned protocol, unsigned ip_hi, unsigned ip_lo){

        unsigned number_of_bytes, i, arp_cache;

        //see if the requested IP address is in the arp cache

        arp_cache = get_arp_cache(ip_hi, ip_lo);

        //Form IP header

        packet[7] = 0x4500;              //Version 4 header length 5x32

        packet[8] = total_length;        //IP data + header

        packet[9] = 0x0000;              //Identification

        packet[10] = 0x4000;             //don't fragment

        packet[11] = 0xFF00u | protocol;  //ttl|protocol

        packet[12] = 0x0000;             //checksum

        packet[13] = local_ip_address_hi;//source_high

        packet[14] = local_ip_address_lo;//source_low

        packet[15] = ip_hi;              //dest_high

        packet[16] = ip_lo;              //dest_low

        number_of_bytes = total_length + 14;

        //calculate checksum

        reset_checksum();

        for(i=7; i<=16; i++){

                add_checksum(packet[i]);

        }

        packet[12] = check_checksum();

        //enforce minimum ethernet frame size

        if(number_of_bytes < 64){

                number_of_bytes = 64;

        }

        //send packet over ethernet

        put_ethernet_packet(

                packet,                  //packet

                number_of_bytes,         //number_of_bytes

                arp_mac_0[arp_cache],    //destination mac address

                arp_mac_1[arp_cache],    //

                arp_mac_2[arp_cache],    //

                0x0800);                 //protocol IPv4

}

unsigned get_ip_packet(unsigned packet[]){

        unsigned ip_payload;

        unsigned total_length;

        unsigned header_length;

        unsigned payload_start;

        unsigned payload_length;

        unsigned i, from, to;

        unsigned payload_end;

        unsigned number_of_bytes;

        number_of_bytes = get_ethernet_packet(packet);

        if(number_of_bytes == 0) return 0;

        if(packet[6] != 0x0800) return 0;

        if(packet[15] != local_ip_address_hi) return 0;

        if(packet[16] != local_ip_address_lo) return 0;

        if((packet[11] & 0xff) == 1){//ICMP

                header_length = ((packet[7] >> 8) & 0xf) << 1;                   //in words

                payload_start = header_length + 7;                               //in words

                total_length = packet[8];                                        //in bytes

                payload_length = ((total_length+1) >> 1) - header_length;        //in words

                payload_end = payload_start + payload_length - 1;                //in words

                if(packet[payload_start] == 0x0800){//ping request

                        //copy icmp packet to response

                        to = 19;//assume that 17 and 18 are 0

                        reset_checksum();

                        for(from=payload_start+2; from<=payload_end; from++){

                                i = packet[from];

                                add_checksum(i);

                                tx_packet[to] = i;

                                to++;

                        }

                        tx_packet[17] = 0;//ping response

                        tx_packet[18] = check_checksum();

                        //send ping response

                        put_ip_packet(

                                tx_packet,

                                total_length,

                                1,//icmp

                                packet[13], //remote ip

                                packet[14]  //remote ip

                        );

                }

                return 0;

        }

        if((packet[11] & 0xff) != 6) return 0;//TCP

        return number_of_bytes;

}

////////////////////////////////////////////////////////////////////////////////

// Transport Layer - TCP

//

unsigned remote_ip_hi, remote_ip_lo;

unsigned tx_source=0;

unsigned tx_dest=0;

unsigned tx_seq[2];

unsigned next_tx_seq[2];

unsigned tx_ack[2];

unsigned tx_window=1460; //ethernet MTU - 40 bytes for TCP/IP header

unsigned tx_fin_flag=0;

unsigned tx_syn_flag=0;

unsigned tx_rst_flag=0;

unsigned tx_psh_flag=0;

unsigned tx_ack_flag=0;

unsigned tx_urg_flag=0;

unsigned rx_source=0;

unsigned rx_dest=0;

unsigned rx_seq[2];

unsigned rx_ack[2];

unsigned rx_window=0;

unsigned rx_fin_flag=0;

unsigned rx_syn_flag=0;

unsigned rx_rst_flag=0;

unsigned rx_psh_flag=0;

unsigned rx_ack_flag=0;

unsigned rx_urg_flag=0;

void put_tcp_packet(unsigned tx_packet [], unsigned tx_length){

        unsigned payload_start = 17;

        unsigned packet_length;

        unsigned index;

        unsigned i;

        //encode TCP header

        tx_packet[payload_start + 0] = tx_source;

        tx_packet[payload_start + 1] = tx_dest;

        tx_packet[payload_start + 2] = tx_seq[1];

        tx_packet[payload_start + 3] = tx_seq[0];

        tx_packet[payload_start + 4] = tx_ack[1];

        tx_packet[payload_start + 5] = tx_ack[0];

        tx_packet[payload_start + 6] = 0x5000; //5 long words

        tx_packet[payload_start + 7] = tx_window;

        tx_packet[payload_start + 8] = 0;

        tx_packet[payload_start + 9] = 0;

        //encode flags

        if(tx_fin_flag) tx_packet[payload_start + 6] |= 0x01;

        if(tx_syn_flag) tx_packet[payload_start + 6] |= 0x02;

        if(tx_rst_flag) tx_packet[payload_start + 6] |= 0x04;

        if(tx_psh_flag) tx_packet[payload_start + 6] |= 0x08;

        if(tx_ack_flag) tx_packet[payload_start + 6] |= 0x10;

        if(tx_urg_flag) tx_packet[payload_start + 6] |= 0x20;

        //calculate checksum

        //length of payload + header + pseudo_header in words

        reset_checksum();

        add_checksum(local_ip_address_hi);

        add_checksum(local_ip_address_lo);

        add_checksum(remote_ip_hi);

        add_checksum(remote_ip_lo);

        add_checksum(0x0006);

        add_checksum(tx_length+20);//tcp_header + tcp_payload in bytes

        packet_length = (tx_length + 20 + 1) >> 1;

        index = payload_start;

        for(i=0; i<packet_length; i++){

                add_checksum(tx_packet[index]);

                index++;

        }

        tx_packet[payload_start + 8] = check_checksum();

        put_ip_packet(

                tx_packet,

                tx_length + 40,

                6,//tcp

                remote_ip_hi, //remote ip

                remote_ip_lo  //remote ip

        );

}

unsigned rx_length, rx_start;

unsigned get_tcp_packet(unsigned rx_packet []){

        unsigned number_of_bytes, header_length, payload_start, total_length, payload_length, payload_end, tcp_header_length;

        number_of_bytes = get_ip_packet(rx_packet);

        //decode lengths from the IP header

        header_length = ((rx_packet[7] >> 8) & 0xf) << 1;                   //in words

        payload_start = header_length + 7;                                  //in words

        total_length = rx_packet[8];                                        //in bytes

        payload_length = total_length - (header_length << 1);               //in bytes

        tcp_header_length = ((rx_packet[payload_start + 6] & 0xf000u)>>10); //in bytes

        rx_length = payload_length - tcp_header_length;                     //in bytes

        rx_start = payload_start + (tcp_header_length >> 1);                //in words

        //decode TCP header

        rx_source = rx_packet[payload_start + 0];

        rx_dest   = rx_packet[payload_start + 1];

        rx_seq[1] = rx_packet[payload_start + 2];

        rx_seq[0] = rx_packet[payload_start + 3];

        rx_ack[1] = rx_packet[payload_start + 4];

        rx_ack[0] = rx_packet[payload_start + 5];

        rx_window = rx_packet[payload_start + 7];

        //decode flags

        rx_fin_flag = rx_packet[payload_start + 6] & 0x01;

        rx_syn_flag = rx_packet[payload_start + 6] & 0x02;

        rx_rst_flag = rx_packet[payload_start + 6] & 0x04;

        rx_psh_flag = rx_packet[payload_start + 6] & 0x08;

        rx_ack_flag = rx_packet[payload_start + 6] & 0x10;

        rx_urg_flag = rx_packet[payload_start + 6] & 0x20;

        return number_of_bytes;

}

void application_put_data(unsigned packet[], unsigned start, unsigned length){

        unsigned i, index;

        index = start;

        put_socket(length);

        for(i=0; i<length; i+=2){

                put_socket(packet[index]);

                index++;

        }

}

unsigned application_get_data(unsigned packet[], unsigned start){

        unsigned i, index, length;

        if(!ready_socket()){

                return 0;

        }

        index = start;

        length = get_socket();

        for(i=0; i<length; i+=2){

                packet[index] = get_socket();

                index++;

        }

        return length;

}

void server()

{

        unsigned rx_packet[1024];

        unsigned tx_packet[1024];

        unsigned tx_start = 27;

        unsigned new_rx_data = 0;

        unsigned new_tx_data = 0;

        unsigned tx_length;

        unsigned timeout;

        unsigned resend_wait;

        unsigned bytes;

        unsigned last_state;

        unsigned new_rx_data;

        const unsigned listen           = 0;

        const unsigned open             = 1;

        const unsigned send             = 2;

        const unsigned wait_acknowledge = 3;

        const unsigned close            = 4;

        unsigned state = listen;

        tx_seq[0] = 0;

        tx_seq[1] = 0;

        while(1){

                if(timeout){

                        timeout--;

                } else {

                        timeout = 120; //2 mins @100 MHz

                        state = listen;

                        tx_syn_flag = 0;

                        tx_fin_flag = 0;

                        tx_ack_flag = 0;

                        tx_rst_flag = 1;

                        put_tcp_packet(tx_packet, 0);//send reset packet

                }

                // (optionaly) send something

                switch(state){

                    case listen:

                        tx_rst_flag = 0;

                        tx_syn_flag = 0;

                        tx_fin_flag = 0;

                        tx_ack_flag = 0;

                        break;

                    case open:

                        // set remote ip/port

                        remote_ip_hi = rx_packet[13];

                        remote_ip_lo = rx_packet[14];

                        tx_dest = rx_source;

                        tx_source = local_port;

                        // send syn_ack

                        calc_ack(tx_ack, rx_seq, 1);

                        tx_syn_flag = 1;

                        tx_ack_flag = 1;

                        put_tcp_packet(tx_packet, 0);

                        break;

                    case send:

                        // application -> tcp

                        tx_length = application_get_data(tx_packet, tx_start);

                        tx_seq[0] = next_tx_seq[0];

                        tx_seq[1] = next_tx_seq[1];

                        calc_ack(next_tx_seq, tx_seq, tx_length);

                        tx_syn_flag = 0;

                        tx_ack_flag = 1;

                        put_tcp_packet(tx_packet, tx_length);

                        break;

                    case wait_acknowledge:

                        // resend until acknowledge recieved

                        put_tcp_packet(tx_packet, tx_length);

                        break;

                    case close:

                        // send fin ack

                        tx_fin_flag = 1;

                        tx_ack_flag = 1;

                        calc_ack(tx_ack, rx_seq, 1);

                        put_tcp_packet(tx_packet, 0);

                        break;

                }

                // repeatedly check for responses

                for(resend_wait = 10000; resend_wait; resend_wait--){ //1 second @ 100MHz

                        bytes = get_tcp_packet(rx_packet);

                        if(bytes && (rx_dest == local_port)){

                                //Once connection is established ignore other connection attempts

                                if(state != listen && rx_source != tx_dest) continue;

                                new_rx_data = 0;

                                last_state = state;

                                switch(state){

                                    // If a syn packet is recieved, wait for an ack

                                    case listen:

                                        if(rx_syn_flag) state = open;

                                        else{

                                                tx_rst_flag = 1;

                                                put_tcp_packet(tx_packet, 0);//send reset packet

                                        }

                                        break;

                                    // If an ack is recieved the connection is established

                                    case open:

                                        if(rx_ack_flag){

                                                tx_seq[1] = rx_ack[1];

                                                tx_seq[0] = rx_ack[0];

                                                next_tx_seq[1] = rx_ack[1];

                                                next_tx_seq[0] = rx_ack[0];

                                                state = send;

                                        }

                                        break;

                                    // Send some data

                                    case send:

                                        new_rx_data = calc_ack(tx_ack, rx_seq, rx_length);

                                        if(rx_fin_flag){

                                                state = close;

                                        } else if( tx_length ){

                                                state = wait_acknowledge;

                                        }

                                        break;

                                    // Wait until data is acknowledged before sending some more.

                                    case wait_acknowledge:

                                        new_rx_data = calc_ack(tx_ack, rx_seq, rx_length);