include/net/xfrm.h

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