998 lines
22 KiB
C
998 lines
22 KiB
C
/*
|
|
* Copyright (c) 1993 Daniel Boulet
|
|
* Copyright (c) 1994 Ugen J.S.Antsilevich
|
|
*
|
|
* Redistribution and use in source forms, with and without modification,
|
|
* are permitted provided that this entire comment appears intact.
|
|
*
|
|
* Redistribution in binary form may occur without any restrictions.
|
|
* Obviously, it would be nice if you gave credit where credit is due
|
|
* but requiring it would be too onerous.
|
|
*
|
|
* This software is provided ``AS IS'' without any warranties of any kind.
|
|
*/
|
|
|
|
/*
|
|
* Implement IP packet firewall
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/domain.h>
|
|
#include <sys/protosw.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/time.h>
|
|
#include <sys/kernel.h>
|
|
|
|
#include <net/if.h>
|
|
#include <net/route.h>
|
|
|
|
|
|
#include <netinet/in.h>
|
|
#include <netinet/in_systm.h>
|
|
#include <netinet/ip.h>
|
|
#include <netinet/tcp.h>
|
|
#include <netinet/udp.h>
|
|
#include <netinet/ip_icmp.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <netinet/ip_fw.h>
|
|
|
|
#ifdef IPFIREWALL
|
|
struct ip_fw *ip_fw_fwd_chain;
|
|
struct ip_fw *ip_fw_blk_chain;
|
|
u_short ip_fw_policy=0;
|
|
#endif
|
|
#ifdef IPACCT
|
|
struct ip_fw *ip_acct_chain;
|
|
#endif
|
|
|
|
|
|
#ifdef IPFIREWALL_DEBUG
|
|
#define dprintf1(a) printf(a)
|
|
#define dprintf2(a1,a2) printf(a1,a2)
|
|
#define dprintf3(a1,a2,a3) printf(a1,a2,a3)
|
|
#define dprintf4(a1,a2,a3,a4) printf(a1,a2,a3,a4)
|
|
#else
|
|
#define dprintf1(a)
|
|
#define dprintf2(a1,a2)
|
|
#define dprintf3(a1,a2,a3)
|
|
#define dprintf4(a1,a2,a3,a4)
|
|
#endif
|
|
|
|
|
|
#define print_ip(a) printf("%d.%d.%d.%d",(ntohl(a.s_addr)>>24)&0xFF,\
|
|
(ntohl(a.s_addr)>>16)&0xFF,\
|
|
(ntohl(a.s_addr)>>8)&0xFF,\
|
|
(ntohl(a.s_addr))&0xFF);
|
|
|
|
#ifdef IPFIREWALL_DEBUG
|
|
#define dprint_ip(a) print_ip(a)
|
|
#else
|
|
#define dprint_ip(a)
|
|
#endif
|
|
|
|
/*
|
|
inline
|
|
void
|
|
print_ip(xaddr)
|
|
struct in_addr xaddr;
|
|
{
|
|
u_long addr = ntohl(xaddr.s_addr);
|
|
printf("%d.%d.%d.%d",(addr>>24) & 0xff,
|
|
(addr>>16)&0xff,
|
|
(addr>>8)&0xff,
|
|
addr&0xFF);
|
|
}
|
|
*/
|
|
|
|
|
|
/*
|
|
* Returns 1 if the port is matched by the vector, 0 otherwise
|
|
*/
|
|
inline
|
|
int port_match(portptr,nports,port,range_flag)
|
|
u_short *portptr;
|
|
int nports;
|
|
u_short port;
|
|
int range_flag;
|
|
{
|
|
if (!nports)
|
|
return 1;
|
|
if (range_flag) {
|
|
if (portptr[0]<=port && port<=portptr[1]) {
|
|
return 1;
|
|
}
|
|
nports-=2;
|
|
portptr+=2;
|
|
}
|
|
while (nports-->0) {
|
|
if (*portptr++==port) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Returns 0 if packet should be dropped, 1 or more if it should be accepted
|
|
*/
|
|
|
|
#ifdef IPFIREWALL
|
|
int ip_fw_chk(ip,rif,chain)
|
|
struct ip *ip;
|
|
struct ifnet *rif;
|
|
struct ip_fw *chain;
|
|
{
|
|
register struct ip_fw *f;
|
|
struct tcphdr *tcp=(struct tcphdr *)((u_long *)ip+ip->ip_hl);
|
|
struct udphdr *udp=(struct udphdr *)((u_long *)ip+ip->ip_hl);
|
|
struct icmp *icmp=(struct icmp *)((u_long *)ip+ip->ip_hl);
|
|
struct ifaddr *ia=NULL, *ia_p;
|
|
struct in_addr src, dst, ia_i;
|
|
struct mbuf *m;
|
|
u_short src_port=0, dst_port=0;
|
|
u_short f_prt=0, prt;
|
|
char notcpsyn=1;
|
|
|
|
/*
|
|
* If the chain is empty
|
|
* allow any packet-this is equal
|
|
* to disabling firewall.
|
|
*/
|
|
if (!chain)
|
|
return(1);
|
|
|
|
/*
|
|
* This way we handle fragmented packets.
|
|
* we ignore all fragments but the first one
|
|
* so the whole packet can't be reassembled.
|
|
* This way we relay on the full info which
|
|
* stored only in first packet.
|
|
*/
|
|
if (ip->ip_off&IP_OFFMASK)
|
|
return(1);
|
|
|
|
src = ip->ip_src;
|
|
dst = ip->ip_dst;
|
|
|
|
/*
|
|
* If we got interface from
|
|
* which packet came-store
|
|
* pointer to it's first adress
|
|
*/
|
|
if (rif)
|
|
ia=rif->if_addrlist;
|
|
|
|
dprintf1("Packet ");
|
|
switch(ip->ip_p) {
|
|
case IPPROTO_TCP:
|
|
dprintf1("TCP ");
|
|
src_port=ntohs(tcp->th_sport);
|
|
dst_port=ntohs(tcp->th_dport);
|
|
if (tcp->th_flags&TH_SYN)
|
|
notcpsyn=0; /* We *DO* have SYN ,value FALSE */
|
|
prt=IP_FW_F_TCP;
|
|
break;
|
|
case IPPROTO_UDP:
|
|
dprintf1("UDP ");
|
|
src_port=ntohs(udp->uh_sport);
|
|
dst_port=ntohs(udp->uh_dport);
|
|
prt=IP_FW_F_UDP;
|
|
break;
|
|
case IPPROTO_ICMP:
|
|
dprintf2("ICMP:%u ",icmp->icmp_type);
|
|
prt=IP_FW_F_ICMP;
|
|
break;
|
|
default:
|
|
dprintf2("p=%d ",ip->ip_p);
|
|
prt=IP_FW_F_ALL;
|
|
break;
|
|
}
|
|
dprint_ip(ip->ip_src);
|
|
if (ip->ip_p==IPPROTO_TCP || ip->ip_p==IPPROTO_UDP) {
|
|
dprintf2(":%d ",src_port);
|
|
}
|
|
dprint_ip(ip->ip_dst);
|
|
if (ip->ip_p==IPPROTO_TCP || ip->ip_p==IPPROTO_UDP) {
|
|
dprintf2(":%d ",dst_port);
|
|
}
|
|
dprintf1("\n");
|
|
|
|
|
|
for (f=chain;f;f=f->fw_next)
|
|
if ((src.s_addr&f->fw_smsk.s_addr)==f->fw_src.s_addr
|
|
&& (dst.s_addr&f->fw_dmsk.s_addr)==f->fw_dst.s_addr) {
|
|
if (f->fw_via.s_addr && rif) {
|
|
for (ia_p=ia;ia_p;ia_p=ia_p->ifa_next) {
|
|
if (!ia_p->ifa_addr ||
|
|
ia_p->ifa_addr->sa_family!=AF_INET)
|
|
/*
|
|
* Next interface adress.
|
|
* This is continue for
|
|
* local "for"
|
|
*/
|
|
continue;
|
|
ia_i.s_addr=(((struct sockaddr_in *)\
|
|
(ia_p->ifa_addr))->sin_addr.s_addr);
|
|
if (ia_i.s_addr==f->fw_via.s_addr)
|
|
goto via_match;
|
|
}
|
|
/*
|
|
* Next interface adress.
|
|
* This is continue for
|
|
* local "for"
|
|
*/
|
|
continue;
|
|
} else {
|
|
/*
|
|
* No special "via" adress set
|
|
* or interface from which packet
|
|
* came unknown so match anyway
|
|
*/
|
|
goto via_match;
|
|
}
|
|
/*
|
|
* Skip to next firewall entry - via
|
|
* address did not matched.
|
|
*/
|
|
continue;
|
|
via_match:
|
|
f_prt=f->fw_flg&IP_FW_F_KIND;
|
|
if (f_prt==IP_FW_F_ALL) {
|
|
/* Universal frwl - we've got a match! */
|
|
goto got_match;
|
|
} else {
|
|
/*
|
|
* This is actually buggy as if you set SYN flag
|
|
* on UDp or ICMP firewall it will never work,but
|
|
* actually it is a concern of software which sets
|
|
* firewall entries.
|
|
*/
|
|
if (f->fw_flg&IP_FW_F_TCPSYN && notcpsyn)
|
|
continue;
|
|
|
|
/*
|
|
* Specific firewall - packet's
|
|
* protocol must match firewall's
|
|
*/
|
|
if (prt==f_prt) {
|
|
|
|
if (prt==IP_FW_F_ICMP ||
|
|
(port_match(&f->fw_pts[0],f->fw_nsp,src_port,
|
|
f->fw_flg&IP_FW_F_SRNG) &&
|
|
port_match(&f->fw_pts[f->fw_nsp],f->fw_ndp,dst_port,
|
|
f->fw_flg&IP_FW_F_DRNG))) {
|
|
goto got_match;
|
|
} /* Ports match */
|
|
} /* Proto matches */
|
|
} /* ALL/Specific */
|
|
} /* IP addr/mask matches */
|
|
|
|
/*
|
|
* If we get here then none of the firewalls matched.
|
|
* So now we relay on policy defined by user-unmatched packet can
|
|
* be ever accepted or rejected...
|
|
*/
|
|
f=(struct ip_fw *)NULL;
|
|
if (ip_fw_policy&IP_FW_P_DENY)
|
|
goto bad_packet;
|
|
else
|
|
goto good_packet;
|
|
|
|
got_match:
|
|
#ifdef IPFIREWALL_VERBOSE
|
|
/*
|
|
* VERY ugly piece of code which actually
|
|
* makes kernel printf for denied packets...
|
|
*/
|
|
if (f->fw_flg&IP_FW_F_PRN) {
|
|
if (f->fw_flg&IP_FW_F_ACCEPT)
|
|
printf("Accept ");
|
|
else
|
|
printf("Deny ");
|
|
switch(ip->ip_p) {
|
|
case IPPROTO_TCP:
|
|
printf("TCP ");
|
|
break;
|
|
case IPPROTO_UDP:
|
|
printf("UDP ");
|
|
break;
|
|
case IPPROTO_ICMP:
|
|
printf("ICMP:%u ",icmp->icmp_type);
|
|
break;
|
|
default:
|
|
printf("p=%d ",ip->ip_p);
|
|
break;
|
|
}
|
|
print_ip(ip->ip_src);
|
|
if (ip->ip_p==IPPROTO_TCP || ip->ip_p==IPPROTO_UDP)
|
|
printf(":%d",src_port);
|
|
printf(" ");
|
|
print_ip(ip->ip_dst);
|
|
if (ip->ip_p==IPPROTO_TCP || ip->ip_p==IPPROTO_UDP)
|
|
printf(":%d",dst_port);
|
|
printf("\n");
|
|
}
|
|
#endif
|
|
if (f->fw_flg&IP_FW_F_ACCEPT)
|
|
goto good_packet;
|
|
#ifdef noneed
|
|
else
|
|
goto bad_packet;
|
|
#endif
|
|
|
|
bad_packet:
|
|
if (f) {
|
|
/*
|
|
* Do not ICMP reply to icmp
|
|
* packets....:)
|
|
*/
|
|
if (f_prt==IP_FW_F_ICMP)
|
|
return 0;
|
|
/*
|
|
* Reply to packets rejected
|
|
* by entry with this flag
|
|
* set only.
|
|
*/
|
|
if (!(f->fw_flg&IP_FW_F_ICMPRPL))
|
|
return 0;
|
|
m = m_get(M_DONTWAIT, MT_SOOPTS);
|
|
/*
|
|
* We never retry,we don't want to
|
|
* waste time-it is not so critical
|
|
* if ICMP unsent.
|
|
*/
|
|
if (!m)
|
|
return 0;
|
|
m->m_len = sizeof(struct ip)+64;
|
|
bcopy((caddr_t)ip,mtod(m, caddr_t),(unsigned)m->m_len);
|
|
if (f_prt==IP_FW_F_ALL)
|
|
icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_HOST, 0L, 0);
|
|
else
|
|
icmp_error(m, ICMP_UNREACH, ICMP_UNREACH_PORT, 0L, 0);
|
|
return 0;
|
|
} else {
|
|
/*
|
|
* If global icmp flag set we will do
|
|
* something here...later..
|
|
*/
|
|
return 0;
|
|
}
|
|
good_packet:
|
|
return 1;
|
|
}
|
|
#endif /* IPFIREWALL */
|
|
|
|
|
|
|
|
|
|
#ifdef IPACCT
|
|
void ip_acct_cnt(ip,rif,chain,nh_conv)
|
|
struct ip *ip;
|
|
struct ifnet *rif;
|
|
struct ip_fw *chain;
|
|
int nh_conv;
|
|
{
|
|
register struct ip_fw *f;
|
|
struct tcphdr *tcp=(struct tcphdr *)((u_long *)ip+ip->ip_hl);
|
|
struct udphdr *udp=(struct udphdr *)((u_long *)ip+ip->ip_hl);
|
|
struct ifaddr *ia=NULL, *ia_p;
|
|
struct in_addr src, dst, ia_i;
|
|
u_short src_port=0, dst_port=0;
|
|
u_short f_prt, prt=0;
|
|
char rev=0;
|
|
|
|
if (!chain)
|
|
return;
|
|
|
|
if (ip->ip_off&IP_OFFMASK)
|
|
return;
|
|
|
|
src = ip->ip_src;
|
|
dst = ip->ip_dst;
|
|
|
|
if (rif)
|
|
ia=rif->if_addrlist;
|
|
|
|
switch(ip->ip_p) {
|
|
case IPPROTO_TCP:
|
|
src_port=ntohs(tcp->th_sport);
|
|
dst_port=ntohs(tcp->th_dport);
|
|
prt=IP_FW_F_TCP;
|
|
break;
|
|
case IPPROTO_UDP:
|
|
src_port=ntohs(udp->uh_sport);
|
|
dst_port=ntohs(udp->uh_dport);
|
|
prt=IP_FW_F_UDP;
|
|
break;
|
|
case IPPROTO_ICMP:
|
|
prt=IP_FW_F_ICMP;
|
|
break;
|
|
default:
|
|
prt=IP_FW_F_ALL;
|
|
break;
|
|
}
|
|
|
|
for (f=chain;f;f=f->fw_next) {
|
|
if ((src.s_addr&f->fw_smsk.s_addr)==f->fw_src.s_addr
|
|
&& (dst.s_addr&f->fw_dmsk.s_addr)==f->fw_dst.s_addr) {
|
|
rev=0;
|
|
goto addr_match;
|
|
}
|
|
if ((f->fw_flg&IP_FW_F_BIDIR) &&
|
|
((src.s_addr&f->fw_smsk.s_addr)==f->fw_dst.s_addr
|
|
&& (dst.s_addr&f->fw_dmsk.s_addr)==f->fw_src.s_addr)) {
|
|
rev=1;
|
|
goto addr_match;
|
|
}
|
|
continue;
|
|
addr_match:
|
|
if (f->fw_via.s_addr && rif) {
|
|
for (ia_p=ia;ia_p;ia_p=ia_p->ifa_next) {
|
|
if (!ia_p->ifa_addr ||
|
|
ia_p->ifa_addr->sa_family!=AF_INET)
|
|
continue;
|
|
ia_i.s_addr=(((struct sockaddr_in *)\
|
|
(ia_p->ifa_addr))->sin_addr.s_addr);
|
|
if (ia_i.s_addr==f->fw_via.s_addr)
|
|
goto via_match;
|
|
}
|
|
continue;
|
|
} else {
|
|
goto via_match;
|
|
}
|
|
continue;
|
|
via_match:
|
|
f_prt=f->fw_flg&IP_FW_F_KIND;
|
|
if (f_prt==IP_FW_F_ALL) {
|
|
/* Universal frwl - we've got a match! */
|
|
|
|
f->fw_pcnt++; /* Rise packet count */
|
|
|
|
/*
|
|
* Rise byte count,
|
|
* if need to convert from
|
|
* host to network byte
|
|
* order,do it.
|
|
*/
|
|
if (nh_conv)
|
|
f->fw_bcnt+=ntohs(ip->ip_len);
|
|
else
|
|
f->fw_bcnt+=ip->ip_len;
|
|
} else {
|
|
/*
|
|
* Specific firewall - packet's
|
|
* protocol must match firewall's
|
|
*/
|
|
if (prt==f_prt) {
|
|
|
|
if ((prt==IP_FW_F_ICMP ||
|
|
(port_match(&f->fw_pts[0],f->fw_nsp,src_port,
|
|
f->fw_flg&IP_FW_F_SRNG) &&
|
|
port_match(&f->fw_pts[f->fw_nsp],f->fw_ndp,dst_port,
|
|
f->fw_flg&IP_FW_F_DRNG)))
|
|
|| ((rev)
|
|
&& (port_match(&f->fw_pts[0],f->fw_nsp,dst_port,
|
|
f->fw_flg&IP_FW_F_SRNG)
|
|
&& port_match(&f->fw_pts[f->fw_nsp],f->fw_ndp,src_port,
|
|
f->fw_flg&IP_FW_F_DRNG))))
|
|
{
|
|
f->fw_pcnt++; /* Rise packet count */
|
|
/*
|
|
* Rise byte count,
|
|
* if need to convert from
|
|
* host to network byte
|
|
* order,do it.
|
|
*/
|
|
if (nh_conv)
|
|
f->fw_bcnt+=ntohs(ip->ip_len);
|
|
else
|
|
f->fw_bcnt+=ip->ip_len;
|
|
} /* Ports match */
|
|
} /* Proto matches */
|
|
} /* ALL/Specific */
|
|
} /* IP addr/mask matches */
|
|
} /* End of whole function */
|
|
#endif /* IPACCT */
|
|
|
|
static
|
|
void
|
|
zero_fw_chain(chainptr)
|
|
struct ip_fw *chainptr;
|
|
{
|
|
struct ip_fw *ctmp=chainptr;
|
|
while(ctmp) {
|
|
ctmp->fw_pcnt=0l;
|
|
ctmp->fw_bcnt=0l;
|
|
ctmp=ctmp->fw_next;
|
|
}
|
|
}
|
|
|
|
static
|
|
void
|
|
free_fw_chain(chainptr)
|
|
struct ip_fw **chainptr;
|
|
{
|
|
int s=splnet();
|
|
while (*chainptr) {
|
|
struct ip_fw *ftmp;
|
|
ftmp = *chainptr;
|
|
*chainptr = ftmp->fw_next;
|
|
free(ftmp,M_SOOPTS);
|
|
}
|
|
splx(s);
|
|
}
|
|
|
|
static
|
|
int
|
|
add_entry(chainptr,frwl)
|
|
struct ip_fw **chainptr;
|
|
struct ip_fw *frwl;
|
|
{
|
|
struct ip_fw *ftmp;
|
|
struct ip_fw *chtmp=NULL;
|
|
struct ip_fw *chtmp_prev=NULL;
|
|
int s=splnet();
|
|
u_long m_src_mask,m_dst_mask;
|
|
u_long n_sa,n_da,o_sa,o_da,o_sm,o_dm,n_sm,n_dm;
|
|
u_short n_sr,n_dr,o_sr,o_dr;
|
|
u_short oldkind,newkind;
|
|
int addb4=0;
|
|
int n_o,n_n;
|
|
|
|
ftmp = malloc(sizeof(struct ip_fw),M_SOOPTS,M_DONTWAIT);
|
|
if ( ftmp == NULL ) {
|
|
dprintf1("ip_fw_ctl: malloc said no\n");
|
|
splx(s);
|
|
return(ENOSPC);
|
|
}
|
|
|
|
bcopy(frwl,ftmp,sizeof(struct ip_fw));
|
|
ftmp->fw_pcnt=0L;
|
|
ftmp->fw_bcnt=0L;
|
|
|
|
ftmp->fw_next = NULL;
|
|
|
|
if (*chainptr==NULL)
|
|
{
|
|
*chainptr=ftmp;
|
|
}
|
|
else
|
|
{
|
|
chtmp_prev=NULL;
|
|
for (chtmp=*chainptr;chtmp!=NULL;chtmp=chtmp->fw_next) {
|
|
|
|
addb4=0;
|
|
|
|
newkind=ftmp->fw_flg & IP_FW_F_KIND;
|
|
oldkind=chtmp->fw_flg & IP_FW_F_KIND;
|
|
|
|
if (newkind!=IP_FW_F_ALL
|
|
&& oldkind!=IP_FW_F_ALL
|
|
&& oldkind!=newkind) {
|
|
chtmp_prev=chtmp;
|
|
continue;
|
|
}
|
|
/*
|
|
* Very very *UGLY* code...
|
|
* Sorry,but i had to do this....
|
|
*/
|
|
n_sa=ntohl(ftmp->fw_src.s_addr);
|
|
n_da=ntohl(ftmp->fw_dst.s_addr);
|
|
n_sm=ntohl(ftmp->fw_smsk.s_addr);
|
|
n_dm=ntohl(ftmp->fw_dmsk.s_addr);
|
|
|
|
o_sa=ntohl(chtmp->fw_src.s_addr);
|
|
o_da=ntohl(chtmp->fw_dst.s_addr);
|
|
o_sm=ntohl(chtmp->fw_smsk.s_addr);
|
|
o_dm=ntohl(chtmp->fw_dmsk.s_addr);
|
|
|
|
m_src_mask = o_sm & n_sm;
|
|
m_dst_mask = o_dm & n_dm;
|
|
|
|
if ((o_sa & m_src_mask) == (n_sa & m_src_mask)) {
|
|
if (n_sm > o_sm)
|
|
addb4++;
|
|
if (n_sm < o_sm)
|
|
addb4--;
|
|
}
|
|
|
|
if ((o_da & m_dst_mask) == (n_da & m_dst_mask)) {
|
|
if (n_dm > o_dm)
|
|
addb4++;
|
|
if (n_dm < o_dm)
|
|
addb4--;
|
|
}
|
|
|
|
if (((o_da & o_dm) == (n_da & n_dm))
|
|
&&((o_sa & o_sm) == (n_sa & n_sm)))
|
|
{
|
|
if (newkind!=IP_FW_F_ALL &&
|
|
oldkind==IP_FW_F_ALL)
|
|
addb4++;
|
|
if (newkind==oldkind && (oldkind==IP_FW_F_TCP
|
|
|| oldkind==IP_FW_F_UDP)) {
|
|
|
|
/*
|
|
* Here the main ide is to check the size
|
|
* of port range which the frwl covers
|
|
* We actually don't check their values but
|
|
* just the wideness of range they have
|
|
* so that less wide ranges or single ports
|
|
* go first and wide ranges go later. No ports
|
|
* at all treated as a range of maximum number
|
|
* of ports.
|
|
*/
|
|
|
|
if (ftmp->fw_flg & IP_FW_F_SRNG)
|
|
n_sr=ftmp->fw_pts[1]-ftmp->fw_pts[0];
|
|
else
|
|
n_sr=(ftmp->fw_nsp)?
|
|
ftmp->fw_nsp : USHRT_MAX;
|
|
|
|
if (chtmp->fw_flg & IP_FW_F_SRNG)
|
|
o_sr=chtmp->fw_pts[1]-chtmp->fw_pts[0];
|
|
else
|
|
o_sr=(chtmp->fw_nsp)?
|
|
chtmp->fw_nsp : USHRT_MAX;
|
|
|
|
if (n_sr<o_sr)
|
|
addb4++;
|
|
if (n_sr>o_sr)
|
|
addb4--;
|
|
|
|
n_n=ftmp->fw_nsp;
|
|
n_o=chtmp->fw_nsp;
|
|
/*
|
|
* Actually this cannot happen as the frwl control
|
|
* procedure checks for number of ports in source and
|
|
* destination range but we will try to be more safe.
|
|
*/
|
|
if ((n_n>(IP_FW_MAX_PORTS-2)) ||
|
|
(n_o>(IP_FW_MAX_PORTS-2)))
|
|
goto skip_check;
|
|
|
|
if (ftmp->fw_flg & IP_FW_F_DRNG)
|
|
n_dr=ftmp->fw_pts[n_n+1]-ftmp->fw_pts[n_n];
|
|
else
|
|
n_dr=(ftmp->fw_ndp)?
|
|
ftmp->fw_ndp : USHRT_MAX;
|
|
|
|
if (chtmp->fw_flg & IP_FW_F_DRNG)
|
|
o_dr=chtmp->fw_pts[n_o+1]-chtmp->fw_pts[n_o];
|
|
else
|
|
o_dr=(chtmp->fw_ndp)?
|
|
chtmp->fw_ndp : USHRT_MAX;
|
|
if (n_dr<o_dr)
|
|
addb4++;
|
|
if (n_dr>o_dr)
|
|
addb4--;
|
|
|
|
skip_check:
|
|
}
|
|
}
|
|
if (addb4>0) {
|
|
if (chtmp_prev) {
|
|
chtmp_prev->fw_next=ftmp;
|
|
ftmp->fw_next=chtmp;
|
|
} else {
|
|
*chainptr=ftmp;
|
|
ftmp->fw_next=chtmp;
|
|
}
|
|
splx(s);
|
|
return 0;
|
|
}
|
|
chtmp_prev=chtmp;
|
|
}
|
|
if (chtmp_prev)
|
|
chtmp_prev->fw_next=ftmp;
|
|
else
|
|
#ifdef DIAGNOSTICS
|
|
panic("Can't happen");
|
|
#else
|
|
*chainptr=ftmp;
|
|
#endif
|
|
}
|
|
splx(s);
|
|
return(0);
|
|
}
|
|
|
|
static
|
|
int
|
|
del_entry(chainptr,frwl)
|
|
struct ip_fw **chainptr;
|
|
struct ip_fw *frwl;
|
|
{
|
|
struct ip_fw *ftmp,*ltmp;
|
|
u_short tport1,tport2,tmpnum;
|
|
char matches,was_found;
|
|
int s=splnet();
|
|
|
|
ftmp=*chainptr;
|
|
|
|
if (ftmp == NULL) {
|
|
dprintf1("ip_fw_ctl: chain is empty\n");
|
|
splx(s);
|
|
return(EINVAL);
|
|
}
|
|
|
|
ltmp=NULL;
|
|
was_found=0;
|
|
|
|
while(ftmp)
|
|
{
|
|
matches=1;
|
|
if (ftmp->fw_src.s_addr!=frwl->fw_src.s_addr
|
|
|| ftmp->fw_dst.s_addr!=frwl->fw_dst.s_addr
|
|
|| ftmp->fw_smsk.s_addr!=frwl->fw_smsk.s_addr
|
|
|| ftmp->fw_dmsk.s_addr!=frwl->fw_dmsk.s_addr
|
|
|| ftmp->fw_via.s_addr!=frwl->fw_via.s_addr
|
|
|| ftmp->fw_flg!=frwl->fw_flg)
|
|
matches=0;
|
|
tport1=ftmp->fw_nsp+ftmp->fw_ndp;
|
|
tport2=frwl->fw_nsp+frwl->fw_ndp;
|
|
if (tport1!=tport2)
|
|
matches=0;
|
|
else
|
|
if (tport1!=0)
|
|
{
|
|
for (tmpnum=0;tmpnum < tport1 && tmpnum < IP_FW_MAX_PORTS;tmpnum++)
|
|
if (ftmp->fw_pts[tmpnum]!=frwl->fw_pts[tmpnum])
|
|
matches=0;
|
|
}
|
|
if(matches)
|
|
{
|
|
was_found=1;
|
|
if (ltmp)
|
|
{
|
|
ltmp->fw_next=ftmp->fw_next;
|
|
free(ftmp,M_SOOPTS);
|
|
ftmp=ltmp->fw_next;
|
|
}
|
|
else
|
|
{
|
|
*chainptr=ftmp->fw_next;
|
|
free(ftmp,M_SOOPTS);
|
|
ftmp=*chainptr;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
ltmp = ftmp;
|
|
ftmp = ftmp->fw_next;
|
|
}
|
|
}
|
|
splx(s);
|
|
if (was_found) return 0;
|
|
else return(EINVAL);
|
|
}
|
|
|
|
static
|
|
int
|
|
clr_entry(chainptr,frwl)
|
|
struct ip_fw **chainptr;
|
|
struct ip_fw *frwl;
|
|
{
|
|
struct ip_fw *ftmp,*ltmp;
|
|
u_short tport1,tport2,tmpnum;
|
|
char matches,was_found;
|
|
|
|
ftmp=*chainptr;
|
|
|
|
if (ftmp == NULL) {
|
|
dprintf1("ip_fw_ctl: chain is empty\n");
|
|
return(EINVAL);
|
|
}
|
|
|
|
was_found=0;
|
|
|
|
while(ftmp)
|
|
{
|
|
matches=1;
|
|
if (ftmp->fw_src.s_addr!=frwl->fw_src.s_addr
|
|
|| ftmp->fw_dst.s_addr!=frwl->fw_dst.s_addr
|
|
|| ftmp->fw_smsk.s_addr!=frwl->fw_smsk.s_addr
|
|
|| ftmp->fw_dmsk.s_addr!=frwl->fw_dmsk.s_addr
|
|
|| ftmp->fw_via.s_addr!=frwl->fw_via.s_addr
|
|
|| ftmp->fw_flg!=frwl->fw_flg)
|
|
matches=0;
|
|
tport1=ftmp->fw_nsp+ftmp->fw_ndp;
|
|
tport2=frwl->fw_nsp+frwl->fw_ndp;
|
|
if (tport1!=tport2)
|
|
matches=0;
|
|
else
|
|
if (tport1!=0)
|
|
{
|
|
for (tmpnum=0;tmpnum < tport1 && tmpnum < IP_FW_MAX_PORTS;tmpnum++)
|
|
if (ftmp->fw_pts[tmpnum]!=frwl->fw_pts[tmpnum])
|
|
matches=0;
|
|
}
|
|
if(matches)
|
|
{
|
|
was_found=1;
|
|
ftmp->fw_pcnt=0L;
|
|
ftmp->fw_bcnt=0L;
|
|
}
|
|
ftmp=ftmp->fw_next;
|
|
}
|
|
if (was_found) return 0;
|
|
else return(EINVAL);
|
|
}
|
|
|
|
struct ip_fw *
|
|
check_ipfw_struct(m)
|
|
struct mbuf *m;
|
|
{
|
|
struct ip_fw *frwl;
|
|
|
|
if ( m->m_len != sizeof(struct ip_fw) ) {
|
|
dprintf3("ip_fw_ctl: len=%d, want %d\n",m->m_len,
|
|
sizeof(struct ip_fw));
|
|
return(NULL);
|
|
}
|
|
|
|
frwl = mtod(m,struct ip_fw*);
|
|
|
|
if ( (frwl->fw_flg & ~IP_FW_F_MASK) != 0 ) {
|
|
dprintf2("ip_fw_ctl: undefined flag bits set (flags=%x)\n",
|
|
frwl->fw_flg);
|
|
return(NULL);
|
|
}
|
|
|
|
if ( (frwl->fw_flg & IP_FW_F_SRNG) && frwl->fw_nsp < 2 ) {
|
|
dprintf2("ip_fw_ctl: src range set but n_src_p=%d\n",
|
|
frwl->fw_nsp);
|
|
return(NULL);
|
|
}
|
|
|
|
if ( (frwl->fw_flg & IP_FW_F_DRNG) && frwl->fw_ndp < 2 ) {
|
|
dprintf2("ip_fw_ctl: dst range set but n_dst_p=%d\n",
|
|
frwl->fw_ndp);
|
|
return(NULL);
|
|
}
|
|
|
|
if ( frwl->fw_nsp + frwl->fw_ndp > IP_FW_MAX_PORTS ) {
|
|
dprintf3("ip_fw_ctl: too many ports (%d+%d)\n",
|
|
frwl->fw_nsp,frwl->fw_ndp);
|
|
return(NULL);
|
|
}
|
|
|
|
#if 0
|
|
if ( (frwl->fw_flg & IP_FW_F_KIND) == IP_FW_F_ICMP ) {
|
|
dprintf1("ip_fw_ctl: request for unsupported ICMP frwling\n");
|
|
return(NULL);
|
|
}
|
|
#endif
|
|
return frwl;
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef IPACCT
|
|
int
|
|
ip_acct_ctl(stage,m)
|
|
int stage;
|
|
struct mbuf *m;
|
|
{
|
|
if ( stage == IP_ACCT_FLUSH )
|
|
{
|
|
free_fw_chain(&ip_acct_chain);
|
|
return(0);
|
|
}
|
|
if ( stage == IP_ACCT_ZERO )
|
|
{
|
|
zero_fw_chain(ip_acct_chain);
|
|
return(0);
|
|
}
|
|
if ( stage == IP_ACCT_ADD
|
|
|| stage == IP_ACCT_DEL
|
|
|| stage == IP_ACCT_CLR
|
|
) {
|
|
|
|
struct ip_fw *frwl;
|
|
|
|
if (!(frwl=check_ipfw_struct(m)))
|
|
return (EINVAL);
|
|
|
|
switch (stage) {
|
|
case IP_ACCT_ADD:
|
|
return( add_entry(&ip_acct_chain,frwl));
|
|
case IP_ACCT_DEL:
|
|
return( del_entry(&ip_acct_chain,frwl));
|
|
case IP_ACCT_CLR:
|
|
return( clr_entry(&ip_acct_chain,frwl));
|
|
default:
|
|
#ifdef DIAGNOSTICS
|
|
panic("Can't happen");
|
|
#else
|
|
dprintf2("ip_acct_ctl: unknown request %d\n",stage);
|
|
return(EINVAL);
|
|
#endif
|
|
}
|
|
}
|
|
dprintf2("ip_acct_ctl: unknown request %d\n",stage);
|
|
return(EINVAL);
|
|
}
|
|
#endif
|
|
|
|
#ifdef IPFIREWALL
|
|
int
|
|
ip_fw_ctl(stage,m)
|
|
int stage;
|
|
struct mbuf *m;
|
|
{
|
|
if ( stage == IP_FW_FLUSH )
|
|
{
|
|
free_fw_chain(&ip_fw_blk_chain);
|
|
free_fw_chain(&ip_fw_fwd_chain);
|
|
return(0);
|
|
}
|
|
|
|
if ( m == 0 )
|
|
{
|
|
printf("ip_fw_ctl: NULL mbuf ptr\n");
|
|
return(EINVAL);
|
|
}
|
|
|
|
if ( stage == IP_FW_POLICY )
|
|
{
|
|
u_short *tmp_policy_ptr;
|
|
tmp_policy_ptr=mtod(m,u_short *);
|
|
if ((*tmp_policy_ptr)&~IP_FW_P_MASK)
|
|
return (EINVAL);
|
|
ip_fw_policy=*tmp_policy_ptr;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Here we really working hard-adding new elements
|
|
* to blocking/forwarding chains or deleting'em
|
|
*/
|
|
|
|
if ( stage == IP_FW_ADD_BLK
|
|
|| stage == IP_FW_ADD_FWD
|
|
|| stage == IP_FW_DEL_BLK
|
|
|| stage == IP_FW_DEL_FWD
|
|
) {
|
|
|
|
struct ip_fw *frwl;
|
|
|
|
frwl=check_ipfw_struct(m);
|
|
if (frwl==NULL)
|
|
return (EINVAL);
|
|
#ifdef nenado
|
|
if (!(frwl=check_ipfw_struct(m)))
|
|
return (EINVAL);
|
|
#endif
|
|
|
|
switch (stage) {
|
|
case IP_FW_ADD_BLK:
|
|
return(add_entry(&ip_fw_blk_chain,frwl));
|
|
case IP_FW_ADD_FWD:
|
|
return(add_entry(&ip_fw_fwd_chain,frwl));
|
|
case IP_FW_DEL_BLK:
|
|
return(del_entry(&ip_fw_blk_chain,frwl));
|
|
case IP_FW_DEL_FWD:
|
|
return(del_entry(&ip_fw_fwd_chain,frwl));
|
|
default:
|
|
/*
|
|
* Should be panic but...
|
|
*/
|
|
dprintf2("ip_fw_ctl: unknown request %d\n",stage);
|
|
return(EINVAL);
|
|
}
|
|
}
|
|
|
|
dprintf2("ip_fw_ctl: unknown request %d\n",stage);
|
|
return(EINVAL);
|
|
}
|
|
#endif /* IPFIREWALL */
|