minix/servers/inet/generic/ip.c
2012-03-25 21:58:14 +02:00

493 lines
10 KiB
C

/*
ip.c
Copyright 1995 Philip Homburg
*/
#include "inet.h"
#include "buf.h"
#include "event.h"
#include "type.h"
#include "arp.h"
#include "assert.h"
#include "clock.h"
#include "eth.h"
#include "icmp.h"
#include "icmp_lib.h"
#include "io.h"
#include "ip.h"
#include "ip_int.h"
#include "ipr.h"
#include "sr.h"
THIS_FILE
static void ip_close ARGS(( int fd ));
static int ip_cancel ARGS(( int fd, int which_operation ));
static int ip_select ARGS(( int fd, unsigned operations ));
static void ip_buffree ARGS(( int priority ));
#ifdef BUF_CONSISTENCY_CHECK
static void ip_bufcheck ARGS(( void ));
#endif
static void ip_bad_callback ARGS(( struct ip_port *ip_port ));
ip_port_t *ip_port_table;
ip_fd_t ip_fd_table[IP_FD_NR];
ip_ass_t ip_ass_table[IP_ASS_NR];
void ip_prep()
{
ip_port_table= alloc(ip_conf_nr * sizeof(ip_port_table[0]));
icmp_prep();
}
void ip_init()
{
int i, j, result;
ip_ass_t *ip_ass;
ip_fd_t *ip_fd;
ip_port_t *ip_port;
struct ip_conf *icp;
assert (BUF_S >= sizeof(struct nwio_ethopt));
assert (BUF_S >= IP_MAX_HDR_SIZE + ETH_HDR_SIZE);
assert (BUF_S >= sizeof(nwio_ipopt_t));
assert (BUF_S >= sizeof(nwio_route_t));
for (i=0, ip_ass= ip_ass_table; i<IP_ASS_NR; i++, ip_ass++)
{
ip_ass->ia_frags= 0;
ip_ass->ia_first_time= 0;
ip_ass->ia_port= 0;
}
for (i=0, ip_fd= ip_fd_table; i<IP_FD_NR; i++, ip_fd++)
{
ip_fd->if_flags= IFF_EMPTY;
ip_fd->if_rdbuf_head= 0;
}
for (i=0, ip_port= ip_port_table, icp= ip_conf;
i<ip_conf_nr; i++, ip_port++, icp++)
{
ip_port->ip_port= i;
ip_port->ip_flags= IPF_EMPTY;
ip_port->ip_dev_main= (ip_dev_t)ip_bad_callback;
ip_port->ip_dev_set_ipaddr= (ip_dev_t)ip_bad_callback;
ip_port->ip_dev_send= (ip_dev_send_t)ip_bad_callback;
ip_port->ip_dl_type= icp->ic_devtype;
ip_port->ip_mtu= IP_DEF_MTU;
ip_port->ip_mtu_max= IP_MAX_PACKSIZE;
switch(ip_port->ip_dl_type)
{
case IPDL_ETH:
ip_port->ip_dl.dl_eth.de_port= icp->ic_port;
result= ipeth_init(ip_port);
if (result == -1)
continue;
assert(result == NW_OK);
break;
case IPDL_PSIP:
ip_port->ip_dl.dl_ps.ps_port= icp->ic_port;
result= ipps_init(ip_port);
if (result == -1)
continue;
assert(result == NW_OK);
break;
default:
ip_panic(( "unknown ip_dl_type %d",
ip_port->ip_dl_type ));
break;
}
ip_port->ip_loopb_head= NULL;
ip_port->ip_loopb_tail= NULL;
ev_init(&ip_port->ip_loopb_event);
ip_port->ip_routeq_head= NULL;
ip_port->ip_routeq_tail= NULL;
ev_init(&ip_port->ip_routeq_event);
ip_port->ip_flags |= IPF_CONFIGURED;
ip_port->ip_proto_any= NULL;
for (j= 0; j<IP_PROTO_HASH_NR; j++)
ip_port->ip_proto[j]= NULL;
}
#ifndef BUF_CONSISTENCY_CHECK
bf_logon(ip_buffree);
#else
bf_logon(ip_buffree, ip_bufcheck);
#endif
icmp_init();
ipr_init();
for (i=0, ip_port= ip_port_table; i<ip_conf_nr; i++, ip_port++)
{
if (!(ip_port->ip_flags & IPF_CONFIGURED))
continue;
ip_port->ip_frame_id= (u16_t)get_time();
sr_add_minor(if2minor(ip_conf[i].ic_ifno, IP_DEV_OFF),
i, ip_open, ip_close, ip_read,
ip_write, ip_ioctl, ip_cancel, ip_select);
(*ip_port->ip_dev_main)(ip_port);
}
}
static int ip_cancel (fd, which_operation)
int fd;
int which_operation;
{
ip_fd_t *ip_fd;
acc_t *repl_res;
int result;
ip_fd= &ip_fd_table[fd];
switch (which_operation)
{
case SR_CANCEL_IOCTL:
assert (ip_fd->if_flags & IFF_IOCTL_IP);
ip_fd->if_flags &= ~IFF_IOCTL_IP;
repl_res= (*ip_fd->if_get_userdata)(ip_fd->if_srfd,
(size_t)EINTR, (size_t)0, TRUE);
assert (!repl_res);
break;
case SR_CANCEL_READ:
assert (ip_fd->if_flags & IFF_READ_IP);
ip_fd->if_flags &= ~IFF_READ_IP;
result= (*ip_fd->if_put_userdata)(ip_fd->if_srfd,
(size_t)EINTR, (acc_t *)0, FALSE);
assert (!result);
break;
#if 0
case SR_CANCEL_WRITE:
assert(0);
assert (ip_fd->if_flags & IFF_WRITE_MASK);
ip_fd->if_flags &= ~IFF_WRITE_MASK;
repl_res= (*ip_fd->if_get_userdata)(ip_fd->if_srfd,
(size_t)EINTR, (size_t)0, FALSE);
assert (!repl_res);
break;
#endif
default:
ip_panic(( "unknown cancel request" ));
break;
}
return NW_OK;
}
static int ip_select(fd, operations)
int fd;
unsigned operations;
{
unsigned resops;
ip_fd_t *ip_fd;
ip_fd= &ip_fd_table[fd];
assert (ip_fd->if_flags & IFF_INUSE);
resops= 0;
if (operations & SR_SELECT_READ)
{
if (ip_sel_read(ip_fd))
resops |= SR_SELECT_READ;
else if (!(operations & SR_SELECT_POLL))
ip_fd->if_flags |= IFF_SEL_READ;
}
if (operations & SR_SELECT_WRITE)
{
/* Should handle special case when the interface is down */
resops |= SR_SELECT_WRITE;
}
if (operations & SR_SELECT_EXCEPTION)
{
printf("ip_select: not implemented for exceptions\n");
}
return resops;
}
int ip_open (port, srfd, get_userdata, put_userdata, put_pkt,
select_res)
int port;
int srfd;
get_userdata_t get_userdata;
put_userdata_t put_userdata;
put_pkt_t put_pkt;
select_res_t select_res;
{
int i;
ip_fd_t *ip_fd;
ip_port_t *ip_port;
ip_port= &ip_port_table[port];
if (!(ip_port->ip_flags & IPF_CONFIGURED))
return ENXIO;
for (i=0; i<IP_FD_NR && (ip_fd_table[i].if_flags & IFF_INUSE);
i++);
if (i>=IP_FD_NR)
{
DBLOCK(1, printf("out of fds\n"));
return EAGAIN;
}
ip_fd= &ip_fd_table[i];
ip_fd->if_flags= IFF_INUSE;
ip_fd->if_ipopt.nwio_flags= NWIO_DEFAULT;
ip_fd->if_ipopt.nwio_tos= 0;
ip_fd->if_ipopt.nwio_df= FALSE;
ip_fd->if_ipopt.nwio_ttl= 255;
ip_fd->if_ipopt.nwio_hdropt.iho_opt_siz= 0;
ip_fd->if_port= ip_port;
ip_fd->if_srfd= srfd;
assert(ip_fd->if_rdbuf_head == NULL);
ip_fd->if_get_userdata= get_userdata;
ip_fd->if_put_userdata= put_userdata;
ip_fd->if_put_pkt= put_pkt;
ip_fd->if_select_res= select_res;
return i;
}
static void ip_close (fd)
int fd;
{
ip_fd_t *ip_fd;
acc_t *pack;
ip_fd= &ip_fd_table[fd];
assert ((ip_fd->if_flags & IFF_INUSE) &&
!(ip_fd->if_flags & IFF_BUSY));
if (ip_fd->if_flags & IFF_OPTSET)
ip_unhash_proto(ip_fd);
while (ip_fd->if_rdbuf_head)
{
pack= ip_fd->if_rdbuf_head;
ip_fd->if_rdbuf_head= pack->acc_ext_link;
bf_afree(pack);
}
ip_fd->if_flags= IFF_EMPTY;
}
static void ip_buffree(priority)
int priority;
{
int i;
ip_port_t *ip_port;
ip_fd_t *ip_fd;
ip_ass_t *ip_ass;
acc_t *pack, *next_pack;
for (i= 0, ip_port= ip_port_table; i<ip_conf_nr; i++, ip_port++)
{
if (ip_port->ip_dl_type == IPDL_ETH)
{
/* Can't free de_frame.
* bf_check_acc(ip_port->ip_dl.dl_eth.de_frame);
*/
if (priority == IP_PRI_PORTBUFS)
{
next_pack= ip_port->ip_dl.dl_eth.de_arp_head;
while(next_pack != NULL)
{
pack= next_pack;
next_pack= pack->acc_ext_link;
bf_afree(pack);
}
ip_port->ip_dl.dl_eth.de_arp_head= next_pack;
next_pack= ip_port->ip_dl.dl_eth.de_q_head;
while(next_pack != NULL)
{
pack= next_pack;
next_pack= pack->acc_ext_link;
bf_afree(pack);
}
ip_port->ip_dl.dl_eth.de_q_head= next_pack;
}
}
else if (ip_port->ip_dl_type == IPDL_PSIP)
{
if (priority == IP_PRI_PORTBUFS)
{
next_pack= ip_port->ip_dl.dl_ps.ps_send_head;
while (next_pack != NULL)
{
pack= next_pack;
next_pack= pack->acc_ext_link;
bf_afree(pack);
}
ip_port->ip_dl.dl_ps.ps_send_head= next_pack;
}
}
if (priority == IP_PRI_PORTBUFS)
{
next_pack= ip_port->ip_loopb_head;
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(&ip_port->ip_loopb_event))
{
#if DEBUG
printf(
"not freeing ip_loopb_head, ip_loopb_event enqueued\n");
#endif
}
else
{
bf_afree(next_pack);
next_pack= NULL;
}
}
ip_port->ip_loopb_head= next_pack;
next_pack= ip_port->ip_routeq_head;
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(&ip_port->ip_routeq_event))
{
#if DEBUG
printf(
"not freeing ip_loopb_head, ip_routeq_event enqueued\n");
#endif
}
else
{
bf_afree(next_pack);
next_pack= NULL;
}
}
ip_port->ip_routeq_head= next_pack;
}
}
if (priority == IP_PRI_FDBUFS_EXTRA)
{
for (i= 0, ip_fd= ip_fd_table; i<IP_FD_NR; i++, ip_fd++)
{
while (ip_fd->if_rdbuf_head &&
ip_fd->if_rdbuf_head->acc_ext_link)
{
pack= ip_fd->if_rdbuf_head;
ip_fd->if_rdbuf_head= pack->acc_ext_link;
bf_afree(pack);
}
}
}
if (priority == IP_PRI_FDBUFS)
{
for (i= 0, ip_fd= ip_fd_table; i<IP_FD_NR; i++, ip_fd++)
{
while (ip_fd->if_rdbuf_head)
{
pack= ip_fd->if_rdbuf_head;
ip_fd->if_rdbuf_head= pack->acc_ext_link;
bf_afree(pack);
}
}
}
if (priority == IP_PRI_ASSBUFS)
{
for (i= 0, ip_ass= ip_ass_table; i<IP_ASS_NR; i++, ip_ass++)
{
while(ip_ass->ia_frags != NULL)
{
pack= ip_ass->ia_frags;
ip_ass->ia_frags= pack->acc_ext_link;
bf_afree(pack);
}
ip_ass->ia_first_time= 0;
}
}
}
#ifdef BUF_CONSISTENCY_CHECK
static void ip_bufcheck()
{
int i;
ip_port_t *ip_port;
ip_fd_t *ip_fd;
ip_ass_t *ip_ass;
acc_t *pack;
for (i= 0, ip_port= ip_port_table; i<ip_conf_nr; i++, ip_port++)
{
if (ip_port->ip_dl_type == IPDL_ETH)
{
bf_check_acc(ip_port->ip_dl.dl_eth.de_frame);
for (pack= ip_port->ip_dl.dl_eth.de_q_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
for (pack= ip_port->ip_dl.dl_eth.de_arp_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
}
else if (ip_port->ip_dl_type == IPDL_PSIP)
{
for (pack= ip_port->ip_dl.dl_ps.ps_send_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
}
for (pack= ip_port->ip_loopb_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
for (pack= ip_port->ip_routeq_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
}
for (i= 0, ip_fd= ip_fd_table; i<IP_FD_NR; i++, ip_fd++)
{
for (pack= ip_fd->if_rdbuf_head; pack;
pack= pack->acc_ext_link)
{
bf_check_acc(pack);
}
}
for (i= 0, ip_ass= ip_ass_table; i<IP_ASS_NR; i++, ip_ass++)
{
for (pack= ip_ass->ia_frags; pack; pack= pack->acc_ext_link)
bf_check_acc(pack);
}
}
#endif /* BUF_CONSISTENCY_CHECK */
static void ip_bad_callback(ip_port)
struct ip_port *ip_port;
{
ip_panic(( "no callback filled in for port %d", ip_port->ip_port ));
}
/*
* $PchId: ip.c,v 1.19 2005/06/28 14:17:40 philip Exp $
*/