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