include/net/xfrm.h

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