nat64lsn.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2015-2019 Yandex LLC
    5  * Copyright (c) 2015 Alexander V. Chernikov <melifaro@FreeBSD.org>
    6  * Copyright (c) 2015-2019 Andrey V. Elsukov <ae@FreeBSD.org>
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  *
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   28  *
   29  * $FreeBSD$
   30  */
   31 
   32 #ifndef _IP_FW_NAT64LSN_H_
   33 #define _IP_FW_NAT64LSN_H_
   34 
   35 #include "ip_fw_nat64.h"
   36 #include "nat64_translate.h"
   37 
   38 #define NAT64_MIN_PORT          1024
   39 struct nat64lsn_host;
   40 struct nat64lsn_alias;
   41 
   42 struct nat64lsn_state {
   43         /* IPv6 host entry keeps hash table to speedup state lookup */
   44         CK_SLIST_ENTRY(nat64lsn_state)  entries;
   45         struct nat64lsn_host    *host;
   46 
   47         struct in6_addr ip6_dst;        /* Destination IPv6 address */
   48 
   49         in_addr_t       ip_src;         /* Alias IPv4 address */
   50         in_addr_t       ip_dst;         /* Destination IPv4 address */
   51         uint16_t        dport;          /* Destination port */
   52         uint16_t        sport;          /* Source port */
   53 
   54         uint32_t        hval;
   55         uint32_t        flags;          /* Internal flags */
   56         uint16_t        aport;
   57         uint16_t        timestamp;      /* last used */
   58         uint8_t         proto;
   59         uint8_t         _spare[7];
   60 };
   61 
   62 struct nat64lsn_states_chunk {
   63         struct nat64lsn_state   state[64];
   64 };
   65 
   66 #define ISSET64(mask, bit)      ((mask) & ((uint64_t)1 << (bit)))
   67 #define ISSET32(mask, bit)      ((mask) & ((uint32_t)1 << (bit)))
   68 struct nat64lsn_pg {
   69         CK_SLIST_ENTRY(nat64lsn_pg)     entries;
   70 
   71         uint16_t                base_port;
   72         uint16_t                timestamp;
   73         uint8_t                 proto;
   74         uint8_t                 chunks_count;
   75         uint8_t                 spare[2];
   76 
   77         union {
   78                 uint64_t        freemask64;
   79                 uint32_t        freemask32[2];
   80                 uint64_t        *freemask64_chunk;
   81                 uint32_t        *freemask32_chunk;
   82                 void            *freemask_chunk;
   83         };
   84         union {
   85                 struct nat64lsn_states_chunk *states;
   86                 struct nat64lsn_states_chunk **states_chunk;
   87         };
   88 };
   89 
   90 #define CHUNK_BY_FADDR(p, a)    ((a) & ((p)->chunks_count - 1))
   91 
   92 #ifdef __LP64__
   93 #define FREEMASK_CHUNK(p, v)    \
   94     ((p)->chunks_count == 1 ? &(p)->freemask64 : \
   95         &(p)->freemask64_chunk[CHUNK_BY_FADDR(p, v)])
   96 #define FREEMASK_BITCOUNT(pg, faddr)    \
   97     bitcount64(*FREEMASK_CHUNK((pg), (faddr)))
   98 #else
   99 #define FREEMASK_CHUNK(p, v)    \
  100     ((p)->chunks_count == 1 ? &(p)->freemask32[0] : \
  101         &(p)->freemask32_chunk[CHUNK_BY_FADDR(p, v) * 2])
  102 #define FREEMASK_BITCOUNT(pg, faddr)    \
  103     bitcount64(*(uint64_t *)FREEMASK_CHUNK((pg), (faddr)))
  104 #endif /* !__LP64__ */
  105 
  106 struct nat64lsn_pgchunk {
  107         struct nat64lsn_pg      *pgptr[32];
  108 };
  109 
  110 struct nat64lsn_aliaslink {
  111         CK_SLIST_ENTRY(nat64lsn_aliaslink)      alias_entries;
  112         CK_SLIST_ENTRY(nat64lsn_aliaslink)      host_entries;
  113         struct nat64lsn_alias   *alias;
  114 };
  115 
  116 CK_SLIST_HEAD(nat64lsn_aliaslink_slist, nat64lsn_aliaslink);
  117 CK_SLIST_HEAD(nat64lsn_states_slist, nat64lsn_state);
  118 CK_SLIST_HEAD(nat64lsn_hosts_slist, nat64lsn_host);
  119 CK_SLIST_HEAD(nat64lsn_pg_slist, nat64lsn_pg);
  120 
  121 struct nat64lsn_alias {
  122         struct nat64lsn_aliaslink_slist hosts;
  123         struct nat64lsn_pg_slist        portgroups;
  124 
  125         struct mtx              lock;
  126         in_addr_t               addr;   /* host byte order */
  127         uint32_t                hosts_count;
  128         uint32_t                portgroups_count;
  129         uint32_t                tcp_chunkmask;
  130         uint32_t                udp_chunkmask;
  131         uint32_t                icmp_chunkmask;
  132 
  133         uint32_t                tcp_pgidx;
  134         uint32_t                udp_pgidx;
  135         uint32_t                icmp_pgidx;
  136         uint16_t                timestamp;
  137         uint16_t                spare;
  138 
  139         uint32_t                tcp_pgmask[32];
  140         uint32_t                udp_pgmask[32];
  141         uint32_t                icmp_pgmask[32];
  142         struct nat64lsn_pgchunk *tcp[32];
  143         struct nat64lsn_pgchunk *udp[32];
  144         struct nat64lsn_pgchunk *icmp[32];
  145 
  146         /* pointer to PG that can be used for faster state allocation */
  147         struct nat64lsn_pg      *tcp_pg;
  148         struct nat64lsn_pg      *udp_pg;
  149         struct nat64lsn_pg      *icmp_pg;
  150 };
  151 #define ALIAS_LOCK_INIT(p)      \
  152         mtx_init(&(p)->lock, "alias_lock", NULL, MTX_DEF)
  153 #define ALIAS_LOCK_DESTROY(p)   mtx_destroy(&(p)->lock)
  154 #define ALIAS_LOCK(p)           mtx_lock(&(p)->lock)
  155 #define ALIAS_UNLOCK(p)         mtx_unlock(&(p)->lock)
  156 
  157 #define NAT64LSN_HSIZE          256
  158 #define NAT64LSN_MAX_HSIZE      4096
  159 #define NAT64LSN_HOSTS_HSIZE    1024
  160 
  161 struct nat64lsn_host {
  162         struct in6_addr         addr;
  163         struct nat64lsn_aliaslink_slist aliases;
  164         struct nat64lsn_states_slist    *states_hash;
  165         CK_SLIST_ENTRY(nat64lsn_host)   entries;
  166         uint32_t                states_count;
  167         uint32_t                hval;
  168         uint32_t                flags;
  169 #define NAT64LSN_DEADHOST       1
  170 #define NAT64LSN_GROWHASH       2
  171         uint16_t                states_hashsize;
  172         uint16_t                timestamp;
  173         struct mtx              lock;
  174 };
  175 
  176 #define HOST_LOCK_INIT(p)       \
  177         mtx_init(&(p)->lock, "host_lock", NULL, MTX_DEF|MTX_NEW)
  178 #define HOST_LOCK_DESTROY(p)    mtx_destroy(&(p)->lock)
  179 #define HOST_LOCK(p)            mtx_lock(&(p)->lock)
  180 #define HOST_UNLOCK(p)          mtx_unlock(&(p)->lock)
  181 
  182 VNET_DECLARE(uint16_t, nat64lsn_eid);
  183 #define V_nat64lsn_eid          VNET(nat64lsn_eid)
  184 #define IPFW_TLV_NAT64LSN_NAME  IPFW_TLV_EACTION_NAME(V_nat64lsn_eid)
  185 
  186 /* Timestamp macro */
  187 #define _CT             ((int)time_uptime % 65536)
  188 #define SET_AGE(x)      (x) = _CT
  189 #define GET_AGE(x)      ((_CT >= (x)) ? _CT - (x): (int)65536 + _CT - (x))
  190 
  191 STAILQ_HEAD(nat64lsn_job_head, nat64lsn_job_item);
  192 
  193 struct nat64lsn_cfg {
  194         struct named_object     no;
  195 
  196         struct nat64lsn_hosts_slist     *hosts_hash;
  197         struct nat64lsn_alias   *aliases;       /* array of aliases */
  198 
  199         struct mtx      lock;
  200         uint32_t        hosts_hashsize;
  201         uint32_t        hash_seed;
  202 
  203         uint32_t        prefix4;        /* IPv4 prefix */
  204         uint32_t        pmask4;         /* IPv4 prefix mask */
  205         uint8_t         plen4;
  206         uint8_t         nomatch_verdict;/* Return value on no-match */
  207 
  208         uint32_t        hosts_count;    /* Number of items in host hash */
  209         uint32_t        states_chunks;  /* Number of states chunks per PG */
  210         uint32_t        jmaxlen;        /* Max jobqueue length */
  211         uint16_t        host_delete_delay;      /* Stale host delete delay */
  212         uint16_t        pgchunk_delete_delay;
  213         uint16_t        pg_delete_delay;        /* Stale portgroup del delay */
  214         uint16_t        st_syn_ttl;     /* TCP syn expire */
  215         uint16_t        st_close_ttl;   /* TCP fin expire */
  216         uint16_t        st_estab_ttl;   /* TCP established expire */
  217         uint16_t        st_udp_ttl;     /* UDP expire */
  218         uint16_t        st_icmp_ttl;    /* ICMP expire */
  219 
  220         struct nat64_config     base;
  221 #define NAT64LSN_FLAGSMASK      (NAT64_LOG | NAT64_ALLOW_PRIVATE)
  222 #define NAT64LSN_ANYPREFIX      0x00000100
  223 
  224         struct mtx              periodic_lock;
  225         struct callout          periodic;
  226         struct callout          jcallout;
  227         struct vnet             *vp;
  228         struct nat64lsn_job_head        jhead;
  229         int                     jlen;
  230         char                    name[64];       /* Nat instance name */
  231 };
  232 
  233 /* CFG_LOCK protects cfg->hosts_hash from modification */
  234 #define CFG_LOCK_INIT(p)        \
  235         mtx_init(&(p)->lock, "cfg_lock", NULL, MTX_DEF)
  236 #define CFG_LOCK_DESTROY(p)     mtx_destroy(&(p)->lock)
  237 #define CFG_LOCK(p)             mtx_lock(&(p)->lock)
  238 #define CFG_UNLOCK(p)           mtx_unlock(&(p)->lock)
  239 
  240 #define CALLOUT_LOCK_INIT(p)    \
  241         mtx_init(&(p)->periodic_lock, "periodic_lock", NULL, MTX_DEF)
  242 #define CALLOUT_LOCK_DESTROY(p) mtx_destroy(&(p)->periodic_lock)
  243 #define CALLOUT_LOCK(p)         mtx_lock(&(p)->periodic_lock)
  244 #define CALLOUT_UNLOCK(p)       mtx_unlock(&(p)->periodic_lock)
  245 
  246 struct nat64lsn_cfg *nat64lsn_init_instance(struct ip_fw_chain *ch,
  247     in_addr_t prefix, int plen);
  248 void nat64lsn_destroy_instance(struct nat64lsn_cfg *cfg);
  249 void nat64lsn_start_instance(struct nat64lsn_cfg *cfg);
  250 void nat64lsn_init_internal(void);
  251 void nat64lsn_uninit_internal(void);
  252 int ipfw_nat64lsn(struct ip_fw_chain *ch, struct ip_fw_args *args,
  253     ipfw_insn *cmd, int *done);
  254 
  255 #endif /* _IP_FW_NAT64LSN_H_ */
Cache object: 50070083090659e7679a92b9bd2d3ddd
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/netpfil/ipfw/nat64/nat64lsn.h

FreeBSD/Linux Kernel Cross Reference
sys/netpfil/ipfw/nat64/nat64lsn.h
