sys/netpfil/ipfw/ip_fw_nat.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2008 Paolo Pisati
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/eventhandler.h>
  35 #include <sys/malloc.h>
  36 #include <sys/mbuf.h>
  37 #include <sys/kernel.h>
  38 #include <sys/lock.h>
  39 #include <sys/module.h>
  40 #include <sys/rwlock.h>
  41 #include <sys/rmlock.h>
  42
  43 #include <netinet/libalias/alias.h>
  44 #include <netinet/libalias/alias_local.h>
  45
  46 #include <net/if.h>
  47 #include <net/if_var.h>
  48 #include <netinet/in.h>
  49 #include <netinet/ip.h>
  50 #include <netinet/ip_var.h>
  51 #include <netinet/ip_fw.h>
  52 #include <netinet/tcp.h>
  53 #include <netinet/udp.h>
  54
  55 #include <netpfil/ipfw/ip_fw_private.h>
  56
  57 #include <machine/in_cksum.h>   /* XXX for in_cksum */
  58
  59 struct cfg_spool {
  60         LIST_ENTRY(cfg_spool)   _next;          /* chain of spool instances */
  61         struct in_addr          addr;
  62         uint16_t                port;
  63 };
  64
  65 /* Nat redirect configuration. */
  66 struct cfg_redir {
  67         LIST_ENTRY(cfg_redir)   _next;  /* chain of redir instances */
  68         uint16_t                mode;   /* type of redirect mode */
  69         uint16_t                proto;  /* protocol: tcp/udp */
  70         struct in_addr          laddr;  /* local ip address */
  71         struct in_addr          paddr;  /* public ip address */
  72         struct in_addr          raddr;  /* remote ip address */
  73         uint16_t                lport;  /* local port */
  74         uint16_t                pport;  /* public port */
  75         uint16_t                rport;  /* remote port  */
  76         uint16_t                pport_cnt;      /* number of public ports */
  77         uint16_t                rport_cnt;      /* number of remote ports */
  78         struct alias_link       **alink;
  79         u_int16_t               spool_cnt; /* num of entry in spool chain */
  80         /* chain of spool instances */
  81         LIST_HEAD(spool_chain, cfg_spool) spool_chain;
  82 };
  83
  84 /* Nat configuration data struct. */
  85 struct cfg_nat {
  86         /* chain of nat instances */
  87         LIST_ENTRY(cfg_nat)     _next;
  88         int                     id;             /* nat id  */
  89         struct in_addr          ip;             /* nat ip address */
  90         struct libalias         *lib;           /* libalias instance */
  91         int                     mode;           /* aliasing mode */
  92         int                     redir_cnt; /* number of entry in spool chain */
  93         /* chain of redir instances */
  94         LIST_HEAD(redir_chain, cfg_redir) redir_chain;
  95         char                    if_name[IF_NAMESIZE];   /* interface name */
  96 };
  97
  98 static eventhandler_tag ifaddr_event_tag;
  99
 100 static void
 101 ifaddr_change(void *arg __unused, struct ifnet *ifp)
 102 {
 103         struct cfg_nat *ptr;
 104         struct ifaddr *ifa;
 105         struct ip_fw_chain *chain;
 106
 107         KASSERT(curvnet == ifp->if_vnet,
 108             ("curvnet(%p) differs from iface vnet(%p)", curvnet, ifp->if_vnet));
 109
 110         if (V_ipfw_vnet_ready == 0 || V_ipfw_nat_ready == 0)
 111                 return;
 112
 113         chain = &V_layer3_chain;
 114         IPFW_UH_WLOCK(chain);
 115         /* Check every nat entry... */
 116         LIST_FOREACH(ptr, &chain->nat, _next) {
 117                 struct epoch_tracker et;
 118
 119                 /* ...using nic 'ifp->if_xname' as dynamic alias address. */
 120                 if (strncmp(ptr->if_name, ifp->if_xname, IF_NAMESIZE) != 0)
 121                         continue;
 122                 NET_EPOCH_ENTER(et);
 123                 CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
 124                         if (ifa->ifa_addr == NULL)
 125                                 continue;
 126                         if (ifa->ifa_addr->sa_family != AF_INET)
 127                                 continue;
 128                         IPFW_WLOCK(chain);
 129                         ptr->ip = ((struct sockaddr_in *)
 130                             (ifa->ifa_addr))->sin_addr;
 131                         LibAliasSetAddress(ptr->lib, ptr->ip);
 132                         IPFW_WUNLOCK(chain);
 133                 }
 134                 NET_EPOCH_EXIT(et);
 135         }
 136         IPFW_UH_WUNLOCK(chain);
 137 }
 138
 139 /*
 140  * delete the pointers for nat entry ix, or all of them if ix < 0
 141  */
 142 static void
 143 flush_nat_ptrs(struct ip_fw_chain *chain, const int ix)
 144 {
 145         ipfw_insn_nat *cmd;
 146         int i;
 147
 148         IPFW_WLOCK_ASSERT(chain);
 149         for (i = 0; i < chain->n_rules; i++) {
 150                 cmd = (ipfw_insn_nat *)ipfw_get_action(chain->map[i]);
 151                 if (cmd->o.opcode == O_NAT && cmd->nat != NULL &&
 152                             (ix < 0 || cmd->nat->id == ix))
 153                         cmd->nat = NULL;
 154         }
 155 }
 156
 157 static void
 158 del_redir_spool_cfg(struct cfg_nat *n, struct redir_chain *head)
 159 {
 160         struct cfg_redir *r, *tmp_r;
 161         struct cfg_spool *s, *tmp_s;
 162         int i, num;
 163
 164         LIST_FOREACH_SAFE(r, head, _next, tmp_r) {
 165                 num = 1; /* Number of alias_link to delete. */
 166                 switch (r->mode) {
 167                 case NAT44_REDIR_PORT:
 168                         num = r->pport_cnt;
 169                         /* FALLTHROUGH */
 170                 case NAT44_REDIR_ADDR:
 171                 case NAT44_REDIR_PROTO:
 172                         /* Delete all libalias redirect entry. */
 173                         for (i = 0; i < num; i++)
 174                                 LibAliasRedirectDelete(n->lib, r->alink[i]);
 175                         /* Del spool cfg if any. */
 176                         LIST_FOREACH_SAFE(s, &r->spool_chain, _next, tmp_s) {
 177                                 LIST_REMOVE(s, _next);
 178                                 free(s, M_IPFW);
 179                         }
 180                         free(r->alink, M_IPFW);
 181                         LIST_REMOVE(r, _next);
 182                         free(r, M_IPFW);
 183                         break;
 184                 default:
 185                         printf("unknown redirect mode: %u\n", r->mode);
 186                         /* XXX - panic?!?!? */
 187                         break;
 188                 }
 189         }
 190 }
 191
 192 static int
 193 add_redir_spool_cfg(char *buf, struct cfg_nat *ptr)
 194 {
 195         struct cfg_redir *r;
 196         struct cfg_spool *s;
 197         struct nat44_cfg_redir *ser_r;
 198         struct nat44_cfg_spool *ser_s;
 199
 200         int cnt, off, i;
 201
 202         for (cnt = 0, off = 0; cnt < ptr->redir_cnt; cnt++) {
 203                 ser_r = (struct nat44_cfg_redir *)&buf[off];
 204                 r = malloc(sizeof(*r), M_IPFW, M_WAITOK | M_ZERO);
 205                 r->mode = ser_r->mode;
 206                 r->laddr = ser_r->laddr;
 207                 r->paddr = ser_r->paddr;
 208                 r->raddr = ser_r->raddr;
 209                 r->lport = ser_r->lport;
 210                 r->pport = ser_r->pport;
 211                 r->rport = ser_r->rport;
 212                 r->pport_cnt = ser_r->pport_cnt;
 213                 r->rport_cnt = ser_r->rport_cnt;
 214                 r->proto = ser_r->proto;
 215                 r->spool_cnt = ser_r->spool_cnt;
 216                 //memcpy(r, ser_r, SOF_REDIR);
 217                 LIST_INIT(&r->spool_chain);
 218                 off += sizeof(struct nat44_cfg_redir);
 219                 r->alink = malloc(sizeof(struct alias_link *) * r->pport_cnt,
 220                     M_IPFW, M_WAITOK | M_ZERO);
 221                 switch (r->mode) {
 222                 case NAT44_REDIR_ADDR:
 223                         r->alink[0] = LibAliasRedirectAddr(ptr->lib, r->laddr,
 224                             r->paddr);
 225                         break;
 226                 case NAT44_REDIR_PORT:
 227                         for (i = 0 ; i < r->pport_cnt; i++) {
 228                                 /* If remotePort is all ports, set it to 0. */
 229                                 u_short remotePortCopy = r->rport + i;
 230                                 if (r->rport_cnt == 1 && r->rport == 0)
 231                                         remotePortCopy = 0;
 232                                 r->alink[i] = LibAliasRedirectPort(ptr->lib,
 233                                     r->laddr, htons(r->lport + i), r->raddr,
 234                                     htons(remotePortCopy), r->paddr,
 235                                     htons(r->pport + i), r->proto);
 236                                 if (r->alink[i] == NULL) {
 237                                         r->alink[0] = NULL;
 238                                         break;
 239                                 }
 240                         }
 241                         break;
 242                 case NAT44_REDIR_PROTO:
 243                         r->alink[0] = LibAliasRedirectProto(ptr->lib ,r->laddr,
 244                             r->raddr, r->paddr, r->proto);
 245                         break;
 246                 default:
 247                         printf("unknown redirect mode: %u\n", r->mode);
 248                         break;
 249                 }
 250                 if (r->alink[0] == NULL) {
 251                         printf("LibAliasRedirect* returned NULL\n");
 252                         free(r->alink, M_IPFW);
 253                         free(r, M_IPFW);
 254                         return (EINVAL);
 255                 }
 256                 /* LSNAT handling. */
 257                 for (i = 0; i < r->spool_cnt; i++) {
 258                         ser_s = (struct nat44_cfg_spool *)&buf[off];
 259                         s = malloc(sizeof(*s), M_IPFW, M_WAITOK | M_ZERO);
 260                         s->addr = ser_s->addr;
 261                         s->port = ser_s->port;
 262                         LibAliasAddServer(ptr->lib, r->alink[0],
 263                             s->addr, htons(s->port));
 264                         off += sizeof(struct nat44_cfg_spool);
 265                         /* Hook spool entry. */
 266                         LIST_INSERT_HEAD(&r->spool_chain, s, _next);
 267                 }
 268                 /* And finally hook this redir entry. */
 269                 LIST_INSERT_HEAD(&ptr->redir_chain, r, _next);
 270         }
 271
 272         return (0);
 273 }
 274
 275 static void
 276 free_nat_instance(struct cfg_nat *ptr)
 277 {
 278
 279         del_redir_spool_cfg(ptr, &ptr->redir_chain);
 280         LibAliasUninit(ptr->lib);
 281         free(ptr, M_IPFW);
 282 }
 283
 284
 285 /*
 286  * ipfw_nat - perform mbuf header translation.
 287  *
 288  * Note V_layer3_chain has to be locked while calling ipfw_nat() in
 289  * 'global' operation mode (t == NULL).
 290  *
 291  */
 292 static int
 293 ipfw_nat(struct ip_fw_args *args, struct cfg_nat *t, struct mbuf *m)
 294 {
 295         struct mbuf *mcl;
 296         struct ip *ip;
 297         /* XXX - libalias duct tape */
 298         int ldt, retval, found;
 299         struct ip_fw_chain *chain;
 300         char *c;
 301
 302         ldt = 0;
 303         retval = 0;
 304         mcl = m_megapullup(m, m->m_pkthdr.len);
 305         if (mcl == NULL) {
 306                 args->m = NULL;
 307                 return (IP_FW_DENY);
 308         }
 309         ip = mtod(mcl, struct ip *);
 310
 311         /*
 312          * XXX - Libalias checksum offload 'duct tape':
 313          *
 314          * locally generated packets have only pseudo-header checksum
 315          * calculated and libalias will break it[1], so mark them for
 316          * later fix.  Moreover there are cases when libalias modifies
 317          * tcp packet data[2], mark them for later fix too.
 318          *
 319          * [1] libalias was never meant to run in kernel, so it does
 320          * not have any knowledge about checksum offloading, and
 321          * expects a packet with a full internet checksum.
 322          * Unfortunately, packets generated locally will have just the
 323          * pseudo header calculated, and when libalias tries to adjust
 324          * the checksum it will actually compute a wrong value.
 325          *
 326          * [2] when libalias modifies tcp's data content, full TCP
 327          * checksum has to be recomputed: the problem is that
 328          * libalias does not have any idea about checksum offloading.
 329          * To work around this, we do not do checksumming in LibAlias,
 330          * but only mark the packets in th_x2 field. If we receive a
 331          * marked packet, we calculate correct checksum for it
 332          * aware of offloading.  Why such a terrible hack instead of
 333          * recalculating checksum for each packet?
 334          * Because the previous checksum was not checked!
 335          * Recalculating checksums for EVERY packet will hide ALL
 336          * transmission errors. Yes, marked packets still suffer from
 337          * this problem. But, sigh, natd(8) has this problem, too.
 338          *
 339          * TODO: -make libalias mbuf aware (so
 340          * it can handle delayed checksum and tso)
 341          */
 342
 343         if (mcl->m_pkthdr.rcvif == NULL &&
 344             mcl->m_pkthdr.csum_flags & CSUM_DELAY_DATA)
 345                 ldt = 1;
 346
 347         c = mtod(mcl, char *);
 348
 349         /* Check if this is 'global' instance */
 350         if (t == NULL) {
 351                 if (args->flags & IPFW_ARGS_IN) {
 352                         /* Wrong direction, skip processing */
 353                         args->m = mcl;
 354                         return (IP_FW_NAT);
 355                 }
 356
 357                 found = 0;
 358                 chain = &V_layer3_chain;
 359                 IPFW_RLOCK_ASSERT(chain);
 360                 /* Check every nat entry... */
 361                 LIST_FOREACH(t, &chain->nat, _next) {
 362                         if ((t->mode & PKT_ALIAS_SKIP_GLOBAL) != 0)
 363                                 continue;
 364                         retval = LibAliasOutTry(t->lib, c,
 365                             mcl->m_len + M_TRAILINGSPACE(mcl), 0);
 366                         if (retval == PKT_ALIAS_OK) {
 367                                 /* Nat instance recognises state */
 368                                 found = 1;
 369                                 break;
 370                         }
 371                 }
 372                 if (found != 1) {
 373                         /* No instance found, return ignore */
 374                         args->m = mcl;
 375                         return (IP_FW_NAT);
 376                 }
 377         } else {
 378                 if (args->flags & IPFW_ARGS_IN)
 379                         retval = LibAliasIn(t->lib, c,
 380                                 mcl->m_len + M_TRAILINGSPACE(mcl));
 381                 else
 382                         retval = LibAliasOut(t->lib, c,
 383                                 mcl->m_len + M_TRAILINGSPACE(mcl));
 384         }
 385
 386         /*
 387          * We drop packet when:
 388          * 1. libalias returns PKT_ALIAS_ERROR;
 389          * 2. For incoming packets:
 390          *      a) for unresolved fragments;
 391          *      b) libalias returns PKT_ALIAS_IGNORED and
 392          *              PKT_ALIAS_DENY_INCOMING flag is set.
 393          */
 394         if (retval == PKT_ALIAS_ERROR ||
 395             ((args->flags & IPFW_ARGS_IN) &&
 396             (retval == PKT_ALIAS_UNRESOLVED_FRAGMENT ||
 397             (retval == PKT_ALIAS_IGNORED &&
 398             (t->mode & PKT_ALIAS_DENY_INCOMING) != 0)))) {
 399                 /* XXX - should i add some logging? */
 400                 m_free(mcl);
 401                 args->m = NULL;
 402                 return (IP_FW_DENY);
 403         }
 404
 405         if (retval == PKT_ALIAS_RESPOND)
 406                 mcl->m_flags |= M_SKIP_FIREWALL;
 407         mcl->m_pkthdr.len = mcl->m_len = ntohs(ip->ip_len);
 408
 409         /*
 410          * XXX - libalias checksum offload
 411          * 'duct tape' (see above)
 412          */
 413
 414         if ((ip->ip_off & htons(IP_OFFMASK)) == 0 &&
 415             ip->ip_p == IPPROTO_TCP) {
 416                 struct tcphdr   *th;
 417
 418                 th = (struct tcphdr *)(ip + 1);
 419                 if (th->th_x2)
 420                         ldt = 1;
 421         }
 422
 423         if (ldt) {
 424                 struct tcphdr   *th;
 425                 struct udphdr   *uh;
 426                 uint16_t ip_len, cksum;
 427
 428                 ip_len = ntohs(ip->ip_len);
 429                 cksum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
 430                     htons(ip->ip_p + ip_len - (ip->ip_hl << 2)));
 431
 432                 switch (ip->ip_p) {
 433                 case IPPROTO_TCP:
 434                         th = (struct tcphdr *)(ip + 1);
 435                         /*
 436                          * Maybe it was set in
 437                          * libalias...
 438                          */
 439                         th->th_x2 = 0;
 440                         th->th_sum = cksum;
 441                         mcl->m_pkthdr.csum_data =
 442                             offsetof(struct tcphdr, th_sum);
 443                         break;
 444                 case IPPROTO_UDP:
 445                         uh = (struct udphdr *)(ip + 1);
 446                         uh->uh_sum = cksum;
 447                         mcl->m_pkthdr.csum_data =
 448                             offsetof(struct udphdr, uh_sum);
 449                         break;
 450                 }
 451                 /* No hw checksum offloading: do it ourselves */
 452                 if ((mcl->m_pkthdr.csum_flags & CSUM_DELAY_DATA) == 0) {
 453                         in_delayed_cksum(mcl);
 454                         mcl->m_pkthdr.csum_flags &= ~CSUM_DELAY_DATA;
 455                 }
 456         }
 457         args->m = mcl;
 458         return (IP_FW_NAT);
 459 }
 460
 461 static struct cfg_nat *
 462 lookup_nat(struct nat_list *l, int nat_id)
 463 {
 464         struct cfg_nat *res;
 465
 466         LIST_FOREACH(res, l, _next) {
 467                 if (res->id == nat_id)
 468                         break;
 469         }
 470         return res;
 471 }
 472
 473 static struct cfg_nat *
 474 lookup_nat_name(struct nat_list *l, char *name)
 475 {
 476         struct cfg_nat *res;
 477         int id;
 478         char *errptr;
 479
 480         id = strtol(name, &errptr, 10);
 481         if (id == 0 || *errptr != '\0')
 482                 return (NULL);
 483
 484         LIST_FOREACH(res, l, _next) {
 485                 if (res->id == id)
 486                         break;
 487         }
 488         return (res);
 489 }
 490
 491 /* IP_FW3 configuration routines */
 492
 493 static void
 494 nat44_config(struct ip_fw_chain *chain, struct nat44_cfg_nat *ucfg)
 495 {
 496         struct cfg_nat *ptr, *tcfg;
 497         int gencnt;
 498
 499         /*
 500          * Find/create nat rule.
 501          */
 502         IPFW_UH_WLOCK(chain);
 503         gencnt = chain->gencnt;
 504         ptr = lookup_nat_name(&chain->nat, ucfg->name);
 505         if (ptr == NULL) {
 506                 IPFW_UH_WUNLOCK(chain);
 507                 /* New rule: allocate and init new instance. */
 508                 ptr = malloc(sizeof(struct cfg_nat), M_IPFW, M_WAITOK | M_ZERO);
 509                 ptr->lib = LibAliasInit(NULL);
 510                 LIST_INIT(&ptr->redir_chain);
 511         } else {
 512                 /* Entry already present: temporarily unhook it. */
 513                 IPFW_WLOCK(chain);
 514                 LIST_REMOVE(ptr, _next);
 515                 flush_nat_ptrs(chain, ptr->id);
 516                 IPFW_WUNLOCK(chain);
 517                 IPFW_UH_WUNLOCK(chain);
 518         }
 519
 520         /*
 521          * Basic nat (re)configuration.
 522          */
 523         ptr->id = strtol(ucfg->name, NULL, 10);
 524         /*
 525          * XXX - what if this rule doesn't nat any ip and just
 526          * redirect?
 527          * do we set aliasaddress to 0.0.0.0?
 528          */
 529         ptr->ip = ucfg->ip;
 530         ptr->redir_cnt = ucfg->redir_cnt;
 531         ptr->mode = ucfg->mode;
 532         strlcpy(ptr->if_name, ucfg->if_name, sizeof(ptr->if_name));
 533         LibAliasSetMode(ptr->lib, ptr->mode, ~0);
 534         LibAliasSetAddress(ptr->lib, ptr->ip);
 535
 536         /*
 537          * Redir and LSNAT configuration.
 538          */
 539         /* Delete old cfgs. */
 540         del_redir_spool_cfg(ptr, &ptr->redir_chain);
 541         /* Add new entries. */
 542         add_redir_spool_cfg((char *)(ucfg + 1), ptr);
 543         IPFW_UH_WLOCK(chain);
 544
 545         /* Extra check to avoid race with another ipfw_nat_cfg() */
 546         tcfg = NULL;
 547         if (gencnt != chain->gencnt)
 548             tcfg = lookup_nat_name(&chain->nat, ucfg->name);
 549         IPFW_WLOCK(chain);
 550         if (tcfg != NULL)
 551                 LIST_REMOVE(tcfg, _next);
 552         LIST_INSERT_HEAD(&chain->nat, ptr, _next);
 553         IPFW_WUNLOCK(chain);
 554         chain->gencnt++;
 555
 556         IPFW_UH_WUNLOCK(chain);
 557
 558         if (tcfg != NULL)
 559                 free_nat_instance(ptr);
 560 }
 561
 562 /*
 563  * Creates/configure nat44 instance
 564  * Data layout (v0)(current):
 565  * Request: [ ipfw_obj_header nat44_cfg_nat .. ]
 566  *
 567  * Returns 0 on success
 568  */
 569 static int
 570 nat44_cfg(struct ip_fw_chain *chain, ip_fw3_opheader *op3,
 571     struct sockopt_data *sd)
 572 {
 573         ipfw_obj_header *oh;
 574         struct nat44_cfg_nat *ucfg;
 575         int id;
 576         size_t read;
 577         char *errptr;
 578
 579         /* Check minimum header size */
 580         if (sd->valsize < (sizeof(*oh) + sizeof(*ucfg)))
 581                 return (EINVAL);
 582
 583         oh = (ipfw_obj_header *)sd->kbuf;
 584
 585         /* Basic length checks for TLVs */
 586         if (oh->ntlv.head.length != sizeof(oh->ntlv))
 587                 return (EINVAL);
 588
 589         ucfg = (struct nat44_cfg_nat *)(oh + 1);
 590
 591         /* Check if name is properly terminated and looks like number */
 592         if (strnlen(ucfg->name, sizeof(ucfg->name)) == sizeof(ucfg->name))
 593                 return (EINVAL);
 594         id = strtol(ucfg->name, &errptr, 10);
 595         if (id == 0 || *errptr != '\0')
 596                 return (EINVAL);
 597
 598         read = sizeof(*oh) + sizeof(*ucfg);
 599         /* Check number of redirs */
 600         if (sd->valsize < read + ucfg->redir_cnt*sizeof(struct nat44_cfg_redir))
 601                 return (EINVAL);
 602
 603         nat44_config(chain, ucfg);
 604         return (0);
 605 }
 606
 607 /*
 608  * Destroys given nat instances.
 609  * Data layout (v0)(current):
 610  * Request: [ ipfw_obj_header ]
 611  *
 612  * Returns 0 on success
 613  */
 614 static int
 615 nat44_destroy(struct ip_fw_chain *chain, ip_fw3_opheader *op3,
 616     struct sockopt_data *sd)
 617 {
 618         ipfw_obj_header *oh;
 619         struct cfg_nat *ptr;
 620         ipfw_obj_ntlv *ntlv;
 621
 622         /* Check minimum header size */
 623         if (sd->valsize < sizeof(*oh))
 624                 return (EINVAL);
 625
 626         oh = (ipfw_obj_header *)sd->kbuf;
 627
 628         /* Basic length checks for TLVs */
 629         if (oh->ntlv.head.length != sizeof(oh->ntlv))
 630                 return (EINVAL);
 631
 632         ntlv = &oh->ntlv;
 633         /* Check if name is properly terminated */
 634         if (strnlen(ntlv->name, sizeof(ntlv->name)) == sizeof(ntlv->name))
 635                 return (EINVAL);
 636
 637         IPFW_UH_WLOCK(chain);
 638         ptr = lookup_nat_name(&chain->nat, ntlv->name);
 639         if (ptr == NULL) {
 640                 IPFW_UH_WUNLOCK(chain);
 641                 return (ESRCH);
 642         }
 643         IPFW_WLOCK(chain);
 644         LIST_REMOVE(ptr, _next);
 645         flush_nat_ptrs(chain, ptr->id);
 646         IPFW_WUNLOCK(chain);
 647         IPFW_UH_WUNLOCK(chain);
 648
 649         free_nat_instance(ptr);
 650
 651         return (0);
 652 }
 653
 654 static void
 655 export_nat_cfg(struct cfg_nat *ptr, struct nat44_cfg_nat *ucfg)
 656 {
 657
 658         snprintf(ucfg->name, sizeof(ucfg->name), "%d", ptr->id);
 659         ucfg->ip = ptr->ip;
 660         ucfg->redir_cnt = ptr->redir_cnt;
 661         ucfg->mode = ptr->mode;
 662         strlcpy(ucfg->if_name, ptr->if_name, sizeof(ucfg->if_name));
 663 }
 664
 665 /*
 666  * Gets config for given nat instance
 667  * Data layout (v0)(current):
 668  * Request: [ ipfw_obj_header nat44_cfg_nat .. ]
 669  *
 670  * Returns 0 on success
 671  */
 672 static int
 673 nat44_get_cfg(struct ip_fw_chain *chain, ip_fw3_opheader *op3,
 674     struct sockopt_data *sd)
 675 {
 676         ipfw_obj_header *oh;
 677         struct nat44_cfg_nat *ucfg;
 678         struct cfg_nat *ptr;
 679         struct cfg_redir *r;
 680         struct cfg_spool *s;
 681         struct nat44_cfg_redir *ser_r;
 682         struct nat44_cfg_spool *ser_s;
 683         size_t sz;
 684
 685         sz = sizeof(*oh) + sizeof(*ucfg);
 686         /* Check minimum header size */
 687         if (sd->valsize < sz)
 688                 return (EINVAL);
 689
 690         oh = (struct _ipfw_obj_header *)ipfw_get_sopt_header(sd, sz);
 691
 692         /* Basic length checks for TLVs */
 693         if (oh->ntlv.head.length != sizeof(oh->ntlv))
 694                 return (EINVAL);
 695
 696         ucfg = (struct nat44_cfg_nat *)(oh + 1);
 697
 698         /* Check if name is properly terminated */
 699         if (strnlen(ucfg->name, sizeof(ucfg->name)) == sizeof(ucfg->name))
 700                 return (EINVAL);
 701
 702         IPFW_UH_RLOCK(chain);
 703         ptr = lookup_nat_name(&chain->nat, ucfg->name);
 704         if (ptr == NULL) {
 705                 IPFW_UH_RUNLOCK(chain);
 706                 return (ESRCH);
 707         }
 708
 709         export_nat_cfg(ptr, ucfg);
 710
 711         /* Estimate memory amount */
 712         sz = sizeof(ipfw_obj_header) + sizeof(struct nat44_cfg_nat);
 713         LIST_FOREACH(r, &ptr->redir_chain, _next) {
 714                 sz += sizeof(struct nat44_cfg_redir);
 715                 LIST_FOREACH(s, &r->spool_chain, _next)
 716                         sz += sizeof(struct nat44_cfg_spool);
 717         }
 718
 719         ucfg->size = sz;
 720         if (sd->valsize < sz) {
 721
 722                 /*
 723                  * Submitted buffer size is not enough.
 724                  * WE've already filled in @ucfg structure with
 725                  * relevant info including size, so we
 726                  * can return. Buffer will be flushed automatically.
 727                  */
 728                 IPFW_UH_RUNLOCK(chain);
 729                 return (ENOMEM);
 730         }
 731
 732         /* Size OK, let's copy data */
 733         LIST_FOREACH(r, &ptr->redir_chain, _next) {
 734                 ser_r = (struct nat44_cfg_redir *)ipfw_get_sopt_space(sd,
 735                     sizeof(*ser_r));
 736                 ser_r->mode = r->mode;
 737                 ser_r->laddr = r->laddr;
 738                 ser_r->paddr = r->paddr;
 739                 ser_r->raddr = r->raddr;
 740                 ser_r->lport = r->lport;
 741                 ser_r->pport = r->pport;
 742                 ser_r->rport = r->rport;
 743                 ser_r->pport_cnt = r->pport_cnt;
 744                 ser_r->rport_cnt = r->rport_cnt;
 745                 ser_r->proto = r->proto;
 746                 ser_r->spool_cnt = r->spool_cnt;
 747
 748                 LIST_FOREACH(s, &r->spool_chain, _next) {
 749                         ser_s = (struct nat44_cfg_spool *)ipfw_get_sopt_space(
 750                             sd, sizeof(*ser_s));
 751
 752                         ser_s->addr = s->addr;
 753                         ser_s->port = s->port;
 754                 }
 755         }
 756
 757         IPFW_UH_RUNLOCK(chain);
 758
 759         return (0);
 760 }
 761
 762 /*
 763  * Lists all nat44 instances currently available in kernel.
 764  * Data layout (v0)(current):
 765  * Request: [ ipfw_obj_lheader ]
 766  * Reply: [ ipfw_obj_lheader nat44_cfg_nat x N ]
 767  *
 768  * Returns 0 on success
 769  */
 770 static int
 771 nat44_list_nat(struct ip_fw_chain *chain, ip_fw3_opheader *op3,
 772     struct sockopt_data *sd)
 773 {
 774         ipfw_obj_lheader *olh;
 775         struct nat44_cfg_nat *ucfg;
 776         struct cfg_nat *ptr;
 777         int nat_count;
 778
 779         /* Check minimum header size */
 780         if (sd->valsize < sizeof(ipfw_obj_lheader))
 781                 return (EINVAL);
 782
 783         olh = (ipfw_obj_lheader *)ipfw_get_sopt_header(sd, sizeof(*olh));
 784         IPFW_UH_RLOCK(chain);
 785         nat_count = 0;
 786         LIST_FOREACH(ptr, &chain->nat, _next)
 787                 nat_count++;
 788
 789         olh->count = nat_count;
 790         olh->objsize = sizeof(struct nat44_cfg_nat);
 791         olh->size = sizeof(*olh) + olh->count * olh->objsize;
 792
 793         if (sd->valsize < olh->size) {
 794                 IPFW_UH_RUNLOCK(chain);
 795                 return (ENOMEM);
 796         }
 797
 798         LIST_FOREACH(ptr, &chain->nat, _next) {
 799                 ucfg = (struct nat44_cfg_nat *)ipfw_get_sopt_space(sd,
 800                     sizeof(*ucfg));
 801                 export_nat_cfg(ptr, ucfg);
 802         }
 803
 804         IPFW_UH_RUNLOCK(chain);
 805
 806         return (0);
 807 }
 808
 809 /*
 810  * Gets log for given nat instance
 811  * Data layout (v0)(current):
 812  * Request: [ ipfw_obj_header nat44_cfg_nat ]
 813  * Reply: [ ipfw_obj_header nat44_cfg_nat LOGBUFFER ]
 814  *
 815  * Returns 0 on success
 816  */
 817 static int
 818 nat44_get_log(struct ip_fw_chain *chain, ip_fw3_opheader *op3,
 819     struct sockopt_data *sd)
 820 {
 821         ipfw_obj_header *oh;
 822         struct nat44_cfg_nat *ucfg;
 823         struct cfg_nat *ptr;
 824         void *pbuf;
 825         size_t sz;
 826
 827         sz = sizeof(*oh) + sizeof(*ucfg);
 828         /* Check minimum header size */
 829         if (sd->valsize < sz)
 830                 return (EINVAL);
 831
 832         oh = (struct _ipfw_obj_header *)ipfw_get_sopt_header(sd, sz);
 833
 834         /* Basic length checks for TLVs */
 835         if (oh->ntlv.head.length != sizeof(oh->ntlv))
 836                 return (EINVAL);
 837
 838         ucfg = (struct nat44_cfg_nat *)(oh + 1);
 839
 840         /* Check if name is properly terminated */
 841         if (strnlen(ucfg->name, sizeof(ucfg->name)) == sizeof(ucfg->name))
 842                 return (EINVAL);
 843
 844         IPFW_UH_RLOCK(chain);
 845         ptr = lookup_nat_name(&chain->nat, ucfg->name);
 846         if (ptr == NULL) {
 847                 IPFW_UH_RUNLOCK(chain);
 848                 return (ESRCH);
 849         }
 850
 851         if (ptr->lib->logDesc == NULL) {
 852                 IPFW_UH_RUNLOCK(chain);
 853                 return (ENOENT);
 854         }
 855
 856         export_nat_cfg(ptr, ucfg);
 857
 858         /* Estimate memory amount */
 859         ucfg->size = sizeof(struct nat44_cfg_nat) + LIBALIAS_BUF_SIZE;
 860         if (sd->valsize < sz + sizeof(*oh)) {
 861
 862                 /*
 863                  * Submitted buffer size is not enough.
 864                  * WE've already filled in @ucfg structure with
 865                  * relevant info including size, so we
 866                  * can return. Buffer will be flushed automatically.
 867                  */
 868                 IPFW_UH_RUNLOCK(chain);
 869                 return (ENOMEM);
 870         }
 871
 872         pbuf = (void *)ipfw_get_sopt_space(sd, LIBALIAS_BUF_SIZE);
 873         memcpy(pbuf, ptr->lib->logDesc, LIBALIAS_BUF_SIZE);
 874
 875         IPFW_UH_RUNLOCK(chain);
 876
 877         return (0);
 878 }
 879
 880 static struct ipfw_sopt_handler scodes[] = {
 881         { IP_FW_NAT44_XCONFIG,  0,      HDIR_SET,       nat44_cfg },
 882         { IP_FW_NAT44_DESTROY,  0,      HDIR_SET,       nat44_destroy },
 883         { IP_FW_NAT44_XGETCONFIG,       0,      HDIR_GET,       nat44_get_cfg },
 884         { IP_FW_NAT44_LIST_NAT, 0,      HDIR_GET,       nat44_list_nat },
 885         { IP_FW_NAT44_XGETLOG,  0,      HDIR_GET,       nat44_get_log },
 886 };
 887
 888
 889 /*
 890  * Legacy configuration routines
 891  */
 892
 893 struct cfg_spool_legacy {
 894         LIST_ENTRY(cfg_spool_legacy)    _next;
 895         struct in_addr                  addr;
 896         u_short                         port;
 897 };
 898
 899 struct cfg_redir_legacy {
 900         LIST_ENTRY(cfg_redir)   _next;
 901         u_int16_t               mode;
 902         struct in_addr          laddr;
 903         struct in_addr          paddr;
 904         struct in_addr          raddr;
 905         u_short                 lport;
 906         u_short                 pport;
 907         u_short                 rport;
 908         u_short                 pport_cnt;
 909         u_short                 rport_cnt;
 910         int                     proto;
 911         struct alias_link       **alink;
 912         u_int16_t               spool_cnt;
 913         LIST_HEAD(, cfg_spool_legacy) spool_chain;
 914 };
 915
 916 struct cfg_nat_legacy {
 917         LIST_ENTRY(cfg_nat_legacy)      _next;
 918         int                             id;
 919         struct in_addr                  ip;
 920         char                            if_name[IF_NAMESIZE];
 921         int                             mode;
 922         struct libalias                 *lib;
 923         int                             redir_cnt;
 924         LIST_HEAD(, cfg_redir_legacy)   redir_chain;
 925 };
 926
 927 static int
 928 ipfw_nat_cfg(struct sockopt *sopt)
 929 {
 930         struct cfg_nat_legacy *cfg;
 931         struct nat44_cfg_nat *ucfg;
 932         struct cfg_redir_legacy *rdir;
 933         struct nat44_cfg_redir *urdir;
 934         char *buf;
 935         size_t len, len2;
 936         int error, i;
 937
 938         len = sopt->sopt_valsize;
 939         len2 = len + 128;
 940
 941         /*
 942          * Allocate 2x buffer to store converted structures.
 943          * new redir_cfg has shrunk, so we're sure that
 944          * new buffer size is enough.
 945          */
 946         buf = malloc(roundup2(len, 8) + len2, M_TEMP, M_WAITOK | M_ZERO);
 947         error = sooptcopyin(sopt, buf, len, sizeof(struct cfg_nat_legacy));
 948         if (error != 0)
 949                 goto out;
 950
 951         cfg = (struct cfg_nat_legacy *)buf;
 952         if (cfg->id < 0) {
 953                 error = EINVAL;
 954                 goto out;
 955         }
 956
 957         ucfg = (struct nat44_cfg_nat *)&buf[roundup2(len, 8)];
 958         snprintf(ucfg->name, sizeof(ucfg->name), "%d", cfg->id);
 959         strlcpy(ucfg->if_name, cfg->if_name, sizeof(ucfg->if_name));
 960         ucfg->ip = cfg->ip;
 961         ucfg->mode = cfg->mode;
 962         ucfg->redir_cnt = cfg->redir_cnt;
 963
 964         if (len < sizeof(*cfg) + cfg->redir_cnt * sizeof(*rdir)) {
 965                 error = EINVAL;
 966                 goto out;
 967         }
 968
 969         urdir = (struct nat44_cfg_redir *)(ucfg + 1);
 970         rdir = (struct cfg_redir_legacy *)(cfg + 1);
 971         for (i = 0; i < cfg->redir_cnt; i++) {
 972                 urdir->mode = rdir->mode;
 973                 urdir->laddr = rdir->laddr;
 974                 urdir->paddr = rdir->paddr;
 975                 urdir->raddr = rdir->raddr;
 976                 urdir->lport = rdir->lport;
 977                 urdir->pport = rdir->pport;
 978                 urdir->rport = rdir->rport;
 979                 urdir->pport_cnt = rdir->pport_cnt;
 980                 urdir->rport_cnt = rdir->rport_cnt;
 981                 urdir->proto = rdir->proto;
 982                 urdir->spool_cnt = rdir->spool_cnt;
 983
 984                 urdir++;
 985                 rdir++;
 986         }
 987
 988         nat44_config(&V_layer3_chain, ucfg);
 989
 990 out:
 991         free(buf, M_TEMP);
 992         return (error);
 993 }
 994
 995 static int
 996 ipfw_nat_del(struct sockopt *sopt)
 997 {
 998         struct cfg_nat *ptr;
 999         struct ip_fw_chain *chain = &V_layer3_chain;
1000         int i;
1001
1002         sooptcopyin(sopt, &i, sizeof i, sizeof i);
1003         /* XXX validate i */
1004         IPFW_UH_WLOCK(chain);
1005         ptr = lookup_nat(&chain->nat, i);
1006         if (ptr == NULL) {
1007                 IPFW_UH_WUNLOCK(chain);
1008                 return (EINVAL);
1009         }
1010         IPFW_WLOCK(chain);
1011         LIST_REMOVE(ptr, _next);
1012         flush_nat_ptrs(chain, i);
1013         IPFW_WUNLOCK(chain);
1014         IPFW_UH_WUNLOCK(chain);
1015         free_nat_instance(ptr);
1016         return (0);
1017 }
1018
1019 static int
1020 ipfw_nat_get_cfg(struct sockopt *sopt)
1021 {
1022         struct ip_fw_chain *chain = &V_layer3_chain;
1023         struct cfg_nat *n;
1024         struct cfg_nat_legacy *ucfg;
1025         struct cfg_redir *r;
1026         struct cfg_spool *s;
1027         struct cfg_redir_legacy *ser_r;
1028         struct cfg_spool_legacy *ser_s;
1029         char *data;
1030         int gencnt, nat_cnt, len, error;
1031
1032         nat_cnt = 0;
1033         len = sizeof(nat_cnt);
1034
1035         IPFW_UH_RLOCK(chain);
1036 retry:
1037         gencnt = chain->gencnt;
1038         /* Estimate memory amount */
1039         LIST_FOREACH(n, &chain->nat, _next) {
1040                 nat_cnt++;
1041                 len += sizeof(struct cfg_nat_legacy);
1042                 LIST_FOREACH(r, &n->redir_chain, _next) {
1043                         len += sizeof(struct cfg_redir_legacy);
1044                         LIST_FOREACH(s, &r->spool_chain, _next)
1045                                 len += sizeof(struct cfg_spool_legacy);
1046                 }
1047         }
1048         IPFW_UH_RUNLOCK(chain);
1049
1050         data = malloc(len, M_TEMP, M_WAITOK | M_ZERO);
1051         bcopy(&nat_cnt, data, sizeof(nat_cnt));
1052
1053         nat_cnt = 0;
1054         len = sizeof(nat_cnt);
1055
1056         IPFW_UH_RLOCK(chain);
1057         if (gencnt != chain->gencnt) {
1058                 free(data, M_TEMP);
1059                 goto retry;
1060         }
1061         /* Serialize all the data. */
1062         LIST_FOREACH(n, &chain->nat, _next) {
1063                 ucfg = (struct cfg_nat_legacy *)&data[len];
1064                 ucfg->id = n->id;
1065                 ucfg->ip = n->ip;
1066                 ucfg->redir_cnt = n->redir_cnt;
1067                 ucfg->mode = n->mode;
1068                 strlcpy(ucfg->if_name, n->if_name, sizeof(ucfg->if_name));
1069                 len += sizeof(struct cfg_nat_legacy);
1070                 LIST_FOREACH(r, &n->redir_chain, _next) {
1071                         ser_r = (struct cfg_redir_legacy *)&data[len];
1072                         ser_r->mode = r->mode;
1073                         ser_r->laddr = r->laddr;
1074                         ser_r->paddr = r->paddr;
1075                         ser_r->raddr = r->raddr;
1076                         ser_r->lport = r->lport;
1077                         ser_r->pport = r->pport;
1078                         ser_r->rport = r->rport;
1079                         ser_r->pport_cnt = r->pport_cnt;
1080                         ser_r->rport_cnt = r->rport_cnt;
1081                         ser_r->proto = r->proto;
1082                         ser_r->spool_cnt = r->spool_cnt;
1083                         len += sizeof(struct cfg_redir_legacy);
1084                         LIST_FOREACH(s, &r->spool_chain, _next) {
1085                                 ser_s = (struct cfg_spool_legacy *)&data[len];
1086                                 ser_s->addr = s->addr;
1087                                 ser_s->port = s->port;
1088                                 len += sizeof(struct cfg_spool_legacy);
1089                         }
1090                 }
1091         }
1092         IPFW_UH_RUNLOCK(chain);
1093
1094         error = sooptcopyout(sopt, data, len);
1095         free(data, M_TEMP);
1096
1097         return (error);
1098 }
1099
1100 static int
1101 ipfw_nat_get_log(struct sockopt *sopt)
1102 {
1103         uint8_t *data;
1104         struct cfg_nat *ptr;
1105         int i, size;
1106         struct ip_fw_chain *chain;
1107         IPFW_RLOCK_TRACKER;
1108
1109         chain = &V_layer3_chain;
1110
1111         IPFW_RLOCK(chain);
1112         /* one pass to count, one to copy the data */
1113         i = 0;
1114         LIST_FOREACH(ptr, &chain->nat, _next) {
1115                 if (ptr->lib->logDesc == NULL)
1116                         continue;
1117                 i++;
1118         }
1119         size = i * (LIBALIAS_BUF_SIZE + sizeof(int));
1120         data = malloc(size, M_IPFW, M_NOWAIT | M_ZERO);
1121         if (data == NULL) {
1122                 IPFW_RUNLOCK(chain);
1123                 return (ENOSPC);
1124         }
1125         i = 0;
1126         LIST_FOREACH(ptr, &chain->nat, _next) {
1127                 if (ptr->lib->logDesc == NULL)
1128                         continue;
1129                 bcopy(&ptr->id, &data[i], sizeof(int));
1130                 i += sizeof(int);
1131                 bcopy(ptr->lib->logDesc, &data[i], LIBALIAS_BUF_SIZE);
1132                 i += LIBALIAS_BUF_SIZE;
1133         }
1134         IPFW_RUNLOCK(chain);
1135         sooptcopyout(sopt, data, size);
1136         free(data, M_IPFW);
1137         return(0);
1138 }
1139
1140 static int
1141 vnet_ipfw_nat_init(const void *arg __unused)
1142 {
1143
1144         V_ipfw_nat_ready = 1;
1145         return (0);
1146 }
1147
1148 static int
1149 vnet_ipfw_nat_uninit(const void *arg __unused)
1150 {
1151         struct cfg_nat *ptr, *ptr_temp;
1152         struct ip_fw_chain *chain;
1153
1154         chain = &V_layer3_chain;
1155         IPFW_WLOCK(chain);
1156         V_ipfw_nat_ready = 0;
1157         LIST_FOREACH_SAFE(ptr, &chain->nat, _next, ptr_temp) {
1158                 LIST_REMOVE(ptr, _next);
1159                 free_nat_instance(ptr);
1160         }
1161         flush_nat_ptrs(chain, -1 /* flush all */);
1162         IPFW_WUNLOCK(chain);
1163         return (0);
1164 }
1165
1166 static void
1167 ipfw_nat_init(void)
1168 {
1169
1170         /* init ipfw hooks */
1171         ipfw_nat_ptr = ipfw_nat;
1172         lookup_nat_ptr = lookup_nat;
1173         ipfw_nat_cfg_ptr = ipfw_nat_cfg;
1174         ipfw_nat_del_ptr = ipfw_nat_del;
1175         ipfw_nat_get_cfg_ptr = ipfw_nat_get_cfg;
1176         ipfw_nat_get_log_ptr = ipfw_nat_get_log;
1177         IPFW_ADD_SOPT_HANDLER(1, scodes);
1178
1179         ifaddr_event_tag = EVENTHANDLER_REGISTER(ifaddr_event, ifaddr_change,
1180             NULL, EVENTHANDLER_PRI_ANY);
1181 }
1182
1183 static void
1184 ipfw_nat_destroy(void)
1185 {
1186
1187         EVENTHANDLER_DEREGISTER(ifaddr_event, ifaddr_event_tag);
1188         /* deregister ipfw_nat */
1189         IPFW_DEL_SOPT_HANDLER(1, scodes);
1190         ipfw_nat_ptr = NULL;
1191         lookup_nat_ptr = NULL;
1192         ipfw_nat_cfg_ptr = NULL;
1193         ipfw_nat_del_ptr = NULL;
1194         ipfw_nat_get_cfg_ptr = NULL;
1195         ipfw_nat_get_log_ptr = NULL;
1196 }
1197
1198 static int
1199 ipfw_nat_modevent(module_t mod, int type, void *unused)
1200 {
1201         int err = 0;
1202
1203         switch (type) {
1204         case MOD_LOAD:
1205                 break;
1206
1207         case MOD_UNLOAD:
1208                 break;
1209
1210         default:
1211                 return EOPNOTSUPP;
1212                 break;
1213         }
1214         return err;
1215 }
1216
1217 static moduledata_t ipfw_nat_mod = {
1218         "ipfw_nat",
1219         ipfw_nat_modevent,
1220         0
1221 };
1222
1223 /* Define startup order. */
1224 #define IPFW_NAT_SI_SUB_FIREWALL        SI_SUB_PROTO_FIREWALL
1225 #define IPFW_NAT_MODEVENT_ORDER         (SI_ORDER_ANY - 128) /* after ipfw */
1226 #define IPFW_NAT_MODULE_ORDER           (IPFW_NAT_MODEVENT_ORDER + 1)
1227 #define IPFW_NAT_VNET_ORDER             (IPFW_NAT_MODEVENT_ORDER + 2)
1228
1229 DECLARE_MODULE(ipfw_nat, ipfw_nat_mod, IPFW_NAT_SI_SUB_FIREWALL, SI_ORDER_ANY);
1230 MODULE_DEPEND(ipfw_nat, libalias, 1, 1, 1);
1231 MODULE_DEPEND(ipfw_nat, ipfw, 3, 3, 3);
1232 MODULE_VERSION(ipfw_nat, 1);
1233
1234 SYSINIT(ipfw_nat_init, IPFW_NAT_SI_SUB_FIREWALL, IPFW_NAT_MODULE_ORDER,
1235     ipfw_nat_init, NULL);
1236 VNET_SYSINIT(vnet_ipfw_nat_init, IPFW_NAT_SI_SUB_FIREWALL, IPFW_NAT_VNET_ORDER,
1237     vnet_ipfw_nat_init, NULL);
1238
1239 SYSUNINIT(ipfw_nat_destroy, IPFW_NAT_SI_SUB_FIREWALL, IPFW_NAT_MODULE_ORDER,
1240     ipfw_nat_destroy, NULL);
1241 VNET_SYSUNINIT(vnet_ipfw_nat_uninit, IPFW_NAT_SI_SUB_FIREWALL,
1242     IPFW_NAT_VNET_ORDER, vnet_ipfw_nat_uninit, NULL);
1243
1244 /* end of file */