ip_compat.h revision 183397
1/* 2 * Copyright (C) 1993-2001, 2003 by Darren Reed. 3 * 4 * See the IPFILTER.LICENCE file for details on licencing. 5 * 6 * @(#)ip_compat.h 1.8 1/14/96 7 * $FreeBSD: head/sys/contrib/ipfilter/netinet/ip_compat.h 183397 2008-09-27 08:51:18Z ed $ 8 * Id: ip_compat.h,v 2.142.2.57 2007/10/10 09:51:42 darrenr Exp $ 9 */ 10 11#ifndef __IP_COMPAT_H__ 12#define __IP_COMPAT_H__ 13 14#ifndef __P 15# ifdef __STDC__ 16# define __P(x) x 17# else 18# define __P(x) () 19# endif 20#endif 21#ifndef __STDC__ 22# undef const 23# define const 24#endif 25 26#if defined(_KERNEL) || defined(KERNEL) || defined(__KERNEL__) 27# undef KERNEL 28# undef _KERNEL 29# undef __KERNEL__ 30# define KERNEL 31# define _KERNEL 32# define __KERNEL__ 33#endif 34 35#ifndef SOLARIS 36#define SOLARIS (defined(sun) && (defined(__svr4__) || defined(__SVR4))) 37#endif 38#if (defined(SOLARIS2) && (SOLARIS2 >= 8)) 39# ifndef USE_INET6 40# define USE_INET6 41# endif 42#endif 43#if defined(__FreeBSD_version) && (__FreeBSD_version >= 400000) && \ 44 !defined(_KERNEL) && !defined(USE_INET6) && !defined(NOINET6) 45# define USE_INET6 46#endif 47#if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105000000) && \ 48 !defined(_KERNEL) && !defined(USE_INET6) 49# define USE_INET6 50# define IPFILTER_M_IPFILTER 51#endif 52#if defined(OpenBSD) && (OpenBSD >= 200206) && \ 53 !defined(_KERNEL) && !defined(USE_INET6) 54# define USE_INET6 55#endif 56#if defined(__osf__) 57# define USE_INET6 58#endif 59#if defined(linux) && (!defined(_KERNEL) || defined(CONFIG_IPV6)) 60# define USE_INET6 61#endif 62#if defined(HPUXREV) && (HPUXREV >= 1111) 63# define USE_INET6 64#endif 65 66#if defined(BSD) && (BSD < 199103) && defined(__osf__) 67# undef BSD 68# define BSD 199103 69#endif 70 71#if defined(__SVR4) || defined(__svr4__) || defined(__sgi) 72# define index strchr 73# if !defined(_KERNEL) 74# define bzero(a,b) memset(a,0,b) 75# define bcmp memcmp 76# define bcopy(a,b,c) memmove(b,a,c) 77# endif 78#endif 79 80#ifndef LIFNAMSIZ 81# ifdef IF_NAMESIZE 82# define LIFNAMSIZ IF_NAMESIZE 83# else 84# ifdef IFNAMSIZ 85# define LIFNAMSIZ IFNAMSIZ 86# else 87# define LIFNAMSIZ 16 88# endif 89# endif 90#endif 91 92#if defined(__sgi) || defined(bsdi) || defined(__hpux) || defined(hpux) 93struct ether_addr { 94 u_char ether_addr_octet[6]; 95}; 96#endif 97 98#if defined(__sgi) && !defined(IPFILTER_LKM) 99# ifdef __STDC__ 100# define IPL_EXTERN(ep) ipfilter##ep 101# else 102# define IPL_EXTERN(ep) ipfilter/**/ep 103# endif 104#else 105# ifdef __STDC__ 106# define IPL_EXTERN(ep) ipl##ep 107# else 108# define IPL_EXTERN(ep) ipl/**/ep 109# endif 110#endif 111 112/* 113 * This is a workaround for <sys/uio.h> troubles on FreeBSD and OpenBSD. 114 */ 115#ifndef linux 116# ifndef _KERNEL 117# define ADD_KERNEL 118# define _KERNEL 119# define KERNEL 120# endif 121# ifdef __OpenBSD__ 122struct file; 123# endif 124# include <sys/uio.h> 125# ifdef ADD_KERNEL 126# undef _KERNEL 127# undef KERNEL 128# endif 129#endif 130 131 132/* ----------------------------------------------------------------------- */ 133/* S O L A R I S */ 134/* ----------------------------------------------------------------------- */ 135#if SOLARIS 136# define MENTAT 1 137# include <sys/cmn_err.h> 138# include <sys/isa_defs.h> 139# include <sys/stream.h> 140# include <sys/ioccom.h> 141# include <sys/sysmacros.h> 142# include <sys/kmem.h> 143# if defined(SOLARIS2) && SOLARIS2 >= 10 144# include <sys/procset.h> 145# include <sys/proc.h> 146# include <sys/devops.h> 147# include <sys/ddi_impldefs.h> 148# endif 149/* 150 * because Solaris 2 defines these in two places :-/ 151 */ 152# ifndef KERNEL 153# define _KERNEL 154# undef RES_INIT 155# endif /* _KERNEL */ 156 157# if defined(SOLARIS2) && SOLARIS2 >= 8 158# include <netinet/ip6.h> 159# include <netinet/icmp6.h> 160# endif 161 162# include <inet/common.h> 163/* These 5 are defined in <inet/ip.h> and <netinet/ip.h> */ 164# undef IPOPT_EOL 165# undef IPOPT_NOP 166# undef IPOPT_LSRR 167# undef IPOPT_RR 168# undef IPOPT_SSRR 169# ifdef i386 170# define _SYS_PROMIF_H 171# endif 172# ifndef _KERNEL 173# include "radix_ipf.h" 174# else 175# include "radix_ipf_local.h" 176# endif 177# include <inet/ip.h> 178# undef COPYOUT 179# include <inet/ip_ire.h> 180# ifndef KERNEL 181# undef _KERNEL 182# endif 183# if defined(SOLARIS2) && SOLARIS2 >= 8 184# define SNPRINTF snprintf 185 186# include <inet/ip_if.h> 187# define ipif_local_addr ipif_lcl_addr 188/* Only defined in private include file */ 189# ifndef V4_PART_OF_V6 190# define V4_PART_OF_V6(v6) v6.s6_addr32[3] 191# endif 192struct ip6_ext { 193 u_char ip6e_nxt; 194 u_char ip6e_len; 195}; 196# endif /* SOLARIS2 >= 8 */ 197 198# if defined(SOLARIS2) && SOLARIS2 >= 6 199# include <sys/atomic.h> 200typedef uint32_t u_32_t; 201# else 202typedef unsigned int u_32_t; 203# endif 204# define U_32_T 1 205 206# ifdef _KERNEL 207# define NEED_LOCAL_RAND 1 208# define ipf_random arc4random 209# define KRWLOCK_T krwlock_t 210# define KMUTEX_T kmutex_t 211 212# if !defined(FW_HOOKS) 213# include "qif.h" 214# include "pfil.h" 215# else 216# include <sys/neti.h> 217 218extern net_data_t ipfipv4; 219extern net_data_t ipfipv6; 220 221typedef struct qpktinfo { 222 void *qpi_data; 223 mblk_t **qpi_mp; 224 mblk_t *qpi_m; 225 uintptr_t qpi_real; 226 int qpi_flags; 227 int qpi_num; 228 int qpi_off; 229} qpktinfo_t; 230# define QF_GROUP 0x01 231# endif 232 233# if SOLARIS2 >= 6 234# if SOLARIS2 == 6 235# define ATOMIC_INCL(x) atomic_add_long((uint32_t*)&(x), 1) 236# define ATOMIC_DECL(x) atomic_add_long((uint32_t*)&(x), -1) 237# else 238# define ATOMIC_INCL(x) atomic_add_long(&(x), 1) 239# define ATOMIC_DECL(x) atomic_add_long(&(x), -1) 240# endif /* SOLARIS2 == 6 */ 241# define ATOMIC_INC64(x) atomic_add_64((uint64_t*)&(x), 1) 242# define ATOMIC_INC32(x) atomic_add_32((uint32_t*)&(x), 1) 243# define ATOMIC_INC16(x) atomic_add_16((uint16_t*)&(x), 1) 244# define ATOMIC_DEC64(x) atomic_add_64((uint64_t*)&(x), -1) 245# define ATOMIC_DEC32(x) atomic_add_32((uint32_t*)&(x), -1) 246# define ATOMIC_DEC16(x) atomic_add_16((uint16_t*)&(x), -1) 247# else 248# define ATOMIC_INC(x) { mutex_enter(&ipf_rw); (x)++; \ 249 mutex_exit(&ipf_rw); } 250# define ATOMIC_DEC(x) { mutex_enter(&ipf_rw); (x)--; \ 251 mutex_exit(&ipf_rw); } 252# endif /* SOLARIS2 >= 6 */ 253# define USE_MUTEXES 254# define MUTEX_ENTER(x) mutex_enter(&(x)->ipf_lk) 255# define READ_ENTER(x) rw_enter(&(x)->ipf_lk, RW_READER) 256# define WRITE_ENTER(x) rw_enter(&(x)->ipf_lk, RW_WRITER) 257# define MUTEX_DOWNGRADE(x) rw_downgrade(&(x)->ipf_lk) 258# define RWLOCK_INIT(x, y) rw_init(&(x)->ipf_lk, (y), \ 259 RW_DRIVER, NULL) 260# define RWLOCK_EXIT(x) rw_exit(&(x)->ipf_lk) 261# define RW_DESTROY(x) rw_destroy(&(x)->ipf_lk) 262# define MUTEX_INIT(x, y) mutex_init(&(x)->ipf_lk, (y), \ 263 MUTEX_DRIVER, NULL) 264# define MUTEX_DESTROY(x) mutex_destroy(&(x)->ipf_lk) 265# define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 266# define MUTEX_EXIT(x) mutex_exit(&(x)->ipf_lk) 267# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 268# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 269# define BCOPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 270# define BCOPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 271# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 272# define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 273# define KFREES(x,s) kmem_free((char *)(x), (s)) 274# define SPL_SCHED(x) ; 275# define SPL_NET(x) ; 276# define SPL_IMP(x) ; 277# undef SPL_X 278# define SPL_X(x) ; 279# ifdef sparc 280# define ntohs(x) (x) 281# define ntohl(x) (x) 282# define htons(x) (x) 283# define htonl(x) (x) 284# endif /* sparc */ 285# define KMALLOC(a,b) (a) = (b)kmem_alloc(sizeof(*(a)), KM_NOSLEEP) 286# define KMALLOCS(a,b,c) (a) = (b)kmem_alloc((c), KM_NOSLEEP) 287# define GET_MINOR(x) getminor(x) 288extern void *get_unit __P((char *, int)); 289# define GETIFP(n, v) get_unit(n, v) 290# if defined(_INET_IP_STACK_H) 291# define COPYIFNAME(v, x, b) \ 292 do { \ 293 if ((v) == 4) { \ 294 (void) net_getifname(ipfipv4,\ 295 (uintptr_t)x, b, \ 296 LIFNAMSIZ); \ 297 } else { \ 298 (void) net_getifname(ipfipv6,\ 299 (uintptr_t)x, b, \ 300 LIFNAMSIZ); \ 301 } \ 302 } while (0) 303# else 304# define COPYIFNAME(v, x, b) \ 305 (void) strncpy(b, ((qif_t *)x)->qf_name, \ 306 LIFNAMSIZ) 307# endif 308# define GETKTIME(x) uniqtime((struct timeval *)x) 309# define MSGDSIZE(x) msgdsize(x) 310# define M_LEN(x) ((x)->b_wptr - (x)->b_rptr) 311# define M_DUPLICATE(x) dupmsg((x)) 312# define MTOD(m,t) ((t)((m)->b_rptr)) 313# define MTYPE(m) ((m)->b_datap->db_type) 314# define FREE_MB_T(m) freemsg(m) 315# define m_next b_cont 316# if !defined(_INET_IP_STACK_H) 317# define CACHE_HASH(x) (((qpktinfo_t *)(x)->fin_qpi)->qpi_num & 7) 318# else 319# define CACHE_HASH(x) ((uintptr_t)(x)->fin_ifp & 7) 320# endif 321# define IPF_PANIC(x,y) if (x) { printf y; cmn_err(CE_PANIC, "ipf_panic"); } 322typedef mblk_t mb_t; 323# endif /* _KERNEL */ 324 325# if defined(SOLARIS2) && (SOLARIS2 >= 7) 326# ifdef lint 327# define ALIGN32(ptr) (ptr ? 0L : 0L) 328# define ALIGN16(ptr) (ptr ? 0L : 0L) 329# else 330# define ALIGN32(ptr) (ptr) 331# define ALIGN16(ptr) (ptr) 332# endif 333# endif 334 335# if defined(SOLARIS2) && SOLARIS2 < 6 336typedef struct uio uio_t; 337# endif 338typedef int ioctlcmd_t; 339typedef uint8_t u_int8_t; 340 341# define OS_RECOGNISED 1 342 343#endif /* SOLARIS */ 344 345/* ----------------------------------------------------------------------- */ 346/* H P U X */ 347/* ----------------------------------------------------------------------- */ 348#ifdef __hpux 349# define MENTAT 1 350# include <sys/sysmacros.h> 351# include <sys/spinlock.h> 352# include <sys/lock.h> 353# include <sys/stream.h> 354# ifdef USE_INET6 355# include <netinet/if_ether.h> 356# include <netinet/ip6.h> 357# include <netinet/icmp6.h> 358typedef struct ip6_hdr ip6_t; 359# endif 360 361# ifdef _KERNEL 362# define SNPRINTF sprintf 363# if (HPUXREV >= 1111) 364# define IPL_SELECT 365# ifdef IPL_SELECT 366# include <machine/sys/user.h> 367# include <sys/kthread_iface.h> 368# define READ_COLLISION 0x01 369 370typedef struct iplog_select_s { 371 kthread_t *read_waiter; 372 int state; 373} iplog_select_t; 374# endif 375# endif 376 377# define GETKTIME(x) uniqtime((struct timeval *)x) 378 379# if HPUXREV == 1111 380# include "kern_svcs.h" 381# else 382# include <sys/kern_svcs.h> 383# endif 384# undef ti_flags 385# undef TCP_NODELAY 386# undef TCP_MAXSEG 387# include <sys/reg.h> 388# include "../netinet/ip_info.h" 389/* 390 * According to /usr/include/sys/spinlock.h on HP-UX 11.00, these functions 391 * are available. Attempting to use them actually results in unresolved 392 * symbols when it comes time to load the module. 393 * This has been fixed! Yipee! 394 */ 395# if 1 396# ifdef __LP64__ 397# define ATOMIC_INCL(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), 1) 398# define ATOMIC_DECL(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), -1) 399# else 400# define ATOMIC_INCL(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), 1) 401# define ATOMIC_DECL(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), -1) 402# endif 403# define ATOMIC_INC64(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), 1) 404# define ATOMIC_INC32(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), 1) 405# define ATOMIC_INC16(x) lock_and_incr_int16(&ipf_rw.ipf_lk, &(x), 1) 406# define ATOMIC_DEC64(x) lock_and_incr_int64(&ipf_rw.ipf_lk, &(x), -1) 407# define ATOMIC_DEC32(x) lock_and_incr_int32(&ipf_rw.ipf_lk, &(x), -1) 408# define ATOMIC_DEC16(x) lock_and_incr_int16(&ipf_rw.ipf_lk, &(x), -1) 409# else /* 0 */ 410# define ATOMIC_INC64(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 411 MUTEX_EXIT(&ipf_rw); } 412# define ATOMIC_DEC64(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 413 MUTEX_EXIT(&ipf_rw); } 414# define ATOMIC_INC32(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 415 MUTEX_EXIT(&ipf_rw); } 416# define ATOMIC_DEC32(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 417 MUTEX_EXIT(&ipf_rw); } 418# define ATOMIC_INCL(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 419 MUTEX_EXIT(&ipf_rw); } 420# define ATOMIC_DECL(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 421 MUTEX_EXIT(&ipf_rw); } 422# define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 423 MUTEX_EXIT(&ipf_rw); } 424# define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 425 MUTEX_EXIT(&ipf_rw); } 426# endif 427# define ip_cksum ip_csuma 428# define memcpy(a,b,c) bcopy((caddr_t)b, (caddr_t)a, c) 429# define USE_MUTEXES 430# define MUTEX_INIT(x, y) initlock(&(x)->ipf_lk, 0, 0, (y)) 431# define MUTEX_ENTER(x) spinlock(&(x)->ipf_lk) 432# define MUTEX_EXIT(x) spinunlock(&(x)->ipf_lk); 433# define MUTEX_DESTROY(x) 434# define MUTEX_NUKE(x) bzero((char *)(x), sizeof(*(x))) 435# define KMUTEX_T lock_t 436# define kmutex_t lock_t /* for pfil.h */ 437# define krwlock_t lock_t /* for pfil.h */ 438/* 439 * The read-write lock implementation in HP-UX 11.0 is crippled - it can 440 * only be used by threads working in a user context! 441 * This has been fixed! Yipee! (Or at least it does in 11.00, not 11.11..) 442 */ 443# if HPUXREV < 1111 444# define MUTEX_DOWNGRADE(x) lock_write_to_read(x) 445# define KRWLOCK_T struct rw_lock 446# define READ_ENTER(x) lock_read(&(x)->ipf_lk) 447# define WRITE_ENTER(x) lock_write(&(x)->ipf_lk) 448# if HPUXREV >= 1111 449# define RWLOCK_INIT(x, y) rwlock_init4(&(x)->ipf_lk, 0, RWLCK_CANSLEEP, 0, y) 450# else 451# define RWLOCK_INIT(x, y) lock_init3(&(x)->ipf_lk, 0, 1, 0, 0, y) 452# endif 453# define RWLOCK_EXIT(x) lock_done(&(x)->ipf_lk) 454# else 455# define KRWLOCK_T lock_t 456# define KMUTEX_T lock_t 457# define READ_ENTER(x) MUTEX_ENTER(x) 458# define WRITE_ENTER(x) MUTEX_ENTER(x) 459# define MUTEX_DOWNGRADE(x) 460# define RWLOCK_INIT(x, y) initlock(&(x)->ipf_lk, 0, 0, y) 461# define RWLOCK_EXIT(x) MUTEX_EXIT(x) 462# endif 463# define RW_DESTROY(x) 464# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 465# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 466# define SPL_SCHED(x) ; 467# define SPL_NET(x) ; 468# define SPL_IMP(x) ; 469# undef SPL_X 470# define SPL_X(x) ; 471extern void *get_unit __P((char *, int)); 472# define GETIFP(n, v) get_unit(n, v) 473# define COPYIFNAME(v, x, b) \ 474 (void) strncpy(b, ((qif_t *)x)->qf_name, \ 475 LIFNAMSIZ) 476# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 477# define SLEEP(id, n) { lock_t *_l = get_sleep_lock((caddr_t)id); \ 478 sleep(id, PZERO+1); \ 479 spinunlock(_l); \ 480 } 481# define WAKEUP(id,x) { lock_t *_l = get_sleep_lock((caddr_t)id); \ 482 wakeup(id + x); \ 483 spinunlock(_l); \ 484 } 485# define POLLWAKEUP(x) ; 486# define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_IOSYS, M_NOWAIT) 487# define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_IOSYS, M_NOWAIT) 488# define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 489# define KFREES(x,s) kmem_free((char *)(x), (s)) 490# define MSGDSIZE(x) msgdsize(x) 491# define M_LEN(x) ((x)->b_wptr - (x)->b_rptr) 492# define M_DUPLICATE(x) dupmsg((x)) 493# define MTOD(m,t) ((t)((m)->b_rptr)) 494# define MTYPE(m) ((m)->b_datap->db_type) 495# define FREE_MB_T(m) freemsg(m) 496# define m_next b_cont 497# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 498typedef mblk_t mb_t; 499 500# define CACHE_HASH(x) (((qpktinfo_t *)(x)->fin_qpi)->qpi_num & 7) 501 502# include "qif.h" 503# include "pfil.h" 504 505# else /* _KERNEL */ 506 507typedef unsigned char uchar_t; 508 509# ifndef _SYS_STREAM_INCLUDED 510typedef char * mblk_t; 511typedef void * queue_t; 512typedef u_long ulong; 513# endif 514# include <netinet/ip_info.h> 515 516# endif /* _KERNEL */ 517 518# ifdef lint 519# define ALIGN32(ptr) (ptr ? 0L : 0L) 520# define ALIGN16(ptr) (ptr ? 0L : 0L) 521# else 522# define ALIGN32(ptr) (ptr) 523# define ALIGN16(ptr) (ptr) 524# endif 525 526typedef struct uio uio_t; 527typedef int ioctlcmd_t; 528typedef int minor_t; 529typedef unsigned int u_32_t; 530# define U_32_T 1 531 532# define OS_RECOGNISED 1 533 534#endif /* __hpux */ 535 536/* ----------------------------------------------------------------------- */ 537/* I R I X */ 538/* ----------------------------------------------------------------------- */ 539#ifdef __sgi 540# undef MENTAT 541# if IRIX < 60500 542typedef struct uio uio_t; 543# endif 544typedef int ioctlcmd_t; 545typedef u_int32_t u_32_t; 546# define U_32_T 1 547 548# ifdef INET6 549# define USE_INET6 550# endif 551 552# define hz HZ 553# include <sys/ksynch.h> 554# define IPF_LOCK_PL plhi 555# include <sys/sema.h> 556# undef kmutex_t 557typedef struct { 558 lock_t *l; 559 int pl; 560} kmutex_t; 561 562# ifdef MUTEX_INIT 563# define KMUTEX_T mutex_t 564# else 565# define KMUTEX_T kmutex_t 566# define KRWLOCK_T kmutex_t 567# endif 568 569# ifdef _KERNEL 570# define NEED_LOCAL_RAND 1 571# define ipf_random arc4random 572# define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); \ 573 (x)++; MUTEX_EXIT(&ipf_rw); } 574# define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); \ 575 (x)--; MUTEX_EXIT(&ipf_rw); } 576# define USE_MUTEXES 577# ifdef MUTEX_INIT 578# include <sys/atomic_ops.h> 579# define ATOMIC_INCL(x) atomicAddUlong(&(x), 1) 580# define ATOMIC_INC64(x) atomicAddUint64(&(x), 1) 581# define ATOMIC_INC32(x) atomicAddUint(&(x), 1) 582# define ATOMIC_INC16 ATOMIC_INC 583# define ATOMIC_DECL(x) atomicAddUlong(&(x), -1) 584# define ATOMIC_DEC64(x) atomicAddUint64(&(x), -1) 585# define ATOMIC_DEC32(x) atomicAddUint(&(x), -1) 586# define ATOMIC_DEC16 ATOMIC_DEC 587# undef MUTEX_INIT 588# define MUTEX_INIT(x, y) mutex_init(&(x)->ipf_lk, \ 589 MUTEX_DEFAULT, y) 590# undef MUTEX_ENTER 591# define MUTEX_ENTER(x) mutex_lock(&(x)->ipf_lk, 0) 592# undef MUTEX_EXIT 593# define MUTEX_EXIT(x) mutex_unlock(&(x)->ipf_lk) 594# undef MUTEX_DESTROY 595# define MUTEX_DESTROY(x) mutex_destroy(&(x)->ipf_lk) 596# define MUTEX_DOWNGRADE(x) mrdemote(&(x)->ipf_lk) 597# define KRWLOCK_T mrlock_t 598# define RWLOCK_INIT(x, y) mrinit(&(x)->ipf_lk, y) 599# undef RW_DESTROY 600# define RW_DESTROY(x) mrfree(&(x)->ipf_lk) 601# define READ_ENTER(x) RW_RDLOCK(&(x)->ipf_lk) 602# define WRITE_ENTER(x) RW_WRLOCK(&(x)->ipf_lk) 603# define RWLOCK_EXIT(x) RW_UNLOCK(&(x)->ipf_lk) 604# else 605# define READ_ENTER(x) MUTEX_ENTER(&(x)->ipf_lk) 606# define WRITE_ENTER(x) MUTEX_ENTER(&(x)->ipf_lk) 607# define MUTEX_DOWNGRADE(x) ; 608# define RWLOCK_EXIT(x) MUTEX_EXIT(&(x)->ipf_lk) 609# define MUTEX_EXIT(x) UNLOCK((x)->ipf_lk.l, (x)->ipf_lk.pl); 610# define MUTEX_INIT(x,y) (x)->ipf_lk.l = LOCK_ALLOC((uchar_t)-1, IPF_LOCK_PL, (lkinfo_t *)-1, KM_NOSLEEP) 611# define MUTEX_DESTROY(x) LOCK_DEALLOC((x)->ipf_lk.l) 612# define MUTEX_ENTER(x) (x)->ipf_lk.pl = LOCK((x)->ipf_lk.l, \ 613 IPF_LOCK_PL); 614# endif 615# define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 616# define FREE_MB_T(m) m_freem(m) 617# define MTOD(m,t) mtod(m,t) 618# define COPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 619# define COPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 620# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 621# define SLEEP(id, n) sleep((id), PZERO+1) 622# define WAKEUP(id,x) wakeup(id+x) 623# define POLLWAKEUP(x) ; 624# define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 625# define KFREES(x,s) kmem_free((char *)(x), (s)) 626# define GETIFP(n,v) ifunit(n) 627# include <sys/kmem.h> 628# include <sys/ddi.h> 629# define KMALLOC(a,b) (a) = (b)kmem_alloc(sizeof(*(a)), KM_NOSLEEP) 630# define KMALLOCS(a,b,c) (a) = (b)kmem_alloc((c), KM_NOSLEEP) 631# define GET_MINOR(x) getminor(x) 632# define USE_SPL 1 633# define SPL_IMP(x) (x) = splimp() 634# define SPL_NET(x) (x) = splnet() 635# define SPL_SCHED(x) (x) = splsched() 636# define SPL_X(x) (void) splx(x) 637extern void m_copydata __P((struct mbuf *, int, int, caddr_t)); 638extern void m_copyback __P((struct mbuf *, int, int, caddr_t)); 639# define MSGDSIZE(x) mbufchainlen(x) 640# define M_LEN(x) (x)->m_len 641# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 642# define GETKTIME(x) microtime((struct timeval *)x) 643# define IFNAME(x) ((struct ifnet *)x)->if_name 644# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 645 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 646# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 647typedef struct mbuf mb_t; 648# else 649# undef RW_DESTROY 650# undef MUTEX_INIT 651# undef MUTEX_DESTROY 652# endif /* _KERNEL */ 653 654# define OS_RECOGNISED 1 655 656#endif /* __sgi */ 657 658/* ----------------------------------------------------------------------- */ 659/* T R U 6 4 */ 660/* ----------------------------------------------------------------------- */ 661#ifdef __osf__ 662# undef MENTAT 663 664# include <kern/lock.h> 665# include <sys/sysmacros.h> 666 667# ifdef _KERNEL 668# define NEED_LOCAL_RAND 1 669# define ipf_random arc4random 670# define KMUTEX_T simple_lock_data_t 671# define KRWLOCK_T lock_data_t 672# include <net/net_globals.h> 673# define USE_MUTEXES 674# define READ_ENTER(x) lock_read(&(x)->ipf_lk) 675# define WRITE_ENTER(x) lock_write(&(x)->ipf_lk) 676# define MUTEX_DOWNGRADE(x) lock_write_to_read(&(x)->ipf_lk) 677# define RWLOCK_INIT(x, y) lock_init(&(x)->ipf_lk, TRUE) 678# define RWLOCK_EXIT(x) lock_done(&(x)->ipf_lk) 679# define RW_DESTROY(x) lock_terminate(&(x)->ipf_lk) 680# define MUTEX_ENTER(x) simple_lock(&(x)->ipf_lk) 681# define MUTEX_INIT(x, y) simple_lock_init(&(x)->ipf_lk) 682# define MUTEX_DESTROY(x) simple_lock_terminate(&(x)->ipf_lk) 683# define MUTEX_EXIT(x) simple_unlock(&(x)->ipf_lk) 684# define MUTEX_NUKE(x) bzero(x, sizeof(*(x))) 685# define ATOMIC_INC64(x) atomic_incq((uint64_t*)&(x)) 686# define ATOMIC_DEC64(x) atomic_decq((uint64_t*)&(x)) 687# define ATOMIC_INC32(x) atomic_incl((uint32_t*)&(x)) 688# define ATOMIC_DEC32(x) atomic_decl((uint32_t*)&(x)) 689# define ATOMIC_INC16(x) { simple_lock(&ipf_rw); (x)++; \ 690 simple_unlock(&ipf_rw); } 691# define ATOMIC_DEC16(x) { simple_lock(&ipf_rw); (x)--; \ 692 simple_unlock(&ipf_rw); } 693# define ATOMIC_INCL(x) atomic_incl((uint32_t*)&(x)) 694# define ATOMIC_DECL(x) atomic_decl((uint32_t*)&(x)) 695# define ATOMIC_INC(x) { simple_lock(&ipf_rw); (x)++; \ 696 simple_unlock(&ipf_rw); } 697# define ATOMIC_DEC(x) { simple_lock(&ipf_rw); (x)--; \ 698 simple_unlock(&ipf_rw); } 699# define SPL_SCHED(x) ; 700# define SPL_NET(x) ; 701# define SPL_IMP(x) ; 702# undef SPL_X 703# define SPL_X(x) ; 704# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a, b, d) 705# define FREE_MB_T(m) m_freem(m) 706# define MTOD(m,t) mtod(m,t) 707# define GETIFP(n, v) ifunit(n) 708# define GET_MINOR getminor 709# define WAKEUP(id,x) wakeup(id + x) 710# define POLLWAKEUP(x) ; 711# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 712# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 713# define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_PFILT, M_NOWAIT) 714# define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_PFILT, \ 715 ((c) > 4096) ? M_WAITOK : M_NOWAIT) 716# define KFREE(x) FREE((x), M_PFILT) 717# define KFREES(x,s) FREE((x), M_PFILT) 718# define MSGDSIZE(x) mbufchainlen(x) 719# define M_LEN(x) (x)->m_len 720# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 721# define GETKTIME(x) microtime((struct timeval *)x) 722# define IFNAME(x) ((struct ifnet *)x)->if_name 723# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 724 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 725# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 726typedef struct mbuf mb_t; 727# endif /* _KERNEL */ 728 729# if (defined(_KERNEL) || defined(_NO_BITFIELDS) || (__STDC__ == 1)) 730# define IP_V(x) ((x)->ip_vhl >> 4) 731# define IP_HL(x) ((x)->ip_vhl & 0xf) 732# define IP_V_A(x,y) (x)->ip_vhl |= (((y) << 4) & 0xf0) 733# define IP_HL_A(x,y) (x)->ip_vhl |= ((y) & 0xf) 734# define TCP_X2(x) ((x)->th_xoff & 0xf) 735# define TCP_X2_A(x,y) (x)->th_xoff |= ((y) & 0xf) 736# define TCP_OFF(x) ((x)->th_xoff >> 4) 737# define TCP_OFF_A(x,y) (x)->th_xoff |= (((y) << 4) & 0xf0) 738# endif 739 740/* 741 * These are from's Solaris' #defines for little endian. 742 */ 743#define IP6F_MORE_FRAG 0x0100 744#define IP6F_RESERVED_MASK 0x0600 745#define IP6F_OFF_MASK 0xf8ff 746 747struct ip6_ext { 748 u_char ip6e_nxt; 749 u_char ip6e_len; 750}; 751 752typedef int ioctlcmd_t; 753/* 754 * Really, any arch where sizeof(long) != sizeof(int). 755 */ 756typedef unsigned int u_32_t; 757# define U_32_T 1 758 759# define OS_RECOGNISED 1 760#endif /* __osf__ */ 761 762/* ----------------------------------------------------------------------- */ 763/* N E T B S D */ 764/* ----------------------------------------------------------------------- */ 765#ifdef __NetBSD__ 766# if (NetBSD >= 199905) && !defined(IPFILTER_LKM) && defined(_KERNEL) 767# include "opt_ipfilter.h" 768# endif 769# if defined(_KERNEL) 770# include <sys/systm.h> 771# else 772# include <stddef.h> 773# endif 774# if defined(_KERNEL) && !defined(IPFILTER_LKM) 775# include "bpfilter.h" 776# if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 104110000) 777# include "opt_inet.h" 778# endif 779# ifdef INET6 780# define USE_INET6 781# endif 782# if (__NetBSD_Version__ >= 105000000) 783# define HAVE_M_PULLDOWN 1 784# endif 785# endif 786 787# if (__NetBSD_Version__ >= 499000000) 788typedef char * caddr_t; 789# endif 790 791# define ipf_random arc4random 792 793# ifdef _KERNEL 794# if (__NetBSD_Version__ >= 399001400) 795# define KMALLOCS(a, b, c) (a) = (b)malloc((c), _M_IPF, M_NOWAIT) 796# endif 797# define MSGDSIZE(x) mbufchainlen(x) 798# define M_LEN(x) (x)->m_len 799# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 800# define GETKTIME(x) microtime((struct timeval *)x) 801# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 802# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 803# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 804typedef struct mbuf mb_t; 805# endif /* _KERNEL */ 806# if (NetBSD <= 1991011) && (NetBSD >= 199606) 807# define IFNAME(x) ((struct ifnet *)x)->if_xname 808# define COPYIFNAME(v, x, b) \ 809 (void) strncpy(b, \ 810 ((struct ifnet *)x)->if_xname, \ 811 LIFNAMSIZ) 812# define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index)&7) 813# else 814# define IFNAME(x) ((struct ifnet *)x)->if_name 815# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 816 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 817# endif 818typedef struct uio uio_t; 819typedef u_long ioctlcmd_t; 820typedef int minor_t; 821typedef u_int32_t u_32_t; 822# define U_32_T 1 823 824# define OS_RECOGNISED 1 825#endif /* __NetBSD__ */ 826 827 828/* ----------------------------------------------------------------------- */ 829/* F R E E B S D */ 830/* ----------------------------------------------------------------------- */ 831#ifdef __FreeBSD__ 832# if (__FreeBSD_version < 400000) 833# define NEED_LOCAL_RAND 1 834# else 835# define ipf_random arc4random 836# endif 837# if defined(_KERNEL) 838# if (__FreeBSD_version >= 500000) 839# include "opt_bpf.h" 840# else 841# include "bpf.h" 842# endif 843# if defined(__FreeBSD_version) && (__FreeBSD_version >= 400000) 844# include "opt_inet6.h" 845# endif 846# if defined(INET6) && !defined(USE_INET6) 847# define USE_INET6 848# endif 849# endif 850 851# if defined(_KERNEL) 852# if (__FreeBSD_version >= 400000) 853/* 854 * When #define'd, the 5.2.1 kernel panics when used with the ftp proxy. 855 * There may be other, safe, kernels but this is not extensively tested yet. 856 */ 857# define HAVE_M_PULLDOWN 858# endif 859# if !defined(IPFILTER_LKM) && (__FreeBSD_version >= 300000) 860# include "opt_ipfilter.h" 861# endif 862# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 863# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 864 865# if (__FreeBSD_version >= 500043) 866# define NETBSD_PF 867# endif 868# endif /* _KERNEL */ 869 870# if (__FreeBSD_version >= 500043) 871# include <sys/mutex.h> 872# if (__FreeBSD_version > 700014) 873# include <sys/rwlock.h> 874# define KRWLOCK_T struct rwlock 875# ifdef _KERNEL 876# define READ_ENTER(x) rw_rlock(&(x)->ipf_lk) 877# define WRITE_ENTER(x) rw_wlock(&(x)->ipf_lk) 878# define MUTEX_DOWNGRADE(x) rw_downgrade(&(x)->ipf_lk) 879# define RWLOCK_INIT(x, y) rw_init(&(x)->ipf_lk, (y)) 880# define RW_DESTROY(x) rw_destroy(&(x)->ipf_lk) 881# define RWLOCK_EXIT(x) do { \ 882 if (rw_wowned(&(x)->ipf_lk)) \ 883 rw_wunlock(&(x)->ipf_lk); \ 884 else \ 885 rw_runlock(&(x)->ipf_lk); \ 886 } while (0) 887# endif 888# else 889# include <sys/sx.h> 890/* 891 * Whilst the sx(9) locks on FreeBSD have the right semantics and interface 892 * for what we want to use them for, despite testing showing they work - 893 * with a WITNESS kernel, it generates LOR messages. 894 */ 895# ifdef _KERNEL 896# if (__FreeBSD_version < 700000) 897# define KRWLOCK_T struct mtx 898# define READ_ENTER(x) mtx_lock(&(x)->ipf_lk) 899# define WRITE_ENTER(x) mtx_lock(&(x)->ipf_lk) 900# define RWLOCK_EXIT(x) mtx_unlock(&(x)->ipf_lk) 901# define MUTEX_DOWNGRADE(x) ; 902# define RWLOCK_INIT(x,y) mtx_init(&(x)->ipf_lk, (y), NULL,\ 903 MTX_DEF) 904# define RW_DESTROY(x) mtx_destroy(&(x)->ipf_lk) 905# else 906# define KRWLOCK_T struct sx 907# define READ_ENTER(x) sx_slock(&(x)->ipf_lk) 908# define WRITE_ENTER(x) sx_xlock(&(x)->ipf_lk) 909# define MUTEX_DOWNGRADE(x) sx_downgrade(&(x)->ipf_lk) 910# define RWLOCK_INIT(x, y) sx_init(&(x)->ipf_lk, (y)) 911# define RW_DESTROY(x) sx_destroy(&(x)->ipf_lk) 912# ifdef sx_unlock 913# define RWLOCK_EXIT(x) sx_unlock(&(x)->ipf_lk) 914# else 915# define RWLOCK_EXIT(x) do { \ 916 if ((x)->ipf_lk.sx_cnt < 0) \ 917 sx_xunlock(&(x)->ipf_lk); \ 918 else \ 919 sx_sunlock(&(x)->ipf_lk); \ 920 } while (0) 921# endif 922# endif 923# endif 924# endif 925# define KMUTEX_T struct mtx 926# endif 927 928# if (__FreeBSD_version >= 501113) 929# include <net/if_var.h> 930# define IFNAME(x) ((struct ifnet *)x)->if_xname 931# define COPYIFNAME(v, x, b) \ 932 (void) strncpy(b, \ 933 ((struct ifnet *)x)->if_xname, \ 934 LIFNAMSIZ) 935# endif 936# if (__FreeBSD_version >= 500043) 937# define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index) & 7) 938# else 939# define IFNAME(x) ((struct ifnet *)x)->if_name 940# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 941 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 942# endif 943 944# ifdef _KERNEL 945# define GETKTIME(x) microtime((struct timeval *)x) 946 947# if (__FreeBSD_version >= 500002) 948# include <netinet/in_systm.h> 949# include <netinet/ip.h> 950# include <machine/in_cksum.h> 951# endif 952 953# if (__FreeBSD_version >= 500043) 954# define USE_MUTEXES 955# define MUTEX_ENTER(x) mtx_lock(&(x)->ipf_lk) 956# define MUTEX_EXIT(x) mtx_unlock(&(x)->ipf_lk) 957# define MUTEX_INIT(x,y) mtx_init(&(x)->ipf_lk, (y), NULL,\ 958 MTX_DEF) 959# define MUTEX_DESTROY(x) mtx_destroy(&(x)->ipf_lk) 960# define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 961# include <machine/atomic.h> 962# define ATOMIC_INC(x) { mtx_lock(&ipf_rw.ipf_lk); (x)++; \ 963 mtx_unlock(&ipf_rw.ipf_lk); } 964# define ATOMIC_DEC(x) { mtx_lock(&ipf_rw.ipf_lk); (x)--; \ 965 mtx_unlock(&ipf_rw.ipf_lk); } 966# define ATOMIC_INCL(x) atomic_add_long(&(x), 1) 967# define ATOMIC_INC64(x) ATOMIC_INC(x) 968# define ATOMIC_INC32(x) atomic_add_32((u_int *)&(x), 1) 969# define ATOMIC_INC16(x) atomic_add_16(&(x), 1) 970# define ATOMIC_DECL(x) atomic_add_long(&(x), -1) 971# define ATOMIC_DEC64(x) ATOMIC_DEC(x) 972# define ATOMIC_DEC32(x) atomic_add_32((u_int *)&(x), -1) 973# define ATOMIC_DEC16(x) atomic_add_16(&(x), -1) 974# define SPL_X(x) ; 975# define SPL_NET(x) ; 976# define SPL_IMP(x) ; 977# define SPL_SCHED(x) ; 978extern int in_cksum __P((struct mbuf *, int)); 979# else 980# define SPL_SCHED(x) x = splhigh() 981# endif /* __FreeBSD_version >= 500043 */ 982# define MSGDSIZE(x) mbufchainlen(x) 983# define M_LEN(x) (x)->m_len 984# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 985# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 986typedef struct mbuf mb_t; 987# endif /* _KERNEL */ 988 989# if __FreeBSD__ < 3 990# include <machine/spl.h> 991# else 992# if __FreeBSD__ == 3 993# if defined(IPFILTER_LKM) && !defined(ACTUALLY_LKM_NOT_KERNEL) 994# define ACTUALLY_LKM_NOT_KERNEL 995# endif 996# endif 997# endif 998 999# if (__FreeBSD_version >= 300000) 1000typedef u_long ioctlcmd_t; 1001# else 1002typedef int ioctlcmd_t; 1003# endif 1004typedef struct uio uio_t; 1005typedef int minor_t; 1006typedef u_int32_t u_32_t; 1007# define U_32_T 1 1008 1009# define OS_RECOGNISED 1 1010#endif /* __FreeBSD__ */ 1011 1012 1013/* ----------------------------------------------------------------------- */ 1014/* O P E N B S D */ 1015/* ----------------------------------------------------------------------- */ 1016#ifdef __OpenBSD__ 1017# ifdef INET6 1018# define USE_INET6 1019# endif 1020 1021# ifdef _KERNEL 1022# if !defined(IPFILTER_LKM) 1023# include "bpfilter.h" 1024# endif 1025# if (OpenBSD >= 200311) 1026# define SNPRINTF snprintf 1027# if defined(USE_INET6) 1028# include "netinet6/in6_var.h" 1029# include "netinet6/nd6.h" 1030# endif 1031# endif 1032# if (OpenBSD >= 200012) 1033# define HAVE_M_PULLDOWN 1 1034# endif 1035# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 1036# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 1037# define GETKTIME(x) microtime((struct timeval *)x) 1038# define MSGDSIZE(x) mbufchainlen(x) 1039# define M_LEN(x) (x)->m_len 1040# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 1041# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 1042typedef struct mbuf mb_t; 1043# endif /* _KERNEL */ 1044# if (OpenBSD >= 199603) 1045# define IFNAME(x, b) ((struct ifnet *)x)->if_xname 1046# define COPYIFNAME(v, x, b) \ 1047 (void) strncpy(b, \ 1048 ((struct ifnet *)x)->if_xname, \ 1049 LIFNAMSIZ) 1050# define CACHE_HASH(x) ((((struct ifnet *)fin->fin_ifp)->if_index)&7) 1051# else 1052# define IFNAME(x, b) ((struct ifnet *)x)->if_name 1053# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1054 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1055# endif 1056 1057typedef struct uio uio_t; 1058typedef u_long ioctlcmd_t; 1059typedef int minor_t; 1060typedef u_int32_t u_32_t; 1061# define U_32_T 1 1062 1063# define OS_RECOGNISED 1 1064#endif /* __OpenBSD__ */ 1065 1066 1067/* ----------------------------------------------------------------------- */ 1068/* B S D O S */ 1069/* ----------------------------------------------------------------------- */ 1070#ifdef _BSDI_VERSION 1071# ifdef INET6 1072# define USE_INET6 1073# endif 1074 1075# ifdef _KERNEL 1076# define GETKTIME(x) microtime((struct timeval *)x) 1077# define MSGDSIZE(x) mbufchainlen(x) 1078# define M_LEN(x) (x)->m_len 1079# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 1080# define IFNAME(x, b) ((struct ifnet *)x)->if_name 1081# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1082 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1083typedef struct mbuf mb_t; 1084# endif /* _KERNEL */ 1085 1086# if (_BSDI_VERSION >= 199701) 1087typedef u_long ioctlcmd_t; 1088# else 1089typedef int ioctlcmd_t; 1090# endif 1091typedef u_int32_t u_32_t; 1092# define U_32_T 1 1093 1094#endif /* _BSDI_VERSION */ 1095 1096 1097/* ----------------------------------------------------------------------- */ 1098/* S U N O S 4 */ 1099/* ----------------------------------------------------------------------- */ 1100#if defined(sun) && !defined(OS_RECOGNISED) /* SunOS4 */ 1101# ifdef _KERNEL 1102# include <sys/kmem_alloc.h> 1103# define GETKTIME(x) uniqtime((struct timeval *)x) 1104# define MSGDSIZE(x) mbufchainlen(x) 1105# define M_LEN(x) (x)->m_len 1106# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 1107# define IFNAME(x, b) ((struct ifnet *)x)->if_name 1108# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1109 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1110# define GETIFP(n, v) ifunit(n, IFNAMSIZ) 1111# define KFREE(x) kmem_free((char *)(x), sizeof(*(x))) 1112# define KFREES(x,s) kmem_free((char *)(x), (s)) 1113# define SLEEP(id, n) sleep((id), PZERO+1) 1114# define WAKEUP(id,x) wakeup(id + x) 1115# define POLLWAKEUP(x) ; 1116# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 1117# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 1118 1119extern void m_copydata __P((struct mbuf *, int, int, caddr_t)); 1120extern void m_copyback __P((struct mbuf *, int, int, caddr_t)); 1121 1122typedef struct mbuf mb_t; 1123# endif 1124 1125typedef struct uio uio_t; 1126typedef int ioctlcmd_t; 1127typedef int minor_t; 1128typedef unsigned int u_32_t; 1129# define U_32_T 1 1130 1131# define OS_RECOGNISED 1 1132 1133#endif /* SunOS 4 */ 1134 1135/* ----------------------------------------------------------------------- */ 1136/* L I N U X */ 1137/* ----------------------------------------------------------------------- */ 1138#if defined(linux) && !defined(OS_RECOGNISED) 1139#include <linux/config.h> 1140#include <linux/version.h> 1141# if (LINUX >= 20600) && defined(_KERNEL) 1142# define HDR_T_PRIVATE 1 1143# endif 1144# undef USE_INET6 1145# ifdef USE_INET6 1146struct ip6_ext { 1147 u_char ip6e_nxt; 1148 u_char ip6e_len; 1149}; 1150# endif 1151 1152# ifdef _KERNEL 1153# define IPF_PANIC(x,y) if (x) { printf y; panic("ipf_panic"); } 1154# define COPYIN(a,b,c) copy_from_user((caddr_t)(b), (caddr_t)(a), (c)) 1155# define COPYOUT(a,b,c) copy_to_user((caddr_t)(b), (caddr_t)(a), (c)) 1156# define FREE_MB_T(m) kfree_skb(m) 1157# define GETKTIME(x) do_gettimeofday((struct timeval *)x) 1158# define POLLWAKEUP(x) ; 1159# ifdef wait_event_interruptible 1160# define SLEEP(x,s) wait_event_interruptible((*(x##_linux)), 0) 1161# else 1162# define SLEEP(x,s) 0, interruptible_sleep_on(x##_linux) 1163# endif 1164# define WAKEUP(x,y) wake_up(x##_linux + y) 1165# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 1166# define USE_MUTEXES 1167# define KRWLOCK_T rwlock_t 1168# define KMUTEX_T spinlock_t 1169# define MUTEX_INIT(x,y) spin_lock_init(&(x)->ipf_lk) 1170# define MUTEX_ENTER(x) spin_lock(&(x)->ipf_lk) 1171# define MUTEX_EXIT(x) spin_unlock(&(x)->ipf_lk) 1172# define MUTEX_DESTROY(x) do { } while (0) 1173# define MUTEX_NUKE(x) bzero(&(x)->ipf_lk, sizeof((x)->ipf_lk)) 1174# define READ_ENTER(x) ipf_read_enter(x) 1175# define WRITE_ENTER(x) ipf_write_enter(x) 1176# define RWLOCK_INIT(x,y) ipf_rw_init(x, y) 1177# define RW_DESTROY(x) do { } while (0) 1178# define RWLOCK_EXIT(x) ipf_rw_exit(x) 1179# define MUTEX_DOWNGRADE(x) ipf_rw_downgrade(x) 1180# define ATOMIC_INCL(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1181 MUTEX_EXIT(&ipf_rw) 1182# define ATOMIC_DECL(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1183 MUTEX_EXIT(&ipf_rw) 1184# define ATOMIC_INC64(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1185 MUTEX_EXIT(&ipf_rw) 1186# define ATOMIC_INC32(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1187 MUTEX_EXIT(&ipf_rw) 1188# define ATOMIC_INC16(x) MUTEX_ENTER(&ipf_rw); (x)++; \ 1189 MUTEX_EXIT(&ipf_rw) 1190# define ATOMIC_DEC64(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1191 MUTEX_EXIT(&ipf_rw) 1192# define ATOMIC_DEC32(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1193 MUTEX_EXIT(&ipf_rw) 1194# define ATOMIC_DEC16(x) MUTEX_ENTER(&ipf_rw); (x)--; \ 1195 MUTEX_EXIT(&ipf_rw) 1196# define SPL_SCHED(x) do { } while (0) 1197# define SPL_IMP(x) do { } while (0) 1198# define SPL_NET(x) do { } while (0) 1199# define SPL_X(x) do { } while (0) 1200# define IFNAME(x) ((struct net_device*)x)->name 1201# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1202 ((struct net_device *)fin->fin_ifp)->ifindex) & 7) 1203typedef struct sk_buff mb_t; 1204extern void m_copydata __P((mb_t *, int, int, caddr_t)); 1205extern void m_copyback __P((mb_t *, int, int, caddr_t)); 1206extern void m_adj __P((mb_t *, int)); 1207extern mb_t *m_pullup __P((mb_t *, int)); 1208# define mbuf sk_buff 1209 1210# define mtod(m, t) ((t)(m)->data) 1211# define m_data data 1212# define m_len len 1213# define m_next next 1214# define M_DUPLICATE(m) skb_clone((m), in_interrupt() ? GFP_ATOMIC : \ 1215 GFP_KERNEL) 1216# define MSGDSIZE(m) (m)->len 1217# define M_LEN(m) (m)->len 1218 1219# define splnet(x) ; 1220# define printf printk 1221# define bcopy(s,d,z) memmove(d, s, z) 1222# define bzero(s,z) memset(s, 0, z) 1223# define bcmp(a,b,z) memcmp(a, b, z) 1224 1225# define ifnet net_device 1226# define if_xname name 1227# define if_unit ifindex 1228 1229# define KMALLOC(x,t) (x) = (t)kmalloc(sizeof(*(x)), \ 1230 in_interrupt() ? GFP_ATOMIC : GFP_KERNEL) 1231# define KFREE(x) kfree(x) 1232# define KMALLOCS(x,t,s) (x) = (t)kmalloc((s), \ 1233 in_interrupt() ? GFP_ATOMIC : GFP_KERNEL) 1234# define KFREES(x,s) kfree(x) 1235 1236# define GETIFP(n,v) dev_get_by_name(n) 1237 1238# else 1239# include <net/ethernet.h> 1240 1241struct mbuf { 1242}; 1243 1244# ifndef _NET_ROUTE_H 1245struct rtentry { 1246}; 1247# endif 1248 1249struct ifnet { 1250 char if_xname[IFNAMSIZ]; 1251 int if_unit; 1252 int (* if_output) __P((struct ifnet *, struct mbuf *, struct sockaddr *, struct rtentry *)); 1253 struct ifaddr *if_addrlist; 1254}; 1255# define IFNAME(x) ((struct ifnet *)x)->if_xname 1256 1257# endif /* _KERNEL */ 1258 1259# define COPYIFNAME(v, x, b) \ 1260 (void) strncpy(b, \ 1261 ((struct ifnet *)x)->if_xname, \ 1262 LIFNAMSIZ) 1263 1264# include <linux/fs.h> 1265# define FWRITE FMODE_WRITE 1266# define FREAD FMODE_READ 1267 1268# define __USE_MISC 1 1269# define __FAVOR_BSD 1 1270 1271typedef struct uio { 1272 struct iovec *uio_iov; 1273 void *uio_file; 1274 char *uio_buf; 1275 int uio_iovcnt; 1276 int uio_offset; 1277 size_t uio_resid; 1278 int uio_rw; 1279} uio_t; 1280 1281extern int uiomove __P((caddr_t, size_t, int, struct uio *)); 1282 1283# define UIO_READ 1 1284# define UIO_WRITE 2 1285 1286typedef u_long ioctlcmd_t; 1287typedef int minor_t; 1288typedef u_int32_t u_32_t; 1289# define U_32_T 1 1290 1291# define OS_RECOGNISED 1 1292 1293#endif 1294 1295 1296/* ----------------------------------------------------------------------- */ 1297/* A I X */ 1298/* ----------------------------------------------------------------------- */ 1299#if defined(_AIX51) 1300# undef MENTAT 1301 1302# include <sys/lock.h> 1303# include <sys/sysmacros.h> 1304 1305# ifdef _KERNEL 1306# define rw_read_locked(x) 0 1307# include <net/net_globals.h> 1308# include <net/net_malloc.h> 1309# define KMUTEX_T simple_lock_t 1310# define KRWLOCK_T complex_lock_t 1311# define USE_MUTEXES 1 1312# define USE_SPL 1 1313# define READ_ENTER(x) lock_read((x)->ipf_lk) 1314# define WRITE_ENTER(x) lock_write((x)->ipf_lk) 1315# define MUTEX_DOWNGRADE(x) lock_write_to_read((x)->ipf_lk) 1316# define RWLOCK_INIT(x, y) lock_alloc(&(x)->ipf_lk, \ 1317 LOCK_ALLOC_PIN, \ 1318 (u_short)y, 0); \ 1319 lock_init((x)->ipf_lk, TRUE) 1320# define RWLOCK_EXIT(x) lock_done((x)->ipf_lk) 1321# define RW_DESTROY(x) lock_free(&(x)->ipf_lk) 1322# define MUTEX_ENTER(x) simple_lock((x)->ipf_lk) 1323# define MUTEX_INIT(x, y) lock_alloc(&(x)->ipf_lk, \ 1324 LOCK_ALLOC_PIN, \ 1325 (u_short)y, 0); \ 1326 simple_lock_init((x)->ipf_lk) 1327# define MUTEX_DESTROY(x) lock_free(&(x)->ipf_lk) 1328# define MUTEX_EXIT(x) simple_unlock((x)->ipf_lk) 1329# define MUTEX_NUKE(x) bzero(&(x)->ipf_lk, sizeof((x)->ipf_lk)) 1330# define ATOMIC_INC64(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1331 MUTEX_EXIT(&ipf_rw); } 1332# define ATOMIC_DEC64(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1333 MUTEX_EXIT(&ipf_rw); } 1334# define ATOMIC_INC32(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1335 MUTEX_EXIT(&ipf_rw); } 1336# define ATOMIC_DEC32(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1337 MUTEX_EXIT(&ipf_rw); } 1338# define ATOMIC_INCL(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1339 MUTEX_EXIT(&ipf_rw); } 1340# define ATOMIC_DECL(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1341 MUTEX_EXIT(&ipf_rw); } 1342# define ATOMIC_INC(x) { MUTEX_ENTER(&ipf_rw); (x)++; \ 1343 MUTEX_EXIT(&ipf_rw); } 1344# define ATOMIC_DEC(x) { MUTEX_ENTER(&ipf_rw); (x)--; \ 1345 MUTEX_EXIT(&ipf_rw); } 1346# define SPL_SCHED(x) x = splsched() 1347# define SPL_NET(x) x = splnet() 1348# define SPL_IMP(x) x = splimp() 1349# undef SPL_X 1350# define SPL_X(x) splx(x) 1351# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,c,d) 1352extern void* getifp __P((char *, int)); 1353# define GETIFP(n, v) getifp(n, v) 1354# define GET_MINOR minor 1355# define SLEEP(id, n) sleepx((id), PZERO+1, 0) 1356# define WAKEUP(id,x) wakeup(id) 1357# define POLLWAKEUP(x) ; 1358# define COPYIN(a,b,c) copyin((caddr_t)(a), (caddr_t)(b), (c)) 1359# define COPYOUT(a,b,c) copyout((caddr_t)(a), (caddr_t)(b), (c)) 1360# define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), M_TEMP, M_NOWAIT) 1361# define KMALLOCS(a, b, c) MALLOC((a), b, (c), M_TEMP, \ 1362 ((c) > 4096) ? M_WAITOK : M_NOWAIT) 1363# define KFREE(x) FREE((x), M_TEMP) 1364# define KFREES(x,s) FREE((x), M_TEMP) 1365# define MSGDSIZE(x) mbufchainlen(x) 1366# define M_LEN(x) (x)->m_len 1367# define M_DUPLICATE(x) m_copy((x), 0, M_COPYALL) 1368# define GETKTIME(x) 1369# define IFNAME(x, b) ((struct ifnet *)x)->if_name 1370# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1371 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1372# define IPF_PANIC(x,y) 1373typedef struct mbuf mb_t; 1374# endif /* _KERNEL */ 1375 1376/* 1377 * These are from's Solaris' #defines for little endian. 1378 */ 1379#if !defined(IP6F_MORE_FRAG) 1380# define IP6F_MORE_FRAG 0x0100 1381#endif 1382#if !defined(IP6F_RESERVED_MASK) 1383# define IP6F_RESERVED_MASK 0x0600 1384#endif 1385#if !defined(IP6F_OFF_MASK) 1386# define IP6F_OFF_MASK 0xf8ff 1387#endif 1388 1389struct ip6_ext { 1390 u_char ip6e_nxt; 1391 u_char ip6e_len; 1392}; 1393 1394typedef int ioctlcmd_t; 1395typedef int minor_t; 1396/* 1397 * Really, any arch where sizeof(long) != sizeof(int). 1398 */ 1399typedef unsigned int u_32_t; 1400# define U_32_T 1 1401 1402# define OS_RECOGNISED 1 1403#endif /* _AIX51 */ 1404 1405 1406#ifndef OS_RECOGNISED 1407#error ip_compat.h does not recognise this platform/OS. 1408#endif 1409 1410 1411/* ----------------------------------------------------------------------- */ 1412/* G E N E R I C */ 1413/* ----------------------------------------------------------------------- */ 1414#ifndef OS_RECOGNISED 1415#endif 1416 1417/* 1418 * For BSD kernels, if bpf is in the kernel, enable ipfilter to use bpf in 1419 * filter rules. 1420 */ 1421#if !defined(IPFILTER_BPF) 1422# if (defined(NBPF) && (NBPF > 0)) || (defined(DEV_BPF) && (DEV_BPF > 0)) || \ 1423 (defined(NBPFILTER) && (NBPFILTER > 0)) 1424# define IPFILTER_BPF 1425# endif 1426#endif 1427 1428/* 1429 * Userland locking primitives 1430 */ 1431typedef struct { 1432 char *eMm_owner; 1433 char *eMm_heldin; 1434 u_int eMm_magic; 1435 int eMm_held; 1436 int eMm_heldat; 1437#if defined(__hpux) || defined(__linux) 1438 char eMm_fill[8]; 1439#endif 1440} eMmutex_t; 1441 1442typedef struct { 1443 char *eMrw_owner; 1444 char *eMrw_heldin; 1445 u_int eMrw_magic; 1446 short eMrw_read; 1447 short eMrw_write; 1448 int eMrw_heldat; 1449#ifdef __hpux 1450 char eMm_fill[24]; 1451#endif 1452} eMrwlock_t; 1453 1454typedef union { 1455#ifdef KMUTEX_T 1456 struct { 1457 KMUTEX_T ipf_slk; 1458 char *ipf_lname; 1459 } ipf_lkun_s; 1460#endif 1461 eMmutex_t ipf_emu; 1462} ipfmutex_t; 1463 1464typedef union { 1465#ifdef KRWLOCK_T 1466 struct { 1467 KRWLOCK_T ipf_slk; 1468 char *ipf_lname; 1469 int ipf_sr; 1470 int ipf_sw; 1471 u_int ipf_magic; 1472 } ipf_lkun_s; 1473#endif 1474 eMrwlock_t ipf_emu; 1475} ipfrwlock_t; 1476 1477#define ipf_lk ipf_lkun_s.ipf_slk 1478#define ipf_lname ipf_lkun_s.ipf_lname 1479#define ipf_isr ipf_lkun_s.ipf_sr 1480#define ipf_isw ipf_lkun_s.ipf_sw 1481#define ipf_magic ipf_lkun_s.ipf_magic 1482 1483#if !defined(__GNUC__) || \ 1484 (defined(__FreeBSD_version) && (__FreeBSD_version >= 503000)) 1485# ifndef INLINE 1486# define INLINE 1487# endif 1488#else 1489# define INLINE __inline__ 1490#endif 1491 1492#if defined(linux) && defined(_KERNEL) 1493extern void ipf_read_enter __P((ipfrwlock_t *)); 1494extern void ipf_write_enter __P((ipfrwlock_t *)); 1495extern void ipf_rw_exit __P((ipfrwlock_t *)); 1496extern void ipf_rw_init __P((ipfrwlock_t *, char *)); 1497extern void ipf_rw_downgrade __P((ipfrwlock_t *)); 1498#endif 1499 1500/* 1501 * In a non-kernel environment, there are a lot of macros that need to be 1502 * filled in to be null-ops or to point to some compatibility function, 1503 * somewhere in userland. 1504 */ 1505#ifndef _KERNEL 1506typedef struct mb_s { 1507 struct mb_s *mb_next; 1508 int mb_len; 1509 u_long mb_buf[2048]; 1510} mb_t; 1511# undef m_next 1512# define m_next mb_next 1513# define MSGDSIZE(x) (x)->mb_len /* XXX - from ipt.c */ 1514# define M_LEN(x) (x)->mb_len 1515# define M_DUPLICATE(x) (x) 1516# define GETKTIME(x) gettimeofday((struct timeval *)(x), NULL) 1517# undef MTOD 1518# define MTOD(m, t) ((t)(m)->mb_buf) 1519# define FREE_MB_T(x) 1520# define SLEEP(x,y) 1; 1521# define WAKEUP(x,y) ; 1522# define POLLWAKEUP(y) ; 1523# define IPF_PANIC(x,y) ; 1524# define PANIC(x,y) ; 1525# define SPL_SCHED(x) ; 1526# define SPL_NET(x) ; 1527# define SPL_IMP(x) ; 1528# define SPL_X(x) ; 1529# define KMALLOC(a,b) (a) = (b)malloc(sizeof(*a)) 1530# define KMALLOCS(a,b,c) (a) = (b)malloc(c) 1531# define KFREE(x) free(x) 1532# define KFREES(x,s) free(x) 1533# define GETIFP(x, v) get_unit(x,v) 1534# define COPYIN(a,b,c) bcopywrap((a), (b), (c)) 1535# define COPYOUT(a,b,c) bcopywrap((a), (b), (c)) 1536# define COPYDATA(m, o, l, b) bcopy(MTOD((mb_t *)m, char *) + (o), \ 1537 (b), (l)) 1538# define COPYBACK(m, o, l, b) bcopy((b), \ 1539 MTOD((mb_t *)m, char *) + (o), \ 1540 (l)) 1541# define UIOMOVE(a,b,c,d) ipfuiomove((caddr_t)a,b,c,d) 1542extern void m_copydata __P((mb_t *, int, int, caddr_t)); 1543extern int ipfuiomove __P((caddr_t, int, int, struct uio *)); 1544extern int bcopywrap __P((void *, void *, size_t)); 1545# ifndef CACHE_HASH 1546# define CACHE_HASH(x) ((IFNAME(fin->fin_ifp)[0] + \ 1547 ((struct ifnet *)fin->fin_ifp)->if_unit) & 7) 1548# endif 1549 1550# define MUTEX_DESTROY(x) eMmutex_destroy(&(x)->ipf_emu) 1551# define MUTEX_ENTER(x) eMmutex_enter(&(x)->ipf_emu, \ 1552 __FILE__, __LINE__) 1553# define MUTEX_EXIT(x) eMmutex_exit(&(x)->ipf_emu) 1554# define MUTEX_INIT(x,y) eMmutex_init(&(x)->ipf_emu, y) 1555# define MUTEX_NUKE(x) bzero((x), sizeof(*(x))) 1556 1557# define MUTEX_DOWNGRADE(x) eMrwlock_downgrade(&(x)->ipf_emu, \ 1558 __FILE__, __LINE__) 1559# define READ_ENTER(x) eMrwlock_read_enter(&(x)->ipf_emu, \ 1560 __FILE__, __LINE__) 1561# define RWLOCK_INIT(x, y) eMrwlock_init(&(x)->ipf_emu, y) 1562# define RWLOCK_EXIT(x) eMrwlock_exit(&(x)->ipf_emu) 1563# define RW_DESTROY(x) eMrwlock_destroy(&(x)->ipf_emu) 1564# define WRITE_ENTER(x) eMrwlock_write_enter(&(x)->ipf_emu, \ 1565 __FILE__, \ 1566 __LINE__) 1567 1568# define USE_MUTEXES 1 1569 1570extern void eMmutex_destroy __P((eMmutex_t *)); 1571extern void eMmutex_enter __P((eMmutex_t *, char *, int)); 1572extern void eMmutex_exit __P((eMmutex_t *)); 1573extern void eMmutex_init __P((eMmutex_t *, char *)); 1574extern void eMrwlock_destroy __P((eMrwlock_t *)); 1575extern void eMrwlock_exit __P((eMrwlock_t *)); 1576extern void eMrwlock_init __P((eMrwlock_t *, char *)); 1577extern void eMrwlock_read_enter __P((eMrwlock_t *, char *, int)); 1578extern void eMrwlock_write_enter __P((eMrwlock_t *, char *, int)); 1579extern void eMrwlock_downgrade __P((eMrwlock_t *, char *, int)); 1580 1581#endif 1582 1583#define MAX_IPV4HDR ((0xf << 2) + sizeof(struct icmp) + sizeof(ip_t) + 8) 1584 1585#ifndef IP_OFFMASK 1586# define IP_OFFMASK 0x1fff 1587#endif 1588 1589 1590/* 1591 * On BSD's use quad_t as a guarantee for getting at least a 64bit sized 1592 * object. 1593 */ 1594#if (BSD > 199306) 1595# define USE_QUAD_T 1596# define U_QUAD_T unsigned long long 1597# define QUAD_T long long 1598#else /* BSD > 199306 */ 1599# define U_QUAD_T u_long 1600# define QUAD_T long 1601#endif /* BSD > 199306 */ 1602 1603 1604#ifdef USE_INET6 1605# if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \ 1606 defined(__osf__) || defined(linux) 1607# include <netinet/ip6.h> 1608# include <netinet/icmp6.h> 1609# if !defined(linux) 1610# if defined(_KERNEL) && !defined(__osf__) 1611# include <netinet6/ip6_var.h> 1612# endif 1613# endif 1614typedef struct ip6_hdr ip6_t; 1615# endif 1616#endif 1617 1618#ifndef MAX 1619# define MAX(a,b) (((a) > (b)) ? (a) : (b)) 1620#endif 1621 1622#if defined(_KERNEL) 1623# ifdef MENTAT 1624# define COPYDATA mb_copydata 1625# define COPYBACK mb_copyback 1626# else 1627# define COPYDATA m_copydata 1628# define COPYBACK m_copyback 1629# endif 1630# if (BSD >= 199306) || defined(__FreeBSD__) 1631# if (defined(__NetBSD_Version__) && (__NetBSD_Version__ < 105180000)) || \ 1632 defined(__FreeBSD__) || (defined(OpenBSD) && (OpenBSD < 200206)) || \ 1633 defined(_BSDI_VERSION) 1634# include <vm/vm.h> 1635# endif 1636# if !defined(__FreeBSD__) || (defined (__FreeBSD_version) && \ 1637 (__FreeBSD_version >= 300000)) 1638# if (defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105180000)) || \ 1639 (defined(OpenBSD) && (OpenBSD >= 200111)) 1640# include <uvm/uvm_extern.h> 1641# else 1642# include <vm/vm_extern.h> 1643extern vm_map_t kmem_map; 1644# endif 1645# include <sys/proc.h> 1646# else /* !__FreeBSD__ || (__FreeBSD__ && __FreeBSD_version >= 300000) */ 1647# include <vm/vm_kern.h> 1648# endif /* !__FreeBSD__ || (__FreeBSD__ && __FreeBSD_version >= 300000) */ 1649 1650# ifdef IPFILTER_M_IPFILTER 1651# include <sys/malloc.h> 1652MALLOC_DECLARE(M_IPFILTER); 1653# define _M_IPF M_IPFILTER 1654# else /* IPFILTER_M_IPFILTER */ 1655# ifdef M_PFIL 1656# define _M_IPF M_PFIL 1657# else 1658# ifdef M_IPFILTER 1659# define _M_IPF M_IPFILTER 1660# else 1661# define _M_IPF M_TEMP 1662# endif /* M_IPFILTER */ 1663# endif /* M_PFIL */ 1664# endif /* IPFILTER_M_IPFILTER */ 1665# define KMALLOC(a, b) MALLOC((a), b, sizeof(*(a)), _M_IPF, M_NOWAIT) 1666# if !defined(KMALLOCS) 1667# define KMALLOCS(a, b, c) MALLOC((a), b, (c), _M_IPF, M_NOWAIT) 1668# endif 1669# define KFREE(x) FREE((x), _M_IPF) 1670# define KFREES(x,s) FREE((x), _M_IPF) 1671# define UIOMOVE(a,b,c,d) uiomove((caddr_t)a,b,d) 1672# define SLEEP(id, n) tsleep((id), PPAUSE|PCATCH, n, 0) 1673# define WAKEUP(id,x) wakeup(id+x) 1674# define POLLWAKEUP(x) selwakeup(ipfselwait+x) 1675# define GETIFP(n, v) ifunit(n) 1676# endif /* (Free)BSD */ 1677 1678# if !defined(USE_MUTEXES) && !defined(SPL_NET) 1679# if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199407)) || \ 1680 (defined(OpenBSD) && (OpenBSD >= 200006)) 1681# define SPL_NET(x) x = splsoftnet() 1682# else 1683# define SPL_IMP(x) x = splimp() 1684# define SPL_NET(x) x = splnet() 1685# endif /* NetBSD && (NetBSD <= 1991011) && (NetBSD >= 199407) */ 1686# if !defined(SPL_SCHED) 1687# define SPL_SCHED(x) x = splsched() 1688# endif 1689# define SPL_X(x) (void) splx(x) 1690# endif /* !USE_MUTEXES */ 1691 1692# ifndef FREE_MB_T 1693# define FREE_MB_T(m) m_freem(m) 1694# endif 1695 1696# ifndef MTOD 1697# define MTOD(m,t) mtod(m,t) 1698# endif 1699 1700# ifndef COPYIN 1701# define COPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 1702# define COPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 1703# endif 1704 1705# ifndef KMALLOC 1706# define KMALLOC(a,b) (a) = (b)new_kmem_alloc(sizeof(*(a)), \ 1707 KMEM_NOSLEEP) 1708# define KMALLOCS(a,b,c) (a) = (b)new_kmem_alloc((c), KMEM_NOSLEEP) 1709# endif 1710 1711# ifndef GET_MINOR 1712# define GET_MINOR(x) dev2unit(x) 1713# endif 1714# define PANIC(x,y) if (x) panic y 1715#endif /* _KERNEL */ 1716 1717#if !defined(IFNAME) && !defined(_KERNEL) 1718# define IFNAME(x) ((struct ifnet *)x)->if_name 1719#endif 1720#ifndef COPYIFNAME 1721# define NEED_FRGETIFNAME 1722extern char *fr_getifname __P((struct ifnet *, char *)); 1723# define COPYIFNAME(v, x, b) \ 1724 fr_getifname((struct ifnet *)x, b) 1725#endif 1726 1727#ifndef ASSERT 1728# ifdef _KERNEL 1729# define ASSERT(x) 1730# else 1731# define ASSERT(x) do { if (!(x)) abort(); } while (0) 1732# endif 1733#endif 1734 1735#ifndef BCOPYIN 1736# define BCOPYIN(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 1737# define BCOPYOUT(a,b,c) (bcopy((caddr_t)(a), (caddr_t)(b), (c)), 0) 1738#endif 1739 1740/* 1741 * Because the ctype(3) posix definition, if used "safely" in code everywhere, 1742 * would mean all normal code that walks through strings needed casts. Yuck. 1743 */ 1744#define ISALNUM(x) isalnum((u_char)(x)) 1745#define ISALPHA(x) isalpha((u_char)(x)) 1746#define ISASCII(x) isascii((u_char)(x)) 1747#define ISDIGIT(x) isdigit((u_char)(x)) 1748#define ISPRINT(x) isprint((u_char)(x)) 1749#define ISSPACE(x) isspace((u_char)(x)) 1750#define ISUPPER(x) isupper((u_char)(x)) 1751#define ISXDIGIT(x) isxdigit((u_char)(x)) 1752#define ISLOWER(x) islower((u_char)(x)) 1753#define TOUPPER(x) toupper((u_char)(x)) 1754#define TOLOWER(x) tolower((u_char)(x)) 1755 1756/* 1757 * If mutexes aren't being used, turn all the mutex functions into null-ops. 1758 */ 1759#if !defined(USE_MUTEXES) 1760# define USE_SPL 1 1761# undef RW_DESTROY 1762# undef MUTEX_INIT 1763# undef MUTEX_NUKE 1764# undef MUTEX_DESTROY 1765# define MUTEX_ENTER(x) ; 1766# define READ_ENTER(x) ; 1767# define WRITE_ENTER(x) ; 1768# define MUTEX_DOWNGRADE(x) ; 1769# define RWLOCK_INIT(x, y) ; 1770# define RWLOCK_EXIT(x) ; 1771# define RW_DESTROY(x) ; 1772# define MUTEX_EXIT(x) ; 1773# define MUTEX_INIT(x,y) ; 1774# define MUTEX_DESTROY(x) ; 1775# define MUTEX_NUKE(x) ; 1776#endif /* !USE_MUTEXES */ 1777#ifndef ATOMIC_INC 1778# define ATOMIC_INC(x) (x)++ 1779# define ATOMIC_DEC(x) (x)-- 1780#endif 1781 1782#if defined(USE_SPL) && defined(_KERNEL) 1783# define SPL_INT(x) int x 1784#else 1785# define SPL_INT(x) 1786#endif 1787 1788/* 1789 * If there are no atomic operations for bit sizes defined, define them to all 1790 * use a generic one that works for all sizes. 1791 */ 1792#ifndef ATOMIC_INCL 1793# define ATOMIC_INCL ATOMIC_INC 1794# define ATOMIC_INC64 ATOMIC_INC 1795# define ATOMIC_INC32 ATOMIC_INC 1796# define ATOMIC_INC16 ATOMIC_INC 1797# define ATOMIC_DECL ATOMIC_DEC 1798# define ATOMIC_DEC64 ATOMIC_DEC 1799# define ATOMIC_DEC32 ATOMIC_DEC 1800# define ATOMIC_DEC16 ATOMIC_DEC 1801#endif 1802 1803#ifndef HDR_T_PRIVATE 1804typedef struct tcphdr tcphdr_t; 1805typedef struct udphdr udphdr_t; 1806#endif 1807typedef struct icmp icmphdr_t; 1808typedef struct ip ip_t; 1809typedef struct ether_header ether_header_t; 1810typedef struct tcpiphdr tcpiphdr_t; 1811 1812#ifndef FR_GROUPLEN 1813# define FR_GROUPLEN 16 1814#endif 1815 1816#ifndef offsetof 1817# define offsetof(t,m) (int)((&((t *)0L)->m)) 1818#endif 1819 1820/* 1821 * This set of macros has been brought about because on Tru64 it is not 1822 * possible to easily assign or examine values in a structure that are 1823 * bit fields. 1824 */ 1825#ifndef IP_V 1826# define IP_V(x) (x)->ip_v 1827#endif 1828#ifndef IP_V_A 1829# define IP_V_A(x,y) (x)->ip_v = (y) 1830#endif 1831#ifndef IP_HL 1832# define IP_HL(x) (x)->ip_hl 1833#endif 1834#ifndef IP_HL_A 1835# define IP_HL_A(x,y) (x)->ip_hl = ((y) & 0xf) 1836#endif 1837#ifndef TCP_X2 1838# define TCP_X2(x) (x)->th_x2 1839#endif 1840#ifndef TCP_X2_A 1841# define TCP_X2_A(x,y) (x)->th_x2 = (y) 1842#endif 1843#ifndef TCP_OFF 1844# define TCP_OFF(x) (x)->th_off 1845#endif 1846#ifndef TCP_OFF_A 1847# define TCP_OFF_A(x,y) (x)->th_off = (y) 1848#endif 1849#define IPMINLEN(i, h) ((i)->ip_len >= (IP_HL(i) * 4 + sizeof(struct h))) 1850 1851 1852/* 1853 * XXX - This is one of those *awful* hacks which nobody likes 1854 */ 1855#ifdef ultrix 1856#define A_A 1857#else 1858#define A_A & 1859#endif 1860 1861#define TCPF_ALL (TH_FIN|TH_SYN|TH_RST|TH_PUSH|TH_ACK|TH_URG|\ 1862 TH_ECN|TH_CWR) 1863 1864#if (BSD >= 199306) && !defined(m_act) 1865# define m_act m_nextpkt 1866#endif 1867 1868/* 1869 * Security Options for Intenet Protocol (IPSO) as defined in RFC 1108. 1870 * 1871 * Basic Option 1872 * 1873 * 00000001 - (Reserved 4) 1874 * 00111101 - Top Secret 1875 * 01011010 - Secret 1876 * 10010110 - Confidential 1877 * 01100110 - (Reserved 3) 1878 * 11001100 - (Reserved 2) 1879 * 10101011 - Unclassified 1880 * 11110001 - (Reserved 1) 1881 */ 1882#define IPSO_CLASS_RES4 0x01 1883#define IPSO_CLASS_TOPS 0x3d 1884#define IPSO_CLASS_SECR 0x5a 1885#define IPSO_CLASS_CONF 0x96 1886#define IPSO_CLASS_RES3 0x66 1887#define IPSO_CLASS_RES2 0xcc 1888#define IPSO_CLASS_UNCL 0xab 1889#define IPSO_CLASS_RES1 0xf1 1890 1891#define IPSO_AUTH_GENSER 0x80 1892#define IPSO_AUTH_ESI 0x40 1893#define IPSO_AUTH_SCI 0x20 1894#define IPSO_AUTH_NSA 0x10 1895#define IPSO_AUTH_DOE 0x08 1896#define IPSO_AUTH_UN 0x06 1897#define IPSO_AUTH_FTE 0x01 1898 1899/* 1900 * IP option #defines 1901 */ 1902#undef IPOPT_RR 1903#define IPOPT_RR 7 1904#undef IPOPT_ZSU 1905#define IPOPT_ZSU 10 /* ZSU */ 1906#undef IPOPT_MTUP 1907#define IPOPT_MTUP 11 /* MTUP */ 1908#undef IPOPT_MTUR 1909#define IPOPT_MTUR 12 /* MTUR */ 1910#undef IPOPT_ENCODE 1911#define IPOPT_ENCODE 15 /* ENCODE */ 1912#undef IPOPT_TS 1913#define IPOPT_TS 68 1914#undef IPOPT_TR 1915#define IPOPT_TR 82 /* TR */ 1916#undef IPOPT_SECURITY 1917#define IPOPT_SECURITY 130 1918#undef IPOPT_LSRR 1919#define IPOPT_LSRR 131 1920#undef IPOPT_E_SEC 1921#define IPOPT_E_SEC 133 /* E-SEC */ 1922#undef IPOPT_CIPSO 1923#define IPOPT_CIPSO 134 /* CIPSO */ 1924#undef IPOPT_SATID 1925#define IPOPT_SATID 136 1926#ifndef IPOPT_SID 1927# define IPOPT_SID IPOPT_SATID 1928#endif 1929#undef IPOPT_SSRR 1930#define IPOPT_SSRR 137 1931#undef IPOPT_ADDEXT 1932#define IPOPT_ADDEXT 147 /* ADDEXT */ 1933#undef IPOPT_VISA 1934#define IPOPT_VISA 142 /* VISA */ 1935#undef IPOPT_IMITD 1936#define IPOPT_IMITD 144 /* IMITD */ 1937#undef IPOPT_EIP 1938#define IPOPT_EIP 145 /* EIP */ 1939#undef IPOPT_RTRALRT 1940#define IPOPT_RTRALRT 148 /* RTRALRT */ 1941#undef IPOPT_SDB 1942#define IPOPT_SDB 149 1943#undef IPOPT_NSAPA 1944#define IPOPT_NSAPA 150 1945#undef IPOPT_DPS 1946#define IPOPT_DPS 151 1947#undef IPOPT_UMP 1948#define IPOPT_UMP 152 1949#undef IPOPT_FINN 1950#define IPOPT_FINN 205 /* FINN */ 1951 1952#ifndef TCPOPT_EOL 1953# define TCPOPT_EOL 0 1954#endif 1955#ifndef TCPOPT_NOP 1956# define TCPOPT_NOP 1 1957#endif 1958#ifndef TCPOPT_MAXSEG 1959# define TCPOPT_MAXSEG 2 1960#endif 1961#ifndef TCPOLEN_MAXSEG 1962# define TCPOLEN_MAXSEG 4 1963#endif 1964#ifndef TCPOPT_WINDOW 1965# define TCPOPT_WINDOW 3 1966#endif 1967#ifndef TCPOLEN_WINDOW 1968# define TCPOLEN_WINDOW 3 1969#endif 1970#ifndef TCPOPT_SACK_PERMITTED 1971# define TCPOPT_SACK_PERMITTED 4 1972#endif 1973#ifndef TCPOLEN_SACK_PERMITTED 1974# define TCPOLEN_SACK_PERMITTED 2 1975#endif 1976#ifndef TCPOPT_SACK 1977# define TCPOPT_SACK 5 1978#endif 1979#ifndef TCPOPT_TIMESTAMP 1980# define TCPOPT_TIMESTAMP 8 1981#endif 1982 1983#ifndef ICMP_MINLEN 1984# define ICMP_MINLEN 8 1985#endif 1986#ifndef ICMP_ECHOREPLY 1987# define ICMP_ECHOREPLY 0 1988#endif 1989#ifndef ICMP_UNREACH 1990# define ICMP_UNREACH 3 1991#endif 1992#ifndef ICMP_UNREACH_NET 1993# define ICMP_UNREACH_NET 0 1994#endif 1995#ifndef ICMP_UNREACH_HOST 1996# define ICMP_UNREACH_HOST 1 1997#endif 1998#ifndef ICMP_UNREACH_PROTOCOL 1999# define ICMP_UNREACH_PROTOCOL 2 2000#endif 2001#ifndef ICMP_UNREACH_PORT 2002# define ICMP_UNREACH_PORT 3 2003#endif 2004#ifndef ICMP_UNREACH_NEEDFRAG 2005# define ICMP_UNREACH_NEEDFRAG 4 2006#endif 2007#ifndef ICMP_UNREACH_SRCFAIL 2008# define ICMP_UNREACH_SRCFAIL 5 2009#endif 2010#ifndef ICMP_UNREACH_NET_UNKNOWN 2011# define ICMP_UNREACH_NET_UNKNOWN 6 2012#endif 2013#ifndef ICMP_UNREACH_HOST_UNKNOWN 2014# define ICMP_UNREACH_HOST_UNKNOWN 7 2015#endif 2016#ifndef ICMP_UNREACH_ISOLATED 2017# define ICMP_UNREACH_ISOLATED 8 2018#endif 2019#ifndef ICMP_UNREACH_NET_PROHIB 2020# define ICMP_UNREACH_NET_PROHIB 9 2021#endif 2022#ifndef ICMP_UNREACH_HOST_PROHIB 2023# define ICMP_UNREACH_HOST_PROHIB 10 2024#endif 2025#ifndef ICMP_UNREACH_TOSNET 2026# define ICMP_UNREACH_TOSNET 11 2027#endif 2028#ifndef ICMP_UNREACH_TOSHOST 2029# define ICMP_UNREACH_TOSHOST 12 2030#endif 2031#ifndef ICMP_UNREACH_ADMIN_PROHIBIT 2032# define ICMP_UNREACH_ADMIN_PROHIBIT 13 2033#endif 2034#ifndef ICMP_UNREACH_FILTER 2035# define ICMP_UNREACH_FILTER 13 2036#endif 2037#ifndef ICMP_UNREACH_HOST_PRECEDENCE 2038# define ICMP_UNREACH_HOST_PRECEDENCE 14 2039#endif 2040#ifndef ICMP_UNREACH_PRECEDENCE_CUTOFF 2041# define ICMP_UNREACH_PRECEDENCE_CUTOFF 15 2042#endif 2043#ifndef ICMP_SOURCEQUENCH 2044# define ICMP_SOURCEQUENCH 4 2045#endif 2046#ifndef ICMP_REDIRECT_NET 2047# define ICMP_REDIRECT_NET 0 2048#endif 2049#ifndef ICMP_REDIRECT_HOST 2050# define ICMP_REDIRECT_HOST 1 2051#endif 2052#ifndef ICMP_REDIRECT_TOSNET 2053# define ICMP_REDIRECT_TOSNET 2 2054#endif 2055#ifndef ICMP_REDIRECT_TOSHOST 2056# define ICMP_REDIRECT_TOSHOST 3 2057#endif 2058#ifndef ICMP_ALTHOSTADDR 2059# define ICMP_ALTHOSTADDR 6 2060#endif 2061#ifndef ICMP_TIMXCEED 2062# define ICMP_TIMXCEED 11 2063#endif 2064#ifndef ICMP_TIMXCEED_INTRANS 2065# define ICMP_TIMXCEED_INTRANS 0 2066#endif 2067#ifndef ICMP_TIMXCEED_REASS 2068# define ICMP_TIMXCEED_REASS 1 2069#endif 2070#ifndef ICMP_PARAMPROB 2071# define ICMP_PARAMPROB 12 2072#endif 2073#ifndef ICMP_PARAMPROB_ERRATPTR 2074# define ICMP_PARAMPROB_ERRATPTR 0 2075#endif 2076#ifndef ICMP_PARAMPROB_OPTABSENT 2077# define ICMP_PARAMPROB_OPTABSENT 1 2078#endif 2079#ifndef ICMP_PARAMPROB_LENGTH 2080# define ICMP_PARAMPROB_LENGTH 2 2081#endif 2082#ifndef ICMP_TSTAMP 2083# define ICMP_TSTAMP 13 2084#endif 2085#ifndef ICMP_TSTAMPREPLY 2086# define ICMP_TSTAMPREPLY 14 2087#endif 2088#ifndef ICMP_IREQ 2089# define ICMP_IREQ 15 2090#endif 2091#ifndef ICMP_IREQREPLY 2092# define ICMP_IREQREPLY 16 2093#endif 2094#ifndef ICMP_MASKREQ 2095# define ICMP_MASKREQ 17 2096#endif 2097#ifndef ICMP_MASKREPLY 2098# define ICMP_MASKREPLY 18 2099#endif 2100#ifndef ICMP_TRACEROUTE 2101# define ICMP_TRACEROUTE 30 2102#endif 2103#ifndef ICMP_DATACONVERR 2104# define ICMP_DATACONVERR 31 2105#endif 2106#ifndef ICMP_MOBILE_REDIRECT 2107# define ICMP_MOBILE_REDIRECT 32 2108#endif 2109#ifndef ICMP_IPV6_WHEREAREYOU 2110# define ICMP_IPV6_WHEREAREYOU 33 2111#endif 2112#ifndef ICMP_IPV6_IAMHERE 2113# define ICMP_IPV6_IAMHERE 34 2114#endif 2115#ifndef ICMP_MOBILE_REGREQUEST 2116# define ICMP_MOBILE_REGREQUEST 35 2117#endif 2118#ifndef ICMP_MOBILE_REGREPLY 2119# define ICMP_MOBILE_REGREPLY 36 2120#endif 2121#ifndef ICMP_SKIP 2122# define ICMP_SKIP 39 2123#endif 2124#ifndef ICMP_PHOTURIS 2125# define ICMP_PHOTURIS 40 2126#endif 2127#ifndef ICMP_PHOTURIS_UNKNOWN_INDEX 2128# define ICMP_PHOTURIS_UNKNOWN_INDEX 1 2129#endif 2130#ifndef ICMP_PHOTURIS_AUTH_FAILED 2131# define ICMP_PHOTURIS_AUTH_FAILED 2 2132#endif 2133#ifndef ICMP_PHOTURIS_DECRYPT_FAILED 2134# define ICMP_PHOTURIS_DECRYPT_FAILED 3 2135#endif 2136#ifndef IPVERSION 2137# define IPVERSION 4 2138#endif 2139#ifndef IPOPT_MINOFF 2140# define IPOPT_MINOFF 4 2141#endif 2142#ifndef IPOPT_COPIED 2143# define IPOPT_COPIED(x) ((x)&0x80) 2144#endif 2145#ifndef IPOPT_EOL 2146# define IPOPT_EOL 0 2147#endif 2148#ifndef IPOPT_NOP 2149# define IPOPT_NOP 1 2150#endif 2151#ifndef IP_MF 2152# define IP_MF ((u_short)0x2000) 2153#endif 2154#ifndef ETHERTYPE_IP 2155# define ETHERTYPE_IP ((u_short)0x0800) 2156#endif 2157#ifndef TH_FIN 2158# define TH_FIN 0x01 2159#endif 2160#ifndef TH_SYN 2161# define TH_SYN 0x02 2162#endif 2163#ifndef TH_RST 2164# define TH_RST 0x04 2165#endif 2166#ifndef TH_PUSH 2167# define TH_PUSH 0x08 2168#endif 2169#ifndef TH_ACK 2170# define TH_ACK 0x10 2171#endif 2172#ifndef TH_URG 2173# define TH_URG 0x20 2174#endif 2175#undef TH_ACKMASK 2176#define TH_ACKMASK (TH_FIN|TH_SYN|TH_RST|TH_ACK) 2177 2178#ifndef IPOPT_EOL 2179# define IPOPT_EOL 0 2180#endif 2181#ifndef IPOPT_NOP 2182# define IPOPT_NOP 1 2183#endif 2184#ifndef IPOPT_RR 2185# define IPOPT_RR 7 2186#endif 2187#ifndef IPOPT_TS 2188# define IPOPT_TS 68 2189#endif 2190#ifndef IPOPT_SECURITY 2191# define IPOPT_SECURITY 130 2192#endif 2193#ifndef IPOPT_LSRR 2194# define IPOPT_LSRR 131 2195#endif 2196#ifndef IPOPT_SATID 2197# define IPOPT_SATID 136 2198#endif 2199#ifndef IPOPT_SSRR 2200# define IPOPT_SSRR 137 2201#endif 2202#ifndef IPOPT_SECUR_UNCLASS 2203# define IPOPT_SECUR_UNCLASS ((u_short)0x0000) 2204#endif 2205#ifndef IPOPT_SECUR_CONFID 2206# define IPOPT_SECUR_CONFID ((u_short)0xf135) 2207#endif 2208#ifndef IPOPT_SECUR_EFTO 2209# define IPOPT_SECUR_EFTO ((u_short)0x789a) 2210#endif 2211#ifndef IPOPT_SECUR_MMMM 2212# define IPOPT_SECUR_MMMM ((u_short)0xbc4d) 2213#endif 2214#ifndef IPOPT_SECUR_RESTR 2215# define IPOPT_SECUR_RESTR ((u_short)0xaf13) 2216#endif 2217#ifndef IPOPT_SECUR_SECRET 2218# define IPOPT_SECUR_SECRET ((u_short)0xd788) 2219#endif 2220#ifndef IPOPT_SECUR_TOPSECRET 2221# define IPOPT_SECUR_TOPSECRET ((u_short)0x6bc5) 2222#endif 2223#ifndef IPOPT_OLEN 2224# define IPOPT_OLEN 1 2225#endif 2226#ifndef IPPROTO_HOPOPTS 2227# define IPPROTO_HOPOPTS 0 2228#endif 2229#ifndef IPPROTO_ENCAP 2230# define IPPROTO_ENCAP 4 2231#endif 2232#ifndef IPPROTO_IPV6 2233# define IPPROTO_IPV6 41 2234#endif 2235#ifndef IPPROTO_ROUTING 2236# define IPPROTO_ROUTING 43 2237#endif 2238#ifndef IPPROTO_FRAGMENT 2239# define IPPROTO_FRAGMENT 44 2240#endif 2241#ifndef IPPROTO_GRE 2242# define IPPROTO_GRE 47 /* GRE encaps RFC 1701 */ 2243#endif 2244#ifndef IPPROTO_ESP 2245# define IPPROTO_ESP 50 2246#endif 2247#ifndef IPPROTO_AH 2248# define IPPROTO_AH 51 2249#endif 2250#ifndef IPPROTO_ICMPV6 2251# define IPPROTO_ICMPV6 58 2252#endif 2253#ifndef IPPROTO_NONE 2254# define IPPROTO_NONE 59 2255#endif 2256#ifndef IPPROTO_DSTOPTS 2257# define IPPROTO_DSTOPTS 60 2258#endif 2259#ifndef IPPROTO_MOBILITY 2260# define IPPROTO_MOBILITY 135 2261#endif 2262 2263#ifndef ICMP_ROUTERADVERT 2264# define ICMP_ROUTERADVERT 9 2265#endif 2266#ifndef ICMP_ROUTERSOLICIT 2267# define ICMP_ROUTERSOLICIT 10 2268#endif 2269#ifndef ICMP6_DST_UNREACH 2270# define ICMP6_DST_UNREACH 1 2271#endif 2272#ifndef ICMP6_PACKET_TOO_BIG 2273# define ICMP6_PACKET_TOO_BIG 2 2274#endif 2275#ifndef ICMP6_TIME_EXCEEDED 2276# define ICMP6_TIME_EXCEEDED 3 2277#endif 2278#ifndef ICMP6_PARAM_PROB 2279# define ICMP6_PARAM_PROB 4 2280#endif 2281 2282#ifndef ICMP6_ECHO_REQUEST 2283# define ICMP6_ECHO_REQUEST 128 2284#endif 2285#ifndef ICMP6_ECHO_REPLY 2286# define ICMP6_ECHO_REPLY 129 2287#endif 2288#ifndef ICMP6_MEMBERSHIP_QUERY 2289# define ICMP6_MEMBERSHIP_QUERY 130 2290#endif 2291#ifndef MLD6_LISTENER_QUERY 2292# define MLD6_LISTENER_QUERY 130 2293#endif 2294#ifndef ICMP6_MEMBERSHIP_REPORT 2295# define ICMP6_MEMBERSHIP_REPORT 131 2296#endif 2297#ifndef MLD6_LISTENER_REPORT 2298# define MLD6_LISTENER_REPORT 131 2299#endif 2300#ifndef ICMP6_MEMBERSHIP_REDUCTION 2301# define ICMP6_MEMBERSHIP_REDUCTION 132 2302#endif 2303#ifndef MLD6_LISTENER_DONE 2304# define MLD6_LISTENER_DONE 132 2305#endif 2306#ifndef ND_ROUTER_SOLICIT 2307# define ND_ROUTER_SOLICIT 133 2308#endif 2309#ifndef ND_ROUTER_ADVERT 2310# define ND_ROUTER_ADVERT 134 2311#endif 2312#ifndef ND_NEIGHBOR_SOLICIT 2313# define ND_NEIGHBOR_SOLICIT 135 2314#endif 2315#ifndef ND_NEIGHBOR_ADVERT 2316# define ND_NEIGHBOR_ADVERT 136 2317#endif 2318#ifndef ND_REDIRECT 2319# define ND_REDIRECT 137 2320#endif 2321#ifndef ICMP6_ROUTER_RENUMBERING 2322# define ICMP6_ROUTER_RENUMBERING 138 2323#endif 2324#ifndef ICMP6_WRUREQUEST 2325# define ICMP6_WRUREQUEST 139 2326#endif 2327#ifndef ICMP6_WRUREPLY 2328# define ICMP6_WRUREPLY 140 2329#endif 2330#ifndef ICMP6_FQDN_QUERY 2331# define ICMP6_FQDN_QUERY 139 2332#endif 2333#ifndef ICMP6_FQDN_REPLY 2334# define ICMP6_FQDN_REPLY 140 2335#endif 2336#ifndef ICMP6_NI_QUERY 2337# define ICMP6_NI_QUERY 139 2338#endif 2339#ifndef ICMP6_NI_REPLY 2340# define ICMP6_NI_REPLY 140 2341#endif 2342#ifndef MLD6_MTRACE_RESP 2343# define MLD6_MTRACE_RESP 200 2344#endif 2345#ifndef MLD6_MTRACE 2346# define MLD6_MTRACE 201 2347#endif 2348#ifndef ICMP6_HADISCOV_REQUEST 2349# define ICMP6_HADISCOV_REQUEST 202 2350#endif 2351#ifndef ICMP6_HADISCOV_REPLY 2352# define ICMP6_HADISCOV_REPLY 203 2353#endif 2354#ifndef ICMP6_MOBILEPREFIX_SOLICIT 2355# define ICMP6_MOBILEPREFIX_SOLICIT 204 2356#endif 2357#ifndef ICMP6_MOBILEPREFIX_ADVERT 2358# define ICMP6_MOBILEPREFIX_ADVERT 205 2359#endif 2360#ifndef ICMP6_MAXTYPE 2361# define ICMP6_MAXTYPE 205 2362#endif 2363 2364#ifndef ICMP6_DST_UNREACH_NOROUTE 2365# define ICMP6_DST_UNREACH_NOROUTE 0 2366#endif 2367#ifndef ICMP6_DST_UNREACH_ADMIN 2368# define ICMP6_DST_UNREACH_ADMIN 1 2369#endif 2370#ifndef ICMP6_DST_UNREACH_NOTNEIGHBOR 2371# define ICMP6_DST_UNREACH_NOTNEIGHBOR 2 2372#endif 2373#ifndef ICMP6_DST_UNREACH_BEYONDSCOPE 2374# define ICMP6_DST_UNREACH_BEYONDSCOPE 2 2375#endif 2376#ifndef ICMP6_DST_UNREACH_ADDR 2377# define ICMP6_DST_UNREACH_ADDR 3 2378#endif 2379#ifndef ICMP6_DST_UNREACH_NOPORT 2380# define ICMP6_DST_UNREACH_NOPORT 4 2381#endif 2382#ifndef ICMP6_TIME_EXCEED_TRANSIT 2383# define ICMP6_TIME_EXCEED_TRANSIT 0 2384#endif 2385#ifndef ICMP6_TIME_EXCEED_REASSEMBLY 2386# define ICMP6_TIME_EXCEED_REASSEMBLY 1 2387#endif 2388 2389#ifndef ICMP6_NI_SUCCESS 2390# define ICMP6_NI_SUCCESS 0 2391#endif 2392#ifndef ICMP6_NI_REFUSED 2393# define ICMP6_NI_REFUSED 1 2394#endif 2395#ifndef ICMP6_NI_UNKNOWN 2396# define ICMP6_NI_UNKNOWN 2 2397#endif 2398 2399#ifndef ICMP6_ROUTER_RENUMBERING_COMMAND 2400# define ICMP6_ROUTER_RENUMBERING_COMMAND 0 2401#endif 2402#ifndef ICMP6_ROUTER_RENUMBERING_RESULT 2403# define ICMP6_ROUTER_RENUMBERING_RESULT 1 2404#endif 2405#ifndef ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 2406# define ICMP6_ROUTER_RENUMBERING_SEQNUM_RESET 255 2407#endif 2408 2409#ifndef ICMP6_PARAMPROB_HEADER 2410# define ICMP6_PARAMPROB_HEADER 0 2411#endif 2412#ifndef ICMP6_PARAMPROB_NEXTHEADER 2413# define ICMP6_PARAMPROB_NEXTHEADER 1 2414#endif 2415#ifndef ICMP6_PARAMPROB_OPTION 2416# define ICMP6_PARAMPROB_OPTION 2 2417#endif 2418 2419#ifndef ICMP6_NI_SUBJ_IPV6 2420# define ICMP6_NI_SUBJ_IPV6 0 2421#endif 2422#ifndef ICMP6_NI_SUBJ_FQDN 2423# define ICMP6_NI_SUBJ_FQDN 1 2424#endif 2425#ifndef ICMP6_NI_SUBJ_IPV4 2426# define ICMP6_NI_SUBJ_IPV4 2 2427#endif 2428 2429/* 2430 * ECN is a new addition to TCP - RFC 2481 2431 */ 2432#ifndef TH_ECN 2433# define TH_ECN 0x40 2434#endif 2435#ifndef TH_CWR 2436# define TH_CWR 0x80 2437#endif 2438#define TH_ECNALL (TH_ECN|TH_CWR) 2439 2440/* 2441 * TCP States 2442 */ 2443#define IPF_TCPS_LISTEN 0 /* listening for connection */ 2444#define IPF_TCPS_SYN_SENT 1 /* active, have sent syn */ 2445#define IPF_TCPS_SYN_RECEIVED 2 /* have send and received syn */ 2446#define IPF_TCPS_HALF_ESTAB 3 /* for connections not fully "up" */ 2447/* states < IPF_TCPS_ESTABLISHED are those where connections not established */ 2448#define IPF_TCPS_ESTABLISHED 4 /* established */ 2449#define IPF_TCPS_CLOSE_WAIT 5 /* rcvd fin, waiting for close */ 2450/* states > IPF_TCPS_CLOSE_WAIT are those where user has closed */ 2451#define IPF_TCPS_FIN_WAIT_1 6 /* have closed, sent fin */ 2452#define IPF_TCPS_CLOSING 7 /* closed xchd FIN; await FIN ACK */ 2453#define IPF_TCPS_LAST_ACK 8 /* had fin and close; await FIN ACK */ 2454/* states > IPF_TCPS_CLOSE_WAIT && < IPF_TCPS_FIN_WAIT_2 await ACK of FIN */ 2455#define IPF_TCPS_FIN_WAIT_2 9 /* have closed, fin is acked */ 2456#define IPF_TCPS_TIME_WAIT 10 /* in 2*msl quiet wait after close */ 2457#define IPF_TCPS_CLOSED 11 /* closed */ 2458#define IPF_TCP_NSTATES 12 2459 2460#define TCP_MSL 120 2461 2462#undef ICMP_MAX_UNREACH 2463#define ICMP_MAX_UNREACH 14 2464#undef ICMP_MAXTYPE 2465#define ICMP_MAXTYPE 18 2466 2467#ifndef IFNAMSIZ 2468#define IFNAMSIZ 16 2469#endif 2470 2471#ifndef LOG_FTP 2472# define LOG_FTP (11<<3) 2473#endif 2474#ifndef LOG_AUTHPRIV 2475# define LOG_AUTHPRIV (10<<3) 2476#endif 2477#ifndef LOG_AUDIT 2478# define LOG_AUDIT (13<<3) 2479#endif 2480#ifndef LOG_NTP 2481# define LOG_NTP (12<<3) 2482#endif 2483#ifndef LOG_SECURITY 2484# define LOG_SECURITY (13<<3) 2485#endif 2486#ifndef LOG_LFMT 2487# define LOG_LFMT (14<<3) 2488#endif 2489#ifndef LOG_CONSOLE 2490# define LOG_CONSOLE (14<<3) 2491#endif 2492 2493/* 2494 * ICMP error replies have an IP header (20 bytes), 8 bytes of ICMP data, 2495 * another IP header and then 64 bits of data, totalling 56. Of course, 2496 * the last 64 bits is dependent on that being available. 2497 */ 2498#define ICMPERR_ICMPHLEN 8 2499#define ICMPERR_IPICMPHLEN (20 + 8) 2500#define ICMPERR_MINPKTLEN (20 + 8 + 20) 2501#define ICMPERR_MAXPKTLEN (20 + 8 + 20 + 8) 2502#define ICMP6ERR_MINPKTLEN (40 + 8) 2503#define ICMP6ERR_IPICMPHLEN (40 + 8 + 40) 2504 2505#ifndef MIN 2506# define MIN(a,b) (((a)<(b))?(a):(b)) 2507#endif 2508 2509#ifdef IPF_DEBUG 2510# define DPRINT(x) printf x 2511#else 2512# define DPRINT(x) 2513#endif 2514 2515#ifdef RESCUE 2516# undef IPFILTER_BPF 2517#endif 2518 2519#endif /* __IP_COMPAT_H__ */ 2520