[tcpip] Allow for transmission to multicast IPv4 addresses
[gpxe.git] / src / net / tcpip.c
1 #include <stdint.h>
2 #include <string.h>
3 #include <errno.h>
4 #include <byteswap.h>
5 #include <gpxe/iobuf.h>
6 #include <gpxe/tables.h>
7 #include <gpxe/tcpip.h>
8
9 /** @file
10  *
11  * Transport-network layer interface
12  *
13  * This file contains functions and utilities for the
14  * TCP/IP transport-network layer interface
15  */
16
17 /** Registered network-layer protocols that support TCP/IP */
18 static struct tcpip_net_protocol tcpip_net_protocols[0]
19         __table_start ( struct tcpip_net_protocol, tcpip_net_protocols );
20 static struct tcpip_net_protocol tcpip_net_protocols_end[0]
21         __table_end ( struct tcpip_net_protocol, tcpip_net_protocols );
22
23 /** Registered transport-layer protocols that support TCP/IP */
24 static struct tcpip_protocol tcpip_protocols[0]
25         __table_start ( struct tcpip_protocol, tcpip_protocols );
26 static struct tcpip_protocol tcpip_protocols_end[0]
27         __table_end ( struct tcpip_protocol, tcpip_protocols );
28
29 /** Process a received TCP/IP packet
30  *
31  * @v iobuf             I/O buffer
32  * @v tcpip_proto       Transport-layer protocol number
33  * @v st_src            Partially-filled source address
34  * @v st_dest           Partially-filled destination address
35  * @v pshdr_csum        Pseudo-header checksum
36  * @ret rc              Return status code
37  *
38  * This function expects a transport-layer segment from the network
39  * layer.  The network layer should fill in as much as it can of the
40  * source and destination addresses (i.e. it should fill in the
41  * address family and the network-layer addresses, but leave the ports
42  * and the rest of the structures as zero).
43  */
44 int tcpip_rx ( struct io_buffer *iobuf, uint8_t tcpip_proto, 
45                struct sockaddr_tcpip *st_src,
46                struct sockaddr_tcpip *st_dest,
47                uint16_t pshdr_csum ) {
48         struct tcpip_protocol *tcpip;
49
50         /* Hand off packet to the appropriate transport-layer protocol */
51         for ( tcpip = tcpip_protocols; tcpip < tcpip_protocols_end; tcpip++ ) {
52                 if ( tcpip->tcpip_proto == tcpip_proto ) {
53                         DBG ( "TCP/IP received %s packet\n", tcpip->name );
54                         return tcpip->rx ( iobuf, st_src, st_dest, pshdr_csum );
55                 }
56         }
57
58         DBG ( "Unrecognised TCP/IP protocol %d\n", tcpip_proto );
59         free_iob ( iobuf );
60         return -EPROTONOSUPPORT;
61 }
62
63 /** Transmit a TCP/IP packet
64  *
65  * @v iobuf             I/O buffer
66  * @v tcpip_protocol    Transport-layer protocol
67  * @v st_src            Source address, or NULL to use route default
68  * @v st_dest           Destination address
69  * @v netdev            Network device to use if no route found, or NULL
70  * @v trans_csum        Transport-layer checksum to complete, or NULL
71  * @ret rc              Return status code
72  */
73 int tcpip_tx ( struct io_buffer *iobuf, struct tcpip_protocol *tcpip_protocol,
74                struct sockaddr_tcpip *st_src, struct sockaddr_tcpip *st_dest,
75                struct net_device *netdev, uint16_t *trans_csum ) {
76         struct tcpip_net_protocol *tcpip_net;
77
78         /* Hand off packet to the appropriate network-layer protocol */
79         for ( tcpip_net = tcpip_net_protocols ;
80               tcpip_net < tcpip_net_protocols_end ; tcpip_net++ ) {
81                 if ( tcpip_net->sa_family == st_dest->st_family ) {
82                         DBG ( "TCP/IP sending %s packet\n", tcpip_net->name );
83                         return tcpip_net->tx ( iobuf, tcpip_protocol, st_src,
84                                                st_dest, netdev, trans_csum );
85                 }
86         }
87         
88         DBG ( "Unrecognised TCP/IP address family %d\n", st_dest->st_family );
89         free_iob ( iobuf );
90         return -EAFNOSUPPORT;
91 }
92
93 /**
94  * Calculate continued TCP/IP checkum
95  *
96  * @v partial           Checksum of already-summed data, in network byte order
97  * @v data              Data buffer
98  * @v len               Length of data buffer
99  * @ret cksum           Updated checksum, in network byte order
100  *
101  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
102  * checksum is returned in network byte order.
103  *
104  * This function may be used to add new data to an existing checksum.
105  * The function assumes that both the old data and the new data start
106  * on even byte offsets; if this is not the case then you will need to
107  * byte-swap either the input partial checksum, the output checksum,
108  * or both.  Deciding which to swap is left as an exercise for the
109  * interested reader.
110  */
111 uint16_t tcpip_continue_chksum ( uint16_t partial, const void *data,
112                                  size_t len ) {
113         unsigned int cksum = ( ( ~partial ) & 0xffff );
114         unsigned int value;
115         unsigned int i;
116         
117         for ( i = 0 ; i < len ; i++ ) {
118                 value = * ( ( uint8_t * ) data + i );
119                 if ( i & 1 ) {
120                         /* Odd bytes: swap on little-endian systems */
121                         value = be16_to_cpu ( value );
122                 } else {
123                         /* Even bytes: swap on big-endian systems */
124                         value = le16_to_cpu ( value );
125                 }
126                 cksum += value;
127                 if ( cksum > 0xffff )
128                         cksum -= 0xffff;
129         }
130         
131         return ( ~cksum );
132 }
133
134 /**
135  * Calculate TCP/IP checkum
136  *
137  * @v data              Data buffer
138  * @v len               Length of data buffer
139  * @ret cksum           Checksum, in network byte order
140  *
141  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
142  * checksum is returned in network byte order.
143  */
144 uint16_t tcpip_chksum ( const void *data, size_t len ) {
145         return tcpip_continue_chksum ( TCPIP_EMPTY_CSUM, data, len );
146 }