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