LCOV - code coverage report
Current view: top level - include/net - xfrm.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 18 201 9.0 %
Date: 2020-09-30 20:25:40 Functions: 3 26 11.5 %
Branches: 13 280 4.6 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _NET_XFRM_H
       3                 :            : #define _NET_XFRM_H
       4                 :            : 
       5                 :            : #include <linux/compiler.h>
       6                 :            : #include <linux/xfrm.h>
       7                 :            : #include <linux/spinlock.h>
       8                 :            : #include <linux/list.h>
       9                 :            : #include <linux/skbuff.h>
      10                 :            : #include <linux/socket.h>
      11                 :            : #include <linux/pfkeyv2.h>
      12                 :            : #include <linux/ipsec.h>
      13                 :            : #include <linux/in6.h>
      14                 :            : #include <linux/mutex.h>
      15                 :            : #include <linux/audit.h>
      16                 :            : #include <linux/slab.h>
      17                 :            : #include <linux/refcount.h>
      18                 :            : 
      19                 :            : #include <net/sock.h>
      20                 :            : #include <net/dst.h>
      21                 :            : #include <net/ip.h>
      22                 :            : #include <net/route.h>
      23                 :            : #include <net/ipv6.h>
      24                 :            : #include <net/ip6_fib.h>
      25                 :            : #include <net/flow.h>
      26                 :            : #include <net/gro_cells.h>
      27                 :            : 
      28                 :            : #include <linux/interrupt.h>
      29                 :            : 
      30                 :            : #ifdef CONFIG_XFRM_STATISTICS
      31                 :            : #include <net/snmp.h>
      32                 :            : #endif
      33                 :            : 
      34                 :            : #define XFRM_PROTO_ESP          50
      35                 :            : #define XFRM_PROTO_AH           51
      36                 :            : #define XFRM_PROTO_COMP         108
      37                 :            : #define XFRM_PROTO_IPIP         4
      38                 :            : #define XFRM_PROTO_IPV6         41
      39                 :            : #define XFRM_PROTO_ROUTING      IPPROTO_ROUTING
      40                 :            : #define XFRM_PROTO_DSTOPTS      IPPROTO_DSTOPTS
      41                 :            : 
      42                 :            : #define XFRM_ALIGN4(len)        (((len) + 3) & ~3)
      43                 :            : #define XFRM_ALIGN8(len)        (((len) + 7) & ~7)
      44                 :            : #define MODULE_ALIAS_XFRM_MODE(family, encap) \
      45                 :            :         MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
      46                 :            : #define MODULE_ALIAS_XFRM_TYPE(family, proto) \
      47                 :            :         MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
      48                 :            : #define MODULE_ALIAS_XFRM_OFFLOAD_TYPE(family, proto) \
      49                 :            :         MODULE_ALIAS("xfrm-offload-" __stringify(family) "-" __stringify(proto))
      50                 :            : 
      51                 :            : #ifdef CONFIG_XFRM_STATISTICS
      52                 :            : #define XFRM_INC_STATS(net, field)      SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
      53                 :            : #else
      54                 :            : #define XFRM_INC_STATS(net, field)      ((void)(net))
      55                 :            : #endif
      56                 :            : 
      57                 :            : 
      58                 :            : /* Organization of SPD aka "XFRM rules"
      59                 :            :    ------------------------------------
      60                 :            : 
      61                 :            :    Basic objects:
      62                 :            :    - policy rule, struct xfrm_policy (=SPD entry)
      63                 :            :    - bundle of transformations, struct dst_entry == struct xfrm_dst (=SA bundle)
      64                 :            :    - instance of a transformer, struct xfrm_state (=SA)
      65                 :            :    - template to clone xfrm_state, struct xfrm_tmpl
      66                 :            : 
      67                 :            :    SPD is plain linear list of xfrm_policy rules, ordered by priority.
      68                 :            :    (To be compatible with existing pfkeyv2 implementations,
      69                 :            :    many rules with priority of 0x7fffffff are allowed to exist and
      70                 :            :    such rules are ordered in an unpredictable way, thanks to bsd folks.)
      71                 :            : 
      72                 :            :    Lookup is plain linear search until the first match with selector.
      73                 :            : 
      74                 :            :    If "action" is "block", then we prohibit the flow, otherwise:
      75                 :            :    if "xfrms_nr" is zero, the flow passes untransformed. Otherwise,
      76                 :            :    policy entry has list of up to XFRM_MAX_DEPTH transformations,
      77                 :            :    described by templates xfrm_tmpl. Each template is resolved
      78                 :            :    to a complete xfrm_state (see below) and we pack bundle of transformations
      79                 :            :    to a dst_entry returned to requestor.
      80                 :            : 
      81                 :            :    dst -. xfrm  .-> xfrm_state #1
      82                 :            :     |---. child .-> dst -. xfrm .-> xfrm_state #2
      83                 :            :                      |---. child .-> dst -. xfrm .-> xfrm_state #3
      84                 :            :                                       |---. child .-> NULL
      85                 :            : 
      86                 :            :    Bundles are cached at xrfm_policy struct (field ->bundles).
      87                 :            : 
      88                 :            : 
      89                 :            :    Resolution of xrfm_tmpl
      90                 :            :    -----------------------
      91                 :            :    Template contains:
      92                 :            :    1. ->mode         Mode: transport or tunnel
      93                 :            :    2. ->id.proto     Protocol: AH/ESP/IPCOMP
      94                 :            :    3. ->id.daddr     Remote tunnel endpoint, ignored for transport mode.
      95                 :            :       Q: allow to resolve security gateway?
      96                 :            :    4. ->id.spi          If not zero, static SPI.
      97                 :            :    5. ->saddr                Local tunnel endpoint, ignored for transport mode.
      98                 :            :    6. ->algos                List of allowed algos. Plain bitmask now.
      99                 :            :       Q: ealgos, aalgos, calgos. What a mess...
     100                 :            :    7. ->share                Sharing mode.
     101                 :            :       Q: how to implement private sharing mode? To add struct sock* to
     102                 :            :       flow id?
     103                 :            : 
     104                 :            :    Having this template we search through SAD searching for entries
     105                 :            :    with appropriate mode/proto/algo, permitted by selector.
     106                 :            :    If no appropriate entry found, it is requested from key manager.
     107                 :            : 
     108                 :            :    PROBLEMS:
     109                 :            :    Q: How to find all the bundles referring to a physical path for
     110                 :            :       PMTU discovery? Seems, dst should contain list of all parents...
     111                 :            :       and enter to infinite locking hierarchy disaster.
     112                 :            :       No! It is easier, we will not search for them, let them find us.
     113                 :            :       We add genid to each dst plus pointer to genid of raw IP route,
     114                 :            :       pmtu disc will update pmtu on raw IP route and increase its genid.
     115                 :            :       dst_check() will see this for top level and trigger resyncing
     116                 :            :       metrics. Plus, it will be made via sk->sk_dst_cache. Solved.
     117                 :            :  */
     118                 :            : 
     119                 :            : struct xfrm_state_walk {
     120                 :            :         struct list_head        all;
     121                 :            :         u8                      state;
     122                 :            :         u8                      dying;
     123                 :            :         u8                      proto;
     124                 :            :         u32                     seq;
     125                 :            :         struct xfrm_address_filter *filter;
     126                 :            : };
     127                 :            : 
     128                 :            : struct xfrm_state_offload {
     129                 :            :         struct net_device       *dev;
     130                 :            :         unsigned long           offload_handle;
     131                 :            :         unsigned int            num_exthdrs;
     132                 :            :         u8                      flags;
     133                 :            : };
     134                 :            : 
     135                 :            : struct xfrm_mode {
     136                 :            :         u8 encap;
     137                 :            :         u8 family;
     138                 :            :         u8 flags;
     139                 :            : };
     140                 :            : 
     141                 :            : /* Flags for xfrm_mode. */
     142                 :            : enum {
     143                 :            :         XFRM_MODE_FLAG_TUNNEL = 1,
     144                 :            : };
     145                 :            : 
     146                 :            : /* Full description of state of transformer. */
     147                 :            : struct xfrm_state {
     148                 :            :         possible_net_t          xs_net;
     149                 :            :         union {
     150                 :            :                 struct hlist_node       gclist;
     151                 :            :                 struct hlist_node       bydst;
     152                 :            :         };
     153                 :            :         struct hlist_node       bysrc;
     154                 :            :         struct hlist_node       byspi;
     155                 :            : 
     156                 :            :         refcount_t              refcnt;
     157                 :            :         spinlock_t              lock;
     158                 :            : 
     159                 :            :         struct xfrm_id          id;
     160                 :            :         struct xfrm_selector    sel;
     161                 :            :         struct xfrm_mark        mark;
     162                 :            :         u32                     if_id;
     163                 :            :         u32                     tfcpad;
     164                 :            : 
     165                 :            :         u32                     genid;
     166                 :            : 
     167                 :            :         /* Key manager bits */
     168                 :            :         struct xfrm_state_walk  km;
     169                 :            : 
     170                 :            :         /* Parameters of this state. */
     171                 :            :         struct {
     172                 :            :                 u32             reqid;
     173                 :            :                 u8              mode;
     174                 :            :                 u8              replay_window;
     175                 :            :                 u8              aalgo, ealgo, calgo;
     176                 :            :                 u8              flags;
     177                 :            :                 u16             family;
     178                 :            :                 xfrm_address_t  saddr;
     179                 :            :                 int             header_len;
     180                 :            :                 int             trailer_len;
     181                 :            :                 u32             extra_flags;
     182                 :            :                 struct xfrm_mark        smark;
     183                 :            :         } props;
     184                 :            : 
     185                 :            :         struct xfrm_lifetime_cfg lft;
     186                 :            : 
     187                 :            :         /* Data for transformer */
     188                 :            :         struct xfrm_algo_auth   *aalg;
     189                 :            :         struct xfrm_algo        *ealg;
     190                 :            :         struct xfrm_algo        *calg;
     191                 :            :         struct xfrm_algo_aead   *aead;
     192                 :            :         const char              *geniv;
     193                 :            : 
     194                 :            :         /* Data for encapsulator */
     195                 :            :         struct xfrm_encap_tmpl  *encap;
     196                 :            : 
     197                 :            :         /* Data for care-of address */
     198                 :            :         xfrm_address_t  *coaddr;
     199                 :            : 
     200                 :            :         /* IPComp needs an IPIP tunnel for handling uncompressed packets */
     201                 :            :         struct xfrm_state       *tunnel;
     202                 :            : 
     203                 :            :         /* If a tunnel, number of users + 1 */
     204                 :            :         atomic_t                tunnel_users;
     205                 :            : 
     206                 :            :         /* State for replay detection */
     207                 :            :         struct xfrm_replay_state replay;
     208                 :            :         struct xfrm_replay_state_esn *replay_esn;
     209                 :            : 
     210                 :            :         /* Replay detection state at the time we sent the last notification */
     211                 :            :         struct xfrm_replay_state preplay;
     212                 :            :         struct xfrm_replay_state_esn *preplay_esn;
     213                 :            : 
     214                 :            :         /* The functions for replay detection. */
     215                 :            :         const struct xfrm_replay *repl;
     216                 :            : 
     217                 :            :         /* internal flag that only holds state for delayed aevent at the
     218                 :            :          * moment
     219                 :            :         */
     220                 :            :         u32                     xflags;
     221                 :            : 
     222                 :            :         /* Replay detection notification settings */
     223                 :            :         u32                     replay_maxage;
     224                 :            :         u32                     replay_maxdiff;
     225                 :            : 
     226                 :            :         /* Replay detection notification timer */
     227                 :            :         struct timer_list       rtimer;
     228                 :            : 
     229                 :            :         /* Statistics */
     230                 :            :         struct xfrm_stats       stats;
     231                 :            : 
     232                 :            :         struct xfrm_lifetime_cur curlft;
     233                 :            :         struct hrtimer          mtimer;
     234                 :            : 
     235                 :            :         struct xfrm_state_offload xso;
     236                 :            : 
     237                 :            :         /* used to fix curlft->add_time when changing date */
     238                 :            :         long            saved_tmo;
     239                 :            : 
     240                 :            :         /* Last used time */
     241                 :            :         time64_t                lastused;
     242                 :            : 
     243                 :            :         struct page_frag xfrag;
     244                 :            : 
     245                 :            :         /* Reference to data common to all the instances of this
     246                 :            :          * transformer. */
     247                 :            :         const struct xfrm_type  *type;
     248                 :            :         struct xfrm_mode        inner_mode;
     249                 :            :         struct xfrm_mode        inner_mode_iaf;
     250                 :            :         struct xfrm_mode        outer_mode;
     251                 :            : 
     252                 :            :         const struct xfrm_type_offload  *type_offload;
     253                 :            : 
     254                 :            :         /* Security context */
     255                 :            :         struct xfrm_sec_ctx     *security;
     256                 :            : 
     257                 :            :         /* Private data of this transformer, format is opaque,
     258                 :            :          * interpreted by xfrm_type methods. */
     259                 :            :         void                    *data;
     260                 :            : };
     261                 :            : 
     262                 :            : static inline struct net *xs_net(struct xfrm_state *x)
     263                 :            : {
     264                 :            :         return read_pnet(&x->xs_net);
     265                 :            : }
     266                 :            : 
     267                 :            : /* xflags - make enum if more show up */
     268                 :            : #define XFRM_TIME_DEFER 1
     269                 :            : #define XFRM_SOFT_EXPIRE 2
     270                 :            : 
     271                 :            : enum {
     272                 :            :         XFRM_STATE_VOID,
     273                 :            :         XFRM_STATE_ACQ,
     274                 :            :         XFRM_STATE_VALID,
     275                 :            :         XFRM_STATE_ERROR,
     276                 :            :         XFRM_STATE_EXPIRED,
     277                 :            :         XFRM_STATE_DEAD
     278                 :            : };
     279                 :            : 
     280                 :            : /* callback structure passed from either netlink or pfkey */
     281                 :            : struct km_event {
     282                 :            :         union {
     283                 :            :                 u32 hard;
     284                 :            :                 u32 proto;
     285                 :            :                 u32 byid;
     286                 :            :                 u32 aevent;
     287                 :            :                 u32 type;
     288                 :            :         } data;
     289                 :            : 
     290                 :            :         u32     seq;
     291                 :            :         u32     portid;
     292                 :            :         u32     event;
     293                 :            :         struct net *net;
     294                 :            : };
     295                 :            : 
     296                 :            : struct xfrm_replay {
     297                 :            :         void    (*advance)(struct xfrm_state *x, __be32 net_seq);
     298                 :            :         int     (*check)(struct xfrm_state *x,
     299                 :            :                          struct sk_buff *skb,
     300                 :            :                          __be32 net_seq);
     301                 :            :         int     (*recheck)(struct xfrm_state *x,
     302                 :            :                            struct sk_buff *skb,
     303                 :            :                            __be32 net_seq);
     304                 :            :         void    (*notify)(struct xfrm_state *x, int event);
     305                 :            :         int     (*overflow)(struct xfrm_state *x, struct sk_buff *skb);
     306                 :            : };
     307                 :            : 
     308                 :            : struct xfrm_if_cb {
     309                 :            :         struct xfrm_if  *(*decode_session)(struct sk_buff *skb,
     310                 :            :                                            unsigned short family);
     311                 :            : };
     312                 :            : 
     313                 :            : void xfrm_if_register_cb(const struct xfrm_if_cb *ifcb);
     314                 :            : void xfrm_if_unregister_cb(void);
     315                 :            : 
     316                 :            : struct net_device;
     317                 :            : struct xfrm_type;
     318                 :            : struct xfrm_dst;
     319                 :            : struct xfrm_policy_afinfo {
     320                 :            :         struct dst_ops          *dst_ops;
     321                 :            :         struct dst_entry        *(*dst_lookup)(struct net *net,
     322                 :            :                                                int tos, int oif,
     323                 :            :                                                const xfrm_address_t *saddr,
     324                 :            :                                                const xfrm_address_t *daddr,
     325                 :            :                                                u32 mark);
     326                 :            :         int                     (*get_saddr)(struct net *net, int oif,
     327                 :            :                                              xfrm_address_t *saddr,
     328                 :            :                                              xfrm_address_t *daddr,
     329                 :            :                                              u32 mark);
     330                 :            :         int                     (*fill_dst)(struct xfrm_dst *xdst,
     331                 :            :                                             struct net_device *dev,
     332                 :            :                                             const struct flowi *fl);
     333                 :            :         struct dst_entry        *(*blackhole_route)(struct net *net, struct dst_entry *orig);
     334                 :            : };
     335                 :            : 
     336                 :            : int xfrm_policy_register_afinfo(const struct xfrm_policy_afinfo *afinfo, int family);
     337                 :            : void xfrm_policy_unregister_afinfo(const struct xfrm_policy_afinfo *afinfo);
     338                 :            : void km_policy_notify(struct xfrm_policy *xp, int dir,
     339                 :            :                       const struct km_event *c);
     340                 :            : void km_state_notify(struct xfrm_state *x, const struct km_event *c);
     341                 :            : 
     342                 :            : struct xfrm_tmpl;
     343                 :            : int km_query(struct xfrm_state *x, struct xfrm_tmpl *t,
     344                 :            :              struct xfrm_policy *pol);
     345                 :            : void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
     346                 :            : int __xfrm_state_delete(struct xfrm_state *x);
     347                 :            : 
     348                 :            : struct xfrm_state_afinfo {
     349                 :            :         u8                              family;
     350                 :            :         u8                              proto;
     351                 :            : 
     352                 :            :         const struct xfrm_type_offload *type_offload_esp;
     353                 :            : 
     354                 :            :         const struct xfrm_type          *type_esp;
     355                 :            :         const struct xfrm_type          *type_ipip;
     356                 :            :         const struct xfrm_type          *type_ipip6;
     357                 :            :         const struct xfrm_type          *type_comp;
     358                 :            :         const struct xfrm_type          *type_ah;
     359                 :            :         const struct xfrm_type          *type_routing;
     360                 :            :         const struct xfrm_type          *type_dstopts;
     361                 :            : 
     362                 :            :         int                     (*output)(struct net *net, struct sock *sk, struct sk_buff *skb);
     363                 :            :         int                     (*output_finish)(struct sock *sk, struct sk_buff *skb);
     364                 :            :         int                     (*extract_input)(struct xfrm_state *x,
     365                 :            :                                                  struct sk_buff *skb);
     366                 :            :         int                     (*extract_output)(struct xfrm_state *x,
     367                 :            :                                                   struct sk_buff *skb);
     368                 :            :         int                     (*transport_finish)(struct sk_buff *skb,
     369                 :            :                                                     int async);
     370                 :            :         void                    (*local_error)(struct sk_buff *skb, u32 mtu);
     371                 :            : };
     372                 :            : 
     373                 :            : int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
     374                 :            : int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
     375                 :            : struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family);
     376                 :            : struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family);
     377                 :            : 
     378                 :            : struct xfrm_input_afinfo {
     379                 :            :         unsigned int            family;
     380                 :            :         int                     (*callback)(struct sk_buff *skb, u8 protocol,
     381                 :            :                                             int err);
     382                 :            : };
     383                 :            : 
     384                 :            : int xfrm_input_register_afinfo(const struct xfrm_input_afinfo *afinfo);
     385                 :            : int xfrm_input_unregister_afinfo(const struct xfrm_input_afinfo *afinfo);
     386                 :            : 
     387                 :            : void xfrm_flush_gc(void);
     388                 :            : void xfrm_state_delete_tunnel(struct xfrm_state *x);
     389                 :            : 
     390                 :            : struct xfrm_type {
     391                 :            :         char                    *description;
     392                 :            :         struct module           *owner;
     393                 :            :         u8                      proto;
     394                 :            :         u8                      flags;
     395                 :            : #define XFRM_TYPE_NON_FRAGMENT  1
     396                 :            : #define XFRM_TYPE_REPLAY_PROT   2
     397                 :            : #define XFRM_TYPE_LOCAL_COADDR  4
     398                 :            : #define XFRM_TYPE_REMOTE_COADDR 8
     399                 :            : 
     400                 :            :         int                     (*init_state)(struct xfrm_state *x);
     401                 :            :         void                    (*destructor)(struct xfrm_state *);
     402                 :            :         int                     (*input)(struct xfrm_state *, struct sk_buff *skb);
     403                 :            :         int                     (*output)(struct xfrm_state *, struct sk_buff *pskb);
     404                 :            :         int                     (*reject)(struct xfrm_state *, struct sk_buff *,
     405                 :            :                                           const struct flowi *);
     406                 :            :         int                     (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
     407                 :            : };
     408                 :            : 
     409                 :            : int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
     410                 :            : void xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
     411                 :            : 
     412                 :            : struct xfrm_type_offload {
     413                 :            :         char            *description;
     414                 :            :         struct module   *owner;
     415                 :            :         u8              proto;
     416                 :            :         void            (*encap)(struct xfrm_state *, struct sk_buff *pskb);
     417                 :            :         int             (*input_tail)(struct xfrm_state *x, struct sk_buff *skb);
     418                 :            :         int             (*xmit)(struct xfrm_state *, struct sk_buff *pskb, netdev_features_t features);
     419                 :            : };
     420                 :            : 
     421                 :            : int xfrm_register_type_offload(const struct xfrm_type_offload *type, unsigned short family);
     422                 :            : void xfrm_unregister_type_offload(const struct xfrm_type_offload *type, unsigned short family);
     423                 :            : 
     424                 :            : static inline int xfrm_af2proto(unsigned int family)
     425                 :            : {
     426   [ #  #  #  #  :          0 :         switch(family) {
             #  #  #  #  
                      # ]
     427                 :            :         case AF_INET:
     428                 :            :                 return IPPROTO_IPIP;
     429                 :            :         case AF_INET6:
     430                 :            :                 return IPPROTO_IPV6;
     431                 :            :         default:
     432                 :            :                 return 0;
     433                 :            :         }
     434                 :            : }
     435                 :            : 
     436                 :            : static inline const struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
     437                 :            : {
     438   [ #  #  #  #  :          0 :         if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
          #  #  #  #  #  
                #  #  # ]
     439   [ #  #  #  # ]:          0 :             (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
     440                 :          0 :                 return &x->inner_mode;
     441                 :            :         else
     442                 :          0 :                 return &x->inner_mode_iaf;
     443                 :            : }
     444                 :            : 
     445                 :            : struct xfrm_tmpl {
     446                 :            : /* id in template is interpreted as:
     447                 :            :  * daddr - destination of tunnel, may be zero for transport mode.
     448                 :            :  * spi   - zero to acquire spi. Not zero if spi is static, then
     449                 :            :  *         daddr must be fixed too.
     450                 :            :  * proto - AH/ESP/IPCOMP
     451                 :            :  */
     452                 :            :         struct xfrm_id          id;
     453                 :            : 
     454                 :            : /* Source address of tunnel. Ignored, if it is not a tunnel. */
     455                 :            :         xfrm_address_t          saddr;
     456                 :            : 
     457                 :            :         unsigned short          encap_family;
     458                 :            : 
     459                 :            :         u32                     reqid;
     460                 :            : 
     461                 :            : /* Mode: transport, tunnel etc. */
     462                 :            :         u8                      mode;
     463                 :            : 
     464                 :            : /* Sharing mode: unique, this session only, this user only etc. */
     465                 :            :         u8                      share;
     466                 :            : 
     467                 :            : /* May skip this transfomration if no SA is found */
     468                 :            :         u8                      optional;
     469                 :            : 
     470                 :            : /* Skip aalgos/ealgos/calgos checks. */
     471                 :            :         u8                      allalgs;
     472                 :            : 
     473                 :            : /* Bit mask of algos allowed for acquisition */
     474                 :            :         u32                     aalgos;
     475                 :            :         u32                     ealgos;
     476                 :            :         u32                     calgos;
     477                 :            : };
     478                 :            : 
     479                 :            : #define XFRM_MAX_DEPTH          6
     480                 :            : #define XFRM_MAX_OFFLOAD_DEPTH  1
     481                 :            : 
     482                 :            : struct xfrm_policy_walk_entry {
     483                 :            :         struct list_head        all;
     484                 :            :         u8                      dead;
     485                 :            : };
     486                 :            : 
     487                 :            : struct xfrm_policy_walk {
     488                 :            :         struct xfrm_policy_walk_entry walk;
     489                 :            :         u8 type;
     490                 :            :         u32 seq;
     491                 :            : };
     492                 :            : 
     493                 :            : struct xfrm_policy_queue {
     494                 :            :         struct sk_buff_head     hold_queue;
     495                 :            :         struct timer_list       hold_timer;
     496                 :            :         unsigned long           timeout;
     497                 :            : };
     498                 :            : 
     499                 :            : struct xfrm_policy {
     500                 :            :         possible_net_t          xp_net;
     501                 :            :         struct hlist_node       bydst;
     502                 :            :         struct hlist_node       byidx;
     503                 :            : 
     504                 :            :         /* This lock only affects elements except for entry. */
     505                 :            :         rwlock_t                lock;
     506                 :            :         refcount_t              refcnt;
     507                 :            :         u32                     pos;
     508                 :            :         struct timer_list       timer;
     509                 :            : 
     510                 :            :         atomic_t                genid;
     511                 :            :         u32                     priority;
     512                 :            :         u32                     index;
     513                 :            :         u32                     if_id;
     514                 :            :         struct xfrm_mark        mark;
     515                 :            :         struct xfrm_selector    selector;
     516                 :            :         struct xfrm_lifetime_cfg lft;
     517                 :            :         struct xfrm_lifetime_cur curlft;
     518                 :            :         struct xfrm_policy_walk_entry walk;
     519                 :            :         struct xfrm_policy_queue polq;
     520                 :            :         bool                    bydst_reinsert;
     521                 :            :         u8                      type;
     522                 :            :         u8                      action;
     523                 :            :         u8                      flags;
     524                 :            :         u8                      xfrm_nr;
     525                 :            :         u16                     family;
     526                 :            :         struct xfrm_sec_ctx     *security;
     527                 :            :         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
     528                 :            :         struct hlist_node       bydst_inexact_list;
     529                 :            :         struct rcu_head         rcu;
     530                 :            : };
     531                 :            : 
     532                 :            : static inline struct net *xp_net(const struct xfrm_policy *xp)
     533                 :            : {
     534                 :            :         return read_pnet(&xp->xp_net);
     535                 :            : }
     536                 :            : 
     537                 :            : struct xfrm_kmaddress {
     538                 :            :         xfrm_address_t          local;
     539                 :            :         xfrm_address_t          remote;
     540                 :            :         u32                     reserved;
     541                 :            :         u16                     family;
     542                 :            : };
     543                 :            : 
     544                 :            : struct xfrm_migrate {
     545                 :            :         xfrm_address_t          old_daddr;
     546                 :            :         xfrm_address_t          old_saddr;
     547                 :            :         xfrm_address_t          new_daddr;
     548                 :            :         xfrm_address_t          new_saddr;
     549                 :            :         u8                      proto;
     550                 :            :         u8                      mode;
     551                 :            :         u16                     reserved;
     552                 :            :         u32                     reqid;
     553                 :            :         u16                     old_family;
     554                 :            :         u16                     new_family;
     555                 :            : };
     556                 :            : 
     557                 :            : #define XFRM_KM_TIMEOUT                30
     558                 :            : /* what happened */
     559                 :            : #define XFRM_REPLAY_UPDATE      XFRM_AE_CR
     560                 :            : #define XFRM_REPLAY_TIMEOUT     XFRM_AE_CE
     561                 :            : 
     562                 :            : /* default aevent timeout in units of 100ms */
     563                 :            : #define XFRM_AE_ETIME                   10
     564                 :            : /* Async Event timer multiplier */
     565                 :            : #define XFRM_AE_ETH_M                   10
     566                 :            : /* default seq threshold size */
     567                 :            : #define XFRM_AE_SEQT_SIZE               2
     568                 :            : 
     569                 :            : struct xfrm_mgr {
     570                 :            :         struct list_head        list;
     571                 :            :         int                     (*notify)(struct xfrm_state *x, const struct km_event *c);
     572                 :            :         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp);
     573                 :            :         struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
     574                 :            :         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
     575                 :            :         int                     (*notify_policy)(struct xfrm_policy *x, int dir, const struct km_event *c);
     576                 :            :         int                     (*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
     577                 :            :         int                     (*migrate)(const struct xfrm_selector *sel,
     578                 :            :                                            u8 dir, u8 type,
     579                 :            :                                            const struct xfrm_migrate *m,
     580                 :            :                                            int num_bundles,
     581                 :            :                                            const struct xfrm_kmaddress *k,
     582                 :            :                                            const struct xfrm_encap_tmpl *encap);
     583                 :            :         bool                    (*is_alive)(const struct km_event *c);
     584                 :            : };
     585                 :            : 
     586                 :            : int xfrm_register_km(struct xfrm_mgr *km);
     587                 :            : int xfrm_unregister_km(struct xfrm_mgr *km);
     588                 :            : 
     589                 :            : struct xfrm_tunnel_skb_cb {
     590                 :            :         union {
     591                 :            :                 struct inet_skb_parm h4;
     592                 :            :                 struct inet6_skb_parm h6;
     593                 :            :         } header;
     594                 :            : 
     595                 :            :         union {
     596                 :            :                 struct ip_tunnel *ip4;
     597                 :            :                 struct ip6_tnl *ip6;
     598                 :            :         } tunnel;
     599                 :            : };
     600                 :            : 
     601                 :            : #define XFRM_TUNNEL_SKB_CB(__skb) ((struct xfrm_tunnel_skb_cb *)&((__skb)->cb[0]))
     602                 :            : 
     603                 :            : /*
     604                 :            :  * This structure is used for the duration where packets are being
     605                 :            :  * transformed by IPsec.  As soon as the packet leaves IPsec the
     606                 :            :  * area beyond the generic IP part may be overwritten.
     607                 :            :  */
     608                 :            : struct xfrm_skb_cb {
     609                 :            :         struct xfrm_tunnel_skb_cb header;
     610                 :            : 
     611                 :            :         /* Sequence number for replay protection. */
     612                 :            :         union {
     613                 :            :                 struct {
     614                 :            :                         __u32 low;
     615                 :            :                         __u32 hi;
     616                 :            :                 } output;
     617                 :            :                 struct {
     618                 :            :                         __be32 low;
     619                 :            :                         __be32 hi;
     620                 :            :                 } input;
     621                 :            :         } seq;
     622                 :            : };
     623                 :            : 
     624                 :            : #define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
     625                 :            : 
     626                 :            : /*
     627                 :            :  * This structure is used by the afinfo prepare_input/prepare_output functions
     628                 :            :  * to transmit header information to the mode input/output functions.
     629                 :            :  */
     630                 :            : struct xfrm_mode_skb_cb {
     631                 :            :         struct xfrm_tunnel_skb_cb header;
     632                 :            : 
     633                 :            :         /* Copied from header for IPv4, always set to zero and DF for IPv6. */
     634                 :            :         __be16 id;
     635                 :            :         __be16 frag_off;
     636                 :            : 
     637                 :            :         /* IP header length (excluding options or extension headers). */
     638                 :            :         u8 ihl;
     639                 :            : 
     640                 :            :         /* TOS for IPv4, class for IPv6. */
     641                 :            :         u8 tos;
     642                 :            : 
     643                 :            :         /* TTL for IPv4, hop limitfor IPv6. */
     644                 :            :         u8 ttl;
     645                 :            : 
     646                 :            :         /* Protocol for IPv4, NH for IPv6. */
     647                 :            :         u8 protocol;
     648                 :            : 
     649                 :            :         /* Option length for IPv4, zero for IPv6. */
     650                 :            :         u8 optlen;
     651                 :            : 
     652                 :            :         /* Used by IPv6 only, zero for IPv4. */
     653                 :            :         u8 flow_lbl[3];
     654                 :            : };
     655                 :            : 
     656                 :            : #define XFRM_MODE_SKB_CB(__skb) ((struct xfrm_mode_skb_cb *)&((__skb)->cb[0]))
     657                 :            : 
     658                 :            : /*
     659                 :            :  * This structure is used by the input processing to locate the SPI and
     660                 :            :  * related information.
     661                 :            :  */
     662                 :            : struct xfrm_spi_skb_cb {
     663                 :            :         struct xfrm_tunnel_skb_cb header;
     664                 :            : 
     665                 :            :         unsigned int daddroff;
     666                 :            :         unsigned int family;
     667                 :            :         __be32 seq;
     668                 :            : };
     669                 :            : 
     670                 :            : #define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
     671                 :            : 
     672                 :            : #ifdef CONFIG_AUDITSYSCALL
     673                 :          0 : static inline struct audit_buffer *xfrm_audit_start(const char *op)
     674                 :            : {
     675                 :            :         struct audit_buffer *audit_buf = NULL;
     676                 :            : 
     677         [ #  # ]:          0 :         if (audit_enabled == AUDIT_OFF)
     678                 :            :                 return NULL;
     679                 :          0 :         audit_buf = audit_log_start(audit_context(), GFP_ATOMIC,
     680                 :            :                                     AUDIT_MAC_IPSEC_EVENT);
     681         [ #  # ]:          0 :         if (audit_buf == NULL)
     682                 :            :                 return NULL;
     683                 :          0 :         audit_log_format(audit_buf, "op=%s", op);
     684                 :          0 :         return audit_buf;
     685                 :            : }
     686                 :            : 
     687                 :          0 : static inline void xfrm_audit_helper_usrinfo(bool task_valid,
     688                 :            :                                              struct audit_buffer *audit_buf)
     689                 :            : {
     690         [ #  # ]:          0 :         const unsigned int auid = from_kuid(&init_user_ns, task_valid ?
     691                 :          0 :                                             audit_get_loginuid(current) :
     692                 :            :                                             INVALID_UID);
     693         [ #  # ]:          0 :         const unsigned int ses = task_valid ? audit_get_sessionid(current) :
     694                 :            :                 AUDIT_SID_UNSET;
     695                 :            : 
     696                 :          0 :         audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
     697                 :          0 :         audit_log_task_context(audit_buf);
     698                 :          0 : }
     699                 :            : 
     700                 :            : void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, bool task_valid);
     701                 :            : void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
     702                 :            :                               bool task_valid);
     703                 :            : void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid);
     704                 :            : void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid);
     705                 :            : void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
     706                 :            :                                       struct sk_buff *skb);
     707                 :            : void xfrm_audit_state_replay(struct xfrm_state *x, struct sk_buff *skb,
     708                 :            :                              __be32 net_seq);
     709                 :            : void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
     710                 :            : void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family, __be32 net_spi,
     711                 :            :                                __be32 net_seq);
     712                 :            : void xfrm_audit_state_icvfail(struct xfrm_state *x, struct sk_buff *skb,
     713                 :            :                               u8 proto);
     714                 :            : #else
     715                 :            : 
     716                 :            : static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
     717                 :            :                                          bool task_valid)
     718                 :            : {
     719                 :            : }
     720                 :            : 
     721                 :            : static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
     722                 :            :                                             bool task_valid)
     723                 :            : {
     724                 :            : }
     725                 :            : 
     726                 :            : static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
     727                 :            :                                         bool task_valid)
     728                 :            : {
     729                 :            : }
     730                 :            : 
     731                 :            : static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
     732                 :            :                                            bool task_valid)
     733                 :            : {
     734                 :            : }
     735                 :            : 
     736                 :            : static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
     737                 :            :                                              struct sk_buff *skb)
     738                 :            : {
     739                 :            : }
     740                 :            : 
     741                 :            : static inline void xfrm_audit_state_replay(struct xfrm_state *x,
     742                 :            :                                            struct sk_buff *skb, __be32 net_seq)
     743                 :            : {
     744                 :            : }
     745                 :            : 
     746                 :            : static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
     747                 :            :                                       u16 family)
     748                 :            : {
     749                 :            : }
     750                 :            : 
     751                 :            : static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
     752                 :            :                                       __be32 net_spi, __be32 net_seq)
     753                 :            : {
     754                 :            : }
     755                 :            : 
     756                 :            : static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
     757                 :            :                                      struct sk_buff *skb, u8 proto)
     758                 :            : {
     759                 :            : }
     760                 :            : #endif /* CONFIG_AUDITSYSCALL */
     761                 :            : 
     762                 :            : static inline void xfrm_pol_hold(struct xfrm_policy *policy)
     763                 :            : {
     764   [ #  #  #  #  :          0 :         if (likely(policy != NULL))
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     765                 :          0 :                 refcount_inc(&policy->refcnt);
     766                 :            : }
     767                 :            : 
     768                 :            : void xfrm_policy_destroy(struct xfrm_policy *policy);
     769                 :            : 
     770                 :          0 : static inline void xfrm_pol_put(struct xfrm_policy *policy)
     771                 :            : {
     772         [ #  # ]:          0 :         if (refcount_dec_and_test(&policy->refcnt))
     773                 :          0 :                 xfrm_policy_destroy(policy);
     774                 :          0 : }
     775                 :            : 
     776                 :       8068 : static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
     777                 :            : {
     778                 :            :         int i;
     779         [ -  + ]:       8068 :         for (i = npols - 1; i >= 0; --i)
     780                 :          0 :                 xfrm_pol_put(pols[i]);
     781                 :       8068 : }
     782                 :            : 
     783                 :            : void __xfrm_state_destroy(struct xfrm_state *, bool);
     784                 :            : 
     785                 :            : static inline void __xfrm_state_put(struct xfrm_state *x)
     786                 :            : {
     787                 :          0 :         refcount_dec(&x->refcnt);
     788                 :            : }
     789                 :            : 
     790                 :          0 : static inline void xfrm_state_put(struct xfrm_state *x)
     791                 :            : {
     792         [ #  # ]:          0 :         if (refcount_dec_and_test(&x->refcnt))
     793                 :          0 :                 __xfrm_state_destroy(x, false);
     794                 :          0 : }
     795                 :            : 
     796                 :          0 : static inline void xfrm_state_put_sync(struct xfrm_state *x)
     797                 :            : {
     798         [ #  # ]:          0 :         if (refcount_dec_and_test(&x->refcnt))
     799                 :          0 :                 __xfrm_state_destroy(x, true);
     800                 :          0 : }
     801                 :            : 
     802                 :            : static inline void xfrm_state_hold(struct xfrm_state *x)
     803                 :            : {
     804                 :          0 :         refcount_inc(&x->refcnt);
     805                 :            : }
     806                 :            : 
     807                 :          0 : static inline bool addr_match(const void *token1, const void *token2,
     808                 :            :                               unsigned int prefixlen)
     809                 :            : {
     810                 :            :         const __be32 *a1 = token1;
     811                 :            :         const __be32 *a2 = token2;
     812                 :            :         unsigned int pdw;
     813                 :            :         unsigned int pbi;
     814                 :            : 
     815                 :          0 :         pdw = prefixlen >> 5;       /* num of whole u32 in prefix */
     816                 :          0 :         pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
     817                 :            : 
     818         [ #  # ]:          0 :         if (pdw)
     819         [ #  # ]:          0 :                 if (memcmp(a1, a2, pdw << 2))
     820                 :            :                         return false;
     821                 :            : 
     822         [ #  # ]:          0 :         if (pbi) {
     823                 :            :                 __be32 mask;
     824                 :            : 
     825                 :          0 :                 mask = htonl((0xffffffff) << (32 - pbi));
     826                 :            : 
     827         [ #  # ]:          0 :                 if ((a1[pdw] ^ a2[pdw]) & mask)
     828                 :            :                         return false;
     829                 :            :         }
     830                 :            : 
     831                 :          0 :         return true;
     832                 :            : }
     833                 :            : 
     834                 :            : static inline bool addr4_match(__be32 a1, __be32 a2, u8 prefixlen)
     835                 :            : {
     836                 :            :         /* C99 6.5.7 (3): u32 << 32 is undefined behaviour */
     837   [ #  #  #  # ]:          0 :         if (sizeof(long) == 4 && prefixlen == 0)
     838                 :            :                 return true;
     839                 :          0 :         return !((a1 ^ a2) & htonl(~0UL << (32 - prefixlen)));
     840                 :            : }
     841                 :            : 
     842                 :            : static __inline__
     843                 :          0 : __be16 xfrm_flowi_sport(const struct flowi *fl, const union flowi_uli *uli)
     844                 :            : {
     845                 :            :         __be16 port;
     846   [ #  #  #  #  :          0 :         switch(fl->flowi_proto) {
                      # ]
     847                 :            :         case IPPROTO_TCP:
     848                 :            :         case IPPROTO_UDP:
     849                 :            :         case IPPROTO_UDPLITE:
     850                 :            :         case IPPROTO_SCTP:
     851                 :          0 :                 port = uli->ports.sport;
     852                 :          0 :                 break;
     853                 :            :         case IPPROTO_ICMP:
     854                 :            :         case IPPROTO_ICMPV6:
     855                 :          0 :                 port = htons(uli->icmpt.type);
     856                 :          0 :                 break;
     857                 :            :         case IPPROTO_MH:
     858                 :          0 :                 port = htons(uli->mht.type);
     859                 :          0 :                 break;
     860                 :            :         case IPPROTO_GRE:
     861                 :          0 :                 port = htons(ntohl(uli->gre_key) >> 16);
     862                 :          0 :                 break;
     863                 :            :         default:
     864                 :            :                 port = 0;       /*XXX*/
     865                 :            :         }
     866                 :          0 :         return port;
     867                 :            : }
     868                 :            : 
     869                 :            : static __inline__
     870                 :          0 : __be16 xfrm_flowi_dport(const struct flowi *fl, const union flowi_uli *uli)
     871                 :            : {
     872                 :            :         __be16 port;
     873   [ #  #  #  # ]:          0 :         switch(fl->flowi_proto) {
     874                 :            :         case IPPROTO_TCP:
     875                 :            :         case IPPROTO_UDP:
     876                 :            :         case IPPROTO_UDPLITE:
     877                 :            :         case IPPROTO_SCTP:
     878                 :          0 :                 port = uli->ports.dport;
     879                 :          0 :                 break;
     880                 :            :         case IPPROTO_ICMP:
     881                 :            :         case IPPROTO_ICMPV6:
     882                 :          0 :                 port = htons(uli->icmpt.code);
     883                 :          0 :                 break;
     884                 :            :         case IPPROTO_GRE:
     885                 :          0 :                 port = htons(ntohl(uli->gre_key) & 0xffff);
     886                 :          0 :                 break;
     887                 :            :         default:
     888                 :            :                 port = 0;       /*XXX*/
     889                 :            :         }
     890                 :          0 :         return port;
     891                 :            : }
     892                 :            : 
     893                 :            : bool xfrm_selector_match(const struct xfrm_selector *sel,
     894                 :            :                          const struct flowi *fl, unsigned short family);
     895                 :            : 
     896                 :            : #ifdef CONFIG_SECURITY_NETWORK_XFRM
     897                 :            : /*      If neither has a context --> match
     898                 :            :  *      Otherwise, both must have a context and the sids, doi, alg must match
     899                 :            :  */
     900                 :            : static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
     901                 :            : {
     902                 :            :         return ((!s1 && !s2) ||
     903                 :            :                 (s1 && s2 &&
     904                 :            :                  (s1->ctx_sid == s2->ctx_sid) &&
     905                 :            :                  (s1->ctx_doi == s2->ctx_doi) &&
     906                 :            :                  (s1->ctx_alg == s2->ctx_alg)));
     907                 :            : }
     908                 :            : #else
     909                 :            : static inline bool xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
     910                 :            : {
     911                 :            :         return true;
     912                 :            : }
     913                 :            : #endif
     914                 :            : 
     915                 :            : /* A struct encoding bundle of transformations to apply to some set of flow.
     916                 :            :  *
     917                 :            :  * xdst->child points to the next element of bundle.
     918                 :            :  * dst->xfrm  points to an instanse of transformer.
     919                 :            :  *
     920                 :            :  * Due to unfortunate limitations of current routing cache, which we
     921                 :            :  * have no time to fix, it mirrors struct rtable and bound to the same
     922                 :            :  * routing key, including saddr,daddr. However, we can have many of
     923                 :            :  * bundles differing by session id. All the bundles grow from a parent
     924                 :            :  * policy rule.
     925                 :            :  */
     926                 :            : struct xfrm_dst {
     927                 :            :         union {
     928                 :            :                 struct dst_entry        dst;
     929                 :            :                 struct rtable           rt;
     930                 :            :                 struct rt6_info         rt6;
     931                 :            :         } u;
     932                 :            :         struct dst_entry *route;
     933                 :            :         struct dst_entry *child;
     934                 :            :         struct dst_entry *path;
     935                 :            :         struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
     936                 :            :         int num_pols, num_xfrms;
     937                 :            :         u32 xfrm_genid;
     938                 :            :         u32 policy_genid;
     939                 :            :         u32 route_mtu_cached;
     940                 :            :         u32 child_mtu_cached;
     941                 :            :         u32 route_cookie;
     942                 :            :         u32 path_cookie;
     943                 :            : };
     944                 :            : 
     945                 :            : static inline struct dst_entry *xfrm_dst_path(const struct dst_entry *dst)
     946                 :            : {
     947                 :            : #ifdef CONFIG_XFRM
     948   [ +  -  -  +  :       2438 :         if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
          +  -  -  +  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     949                 :            :                 const struct xfrm_dst *xdst = (const struct xfrm_dst *) dst;
     950                 :            : 
     951                 :          0 :                 return xdst->path;
     952                 :            :         }
     953                 :            : #endif
     954                 :            :         return (struct dst_entry *) dst;
     955                 :            : }
     956                 :            : 
     957                 :            : static inline struct dst_entry *xfrm_dst_child(const struct dst_entry *dst)
     958                 :            : {
     959                 :            : #ifdef CONFIG_XFRM
     960   [ #  #  #  #  :          0 :         if (dst->xfrm || (dst->flags & DST_XFRM_QUEUE)) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     961                 :            :                 struct xfrm_dst *xdst = (struct xfrm_dst *) dst;
     962                 :          0 :                 return xdst->child;
     963                 :            :         }
     964                 :            : #endif
     965                 :            :         return NULL;
     966                 :            : }
     967                 :            : 
     968                 :            : #ifdef CONFIG_XFRM
     969                 :            : static inline void xfrm_dst_set_child(struct xfrm_dst *xdst, struct dst_entry *child)
     970                 :            : {
     971                 :          0 :         xdst->child = child;
     972                 :            : }
     973                 :            : 
     974                 :          0 : static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
     975                 :            : {
     976                 :          0 :         xfrm_pols_put(xdst->pols, xdst->num_pols);
     977                 :          0 :         dst_release(xdst->route);
     978         [ #  # ]:          0 :         if (likely(xdst->u.dst.xfrm))
     979                 :          0 :                 xfrm_state_put(xdst->u.dst.xfrm);
     980                 :          0 : }
     981                 :            : #endif
     982                 :            : 
     983                 :            : void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
     984                 :            : 
     985                 :            : struct xfrm_if_parms {
     986                 :            :         int link;               /* ifindex of underlying L2 interface */
     987                 :            :         u32 if_id;              /* interface identifyer */
     988                 :            : };
     989                 :            : 
     990                 :            : struct xfrm_if {
     991                 :            :         struct xfrm_if __rcu *next;     /* next interface in list */
     992                 :            :         struct net_device *dev;         /* virtual device associated with interface */
     993                 :            :         struct net *net;                /* netns for packet i/o */
     994                 :            :         struct xfrm_if_parms p;         /* interface parms */
     995                 :            : 
     996                 :            :         struct gro_cells gro_cells;
     997                 :            : };
     998                 :            : 
     999                 :            : struct xfrm_offload {
    1000                 :            :         /* Output sequence number for replay protection on offloading. */
    1001                 :            :         struct {
    1002                 :            :                 __u32 low;
    1003                 :            :                 __u32 hi;
    1004                 :            :         } seq;
    1005                 :            : 
    1006                 :            :         __u32                   flags;
    1007                 :            : #define SA_DELETE_REQ           1
    1008                 :            : #define CRYPTO_DONE             2
    1009                 :            : #define CRYPTO_NEXT_DONE        4
    1010                 :            : #define CRYPTO_FALLBACK         8
    1011                 :            : #define XFRM_GSO_SEGMENT        16
    1012                 :            : #define XFRM_GRO                32
    1013                 :            : #define XFRM_ESP_NO_TRAILER     64
    1014                 :            : #define XFRM_DEV_RESUME         128
    1015                 :            : #define XFRM_XMIT               256
    1016                 :            : 
    1017                 :            :         __u32                   status;
    1018                 :            : #define CRYPTO_SUCCESS                          1
    1019                 :            : #define CRYPTO_GENERIC_ERROR                    2
    1020                 :            : #define CRYPTO_TRANSPORT_AH_AUTH_FAILED         4
    1021                 :            : #define CRYPTO_TRANSPORT_ESP_AUTH_FAILED        8
    1022                 :            : #define CRYPTO_TUNNEL_AH_AUTH_FAILED            16
    1023                 :            : #define CRYPTO_TUNNEL_ESP_AUTH_FAILED           32
    1024                 :            : #define CRYPTO_INVALID_PACKET_SYNTAX            64
    1025                 :            : #define CRYPTO_INVALID_PROTOCOL                 128
    1026                 :            : 
    1027                 :            :         __u8                    proto;
    1028                 :            : };
    1029                 :            : 
    1030                 :            : struct sec_path {
    1031                 :            :         int                     len;
    1032                 :            :         int                     olen;
    1033                 :            : 
    1034                 :            :         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
    1035                 :            :         struct xfrm_offload     ovec[XFRM_MAX_OFFLOAD_DEPTH];
    1036                 :            : };
    1037                 :            : 
    1038                 :            : struct sec_path *secpath_set(struct sk_buff *skb);
    1039                 :            : 
    1040                 :            : static inline void
    1041                 :            : secpath_reset(struct sk_buff *skb)
    1042                 :            : {
    1043                 :            : #ifdef CONFIG_XFRM
    1044                 :            :         skb_ext_del(skb, SKB_EXT_SEC_PATH);
    1045                 :            : #endif
    1046                 :            : }
    1047                 :            : 
    1048                 :            : static inline int
    1049                 :            : xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
    1050                 :            : {
    1051   [ #  #  #  #  :          0 :         switch (family) {
                   #  # ]
    1052                 :            :         case AF_INET:
    1053                 :          0 :                 return addr->a4 == 0;
    1054                 :            :         case AF_INET6:
    1055                 :          0 :                 return ipv6_addr_any(&addr->in6);
    1056                 :            :         }
    1057                 :            :         return 0;
    1058                 :            : }
    1059                 :            : 
    1060                 :            : static inline int
    1061                 :            : __xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
    1062                 :            : {
    1063   [ #  #  #  # ]:          0 :         return  (tmpl->saddr.a4 &&
    1064                 :          0 :                  tmpl->saddr.a4 != x->props.saddr.a4);
    1065                 :            : }
    1066                 :            : 
    1067                 :            : static inline int
    1068                 :          0 : __xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
    1069                 :            : {
    1070   [ #  #  #  # ]:          0 :         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
    1071                 :            :                  !ipv6_addr_equal((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
    1072                 :            : }
    1073                 :            : 
    1074                 :            : static inline int
    1075                 :          0 : xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
    1076                 :            : {
    1077      [ #  #  # ]:          0 :         switch (family) {
    1078                 :            :         case AF_INET:
    1079                 :          0 :                 return __xfrm4_state_addr_cmp(tmpl, x);
    1080                 :            :         case AF_INET6:
    1081                 :          0 :                 return __xfrm6_state_addr_cmp(tmpl, x);
    1082                 :            :         }
    1083                 :            :         return !0;
    1084                 :            : }
    1085                 :            : 
    1086                 :            : #ifdef CONFIG_XFRM
    1087                 :            : int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb,
    1088                 :            :                         unsigned short family);
    1089                 :            : 
    1090                 :       5238 : static inline int __xfrm_policy_check2(struct sock *sk, int dir,
    1091                 :            :                                        struct sk_buff *skb,
    1092                 :            :                                        unsigned int family, int reverse)
    1093                 :            : {
    1094                 :       5238 :         struct net *net = dev_net(skb->dev);
    1095         [ +  - ]:       5238 :         int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
    1096                 :            : 
    1097   [ +  +  -  + ]:       5238 :         if (sk && sk->sk_policy[XFRM_POLICY_IN])
    1098                 :          0 :                 return __xfrm_policy_check(sk, ndir, skb, family);
    1099                 :            : 
    1100   [ -  +  #  # ]:      15714 :         return  (!net->xfrm.policy_count[dir] && !secpath_exists(skb)) ||
    1101   [ +  -  #  # ]:       5238 :                 (skb_dst(skb)->flags & DST_NOPOLICY) ||
    1102                 :          0 :                 __xfrm_policy_check(sk, ndir, skb, family);
    1103                 :            : }
    1104                 :            : 
    1105                 :            : static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
    1106                 :            : {
    1107                 :       5238 :         return __xfrm_policy_check2(sk, dir, skb, family, 0);
    1108                 :            : }
    1109                 :            : 
    1110                 :            : static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
    1111                 :            : {
    1112                 :            :         return xfrm_policy_check(sk, dir, skb, AF_INET);
    1113                 :            : }
    1114                 :            : 
    1115                 :            : static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
    1116                 :            : {
    1117                 :            :         return xfrm_policy_check(sk, dir, skb, AF_INET6);
    1118                 :            : }
    1119                 :            : 
    1120                 :            : static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
    1121                 :            :                                              struct sk_buff *skb)
    1122                 :            : {
    1123                 :          0 :         return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
    1124                 :            : }
    1125                 :            : 
    1126                 :            : static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
    1127                 :            :                                              struct sk_buff *skb)
    1128                 :            : {
    1129                 :          0 :         return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
    1130                 :            : }
    1131                 :            : 
    1132                 :            : int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
    1133                 :            :                           unsigned int family, int reverse);
    1134                 :            : 
    1135                 :            : static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
    1136                 :            :                                       unsigned int family)
    1137                 :            : {
    1138                 :          0 :         return __xfrm_decode_session(skb, fl, family, 0);
    1139                 :            : }
    1140                 :            : 
    1141                 :            : static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
    1142                 :            :                                               struct flowi *fl,
    1143                 :            :                                               unsigned int family)
    1144                 :            : {
    1145                 :        828 :         return __xfrm_decode_session(skb, fl, family, 1);
    1146                 :            : }
    1147                 :            : 
    1148                 :            : int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
    1149                 :            : 
    1150                 :          0 : static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
    1151                 :            : {
    1152                 :          0 :         struct net *net = dev_net(skb->dev);
    1153                 :            : 
    1154         [ #  # ]:          0 :         return  !net->xfrm.policy_count[XFRM_POLICY_OUT] ||
    1155   [ #  #  #  # ]:          0 :                 (skb_dst(skb)->flags & DST_NOXFRM) ||
    1156                 :          0 :                 __xfrm_route_forward(skb, family);
    1157                 :            : }
    1158                 :            : 
    1159                 :            : static inline int xfrm4_route_forward(struct sk_buff *skb)
    1160                 :            : {
    1161                 :          0 :         return xfrm_route_forward(skb, AF_INET);
    1162                 :            : }
    1163                 :            : 
    1164                 :            : static inline int xfrm6_route_forward(struct sk_buff *skb)
    1165                 :            : {
    1166                 :          0 :         return xfrm_route_forward(skb, AF_INET6);
    1167                 :            : }
    1168                 :            : 
    1169                 :            : int __xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk);
    1170                 :            : 
    1171                 :          0 : static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk)
    1172                 :            : {
    1173                 :          0 :         sk->sk_policy[0] = NULL;
    1174                 :          0 :         sk->sk_policy[1] = NULL;
    1175   [ #  #  #  # ]:          0 :         if (unlikely(osk->sk_policy[0] || osk->sk_policy[1]))
    1176                 :          0 :                 return __xfrm_sk_clone_policy(sk, osk);
    1177                 :            :         return 0;
    1178                 :            : }
    1179                 :            : 
    1180                 :            : int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
    1181                 :            : 
    1182                 :       6170 : static inline void xfrm_sk_free_policy(struct sock *sk)
    1183                 :            : {
    1184                 :            :         struct xfrm_policy *pol;
    1185                 :            : 
    1186                 :       6170 :         pol = rcu_dereference_protected(sk->sk_policy[0], 1);
    1187         [ -  + ]:       6170 :         if (unlikely(pol != NULL)) {
    1188                 :          0 :                 xfrm_policy_delete(pol, XFRM_POLICY_MAX);
    1189                 :          0 :                 sk->sk_policy[0] = NULL;
    1190                 :            :         }
    1191                 :       6170 :         pol = rcu_dereference_protected(sk->sk_policy[1], 1);
    1192         [ -  + ]:       6170 :         if (unlikely(pol != NULL)) {
    1193                 :          0 :                 xfrm_policy_delete(pol, XFRM_POLICY_MAX+1);
    1194                 :          0 :                 sk->sk_policy[1] = NULL;
    1195                 :            :         }
    1196                 :       6170 : }
    1197                 :            : 
    1198                 :            : #else
    1199                 :            : 
    1200                 :            : static inline void xfrm_sk_free_policy(struct sock *sk) {}
    1201                 :            : static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk) { return 0; }
    1202                 :            : static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
    1203                 :            : static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
    1204                 :            : static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
    1205                 :            : {
    1206                 :            :         return 1;
    1207                 :            : }
    1208                 :            : static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
    1209                 :            : {
    1210                 :            :         return 1;
    1211                 :            : }
    1212                 :            : static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
    1213                 :            : {
    1214                 :            :         return 1;
    1215                 :            : }
    1216                 :            : static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
    1217                 :            :                                               struct flowi *fl,
    1218                 :            :                                               unsigned int family)
    1219                 :            : {
    1220                 :            :         return -ENOSYS;
    1221                 :            : }
    1222                 :            : static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
    1223                 :            :                                              struct sk_buff *skb)
    1224                 :            : {
    1225                 :            :         return 1;
    1226                 :            : }
    1227                 :            : static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
    1228                 :            :                                              struct sk_buff *skb)
    1229                 :            : {
    1230                 :            :         return 1;
    1231                 :            : }
    1232                 :            : #endif
    1233                 :            : 
    1234                 :            : static __inline__
    1235                 :            : xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
    1236                 :            : {
    1237   [ #  #  #  #  :          0 :         switch (family){
                   #  # ]
    1238                 :            :         case AF_INET:
    1239                 :          0 :                 return (xfrm_address_t *)&fl->u.ip4.daddr;
    1240                 :            :         case AF_INET6:
    1241                 :          0 :                 return (xfrm_address_t *)&fl->u.ip6.daddr;
    1242                 :            :         }
    1243                 :            :         return NULL;
    1244                 :            : }
    1245                 :            : 
    1246                 :            : static __inline__
    1247                 :            : xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
    1248                 :            : {
    1249   [ #  #  #  #  :          0 :         switch (family){
                   #  # ]
    1250                 :            :         case AF_INET:
    1251                 :          0 :                 return (xfrm_address_t *)&fl->u.ip4.saddr;
    1252                 :            :         case AF_INET6:
    1253                 :          0 :                 return (xfrm_address_t *)&fl->u.ip6.saddr;
    1254                 :            :         }
    1255                 :            :         return NULL;
    1256                 :            : }
    1257                 :            : 
    1258                 :            : static __inline__
    1259                 :          0 : void xfrm_flowi_addr_get(const struct flowi *fl,
    1260                 :            :                          xfrm_address_t *saddr, xfrm_address_t *daddr,
    1261                 :            :                          unsigned short family)
    1262                 :            : {
    1263      [ #  #  # ]:          0 :         switch(family) {
    1264                 :            :         case AF_INET:
    1265                 :          0 :                 memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
    1266                 :          0 :                 memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
    1267                 :          0 :                 break;
    1268                 :            :         case AF_INET6:
    1269                 :          0 :                 saddr->in6 = fl->u.ip6.saddr;
    1270                 :          0 :                 daddr->in6 = fl->u.ip6.daddr;
    1271                 :          0 :                 break;
    1272                 :            :         }
    1273                 :          0 : }
    1274                 :            : 
    1275                 :            : static __inline__ int
    1276                 :            : __xfrm4_state_addr_check(const struct xfrm_state *x,
    1277                 :            :                          const xfrm_address_t *daddr, const xfrm_address_t *saddr)
    1278                 :            : {
    1279   [ #  #  #  # ]:          0 :         if (daddr->a4 == x->id.daddr.a4 &&
    1280   [ #  #  #  # ]:          0 :             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
    1281                 :            :                 return 1;
    1282                 :            :         return 0;
    1283                 :            : }
    1284                 :            : 
    1285                 :            : static __inline__ int
    1286                 :          0 : __xfrm6_state_addr_check(const struct xfrm_state *x,
    1287                 :            :                          const xfrm_address_t *daddr, const xfrm_address_t *saddr)
    1288                 :            : {
    1289   [ #  #  #  # ]:          0 :         if (ipv6_addr_equal((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
    1290         [ #  # ]:          0 :             (ipv6_addr_equal((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr) ||
    1291         [ #  # ]:          0 :              ipv6_addr_any((struct in6_addr *)saddr) ||
    1292                 :            :              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
    1293                 :            :                 return 1;
    1294                 :          0 :         return 0;
    1295                 :            : }
    1296                 :            : 
    1297                 :            : static __inline__ int
    1298                 :          0 : xfrm_state_addr_check(const struct xfrm_state *x,
    1299                 :            :                       const xfrm_address_t *daddr, const xfrm_address_t *saddr,
    1300                 :            :                       unsigned short family)
    1301                 :            : {
    1302      [ #  #  # ]:          0 :         switch (family) {
    1303                 :            :         case AF_INET:
    1304                 :          0 :                 return __xfrm4_state_addr_check(x, daddr, saddr);
    1305                 :            :         case AF_INET6:
    1306                 :          0 :                 return __xfrm6_state_addr_check(x, daddr, saddr);
    1307                 :            :         }
    1308                 :            :         return 0;
    1309                 :            : }
    1310                 :            : 
    1311                 :            : static __inline__ int
    1312                 :            : xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
    1313                 :            :                            unsigned short family)
    1314                 :            : {
    1315                 :            :         switch (family) {
    1316                 :            :         case AF_INET:
    1317                 :            :                 return __xfrm4_state_addr_check(x,
    1318                 :            :                                                 (const xfrm_address_t *)&fl->u.ip4.daddr,
    1319                 :            :                                                 (const xfrm_address_t *)&fl->u.ip4.saddr);
    1320                 :            :         case AF_INET6:
    1321                 :            :                 return __xfrm6_state_addr_check(x,
    1322                 :            :                                                 (const xfrm_address_t *)&fl->u.ip6.daddr,
    1323                 :            :                                                 (const xfrm_address_t *)&fl->u.ip6.saddr);
    1324                 :            :         }
    1325                 :            :         return 0;
    1326                 :            : }
    1327                 :            : 
    1328                 :            : static inline int xfrm_state_kern(const struct xfrm_state *x)
    1329                 :            : {
    1330                 :            :         return atomic_read(&x->tunnel_users);
    1331                 :            : }
    1332                 :            : 
    1333                 :            : static inline bool xfrm_id_proto_valid(u8 proto)
    1334                 :            : {
    1335         [ #  # ]:          0 :         switch (proto) {
    1336                 :            :         case IPPROTO_AH:
    1337                 :            :         case IPPROTO_ESP:
    1338                 :            :         case IPPROTO_COMP:
    1339                 :            : #if IS_ENABLED(CONFIG_IPV6)
    1340                 :            :         case IPPROTO_ROUTING:
    1341                 :            :         case IPPROTO_DSTOPTS:
    1342                 :            : #endif
    1343                 :            :                 return true;
    1344                 :            :         default:
    1345                 :            :                 return false;
    1346                 :            :         }
    1347                 :            : }
    1348                 :            : 
    1349                 :            : /* IPSEC_PROTO_ANY only matches 3 IPsec protocols, 0 could match all. */
    1350                 :            : static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
    1351                 :            : {
    1352   [ #  #  #  #  :          0 :         return (!userproto || proto == userproto ||
          #  #  #  #  #  
                #  #  # ]
    1353   [ #  #  #  #  :          0 :                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
             #  #  #  # ]
    1354                 :          0 :                                                   proto == IPPROTO_ESP ||
    1355                 :          0 :                                                   proto == IPPROTO_COMP)));
    1356                 :            : }
    1357                 :            : 
    1358                 :            : /*
    1359                 :            :  * xfrm algorithm information
    1360                 :            :  */
    1361                 :            : struct xfrm_algo_aead_info {
    1362                 :            :         char *geniv;
    1363                 :            :         u16 icv_truncbits;
    1364                 :            : };
    1365                 :            : 
    1366                 :            : struct xfrm_algo_auth_info {
    1367                 :            :         u16 icv_truncbits;
    1368                 :            :         u16 icv_fullbits;
    1369                 :            : };
    1370                 :            : 
    1371                 :            : struct xfrm_algo_encr_info {
    1372                 :            :         char *geniv;
    1373                 :            :         u16 blockbits;
    1374                 :            :         u16 defkeybits;
    1375                 :            : };
    1376                 :            : 
    1377                 :            : struct xfrm_algo_comp_info {
    1378                 :            :         u16 threshold;
    1379                 :            : };
    1380                 :            : 
    1381                 :            : struct xfrm_algo_desc {
    1382                 :            :         char *name;
    1383                 :            :         char *compat;
    1384                 :            :         u8 available:1;
    1385                 :            :         u8 pfkey_supported:1;
    1386                 :            :         union {
    1387                 :            :                 struct xfrm_algo_aead_info aead;
    1388                 :            :                 struct xfrm_algo_auth_info auth;
    1389                 :            :                 struct xfrm_algo_encr_info encr;
    1390                 :            :                 struct xfrm_algo_comp_info comp;
    1391                 :            :         } uinfo;
    1392                 :            :         struct sadb_alg desc;
    1393                 :            : };
    1394                 :            : 
    1395                 :            : /* XFRM protocol handlers.  */
    1396                 :            : struct xfrm4_protocol {
    1397                 :            :         int (*handler)(struct sk_buff *skb);
    1398                 :            :         int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
    1399                 :            :                              int encap_type);
    1400                 :            :         int (*cb_handler)(struct sk_buff *skb, int err);
    1401                 :            :         int (*err_handler)(struct sk_buff *skb, u32 info);
    1402                 :            : 
    1403                 :            :         struct xfrm4_protocol __rcu *next;
    1404                 :            :         int priority;
    1405                 :            : };
    1406                 :            : 
    1407                 :            : struct xfrm6_protocol {
    1408                 :            :         int (*handler)(struct sk_buff *skb);
    1409                 :            :         int (*cb_handler)(struct sk_buff *skb, int err);
    1410                 :            :         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
    1411                 :            :                            u8 type, u8 code, int offset, __be32 info);
    1412                 :            : 
    1413                 :            :         struct xfrm6_protocol __rcu *next;
    1414                 :            :         int priority;
    1415                 :            : };
    1416                 :            : 
    1417                 :            : /* XFRM tunnel handlers.  */
    1418                 :            : struct xfrm_tunnel {
    1419                 :            :         int (*handler)(struct sk_buff *skb);
    1420                 :            :         int (*err_handler)(struct sk_buff *skb, u32 info);
    1421                 :            : 
    1422                 :            :         struct xfrm_tunnel __rcu *next;
    1423                 :            :         int priority;
    1424                 :            : };
    1425                 :            : 
    1426                 :            : struct xfrm6_tunnel {
    1427                 :            :         int (*handler)(struct sk_buff *skb);
    1428                 :            :         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
    1429                 :            :                            u8 type, u8 code, int offset, __be32 info);
    1430                 :            :         struct xfrm6_tunnel __rcu *next;
    1431                 :            :         int priority;
    1432                 :            : };
    1433                 :            : 
    1434                 :            : void xfrm_init(void);
    1435                 :            : void xfrm4_init(void);
    1436                 :            : int xfrm_state_init(struct net *net);
    1437                 :            : void xfrm_state_fini(struct net *net);
    1438                 :            : void xfrm4_state_init(void);
    1439                 :            : void xfrm4_protocol_init(void);
    1440                 :            : #ifdef CONFIG_XFRM
    1441                 :            : int xfrm6_init(void);
    1442                 :            : void xfrm6_fini(void);
    1443                 :            : int xfrm6_state_init(void);
    1444                 :            : void xfrm6_state_fini(void);
    1445                 :            : int xfrm6_protocol_init(void);
    1446                 :            : void xfrm6_protocol_fini(void);
    1447                 :            : #else
    1448                 :            : static inline int xfrm6_init(void)
    1449                 :            : {
    1450                 :            :         return 0;
    1451                 :            : }
    1452                 :            : static inline void xfrm6_fini(void)
    1453                 :            : {
    1454                 :            :         ;
    1455                 :            : }
    1456                 :            : #endif
    1457                 :            : 
    1458                 :            : #ifdef CONFIG_XFRM_STATISTICS
    1459                 :            : int xfrm_proc_init(struct net *net);
    1460                 :            : void xfrm_proc_fini(struct net *net);
    1461                 :            : #endif
    1462                 :            : 
    1463                 :            : int xfrm_sysctl_init(struct net *net);
    1464                 :            : #ifdef CONFIG_SYSCTL
    1465                 :            : void xfrm_sysctl_fini(struct net *net);
    1466                 :            : #else
    1467                 :            : static inline void xfrm_sysctl_fini(struct net *net)
    1468                 :            : {
    1469                 :            : }
    1470                 :            : #endif
    1471                 :            : 
    1472                 :            : void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
    1473                 :            :                           struct xfrm_address_filter *filter);
    1474                 :            : int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
    1475                 :            :                     int (*func)(struct xfrm_state *, int, void*), void *);
    1476                 :            : void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net);
    1477                 :            : struct xfrm_state *xfrm_state_alloc(struct net *net);
    1478                 :            : void xfrm_state_free(struct xfrm_state *x);
    1479                 :            : struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
    1480                 :            :                                    const xfrm_address_t *saddr,
    1481                 :            :                                    const struct flowi *fl,
    1482                 :            :                                    struct xfrm_tmpl *tmpl,
    1483                 :            :                                    struct xfrm_policy *pol, int *err,
    1484                 :            :                                    unsigned short family, u32 if_id);
    1485                 :            : struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
    1486                 :            :                                        xfrm_address_t *daddr,
    1487                 :            :                                        xfrm_address_t *saddr,
    1488                 :            :                                        unsigned short family,
    1489                 :            :                                        u8 mode, u8 proto, u32 reqid);
    1490                 :            : struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
    1491                 :            :                                               unsigned short family);
    1492                 :            : int xfrm_state_check_expire(struct xfrm_state *x);
    1493                 :            : void xfrm_state_insert(struct xfrm_state *x);
    1494                 :            : int xfrm_state_add(struct xfrm_state *x);
    1495                 :            : int xfrm_state_update(struct xfrm_state *x);
    1496                 :            : struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
    1497                 :            :                                      const xfrm_address_t *daddr, __be32 spi,
    1498                 :            :                                      u8 proto, unsigned short family);
    1499                 :            : struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
    1500                 :            :                                             const xfrm_address_t *daddr,
    1501                 :            :                                             const xfrm_address_t *saddr,
    1502                 :            :                                             u8 proto,
    1503                 :            :                                             unsigned short family);
    1504                 :            : #ifdef CONFIG_XFRM_SUB_POLICY
    1505                 :            : void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
    1506                 :            :                     unsigned short family);
    1507                 :            : void xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
    1508                 :            :                      unsigned short family);
    1509                 :            : #else
    1510                 :            : static inline void xfrm_tmpl_sort(struct xfrm_tmpl **d, struct xfrm_tmpl **s,
    1511                 :            :                                   int n, unsigned short family)
    1512                 :            : {
    1513                 :            : }
    1514                 :            : 
    1515                 :            : static inline void xfrm_state_sort(struct xfrm_state **d, struct xfrm_state **s,
    1516                 :            :                                    int n, unsigned short family)
    1517                 :            : {
    1518                 :            : }
    1519                 :            : #endif
    1520                 :            : 
    1521                 :            : struct xfrmk_sadinfo {
    1522                 :            :         u32 sadhcnt; /* current hash bkts */
    1523                 :            :         u32 sadhmcnt; /* max allowed hash bkts */
    1524                 :            :         u32 sadcnt; /* current running count */
    1525                 :            : };
    1526                 :            : 
    1527                 :            : struct xfrmk_spdinfo {
    1528                 :            :         u32 incnt;
    1529                 :            :         u32 outcnt;
    1530                 :            :         u32 fwdcnt;
    1531                 :            :         u32 inscnt;
    1532                 :            :         u32 outscnt;
    1533                 :            :         u32 fwdscnt;
    1534                 :            :         u32 spdhcnt;
    1535                 :            :         u32 spdhmcnt;
    1536                 :            : };
    1537                 :            : 
    1538                 :            : struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
    1539                 :            : int xfrm_state_delete(struct xfrm_state *x);
    1540                 :            : int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync);
    1541                 :            : int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid);
    1542                 :            : void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
    1543                 :            : void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
    1544                 :            : u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
    1545                 :            : int xfrm_init_replay(struct xfrm_state *x);
    1546                 :            : u32 xfrm_state_mtu(struct xfrm_state *x, int mtu);
    1547                 :            : int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload);
    1548                 :            : int xfrm_init_state(struct xfrm_state *x);
    1549                 :            : int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);
    1550                 :            : int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
    1551                 :            : int xfrm_trans_queue(struct sk_buff *skb,
    1552                 :            :                      int (*finish)(struct net *, struct sock *,
    1553                 :            :                                    struct sk_buff *));
    1554                 :            : int xfrm_output_resume(struct sk_buff *skb, int err);
    1555                 :            : int xfrm_output(struct sock *sk, struct sk_buff *skb);
    1556                 :            : 
    1557                 :            : #if IS_ENABLED(CONFIG_NET_PKTGEN)
    1558                 :            : int pktgen_xfrm_outer_mode_output(struct xfrm_state *x, struct sk_buff *skb);
    1559                 :            : #endif
    1560                 :            : 
    1561                 :            : void xfrm_local_error(struct sk_buff *skb, int mtu);
    1562                 :            : int xfrm4_extract_header(struct sk_buff *skb);
    1563                 :            : int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
    1564                 :            : int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
    1565                 :            :                     int encap_type);
    1566                 :            : int xfrm4_transport_finish(struct sk_buff *skb, int async);
    1567                 :            : int xfrm4_rcv(struct sk_buff *skb);
    1568                 :            : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
    1569                 :            : 
    1570                 :            : static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
    1571                 :            : {
    1572                 :          0 :         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
    1573                 :          0 :         XFRM_SPI_SKB_CB(skb)->family = AF_INET;
    1574                 :          0 :         XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
    1575                 :          0 :         return xfrm_input(skb, nexthdr, spi, 0);
    1576                 :            : }
    1577                 :            : 
    1578                 :            : int xfrm4_extract_output(struct xfrm_state *x, struct sk_buff *skb);
    1579                 :            : int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb);
    1580                 :            : int xfrm4_output_finish(struct sock *sk, struct sk_buff *skb);
    1581                 :            : int xfrm4_protocol_register(struct xfrm4_protocol *handler, unsigned char protocol);
    1582                 :            : int xfrm4_protocol_deregister(struct xfrm4_protocol *handler, unsigned char protocol);
    1583                 :            : int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
    1584                 :            : int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
    1585                 :            : void xfrm4_local_error(struct sk_buff *skb, u32 mtu);
    1586                 :            : int xfrm6_extract_header(struct sk_buff *skb);
    1587                 :            : int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
    1588                 :            : int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi,
    1589                 :            :                   struct ip6_tnl *t);
    1590                 :            : int xfrm6_transport_finish(struct sk_buff *skb, int async);
    1591                 :            : int xfrm6_rcv_tnl(struct sk_buff *skb, struct ip6_tnl *t);
    1592                 :            : int xfrm6_rcv(struct sk_buff *skb);
    1593                 :            : int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
    1594                 :            :                      xfrm_address_t *saddr, u8 proto);
    1595                 :            : void xfrm6_local_error(struct sk_buff *skb, u32 mtu);
    1596                 :            : int xfrm6_protocol_register(struct xfrm6_protocol *handler, unsigned char protocol);
    1597                 :            : int xfrm6_protocol_deregister(struct xfrm6_protocol *handler, unsigned char protocol);
    1598                 :            : int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
    1599                 :            : int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
    1600                 :            : __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
    1601                 :            : __be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
    1602                 :            : int xfrm6_extract_output(struct xfrm_state *x, struct sk_buff *skb);
    1603                 :            : int xfrm6_output(struct net *net, struct sock *sk, struct sk_buff *skb);
    1604                 :            : int xfrm6_output_finish(struct sock *sk, struct sk_buff *skb);
    1605                 :            : int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
    1606                 :            :                           u8 **prevhdr);
    1607                 :            : 
    1608                 :            : #ifdef CONFIG_XFRM
    1609                 :            : int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
    1610                 :            : int xfrm_user_policy(struct sock *sk, int optname,
    1611                 :            :                      u8 __user *optval, int optlen);
    1612                 :            : #else
    1613                 :            : static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
    1614                 :            : {
    1615                 :            :         return -ENOPROTOOPT;
    1616                 :            : }
    1617                 :            : 
    1618                 :            : static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
    1619                 :            : {
    1620                 :            :         /* should not happen */
    1621                 :            :         kfree_skb(skb);
    1622                 :            :         return 0;
    1623                 :            : }
    1624                 :            : #endif
    1625                 :            : 
    1626                 :            : struct dst_entry *__xfrm_dst_lookup(struct net *net, int tos, int oif,
    1627                 :            :                                     const xfrm_address_t *saddr,
    1628                 :            :                                     const xfrm_address_t *daddr,
    1629                 :            :                                     int family, u32 mark);
    1630                 :            : 
    1631                 :            : struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
    1632                 :            : 
    1633                 :            : void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
    1634                 :            : int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
    1635                 :            :                      int (*func)(struct xfrm_policy *, int, int, void*),
    1636                 :            :                      void *);
    1637                 :            : void xfrm_policy_walk_done(struct xfrm_policy_walk *walk, struct net *net);
    1638                 :            : int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
    1639                 :            : struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net,
    1640                 :            :                                           const struct xfrm_mark *mark,
    1641                 :            :                                           u32 if_id, u8 type, int dir,
    1642                 :            :                                           struct xfrm_selector *sel,
    1643                 :            :                                           struct xfrm_sec_ctx *ctx, int delete,
    1644                 :            :                                           int *err);
    1645                 :            : struct xfrm_policy *xfrm_policy_byid(struct net *net,
    1646                 :            :                                      const struct xfrm_mark *mark, u32 if_id,
    1647                 :            :                                      u8 type, int dir, u32 id, int delete,
    1648                 :            :                                      int *err);
    1649                 :            : int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
    1650                 :            : void xfrm_policy_hash_rebuild(struct net *net);
    1651                 :            : u32 xfrm_get_acqseq(void);
    1652                 :            : int verify_spi_info(u8 proto, u32 min, u32 max);
    1653                 :            : int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
    1654                 :            : struct xfrm_state *xfrm_find_acq(struct net *net, const struct xfrm_mark *mark,
    1655                 :            :                                  u8 mode, u32 reqid, u32 if_id, u8 proto,
    1656                 :            :                                  const xfrm_address_t *daddr,
    1657                 :            :                                  const xfrm_address_t *saddr, int create,
    1658                 :            :                                  unsigned short family);
    1659                 :            : int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
    1660                 :            : 
    1661                 :            : #ifdef CONFIG_XFRM_MIGRATE
    1662                 :            : int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
    1663                 :            :                const struct xfrm_migrate *m, int num_bundles,
    1664                 :            :                const struct xfrm_kmaddress *k,
    1665                 :            :                const struct xfrm_encap_tmpl *encap);
    1666                 :            : struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net);
    1667                 :            : struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
    1668                 :            :                                       struct xfrm_migrate *m,
    1669                 :            :                                       struct xfrm_encap_tmpl *encap);
    1670                 :            : int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
    1671                 :            :                  struct xfrm_migrate *m, int num_bundles,
    1672                 :            :                  struct xfrm_kmaddress *k, struct net *net,
    1673                 :            :                  struct xfrm_encap_tmpl *encap);
    1674                 :            : #endif
    1675                 :            : 
    1676                 :            : int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
    1677                 :            : void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid);
    1678                 :            : int km_report(struct net *net, u8 proto, struct xfrm_selector *sel,
    1679                 :            :               xfrm_address_t *addr);
    1680                 :            : 
    1681                 :            : void xfrm_input_init(void);
    1682                 :            : int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
    1683                 :            : 
    1684                 :            : void xfrm_probe_algs(void);
    1685                 :            : int xfrm_count_pfkey_auth_supported(void);
    1686                 :            : int xfrm_count_pfkey_enc_supported(void);
    1687                 :            : struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
    1688                 :            : struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
    1689                 :            : struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
    1690                 :            : struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
    1691                 :            : struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
    1692                 :            : struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
    1693                 :            : struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
    1694                 :            : struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
    1695                 :            : struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
    1696                 :            :                                             int probe);
    1697                 :            : 
    1698                 :            : static inline bool xfrm6_addr_equal(const xfrm_address_t *a,
    1699                 :            :                                     const xfrm_address_t *b)
    1700                 :            : {
    1701                 :            :         return ipv6_addr_equal((const struct in6_addr *)a,
    1702                 :            :                                (const struct in6_addr *)b);
    1703                 :            : }
    1704                 :            : 
    1705                 :          0 : static inline bool xfrm_addr_equal(const xfrm_address_t *a,
    1706                 :            :                                    const xfrm_address_t *b,
    1707                 :            :                                    sa_family_t family)
    1708                 :            : {
    1709         [ #  # ]:          0 :         switch (family) {
    1710                 :            :         default:
    1711                 :            :         case AF_INET:
    1712                 :          0 :                 return ((__force u32)a->a4 ^ (__force u32)b->a4) == 0;
    1713                 :            :         case AF_INET6:
    1714                 :          0 :                 return xfrm6_addr_equal(a, b);
    1715                 :            :         }
    1716                 :            : }
    1717                 :            : 
    1718                 :            : static inline int xfrm_policy_id2dir(u32 index)
    1719                 :            : {
    1720                 :          0 :         return index & 7;
    1721                 :            : }
    1722                 :            : 
    1723                 :            : #ifdef CONFIG_XFRM
    1724                 :          0 : static inline int xfrm_aevent_is_on(struct net *net)
    1725                 :            : {
    1726                 :            :         struct sock *nlsk;
    1727                 :            :         int ret = 0;
    1728                 :            : 
    1729                 :            :         rcu_read_lock();
    1730                 :          0 :         nlsk = rcu_dereference(net->xfrm.nlsk);
    1731         [ #  # ]:          0 :         if (nlsk)
    1732                 :          0 :                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
    1733                 :            :         rcu_read_unlock();
    1734                 :          0 :         return ret;
    1735                 :            : }
    1736                 :            : 
    1737                 :          0 : static inline int xfrm_acquire_is_on(struct net *net)
    1738                 :            : {
    1739                 :            :         struct sock *nlsk;
    1740                 :            :         int ret = 0;
    1741                 :            : 
    1742                 :            :         rcu_read_lock();
    1743                 :          0 :         nlsk = rcu_dereference(net->xfrm.nlsk);
    1744         [ #  # ]:          0 :         if (nlsk)
    1745                 :          0 :                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE);
    1746                 :            :         rcu_read_unlock();
    1747                 :            : 
    1748                 :          0 :         return ret;
    1749                 :            : }
    1750                 :            : #endif
    1751                 :            : 
    1752                 :            : static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
    1753                 :            : {
    1754                 :          0 :         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
    1755                 :            : }
    1756                 :            : 
    1757                 :            : static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
    1758                 :            : {
    1759                 :          0 :         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
    1760                 :            : }
    1761                 :            : 
    1762                 :            : static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
    1763                 :            : {
    1764                 :          0 :         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
    1765                 :            : }
    1766                 :            : 
    1767                 :            : static inline unsigned int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
    1768                 :            : {
    1769                 :          0 :         return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
    1770                 :            : }
    1771                 :            : 
    1772                 :            : #ifdef CONFIG_XFRM_MIGRATE
    1773                 :            : static inline int xfrm_replay_clone(struct xfrm_state *x,
    1774                 :            :                                      struct xfrm_state *orig)
    1775                 :            : {
    1776                 :            :         x->replay_esn = kzalloc(xfrm_replay_state_esn_len(orig->replay_esn),
    1777                 :            :                                 GFP_KERNEL);
    1778                 :            :         if (!x->replay_esn)
    1779                 :            :                 return -ENOMEM;
    1780                 :            : 
    1781                 :            :         x->replay_esn->bmp_len = orig->replay_esn->bmp_len;
    1782                 :            :         x->replay_esn->replay_window = orig->replay_esn->replay_window;
    1783                 :            : 
    1784                 :            :         x->preplay_esn = kmemdup(x->replay_esn,
    1785                 :            :                                  xfrm_replay_state_esn_len(x->replay_esn),
    1786                 :            :                                  GFP_KERNEL);
    1787                 :            :         if (!x->preplay_esn) {
    1788                 :            :                 kfree(x->replay_esn);
    1789                 :            :                 return -ENOMEM;
    1790                 :            :         }
    1791                 :            : 
    1792                 :            :         return 0;
    1793                 :            : }
    1794                 :            : 
    1795                 :            : static inline struct xfrm_algo_aead *xfrm_algo_aead_clone(struct xfrm_algo_aead *orig)
    1796                 :            : {
    1797                 :            :         return kmemdup(orig, aead_len(orig), GFP_KERNEL);
    1798                 :            : }
    1799                 :            : 
    1800                 :            : 
    1801                 :            : static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
    1802                 :            : {
    1803                 :            :         return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
    1804                 :            : }
    1805                 :            : 
    1806                 :            : static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
    1807                 :            : {
    1808                 :            :         return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
    1809                 :            : }
    1810                 :            : 
    1811                 :            : static inline void xfrm_states_put(struct xfrm_state **states, int n)
    1812                 :            : {
    1813                 :            :         int i;
    1814                 :            :         for (i = 0; i < n; i++)
    1815                 :            :                 xfrm_state_put(*(states + i));
    1816                 :            : }
    1817                 :            : 
    1818                 :            : static inline void xfrm_states_delete(struct xfrm_state **states, int n)
    1819                 :            : {
    1820                 :            :         int i;
    1821                 :            :         for (i = 0; i < n; i++)
    1822                 :            :                 xfrm_state_delete(*(states + i));
    1823                 :            : }
    1824                 :            : #endif
    1825                 :            : 
    1826                 :            : #ifdef CONFIG_XFRM
    1827                 :            : static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
    1828                 :            : {
    1829                 :            :         struct sec_path *sp = skb_sec_path(skb);
    1830                 :            : 
    1831                 :          0 :         return sp->xvec[sp->len - 1];
    1832                 :            : }
    1833                 :            : #endif
    1834                 :            : 
    1835                 :          0 : static inline struct xfrm_offload *xfrm_offload(struct sk_buff *skb)
    1836                 :            : {
    1837                 :            : #ifdef CONFIG_XFRM
    1838                 :            :         struct sec_path *sp = skb_sec_path(skb);
    1839                 :            : 
    1840   [ #  #  #  #  :          0 :         if (!sp || !sp->olen || sp->len != sp->olen)
                   #  # ]
    1841                 :            :                 return NULL;
    1842                 :            : 
    1843                 :          0 :         return &sp->ovec[sp->olen - 1];
    1844                 :            : #else
    1845                 :            :         return NULL;
    1846                 :            : #endif
    1847                 :            : }
    1848                 :            : 
    1849                 :            : void __init xfrm_dev_init(void);
    1850                 :            : 
    1851                 :            : #ifdef CONFIG_XFRM_OFFLOAD
    1852                 :            : void xfrm_dev_resume(struct sk_buff *skb);
    1853                 :            : void xfrm_dev_backlog(struct softnet_data *sd);
    1854                 :            : struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again);
    1855                 :            : int xfrm_dev_state_add(struct net *net, struct xfrm_state *x,
    1856                 :            :                        struct xfrm_user_offload *xuo);
    1857                 :            : bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x);
    1858                 :            : 
    1859                 :            : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
    1860                 :            : {
    1861                 :            :         struct xfrm_state_offload *xso = &x->xso;
    1862                 :            : 
    1863                 :            :         if (xso->dev && xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn)
    1864                 :            :                 xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn(x);
    1865                 :            : }
    1866                 :            : 
    1867                 :            : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
    1868                 :            : {
    1869                 :            :         struct xfrm_state *x = dst->xfrm;
    1870                 :            :         struct xfrm_dst *xdst;
    1871                 :            : 
    1872                 :            :         if (!x || !x->type_offload)
    1873                 :            :                 return false;
    1874                 :            : 
    1875                 :            :         xdst = (struct xfrm_dst *) dst;
    1876                 :            :         if (!x->xso.offload_handle && !xdst->child->xfrm)
    1877                 :            :                 return true;
    1878                 :            :         if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&
    1879                 :            :             !xdst->child->xfrm)
    1880                 :            :                 return true;
    1881                 :            : 
    1882                 :            :         return false;
    1883                 :            : }
    1884                 :            : 
    1885                 :            : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
    1886                 :            : {
    1887                 :            :         struct xfrm_state_offload *xso = &x->xso;
    1888                 :            : 
    1889                 :            :         if (xso->dev)
    1890                 :            :                 xso->dev->xfrmdev_ops->xdo_dev_state_delete(x);
    1891                 :            : }
    1892                 :            : 
    1893                 :            : static inline void xfrm_dev_state_free(struct xfrm_state *x)
    1894                 :            : {
    1895                 :            :         struct xfrm_state_offload *xso = &x->xso;
    1896                 :            :         struct net_device *dev = xso->dev;
    1897                 :            : 
    1898                 :            :         if (dev && dev->xfrmdev_ops) {
    1899                 :            :                 if (dev->xfrmdev_ops->xdo_dev_state_free)
    1900                 :            :                         dev->xfrmdev_ops->xdo_dev_state_free(x);
    1901                 :            :                 xso->dev = NULL;
    1902                 :            :                 dev_put(dev);
    1903                 :            :         }
    1904                 :            : }
    1905                 :            : #else
    1906                 :            : static inline void xfrm_dev_resume(struct sk_buff *skb)
    1907                 :            : {
    1908                 :            : }
    1909                 :            : 
    1910                 :            : static inline void xfrm_dev_backlog(struct softnet_data *sd)
    1911                 :            : {
    1912                 :            : }
    1913                 :            : 
    1914                 :            : static inline struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again)
    1915                 :            : {
    1916                 :            :         return skb;
    1917                 :            : }
    1918                 :            : 
    1919                 :            : static inline int xfrm_dev_state_add(struct net *net, struct xfrm_state *x, struct xfrm_user_offload *xuo)
    1920                 :            : {
    1921                 :            :         return 0;
    1922                 :            : }
    1923                 :            : 
    1924                 :            : static inline void xfrm_dev_state_delete(struct xfrm_state *x)
    1925                 :            : {
    1926                 :            : }
    1927                 :            : 
    1928                 :            : static inline void xfrm_dev_state_free(struct xfrm_state *x)
    1929                 :            : {
    1930                 :            : }
    1931                 :            : 
    1932                 :            : static inline bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x)
    1933                 :            : {
    1934                 :            :         return false;
    1935                 :            : }
    1936                 :            : 
    1937                 :            : static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
    1938                 :            : {
    1939                 :            : }
    1940                 :            : 
    1941                 :            : static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
    1942                 :            : {
    1943                 :            :         return false;
    1944                 :            : }
    1945                 :            : #endif
    1946                 :            : 
    1947                 :          0 : static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
    1948                 :            : {
    1949         [ #  # ]:          0 :         if (attrs[XFRMA_MARK])
    1950                 :          0 :                 memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
    1951                 :            :         else
    1952                 :          0 :                 m->v = m->m = 0;
    1953                 :            : 
    1954                 :          0 :         return m->v & m->m;
    1955                 :            : }
    1956                 :            : 
    1957                 :          0 : static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
    1958                 :            : {
    1959                 :            :         int ret = 0;
    1960                 :            : 
    1961         [ #  # ]:          0 :         if (m->m | m->v)
    1962                 :          0 :                 ret = nla_put(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
    1963                 :          0 :         return ret;
    1964                 :            : }
    1965                 :            : 
    1966                 :            : static inline __u32 xfrm_smark_get(__u32 mark, struct xfrm_state *x)
    1967                 :            : {
    1968                 :            :         struct xfrm_mark *m = &x->props.smark;
    1969                 :            : 
    1970                 :          0 :         return (m->v & m->m) | (mark & ~m->m);
    1971                 :            : }
    1972                 :            : 
    1973                 :            : static inline int xfrm_if_id_put(struct sk_buff *skb, __u32 if_id)
    1974                 :            : {
    1975                 :            :         int ret = 0;
    1976                 :            : 
    1977   [ #  #  #  #  :          0 :         if (if_id)
          #  #  #  #  #  
                #  #  # ]
    1978                 :            :                 ret = nla_put_u32(skb, XFRMA_IF_ID, if_id);
    1979                 :            :         return ret;
    1980                 :            : }
    1981                 :            : 
    1982                 :          0 : static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,
    1983                 :            :                                     unsigned int family)
    1984                 :            : {
    1985                 :            :         bool tunnel = false;
    1986                 :            : 
    1987      [ #  #  # ]:          0 :         switch(family) {
    1988                 :            :         case AF_INET:
    1989         [ #  # ]:          0 :                 if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4)
    1990                 :            :                         tunnel = true;
    1991                 :            :                 break;
    1992                 :            :         case AF_INET6:
    1993         [ #  # ]:          0 :                 if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
    1994                 :            :                         tunnel = true;
    1995                 :            :                 break;
    1996                 :            :         }
    1997   [ #  #  #  # ]:          0 :         if (tunnel && !(x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL))
    1998                 :            :                 return -EINVAL;
    1999                 :            : 
    2000                 :          0 :         return 0;
    2001                 :            : }
    2002                 :            : #endif  /* _NET_XFRM_H */

Generated by: LCOV version 1.14