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