/**************************************************************************
*
* Copyright (c) 2013 Alcatel-Lucent
*
* Alcatel Lucent licenses this file to You under the Apache License,
* Version 2.0 (the "License"); you may not use this file except in
* compliance with the License. A copy of the License is contained the
* file LICENSE at the top level of this repository.
* You may also obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
**************************************************************************
*
* arp.c:
* This code supports some basic arp/rarp stuff.
*
* Original author: Ed Sutter (ed.sutter@alcatel-lucent.com)
*
*/
#include "config.h"
#if INCLUDE_ETHERNET
#include "endian.h"
#include "genlib.h"
#include "ether.h"
#include "stddefs.h"
#include "cli.h"
#include "timer.h"
static void ArpFlush(void);
static void ArpShow(char *);
static void llas(char *);
static int ArpStore(uchar *,uchar *);
static int IpIsOnThisNet(uchar *);
static unsigned long probeIP;
static char probeAbort;
/* Constants used by Dynamic IPV4 Local-Link Address setup...
* (see RFC 3927)
*/
#define PROBE_WAIT 1000 /* (msec) */
#define PROBE_NUM 3
#define PROBE_MIN 1000 /* (msec) */
#define PROBE_MAX 2000 /* (msec) */
#define ANNOUNCE_WAIT 2000 /* (msec) */
#define ANNOUNCE_NUM 2
#define ANNOUNCE_INTERVAL 2000 /* (msec) */
#define MAX_CONFLICTS 10
#define RATE_LIMIT_INTERVAL 60000 /* (msec) */
#define DEFEND_INTERVAL 10000 /* (msec) */
/* arpcache[]:
* Used to store the most recent set of IP-to-MAC address correlations.
*/
struct arpcache {
uchar ip[4];
uchar ether[6];
} ArpCache[SIZEOFARPCACHE];
/* ArpIdx & ArpTot:
* Used for keeping track of current arp cache content.
*/
int ArpIdx, ArpTot;
/* ArpStore():
* Called with binary ip and ethernet addresses.
* It will store that set away in the cache.
*/
int
ArpStore(uchar *ip,uchar *ether)
{
if(EtherFromCache(ip)) {
return(0);
}
if(ArpIdx >= SIZEOFARPCACHE) {
ArpIdx=0;
}
memcpy((char *)ArpCache[ArpIdx].ip,(char *)ip,4);
memcpy((char *)ArpCache[ArpIdx].ether,(char *)ether,6);
ArpIdx++;
ArpTot++;
return(0);
}
/* EtherFromCache():
* Called with a binary (4-byte) ip address. If a match is found
* in the cache, return a pointer to that ethernet address; else
* return NULL.
*/
uchar *
EtherFromCache(uchar *ip)
{
int i;
for(i=0; i<SIZEOFARPCACHE; i++) {
if(!memcmp((char *)ArpCache[i].ip, (char *)ip,4)) {
return(ArpCache[i].ether);
}
}
return(0);
}
void
ArpFlush(void)
{
int i;
for(i=0; i<SIZEOFARPCACHE; i++) {
memset((char *)ArpCache[i].ip,0,4);
memset((char *)ArpCache[i].ether,0,6);
}
ArpIdx = ArpTot = 0;
}
/* ArpShow():
* Dump the content of the current arp cache.
*/
void
ArpShow(char *ip)
{
struct arpcache *ap, *end;
if(ArpTot < SIZEOFARPCACHE) {
end = &ArpCache[ArpTot];
} else {
end = &ArpCache[SIZEOFARPCACHE];
}
for(ap=ArpCache; ap<end; ap++) {
if((!ip) || (!memcmp((char *)ip, (char *)ap->ip,4))) {
printf("%02x:%02x:%02x:%02x:%02x:%02x = ",
ap->ether[0], ap->ether[1], ap->ether[2], ap->ether[3],
ap->ether[4], ap->ether[5]);
printf("%d.%d.%d.%d\n",
ap->ip[0], ap->ip[1], ap->ip[2], ap->ip[3]);
}
}
}
/* SendArpResp():
* Called in response to an ARP REQUEST. The incoming ethernet
* header pointer points to the memory area that contains the incoming
* ethernet packet that this function is called in response to.
* In other words, it is used to fill the majority of the response
* packet fields.
*/
int
SendArpResp(struct ether_header *re)
{
struct ether_header *te;
struct arphdr *ta, *ra;
te = (struct ether_header *) getXmitBuffer();
memcpy((char *)&(te->ether_shost), (char *)BinEnetAddr,6);
memcpy((char *)&(te->ether_dhost),(char *)&(re->ether_shost),6);
te->ether_type = ecs(ETHERTYPE_ARP);
ta = (struct arphdr *)(te + 1);
ra = (struct arphdr *)(re + 1);
ta->hardware = ra->hardware;
ta->protocol = ra->protocol;
ta->hlen = ra->hlen;
ta->plen = ra->plen;
ta->operation = ARP_RESPONSE;
memcpy((char *)ta->senderha, (char *)BinEnetAddr,6);
memcpy((char *)ta->senderia, (char *)ra->targetia,4);
memcpy((char *)ta->targetha, (char *)ra->senderha,6);
memcpy((char *)ta->targetia, (char *)ra->senderia,4);
self_ecs(ta->hardware);
self_ecs(ta->protocol);
self_ecs(ta->operation);
sendBuffer(ARPSIZE);
return(0);
}
/* SendArpRequest():
* If 'probe' is non-zero, then the request is an arp-probe.
* Refer to RFC3927 for more on that.
*/
static int
SendArpRequest(uchar *ip, int probe)
{
struct ether_header *te;
struct arphdr *ta;
/* Populate the ethernet header: */
te = (struct ether_header *) getXmitBuffer();
memcpy((char *)&(te->ether_shost), (char *)BinEnetAddr,6);
memcpy((char *)&(te->ether_dhost), (char *)BroadcastAddr,6);
te->ether_type = ecs(ETHERTYPE_ARP);
/* Populate the arp header: */
ta = (struct arphdr *)(te + 1);
ta->hardware = ecs(1); /* 1 for ethernet */
ta->protocol = ecs(ETHERTYPE_IP);
ta->hlen = 6; /* Length of hdware (ethernet) address */
ta->plen = 4; /* Length of protocol (ip) address */
ta->operation = ecs(ARP_REQUEST);
memcpy((char *)ta->senderha, (char *)BinEnetAddr,6);
if(probe) {
memset((char *)ta->senderia,0,4);
memset((char *)ta->targetha,0,6);
} else {
memcpy((char *)ta->senderia, (char *)BinIpAddr,4);
memcpy((char *)ta->targetha, (char *)BroadcastAddr,6);
}
memcpy((char *)ta->targetia, (char *)ip,4);
sendBuffer(ARPSIZE);
return(0);
}
/* GetBinNetMask():
* Return a subnet mask in binary form.
* Since this function needs a netmask, if NETMASK is not set, then
* it uses the default based on the upper 3 bits of the IP address
* (refer to TCP/IP Illustrated Volume 1 Pg8 for details).
*/
void
GetBinNetMask(uchar *binnetmask)
{
char *nm;
nm = getenv("NETMASK");
if(!nm) {
memset((char *)binnetmask,0xff,4);
if((BinIpAddr[0] & 0xe0) == 0xc0) { /* Class C */
binnetmask[3] = 0;
} else if((BinIpAddr[0] & 0xc0) == 0x80) { /* Class B */
binnetmask[3] = 0;
binnetmask[2] = 0;
} else if((BinIpAddr[0] & 0x80) == 0x00) { /* Class A */
binnetmask[3] = 0;
binnetmask[2] = 0;
binnetmask[1] = 0;
}
} else {
IpToBin(nm,binnetmask);
}
}
/* IpIsOnThisNet():
* Return 1 if the incoming ip is on this subnet; else 0.
* For each bit in the netmask that is set to 1...
* If the corresponding bits in the incoming IP and this board's IP
* do not match, return 0; else return 1.
*/
int
IpIsOnThisNet(uchar *ip)
{
int i;
uchar binnetmask[8];
GetBinNetMask(binnetmask);
for(i=0; i<4; i++) {
if((ip[i] & binnetmask[i]) != (BinIpAddr[i] & binnetmask[i])) {
return(0);
}
}
return(1);
}
/* Arp():
* If no args, just dump the arp cache.
* If arg is present, then assume it to be an ip address.
* Check the arp cache for the presence of that ip<->correlation, if
* present, print it; else issue and arp request for that IP and wait
* for a response.
*/
char *ArpHelp[] = {
"Address resolution protocol",
"-[flps:v] [IP]",
#if INCLUDE_VERBOSEHELP
" -f flush cache",
" -l dynamic config using link-local arp probe",
" -p proxy arp",
" -s{eadr} store eadr/IP into cache",
#if INCLUDE_ETHERVERBOSE
" -v verbose",
#endif
#endif
0,
};
int
Arp(int argc,char *argv[])
{
int opt, proxyarp, llad;
char binip[8], binether[8], *storeether;
llad = proxyarp = 0;
storeether = (char *)0;
while((opt=getopt(argc,argv,"flps:v")) != -1) {
switch(opt) {
case 'f': /* Flush current arp cache */
ArpFlush();
break;
case 'l': /* Dynamic ip-config using link-local addressing */
llad = 1; /* (refer to RFC 3927) */
break;
case 's': /* Store specified IP/MAC combination in arp cache. */
storeether = optarg;
break;
case 'p': /* Assume gateway will run proxy arp */
proxyarp = 1;
break;
#if INCLUDE_ETHERVERBOSE
case 'v': /* Enable verbosity for ARP. */
EtherVerbose |= SHOW_ARP;
break;
#endif
default:
return(CMD_PARAM_ERROR);
}
}
/* If llad flag is set, then we do a dynamic configuration using the
* link-local protocol as described in RFC 3927...
*/
if(llad) {
char buf[32];
struct elapsed_tmr tmr;
int i, retry, conflicts, psval;
#if INCLUDE_DHCPBOOT
dhcpDisable();
#endif
probeAbort = retry = conflicts = 0;
/* Use MAC address to establish a uniformly selected pseudo random
* value between 0 and 1000...
*/
psval = (BinEnetAddr[5] * 4);
monDelay(psval);
if(argc == (optind+1)) {
IpToBin((char *)argv[optind],(unsigned char *)&probeIP);
} else {
llas((char *)&probeIP);
}
nextllas:
SendArpRequest((uchar *)&probeIP,1);
startElapsedTimer(&tmr,ANNOUNCE_WAIT);
while(!msecElapsed(&tmr)) {
if(probeAbort) {
llas((char *)&probeIP);
probeAbort = retry = 0;
monDelay(psval + PROBE_MIN);
goto nextllas;
}
if(EtherFromCache((uchar *)&probeIP)) {
if(++conflicts > MAX_CONFLICTS) {
monDelay(RATE_LIMIT_INTERVAL);
} else {
monDelay(psval + PROBE_MIN);
}
if(++retry == PROBE_NUM) {
llas((char *)&probeIP);
retry = 0;
}
goto nextllas;
}
pollethernet();
}
/* If we're here, then we found an IP address that is not being
* used on the local subnet...
*/
setenv("IPADD",IpToString(probeIP,buf));
setenv("NETMASK","255.255.0.0");
setenv("GIPADD",0);
#if INCLUDE_ETHERVERBOSE
EthernetStartup(EtherVerbose,0);
#else
EthernetStartup(0,0);
#endif
for(i=0; i<ANNOUNCE_NUM; i++) {
SendArpRequest(BinIpAddr,0);
monDelay(ANNOUNCE_INTERVAL);
}
} else if(argc == (optind+1)) {
IpToBin((char *)argv[optind],(unsigned char *)binip);
if(storeether) {
EtherToBin((char *)storeether, (unsigned char *)binether);
ArpStore((unsigned char *)binip,(unsigned char *)binether);
} else {
if(ArpEther((unsigned char *)binip,(unsigned char *)0,proxyarp)) {
ArpShow(binip);
}
}
} else {
ArpShow(0);
}
#if INCLUDE_ETHERVERBOSE
EtherVerbose &= ~ SHOW_ARP;
#endif
return(CMD_SUCCESS);
}
/* ArpEther():
* Retrieve the ethernet address that corresponds to the incoming IP
* address. First check the local ArpCache[], then if not found issue
* an ARP request... If the incoming IP is on this net, then issue the
* request for the MAC address of that IP; otherwise, issue the request
* for this net's GATEWAY.
*/
uchar *
ArpEther(uchar *binip, uchar *ecpy, int proxyarp)
{
char *gip;
struct elapsed_tmr tmr;
uchar gbinip[8], *Ip, *ep;
int timeoutsecs, retry;
if(!EtherIsActive) {
printf("Ethernet disabled\n");
return(0);
}
/* First check local cache. If found, return with pointer to MAC. */
ep = EtherFromCache(binip);
if(ep) {
if(ecpy) {
memcpy((char *)ecpy, (char *)ep,6);
ep = ecpy;
}
return(ep);
}
retry = 0;
RetransmitDelay(DELAY_INIT_ARP);
while(1) {
/* If IP is not on this net, then get the GATEWAY IP address. */
if(!proxyarp && !IpIsOnThisNet(binip)) {
gip = getenv("GIPADD");
if(gip) {
IpToBin(gip,gbinip);
if(!IpIsOnThisNet(gbinip)) {
printf("GIPADD/IPADD subnet confusion.\n");
return(0);
}
ep = EtherFromCache(gbinip);
if(ep) {
if(ecpy) {
memcpy((char *)ecpy, (char *)ep,6);
ep = ecpy;
}
return(ep);
}
SendArpRequest(gbinip,0);
Ip = gbinip;
} else {
SendArpRequest(binip,0);
Ip = binip;
}
} else {
SendArpRequest(binip,0);
Ip = binip;
}
if(retry) {
printf(" ARP Retry #%d (%d.%d.%d.%d)\n",retry,
binip[0],binip[1],binip[2],binip[3]);
}
/* Now that the request has been issued, wait for a while to see if
* the ARP cache is loaded with the result of the request.
*/
timeoutsecs = RetransmitDelay(DELAY_OR_TIMEOUT_RETURN);
if(timeoutsecs == RETRANSMISSION_TIMEOUT) {
break;
}
startElapsedTimer(&tmr,timeoutsecs*1000);
while(!msecElapsed(&tmr)) {
ep = EtherFromCache(Ip);
if(ep) {
break;
}
pollethernet();
}
if(ep) {
if(ecpy) {
memcpy((char *)ecpy, (char *)ep,6);
ep = ecpy;
}
return(ep);
}
RetransmitDelay(DELAY_INCREMENT);
retry++;
}
#if INCLUDE_ETHERVERBOSE
if((EtherVerbose & SHOW_ARP) && (retry)) {
printf(" ARP giving up\n");
}
#endif
return(0);
}
/* processRARP();
* Called by the fundamental ethernet driver code to process a RARP
* request.
*/
int
processRARP(struct ether_header *ehdr,ushort size)
{
struct arphdr *arpp;
arpp = (struct arphdr *)(ehdr+1);
self_ecs(arpp->hardware);
self_ecs(arpp->protocol);
self_ecs(arpp->operation);
switch(arpp->operation) {
case RARP_RESPONSE:
if(!memcmp((char *)arpp->targetha, (char *)BinEnetAddr,6)) {
#if INCLUDE_ETHERVERBOSE
if(EtherVerbose & SHOW_ARP) {
printf(" RARP Response from %d.%d.%d.%d\n",
arpp->senderia[0],arpp->senderia[1],
arpp->senderia[2],arpp->senderia[3]);
printf(" MY IP: from %d.%d.%d.%d\n",
arpp->targetia[0],arpp->targetia[1],
arpp->targetia[2],arpp->targetia[3]);
}
#endif
memcpy((char *)BinIpAddr, (char *)arpp->targetia,6);
}
break;
case RARP_REQUEST:
break;
default:
printf(" Invalid RARP operation: 0x%x\n",arpp->operation);
return(-1);
}
return(0);
}
/* processARP();
* Called by the fundamental ethernet driver code to process a ARP
* request.
*/
char *
processARP(struct ether_header *ehdr,ushort size)
{
struct arphdr *arpp;
arpp = (struct arphdr *)(ehdr+1);
self_ecs(arpp->hardware);
self_ecs(arpp->protocol);
self_ecs(arpp->operation);
/* If the sender IP address is all zeroes, then assume this is
* an arp probe. If we are currently doing a probe, and the
* address we are probing matches the target IP address of this
* probe, then set a flag that will abort the current probe.
*/
if((arpp->senderia[0] == 0) && (arpp->senderia[1] == 0) &&
(arpp->senderia[2] == 0) && (arpp->senderia[3] == 0)) {
if(memcmp((char *)arpp->targetia,(char *)&probeIP,4) == 0) {
probeAbort = 1;
}
}
switch(arpp->operation) {
case ARP_REQUEST:
if(!memcmp((char *)arpp->targetia, (char *)BinIpAddr,4)) {
ArpStore(arpp->senderia,arpp->senderha);
SendArpResp(ehdr);
}
break;
case ARP_RESPONSE:
if(!memcmp((char *)arpp->targetia, (char *)BinIpAddr,4)) {
if(!memcmp((char *)arpp->targetia,(char *)arpp->senderia,4)) {
printf("WARNING: IP %s may be in use on network\n",IPadd);
}
ArpStore(arpp->senderia,arpp->senderha);
}
break;
default:
printf(" Invalid ARP operation: 0x%x\n",arpp->operation);
printPkt(ehdr,(int)size,ETHER_INCOMING);
return((char *)0);
}
return((char *)(arpp + 1));
}
/* sendGratuitousARP():
* As defined in RFC 3220...
*
* An ARP packet sent by a node in order to spontaneously
* cause other nodes to update an entry in their ARP cache.
*
* Issue a "gratuitous ARP" (RFC 3220) for two reasons...
* - make sure no other host is already using this IP address.
* - cause other devices on cable to update their arp cache.
*/
void
sendGratuitousArp(void)
{
SendArpRequest(BinIpAddr,0);
}
/* llas():
* Link local address selection.
* Referring to sec 2.1 of RFC3927, select an address using a pseudo-random
* number generator to assign a number in the range from
* 169.254.1.0 (0xa9fe0100) thru 169.254.254.255 (0xa9fefeff).
* To do this, we run a 32-bit CRC on the 6-byte MAC address, then add the
* least significant 8 bits of that value to the base of the address
* range. Each successive time this function is called, then increment
* by the least significant 4 bits of the LSB of the MAC.
*/
#define LLAD_BEGIN 0xa9fe0100
#define LLAD_END 0xa9fefeff
static void
llas(char *ipptr)
{
static char beenhere;
static unsigned long llad;
unsigned long pseudorandval, tmp;
if(beenhere == 0) {
pseudorandval = crc32(BinEnetAddr,6);
llad = LLAD_BEGIN + (pseudorandval & 0xff);
} else {
pseudorandval = (unsigned long)(BinEnetAddr[5] & 0xf);
llad += pseudorandval;
if(llad >= LLAD_END) {
llad = LLAD_BEGIN + pseudorandval + beenhere;
}
}
beenhere++;
printf("LLAD: %d.%d.%d.%d\n",
(llad & 0xff000000) >> 24, (llad & 0xff0000) >> 16,
(llad & 0xff00) >> 8, (llad & 0xff));
tmp = ecl(llad);
if(ipptr) {
memcpy(ipptr,(char *)&tmp,4);
}
}
#endif
