sys/net/pf/if_pflog.c

   1 /*      $OpenBSD: if_pflog.c,v 1.24 2007/05/26 17:13:30 jason Exp $     */
   2 /*
   3  * The authors of this code are John Ioannidis (ji@tla.org),
   4  * Angelos D. Keromytis (kermit@csd.uch.gr) and
   5  * Niels Provos (provos@physnet.uni-hamburg.de).
   6  *
   7  * This code was written by John Ioannidis for BSD/OS in Athens, Greece,
   8  * in November 1995.
   9  *
  10  * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996,
  11  * by Angelos D. Keromytis.
  12  *
  13  * Additional transforms and features in 1997 and 1998 by Angelos D. Keromytis
  14  * and Niels Provos.
  15  *
  16  * Copyright (C) 1995, 1996, 1997, 1998 by John Ioannidis, Angelos D. Keromytis
  17  * and Niels Provos.
  18  * Copyright (c) 2001, Angelos D. Keromytis, Niels Provos.
  19  *
  20  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
  21  *
  22  * Permission to use, copy, and modify this software with or without fee
  23  * is hereby granted, provided that this entire notice is included in
  24  * all copies of any software which is or includes a copy or
  25  * modification of this software.
  26  * You may use this code under the GNU public license if you so wish. Please
  27  * contribute changes back to the authors under this freer than GPL license
  28  * so that we may further the use of strong encryption without limitations to
  29  * all.
  30  *
  31  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  32  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  33  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  34  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  35  * PURPOSE.
  36  */
  37
  38 #include "opt_inet.h"
  39 #include "opt_inet6.h"
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/in_cksum.h>
  44 #include <sys/mbuf.h>
  45 #include <sys/proc.h>
  46 #include <sys/socket.h>
  47 #include <sys/kernel.h>
  48 #include <sys/malloc.h>
  49 #include <sys/module.h>
  50 #include <sys/sockio.h>
  51 #include <sys/thread2.h>
  52 #include <vm/vm_zone.h>
  53
  54 #include <net/if.h>
  55 #include <net/if_types.h>
  56 #include <net/route.h>
  57 #include <net/bpf.h>
  58
  59 #ifdef  INET
  60 #include <netinet/in.h>
  61 #include <netinet/in_var.h>
  62 #include <netinet/in_systm.h>
  63 #include <netinet/ip.h>
  64 #endif
  65
  66 #ifdef INET6
  67 #ifndef INET
  68 #include <netinet/in.h>
  69 #endif
  70 #include <netinet6/nd6.h>
  71 #endif /* INET6 */
  72
  73 #include <net/pf/pfvar.h>
  74 #include <net/pf/if_pflog.h>
  75
  76 #define PFLOGNAME       "pflog"
  77
  78 #define PFLOGMTU        (32768 + MHLEN + MLEN)
  79
  80 #ifdef PFLOGDEBUG
  81 #define DPRINTF(x)    do { if (pflogdebug) kprintf x ; } while (0)
  82 #else
  83 #define DPRINTF(x)
  84 #endif
  85
  86 void    pflogattach(int);
  87 int     pflogoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
  88                        struct rtentry *);
  89 int     pflogioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
  90 void    pflogrtrequest(int, struct rtentry *, struct sockaddr *);
  91 void    pflogstart(struct ifnet *);
  92 int     pflog_clone_create(struct if_clone *, int, caddr_t);
  93 void pflog_clone_destroy(struct ifnet *);
  94
  95 LIST_HEAD(, pflog_softc)        pflogif_list;
  96 struct if_clone pflog_cloner =
  97     IF_CLONE_INITIALIZER("pflog", pflog_clone_create, pflog_clone_destroy, 1, 1);
  98
  99 struct ifnet    *pflogifs[PFLOGIFS_MAX];        /* for fast access */
 100
 101 void
 102 pflogattach(int npflog)
 103 {
 104         int     i;
 105         LIST_INIT(&pflogif_list);
 106         for (i = 0; i < PFLOGIFS_MAX; i++)
 107                 pflogifs[i] = NULL;
 108         if_clone_attach(&pflog_cloner);
 109 }
 110
 111 int
 112 pflog_clone_create(struct if_clone *ifc, int unit, caddr_t param __unused)
 113 {
 114         struct ifnet *ifp;
 115         struct pflog_softc *pflogif;
 116
 117         lwkt_gettoken(&pf_token);
 118
 119         if (unit >= PFLOGIFS_MAX) {
 120                 lwkt_reltoken(&pf_token);
 121                 return (EINVAL);
 122         }
 123
 124         if ((pflogif = kmalloc(sizeof(*pflogif), M_DEVBUF, M_WAITOK)) == NULL) {
 125                 lwkt_reltoken(&pf_token);
 126                 return (ENOMEM);
 127         }
 128         bzero(pflogif, sizeof(*pflogif));
 129
 130         pflogif->sc_unit = unit;
 131         lwkt_reltoken(&pf_token);
 132         ifp = &pflogif->sc_if;
 133         ksnprintf(ifp->if_xname, sizeof ifp->if_xname, "pflog%d", unit);
 134         ifp->if_softc = pflogif;
 135         ifp->if_mtu = PFLOGMTU;
 136         ifp->if_ioctl = pflogioctl;
 137         ifp->if_output = pflogoutput;
 138         ifp->if_start = pflogstart;
 139         ifp->if_type = IFT_PFLOG;
 140         ifp->if_snd.ifq_maxlen = ifqmaxlen;
 141         ifp->if_hdrlen = PFLOG_HDRLEN;
 142         if_attach(ifp, NULL);
 143
 144         bpfattach(&pflogif->sc_if, DLT_PFLOG, PFLOG_HDRLEN);
 145         lwkt_gettoken(&pf_token);
 146
 147         crit_enter();
 148         LIST_INSERT_HEAD(&pflogif_list, pflogif, sc_list);
 149         pflogifs[unit] = ifp;
 150         crit_exit();
 151
 152         lwkt_reltoken(&pf_token);
 153         return (0);
 154 }
 155
 156 void
 157 pflog_clone_destroy(struct ifnet *ifp)
 158 {
 159         struct pflog_softc      *pflogif = ifp->if_softc;
 160
 161         lwkt_gettoken(&pf_token);
 162
 163         crit_enter();
 164         pflogifs[pflogif->sc_unit] = NULL;
 165         LIST_REMOVE(pflogif, sc_list);
 166         crit_exit();
 167
 168         lwkt_reltoken(&pf_token);
 169 #if NBPFILTER > 0
 170         bpfdetach(ifp);
 171 #endif
 172         if_detach(ifp);
 173         lwkt_gettoken(&pf_token);
 174         kfree(pflogif, M_DEVBUF);
 175         lwkt_reltoken(&pf_token);
 176 }
 177
 178 /*
 179  * Start output on the pflog interface.
 180  */
 181 void
 182 pflogstart(struct ifnet *ifp)
 183 {
 184         struct mbuf *m;
 185
 186         ASSERT_LWKT_TOKEN_HELD(&pf_token);
 187
 188         for (;;) {
 189                 lwkt_reltoken(&pf_token);
 190                 crit_enter();
 191                 IF_DROP(&ifp->if_snd);
 192                 IF_DEQUEUE(&ifp->if_snd, m);
 193                 crit_exit();
 194                 lwkt_gettoken(&pf_token);
 195
 196                 if (m == NULL)
 197                         return;
 198                 else
 199                         m_freem(m);
 200         }
 201 }
 202
 203 int
 204 pflogoutput(struct ifnet *ifp, struct mbuf *m, struct sockaddr *dst,
 205         struct rtentry *rt)
 206 {
 207         m_freem(m);
 208         return (0);
 209 }
 210
 211 /* ARGSUSED */
 212 void
 213 pflogrtrequest(int cmd, struct rtentry *rt, struct sockaddr *sa)
 214 {
 215         if (rt)
 216                 rt->rt_rmx.rmx_mtu = PFLOGMTU;
 217 }
 218
 219 /* ARGSUSED */
 220 int
 221 pflogioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 222 {
 223
 224         lwkt_gettoken(&pf_token);
 225
 226         switch (cmd) {
 227         case SIOCSIFADDR:
 228         case SIOCAIFADDR:
 229         case SIOCSIFDSTADDR:
 230         case SIOCSIFFLAGS:
 231                 lwkt_reltoken(&pf_token);
 232                 if (ifp->if_flags & IFF_UP)
 233                         ifp->if_flags |= IFF_RUNNING;
 234                 else
 235                         ifp->if_flags &= ~IFF_RUNNING;
 236                 lwkt_gettoken(&pf_token);
 237                 break;
 238         default:
 239                 lwkt_reltoken(&pf_token);
 240                 return (EINVAL);
 241         }
 242
 243         lwkt_reltoken(&pf_token);
 244         return (0);
 245 }
 246
 247 int
 248 pflog_packet(struct pfi_kif *kif, struct mbuf *m, sa_family_t af, u_int8_t dir,
 249     u_int8_t reason, struct pf_rule *rm, struct pf_rule *am,
 250     struct pf_ruleset *ruleset, struct pf_pdesc *pd)
 251 {
 252         struct ifnet *ifn = NULL;
 253         struct pfloghdr hdr;
 254
 255         ASSERT_LWKT_TOKEN_HELD(&pf_token);
 256
 257         if (kif == NULL || m == NULL || rm == NULL)
 258                 return (-1);
 259
 260         if ((ifn = pflogifs[rm->logif]) == NULL || !ifn->if_bpf)
 261                 return (0);
 262
 263         bzero(&hdr, sizeof(hdr));
 264         hdr.length = PFLOG_REAL_HDRLEN;
 265         hdr.af = af;
 266         hdr.action = rm->action;
 267         hdr.reason = reason;
 268         memcpy(hdr.ifname, kif->pfik_name, sizeof(hdr.ifname));
 269
 270         if (am == NULL) {
 271                 hdr.rulenr = htonl(rm->nr);
 272                 hdr.subrulenr = -1;
 273         } else {
 274                 hdr.rulenr = htonl(am->nr);
 275                 hdr.subrulenr = htonl(rm->nr);
 276                 if (ruleset != NULL && ruleset->anchor != NULL)
 277                         strlcpy(hdr.ruleset, ruleset->anchor->name,
 278                             sizeof(hdr.ruleset));
 279         }
 280         if (rm->log & PF_LOG_SOCKET_LOOKUP && !pd->lookup.done)
 281                 pd->lookup.done = pf_socket_lookup(dir, pd);
 282         if (pd->lookup.done > 0) {
 283                 hdr.uid = pd->lookup.uid;
 284                 hdr.pid = pd->lookup.pid;
 285         } else {
 286                 hdr.uid = UID_MAX;
 287                 hdr.pid = NO_PID;
 288         }
 289         hdr.rule_uid = rm->cuid;
 290         hdr.rule_pid = rm->cpid;
 291         hdr.dir = dir;
 292
 293 #ifdef INET
 294         if (af == AF_INET) {
 295                 struct ip *ip;
 296                 ip = mtod(m, struct ip *);
 297                 ip->ip_len = htons(ip->ip_len);
 298                 ip->ip_off = htons(ip->ip_off);
 299
 300                 if (dir == PF_OUT) {
 301                         ip->ip_sum = 0;
 302                         ip->ip_sum = in_cksum(m, ip->ip_hl << 2);
 303                 }
 304         }
 305 #endif /* INET */
 306
 307         ifn->if_opackets++;
 308         ifn->if_obytes += m->m_pkthdr.len;
 309         lwkt_reltoken(&pf_token);
 310         bpf_mtap_hdr(ifn->if_bpf, (char *)&hdr, PFLOG_HDRLEN, m,
 311             BPF_DIRECTION_OUT);
 312         lwkt_gettoken(&pf_token);
 313
 314 #ifdef INET
 315         if (af == AF_INET) {
 316                 struct ip *ip = mtod(m, struct ip *);
 317
 318                 ip->ip_len = ntohs(ip->ip_len);
 319                 ip->ip_off = ntohs(ip->ip_off);
 320         }
 321 #endif /* INET */
 322
 323         return (0);
 324 }
 325
 326 static int
 327 pflog_modevent(module_t mod, int type, void *data)
 328 {
 329         int error = 0;
 330
 331         lwkt_gettoken(&pf_token);
 332
 333         switch (type) {
 334         case MOD_LOAD:
 335                 LIST_INIT(&pflogif_list);
 336                 lwkt_reltoken(&pf_token);
 337                 if_clone_attach(&pflog_cloner);
 338                 lwkt_gettoken(&pf_token);
 339                 break;
 340
 341         case MOD_UNLOAD:
 342                 lwkt_reltoken(&pf_token);
 343                 if_clone_detach(&pflog_cloner);
 344                 while (!LIST_EMPTY(&pflogif_list)) {
 345                         pflog_clone_destroy(
 346                                 &LIST_FIRST(&pflogif_list)->sc_if);
 347                 }
 348                 lwkt_gettoken(&pf_token);
 349                 break;
 350
 351         default:
 352                 error = EINVAL;
 353                 break;
 354         }
 355         lwkt_reltoken(&pf_token);
 356         return error;
 357 }
 358
 359 static moduledata_t pflog_mod = {
 360         "pflog",
 361         pflog_modevent,
 362         0
 363 };
 364
 365 #define PFLOG_MODVER 1
 366
 367 DECLARE_MODULE(pflog, pflog_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
 368 MODULE_VERSION(pflog, PFLOG_MODVER);