I have no idea how this ever worked before.
[gpxe.git] / src / net / ipv4.c
1 #include <string.h>
2 #include <stdint.h>
3 #include <errno.h>
4 #include <byteswap.h>
5 #include <vsprintf.h>
6 #include <gpxe/in.h>
7
8
9 #include <ip.h>
10
11
12 #include <gpxe/if_ether.h>
13 #include <gpxe/pkbuff.h>
14 #include <gpxe/netdevice.h>
15 #include "uip/uip.h"
16
17 /** @file
18  *
19  * IPv4 protocol
20  *
21  * The gPXE IP stack is currently implemented on top of the uIP
22  * protocol stack.  This file provides wrappers around uIP so that
23  * higher-level protocol implementations do not need to talk directly
24  * to uIP (which has a somewhat baroque API).
25  *
26  */
27
28 struct net_protocol ipv4_protocol;
29
30 /** An IPv4 routing table entry */
31 struct ipv4_route {
32         /** Network address */
33         struct in_addr network;
34         /** Subnet mask */
35         struct in_addr netmask;
36         /** Gateway address */
37         struct in_addr gateway;
38         /** Gateway device */
39         struct in_addr gatewaydev;
40 };
41
42 enum {
43         STATIC_SINGLE_NETDEV_ROUTE = 0,
44         DEFAULT_ROUTE,
45         NUM_ROUTES
46 };
47
48 /** IPv4 routing table */
49 static struct ipv4_route routing_table[NUM_ROUTES];
50
51 #define routing_table_end ( routing_table + NUM_ROUTES )
52
53 #if 0
54 /**
55  * Set IP address
56  *
57  */
58 void set_ipaddr ( struct in_addr address ) {
59         union {
60                 struct in_addr address;
61                 uint16_t uip_address[2];
62         } u;
63
64         u.address = address;
65         uip_sethostaddr ( u.uip_address );
66 }
67
68 /**
69  * Set netmask
70  *
71  */
72 void set_netmask ( struct in_addr address ) {
73         union {
74                 struct in_addr address;
75                 uint16_t uip_address[2];
76         } u;
77
78         u.address = address;
79         uip_setnetmask ( u.uip_address );
80 }
81
82 /**
83  * Set default gateway
84  *
85  */
86 void set_gateway ( struct in_addr address ) {
87         union {
88                 struct in_addr address;
89                 uint16_t uip_address[2];
90         } u;
91
92         u.address = address;
93         uip_setdraddr ( u.uip_address );
94 }
95
96 /**
97  * Run the TCP/IP stack
98  *
99  * Call this function in a loop in order to allow TCP/IP processing to
100  * take place.  This call takes the stack through a single iteration;
101  * it will typically be used in a loop such as
102  *
103  * @code
104  *
105  * struct tcp_connection *my_connection;
106  * ...
107  * tcp_connect ( my_connection );
108  * while ( ! my_connection->finished ) {
109  *   run_tcpip();
110  * }
111  *
112  * @endcode
113  *
114  * where @c my_connection->finished is set by one of the connection's
115  * #tcp_operations methods to indicate completion.
116  */
117 void run_tcpip ( void ) {
118         void *data;
119         size_t len;
120         uint16_t type;
121         int i;
122         
123         if ( netdev_poll ( 1, &data, &len ) ) {
124                 /* We have data */
125                 memcpy ( uip_buf, data, len );
126                 uip_len = len;
127                 type = ntohs ( *( ( uint16_t * ) ( uip_buf + 12 ) ) );
128                 if ( type == UIP_ETHTYPE_ARP ) {
129                         uip_arp_arpin();
130                 } else {
131                         uip_arp_ipin();
132                         uip_input();
133                 }
134                 if ( uip_len > 0 )
135                         uip_transmit();
136         } else {
137                 for ( i = 0 ; i < UIP_CONNS ; i++ ) {
138                         uip_periodic ( i );
139                         if ( uip_len > 0 )
140                                 uip_transmit();
141                 }
142         }
143 }
144 #endif
145
146 /**
147  * Process incoming IP packets
148  *
149  * @v pkb               Packet buffer
150  * @ret rc              Return status code
151  *
152  * This handles IP packets by handing them off to the uIP protocol
153  * stack.
154  */
155 static int ipv4_rx ( struct pk_buff *pkb ) {
156
157         /* Transfer to uIP buffer.  Horrendously space-inefficient,
158          * but will do as a proof-of-concept for now.
159          */
160         uip_len = pkb_len ( pkb );
161         memcpy ( uip_buf, pkb->data, uip_len );
162         free_pkb ( pkb );
163
164         /* Hand to uIP for processing */
165         uip_input ();
166         if ( uip_len > 0 ) {
167                 pkb = alloc_pkb ( MAX_LL_HEADER_LEN + uip_len );
168                 if ( ! pkb )
169                         return -ENOMEM;
170                 pkb->net_protocol = &ipv4_protocol;
171                 pkb_reserve ( pkb, MAX_LL_HEADER_LEN );
172                 memcpy ( pkb_put ( pkb, uip_len ), uip_buf, uip_len );
173                 net_transmit ( pkb );
174         }
175         return 0;
176 }
177
178 /**
179  * Perform IP layer routing
180  *
181  * @v pkb       Packet buffer
182  * @ret source  Network-layer source address
183  * @ret dest    Network-layer destination address
184  * @ret rc      Return status code
185  */
186 static int ipv4_route ( const struct pk_buff *pkb,
187                         struct net_header *nethdr ) {
188         struct iphdr *iphdr = pkb->data;
189         struct in_addr *source = ( struct in_addr * ) nethdr->source_net_addr;
190         struct in_addr *dest = ( struct in_addr * ) nethdr->dest_net_addr;
191         struct ipv4_route *route;
192
193         /* Route IP packet according to routing table */
194         source->s_addr = INADDR_NONE;
195         dest->s_addr = iphdr->dest.s_addr;
196         for ( route = routing_table ; route < routing_table_end ; route++ ) {
197                 if ( ( dest->s_addr & route->netmask.s_addr )
198                      == route->network.s_addr ) {
199                         source->s_addr = route->gatewaydev.s_addr;
200                         if ( route->gateway.s_addr )
201                                 dest->s_addr = route->gateway.s_addr;
202                         break;
203                 }
204         }
205
206         /* Set broadcast and multicast flags as applicable */
207         nethdr->flags = 0;
208         if ( dest->s_addr == htonl ( INADDR_BROADCAST ) ) {
209                 nethdr->flags = PKT_FL_BROADCAST;
210         } else if ( IN_MULTICAST ( dest->s_addr ) ) {
211                 nethdr->flags = PKT_FL_MULTICAST;
212         }
213
214         return 0;
215 }
216
217 /**
218  * Transcribe IP address
219  *
220  * @v net_addr  IP address
221  * @ret string  IP address in dotted-quad notation
222  *
223  */
224 static const char * ipv4_ntoa ( const void *net_addr ) {
225         static char buf[16]; /* "xxx.xxx.xxx.xxx" */
226         uint8_t *ip_addr = net_addr;
227
228         sprintf ( buf, "%d.%d.%d.%d", ip_addr[0], ip_addr[1], ip_addr[2],
229                   ip_addr[3] );
230         return buf;
231 }
232
233 /** IPv4 protocol */
234 struct net_protocol ipv4_protocol = {
235         .name = "IP",
236         .net_proto = htons ( ETH_P_IP ),
237         .net_addr_len = sizeof ( struct in_addr ),
238         .rx_process = ipv4_rx,
239         .route = ipv4_route,
240         .ntoa = ipv4_ntoa,
241 };
242
243 NET_PROTOCOL ( ipv4_protocol );
244
245 /** IPv4 address for the static single net device */
246 struct net_address static_single_ipv4_address = {
247         .net_protocol = &ipv4_protocol,
248
249 #warning "Remove this static-IP hack"
250         .net_addr = { 0x0a, 0xfe, 0xfe, 0x01 },
251 };
252
253 STATIC_SINGLE_NETDEV_ADDRESS ( static_single_ipv4_address );
254
255 #warning "Remove this static-IP hack"
256 static struct ipv4_route routing_table[NUM_ROUTES] = {
257         { { htonl ( 0x0afefe00 ) }, { htonl ( 0xfffffffc ) },
258           { htonl ( 0x00000000 ) }, { htonl ( 0x0afefe01 ) } },
259         { { htonl ( 0x00000000 ) }, { htonl ( 0x00000000 ) },
260           { htonl ( 0x0afefe02 ) }, { htonl ( 0x0afefe01 ) } },
261 };
262