145916cd2Sjpk /* 2ab25eeb5Syz * Copyright (C) 1993-2001, 2003 by Darren Reed. 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * See the IPFILTER.LICENCE file for details on licencing. 57c478bd9Sstevel@tonic-gate * 6ab25eeb5Syz * @(#)ip_compat.h 1.8 1/14/96 7ab25eeb5Syz * $Id: ip_compat.h,v 2.142.2.30 2005/08/11 15:13:49 darrenr Exp $ 8ab25eeb5Syz * 91b47e080Sdr * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 107c478bd9Sstevel@tonic-gate * Use is subject to license terms. 117c478bd9Sstevel@tonic-gate */ 127c478bd9Sstevel@tonic-gate 137c478bd9Sstevel@tonic-gate #ifndef __IP_COMPAT_H__ 147c478bd9Sstevel@tonic-gate #define __IP_COMPAT_H__ 157c478bd9Sstevel@tonic-gate 167c478bd9Sstevel@tonic-gate #ifndef __P 177c478bd9Sstevel@tonic-gate # ifdef __STDC__ 187c478bd9Sstevel@tonic-gate # define __P(x) x 197c478bd9Sstevel@tonic-gate # else 207c478bd9Sstevel@tonic-gate # define __P(x) () 217c478bd9Sstevel@tonic-gate # endif 227c478bd9Sstevel@tonic-gate #endif 237c478bd9Sstevel@tonic-gate #ifndef __STDC__ 247c478bd9Sstevel@tonic-gate # undef const 257c478bd9Sstevel@tonic-gate # define const 267c478bd9Sstevel@tonic-gate #endif 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #if defined(_KERNEL) || defined(KERNEL) || defined(__KERNEL__) 297c478bd9Sstevel@tonic-gate # undef KERNEL 307c478bd9Sstevel@tonic-gate # undef _KERNEL 317c478bd9Sstevel@tonic-gate # undef __KERNEL__ 327c478bd9Sstevel@tonic-gate # define KERNEL 337c478bd9Sstevel@tonic-gate # define _KERNEL 347c478bd9Sstevel@tonic-gate # define __KERNEL__ 357c478bd9Sstevel@tonic-gate #endif 367c478bd9Sstevel@tonic-gate 377c478bd9Sstevel@tonic-gate #ifndef SOLARIS 387c478bd9Sstevel@tonic-gate #define SOLARIS (defined(sun) && (defined(__svr4__) || defined(__SVR4))) 397c478bd9Sstevel@tonic-gate #endif 40ab25eeb5Syz #if SOLARIS2 >= 8 417c478bd9Sstevel@tonic-gate # ifndef USE_INET6 427c478bd9Sstevel@tonic-gate # define USE_INET6 437c478bd9Sstevel@tonic-gate # endif 447c478bd9Sstevel@tonic-gate #endif 457c478bd9Sstevel@tonic-gate #if defined(__FreeBSD_version) && (__FreeBSD_version >= 400000) && \ 46ab25eeb5Syz !defined(_KERNEL) && !defined(USE_INET6) && !defined(NOINET6) 477c478bd9Sstevel@tonic-gate # define USE_INET6 487c478bd9Sstevel@tonic-gate #endif 497c478bd9Sstevel@tonic-gate #if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105000000) && \ 50ab25eeb5Syz !defined(_KERNEL) && !defined(USE_INET6) 517c478bd9Sstevel@tonic-gate # define USE_INET6 52ab25eeb5Syz # define IPFILTER_M_IPFILTER 537c478bd9Sstevel@tonic-gate #endif 54ab25eeb5Syz #if defined(OpenBSD) && (OpenBSD >= 200206) && \ 55ab25eeb5Syz !defined(_KERNEL) && !defined(USE_INET6) 567c478bd9Sstevel@tonic-gate # define USE_INET6 577c478bd9Sstevel@tonic-gate #endif 587c478bd9Sstevel@tonic-gate #if defined(__osf__) 597c478bd9Sstevel@tonic-gate # define USE_INET6 607c478bd9Sstevel@tonic-gate #endif 61ab25eeb5Syz #if defined(linux) && (!defined(_KERNEL) || defined(CONFIG_IPV6)) 62ab25eeb5Syz # define USE_INET6 63ab25eeb5Syz #endif 64ab25eeb5Syz #if defined(HPUXREV) && (HPUXREV >= 1111) 65ab25eeb5Syz # define USE_INET6 66ab25eeb5Syz #endif 677c478bd9Sstevel@tonic-gate 687c478bd9Sstevel@tonic-gate #if defined(BSD) && (BSD < 199103) && defined(__osf__) 697c478bd9Sstevel@tonic-gate # undef BSD 707c478bd9Sstevel@tonic-gate # define BSD 199103 717c478bd9Sstevel@tonic-gate #endif 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate #if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 747c478bd9Sstevel@tonic-gate # define index strchr 757c478bd9Sstevel@tonic-gate # if !defined(_KERNEL) 767c478bd9Sstevel@tonic-gate # define bzero(a,b) memset(a,0,b) 777c478bd9Sstevel@tonic-gate # define bcmp memcmp 787c478bd9Sstevel@tonic-gate # define bcopy(a,b,c) memmove(b,a,c) 797c478bd9Sstevel@tonic-gate # endif 807c478bd9Sstevel@tonic-gate #endif 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate #ifndef LIFNAMSIZ 837c478bd9Sstevel@tonic-gate # ifdef IF_NAMESIZE 847c478bd9Sstevel@tonic-gate # define LIFNAMSIZ IF_NAMESIZE 857c478bd9Sstevel@tonic-gate # else 867c478bd9Sstevel@tonic-gate # ifdef IFNAMSIZ 877c478bd9Sstevel@tonic-gate # define LIFNAMSIZ IFNAMSIZ 887c478bd9Sstevel@tonic-gate # else 897c478bd9Sstevel@tonic-gate # define LIFNAMSIZ 16 907c478bd9Sstevel@tonic-gate # endif 917c478bd9Sstevel@tonic-gate # endif 927c478bd9Sstevel@tonic-gate #endif 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate #if defined(__sgi) || defined(bsdi) || defined(__hpux) || defined(hpux) 957c478bd9Sstevel@tonic-gate struct ether_addr { 967c478bd9Sstevel@tonic-gate u_char ether_addr_octet[6]; 977c478bd9Sstevel@tonic-gate }; 987c478bd9Sstevel@tonic-gate #endif 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate #if defined(__sgi) && !defined(IPFILTER_LKM) 1017c478bd9Sstevel@tonic-gate # ifdef __STDC__ 1027c478bd9Sstevel@tonic-gate # define IPL_EXTERN(ep) ipfilter##ep 1037c478bd9Sstevel@tonic-gate # else 1047c478bd9Sstevel@tonic-gate # define IPL_EXTERN(ep) ipfilter/**/ep 1057c478bd9Sstevel@tonic-gate # endif 1067c478bd9Sstevel@tonic-gate #else 1077c478bd9Sstevel@tonic-gate # ifdef __STDC__ 1087c478bd9Sstevel@tonic-gate # define IPL_EXTERN(ep) ipl##ep 1097c478bd9Sstevel@tonic-gate # else 1107c478bd9Sstevel@tonic-gate # define IPL_EXTERN(ep) ipl/**/ep 1117c478bd9Sstevel@tonic-gate # endif 1127c478bd9Sstevel@tonic-gate #endif 1137c478bd9Sstevel@tonic-gate 1147c478bd9Sstevel@tonic-gate /* 1157c478bd9Sstevel@tonic-gate * This is a workaround for <sys/uio.h> troubles on FreeBSD and OpenBSD. 1167c478bd9Sstevel@tonic-gate */ 117ab25eeb5Syz #ifndef linux 118ab25eeb5Syz # ifndef _KERNEL 119ab25eeb5Syz # define ADD_KERNEL 120ab25eeb5Syz # define _KERNEL 121ab25eeb5Syz # define KERNEL 122ab25eeb5Syz # endif 123ab25eeb5Syz # ifdef __OpenBSD__ 1247c478bd9Sstevel@tonic-gate struct file; 125ab25eeb5Syz # endif 126ab25eeb5Syz # include <sys/uio.h> 127ab25eeb5Syz # ifdef ADD_KERNEL 128ab25eeb5Syz # undef _KERNEL 129ab25eeb5Syz # undef KERNEL 130ab25eeb5Syz # endif 1317c478bd9Sstevel@tonic-gate #endif 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 1357c478bd9Sstevel@tonic-gate /* S O L A R I S */ 1367c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 1377c478bd9Sstevel@tonic-gate #if SOLARIS 1387c478bd9Sstevel@tonic-gate # define MENTAT 1 1397c478bd9Sstevel@tonic-gate # include <sys/cmn_err.h> 1407c478bd9Sstevel@tonic-gate # include <sys/isa_defs.h> 1417c478bd9Sstevel@tonic-gate # include <sys/stream.h> 1427c478bd9Sstevel@tonic-gate # include <sys/ioccom.h> 1437c478bd9Sstevel@tonic-gate # include <sys/sysmacros.h> 1447c478bd9Sstevel@tonic-gate # include <sys/kmem.h> 1457c478bd9Sstevel@tonic-gate # if SOLARIS2 >= 10 1467c478bd9Sstevel@tonic-gate # include <sys/procset.h> 1477c478bd9Sstevel@tonic-gate # include <sys/proc.h> 1487c478bd9Sstevel@tonic-gate # include <sys/devops.h> 1497c478bd9Sstevel@tonic-gate # include <sys/ddi_impldefs.h> 150f4b3ec61Sdh # include <sys/neti.h> 1517c478bd9Sstevel@tonic-gate # endif 152c793af95Ssangeeta 153c793af95Ssangeeta /* 154c793af95Ssangeeta * inet/ip.h would end up including radix.h with _KERNEL, which is not 155c793af95Ssangeeta * what the tools intend, so include radix.h first. 156c793af95Ssangeeta */ 157c793af95Ssangeeta #if SOLARIS2 > 10 158c793af95Ssangeeta # include <net/radix.h> 159c793af95Ssangeeta #endif 1607c478bd9Sstevel@tonic-gate /* 1617c478bd9Sstevel@tonic-gate * because Solaris 2 defines these in two places :-/ 1627c478bd9Sstevel@tonic-gate */ 1637c478bd9Sstevel@tonic-gate # ifndef KERNEL 164f4b3ec61Sdh # define ADD_KERNEL 1657c478bd9Sstevel@tonic-gate # define _KERNEL 1667c478bd9Sstevel@tonic-gate # undef RES_INIT 1677c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate # if SOLARIS2 >= 8 1707c478bd9Sstevel@tonic-gate # include <netinet/ip6.h> 1717c478bd9Sstevel@tonic-gate # include <netinet/icmp6.h> 1727c478bd9Sstevel@tonic-gate # endif 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate # include <inet/common.h> 1757c478bd9Sstevel@tonic-gate /* These 5 are defined in <inet/ip.h> and <netinet/ip.h> */ 1767c478bd9Sstevel@tonic-gate # undef IPOPT_EOL 1777c478bd9Sstevel@tonic-gate # undef IPOPT_NOP 1787c478bd9Sstevel@tonic-gate # undef IPOPT_LSRR 1797c478bd9Sstevel@tonic-gate # undef IPOPT_RR 1807c478bd9Sstevel@tonic-gate # undef IPOPT_SSRR 181ab25eeb5Syz # ifdef i386 182ab25eeb5Syz # define _SYS_PROMIF_H 183ab25eeb5Syz # endif 184f4b3ec61Sdh # ifdef ADD_KERNEL 185f4b3ec61Sdh # undef _KERNEL 186f4b3ec61Sdh # endif 1877c478bd9Sstevel@tonic-gate # include <inet/ip.h> 1887c478bd9Sstevel@tonic-gate # undef COPYOUT 1897c478bd9Sstevel@tonic-gate # include <inet/ip_ire.h> 1907c478bd9Sstevel@tonic-gate # ifndef KERNEL 1917c478bd9Sstevel@tonic-gate # undef _KERNEL 1927c478bd9Sstevel@tonic-gate # endif 1937c478bd9Sstevel@tonic-gate # if SOLARIS2 >= 8 194ab25eeb5Syz # define SNPRINTF snprintf 195ab25eeb5Syz 1967c478bd9Sstevel@tonic-gate # include <inet/ip_if.h> 1977c478bd9Sstevel@tonic-gate # define ipif_local_addr ipif_lcl_addr 1987c478bd9Sstevel@tonic-gate /* Only defined in private include file */ 1997c478bd9Sstevel@tonic-gate # ifndef V4_PART_OF_V6 2007c478bd9Sstevel@tonic-gate # define V4_PART_OF_V6(v6) v6.s6_addr32[3] 2017c478bd9Sstevel@tonic-gate # endif 2027c478bd9Sstevel@tonic-gate struct ip6_ext { 2037c478bd9Sstevel@tonic-gate u_char ip6e_nxt; 2047c478bd9Sstevel@tonic-gate u_char ip6e_len; 2057c478bd9Sstevel@tonic-gate }; 2067c478bd9Sstevel@tonic-gate # endif /* SOLARIS2 >= 8 */ 2077c478bd9Sstevel@tonic-gate 208381a2a9aSdr # ifdef FW_HOOKS 209381a2a9aSdr 210381a2a9aSdr # define SOLARIS_PFHOOKS 1 211381a2a9aSdr 212381a2a9aSdr typedef struct qpktinfo { 213381a2a9aSdr /* data that changes per-packet */ 214381a2a9aSdr void *qpi_ill; /* COPIED */ 215381a2a9aSdr mblk_t *qpi_m; 216381a2a9aSdr void *qpi_data; /* where layer 3 header starts */ 217381a2a9aSdr size_t qpi_off; 2181b47e080Sdr int qpi_flags; /* Uses FI_* flags */ 219381a2a9aSdr } qpktinfo_t; 220381a2a9aSdr 221381a2a9aSdr extern void mb_copydata __P((mblk_t *, size_t , size_t, char *)); 222381a2a9aSdr extern void mb_copyback __P((mblk_t *, size_t , size_t, char *)); 223381a2a9aSdr # endif 224381a2a9aSdr 2257c478bd9Sstevel@tonic-gate # if SOLARIS2 >= 6 2267c478bd9Sstevel@tonic-gate # include <sys/atomic.h> 2277c478bd9Sstevel@tonic-gate typedef uint32_t u_32_t; 2287c478bd9Sstevel@tonic-gate # else 2297c478bd9Sstevel@tonic-gate typedef unsigned int u_32_t; 2307c478bd9Sstevel@tonic-gate # endif 2317c478bd9Sstevel@tonic-gate # define U_32_T 1 2327c478bd9Sstevel@tonic-gate 2337c478bd9Sstevel@tonic-gate # ifdef _KERNEL 2347c478bd9Sstevel@tonic-gate # define KRWLOCK_T krwlock_t 2357c478bd9Sstevel@tonic-gate # define KMUTEX_T kmutex_t 2367c478bd9Sstevel@tonic-gate # if SOLARIS2 >= 6 2377c478bd9Sstevel@tonic-gate # if SOLARIS2 == 6 2387c478bd9Sstevel@tonic-gate # define ATOMIC_INCL(x) atomic_add_long((uint32_t*)&(x), 1) 2397c478bd9Sstevel@tonic-gate # define ATOMIC_DECL(x) atomic_add_long((uint32_t*)&(x), -1) 2407c478bd9Sstevel@tonic-gate # else 2417c478bd9Sstevel@tonic-gate # define ATOMIC_INCL(x) atomic_add_long(&(x), 1) 2427c478bd9Sstevel@tonic-gate # define ATOMIC_DECL(x) atomic_add_long(&(x), -1) 2437c478bd9Sstevel@tonic-gate # endif /* SOLARIS2 == 6 */ 2447c478bd9Sstevel@tonic-gate # define ATOMIC_INC64(x) atomic_add_64((uint64_t*)&(x), 1) 2457c478bd9Sstevel@tonic-gate # define ATOMIC_INC32(x) atomic_add_32((uint32_t*)&(x), 1) 2467c478bd9Sstevel@tonic-gate # define ATOMIC_INC16(x) atomic_add_16((uint16_t*)&(x), 1) 2477c478bd9Sstevel@tonic-gate # define ATOMIC_DEC64(x) atomic_add_64((uint64_t*)&(x), -1) 2487c478bd9Sstevel@tonic-gate # define ATOMIC_DEC32(x) atomic_add_32((uint32_t*)&(x), -1) 2497c478bd9Sstevel@tonic-gate # define ATOMIC_DEC16(x) atomic_add_16((uint16_t*)&(x), -1) 2507c478bd9Sstevel@tonic-gate # else 2517c478bd9Sstevel@tonic-gate # define ATOMIC_INC(x) { mutex_enter(&ipf_rw); (x)++; \ 2527c478bd9Sstevel@tonic-gate mutex_exit(&ipf_rw); } 2537c478bd9Sstevel@tonic-gate # define ATOMIC_DEC(x) { mutex_enter(&ipf_rw); (x)--; \ 2547c478bd9Sstevel@tonic-gate mutex_exit(&ipf_rw); } 2557c478bd9Sstevel@tonic-gate # endif /* SOLARIS2 >= 6 */ 2567c478bd9Sstevel@tonic-gate # define USE_MUTEXES 2577c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) mutex_enter(&(x)->ipf_lk) 2587c478bd9Sstevel@tonic-gate # define READ_ENTER(x) rw_enter(&(x)->ipf_lk, RW_READER) 2597c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) rw_enter(&(x)->ipf_lk, RW_WRITER) 2607c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) rw_downgrade(&(x)->ipf_lk) 2617c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) rw_init(&(x)->ipf_lk, (y), \ 2627c478bd9Sstevel@tonic-gate RW_DRIVER, NULL) 2637c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) rw_exit(&(x)->ipf_lk) 2647c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) rw_destroy(&(x)->ipf_lk) 2657c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x, y) mutex_init(&(x)->ipf_lk, (y), \ 2667c478bd9Sstevel@tonic-gate MUTEX_DRIVER, NULL) 2677c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) mutex_destroy(&(x)->ipf_lk) 2687c478bd9Sstevel@tonic-gate # define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 2697c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) mutex_exit(&(x)->ipf_lk) 2707c478bd9Sstevel@tonic-gate # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 2717c478bd9Sstevel@tonic-gate # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 272*bb1d9de5SJohn Ojemann # define BCOPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 273*bb1d9de5SJohn Ojemann # define BCOPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 2747c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 2757c478bd9Sstevel@tonic-gate # define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 2767c478bd9Sstevel@tonic-gate # define KFREES(x,s) kmem_free((char *)(x), (s)) 2777c478bd9Sstevel@tonic-gate # define SPL_NET(x) ; 2787c478bd9Sstevel@tonic-gate # define SPL_IMP(x) ; 2797c478bd9Sstevel@tonic-gate # undef SPL_X 2807c478bd9Sstevel@tonic-gate # define SPL_X(x) ; 2817c478bd9Sstevel@tonic-gate # ifdef sparc 2827c478bd9Sstevel@tonic-gate # define ntohs(x) (x) 2837c478bd9Sstevel@tonic-gate # define ntohl(x) (x) 2847c478bd9Sstevel@tonic-gate # define htons(x) (x) 2857c478bd9Sstevel@tonic-gate # define htonl(x) (x) 2867c478bd9Sstevel@tonic-gate # endif /* sparc */ 2877c478bd9Sstevel@tonic-gate # define KMALLOC(a,b) (a) = (b)kmem_alloc(sizeof(*(a)), KM_NOSLEEP) 2887c478bd9Sstevel@tonic-gate # define KMALLOCS(a,b,c) (a) = (b)kmem_alloc((c), KM_NOSLEEP) 2897c478bd9Sstevel@tonic-gate # define GET_MINOR(x) getminor(x) 290f4b3ec61Sdh /*extern phy_if_t get_unit __P((char *, int, ipf_stack_t *));*/ 291f4b3ec61Sdh # define GETIFP(n, v, ifs) (void *)get_unit(n, v, ifs) 292381a2a9aSdr # define IFNAME(x) ((ill_t *)x)->ill_name 293381a2a9aSdr # define COPYIFNAME(x, b, v) (void) net_getifname(((v) == 4) ? \ 294f4b3ec61Sdh ifs->ifs_ipf_ipv4 : ifs->ifs_ipf_ipv6,\ 295f4b3ec61Sdh (phy_if_t)(x), (b), sizeof(b)) 2967c478bd9Sstevel@tonic-gate # define GETKTIME(x) uniqtime((struct timeval *)x) 2977c478bd9Sstevel@tonic-gate # define MSGDSIZE(x) msgdsize(x) 2987c478bd9Sstevel@tonic-gate # define M_LEN(x) ((x)->b_wptr - (x)->b_rptr) 2997c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) dupmsg((x)) 300ab25eeb5Syz # define MTOD(m,t) ((t)((m)->b_rptr)) 3017c478bd9Sstevel@tonic-gate # define MTYPE(m) ((m)->b_datap->db_type) 3027c478bd9Sstevel@tonic-gate # define FREE_MB_T(m) freemsg(m) 303ab25eeb5Syz # define m_next b_cont 304381a2a9aSdr # define CACHE_HASH(x) (((phy_if_t)(x)->fin_ifp) & 7) 3057c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; cmn_err(CE_PANIC, "ipf_panic"); } 3067c478bd9Sstevel@tonic-gate typedef mblk_t mb_t; 3077c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate # if (SOLARIS2 >= 7) 3107c478bd9Sstevel@tonic-gate # ifdef lint 3117c478bd9Sstevel@tonic-gate # define ALIGN32(ptr) (ptr ? 0L : 0L) 3127c478bd9Sstevel@tonic-gate # define ALIGN16(ptr) (ptr ? 0L : 0L) 3137c478bd9Sstevel@tonic-gate # else 3147c478bd9Sstevel@tonic-gate # define ALIGN32(ptr) (ptr) 3157c478bd9Sstevel@tonic-gate # define ALIGN16(ptr) (ptr) 3167c478bd9Sstevel@tonic-gate # endif 3177c478bd9Sstevel@tonic-gate # endif 3187c478bd9Sstevel@tonic-gate 319ab25eeb5Syz # if SOLARIS2 < 6 320ab25eeb5Syz typedef struct uio uio_t; 321ab25eeb5Syz # endif 322ab25eeb5Syz typedef int ioctlcmd_t; 323ab073b32Sdr typedef uint8_t u_int8_t; 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate #endif /* SOLARIS */ 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 3307c478bd9Sstevel@tonic-gate /* H P U X */ 3317c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 3327c478bd9Sstevel@tonic-gate #ifdef __hpux 3337c478bd9Sstevel@tonic-gate # define MENTAT 1 3347c478bd9Sstevel@tonic-gate # include <sys/sysmacros.h> 3357c478bd9Sstevel@tonic-gate # include <sys/spinlock.h> 3367c478bd9Sstevel@tonic-gate # include <sys/lock.h> 3377c478bd9Sstevel@tonic-gate # include <sys/stream.h> 338ab25eeb5Syz # ifdef USE_INET6 339ab25eeb5Syz # include <netinet/if_ether.h> 340ab25eeb5Syz # include <netinet/ip6.h> 341ab25eeb5Syz # include <netinet/icmp6.h> 342ab25eeb5Syz typedef struct ip6_hdr ip6_t; 343ab25eeb5Syz # endif 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate # ifdef _KERNEL 346ab25eeb5Syz # define SNPRINTF sprintf 347ab25eeb5Syz # if (HPUXREV >= 1111) 348ab25eeb5Syz # define IPL_SELECT 349ab25eeb5Syz # ifdef IPL_SELECT 350ab25eeb5Syz # include <machine/sys/user.h> 351ab25eeb5Syz # include <sys/kthread_iface.h> 352ab25eeb5Syz # define READ_COLLISION 0x01 353ab25eeb5Syz 354ab25eeb5Syz typedef struct iplog_select_s { 355ab25eeb5Syz kthread_t *read_waiter; 356ab25eeb5Syz int state; 357ab25eeb5Syz } iplog_select_t; 358ab25eeb5Syz # endif 359ab25eeb5Syz # endif 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate # define GETKTIME(x) uniqtime((struct timeval *)x) 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate # if HPUXREV == 1111 3647c478bd9Sstevel@tonic-gate # include "kern_svcs.h" 3657c478bd9Sstevel@tonic-gate # else 3667c478bd9Sstevel@tonic-gate # include <sys/kern_svcs.h> 3677c478bd9Sstevel@tonic-gate # endif 3687c478bd9Sstevel@tonic-gate # undef ti_flags 3697c478bd9Sstevel@tonic-gate # undef TCP_NODELAY 3707c478bd9Sstevel@tonic-gate # undef TCP_MAXSEG 3717c478bd9Sstevel@tonic-gate # include <sys/reg.h> 3727c478bd9Sstevel@tonic-gate # include "../netinet/ip_info.h" 3737c478bd9Sstevel@tonic-gate /* 3747c478bd9Sstevel@tonic-gate * According to /usr/include/sys/spinlock.h on HP-UX 11.00, these functions 3757c478bd9Sstevel@tonic-gate * are available. Attempting to use them actually results in unresolved 3767c478bd9Sstevel@tonic-gate * symbols when it comes time to load the module. 377ab25eeb5Syz * This has been fixed! Yipee! 3787c478bd9Sstevel@tonic-gate */ 379ab25eeb5Syz # if 1 3807c478bd9Sstevel@tonic-gate # ifdef __LP64__ 381ab25eeb5Syz # define ATOMIC_INCL(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), 1) 382ab25eeb5Syz # define ATOMIC_DECL(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), -1) 3837c478bd9Sstevel@tonic-gate # else 384ab25eeb5Syz # define ATOMIC_INCL(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), 1) 385ab25eeb5Syz # define ATOMIC_DECL(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), -1) 3867c478bd9Sstevel@tonic-gate # endif 387ab25eeb5Syz # define ATOMIC_INC64(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), 1) 388ab25eeb5Syz # define ATOMIC_INC32(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), 1) 389ab25eeb5Syz # define ATOMIC_INC16(x) lock_and_incr_int16(&ipf_rw.ipf_lk, &(x), 1) 390ab25eeb5Syz # define ATOMIC_DEC64(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), -1) 391ab25eeb5Syz # define ATOMIC_DEC32(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), -1) 392ab25eeb5Syz # define ATOMIC_DEC16(x) lock_and_incr_int16(&ipf_rw.ipf_lk, &(x), -1) 3937c478bd9Sstevel@tonic-gate # else /* 0 */ 394ab25eeb5Syz # define ATOMIC_INC64(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 395ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 396ab25eeb5Syz # define ATOMIC_DEC64(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 397ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 398ab25eeb5Syz # define ATOMIC_INC32(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 399ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 400ab25eeb5Syz # define ATOMIC_DEC32(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 401ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 402ab25eeb5Syz # define ATOMIC_INCL(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 403ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 404ab25eeb5Syz # define ATOMIC_DECL(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 405ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 406ab25eeb5Syz # define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 407ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 408ab25eeb5Syz # define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 409ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 4107c478bd9Sstevel@tonic-gate # endif 4117c478bd9Sstevel@tonic-gate # define ip_cksum ip_csuma 4127c478bd9Sstevel@tonic-gate # define memcpy(a,b,c) bcopy((caddr_t)b, (caddr_t)a, c) 4137c478bd9Sstevel@tonic-gate # define USE_MUTEXES 4147c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x, y) initlock(&(x)->ipf_lk, 0, 0, (y)) 4157c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) spinlock(&(x)->ipf_lk) 416ab25eeb5Syz # define MUTEX_EXIT(x) spinunlock(&(x)->ipf_lk); 4177c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) 418ab25eeb5Syz # define MUTEX_NUKE(x) bzero((char *)(x), sizeof(*(x))) 419ab25eeb5Syz # define KMUTEX_T lock_t 420ab25eeb5Syz # define kmutex_t lock_t /* for pfil.h */ 421ab25eeb5Syz # define krwlock_t lock_t /* for pfil.h */ 4227c478bd9Sstevel@tonic-gate /* 4237c478bd9Sstevel@tonic-gate * The read-write lock implementation in HP-UX 11.0 is crippled - it can 4247c478bd9Sstevel@tonic-gate * only be used by threads working in a user context! 425ab25eeb5Syz * This has been fixed! Yipee! (Or at least it does in 11.00, not 11.11..) 4267c478bd9Sstevel@tonic-gate */ 427ab25eeb5Syz # if HPUXREV < 1111 4287c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) lock_write_to_read(x) 429ab25eeb5Syz # define KRWLOCK_T struct rw_lock 4307c478bd9Sstevel@tonic-gate # define READ_ENTER(x) lock_read(&(x)->ipf_lk) 4317c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) lock_write(&(x)->ipf_lk) 432ab25eeb5Syz # if HPUXREV >= 1111 433ab25eeb5Syz # define RWLOCK_INIT(x, y) rwlock_init4(&(x)->ipf_lk, 0, RWLCK_CANSLEEP, 0, y) 434ab25eeb5Syz # else 435ab25eeb5Syz # define RWLOCK_INIT(x, y) lock_init3(&(x)->ipf_lk, 0, 1, 0, 0, y) 436ab25eeb5Syz # endif 4377c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) lock_done(&(x)->ipf_lk) 4387c478bd9Sstevel@tonic-gate # else 4397c478bd9Sstevel@tonic-gate # define KRWLOCK_T lock_t 4407c478bd9Sstevel@tonic-gate # define KMUTEX_T lock_t 441ab25eeb5Syz # define READ_ENTER(x) MUTEX_ENTER(x) 442ab25eeb5Syz # define WRITE_ENTER(x) MUTEX_ENTER(x) 4437c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) 4447c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) initlock(&(x)->ipf_lk, 0, 0, y) 445ab25eeb5Syz # define RWLOCK_EXIT(x) MUTEX_EXIT(x) 4467c478bd9Sstevel@tonic-gate # endif 4477c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) 4487c478bd9Sstevel@tonic-gate # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 4497c478bd9Sstevel@tonic-gate # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 450ab25eeb5Syz # if HPUXREV >= 1111 451ab25eeb5Syz # define BCOPYIN(a,b,c) 0; bcopy((caddr_t)(a), (caddr_t)(b), (c)) 452ab25eeb5Syz # define BCOPYOUT(a,b,c) 0; bcopy((caddr_t)(a), (caddr_t)(b), (c)) 4537c478bd9Sstevel@tonic-gate # else 4547c478bd9Sstevel@tonic-gate # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 4557c478bd9Sstevel@tonic-gate # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 4567c478bd9Sstevel@tonic-gate # endif 4577c478bd9Sstevel@tonic-gate # define SPL_NET(x) ; 4587c478bd9Sstevel@tonic-gate # define SPL_IMP(x) ; 4597c478bd9Sstevel@tonic-gate # undef SPL_X 4607c478bd9Sstevel@tonic-gate # define SPL_X(x) ; 461f4b3ec61Sdh /*extern void *get_unit __P((char *, int, ipf_stack_t *));*/ 462f4b3ec61Sdh # define GETIFP(n, v, ifs) get_unit(n, v, ifs) 463ab25eeb5Syz # define IFNAME(x, b) ((ill_t *)x)->ill_name 464381a2a9aSdr # define COPYIFNAME(x, b, v) \ 465381a2a9aSdr strncpy(b, ((ifinfo_t *)x)->ifi_name, \ 466381a2a9aSdr LIFNAMSIZ) 4677c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 4687c478bd9Sstevel@tonic-gate # define SLEEP(id, n) { lock_t *_l = get_sleep_lock((caddr_t)id); \ 4697c478bd9Sstevel@tonic-gate sleep(id, PZERO+1); \ 4707c478bd9Sstevel@tonic-gate spinunlock(_l); \ 4717c478bd9Sstevel@tonic-gate } 472ab25eeb5Syz # define WAKEUP(id,x) { lock_t *_l = get_sleep_lock((caddr_t)id); \ 473ab25eeb5Syz wakeup(id + x); \ 4747c478bd9Sstevel@tonic-gate spinunlock(_l); \ 4757c478bd9Sstevel@tonic-gate } 4767c478bd9Sstevel@tonic-gate # define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_IOSYS, M_NOWAIT) 4777c478bd9Sstevel@tonic-gate # define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_IOSYS, M_NOWAIT) 4787c478bd9Sstevel@tonic-gate # define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 4797c478bd9Sstevel@tonic-gate # define KFREES(x,s) kmem_free((char *)(x), (s)) 4807c478bd9Sstevel@tonic-gate # define MSGDSIZE(x) msgdsize(x) 4817c478bd9Sstevel@tonic-gate # define M_LEN(x) ((x)->b_wptr - (x)->b_rptr) 4827c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) dupmsg((x)) 483ab25eeb5Syz # define MTOD(m,t) ((t)((m)->b_rptr)) 4847c478bd9Sstevel@tonic-gate # define MTYPE(m) ((m)->b_datap->db_type) 4857c478bd9Sstevel@tonic-gate # define FREE_MB_T(m) freemsg(m) 486ab25eeb5Syz # define m_next b_cont 4877c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 4887c478bd9Sstevel@tonic-gate typedef mblk_t mb_t; 4897c478bd9Sstevel@tonic-gate 490381a2a9aSdr # define CACHE_HASH(x) (((phy_if_t)(x)->fin_ifp) & 7) 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate # include "qif.h" 493ab25eeb5Syz # include "pfil.h" 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate # else /* _KERNEL */ 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate typedef unsigned char uchar_t; 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate # ifndef _SYS_STREAM_INCLUDED 5007c478bd9Sstevel@tonic-gate typedef char * mblk_t; 5017c478bd9Sstevel@tonic-gate typedef void * queue_t; 5027c478bd9Sstevel@tonic-gate typedef u_long ulong; 5037c478bd9Sstevel@tonic-gate # endif 5047c478bd9Sstevel@tonic-gate # include <netinet/ip_info.h> 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate # ifdef lint 5097c478bd9Sstevel@tonic-gate # define ALIGN32(ptr) (ptr ? 0L : 0L) 5107c478bd9Sstevel@tonic-gate # define ALIGN16(ptr) (ptr ? 0L : 0L) 5117c478bd9Sstevel@tonic-gate # else 5127c478bd9Sstevel@tonic-gate # define ALIGN32(ptr) (ptr) 5137c478bd9Sstevel@tonic-gate # define ALIGN16(ptr) (ptr) 5147c478bd9Sstevel@tonic-gate # endif 5157c478bd9Sstevel@tonic-gate 516ab25eeb5Syz typedef struct uio uio_t; 517ab25eeb5Syz typedef int ioctlcmd_t; 5187c478bd9Sstevel@tonic-gate typedef int minor_t; 5197c478bd9Sstevel@tonic-gate typedef unsigned int u_32_t; 5207c478bd9Sstevel@tonic-gate # define U_32_T 1 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate #endif /* __hpux */ 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 5277c478bd9Sstevel@tonic-gate /* I R I X */ 5287c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 5297c478bd9Sstevel@tonic-gate #ifdef __sgi 5307c478bd9Sstevel@tonic-gate # undef MENTAT 531ab25eeb5Syz # if IRIX < 60500 532ab25eeb5Syz typedef struct uio uio_t; 533ab25eeb5Syz # endif 534ab25eeb5Syz typedef int ioctlcmd_t; 5357c478bd9Sstevel@tonic-gate typedef u_int32_t u_32_t; 5367c478bd9Sstevel@tonic-gate # define U_32_T 1 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate # ifdef INET6 5397c478bd9Sstevel@tonic-gate # define USE_INET6 5407c478bd9Sstevel@tonic-gate # endif 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate # define hz HZ 5437c478bd9Sstevel@tonic-gate # include <sys/ksynch.h> 5447c478bd9Sstevel@tonic-gate # define IPF_LOCK_PL plhi 5457c478bd9Sstevel@tonic-gate # include <sys/sema.h> 5467c478bd9Sstevel@tonic-gate # undef kmutex_t 5477c478bd9Sstevel@tonic-gate typedef struct { 5487c478bd9Sstevel@tonic-gate lock_t *l; 5497c478bd9Sstevel@tonic-gate int pl; 5507c478bd9Sstevel@tonic-gate } kmutex_t; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate # ifdef MUTEX_INIT 5537c478bd9Sstevel@tonic-gate # define KMUTEX_T mutex_t 5547c478bd9Sstevel@tonic-gate # else 5557c478bd9Sstevel@tonic-gate # define KMUTEX_T kmutex_t 5567c478bd9Sstevel@tonic-gate # define KRWLOCK_T kmutex_t 5577c478bd9Sstevel@tonic-gate # endif 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate # ifdef _KERNEL 560ab073b32Sdr # define NEED_LOCAL_RAND 1 561ab073b32Sdr # define ipf_random arc4random 5627c478bd9Sstevel@tonic-gate # define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); \ 5637c478bd9Sstevel@tonic-gate (x)++; MUTEX_EXIT(&ipf_rw); } 5647c478bd9Sstevel@tonic-gate # define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); \ 5657c478bd9Sstevel@tonic-gate (x)--; MUTEX_EXIT(&ipf_rw); } 5667c478bd9Sstevel@tonic-gate # define USE_MUTEXES 5677c478bd9Sstevel@tonic-gate # ifdef MUTEX_INIT 5687c478bd9Sstevel@tonic-gate # include <sys/atomic_ops.h> 5697c478bd9Sstevel@tonic-gate # define ATOMIC_INCL(x) atomicAddUlong(&(x), 1) 5707c478bd9Sstevel@tonic-gate # define ATOMIC_INC64(x) atomicAddUint64(&(x), 1) 5717c478bd9Sstevel@tonic-gate # define ATOMIC_INC32(x) atomicAddUint(&(x), 1) 5727c478bd9Sstevel@tonic-gate # define ATOMIC_INC16 ATOMIC_INC 5737c478bd9Sstevel@tonic-gate # define ATOMIC_DECL(x) atomicAddUlong(&(x), -1) 5747c478bd9Sstevel@tonic-gate # define ATOMIC_DEC64(x) atomicAddUint64(&(x), -1) 5757c478bd9Sstevel@tonic-gate # define ATOMIC_DEC32(x) atomicAddUint(&(x), -1) 5767c478bd9Sstevel@tonic-gate # define ATOMIC_DEC16 ATOMIC_DEC 5777c478bd9Sstevel@tonic-gate # undef MUTEX_INIT 578ab25eeb5Syz # define MUTEX_INIT(x, y) mutex_init(&(x)->ipf_lk, \ 5797c478bd9Sstevel@tonic-gate MUTEX_DEFAULT, y) 5807c478bd9Sstevel@tonic-gate # undef MUTEX_ENTER 5817c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) mutex_lock(&(x)->ipf_lk, 0) 5827c478bd9Sstevel@tonic-gate # undef MUTEX_EXIT 5837c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) mutex_unlock(&(x)->ipf_lk) 5847c478bd9Sstevel@tonic-gate # undef MUTEX_DESTROY 5857c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) mutex_destroy(&(x)->ipf_lk) 5867c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) mrdemote(&(x)->ipf_lk) 5877c478bd9Sstevel@tonic-gate # define KRWLOCK_T mrlock_t 5887c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) mrinit(&(x)->ipf_lk, y) 5897c478bd9Sstevel@tonic-gate # undef RW_DESTROY 5907c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) mrfree(&(x)->ipf_lk) 5917c478bd9Sstevel@tonic-gate # define READ_ENTER(x) RW_RDLOCK(&(x)->ipf_lk) 5927c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) RW_WRLOCK(&(x)->ipf_lk) 5937c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) RW_UNLOCK(&(x)->ipf_lk) 5947c478bd9Sstevel@tonic-gate # else 5957c478bd9Sstevel@tonic-gate # define READ_ENTER(x) MUTEX_ENTER(&(x)->ipf_lk) 5967c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) MUTEX_ENTER(&(x)->ipf_lk) 5977c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) ; 5987c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) MUTEX_EXIT(&(x)->ipf_lk) 5997c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) UNLOCK((x)->ipf_lk.l, (x)->ipf_lk.pl); 6007c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x,y) (x)->ipf_lk.l = LOCK_ALLOC((uchar_t)-1, IPF_LOCK_PL, (lkinfo_t *)-1, KM_NOSLEEP) 6017c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) LOCK_DEALLOC((x)->ipf_lk.l) 6027c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) (x)->ipf_lk.pl = LOCK((x)->ipf_lk.l, \ 6037c478bd9Sstevel@tonic-gate IPF_LOCK_PL); 6047c478bd9Sstevel@tonic-gate # endif 6057c478bd9Sstevel@tonic-gate # define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 6067c478bd9Sstevel@tonic-gate # define FREE_MB_T(m) m_freem(m) 6077c478bd9Sstevel@tonic-gate # define MTOD(m,t) mtod(m,t) 6087c478bd9Sstevel@tonic-gate # define COPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 6097c478bd9Sstevel@tonic-gate # define COPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 6107c478bd9Sstevel@tonic-gate # define BCOPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 6117c478bd9Sstevel@tonic-gate # define BCOPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 6127c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 6137c478bd9Sstevel@tonic-gate # define SLEEP(id, n) sleep((id), PZERO+1) 614ab25eeb5Syz # define WAKEUP(id,x) wakeup(id+x) 6157c478bd9Sstevel@tonic-gate # define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 6167c478bd9Sstevel@tonic-gate # define KFREES(x,s) kmem_free((char *)(x), (s)) 617f4b3ec61Sdh # define GETIFP(n,v, ifs) ifunit(n) 6187c478bd9Sstevel@tonic-gate # include <sys/kmem.h> 6197c478bd9Sstevel@tonic-gate # include <sys/ddi.h> 6207c478bd9Sstevel@tonic-gate # define KMALLOC(a,b) (a) = (b)kmem_alloc(sizeof(*(a)), KM_NOSLEEP) 6217c478bd9Sstevel@tonic-gate # define KMALLOCS(a,b,c) (a) = (b)kmem_alloc((c), KM_NOSLEEP) 6227c478bd9Sstevel@tonic-gate # define GET_MINOR(x) getminor(x) 623ab25eeb5Syz # define USE_SPL 1 6247c478bd9Sstevel@tonic-gate # define SPL_IMP(x) (x) = splimp() 6257c478bd9Sstevel@tonic-gate # define SPL_NET(x) (x) = splnet() 6267c478bd9Sstevel@tonic-gate # define SPL_X(x) (void) splx(x) 6277c478bd9Sstevel@tonic-gate extern void m_copydata __P((struct mbuf *, int, int, caddr_t)); 6287c478bd9Sstevel@tonic-gate extern void m_copyback __P((struct mbuf *, int, int, caddr_t)); 6297c478bd9Sstevel@tonic-gate # define MSGDSIZE(x) mbufchainlen(x) 6307c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 6317c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 6327c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 6337c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 6347c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 6357c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 6367c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 637ab25eeb5Syz # else 638ab25eeb5Syz # undef RW_DESTROY 639ab25eeb5Syz # undef MUTEX_INIT 640ab25eeb5Syz # undef MUTEX_DESTROY 6417c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate #endif /* __sgi */ 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 6487c478bd9Sstevel@tonic-gate /* T R U 6 4 */ 6497c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 6507c478bd9Sstevel@tonic-gate #ifdef __osf__ 6517c478bd9Sstevel@tonic-gate # undef MENTAT 6527c478bd9Sstevel@tonic-gate 6537c478bd9Sstevel@tonic-gate # include <kern/lock.h> 6547c478bd9Sstevel@tonic-gate # include <sys/sysmacros.h> 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate # ifdef _KERNEL 657ab073b32Sdr # define NEED_LOCAL_RAND 1 658ab073b32Sdr # define ipf_random arc4random 6597c478bd9Sstevel@tonic-gate # define KMUTEX_T simple_lock_data_t 6607c478bd9Sstevel@tonic-gate # define KRWLOCK_T lock_data_t 6617c478bd9Sstevel@tonic-gate # include <net/net_globals.h> 6627c478bd9Sstevel@tonic-gate # define USE_MUTEXES 6637c478bd9Sstevel@tonic-gate # define READ_ENTER(x) lock_read(&(x)->ipf_lk) 6647c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) lock_write(&(x)->ipf_lk) 6657c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) lock_write_to_read(&(x)->ipf_lk) 6667c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) lock_init(&(x)->ipf_lk, TRUE) 6677c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) lock_done(&(x)->ipf_lk) 6687c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) lock_terminate(&(x)->ipf_lk) 6697c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) simple_lock(&(x)->ipf_lk) 6707c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x, y) simple_lock_init(&(x)->ipf_lk) 6717c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) simple_lock_terminate(&(x)->ipf_lk) 6727c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) simple_unlock(&(x)->ipf_lk) 6737c478bd9Sstevel@tonic-gate # define MUTEX_NUKE(x) bzero(x, sizeof(*(x))) 6747c478bd9Sstevel@tonic-gate # define ATOMIC_INC64(x) atomic_incq((uint64_t*)&(x)) 6757c478bd9Sstevel@tonic-gate # define ATOMIC_DEC64(x) atomic_decq((uint64_t*)&(x)) 6767c478bd9Sstevel@tonic-gate # define ATOMIC_INC32(x) atomic_incl((uint32_t*)&(x)) 6777c478bd9Sstevel@tonic-gate # define ATOMIC_DEC32(x) atomic_decl((uint32_t*)&(x)) 6787c478bd9Sstevel@tonic-gate # define ATOMIC_INC16(x) { simple_lock(&ipf_rw); (x)++; \ 6797c478bd9Sstevel@tonic-gate simple_unlock(&ipf_rw); } 6807c478bd9Sstevel@tonic-gate # define ATOMIC_DEC16(x) { simple_lock(&ipf_rw); (x)--; \ 6817c478bd9Sstevel@tonic-gate simple_unlock(&ipf_rw); } 6827c478bd9Sstevel@tonic-gate # define ATOMIC_INCL(x) atomic_incl((uint32_t*)&(x)) 6837c478bd9Sstevel@tonic-gate # define ATOMIC_DECL(x) atomic_decl((uint32_t*)&(x)) 6847c478bd9Sstevel@tonic-gate # define ATOMIC_INC(x) { simple_lock(&ipf_rw); (x)++; \ 6857c478bd9Sstevel@tonic-gate simple_unlock(&ipf_rw); } 6867c478bd9Sstevel@tonic-gate # define ATOMIC_DEC(x) { simple_lock(&ipf_rw); (x)--; \ 6877c478bd9Sstevel@tonic-gate simple_unlock(&ipf_rw); } 6887c478bd9Sstevel@tonic-gate # define SPL_NET(x) ; 6897c478bd9Sstevel@tonic-gate # define SPL_IMP(x) ; 6907c478bd9Sstevel@tonic-gate # undef SPL_X 6917c478bd9Sstevel@tonic-gate # define SPL_X(x) ; 6927c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a, b, d) 6937c478bd9Sstevel@tonic-gate # define FREE_MB_T(m) m_freem(m) 6947c478bd9Sstevel@tonic-gate # define MTOD(m,t) mtod(m,t) 695f4b3ec61Sdh # define GETIFP(n, v, ifs) ifunit(n) 6967c478bd9Sstevel@tonic-gate # define GET_MINOR getminor 697ab25eeb5Syz # define WAKEUP(id,x) wakeup(id + x) 6987c478bd9Sstevel@tonic-gate # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 6997c478bd9Sstevel@tonic-gate # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 7007c478bd9Sstevel@tonic-gate # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 7017c478bd9Sstevel@tonic-gate # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 7027c478bd9Sstevel@tonic-gate # define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_PFILT, M_NOWAIT) 703ab25eeb5Syz # define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_PFILT, \ 704ab25eeb5Syz ((c) > 4096) ? M_WAITOK : M_NOWAIT) 7057c478bd9Sstevel@tonic-gate # define KFREE(x) FREE((x), M_PFILT) 7067c478bd9Sstevel@tonic-gate # define KFREES(x,s) FREE((x), M_PFILT) 707ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 7087c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 7097c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 7107c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 7117c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 7127c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 7137c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 7147c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 7157c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate # if (defined(_KERNEL) || defined(_NO_BITFIELDS) || (__STDC__ == 1)) 7187c478bd9Sstevel@tonic-gate # define IP_V(x) ((x)->ip_vhl >> 4) 7197c478bd9Sstevel@tonic-gate # define IP_HL(x) ((x)->ip_vhl & 0xf) 7207c478bd9Sstevel@tonic-gate # define IP_V_A(x,y) (x)->ip_vhl |= (((y) << 4) & 0xf0) 7217c478bd9Sstevel@tonic-gate # define IP_HL_A(x,y) (x)->ip_vhl |= ((y) & 0xf) 722ab25eeb5Syz # define TCP_X2(x) ((x)->th_xoff & 0xf) 723ab25eeb5Syz # define TCP_X2_A(x,y) (x)->th_xoff |= ((y) & 0xf) 7247c478bd9Sstevel@tonic-gate # define TCP_OFF(x) ((x)->th_xoff >> 4) 725ab25eeb5Syz # define TCP_OFF_A(x,y) (x)->th_xoff |= (((y) << 4) & 0xf0) 7267c478bd9Sstevel@tonic-gate # endif 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate /* 7297c478bd9Sstevel@tonic-gate * These are from's Solaris' #defines for little endian. 7307c478bd9Sstevel@tonic-gate */ 7317c478bd9Sstevel@tonic-gate #define IP6F_MORE_FRAG 0x0100 7327c478bd9Sstevel@tonic-gate #define IP6F_RESERVED_MASK 0x0600 7337c478bd9Sstevel@tonic-gate #define IP6F_OFF_MASK 0xf8ff 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate struct ip6_ext { 7367c478bd9Sstevel@tonic-gate u_char ip6e_nxt; 7377c478bd9Sstevel@tonic-gate u_char ip6e_len; 7387c478bd9Sstevel@tonic-gate }; 7397c478bd9Sstevel@tonic-gate 740ab25eeb5Syz typedef int ioctlcmd_t; 741ab25eeb5Syz /* 742ab25eeb5Syz * Really, any arch where sizeof(long) != sizeof(int). 743ab25eeb5Syz */ 744ab25eeb5Syz typedef unsigned int u_32_t; 745ab25eeb5Syz # define U_32_T 1 746ab25eeb5Syz 7477c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 7487c478bd9Sstevel@tonic-gate #endif /* __osf__ */ 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 7517c478bd9Sstevel@tonic-gate /* N E T B S D */ 7527c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 7537c478bd9Sstevel@tonic-gate #ifdef __NetBSD__ 7547c478bd9Sstevel@tonic-gate # if defined(_KERNEL) && !defined(IPFILTER_LKM) 755ab25eeb5Syz # include "bpfilter.h" 7567c478bd9Sstevel@tonic-gate # if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 104110000) 7577c478bd9Sstevel@tonic-gate # include "opt_inet.h" 7587c478bd9Sstevel@tonic-gate # endif 7597c478bd9Sstevel@tonic-gate # ifdef INET6 7607c478bd9Sstevel@tonic-gate # define USE_INET6 7617c478bd9Sstevel@tonic-gate # endif 762ab25eeb5Syz # if (__NetBSD_Version__ >= 105000000) 763ab25eeb5Syz # define HAVE_M_PULLDOWN 1 764ab25eeb5Syz # endif 7657c478bd9Sstevel@tonic-gate # endif 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate # ifdef _KERNEL 768ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 7697c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 7707c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 7717c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 7727c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 773ab25eeb5Syz # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 774ab25eeb5Syz # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 775ab25eeb5Syz # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 776ab25eeb5Syz # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 7777c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 7787c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 7797c478bd9Sstevel@tonic-gate # if (NetBSD <= 1991011) && (NetBSD >= 199606) 7807c478bd9Sstevel@tonic-gate # define IFNAME(x) ((struct ifnet *)x)->if_xname 781381a2a9aSdr # define COPYIFNAME(x, b, v) \ 782ab25eeb5Syz (void) strncpy(b, \ 783ab25eeb5Syz ((struct ifnet *)x)->if_xname, \ 784ab25eeb5Syz LIFNAMSIZ) 7857c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index)&7) 7867c478bd9Sstevel@tonic-gate # else 7877c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 7887c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 7897c478bd9Sstevel@tonic-gate # endif 7907c478bd9Sstevel@tonic-gate 791ab25eeb5Syz typedef struct uio uio_t; 792ab25eeb5Syz typedef u_long ioctlcmd_t; 7937c478bd9Sstevel@tonic-gate typedef int minor_t; 7947c478bd9Sstevel@tonic-gate typedef u_int32_t u_32_t; 7957c478bd9Sstevel@tonic-gate # define U_32_T 1 7967c478bd9Sstevel@tonic-gate 7977c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 7987c478bd9Sstevel@tonic-gate #endif /* __NetBSD__ */ 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 8027c478bd9Sstevel@tonic-gate /* F R E E B S D */ 8037c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 8047c478bd9Sstevel@tonic-gate #ifdef __FreeBSD__ 805ab25eeb5Syz # if defined(_KERNEL) 806ab25eeb5Syz # if (__FreeBSD_version >= 500000) 807ab25eeb5Syz # include "opt_bpf.h" 808ab25eeb5Syz # else 809ab25eeb5Syz # include "bpf.h" 810ab25eeb5Syz # endif 8117c478bd9Sstevel@tonic-gate # if defined(__FreeBSD_version) && (__FreeBSD_version >= 400000) 8127c478bd9Sstevel@tonic-gate # include "opt_inet6.h" 8137c478bd9Sstevel@tonic-gate # endif 814ab25eeb5Syz # if defined(INET6) && !defined(USE_INET6) 8157c478bd9Sstevel@tonic-gate # define USE_INET6 8167c478bd9Sstevel@tonic-gate # endif 8177c478bd9Sstevel@tonic-gate # endif 8187c478bd9Sstevel@tonic-gate 819ab25eeb5Syz # if defined(_KERNEL) 820ab25eeb5Syz # if (__FreeBSD_version >= 400000) 821ab25eeb5Syz /* 822ab25eeb5Syz * When #define'd, the 5.2.1 kernel panics when used with the ftp proxy. 823ab25eeb5Syz * There may be other, safe, kernels but this is not extensively tested yet. 824ab25eeb5Syz */ 825ab25eeb5Syz # define HAVE_M_PULLDOWN 826ab25eeb5Syz # endif 827ab25eeb5Syz # if !defined(IPFILTER_LKM) && (__FreeBSD_version >= 300000) 828ab25eeb5Syz # include "opt_ipfilter.h" 829ab25eeb5Syz # endif 830ab25eeb5Syz # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 831ab25eeb5Syz # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 832ab25eeb5Syz # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 833ab25eeb5Syz # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 834ab25eeb5Syz 8357c478bd9Sstevel@tonic-gate # if (__FreeBSD_version >= 500043) 8367c478bd9Sstevel@tonic-gate # define NETBSD_PF 837ab25eeb5Syz # endif 8387c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate # if (__FreeBSD_version >= 500043) 8417c478bd9Sstevel@tonic-gate # include <sys/mutex.h> 842ab25eeb5Syz # include <sys/sx.h> 843ab25eeb5Syz /* 844ab25eeb5Syz * Whilst the sx(9) locks on FreeBSD have the right semantics and interface 845ab25eeb5Syz * for what we want to use them for, despite testing showing they work - 846ab25eeb5Syz * with a WITNESS kernel, it generates LOR messages. 847ab25eeb5Syz */ 8487c478bd9Sstevel@tonic-gate # define KMUTEX_T struct mtx 849ab25eeb5Syz # if 1 850ab25eeb5Syz # define KRWLOCK_T struct mtx 851ab25eeb5Syz # else 852ab25eeb5Syz # define KRWLOCK_T struct sx 853ab25eeb5Syz # endif 854ab25eeb5Syz # endif 855ab25eeb5Syz 856ab25eeb5Syz # if (__FreeBSD_version >= 501113) 857ab25eeb5Syz # include <net/if_var.h> 858ab25eeb5Syz # define IFNAME(x) ((struct ifnet *)x)->if_xname 859ab25eeb5Syz # define COPYIFNAME(x, b) \ 860ab25eeb5Syz (void) strncpy(b, \ 861ab25eeb5Syz ((struct ifnet *)x)->if_xname, \ 862ab25eeb5Syz LIFNAMSIZ) 863ab25eeb5Syz # endif 864ab25eeb5Syz # if (__FreeBSD_version >= 500043) 865ab25eeb5Syz # define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index) & 7) 866ab25eeb5Syz # else 867ab25eeb5Syz # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 868ab25eeb5Syz ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 8697c478bd9Sstevel@tonic-gate # endif 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate # ifdef _KERNEL 8727c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 8737c478bd9Sstevel@tonic-gate 8747c478bd9Sstevel@tonic-gate # if (__FreeBSD_version >= 500002) 8757c478bd9Sstevel@tonic-gate # include <netinet/in_systm.h> 8767c478bd9Sstevel@tonic-gate # include <netinet/ip.h> 8777c478bd9Sstevel@tonic-gate # include <machine/in_cksum.h> 8787c478bd9Sstevel@tonic-gate # endif 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate # if (__FreeBSD_version >= 500043) 8817c478bd9Sstevel@tonic-gate # define USE_MUTEXES 8827c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) mtx_lock(&(x)->ipf_lk) 8837c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) mtx_unlock(&(x)->ipf_lk) 8847c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x,y) mtx_init(&(x)->ipf_lk, (y), NULL,\ 8857c478bd9Sstevel@tonic-gate MTX_DEF) 8867c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) mtx_destroy(&(x)->ipf_lk) 887ab25eeb5Syz # define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 888ab25eeb5Syz /* 889ab25eeb5Syz * Whilst the sx(9) locks on FreeBSD have the right semantics and interface 890ab25eeb5Syz * for what we want to use them for, despite testing showing they work - 891ab25eeb5Syz * with a WITNESS kernel, it generates LOR messages. 892ab25eeb5Syz */ 893ab25eeb5Syz # if 1 894ab25eeb5Syz # define READ_ENTER(x) mtx_lock(&(x)->ipf_lk) 895ab25eeb5Syz # define WRITE_ENTER(x) mtx_lock(&(x)->ipf_lk) 896ab25eeb5Syz # define RWLOCK_EXIT(x) mtx_unlock(&(x)->ipf_lk) 897ab25eeb5Syz # define MUTEX_DOWNGRADE(x) ; 898ab25eeb5Syz # define RWLOCK_INIT(x,y) mtx_init(&(x)->ipf_lk, (y), NULL,\ 899ab25eeb5Syz MTX_DEF) 900ab25eeb5Syz # define RW_DESTROY(x) mtx_destroy(&(x)->ipf_lk) 901ab25eeb5Syz # else 902ab25eeb5Syz # define READ_ENTER(x) sx_slock(&(x)->ipf_lk) 903ab25eeb5Syz # define WRITE_ENTER(x) sx_xlock(&(x)->ipf_lk) 904ab25eeb5Syz # define MUTEX_DOWNGRADE(x) sx_downgrade(&(x)->ipf_lk) 905ab25eeb5Syz # define RWLOCK_INIT(x, y) sx_init(&(x)->ipf_lk, (y)) 906ab25eeb5Syz # define RW_DESTROY(x) sx_destroy(&(x)->ipf_lk) 907ab25eeb5Syz # ifdef sx_unlock 908ab25eeb5Syz # define RWLOCK_EXIT(x) sx_unlock(x) 909ab25eeb5Syz # else 910ab25eeb5Syz # define RWLOCK_EXIT(x) do { \ 911ab25eeb5Syz if ((x)->ipf_lk.sx_cnt < 0) \ 912ab25eeb5Syz sx_xunlock(&(x)->ipf_lk); \ 913ab25eeb5Syz else \ 914ab25eeb5Syz sx_sunlock(&(x)->ipf_lk); \ 915ab25eeb5Syz } while (0) 916ab25eeb5Syz # endif 917ab25eeb5Syz # endif 9187c478bd9Sstevel@tonic-gate # include <machine/atomic.h> 9197c478bd9Sstevel@tonic-gate # define ATOMIC_INC(x) { mtx_lock(&ipf_rw.ipf_lk); (x)++; \ 9207c478bd9Sstevel@tonic-gate mtx_unlock(&ipf_rw.ipf_lk); } 9217c478bd9Sstevel@tonic-gate # define ATOMIC_DEC(x) { mtx_lock(&ipf_rw.ipf_lk); (x)--; \ 9227c478bd9Sstevel@tonic-gate mtx_unlock(&ipf_rw.ipf_lk); } 923ab25eeb5Syz # define ATOMIC_INCL(x) atomic_add_long(&(x), 1) 924ab25eeb5Syz # define ATOMIC_INC64(x) ATOMIC_INC(x) 925ab25eeb5Syz # define ATOMIC_INC32(x) atomic_add_32(&(x), 1) 926ab25eeb5Syz # define ATOMIC_INC16(x) atomic_add_16(&(x), 1) 927ab25eeb5Syz # define ATOMIC_DECL(x) atomic_add_long(&(x), -1) 928ab25eeb5Syz # define ATOMIC_DEC64(x) ATOMIC_DEC(x) 929ab25eeb5Syz # define ATOMIC_DEC32(x) atomic_add_32(&(x), -1) 930ab25eeb5Syz # define ATOMIC_DEC16(x) atomic_add_16(&(x), -1) 9317c478bd9Sstevel@tonic-gate # define SPL_X(x) ; 9327c478bd9Sstevel@tonic-gate # define SPL_NET(x) ; 9337c478bd9Sstevel@tonic-gate # define SPL_IMP(x) ; 9347c478bd9Sstevel@tonic-gate extern int in_cksum __P((struct mbuf *, int)); 9357c478bd9Sstevel@tonic-gate # endif /* __FreeBSD_version >= 500043 */ 936ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 9377c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 9387c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 9397c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 9407c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 9417c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate # if __FreeBSD__ < 3 9447c478bd9Sstevel@tonic-gate # include <machine/spl.h> 9457c478bd9Sstevel@tonic-gate # else 9467c478bd9Sstevel@tonic-gate # if __FreeBSD__ == 3 9477c478bd9Sstevel@tonic-gate # if defined(IPFILTER_LKM) && !defined(ACTUALLY_LKM_NOT_KERNEL) 9487c478bd9Sstevel@tonic-gate # define ACTUALLY_LKM_NOT_KERNEL 9497c478bd9Sstevel@tonic-gate # endif 9507c478bd9Sstevel@tonic-gate # endif 9517c478bd9Sstevel@tonic-gate # endif 9527c478bd9Sstevel@tonic-gate 953ab25eeb5Syz # if (__FreeBSD_version >= 300000) 954ab25eeb5Syz typedef u_long ioctlcmd_t; 955ab25eeb5Syz # else 956ab25eeb5Syz typedef int ioctlcmd_t; 957ab25eeb5Syz # endif 958ab25eeb5Syz typedef struct uio uio_t; 9597c478bd9Sstevel@tonic-gate typedef int minor_t; 9607c478bd9Sstevel@tonic-gate typedef u_int32_t u_32_t; 9617c478bd9Sstevel@tonic-gate # define U_32_T 1 9627c478bd9Sstevel@tonic-gate 9637c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 9647c478bd9Sstevel@tonic-gate #endif /* __FreeBSD__ */ 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 9687c478bd9Sstevel@tonic-gate /* O P E N B S D */ 9697c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 9707c478bd9Sstevel@tonic-gate #ifdef __OpenBSD__ 9717c478bd9Sstevel@tonic-gate # ifdef INET6 9727c478bd9Sstevel@tonic-gate # define USE_INET6 9737c478bd9Sstevel@tonic-gate # endif 9747c478bd9Sstevel@tonic-gate 9757c478bd9Sstevel@tonic-gate # ifdef _KERNEL 976ab25eeb5Syz # if !defined(IPFILTER_LKM) 977ab25eeb5Syz # include "bpfilter.h" 978ab25eeb5Syz # endif 979ab25eeb5Syz # if (OpenBSD >= 200311) 980ab25eeb5Syz # define SNPRINTF snprintf 981ab25eeb5Syz # if defined(USE_INET6) 982ab25eeb5Syz # include "netinet6/in6_var.h" 983ab25eeb5Syz # include "netinet6/nd6.h" 984ab25eeb5Syz # endif 985ab25eeb5Syz # endif 986ab25eeb5Syz # if (OpenBSD >= 200012) 987ab25eeb5Syz # define HAVE_M_PULLDOWN 1 988ab25eeb5Syz # endif 989ab25eeb5Syz # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 990ab25eeb5Syz # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 991ab25eeb5Syz # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 992ab25eeb5Syz # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 9937c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 994ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 9957c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 9967c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 9977c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 9987c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 9997c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 10007c478bd9Sstevel@tonic-gate # if (OpenBSD >= 199603) 10017c478bd9Sstevel@tonic-gate # define IFNAME(x, b) ((struct ifnet *)x)->if_xname 1002381a2a9aSdr # define COPYIFNAME(x, b, v) \ 1003ab25eeb5Syz (void) strncpy(b, \ 1004ab25eeb5Syz ((struct ifnet *)x)->if_xname, \ 1005ab25eeb5Syz LIFNAMSIZ) 10067c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index)&7) 10077c478bd9Sstevel@tonic-gate # else 10087c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 10097c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 10107c478bd9Sstevel@tonic-gate # endif 10117c478bd9Sstevel@tonic-gate 1012ab25eeb5Syz typedef struct uio uio_t; 1013ab25eeb5Syz typedef u_long ioctlcmd_t; 10147c478bd9Sstevel@tonic-gate typedef int minor_t; 10157c478bd9Sstevel@tonic-gate typedef u_int32_t u_32_t; 10167c478bd9Sstevel@tonic-gate # define U_32_T 1 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 10197c478bd9Sstevel@tonic-gate #endif /* __OpenBSD__ */ 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 10237c478bd9Sstevel@tonic-gate /* B S D O S */ 10247c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 10257c478bd9Sstevel@tonic-gate #ifdef _BSDI_VERSION 10267c478bd9Sstevel@tonic-gate # ifdef INET6 10277c478bd9Sstevel@tonic-gate # define USE_INET6 10287c478bd9Sstevel@tonic-gate # endif 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate # ifdef _KERNEL 10317c478bd9Sstevel@tonic-gate # define GETKTIME(x) microtime((struct timeval *)x) 1032ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 10337c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 10347c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 10357c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 10367c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 10377c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 10387c478bd9Sstevel@tonic-gate # endif /* _KERNEL */ 10397c478bd9Sstevel@tonic-gate 1040ab25eeb5Syz # if (_BSDI_VERSION >= 199701) 1041ab25eeb5Syz typedef u_long ioctlcmd_t; 1042ab25eeb5Syz # else 1043ab25eeb5Syz typedef int ioctlcmd_t; 1044ab25eeb5Syz # endif 10457c478bd9Sstevel@tonic-gate typedef u_int32_t u_32_t; 10467c478bd9Sstevel@tonic-gate # define U_32_T 1 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate #endif /* _BSDI_VERSION */ 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 10527c478bd9Sstevel@tonic-gate /* S U N O S 4 */ 10537c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 10547c478bd9Sstevel@tonic-gate #if defined(sun) && !defined(OS_RECOGNISED) /* SunOS4 */ 10557c478bd9Sstevel@tonic-gate # ifdef _KERNEL 10567c478bd9Sstevel@tonic-gate # include <sys/kmem_alloc.h> 10577c478bd9Sstevel@tonic-gate # define GETKTIME(x) uniqtime((struct timeval *)x) 10587c478bd9Sstevel@tonic-gate # define MSGDSIZE(x) mbufchainlen(x) 10597c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->m_len 10607c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 10617c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 10627c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1063f4b3ec61Sdh # define GETIFP(n, v, ifs) ifunit(n, IFNAMSIZ) 10647c478bd9Sstevel@tonic-gate # define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 10657c478bd9Sstevel@tonic-gate # define KFREES(x,s) kmem_free((char *)(x), (s)) 10667c478bd9Sstevel@tonic-gate # define SLEEP(id, n) sleep((id), PZERO+1) 1067ab25eeb5Syz # define WAKEUP(id,x) wakeup(id + x) 10687c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 10697c478bd9Sstevel@tonic-gate # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate extern void m_copydata __P((struct mbuf *, int, int, caddr_t)); 10727c478bd9Sstevel@tonic-gate extern void m_copyback __P((struct mbuf *, int, int, caddr_t)); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate typedef struct mbuf mb_t; 10757c478bd9Sstevel@tonic-gate # endif 10767c478bd9Sstevel@tonic-gate 1077ab25eeb5Syz typedef struct uio uio_t; 1078ab25eeb5Syz typedef int ioctlcmd_t; 10797c478bd9Sstevel@tonic-gate typedef int minor_t; 10807c478bd9Sstevel@tonic-gate typedef unsigned int u_32_t; 10817c478bd9Sstevel@tonic-gate # define U_32_T 1 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate # define OS_RECOGNISED 1 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate #endif /* SunOS 4 */ 10867c478bd9Sstevel@tonic-gate 1087ab25eeb5Syz /* ----------------------------------------------------------------------- */ 1088ab25eeb5Syz /* L I N U X */ 1089ab25eeb5Syz /* ----------------------------------------------------------------------- */ 1090ab25eeb5Syz #if defined(linux) && !defined(OS_RECOGNISED) 1091ab25eeb5Syz #include <linux/config.h> 1092ab25eeb5Syz #include <linux/version.h> 1093ab25eeb5Syz # if LINUX >= 20600 1094ab25eeb5Syz # define HDR_T_PRIVATE 1 1095ab25eeb5Syz # endif 1096ab25eeb5Syz # undef USE_INET6 1097ab25eeb5Syz # ifdef USE_INET6 1098ab25eeb5Syz struct ip6_ext { 1099ab25eeb5Syz u_char ip6e_nxt; 1100ab25eeb5Syz u_char ip6e_len; 1101ab25eeb5Syz }; 1102ab25eeb5Syz # endif 1103ab25eeb5Syz 1104ab25eeb5Syz # ifdef _KERNEL 1105ab25eeb5Syz # define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 1106ab25eeb5Syz # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 1107ab25eeb5Syz # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 1108ab25eeb5Syz # define COPYIN(a,b,c) copy_from_user((caddr_t)(b), (caddr_t)(a), (c)) 1109ab25eeb5Syz # define COPYOUT(a,b,c) copy_to_user((caddr_t)(b), (caddr_t)(a), (c)) 1110ab25eeb5Syz # define FREE_MB_T(m) kfree_skb(m) 1111ab25eeb5Syz # define GETKTIME(x) do_gettimeofday((struct timeval *)x) 1112ab25eeb5Syz # define SLEEP(x,s) 0, interruptible_sleep_on(x##_linux) 1113ab25eeb5Syz # define WAKEUP(x,y) wake_up(x##_linux + y) 1114ab25eeb5Syz # define UIOMOVE(a,b,c,d) uiomove(a,b,c,d) 1115ab25eeb5Syz # define USE_MUTEXES 1116ab25eeb5Syz # define KRWLOCK_T rwlock_t 1117ab25eeb5Syz # define KMUTEX_T spinlock_t 1118ab25eeb5Syz # define MUTEX_INIT(x,y) spin_lock_init(&(x)->ipf_lk) 1119ab25eeb5Syz # define MUTEX_ENTER(x) spin_lock(&(x)->ipf_lk) 1120ab25eeb5Syz # define MUTEX_EXIT(x) spin_unlock(&(x)->ipf_lk) 1121ab25eeb5Syz # define MUTEX_DESTROY(x) do { } while (0) 1122ab25eeb5Syz # define MUTEX_NUKE(x) bzero(&(x)->ipf_lk, sizeof((x)->ipf_lk)) 1123ab25eeb5Syz # define READ_ENTER(x) ipf_read_enter(x) 1124ab25eeb5Syz # define WRITE_ENTER(x) ipf_write_enter(x) 1125ab25eeb5Syz # define RWLOCK_INIT(x,y) rwlock_init(&(x)->ipf_lk) 1126ab25eeb5Syz # define RW_DESTROY(x) do { } while (0) 1127ab25eeb5Syz # define RWLOCK_EXIT(x) ipf_rw_exit(x) 1128ab25eeb5Syz # define MUTEX_DOWNGRADE(x) ipf_rw_downgrade(x) 1129ab25eeb5Syz # define ATOMIC_INCL(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1130ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1131ab25eeb5Syz # define ATOMIC_DECL(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1132ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1133ab25eeb5Syz # define ATOMIC_INC64(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1134ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1135ab25eeb5Syz # define ATOMIC_INC32(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1136ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1137ab25eeb5Syz # define ATOMIC_INC16(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1138ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1139ab25eeb5Syz # define ATOMIC_DEC64(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1140ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1141ab25eeb5Syz # define ATOMIC_DEC32(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1142ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1143ab25eeb5Syz # define ATOMIC_DEC16(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1144ab25eeb5Syz MUTEX_EXIT(&ipf_rw) 1145ab25eeb5Syz # define SPL_IMP(x) do { } while (0) 1146ab25eeb5Syz # define SPL_NET(x) do { } while (0) 1147ab25eeb5Syz # define SPL_X(x) do { } while (0) 1148ab25eeb5Syz # define IFNAME(x) ((struct net_device*)x)->name 1149ab25eeb5Syz # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1150ab25eeb5Syz ((struct net_device *)fin->fin_ifp)->ifindex) & 7) 1151ab25eeb5Syz typedef struct sk_buff mb_t; 1152ab25eeb5Syz extern void m_copydata __P((mb_t *, int, int, caddr_t)); 1153ab25eeb5Syz extern void m_copyback __P((mb_t *, int, int, caddr_t)); 1154ab25eeb5Syz extern void m_adj __P((mb_t *, int)); 1155ab25eeb5Syz extern mb_t *m_pullup __P((mb_t *, int)); 1156ab25eeb5Syz # define mbuf sk_buff 1157ab25eeb5Syz 1158ab25eeb5Syz # define mtod(m, t) ((t)(m)->data) 1159ab25eeb5Syz # define m_len len 1160ab25eeb5Syz # define m_next next 1161ab25eeb5Syz # define M_DUPLICATE(m) skb_clone((m), in_interrupt() ? GFP_ATOMIC : \ 1162ab25eeb5Syz GFP_KERNEL) 1163ab25eeb5Syz # define MSGDSIZE(m) (m)->len 1164ab25eeb5Syz # define M_LEN(m) (m)->len 1165ab25eeb5Syz 1166ab25eeb5Syz # define splnet(x) ; 1167ab25eeb5Syz # define printf printk 1168ab25eeb5Syz # define bcopy(s,d,z) memmove(d, s, z) 1169ab25eeb5Syz # define bzero(s,z) memset(s, 0, z) 1170ab25eeb5Syz # define bcmp(a,b,z) memcmp(a, b, z) 1171ab25eeb5Syz 1172ab25eeb5Syz # define ifnet net_device 1173ab25eeb5Syz # define if_xname name 1174ab25eeb5Syz # define if_unit ifindex 1175ab25eeb5Syz 1176ab25eeb5Syz # define KMALLOC(x,t) (x) = (t)kmalloc(sizeof(*(x)), \ 1177ab25eeb5Syz in_interrupt() ? GFP_ATOMIC : GFP_KERNEL) 1178ab25eeb5Syz # define KFREE(x) kfree(x) 1179ab25eeb5Syz # define KMALLOCS(x,t,s) (x) = (t)kmalloc((s), \ 1180ab25eeb5Syz in_interrupt() ? GFP_ATOMIC : GFP_KERNEL) 1181ab25eeb5Syz # define KFREES(x,s) kfree(x) 1182ab25eeb5Syz 1183ab25eeb5Syz # define GETIFP(n,v) dev_get_by_name(n) 1184ab25eeb5Syz 1185ab25eeb5Syz # else 1186ab25eeb5Syz # include <net/ethernet.h> 1187ab25eeb5Syz 1188ab25eeb5Syz struct mbuf { 1189ab25eeb5Syz }; 1190ab25eeb5Syz 1191ab25eeb5Syz # ifndef _NET_ROUTE_H 1192ab25eeb5Syz struct rtentry { 1193ab25eeb5Syz }; 1194ab25eeb5Syz # endif 1195ab25eeb5Syz 1196ab25eeb5Syz struct ifnet { 1197ab25eeb5Syz char if_xname[IFNAMSIZ]; 1198ab25eeb5Syz int if_unit; 1199ab25eeb5Syz int (* if_output) __P((struct ifnet *, struct mbuf *, struct sockaddr *, struct rtentry *)); 1200ab25eeb5Syz struct ifaddr *if_addrlist; 1201ab25eeb5Syz }; 1202ab25eeb5Syz # define IFNAME(x) ((struct ifnet *)x)->if_xname 1203ab25eeb5Syz 1204ab25eeb5Syz # endif /* _KERNEL */ 1205ab25eeb5Syz 1206ab25eeb5Syz # define COPYIFNAME(x, b) \ 1207ab25eeb5Syz (void) strncpy(b, \ 1208ab25eeb5Syz ((struct ifnet *)x)->if_xname, \ 1209ab25eeb5Syz LIFNAMSIZ) 1210ab25eeb5Syz 1211ab25eeb5Syz # include <linux/fs.h> 1212ab25eeb5Syz # define FWRITE FMODE_WRITE 1213ab25eeb5Syz # define FREAD FMODE_READ 1214ab25eeb5Syz 1215ab25eeb5Syz # define __USE_MISC 1 1216ab25eeb5Syz # define __FAVOR_BSD 1 1217ab25eeb5Syz 1218ab25eeb5Syz typedef struct uio { 1219ab25eeb5Syz struct iovec *uio_iov; 1220ab25eeb5Syz void *uio_file; 1221ab25eeb5Syz char *uio_buf; 1222ab25eeb5Syz int uio_iovcnt; 1223ab25eeb5Syz int uio_offset; 1224ab25eeb5Syz size_t uio_resid; 1225ab25eeb5Syz int uio_rw; 1226ab25eeb5Syz } uio_t; 1227ab25eeb5Syz 1228ab25eeb5Syz extern int uiomove __P((caddr_t, size_t, int, struct uio *)); 1229ab25eeb5Syz 1230ab25eeb5Syz # define UIO_READ 1 1231ab25eeb5Syz # define UIO_WRITE 2 1232ab25eeb5Syz 1233ab25eeb5Syz typedef u_long ioctlcmd_t; 1234ab25eeb5Syz typedef int minor_t; 1235ab25eeb5Syz typedef u_int32_t u_32_t; 1236ab25eeb5Syz # define U_32_T 1 1237ab25eeb5Syz 1238ab25eeb5Syz # define OS_RECOGNISED 1 1239ab25eeb5Syz 1240ab25eeb5Syz #endif 1241ab25eeb5Syz 1242ab25eeb5Syz 1243ab25eeb5Syz /* ----------------------------------------------------------------------- */ 1244ab25eeb5Syz /* A I X */ 1245ab25eeb5Syz /* ----------------------------------------------------------------------- */ 1246ab25eeb5Syz #if defined(_AIX51) 1247ab25eeb5Syz # undef MENTAT 1248ab25eeb5Syz 1249ab25eeb5Syz # include <sys/lock.h> 1250ab25eeb5Syz # include <sys/sysmacros.h> 1251ab25eeb5Syz 1252ab25eeb5Syz # ifdef _KERNEL 1253ab25eeb5Syz # define rw_read_locked(x) 0 1254ab25eeb5Syz # include <net/net_globals.h> 1255ab25eeb5Syz # include <net/net_malloc.h> 1256ab25eeb5Syz # define KMUTEX_T simple_lock_t 1257ab25eeb5Syz # define KRWLOCK_T complex_lock_t 1258ab25eeb5Syz # define USE_MUTEXES 1 1259ab25eeb5Syz # define USE_SPL 1 1260ab25eeb5Syz # define READ_ENTER(x) lock_read((x)->ipf_lk) 1261ab25eeb5Syz # define WRITE_ENTER(x) lock_write((x)->ipf_lk) 1262ab25eeb5Syz # define MUTEX_DOWNGRADE(x) lock_write_to_read((x)->ipf_lk) 1263ab25eeb5Syz # define RWLOCK_INIT(x, y) lock_alloc(&(x)->ipf_lk, \ 1264ab25eeb5Syz LOCK_ALLOC_PIN, \ 1265ab25eeb5Syz (u_short)y, 0); \ 1266ab25eeb5Syz lock_init((x)->ipf_lk, TRUE) 1267ab25eeb5Syz # define RWLOCK_EXIT(x) lock_done((x)->ipf_lk) 1268ab25eeb5Syz # define RW_DESTROY(x) lock_free(&(x)->ipf_lk) 1269ab25eeb5Syz # define MUTEX_ENTER(x) simple_lock((x)->ipf_lk) 1270ab25eeb5Syz # define MUTEX_INIT(x, y) lock_alloc(&(x)->ipf_lk, \ 1271ab25eeb5Syz LOCK_ALLOC_PIN, \ 1272ab25eeb5Syz (u_short)y, 0); \ 1273ab25eeb5Syz simple_lock_init((x)->ipf_lk) 1274ab25eeb5Syz # define MUTEX_DESTROY(x) lock_free(&(x)->ipf_lk) 1275ab25eeb5Syz # define MUTEX_EXIT(x) simple_unlock((x)->ipf_lk) 1276ab25eeb5Syz # define MUTEX_NUKE(x) bzero(&(x)->ipf_lk, sizeof((x)->ipf_lk)) 1277ab25eeb5Syz # define ATOMIC_INC64(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1278ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1279ab25eeb5Syz # define ATOMIC_DEC64(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1280ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1281ab25eeb5Syz # define ATOMIC_INC32(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1282ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1283ab25eeb5Syz # define ATOMIC_DEC32(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1284ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1285ab25eeb5Syz # define ATOMIC_INCL(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1286ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1287ab25eeb5Syz # define ATOMIC_DECL(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1288ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1289ab25eeb5Syz # define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1290ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1291ab25eeb5Syz # define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1292ab25eeb5Syz MUTEX_EXIT(&ipf_rw); } 1293ab25eeb5Syz # define SPL_NET(x) x = splnet() 1294ab25eeb5Syz # define SPL_IMP(x) x = splimp() 1295ab25eeb5Syz # undef SPL_X 1296ab25eeb5Syz # define SPL_X(x) splx(x) 1297ab25eeb5Syz # define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 1298ab25eeb5Syz extern void* getifp __P((char *, int)); 1299ab25eeb5Syz # define GETIFP(n, v) getifp(n, v) 1300ab25eeb5Syz # define GET_MINOR minor 1301ab25eeb5Syz # define SLEEP(id, n) sleepx((id), PZERO+1, 0) 1302ab25eeb5Syz # define WAKEUP(id,x) wakeup(id) 1303ab25eeb5Syz # define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 1304ab25eeb5Syz # define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 1305ab25eeb5Syz # define BCOPYIN(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 1306ab25eeb5Syz # define BCOPYOUT(a,b,c) bcopy((caddr_t)(a), (caddr_t)(b), (c)) 1307ab25eeb5Syz # define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_TEMP, M_NOWAIT) 1308ab25eeb5Syz # define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_TEMP, \ 1309ab25eeb5Syz ((c) > 4096) ? M_WAITOK : M_NOWAIT) 1310ab25eeb5Syz # define KFREE(x) FREE((x), M_TEMP) 1311ab25eeb5Syz # define KFREES(x,s) FREE((x), M_TEMP) 1312ab25eeb5Syz # define MSGDSIZE(x) mbufchainlen(x) 1313ab25eeb5Syz # define M_LEN(x) (x)->m_len 1314ab25eeb5Syz # define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 1315ab25eeb5Syz # define GETKTIME(x) 1316ab25eeb5Syz # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1317ab25eeb5Syz ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1318ab25eeb5Syz # define IPF_PANIC(x,y) 1319ab25eeb5Syz typedef struct mbuf mb_t; 1320ab25eeb5Syz # endif /* _KERNEL */ 1321ab25eeb5Syz 1322ab25eeb5Syz /* 1323ab25eeb5Syz * These are from's Solaris' #defines for little endian. 1324ab25eeb5Syz */ 1325ab25eeb5Syz #if !defined(IP6F_MORE_FRAG) 1326ab25eeb5Syz # define IP6F_MORE_FRAG 0x0100 1327ab25eeb5Syz #endif 1328ab25eeb5Syz #if !defined(IP6F_RESERVED_MASK) 1329ab25eeb5Syz # define IP6F_RESERVED_MASK 0x0600 1330ab25eeb5Syz #endif 1331ab25eeb5Syz #if !defined(IP6F_OFF_MASK) 1332ab25eeb5Syz # define IP6F_OFF_MASK 0xf8ff 1333ab25eeb5Syz #endif 1334ab25eeb5Syz 1335ab25eeb5Syz struct ip6_ext { 1336ab25eeb5Syz u_char ip6e_nxt; 1337ab25eeb5Syz u_char ip6e_len; 1338ab25eeb5Syz }; 1339ab25eeb5Syz 1340ab25eeb5Syz typedef int ioctlcmd_t; 1341ab25eeb5Syz typedef int minor_t; 1342ab25eeb5Syz /* 1343ab25eeb5Syz * Really, any arch where sizeof(long) != sizeof(int). 1344ab25eeb5Syz */ 1345ab25eeb5Syz typedef unsigned int u_32_t; 1346ab25eeb5Syz # define U_32_T 1 1347ab25eeb5Syz 1348ab25eeb5Syz # define OS_RECOGNISED 1 1349ab25eeb5Syz #endif /* _AIX51 */ 1350ab25eeb5Syz 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate #ifndef OS_RECOGNISED 13537c478bd9Sstevel@tonic-gate #error ip_compat.h does not recognise this platform/OS. 13547c478bd9Sstevel@tonic-gate #endif 13557c478bd9Sstevel@tonic-gate 1356ab25eeb5Syz 13577c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 13587c478bd9Sstevel@tonic-gate /* G E N E R I C */ 13597c478bd9Sstevel@tonic-gate /* ----------------------------------------------------------------------- */ 13607c478bd9Sstevel@tonic-gate #ifndef OS_RECOGNISED 13617c478bd9Sstevel@tonic-gate #endif 13627c478bd9Sstevel@tonic-gate 1363ab25eeb5Syz /* 1364ab25eeb5Syz * For BSD kernels, if bpf is in the kernel, enable ipfilter to use bpf in 1365ab25eeb5Syz * filter rules. 1366ab25eeb5Syz */ 1367ab25eeb5Syz #if !defined(IPFILTER_BPF) && ((NBPF > 0) || (NBPFILTER > 0) || (DEV_BPF > 0)) 1368ab25eeb5Syz # define IPFILTER_BPF 1369ab25eeb5Syz #endif 1370ab25eeb5Syz 13717c478bd9Sstevel@tonic-gate /* 13727c478bd9Sstevel@tonic-gate * Userland locking primitives 13737c478bd9Sstevel@tonic-gate */ 13747c478bd9Sstevel@tonic-gate typedef struct { 1375ab25eeb5Syz char *eMm_owner; 1376ab25eeb5Syz char *eMm_heldin; 13777c478bd9Sstevel@tonic-gate u_int eMm_magic; 13787c478bd9Sstevel@tonic-gate int eMm_held; 13797c478bd9Sstevel@tonic-gate int eMm_heldat; 1380ab25eeb5Syz #ifdef __hpux 1381ab25eeb5Syz char eMm_fill[8]; 1382ab25eeb5Syz #endif 13837c478bd9Sstevel@tonic-gate } eMmutex_t; 13847c478bd9Sstevel@tonic-gate 13857c478bd9Sstevel@tonic-gate typedef struct { 13867c478bd9Sstevel@tonic-gate char *eMrw_owner; 13877c478bd9Sstevel@tonic-gate char *eMrw_heldin; 1388ab25eeb5Syz u_int eMrw_magic; 1389ab25eeb5Syz short eMrw_read; 1390ab25eeb5Syz short eMrw_write; 1391ab25eeb5Syz int eMrw_heldat; 1392ab25eeb5Syz #ifdef __hpux 1393ab25eeb5Syz char eMm_fill[24]; 1394ab25eeb5Syz #endif 13957c478bd9Sstevel@tonic-gate } eMrwlock_t; 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate typedef union { 13987c478bd9Sstevel@tonic-gate #ifdef KMUTEX_T 1399ab25eeb5Syz struct { 1400ab25eeb5Syz KMUTEX_T ipf_slk; 1401ab25eeb5Syz char *ipf_lname; 1402ab25eeb5Syz } ipf_lkun_s; 14037c478bd9Sstevel@tonic-gate #endif 14047c478bd9Sstevel@tonic-gate eMmutex_t ipf_emu; 14057c478bd9Sstevel@tonic-gate } ipfmutex_t; 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate typedef union { 14087c478bd9Sstevel@tonic-gate #ifdef KRWLOCK_T 1409ab25eeb5Syz struct { 1410ab25eeb5Syz KRWLOCK_T ipf_slk; 1411ab25eeb5Syz char *ipf_lname; 1412ab25eeb5Syz int ipf_sr; 1413ab25eeb5Syz int ipf_sw; 1414ab25eeb5Syz u_int ipf_magic; 1415ab25eeb5Syz } ipf_lkun_s; 14167c478bd9Sstevel@tonic-gate #endif 14177c478bd9Sstevel@tonic-gate eMrwlock_t ipf_emu; 14187c478bd9Sstevel@tonic-gate } ipfrwlock_t; 14197c478bd9Sstevel@tonic-gate 1420ab25eeb5Syz #define ipf_lk ipf_lkun_s.ipf_slk 1421ab25eeb5Syz #define ipf_lname ipf_lkun_s.ipf_lname 1422ab25eeb5Syz #define ipf_isr ipf_lkun_s.ipf_sr 1423ab25eeb5Syz #define ipf_isw ipf_lkun_s.ipf_sw 1424ab25eeb5Syz #define ipf_magic ipf_lkun_s.ipf_magic 1425ab25eeb5Syz 1426ab25eeb5Syz #if !defined(__GNUC__) || \ 1427ab25eeb5Syz (defined(__FreeBSD_version) && (__FreeBSD_version >= 503000)) 1428ab25eeb5Syz # ifndef INLINE 1429ab25eeb5Syz # define INLINE 1430ab25eeb5Syz # endif 1431ab25eeb5Syz #else 1432ab25eeb5Syz # define INLINE __inline__ 1433ab25eeb5Syz #endif 1434ab25eeb5Syz 1435ab25eeb5Syz #if defined(linux) && defined(_KERNEL) 1436ab25eeb5Syz extern INLINE void ipf_read_enter __P((ipfrwlock_t *)); 1437ab25eeb5Syz extern INLINE void ipf_write_enter __P((ipfrwlock_t *)); 1438ab25eeb5Syz extern INLINE void ipf_rw_exit __P((ipfrwlock_t *)); 1439ab25eeb5Syz extern INLINE void ipf_rw_downgrade __P((ipfrwlock_t *)); 1440ab25eeb5Syz #endif 1441ab25eeb5Syz 1442ab25eeb5Syz /* 1443ab25eeb5Syz * In a non-kernel environment, there are a lot of macros that need to be 1444ab25eeb5Syz * filled in to be null-ops or to point to some compatibility function, 1445ab25eeb5Syz * somewhere in userland. 1446ab25eeb5Syz */ 14477c478bd9Sstevel@tonic-gate #ifndef _KERNEL 14487c478bd9Sstevel@tonic-gate typedef struct mb_s { 14497c478bd9Sstevel@tonic-gate struct mb_s *mb_next; 14507c478bd9Sstevel@tonic-gate int mb_len; 14517c478bd9Sstevel@tonic-gate u_long mb_buf[2048]; 14527c478bd9Sstevel@tonic-gate } mb_t; 1453ab25eeb5Syz # undef m_next 1454ab25eeb5Syz # define m_next mb_next 14557c478bd9Sstevel@tonic-gate # define MSGDSIZE(x) (x)->mb_len /* XXX - from ipt.c */ 14567c478bd9Sstevel@tonic-gate # define M_LEN(x) (x)->mb_len 14577c478bd9Sstevel@tonic-gate # define M_DUPLICATE(x) (x) 14587c478bd9Sstevel@tonic-gate # define GETKTIME(x) gettimeofday((struct timeval *)(x), NULL) 1459ab25eeb5Syz # undef MTOD 1460ab25eeb5Syz # define MTOD(m, t) ((t)(m)->mb_buf) 14617c478bd9Sstevel@tonic-gate # define FREE_MB_T(x) 1462ab25eeb5Syz # define SLEEP(x,y) 1; 1463ab25eeb5Syz # define WAKEUP(x,y) ; 1464ab25eeb5Syz # define IPF_PANIC(x,y) ; 1465ab25eeb5Syz # define PANIC(x,y) ; 1466ab25eeb5Syz # define SPL_NET(x) ; 1467ab25eeb5Syz # define SPL_IMP(x) ; 1468ab25eeb5Syz # define SPL_X(x) ; 1469ab25eeb5Syz # define KMALLOC(a,b) (a) = (b)malloc(sizeof(*a)) 1470ab25eeb5Syz # define KMALLOCS(a,b,c) (a) = (b)malloc(c) 1471ab25eeb5Syz # define KFREE(x) free(x) 1472ab25eeb5Syz # define KFREES(x,s) free(x) 1473f4b3ec61Sdh # define GETIFP(x, v, ifs) get_unit(x,v, ifs) 1474ab25eeb5Syz # define COPYIN(a,b,c) (bcopy((a), (b), (c)), 0) 1475ab25eeb5Syz # define COPYOUT(a,b,c) (bcopy((a), (b), (c)), 0) 1476ab25eeb5Syz # define BCOPYIN(a,b,c) (bcopy((a), (b), (c)), 0) 1477ab25eeb5Syz # define BCOPYOUT(a,b,c) (bcopy((a), (b), (c)), 0) 1478ab25eeb5Syz # define COPYDATA(m, o, l, b) bcopy(MTOD((mb_t *)m, char *) + (o), \ 1479ab25eeb5Syz (b), (l)) 1480ab25eeb5Syz # define COPYBACK(m, o, l, b) bcopy((b), \ 1481ab25eeb5Syz MTOD((mb_t *)m, char *) + (o), \ 1482ab25eeb5Syz (l)) 1483ab25eeb5Syz # define UIOMOVE(a,b,c,d) ipfuiomove(a,b,c,d) 1484ab25eeb5Syz extern void m_copydata __P((mb_t *, int, int, caddr_t)); 1485ab25eeb5Syz extern int ipfuiomove __P((caddr_t, int, int, struct uio *)); 14867c478bd9Sstevel@tonic-gate # ifndef CACHE_HASH 14877c478bd9Sstevel@tonic-gate # define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 14887c478bd9Sstevel@tonic-gate ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 14897c478bd9Sstevel@tonic-gate # endif 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) eMmutex_destroy(&(x)->ipf_emu) 14927c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) eMmutex_enter(&(x)->ipf_emu, \ 14937c478bd9Sstevel@tonic-gate __FILE__, __LINE__) 14947c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) eMmutex_exit(&(x)->ipf_emu) 14957c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x,y) eMmutex_init(&(x)->ipf_emu, y) 14967c478bd9Sstevel@tonic-gate # define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 14977c478bd9Sstevel@tonic-gate 14987c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) eMrwlock_downgrade(&(x)->ipf_emu, \ 14997c478bd9Sstevel@tonic-gate __FILE__, __LINE__) 15007c478bd9Sstevel@tonic-gate # define READ_ENTER(x) eMrwlock_read_enter(&(x)->ipf_emu, \ 15017c478bd9Sstevel@tonic-gate __FILE__, __LINE__) 15027c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) eMrwlock_init(&(x)->ipf_emu, y) 15037c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) eMrwlock_exit(&(x)->ipf_emu) 15047c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) eMrwlock_destroy(&(x)->ipf_emu) 15057c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) eMrwlock_write_enter(&(x)->ipf_emu, \ 15067c478bd9Sstevel@tonic-gate __FILE__, \ 15077c478bd9Sstevel@tonic-gate __LINE__) 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate # define USE_MUTEXES 1 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate extern void eMmutex_destroy __P((eMmutex_t *)); 15127c478bd9Sstevel@tonic-gate extern void eMmutex_enter __P((eMmutex_t *, char *, int)); 15137c478bd9Sstevel@tonic-gate extern void eMmutex_exit __P((eMmutex_t *)); 15147c478bd9Sstevel@tonic-gate extern void eMmutex_init __P((eMmutex_t *, char *)); 15157c478bd9Sstevel@tonic-gate extern void eMrwlock_destroy __P((eMrwlock_t *)); 15167c478bd9Sstevel@tonic-gate extern void eMrwlock_exit __P((eMrwlock_t *)); 15177c478bd9Sstevel@tonic-gate extern void eMrwlock_init __P((eMrwlock_t *, char *)); 15187c478bd9Sstevel@tonic-gate extern void eMrwlock_read_enter __P((eMrwlock_t *, char *, int)); 15197c478bd9Sstevel@tonic-gate extern void eMrwlock_write_enter __P((eMrwlock_t *, char *, int)); 15207c478bd9Sstevel@tonic-gate extern void eMrwlock_downgrade __P((eMrwlock_t *, char *, int)); 15217c478bd9Sstevel@tonic-gate 1522381a2a9aSdr #undef NET_IS_HCK_L3_FULL 1523381a2a9aSdr #define NET_IS_HCK_L3_FULL(n, x) (0) 1524381a2a9aSdr #undef NET_IS_HCK_L3_PART 1525381a2a9aSdr #define NET_IS_HCK_L3_PART(n, x) (0) 1526381a2a9aSdr #undef NET_IS_HCK_L4_FULL 1527381a2a9aSdr #define NET_IS_HCK_L4_FULL(n, x) (0) 1528381a2a9aSdr #undef NET_IS_HCK_L4_PART 1529381a2a9aSdr #define NET_IS_HCK_L4_PART(n, x) (0) 1530381a2a9aSdr 15317c478bd9Sstevel@tonic-gate #endif 15327c478bd9Sstevel@tonic-gate 15337c478bd9Sstevel@tonic-gate #define MAX_IPV4HDR ((0xf << 2) + sizeof(struct icmp) + sizeof(ip_t) + 8) 15347c478bd9Sstevel@tonic-gate 1535ab25eeb5Syz #ifndef IP_OFFMASK 1536ab25eeb5Syz # define IP_OFFMASK 0x1fff 1537ab25eeb5Syz #endif 1538ab25eeb5Syz 15397c478bd9Sstevel@tonic-gate 1540ab25eeb5Syz /* 1541ab25eeb5Syz * On BSD's use quad_t as a guarantee for getting at least a 64bit sized 1542ab25eeb5Syz * object. 1543ab25eeb5Syz */ 15447c478bd9Sstevel@tonic-gate #if BSD > 199306 15457c478bd9Sstevel@tonic-gate # define USE_QUAD_T 15467c478bd9Sstevel@tonic-gate # define U_QUAD_T u_quad_t 15477c478bd9Sstevel@tonic-gate # define QUAD_T quad_t 15487c478bd9Sstevel@tonic-gate #else /* BSD > 199306 */ 15497c478bd9Sstevel@tonic-gate # define U_QUAD_T u_long 15507c478bd9Sstevel@tonic-gate # define QUAD_T long 15517c478bd9Sstevel@tonic-gate #endif /* BSD > 199306 */ 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate #ifdef USE_INET6 15557c478bd9Sstevel@tonic-gate # if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \ 1556ab25eeb5Syz defined(__osf__) || defined(linux) 15577c478bd9Sstevel@tonic-gate # include <netinet/ip6.h> 15587c478bd9Sstevel@tonic-gate # include <netinet/icmp6.h> 1559ab25eeb5Syz # if !defined(linux) 1560ab25eeb5Syz # if defined(_KERNEL) && !defined(__osf__) 1561ab25eeb5Syz # include <netinet6/ip6_var.h> 1562ab25eeb5Syz # endif 15637c478bd9Sstevel@tonic-gate # endif 15647c478bd9Sstevel@tonic-gate typedef struct ip6_hdr ip6_t; 15657c478bd9Sstevel@tonic-gate # endif 15667c478bd9Sstevel@tonic-gate #endif 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate #ifndef MAX 15697c478bd9Sstevel@tonic-gate # define MAX(a,b) (((a) > (b)) ? (a) : (b)) 15707c478bd9Sstevel@tonic-gate #endif 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate #if defined(_KERNEL) 15737c478bd9Sstevel@tonic-gate # ifdef MENTAT 15747c478bd9Sstevel@tonic-gate # define COPYDATA mb_copydata 15757c478bd9Sstevel@tonic-gate # define COPYBACK mb_copyback 15767c478bd9Sstevel@tonic-gate # else 15777c478bd9Sstevel@tonic-gate # define COPYDATA m_copydata 15787c478bd9Sstevel@tonic-gate # define COPYBACK m_copyback 15797c478bd9Sstevel@tonic-gate # endif 15807c478bd9Sstevel@tonic-gate # if (BSD >= 199306) || defined(__FreeBSD__) 15817c478bd9Sstevel@tonic-gate # if (defined(__NetBSD_Version__) && (__NetBSD_Version__ < 105180000)) || \ 15827c478bd9Sstevel@tonic-gate defined(__FreeBSD__) || (defined(OpenBSD) && (OpenBSD < 200206)) || \ 15837c478bd9Sstevel@tonic-gate defined(_BSDI_VERSION) 15847c478bd9Sstevel@tonic-gate # include <vm/vm.h> 15857c478bd9Sstevel@tonic-gate # endif 15867c478bd9Sstevel@tonic-gate # if !defined(__FreeBSD__) || (defined (__FreeBSD_version) && \ 15877c478bd9Sstevel@tonic-gate (__FreeBSD_version >= 300000)) 15887c478bd9Sstevel@tonic-gate # if (defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105180000)) || \ 15897c478bd9Sstevel@tonic-gate (defined(OpenBSD) && (OpenBSD >= 200111)) 15907c478bd9Sstevel@tonic-gate # include <uvm/uvm_extern.h> 15917c478bd9Sstevel@tonic-gate # else 15927c478bd9Sstevel@tonic-gate # include <vm/vm_extern.h> 15937c478bd9Sstevel@tonic-gate extern vm_map_t kmem_map; 15947c478bd9Sstevel@tonic-gate # endif 15957c478bd9Sstevel@tonic-gate # include <sys/proc.h> 15967c478bd9Sstevel@tonic-gate # else /* !__FreeBSD__ || (__FreeBSD__ && __FreeBSD_version >= 300000) */ 15977c478bd9Sstevel@tonic-gate # include <vm/vm_kern.h> 15987c478bd9Sstevel@tonic-gate # endif /* !__FreeBSD__ || (__FreeBSD__ && __FreeBSD_version >= 300000) */ 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate # ifdef IPFILTER_M_IPFILTER 16017c478bd9Sstevel@tonic-gate # include <sys/malloc.h> 16027c478bd9Sstevel@tonic-gate MALLOC_DECLARE(M_IPFILTER); 1603ab25eeb5Syz # define _M_IPF M_IPFILTER 16047c478bd9Sstevel@tonic-gate # else /* IPFILTER_M_IPFILTER */ 16057c478bd9Sstevel@tonic-gate # ifdef M_PFIL 1606ab25eeb5Syz # define _M_IPF M_PFIL 1607ab25eeb5Syz # else 1608ab25eeb5Syz # ifdef M_IPFILTER 1609ab25eeb5Syz # define _M_IPF M_IPFILTER 1610ab25eeb5Syz # else 1611ab25eeb5Syz # define _M_IPF M_TEMP 1612ab25eeb5Syz # endif /* M_IPFILTER */ 16137c478bd9Sstevel@tonic-gate # endif /* M_PFIL */ 16147c478bd9Sstevel@tonic-gate # endif /* IPFILTER_M_IPFILTER */ 1615ab25eeb5Syz # define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), _M_IPF, M_NOWAIT) 1616ab25eeb5Syz # define KMALLOCS(a, b, c) MALLOC((a), b, (c), _M_IPF, M_NOWAIT) 1617ab25eeb5Syz # define KFREE(x) FREE((x), _M_IPF) 1618ab25eeb5Syz # define KFREES(x,s) FREE((x), _M_IPF) 16197c478bd9Sstevel@tonic-gate # define UIOMOVE(a,b,c,d) uiomove(a,b,d) 16207c478bd9Sstevel@tonic-gate # define SLEEP(id, n) tsleep((id), PPAUSE|PCATCH, n, 0) 1621ab25eeb5Syz # define WAKEUP(id,x) wakeup(id+x) 1622f4b3ec61Sdh # define GETIFP(n, v, ifs) ifunit(n) 16237c478bd9Sstevel@tonic-gate # endif /* (Free)BSD */ 16247c478bd9Sstevel@tonic-gate 1625ab25eeb5Syz # if !defined(USE_MUTEXES) && !defined(SPL_NET) 16267c478bd9Sstevel@tonic-gate # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199407)) || \ 16277c478bd9Sstevel@tonic-gate (defined(OpenBSD) && (OpenBSD >= 200006)) 16287c478bd9Sstevel@tonic-gate # define SPL_NET(x) x = splsoftnet() 16297c478bd9Sstevel@tonic-gate # else 16307c478bd9Sstevel@tonic-gate # define SPL_IMP(x) x = splimp() 16317c478bd9Sstevel@tonic-gate # define SPL_NET(x) x = splnet() 16327c478bd9Sstevel@tonic-gate # endif /* NetBSD && (NetBSD <= 1991011) && (NetBSD >= 199407) */ 16337c478bd9Sstevel@tonic-gate # define SPL_X(x) (void) splx(x) 16347c478bd9Sstevel@tonic-gate # endif /* !USE_MUTEXES */ 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate # ifndef FREE_MB_T 16377c478bd9Sstevel@tonic-gate # define FREE_MB_T(m) m_freem(m) 16387c478bd9Sstevel@tonic-gate # endif 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate # ifndef MTOD 16417c478bd9Sstevel@tonic-gate # define MTOD(m,t) mtod(m,t) 16427c478bd9Sstevel@tonic-gate # endif 16437c478bd9Sstevel@tonic-gate 16447c478bd9Sstevel@tonic-gate # ifndef COPYIN 16457c478bd9Sstevel@tonic-gate # define COPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 16467c478bd9Sstevel@tonic-gate # define COPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 16477c478bd9Sstevel@tonic-gate # define BCOPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 16487c478bd9Sstevel@tonic-gate # define BCOPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 16497c478bd9Sstevel@tonic-gate # endif 16507c478bd9Sstevel@tonic-gate 16517c478bd9Sstevel@tonic-gate # ifndef KMALLOC 16527c478bd9Sstevel@tonic-gate # define KMALLOC(a,b) (a) = (b)new_kmem_alloc(sizeof(*(a)), \ 16537c478bd9Sstevel@tonic-gate KMEM_NOSLEEP) 16547c478bd9Sstevel@tonic-gate # define KMALLOCS(a,b,c) (a) = (b)new_kmem_alloc((c), KMEM_NOSLEEP) 16557c478bd9Sstevel@tonic-gate # endif 16567c478bd9Sstevel@tonic-gate 16577c478bd9Sstevel@tonic-gate # ifndef GET_MINOR 16587c478bd9Sstevel@tonic-gate # define GET_MINOR(x) minor(x) 16597c478bd9Sstevel@tonic-gate # endif 1660ab25eeb5Syz # define PANIC(x,y) if (x) panic y 16617c478bd9Sstevel@tonic-gate #endif /* _KERNEL */ 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate #ifndef IFNAME 16647c478bd9Sstevel@tonic-gate # define IFNAME(x) ((struct ifnet *)x)->if_name 16657c478bd9Sstevel@tonic-gate #endif 16667c478bd9Sstevel@tonic-gate #ifndef COPYIFNAME 16677c478bd9Sstevel@tonic-gate # define NEED_FRGETIFNAME 16687c478bd9Sstevel@tonic-gate extern char *fr_getifname __P((struct ifnet *, char *)); 1669381a2a9aSdr # define COPYIFNAME(x, b, v) \ 16707c478bd9Sstevel@tonic-gate fr_getifname((struct ifnet *)x, b) 16717c478bd9Sstevel@tonic-gate #endif 16727c478bd9Sstevel@tonic-gate 1673ab25eeb5Syz #ifndef ASSERT 1674ab25eeb5Syz # define ASSERT(x) 1675ab25eeb5Syz #endif 16767c478bd9Sstevel@tonic-gate 1677ab25eeb5Syz /* 1678ab25eeb5Syz * Because the ctype(3) posix definition, if used "safely" in code everywhere, 1679ab25eeb5Syz * would mean all normal code that walks through strings needed casts. Yuck. 1680ab25eeb5Syz */ 1681ab25eeb5Syz #define ISALNUM(x) isalnum((u_char)(x)) 1682ab25eeb5Syz #define ISALPHA(x) isalpha((u_char)(x)) 1683ab25eeb5Syz #define ISASCII(x) isascii((u_char)(x)) 1684ab25eeb5Syz #define ISDIGIT(x) isdigit((u_char)(x)) 1685ab25eeb5Syz #define ISPRINT(x) isprint((u_char)(x)) 1686ab25eeb5Syz #define ISSPACE(x) isspace((u_char)(x)) 1687ab25eeb5Syz #define ISUPPER(x) isupper((u_char)(x)) 1688ab25eeb5Syz #define ISXDIGIT(x) isxdigit((u_char)(x)) 1689ab25eeb5Syz #define ISLOWER(x) islower((u_char)(x)) 1690ab25eeb5Syz #define TOUPPER(x) toupper((u_char)(x)) 1691ab25eeb5Syz #define TOLOWER(x) tolower((u_char)(x)) 1692ab25eeb5Syz 1693ab25eeb5Syz /* 1694ab25eeb5Syz * If mutexes aren't being used, turn all the mutex functions into null-ops. 1695ab25eeb5Syz */ 16967c478bd9Sstevel@tonic-gate #if !defined(USE_MUTEXES) 16977c478bd9Sstevel@tonic-gate # define USE_SPL 1 16987c478bd9Sstevel@tonic-gate # undef RW_DESTROY 16997c478bd9Sstevel@tonic-gate # undef MUTEX_INIT 17007c478bd9Sstevel@tonic-gate # undef MUTEX_NUKE 17017c478bd9Sstevel@tonic-gate # undef MUTEX_DESTROY 17027c478bd9Sstevel@tonic-gate # define MUTEX_ENTER(x) ; 17037c478bd9Sstevel@tonic-gate # define READ_ENTER(x) ; 17047c478bd9Sstevel@tonic-gate # define WRITE_ENTER(x) ; 17057c478bd9Sstevel@tonic-gate # define MUTEX_DOWNGRADE(x) ; 17067c478bd9Sstevel@tonic-gate # define RWLOCK_INIT(x, y) ; 17077c478bd9Sstevel@tonic-gate # define RWLOCK_EXIT(x) ; 17087c478bd9Sstevel@tonic-gate # define RW_DESTROY(x) ; 17097c478bd9Sstevel@tonic-gate # define MUTEX_EXIT(x) ; 17107c478bd9Sstevel@tonic-gate # define MUTEX_INIT(x,y) ; 17117c478bd9Sstevel@tonic-gate # define MUTEX_DESTROY(x) ; 17127c478bd9Sstevel@tonic-gate # define MUTEX_NUKE(x) ; 17137c478bd9Sstevel@tonic-gate #endif /* !USE_MUTEXES */ 17147c478bd9Sstevel@tonic-gate #ifndef ATOMIC_INC 17157c478bd9Sstevel@tonic-gate # define ATOMIC_INC(x) (x)++ 17167c478bd9Sstevel@tonic-gate # define ATOMIC_DEC(x) (x)-- 17177c478bd9Sstevel@tonic-gate #endif 17187c478bd9Sstevel@tonic-gate 1719ab25eeb5Syz #if defined(USE_SPL) && defined(_KERNEL) 1720ab25eeb5Syz # define SPL_INT(x) int x 1721ab25eeb5Syz #else 1722ab25eeb5Syz # define SPL_INT(x) 1723ab25eeb5Syz #endif 1724ab25eeb5Syz 17257c478bd9Sstevel@tonic-gate /* 1726ab25eeb5Syz * If there are no atomic operations for bit sizes defined, define them to all 1727ab25eeb5Syz * use a generic one that works for all sizes. 17287c478bd9Sstevel@tonic-gate */ 17297c478bd9Sstevel@tonic-gate #ifndef ATOMIC_INCL 17307c478bd9Sstevel@tonic-gate # define ATOMIC_INCL ATOMIC_INC 17317c478bd9Sstevel@tonic-gate # define ATOMIC_INC64 ATOMIC_INC 17327c478bd9Sstevel@tonic-gate # define ATOMIC_INC32 ATOMIC_INC 17337c478bd9Sstevel@tonic-gate # define ATOMIC_INC16 ATOMIC_INC 17347c478bd9Sstevel@tonic-gate # define ATOMIC_DECL ATOMIC_DEC 17357c478bd9Sstevel@tonic-gate # define ATOMIC_DEC64 ATOMIC_DEC 17367c478bd9Sstevel@tonic-gate # define ATOMIC_DEC32 ATOMIC_DEC 17377c478bd9Sstevel@tonic-gate # define ATOMIC_DEC16 ATOMIC_DEC 17387c478bd9Sstevel@tonic-gate #endif 17397c478bd9Sstevel@tonic-gate 1740ab25eeb5Syz #ifndef HDR_T_PRIVATE 17417c478bd9Sstevel@tonic-gate typedef struct tcphdr tcphdr_t; 17427c478bd9Sstevel@tonic-gate typedef struct udphdr udphdr_t; 1743ab25eeb5Syz #endif 17447c478bd9Sstevel@tonic-gate typedef struct icmp icmphdr_t; 17457c478bd9Sstevel@tonic-gate typedef struct ip ip_t; 17467c478bd9Sstevel@tonic-gate typedef struct ether_header ether_header_t; 17477c478bd9Sstevel@tonic-gate typedef struct tcpiphdr tcpiphdr_t; 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate #ifndef FR_GROUPLEN 17507c478bd9Sstevel@tonic-gate # define FR_GROUPLEN 16 17517c478bd9Sstevel@tonic-gate #endif 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate #ifdef offsetof 17547c478bd9Sstevel@tonic-gate # undef offsetof 17557c478bd9Sstevel@tonic-gate #endif 17567c478bd9Sstevel@tonic-gate #ifndef offsetof 17577c478bd9Sstevel@tonic-gate # define offsetof(t,m) (int)((&((t *)0L)->m)) 17587c478bd9Sstevel@tonic-gate #endif 17597c478bd9Sstevel@tonic-gate 1760ab25eeb5Syz /* 1761ab25eeb5Syz * This set of macros has been brought about because on Tru64 it is not 1762ab25eeb5Syz * possible to easily assign or examine values in a structure that are 1763ab25eeb5Syz * bit fields. 1764ab25eeb5Syz */ 17657c478bd9Sstevel@tonic-gate #ifndef IP_V 17667c478bd9Sstevel@tonic-gate # define IP_V(x) (x)->ip_v 17677c478bd9Sstevel@tonic-gate #endif 17687c478bd9Sstevel@tonic-gate #ifndef IP_V_A 17697c478bd9Sstevel@tonic-gate # define IP_V_A(x,y) (x)->ip_v = (y) 17707c478bd9Sstevel@tonic-gate #endif 17717c478bd9Sstevel@tonic-gate #ifndef IP_HL 17727c478bd9Sstevel@tonic-gate # define IP_HL(x) (x)->ip_hl 17737c478bd9Sstevel@tonic-gate #endif 17747c478bd9Sstevel@tonic-gate #ifndef IP_HL_A 17757c478bd9Sstevel@tonic-gate # define IP_HL_A(x,y) (x)->ip_hl = (y) 17767c478bd9Sstevel@tonic-gate #endif 1777ab25eeb5Syz #ifndef TCP_X2 1778ab25eeb5Syz # define TCP_X2(x) (x)->th_x2 1779ab25eeb5Syz #endif 1780ab25eeb5Syz #ifndef TCP_X2_A 1781ab25eeb5Syz # define TCP_X2_A(x,y) (x)->th_x2 = (y) 1782ab25eeb5Syz #endif 17837c478bd9Sstevel@tonic-gate #ifndef TCP_OFF 17847c478bd9Sstevel@tonic-gate # define TCP_OFF(x) (x)->th_off 17857c478bd9Sstevel@tonic-gate #endif 17867c478bd9Sstevel@tonic-gate #ifndef TCP_OFF_A 17877c478bd9Sstevel@tonic-gate # define TCP_OFF_A(x,y) (x)->th_off = (y) 17887c478bd9Sstevel@tonic-gate #endif 17897c478bd9Sstevel@tonic-gate #define IPMINLEN(i, h) ((i)->ip_len >= (IP_HL(i) * 4 + sizeof(struct h))) 17907c478bd9Sstevel@tonic-gate 17917c478bd9Sstevel@tonic-gate 17927c478bd9Sstevel@tonic-gate /* 17937c478bd9Sstevel@tonic-gate * XXX - This is one of those *awful* hacks which nobody likes 17947c478bd9Sstevel@tonic-gate */ 17957c478bd9Sstevel@tonic-gate #ifdef ultrix 17967c478bd9Sstevel@tonic-gate #define A_A 17977c478bd9Sstevel@tonic-gate #else 17987c478bd9Sstevel@tonic-gate #define A_A & 17997c478bd9Sstevel@tonic-gate #endif 18007c478bd9Sstevel@tonic-gate 18017c478bd9Sstevel@tonic-gate #define TCPF_ALL (TH_FIN|TH_SYN|TH_RST|TH_PUSH|TH_ACK|TH_URG|\ 18027c478bd9Sstevel@tonic-gate TH_ECN|TH_CWR) 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate #if (BSD >= 199306) && !defined(m_act) 18057c478bd9Sstevel@tonic-gate # define m_act m_nextpkt 18067c478bd9Sstevel@tonic-gate #endif 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate /* 18097c478bd9Sstevel@tonic-gate * Security Options for Intenet Protocol (IPSO) as defined in RFC 1108. 18107c478bd9Sstevel@tonic-gate * 18117c478bd9Sstevel@tonic-gate * Basic Option 18127c478bd9Sstevel@tonic-gate * 18137c478bd9Sstevel@tonic-gate * 00000001 - (Reserved 4) 18147c478bd9Sstevel@tonic-gate * 00111101 - Top Secret 18157c478bd9Sstevel@tonic-gate * 01011010 - Secret 18167c478bd9Sstevel@tonic-gate * 10010110 - Confidential 18177c478bd9Sstevel@tonic-gate * 01100110 - (Reserved 3) 18187c478bd9Sstevel@tonic-gate * 11001100 - (Reserved 2) 18197c478bd9Sstevel@tonic-gate * 10101011 - Unclassified 18207c478bd9Sstevel@tonic-gate * 11110001 - (Reserved 1) 18217c478bd9Sstevel@tonic-gate */ 18227c478bd9Sstevel@tonic-gate #define IPSO_CLASS_RES4 0x01 18237c478bd9Sstevel@tonic-gate #define IPSO_CLASS_TOPS 0x3d 18247c478bd9Sstevel@tonic-gate #define IPSO_CLASS_SECR 0x5a 18257c478bd9Sstevel@tonic-gate #define IPSO_CLASS_CONF 0x96 18267c478bd9Sstevel@tonic-gate #define IPSO_CLASS_RES3 0x66 18277c478bd9Sstevel@tonic-gate #define IPSO_CLASS_RES2 0xcc 18287c478bd9Sstevel@tonic-gate #define IPSO_CLASS_UNCL 0xab 18297c478bd9Sstevel@tonic-gate #define IPSO_CLASS_RES1 0xf1 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate #define IPSO_AUTH_GENSER 0x80 18327c478bd9Sstevel@tonic-gate #define IPSO_AUTH_ESI 0x40 18337c478bd9Sstevel@tonic-gate #define IPSO_AUTH_SCI 0x20 18347c478bd9Sstevel@tonic-gate #define IPSO_AUTH_NSA 0x10 18357c478bd9Sstevel@tonic-gate #define IPSO_AUTH_DOE 0x08 18367c478bd9Sstevel@tonic-gate #define IPSO_AUTH_UN 0x06 18377c478bd9Sstevel@tonic-gate #define IPSO_AUTH_FTE 0x01 18387c478bd9Sstevel@tonic-gate 18397c478bd9Sstevel@tonic-gate /* 18407c478bd9Sstevel@tonic-gate * IP option #defines 18417c478bd9Sstevel@tonic-gate */ 18427c478bd9Sstevel@tonic-gate #undef IPOPT_RR 18437c478bd9Sstevel@tonic-gate #define IPOPT_RR 7 1844ab25eeb5Syz #undef IPOPT_ZSU 18457c478bd9Sstevel@tonic-gate #define IPOPT_ZSU 10 /* ZSU */ 1846ab25eeb5Syz #undef IPOPT_MTUP 18477c478bd9Sstevel@tonic-gate #define IPOPT_MTUP 11 /* MTUP */ 1848ab25eeb5Syz #undef IPOPT_MTUR 18497c478bd9Sstevel@tonic-gate #define IPOPT_MTUR 12 /* MTUR */ 1850ab25eeb5Syz #undef IPOPT_ENCODE 18517c478bd9Sstevel@tonic-gate #define IPOPT_ENCODE 15 /* ENCODE */ 18527c478bd9Sstevel@tonic-gate #undef IPOPT_TS 18537c478bd9Sstevel@tonic-gate #define IPOPT_TS 68 1854ab25eeb5Syz #undef IPOPT_TR 18557c478bd9Sstevel@tonic-gate #define IPOPT_TR 82 /* TR */ 18567c478bd9Sstevel@tonic-gate #undef IPOPT_SECURITY 18577c478bd9Sstevel@tonic-gate #define IPOPT_SECURITY 130 18587c478bd9Sstevel@tonic-gate #undef IPOPT_LSRR 18597c478bd9Sstevel@tonic-gate #define IPOPT_LSRR 131 1860ab25eeb5Syz #undef IPOPT_E_SEC 18617c478bd9Sstevel@tonic-gate #define IPOPT_E_SEC 133 /* E-SEC */ 186245916cd2Sjpk #undef IPOPT_CIPSO 18637c478bd9Sstevel@tonic-gate #define IPOPT_CIPSO 134 /* CIPSO */ 18647c478bd9Sstevel@tonic-gate #undef IPOPT_SATID 18657c478bd9Sstevel@tonic-gate #define IPOPT_SATID 136 18667c478bd9Sstevel@tonic-gate #ifndef IPOPT_SID 18677c478bd9Sstevel@tonic-gate # define IPOPT_SID IPOPT_SATID 18687c478bd9Sstevel@tonic-gate #endif 18697c478bd9Sstevel@tonic-gate #undef IPOPT_SSRR 18707c478bd9Sstevel@tonic-gate #define IPOPT_SSRR 137 1871ab25eeb5Syz #undef IPOPT_ADDEXT 18727c478bd9Sstevel@tonic-gate #define IPOPT_ADDEXT 147 /* ADDEXT */ 1873ab25eeb5Syz #undef IPOPT_VISA 18747c478bd9Sstevel@tonic-gate #define IPOPT_VISA 142 /* VISA */ 1875ab25eeb5Syz #undef IPOPT_IMITD 18767c478bd9Sstevel@tonic-gate #define IPOPT_IMITD 144 /* IMITD */ 1877ab25eeb5Syz #undef IPOPT_EIP 18787c478bd9Sstevel@tonic-gate #define IPOPT_EIP 145 /* EIP */ 1879ab25eeb5Syz #undef IPOPT_RTRALRT 18807c478bd9Sstevel@tonic-gate #define IPOPT_RTRALRT 148 /* RTRALRT */ 1881ab25eeb5Syz #undef IPOPT_SDB 18827c478bd9Sstevel@tonic-gate #define IPOPT_SDB 149 1883ab25eeb5Syz #undef IPOPT_NSAPA 18847c478bd9Sstevel@tonic-gate #define IPOPT_NSAPA 150 1885ab25eeb5Syz #undef IPOPT_DPS 18867c478bd9Sstevel@tonic-gate #define IPOPT_DPS 151 1887ab25eeb5Syz #undef IPOPT_UMP 18887c478bd9Sstevel@tonic-gate #define IPOPT_UMP 152 1889ab25eeb5Syz #undef IPOPT_FINN 18907c478bd9Sstevel@tonic-gate #define IPOPT_FINN 205 /* FINN */ 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate #ifndef TCPOPT_EOL 18937c478bd9Sstevel@tonic-gate # define TCPOPT_EOL 0 18947c478bd9Sstevel@tonic-gate #endif 18957c478bd9Sstevel@tonic-gate #ifndef TCPOPT_NOP 18967c478bd9Sstevel@tonic-gate # define TCPOPT_NOP 1 18977c478bd9Sstevel@tonic-gate #endif 18987c478bd9Sstevel@tonic-gate #ifndef TCPOPT_MAXSEG 18997c478bd9Sstevel@tonic-gate # define TCPOPT_MAXSEG 2 19007c478bd9Sstevel@tonic-gate #endif 19017c478bd9Sstevel@tonic-gate #ifndef TCPOLEN_MAXSEG 19027c478bd9Sstevel@tonic-gate # define TCPOLEN_MAXSEG 4 19037c478bd9Sstevel@tonic-gate #endif 19047c478bd9Sstevel@tonic-gate #ifndef TCPOPT_WINDOW 19057c478bd9Sstevel@tonic-gate # define TCPOPT_WINDOW 3 19067c478bd9Sstevel@tonic-gate #endif 19077c478bd9Sstevel@tonic-gate #ifndef TCPOLEN_WINDOW 19087c478bd9Sstevel@tonic-gate # define TCPOLEN_WINDOW 3 19097c478bd9Sstevel@tonic-gate #endif 19107c478bd9Sstevel@tonic-gate #ifndef TCPOPT_SACK_PERMITTED 19117c478bd9Sstevel@tonic-gate # define TCPOPT_SACK_PERMITTED 4 19127c478bd9Sstevel@tonic-gate #endif 19137c478bd9Sstevel@tonic-gate #ifndef TCPOLEN_SACK_PERMITTED 19147c478bd9Sstevel@tonic-gate # define TCPOLEN_SACK_PERMITTED 2 19157c478bd9Sstevel@tonic-gate #endif 19167c478bd9Sstevel@tonic-gate #ifndef TCPOPT_SACK 19177c478bd9Sstevel@tonic-gate # define TCPOPT_SACK 5 19187c478bd9Sstevel@tonic-gate #endif 19197c478bd9Sstevel@tonic-gate #ifndef TCPOPT_TIMESTAMP 19207c478bd9Sstevel@tonic-gate # define TCPOPT_TIMESTAMP 8 19217c478bd9Sstevel@tonic-gate #endif 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate #ifndef ICMP_MINLEN 19247c478bd9Sstevel@tonic-gate # define ICMP_MINLEN 8 19257c478bd9Sstevel@tonic-gate #endif 19267c478bd9Sstevel@tonic-gate #ifndef ICMP_ECHOREPLY 19277c478bd9Sstevel@tonic-gate # define ICMP_ECHOREPLY 0 19287c478bd9Sstevel@tonic-gate #endif 19297c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH 19307c478bd9Sstevel@tonic-gate # define ICMP_UNREACH 3 19317c478bd9Sstevel@tonic-gate #endif 19327c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_NET 19337c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_NET 0 19347c478bd9Sstevel@tonic-gate #endif 19357c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_HOST 19367c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_HOST 1 19377c478bd9Sstevel@tonic-gate #endif 19387c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_PROTOCOL 19397c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_PROTOCOL 2 19407c478bd9Sstevel@tonic-gate #endif 19417c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_PORT 19427c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_PORT 3 19437c478bd9Sstevel@tonic-gate #endif 19447c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_NEEDFRAG 19457c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_NEEDFRAG 4 19467c478bd9Sstevel@tonic-gate #endif 19477c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_SRCFAIL 19487c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_SRCFAIL 5 19497c478bd9Sstevel@tonic-gate #endif 19507c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_NET_UNKNOWN 19517c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_NET_UNKNOWN 6 19527c478bd9Sstevel@tonic-gate #endif 19537c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_HOST_UNKNOWN 19547c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_HOST_UNKNOWN 7 19557c478bd9Sstevel@tonic-gate #endif 19567c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_ISOLATED 19577c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_ISOLATED 8 19587c478bd9Sstevel@tonic-gate #endif 19597c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_NET_PROHIB 19607c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_NET_PROHIB 9 19617c478bd9Sstevel@tonic-gate #endif 19627c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_HOST_PROHIB 19637c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_HOST_PROHIB 10 19647c478bd9Sstevel@tonic-gate #endif 19657c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_TOSNET 19667c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_TOSNET 11 19677c478bd9Sstevel@tonic-gate #endif 19687c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_TOSHOST 19697c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_TOSHOST 12 19707c478bd9Sstevel@tonic-gate #endif 19717c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_ADMIN_PROHIBIT 19727c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_ADMIN_PROHIBIT 13 19737c478bd9Sstevel@tonic-gate #endif 19747c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_FILTER 19757c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_FILTER 13 19767c478bd9Sstevel@tonic-gate #endif 19777c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_HOST_PRECEDENCE 19787c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_HOST_PRECEDENCE 14 19797c478bd9Sstevel@tonic-gate #endif 19807c478bd9Sstevel@tonic-gate #ifndef ICMP_UNREACH_PRECEDENCE_CUTOFF 19817c478bd9Sstevel@tonic-gate # define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 19827c478bd9Sstevel@tonic-gate #endif 19837c478bd9Sstevel@tonic-gate #ifndef ICMP_SOURCEQUENCH 19847c478bd9Sstevel@tonic-gate # define ICMP_SOURCEQUENCH 4 19857c478bd9Sstevel@tonic-gate #endif 19867c478bd9Sstevel@tonic-gate #ifndef ICMP_REDIRECT_NET 19877c478bd9Sstevel@tonic-gate # define ICMP_REDIRECT_NET 0 19887c478bd9Sstevel@tonic-gate #endif 19897c478bd9Sstevel@tonic-gate #ifndef ICMP_REDIRECT_HOST 19907c478bd9Sstevel@tonic-gate # define ICMP_REDIRECT_HOST 1 19917c478bd9Sstevel@tonic-gate #endif 19927c478bd9Sstevel@tonic-gate #ifndef ICMP_REDIRECT_TOSNET 19937c478bd9Sstevel@tonic-gate # define ICMP_REDIRECT_TOSNET 2 19947c478bd9Sstevel@tonic-gate #endif 19957c478bd9Sstevel@tonic-gate #ifndef ICMP_REDIRECT_TOSHOST 19967c478bd9Sstevel@tonic-gate # define ICMP_REDIRECT_TOSHOST 3 19977c478bd9Sstevel@tonic-gate #endif 19987c478bd9Sstevel@tonic-gate #ifndef ICMP_ALTHOSTADDR 19997c478bd9Sstevel@tonic-gate # define ICMP_ALTHOSTADDR 6 20007c478bd9Sstevel@tonic-gate #endif 20017c478bd9Sstevel@tonic-gate #ifndef ICMP_TIMXCEED 20027c478bd9Sstevel@tonic-gate # define ICMP_TIMXCEED 11 20037c478bd9Sstevel@tonic-gate #endif 20047c478bd9Sstevel@tonic-gate #ifndef ICMP_TIMXCEED_INTRANS 20057c478bd9Sstevel@tonic-gate # define ICMP_TIMXCEED_INTRANS 0 20067c478bd9Sstevel@tonic-gate #endif 20077c478bd9Sstevel@tonic-gate #ifndef ICMP_TIMXCEED_REASS 20087c478bd9Sstevel@tonic-gate # define ICMP_TIMXCEED_REASS 1 20097c478bd9Sstevel@tonic-gate #endif 20107c478bd9Sstevel@tonic-gate #ifndef ICMP_PARAMPROB 20117c478bd9Sstevel@tonic-gate # define ICMP_PARAMPROB 12 20127c478bd9Sstevel@tonic-gate #endif 20137c478bd9Sstevel@tonic-gate #ifndef ICMP_PARAMPROB_ERRATPTR 20147c478bd9Sstevel@tonic-gate # define ICMP_PARAMPROB_ERRATPTR 0 20157c478bd9Sstevel@tonic-gate #endif 20167c478bd9Sstevel@tonic-gate #ifndef ICMP_PARAMPROB_OPTABSENT 20177c478bd9Sstevel@tonic-gate # define ICMP_PARAMPROB_OPTABSENT 1 20187c478bd9Sstevel@tonic-gate #endif 20197c478bd9Sstevel@tonic-gate #ifndef ICMP_PARAMPROB_LENGTH 20207c478bd9Sstevel@tonic-gate # define ICMP_PARAMPROB_LENGTH 2 20217c478bd9Sstevel@tonic-gate #endif 20227c478bd9Sstevel@tonic-gate #ifndef ICMP_TSTAMP 20237c478bd9Sstevel@tonic-gate # define ICMP_TSTAMP 13 20247c478bd9Sstevel@tonic-gate #endif 20257c478bd9Sstevel@tonic-gate #ifndef ICMP_TSTAMPREPLY 20267c478bd9Sstevel@tonic-gate # define ICMP_TSTAMPREPLY 14 20277c478bd9Sstevel@tonic-gate #endif 20287c478bd9Sstevel@tonic-gate #ifndef ICMP_IREQ 20297c478bd9Sstevel@tonic-gate # define ICMP_IREQ 15 20307c478bd9Sstevel@tonic-gate #endif 20317c478bd9Sstevel@tonic-gate #ifndef ICMP_IREQREPLY 20327c478bd9Sstevel@tonic-gate # define ICMP_IREQREPLY 16 20337c478bd9Sstevel@tonic-gate #endif 20347c478bd9Sstevel@tonic-gate #ifndef ICMP_MASKREQ 20357c478bd9Sstevel@tonic-gate # define ICMP_MASKREQ 17 20367c478bd9Sstevel@tonic-gate #endif 20377c478bd9Sstevel@tonic-gate #ifndef ICMP_MASKREPLY 20387c478bd9Sstevel@tonic-gate # define ICMP_MASKREPLY 18 20397c478bd9Sstevel@tonic-gate #endif 20407c478bd9Sstevel@tonic-gate #ifndef ICMP_TRACEROUTE 20417c478bd9Sstevel@tonic-gate # define ICMP_TRACEROUTE 30 20427c478bd9Sstevel@tonic-gate #endif 20437c478bd9Sstevel@tonic-gate #ifndef ICMP_DATACONVERR 20447c478bd9Sstevel@tonic-gate # define ICMP_DATACONVERR 31 20457c478bd9Sstevel@tonic-gate #endif 20467c478bd9Sstevel@tonic-gate #ifndef ICMP_MOBILE_REDIRECT 20477c478bd9Sstevel@tonic-gate # define ICMP_MOBILE_REDIRECT 32 20487c478bd9Sstevel@tonic-gate #endif 20497c478bd9Sstevel@tonic-gate #ifndef ICMP_IPV6_WHEREAREYOU 20507c478bd9Sstevel@tonic-gate # define ICMP_IPV6_WHEREAREYOU 33 20517c478bd9Sstevel@tonic-gate #endif 20527c478bd9Sstevel@tonic-gate #ifndef ICMP_IPV6_IAMHERE 20537c478bd9Sstevel@tonic-gate # define ICMP_IPV6_IAMHERE 34 20547c478bd9Sstevel@tonic-gate #endif 20557c478bd9Sstevel@tonic-gate #ifndef ICMP_MOBILE_REGREQUEST 20567c478bd9Sstevel@tonic-gate # define ICMP_MOBILE_REGREQUEST 35 20577c478bd9Sstevel@tonic-gate #endif 20587c478bd9Sstevel@tonic-gate #ifndef ICMP_MOBILE_REGREPLY 20597c478bd9Sstevel@tonic-gate # define ICMP_MOBILE_REGREPLY 36 20607c478bd9Sstevel@tonic-gate #endif 20617c478bd9Sstevel@tonic-gate #ifndef ICMP_SKIP 20627c478bd9Sstevel@tonic-gate # define ICMP_SKIP 39 20637c478bd9Sstevel@tonic-gate #endif 20647c478bd9Sstevel@tonic-gate #ifndef ICMP_PHOTURIS 20657c478bd9Sstevel@tonic-gate # define ICMP_PHOTURIS 40 20667c478bd9Sstevel@tonic-gate #endif 20677c478bd9Sstevel@tonic-gate #ifndef ICMP_PHOTURIS_UNKNOWN_INDEX 20687c478bd9Sstevel@tonic-gate # define ICMP_PHOTURIS_UNKNOWN_INDEX 1 20697c478bd9Sstevel@tonic-gate #endif 20707c478bd9Sstevel@tonic-gate #ifndef ICMP_PHOTURIS_AUTH_FAILED 20717c478bd9Sstevel@tonic-gate # define ICMP_PHOTURIS_AUTH_FAILED 2 20727c478bd9Sstevel@tonic-gate #endif 20737c478bd9Sstevel@tonic-gate #ifndef ICMP_PHOTURIS_DECRYPT_FAILED 20747c478bd9Sstevel@tonic-gate # define ICMP_PHOTURIS_DECRYPT_FAILED 3 20757c478bd9Sstevel@tonic-gate #endif 20767c478bd9Sstevel@tonic-gate #ifndef IPVERSION 20777c478bd9Sstevel@tonic-gate # define IPVERSION 4 20787c478bd9Sstevel@tonic-gate #endif 20797c478bd9Sstevel@tonic-gate #ifndef IPOPT_MINOFF 20807c478bd9Sstevel@tonic-gate # define IPOPT_MINOFF 4 20817c478bd9Sstevel@tonic-gate #endif 20827c478bd9Sstevel@tonic-gate #ifndef IPOPT_COPIED 20837c478bd9Sstevel@tonic-gate # define IPOPT_COPIED(x) ((x)&0x80) 20847c478bd9Sstevel@tonic-gate #endif 20857c478bd9Sstevel@tonic-gate #ifndef IPOPT_EOL 20867c478bd9Sstevel@tonic-gate # define IPOPT_EOL 0 20877c478bd9Sstevel@tonic-gate #endif 20887c478bd9Sstevel@tonic-gate #ifndef IPOPT_NOP 20897c478bd9Sstevel@tonic-gate # define IPOPT_NOP 1 20907c478bd9Sstevel@tonic-gate #endif 20917c478bd9Sstevel@tonic-gate #ifndef IP_MF 20927c478bd9Sstevel@tonic-gate # define IP_MF ((u_short)0x2000) 20937c478bd9Sstevel@tonic-gate #endif 20947c478bd9Sstevel@tonic-gate #ifndef ETHERTYPE_IP 20957c478bd9Sstevel@tonic-gate # define ETHERTYPE_IP ((u_short)0x0800) 20967c478bd9Sstevel@tonic-gate #endif 20977c478bd9Sstevel@tonic-gate #ifndef TH_FIN 20987c478bd9Sstevel@tonic-gate # define TH_FIN 0x01 20997c478bd9Sstevel@tonic-gate #endif 21007c478bd9Sstevel@tonic-gate #ifndef TH_SYN 21017c478bd9Sstevel@tonic-gate # define TH_SYN 0x02 21027c478bd9Sstevel@tonic-gate #endif 21037c478bd9Sstevel@tonic-gate #ifndef TH_RST 21047c478bd9Sstevel@tonic-gate # define TH_RST 0x04 21057c478bd9Sstevel@tonic-gate #endif 21067c478bd9Sstevel@tonic-gate #ifndef TH_PUSH 21077c478bd9Sstevel@tonic-gate # define TH_PUSH 0x08 21087c478bd9Sstevel@tonic-gate #endif 21097c478bd9Sstevel@tonic-gate #ifndef TH_ACK 21107c478bd9Sstevel@tonic-gate # define TH_ACK 0x10 21117c478bd9Sstevel@tonic-gate #endif 21127c478bd9Sstevel@tonic-gate #ifndef TH_URG 21137c478bd9Sstevel@tonic-gate # define TH_URG 0x20 21147c478bd9Sstevel@tonic-gate #endif 21157c478bd9Sstevel@tonic-gate #undef TH_ACKMASK 21167c478bd9Sstevel@tonic-gate #define TH_ACKMASK (TH_FIN|TH_SYN|TH_RST|TH_ACK) 21177c478bd9Sstevel@tonic-gate 21187c478bd9Sstevel@tonic-gate #ifndef IPOPT_EOL 21197c478bd9Sstevel@tonic-gate # define IPOPT_EOL 0 21207c478bd9Sstevel@tonic-gate #endif 21217c478bd9Sstevel@tonic-gate #ifndef IPOPT_NOP 21227c478bd9Sstevel@tonic-gate # define IPOPT_NOP 1 21237c478bd9Sstevel@tonic-gate #endif 21247c478bd9Sstevel@tonic-gate #ifndef IPOPT_RR 21257c478bd9Sstevel@tonic-gate # define IPOPT_RR 7 21267c478bd9Sstevel@tonic-gate #endif 21277c478bd9Sstevel@tonic-gate #ifndef IPOPT_TS 21287c478bd9Sstevel@tonic-gate # define IPOPT_TS 68 21297c478bd9Sstevel@tonic-gate #endif 21307c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECURITY 21317c478bd9Sstevel@tonic-gate # define IPOPT_SECURITY 130 21327c478bd9Sstevel@tonic-gate #endif 21337c478bd9Sstevel@tonic-gate #ifndef IPOPT_LSRR 21347c478bd9Sstevel@tonic-gate # define IPOPT_LSRR 131 21357c478bd9Sstevel@tonic-gate #endif 21367c478bd9Sstevel@tonic-gate #ifndef IPOPT_SATID 21377c478bd9Sstevel@tonic-gate # define IPOPT_SATID 136 21387c478bd9Sstevel@tonic-gate #endif 21397c478bd9Sstevel@tonic-gate #ifndef IPOPT_SSRR 21407c478bd9Sstevel@tonic-gate # define IPOPT_SSRR 137 21417c478bd9Sstevel@tonic-gate #endif 21427c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_UNCLASS 21437c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_UNCLASS ((u_short)0x0000) 21447c478bd9Sstevel@tonic-gate #endif 21457c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_CONFID 21467c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_CONFID ((u_short)0xf135) 21477c478bd9Sstevel@tonic-gate #endif 21487c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_EFTO 21497c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_EFTO ((u_short)0x789a) 21507c478bd9Sstevel@tonic-gate #endif 21517c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_MMMM 21527c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_MMMM ((u_short)0xbc4d) 21537c478bd9Sstevel@tonic-gate #endif 21547c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_RESTR 21557c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_RESTR ((u_short)0xaf13) 21567c478bd9Sstevel@tonic-gate #endif 21577c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_SECRET 21587c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_SECRET ((u_short)0xd788) 21597c478bd9Sstevel@tonic-gate #endif 21607c478bd9Sstevel@tonic-gate #ifndef IPOPT_SECUR_TOPSECRET 21617c478bd9Sstevel@tonic-gate # define IPOPT_SECUR_TOPSECRET ((u_short)0x6bc5) 21627c478bd9Sstevel@tonic-gate #endif 21637c478bd9Sstevel@tonic-gate #ifndef IPOPT_OLEN 21647c478bd9Sstevel@tonic-gate # define IPOPT_OLEN 1 21657c478bd9Sstevel@tonic-gate #endif 21667c478bd9Sstevel@tonic-gate #ifndef IPPROTO_HOPOPTS 21677c478bd9Sstevel@tonic-gate # define IPPROTO_HOPOPTS 0 21687c478bd9Sstevel@tonic-gate #endif 21697c478bd9Sstevel@tonic-gate #ifndef IPPROTO_ENCAP 21707c478bd9Sstevel@tonic-gate # define IPPROTO_ENCAP 4 21717c478bd9Sstevel@tonic-gate #endif 21727c478bd9Sstevel@tonic-gate #ifndef IPPROTO_IPV6 21737c478bd9Sstevel@tonic-gate # define IPPROTO_IPV6 41 21747c478bd9Sstevel@tonic-gate #endif 21757c478bd9Sstevel@tonic-gate #ifndef IPPROTO_ROUTING 21767c478bd9Sstevel@tonic-gate # define IPPROTO_ROUTING 43 21777c478bd9Sstevel@tonic-gate #endif 21787c478bd9Sstevel@tonic-gate #ifndef IPPROTO_FRAGMENT 21797c478bd9Sstevel@tonic-gate # define IPPROTO_FRAGMENT 44 21807c478bd9Sstevel@tonic-gate #endif 21817c478bd9Sstevel@tonic-gate #ifndef IPPROTO_GRE 21827c478bd9Sstevel@tonic-gate # define IPPROTO_GRE 47 /* GRE encaps RFC 1701 */ 21837c478bd9Sstevel@tonic-gate #endif 21847c478bd9Sstevel@tonic-gate #ifndef IPPROTO_ESP 21857c478bd9Sstevel@tonic-gate # define IPPROTO_ESP 50 21867c478bd9Sstevel@tonic-gate #endif 21877c478bd9Sstevel@tonic-gate #ifndef IPPROTO_AH 21887c478bd9Sstevel@tonic-gate # define IPPROTO_AH 51 21897c478bd9Sstevel@tonic-gate #endif 21907c478bd9Sstevel@tonic-gate #ifndef IPPROTO_ICMPV6 21917c478bd9Sstevel@tonic-gate # define IPPROTO_ICMPV6 58 21927c478bd9Sstevel@tonic-gate #endif 21937c478bd9Sstevel@tonic-gate #ifndef IPPROTO_NONE 21947c478bd9Sstevel@tonic-gate # define IPPROTO_NONE 59 21957c478bd9Sstevel@tonic-gate #endif 21967c478bd9Sstevel@tonic-gate #ifndef IPPROTO_DSTOPTS 21977c478bd9Sstevel@tonic-gate # define IPPROTO_DSTOPTS 60 21987c478bd9Sstevel@tonic-gate #endif 21997c478bd9Sstevel@tonic-gate #ifndef IPPROTO_FRAGMENT 22007c478bd9Sstevel@tonic-gate # define IPPROTO_FRAGMENT 44 22017c478bd9Sstevel@tonic-gate #endif 22027c478bd9Sstevel@tonic-gate #ifndef ICMP_ROUTERADVERT 22037c478bd9Sstevel@tonic-gate # define ICMP_ROUTERADVERT 9 22047c478bd9Sstevel@tonic-gate #endif 22057c478bd9Sstevel@tonic-gate #ifndef ICMP_ROUTERSOLICIT 22067c478bd9Sstevel@tonic-gate # define ICMP_ROUTERSOLICIT 10 22077c478bd9Sstevel@tonic-gate #endif 22087c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH 22097c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH 1 22107c478bd9Sstevel@tonic-gate #endif 22117c478bd9Sstevel@tonic-gate #ifndef ICMP6_PACKET_TOO_BIG 22127c478bd9Sstevel@tonic-gate # define ICMP6_PACKET_TOO_BIG 2 22137c478bd9Sstevel@tonic-gate #endif 22147c478bd9Sstevel@tonic-gate #ifndef ICMP6_TIME_EXCEEDED 22157c478bd9Sstevel@tonic-gate # define ICMP6_TIME_EXCEEDED 3 22167c478bd9Sstevel@tonic-gate #endif 22177c478bd9Sstevel@tonic-gate #ifndef ICMP6_PARAM_PROB 22187c478bd9Sstevel@tonic-gate # define ICMP6_PARAM_PROB 4 22197c478bd9Sstevel@tonic-gate #endif 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate #ifndef ICMP6_ECHO_REQUEST 22227c478bd9Sstevel@tonic-gate # define ICMP6_ECHO_REQUEST 128 22237c478bd9Sstevel@tonic-gate #endif 22247c478bd9Sstevel@tonic-gate #ifndef ICMP6_ECHO_REPLY 22257c478bd9Sstevel@tonic-gate # define ICMP6_ECHO_REPLY 129 22267c478bd9Sstevel@tonic-gate #endif 22277c478bd9Sstevel@tonic-gate #ifndef ICMP6_MEMBERSHIP_QUERY 22287c478bd9Sstevel@tonic-gate # define ICMP6_MEMBERSHIP_QUERY 130 22297c478bd9Sstevel@tonic-gate #endif 22307c478bd9Sstevel@tonic-gate #ifndef MLD6_LISTENER_QUERY 22317c478bd9Sstevel@tonic-gate # define MLD6_LISTENER_QUERY 130 22327c478bd9Sstevel@tonic-gate #endif 22337c478bd9Sstevel@tonic-gate #ifndef ICMP6_MEMBERSHIP_REPORT 22347c478bd9Sstevel@tonic-gate # define ICMP6_MEMBERSHIP_REPORT 131 22357c478bd9Sstevel@tonic-gate #endif 22367c478bd9Sstevel@tonic-gate #ifndef MLD6_LISTENER_REPORT 22377c478bd9Sstevel@tonic-gate # define MLD6_LISTENER_REPORT 131 22387c478bd9Sstevel@tonic-gate #endif 22397c478bd9Sstevel@tonic-gate #ifndef ICMP6_MEMBERSHIP_REDUCTION 22407c478bd9Sstevel@tonic-gate # define ICMP6_MEMBERSHIP_REDUCTION 132 22417c478bd9Sstevel@tonic-gate #endif 22427c478bd9Sstevel@tonic-gate #ifndef MLD6_LISTENER_DONE 22437c478bd9Sstevel@tonic-gate # define MLD6_LISTENER_DONE 132 22447c478bd9Sstevel@tonic-gate #endif 22457c478bd9Sstevel@tonic-gate #ifndef ND_ROUTER_SOLICIT 22467c478bd9Sstevel@tonic-gate # define ND_ROUTER_SOLICIT 133 22477c478bd9Sstevel@tonic-gate #endif 22487c478bd9Sstevel@tonic-gate #ifndef ND_ROUTER_ADVERT 22497c478bd9Sstevel@tonic-gate # define ND_ROUTER_ADVERT 134 22507c478bd9Sstevel@tonic-gate #endif 22517c478bd9Sstevel@tonic-gate #ifndef ND_NEIGHBOR_SOLICIT 22527c478bd9Sstevel@tonic-gate # define ND_NEIGHBOR_SOLICIT 135 22537c478bd9Sstevel@tonic-gate #endif 22547c478bd9Sstevel@tonic-gate #ifndef ND_NEIGHBOR_ADVERT 22557c478bd9Sstevel@tonic-gate # define ND_NEIGHBOR_ADVERT 136 22567c478bd9Sstevel@tonic-gate #endif 22577c478bd9Sstevel@tonic-gate #ifndef ND_REDIRECT 22587c478bd9Sstevel@tonic-gate # define ND_REDIRECT 137 22597c478bd9Sstevel@tonic-gate #endif 22607c478bd9Sstevel@tonic-gate #ifndef ICMP6_ROUTER_RENUMBERING 22617c478bd9Sstevel@tonic-gate # define ICMP6_ROUTER_RENUMBERING 138 22627c478bd9Sstevel@tonic-gate #endif 22637c478bd9Sstevel@tonic-gate #ifndef ICMP6_WRUREQUEST 22647c478bd9Sstevel@tonic-gate # define ICMP6_WRUREQUEST 139 22657c478bd9Sstevel@tonic-gate #endif 22667c478bd9Sstevel@tonic-gate #ifndef ICMP6_WRUREPLY 22677c478bd9Sstevel@tonic-gate # define ICMP6_WRUREPLY 140 22687c478bd9Sstevel@tonic-gate #endif 22697c478bd9Sstevel@tonic-gate #ifndef ICMP6_FQDN_QUERY 22707c478bd9Sstevel@tonic-gate # define ICMP6_FQDN_QUERY 139 22717c478bd9Sstevel@tonic-gate #endif 22727c478bd9Sstevel@tonic-gate #ifndef ICMP6_FQDN_REPLY 22737c478bd9Sstevel@tonic-gate # define ICMP6_FQDN_REPLY 140 22747c478bd9Sstevel@tonic-gate #endif 22757c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_QUERY 22767c478bd9Sstevel@tonic-gate # define ICMP6_NI_QUERY 139 22777c478bd9Sstevel@tonic-gate #endif 22787c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_REPLY 22797c478bd9Sstevel@tonic-gate # define ICMP6_NI_REPLY 140 22807c478bd9Sstevel@tonic-gate #endif 22817c478bd9Sstevel@tonic-gate #ifndef MLD6_MTRACE_RESP 22827c478bd9Sstevel@tonic-gate # define MLD6_MTRACE_RESP 200 22837c478bd9Sstevel@tonic-gate #endif 22847c478bd9Sstevel@tonic-gate #ifndef MLD6_MTRACE 22857c478bd9Sstevel@tonic-gate # define MLD6_MTRACE 201 22867c478bd9Sstevel@tonic-gate #endif 22877c478bd9Sstevel@tonic-gate #ifndef ICMP6_HADISCOV_REQUEST 22887c478bd9Sstevel@tonic-gate # define ICMP6_HADISCOV_REQUEST 202 22897c478bd9Sstevel@tonic-gate #endif 22907c478bd9Sstevel@tonic-gate #ifndef ICMP6_HADISCOV_REPLY 22917c478bd9Sstevel@tonic-gate # define ICMP6_HADISCOV_REPLY 203 22927c478bd9Sstevel@tonic-gate #endif 22937c478bd9Sstevel@tonic-gate #ifndef ICMP6_MOBILEPREFIX_SOLICIT 22947c478bd9Sstevel@tonic-gate # define ICMP6_MOBILEPREFIX_SOLICIT 204 22957c478bd9Sstevel@tonic-gate #endif 22967c478bd9Sstevel@tonic-gate #ifndef ICMP6_MOBILEPREFIX_ADVERT 22977c478bd9Sstevel@tonic-gate # define ICMP6_MOBILEPREFIX_ADVERT 205 22987c478bd9Sstevel@tonic-gate #endif 22997c478bd9Sstevel@tonic-gate #ifndef ICMP6_MAXTYPE 23007c478bd9Sstevel@tonic-gate # define ICMP6_MAXTYPE 205 23017c478bd9Sstevel@tonic-gate #endif 23027c478bd9Sstevel@tonic-gate 23037c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_NOROUTE 23047c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_NOROUTE 0 23057c478bd9Sstevel@tonic-gate #endif 23067c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_ADMIN 23077c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_ADMIN 1 23087c478bd9Sstevel@tonic-gate #endif 23097c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_NOTNEIGHBOR 23107c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_NOTNEIGHBOR 2 23117c478bd9Sstevel@tonic-gate #endif 23127c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_BEYONDSCOPE 23137c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_BEYONDSCOPE 2 23147c478bd9Sstevel@tonic-gate #endif 23157c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_ADDR 23167c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_ADDR 3 23177c478bd9Sstevel@tonic-gate #endif 23187c478bd9Sstevel@tonic-gate #ifndef ICMP6_DST_UNREACH_NOPORT 23197c478bd9Sstevel@tonic-gate # define ICMP6_DST_UNREACH_NOPORT 4 23207c478bd9Sstevel@tonic-gate #endif 23217c478bd9Sstevel@tonic-gate #ifndef ICMP6_TIME_EXCEED_TRANSIT 23227c478bd9Sstevel@tonic-gate # define ICMP6_TIME_EXCEED_TRANSIT 0 23237c478bd9Sstevel@tonic-gate #endif 23247c478bd9Sstevel@tonic-gate #ifndef ICMP6_TIME_EXCEED_REASSEMBLY 23257c478bd9Sstevel@tonic-gate # define ICMP6_TIME_EXCEED_REASSEMBLY 1 23267c478bd9Sstevel@tonic-gate #endif 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_SUCCESS 23297c478bd9Sstevel@tonic-gate # define ICMP6_NI_SUCCESS 0 23307c478bd9Sstevel@tonic-gate #endif 23317c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_REFUSED 23327c478bd9Sstevel@tonic-gate # define ICMP6_NI_REFUSED 1 23337c478bd9Sstevel@tonic-gate #endif 23347c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_UNKNOWN 23357c478bd9Sstevel@tonic-gate # define ICMP6_NI_UNKNOWN 2 23367c478bd9Sstevel@tonic-gate #endif 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate #ifndef ICMP6_ROUTER_RENUMBERING_COMMAND 23397c478bd9Sstevel@tonic-gate # define ICMP6_ROUTER_RENUMBERING_COMMAND 0 23407c478bd9Sstevel@tonic-gate #endif 23417c478bd9Sstevel@tonic-gate #ifndef ICMP6_ROUTER_RENUMBERING_RESULT 23427c478bd9Sstevel@tonic-gate # define ICMP6_ROUTER_RENUMBERING_RESULT 1 23437c478bd9Sstevel@tonic-gate #endif 23447c478bd9Sstevel@tonic-gate #ifndef ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 23457c478bd9Sstevel@tonic-gate # define ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 255 23467c478bd9Sstevel@tonic-gate #endif 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate #ifndef ICMP6_PARAMPROB_HEADER 23497c478bd9Sstevel@tonic-gate # define ICMP6_PARAMPROB_HEADER 0 23507c478bd9Sstevel@tonic-gate #endif 23517c478bd9Sstevel@tonic-gate #ifndef ICMP6_PARAMPROB_NEXTHEADER 23527c478bd9Sstevel@tonic-gate # define ICMP6_PARAMPROB_NEXTHEADER 1 23537c478bd9Sstevel@tonic-gate #endif 23547c478bd9Sstevel@tonic-gate #ifndef ICMP6_PARAMPROB_OPTION 23557c478bd9Sstevel@tonic-gate # define ICMP6_PARAMPROB_OPTION 2 23567c478bd9Sstevel@tonic-gate #endif 23577c478bd9Sstevel@tonic-gate 23587c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_SUBJ_IPV6 23597c478bd9Sstevel@tonic-gate # define ICMP6_NI_SUBJ_IPV6 0 23607c478bd9Sstevel@tonic-gate #endif 23617c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_SUBJ_FQDN 23627c478bd9Sstevel@tonic-gate # define ICMP6_NI_SUBJ_FQDN 1 23637c478bd9Sstevel@tonic-gate #endif 23647c478bd9Sstevel@tonic-gate #ifndef ICMP6_NI_SUBJ_IPV4 23657c478bd9Sstevel@tonic-gate # define ICMP6_NI_SUBJ_IPV4 2 23667c478bd9Sstevel@tonic-gate #endif 23677c478bd9Sstevel@tonic-gate 23687c478bd9Sstevel@tonic-gate /* 23697c478bd9Sstevel@tonic-gate * ECN is a new addition to TCP - RFC 2481 23707c478bd9Sstevel@tonic-gate */ 23717c478bd9Sstevel@tonic-gate #ifndef TH_ECN 23727c478bd9Sstevel@tonic-gate # define TH_ECN 0x40 23737c478bd9Sstevel@tonic-gate #endif 23747c478bd9Sstevel@tonic-gate #ifndef TH_CWR 23757c478bd9Sstevel@tonic-gate # define TH_CWR 0x80 23767c478bd9Sstevel@tonic-gate #endif 23777c478bd9Sstevel@tonic-gate #define TH_ECNALL (TH_ECN|TH_CWR) 23787c478bd9Sstevel@tonic-gate 23797c478bd9Sstevel@tonic-gate /* 23807c478bd9Sstevel@tonic-gate * TCP States 23817c478bd9Sstevel@tonic-gate */ 23827c478bd9Sstevel@tonic-gate #define IPF_TCPS_CLOSED 0 /* closed */ 23837c478bd9Sstevel@tonic-gate #define IPF_TCPS_LISTEN 1 /* listening for connection */ 23847c478bd9Sstevel@tonic-gate #define IPF_TCPS_SYN_SENT 2 /* active, have sent syn */ 23857c478bd9Sstevel@tonic-gate #define IPF_TCPS_SYN_RECEIVED 3 /* have send and received syn */ 23867c478bd9Sstevel@tonic-gate #define IPF_TCPS_HALF_ESTAB 4 /* for connections not fully "up" */ 23877c478bd9Sstevel@tonic-gate /* states < IPF_TCPS_ESTABLISHED are those where connections not established */ 23887c478bd9Sstevel@tonic-gate #define IPF_TCPS_ESTABLISHED 5 /* established */ 23897c478bd9Sstevel@tonic-gate #define IPF_TCPS_CLOSE_WAIT 6 /* rcvd fin, waiting for close */ 23907c478bd9Sstevel@tonic-gate /* states > IPF_TCPS_CLOSE_WAIT are those where user has closed */ 23917c478bd9Sstevel@tonic-gate #define IPF_TCPS_FIN_WAIT_1 7 /* have closed, sent fin */ 23927c478bd9Sstevel@tonic-gate #define IPF_TCPS_CLOSING 8 /* closed xchd FIN; await FIN ACK */ 23937c478bd9Sstevel@tonic-gate #define IPF_TCPS_LAST_ACK 9 /* had fin and close; await FIN ACK */ 23947c478bd9Sstevel@tonic-gate /* states > IPF_TCPS_CLOSE_WAIT && < IPF_TCPS_FIN_WAIT_2 await ACK of FIN */ 23957c478bd9Sstevel@tonic-gate #define IPF_TCPS_FIN_WAIT_2 10 /* have closed, fin is acked */ 23967c478bd9Sstevel@tonic-gate #define IPF_TCPS_TIME_WAIT 11 /* in 2*msl quiet wait after close */ 23977c478bd9Sstevel@tonic-gate #define IPF_TCP_NSTATES 12 23987c478bd9Sstevel@tonic-gate 23997c478bd9Sstevel@tonic-gate #define TCP_MSL 120 24007c478bd9Sstevel@tonic-gate 24017c478bd9Sstevel@tonic-gate #undef ICMP_MAX_UNREACH 24027c478bd9Sstevel@tonic-gate #define ICMP_MAX_UNREACH 14 24037c478bd9Sstevel@tonic-gate #undef ICMP_MAXTYPE 24047c478bd9Sstevel@tonic-gate #define ICMP_MAXTYPE 18 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate #ifndef IFNAMSIZ 24077c478bd9Sstevel@tonic-gate #define IFNAMSIZ 16 24087c478bd9Sstevel@tonic-gate #endif 24097c478bd9Sstevel@tonic-gate 24107c478bd9Sstevel@tonic-gate #ifndef LOG_FTP 24117c478bd9Sstevel@tonic-gate # define LOG_FTP (11<<3) 24127c478bd9Sstevel@tonic-gate #endif 24137c478bd9Sstevel@tonic-gate #ifndef LOG_AUTHPRIV 24147c478bd9Sstevel@tonic-gate # define LOG_AUTHPRIV (10<<3) 24157c478bd9Sstevel@tonic-gate #endif 24167c478bd9Sstevel@tonic-gate #ifndef LOG_AUDIT 24177c478bd9Sstevel@tonic-gate # define LOG_AUDIT (13<<3) 24187c478bd9Sstevel@tonic-gate #endif 24197c478bd9Sstevel@tonic-gate #ifndef LOG_NTP 24207c478bd9Sstevel@tonic-gate # define LOG_NTP (12<<3) 24217c478bd9Sstevel@tonic-gate #endif 24227c478bd9Sstevel@tonic-gate #ifndef LOG_SECURITY 24237c478bd9Sstevel@tonic-gate # define LOG_SECURITY (13<<3) 24247c478bd9Sstevel@tonic-gate #endif 24257c478bd9Sstevel@tonic-gate #ifndef LOG_LFMT 24267c478bd9Sstevel@tonic-gate # define LOG_LFMT (14<<3) 24277c478bd9Sstevel@tonic-gate #endif 24287c478bd9Sstevel@tonic-gate #ifndef LOG_CONSOLE 24297c478bd9Sstevel@tonic-gate # define LOG_CONSOLE (14<<3) 24307c478bd9Sstevel@tonic-gate #endif 24317c478bd9Sstevel@tonic-gate 24327c478bd9Sstevel@tonic-gate /* 24337c478bd9Sstevel@tonic-gate * ICMP error replies have an IP header (20 bytes), 8 bytes of ICMP data, 24347c478bd9Sstevel@tonic-gate * another IP header and then 64 bits of data, totalling 56. Of course, 2435ab25eeb5Syz * the last 64 bits is dependent on that being available. 24367c478bd9Sstevel@tonic-gate */ 24377c478bd9Sstevel@tonic-gate #define ICMPERR_ICMPHLEN 8 24387c478bd9Sstevel@tonic-gate #define ICMPERR_IPICMPHLEN (20 + 8) 24397c478bd9Sstevel@tonic-gate #define ICMPERR_MINPKTLEN (20 + 8 + 20) 24407c478bd9Sstevel@tonic-gate #define ICMPERR_MAXPKTLEN (20 + 8 + 20 + 8) 24417c478bd9Sstevel@tonic-gate #define ICMP6ERR_MINPKTLEN (40 + 8) 24427c478bd9Sstevel@tonic-gate #define ICMP6ERR_IPICMPHLEN (40 + 8 + 40) 24437c478bd9Sstevel@tonic-gate 2444ab25eeb5Syz #ifndef MIN 2445ab25eeb5Syz # define MIN(a,b) (((a)<(b))?(a):(b)) 2446ab25eeb5Syz #endif 2447ab25eeb5Syz 2448ab25eeb5Syz #ifdef IPF_DEBUG 2449ab25eeb5Syz # define DPRINT(x) printf x 24507c478bd9Sstevel@tonic-gate #else 2451ab25eeb5Syz # define DPRINT(x) 24527c478bd9Sstevel@tonic-gate #endif 24537c478bd9Sstevel@tonic-gate 2454ab25eeb5Syz #ifdef RESCUE 2455ab25eeb5Syz # undef IPFILTER_BPF 24567c478bd9Sstevel@tonic-gate #endif 24577c478bd9Sstevel@tonic-gate 24587c478bd9Sstevel@tonic-gate #endif /* __IP_COMPAT_H__ */ 2459