[tcp] Ignore duplicate ACKs in TCP ESTABLISHED state
[people/oremanj/gpxe.git] / src / net / arp.c
1 /*
2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <stdint.h>
22 #include <string.h>
23 #include <byteswap.h>
24 #include <errno.h>
25 #include <gpxe/if_ether.h>
26 #include <gpxe/if_arp.h>
27 #include <gpxe/iobuf.h>
28 #include <gpxe/netdevice.h>
29 #include <gpxe/arp.h>
30
31 /** @file
32  *
33  * Address Resolution Protocol
34  *
35  * This file implements the address resolution protocol as defined in
36  * RFC826.  The implementation is media-independent and
37  * protocol-independent; it is not limited to Ethernet or to IPv4.
38  *
39  */
40
41 /** An ARP cache entry */
42 struct arp_entry {
43         /** Network-layer protocol */
44         struct net_protocol *net_protocol;
45         /** Link-layer protocol */
46         struct ll_protocol *ll_protocol;
47         /** Network-layer address */
48         uint8_t net_addr[MAX_NET_ADDR_LEN];
49         /** Link-layer address */
50         uint8_t ll_addr[MAX_LL_ADDR_LEN];
51 };
52
53 /** Number of entries in the ARP cache
54  *
55  * This is a global cache, covering all network interfaces,
56  * network-layer protocols and link-layer protocols.
57  */
58 #define NUM_ARP_ENTRIES 4
59
60 /** The ARP cache */
61 static struct arp_entry arp_table[NUM_ARP_ENTRIES];
62 #define arp_table_end &arp_table[NUM_ARP_ENTRIES]
63
64 static unsigned int next_new_arp_entry = 0;
65
66 struct net_protocol arp_protocol;
67
68 /**
69  * Find entry in the ARP cache
70  *
71  * @v ll_protocol       Link-layer protocol
72  * @v net_protocol      Network-layer protocol
73  * @v net_addr          Network-layer address
74  * @ret arp             ARP cache entry, or NULL if not found
75  *
76  */
77 static struct arp_entry *
78 arp_find_entry ( struct ll_protocol *ll_protocol,
79                  struct net_protocol *net_protocol,
80                  const void *net_addr ) {
81         struct arp_entry *arp;
82
83         for ( arp = arp_table ; arp < arp_table_end ; arp++ ) {
84                 if ( ( arp->ll_protocol == ll_protocol ) &&
85                      ( arp->net_protocol == net_protocol ) &&
86                      ( memcmp ( arp->net_addr, net_addr,
87                                 net_protocol->net_addr_len ) == 0 ) )
88                         return arp;
89         }
90         return NULL;
91 }
92
93 /**
94  * Look up media-specific link-layer address in the ARP cache
95  *
96  * @v netdev            Network device
97  * @v net_protocol      Network-layer protocol
98  * @v dest_net_addr     Destination network-layer address
99  * @v source_net_addr   Source network-layer address
100  * @ret dest_ll_addr    Destination link layer address
101  * @ret rc              Return status code
102  *
103  * This function will use the ARP cache to look up the link-layer
104  * address for the link-layer protocol associated with the network
105  * device and the given network-layer protocol and addresses.  If
106  * found, the destination link-layer address will be filled in in @c
107  * dest_ll_addr.
108  *
109  * If no address is found in the ARP cache, an ARP request will be
110  * transmitted on the specified network device and -ENOENT will be
111  * returned.
112  */
113 int arp_resolve ( struct net_device *netdev, struct net_protocol *net_protocol,
114                   const void *dest_net_addr, const void *source_net_addr,
115                   void *dest_ll_addr ) {
116         struct ll_protocol *ll_protocol = netdev->ll_protocol;
117         const struct arp_entry *arp;
118         struct io_buffer *iobuf;
119         struct arphdr *arphdr;
120         int rc;
121
122         /* Look for existing entry in ARP table */
123         arp = arp_find_entry ( ll_protocol, net_protocol, dest_net_addr );
124         if ( arp ) {
125                 DBG ( "ARP cache hit: %s %s => %s %s\n",
126                       net_protocol->name, net_protocol->ntoa ( arp->net_addr ),
127                       ll_protocol->name, ll_protocol->ntoa ( arp->ll_addr ) );
128                 memcpy ( dest_ll_addr, arp->ll_addr, ll_protocol->ll_addr_len);
129                 return 0;
130         }
131         DBG ( "ARP cache miss: %s %s\n", net_protocol->name,
132               net_protocol->ntoa ( dest_net_addr ) );
133
134         /* Allocate ARP packet */
135         iobuf = alloc_iob ( MAX_LL_HEADER_LEN + sizeof ( *arphdr ) +
136                           2 * ( MAX_LL_ADDR_LEN + MAX_NET_ADDR_LEN ) );
137         if ( ! iobuf )
138                 return -ENOMEM;
139         iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
140
141         /* Build up ARP request */
142         arphdr = iob_put ( iobuf, sizeof ( *arphdr ) );
143         arphdr->ar_hrd = ll_protocol->ll_proto;
144         arphdr->ar_hln = ll_protocol->ll_addr_len;
145         arphdr->ar_pro = net_protocol->net_proto;
146         arphdr->ar_pln = net_protocol->net_addr_len;
147         arphdr->ar_op = htons ( ARPOP_REQUEST );
148         memcpy ( iob_put ( iobuf, ll_protocol->ll_addr_len ),
149                  netdev->ll_addr, ll_protocol->ll_addr_len );
150         memcpy ( iob_put ( iobuf, net_protocol->net_addr_len ),
151                  source_net_addr, net_protocol->net_addr_len );
152         memset ( iob_put ( iobuf, ll_protocol->ll_addr_len ),
153                  0, ll_protocol->ll_addr_len );
154         memcpy ( iob_put ( iobuf, net_protocol->net_addr_len ),
155                  dest_net_addr, net_protocol->net_addr_len );
156
157         /* Transmit ARP request */
158         if ( ( rc = net_tx ( iobuf, netdev, &arp_protocol, 
159                              ll_protocol->ll_broadcast ) ) != 0 )
160                 return rc;
161
162         return -ENOENT;
163 }
164
165 /**
166  * Identify ARP protocol
167  *
168  * @v net_proto                 Network-layer protocol, in network-endian order
169  * @ret arp_net_protocol        ARP protocol, or NULL
170  *
171  */
172 static struct arp_net_protocol * arp_find_protocol ( uint16_t net_proto ) {
173         struct arp_net_protocol *arp_net_protocol;
174
175         for_each_table_entry ( arp_net_protocol, ARP_NET_PROTOCOLS ) {
176                 if ( arp_net_protocol->net_protocol->net_proto == net_proto ) {
177                         return arp_net_protocol;
178                 }
179         }
180         return NULL;
181 }
182
183 /**
184  * Process incoming ARP packets
185  *
186  * @v iobuf             I/O buffer
187  * @v netdev            Network device
188  * @v ll_source         Link-layer source address
189  * @ret rc              Return status code
190  *
191  * This handles ARP requests and responses as detailed in RFC826.  The
192  * method detailed within the RFC is pretty optimised, handling
193  * requests and responses with basically a single code path and
194  * avoiding the need for extraneous ARP requests; read the RFC for
195  * details.
196  */
197 static int arp_rx ( struct io_buffer *iobuf, struct net_device *netdev,
198                     const void *ll_source __unused ) {
199         struct arphdr *arphdr = iobuf->data;
200         struct arp_net_protocol *arp_net_protocol;
201         struct net_protocol *net_protocol;
202         struct ll_protocol *ll_protocol;
203         struct arp_entry *arp;
204         int merge = 0;
205
206         /* Identify network-layer and link-layer protocols */
207         arp_net_protocol = arp_find_protocol ( arphdr->ar_pro );
208         if ( ! arp_net_protocol )
209                 goto done;
210         net_protocol = arp_net_protocol->net_protocol;
211         ll_protocol = netdev->ll_protocol;
212
213         /* Sanity checks */
214         if ( ( arphdr->ar_hrd != ll_protocol->ll_proto ) ||
215              ( arphdr->ar_hln != ll_protocol->ll_addr_len ) ||
216              ( arphdr->ar_pln != net_protocol->net_addr_len ) )
217                 goto done;
218
219         /* See if we have an entry for this sender, and update it if so */
220         arp = arp_find_entry ( ll_protocol, net_protocol,
221                                arp_sender_pa ( arphdr ) );
222         if ( arp ) {
223                 memcpy ( arp->ll_addr, arp_sender_ha ( arphdr ),
224                          arphdr->ar_hln );
225                 merge = 1;
226                 DBG ( "ARP cache update: %s %s => %s %s\n",
227                       net_protocol->name, net_protocol->ntoa ( arp->net_addr ),
228                       ll_protocol->name, ll_protocol->ntoa ( arp->ll_addr ) );
229         }
230
231         /* See if we own the target protocol address */
232         if ( arp_net_protocol->check ( netdev, arp_target_pa ( arphdr ) ) != 0)
233                 goto done;
234         
235         /* Create new ARP table entry if necessary */
236         if ( ! merge ) {
237                 arp = &arp_table[next_new_arp_entry++ % NUM_ARP_ENTRIES];
238                 arp->ll_protocol = ll_protocol;
239                 arp->net_protocol = net_protocol;
240                 memcpy ( arp->ll_addr, arp_sender_ha ( arphdr ),
241                          arphdr->ar_hln );
242                 memcpy ( arp->net_addr, arp_sender_pa ( arphdr ),
243                          arphdr->ar_pln);
244                 DBG ( "ARP cache add: %s %s => %s %s\n",
245                       net_protocol->name, net_protocol->ntoa ( arp->net_addr ),
246                       ll_protocol->name, ll_protocol->ntoa ( arp->ll_addr ) );
247         }
248
249         /* If it's not a request, there's nothing more to do */
250         if ( arphdr->ar_op != htons ( ARPOP_REQUEST ) )
251                 goto done;
252
253         /* Change request to a reply */
254         DBG ( "ARP reply: %s %s => %s %s\n", net_protocol->name,
255               net_protocol->ntoa ( arp_target_pa ( arphdr ) ),
256               ll_protocol->name, ll_protocol->ntoa ( netdev->ll_addr ) );
257         arphdr->ar_op = htons ( ARPOP_REPLY );
258         memswap ( arp_sender_ha ( arphdr ), arp_target_ha ( arphdr ),
259                  arphdr->ar_hln + arphdr->ar_pln );
260         memcpy ( arp_sender_ha ( arphdr ), netdev->ll_addr, arphdr->ar_hln );
261
262         /* Send reply */
263         net_tx ( iob_disown ( iobuf ), netdev, &arp_protocol,
264                  arp_target_ha ( arphdr ) );
265
266  done:
267         free_iob ( iobuf );
268         return 0;
269 }
270
271 /**
272  * Transcribe ARP address
273  *
274  * @v net_addr  ARP address
275  * @ret string  "<ARP>"
276  *
277  * This operation is meaningless for the ARP protocol.
278  */
279 static const char * arp_ntoa ( const void *net_addr __unused ) {
280         return "<ARP>";
281 }
282
283 /** ARP protocol */
284 struct net_protocol arp_protocol __net_protocol = {
285         .name = "ARP",
286         .net_proto = htons ( ETH_P_ARP ),
287         .rx = arp_rx,
288         .ntoa = arp_ntoa,
289 };