pkgbase: Put geom utilities in their own package

[manu]

Summary

For most users it's not needed to boot and they are also
available in the FreeBSD-rescue package in case an update
break and FreeBSD-geom package isn't updated correctly.

lib/geom/cache/Makefile

  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 #ifdef _KERNEL
-#include <machine/stdarg.h>
 #include <sys/param.h>
-#include <sys/kernel.h>
 #include <sys/systm.h>
+#include <sys/kernel.h>
 #include <sys/lock.h>
 #include <sys/module.h>
 #include <sys/rwlock.h>
 #include <sys/syslog.h>
+
+#include <machine/stdarg.h>
 #else
-#include <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
 #include <sys/errno.h>
 #include <sys/time.h>
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
 #endif
 
 #include <sys/socket.h>
+
 #include <netinet/tcp.h>
 
 #ifdef _KERNEL
+#include <net/if.h>
 #include <netinet/libalias/alias.h>
 #include <netinet/libalias/alias_local.h>
 #include <netinet/libalias/alias_mod.h>
-#include <net/if.h>
 #else
 #include "alias.h"
 #include "alias_local.h"
 #include "alias_mod.h"
 #endif
 
 #include "alias_db.h"
 
case MOD_UNLOAD:
                 finishoff();
         case MOD_LOAD:
                 return (0);
         default:
                 return (EINVAL);
         }
 }
 
-static moduledata_t alias_mod = {
-       "alias", alias_mod_handler, NULL
-};
+static moduledata_t alias_mod = { "alias", alias_mod_handler, NULL };
 
 DECLARE_MODULE(alias, alias_mod, SI_SUB_DRIVERS, SI_ORDER_SECOND);
 #endif
 
 SPLAY_GENERATE(splay_out, alias_link, all.out, cmp_out);
 SPLAY_GENERATE(splay_in, group_in, in, cmp_in);
 
 static struct group_in *
-StartPointIn(struct libalias *la,
-    struct in_addr alias_addr, u_short alias_port, int link_type,
-    int create)
+StartPointIn(struct libalias *la, struct in_addr alias_addr, u_short alias_port,
+    int link_type, int create)
 {
         struct group_in *grp;
-        struct group_in needle = {
-                .alias_addr = alias_addr,
+        struct group_in needle = { .alias_addr = alias_addr,
                 .alias_port = alias_port,
-                .link_type = link_type
-        };
+                .link_type = link_type };
 
         grp = SPLAY_FIND(splay_in, &la->linkSplayIn, &needle);
         if (grp != NULL || !create || (grp = malloc(sizeof(*grp))) == NULL)
                 return (grp);
         grp->alias_addr = alias_addr;
         grp->alias_port = alias_port;
         grp->link_type = link_type;
         LIST_INIT(&grp->full);
         LIST_INIT(&grp->partial);
         SPLAY_INSERT(splay_in, &la->linkSplayIn, grp);
         return (grp);
 }
 
 static int
 SeqDiff(u_long x, u_long y)
 {
         /* Return the difference between two TCP sequence numbers
          * This function is encapsulated in case there are any unusual
          * arithmetic conditions that need to be considered.
          */
         return (ntohl(y) - ntohl(x));
 }
 
 #ifdef _KERNEL
 static void
 AliasLog(char *str, const char *format, ...)
 {
         va_list ap;

 #endif
 
 static void
 ShowAliasStats(struct libalias *la)
 {
         LIBALIAS_LOCK_ASSERT(la);
         /* Used for debugging */
         if (la->logDesc) {
-                int tot  = la->icmpLinkCount + la->udpLinkCount +
-                    (la->sctpLinkCount>>1) + /* sctp counts half associations */
-                    la->tcpLinkCount + la->pptpLinkCount +
-                    la->protoLinkCount + la->fragmentIdLinkCount +
-                    la->fragmentPtrLinkCount;
+                int tot = la->icmpLinkCount + la->udpLinkCount +
+                    (la->sctpLinkCount >>
+                        1) + /* sctp counts half associations */
+                    la->tcpLinkCount +
+                    la->pptpLinkCount + la->protoLinkCount +
+                    la->fragmentIdLinkCount + la->fragmentPtrLinkCount;
 
                 AliasLog(la->logDesc,
                     "icmp=%u, udp=%u, tcp=%u, sctp=%u, pptp=%u, proto=%u, frag_id=%u frag_ptr=%u / tot=%u",
-                    la->icmpLinkCount,
-                    la->udpLinkCount,
-                    la->tcpLinkCount,
-                    la->sctpLinkCount>>1, /* sctp counts half associations */
-                    la->pptpLinkCount,
-                    la->protoLinkCount,
-                    la->fragmentIdLinkCount,
-                    la->fragmentPtrLinkCount,
-                    tot);
+                    la->icmpLinkCount, la->udpLinkCount, la->tcpLinkCount,
+                    la->sctpLinkCount >> 1, /* sctp counts half associations */
+                    la->pptpLinkCount, la->protoLinkCount,
+                    la->fragmentIdLinkCount, la->fragmentPtrLinkCount, tot);
 #ifndef _KERNEL
                 AliasLog(la->logDesc, " (sock=%u)\n", la->sockCount);
 #endif
         }
 }
 
-void SctpShowAliasStats(struct libalias *la)
+void
+SctpShowAliasStats(struct libalias *la)
 {
         ShowAliasStats(la);
 }
 
 /* get random port in network byte order */
 static u_short
-_RandomPort(struct libalias *la) {
+_RandomPort(struct libalias *la)
+{
         u_short port;
 
-        port = la->aliasPortLower +
-            arc4random_uniform(la->aliasPortLength);
+        port = la->aliasPortLower + arc4random_uniform(la->aliasPortLength);
 
         return ntohs(port);
 }
 
 /* GetNewPort() allocates port numbers.  Note that if a port number
    is already in use, that does not mean that it cannot be used by
    another link concurrently.  This is because GetNewPort() looks for
    unused triplets: (dest addr, dest port, alias port). */
 
 static int
 GetNewPort(struct libalias *la, struct alias_link *lnk, int alias_port_param)
 {
         int i;
         int max_trials;
         u_short port;
 
         LIBALIAS_LOCK_ASSERT(la);
         /*
          * Description of alias_port_param for GetNewPort().  When
          * this parameter is zero or positive, it precisely specifies
          * the port number.  GetNewPort() will return this number
          * without check that it is in use.
-        *
+         *
          * The aliasing port is automatically selected by one of
          * two methods below:
          *
          * When this parameter is GET_ALIAS_PORT, it indicates to get
          * a randomly selected port number.
          */
         if (alias_port_param >= 0 && alias_port_param < 0x10000) {
-                lnk->alias_port = (u_short) alias_port_param;
+                lnk->alias_port = (u_short)alias_port_param;
                 return (0);
         }
         if (alias_port_param != GET_ALIAS_PORT) {
 #ifdef LIBALIAS_DEBUG
                 fprintf(stderr, "PacketAlias/GetNewPort(): ");
                 fprintf(stderr, "input parameter error\n");
 #endif
                 return (-1);
         }
 
         max_trials = GET_NEW_PORT_MAX_ATTEMPTS;
 
         /*
          * When the PKT_ALIAS_SAME_PORTS option is chosen,
          * the first try will be the actual source port. If
          * this is already in use, the remainder of the
          * trials will be random.
          */
-        port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS)
-            ? lnk->src_port
-            : _RandomPort(la);
+        port = (la->packetAliasMode & PKT_ALIAS_SAME_PORTS) ? lnk->src_port :
+                                                              _RandomPort(la);
 
         /* Port number search */
         for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
                 struct group_in *grp;
                 struct alias_link *search_result;
 
-                grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type, 0);
+                grp = StartPointIn(la, lnk->alias_addr, port, lnk->link_type,
+                    0);
                 if (grp == NULL)
                         break;
 
                 LIST_FOREACH(search_result, &grp->full, all.in) {
-                        if (lnk->dst_addr.s_addr == search_result->dst_addr.s_addr &&
+                        if (lnk->dst_addr.s_addr ==
+                                search_result->dst_addr.s_addr &&
                             lnk->dst_port == search_result->dst_port)
-                            break;     /* found match */
+                                break; /* found match */
                 }
                 if (search_result == NULL)
                         break;
         }
 
         if (i >= max_trials) {
 #ifdef LIBALIAS_DEBUG
                 fprintf(stderr, "PacketAlias/GetNewPort(): ");
                 fprintf(stderr, "could not find free port\n");
 #endif
                 return (-1);
         }
 
 #ifndef NO_USE_SOCKETS
         if ((la->packetAliasMode & PKT_ALIAS_USE_SOCKETS) &&
             (lnk->flags & LINK_PARTIALLY_SPECIFIED) &&
-            ((lnk->link_type == LINK_TCP) ||
-             (lnk->link_type == LINK_UDP))) {
+            ((lnk->link_type == LINK_TCP) || (lnk->link_type == LINK_UDP))) {
                 if (!GetSocket(la, port, &lnk->sockfd, lnk->link_type)) {
                         return (-1);
                 }
         }
 #endif
         lnk->alias_port = port;
 
         return (0);
 }
 
 #ifndef NO_USE_SOCKETS
-static          u_short
+static u_short
 GetSocket(struct libalias *la, u_short port_net, int *sockfd, int link_type)
 {
         int err;
         int sock;
         struct sockaddr_in sock_addr;
 
         LIBALIAS_LOCK_ASSERT(la);
         if (link_type == LINK_TCP)
#ifdef LIBALIAS_DEBUG
                 fprintf(stderr, "socket() error %d\n", *sockfd);
 #endif
                 return (0);
         }
         sock_addr.sin_family = AF_INET;
         sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
         sock_addr.sin_port = port_net;
 
-        err = bind(sock,
-            (struct sockaddr *)&sock_addr,
-            sizeof(sock_addr));
+        err = bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
         if (err == 0) {
                 la->sockCount++;
                 *sockfd = sock;
                 return (1);
         } else {
                 close(sock);
                 return (0);
         }
 }
 #endif
 
 /* FindNewPortGroup() returns a base port number for an available
    range of contiguous port numbers. Note that if a port number
    is already in use, that does not mean that it cannot be used by
    another link concurrently.  This is because FindNewPortGroup()
    looks for unused triplets: (dest addr, dest port, alias port). */
 
 int
-FindNewPortGroup(struct libalias *la,
-    struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short src_port,
-    u_short dst_port,
-    u_short port_count,
-    u_char proto,
-    u_char align)
+FindNewPortGroup(struct libalias *la, struct in_addr dst_addr,
+    struct in_addr alias_addr, u_short src_port, u_short dst_port,
+    u_short port_count, u_char proto, u_char align)
 {
         int i, j;
         int max_trials;
         u_short port;
         int link_type;
 
         LIBALIAS_LOCK_ASSERT(la);
         /*
for (i = 0; i < max_trials; i++, port = _RandomPort(la)) {
 
                 if (align)
                         port &= htons(0xfffe);
 
                 for (j = 0; j < port_count; j++) {
                         u_short port_j = ntohs(port) + j;
 
                         if ((search_result = FindLinkIn(la, dst_addr,
-                            alias_addr, dst_port, htons(port_j),
-                            link_type, 0)) != NULL)
+                                 alias_addr, dst_port, htons(port_j), link_type,
+                                 0)) != NULL)
                                 break;
                 }
 
                 /* Found a good range, return base */
                 if (j == port_count)
                         return (port);
         }
 
CleanupAliasData(struct libalias *la, int deletePermanent)
 
         /* permanent entries may stay */
         TAILQ_FOREACH_SAFE(lnk, &la->checkExpire, expire.list, lnk_tmp)
                 DeleteLink(&lnk, deletePermanent);
 }
 static void
 CleanupLink(struct libalias *la, struct alias_link **lnk, int deletePermanent)
 {
         LIBALIAS_LOCK_ASSERT(la);
 
         if (lnk == NULL || *lnk == NULL)
                 return;
 
         if (LibAliasTime - (*lnk)->timestamp > (*lnk)->expire.time) {
                 DeleteLink(lnk, deletePermanent);
                 if ((*lnk) == NULL)
                         return;
         }
if (lnk->server != NULL) {
                         /* Adjust output table pointers */
                         SPLAY_REMOVE(splay_out, &la->linkSplayOut, lnk);
                 }
 
                 /* Adjust input table pointers */
                 LIST_REMOVE(lnk, all.in);
 
                 /* Remove intermediate node, if empty */
-                grp = StartPointIn(la, lnk->alias_addr, lnk->alias_port, lnk->link_type, 0);
-                if (grp != NULL &&
-                    LIST_EMPTY(&grp->full) &&
+                grp = StartPointIn(la, lnk->alias_addr, lnk->alias_port,
+                    lnk->link_type, 0);
+                if (grp != NULL && LIST_EMPTY(&grp->full) &&
                     LIST_EMPTY(&grp->partial)) {
                         SPLAY_REMOVE(splay_in, &la->linkSplayIn, grp);
                         free(grp);
                 }
+        } break;
         }
-                break;
-        }
 
         /* remove from housekeeping */
         TAILQ_REMOVE(&la->checkExpire, lnk, expire.list);
 
 #ifndef NO_USE_SOCKETS
         /* Close socket, if one has been allocated */
         if (lnk->sockfd != -1) {
                 la->sockCount--;
#endif
         case LINK_TCP: {
                 struct tcp_dat *aux_tcp;
                 int i;
 
                 aux_tcp = malloc(sizeof(struct tcp_dat));
                 if (aux_tcp == NULL) {
 #ifdef LIBALIAS_DEBUG
                         fprintf(stderr, "PacketAlias/AddLink: ");
-                        fprintf(stderr, " cannot allocate auxiliary TCP data\n");
+                        fprintf(stderr,
+                            " cannot allocate auxiliary TCP data\n");
 #endif
                         free(lnk);
                         return (NULL);
                 }
 
                 la->tcpLinkCount++;
                 aux_tcp->state.in = ALIAS_TCP_STATE_NOT_CONNECTED;
                 aux_tcp->state.out = ALIAS_TCP_STATE_NOT_CONNECTED;
                 aux_tcp->state.index = 0;
                 aux_tcp->state.ack_modified = 0;
                 for (i = 0; i < N_LINK_TCP_DATA; i++)
                         aux_tcp->ack[i].active = 0;
                 aux_tcp->fwhole = -1;
                 lnk->data.tcp = aux_tcp;
-        }
-                break;
+        } break;
         case LINK_PPTP:
                 la->pptpLinkCount++;
                 break;
         case LINK_FRAGMENT_ID:
                 la->fragmentIdLinkCount++;
                 break;
         case LINK_FRAGMENT_PTR:
                 la->fragmentPtrLinkCount++;
                 break;
         case LINK_ADDR:
                 break;
         default:
                 la->protoLinkCount++;
                 break;
         }
 
         switch (link_type) {
         case LINK_PPTP:
                 LIST_INSERT_HEAD(&la->pptpList, lnk, pptp.list);
                 break;
         default: {
                 struct group_in *grp;
 
-                grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type, 1);
+                grp = StartPointIn(la, alias_addr, lnk->alias_port, link_type,
+                    1);
                 if (grp == NULL) {
                         free(lnk);
                         return (NULL);
                 }
 
                 /* Set up pointers for output lookup table */
                 SPLAY_INSERT(splay_out, &la->linkSplayOut, lnk);
 
                 /* Set up pointers for input lookup table */
                 if (lnk->flags & LINK_PARTIALLY_SPECIFIED)
                         LIST_INSERT_HEAD(&grp->partial, lnk, all.in);
                 else
                         LIST_INSERT_HEAD(&grp->full, lnk, all.in);
+        } break;
         }
-                break;
-        }
 
         /* Include the element into the housekeeping list */
         TAILQ_INSERT_TAIL(&la->checkExpire, lnk, expire.list);
 
         if (la->packetAliasMode & PKT_ALIAS_LOG)
                 ShowAliasStats(la);
 
         return (lnk);
 }
 
 /*
  * If alias_port_param is less than zero, alias port will be automatically
  * chosen. If greater than zero, equal to alias port
  */
 static struct alias_link *
-ReLink(struct alias_link *old_lnk,
-    struct in_addr src_addr,
-    struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short src_port,
-    u_short dst_port,
-    int alias_port_param,
-    int link_type,
-    int deletePermanent)
+ReLink(struct alias_link *old_lnk, struct in_addr src_addr,
+    struct in_addr dst_addr, struct in_addr alias_addr, u_short src_port,
+    u_short dst_port, int alias_port_param, int link_type, int deletePermanent)
 {
         struct alias_link *new_lnk;
         struct libalias *la = old_lnk->la;
 
         LIBALIAS_LOCK_ASSERT(la);
-        new_lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-            src_port, dst_port, alias_port_param,
-            link_type);
+        new_lnk = AddLink(la, src_addr, dst_addr, alias_addr, src_port,
+            dst_port, alias_port_param, link_type);
 #ifndef NO_FW_PUNCH
-        if (new_lnk != NULL &&
-            old_lnk->link_type == LINK_TCP &&
+        if (new_lnk != NULL && old_lnk->link_type == LINK_TCP &&
             old_lnk->data.tcp->fwhole > 0) {
                 PunchFWHole(new_lnk);
         }
 #endif
         DeleteLink(&old_lnk, deletePermanent);
         return (new_lnk);
 }
 
 static struct alias_link *
 _SearchLinkOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short src_port,
-    u_short dst_port,
-    int link_type) {
+    struct in_addr dst_addr, u_short src_port, u_short dst_port, int link_type)
+{
         struct alias_link *lnk;
-        struct alias_link needle = {
-                .src_addr = src_addr,
+        struct alias_link needle = { .src_addr = src_addr,
                 .dst_addr = dst_addr,
                 .src_port = src_port,
                 .dst_port = dst_port,
-                .link_type = link_type
-        };
+                .link_type = link_type };
 
         lnk = SPLAY_FIND(splay_out, &la->linkSplayOut, &needle);
         return (UseLink(la, lnk));
 }
 
 static struct alias_link *
 _FindLinkOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short src_port,
-    u_short dst_port,
-    int link_type,
+    struct in_addr dst_addr, u_short src_port, u_short dst_port, int link_type,
     int replace_partial_links)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type);
+        lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, dst_port,
+            link_type);
         if (lnk != NULL || !replace_partial_links)
                 return (lnk);
 
         /* Search for partially specified links. */
         if (dst_port != 0 && dst_addr.s_addr != INADDR_ANY) {
                 lnk = _SearchLinkOut(la, src_addr, dst_addr, src_port, 0,
                     link_type);
                 if (lnk == NULL)
                         lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port,
                             dst_port, link_type);
         }
-        if (lnk == NULL &&
-            (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
+        if (lnk == NULL && (dst_port != 0 || dst_addr.s_addr != INADDR_ANY)) {
                 lnk = _SearchLinkOut(la, src_addr, ANY_ADDR, src_port, 0,
                     link_type);
         }
         if (lnk != NULL) {
-                lnk = ReLink(lnk,
-                    src_addr, dst_addr, lnk->alias_addr,
-                    src_port, dst_port, lnk->alias_port,
-                    link_type, 0);
+                lnk = ReLink(lnk, src_addr, dst_addr, lnk->alias_addr, src_port,
+                    dst_port, lnk->alias_port, link_type, 0);
         }
         return (lnk);
 }
 
 static struct alias_link *
 FindLinkOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short src_port,
-    u_short dst_port,
-    int link_type,
+    struct in_addr dst_addr, u_short src_port, u_short dst_port, int link_type,
     int replace_partial_links)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         lnk = _FindLinkOut(la, src_addr, dst_addr, src_port, dst_port,
             link_type, replace_partial_links);
 
         if (lnk == NULL) {
                 /*
                  * The following allows permanent links to be specified as
                  * using the default source address (i.e. device interface
                  * address) without knowing in advance what that address
                  * is.
                  */
                 if (la->aliasAddress.s_addr != INADDR_ANY &&
                     src_addr.s_addr == la->aliasAddress.s_addr) {
-                        lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port, dst_port,
-                            link_type, replace_partial_links);
+                        lnk = _FindLinkOut(la, ANY_ADDR, dst_addr, src_port,
+                            dst_port, link_type, replace_partial_links);
                 }
         }
         return (lnk);
 }
 
 static struct alias_link *
 _FindLinkIn(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short dst_port,
-    u_short alias_port,
-    int link_type,
-    int replace_partial_links)
+    struct in_addr alias_addr, u_short dst_port, u_short alias_port,
+    int link_type, int replace_partial_links)
 {
         int flags_in;
         struct group_in *grp;
         struct alias_link *lnk;
         struct alias_link *lnk_unknown_all;
         struct alias_link *lnk_unknown_dst_addr;
         struct alias_link *lnk_unknown_dst_port;
         struct in_addr src_addr;
case 0:
                 LIST_FOREACH(lnk, &grp->full, all.in) {
                         if (lnk->dst_addr.s_addr == dst_addr.s_addr &&
                             lnk->dst_port == dst_port)
                                 return (UseLink(la, lnk));
                 }
                 break;
         case LINK_UNKNOWN_DEST_PORT:
                 LIST_FOREACH(lnk, &grp->full, all.in) {
-                        if(lnk->dst_addr.s_addr == dst_addr.s_addr) {
+                        if (lnk->dst_addr.s_addr == dst_addr.s_addr) {
                                 lnk_unknown_dst_port = lnk;
                                 break;
                         }
                 }
                 break;
         case LINK_UNKNOWN_DEST_ADDR:
                 LIST_FOREACH(lnk, &grp->full, all.in) {
-                        if(lnk->dst_port == dst_port) {
+                        if (lnk->dst_port == dst_port) {
                                 lnk_unknown_dst_addr = lnk;
                                 break;
                         }
                 }
                 break;
         case LINK_PARTIALLY_SPECIFIED:
                 lnk_unknown_all = LIST_FIRST(&grp->full);
                 break;
         }
 
         if (lnk_unknown_dst_port == NULL) {
                 LIST_FOREACH(lnk, &grp->partial, all.in) {
-                        int flags = (flags_in | lnk->flags) & LINK_PARTIALLY_SPECIFIED;
+                        int flags = (flags_in | lnk->flags) &
+                            LINK_PARTIALLY_SPECIFIED;
 
                         if (flags == LINK_PARTIALLY_SPECIFIED &&
                             lnk_unknown_all == NULL)
                                 lnk_unknown_all = lnk;
                         if (flags == LINK_UNKNOWN_DEST_ADDR &&
                             lnk->dst_port == dst_port &&
                             lnk_unknown_dst_addr == NULL)
                                 lnk_unknown_dst_addr = lnk;
                         if (flags == LINK_UNKNOWN_DEST_PORT &&
                             lnk->dst_addr.s_addr == dst_addr.s_addr) {
                                 lnk_unknown_dst_port = lnk;
                                 break;
                         }
                 }
         }
 
-        lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port
-            : (lnk_unknown_dst_addr != NULL) ? lnk_unknown_dst_addr
-            : lnk_unknown_all;
+        lnk = (lnk_unknown_dst_port != NULL) ? lnk_unknown_dst_port :
+            (lnk_unknown_dst_addr != NULL)   ? lnk_unknown_dst_addr :
+                                               lnk_unknown_all;
 
         if (lnk == NULL || !replace_partial_links)
                 return (lnk);
 
-        if (lnk->server != NULL) {        /* LSNAT link */
+        if (lnk->server != NULL) { /* LSNAT link */
                 src_addr = lnk->server->addr;
                 src_port = lnk->server->port;
                 lnk->server = lnk->server->next;
         } else {
                 src_addr = lnk->src_addr;
                 src_port = lnk->src_port;
         }
 
         if (link_type == LINK_SCTP) {
                 lnk->src_addr = src_addr;
                 lnk->src_port = src_port;
         } else {
-                lnk = ReLink(lnk,
-                    src_addr, dst_addr, alias_addr,
-                    src_port, dst_port, alias_port,
-                    link_type, 0);
+                lnk = ReLink(lnk, src_addr, dst_addr, alias_addr, src_port,
+                    dst_port, alias_port, link_type, 0);
         }
         return (lnk);
 }
 
 static struct alias_link *
 FindLinkIn(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short dst_port,
-    u_short alias_port,
-    int link_type,
-    int replace_partial_links)
+    struct in_addr alias_addr, u_short dst_port, u_short alias_port,
+    int link_type, int replace_partial_links)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         lnk = _FindLinkIn(la, dst_addr, alias_addr, dst_port, alias_port,
             link_type, replace_partial_links);
 
         if (lnk == NULL) {
                 /*
                  * The following allows permanent links to be specified as
                  * using the default aliasing address (i.e. device
                  * interface address) without knowing in advance what that
                  * address is.
                  */
                 if (la->aliasAddress.s_addr != INADDR_ANY &&
                     alias_addr.s_addr == la->aliasAddress.s_addr) {
-                        lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port, alias_port,
-                            link_type, replace_partial_links);
+                        lnk = _FindLinkIn(la, dst_addr, ANY_ADDR, dst_port,
+                            alias_port, link_type, replace_partial_links);
                 }
         }
         return (lnk);
 }
 
 /* External routines for finding/adding links
 
 -- "external" means outside alias_db.c, but within alias*.c --
 
     FindIcmpIn(), FindIcmpOut()
     FindFragmentIn1(), FindFragmentIn2()
     AddFragmentPtrLink(), FindFragmentPtr()
     FindProtoIn(), FindProtoOut()
     FindUdpTcpIn(), FindUdpTcpOut()
     AddPptp(), FindPptpOutByCallId(), FindPptpInByCallId(),
     FindPptpOutByPeerCallId(), FindPptpInByPeerCallId()
     FindOriginalAddress(), FindAliasAddress()
 
 (prototypes in alias_local.h)
 */
 
 struct alias_link *
 FindIcmpIn(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short id_alias,
-    int create)
+    struct in_addr alias_addr, u_short id_alias, int create)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkIn(la, dst_addr, alias_addr,
-            NO_DEST_PORT, id_alias,
+        lnk = FindLinkIn(la, dst_addr, alias_addr, NO_DEST_PORT, id_alias,
             LINK_ICMP, 0);
-        if (lnk == NULL && create && !(la->packetAliasMode & PKT_ALIAS_DENY_INCOMING)) {
+        if (lnk == NULL && create &&
+            !(la->packetAliasMode & PKT_ALIAS_DENY_INCOMING)) {
                 struct in_addr target_addr;
 
                 target_addr = FindOriginalAddress(la, alias_addr);
-                lnk = AddLink(la, target_addr, dst_addr, alias_addr,
-                    id_alias, NO_DEST_PORT, id_alias,
-                    LINK_ICMP);
+                lnk = AddLink(la, target_addr, dst_addr, alias_addr, id_alias,
+                    NO_DEST_PORT, id_alias, LINK_ICMP);
         }
         return (lnk);
 }
 
 struct alias_link *
 FindIcmpOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short id,
-    int create)
+    struct in_addr dst_addr, u_short id, int create)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkOut(la, src_addr, dst_addr,
-            id, NO_DEST_PORT,
-            LINK_ICMP, 0);
+        lnk = FindLinkOut(la, src_addr, dst_addr, id, NO_DEST_PORT, LINK_ICMP,
+            0);
         if (lnk == NULL && create) {
                 struct in_addr alias_addr;
 
                 alias_addr = FindAliasAddress(la, src_addr);
-                lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-                    id, NO_DEST_PORT, GET_ALIAS_ID,
-                    LINK_ICMP);
+                lnk = AddLink(la, src_addr, dst_addr, alias_addr, id,
+                    NO_DEST_PORT, GET_ALIAS_ID, LINK_ICMP);
         }
         return (lnk);
 }
 
 struct alias_link *
 FindFragmentIn1(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short ip_id)
+    struct in_addr alias_addr, u_short ip_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkIn(la, dst_addr, alias_addr,
-            NO_DEST_PORT, ip_id,
+        lnk = FindLinkIn(la, dst_addr, alias_addr, NO_DEST_PORT, ip_id,
             LINK_FRAGMENT_ID, 0);
 
         if (lnk == NULL) {
-                lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr,
-                    NO_SRC_PORT, NO_DEST_PORT, ip_id,
-                    LINK_FRAGMENT_ID);
+                lnk = AddLink(la, ANY_ADDR, dst_addr, alias_addr, NO_SRC_PORT,
+                    NO_DEST_PORT, ip_id, LINK_FRAGMENT_ID);
         }
         return (lnk);
 }
 
 /* Doesn't add a link if one is not found. */
 struct alias_link *
 FindFragmentIn2(struct libalias *la, struct in_addr dst_addr,
     struct in_addr alias_addr, u_short ip_id)
 {
         LIBALIAS_LOCK_ASSERT(la);
-        return FindLinkIn(la, dst_addr, alias_addr,
-            NO_DEST_PORT, ip_id,
+        return FindLinkIn(la, dst_addr, alias_addr, NO_DEST_PORT, ip_id,
             LINK_FRAGMENT_ID, 0);
 }
 
 struct alias_link *
-AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr,
-    u_short ip_id)
+AddFragmentPtrLink(struct libalias *la, struct in_addr dst_addr, u_short ip_id)
 {
         LIBALIAS_LOCK_ASSERT(la);
-        return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR,
-            NO_SRC_PORT, NO_DEST_PORT, ip_id,
-            LINK_FRAGMENT_PTR);
+        return AddLink(la, ANY_ADDR, dst_addr, ANY_ADDR, NO_SRC_PORT,
+            NO_DEST_PORT, ip_id, LINK_FRAGMENT_PTR);
 }
 
 struct alias_link *
-FindFragmentPtr(struct libalias *la, struct in_addr dst_addr,
-    u_short ip_id)
+FindFragmentPtr(struct libalias *la, struct in_addr dst_addr, u_short ip_id)
 {
         LIBALIAS_LOCK_ASSERT(la);
-        return FindLinkIn(la, dst_addr, ANY_ADDR,
-            NO_DEST_PORT, ip_id,
+        return FindLinkIn(la, dst_addr, ANY_ADDR, NO_DEST_PORT, ip_id,
             LINK_FRAGMENT_PTR, 0);
 }
 
 struct alias_link *
 FindProtoIn(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_char proto)
+    struct in_addr alias_addr, u_char proto)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkIn(la, dst_addr, alias_addr,
-            NO_DEST_PORT, 0,
-            proto, 1);
+        lnk = FindLinkIn(la, dst_addr, alias_addr, NO_DEST_PORT, 0, proto, 1);
 
         if (lnk == NULL && !(la->packetAliasMode & PKT_ALIAS_DENY_INCOMING)) {
                 struct in_addr target_addr;
 
                 target_addr = FindOriginalAddress(la, alias_addr);
                 lnk = AddLink(la, target_addr, dst_addr, alias_addr,
-                    NO_SRC_PORT, NO_DEST_PORT, 0,
-                    proto);
+                    NO_SRC_PORT, NO_DEST_PORT, 0, proto);
         }
         return (lnk);
 }
 
 struct alias_link *
 FindProtoOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_char proto)
+    struct in_addr dst_addr, u_char proto)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkOut(la, src_addr, dst_addr,
-            NO_SRC_PORT, NO_DEST_PORT,
+        lnk = FindLinkOut(la, src_addr, dst_addr, NO_SRC_PORT, NO_DEST_PORT,
             proto, 1);
 
         if (lnk == NULL) {
                 struct in_addr alias_addr;
 
                 alias_addr = FindAliasAddress(la, src_addr);
-                lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-                    NO_SRC_PORT, NO_DEST_PORT, 0,
-                    proto);
+                lnk = AddLink(la, src_addr, dst_addr, alias_addr, NO_SRC_PORT,
+                    NO_DEST_PORT, 0, proto);
         }
         return (lnk);
 }
 
 struct alias_link *
 FindUdpTcpIn(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_short dst_port,
-    u_short alias_port,
-    u_char proto,
-    int create)
+    struct in_addr alias_addr, u_short dst_port, u_short alias_port,
+    u_char proto, int create)
 {
         int link_type;
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         switch (proto) {
         case IPPROTO_UDP:
                 link_type = LINK_UDP;
                 break;
         case IPPROTO_TCP:
                 link_type = LINK_TCP;
                 break;
         default:
                 return (NULL);
                 break;
         }
 
-        lnk = FindLinkIn(la, dst_addr, alias_addr,
-            dst_port, alias_port,
+        lnk = FindLinkIn(la, dst_addr, alias_addr, dst_port, alias_port,
             link_type, create);
 
-        if (lnk == NULL && create && !(la->packetAliasMode & PKT_ALIAS_DENY_INCOMING)) {
+        if (lnk == NULL && create &&
+            !(la->packetAliasMode & PKT_ALIAS_DENY_INCOMING)) {
                 struct in_addr target_addr;
 
                 target_addr = FindOriginalAddress(la, alias_addr);
-                lnk = AddLink(la, target_addr, dst_addr, alias_addr,
-                    alias_port, dst_port, alias_port,
-                    link_type);
+                lnk = AddLink(la, target_addr, dst_addr, alias_addr, alias_port,
+                    dst_port, alias_port, link_type);
         }
         return (lnk);
 }
 
 struct alias_link *
 FindUdpTcpOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short src_port,
-    u_short dst_port,
-    u_char proto,
+    struct in_addr dst_addr, u_short src_port, u_short dst_port, u_char proto,
     int create)
 {
         int link_type;
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         switch (proto) {
         case IPPROTO_UDP:
                 link_type = LINK_UDP;
                 break;
         case IPPROTO_TCP:
                 link_type = LINK_TCP;
                 break;
         default:
                 return (NULL);
                 break;
         }
 
-        lnk = FindLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type, create);
+        lnk = FindLinkOut(la, src_addr, dst_addr, src_port, dst_port, link_type,
+            create);
 
         if (lnk == NULL && create) {
                 struct in_addr alias_addr;
 
                 alias_addr = FindAliasAddress(la, src_addr);
-                lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-                    src_port, dst_port, GET_ALIAS_PORT,
-                    link_type);
+                lnk = AddLink(la, src_addr, dst_addr, alias_addr, src_port,
+                    dst_port, GET_ALIAS_PORT, link_type);
         }
         return (lnk);
 }
 
 struct alias_link *
-AddPptp(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_int16_t src_call_id)
+AddPptp(struct libalias *la, struct in_addr src_addr, struct in_addr dst_addr,
+    struct in_addr alias_addr, u_int16_t src_call_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-            src_call_id, 0, GET_ALIAS_PORT,
-            LINK_PPTP);
+        lnk = AddLink(la, src_addr, dst_addr, alias_addr, src_call_id, 0,
+            GET_ALIAS_PORT, LINK_PPTP);
 
         return (lnk);
 }
 
 struct alias_link *
 FindPptpOutByCallId(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_int16_t src_call_id)
+    struct in_addr dst_addr, u_int16_t src_call_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         LIST_FOREACH(lnk, &la->pptpList, pptp.list)
                 if (lnk->src_addr.s_addr == src_addr.s_addr &&
                     lnk->dst_addr.s_addr == dst_addr.s_addr &&
                     lnk->src_port == src_call_id)
                         break;
 
         return (UseLink(la, lnk));
 }
 
 struct alias_link *
 FindPptpOutByPeerCallId(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_int16_t dst_call_id)
+    struct in_addr dst_addr, u_int16_t dst_call_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         LIST_FOREACH(lnk, &la->pptpList, pptp.list)
                 if (lnk->src_addr.s_addr == src_addr.s_addr &&
                     lnk->dst_addr.s_addr == dst_addr.s_addr &&
                     lnk->dst_port == dst_call_id)
                         break;
 
         return (UseLink(la, lnk));
 }
 
 struct alias_link *
 FindPptpInByCallId(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_int16_t dst_call_id)
+    struct in_addr alias_addr, u_int16_t dst_call_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
 
         LIST_FOREACH(lnk, &la->pptpList, pptp.list)
                 if (lnk->dst_port == dst_call_id &&
                     lnk->dst_addr.s_addr == dst_addr.s_addr &&
                     lnk->alias_addr.s_addr == alias_addr.s_addr)
                         break;
 
         return (UseLink(la, lnk));
 }
 
 struct alias_link *
 FindPptpInByPeerCallId(struct libalias *la, struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_int16_t alias_call_id)
+    struct in_addr alias_addr, u_int16_t alias_call_id)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         LIST_FOREACH(lnk, &la->pptpList, pptp.list)
                 if (lnk->alias_port == alias_call_id &&
                     lnk->dst_addr.s_addr == dst_addr.s_addr &&
                     lnk->alias_addr.s_addr == alias_addr.s_addr)
                         break;
 
         return (lnk);
 }
 
 struct alias_link *
 FindRtspOut(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    u_short src_port,
-    u_short alias_port,
-    u_char proto)
+    struct in_addr dst_addr, u_short src_port, u_short alias_port, u_char proto)
 {
         int link_type;
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
         switch (proto) {
         case IPPROTO_UDP:
                 link_type = LINK_UDP;
                 break;
         case IPPROTO_TCP:
                 link_type = LINK_TCP;
                 break;
         default:
                 return (NULL);
                 break;
         }
 
         lnk = FindLinkOut(la, src_addr, dst_addr, src_port, 0, link_type, 1);
 
         if (lnk == NULL) {
                 struct in_addr alias_addr;
 
                 alias_addr = FindAliasAddress(la, src_addr);
-                lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-                    src_port, 0, alias_port,
-                    link_type);
+                lnk = AddLink(la, src_addr, dst_addr, alias_addr, src_port, 0,
+                    alias_port, link_type);
         }
         return (lnk);
 }
 
 struct in_addr
 FindOriginalAddress(struct libalias *la, struct in_addr alias_addr)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkIn(la, ANY_ADDR, alias_addr,
-            0, 0, LINK_ADDR, 0);
+        lnk = FindLinkIn(la, ANY_ADDR, alias_addr, 0, 0, LINK_ADDR, 0);
         if (lnk == NULL) {
                 if (la->targetAddress.s_addr == INADDR_ANY)
                         return (alias_addr);
                 else if (la->targetAddress.s_addr == INADDR_NONE)
                         return (la->aliasAddress.s_addr != INADDR_ANY) ?
-                            la->aliasAddress : alias_addr;
+                            la->aliasAddress :
+                            alias_addr;
                 else
                         return (la->targetAddress);
         } else {
-                if (lnk->server != NULL) {        /* LSNAT link */
+                if (lnk->server != NULL) { /* LSNAT link */
                         struct in_addr src_addr;
 
                         src_addr = lnk->server->addr;
                         lnk->server = lnk->server->next;
                         return (src_addr);
                 } else if (lnk->src_addr.s_addr == INADDR_ANY)
                         return (la->aliasAddress.s_addr != INADDR_ANY) ?
-                            la->aliasAddress : alias_addr;
+                            la->aliasAddress :
+                            alias_addr;
                 else
                         return (lnk->src_addr);
         }
 }
 
 struct in_addr
 FindAliasAddress(struct libalias *la, struct in_addr original_addr)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK_ASSERT(la);
-        lnk = FindLinkOut(la, original_addr, ANY_ADDR,
-            0, 0, LINK_ADDR, 0);
+        lnk = FindLinkOut(la, original_addr, ANY_ADDR, 0, 0, LINK_ADDR, 0);
         if (lnk == NULL) {
                 return (la->aliasAddress.s_addr != INADDR_ANY) ?
-                    la->aliasAddress : original_addr;
+                    la->aliasAddress :
+                    original_addr;
         } else {
                 if (lnk->alias_addr.s_addr == INADDR_ANY)
                         return (la->aliasAddress.s_addr != INADDR_ANY) ?
-                            la->aliasAddress : original_addr;
+                            la->aliasAddress :
+                            original_addr;
                 else
                         return (lnk->alias_addr);
         }
 }
 
 /* External routines for getting or changing link data
    (external to alias_db.c, but internal to alias*.c)
 
GetFragmentPtr(struct alias_link *lnk, void **fptr)
         *fptr = lnk->data.frag_ptr;
 }
 
 void
 SetStateIn(struct alias_link *lnk, int state)
 {
         /* TCP input state */
         switch (state) {
-                case ALIAS_TCP_STATE_DISCONNECTED:
                 if (lnk->data.tcp->state.out != ALIAS_TCP_STATE_CONNECTED)
                         lnk->expire.time = TCP_EXPIRE_DEAD;
                 else
                         lnk->expire.time = TCP_EXPIRE_SINGLEDEAD;
                 break;
         case ALIAS_TCP_STATE_CONNECTED:
                 if (lnk->data.tcp->state.out == ALIAS_TCP_STATE_CONNECTED)
                         lnk->expire.time = TCP_EXPIRE_CONNECTED;
                 break;
         default:
 #ifdef _KERNEL
                 panic("libalias:SetStateIn() unknown state");
 #else
                 abort();
 #endif
         }
         lnk->data.tcp->state.in = state;
 }
 
 void
 SetStateOut(struct alias_link *lnk, int state)
 {
         /* TCP output state */
         switch (state) {
-                case ALIAS_TCP_STATE_DISCONNECTED:
                 if (lnk->data.tcp->state.in != ALIAS_TCP_STATE_CONNECTED)
                         lnk->expire.time = TCP_EXPIRE_DEAD;
                 else
                         lnk->expire.time = TCP_EXPIRE_SINGLEDEAD;
                 break;
         case ALIAS_TCP_STATE_CONNECTED:
                 if (lnk->data.tcp->state.in == ALIAS_TCP_STATE_CONNECTED)
                         lnk->expire.time = TCP_EXPIRE_CONNECTED;
#else
                 now = time(NULL);
 #endif
                 if (now != LibAliasTime) {
                         /* retry three times a second */
                         packet_limit = packets / 3;
                         packets = 0;
                         LibAliasTime = now;
                 }
-
         }
         /* Do a cleanup for the first packets of the new second only */
         if (packets < (la->udpLinkCount + la->tcpLinkCount)) {
-                struct alias_link * lnk = TAILQ_FIRST(&la->checkExpire);
+                struct alias_link *lnk = TAILQ_FIRST(&la->checkExpire);
 
                 CleanupLink(la, &lnk, 0);
         }
 }
 
 /* Init the log file and enable logging */
 static int
 InitPacketAliasLog(struct libalias *la)
 {
         LIBALIAS_LOCK_ASSERT(la);
         if (~la->packetAliasMode & PKT_ALIAS_LOG) {
 #ifdef _KERNEL
                 if ((la->logDesc = malloc(LIBALIAS_BUF_SIZE)))
                         ;
 #else
                 if ((la->logDesc = fopen("/var/log/alias.log", "w")))
-                        fprintf(la->logDesc, "PacketAlias/InitPacketAliasLog: Packet alias logging enabled.\n");
+                        fprintf(la->logDesc,
+                            "PacketAlias/InitPacketAliasLog: Packet alias logging enabled.\n");
 #endif
                 else
                         return (ENOMEM); /* log initialization failed */
                 la->packetAliasMode |= PKT_ALIAS_LOG;
         }
 
         return (1);
 }
-- "outside world" means other than alias*.c routines --
     PacketAliasSetMode()
 
 (prototypes in alias.h)
 */
 
 /* Redirection from a specific public addr:port to a
    private addr:port */
 struct alias_link *
-LibAliasRedirectPort(struct libalias *la, struct in_addr src_addr, u_short src_port,
-    struct in_addr dst_addr, u_short dst_port,
-    struct in_addr alias_addr, u_short alias_port,
-    u_char proto)
+LibAliasRedirectPort(struct libalias *la, struct in_addr src_addr,
+    u_short src_port, struct in_addr dst_addr, u_short dst_port,
+    struct in_addr alias_addr, u_short alias_port, u_char proto)
 {
         int link_type;
         struct alias_link *lnk;
 
         LIBALIAS_LOCK(la);
         switch (proto) {
         case IPPROTO_UDP:
                 link_type = LINK_UDP;
                 break;
         case IPPROTO_TCP:
                 link_type = LINK_TCP;
                 break;
         case IPPROTO_SCTP:
                 link_type = LINK_SCTP;
                 break;
         default:
 #ifdef LIBALIAS_DEBUG
                 fprintf(stderr, "PacketAliasRedirectPort(): ");
                 fprintf(stderr, "only SCTP, TCP and UDP protocols allowed\n");
 #endif
                 lnk = NULL;
                 goto getout;
         }
 
-        lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-            src_port, dst_port, alias_port,
-            link_type);
+        lnk = AddLink(la, src_addr, dst_addr, alias_addr, src_port, dst_port,
+            alias_port, link_type);
 
         if (lnk != NULL) {
                 lnk->flags |= LINK_PERMANENT;
         }
 #ifdef LIBALIAS_DEBUG
         else {
-                fprintf(stderr, "PacketAliasRedirectPort(): "
+                fprintf(stderr,
+                    "PacketAliasRedirectPort(): "
                     "call to AddLink() failed\n");
         }
 #endif
 
 getout:
         LIBALIAS_UNLOCK(la);
         return (lnk);
 }
 
 /* Add server to the pool of servers */
 int
-LibAliasAddServer(struct libalias *la, struct alias_link *lnk, struct in_addr addr, u_short port)
+LibAliasAddServer(struct libalias *la, struct alias_link *lnk,
+    struct in_addr addr, u_short port)
 {
         struct server *server;
         int res;
 
         LIBALIAS_LOCK(la);
         (void)la;
 
         switch (lnk->link_type) {
LibAliasAddServer(struct libalias *la, struct alias_link *lnk,
         LIBALIAS_UNLOCK(la);
         return (res);
 }
 
 /* Redirect packets of a given IP protocol from a specific
    public address to a private address */
 struct alias_link *
 LibAliasRedirectProto(struct libalias *la, struct in_addr src_addr,
-    struct in_addr dst_addr,
-    struct in_addr alias_addr,
-    u_char proto)
+    struct in_addr dst_addr, struct in_addr alias_addr, u_char proto)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK(la);
-        lnk = AddLink(la, src_addr, dst_addr, alias_addr,
-            NO_SRC_PORT, NO_DEST_PORT, 0,
-            proto);
+        lnk = AddLink(la, src_addr, dst_addr, alias_addr, NO_SRC_PORT,
+            NO_DEST_PORT, 0, proto);
 
         if (lnk != NULL) {
                 lnk->flags |= LINK_PERMANENT;
         }
 #ifdef LIBALIAS_DEBUG
         else {
-                fprintf(stderr, "PacketAliasRedirectProto(): "
+                fprintf(stderr,
+                    "PacketAliasRedirectProto(): "
                     "call to AddLink() failed\n");
         }
 #endif
 
         LIBALIAS_UNLOCK(la);
         return (lnk);
 }
 
 /* Static address translation */
 struct alias_link *
 LibAliasRedirectAddr(struct libalias *la, struct in_addr src_addr,
     struct in_addr alias_addr)
 {
         struct alias_link *lnk;
 
         LIBALIAS_LOCK(la);
-        lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr,
-            0, 0, 0,
-            LINK_ADDR);
+        lnk = AddLink(la, src_addr, ANY_ADDR, alias_addr, 0, 0, 0, LINK_ADDR);
 
         if (lnk != NULL) {
                 lnk->flags |= LINK_PERMANENT;
         }
 #ifdef LIBALIAS_DEBUG
         else {
-                fprintf(stderr, "PacketAliasRedirectAddr(): "
+                fprintf(stderr,
+                    "PacketAliasRedirectAddr(): "
                     "call to AddLink() failed\n");
         }
 #endif
 
         LIBALIAS_UNLOCK(la);
         return (lnk);
 }
 
LibAliasRedirectDelete(struct libalias *la, struct alias_link *lnk)
         DeleteLink(&lnk, 1);
         LIBALIAS_UNLOCK(la);
 }
 
 void
 LibAliasSetAddress(struct libalias *la, struct in_addr addr)
 {
         LIBALIAS_LOCK(la);
-        if (la->packetAliasMode & PKT_ALIAS_RESET_ON_ADDR_CHANGE
-            && la->aliasAddress.s_addr != addr.s_addr)
+        if (la->packetAliasMode & PKT_ALIAS_RESET_ON_ADDR_CHANGE &&
+            la->aliasAddress.s_addr != addr.s_addr)
                 CleanupAliasData(la, 0);
 
         la->aliasAddress = addr;
         LIBALIAS_UNLOCK(la);
 }
 
 void
 LibAliasSetAliasPortRange(struct libalias *la, u_short port_low,
     u_short port_high)
 {
         LIBALIAS_LOCK(la);
         if (port_low) {
                 la->aliasPortLower = port_low;
-                /* Add 1 to the aliasPortLength as modulo has range of 1 to n-1 */
+                /* Add 1 to the aliasPortLength as modulo has range of 1 to n-1
+                 */
                 la->aliasPortLength = port_high - port_low + 1;
         } else {
                 /* Set default values */
                 la->aliasPortLower = 0x8000;
                 la->aliasPortLength = 0x8000;
         }
         LIBALIAS_UNLOCK(la);
 }
while (!LIST_EMPTY(&instancehead))
                 LibAliasUninit(LIST_FIRST(&instancehead));
 }
 
 struct libalias *
 LibAliasInit(struct libalias *la)
 {
         if (la == NULL) {
 #ifdef _KERNEL
-#undef malloc   /* XXX: ugly */
+#undef malloc /* XXX: ugly */
                 la = malloc(sizeof *la, M_ALIAS, M_WAITOK | M_ZERO);
 #else
                 la = calloc(sizeof *la, 1);
                 if (la == NULL)
                         return (la);
 #endif
 
 #ifndef _KERNEL
#endif
         LIST_REMOVE(la, instancelist);
         LIBALIAS_UNLOCK(la);
         LIBALIAS_LOCK_DESTROY(la);
         free(la);
 }
 
 /* Change mode for some operations */
 unsigned int
-LibAliasSetMode(
-    struct libalias *la,
-    unsigned int flags,                /* Which state to bring flags to */
-    unsigned int mask                /* Mask of which flags to affect (use 0 to
-                                 * do a probe for flag values) */
+LibAliasSetMode(struct libalias *la,
+    unsigned int flags, /* Which state to bring flags to */
+    unsigned int mask   /* Mask of which flags to affect (use 0 to
 )
 {
         int res = -1;
 
         LIBALIAS_LOCK(la);
         if (flags & mask & PKT_ALIAS_LOG) {
                 /* Enable logging */
                 if (InitPacketAliasLog(la) == ENOMEM)

 /*****************
   Code to support firewall punching.  This shouldn't really be in this
   file, but making variables global is evil too.
   ****************/
 
 /* Firewall include files */
 #include <net/if.h>
 #include <netinet/ip_fw.h>
-#include <string.h>
+
 #include <err.h>
+#include <string.h>
 
 /*
  * helper function, updates the pointer to cmd with the length
  * of the current command, and also cleans up the first word of
  * the new command in case it has been clobbered before.
  */
 static ipfw_insn *
-next_cmd(ipfw_insn * cmd)
+next_cmd(ipfw_insn *cmd)
 {
         cmd += F_LEN(cmd);
         bzero(cmd, sizeof(*cmd));
         return (cmd);
 }
 
 /*
  * A function to fill simple commands of size 1.
  * Existing flags are preserved.
  */
 static ipfw_insn *
-fill_cmd(ipfw_insn * cmd, enum ipfw_opcodes opcode, int size,
-    int flags, u_int16_t arg)
+fill_cmd(ipfw_insn *cmd, enum ipfw_opcodes opcode, int size, int flags,
+    u_int16_t arg)
 {
         cmd->opcode = opcode;
         cmd->len = ((cmd->len | flags) & (F_NOT | F_OR)) | (size & F_LEN_MASK);
         cmd->arg1 = arg;
         return next_cmd(cmd);
 }
 
 static ipfw_insn *
-fill_ip(ipfw_insn * cmd1, enum ipfw_opcodes opcode, u_int32_t addr)
+fill_ip(ipfw_insn *cmd1, enum ipfw_opcodes opcode, u_int32_t addr)
 {
         ipfw_insn_ip *cmd = (ipfw_insn_ip *)cmd1;
 
         cmd->addr.s_addr = addr;
         return fill_cmd(cmd1, opcode, F_INSN_SIZE(ipfw_insn_u32), 0, 0);
 }
 
 static ipfw_insn *
-fill_one_port(ipfw_insn * cmd1, enum ipfw_opcodes opcode, u_int16_t port)
+fill_one_port(ipfw_insn *cmd1, enum ipfw_opcodes opcode, u_int16_t port)
 {
         ipfw_insn_u16 *cmd = (ipfw_insn_u16 *)cmd1;
 
         cmd->ports[0] = cmd->ports[1] = port;
         return fill_cmd(cmd1, opcode, F_INSN_SIZE(ipfw_insn_u16), 0, 0);
 }
 
 static int
-fill_rule(void *buf, int bufsize, int rulenum,
-    enum ipfw_opcodes action, int proto,
-    struct in_addr sa, u_int16_t sp, struct in_addr da, u_int16_t dp)
+fill_rule(void *buf, int bufsize, int rulenum, enum ipfw_opcodes action,
+    int proto, struct in_addr sa, u_int16_t sp, struct in_addr da, u_int16_t dp)
 {
         struct ip_fw *rule = (struct ip_fw *)buf;
         ipfw_insn *cmd = (ipfw_insn *)rule->cmd;
 
         bzero(buf, bufsize);
         rule->rulenum = rulenum;
 
         cmd = fill_cmd(cmd, O_PROTO, F_INSN_SIZE(ipfw_insn), 0, proto);
UninitPunchFW(struct libalias *la)
         la->packetAliasMode &= ~PKT_ALIAS_PUNCH_FW;
 }
 
 /* Make a certain link go through the firewall */
 void
 PunchFWHole(struct alias_link *lnk)
 {
         struct libalias *la;
-        int r;                  /* Result code */
-        struct ip_fw rule;        /* On-the-fly built rule */
-        int fwhole;             /* Where to punch hole */
+        int r;             /* Result code */
+        struct ip_fw rule; /* On-the-fly built rule */
+        int fwhole;        /* Where to punch hole */
 
         la = lnk->la;
 
         /* Don't do anything unless we are asked to */
-        if (!(la->packetAliasMode & PKT_ALIAS_PUNCH_FW) ||
-            la->fireWallFD < 0 ||
+        if (!(la->packetAliasMode & PKT_ALIAS_PUNCH_FW) || la->fireWallFD < 0 ||
             lnk->link_type != LINK_TCP)
                 return;
 
         memset(&rule, 0, sizeof rule);
 
         /** Build rule **/
 
         /* Find empty slot */
         for (fwhole = la->fireWallActiveNum;
-            fwhole < la->fireWallBaseNum + la->fireWallNumNums &&
-            fw_tstfield(la, la->fireWallField, fwhole);
-            fwhole++);
+             fwhole < la->fireWallBaseNum + la->fireWallNumNums &&
+             fw_tstfield(la, la->fireWallField, fwhole);
+             fwhole++)
+                ;
         if (fwhole == la->fireWallBaseNum + la->fireWallNumNums) {
                 for (fwhole = la->fireWallBaseNum;
-                    fwhole < la->fireWallActiveNum &&
-                    fw_tstfield(la, la->fireWallField, fwhole);
-                    fwhole++);
+                     fwhole < la->fireWallActiveNum &&
+                     fw_tstfield(la, la->fireWallField, fwhole);
+                     fwhole++)
+                        ;
                 if (fwhole == la->fireWallActiveNum) {
                         /* No rule point empty - we can't punch more holes. */
                         la->fireWallActiveNum = la->fireWallBaseNum;
 #ifdef LIBALIAS_DEBUG
-                        fprintf(stderr, "libalias: Unable to create firewall hole!\n");
+                        fprintf(stderr,
+                            "libalias: Unable to create firewall hole!\n");
 #endif
                         return;
                 }
         }
         /* Start next search at next position */
         la->fireWallActiveNum = fwhole + 1;
 
         /*
          * generate two rules of the form
          *
          * add fwhole accept tcp from OAddr OPort to DAddr DPort add fwhole
          * accept tcp from DAddr DPort to OAddr OPort
          */
         if (GetOriginalPort(lnk) != 0 && GetDestPort(lnk) != 0) {
                 u_int32_t rulebuf[255];
                 int i;
 
-                i = fill_rule(rulebuf, sizeof(rulebuf), fwhole,
-                    O_ACCEPT, IPPROTO_TCP,
-                    GetOriginalAddress(lnk), ntohs(GetOriginalPort(lnk)),
-                    GetDestAddress(lnk), ntohs(GetDestPort(lnk)));
-                r = setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_ADD, rulebuf, i);
+                i = fill_rule(rulebuf, sizeof(rulebuf), fwhole, O_ACCEPT,
+                    IPPROTO_TCP, GetOriginalAddress(lnk),
+                    ntohs(GetOriginalPort(lnk)), GetDestAddress(lnk),
+                    ntohs(GetDestPort(lnk)));
+                r = setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_ADD, rulebuf,
+                    i);
                 if (r)
                         err(1, "alias punch inbound(1) setsockopt(IP_FW_ADD)");
 
-                i = fill_rule(rulebuf, sizeof(rulebuf), fwhole,
-                    O_ACCEPT, IPPROTO_TCP,
-                    GetDestAddress(lnk), ntohs(GetDestPort(lnk)),
+                i = fill_rule(rulebuf, sizeof(rulebuf), fwhole, O_ACCEPT,
+                    IPPROTO_TCP, GetDestAddress(lnk), ntohs(GetDestPort(lnk)),
                     GetOriginalAddress(lnk), ntohs(GetOriginalPort(lnk)));
-                r = setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_ADD, rulebuf, i);
+                r = setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_ADD, rulebuf,
+                    i);
                 if (r)
                         err(1, "alias punch inbound(2) setsockopt(IP_FW_ADD)");
         }
 
         /* Indicate hole applied */
         lnk->data.tcp->fwhole = fwhole;
         fw_setfield(la, la->fireWallField, fwhole);
 }
 
 /* Remove a hole in a firewall associated with a particular alias
    lnk.  Calling this too often is harmless. */
 static void
 ClearFWHole(struct alias_link *lnk)
 {
         struct libalias *la;
 
         la = lnk->la;
         if (lnk->link_type == LINK_TCP) {
-                int fwhole = lnk->data.tcp->fwhole;  /* Where is the firewall hole? */
+                int fwhole =
+                    lnk->data.tcp->fwhole; /* Where is the firewall hole? */
                 struct ip_fw rule;
 
                 if (fwhole < 0)
                         return;
 
-                memset(&rule, 0, sizeof rule);        /* useless for ipfw2 */
+                memset(&rule, 0, sizeof rule); /* useless for ipfw2 */
                 while (!setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_DEL,
-                    &fwhole, sizeof fwhole));
+                    &fwhole, sizeof fwhole))
+                        ;
                 fw_clrfield(la, la->fireWallField, fwhole);
                 lnk->data.tcp->fwhole = -1;
         }
 }
 
 /* Clear out the entire range dedicated to firewall holes. */
 static void
 ClearAllFWHoles(struct libalias *la)
 {
-        struct ip_fw rule;        /* On-the-fly built rule */
+        struct ip_fw rule; /* On-the-fly built rule */
         int i;
 
         if (la->fireWallFD < 0)
                 return;
 
         memset(&rule, 0, sizeof rule);
-        for (i = la->fireWallBaseNum; i < la->fireWallBaseNum + la->fireWallNumNums; i++) {
+        for (i = la->fireWallBaseNum;
+             i < la->fireWallBaseNum + la->fireWallNumNums; i++) {
                 int r = i;
 
-                while (!setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_DEL, &r, sizeof r));
+                while (!setsockopt(la->fireWallFD, IPPROTO_IP, IP_FW_DEL, &r,
+                    sizeof r))
+                        ;
         }
         /* XXX: third arg correct here ? /phk */
         memset(la->fireWallField, 0, la->fireWallNumNums);
 }
 
 #endif /* !NO_FW_PUNCH */
 
 void
LibAliasSetSkinnyPort(struct libalias *la, unsigned int port)
         la->skinnyPort = port;
         LIBALIAS_UNLOCK(la);
 }
 
 /*
  * Find the address to redirect incoming packets
  */
 struct in_addr
-FindSctpRedirectAddress(struct libalias *la,  struct sctp_nat_msg *sm)
+FindSctpRedirectAddress(struct libalias *la, struct sctp_nat_msg *sm)
 {
         struct alias_link *lnk;
         struct in_addr redir;
 
         LIBALIAS_LOCK_ASSERT(la);
         lnk = FindLinkIn(la, sm->ip_hdr->ip_src, sm->ip_hdr->ip_dst,
-            sm->sctp_hdr->dest_port,sm->sctp_hdr->dest_port, LINK_SCTP, 1);
+            sm->sctp_hdr->dest_port, sm->sctp_hdr->dest_port, LINK_SCTP, 1);
         if (lnk != NULL) {
                 /* port redirect */
                 return (lnk->src_addr);
         } else {
-                redir = FindOriginalAddress(la,sm->ip_hdr->ip_dst);
+                redir = FindOriginalAddress(la, sm->ip_hdr->ip_dst);
                 if (redir.s_addr == la->aliasAddress.s_addr ||
                     redir.s_addr == la->targetAddress.s_addr) {
                         /* No address found */
-                        lnk = FindLinkIn(la, sm->ip_hdr->ip_src, sm->ip_hdr->ip_dst,
-                            NO_DEST_PORT, 0, LINK_SCTP, 1);
+                        lnk = FindLinkIn(la, sm->ip_hdr->ip_src,
+                            sm->ip_hdr->ip_dst, NO_DEST_PORT, 0, LINK_SCTP, 1);
                         if (lnk != NULL)
                                 /* redirect proto */
                                 return (lnk->src_addr);
                 }
                 return (redir); /* address redirect */
         }
 }