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         int                     verified_cnt;
1030
1031         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
1032         struct xfrm_offload     ovec[XFRM_MAX_OFFLOAD_DEPTH];
1033 };
1034
1035 struct sec_path *secpath_set(struct sk_buff *skb);
1036
1037 static inline void
1038 secpath_reset(struct sk_buff *skb)
1039 {
1040 #ifdef CONFIG_XFRM
1041         skb_ext_del(skb, SKB_EXT_SEC_PATH);
1042 #endif
1043 }
1044
1045 static inline int
1046 xfrm_addr_any(const xfrm_address_t *addr, unsigned short family)
1047 {
1048         switch (family) {
1049         case AF_INET:
1050                 return addr->a4 == 0;
1051         case AF_INET6:
1052                 return ipv6_addr_any(&addr->in6);
1053         }
1054         return 0;
1055 }
1056
1057 static inline int
1058 __xfrm4_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1059 {
1060         return  (tmpl->saddr.a4 &&
1061                  tmpl->saddr.a4 != x->props.saddr.a4);
1062 }
1063
1064 static inline int
1065 __xfrm6_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x)
1066 {
1067         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
1068                  !ipv6_addr_equal((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
1069 }
1070
1071 static inline int
1072 xfrm_state_addr_cmp(const struct xfrm_tmpl *tmpl, const struct xfrm_state *x, unsigned short family)
1073 {
1074         switch (family) {
1075         case AF_INET:
1076                 return __xfrm4_state_addr_cmp(tmpl, x);
1077         case AF_INET6:
1078                 return __xfrm6_state_addr_cmp(tmpl, x);
1079         }
1080         return !0;
1081 }
1082
1083 #ifdef CONFIG_XFRM
1084 int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb,
1085                         unsigned short family);
1086
1087 static inline bool __xfrm_check_nopolicy(struct net *net, struct sk_buff *skb,
1088                                          int dir)
1089 {
1090         if (!net->xfrm.policy_count[dir] && !secpath_exists(skb))
1091                 return net->xfrm.policy_default[dir] == XFRM_USERPOLICY_ACCEPT;
1092
1093         return false;
1094 }
1095
1096 static inline bool __xfrm_check_dev_nopolicy(struct sk_buff *skb,
1097                                              int dir, unsigned short family)
1098 {
1099         if (dir != XFRM_POLICY_OUT && family == AF_INET) {
1100                 /* same dst may be used for traffic originating from
1101                  * devices with different policy settings.
1102                  */
1103                 return IPCB(skb)->flags & IPSKB_NOPOLICY;
1104         }
1105         return skb_dst(skb) && (skb_dst(skb)->flags & DST_NOPOLICY);
1106 }
1107
1108 static inline int __xfrm_policy_check2(struct sock *sk, int dir,
1109                                        struct sk_buff *skb,
1110                                        unsigned int family, int reverse)
1111 {
1112         struct net *net = dev_net(skb->dev);
1113         int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
1114
1115         if (sk && sk->sk_policy[XFRM_POLICY_IN])
1116                 return __xfrm_policy_check(sk, ndir, skb, family);
1117
1118         return __xfrm_check_nopolicy(net, skb, dir) ||
1119                __xfrm_check_dev_nopolicy(skb, dir, family) ||
1120                __xfrm_policy_check(sk, ndir, skb, family);
1121 }
1122
1123 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1124 {
1125         return __xfrm_policy_check2(sk, dir, skb, family, 0);
1126 }
1127
1128 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1129 {
1130         return xfrm_policy_check(sk, dir, skb, AF_INET);
1131 }
1132
1133 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1134 {
1135         return xfrm_policy_check(sk, dir, skb, AF_INET6);
1136 }
1137
1138 static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1139                                              struct sk_buff *skb)
1140 {
1141         return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
1142 }
1143
1144 static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1145                                              struct sk_buff *skb)
1146 {
1147         return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
1148 }
1149
1150 int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1151                           unsigned int family, int reverse);
1152
1153 static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1154                                       unsigned int family)
1155 {
1156         return __xfrm_decode_session(skb, fl, family, 0);
1157 }
1158
1159 static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1160                                               struct flowi *fl,
1161                                               unsigned int family)
1162 {
1163         return __xfrm_decode_session(skb, fl, family, 1);
1164 }
1165
1166 int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
1167
1168 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
1169 {
1170         struct net *net = dev_net(skb->dev);
1171
1172         if (!net->xfrm.policy_count[XFRM_POLICY_OUT] &&
1173             net->xfrm.policy_default[XFRM_POLICY_OUT] == XFRM_USERPOLICY_ACCEPT)
1174                 return true;
1175
1176         return (skb_dst(skb)->flags & DST_NOXFRM) ||
1177                __xfrm_route_forward(skb, family);
1178 }
1179
1180 static inline int xfrm4_route_forward(struct sk_buff *skb)
1181 {
1182         return xfrm_route_forward(skb, AF_INET);
1183 }
1184
1185 static inline int xfrm6_route_forward(struct sk_buff *skb)
1186 {
1187         return xfrm_route_forward(skb, AF_INET6);
1188 }
1189
1190 int __xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk);
1191
1192 static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk)
1193 {
1194         if (!sk_fullsock(osk))
1195                 return 0;
1196         sk->sk_policy[0] = NULL;
1197         sk->sk_policy[1] = NULL;
1198         if (unlikely(osk->sk_policy[0] || osk->sk_policy[1]))
1199                 return __xfrm_sk_clone_policy(sk, osk);
1200         return 0;
1201 }
1202
1203 int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
1204
1205 static inline void xfrm_sk_free_policy(struct sock *sk)
1206 {
1207         struct xfrm_policy *pol;
1208
1209         pol = rcu_dereference_protected(sk->sk_policy[0], 1);
1210         if (unlikely(pol != NULL)) {
1211                 xfrm_policy_delete(pol, XFRM_POLICY_MAX);
1212                 sk->sk_policy[0] = NULL;
1213         }
1214         pol = rcu_dereference_protected(sk->sk_policy[1], 1);
1215         if (unlikely(pol != NULL)) {
1216                 xfrm_policy_delete(pol, XFRM_POLICY_MAX+1);
1217                 sk->sk_policy[1] = NULL;
1218         }
1219 }
1220
1221 #else
1222
1223 static inline void xfrm_sk_free_policy(struct sock *sk) {}
1224 static inline int xfrm_sk_clone_policy(struct sock *sk, const struct sock *osk) { return 0; }
1225 static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
1226 static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
1227 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1228 {
1229         return 1;
1230 }
1231 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1232 {
1233         return 1;
1234 }
1235 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1236 {
1237         return 1;
1238 }
1239 static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1240                                               struct flowi *fl,
1241                                               unsigned int family)
1242 {
1243         return -ENOSYS;
1244 }
1245 static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1246                                              struct sk_buff *skb)
1247 {
1248         return 1;
1249 }
1250 static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1251                                              struct sk_buff *skb)
1252 {
1253         return 1;
1254 }
1255 #endif
1256
1257 static __inline__
1258 xfrm_address_t *xfrm_flowi_daddr(const struct flowi *fl, unsigned short family)
1259 {
1260         switch (family){
1261         case AF_INET:
1262                 return (xfrm_address_t *)&fl->u.ip4.daddr;
1263         case AF_INET6:
1264                 return (xfrm_address_t *)&fl->u.ip6.daddr;
1265         }
1266         return NULL;
1267 }
1268
1269 static __inline__
1270 xfrm_address_t *xfrm_flowi_saddr(const struct flowi *fl, unsigned short family)
1271 {
1272         switch (family){
1273         case AF_INET:
1274                 return (xfrm_address_t *)&fl->u.ip4.saddr;
1275         case AF_INET6:
1276                 return (xfrm_address_t *)&fl->u.ip6.saddr;
1277         }
1278         return NULL;
1279 }
1280
1281 static __inline__
1282 void xfrm_flowi_addr_get(const struct flowi *fl,
1283                          xfrm_address_t *saddr, xfrm_address_t *daddr,
1284                          unsigned short family)
1285 {
1286         switch(family) {
1287         case AF_INET:
1288                 memcpy(&saddr->a4, &fl->u.ip4.saddr, sizeof(saddr->a4));
1289                 memcpy(&daddr->a4, &fl->u.ip4.daddr, sizeof(daddr->a4));
1290                 break;
1291         case AF_INET6:
1292                 saddr->in6 = fl->u.ip6.saddr;
1293                 daddr->in6 = fl->u.ip6.daddr;
1294                 break;
1295         }
1296 }
1297
1298 static __inline__ int
1299 __xfrm4_state_addr_check(const struct xfrm_state *x,
1300                          const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1301 {
1302         if (daddr->a4 == x->id.daddr.a4 &&
1303             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
1304                 return 1;
1305         return 0;
1306 }
1307
1308 static __inline__ int
1309 __xfrm6_state_addr_check(const struct xfrm_state *x,
1310                          const xfrm_address_t *daddr, const xfrm_address_t *saddr)
1311 {
1312         if (ipv6_addr_equal((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
1313             (ipv6_addr_equal((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr) ||
1314              ipv6_addr_any((struct in6_addr *)saddr) ||
1315              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
1316                 return 1;
1317         return 0;
1318 }
1319
1320 static __inline__ int
1321 xfrm_state_addr_check(const struct xfrm_state *x,
1322                       const xfrm_address_t *daddr, const xfrm_address_t *saddr,
1323                       unsigned short family)
1324 {
1325         switch (family) {
1326         case AF_INET:
1327                 return __xfrm4_state_addr_check(x, daddr, saddr);
1328         case AF_INET6:
1329                 return __xfrm6_state_addr_check(x, daddr, saddr);
1330         }
1331         return 0;
1332 }
1333
1334 static __inline__ int
1335 xfrm_state_addr_flow_check(const struct xfrm_state *x, const struct flowi *fl,
1336                            unsigned short family)
1337 {
1338         switch (family) {
1339         case AF_INET:
1340                 return __xfrm4_state_addr_check(x,
1341                                                 (const xfrm_address_t *)&fl->u.ip4.daddr,
1342                                                 (const xfrm_address_t *)&fl->u.ip4.saddr);
1343         case AF_INET6:
1344                 return __xfrm6_state_addr_check(x,
1345                                                 (const xfrm_address_t *)&fl->u.ip6.daddr,
1346                                                 (const xfrm_address_t *)&fl->u.ip6.saddr);
1347         }
1348         return 0;
1349 }
1350
1351 static inline int xfrm_state_kern(const struct xfrm_state *x)
1352 {
1353         return atomic_read(&x->tunnel_users);
1354 }
1355
1356 static inline bool xfrm_id_proto_valid(u8 proto)
1357 {
1358         switch (proto) {
1359         case IPPROTO_AH:
1360         case IPPROTO_ESP:
1361         case IPPROTO_COMP:
1362 #if IS_ENABLED(CONFIG_IPV6)
1363         case IPPROTO_ROUTING:
1364         case IPPROTO_DSTOPTS:
1365 #endif
1366                 return true;
1367         default:
1368                 return false;
1369         }
1370 }
1371
1372 /* IPSEC_PROTO_ANY only matches 3 IPsec protocols, 0 could match all. */
1373 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
1374 {
1375         return (!userproto || proto == userproto ||
1376                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
1377                                                   proto == IPPROTO_ESP ||
1378                                                   proto == IPPROTO_COMP)));
1379 }
1380
1381 /*
1382  * xfrm algorithm information
1383  */
1384 struct xfrm_algo_aead_info {
1385         char *geniv;
1386         u16 icv_truncbits;
1387 };
1388
1389 struct xfrm_algo_auth_info {
1390         u16 icv_truncbits;
1391         u16 icv_fullbits;
1392 };
1393
1394 struct xfrm_algo_encr_info {
1395         char *geniv;
1396         u16 blockbits;
1397         u16 defkeybits;
1398 };
1399
1400 struct xfrm_algo_comp_info {
1401         u16 threshold;
1402 };
1403
1404 struct xfrm_algo_desc {
1405         char *name;
1406         char *compat;
1407         u8 available:1;
1408         u8 pfkey_supported:1;
1409         union {
1410                 struct xfrm_algo_aead_info aead;
1411                 struct xfrm_algo_auth_info auth;
1412                 struct xfrm_algo_encr_info encr;
1413                 struct xfrm_algo_comp_info comp;
1414         } uinfo;
1415         struct sadb_alg desc;
1416 };
1417
1418 /* XFRM protocol handlers.  */
1419 struct xfrm4_protocol {
1420         int (*handler)(struct sk_buff *skb);
1421         int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
1422                              int encap_type);
1423         int (*cb_handler)(struct sk_buff *skb, int err);
1424         int (*err_handler)(struct sk_buff *skb, u32 info);
1425
1426         struct xfrm4_protocol __rcu *next;
1427         int priority;
1428 };
1429
1430 struct xfrm6_protocol {
1431         int (*handler)(struct sk_buff *skb);
1432         int (*input_handler)(struct sk_buff *skb, int nexthdr, __be32 spi,
1433                              int encap_type);
1434         int (*cb_handler)(struct sk_buff *skb, int err);
1435         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1436                            u8 type, u8 code, int offset, __be32 info);
1437
1438         struct xfrm6_protocol __rcu *next;
1439         int priority;
1440 };
1441
1442 /* XFRM tunnel handlers.  */
1443 struct xfrm_tunnel {
1444         int (*handler)(struct sk_buff *skb);
1445         int (*cb_handler)(struct sk_buff *skb, int err);
1446         int (*err_handler)(struct sk_buff *skb, u32 info);
1447
1448         struct xfrm_tunnel __rcu *next;
1449         int priority;
1450 };
1451
1452 struct xfrm6_tunnel {
1453         int (*handler)(struct sk_buff *skb);
1454         int (*cb_handler)(struct sk_buff *skb, int err);
1455         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1456                            u8 type, u8 code, int offset, __be32 info);
1457         struct xfrm6_tunnel __rcu *next;
1458         int priority;
1459 };
1460
1461 void xfrm_init(void);
1462 void xfrm4_init(void);
1463 int xfrm_state_init(struct net *net);
1464 void xfrm_state_fini(struct net *net);
1465 void xfrm4_state_init(void);
1466 void xfrm4_protocol_init(void);
1467 #ifdef CONFIG_XFRM
1468 int xfrm6_init(void);
1469 void xfrm6_fini(void);
1470 int xfrm6_state_init(void);
1471 void xfrm6_state_fini(void);
1472 int xfrm6_protocol_init(void);
1473 void xfrm6_protocol_fini(void);
1474 #else
1475 static inline int xfrm6_init(void)
1476 {
1477         return 0;
1478 }
1479 static inline void xfrm6_fini(void)
1480 {
1481         ;
1482 }
1483 #endif
1484
1485 #ifdef CONFIG_XFRM_STATISTICS
1486 int xfrm_proc_init(struct net *net);
1487 void xfrm_proc_fini(struct net *net);
1488 #endif
1489
1490 int xfrm_sysctl_init(struct net *net);
1491 #ifdef CONFIG_SYSCTL
1492 void xfrm_sysctl_fini(struct net *net);
1493 #else
1494 static inline void xfrm_sysctl_fini(struct net *net)
1495 {
1496 }
1497 #endif
1498
1499 void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
1500                           struct xfrm_address_filter *filter);
1501 int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
1502                     int (*func)(struct xfrm_state *, int, void*), void *);
1503 void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net);
1504 struct xfrm_state *xfrm_state_alloc(struct net *net);
1505 void xfrm_state_free(struct xfrm_state *x);
1506 struct xfrm_state *xfrm_state_find(const xfrm_address_t *daddr,
1507                                    const xfrm_address_t *saddr,
1508                                    const struct flowi *fl,
1509                                    struct xfrm_tmpl *tmpl,
1510                                    struct xfrm_policy *pol, int *err,
1511                                    unsigned short family, u32 if_id);
1512 struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
1513                                        xfrm_address_t *daddr,
1514                                        xfrm_address_t *saddr,
1515                                        unsigned short family,
1516                                        u8 mode, u8 proto, u32 reqid);
1517 struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
1518                                               unsigned short family);
1519 int xfrm_state_check_expire(struct xfrm_state *x);
1520 void xfrm_state_insert(struct xfrm_state *x);
1521 int xfrm_state_add(struct xfrm_state *x);
1522 int xfrm_state_update(struct xfrm_state *x);
1523 struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
1524                                      const xfrm_address_t *daddr, __be32 spi,
1525                                      u8 proto, unsigned short family);
1526 struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
1527                                             const xfrm_address_t *daddr,
1528                                             const xfrm_address_t *saddr,
1529                                             u8 proto,
1530                                             unsigned short family);
1531 #ifdef CONFIG_XFRM_SUB_POLICY
1532 void xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
1533                     unsigned short family);
1534 void xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
1535                      unsigned short family);
1536 #else
1537 static inline void xfrm_tmpl_sort(struct xfrm_tmpl **d, struct xfrm_tmpl **s,
1538                                   int n, unsigned short family)
1539 {
1540 }
1541
1542 static inline void xfrm_state_sort(struct xfrm_state **d, struct xfrm_state **s,
1543                                    int n, unsigned short family)
1544 {
1545 }
1546 #endif
1547
1548 struct xfrmk_sadinfo {
1549         u32 sadhcnt; /* current hash bkts */
1550         u32 sadhmcnt; /* max allowed hash bkts */
1551         u32 sadcnt; /* current running count */
1552 };
1553
1554 struct xfrmk_spdinfo {
1555         u32 incnt;
1556         u32 outcnt;
1557         u32 fwdcnt;
1558         u32 inscnt;
1559         u32 outscnt;
1560         u32 fwdscnt;
1561         u32 spdhcnt;
1562         u32 spdhmcnt;
1563 };
1564
1565 struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
1566 int xfrm_state_delete(struct xfrm_state *x);
1567 int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync);
1568 int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid);
1569 void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
1570 void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
1571 u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
1572 int xfrm_init_replay(struct xfrm_state *x);
1573 u32 xfrm_state_mtu(struct xfrm_state *x, int mtu);
1574 int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload);
1575 int xfrm_init_state(struct xfrm_state *x);
1576 int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);
1577 int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
1578 int xfrm_trans_queue_net(struct net *net, struct sk_buff *skb,
1579                          int (*finish)(struct net *, struct sock *,
1580                                        struct sk_buff *));
1581 int xfrm_trans_queue(struct sk_buff *skb,
1582                      int (*finish)(struct net *, struct sock *,
1583                                    struct sk_buff *));
1584 int xfrm_output_resume(struct sock *sk, struct sk_buff *skb, int err);
1585 int xfrm_output(struct sock *sk, struct sk_buff *skb);
1586
1587 #if IS_ENABLED(CONFIG_NET_PKTGEN)
1588 int pktgen_xfrm_outer_mode_output(struct xfrm_state *x, struct sk_buff *skb);
1589 #endif
1590
1591 void xfrm_local_error(struct sk_buff *skb, int mtu);
1592 int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1593 int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1594                     int encap_type);
1595 int xfrm4_transport_finish(struct sk_buff *skb, int async);
1596 int xfrm4_rcv(struct sk_buff *skb);
1597
1598 static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
1599 {
1600         XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL;
1601         XFRM_SPI_SKB_CB(skb)->family = AF_INET;
1602         XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr);
1603         return xfrm_input(skb, nexthdr, spi, 0);
1604 }
1605
1606 int xfrm4_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1607 int xfrm4_protocol_register(struct xfrm4_protocol *handler, unsigned char protocol);
1608 int xfrm4_protocol_deregister(struct xfrm4_protocol *handler, unsigned char protocol);
1609 int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1610 int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1611 void xfrm4_local_error(struct sk_buff *skb, u32 mtu);
1612 int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1613 int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi,
1614                   struct ip6_tnl *t);
1615 int xfrm6_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1616                     int encap_type);
1617 int xfrm6_transport_finish(struct sk_buff *skb, int async);
1618 int xfrm6_rcv_tnl(struct sk_buff *skb, struct ip6_tnl *t);
1619 int xfrm6_rcv(struct sk_buff *skb);
1620 int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1621                      xfrm_address_t *saddr, u8 proto);
1622 void xfrm6_local_error(struct sk_buff *skb, u32 mtu);
1623 int xfrm6_protocol_register(struct xfrm6_protocol *handler, unsigned char protocol);
1624 int xfrm6_protocol_deregister(struct xfrm6_protocol *handler, unsigned char protocol);
1625 int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1626 int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1627 __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
1628 __be32 xfrm6_tunnel_spi_lookup(struct net *net, const xfrm_address_t *saddr);
1629 int xfrm6_output(struct net *net, struct sock *sk, struct sk_buff *skb);
1630
1631 #ifdef CONFIG_XFRM
1632 void xfrm6_local_rxpmtu(struct sk_buff *skb, u32 mtu);
1633 int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1634 int xfrm6_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1635 int xfrm_user_policy(struct sock *sk, int optname, sockptr_t optval,
1636                      int optlen);
1637 #else
1638 static inline int xfrm_user_policy(struct sock *sk, int optname,
1639                                    sockptr_t optval, int optlen)
1640 {
1641         return -ENOPROTOOPT;
1642 }
1643 #endif
1644
1645 struct dst_entry *__xfrm_dst_lookup(struct net *net, int tos, int oif,
1646                                     const xfrm_address_t *saddr,
1647                                     const xfrm_address_t *daddr,
1648                                     int family, u32 mark);
1649
1650 struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
1651
1652 void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
1653 int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
1654                      int (*func)(struct xfrm_policy *, int, int, void*),
1655                      void *);
1656 void xfrm_policy_walk_done(struct xfrm_policy_walk *walk, struct net *net);
1657 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1658 struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net,
1659                                           const struct xfrm_mark *mark,
1660                                           u32 if_id, u8 type, int dir,
1661                                           struct xfrm_selector *sel,
1662                                           struct xfrm_sec_ctx *ctx, int delete,
1663                                           int *err);
1664 struct xfrm_policy *xfrm_policy_byid(struct net *net,
1665                                      const struct xfrm_mark *mark, u32 if_id,
1666                                      u8 type, int dir, u32 id, int delete,
1667                                      int *err);
1668 int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
1669 void xfrm_policy_hash_rebuild(struct net *net);
1670 u32 xfrm_get_acqseq(void);
1671 int verify_spi_info(u8 proto, u32 min, u32 max);
1672 int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1673 struct xfrm_state *xfrm_find_acq(struct net *net, const struct xfrm_mark *mark,
1674                                  u8 mode, u32 reqid, u32 if_id, u8 proto,
1675                                  const xfrm_address_t *daddr,
1676                                  const xfrm_address_t *saddr, int create,
1677                                  unsigned short family);
1678 int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1679
1680 #ifdef CONFIG_XFRM_MIGRATE
1681 int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1682                const struct xfrm_migrate *m, int num_bundles,
1683                const struct xfrm_kmaddress *k,
1684                const struct xfrm_encap_tmpl *encap);
1685 struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net,
1686                                                 u32 if_id);
1687 struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
1688                                       struct xfrm_migrate *m,
1689                                       struct xfrm_encap_tmpl *encap);
1690 int xfrm_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
1691                  struct xfrm_migrate *m, int num_bundles,
1692                  struct xfrm_kmaddress *k, struct net *net,
1693                  struct xfrm_encap_tmpl *encap, u32 if_id);
1694 #endif
1695
1696 int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1697 void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid);
1698 int km_report(struct net *net, u8 proto, struct xfrm_selector *sel,
1699               xfrm_address_t *addr);
1700
1701 void xfrm_input_init(void);
1702 int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1703
1704 void xfrm_probe_algs(void);
1705 int xfrm_count_pfkey_auth_supported(void);
1706 int xfrm_count_pfkey_enc_supported(void);
1707 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1708 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1709 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1710 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1711 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1712 struct xfrm_algo_desc *xfrm_aalg_get_byname(const char *name, int probe);
1713 struct xfrm_algo_desc *xfrm_ealg_get_byname(const char *name, int probe);
1714 struct xfrm_algo_desc *xfrm_calg_get_byname(const char *name, int probe);
1715 struct xfrm_algo_desc *xfrm_aead_get_byname(const char *name, int icv_len,
1716                                             int probe);
1717
1718 static inline bool xfrm6_addr_equal(const xfrm_address_t *a,
1719                                     const xfrm_address_t *b)
1720 {
1721         return ipv6_addr_equal((const struct in6_addr *)a,
1722                                (const struct in6_addr *)b);
1723 }
1724
1725 static inline bool xfrm_addr_equal(const xfrm_address_t *a,
1726                                    const xfrm_address_t *b,
1727                                    sa_family_t family)
1728 {
1729         switch (family) {
1730         default:
1731         case AF_INET:
1732                 return ((__force u32)a->a4 ^ (__force u32)b->a4) == 0;
1733         case AF_INET6:
1734                 return xfrm6_addr_equal(a, b);
1735         }
1736 }
1737
1738 static inline int xfrm_policy_id2dir(u32 index)
1739 {
1740         return index & 7;
1741 }
1742
1743 #ifdef CONFIG_XFRM
1744 void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq);
1745 int xfrm_replay_check(struct xfrm_state *x, struct sk_buff *skb, __be32 net_seq);
1746 void xfrm_replay_notify(struct xfrm_state *x, int event);
1747 int xfrm_replay_overflow(struct xfrm_state *x, struct sk_buff *skb);
1748 int xfrm_replay_recheck(struct xfrm_state *x, struct sk_buff *skb, __be32 net_seq);
1749
1750 static inline int xfrm_aevent_is_on(struct net *net)
1751 {
1752         struct sock *nlsk;
1753         int ret = 0;
1754
1755         rcu_read_lock();
1756         nlsk = rcu_dereference(net->xfrm.nlsk);
1757         if (nlsk)
1758                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1759         rcu_read_unlock();
1760         return ret;
1761 }
1762
1763 static inline int xfrm_acquire_is_on(struct net *net)
1764 {
1765         struct sock *nlsk;
1766         int ret = 0;
1767
1768         rcu_read_lock();
1769         nlsk = rcu_dereference(net->xfrm.nlsk);
1770         if (nlsk)
1771                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE);
1772         rcu_read_unlock();
1773
1774         return ret;
1775 }
1776 #endif
1777
1778 static inline unsigned int aead_len(struct xfrm_algo_aead *alg)
1779 {
1780         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1781 }
1782
1783 static inline unsigned int xfrm_alg_len(const struct xfrm_algo *alg)
1784 {
1785         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1786 }
1787
1788 static inline unsigned int xfrm_alg_auth_len(const struct xfrm_algo_auth *alg)
1789 {
1790         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1791 }
1792
1793 static inline unsigned int xfrm_replay_state_esn_len(struct xfrm_replay_state_esn *replay_esn)
1794 {
1795         return sizeof(*replay_esn) + replay_esn->bmp_len * sizeof(__u32);
1796 }
1797
1798 #ifdef CONFIG_XFRM_MIGRATE
1799 static inline int xfrm_replay_clone(struct xfrm_state *x,
1800                                      struct xfrm_state *orig)
1801 {
1802
1803         x->replay_esn = kmemdup(orig->replay_esn,
1804                                 xfrm_replay_state_esn_len(orig->replay_esn),
1805                                 GFP_KERNEL);
1806         if (!x->replay_esn)
1807                 return -ENOMEM;
1808         x->preplay_esn = kmemdup(orig->preplay_esn,
1809                                  xfrm_replay_state_esn_len(orig->preplay_esn),
1810                                  GFP_KERNEL);
1811         if (!x->preplay_esn)
1812                 return -ENOMEM;
1813
1814         return 0;
1815 }
1816
1817 static inline struct xfrm_algo_aead *xfrm_algo_aead_clone(struct xfrm_algo_aead *orig)
1818 {
1819         return kmemdup(orig, aead_len(orig), GFP_KERNEL);
1820 }
1821
1822
1823 static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1824 {
1825         return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
1826 }
1827
1828 static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
1829 {
1830         return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
1831 }
1832
1833 static inline void xfrm_states_put(struct xfrm_state **states, int n)
1834 {
1835         int i;
1836         for (i = 0; i < n; i++)
1837                 xfrm_state_put(*(states + i));
1838 }
1839
1840 static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1841 {
1842         int i;
1843         for (i = 0; i < n; i++)
1844                 xfrm_state_delete(*(states + i));
1845 }
1846 #endif
1847
1848 #ifdef CONFIG_XFRM
1849 static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
1850 {
1851         struct sec_path *sp = skb_sec_path(skb);
1852
1853         return sp->xvec[sp->len - 1];
1854 }
1855 #endif
1856
1857 static inline struct xfrm_offload *xfrm_offload(struct sk_buff *skb)
1858 {
1859 #ifdef CONFIG_XFRM
1860         struct sec_path *sp = skb_sec_path(skb);
1861
1862         if (!sp || !sp->olen || sp->len != sp->olen)
1863                 return NULL;
1864
1865         return &sp->ovec[sp->olen - 1];
1866 #else
1867         return NULL;
1868 #endif
1869 }
1870
1871 void __init xfrm_dev_init(void);
1872
1873 #ifdef CONFIG_XFRM_OFFLOAD
1874 void xfrm_dev_resume(struct sk_buff *skb);
1875 void xfrm_dev_backlog(struct softnet_data *sd);
1876 struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again);
1877 int xfrm_dev_state_add(struct net *net, struct xfrm_state *x,
1878                        struct xfrm_user_offload *xuo);
1879 bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x);
1880
1881 static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1882 {
1883         struct xfrm_state_offload *xso = &x->xso;
1884
1885         if (xso->dev && xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn)
1886                 xso->dev->xfrmdev_ops->xdo_dev_state_advance_esn(x);
1887 }
1888
1889 static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1890 {
1891         struct xfrm_state *x = dst->xfrm;
1892         struct xfrm_dst *xdst;
1893
1894         if (!x || !x->type_offload)
1895                 return false;
1896
1897         xdst = (struct xfrm_dst *) dst;
1898         if (!x->xso.offload_handle && !xdst->child->xfrm)
1899                 return true;
1900         if (x->xso.offload_handle && (x->xso.dev == xfrm_dst_path(dst)->dev) &&
1901             !xdst->child->xfrm)
1902                 return true;
1903
1904         return false;
1905 }
1906
1907 static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1908 {
1909         struct xfrm_state_offload *xso = &x->xso;
1910
1911         if (xso->dev)
1912                 xso->dev->xfrmdev_ops->xdo_dev_state_delete(x);
1913 }
1914
1915 static inline void xfrm_dev_state_free(struct xfrm_state *x)
1916 {
1917         struct xfrm_state_offload *xso = &x->xso;
1918         struct net_device *dev = xso->dev;
1919
1920         if (dev && dev->xfrmdev_ops) {
1921                 if (dev->xfrmdev_ops->xdo_dev_state_free)
1922                         dev->xfrmdev_ops->xdo_dev_state_free(x);
1923                 xso->dev = NULL;
1924                 dev_put(dev);
1925         }
1926 }
1927 #else
1928 static inline void xfrm_dev_resume(struct sk_buff *skb)
1929 {
1930 }
1931
1932 static inline void xfrm_dev_backlog(struct softnet_data *sd)
1933 {
1934 }
1935
1936 static inline struct sk_buff *validate_xmit_xfrm(struct sk_buff *skb, netdev_features_t features, bool *again)
1937 {
1938         return skb;
1939 }
1940
1941 static inline int xfrm_dev_state_add(struct net *net, struct xfrm_state *x, struct xfrm_user_offload *xuo)
1942 {
1943         return 0;
1944 }
1945
1946 static inline void xfrm_dev_state_delete(struct xfrm_state *x)
1947 {
1948 }
1949
1950 static inline void xfrm_dev_state_free(struct xfrm_state *x)
1951 {
1952 }
1953
1954 static inline bool xfrm_dev_offload_ok(struct sk_buff *skb, struct xfrm_state *x)
1955 {
1956         return false;
1957 }
1958
1959 static inline void xfrm_dev_state_advance_esn(struct xfrm_state *x)
1960 {
1961 }
1962
1963 static inline bool xfrm_dst_offload_ok(struct dst_entry *dst)
1964 {
1965         return false;
1966 }
1967 #endif
1968
1969 static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
1970 {
1971         if (attrs[XFRMA_MARK])
1972                 memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
1973         else
1974                 m->v = m->m = 0;
1975
1976         return m->v & m->m;
1977 }
1978
1979 static inline int xfrm_mark_put(struct sk_buff *skb, const struct xfrm_mark *m)
1980 {
1981         int ret = 0;
1982
1983         if (m->m | m->v)
1984                 ret = nla_put(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
1985         return ret;
1986 }
1987
1988 static inline __u32 xfrm_smark_get(__u32 mark, struct xfrm_state *x)
1989 {
1990         struct xfrm_mark *m = &x->props.smark;
1991
1992         return (m->v & m->m) | (mark & ~m->m);
1993 }
1994
1995 static inline int xfrm_if_id_put(struct sk_buff *skb, __u32 if_id)
1996 {
1997         int ret = 0;
1998
1999         if (if_id)
2000                 ret = nla_put_u32(skb, XFRMA_IF_ID, if_id);
2001         return ret;
2002 }
2003
2004 static inline int xfrm_tunnel_check(struct sk_buff *skb, struct xfrm_state *x,
2005                                     unsigned int family)
2006 {
2007         bool tunnel = false;
2008
2009         switch(family) {
2010         case AF_INET:
2011                 if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4)
2012                         tunnel = true;
2013                 break;
2014         case AF_INET6:
2015                 if (XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6)
2016                         tunnel = true;
2017                 break;
2018         }
2019         if (tunnel && !(x->outer_mode.flags & XFRM_MODE_FLAG_TUNNEL))
2020                 return -EINVAL;
2021
2022         return 0;
2023 }
2024
2025 extern const int xfrm_msg_min[XFRM_NR_MSGTYPES];
2026 extern const struct nla_policy xfrma_policy[XFRMA_MAX+1];
2027
2028 struct xfrm_translator {
2029         /* Allocate frag_list and put compat translation there */
2030         int (*alloc_compat)(struct sk_buff *skb, const struct nlmsghdr *src);
2031
2032         /* Allocate nlmsg with 64-bit translaton of received 32-bit message */
2033         struct nlmsghdr *(*rcv_msg_compat)(const struct nlmsghdr *nlh,
2034                         int maxtype, const struct nla_policy *policy,
2035                         struct netlink_ext_ack *extack);
2036
2037         /* Translate 32-bit user_policy from sockptr */
2038         int (*xlate_user_policy_sockptr)(u8 **pdata32, int optlen);
2039
2040         struct module *owner;
2041 };
2042
2043 #if IS_ENABLED(CONFIG_XFRM_USER_COMPAT)
2044 extern int xfrm_register_translator(struct xfrm_translator *xtr);
2045 extern int xfrm_unregister_translator(struct xfrm_translator *xtr);
2046 extern struct xfrm_translator *xfrm_get_translator(void);
2047 extern void xfrm_put_translator(struct xfrm_translator *xtr);
2048 #else
2049 static inline struct xfrm_translator *xfrm_get_translator(void)
2050 {
2051         return NULL;
2052 }
2053 static inline void xfrm_put_translator(struct xfrm_translator *xtr)
2054 {
2055 }
2056 #endif
2057
2058 #if IS_ENABLED(CONFIG_IPV6)
2059 static inline bool xfrm6_local_dontfrag(const struct sock *sk)
2060 {
2061         int proto;
2062
2063         if (!sk || sk->sk_family != AF_INET6)
2064                 return false;
2065
2066         proto = sk->sk_protocol;
2067         if (proto == IPPROTO_UDP || proto == IPPROTO_RAW)
2068                 return inet6_sk(sk)->dontfrag;
2069
2070         return false;
2071 }
2072 #endif
2073 #endif  /* _NET_XFRM_H */