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