33c9872c804564f664bf4005ed3f0b1807efa633
[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/pkbuff.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
19 tcpip_net_protocols[0] __table_start ( tcpip_net_protocols );
20 static struct tcpip_net_protocol
21 tcpip_net_protocols_end[0] __table_end ( tcpip_net_protocols );
22
23 /** Registered transport-layer protocols that support TCP/IP */
24 static struct tcpip_protocol
25 tcpip_protocols[0]__table_start ( tcpip_protocols );
26 static struct tcpip_protocol
27 tcpip_protocols_end[0] __table_end ( tcpip_protocols );
28
29 /** Process a received TCP/IP packet
30  *
31  * @v pkb               Packet 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  * @ret rc              Return status code
36  *
37  * This function expects a transport-layer segment from the network
38  * layer.  The network layer should fill in as much as it can of the
39  * source and destination addresses (i.e. it should fill in the
40  * address family and the network-layer addresses, but leave the ports
41  * and the rest of the structures as zero).
42  */
43 int tcpip_rx ( struct pk_buff *pkb, uint8_t tcpip_proto, 
44                struct sockaddr_tcpip *st_src,
45                struct sockaddr_tcpip *st_dest ) {
46         struct tcpip_protocol *tcpip;
47
48         /* Hand off packet to the appropriate transport-layer protocol */
49         for ( tcpip = tcpip_protocols; tcpip < tcpip_protocols_end; tcpip++ ) {
50                 if ( tcpip->tcpip_proto == tcpip_proto ) {
51                         DBG ( "TCP/IP received %s packet\n", tcpip->name );
52                         return tcpip->rx ( pkb, st_src, st_dest );
53                 }
54         }
55
56         DBG ( "Unrecognised TCP/IP protocol %d\n", tcpip_proto );
57         free_pkb ( pkb );
58         return -EPROTONOSUPPORT;
59 }
60
61 /** Transmit a TCP/IP packet
62  *
63  * @v pkb               Packet buffer
64  * @v tcpip_protocol    Transport-layer protocol
65  * @v st_dest           Destination address
66  * @ret rc              Return status code
67  */
68 int tcpip_tx ( struct pk_buff *pkb, struct tcpip_protocol *tcpip_protocol,
69                struct sockaddr_tcpip *st_dest ) {
70         struct tcpip_net_protocol *tcpip_net;
71
72         /* Hand off packet to the appropriate network-layer protocol */
73         for ( tcpip_net = tcpip_net_protocols ;
74               tcpip_net < tcpip_net_protocols_end ; tcpip_net++ ) {
75                 if ( tcpip_net->sa_family == st_dest->st_family ) {
76                         DBG ( "TCP/IP sending %s packet\n", tcpip_net->name );
77                         return tcpip_net->tx ( pkb, tcpip_protocol, st_dest );
78                 }
79         }
80         
81         DBG ( "Unrecognised TCP/IP address family %d\n", st_dest->st_family );
82         free_pkb ( pkb );
83         return -EAFNOSUPPORT;
84 }
85
86 /**
87  * Calculate continued TCP/IP checkum
88  *
89  * @v partial           Checksum of already-summed data, in network byte order
90  * @v data              Data buffer
91  * @v len               Length of data buffer
92  * @ret cksum           Updated checksum, in network byte order
93  *
94  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
95  * checksum is returned in network byte order.
96  *
97  * This function may be used to add new data to an existing checksum.
98  * The function assumes that both the old data and the new data start
99  * on even byte offsets; if this is not the case then you will need to
100  * byte-swap either the input partial checksum, the output checksum,
101  * or both.  Deciding which to swap is left as an exercise for the
102  * interested reader.
103  */
104 unsigned int tcpip_continue_chksum ( unsigned int partial, const void *data,
105                                      size_t len ) {
106         unsigned int cksum = ( ( ~partial ) & 0xffff );
107         unsigned int value;
108         unsigned int i;
109         
110         for ( i = 0 ; i < len ; i++ ) {
111                 value = * ( ( uint8_t * ) data + i );
112                 if ( i & 1 ) {
113                         /* Odd bytes: swap on little-endian systems */
114                         value = be16_to_cpu ( value );
115                 } else {
116                         /* Even bytes: swap on big-endian systems */
117                         value = le16_to_cpu ( value );
118                 }
119                 cksum += value;
120                 if ( cksum > 0xffff )
121                         cksum -= 0xffff;
122         }
123         
124         return ( ( ~cksum ) & 0xffff );
125 }
126
127 /**
128  * Calculate TCP/IP checkum
129  *
130  * @v data              Data buffer
131  * @v len               Length of data buffer
132  * @ret cksum           Checksum, in network byte order
133  *
134  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
135  * checksum is returned in network byte order.
136  */
137 unsigned int tcpip_chksum ( const void *data, size_t len ) {
138         return tcpip_continue_chksum ( 0xffff, data, len );
139 }