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