819 lines
18 KiB
C
819 lines
18 KiB
C
/*
|
|
generic/psip.c
|
|
|
|
Implementation of a pseudo IP device.
|
|
|
|
Created: Apr 22, 1993 by Philip Homburg
|
|
|
|
Copyright 1995 Philip Homburg
|
|
*/
|
|
|
|
#include "inet.h"
|
|
#include "assert.h"
|
|
#include "buf.h"
|
|
#include "event.h"
|
|
#include "type.h"
|
|
#include "ip_int.h"
|
|
#include "psip.h"
|
|
#include "sr.h"
|
|
|
|
THIS_FILE
|
|
|
|
typedef struct psip_port
|
|
{
|
|
int pp_flags;
|
|
int pp_ipdev;
|
|
int pp_opencnt;
|
|
struct psip_fd *pp_rd_head;
|
|
struct psip_fd *pp_rd_tail;
|
|
acc_t *pp_promisc_head;
|
|
acc_t *pp_promisc_tail;
|
|
} psip_port_t;
|
|
|
|
#define PPF_EMPTY 0
|
|
#define PPF_CONFIGURED 1
|
|
#define PPF_ENABLED 2
|
|
#define PPF_PROMISC 4
|
|
|
|
#define PSIP_FD_NR (1*IP_PORT_MAX)
|
|
|
|
typedef struct psip_fd
|
|
{
|
|
int pf_flags;
|
|
int pf_srfd;
|
|
psip_port_t *pf_port;
|
|
get_userdata_t pf_get_userdata;
|
|
put_userdata_t pf_put_userdata;
|
|
struct psip_fd *pf_rd_next;
|
|
size_t pf_rd_count;
|
|
nwio_psipopt_t pf_psipopt;
|
|
} psip_fd_t;
|
|
|
|
#define PFF_EMPTY 0
|
|
#define PFF_INUSE 1
|
|
#define PFF_READ_IP 2
|
|
#define PFF_PROMISC 4
|
|
#define PFF_NEXTHOP 8
|
|
|
|
PRIVATE psip_port_t *psip_port_table;
|
|
PRIVATE psip_fd_t psip_fd_table[PSIP_FD_NR];
|
|
|
|
FORWARD int psip_open ARGS(( int port, int srfd,
|
|
get_userdata_t get_userdata, put_userdata_t put_userdata,
|
|
put_pkt_t pkt_pkt, select_res_t select_res ));
|
|
FORWARD int psip_ioctl ARGS(( int fd, ioreq_t req ));
|
|
FORWARD int psip_read ARGS(( int fd, size_t count ));
|
|
FORWARD int psip_write ARGS(( int fd, size_t count ));
|
|
FORWARD int psip_select ARGS(( int port_nr, unsigned operations ));
|
|
FORWARD void psip_close ARGS(( int fd ));
|
|
FORWARD int psip_cancel ARGS(( int fd, int which_operation ));
|
|
FORWARD void promisc_restart_read ARGS(( psip_port_t *psip_port ));
|
|
FORWARD int psip_setopt ARGS(( psip_fd_t *psip_fd, nwio_psipopt_t *newoptp ));
|
|
FORWARD void psip_buffree ARGS(( int priority ));
|
|
FORWARD void check_promisc ARGS(( psip_port_t *psip_port ));
|
|
#ifdef BUF_CONSISTENCY_CHECK
|
|
FORWARD void psip_bufcheck ARGS(( void ));
|
|
#endif
|
|
FORWARD void reply_thr_put ARGS(( psip_fd_t *psip_fd, int reply,
|
|
int for_ioctl ));
|
|
FORWARD void reply_thr_get ARGS(( psip_fd_t *psip_fd, int reply,
|
|
int for_ioctl ));
|
|
|
|
PUBLIC void psip_prep()
|
|
{
|
|
psip_port_table= alloc(psip_conf_nr * sizeof(psip_port_table[0]));
|
|
}
|
|
|
|
PUBLIC void psip_init()
|
|
{
|
|
int i;
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd;
|
|
|
|
for (i=0, psip_port= psip_port_table; i<psip_conf_nr; i++, psip_port++)
|
|
psip_port->pp_flags= PPF_EMPTY;
|
|
|
|
for (i=0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
|
|
psip_fd->pf_flags= PFF_EMPTY;
|
|
|
|
for (i=0, psip_port= psip_port_table; i<psip_conf_nr; i++, psip_port++)
|
|
{
|
|
psip_port->pp_flags |= PPF_CONFIGURED;
|
|
psip_port->pp_opencnt= 0;
|
|
psip_port->pp_rd_head= NULL;
|
|
psip_port->pp_promisc_head= NULL;
|
|
}
|
|
|
|
#ifndef BUF_CONSISTENCY_CHECK
|
|
bf_logon(psip_buffree);
|
|
#else
|
|
bf_logon(psip_buffree, psip_bufcheck);
|
|
#endif
|
|
}
|
|
|
|
PUBLIC int psip_enable(port_nr, ip_port_nr)
|
|
int port_nr;
|
|
int ip_port_nr;
|
|
{
|
|
psip_port_t *psip_port;
|
|
|
|
assert(port_nr >= 0);
|
|
if (port_nr >= psip_conf_nr)
|
|
return -1;
|
|
|
|
psip_port= &psip_port_table[port_nr];
|
|
if (!(psip_port->pp_flags &PPF_CONFIGURED))
|
|
return -1;
|
|
|
|
psip_port->pp_ipdev= ip_port_nr;
|
|
psip_port->pp_flags |= PPF_ENABLED;
|
|
|
|
sr_add_minor(if2minor(psip_conf[port_nr].pc_ifno, PSIP_DEV_OFF),
|
|
port_nr, psip_open, psip_close, psip_read,
|
|
psip_write, psip_ioctl, psip_cancel, psip_select);
|
|
|
|
return NW_OK;
|
|
}
|
|
|
|
PUBLIC int psip_send(port_nr, dest, pack)
|
|
int port_nr;
|
|
ipaddr_t dest;
|
|
acc_t *pack;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd, *mark_fd;
|
|
int i, result, result1;
|
|
size_t buf_size, extrasize;
|
|
acc_t *hdr_pack, *acc;
|
|
psip_io_hdr_t *hdr;
|
|
|
|
assert(port_nr >= 0 && port_nr < psip_conf_nr);
|
|
psip_port= &psip_port_table[port_nr];
|
|
|
|
if (psip_port->pp_opencnt == 0)
|
|
{
|
|
bf_afree(pack);
|
|
return NW_OK;
|
|
}
|
|
|
|
for(;;)
|
|
{
|
|
mark_fd= psip_port->pp_rd_tail;
|
|
|
|
for(i= 0; i<PSIP_FD_NR; i++)
|
|
{
|
|
psip_fd= psip_port->pp_rd_head;
|
|
if (!psip_fd)
|
|
return NW_SUSPEND;
|
|
psip_port->pp_rd_head= psip_fd->pf_rd_next;
|
|
if (!(psip_fd->pf_flags & PFF_PROMISC))
|
|
break;
|
|
psip_fd->pf_rd_next= NULL;
|
|
if (psip_port->pp_rd_head == NULL)
|
|
psip_port->pp_rd_head= psip_fd;
|
|
else
|
|
psip_port->pp_rd_tail->pf_rd_next= psip_fd;
|
|
psip_port->pp_rd_tail= psip_fd;
|
|
if (psip_fd == mark_fd)
|
|
return NW_SUSPEND;
|
|
}
|
|
if (i == PSIP_FD_NR)
|
|
ip_panic(( "psip_send: loop" ));
|
|
|
|
assert(psip_fd->pf_flags & PFF_READ_IP);
|
|
psip_fd->pf_flags &= ~PFF_READ_IP;
|
|
|
|
if (psip_fd->pf_flags & PFF_NEXTHOP)
|
|
extrasize= sizeof(dest);
|
|
else
|
|
extrasize= 0;
|
|
|
|
buf_size= bf_bufsize(pack);
|
|
if (buf_size+extrasize <= psip_fd->pf_rd_count)
|
|
{
|
|
if (psip_port->pp_flags & PPF_PROMISC)
|
|
{
|
|
/* Deal with promiscuous mode. */
|
|
hdr_pack= bf_memreq(sizeof(*hdr));
|
|
hdr= (psip_io_hdr_t *)ptr2acc_data(hdr_pack);
|
|
memset(hdr, '\0', sizeof(*hdr));
|
|
hdr->pih_flags |= PF_LOC2REM;
|
|
hdr->pih_nexthop= dest;
|
|
|
|
pack->acc_linkC++;
|
|
hdr_pack->acc_next= pack;
|
|
hdr_pack->acc_ext_link= NULL;
|
|
if (psip_port->pp_promisc_head)
|
|
{
|
|
/* Append at the end. */
|
|
psip_port->pp_promisc_tail->
|
|
acc_ext_link= hdr_pack;
|
|
psip_port->pp_promisc_tail= hdr_pack;
|
|
}
|
|
else
|
|
{
|
|
/* First packet. */
|
|
psip_port->pp_promisc_head= hdr_pack;
|
|
psip_port->pp_promisc_tail= hdr_pack;
|
|
if (psip_port->pp_rd_head)
|
|
promisc_restart_read(psip_port);
|
|
}
|
|
}
|
|
|
|
if (extrasize)
|
|
{
|
|
/* Prepend nexthop address */
|
|
acc= bf_memreq(sizeof(dest));
|
|
*(ipaddr_t *)(ptr2acc_data(acc))= dest;
|
|
acc->acc_next= pack;
|
|
pack= acc; acc= NULL;
|
|
buf_size += extrasize;
|
|
}
|
|
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)0, pack, FALSE);
|
|
if (result == NW_OK)
|
|
result= buf_size;
|
|
}
|
|
else
|
|
result= EPACKSIZE;
|
|
|
|
result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)result, NULL, FALSE);
|
|
assert(result1 == NW_OK);
|
|
if (result == EPACKSIZE)
|
|
continue;
|
|
return NW_OK;
|
|
}
|
|
return NW_SUSPEND;
|
|
}
|
|
|
|
PRIVATE int psip_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;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd;
|
|
int i;
|
|
|
|
assert(port >= 0 && port < psip_conf_nr);
|
|
psip_port= &psip_port_table[port];
|
|
|
|
if (!(psip_port->pp_flags & PPF_ENABLED))
|
|
return ENXIO;
|
|
|
|
for (i= 0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
|
|
{
|
|
if (psip_fd->pf_flags & PFF_INUSE)
|
|
continue;
|
|
break;
|
|
}
|
|
if (i == PSIP_FD_NR)
|
|
return ENFILE;
|
|
psip_fd->pf_flags |= PFF_INUSE;
|
|
psip_fd->pf_srfd= srfd;
|
|
psip_fd->pf_port= psip_port;
|
|
psip_fd->pf_get_userdata= get_userdata;
|
|
psip_fd->pf_put_userdata= put_userdata;
|
|
psip_port->pp_opencnt++;
|
|
|
|
return i;
|
|
}
|
|
|
|
PRIVATE int psip_ioctl(fd, req)
|
|
int fd;
|
|
ioreq_t req;
|
|
{
|
|
int result;
|
|
psip_fd_t *psip_fd;
|
|
acc_t *data;
|
|
nwio_ipconf_t *ipconfp;
|
|
nwio_psipopt_t *psip_opt, *newoptp;
|
|
|
|
assert(fd >= 0 && fd < PSIP_FD_NR);
|
|
psip_fd= &psip_fd_table[fd];
|
|
|
|
switch(req)
|
|
{
|
|
case NWIOSIPCONF:
|
|
data= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, 0,
|
|
sizeof(*ipconfp), TRUE);
|
|
if (!data)
|
|
{
|
|
result= EFAULT;
|
|
break;
|
|
}
|
|
data= bf_packIffLess(data, sizeof(*ipconfp));
|
|
assert (data->acc_length == sizeof(*ipconfp));
|
|
|
|
ipconfp= (nwio_ipconf_t *)ptr2acc_data(data);
|
|
result= ip_setconf(psip_fd->pf_port->pp_ipdev, ipconfp);
|
|
bf_afree(data);
|
|
reply_thr_get(psip_fd, result, TRUE);
|
|
break;
|
|
case NWIOSPSIPOPT:
|
|
data= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, 0,
|
|
sizeof(*psip_opt), TRUE);
|
|
if (!data)
|
|
{
|
|
result= EFAULT;
|
|
break;
|
|
}
|
|
data= bf_packIffLess(data, sizeof(*psip_opt));
|
|
assert (data->acc_length == sizeof(*psip_opt));
|
|
|
|
newoptp= (nwio_psipopt_t *)ptr2acc_data(data);
|
|
result= psip_setopt(psip_fd, newoptp);
|
|
bf_afree(data);
|
|
if (result == NW_OK)
|
|
{
|
|
if (psip_fd->pf_psipopt.nwpo_flags & NWPO_EN_PROMISC)
|
|
{
|
|
psip_fd->pf_flags |= PFF_PROMISC;
|
|
psip_fd->pf_port->pp_flags |= PPF_PROMISC;
|
|
}
|
|
else
|
|
{
|
|
psip_fd->pf_flags &= ~PFF_PROMISC;
|
|
check_promisc(psip_fd->pf_port);
|
|
}
|
|
if (psip_fd->pf_psipopt.nwpo_flags & NWPO_EN_NEXTHOP)
|
|
{
|
|
psip_fd->pf_flags |= PFF_NEXTHOP;
|
|
}
|
|
else
|
|
{
|
|
psip_fd->pf_flags &= ~PFF_NEXTHOP;
|
|
}
|
|
}
|
|
reply_thr_get(psip_fd, result, TRUE);
|
|
break;
|
|
case NWIOGPSIPOPT:
|
|
data= bf_memreq(sizeof(*psip_opt));
|
|
psip_opt= (nwio_psipopt_t *)ptr2acc_data(data);
|
|
|
|
*psip_opt= psip_fd->pf_psipopt;
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd, 0,
|
|
data, TRUE);
|
|
if (result == NW_OK)
|
|
reply_thr_put(psip_fd, NW_OK, TRUE);
|
|
break;
|
|
default:
|
|
reply_thr_put(psip_fd, ENOTTY, TRUE);
|
|
break;
|
|
}
|
|
return NW_OK;
|
|
}
|
|
|
|
PRIVATE int psip_read(fd, count)
|
|
int fd;
|
|
size_t count;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd;
|
|
acc_t *pack;
|
|
size_t buf_size;
|
|
int result, result1;
|
|
|
|
assert(fd >= 0 && fd < PSIP_FD_NR);
|
|
psip_fd= &psip_fd_table[fd];
|
|
psip_port= psip_fd->pf_port;
|
|
|
|
if ((psip_fd->pf_flags & PFF_PROMISC) && psip_port->pp_promisc_head)
|
|
{
|
|
/* Deliver a queued packet. */
|
|
pack= psip_port->pp_promisc_head;
|
|
buf_size= bf_bufsize(pack);
|
|
if (buf_size <= count)
|
|
{
|
|
psip_port->pp_promisc_head= pack->acc_ext_link;
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)0, pack, FALSE);
|
|
if (result == NW_OK)
|
|
result= buf_size;
|
|
}
|
|
else
|
|
result= EPACKSIZE;
|
|
|
|
result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)result, NULL, FALSE);
|
|
assert(result1 == NW_OK);
|
|
return NW_OK;
|
|
}
|
|
|
|
psip_fd->pf_rd_count= count;
|
|
if (psip_port->pp_rd_head == NULL)
|
|
psip_port->pp_rd_head= psip_fd;
|
|
else
|
|
psip_port->pp_rd_tail->pf_rd_next= psip_fd;
|
|
psip_fd->pf_rd_next= NULL;
|
|
psip_port->pp_rd_tail= psip_fd;
|
|
|
|
psip_fd->pf_flags |= PFF_READ_IP;
|
|
if (!(psip_fd->pf_flags & PFF_PROMISC))
|
|
ipps_get(psip_port->pp_ipdev);
|
|
if (psip_fd->pf_flags & PFF_READ_IP)
|
|
return NW_SUSPEND;
|
|
return NW_OK;
|
|
}
|
|
|
|
PRIVATE int psip_write(fd, count)
|
|
int fd;
|
|
size_t count;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd;
|
|
acc_t *pack, *hdr_pack;
|
|
psip_io_hdr_t *hdr;
|
|
size_t pack_len;
|
|
ipaddr_t nexthop;
|
|
|
|
assert(fd >= 0 && fd < PSIP_FD_NR);
|
|
psip_fd= &psip_fd_table[fd];
|
|
psip_port= psip_fd->pf_port;
|
|
|
|
pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, (size_t)0,
|
|
count, FALSE);
|
|
if (pack == NULL)
|
|
{
|
|
pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd,
|
|
(size_t)EFAULT, (size_t)0, FALSE);
|
|
assert(pack == NULL);
|
|
return NW_OK;
|
|
}
|
|
|
|
if (psip_fd->pf_flags & PFF_NEXTHOP)
|
|
{
|
|
pack_len= bf_bufsize(pack);
|
|
if (pack_len <= sizeof(nexthop))
|
|
{
|
|
/* Something strange */
|
|
bf_afree(pack); pack= NULL;
|
|
pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd,
|
|
(size_t)EPACKSIZE, (size_t)0, FALSE);
|
|
assert(pack == NULL);
|
|
return NW_OK;
|
|
}
|
|
pack= bf_packIffLess(pack, sizeof(nexthop));
|
|
nexthop= *(ipaddr_t *)ptr2acc_data(pack);
|
|
pack= bf_delhead(pack, sizeof(nexthop));
|
|
|
|
/* Map multicast to broadcast */
|
|
if ((nexthop & HTONL(0xE0000000)) == HTONL(0xE0000000))
|
|
nexthop= HTONL(0xffffffff);
|
|
}
|
|
else
|
|
{
|
|
/* Assume point to point */
|
|
nexthop= HTONL(0x00000000);
|
|
}
|
|
|
|
if (psip_port->pp_flags & PPF_PROMISC)
|
|
{
|
|
/* Deal with promiscuous mode. */
|
|
hdr_pack= bf_memreq(sizeof(*hdr));
|
|
hdr= (psip_io_hdr_t *)ptr2acc_data(hdr_pack);
|
|
memset(hdr, '\0', sizeof(*hdr));
|
|
hdr->pih_flags |= PF_REM2LOC;
|
|
hdr->pih_nexthop= nexthop;
|
|
|
|
pack->acc_linkC++;
|
|
hdr_pack->acc_next= pack;
|
|
hdr_pack->acc_ext_link= NULL;
|
|
if (psip_port->pp_promisc_head)
|
|
{
|
|
/* Append at the end. */
|
|
psip_port->pp_promisc_tail->acc_ext_link= hdr_pack;
|
|
psip_port->pp_promisc_tail= hdr_pack;
|
|
}
|
|
else
|
|
{
|
|
/* First packet. */
|
|
psip_port->pp_promisc_head= hdr_pack;
|
|
psip_port->pp_promisc_tail= hdr_pack;
|
|
if (psip_port->pp_rd_head)
|
|
promisc_restart_read(psip_port);
|
|
}
|
|
}
|
|
ipps_put(psip_port->pp_ipdev, nexthop, pack);
|
|
pack= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, (size_t)count,
|
|
(size_t)0, FALSE);
|
|
assert(pack == NULL);
|
|
return NW_OK;
|
|
}
|
|
|
|
PRIVATE int psip_select(fd, operations)
|
|
int fd;
|
|
unsigned operations;
|
|
{
|
|
printf("psip_select: not implemented\n");
|
|
return 0;
|
|
}
|
|
|
|
PRIVATE void psip_close(fd)
|
|
int fd;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd;
|
|
|
|
assert(fd >= 0 && fd < PSIP_FD_NR);
|
|
psip_fd= &psip_fd_table[fd];
|
|
psip_port= psip_fd->pf_port;
|
|
|
|
if (psip_fd->pf_flags & PFF_PROMISC)
|
|
{
|
|
/* Check if the port should still be in promiscuous mode.
|
|
*/
|
|
psip_fd->pf_flags &= ~PFF_PROMISC;
|
|
check_promisc(psip_fd->pf_port);
|
|
}
|
|
|
|
assert(psip_port->pp_opencnt >0);
|
|
psip_port->pp_opencnt--;
|
|
psip_fd->pf_flags= PFF_EMPTY;
|
|
ipps_get(psip_port->pp_ipdev);
|
|
|
|
}
|
|
|
|
PRIVATE int psip_cancel(fd, which_operation)
|
|
int fd;
|
|
int which_operation;
|
|
{
|
|
psip_port_t *psip_port;
|
|
psip_fd_t *psip_fd, *prev_fd, *tmp_fd;
|
|
int result;
|
|
|
|
DBLOCK(1, printf("psip_cancel(%d, %d)\n", fd, which_operation));
|
|
|
|
assert(fd >= 0 && fd < PSIP_FD_NR);
|
|
psip_fd= &psip_fd_table[fd];
|
|
psip_port= psip_fd->pf_port;
|
|
|
|
switch(which_operation)
|
|
{
|
|
case SR_CANCEL_IOCTL:
|
|
ip_panic(( "should not be here" ));
|
|
case SR_CANCEL_READ:
|
|
assert(psip_fd->pf_flags & PFF_READ_IP);
|
|
for (prev_fd= NULL, tmp_fd= psip_port->pp_rd_head; tmp_fd;
|
|
prev_fd= tmp_fd, tmp_fd= tmp_fd->pf_rd_next)
|
|
{
|
|
if (tmp_fd == psip_fd)
|
|
break;
|
|
}
|
|
if (tmp_fd == NULL)
|
|
ip_panic(( "unable to find to request to cancel" ));
|
|
if (prev_fd == NULL)
|
|
psip_port->pp_rd_head= psip_fd->pf_rd_next;
|
|
else
|
|
prev_fd->pf_rd_next= psip_fd->pf_rd_next;
|
|
if (psip_fd->pf_rd_next == NULL)
|
|
psip_port->pp_rd_tail= prev_fd;
|
|
psip_fd->pf_flags &= ~PFF_READ_IP;
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)EINTR, NULL, FALSE);
|
|
assert(result == NW_OK);
|
|
break;
|
|
case SR_CANCEL_WRITE:
|
|
ip_panic(( "should not be here" ));
|
|
default:
|
|
ip_panic(( "invalid operation for cancel" ));
|
|
}
|
|
return NW_OK;
|
|
}
|
|
|
|
PRIVATE void promisc_restart_read(psip_port)
|
|
psip_port_t *psip_port;
|
|
{
|
|
psip_fd_t *psip_fd, *prev, *next;
|
|
acc_t *pack;
|
|
size_t buf_size;
|
|
int result, result1;
|
|
|
|
/* Overkill at the moment: just one reader in promiscious mode is
|
|
* allowed.
|
|
*/
|
|
pack= psip_port->pp_promisc_head;
|
|
if (!pack)
|
|
return;
|
|
assert(pack->acc_ext_link == NULL);
|
|
|
|
for(psip_fd= psip_port->pp_rd_head, prev= NULL; psip_fd;
|
|
prev= psip_fd, psip_fd= psip_fd->pf_rd_next)
|
|
{
|
|
again:
|
|
if (!(psip_fd->pf_flags & PFF_PROMISC))
|
|
continue;
|
|
next= psip_fd->pf_rd_next;
|
|
if (prev)
|
|
prev->pf_rd_next= next;
|
|
else
|
|
psip_port->pp_rd_head= next;
|
|
if (!next)
|
|
psip_port->pp_rd_tail= prev;
|
|
|
|
assert(psip_fd->pf_flags & PFF_READ_IP);
|
|
psip_fd->pf_flags &= ~PFF_READ_IP;
|
|
|
|
buf_size= bf_bufsize(pack);
|
|
if (buf_size <= psip_fd->pf_rd_count)
|
|
{
|
|
psip_port->pp_promisc_head= pack->acc_ext_link;
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)0, pack, FALSE);
|
|
if (result == NW_OK)
|
|
result= buf_size;
|
|
}
|
|
else
|
|
result= EPACKSIZE;
|
|
|
|
result1= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd,
|
|
(size_t)result, NULL, FALSE);
|
|
assert(result1 == NW_OK);
|
|
|
|
if (psip_port->pp_promisc_head)
|
|
{
|
|
/* Restart from the beginning */
|
|
assert(result == EPACKSIZE);
|
|
psip_fd= psip_port->pp_rd_head;
|
|
prev= NULL;
|
|
goto again;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
PRIVATE int psip_setopt(psip_fd, newoptp)
|
|
psip_fd_t *psip_fd;
|
|
nwio_psipopt_t *newoptp;
|
|
{
|
|
nwio_psipopt_t oldopt;
|
|
unsigned int new_en_flags, new_di_flags, old_en_flags, old_di_flags;
|
|
unsigned long new_flags;
|
|
|
|
oldopt= psip_fd->pf_psipopt;
|
|
|
|
old_en_flags= oldopt.nwpo_flags & 0xffff;
|
|
old_di_flags= (oldopt.nwpo_flags >> 16) & 0xffff;
|
|
|
|
new_en_flags= newoptp->nwpo_flags & 0xffff;
|
|
new_di_flags= (newoptp->nwpo_flags >> 16) & 0xffff;
|
|
|
|
if (new_en_flags & new_di_flags)
|
|
return EBADMODE;
|
|
|
|
/* NWUO_LOCADDR_MASK */
|
|
if (!((new_en_flags | new_di_flags) & NWPO_PROMISC_MASK))
|
|
{
|
|
new_en_flags |= (old_en_flags & NWPO_PROMISC_MASK);
|
|
new_di_flags |= (old_di_flags & NWPO_PROMISC_MASK);
|
|
}
|
|
|
|
new_flags= ((unsigned long)new_di_flags << 16) | new_en_flags;
|
|
if ((new_flags & NWPO_EN_PROMISC) &&
|
|
(psip_fd->pf_port->pp_flags & PPF_PROMISC))
|
|
{
|
|
printf("psip_setopt: EBUSY for port %d, flags 0x%x\n",
|
|
psip_fd->pf_port - psip_port_table,
|
|
psip_fd->pf_port->pp_flags);
|
|
/* We can support only one at a time. */
|
|
return EBUSY;
|
|
}
|
|
|
|
psip_fd->pf_psipopt= *newoptp;
|
|
psip_fd->pf_psipopt.nwpo_flags= new_flags;
|
|
|
|
return NW_OK;
|
|
}
|
|
|
|
PRIVATE void check_promisc(psip_port)
|
|
psip_port_t *psip_port;
|
|
{
|
|
int i;
|
|
psip_fd_t *psip_fd;
|
|
acc_t *acc, *acc_next;
|
|
|
|
/* Check if the port should still be in promiscuous mode. Overkill
|
|
* at the moment.
|
|
*/
|
|
if (!(psip_port->pp_flags & PPF_PROMISC))
|
|
return;
|
|
|
|
psip_port->pp_flags &= ~PPF_PROMISC;
|
|
for (i= 0, psip_fd= psip_fd_table; i<PSIP_FD_NR; i++, psip_fd++)
|
|
{
|
|
if ((psip_fd->pf_flags & (PFF_INUSE|PFF_PROMISC)) !=
|
|
(PFF_INUSE|PFF_PROMISC))
|
|
{
|
|
continue;
|
|
}
|
|
if (psip_fd->pf_port != psip_port)
|
|
continue;
|
|
printf("check_promisc: setting PROMISC for port %d\n",
|
|
psip_port-psip_port_table);
|
|
psip_port->pp_flags |= PPF_PROMISC;
|
|
break;
|
|
}
|
|
if (!(psip_port->pp_flags & PPF_PROMISC))
|
|
{
|
|
/* Delete queued packets. */
|
|
acc= psip_port->pp_promisc_head;
|
|
psip_port->pp_promisc_head= NULL;
|
|
while (acc)
|
|
{
|
|
acc_next= acc->acc_ext_link;
|
|
bf_afree(acc);
|
|
acc= acc_next;
|
|
}
|
|
}
|
|
}
|
|
|
|
PRIVATE void psip_buffree (priority)
|
|
int priority;
|
|
{
|
|
int i;
|
|
psip_port_t *psip_port;
|
|
acc_t *tmp_acc, *next_acc;
|
|
|
|
if (priority == PSIP_PRI_EXP_PROMISC)
|
|
{
|
|
for (i=0, psip_port= psip_port_table; i<psip_conf_nr;
|
|
i++, psip_port++)
|
|
{
|
|
if (!(psip_port->pp_flags & PPF_CONFIGURED) )
|
|
continue;
|
|
if (psip_port->pp_promisc_head)
|
|
{
|
|
tmp_acc= psip_port->pp_promisc_head;
|
|
while(tmp_acc)
|
|
{
|
|
next_acc= tmp_acc->acc_ext_link;
|
|
bf_afree(tmp_acc);
|
|
tmp_acc= next_acc;
|
|
}
|
|
psip_port->pp_promisc_head= NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef BUF_CONSISTENCY_CHECK
|
|
PRIVATE void psip_bufcheck()
|
|
{
|
|
int i;
|
|
psip_port_t *psip_port;
|
|
acc_t *tmp_acc;
|
|
|
|
for (i= 0, psip_port= psip_port_table; i<psip_conf_nr;
|
|
i++, psip_port++)
|
|
{
|
|
for (tmp_acc= psip_port->pp_promisc_head; tmp_acc;
|
|
tmp_acc= tmp_acc->acc_ext_link)
|
|
{
|
|
bf_check_acc(tmp_acc);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
reply_thr_put
|
|
*/
|
|
|
|
PRIVATE void reply_thr_put(psip_fd, reply, for_ioctl)
|
|
psip_fd_t *psip_fd;
|
|
int reply;
|
|
int for_ioctl;
|
|
{
|
|
int result;
|
|
|
|
result= (*psip_fd->pf_put_userdata)(psip_fd->pf_srfd, reply,
|
|
(acc_t *)0, for_ioctl);
|
|
assert(result == NW_OK);
|
|
}
|
|
|
|
/*
|
|
reply_thr_get
|
|
*/
|
|
|
|
PRIVATE void reply_thr_get(psip_fd, reply, for_ioctl)
|
|
psip_fd_t *psip_fd;
|
|
int reply;
|
|
int for_ioctl;
|
|
{
|
|
acc_t *result;
|
|
result= (*psip_fd->pf_get_userdata)(psip_fd->pf_srfd, reply,
|
|
(size_t)0, for_ioctl);
|
|
assert (!result);
|
|
}
|
|
|
|
|
|
/*
|
|
* $PchId: psip.c,v 1.15 2005/06/28 14:19:29 philip Exp $
|
|
*/
|