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 *
arp_find_entry(struct ll_protocol * ll_protocol,struct net_protocol * net_protocol,const void * net_addr)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 */
arp_resolve(struct net_device * netdev,struct net_protocol * net_protocol,const void * dest_net_addr,const void * source_net_addr,void * dest_ll_addr)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 netdev->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 */
arp_find_protocol(uint16_t net_proto)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 */
arp_rx(struct io_buffer * iobuf,struct net_device * netdev,const void * ll_source __unused)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 */
arp_ntoa(const void * net_addr __unused)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 };
290