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