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