1358 lines
29 KiB
C
1358 lines
29 KiB
C
/*
|
|
arp.c
|
|
|
|
Copyright 1995 Philip Homburg
|
|
*/
|
|
|
|
#include "inet.h"
|
|
#include "type.h"
|
|
|
|
#include "arp.h"
|
|
#include "assert.h"
|
|
#include "buf.h"
|
|
#include "clock.h"
|
|
#include "event.h"
|
|
#include "eth.h"
|
|
#include "io.h"
|
|
|
|
THIS_FILE
|
|
|
|
#define ARP_CACHE_NR 256
|
|
#define AP_REQ_NR 32
|
|
|
|
#define ARP_HASH_NR 256
|
|
#define ARP_HASH_MASK 0xff
|
|
#define ARP_HASH_WIDTH 4
|
|
|
|
#define MAX_ARP_RETRIES 5
|
|
#define ARP_TIMEOUT (HZ/2+1) /* .5 seconds */
|
|
#ifndef ARP_EXP_TIME
|
|
#define ARP_EXP_TIME (20L*60L*HZ) /* 20 minutes */
|
|
#endif
|
|
#define ARP_NOTRCH_EXP_TIME (30*HZ) /* 30 seconds */
|
|
#define ARP_INUSE_OFFSET (60*HZ) /* an entry in the cache can be deleted
|
|
if its not used for 1 minute */
|
|
|
|
typedef struct arp46
|
|
{
|
|
ether_addr_t a46_dstaddr;
|
|
ether_addr_t a46_srcaddr;
|
|
ether_type_t a46_ethtype;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
u16_t a_hdr, a_pro;
|
|
u8_t a_hln, a_pln;
|
|
u16_t a_op;
|
|
ether_addr_t a_sha;
|
|
u8_t a_spa[4];
|
|
ether_addr_t a_tha;
|
|
u8_t a_tpa[4];
|
|
} a46_data;
|
|
char a46_dummy[ETH_MIN_PACK_SIZE-ETH_HDR_SIZE];
|
|
} a46_data;
|
|
} arp46_t;
|
|
|
|
#define a46_hdr a46_data.a46_data.a_hdr
|
|
#define a46_pro a46_data.a46_data.a_pro
|
|
#define a46_hln a46_data.a46_data.a_hln
|
|
#define a46_pln a46_data.a46_data.a_pln
|
|
#define a46_op a46_data.a46_data.a_op
|
|
#define a46_sha a46_data.a46_data.a_sha
|
|
#define a46_spa a46_data.a46_data.a_spa
|
|
#define a46_tha a46_data.a46_data.a_tha
|
|
#define a46_tpa a46_data.a46_data.a_tpa
|
|
|
|
typedef struct arp_port
|
|
{
|
|
int ap_flags;
|
|
int ap_state;
|
|
int ap_eth_port;
|
|
int ap_ip_port;
|
|
int ap_eth_fd;
|
|
|
|
ether_addr_t ap_ethaddr; /* Ethernet address of this port */
|
|
ipaddr_t ap_ipaddr; /* IP address of this port */
|
|
|
|
struct arp_req
|
|
{
|
|
timer_t ar_timer;
|
|
int ar_entry;
|
|
int ar_req_count;
|
|
} ap_req[AP_REQ_NR];
|
|
|
|
arp_func_t ap_arp_func;
|
|
|
|
acc_t *ap_sendpkt;
|
|
acc_t *ap_sendlist;
|
|
acc_t *ap_reclist;
|
|
event_t ap_event;
|
|
} arp_port_t;
|
|
|
|
#define APF_EMPTY 0x00
|
|
#define APF_ARP_RD_IP 0x01
|
|
#define APF_ARP_RD_SP 0x02
|
|
#define APF_ARP_WR_IP 0x04
|
|
#define APF_ARP_WR_SP 0x08
|
|
#define APF_INADDR_SET 0x10
|
|
#define APF_SUSPEND 0x20
|
|
|
|
#define APS_INITIAL 1
|
|
#define APS_GETADDR 2
|
|
#define APS_ARPSTART 3
|
|
#define APS_ARPPROTO 4
|
|
#define APS_ARPMAIN 5
|
|
#define APS_ERROR 6
|
|
|
|
typedef struct arp_cache
|
|
{
|
|
int ac_flags;
|
|
int ac_state;
|
|
ether_addr_t ac_ethaddr;
|
|
ipaddr_t ac_ipaddr;
|
|
arp_port_t *ac_port;
|
|
time_t ac_expire;
|
|
time_t ac_lastuse;
|
|
} arp_cache_t;
|
|
|
|
#define ACF_EMPTY 0
|
|
#define ACF_PERM 1
|
|
#define ACF_PUB 2
|
|
|
|
#define ACS_UNUSED 0
|
|
#define ACS_INCOMPLETE 1
|
|
#define ACS_VALID 2
|
|
#define ACS_UNREACHABLE 3
|
|
|
|
PRIVATE struct arp_hash_ent
|
|
{
|
|
arp_cache_t *ahe_row[ARP_HASH_WIDTH];
|
|
} arp_hash[ARP_HASH_NR];
|
|
|
|
PRIVATE arp_port_t *arp_port_table;
|
|
PRIVATE arp_cache_t *arp_cache;
|
|
PRIVATE int arp_cache_nr;
|
|
|
|
FORWARD acc_t *arp_getdata ARGS(( int fd, size_t offset,
|
|
size_t count, int for_ioctl ));
|
|
FORWARD int arp_putdata ARGS(( int fd, size_t offset,
|
|
acc_t *data, int for_ioctl ));
|
|
FORWARD void arp_main ARGS(( arp_port_t *arp_port ));
|
|
FORWARD void arp_timeout ARGS(( int ref, timer_t *timer ));
|
|
FORWARD void setup_write ARGS(( arp_port_t *arp_port ));
|
|
FORWARD void setup_read ARGS(( arp_port_t *arp_port ));
|
|
FORWARD void do_reclist ARGS(( event_t *ev, ev_arg_t ev_arg ));
|
|
FORWARD void process_arp_pkt ARGS(( arp_port_t *arp_port, acc_t *data ));
|
|
FORWARD void client_reply ARGS(( arp_port_t *arp_port,
|
|
ipaddr_t ipaddr, ether_addr_t *ethaddr ));
|
|
FORWARD arp_cache_t *find_cache_ent ARGS(( arp_port_t *arp_port,
|
|
ipaddr_t ipaddr ));
|
|
FORWARD arp_cache_t *alloc_cache_ent ARGS(( int flags ));
|
|
FORWARD void arp_buffree ARGS(( int priority ));
|
|
#ifdef BUF_CONSISTENCY_CHECK
|
|
FORWARD void arp_bufcheck ARGS(( void ));
|
|
#endif
|
|
|
|
PUBLIC void arp_prep()
|
|
{
|
|
arp_port_table= alloc(eth_conf_nr * sizeof(arp_port_table[0]));
|
|
|
|
arp_cache_nr= ARP_CACHE_NR;
|
|
if (arp_cache_nr < (eth_conf_nr+1)*AP_REQ_NR)
|
|
{
|
|
arp_cache_nr= (eth_conf_nr+1)*AP_REQ_NR;
|
|
printf("arp: using %d cache entries instead of %d\n",
|
|
arp_cache_nr, ARP_CACHE_NR);
|
|
}
|
|
arp_cache= alloc(arp_cache_nr * sizeof(arp_cache[0]));
|
|
}
|
|
|
|
PUBLIC void arp_init()
|
|
{
|
|
arp_port_t *arp_port;
|
|
arp_cache_t *cache;
|
|
int i;
|
|
|
|
assert (BUF_S >= sizeof(struct nwio_ethstat));
|
|
assert (BUF_S >= sizeof(struct nwio_ethopt));
|
|
assert (BUF_S >= sizeof(arp46_t));
|
|
|
|
for (i=0, arp_port= arp_port_table; i<eth_conf_nr; i++, arp_port++)
|
|
{
|
|
arp_port->ap_state= APS_ERROR; /* Mark all ports as
|
|
* unavailable */
|
|
}
|
|
|
|
cache= arp_cache;
|
|
for (i=0; i<arp_cache_nr; i++, cache++)
|
|
{
|
|
cache->ac_state= ACS_UNUSED;
|
|
cache->ac_flags= ACF_EMPTY;
|
|
cache->ac_expire= 0;
|
|
cache->ac_lastuse= 0;
|
|
}
|
|
|
|
#ifndef BUF_CONSISTENCY_CHECK
|
|
bf_logon(arp_buffree);
|
|
#else
|
|
bf_logon(arp_buffree, arp_bufcheck);
|
|
#endif
|
|
}
|
|
|
|
PRIVATE void arp_main(arp_port)
|
|
arp_port_t *arp_port;
|
|
{
|
|
int result;
|
|
|
|
switch (arp_port->ap_state)
|
|
{
|
|
case APS_INITIAL:
|
|
arp_port->ap_eth_fd= eth_open(arp_port->ap_eth_port,
|
|
arp_port->ap_eth_port, arp_getdata, arp_putdata,
|
|
0 /* no put_pkt */, 0 /* no select_res */);
|
|
|
|
if (arp_port->ap_eth_fd<0)
|
|
{
|
|
DBLOCK(1, printf("arp[%d]: unable to open eth[%d]\n",
|
|
arp_port-arp_port_table,
|
|
arp_port->ap_eth_port));
|
|
return;
|
|
}
|
|
|
|
arp_port->ap_state= APS_GETADDR;
|
|
|
|
result= eth_ioctl (arp_port->ap_eth_fd, NWIOGETHSTAT);
|
|
|
|
if ( result == NW_SUSPEND)
|
|
{
|
|
arp_port->ap_flags |= APF_SUSPEND;
|
|
return;
|
|
}
|
|
assert(result == NW_OK);
|
|
|
|
/* fall through */
|
|
case APS_GETADDR:
|
|
/* Wait for IP address */
|
|
if (!(arp_port->ap_flags & APF_INADDR_SET))
|
|
return;
|
|
|
|
/* fall through */
|
|
case APS_ARPSTART:
|
|
arp_port->ap_state= APS_ARPPROTO;
|
|
|
|
result= eth_ioctl (arp_port->ap_eth_fd, NWIOSETHOPT);
|
|
|
|
if (result==NW_SUSPEND)
|
|
{
|
|
arp_port->ap_flags |= APF_SUSPEND;
|
|
return;
|
|
}
|
|
assert(result == NW_OK);
|
|
|
|
/* fall through */
|
|
case APS_ARPPROTO:
|
|
arp_port->ap_state= APS_ARPMAIN;
|
|
setup_write(arp_port);
|
|
setup_read(arp_port);
|
|
return;
|
|
|
|
default:
|
|
ip_panic((
|
|
"arp_main(&arp_port_table[%d]) called but ap_state=0x%x\n",
|
|
arp_port->ap_eth_port, arp_port->ap_state ));
|
|
}
|
|
}
|
|
|
|
PRIVATE acc_t *arp_getdata (fd, offset, count, for_ioctl)
|
|
int fd;
|
|
size_t offset;
|
|
size_t count;
|
|
int for_ioctl;
|
|
{
|
|
arp_port_t *arp_port;
|
|
acc_t *data;
|
|
int result;
|
|
|
|
arp_port= &arp_port_table[fd];
|
|
|
|
switch (arp_port->ap_state)
|
|
{
|
|
case APS_ARPPROTO:
|
|
if (!count)
|
|
{
|
|
result= (int)offset;
|
|
if (result<0)
|
|
{
|
|
arp_port->ap_state= APS_ERROR;
|
|
break;
|
|
}
|
|
if (arp_port->ap_flags & APF_SUSPEND)
|
|
{
|
|
arp_port->ap_flags &= ~APF_SUSPEND;
|
|
arp_main(arp_port);
|
|
}
|
|
return NW_OK;
|
|
}
|
|
assert ((!offset) && (count == sizeof(struct nwio_ethopt)));
|
|
{
|
|
struct nwio_ethopt *ethopt;
|
|
acc_t *acc;
|
|
|
|
acc= bf_memreq(sizeof(*ethopt));
|
|
ethopt= (struct nwio_ethopt *)ptr2acc_data(acc);
|
|
ethopt->nweo_flags= NWEO_COPY|NWEO_EN_BROAD|
|
|
NWEO_TYPESPEC;
|
|
ethopt->nweo_type= HTONS(ETH_ARP_PROTO);
|
|
return acc;
|
|
}
|
|
case APS_ARPMAIN:
|
|
assert (arp_port->ap_flags & APF_ARP_WR_IP);
|
|
if (!count)
|
|
{
|
|
data= arp_port->ap_sendpkt;
|
|
arp_port->ap_sendpkt= NULL;
|
|
assert(data);
|
|
bf_afree(data); data= NULL;
|
|
|
|
result= (int)offset;
|
|
if (result<0)
|
|
{
|
|
DIFBLOCK(1, (result != NW_SUSPEND),
|
|
printf(
|
|
"arp[%d]: write error on port %d: error %d\n",
|
|
fd, arp_port->ap_eth_fd, result));
|
|
|
|
arp_port->ap_state= APS_ERROR;
|
|
break;
|
|
}
|
|
arp_port->ap_flags &= ~APF_ARP_WR_IP;
|
|
if (arp_port->ap_flags & APF_ARP_WR_SP)
|
|
setup_write(arp_port);
|
|
return NW_OK;
|
|
}
|
|
assert (offset+count <= sizeof(arp46_t));
|
|
data= arp_port->ap_sendpkt;
|
|
assert(data);
|
|
data= bf_cut(data, offset, count);
|
|
|
|
return data;
|
|
default:
|
|
printf("arp_getdata(%d, 0x%d, 0x%d) called but ap_state=0x%x\n",
|
|
fd, offset, count, arp_port->ap_state);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
PRIVATE int arp_putdata (fd, offset, data, for_ioctl)
|
|
int fd;
|
|
size_t offset;
|
|
acc_t *data;
|
|
int for_ioctl;
|
|
{
|
|
arp_port_t *arp_port;
|
|
int result;
|
|
struct nwio_ethstat *ethstat;
|
|
ev_arg_t ev_arg;
|
|
acc_t *tmpacc;
|
|
|
|
arp_port= &arp_port_table[fd];
|
|
|
|
if (arp_port->ap_flags & APF_ARP_RD_IP)
|
|
{
|
|
if (!data)
|
|
{
|
|
result= (int)offset;
|
|
if (result<0)
|
|
{
|
|
DIFBLOCK(1, (result != NW_SUSPEND), printf(
|
|
"arp[%d]: read error on port %d: error %d\n",
|
|
fd, arp_port->ap_eth_fd, result));
|
|
|
|
return NW_OK;
|
|
}
|
|
if (arp_port->ap_flags & APF_ARP_RD_SP)
|
|
{
|
|
arp_port->ap_flags &= ~(APF_ARP_RD_IP|
|
|
APF_ARP_RD_SP);
|
|
setup_read(arp_port);
|
|
}
|
|
else
|
|
arp_port->ap_flags &= ~(APF_ARP_RD_IP|
|
|
APF_ARP_RD_SP);
|
|
return NW_OK;
|
|
}
|
|
assert (!offset);
|
|
/* Warning: the above assertion is illegal; puts and gets of
|
|
data can be brokenup in any piece the server likes. However
|
|
we assume that the server is eth.c and it transfers only
|
|
whole packets.
|
|
*/
|
|
data= bf_packIffLess(data, sizeof(arp46_t));
|
|
if (data->acc_length >= sizeof(arp46_t))
|
|
{
|
|
if (!arp_port->ap_reclist)
|
|
{
|
|
ev_arg.ev_ptr= arp_port;
|
|
ev_enqueue(&arp_port->ap_event, do_reclist,
|
|
ev_arg);
|
|
}
|
|
if (data->acc_linkC != 1)
|
|
{
|
|
tmpacc= bf_dupacc(data);
|
|
bf_afree(data);
|
|
data= tmpacc;
|
|
tmpacc= NULL;
|
|
}
|
|
data->acc_ext_link= arp_port->ap_reclist;
|
|
arp_port->ap_reclist= data;
|
|
}
|
|
else
|
|
bf_afree(data);
|
|
return NW_OK;
|
|
}
|
|
switch (arp_port->ap_state)
|
|
{
|
|
case APS_GETADDR:
|
|
if (!data)
|
|
{
|
|
result= (int)offset;
|
|
if (result<0)
|
|
{
|
|
arp_port->ap_state= APS_ERROR;
|
|
break;
|
|
}
|
|
if (arp_port->ap_flags & APF_SUSPEND)
|
|
{
|
|
arp_port->ap_flags &= ~APF_SUSPEND;
|
|
arp_main(arp_port);
|
|
}
|
|
return NW_OK;
|
|
}
|
|
compare (bf_bufsize(data), ==, sizeof(*ethstat));
|
|
data= bf_packIffLess(data, sizeof(*ethstat));
|
|
compare (data->acc_length, ==, sizeof(*ethstat));
|
|
ethstat= (struct nwio_ethstat *)ptr2acc_data(data);
|
|
arp_port->ap_ethaddr= ethstat->nwes_addr;
|
|
bf_afree(data);
|
|
return NW_OK;
|
|
default:
|
|
printf("arp_putdata(%d, 0x%d, 0x%lx) called but ap_state=0x%x\n",
|
|
fd, offset, (unsigned long)data, arp_port->ap_state);
|
|
break;
|
|
}
|
|
return EGENERIC;
|
|
}
|
|
|
|
PRIVATE void setup_read(arp_port)
|
|
arp_port_t *arp_port;
|
|
{
|
|
int result;
|
|
|
|
while (!(arp_port->ap_flags & APF_ARP_RD_IP))
|
|
{
|
|
arp_port->ap_flags |= APF_ARP_RD_IP;
|
|
result= eth_read (arp_port->ap_eth_fd, ETH_MAX_PACK_SIZE);
|
|
if (result == NW_SUSPEND)
|
|
{
|
|
arp_port->ap_flags |= APF_ARP_RD_SP;
|
|
return;
|
|
}
|
|
DIFBLOCK(1, (result != NW_OK),
|
|
printf("arp[%d]: eth_read(..,%d)=%d\n",
|
|
arp_port-arp_port_table, ETH_MAX_PACK_SIZE, result));
|
|
}
|
|
}
|
|
|
|
PRIVATE void setup_write(arp_port)
|
|
arp_port_t *arp_port;
|
|
{
|
|
int result;
|
|
acc_t *data;
|
|
|
|
for(;;)
|
|
{
|
|
data= arp_port->ap_sendlist;
|
|
if (!data)
|
|
break;
|
|
arp_port->ap_sendlist= data->acc_ext_link;
|
|
|
|
if (arp_port->ap_ipaddr == HTONL(0x00000000))
|
|
{
|
|
/* Interface is down */
|
|
printf(
|
|
"arp[%d]: not sending ARP packet, interface is down\n",
|
|
arp_port-arp_port_table);
|
|
bf_afree(data); data= NULL;
|
|
continue;
|
|
}
|
|
|
|
assert(!arp_port->ap_sendpkt);
|
|
arp_port->ap_sendpkt= data; data= NULL;
|
|
|
|
arp_port->ap_flags= (arp_port->ap_flags & ~APF_ARP_WR_SP) |
|
|
APF_ARP_WR_IP;
|
|
result= eth_write(arp_port->ap_eth_fd, sizeof(arp46_t));
|
|
if (result == NW_SUSPEND)
|
|
{
|
|
arp_port->ap_flags |= APF_ARP_WR_SP;
|
|
break;
|
|
}
|
|
if (result<0)
|
|
{
|
|
DIFBLOCK(1, (result != NW_SUSPEND),
|
|
printf("arp[%d]: eth_write(..,%d)=%d\n",
|
|
arp_port-arp_port_table, sizeof(arp46_t),
|
|
result));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
PRIVATE void do_reclist(ev, ev_arg)
|
|
event_t *ev;
|
|
ev_arg_t ev_arg;
|
|
{
|
|
arp_port_t *arp_port;
|
|
acc_t *data;
|
|
|
|
arp_port= ev_arg.ev_ptr;
|
|
assert(ev == &arp_port->ap_event);
|
|
|
|
while (data= arp_port->ap_reclist, data != NULL)
|
|
{
|
|
arp_port->ap_reclist= data->acc_ext_link;
|
|
process_arp_pkt(arp_port, data);
|
|
bf_afree(data);
|
|
}
|
|
}
|
|
|
|
PRIVATE void process_arp_pkt (arp_port, data)
|
|
arp_port_t *arp_port;
|
|
acc_t *data;
|
|
{
|
|
int i, entry, do_reply;
|
|
arp46_t *arp;
|
|
u16_t *p;
|
|
arp_cache_t *ce, *cache;
|
|
struct arp_req *reqp;
|
|
time_t curr_time;
|
|
ipaddr_t spa, tpa;
|
|
|
|
curr_time= get_time();
|
|
|
|
arp= (arp46_t *)ptr2acc_data(data);
|
|
memcpy(&spa, arp->a46_spa, sizeof(ipaddr_t));
|
|
memcpy(&tpa, arp->a46_tpa, sizeof(ipaddr_t));
|
|
|
|
if (arp->a46_hdr != HTONS(ARP_ETHERNET) ||
|
|
arp->a46_hln != 6 ||
|
|
arp->a46_pro != HTONS(ETH_IP_PROTO) ||
|
|
arp->a46_pln != 4)
|
|
return;
|
|
if (arp_port->ap_ipaddr == HTONL(0x00000000))
|
|
{
|
|
/* Interface is down */
|
|
#if DEBUG
|
|
printf("arp[%d]: dropping ARP packet, interface is down\n",
|
|
arp_port-arp_port_table);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
ce= find_cache_ent(arp_port, spa);
|
|
cache= NULL; /* lint */
|
|
|
|
do_reply= 0;
|
|
if (arp->a46_op != HTONS(ARP_REQUEST))
|
|
; /* No need to reply */
|
|
else if (tpa == arp_port->ap_ipaddr)
|
|
do_reply= 1;
|
|
else
|
|
{
|
|
/* Look for a published entry */
|
|
cache= find_cache_ent(arp_port, tpa);
|
|
if (cache)
|
|
{
|
|
if (cache->ac_flags & ACF_PUB)
|
|
{
|
|
/* Published entry */
|
|
do_reply= 1;
|
|
}
|
|
else
|
|
{
|
|
/* Nothing to do */
|
|
cache= NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ce == NULL)
|
|
{
|
|
if (!do_reply)
|
|
return;
|
|
|
|
DBLOCK(0x10, printf("arp[%d]: allocating entry for ",
|
|
arp_port-arp_port_table);
|
|
writeIpAddr(spa); printf("\n"));
|
|
|
|
ce= alloc_cache_ent(ACF_EMPTY);
|
|
ce->ac_flags= ACF_EMPTY;
|
|
ce->ac_state= ACS_VALID;
|
|
ce->ac_ethaddr= arp->a46_sha;
|
|
ce->ac_ipaddr= spa;
|
|
ce->ac_port= arp_port;
|
|
ce->ac_expire= curr_time+ARP_EXP_TIME;
|
|
ce->ac_lastuse= curr_time-ARP_INUSE_OFFSET; /* never used */
|
|
}
|
|
|
|
if (ce->ac_state == ACS_INCOMPLETE || ce->ac_state == ACS_UNREACHABLE)
|
|
{
|
|
ce->ac_ethaddr= arp->a46_sha;
|
|
if (ce->ac_state == ACS_INCOMPLETE)
|
|
{
|
|
/* Find request entry */
|
|
entry= ce-arp_cache;
|
|
for (i= 0, reqp= arp_port->ap_req; i<AP_REQ_NR;
|
|
i++, reqp++)
|
|
{
|
|
if (reqp->ar_entry == entry)
|
|
break;
|
|
}
|
|
assert(i < AP_REQ_NR);
|
|
clck_untimer(&reqp->ar_timer);
|
|
reqp->ar_entry= -1;
|
|
|
|
ce->ac_state= ACS_VALID;
|
|
client_reply(arp_port, spa, &arp->a46_sha);
|
|
}
|
|
else
|
|
ce->ac_state= ACS_VALID;
|
|
}
|
|
|
|
/* Update fields in the arp cache. */
|
|
if (memcmp(&ce->ac_ethaddr, &arp->a46_sha,
|
|
sizeof(ce->ac_ethaddr)) != 0)
|
|
{
|
|
printf("arp[%d]: ethernet address for IP address ",
|
|
arp_port-arp_port_table);
|
|
writeIpAddr(spa);
|
|
printf(" changed from ");
|
|
writeEtherAddr(&ce->ac_ethaddr);
|
|
printf(" to ");
|
|
writeEtherAddr(&arp->a46_sha);
|
|
printf("\n");
|
|
ce->ac_ethaddr= arp->a46_sha;
|
|
}
|
|
ce->ac_expire= curr_time+ARP_EXP_TIME;
|
|
|
|
if (do_reply)
|
|
{
|
|
data= bf_memreq(sizeof(arp46_t));
|
|
arp= (arp46_t *)ptr2acc_data(data);
|
|
|
|
/* Clear padding */
|
|
assert(sizeof(arp->a46_data.a46_dummy) % sizeof(*p) == 0);
|
|
for (i= 0, p= (u16_t *)arp->a46_data.a46_dummy;
|
|
i < sizeof(arp->a46_data.a46_dummy)/sizeof(*p);
|
|
i++, p++)
|
|
{
|
|
*p= 0xdead;
|
|
}
|
|
|
|
arp->a46_dstaddr= ce->ac_ethaddr;
|
|
arp->a46_hdr= HTONS(ARP_ETHERNET);
|
|
arp->a46_pro= HTONS(ETH_IP_PROTO);
|
|
arp->a46_hln= 6;
|
|
arp->a46_pln= 4;
|
|
|
|
arp->a46_op= htons(ARP_REPLY);
|
|
if (tpa == arp_port->ap_ipaddr)
|
|
{
|
|
arp->a46_sha= arp_port->ap_ethaddr;
|
|
}
|
|
else
|
|
{
|
|
assert(cache);
|
|
arp->a46_sha= cache->ac_ethaddr;
|
|
}
|
|
memcpy (arp->a46_spa, &tpa, sizeof(ipaddr_t));
|
|
arp->a46_tha= ce->ac_ethaddr;
|
|
memcpy (arp->a46_tpa, &ce->ac_ipaddr, sizeof(ipaddr_t));
|
|
|
|
assert(data->acc_linkC == 1);
|
|
data->acc_ext_link= arp_port->ap_sendlist;
|
|
arp_port->ap_sendlist= data; data= NULL;
|
|
|
|
if (!(arp_port->ap_flags & APF_ARP_WR_IP))
|
|
setup_write(arp_port);
|
|
}
|
|
}
|
|
|
|
PRIVATE void client_reply (arp_port, ipaddr, ethaddr)
|
|
arp_port_t *arp_port;
|
|
ipaddr_t ipaddr;
|
|
ether_addr_t *ethaddr;
|
|
{
|
|
(*arp_port->ap_arp_func)(arp_port->ap_ip_port, ipaddr, ethaddr);
|
|
}
|
|
|
|
PRIVATE arp_cache_t *find_cache_ent (arp_port, ipaddr)
|
|
arp_port_t *arp_port;
|
|
ipaddr_t ipaddr;
|
|
{
|
|
arp_cache_t *ce;
|
|
int i;
|
|
unsigned hash;
|
|
|
|
hash= (ipaddr >> 24) ^ (ipaddr >> 16) ^ (ipaddr >> 8) ^ ipaddr;
|
|
hash &= ARP_HASH_MASK;
|
|
|
|
ce= arp_hash[hash].ahe_row[0];
|
|
if (ce && ce->ac_ipaddr == ipaddr && ce->ac_port == arp_port &&
|
|
ce->ac_state != ACS_UNUSED)
|
|
{
|
|
return ce;
|
|
}
|
|
for (i= 1; i<ARP_HASH_WIDTH; i++)
|
|
{
|
|
ce= arp_hash[hash].ahe_row[i];
|
|
if (!ce || ce->ac_ipaddr != ipaddr || ce->ac_port != arp_port
|
|
|| ce->ac_state == ACS_UNUSED)
|
|
{
|
|
continue;
|
|
}
|
|
arp_hash[hash].ahe_row[i]= arp_hash[hash].ahe_row[0];
|
|
arp_hash[hash].ahe_row[0]= ce;
|
|
return ce;
|
|
}
|
|
|
|
for (i=0, ce= arp_cache; i<arp_cache_nr; i++, ce++)
|
|
{
|
|
if (ce->ac_state != ACS_UNUSED &&
|
|
ce->ac_port == arp_port &&
|
|
ce->ac_ipaddr == ipaddr)
|
|
{
|
|
for (i= ARP_HASH_WIDTH-1; i>0; i--)
|
|
{
|
|
arp_hash[hash].ahe_row[i]=
|
|
arp_hash[hash].ahe_row[i-1];
|
|
}
|
|
assert(i == 0);
|
|
arp_hash[hash].ahe_row[0]= ce;
|
|
return ce;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
PRIVATE arp_cache_t *alloc_cache_ent(flags)
|
|
int flags;
|
|
{
|
|
arp_cache_t *cache, *old;
|
|
int i;
|
|
|
|
old= NULL;
|
|
for (i=0, cache= arp_cache; i<arp_cache_nr; i++, cache++)
|
|
{
|
|
if (cache->ac_state == ACS_UNUSED)
|
|
{
|
|
old= cache;
|
|
break;
|
|
}
|
|
if (cache->ac_state == ACS_INCOMPLETE)
|
|
continue;
|
|
if (cache->ac_flags & ACF_PERM)
|
|
continue;
|
|
if (!old || cache->ac_lastuse < old->ac_lastuse)
|
|
old= cache;
|
|
}
|
|
assert(old);
|
|
|
|
if (!flags)
|
|
return old;
|
|
|
|
/* Get next permanent entry */
|
|
for (i=0, cache= arp_cache; i<arp_cache_nr; i++, cache++)
|
|
{
|
|
if (cache->ac_state == ACS_UNUSED)
|
|
break;
|
|
if (cache->ac_flags & ACF_PERM)
|
|
continue;
|
|
break;
|
|
}
|
|
if (i >= arp_cache_nr/2)
|
|
return NULL; /* Too many entries */
|
|
if (cache != old)
|
|
{
|
|
assert(old > cache);
|
|
*old= *cache;
|
|
old= cache;
|
|
}
|
|
|
|
if (!(flags & ACF_PUB))
|
|
return old;
|
|
|
|
/* Get first nonpublished entry */
|
|
for (i=0, cache= arp_cache; i<arp_cache_nr; i++, cache++)
|
|
{
|
|
if (cache->ac_state == ACS_UNUSED)
|
|
break;
|
|
if (cache->ac_flags & ACF_PUB)
|
|
continue;
|
|
break;
|
|
}
|
|
if (cache != old)
|
|
{
|
|
assert(old > cache);
|
|
*old= *cache;
|
|
old= cache;
|
|
}
|
|
return old;
|
|
}
|
|
|
|
PUBLIC void arp_set_ipaddr (eth_port, ipaddr)
|
|
int eth_port;
|
|
ipaddr_t ipaddr;
|
|
{
|
|
arp_port_t *arp_port;
|
|
|
|
if (eth_port < 0 || eth_port >= eth_conf_nr)
|
|
return;
|
|
arp_port= &arp_port_table[eth_port];
|
|
|
|
arp_port->ap_ipaddr= ipaddr;
|
|
arp_port->ap_flags |= APF_INADDR_SET;
|
|
arp_port->ap_flags &= ~APF_SUSPEND;
|
|
if (arp_port->ap_state == APS_GETADDR)
|
|
arp_main(arp_port);
|
|
}
|
|
|
|
PUBLIC int arp_set_cb(eth_port, ip_port, arp_func)
|
|
int eth_port;
|
|
int ip_port;
|
|
arp_func_t arp_func;
|
|
{
|
|
int i;
|
|
arp_port_t *arp_port;
|
|
|
|
assert(eth_port >= 0);
|
|
if (eth_port >= eth_conf_nr)
|
|
return ENXIO;
|
|
|
|
arp_port= &arp_port_table[eth_port];
|
|
arp_port->ap_eth_port= eth_port;
|
|
arp_port->ap_ip_port= ip_port;
|
|
arp_port->ap_state= APS_INITIAL;
|
|
arp_port->ap_flags= APF_EMPTY;
|
|
arp_port->ap_arp_func= arp_func;
|
|
arp_port->ap_sendpkt= NULL;
|
|
arp_port->ap_sendlist= NULL;
|
|
arp_port->ap_reclist= NULL;
|
|
for (i= 0; i<AP_REQ_NR; i++)
|
|
arp_port->ap_req[i].ar_entry= -1;
|
|
ev_init(&arp_port->ap_event);
|
|
|
|
arp_main(arp_port);
|
|
|
|
return NW_OK;
|
|
}
|
|
|
|
PUBLIC int arp_ip_eth (eth_port, ipaddr, ethaddr)
|
|
int eth_port;
|
|
ipaddr_t ipaddr;
|
|
ether_addr_t *ethaddr;
|
|
{
|
|
int i, ref;
|
|
arp_port_t *arp_port;
|
|
struct arp_req *reqp;
|
|
arp_cache_t *ce;
|
|
time_t curr_time;
|
|
|
|
assert(eth_port >= 0 && eth_port < eth_conf_nr);
|
|
arp_port= &arp_port_table[eth_port];
|
|
assert(arp_port->ap_state == APS_ARPMAIN ||
|
|
(printf("arp[%d]: ap_state= %d\n", arp_port-arp_port_table,
|
|
arp_port->ap_state), 0));
|
|
|
|
curr_time= get_time();
|
|
|
|
ce= find_cache_ent (arp_port, ipaddr);
|
|
if (ce && ce->ac_expire < curr_time)
|
|
{
|
|
assert(ce->ac_state != ACS_INCOMPLETE);
|
|
|
|
/* Check whether there is enough space for an ARP
|
|
* request or not.
|
|
*/
|
|
for (i= 0, reqp= arp_port->ap_req; i<AP_REQ_NR; i++, reqp++)
|
|
{
|
|
if (reqp->ar_entry < 0)
|
|
break;
|
|
}
|
|
if (i < AP_REQ_NR)
|
|
{
|
|
/* Okay, expire this entry. */
|
|
ce->ac_state= ACS_UNUSED;
|
|
ce= NULL;
|
|
}
|
|
else
|
|
{
|
|
/* Continue using this entry for a while */
|
|
printf("arp[%d]: Overloaded! Keeping entry for ",
|
|
arp_port-arp_port_table);
|
|
writeIpAddr(ipaddr);
|
|
printf("\n");
|
|
ce->ac_expire= curr_time+ARP_NOTRCH_EXP_TIME;
|
|
}
|
|
}
|
|
if (ce)
|
|
{
|
|
/* Found an entry. This entry should be valid, unreachable
|
|
* or incomplete.
|
|
*/
|
|
ce->ac_lastuse= curr_time;
|
|
if (ce->ac_state == ACS_VALID)
|
|
{
|
|
*ethaddr= ce->ac_ethaddr;
|
|
return NW_OK;
|
|
}
|
|
if (ce->ac_state == ACS_UNREACHABLE)
|
|
return EHOSTUNREACH;
|
|
assert(ce->ac_state == ACS_INCOMPLETE);
|
|
|
|
return NW_SUSPEND;
|
|
}
|
|
|
|
/* Find an empty slot for an ARP request */
|
|
for (i= 0, reqp= arp_port->ap_req; i<AP_REQ_NR; i++, reqp++)
|
|
{
|
|
if (reqp->ar_entry < 0)
|
|
break;
|
|
}
|
|
if (i >= AP_REQ_NR)
|
|
{
|
|
/* We should be able to report that this ARP request
|
|
* cannot be accepted. At the moment we just return SUSPEND.
|
|
*/
|
|
return NW_SUSPEND;
|
|
}
|
|
ref= (eth_port*AP_REQ_NR + i);
|
|
|
|
ce= alloc_cache_ent(ACF_EMPTY);
|
|
ce->ac_flags= 0;
|
|
ce->ac_state= ACS_INCOMPLETE;
|
|
ce->ac_ipaddr= ipaddr;
|
|
ce->ac_port= arp_port;
|
|
ce->ac_expire= curr_time+ARP_EXP_TIME;
|
|
ce->ac_lastuse= curr_time;
|
|
|
|
reqp->ar_entry= ce-arp_cache;
|
|
reqp->ar_req_count= -1;
|
|
|
|
/* Send the first packet by expiring the timer */
|
|
clck_timer(&reqp->ar_timer, 1, arp_timeout, ref);
|
|
|
|
return NW_SUSPEND;
|
|
}
|
|
|
|
PUBLIC int arp_ioctl (eth_port, fd, req, get_userdata, put_userdata)
|
|
int eth_port;
|
|
int fd;
|
|
ioreq_t req;
|
|
get_userdata_t get_userdata;
|
|
put_userdata_t put_userdata;
|
|
{
|
|
arp_port_t *arp_port;
|
|
arp_cache_t *ce, *cache;
|
|
acc_t *data;
|
|
nwio_arp_t *arp_iop;
|
|
int entno, result, ac_flags;
|
|
u32_t flags;
|
|
ipaddr_t ipaddr;
|
|
time_t curr_time;
|
|
|
|
assert(eth_port >= 0 && eth_port < eth_conf_nr);
|
|
arp_port= &arp_port_table[eth_port];
|
|
assert(arp_port->ap_state == APS_ARPMAIN ||
|
|
(printf("arp[%d]: ap_state= %d\n", arp_port-arp_port_table,
|
|
arp_port->ap_state), 0));
|
|
|
|
switch(req)
|
|
{
|
|
case NWIOARPGIP:
|
|
data= (*get_userdata)(fd, 0, sizeof(*arp_iop), TRUE);
|
|
if (data == NULL)
|
|
return EFAULT;
|
|
data= bf_packIffLess(data, sizeof(*arp_iop));
|
|
arp_iop= (nwio_arp_t *)ptr2acc_data(data);
|
|
ipaddr= arp_iop->nwa_ipaddr;
|
|
ce= NULL; /* lint */
|
|
for (entno= 0; entno < arp_cache_nr; entno++)
|
|
{
|
|
ce= &arp_cache[entno];
|
|
if (ce->ac_state == ACS_UNUSED ||
|
|
ce->ac_port != arp_port)
|
|
{
|
|
continue;
|
|
}
|
|
if (ce->ac_ipaddr == ipaddr)
|
|
break;
|
|
}
|
|
if (entno == arp_cache_nr)
|
|
{
|
|
/* Also report the address of this interface */
|
|
if (ipaddr != arp_port->ap_ipaddr)
|
|
{
|
|
bf_afree(data);
|
|
return ENOENT;
|
|
}
|
|
arp_iop->nwa_entno= arp_cache_nr;
|
|
arp_iop->nwa_ipaddr= ipaddr;
|
|
arp_iop->nwa_ethaddr= arp_port->ap_ethaddr;
|
|
arp_iop->nwa_flags= NWAF_PERM | NWAF_PUB;
|
|
}
|
|
else
|
|
{
|
|
arp_iop->nwa_entno= entno+1;
|
|
arp_iop->nwa_ipaddr= ce->ac_ipaddr;
|
|
arp_iop->nwa_ethaddr= ce->ac_ethaddr;
|
|
arp_iop->nwa_flags= 0;
|
|
if (ce->ac_state == ACS_INCOMPLETE)
|
|
arp_iop->nwa_flags |= NWAF_INCOMPLETE;
|
|
if (ce->ac_state == ACS_UNREACHABLE)
|
|
arp_iop->nwa_flags |= NWAF_DEAD;
|
|
if (ce->ac_flags & ACF_PERM)
|
|
arp_iop->nwa_flags |= NWAF_PERM;
|
|
if (ce->ac_flags & ACF_PUB)
|
|
arp_iop->nwa_flags |= NWAF_PUB;
|
|
}
|
|
|
|
result= (*put_userdata)(fd, 0, data, TRUE);
|
|
return result;
|
|
|
|
case NWIOARPGNEXT:
|
|
data= (*get_userdata)(fd, 0, sizeof(*arp_iop), TRUE);
|
|
if (data == NULL)
|
|
return EFAULT;
|
|
data= bf_packIffLess(data, sizeof(*arp_iop));
|
|
arp_iop= (nwio_arp_t *)ptr2acc_data(data);
|
|
entno= arp_iop->nwa_entno;
|
|
if (entno < 0)
|
|
entno= 0;
|
|
ce= NULL; /* lint */
|
|
for (; entno < arp_cache_nr; entno++)
|
|
{
|
|
ce= &arp_cache[entno];
|
|
if (ce->ac_state == ACS_UNUSED ||
|
|
ce->ac_port != arp_port)
|
|
{
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (entno == arp_cache_nr)
|
|
{
|
|
bf_afree(data);
|
|
return ENOENT;
|
|
}
|
|
arp_iop->nwa_entno= entno+1;
|
|
arp_iop->nwa_ipaddr= ce->ac_ipaddr;
|
|
arp_iop->nwa_ethaddr= ce->ac_ethaddr;
|
|
arp_iop->nwa_flags= 0;
|
|
if (ce->ac_state == ACS_INCOMPLETE)
|
|
arp_iop->nwa_flags |= NWAF_INCOMPLETE;
|
|
if (ce->ac_state == ACS_UNREACHABLE)
|
|
arp_iop->nwa_flags |= NWAF_DEAD;
|
|
if (ce->ac_flags & ACF_PERM)
|
|
arp_iop->nwa_flags |= NWAF_PERM;
|
|
if (ce->ac_flags & ACF_PUB)
|
|
arp_iop->nwa_flags |= NWAF_PUB;
|
|
|
|
result= (*put_userdata)(fd, 0, data, TRUE);
|
|
return result;
|
|
|
|
case NWIOARPSIP:
|
|
data= (*get_userdata)(fd, 0, sizeof(*arp_iop), TRUE);
|
|
if (data == NULL)
|
|
return EFAULT;
|
|
data= bf_packIffLess(data, sizeof(*arp_iop));
|
|
arp_iop= (nwio_arp_t *)ptr2acc_data(data);
|
|
ipaddr= arp_iop->nwa_ipaddr;
|
|
if (find_cache_ent(arp_port, ipaddr))
|
|
{
|
|
bf_afree(data);
|
|
return EEXIST;
|
|
}
|
|
|
|
flags= arp_iop->nwa_flags;
|
|
ac_flags= ACF_EMPTY;
|
|
if (flags & NWAF_PERM)
|
|
ac_flags |= ACF_PERM;
|
|
if (flags & NWAF_PUB)
|
|
ac_flags |= ACF_PUB|ACF_PERM;
|
|
|
|
/* Allocate a cache entry */
|
|
ce= alloc_cache_ent(ac_flags);
|
|
if (ce == NULL)
|
|
{
|
|
bf_afree(data);
|
|
return ENOMEM;
|
|
}
|
|
|
|
ce->ac_flags= ac_flags;
|
|
ce->ac_state= ACS_VALID;
|
|
ce->ac_ethaddr= arp_iop->nwa_ethaddr;
|
|
ce->ac_ipaddr= arp_iop->nwa_ipaddr;
|
|
ce->ac_port= arp_port;
|
|
|
|
curr_time= get_time();
|
|
ce->ac_expire= curr_time+ARP_EXP_TIME;
|
|
ce->ac_lastuse= curr_time;
|
|
|
|
bf_afree(data);
|
|
return 0;
|
|
|
|
case NWIOARPDIP:
|
|
data= (*get_userdata)(fd, 0, sizeof(*arp_iop), TRUE);
|
|
if (data == NULL)
|
|
return EFAULT;
|
|
data= bf_packIffLess(data, sizeof(*arp_iop));
|
|
arp_iop= (nwio_arp_t *)ptr2acc_data(data);
|
|
ipaddr= arp_iop->nwa_ipaddr;
|
|
bf_afree(data); data= NULL;
|
|
ce= find_cache_ent(arp_port, ipaddr);
|
|
if (!ce)
|
|
return ENOENT;
|
|
if (ce->ac_state == ACS_INCOMPLETE)
|
|
return EINVAL;
|
|
|
|
ac_flags= ce->ac_flags;
|
|
if (ac_flags & ACF_PUB)
|
|
{
|
|
/* Make sure entry is at the end of published
|
|
* entries.
|
|
*/
|
|
for (entno= 0, cache= arp_cache;
|
|
entno<arp_cache_nr; entno++, cache++)
|
|
{
|
|
if (cache->ac_state == ACS_UNUSED)
|
|
break;
|
|
if (cache->ac_flags & ACF_PUB)
|
|
continue;
|
|
break;
|
|
}
|
|
assert(cache > arp_cache);
|
|
cache--;
|
|
if (cache != ce)
|
|
{
|
|
assert(cache > ce);
|
|
*ce= *cache;
|
|
ce= cache;
|
|
}
|
|
}
|
|
if (ac_flags & ACF_PERM)
|
|
{
|
|
/* Make sure entry is at the end of permanent
|
|
* entries.
|
|
*/
|
|
for (entno= 0, cache= arp_cache;
|
|
entno<arp_cache_nr; entno++, cache++)
|
|
{
|
|
if (cache->ac_state == ACS_UNUSED)
|
|
break;
|
|
if (cache->ac_flags & ACF_PERM)
|
|
continue;
|
|
break;
|
|
}
|
|
assert(cache > arp_cache);
|
|
cache--;
|
|
if (cache != ce)
|
|
{
|
|
assert(cache > ce);
|
|
*ce= *cache;
|
|
ce= cache;
|
|
}
|
|
}
|
|
|
|
/* Clear entry */
|
|
ce->ac_state= ACS_UNUSED;
|
|
|
|
return 0;
|
|
|
|
default:
|
|
ip_panic(("arp_ioctl: unknown request 0x%lx",
|
|
(unsigned long)req));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
PRIVATE void arp_timeout (ref, timer)
|
|
int ref;
|
|
timer_t *timer;
|
|
{
|
|
int i, port, reqind, acind;
|
|
arp_port_t *arp_port;
|
|
arp_cache_t *ce;
|
|
struct arp_req *reqp;
|
|
time_t curr_time;
|
|
acc_t *data;
|
|
arp46_t *arp;
|
|
u16_t *p;
|
|
|
|
port= ref / AP_REQ_NR;
|
|
reqind= ref % AP_REQ_NR;
|
|
|
|
assert(port >= 0 && port <eth_conf_nr);
|
|
arp_port= &arp_port_table[port];
|
|
|
|
reqp= &arp_port->ap_req[reqind];
|
|
assert (timer == &reqp->ar_timer);
|
|
|
|
acind= reqp->ar_entry;
|
|
|
|
assert(acind >= 0 && acind < arp_cache_nr);
|
|
ce= &arp_cache[acind];
|
|
|
|
assert(ce->ac_port == arp_port);
|
|
assert(ce->ac_state == ACS_INCOMPLETE);
|
|
|
|
if (++reqp->ar_req_count >= MAX_ARP_RETRIES)
|
|
{
|
|
curr_time= get_time();
|
|
ce->ac_state= ACS_UNREACHABLE;
|
|
ce->ac_expire= curr_time+ ARP_NOTRCH_EXP_TIME;
|
|
ce->ac_lastuse= curr_time;
|
|
|
|
clck_untimer(&reqp->ar_timer);
|
|
reqp->ar_entry= -1;
|
|
client_reply(arp_port, ce->ac_ipaddr, NULL);
|
|
return;
|
|
}
|
|
|
|
data= bf_memreq(sizeof(arp46_t));
|
|
arp= (arp46_t *)ptr2acc_data(data);
|
|
|
|
/* Clear padding */
|
|
assert(sizeof(arp->a46_data.a46_dummy) % sizeof(*p) == 0);
|
|
for (i= 0, p= (u16_t *)arp->a46_data.a46_dummy;
|
|
i < sizeof(arp->a46_data.a46_dummy)/sizeof(*p);
|
|
i++, p++)
|
|
{
|
|
*p= 0xdead;
|
|
}
|
|
|
|
arp->a46_dstaddr.ea_addr[0]= 0xff;
|
|
arp->a46_dstaddr.ea_addr[1]= 0xff;
|
|
arp->a46_dstaddr.ea_addr[2]= 0xff;
|
|
arp->a46_dstaddr.ea_addr[3]= 0xff;
|
|
arp->a46_dstaddr.ea_addr[4]= 0xff;
|
|
arp->a46_dstaddr.ea_addr[5]= 0xff;
|
|
arp->a46_hdr= HTONS(ARP_ETHERNET);
|
|
arp->a46_pro= HTONS(ETH_IP_PROTO);
|
|
arp->a46_hln= 6;
|
|
arp->a46_pln= 4;
|
|
arp->a46_op= HTONS(ARP_REQUEST);
|
|
arp->a46_sha= arp_port->ap_ethaddr;
|
|
memcpy (arp->a46_spa, &arp_port->ap_ipaddr, sizeof(ipaddr_t));
|
|
memset(&arp->a46_tha, '\0', sizeof(ether_addr_t));
|
|
memcpy (arp->a46_tpa, &ce->ac_ipaddr, sizeof(ipaddr_t));
|
|
|
|
assert(data->acc_linkC == 1);
|
|
data->acc_ext_link= arp_port->ap_sendlist;
|
|
arp_port->ap_sendlist= data; data= NULL;
|
|
|
|
if (!(arp_port->ap_flags & APF_ARP_WR_IP))
|
|
setup_write(arp_port);
|
|
|
|
clck_timer(&reqp->ar_timer, get_time() + ARP_TIMEOUT,
|
|
arp_timeout, ref);
|
|
}
|
|
|
|
PRIVATE void arp_buffree(priority)
|
|
int priority;
|
|
{
|
|
int i;
|
|
acc_t *pack, *next_pack;
|
|
arp_port_t *arp_port;
|
|
|
|
for (i= 0, arp_port= arp_port_table; i<eth_conf_nr; i++, arp_port++)
|
|
{
|
|
if (priority == ARP_PRI_REC)
|
|
{
|
|
next_pack= arp_port->ap_reclist;
|
|
while(next_pack && next_pack->acc_ext_link)
|
|
{
|
|
pack= next_pack;
|
|
next_pack= pack->acc_ext_link;
|
|
bf_afree(pack);
|
|
}
|
|
if (next_pack)
|
|
{
|
|
if (ev_in_queue(&arp_port->ap_event))
|
|
{
|
|
DBLOCK(1, printf(
|
|
"not freeing ap_reclist, ap_event enqueued\n"));
|
|
}
|
|
else
|
|
{
|
|
bf_afree(next_pack);
|
|
next_pack= NULL;
|
|
}
|
|
}
|
|
arp_port->ap_reclist= next_pack;
|
|
}
|
|
if (priority == ARP_PRI_SEND)
|
|
{
|
|
next_pack= arp_port->ap_sendlist;
|
|
while(next_pack && next_pack->acc_ext_link)
|
|
{
|
|
pack= next_pack;
|
|
next_pack= pack->acc_ext_link;
|
|
bf_afree(pack);
|
|
}
|
|
if (next_pack)
|
|
{
|
|
if (ev_in_queue(&arp_port->ap_event))
|
|
{
|
|
DBLOCK(1, printf(
|
|
"not freeing ap_sendlist, ap_event enqueued\n"));
|
|
}
|
|
else
|
|
{
|
|
bf_afree(next_pack);
|
|
next_pack= NULL;
|
|
}
|
|
}
|
|
arp_port->ap_sendlist= next_pack;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef BUF_CONSISTENCY_CHECK
|
|
PRIVATE void arp_bufcheck()
|
|
{
|
|
int i;
|
|
arp_port_t *arp_port;
|
|
acc_t *pack;
|
|
|
|
for (i= 0, arp_port= arp_port_table; i<eth_conf_nr; i++, arp_port++)
|
|
{
|
|
for (pack= arp_port->ap_reclist; pack;
|
|
pack= pack->acc_ext_link)
|
|
{
|
|
bf_check_acc(pack);
|
|
}
|
|
for (pack= arp_port->ap_sendlist; pack;
|
|
pack= pack->acc_ext_link)
|
|
{
|
|
bf_check_acc(pack);
|
|
}
|
|
}
|
|
}
|
|
#endif /* BUF_CONSISTENCY_CHECK */
|
|
|
|
/*
|
|
* $PchId: arp.c,v 1.22 2005/06/28 14:15:06 philip Exp $
|
|
*/
|