Minor changes to the network layer rx() functions
[gpxe.git] / src / net / tcpip.c
1 #include <stdint.h>
2 #include <string.h>
3 #include <errno.h>
4 #include <malloc.h>
5 #include <byteswap.h>
6 #include <gpxe/in.h>
7 #include <gpxe/ip.h>
8 #include <gpxe/ip6.h>
9 #include <gpxe/pkbuff.h>
10 #include <gpxe/tables.h>
11 #include <gpxe/netdevice.h>
12 #include <gpxe/tcpip.h>
13
14 /** @file
15  *
16  * Transport-network layer interface
17  *
18  * This file contains functions and utilities for the transport-network layer interface
19  */
20
21 /** Registered network-layer protocols that support TCPIP */
22 static struct tcpip_net_protocol tcpip_net_protocols[0] __table_start ( tcpip_net_protocols );
23 static struct tcpip_net_protocol tcpip_net_protocols_end[0] __table_end ( tcpip_net_protocols );
24
25 /** Registered transport-layer protocols that support TCPIP */
26 static struct tcpip_protocol tcpip_protocols[0] __table_start ( tcpip_protocols );
27 static struct tcpip_protocol tcpip_protocols_end[0] __table_end ( tcpip_protocols );
28
29 /** Process a received packet
30  *
31  * @v pkb               Packet buffer
32  * @v trans_proto       Transport-layer protocol number
33  * @v src               Source network-layer address
34  * @v dest              Destination network-layer address
35  *
36  * This function expects a transport-layer segment from the network-layer
37  */
38 void tcpip_rx ( struct pk_buff *pkb, uint8_t trans_proto, struct in_addr *src,
39                 struct in_addr *dest ) {
40         struct tcpip_protocol *tcpip;
41
42         /* Identify the transport layer protocol */
43         for ( tcpip = tcpip_protocols; tcpip <= tcpip_protocols_end; ++tcpip ) {
44                 if ( tcpip->trans_proto == trans_proto ) {
45                         tcpip->rx ( pkb, src, dest );
46                 }
47         }
48 }
49
50 /** Transmit a transport-layer segment
51  *
52  * @v pkb               Packet buffer
53  * @v trans_proto       Transport-layer protocol
54  * @v sock              Destination socket address
55  * @ret                 Status
56  */
57 int tcpip_tx ( struct pk_buff *pkb, struct tcpip_protocol *tcpip,
58                struct sockaddr *sock ) {
59
60 #if 0 /* This is the right thing to do */
61
62         struct tcpip_net_protocol *tcpip_net;
63
64         /* Identify the network layer protocol */
65         for ( tcpip_net = tcpip_net_protocols; 
66                         tcpip_net <= tcpip_net_protocols_end; ++tcpip_net ) {
67                 if ( tcpip_net->sa_family == sock->sa_family ) {
68                         DBG ( "Packet sent to %s module\n", tcpip_net->net_protocol->name );
69                         return tcpip_net->tx ( pkb, tcpip, sock );
70                 }
71         }
72         DBG ( "No suitable network layer protocol found for sa_family %s\n",
73                                                 ( sock->sa_family );
74         return -EAFNOSUPPORT;
75 }
76
77 #else
78
79         /* Identify the network layer protocol and send it using xxx_tx() */
80         switch ( sock->sa_family ) {
81         case AF_INET: /* IPv4 network family */
82                 return ipv4_tx ( pkb, tcpip, sock );
83         case AF_INET6: /* IPv6 network family */
84                 return ipv6_tx ( pkb, tcpip, sock );
85         }
86         DBG ( "Network family %d not supported", sock->sa_family );
87         return -EAFNOSUPPORT;
88 }
89
90 #endif
91
92 /**
93  * Calculate continued TCP/IP checkum
94  *
95  * @v partial           Checksum of already-summed data, in network byte order
96  * @v data              Data buffer
97  * @v len               Length of data buffer
98  * @ret cksum           Updated checksum, in network byte order
99  *
100  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
101  * checksum is returned in network byte order.
102  *
103  * This function may be used to add new data to an existing checksum.
104  * The function assumes that both the old data and the new data start
105  * on even byte offsets; if this is not the case then you will need to
106  * byte-swap either the input partial checksum, the output checksum,
107  * or both.  Deciding which to swap is left as an exercise for the
108  * interested reader.
109  */
110 unsigned int tcpip_continue_chksum ( unsigned int partial, const void *data,
111                                      size_t len ) {
112         unsigned int cksum = ( ( ~partial ) & 0xffff );
113         unsigned int value;
114         unsigned int i;
115         
116         for ( i = 0 ; i < len ; i++ ) {
117                 value = * ( ( uint8_t * ) data + i );
118                 if ( i & 1 ) {
119                         /* Odd bytes: swap on little-endian systems */
120                         value = be16_to_cpu ( value );
121                 } else {
122                         /* Even bytes: swap on big-endian systems */
123                         value = le16_to_cpu ( value );
124                 }
125                 cksum += value;
126                 if ( cksum > 0xffff )
127                         cksum -= 0xffff;
128         }
129         
130         return ( ( ~cksum ) & 0xffff );
131 }
132
133 /**
134  * Calculate TCP/IP checkum
135  *
136  * @v data              Data buffer
137  * @v len               Length of data buffer
138  * @ret cksum           Checksum, in network byte order
139  *
140  * Calculates a TCP/IP-style 16-bit checksum over the data block.  The
141  * checksum is returned in network byte order.
142  */
143 unsigned int tcpip_chksum ( const void *data, size_t len ) {
144         return tcpip_continue_chksum ( 0xffff, data, len );
145 }