xref: /illumos-gate/usr/src/uts/common/inet/ipf/ip_log.c (revision 7ddc9b1a)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * Copyright (C) 1997-2003 by Darren Reed.
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * See the IPFILTER.LICENCE file for details on licencing.
57c478bd9Sstevel@tonic-gate  *
6ab25eeb5Syz  * $Id: ip_log.c,v 2.75.2.7 2005/06/11 07:47:44 darrenr Exp $
77c478bd9Sstevel@tonic-gate  *
8*7ddc9b1aSDarren Reed  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
97c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
107c478bd9Sstevel@tonic-gate  */
117c478bd9Sstevel@tonic-gate 
127c478bd9Sstevel@tonic-gate #include <sys/param.h>
137c478bd9Sstevel@tonic-gate #if defined(KERNEL) || defined(_KERNEL)
147c478bd9Sstevel@tonic-gate # undef KERNEL
157c478bd9Sstevel@tonic-gate # undef _KERNEL
167c478bd9Sstevel@tonic-gate # define        KERNEL	1
177c478bd9Sstevel@tonic-gate # define        _KERNEL	1
187c478bd9Sstevel@tonic-gate #endif
197c478bd9Sstevel@tonic-gate #if defined(__NetBSD__) && (NetBSD >= 199905) && !defined(IPFILTER_LKM) && \
207c478bd9Sstevel@tonic-gate     defined(_KERNEL)
217c478bd9Sstevel@tonic-gate # include "opt_ipfilter_log.h"
227c478bd9Sstevel@tonic-gate #endif
23ab25eeb5Syz #if defined(__FreeBSD__) && !defined(IPFILTER_LKM)
24ab25eeb5Syz # if defined(_KERNEL)
25ab25eeb5Syz #  if defined(__FreeBSD_version) && (__FreeBSD_version >= 300000)
26ab25eeb5Syz #   include "opt_ipfilter.h"
277c478bd9Sstevel@tonic-gate #  endif
28ab25eeb5Syz # else
29ab25eeb5Syz #  include <osreldate.h>
307c478bd9Sstevel@tonic-gate # endif
317c478bd9Sstevel@tonic-gate #endif
32ab25eeb5Syz #ifndef SOLARIS
33ab25eeb5Syz # define SOLARIS (defined(sun) && (defined(__svr4__) || defined(__SVR4)))
34ab25eeb5Syz #endif
35ab25eeb5Syz #include <sys/errno.h>
36ab25eeb5Syz #include <sys/types.h>
37ab25eeb5Syz #include <sys/file.h>
38ab25eeb5Syz #ifndef _KERNEL
39ab25eeb5Syz # include <stdio.h>
40ab25eeb5Syz # include <string.h>
41ab25eeb5Syz # include <stdlib.h>
42ab25eeb5Syz # include <ctype.h>
43ab25eeb5Syz # define _KERNEL
44ab25eeb5Syz # define KERNEL
457c478bd9Sstevel@tonic-gate # ifdef __OpenBSD__
467c478bd9Sstevel@tonic-gate struct file;
477c478bd9Sstevel@tonic-gate # endif
48ab25eeb5Syz # include <sys/uio.h>
49ab25eeb5Syz # undef _KERNEL
50ab25eeb5Syz # undef KERNEL
51ab25eeb5Syz #endif
52ab25eeb5Syz #if __FreeBSD_version >= 220000 && defined(_KERNEL)
53ab25eeb5Syz # include <sys/fcntl.h>
54ab25eeb5Syz # include <sys/filio.h>
55ab25eeb5Syz #else
56ab25eeb5Syz # include <sys/ioctl.h>
57ab25eeb5Syz #endif
58ab25eeb5Syz #include <sys/time.h>
59ab25eeb5Syz #if defined(_KERNEL)
60ab25eeb5Syz # include <sys/systm.h>
61ab25eeb5Syz # if defined(NetBSD) && (__NetBSD_Version__ >= 104000000)
62ab25eeb5Syz #  include <sys/proc.h>
637c478bd9Sstevel@tonic-gate # endif
64ab25eeb5Syz #endif /* _KERNEL */
65ab25eeb5Syz #if !SOLARIS && !defined(__hpux) && !defined(linux)
66ab25eeb5Syz # if (NetBSD > 199609) || (OpenBSD > 199603) || (__FreeBSD_version >= 300000)
67ab25eeb5Syz #  include <sys/dirent.h>
687c478bd9Sstevel@tonic-gate # else
69ab25eeb5Syz #  include <sys/dir.h>
707c478bd9Sstevel@tonic-gate # endif
71ab25eeb5Syz # include <sys/mbuf.h>
72ab25eeb5Syz #else
73ab25eeb5Syz # if !defined(__hpux) && defined(_KERNEL)
74ab25eeb5Syz #  include <sys/filio.h>
75ab25eeb5Syz #  include <sys/cred.h>
76ab25eeb5Syz #  include <sys/ddi.h>
77ab25eeb5Syz #  include <sys/sunddi.h>
78ab25eeb5Syz #  include <sys/ksynch.h>
79ab25eeb5Syz #  include <sys/kmem.h>
80ab25eeb5Syz #  include <sys/mkdev.h>
81ab25eeb5Syz #  include <sys/dditypes.h>
82ab25eeb5Syz #  include <sys/cmn_err.h>
83ab25eeb5Syz # endif /* !__hpux */
84ab25eeb5Syz #endif /* !SOLARIS && !__hpux */
85ab25eeb5Syz #if !defined(linux)
867c478bd9Sstevel@tonic-gate # include <sys/protosw.h>
87ab25eeb5Syz #endif
88ab25eeb5Syz #include <sys/socket.h>
897c478bd9Sstevel@tonic-gate 
90ab25eeb5Syz #include <net/if.h>
91ab25eeb5Syz #ifdef sun
92ab25eeb5Syz # include <net/af.h>
93ab25eeb5Syz #endif
94ab25eeb5Syz #if __FreeBSD_version >= 300000
95ab25eeb5Syz # include <net/if_var.h>
96ab25eeb5Syz #endif
97ab25eeb5Syz #include <net/route.h>
98ab25eeb5Syz #include <netinet/in.h>
99ab25eeb5Syz #ifdef __sgi
100ab25eeb5Syz # include <sys/ddi.h>
101ab25eeb5Syz # ifdef IFF_DRVRLOCK /* IRIX6 */
102ab25eeb5Syz #  include <sys/hashing.h>
1037c478bd9Sstevel@tonic-gate # endif
104ab25eeb5Syz #endif
105ab25eeb5Syz #if !defined(__hpux) && !defined(linux) && \
106ab25eeb5Syz     !(defined(__sgi) && !defined(IFF_DRVRLOCK)) /*IRIX<6*/
107ab25eeb5Syz # include <netinet/in_var.h>
108ab25eeb5Syz #endif
109ab25eeb5Syz #include <netinet/in_systm.h>
110ab25eeb5Syz #include <netinet/ip.h>
111ab25eeb5Syz #include <netinet/tcp.h>
112ab25eeb5Syz #include <netinet/udp.h>
113ab25eeb5Syz #include <netinet/ip_icmp.h>
114ab25eeb5Syz #ifdef USE_INET6
115ab25eeb5Syz # include <netinet/icmp6.h>
116ab25eeb5Syz #endif
117ab25eeb5Syz #if !defined(linux)
1187c478bd9Sstevel@tonic-gate # include <netinet/ip_var.h>
1197c478bd9Sstevel@tonic-gate #endif
120ab25eeb5Syz #ifndef _KERNEL
121ab25eeb5Syz # include <syslog.h>
122ab25eeb5Syz #endif
123ab25eeb5Syz #include "netinet/ip_compat.h"
124ab25eeb5Syz #include <netinet/tcpip.h>
125ab25eeb5Syz #include "netinet/ip_fil.h"
126ab25eeb5Syz #include "netinet/ip_nat.h"
127ab25eeb5Syz #include "netinet/ip_frag.h"
128ab25eeb5Syz #include "netinet/ip_state.h"
129ab25eeb5Syz #include "netinet/ip_auth.h"
130f4b3ec61Sdh #include "netinet/ipf_stack.h"
131ab25eeb5Syz #if (__FreeBSD_version >= 300000) || defined(__NetBSD__)
132ab25eeb5Syz # include <sys/malloc.h>
133ab25eeb5Syz #endif
134ab25eeb5Syz /* END OF INCLUDES */
1357c478bd9Sstevel@tonic-gate 
136ab25eeb5Syz #ifdef	IPFILTER_LOG
1377c478bd9Sstevel@tonic-gate 
1387c478bd9Sstevel@tonic-gate # if defined(IPL_SELECT)
139ab25eeb5Syz #  include	<machine/sys/user.h>
140ab25eeb5Syz #  include	<sys/kthread_iface.h>
141ab25eeb5Syz #  define	READ_COLLISION	0x001
1427c478bd9Sstevel@tonic-gate 
143ab25eeb5Syz iplog_select_t	iplog_ss[IPL_LOGMAX+1];
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate extern int selwait;
1467c478bd9Sstevel@tonic-gate # endif /* IPL_SELECT */
1477c478bd9Sstevel@tonic-gate 
148f4b3ec61Sdh /* ipl_magic never changes */
149ab25eeb5Syz int	ipl_magic[IPL_LOGSIZE] = { IPL_MAGIC, IPL_MAGIC_NAT, IPL_MAGIC_STATE,
150ab25eeb5Syz 				   IPL_MAGIC, IPL_MAGIC, IPL_MAGIC,
151ab25eeb5Syz 				   IPL_MAGIC, IPL_MAGIC };
1527c478bd9Sstevel@tonic-gate 
1537c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
1547c478bd9Sstevel@tonic-gate /* Function:    fr_loginit                                                  */
1557c478bd9Sstevel@tonic-gate /* Returns:     int - 0 == success (always returned)                        */
1567c478bd9Sstevel@tonic-gate /* Parameters:  Nil                                                         */
1577c478bd9Sstevel@tonic-gate /*                                                                          */
1587c478bd9Sstevel@tonic-gate /* Initialise log buffers & pointers.  Also iniialised the CRC to a local   */
1597c478bd9Sstevel@tonic-gate /* secret for use in calculating the "last log checksum".                   */
1607c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
161f4b3ec61Sdh int fr_loginit(ifs)
162f4b3ec61Sdh ipf_stack_t *ifs;
1637c478bd9Sstevel@tonic-gate {
1647c478bd9Sstevel@tonic-gate 	int	i;
165f4b3ec61Sdh 
1667c478bd9Sstevel@tonic-gate 	for (i = IPL_LOGMAX; i >= 0; i--) {
167f4b3ec61Sdh 		ifs->ifs_iplt[i] = NULL;
168f4b3ec61Sdh 		ifs->ifs_ipll[i] = NULL;
169f4b3ec61Sdh 		ifs->ifs_iplh[i] = &ifs->ifs_iplt[i];
170f4b3ec61Sdh 		ifs->ifs_iplused[i] = 0;
171f4b3ec61Sdh 		bzero((char *)&ifs->ifs_iplcrc[i], sizeof(ifs->ifs_iplcrc[i]));
1727c478bd9Sstevel@tonic-gate # ifdef	IPL_SELECT
1737c478bd9Sstevel@tonic-gate 		iplog_ss[i].read_waiter = 0;
1747c478bd9Sstevel@tonic-gate 		iplog_ss[i].state = 0;
175ab25eeb5Syz # endif
176ab25eeb5Syz # if defined(linux) && defined(_KERNEL)
177ab25eeb5Syz 		init_waitqueue_head(iplh_linux + i);
1787c478bd9Sstevel@tonic-gate # endif
1797c478bd9Sstevel@tonic-gate 	}
1807c478bd9Sstevel@tonic-gate 
1817c478bd9Sstevel@tonic-gate # if SOLARIS && defined(_KERNEL)
182f4b3ec61Sdh 	cv_init(&ifs->ifs_iplwait, "ipl condvar", CV_DRIVER, NULL);
1837c478bd9Sstevel@tonic-gate # endif
184f4b3ec61Sdh 	MUTEX_INIT(&ifs->ifs_ipl_mutex, "ipf log mutex");
1857c478bd9Sstevel@tonic-gate 
186f4b3ec61Sdh 	ifs->ifs_ipl_log_init = 1;
1877c478bd9Sstevel@tonic-gate 
1887c478bd9Sstevel@tonic-gate 	return 0;
1897c478bd9Sstevel@tonic-gate }
1907c478bd9Sstevel@tonic-gate 
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
1937c478bd9Sstevel@tonic-gate /* Function:    fr_logunload                                                */
1947c478bd9Sstevel@tonic-gate /* Returns:     Nil                                                         */
1957c478bd9Sstevel@tonic-gate /* Parameters:  Nil                                                         */
1967c478bd9Sstevel@tonic-gate /*                                                                          */
1977c478bd9Sstevel@tonic-gate /* Clean up any log data that has accumulated without being read.           */
1987c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
199f4b3ec61Sdh void fr_logunload(ifs)
200f4b3ec61Sdh ipf_stack_t *ifs;
2017c478bd9Sstevel@tonic-gate {
2027c478bd9Sstevel@tonic-gate 	int i;
2037c478bd9Sstevel@tonic-gate 
204f4b3ec61Sdh 	if (ifs->ifs_ipl_log_init == 0)
2057c478bd9Sstevel@tonic-gate 		return;
2067c478bd9Sstevel@tonic-gate 
2077c478bd9Sstevel@tonic-gate 	for (i = IPL_LOGMAX; i >= 0; i--)
208f4b3ec61Sdh 		(void) ipflog_clear(i, ifs);
2097c478bd9Sstevel@tonic-gate 
2107c478bd9Sstevel@tonic-gate # if SOLARIS && defined(_KERNEL)
211f4b3ec61Sdh 	cv_destroy(&ifs->ifs_iplwait);
2127c478bd9Sstevel@tonic-gate # endif
213f4b3ec61Sdh 	MUTEX_DESTROY(&ifs->ifs_ipl_mutex);
2147c478bd9Sstevel@tonic-gate 
215f4b3ec61Sdh 	ifs->ifs_ipl_log_init = 0;
2167c478bd9Sstevel@tonic-gate }
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 
2197c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
2207c478bd9Sstevel@tonic-gate /* Function:    ipflog                                                      */
2217c478bd9Sstevel@tonic-gate /* Returns:     int - 0 == success, -1 == failure                           */
2227c478bd9Sstevel@tonic-gate /* Parameters:  fin(I)   - pointer to packet information                    */
2237c478bd9Sstevel@tonic-gate /*              flags(I) - flags from filter rules                          */
2247c478bd9Sstevel@tonic-gate /*                                                                          */
2257c478bd9Sstevel@tonic-gate /* Create a log record for a packet given that it has been triggered by a   */
2267c478bd9Sstevel@tonic-gate /* rule (or the default setting).  Calculate the transport protocol header  */
2277c478bd9Sstevel@tonic-gate /* size using predetermined size of a couple of popular protocols and thus  */
2287c478bd9Sstevel@tonic-gate /* how much data to copy into the log, including part of the data body if   */
2297c478bd9Sstevel@tonic-gate /* requested.                                                               */
2307c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
2317c478bd9Sstevel@tonic-gate int ipflog(fin, flags)
2327c478bd9Sstevel@tonic-gate fr_info_t *fin;
2337c478bd9Sstevel@tonic-gate u_int flags;
2347c478bd9Sstevel@tonic-gate {
2357c478bd9Sstevel@tonic-gate 	register size_t hlen;
2367c478bd9Sstevel@tonic-gate 	int types[2], mlen;
2377c478bd9Sstevel@tonic-gate 	size_t sizes[2];
2387c478bd9Sstevel@tonic-gate 	void *ptrs[2];
2397c478bd9Sstevel@tonic-gate 	ipflog_t ipfl;
2407c478bd9Sstevel@tonic-gate 	u_char p;
2417c478bd9Sstevel@tonic-gate 	mb_t *m;
242381a2a9aSdr # if SOLARIS && defined(_KERNEL)
243*7ddc9b1aSDarren Reed 	net_handle_t nif;
244381a2a9aSdr 	void *ifp;
245381a2a9aSdr # else
246381a2a9aSdr #  if defined(__hpux) && defined(_KERNEL)
247ab25eeb5Syz 	qif_t *ifp;
2487c478bd9Sstevel@tonic-gate #  else
2497c478bd9Sstevel@tonic-gate 	struct ifnet *ifp;
250381a2a9aSdr #  endif
251381a2a9aSdr # endif /* SOLARIS */
252f4b3ec61Sdh 	ipf_stack_t *ifs = fin->fin_ifs;
2537c478bd9Sstevel@tonic-gate 
254ab25eeb5Syz 	ipfl.fl_nattag.ipt_num[0] = 0;
2557c478bd9Sstevel@tonic-gate 	m = fin->fin_m;
2567c478bd9Sstevel@tonic-gate 	ifp = fin->fin_ifp;
2577c478bd9Sstevel@tonic-gate 	hlen = fin->fin_hlen;
2587c478bd9Sstevel@tonic-gate 	/*
2597c478bd9Sstevel@tonic-gate 	 * calculate header size.
2607c478bd9Sstevel@tonic-gate 	 */
2617c478bd9Sstevel@tonic-gate 	if (fin->fin_off == 0) {
2627c478bd9Sstevel@tonic-gate 		p = fin->fin_fi.fi_p;
2637c478bd9Sstevel@tonic-gate 		if (p == IPPROTO_TCP)
2647c478bd9Sstevel@tonic-gate 			hlen += MIN(sizeof(tcphdr_t), fin->fin_dlen);
2657c478bd9Sstevel@tonic-gate 		else if (p == IPPROTO_UDP)
2667c478bd9Sstevel@tonic-gate 			hlen += MIN(sizeof(udphdr_t), fin->fin_dlen);
2677c478bd9Sstevel@tonic-gate 		else if (p == IPPROTO_ICMP) {
2687c478bd9Sstevel@tonic-gate 			struct icmp *icmp;
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate 			icmp = (struct icmp *)fin->fin_dp;
271ab25eeb5Syz 
2727c478bd9Sstevel@tonic-gate 			/*
2737c478bd9Sstevel@tonic-gate 			 * For ICMP, if the packet is an error packet, also
2747c478bd9Sstevel@tonic-gate 			 * include the information about the packet which
2757c478bd9Sstevel@tonic-gate 			 * caused the error.
2767c478bd9Sstevel@tonic-gate 			 */
2777c478bd9Sstevel@tonic-gate 			switch (icmp->icmp_type)
2787c478bd9Sstevel@tonic-gate 			{
2797c478bd9Sstevel@tonic-gate 			case ICMP_UNREACH :
2807c478bd9Sstevel@tonic-gate 			case ICMP_SOURCEQUENCH :
2817c478bd9Sstevel@tonic-gate 			case ICMP_REDIRECT :
2827c478bd9Sstevel@tonic-gate 			case ICMP_TIMXCEED :
2837c478bd9Sstevel@tonic-gate 			case ICMP_PARAMPROB :
2847c478bd9Sstevel@tonic-gate 				hlen += MIN(sizeof(struct icmp) + 8,
2857c478bd9Sstevel@tonic-gate 					    fin->fin_dlen);
2867c478bd9Sstevel@tonic-gate 				break;
2877c478bd9Sstevel@tonic-gate 			default :
2887c478bd9Sstevel@tonic-gate 				hlen += MIN(sizeof(struct icmp),
2897c478bd9Sstevel@tonic-gate 					    fin->fin_dlen);
2907c478bd9Sstevel@tonic-gate 				break;
2917c478bd9Sstevel@tonic-gate 			}
2927c478bd9Sstevel@tonic-gate 		}
2937c478bd9Sstevel@tonic-gate # ifdef USE_INET6
2947c478bd9Sstevel@tonic-gate 		else if (p == IPPROTO_ICMPV6) {
2957c478bd9Sstevel@tonic-gate 			struct icmp6_hdr *icmp;
2967c478bd9Sstevel@tonic-gate 
2977c478bd9Sstevel@tonic-gate 			icmp = (struct icmp6_hdr *)fin->fin_dp;
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate 			/*
3007c478bd9Sstevel@tonic-gate 			 * For ICMPV6, if the packet is an error packet, also
3017c478bd9Sstevel@tonic-gate 			 * include the information about the packet which
3027c478bd9Sstevel@tonic-gate 			 * caused the error.
3037c478bd9Sstevel@tonic-gate 			 */
3047c478bd9Sstevel@tonic-gate 			if (icmp->icmp6_type < 128) {
3057c478bd9Sstevel@tonic-gate 				hlen += MIN(sizeof(struct icmp6_hdr) + 8,
3067c478bd9Sstevel@tonic-gate 					    fin->fin_dlen);
3077c478bd9Sstevel@tonic-gate 			} else {
3087c478bd9Sstevel@tonic-gate 				hlen += MIN(sizeof(struct icmp6_hdr),
3097c478bd9Sstevel@tonic-gate 					    fin->fin_dlen);
3107c478bd9Sstevel@tonic-gate 			}
3117c478bd9Sstevel@tonic-gate 		}
3127c478bd9Sstevel@tonic-gate # endif
3137c478bd9Sstevel@tonic-gate 	}
3147c478bd9Sstevel@tonic-gate 	/*
3157c478bd9Sstevel@tonic-gate 	 * Get the interface number and name to which this packet is
3167c478bd9Sstevel@tonic-gate 	 * currently associated.
3177c478bd9Sstevel@tonic-gate 	 */
318381a2a9aSdr # if SOLARIS && defined(_KERNEL)
319ab25eeb5Syz 	ipfl.fl_unit = (u_int)0;
320381a2a9aSdr 	nif = NULL;
321381a2a9aSdr 	if (fin->fin_fi.fi_v == 4)
322f4b3ec61Sdh 		nif = ifs->ifs_ipf_ipv4;
323381a2a9aSdr 	else if (fin->fin_fi.fi_v == 6)
324f4b3ec61Sdh 		nif = ifs->ifs_ipf_ipv6;
325381a2a9aSdr 	if (nif != NULL) {
326381a2a9aSdr 		if (net_getifname(nif, (phy_if_t)ifp,
327381a2a9aSdr 		    ipfl.fl_ifname, sizeof(ipfl.fl_ifname)) != 0)
328381a2a9aSdr 			return (-1);
329381a2a9aSdr 	}
330381a2a9aSdr 
3317c478bd9Sstevel@tonic-gate # else
332381a2a9aSdr #  if defined(__hpux) && defined(_KERNEL)
333381a2a9aSdr 	ipfl.fl_unit = (u_int)0;
334381a2a9aSdr 	(void) strncpy(ipfl.fl_ifname, IFNAME(ifp), sizeof(ipfl.fl_ifname));
3357c478bd9Sstevel@tonic-gate #  else
336381a2a9aSdr #   if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199603)) || \
337381a2a9aSdr        (defined(OpenBSD) && (OpenBSD >= 199603)) || defined(linux) || \
338381a2a9aSdr        (defined(__FreeBSD__) && (__FreeBSD_version >= 501113))
339381a2a9aSdr 	COPYIFNAME(ifp, ipfl.fl_ifname);
340381a2a9aSdr #   else
341ab25eeb5Syz 	ipfl.fl_unit = (u_int)ifp->if_unit;
342381a2a9aSdr #    if defined(_KERNEL)
3437c478bd9Sstevel@tonic-gate 	if ((ipfl.fl_ifname[0] = ifp->if_name[0]))
3447c478bd9Sstevel@tonic-gate 		if ((ipfl.fl_ifname[1] = ifp->if_name[1]))
3457c478bd9Sstevel@tonic-gate 			if ((ipfl.fl_ifname[2] = ifp->if_name[2]))
3467c478bd9Sstevel@tonic-gate 				ipfl.fl_ifname[3] = ifp->if_name[3];
347381a2a9aSdr #    else
348ab25eeb5Syz 	(void) strncpy(ipfl.fl_ifname, IFNAME(ifp), sizeof(ipfl.fl_ifname));
349ab25eeb5Syz 	ipfl.fl_ifname[sizeof(ipfl.fl_ifname) - 1] = '\0';
350381a2a9aSdr #    endif
3517c478bd9Sstevel@tonic-gate #   endif
352381a2a9aSdr #  endif /* __hpux */
353381a2a9aSdr # endif /* SOLARIS */
3547c478bd9Sstevel@tonic-gate 	mlen = fin->fin_plen - hlen;
355f4b3ec61Sdh 	if (!ifs->ifs_ipl_logall) {
3567c478bd9Sstevel@tonic-gate 		mlen = (flags & FR_LOGBODY) ? MIN(mlen, 128) : 0;
3577c478bd9Sstevel@tonic-gate 	} else if ((flags & FR_LOGBODY) == 0) {
3587c478bd9Sstevel@tonic-gate 		mlen = 0;
3597c478bd9Sstevel@tonic-gate 	}
3607c478bd9Sstevel@tonic-gate 	if (mlen < 0)
3617c478bd9Sstevel@tonic-gate 		mlen = 0;
3627c478bd9Sstevel@tonic-gate 	ipfl.fl_plen = (u_char)mlen;
3637c478bd9Sstevel@tonic-gate 	ipfl.fl_hlen = (u_char)hlen;
3647c478bd9Sstevel@tonic-gate 	ipfl.fl_rule = fin->fin_rule;
3657c478bd9Sstevel@tonic-gate 	(void) strncpy(ipfl.fl_group, fin->fin_group, FR_GROUPLEN);
3667c478bd9Sstevel@tonic-gate 	if (fin->fin_fr != NULL) {
3677c478bd9Sstevel@tonic-gate 		ipfl.fl_loglevel = fin->fin_fr->fr_loglevel;
368ab25eeb5Syz 		ipfl.fl_logtag = fin->fin_fr->fr_logtag;
3697c478bd9Sstevel@tonic-gate 	} else {
3707c478bd9Sstevel@tonic-gate 		ipfl.fl_loglevel = 0xffff;
371ab25eeb5Syz 		ipfl.fl_logtag = FR_NOLOGTAG;
3727c478bd9Sstevel@tonic-gate 	}
373ab25eeb5Syz 	if (fin->fin_nattag != NULL)
374ab25eeb5Syz 		bcopy(fin->fin_nattag, (void *)&ipfl.fl_nattag,
375ab25eeb5Syz 		      sizeof(ipfl.fl_nattag));
3767c478bd9Sstevel@tonic-gate 	ipfl.fl_flags = flags;
3777c478bd9Sstevel@tonic-gate 	ipfl.fl_dir = fin->fin_out;
3787c478bd9Sstevel@tonic-gate 	ipfl.fl_lflags = fin->fin_flx;
3797c478bd9Sstevel@tonic-gate 	ptrs[0] = (void *)&ipfl;
3807c478bd9Sstevel@tonic-gate 	sizes[0] = sizeof(ipfl);
3817c478bd9Sstevel@tonic-gate 	types[0] = 0;
3827c478bd9Sstevel@tonic-gate # if defined(MENTAT) && defined(_KERNEL)
3837c478bd9Sstevel@tonic-gate 	/*
3847c478bd9Sstevel@tonic-gate 	 * Are we copied from the mblk or an aligned array ?
3857c478bd9Sstevel@tonic-gate 	 */
3867c478bd9Sstevel@tonic-gate 	if (fin->fin_ip == (ip_t *)m->b_rptr) {
3877c478bd9Sstevel@tonic-gate 		ptrs[1] = m;
3887c478bd9Sstevel@tonic-gate 		sizes[1] = hlen + mlen;
3897c478bd9Sstevel@tonic-gate 		types[1] = 1;
3907c478bd9Sstevel@tonic-gate 	} else {
3917c478bd9Sstevel@tonic-gate 		ptrs[1] = fin->fin_ip;
3927c478bd9Sstevel@tonic-gate 		sizes[1] = hlen + mlen;
3937c478bd9Sstevel@tonic-gate 		types[1] = 0;
3947c478bd9Sstevel@tonic-gate 	}
3957c478bd9Sstevel@tonic-gate # else
3967c478bd9Sstevel@tonic-gate 	ptrs[1] = m;
3977c478bd9Sstevel@tonic-gate 	sizes[1] = hlen + mlen;
3987c478bd9Sstevel@tonic-gate 	types[1] = 1;
3997c478bd9Sstevel@tonic-gate # endif /* MENTAT */
400f4b3ec61Sdh 	return ipllog(IPL_LOGIPF, fin, ptrs, sizes, types, 2, fin->fin_ifs);
4017c478bd9Sstevel@tonic-gate }
4027c478bd9Sstevel@tonic-gate 
4037c478bd9Sstevel@tonic-gate 
4047c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
4057c478bd9Sstevel@tonic-gate /* Function:    ipllog                                                      */
4067c478bd9Sstevel@tonic-gate /* Returns:     int - 0 == success, -1 == failure                           */
4077c478bd9Sstevel@tonic-gate /* Parameters:  dev(I)    - device that owns this log record                */
4087c478bd9Sstevel@tonic-gate /*              fin(I)    - pointer to packet information                   */
4097c478bd9Sstevel@tonic-gate /*              items(I)  - array of pointers to log data                   */
4107c478bd9Sstevel@tonic-gate /*              itemsz(I) - array of size of valid memory pointed to        */
4117c478bd9Sstevel@tonic-gate /*              types(I)  - type of data pointed to by items pointers       */
4127c478bd9Sstevel@tonic-gate /*              cnt(I)    - number of elements in arrays items/itemsz/types */
4137c478bd9Sstevel@tonic-gate /*                                                                          */
4147c478bd9Sstevel@tonic-gate /* Takes an array of parameters and constructs one record to include the    */
4157c478bd9Sstevel@tonic-gate /* miscellaneous packet information, as well as packet data, for reading    */
4167c478bd9Sstevel@tonic-gate /* from the log device.                                                     */
4177c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
418f4b3ec61Sdh int ipllog(dev, fin, items, itemsz, types, cnt, ifs)
4197c478bd9Sstevel@tonic-gate int dev;
4207c478bd9Sstevel@tonic-gate fr_info_t *fin;
4217c478bd9Sstevel@tonic-gate void **items;
4227c478bd9Sstevel@tonic-gate size_t *itemsz;
4237c478bd9Sstevel@tonic-gate int *types, cnt;
424f4b3ec61Sdh ipf_stack_t *ifs;
4257c478bd9Sstevel@tonic-gate {
426ab25eeb5Syz 	caddr_t buf, ptr;
4277c478bd9Sstevel@tonic-gate 	iplog_t *ipl;
4287c478bd9Sstevel@tonic-gate 	size_t len;
4297c478bd9Sstevel@tonic-gate 	int i;
430ab25eeb5Syz 	SPL_INT(s);
431ab25eeb5Syz 
4327c478bd9Sstevel@tonic-gate 	/*
4337c478bd9Sstevel@tonic-gate 	 * Check to see if this log record has a CRC which matches the last
4347c478bd9Sstevel@tonic-gate 	 * record logged.  If it does, just up the count on the previous one
4357c478bd9Sstevel@tonic-gate 	 * rather than create a new one.
4367c478bd9Sstevel@tonic-gate 	 */
437f4b3ec61Sdh 	if (ifs->ifs_ipl_suppress) {
438f4b3ec61Sdh 		MUTEX_ENTER(&ifs->ifs_ipl_mutex);
439ab25eeb5Syz 		if ((fin != NULL) && (fin->fin_off == 0)) {
440f4b3ec61Sdh 			if ((ifs->ifs_ipll[dev] != NULL) &&
441f4b3ec61Sdh 			    bcmp((char *)fin, (char *)&ifs->ifs_iplcrc[dev],
4427c478bd9Sstevel@tonic-gate 				 FI_LCSIZE) == 0) {
443f4b3ec61Sdh 				ifs->ifs_ipll[dev]->ipl_count++;
444f4b3ec61Sdh 				MUTEX_EXIT(&ifs->ifs_ipl_mutex);
4457c478bd9Sstevel@tonic-gate 				return 0;
4467c478bd9Sstevel@tonic-gate 			}
447f4b3ec61Sdh 			bcopy((char *)fin, (char *)&ifs->ifs_iplcrc[dev],
448f4b3ec61Sdh 			      FI_LCSIZE);
4497c478bd9Sstevel@tonic-gate 		} else
450f4b3ec61Sdh 			bzero((char *)&ifs->ifs_iplcrc[dev], FI_CSIZE);
451f4b3ec61Sdh 		MUTEX_EXIT(&ifs->ifs_ipl_mutex);
4527c478bd9Sstevel@tonic-gate 	}
4537c478bd9Sstevel@tonic-gate 
4547c478bd9Sstevel@tonic-gate 	/*
4557c478bd9Sstevel@tonic-gate 	 * Get the total amount of data to be logged.
4567c478bd9Sstevel@tonic-gate 	 */
4577c478bd9Sstevel@tonic-gate 	for (i = 0, len = sizeof(iplog_t); i < cnt; i++)
4587c478bd9Sstevel@tonic-gate 		len += itemsz[i];
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 	/*
4617c478bd9Sstevel@tonic-gate 	 * check that we have space to record this information and can
4627c478bd9Sstevel@tonic-gate 	 * allocate that much.
4637c478bd9Sstevel@tonic-gate 	 */
464ab25eeb5Syz 	KMALLOCS(buf, caddr_t, len);
465ab25eeb5Syz 	if (buf == NULL)
466ab25eeb5Syz 		return -1;
467ab25eeb5Syz 	SPL_NET(s);
468f4b3ec61Sdh 	MUTEX_ENTER(&ifs->ifs_ipl_mutex);
469f4b3ec61Sdh 	if ((ifs->ifs_iplused[dev] + len) > IPFILTER_LOGSIZE) {
470f4b3ec61Sdh 		MUTEX_EXIT(&ifs->ifs_ipl_mutex);
471ab25eeb5Syz 		SPL_X(s);
472ab25eeb5Syz 		KFREES(buf, len);
473ab25eeb5Syz 		return -1;
4747c478bd9Sstevel@tonic-gate 	}
475f4b3ec61Sdh 	ifs->ifs_iplused[dev] += len;
476f4b3ec61Sdh 	MUTEX_EXIT(&ifs->ifs_ipl_mutex);
477ab25eeb5Syz 	SPL_X(s);
4787c478bd9Sstevel@tonic-gate 
4797c478bd9Sstevel@tonic-gate 	/*
4807c478bd9Sstevel@tonic-gate 	 * advance the log pointer to the next empty record and deduct the
4817c478bd9Sstevel@tonic-gate 	 * amount of space we're going to use.
4827c478bd9Sstevel@tonic-gate 	 */
4837c478bd9Sstevel@tonic-gate 	ipl = (iplog_t *)buf;
484ab25eeb5Syz 	ipl->ipl_magic = ipl_magic[dev];
4857c478bd9Sstevel@tonic-gate 	ipl->ipl_count = 1;
4867c478bd9Sstevel@tonic-gate 	ipl->ipl_next = NULL;
4877c478bd9Sstevel@tonic-gate 	ipl->ipl_dsize = len;
4887c478bd9Sstevel@tonic-gate #ifdef _KERNEL
4897c478bd9Sstevel@tonic-gate 	GETKTIME(&ipl->ipl_sec);
4907c478bd9Sstevel@tonic-gate #else
4917c478bd9Sstevel@tonic-gate 	ipl->ipl_sec = 0;
4927c478bd9Sstevel@tonic-gate 	ipl->ipl_usec = 0;
4937c478bd9Sstevel@tonic-gate #endif
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate 	/*
4967c478bd9Sstevel@tonic-gate 	 * Loop through all the items to be logged, copying each one to the
4977c478bd9Sstevel@tonic-gate 	 * buffer.  Use bcopy for normal data or the mb_t copyout routine.
4987c478bd9Sstevel@tonic-gate 	 */
499ab25eeb5Syz 	for (i = 0, ptr = buf + sizeof(*ipl); i < cnt; i++) {
5007c478bd9Sstevel@tonic-gate 		if (types[i] == 0) {
501ab25eeb5Syz 			bcopy(items[i], ptr, itemsz[i]);
5027c478bd9Sstevel@tonic-gate 		} else if (types[i] == 1) {
503ab25eeb5Syz 			COPYDATA(items[i], 0, itemsz[i], ptr);
5047c478bd9Sstevel@tonic-gate 		}
505ab25eeb5Syz 		ptr += itemsz[i];
5067c478bd9Sstevel@tonic-gate 	}
507ab25eeb5Syz 	SPL_NET(s);
508f4b3ec61Sdh 	MUTEX_ENTER(&ifs->ifs_ipl_mutex);
509f4b3ec61Sdh 	ifs->ifs_ipll[dev] = ipl;
510f4b3ec61Sdh 	*ifs->ifs_iplh[dev] = ipl;
511f4b3ec61Sdh 	ifs->ifs_iplh[dev] = &ipl->ipl_next;
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate 	/*
5147c478bd9Sstevel@tonic-gate 	 * Now that the log record has been completed and added to the queue,
5157c478bd9Sstevel@tonic-gate 	 * wake up any listeners who may want to read it.
5167c478bd9Sstevel@tonic-gate 	 */
5177c478bd9Sstevel@tonic-gate # if SOLARIS && defined(_KERNEL)
518f4b3ec61Sdh 	cv_signal(&ifs->ifs_iplwait);
519f4b3ec61Sdh 	MUTEX_EXIT(&ifs->ifs_ipl_mutex);
5207c478bd9Sstevel@tonic-gate # else
521f4b3ec61Sdh 	MUTEX_EXIT(&ifs->ifs_ipl_mutex);
522f4b3ec61Sdh 	WAKEUP(&ifs->ifs_iplh, dev);
5237c478bd9Sstevel@tonic-gate # endif
524ab25eeb5Syz 	SPL_X(s);
5257c478bd9Sstevel@tonic-gate # ifdef	IPL_SELECT
5267c478bd9Sstevel@tonic-gate 	iplog_input_ready(dev);
5277c478bd9Sstevel@tonic-gate # endif
528ab25eeb5Syz 	return 0;
5297c478bd9Sstevel@tonic-gate }
5307c478bd9Sstevel@tonic-gate 
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
5337c478bd9Sstevel@tonic-gate /* Function:    ipflog_read                                                 */
5347c478bd9Sstevel@tonic-gate /* Returns:     int    - 0 == success, else error value.                    */
5357c478bd9Sstevel@tonic-gate /* Parameters:  unit(I) - device we are reading from                        */
5367c478bd9Sstevel@tonic-gate /*              uio(O)  - pointer to information about where to store data  */
5377c478bd9Sstevel@tonic-gate /*                                                                          */
5387c478bd9Sstevel@tonic-gate /* Called to handle a read on an IPFilter device.  Returns only complete    */
5397c478bd9Sstevel@tonic-gate /* log messages - will not partially copy a log record out to userland.     */
5407c478bd9Sstevel@tonic-gate /*                                                                          */
5417c478bd9Sstevel@tonic-gate /* NOTE: This function will block and wait for a signal to return data if   */
5427c478bd9Sstevel@tonic-gate /* there is none present.  Asynchronous I/O is not implemented.             */
5437c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
544f4b3ec61Sdh int ipflog_read(unit, uio, ifs)
5457c478bd9Sstevel@tonic-gate minor_t unit;
5467c478bd9Sstevel@tonic-gate struct uio *uio;
547f4b3ec61Sdh ipf_stack_t *ifs;
5487c478bd9Sstevel@tonic-gate {
5497c478bd9Sstevel@tonic-gate 	size_t dlen, copied;
5507c478bd9Sstevel@tonic-gate 	int error = 0;
5517c478bd9Sstevel@tonic-gate 	iplog_t *ipl;
552ab25eeb5Syz 	SPL_INT(s);
5537c478bd9Sstevel@tonic-gate 
5547c478bd9Sstevel@tonic-gate 	/*
5557c478bd9Sstevel@tonic-gate 	 * Sanity checks.  Make sure the minor # is valid and we're copying
5567c478bd9Sstevel@tonic-gate 	 * a valid chunk of data.
5577c478bd9Sstevel@tonic-gate 	 */
5587c478bd9Sstevel@tonic-gate 	if (IPL_LOGMAX < unit)
5597c478bd9Sstevel@tonic-gate 		return ENXIO;
5607c478bd9Sstevel@tonic-gate 	if (uio->uio_resid == 0)
5617c478bd9Sstevel@tonic-gate 		return 0;
5627c478bd9Sstevel@tonic-gate 	if ((uio->uio_resid < sizeof(iplog_t)) ||
563f4b3ec61Sdh 	    (uio->uio_resid > ifs->ifs_ipl_logsize))
5647c478bd9Sstevel@tonic-gate 		return EINVAL;
565ab25eeb5Syz 
5667c478bd9Sstevel@tonic-gate 	/*
5677c478bd9Sstevel@tonic-gate 	 * Lock the log so we can snapshot the variables.  Wait for a signal
5687c478bd9Sstevel@tonic-gate 	 * if the log is empty.
5697c478bd9Sstevel@tonic-gate 	 */
5707c478bd9Sstevel@tonic-gate 	SPL_NET(s);
571f4b3ec61Sdh 	MUTEX_ENTER(&ifs->ifs_ipl_mutex);
5727c478bd9Sstevel@tonic-gate 
573f4b3ec61Sdh 	while (ifs->ifs_iplt[unit] == NULL) {
5747c478bd9Sstevel@tonic-gate # if SOLARIS && defined(_KERNEL)
575f4b3ec61Sdh 		if (!cv_wait_sig(&ifs->ifs_iplwait, &ifs->ifs_ipl_mutex.ipf_lk)) {
576f4b3ec61Sdh 			MUTEX_EXIT(&ifs->ifs_ipl_mutex);
5777c478bd9Sstevel@tonic-gate 			return EINTR;
5787c478bd9Sstevel@tonic-gate 		}
5797c478bd9Sstevel@tonic-gate # else
5807c478bd9Sstevel@tonic-gate #  if defined(__hpux) && defined(_KERNEL)
5817c478bd9Sstevel@tonic-gate 		lock_t *l;
5827c478bd9Sstevel@tonic-gate 
5837c478bd9Sstevel@tonic-gate #   ifdef IPL_SELECT
5847c478bd9Sstevel@tonic-gate 		if (uio->uio_fpflags & (FNBLOCK|FNDELAY)) {
5857c478bd9Sstevel@tonic-gate 			/* this is no blocking system call */
586f4b3ec61Sdh 			MUTEX_EXIT(&ifs->ifs_ipl_mutex);
5877c478bd9Sstevel@tonic-gate 			return 0;
5887c478bd9Sstevel@tonic-gate 		}
5897c478bd9Sstevel@tonic-gate #   endif
5907c478bd9Sstevel@tonic-gate 
591f4b3ec61Sdh 		MUTEX_EXIT(&ifs->ifs_ipl_mutex);
592f4b3ec61Sdh 		l = get_sleep_lock(&ifs->ifs_iplh[unit]);
593f4b3ec61Sdh 		error = sleep(&ifs->ifs_iplh[unit], PZERO+1);
5947c478bd9Sstevel@tonic-gate 		spinunlock(l);
5957c478bd9Sstevel@tonic-gate #  else
5967c478bd9Sstevel@tonic-gate #   if defined(__osf__) && defined(_KERNEL)
597f4b3ec61Sdh 		error = mpsleep(&ifs->ifs_iplh[unit], PSUSP|PCATCH,  "iplread", 0,
598f4b3ec61Sdh 				&ifs->ifs_ipl_mutex, MS_LOCK_SIMPLE);
5997c478bd9Sstevel@tonic-gate #   else
600f4b3ec61Sdh 		MUTEX_EXIT(&ifs->ifs_ipl_mutex);
6017c478bd9Sstevel@tonic-gate 		SPL_X(s);
602f4b3ec61Sdh 		error = SLEEP(&ifs->ifs_iplh[unit], "ipl sleep");
6037c478bd9Sstevel@tonic-gate #   endif /* __osf__ */
6047c478bd9Sstevel@tonic-gate #  endif /* __hpux */
6057c478bd9Sstevel@tonic-gate 		if (error)
6067c478bd9Sstevel@tonic-gate 			return error;
6077c478bd9Sstevel@tonic-gate 		SPL_NET(s);
608f4b3ec61Sdh 		MUTEX_ENTER(&ifs->ifs_ipl_mutex);
6097c478bd9Sstevel@tonic-gate # endif /* SOLARIS */
6107c478bd9Sstevel@tonic-gate 	}
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate # if (BSD >= 199101) || defined(__FreeBSD__) || defined(__osf__)
6137c478bd9Sstevel@tonic-gate 	uio->uio_rw = UIO_READ;
6147c478bd9Sstevel@tonic-gate # endif
6157c478bd9Sstevel@tonic-gate 
616f4b3ec61Sdh 	for (copied = 0; ((ipl = ifs->ifs_iplt[unit]) != NULL); copied += dlen) {
6177c478bd9Sstevel@tonic-gate 		dlen = ipl->ipl_dsize;
6187c478bd9Sstevel@tonic-gate 		if (dlen > uio->uio_resid)
6197c478bd9Sstevel@tonic-gate 			break;
6207c478bd9Sstevel@tonic-gate 		/*
6217c478bd9Sstevel@tonic-gate 		 * Don't hold the mutex over the uiomove call.
6227c478bd9Sstevel@tonic-gate 		 */
623f4b3ec61Sdh 		ifs->ifs_iplt[unit] = ipl->ipl_next;
624f4b3ec61Sdh 		ifs->ifs_iplused[unit] -= dlen;
625f4b3ec61Sdh 		if (ifs->ifs_iplt[unit] == NULL) {
626f4b3ec61Sdh 			ifs->ifs_iplh[unit] = &ifs->ifs_iplt[unit];
627f4b3ec61Sdh 			ifs->ifs_ipll[unit] = NULL;
628381a2a9aSdr 		}
629f4b3ec61Sdh 		MUTEX_EXIT(&ifs->ifs_ipl_mutex);
6307c478bd9Sstevel@tonic-gate 		SPL_X(s);
6317c478bd9Sstevel@tonic-gate 		error = UIOMOVE((caddr_t)ipl, dlen, UIO_READ, uio);
6327c478bd9Sstevel@tonic-gate 		if (error) {
6337c478bd9Sstevel@tonic-gate 			SPL_NET(s);
634f4b3ec61Sdh 			MUTEX_ENTER(&ifs->ifs_ipl_mutex);
635f4b3ec61Sdh 			ifs->ifs_iplused[unit] += dlen;
636f4b3ec61Sdh 			ipl->ipl_next = ifs->ifs_iplt[unit];
637f4b3ec61Sdh 			ifs->ifs_iplt[unit] = ipl;
638f4b3ec61Sdh 			ifs->ifs_ipll[unit] = ipl;
639f4b3ec61Sdh 			if (ifs->ifs_iplh[unit] == &ifs->ifs_iplt[unit]) {
640f4b3ec61Sdh 				*ifs->ifs_iplh[unit] = ipl;
641f4b3ec61Sdh 				ifs->ifs_iplh[unit] = &ipl->ipl_next;
642381a2a9aSdr 			}
6437c478bd9Sstevel@tonic-gate 			break;
6447c478bd9Sstevel@tonic-gate 		}
645f4b3ec61Sdh 		MUTEX_ENTER(&ifs->ifs_ipl_mutex);
6467c478bd9Sstevel@tonic-gate 		KFREES((caddr_t)ipl, dlen);
6477c478bd9Sstevel@tonic-gate 		SPL_NET(s);
6487c478bd9Sstevel@tonic-gate 	}
649ab25eeb5Syz 
650f4b3ec61Sdh 	MUTEX_EXIT(&ifs->ifs_ipl_mutex);
6517c478bd9Sstevel@tonic-gate 	SPL_X(s);
6527c478bd9Sstevel@tonic-gate 	return error;
6537c478bd9Sstevel@tonic-gate }
6547c478bd9Sstevel@tonic-gate 
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
6577c478bd9Sstevel@tonic-gate /* Function:    ipflog_clear                                                */
6587c478bd9Sstevel@tonic-gate /* Returns:     int    - number of log bytes cleared.                       */
6597c478bd9Sstevel@tonic-gate /* Parameters:  unit(I) - device we are reading from                        */
6607c478bd9Sstevel@tonic-gate /*                                                                          */
6617c478bd9Sstevel@tonic-gate /* Deletes all queued up log records for a given output device.             */
6627c478bd9Sstevel@tonic-gate /* ------------------------------------------------------------------------ */
663f4b3ec61Sdh int ipflog_clear(unit, ifs)
6647c478bd9Sstevel@tonic-gate minor_t unit;
665f4b3ec61Sdh ipf_stack_t *ifs;
6667c478bd9Sstevel@tonic-gate {
6677c478bd9Sstevel@tonic-gate 	iplog_t *ipl;
6687c478bd9Sstevel@tonic-gate 	int used;
669ab25eeb5Syz 	SPL_INT(s);
6707c478bd9Sstevel@tonic-gate 
671ab25eeb5Syz 	SPL_NET(s);
672f4b3ec61Sdh 	MUTEX_ENTER(&ifs->ifs_ipl_mutex);
673f4b3ec61Sdh 	while ((ipl = ifs->ifs_iplt[unit]) != NULL) {
674f4b3ec61Sdh 		ifs->ifs_iplt[unit] = ipl->ipl_next;
6757c478bd9Sstevel@tonic-gate 		KFREES((caddr_t)ipl, ipl->ipl_dsize);
6767c478bd9Sstevel@tonic-gate 	}
677f4b3ec61Sdh 	ifs->ifs_iplh[unit] = &ifs->ifs_iplt[unit];
678f4b3ec61Sdh 	ifs->ifs_ipll[unit] = NULL;
679f4b3ec61Sdh 	used = ifs->ifs_iplused[unit];
680f4b3ec61Sdh 	ifs->ifs_iplused[unit] = 0;
681f4b3ec61Sdh 	bzero((char *)&ifs->ifs_iplcrc[unit], FI_CSIZE);
682f4b3ec61Sdh 	MUTEX_EXIT(&ifs->ifs_ipl_mutex);
683ab25eeb5Syz 	SPL_X(s);
6847c478bd9Sstevel@tonic-gate 	return used;
6857c478bd9Sstevel@tonic-gate }
6867c478bd9Sstevel@tonic-gate #endif /* IPFILTER_LOG */
687