1 /* $NetBSD: ip_log.c,v 1.8 2018/06/03 10:37:23 maxv Exp $ */ 2 3 /* 4 * Copyright (C) 2012 by Darren Reed. 5 * 6 * See the IPFILTER.LICENCE file for details on licencing. 7 * 8 * Id: ip_log.c,v 1.1.1.2 2012/07/22 13:45:19 darrenr Exp 9 */ 10 11 #include <sys/cdefs.h> 12 __KERNEL_RCSID(0, "$NetBSD: ip_log.c,v 1.8 2018/06/03 10:37:23 maxv Exp $"); 13 14 #include <sys/param.h> 15 #if defined(KERNEL) || defined(_KERNEL) 16 # undef KERNEL 17 # undef _KERNEL 18 # define KERNEL 1 19 # define _KERNEL 1 20 #endif 21 #if defined(__FreeBSD__) && !defined(_KERNEL) 22 # include <osreldate.h> 23 #endif 24 #ifndef SOLARIS 25 # if (defined(sun) && (defined(__svr4__) || defined(__SVR4))) 26 # define SOLARIS 1 27 # else 28 # define SOLARIS 0 29 # endif 30 #endif 31 #include <sys/errno.h> 32 #include <sys/types.h> 33 #include <sys/file.h> 34 #ifndef _KERNEL 35 # include <stdio.h> 36 # include <string.h> 37 # include <stdlib.h> 38 # include <ctype.h> 39 # define _KERNEL 40 # define KERNEL 41 # ifdef __OpenBSD__ 42 struct file; 43 # endif 44 # include <sys/uio.h> 45 # undef _KERNEL 46 # undef KERNEL 47 #endif 48 #if (defined(__FreeBSD_version) && (__FreeBSD_version >= 220000)) && \ 49 defined(_KERNEL) 50 # include <sys/fcntl.h> 51 # include <sys/filio.h> 52 #else 53 # include <sys/ioctl.h> 54 #endif 55 #include <sys/time.h> 56 #if defined(_KERNEL) 57 # include <sys/systm.h> 58 # if (defined(NetBSD) && (__NetBSD_Version__ >= 104000000)) 59 # include <sys/proc.h> 60 # endif 61 #endif /* _KERNEL */ 62 #if !SOLARIS && !defined(__hpux) && !defined(linux) 63 # if (defined(NetBSD) && (NetBSD > 199609)) || \ 64 (defined(OpenBSD) && (OpenBSD > 199603)) || \ 65 (defined(__FreeBSD_version) && (__FreeBSD_version >= 300000)) 66 # include <sys/dirent.h> 67 # else 68 # include <sys/dir.h> 69 # endif 70 # include <sys/mbuf.h> 71 # include <sys/select.h> 72 # if __FreeBSD_version >= 500000 73 # include <sys/selinfo.h> 74 # endif 75 #else 76 # if !defined(__hpux) && defined(_KERNEL) 77 # include <sys/filio.h> 78 # include <sys/cred.h> 79 # include <sys/ddi.h> 80 # include <sys/sunddi.h> 81 # include <sys/ksynch.h> 82 # include <sys/kmem.h> 83 # include <sys/mkdev.h> 84 # include <sys/dditypes.h> 85 # include <sys/cmn_err.h> 86 # endif /* !__hpux */ 87 #endif /* !SOLARIS && !__hpux */ 88 #if !defined(linux) 89 # include <sys/protosw.h> 90 #endif 91 #include <sys/socket.h> 92 93 #include <net/if.h> 94 #ifdef sun 95 # include <net/af.h> 96 #endif 97 #if __FreeBSD_version >= 300000 98 # include <net/if_var.h> 99 #endif 100 #include <netinet/in.h> 101 #ifdef __sgi 102 # include <sys/ddi.h> 103 # ifdef IFF_DRVRLOCK /* IRIX6 */ 104 # include <sys/hashing.h> 105 # endif 106 #endif 107 #if !defined(__hpux) && !defined(linux) && \ 108 !(defined(__sgi) && !defined(IFF_DRVRLOCK)) /*IRIX<6*/ 109 # include <netinet/in_var.h> 110 #endif 111 #include <netinet/in_systm.h> 112 #include <netinet/ip.h> 113 #include <netinet/tcp.h> 114 #include <netinet/udp.h> 115 #include <netinet/ip_icmp.h> 116 #ifdef USE_INET6 117 # include <netinet/icmp6.h> 118 #endif 119 #if !defined(linux) 120 # include <netinet/ip_var.h> 121 #endif 122 #ifndef _KERNEL 123 # include <syslog.h> 124 #endif 125 #include "netinet/ip_compat.h" 126 #include "netinet/ip_fil.h" 127 #include "netinet/ip_nat.h" 128 #include "netinet/ip_frag.h" 129 #include "netinet/ip_state.h" 130 #include "netinet/ip_auth.h" 131 #if (__FreeBSD_version >= 300000) || defined(__NetBSD__) 132 # include <sys/malloc.h> 133 #endif 134 /* END OF INCLUDES */ 135 136 #ifdef IPFILTER_LOG 137 138 # if defined(IPL_SELECT) 139 # include <machine/sys/user.h> 140 # include <sys/kthread_iface.h> 141 # define READ_COLLISION 0x001 142 extern int selwait; 143 # endif /* IPL_SELECT */ 144 145 typedef struct ipf_log_softc_s { 146 ipfmutex_t ipl_mutex[IPL_LOGSIZE]; 147 # if SOLARIS && defined(_KERNEL) 148 kcondvar_t ipl_wait[IPL_LOGSIZE]; 149 # endif 150 # if defined(linux) && defined(_KERNEL) 151 wait_queue_head_t iplh_linux[IPL_LOGSIZE]; 152 # endif 153 # if defined(__hpux) && defined(_KERNEL) 154 iplog_select_t ipl_ss[IPL_LOGSIZE]; 155 # endif 156 iplog_t **iplh[IPL_LOGSIZE]; 157 iplog_t *iplt[IPL_LOGSIZE]; 158 iplog_t *ipll[IPL_LOGSIZE]; 159 u_long ipl_logfail[IPL_LOGSIZE]; 160 u_long ipl_logok[IPL_LOGSIZE]; 161 fr_info_t ipl_crc[IPL_LOGSIZE]; 162 u_32_t ipl_counter[IPL_LOGSIZE]; 163 int ipl_suppress; 164 int ipl_logall; 165 int ipl_log_init; 166 int ipl_logsize; 167 int ipl_used[IPL_LOGSIZE]; 168 int ipl_magic[IPL_LOGSIZE]; 169 ipftuneable_t *ipf_log_tune; 170 int ipl_readers[IPL_LOGSIZE]; 171 } ipf_log_softc_t; 172 173 static int magic[IPL_LOGSIZE] = { IPL_MAGIC, IPL_MAGIC_NAT, IPL_MAGIC_STATE, 174 IPL_MAGIC, IPL_MAGIC, IPL_MAGIC, 175 IPL_MAGIC, IPL_MAGIC }; 176 177 static const ipftuneable_t ipf_log_tuneables[] = { 178 /* log */ 179 { { (void *)offsetof(ipf_log_softc_t, ipl_suppress) }, 180 "log_suppress", 0, 1, 181 stsizeof(ipf_log_softc_t, ipl_suppress), 182 0, NULL, NULL }, 183 { { (void *)offsetof(ipf_log_softc_t, ipl_logall) }, 184 "log_all", 0, 1, 185 stsizeof(ipf_log_softc_t, ipl_logall), 186 0, NULL, NULL }, 187 { { (void *)offsetof(ipf_log_softc_t, ipl_logsize) }, 188 "log_size", 0, 0x80000, 189 stsizeof(ipf_log_softc_t, ipl_logsize), 190 0, NULL, NULL }, 191 { { NULL }, NULL, 0, 0, 192 0, 193 0, NULL, NULL } 194 }; 195 196 197 int 198 ipf_log_main_load(void) 199 { 200 return 0; 201 } 202 203 204 int 205 ipf_log_main_unload(void) 206 { 207 return 0; 208 } 209 210 /* ------------------------------------------------------------------------ */ 211 /* Function: ipf_log_soft_create */ 212 /* Returns: void * - NULL = failure, else pointer to log context data */ 213 /* Parameters: softc(I) - pointer to soft context main structure */ 214 /* */ 215 /* Initialise log buffers & pointers. Also iniialised the CRC to a local */ 216 /* secret for use in calculating the "last log checksum". */ 217 /* ------------------------------------------------------------------------ */ 218 void * 219 ipf_log_soft_create(ipf_main_softc_t *softc) 220 { 221 ipf_log_softc_t *softl; 222 223 KMALLOC(softl, ipf_log_softc_t *); 224 if (softl == NULL) 225 return NULL; 226 227 bzero((char *)softl, sizeof(*softl)); 228 bcopy((char *)magic, (char *)softl->ipl_magic, sizeof(magic)); 229 230 softl->ipf_log_tune = ipf_tune_array_copy(softl, 231 sizeof(ipf_log_tuneables), 232 ipf_log_tuneables); 233 if (softl->ipf_log_tune == NULL) { 234 ipf_log_soft_destroy(softc, softl); 235 return NULL; 236 } 237 if (ipf_tune_array_link(softc, softl->ipf_log_tune) == -1) { 238 ipf_log_soft_destroy(softc, softl); 239 return NULL; 240 } 241 242 softl->ipl_suppress = 1; 243 softl->ipl_logall = 0; 244 softl->ipl_log_init = 0; 245 softl->ipl_logsize = IPFILTER_LOGSIZE; 246 247 return softl; 248 } 249 250 /* ------------------------------------------------------------------------ */ 251 /* Function: ipf_log_soft_init */ 252 /* Returns: int - 0 == success (always returned) */ 253 /* Parameters: softc(I) - pointer to soft context main structure */ 254 /* */ 255 /* Initialise log buffers & pointers. Also iniialised the CRC to a local */ 256 /* secret for use in calculating the "last log checksum". */ 257 /* ------------------------------------------------------------------------ */ 258 int 259 ipf_log_soft_init(ipf_main_softc_t *softc, void *arg) 260 { 261 ipf_log_softc_t *softl = arg; 262 int i; 263 264 for (i = IPL_LOGMAX; i >= 0; i--) { 265 softl->iplt[i] = NULL; 266 softl->ipll[i] = NULL; 267 softl->iplh[i] = &softl->iplt[i]; 268 bzero((char *)&softl->ipl_crc[i], sizeof(softl->ipl_crc[i])); 269 # ifdef IPL_SELECT 270 softl->iplog_ss[i].read_waiter = 0; 271 softl->iplog_ss[i].state = 0; 272 # endif 273 # if defined(linux) && defined(_KERNEL) 274 init_waitqueue_head(softl->iplh_linux + i); 275 # endif 276 # if SOLARIS && defined(_KERNEL) 277 cv_init(&softl->ipl_wait[i], NULL, CV_DRIVER, NULL); 278 # endif 279 MUTEX_INIT(&softl->ipl_mutex[i], "ipf log mutex"); 280 } 281 282 283 softl->ipl_log_init = 1; 284 285 return 0; 286 } 287 288 289 /* ------------------------------------------------------------------------ */ 290 /* Function: ipf_log_soft_fini */ 291 /* Parameters: softc(I) - pointer to soft context main structure */ 292 /* arg(I) - pointer to log context structure */ 293 /* */ 294 /* Clean up any log data that has accumulated without being read. */ 295 /* ------------------------------------------------------------------------ */ 296 int 297 ipf_log_soft_fini(ipf_main_softc_t *softc, void *arg) 298 { 299 ipf_log_softc_t *softl = arg; 300 int i; 301 302 if (softl->ipl_log_init == 0) 303 return 0; 304 305 softl->ipl_log_init = 0; 306 307 for (i = IPL_LOGMAX; i >= 0; i--) { 308 (void) ipf_log_clear(softc, i); 309 310 /* 311 * This is a busy-wait loop so as to avoid yet another lock 312 * to wait on. 313 */ 314 MUTEX_ENTER(&softl->ipl_mutex[i]); 315 while (softl->ipl_readers[i] > 0) { 316 # if SOLARIS && defined(_KERNEL) 317 cv_broadcast(&softl->ipl_wait[i]); 318 MUTEX_EXIT(&softl->ipl_mutex[i]); 319 delay(100); 320 pollwakeup(&softc->ipf_poll_head[i], POLLRDNORM); 321 # else 322 MUTEX_EXIT(&softl->ipl_mutex[i]); 323 WAKEUP(softl->iplh, i); 324 POLLWAKEUP(i); 325 # endif 326 MUTEX_ENTER(&softl->ipl_mutex[i]); 327 } 328 MUTEX_EXIT(&softl->ipl_mutex[i]); 329 MUTEX_DESTROY(&softl->ipl_mutex[i]); 330 } 331 332 return 0; 333 } 334 335 336 /* ------------------------------------------------------------------------ */ 337 /* Function: ipf_log_soft_destroy */ 338 /* Parameters: softc(I) - pointer to soft context main structure */ 339 /* arg(I) - pointer to log context structure */ 340 /* */ 341 /* When this function is called, it is expected that there are no longer */ 342 /* any threads active in the reading code path or the logging code path. */ 343 /* ------------------------------------------------------------------------ */ 344 void 345 ipf_log_soft_destroy(ipf_main_softc_t *softc, void *arg) 346 { 347 ipf_log_softc_t *softl = arg; 348 int i; 349 350 for (i = IPL_LOGMAX; i >= 0; i--) { 351 # if SOLARIS && defined(_KERNEL) 352 cv_destroy(&softl->ipl_wait[i]); 353 # endif 354 } 355 356 if (softl->ipf_log_tune != NULL) { 357 ipf_tune_array_unlink(softc, softl->ipf_log_tune); 358 KFREES(softl->ipf_log_tune, sizeof(ipf_log_tuneables)); 359 softl->ipf_log_tune = NULL; 360 } 361 362 KFREE(softl); 363 } 364 365 366 /* ------------------------------------------------------------------------ */ 367 /* Function: ipf_log_pkt */ 368 /* Returns: int - 0 == success, -1 == failure */ 369 /* Parameters: fin(I) - pointer to packet information */ 370 /* flags(I) - flags from filter rules */ 371 /* */ 372 /* Create a log record for a packet given that it has been triggered by a */ 373 /* rule (or the default setting). Calculate the transport protocol header */ 374 /* size using predetermined size of a couple of popular protocols and thus */ 375 /* how much data to copy into the log, including part of the data body if */ 376 /* requested. */ 377 /* ------------------------------------------------------------------------ */ 378 int 379 ipf_log_pkt(fr_info_t *fin, u_int flags) 380 { 381 ipf_main_softc_t *softc = fin->fin_main_soft; 382 ipf_log_softc_t *softl = softc->ipf_log_soft; 383 register size_t hlen; 384 int types[2], mlen; 385 size_t sizes[2]; 386 void *ptrs[2]; 387 ipflog_t ipfl; 388 u_char p; 389 mb_t *m; 390 # if (SOLARIS || defined(__hpux)) && defined(_KERNEL) && !defined(FW_HOOKS) 391 qif_t *ifp; 392 # else 393 struct ifnet *ifp; 394 # endif /* SOLARIS || __hpux */ 395 396 m = fin->fin_m; 397 if (m == NULL) 398 return -1; 399 400 ipfl.fl_nattag.ipt_num[0] = 0; 401 ifp = fin->fin_ifp; 402 hlen = (char *)fin->fin_dp - (char *)fin->fin_ip; 403 404 /* 405 * calculate header size. 406 */ 407 if (fin->fin_off == 0) { 408 p = fin->fin_fi.fi_p; 409 if (p == IPPROTO_TCP) 410 hlen += MIN(sizeof(tcphdr_t), fin->fin_dlen); 411 else if (p == IPPROTO_UDP) 412 hlen += MIN(sizeof(udphdr_t), fin->fin_dlen); 413 else if (p == IPPROTO_ICMP) { 414 struct icmp *icmp; 415 416 icmp = (struct icmp *)fin->fin_dp; 417 418 /* 419 * For ICMP, if the packet is an error packet, also 420 * include the information about the packet which 421 * caused the error. 422 */ 423 switch (icmp->icmp_type) 424 { 425 case ICMP_UNREACH : 426 case ICMP_SOURCEQUENCH : 427 case ICMP_REDIRECT : 428 case ICMP_TIMXCEED : 429 case ICMP_PARAMPROB : 430 hlen += MIN(sizeof(struct icmp) + 8, 431 fin->fin_dlen); 432 break; 433 default : 434 hlen += MIN(sizeof(struct icmp), 435 fin->fin_dlen); 436 break; 437 } 438 } 439 # ifdef USE_INET6 440 else if (p == IPPROTO_ICMPV6) { 441 struct icmp6_hdr *icmp; 442 443 icmp = (struct icmp6_hdr *)fin->fin_dp; 444 445 /* 446 * For ICMPV6, if the packet is an error packet, also 447 * include the information about the packet which 448 * caused the error. 449 */ 450 if (icmp->icmp6_type < 128) { 451 hlen += MIN(sizeof(struct icmp6_hdr) + 8, 452 fin->fin_dlen); 453 } else { 454 hlen += MIN(sizeof(struct icmp6_hdr), 455 fin->fin_dlen); 456 } 457 } 458 # endif 459 } 460 /* 461 * Get the interface number and name to which this packet is 462 * currently associated. 463 */ 464 # if (SOLARIS || defined(__hpux)) && defined(_KERNEL) 465 # if !defined(FW_HOOKS) 466 ipfl.fl_unit = (u_int)ifp->qf_ppa; 467 # endif 468 COPYIFNAME(fin->fin_v, ifp, ipfl.fl_ifname); 469 # else 470 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199603)) || \ 471 OPENBSD_GE_REV(199603) || defined(linux) || FREEBSD_GE_REV(501113) 472 COPYIFNAME(fin->fin_v, ifp, ipfl.fl_ifname); 473 # else 474 ipfl.fl_unit = (u_int)ifp->if_unit; 475 # if defined(_KERNEL) 476 if ((ipfl.fl_ifname[0] = ifp->if_name[0])) 477 if ((ipfl.fl_ifname[1] = ifp->if_name[1])) 478 if ((ipfl.fl_ifname[2] = ifp->if_name[2])) 479 ipfl.fl_ifname[3] = ifp->if_name[3]; 480 # else 481 (void) strncpy(ipfl.fl_ifname, IFNAME(ifp), sizeof(ipfl.fl_ifname)); 482 ipfl.fl_ifname[sizeof(ipfl.fl_ifname) - 1] = '\0'; 483 # endif 484 # endif 485 # endif /* __hpux || SOLARIS */ 486 mlen = fin->fin_plen - hlen; 487 if (!softl->ipl_logall) { 488 mlen = (flags & FR_LOGBODY) ? MIN(mlen, 128) : 0; 489 } else if ((flags & FR_LOGBODY) == 0) { 490 mlen = 0; 491 } 492 if (mlen < 0) 493 mlen = 0; 494 ipfl.fl_plen = (u_char)mlen; 495 ipfl.fl_hlen = (u_char)hlen; 496 ipfl.fl_rule = fin->fin_rule; 497 (void) strncpy(ipfl.fl_group, fin->fin_group, FR_GROUPLEN); 498 if (fin->fin_fr != NULL) { 499 ipfl.fl_loglevel = fin->fin_fr->fr_loglevel; 500 ipfl.fl_logtag = fin->fin_fr->fr_logtag; 501 } else { 502 ipfl.fl_loglevel = 0xffff; 503 ipfl.fl_logtag = FR_NOLOGTAG; 504 } 505 if (fin->fin_nattag != NULL) 506 bcopy(fin->fin_nattag, (void *)&ipfl.fl_nattag, 507 sizeof(ipfl.fl_nattag)); 508 ipfl.fl_flags = flags; 509 ipfl.fl_breason = (fin->fin_reason & 0xff); 510 ipfl.fl_dir = fin->fin_out; 511 ipfl.fl_lflags = fin->fin_flx; 512 ipfl.fl_family = fin->fin_family; 513 ptrs[0] = (void *)&ipfl; 514 sizes[0] = sizeof(ipfl); 515 types[0] = 0; 516 # if defined(MENTAT) && defined(_KERNEL) 517 /* 518 * Are we copied from the mblk or an aligned array ? 519 */ 520 if (fin->fin_ip == (ip_t *)m->b_rptr) { 521 ptrs[1] = m; 522 sizes[1] = hlen + mlen; 523 types[1] = 1; 524 } else { 525 ptrs[1] = fin->fin_ip; 526 sizes[1] = hlen + mlen; 527 types[1] = 0; 528 } 529 # else 530 ptrs[1] = m; 531 sizes[1] = hlen + mlen; 532 types[1] = 1; 533 # endif /* MENTAT */ 534 return ipf_log_items(softc, IPL_LOGIPF, fin, ptrs, sizes, types, 2); 535 } 536 537 538 /* ------------------------------------------------------------------------ */ 539 /* Function: ipf_log_items */ 540 /* Returns: int - 0 == success, -1 == failure */ 541 /* Parameters: softc(I) - pointer to main soft context */ 542 /* unit(I) - device we are reading from */ 543 /* fin(I) - pointer to packet information */ 544 /* items(I) - array of pointers to log data */ 545 /* itemsz(I) - array of size of valid memory pointed to */ 546 /* types(I) - type of data pointed to by items pointers */ 547 /* cnt(I) - number of elements in arrays items/itemsz/types */ 548 /* */ 549 /* Takes an array of parameters and constructs one record to include the */ 550 /* miscellaneous packet information, as well as packet data, for reading */ 551 /* from the log device. */ 552 /* ------------------------------------------------------------------------ */ 553 int 554 ipf_log_items(ipf_main_softc_t *softc, int unit, fr_info_t *fin, 555 void **items, size_t *itemsz, int *types, int cnt) 556 { 557 ipf_log_softc_t *softl = softc->ipf_log_soft; 558 char *buf, *ptr; 559 iplog_t *ipl; 560 size_t len; 561 int i; 562 SPL_INT(s); 563 564 /* 565 * Get the total amount of data to be logged. 566 */ 567 for (i = 0, len = sizeof(iplog_t); i < cnt; i++) 568 len += itemsz[i]; 569 570 SPL_NET(s); 571 MUTEX_ENTER(&softl->ipl_mutex[unit]); 572 softl->ipl_counter[unit]++; 573 /* 574 * check that we have space to record this information and can 575 * allocate that much. 576 */ 577 if ((softl->ipl_used[unit] + len) > softl->ipl_logsize) { 578 softl->ipl_logfail[unit]++; 579 MUTEX_EXIT(&softl->ipl_mutex[unit]); 580 return -1; 581 } 582 583 KMALLOCS(buf, char *, len); 584 if (buf == NULL) { 585 softl->ipl_logfail[unit]++; 586 MUTEX_EXIT(&softl->ipl_mutex[unit]); 587 return -1; 588 } 589 ipl = (iplog_t *)buf; 590 ipl->ipl_magic = softl->ipl_magic[unit]; 591 ipl->ipl_count = 1; 592 ipl->ipl_seqnum = softl->ipl_counter[unit]; 593 ipl->ipl_next = NULL; 594 ipl->ipl_dsize = len; 595 #ifdef _KERNEL 596 GETKTIME(&ipl->ipl_sec); 597 #else 598 ipl->ipl_sec = 0; 599 ipl->ipl_usec = 0; 600 #endif 601 602 /* 603 * Loop through all the items to be logged, copying each one to the 604 * buffer. Use bcopy for normal data or the mb_t copyout routine. 605 */ 606 for (i = 0, ptr = buf + sizeof(*ipl); i < cnt; i++) { 607 if (types[i] == 0) { 608 memcpy(ptr, items[i], itemsz[i]); 609 } else if (types[i] == 1) { 610 COPYDATA(items[i], 0, itemsz[i], ptr); 611 } 612 ptr += itemsz[i]; 613 } 614 /* 615 * Check to see if this log record has a CRC which matches the last 616 * record logged. If it does, just up the count on the previous one 617 * rather than create a new one. 618 */ 619 if (softl->ipl_suppress) { 620 if ((fin != NULL) && (fin->fin_off == 0)) { 621 if ((softl->ipll[unit] != NULL) && 622 (fin->fin_crc == softl->ipl_crc[unit].fin_crc) && 623 bcmp((char *)fin, (char *)&softl->ipl_crc[unit], 624 FI_LCSIZE) == 0) { 625 softl->ipll[unit]->ipl_count++; 626 MUTEX_EXIT(&softl->ipl_mutex[unit]); 627 SPL_X(s); 628 KFREES(buf, len); 629 return 0; 630 } 631 bcopy((char *)fin, (char *)&softl->ipl_crc[unit], 632 FI_LCSIZE); 633 softl->ipl_crc[unit].fin_crc = fin->fin_crc; 634 } else 635 bzero((char *)&softl->ipl_crc[unit], FI_CSIZE); 636 } 637 638 /* 639 * advance the log pointer to the next empty record and deduct the 640 * amount of space we're going to use. 641 */ 642 softl->ipl_logok[unit]++; 643 softl->ipll[unit] = ipl; 644 *softl->iplh[unit] = ipl; 645 softl->iplh[unit] = &ipl->ipl_next; 646 softl->ipl_used[unit] += len; 647 648 /* 649 * Now that the log record has been completed and added to the queue, 650 * wake up any listeners who may want to read it. 651 */ 652 # if SOLARIS && defined(_KERNEL) 653 cv_signal(&softl->ipl_wait[unit]); 654 MUTEX_EXIT(&softl->ipl_mutex[unit]); 655 pollwakeup(&softc->ipf_poll_head[unit], POLLRDNORM); 656 # else 657 MUTEX_EXIT(&softl->ipl_mutex[unit]); 658 WAKEUP(softl->iplh, unit); 659 POLLWAKEUP(unit); 660 # endif 661 SPL_X(s); 662 # ifdef IPL_SELECT 663 iplog_input_ready(unit); 664 # endif 665 return 0; 666 } 667 668 669 /* ------------------------------------------------------------------------ */ 670 /* Function: ipf_log_read */ 671 /* Returns: int - 0 == success, else error value. */ 672 /* Parameters: softc(I) - pointer to main soft context */ 673 /* unit(I) - device we are reading from */ 674 /* uio(O) - pointer to information about where to store data */ 675 /* */ 676 /* Called to handle a read on an IPFilter device. Returns only complete */ 677 /* log messages - will not partially copy a log record out to userland. */ 678 /* */ 679 /* NOTE: This function will block and wait for a signal to return data if */ 680 /* there is none present. Asynchronous I/O is not implemented. */ 681 /* ------------------------------------------------------------------------ */ 682 int 683 ipf_log_read(ipf_main_softc_t *softc, minor_t unit, struct uio *uio) 684 { 685 ipf_log_softc_t *softl = softc->ipf_log_soft; 686 size_t dlen, copied; 687 int error = 0; 688 iplog_t *ipl; 689 SPL_INT(s); 690 691 if (softl->ipl_log_init == 0) { 692 IPFERROR(40007); 693 return 0; 694 } 695 696 /* 697 * Sanity checks. Make sure the minor # is valid and we're copying 698 * a valid chunk of data. 699 */ 700 if (IPL_LOGMAX < unit) { 701 IPFERROR(40001); 702 return ENXIO; 703 } 704 if (uio->uio_resid == 0) 705 return 0; 706 707 if (uio->uio_resid < sizeof(iplog_t)) { 708 IPFERROR(40002); 709 return EINVAL; 710 } 711 if (uio->uio_resid > softl->ipl_logsize) { 712 IPFERROR(40005); 713 return EINVAL; 714 } 715 716 /* 717 * Lock the log so we can snapshot the variables. Wait for a signal 718 * if the log is empty. 719 */ 720 SPL_NET(s); 721 MUTEX_ENTER(&softl->ipl_mutex[unit]); 722 softl->ipl_readers[unit]++; 723 724 while (softl->ipl_log_init == 1 && softl->iplt[unit] == NULL) { 725 # if SOLARIS && defined(_KERNEL) 726 if (!cv_wait_sig(&softl->ipl_wait[unit], 727 &softl->ipl_mutex[unit].ipf_lk)) { 728 softl->ipl_readers[unit]--; 729 MUTEX_EXIT(&softl->ipl_mutex[unit]); 730 IPFERROR(40003); 731 return EINTR; 732 } 733 # else 734 # if defined(__hpux) && defined(_KERNEL) 735 lock_t *l; 736 737 # ifdef IPL_SELECT 738 if (uio->uio_fpflags & (FNBLOCK|FNDELAY)) { 739 /* this is no blocking system call */ 740 softl->ipl_readers[unit]--; 741 MUTEX_EXIT(&softl->ipl_mutex[unit]); 742 return 0; 743 } 744 # endif 745 746 MUTEX_EXIT(&softl->ipl_mutex[unit]); 747 l = get_sleep_lock(&softl->iplh[unit]); 748 error = sleep(&softl->iplh[unit], PZERO+1); 749 spinunlock(l); 750 # else 751 # if defined(__osf__) && defined(_KERNEL) 752 error = mpsleep(&softl->iplh[unit], PSUSP|PCATCH, "ipfread", 0, 753 &softl->ipl_mutex, MS_LOCK_SIMPLE); 754 # else 755 MUTEX_EXIT(&softl->ipl_mutex[unit]); 756 SPL_X(s); 757 error = SLEEP(unit + softl->iplh, "ipl sleep"); 758 # endif /* __osf__ */ 759 # endif /* __hpux */ 760 SPL_NET(s); 761 MUTEX_ENTER(&softl->ipl_mutex[unit]); 762 if (error) { 763 softl->ipl_readers[unit]--; 764 MUTEX_EXIT(&softl->ipl_mutex[unit]); 765 IPFERROR(40004); 766 return error; 767 } 768 # endif /* SOLARIS */ 769 } 770 if (softl->ipl_log_init != 1) { 771 softl->ipl_readers[unit]--; 772 MUTEX_EXIT(&softl->ipl_mutex[unit]); 773 IPFERROR(40008); 774 return EIO; 775 } 776 777 # if (defined(BSD) && (BSD >= 199101)) || defined(__FreeBSD__) || \ 778 defined(__osf__) 779 uio->uio_rw = UIO_READ; 780 # endif 781 782 for (copied = 0; (ipl = softl->iplt[unit]) != NULL; copied += dlen) { 783 dlen = ipl->ipl_dsize; 784 if (dlen > uio->uio_resid) 785 break; 786 /* 787 * Don't hold the mutex over the uiomove call. 788 */ 789 softl->iplt[unit] = ipl->ipl_next; 790 softl->ipl_used[unit] -= dlen; 791 MUTEX_EXIT(&softl->ipl_mutex[unit]); 792 SPL_X(s); 793 error = UIOMOVE((void *)ipl, dlen, UIO_READ, uio); 794 if (error) { 795 SPL_NET(s); 796 MUTEX_ENTER(&softl->ipl_mutex[unit]); 797 IPFERROR(40006); 798 ipl->ipl_next = softl->iplt[unit]; 799 softl->iplt[unit] = ipl; 800 softl->ipl_used[unit] += dlen; 801 break; 802 } 803 MUTEX_ENTER(&softl->ipl_mutex[unit]); 804 KFREES((void *)ipl, dlen); 805 SPL_NET(s); 806 } 807 if (!softl->iplt[unit]) { 808 softl->ipl_used[unit] = 0; 809 softl->iplh[unit] = &softl->iplt[unit]; 810 softl->ipll[unit] = NULL; 811 } 812 813 softl->ipl_readers[unit]--; 814 MUTEX_EXIT(&softl->ipl_mutex[unit]); 815 SPL_X(s); 816 return error; 817 } 818 819 820 /* ------------------------------------------------------------------------ */ 821 /* Function: ipf_log_clear */ 822 /* Returns: int - number of log bytes cleared. */ 823 /* Parameters: softc(I) - pointer to main soft context */ 824 /* unit(I) - device we are reading from */ 825 /* */ 826 /* Deletes all queued up log records for a given output device. */ 827 /* ------------------------------------------------------------------------ */ 828 int 829 ipf_log_clear(ipf_main_softc_t *softc, minor_t unit) 830 { 831 ipf_log_softc_t *softl = softc->ipf_log_soft; 832 iplog_t *ipl; 833 int used; 834 SPL_INT(s); 835 836 SPL_NET(s); 837 MUTEX_ENTER(&softl->ipl_mutex[unit]); 838 while ((ipl = softl->iplt[unit]) != NULL) { 839 softl->iplt[unit] = ipl->ipl_next; 840 KFREES((void *)ipl, ipl->ipl_dsize); 841 } 842 softl->iplh[unit] = &softl->iplt[unit]; 843 softl->ipll[unit] = NULL; 844 used = softl->ipl_used[unit]; 845 softl->ipl_used[unit] = 0; 846 bzero((char *)&softl->ipl_crc[unit], FI_CSIZE); 847 MUTEX_EXIT(&softl->ipl_mutex[unit]); 848 SPL_X(s); 849 return used; 850 } 851 852 853 /* ------------------------------------------------------------------------ */ 854 /* Function: ipf_log_canread */ 855 /* Returns: int - 0 == no data to read, 1 = data present */ 856 /* Parameters: softc(I) - pointer to main soft context */ 857 /* unit(I) - device we are reading from */ 858 /* */ 859 /* Returns an indication of whether or not there is data present in the */ 860 /* current buffer for the selected ipf device. */ 861 /* ------------------------------------------------------------------------ */ 862 int 863 ipf_log_canread(ipf_main_softc_t *softc, int unit) 864 { 865 ipf_log_softc_t *softl = softc->ipf_log_soft; 866 867 return softl->iplt[unit] != NULL; 868 } 869 870 871 /* ------------------------------------------------------------------------ */ 872 /* Function: ipf_log_canread */ 873 /* Returns: int - 0 == no data to read, 1 = data present */ 874 /* Parameters: softc(I) - pointer to main soft context */ 875 /* unit(I) - device we are reading from */ 876 /* */ 877 /* Returns how many bytes are currently held in log buffers for the */ 878 /* selected ipf device. */ 879 /* ------------------------------------------------------------------------ */ 880 int 881 ipf_log_bytesused(ipf_main_softc_t *softc, int unit) 882 { 883 ipf_log_softc_t *softl = softc->ipf_log_soft; 884 885 if (softl == NULL) 886 return 0; 887 888 return softl->ipl_used[unit]; 889 } 890 891 892 /* ------------------------------------------------------------------------ */ 893 /* Function: ipf_log_failures */ 894 /* Returns: U_QUAD_T - number of log failures */ 895 /* Parameters: softc(I) - pointer to main soft context */ 896 /* unit(I) - device we are reading from */ 897 /* */ 898 /* Returns how many times we've tried to log a packet but failed to do so */ 899 /* for the selected ipf device. */ 900 /* ------------------------------------------------------------------------ */ 901 u_long 902 ipf_log_failures(ipf_main_softc_t *softc, int unit) 903 { 904 ipf_log_softc_t *softl = softc->ipf_log_soft; 905 906 if (softl == NULL) 907 return 0; 908 909 return softl->ipl_logfail[unit]; 910 } 911 912 913 /* ------------------------------------------------------------------------ */ 914 /* Function: ipf_log_logok */ 915 /* Returns: U_QUAD_T - number of packets logged */ 916 /* Parameters: softc(I) - pointer to main soft context */ 917 /* unit(I) - device we are reading from */ 918 /* */ 919 /* Returns how many times we've successfully logged a packet for the */ 920 /* selected ipf device. */ 921 /* ------------------------------------------------------------------------ */ 922 u_long 923 ipf_log_logok(ipf_main_softc_t *softc, int unit) 924 { 925 ipf_log_softc_t *softl = softc->ipf_log_soft; 926 927 if (softl == NULL) 928 return 0; 929 930 return softl->ipl_logok[unit]; 931 } 932 #endif /* IPFILTER_LOG */ 933
Indexes created Sat Sep 20 22:09:52 GMT 2025