include/net/xfrm.h

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