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