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