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