sys/netgraph/ng_nat.c

   1 /*-
   2  * Copyright 2005, Gleb Smirnoff <glebius@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/mbuf.h>
  33 #include <sys/malloc.h>
  34 #include <sys/ctype.h>
  35 #include <sys/errno.h>
  36 #include <sys/syslog.h>
  37
  38 #include <netinet/in_systm.h>
  39 #include <netinet/in.h>
  40 #include <netinet/ip.h>
  41 #include <netinet/ip_icmp.h>
  42 #include <netinet/tcp.h>
  43 #include <netinet/udp.h>
  44
  45 #include <netinet/libalias/alias.h>
  46
  47 #include <netgraph/ng_message.h>
  48 #include <netgraph/ng_parse.h>
  49 #include <netgraph/ng_nat.h>
  50 #include <netgraph/netgraph.h>
  51
  52 static ng_constructor_t ng_nat_constructor;
  53 static ng_rcvmsg_t      ng_nat_rcvmsg;
  54 static ng_shutdown_t    ng_nat_shutdown;
  55 static ng_newhook_t     ng_nat_newhook;
  56 static ng_rcvdata_t     ng_nat_rcvdata;
  57 static ng_disconnect_t  ng_nat_disconnect;
  58
  59 static struct mbuf * m_megapullup(struct mbuf *, int);
  60
  61 /* List of commands and how to convert arguments to/from ASCII. */
  62 static const struct ng_cmdlist ng_nat_cmdlist[] = {
  63         {
  64           NGM_NAT_COOKIE,
  65           NGM_NAT_SET_IPADDR,
  66           "setaliasaddr",
  67           &ng_parse_ipaddr_type,
  68           NULL
  69         },
  70         { 0 }
  71 };
  72
  73 /* Netgraph node type descriptor. */
  74 static struct ng_type typestruct = {
  75         .version =      NG_ABI_VERSION,
  76         .name =         NG_NAT_NODE_TYPE,
  77         .constructor =  ng_nat_constructor,
  78         .rcvmsg =       ng_nat_rcvmsg,
  79         .shutdown =     ng_nat_shutdown,
  80         .newhook =      ng_nat_newhook,
  81         .rcvdata =      ng_nat_rcvdata,
  82         .disconnect =   ng_nat_disconnect,
  83         .cmdlist =      ng_nat_cmdlist,
  84 };
  85 NETGRAPH_INIT(nat, &typestruct);
  86 MODULE_DEPEND(ng_nat, libalias, 1, 1, 1);
  87
  88 /* Information we store for each node. */
  89 struct ng_priv_priv {
  90         node_p          node;           /* back pointer to node */
  91         hook_p          in;             /* hook for demasquerading */
  92         hook_p          out;            /* hook for masquerading */
  93         struct libalias *lib;           /* libalias handler */
  94         uint32_t        flags;          /* status flags */
  95 };
  96 typedef struct ng_priv_priv *priv_p;
  97
  98 /* Values of flags */
  99 #define NGNAT_READY             0x1     /* We have everything to work */
 100 #define NGNAT_ADDR_DEFINED      0x2     /* NGM_NAT_SET_IPADDR happened */
 101
 102 static int
 103 ng_nat_constructor(node_p node)
 104 {
 105         priv_p priv;
 106
 107         /* Initialize private descriptor. */
 108         MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH,
 109                 M_NOWAIT | M_ZERO);
 110         if (priv == NULL)
 111                 return (ENOMEM);
 112
 113         /* Init aliasing engine. */
 114         priv->lib = LibAliasInit(NULL);
 115         if (priv->lib == NULL) {
 116                 FREE(priv, M_NETGRAPH);
 117                 return (ENOMEM);
 118         }
 119
 120         /* Set same ports on. */
 121         (void )LibAliasSetMode(priv->lib, PKT_ALIAS_SAME_PORTS,
 122             PKT_ALIAS_SAME_PORTS);
 123
 124         /* Link structs together. */
 125         NG_NODE_SET_PRIVATE(node, priv);
 126         priv->node = node;
 127
 128         /*
 129          * libalias is not thread safe, so our node
 130          * must be single threaded.
 131          */
 132         NG_NODE_FORCE_WRITER(node);
 133
 134         return (0);
 135 }
 136
 137 static int
 138 ng_nat_newhook(node_p node, hook_p hook, const char *name)
 139 {
 140         const priv_p priv = NG_NODE_PRIVATE(node);
 141
 142         if (strcmp(name, NG_NAT_HOOK_IN) == 0) {
 143                 priv->in = hook;
 144         } else if (strcmp(name, NG_NAT_HOOK_OUT) == 0) {
 145                 priv->out = hook;
 146         } else
 147                 return (EINVAL);
 148
 149         if (priv->out != NULL &&
 150             priv->in != NULL &&
 151             priv->flags & NGNAT_ADDR_DEFINED)
 152                 priv->flags |= NGNAT_READY;
 153
 154         return(0);
 155 }
 156
 157 static int
 158 ng_nat_rcvmsg(node_p node, item_p item, hook_p lasthook)
 159 {
 160         const priv_p priv = NG_NODE_PRIVATE(node);
 161         struct ng_mesg *resp = NULL;
 162         struct ng_mesg *msg;
 163         int error = 0;
 164
 165         NGI_GET_MSG(item, msg);
 166
 167         switch (msg->header.typecookie) {
 168         case NGM_NAT_COOKIE:
 169                 switch (msg->header.cmd) {
 170                 case NGM_NAT_SET_IPADDR:
 171                     {
 172                         struct in_addr *const ia = (struct in_addr *)msg->data;
 173
 174                         if (msg->header.arglen < sizeof(*ia)) {
 175                                 error = EINVAL;
 176                                 break;
 177                         }
 178
 179                         LibAliasSetAddress(priv->lib, *ia);
 180
 181                         priv->flags |= NGNAT_ADDR_DEFINED;
 182                         if (priv->out != NULL &&
 183                             priv->in != NULL)
 184                                 priv->flags |= NGNAT_READY;
 185                     }
 186                         break;
 187                 default:
 188                         error = EINVAL;         /* unknown command */
 189                         break;
 190                 }
 191                 break;
 192         default:
 193                 error = EINVAL;                 /* unknown cookie type */
 194                 break;
 195         }
 196
 197         NG_RESPOND_MSG(error, node, item, resp);
 198         NG_FREE_MSG(msg);
 199         return (error);
 200 }
 201
 202 static int
 203 ng_nat_rcvdata(hook_p hook, item_p item )
 204 {
 205         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 206         struct mbuf     *m;
 207         struct ip       *ip;
 208         int rval, error = 0;
 209         char *c;
 210
 211         if (!(priv->flags & NGNAT_READY)) {
 212                 NG_FREE_ITEM(item);
 213                 return (ENXIO);
 214         }
 215
 216         m = NGI_M(item);
 217
 218         if ((m = m_megapullup(m, m->m_pkthdr.len)) == NULL) {
 219                 NGI_M(item) = NULL;     /* avoid double free */
 220                 NG_FREE_ITEM(item);
 221                 return (ENOBUFS);
 222         }
 223
 224         NGI_M(item) = m;
 225
 226         c = mtod(m, char *);
 227         ip = mtod(m, struct ip *);
 228
 229         KASSERT(m->m_pkthdr.len == ntohs(ip->ip_len),
 230             ("ng_nat: ip_len != m_pkthdr.len"));
 231
 232         if (hook == priv->in) {
 233                 rval = LibAliasIn(priv->lib, c, MCLBYTES);
 234                 if (rval != PKT_ALIAS_OK) {
 235                         printf("in %u\n", rval);
 236                         NG_FREE_ITEM(item);
 237                         return (EINVAL);
 238                 }
 239                 m->m_pkthdr.len = m->m_len = ntohs(ip->ip_len);
 240                 NG_FWD_ITEM_HOOK(error, item, priv->out);
 241         } else if (hook == priv->out) {
 242                 rval = LibAliasOut(priv->lib, c, MCLBYTES);
 243                 if (rval != PKT_ALIAS_OK) {
 244                         printf("out %u\n", rval);
 245                         NG_FREE_ITEM(item);
 246                         return (EINVAL);
 247                 }
 248                 m->m_pkthdr.len = m->m_len = ntohs(ip->ip_len);
 249                 NG_FWD_ITEM_HOOK(error, item, priv->in);
 250         } else
 251                 panic("ng_nat: unknown hook!\n");
 252
 253         return (error);
 254 }
 255
 256 static int
 257 ng_nat_shutdown(node_p node)
 258 {
 259         const priv_p priv = NG_NODE_PRIVATE(node);
 260
 261         NG_NODE_SET_PRIVATE(node, NULL);
 262         NG_NODE_UNREF(node);
 263         LibAliasUninit(priv->lib);
 264         FREE(priv, M_NETGRAPH);
 265
 266         return (0);
 267 }
 268
 269 static int
 270 ng_nat_disconnect(hook_p hook)
 271 {
 272         const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
 273
 274         priv->flags &= ~NGNAT_READY;
 275
 276         if (hook == priv->out)
 277                 priv->out = NULL;
 278         if (hook == priv->in)
 279                 priv->in = NULL;
 280
 281         if (priv->out == NULL && priv->in == NULL)
 282                 ng_rmnode_self(NG_HOOK_NODE(hook));
 283
 284         return (0);
 285 }
 286
 287 /*
 288  * m_megapullup() function is a big hack.
 289  *
 290  * It allocates an mbuf with cluster and copies the whole
 291  * chain into cluster, so that it is all contigous and the
 292  * whole packet can be accessed via char pointer.
 293  *
 294  * This is required, because libalias doesn't have idea
 295  * about mbufs.
 296  */
 297 static struct mbuf *
 298 m_megapullup(struct mbuf *m, int len)
 299 {
 300         struct mbuf *mcl;
 301         caddr_t cp;
 302
 303         if (len > MCLBYTES)
 304                 goto bad;
 305
 306         if ((mcl = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR)) == NULL)
 307                 goto bad;
 308
 309         cp = mtod(mcl, caddr_t);
 310         m_copydata(m, 0, len, cp);
 311         m_move_pkthdr(mcl, m);
 312         mcl->m_len = mcl->m_pkthdr.len;
 313         m_freem(m);
 314
 315         return (mcl);
 316 bad:
 317         m_freem(m);
 318         return (NULL);
 319 }