1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * Copyright (c) 2014, 2018 Andrey V. Elsukov <ae@FreeBSD.org> 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Heiko W.Rupp <hwr@pilhuhn.de> 10 * 11 * IPv6-over-GRE contributed by Gert Doering <gert@greenie.muc.de> 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 * 34 * $NetBSD: if_gre.c,v 1.49 2003/12/11 00:22:29 itojun Exp $ 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include "opt_inet.h" 41 #include "opt_inet6.h" 42 43 #include <sys/param.h> 44 #include <sys/kernel.h> 45 #include <sys/lock.h> 46 #include <sys/malloc.h> 47 #include <sys/module.h> 48 #include <sys/mbuf.h> 49 #include <sys/priv.h> 50 #include <sys/proc.h> 51 #include <sys/socket.h> 52 #include <sys/sockio.h> 53 #include <sys/sx.h> 54 #include <sys/sysctl.h> 55 #include <sys/syslog.h> 56 #include <sys/systm.h> 57 58 #include <net/ethernet.h> 59 #include <net/if.h> 60 #include <net/if_var.h> 61 #include <net/if_clone.h> 62 #include <net/if_types.h> 63 #include <net/netisr.h> 64 #include <net/vnet.h> 65 #include <net/route.h> 66 67 #include <netinet/in.h> 68 #ifdef INET 69 #include <netinet/in_var.h> 70 #include <netinet/ip.h> 71 #include <netinet/ip_var.h> 72 #endif 73 74 #ifdef INET6 75 #include <netinet/ip6.h> 76 #include <netinet6/in6_var.h> 77 #include <netinet6/ip6_var.h> 78 #endif 79 80 #include <netinet/ip_encap.h> 81 #include <net/bpf.h> 82 #include <net/if_gre.h> 83 84 #include <machine/in_cksum.h> 85 #include <security/mac/mac_framework.h> 86 87 #define GREMTU 1476 88 89 static const char grename[] = "gre"; 90 MALLOC_DEFINE(M_GRE, grename, "Generic Routing Encapsulation"); 91 92 static struct sx gre_ioctl_sx; 93 SX_SYSINIT(gre_ioctl_sx, &gre_ioctl_sx, "gre_ioctl"); 94 95 static int gre_clone_create(struct if_clone *, int, caddr_t); 96 static void gre_clone_destroy(struct ifnet *); 97 static VNET_DEFINE(struct if_clone *, gre_cloner); 98 #define V_gre_cloner VNET(gre_cloner) 99 100 static void gre_qflush(struct ifnet *); 101 static int gre_transmit(struct ifnet *, struct mbuf *); 102 static int gre_ioctl(struct ifnet *, u_long, caddr_t); 103 static int gre_output(struct ifnet *, struct mbuf *, 104 const struct sockaddr *, struct route *); 105 static void gre_delete_tunnel(struct gre_softc *); 106 107 SYSCTL_DECL(_net_link); 108 static SYSCTL_NODE(_net_link, IFT_TUNNEL, gre, CTLFLAG_RW, 0, 109 "Generic Routing Encapsulation"); 110 #ifndef MAX_GRE_NEST 111 /* 112 * This macro controls the default upper limitation on nesting of gre tunnels. 113 * Since, setting a large value to this macro with a careless configuration 114 * may introduce system crash, we don't allow any nestings by default. 115 * If you need to configure nested gre tunnels, you can define this macro 116 * in your kernel configuration file. However, if you do so, please be 117 * careful to configure the tunnels so that it won't make a loop. 118 */ 119 #define MAX_GRE_NEST 1 120 #endif 121 122 static VNET_DEFINE(int, max_gre_nesting) = MAX_GRE_NEST; 123 #define V_max_gre_nesting VNET(max_gre_nesting) 124 SYSCTL_INT(_net_link_gre, OID_AUTO, max_nesting, CTLFLAG_RW | CTLFLAG_VNET, 125 &VNET_NAME(max_gre_nesting), 0, "Max nested tunnels"); 126 127 static void 128 vnet_gre_init(const void *unused __unused) 129 { 130 131 V_gre_cloner = if_clone_simple(grename, gre_clone_create, 132 gre_clone_destroy, 0); 133 #ifdef INET 134 in_gre_init(); 135 #endif 136 #ifdef INET6 137 in6_gre_init(); 138 #endif 139 } 140 VNET_SYSINIT(vnet_gre_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 141 vnet_gre_init, NULL); 142 143 static void 144 vnet_gre_uninit(const void *unused __unused) 145 { 146 147 if_clone_detach(V_gre_cloner); 148 #ifdef INET 149 in_gre_uninit(); 150 #endif 151 #ifdef INET6 152 in6_gre_uninit(); 153 #endif 154 } 155 VNET_SYSUNINIT(vnet_gre_uninit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 156 vnet_gre_uninit, NULL); 157 158 static int 159 gre_clone_create(struct if_clone *ifc, int unit, caddr_t params) 160 { 161 struct gre_softc *sc; 162 163 sc = malloc(sizeof(struct gre_softc), M_GRE, M_WAITOK | M_ZERO); 164 sc->gre_fibnum = curthread->td_proc->p_fibnum; 165 GRE2IFP(sc) = if_alloc(IFT_TUNNEL); 166 GRE2IFP(sc)->if_softc = sc; 167 if_initname(GRE2IFP(sc), grename, unit); 168 169 GRE2IFP(sc)->if_mtu = GREMTU; 170 GRE2IFP(sc)->if_flags = IFF_POINTOPOINT|IFF_MULTICAST; 171 GRE2IFP(sc)->if_output = gre_output; 172 GRE2IFP(sc)->if_ioctl = gre_ioctl; 173 GRE2IFP(sc)->if_transmit = gre_transmit; 174 GRE2IFP(sc)->if_qflush = gre_qflush; 175 GRE2IFP(sc)->if_capabilities |= IFCAP_LINKSTATE; 176 GRE2IFP(sc)->if_capenable |= IFCAP_LINKSTATE; 177 if_attach(GRE2IFP(sc)); 178 bpfattach(GRE2IFP(sc), DLT_NULL, sizeof(u_int32_t)); 179 return (0); 180 } 181 182 static void 183 gre_clone_destroy(struct ifnet *ifp) 184 { 185 struct gre_softc *sc; 186 187 sx_xlock(&gre_ioctl_sx); 188 sc = ifp->if_softc; 189 gre_delete_tunnel(sc); 190 bpfdetach(ifp); 191 if_detach(ifp); 192 ifp->if_softc = NULL; 193 sx_xunlock(&gre_ioctl_sx); 194 195 GRE_WAIT(); 196 if_free(ifp); 197 free(sc, M_GRE); 198 } 199 200 static int 201 gre_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 202 { 203 struct ifreq *ifr = (struct ifreq *)data; 204 struct gre_softc *sc; 205 uint32_t opt; 206 int error; 207 208 switch (cmd) { 209 case SIOCSIFMTU: 210 /* XXX: */ 211 if (ifr->ifr_mtu < 576) 212 return (EINVAL); 213 ifp->if_mtu = ifr->ifr_mtu; 214 return (0); 215 case SIOCSIFADDR: 216 ifp->if_flags |= IFF_UP; 217 case SIOCSIFFLAGS: 218 case SIOCADDMULTI: 219 case SIOCDELMULTI: 220 return (0); 221 case GRESADDRS: 222 case GRESADDRD: 223 case GREGADDRS: 224 case GREGADDRD: 225 case GRESPROTO: 226 case GREGPROTO: 227 return (EOPNOTSUPP); 228 } 229 sx_xlock(&gre_ioctl_sx); 230 sc = ifp->if_softc; 231 if (sc == NULL) { 232 error = ENXIO; 233 goto end; 234 } 235 error = 0; 236 switch (cmd) { 237 case SIOCDIFPHYADDR: 238 if (sc->gre_family == 0) 239 break; 240 gre_delete_tunnel(sc); 241 break; 242 #ifdef INET 243 case SIOCSIFPHYADDR: 244 case SIOCGIFPSRCADDR: 245 case SIOCGIFPDSTADDR: 246 error = in_gre_ioctl(sc, cmd, data); 247 break; 248 #endif 249 #ifdef INET6 250 case SIOCSIFPHYADDR_IN6: 251 case SIOCGIFPSRCADDR_IN6: 252 case SIOCGIFPDSTADDR_IN6: 253 error = in6_gre_ioctl(sc, cmd, data); 254 break; 255 #endif 256 case SIOCGTUNFIB: 257 ifr->ifr_fib = sc->gre_fibnum; 258 break; 259 case SIOCSTUNFIB: 260 if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0) 261 break; 262 if (ifr->ifr_fib >= rt_numfibs) 263 error = EINVAL; 264 else 265 sc->gre_fibnum = ifr->ifr_fib; 266 break; 267 case GRESKEY: 268 case GRESOPTS: 269 if ((error = priv_check(curthread, PRIV_NET_GRE)) != 0) 270 break; 271 if ((error = copyin(ifr_data_get_ptr(ifr), &opt, 272 sizeof(opt))) != 0) 273 break; 274 if (cmd == GRESKEY) { 275 if (sc->gre_key == opt) 276 break; 277 } else if (cmd == GRESOPTS) { 278 if (opt & ~GRE_OPTMASK) { 279 error = EINVAL; 280 break; 281 } 282 if (sc->gre_options == opt) 283 break; 284 } 285 switch (sc->gre_family) { 286 #ifdef INET 287 case AF_INET: 288 in_gre_setopts(sc, cmd, opt); 289 break; 290 #endif 291 #ifdef INET6 292 case AF_INET6: 293 in6_gre_setopts(sc, cmd, opt); 294 break; 295 #endif 296 default: 297 if (cmd == GRESKEY) 298 sc->gre_key = opt; 299 else 300 sc->gre_options = opt; 301 break; 302 } 303 /* 304 * XXX: Do we need to initiate change of interface 305 * state here? 306 */ 307 break; 308 case GREGKEY: 309 error = copyout(&sc->gre_key, ifr_data_get_ptr(ifr), 310 sizeof(sc->gre_key)); 311 break; 312 case GREGOPTS: 313 error = copyout(&sc->gre_options, ifr_data_get_ptr(ifr), 314 sizeof(sc->gre_options)); 315 break; 316 default: 317 error = EINVAL; 318 break; 319 } 320 if (error == 0 && sc->gre_family != 0) { 321 if ( 322 #ifdef INET 323 cmd == SIOCSIFPHYADDR || 324 #endif 325 #ifdef INET6 326 cmd == SIOCSIFPHYADDR_IN6 || 327 #endif 328 0) { 329 ifp->if_drv_flags |= IFF_DRV_RUNNING; 330 if_link_state_change(ifp, LINK_STATE_UP); 331 } 332 } 333 end: 334 sx_xunlock(&gre_ioctl_sx); 335 return (error); 336 } 337 338 static void 339 gre_delete_tunnel(struct gre_softc *sc) 340 { 341 342 sx_assert(&gre_ioctl_sx, SA_XLOCKED); 343 if (sc->gre_family != 0) { 344 CK_LIST_REMOVE(sc, chain); 345 GRE_WAIT(); 346 free(sc->gre_hdr, M_GRE); 347 sc->gre_family = 0; 348 } 349 GRE2IFP(sc)->if_drv_flags &= ~IFF_DRV_RUNNING; 350 if_link_state_change(GRE2IFP(sc), LINK_STATE_DOWN); 351 } 352 353 struct gre_list * 354 gre_hashinit(void) 355 { 356 struct gre_list *hash; 357 int i; 358 359 hash = malloc(sizeof(struct gre_list) * GRE_HASH_SIZE, 360 M_GRE, M_WAITOK); 361 for (i = 0; i < GRE_HASH_SIZE; i++) 362 CK_LIST_INIT(&hash[i]); 363 364 return (hash); 365 } 366 367 void 368 gre_hashdestroy(struct gre_list *hash) 369 { 370 371 free(hash, M_GRE); 372 } 373 374 void 375 gre_updatehdr(struct gre_softc *sc, struct grehdr *gh) 376 { 377 uint32_t *opts; 378 uint16_t flags; 379 380 sx_assert(&gre_ioctl_sx, SA_XLOCKED); 381 382 flags = 0; 383 opts = gh->gre_opts; 384 if (sc->gre_options & GRE_ENABLE_CSUM) { 385 flags |= GRE_FLAGS_CP; 386 sc->gre_hlen += 2 * sizeof(uint16_t); 387 *opts++ = 0; 388 } 389 if (sc->gre_key != 0) { 390 flags |= GRE_FLAGS_KP; 391 sc->gre_hlen += sizeof(uint32_t); 392 *opts++ = htonl(sc->gre_key); 393 } 394 if (sc->gre_options & GRE_ENABLE_SEQ) { 395 flags |= GRE_FLAGS_SP; 396 sc->gre_hlen += sizeof(uint32_t); 397 *opts++ = 0; 398 } else 399 sc->gre_oseq = 0; 400 gh->gre_flags = htons(flags); 401 } 402 403 int 404 gre_input(struct mbuf *m, int off, int proto, void *arg) 405 { 406 struct gre_softc *sc = arg; 407 struct grehdr *gh; 408 struct ifnet *ifp; 409 uint32_t *opts; 410 #ifdef notyet 411 uint32_t key; 412 #endif 413 uint16_t flags; 414 int hlen, isr, af; 415 416 ifp = GRE2IFP(sc); 417 hlen = off + sizeof(struct grehdr) + 4 * sizeof(uint32_t); 418 if (m->m_pkthdr.len < hlen) 419 goto drop; 420 if (m->m_len < hlen) { 421 m = m_pullup(m, hlen); 422 if (m == NULL) 423 goto drop; 424 } 425 gh = (struct grehdr *)mtodo(m, off); 426 flags = ntohs(gh->gre_flags); 427 if (flags & ~GRE_FLAGS_MASK) 428 goto drop; 429 opts = gh->gre_opts; 430 hlen = 2 * sizeof(uint16_t); 431 if (flags & GRE_FLAGS_CP) { 432 /* reserved1 field must be zero */ 433 if (((uint16_t *)opts)[1] != 0) 434 goto drop; 435 if (in_cksum_skip(m, m->m_pkthdr.len, off) != 0) 436 goto drop; 437 hlen += 2 * sizeof(uint16_t); 438 opts++; 439 } 440 if (flags & GRE_FLAGS_KP) { 441 #ifdef notyet 442 /* 443 * XXX: The current implementation uses the key only for outgoing 444 * packets. But we can check the key value here, or even in the 445 * encapcheck function. 446 */ 447 key = ntohl(*opts); 448 #endif 449 hlen += sizeof(uint32_t); 450 opts++; 451 } 452 #ifdef notyet 453 } else 454 key = 0; 455 456 if (sc->gre_key != 0 && (key != sc->gre_key || key != 0)) 457 goto drop; 458 #endif 459 if (flags & GRE_FLAGS_SP) { 460 #ifdef notyet 461 seq = ntohl(*opts); 462 #endif 463 hlen += sizeof(uint32_t); 464 } 465 switch (ntohs(gh->gre_proto)) { 466 case ETHERTYPE_WCCP: 467 /* 468 * For WCCP skip an additional 4 bytes if after GRE header 469 * doesn't follow an IP header. 470 */ 471 if (flags == 0 && (*(uint8_t *)gh->gre_opts & 0xF0) != 0x40) 472 hlen += sizeof(uint32_t); 473 /* FALLTHROUGH */ 474 case ETHERTYPE_IP: 475 isr = NETISR_IP; 476 af = AF_INET; 477 break; 478 case ETHERTYPE_IPV6: 479 isr = NETISR_IPV6; 480 af = AF_INET6; 481 break; 482 default: 483 goto drop; 484 } 485 m_adj(m, off + hlen); 486 m_clrprotoflags(m); 487 m->m_pkthdr.rcvif = ifp; 488 M_SETFIB(m, ifp->if_fib); 489 #ifdef MAC 490 mac_ifnet_create_mbuf(ifp, m); 491 #endif 492 BPF_MTAP2(ifp, &af, sizeof(af), m); 493 if_inc_counter(ifp, IFCOUNTER_IPACKETS, 1); 494 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 495 if ((ifp->if_flags & IFF_MONITOR) != 0) 496 m_freem(m); 497 else 498 netisr_dispatch(isr, m); 499 return (IPPROTO_DONE); 500 drop: 501 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 502 m_freem(m); 503 return (IPPROTO_DONE); 504 } 505 506 #define MTAG_GRE 1307983903 507 static int 508 gre_check_nesting(struct ifnet *ifp, struct mbuf *m) 509 { 510 struct m_tag *mtag; 511 int count; 512 513 count = 1; 514 mtag = NULL; 515 while ((mtag = m_tag_locate(m, MTAG_GRE, 0, mtag)) != NULL) { 516 if (*(struct ifnet **)(mtag + 1) == ifp) { 517 log(LOG_NOTICE, "%s: loop detected\n", ifp->if_xname); 518 return (EIO); 519 } 520 count++; 521 } 522 if (count > V_max_gre_nesting) { 523 log(LOG_NOTICE, 524 "%s: if_output recursively called too many times(%d)\n", 525 ifp->if_xname, count); 526 return (EIO); 527 } 528 mtag = m_tag_alloc(MTAG_GRE, 0, sizeof(struct ifnet *), M_NOWAIT); 529 if (mtag == NULL) 530 return (ENOMEM); 531 *(struct ifnet **)(mtag + 1) = ifp; 532 m_tag_prepend(m, mtag); 533 return (0); 534 } 535 536 static int 537 gre_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst, 538 struct route *ro) 539 { 540 uint32_t af; 541 542 if (dst->sa_family == AF_UNSPEC) 543 bcopy(dst->sa_data, &af, sizeof(af)); 544 else 545 af = dst->sa_family; 546 /* 547 * Now save the af in the inbound pkt csum data, this is a cheat since 548 * we are using the inbound csum_data field to carry the af over to 549 * the gre_transmit() routine, avoiding using yet another mtag. 550 */ 551 m->m_pkthdr.csum_data = af; 552 return (ifp->if_transmit(ifp, m)); 553 } 554 555 static void 556 gre_setseqn(struct grehdr *gh, uint32_t seq) 557 { 558 uint32_t *opts; 559 uint16_t flags; 560 561 opts = gh->gre_opts; 562 flags = ntohs(gh->gre_flags); 563 KASSERT((flags & GRE_FLAGS_SP) != 0, 564 ("gre_setseqn called, but GRE_FLAGS_SP isn't set ")); 565 if (flags & GRE_FLAGS_CP) 566 opts++; 567 if (flags & GRE_FLAGS_KP) 568 opts++; 569 *opts = htonl(seq); 570 } 571 572 static int 573 gre_transmit(struct ifnet *ifp, struct mbuf *m) 574 { 575 struct gre_softc *sc; 576 struct grehdr *gh; 577 uint32_t af; 578 int error, len; 579 uint16_t proto; 580 581 len = 0; 582 #ifdef MAC 583 error = mac_ifnet_check_transmit(ifp, m); 584 if (error) { 585 m_freem(m); 586 goto drop; 587 } 588 #endif 589 error = ENETDOWN; 590 GRE_RLOCK(); 591 sc = ifp->if_softc; 592 if ((ifp->if_flags & IFF_MONITOR) != 0 || 593 (ifp->if_flags & IFF_UP) == 0 || 594 sc->gre_family == 0 || 595 (error = gre_check_nesting(ifp, m)) != 0) { 596 m_freem(m); 597 goto drop; 598 } 599 af = m->m_pkthdr.csum_data; 600 M_SETFIB(m, sc->gre_fibnum); 601 M_PREPEND(m, sc->gre_hlen, M_NOWAIT); 602 if (m == NULL) { 603 error = ENOBUFS; 604 goto drop; 605 } 606 bcopy(sc->gre_hdr, mtod(m, void *), sc->gre_hlen); 607 /* Determine GRE proto */ 608 switch (af) { 609 #ifdef INET 610 case AF_INET: 611 proto = htons(ETHERTYPE_IP); 612 break; 613 #endif 614 #ifdef INET6 615 case AF_INET6: 616 proto = htons(ETHERTYPE_IPV6); 617 break; 618 #endif 619 default: 620 m_freem(m); 621 error = ENETDOWN; 622 goto drop; 623 } 624 /* Determine offset of GRE header */ 625 switch (sc->gre_family) { 626 #ifdef INET 627 case AF_INET: 628 len = sizeof(struct ip); 629 break; 630 #endif 631 #ifdef INET6 632 case AF_INET6: 633 len = sizeof(struct ip6_hdr); 634 break; 635 #endif 636 default: 637 m_freem(m); 638 error = ENETDOWN; 639 goto drop; 640 } 641 gh = (struct grehdr *)mtodo(m, len); 642 gh->gre_proto = proto; 643 if (sc->gre_options & GRE_ENABLE_SEQ) 644 gre_setseqn(gh, sc->gre_oseq++); 645 if (sc->gre_options & GRE_ENABLE_CSUM) { 646 *(uint16_t *)gh->gre_opts = in_cksum_skip(m, 647 m->m_pkthdr.len, len); 648 } 649 len = m->m_pkthdr.len - len; 650 switch (sc->gre_family) { 651 #ifdef INET 652 case AF_INET: 653 error = in_gre_output(m, af, sc->gre_hlen); 654 break; 655 #endif 656 #ifdef INET6 657 case AF_INET6: 658 error = in6_gre_output(m, af, sc->gre_hlen); 659 break; 660 #endif 661 default: 662 m_freem(m); 663 error = ENETDOWN; 664 } 665 drop: 666 if (error) 667 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 668 else { 669 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 670 if_inc_counter(ifp, IFCOUNTER_OBYTES, len); 671 } 672 GRE_RUNLOCK(); 673 return (error); 674 } 675 676 static void 677 gre_qflush(struct ifnet *ifp __unused) 678 { 679 680 } 681 682 static int 683 gremodevent(module_t mod, int type, void *data) 684 { 685 686 switch (type) { 687 case MOD_LOAD: 688 case MOD_UNLOAD: 689 break; 690 default: 691 return (EOPNOTSUPP); 692 } 693 return (0); 694 } 695 696 static moduledata_t gre_mod = { 697 "if_gre", 698 gremodevent, 699 0 700 }; 701 702 DECLARE_MODULE(if_gre, gre_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 703 MODULE_VERSION(if_gre, 1); 704