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