tcpip.c

Go to the documentation of this file.

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/iobuf.h>
#include <ipxe/tables.h>
#include <ipxe/ipstat.h>
#include <ipxe/netdevice.h>
#include <ipxe/tcpip.h>

/** @file
 *
 * Transport-network layer interface
 *
 * This file contains functions and utilities for the
 * TCP/IP transport-network layer interface
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

/**
 * Process a received TCP/IP packet
 *
 * @v iobuf             I/O buffer
 * @v netdev            Network device
 * @v tcpip_proto       Transport-layer protocol number
 * @v st_src            Partially-filled source address
 * @v st_dest           Partially-filled destination address
 * @v pshdr_csum        Pseudo-header checksum
 * @v stats             IP statistics
 * @ret rc              Return status code
 *
 * This function expects a transport-layer segment from the network
 * layer.  The network layer should fill in as much as it can of the
 * source and destination addresses (i.e. it should fill in the
 * address family and the network-layer addresses, but leave the ports
 * and the rest of the structures as zero).
 */
int tcpip_rx ( struct io_buffer *iobuf, struct net_device *netdev,
               uint8_t tcpip_proto, struct sockaddr_tcpip *st_src,
               struct sockaddr_tcpip *st_dest, uint16_t pshdr_csum,
               struct ip_statistics *stats ) {
        struct tcpip_protocol *tcpip;

        /* Hand off packet to the appropriate transport-layer protocol */
        for_each_table_entry ( tcpip, TCPIP_PROTOCOLS ) {
                if ( tcpip->tcpip_proto == tcpip_proto ) {
                        DBG ( "TCP/IP received %s packet\n", tcpip->name );
                        stats->in_delivers++;
                        return tcpip->rx ( iobuf, netdev, st_src, st_dest,
                                           pshdr_csum );
                }
        }

        DBG ( "Unrecognised TCP/IP protocol %d\n", tcpip_proto );
        stats->in_unknown_protos++;
        free_iob ( iobuf );
        return -EPROTONOSUPPORT;
}

/**
 * Find TCP/IP network-layer protocol
 *
 * @v sa_family         Address family
 * @ret tcpip_net       TCP/IP network-layer protocol, or NULL if not found
 */
struct tcpip_net_protocol * tcpip_net_protocol ( sa_family_t sa_family ) {
        struct tcpip_net_protocol *tcpip_net;

        for_each_table_entry ( tcpip_net, TCPIP_NET_PROTOCOLS ) {
                if ( tcpip_net->sa_family == sa_family )
                        return tcpip_net;
        }

        DBG ( "Unrecognised TCP/IP address family %d\n", sa_family );
        return NULL;
}

/**
 * Transmit a TCP/IP packet
 *
 * @v iobuf             I/O buffer
 * @v tcpip_protocol    Transport-layer protocol
 * @v st_src            Source address, or NULL to use route default
 * @v st_dest           Destination address
 * @v netdev            Network device to use if no route found, or NULL
 * @v trans_csum        Transport-layer checksum to complete, or NULL
 * @ret rc              Return status code
 */
int tcpip_tx ( struct io_buffer *iobuf, struct tcpip_protocol *tcpip_protocol,
               struct sockaddr_tcpip *st_src, struct sockaddr_tcpip *st_dest,
               struct net_device *netdev, uint16_t *trans_csum ) {
        struct tcpip_net_protocol *tcpip_net;

        /* Hand off packet to the appropriate network-layer protocol */
        tcpip_net = tcpip_net_protocol ( st_dest->st_family );
        if ( tcpip_net ) {
                DBG ( "TCP/IP sending %s packet\n", tcpip_net->name );
                return tcpip_net->tx ( iobuf, tcpip_protocol, st_src, st_dest,
                                       netdev, trans_csum );
        }

        free_iob ( iobuf );
        return -EAFNOSUPPORT;
}

/**
 * Determine transmitting network device
 *
 * @v st_dest           Destination address
 * @ret netdev          Network device, or NULL
 */
struct net_device * tcpip_netdev ( struct sockaddr_tcpip *st_dest ) {
        struct tcpip_net_protocol *tcpip_net;

        /* Hand off to the appropriate network-layer protocol */
        tcpip_net = tcpip_net_protocol ( st_dest->st_family );
        if ( tcpip_net )
                return tcpip_net->netdev ( st_dest );

        return NULL;
}

/**
 * Determine maximum transmission unit
 *
 * @v st_dest           Destination address
 * @ret mtu             Maximum transmission unit
 */
size_t tcpip_mtu ( struct sockaddr_tcpip *st_dest ) {
        struct tcpip_net_protocol *tcpip_net;
        struct net_device *netdev;
        size_t mtu;

        /* Find appropriate network-layer protocol */
        tcpip_net = tcpip_net_protocol ( st_dest->st_family );
        if ( ! tcpip_net )
                return 0;

        /* Find transmitting network device */
        netdev = tcpip_net->netdev ( st_dest );
        if ( ! netdev )
                return 0;

        /* Calculate MTU */
        mtu = ( netdev->mtu - tcpip_net->header_len );

        return mtu;
}

/**
 * Calculate continued TCP/IP checkum
 *
 * @v partial           Checksum of already-summed data, in network byte order
 * @v data              Data buffer
 * @v len               Length of data buffer
 * @ret cksum           Updated checksum, in network byte order
 *
 * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
 * checksum is returned in network byte order.
 *
 * This function may be used to add new data to an existing checksum.
 * The function assumes that both the old data and the new data start
 * on even byte offsets; if this is not the case then you will need to
 * byte-swap either the input partial checksum, the output checksum,
 * or both.  Deciding which to swap is left as an exercise for the
 * interested reader.
 */
uint16_t generic_tcpip_continue_chksum ( uint16_t partial,
                                         const void *data, size_t len ) {
        unsigned int cksum = ( ( ~partial ) & 0xffff );
        unsigned int value;
        unsigned int i;
        
        for ( i = 0 ; i < len ; i++ ) {
                value = * ( ( uint8_t * ) data + i );
                if ( i & 1 ) {
                        /* Odd bytes: swap on little-endian systems */
                        value = be16_to_cpu ( value );
                } else {
                        /* Even bytes: swap on big-endian systems */
                        value = le16_to_cpu ( value );
                }
                cksum += value;
                if ( cksum > 0xffff )
                        cksum -= 0xffff;
        }
        
        return ( ~cksum );
}

/**
 * Calculate TCP/IP checkum
 *
 * @v data              Data buffer
 * @v len               Length of data buffer
 * @ret cksum           Checksum, in network byte order
 *
 * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
 * checksum is returned in network byte order.
 */
uint16_t tcpip_chksum ( const void *data, size_t len ) {
        return tcpip_continue_chksum ( TCPIP_EMPTY_CSUM, data, len );
}

/**
 * Bind to local TCP/IP port
 *
 * @v st_local          Local TCP/IP socket address, or NULL
 * @v available         Function to check port availability
 * @ret port            Local port number, or negative error
 */
int tcpip_bind ( struct sockaddr_tcpip *st_local,
                 int ( * available ) ( int port ) ) {
        uint16_t flags = 0;
        uint16_t try_port = 0;
        uint16_t min_port;
        uint16_t max_port;
        unsigned int offset;
        unsigned int i;

        /* Extract parameters from local socket address */
        if ( st_local ) {
                flags = st_local->st_flags;
                try_port = ntohs ( st_local->st_port );
        }

        /* If an explicit port is specified, check its availability */
        if ( try_port )
                return available ( try_port );

        /* Otherwise, find an available port in the range [1,1023] or
         * [1025,65535] as appropriate.
         */
        min_port = ( ( ( ~flags ) & TCPIP_BIND_PRIVILEGED ) + 1 );
        max_port = ( ( flags & TCPIP_BIND_PRIVILEGED ) - 1 );
        offset = random();
        for ( i = 0 ; i <= max_port ; i++ ) {
                try_port = ( ( i + offset ) & max_port );
                if ( try_port < min_port )
                        continue;
                if ( available ( try_port ) < 0 )
                        continue;
                return try_port;
        }
        return -EADDRINUSE;
}