include/net/xfrm.h

   1 #ifndef _NET_XFRM_H
   2 #define _NET_XFRM_H
   3
   4 #include <linux/compiler.h>
   5 #include <linux/xfrm.h>
   6 #include <linux/spinlock.h>
   7 #include <linux/list.h>
   8 #include <linux/skbuff.h>
   9 #include <linux/socket.h>
  10 #include <linux/pfkeyv2.h>
  11 #include <linux/ipsec.h>
  12 #include <linux/in6.h>
  13 #include <linux/mutex.h>
  14 #include <linux/audit.h>
  15 #include <linux/slab.h>
  16
  17 #include <net/sock.h>
  18 #include <net/dst.h>
  19 #include <net/ip.h>
  20 #include <net/route.h>
  21 #include <net/ipv6.h>
  22 #include <net/ip6_fib.h>
  23 #include <net/flow.h>
  24
  25 #include <linux/interrupt.h>
  26
  27 #ifdef CONFIG_XFRM_STATISTICS
  28 #include <net/snmp.h>
  29 #endif
  30
  31 #define XFRM_PROTO_ESP          50
  32 #define XFRM_PROTO_AH           51
  33 #define XFRM_PROTO_COMP         108
  34 #define XFRM_PROTO_IPIP         4
  35 #define XFRM_PROTO_IPV6         41
  36 #define XFRM_PROTO_ROUTING      IPPROTO_ROUTING
  37 #define XFRM_PROTO_DSTOPTS      IPPROTO_DSTOPTS
  38
  39 #define XFRM_ALIGN4(len)        (((len) + 3) & ~3)
  40 #define XFRM_ALIGN8(len)        (((len) + 7) & ~7)
  41 #define MODULE_ALIAS_XFRM_MODE(family, encap) \
  42         MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
  43 #define MODULE_ALIAS_XFRM_TYPE(family, proto) \
  44         MODULE_ALIAS("xfrm-type-" __stringify(family) "-" __stringify(proto))
  45
  46 #ifdef CONFIG_XFRM_STATISTICS
  47 #define XFRM_INC_STATS(net, field)      SNMP_INC_STATS((net)->mib.xfrm_statistics, field)
  48 #define XFRM_INC_STATS_BH(net, field)   SNMP_INC_STATS_BH((net)->mib.xfrm_statistics, field)
  49 #define XFRM_INC_STATS_USER(net, field) SNMP_INC_STATS_USER((net)-mib.xfrm_statistics, field)
  50 #else
  51 #define XFRM_INC_STATS(net, field)      ((void)(net))
  52 #define XFRM_INC_STATS_BH(net, field)   ((void)(net))
  53 #define XFRM_INC_STATS_USER(net, field) ((void)(net))
  54 #endif
  55
  56 extern struct mutex xfrm_cfg_mutex;
  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         union {
 123                 u8              dying;
 124                 u8              proto;
 125         };
 126         u32                     seq;
 127 };
 128
 129 /* Full description of state of transformer. */
 130 struct xfrm_state {
 131 #ifdef CONFIG_NET_NS
 132         struct net              *xs_net;
 133 #endif
 134         union {
 135                 struct hlist_node       gclist;
 136                 struct hlist_node       bydst;
 137         };
 138         struct hlist_node       bysrc;
 139         struct hlist_node       byspi;
 140
 141         atomic_t                refcnt;
 142         spinlock_t              lock;
 143
 144         struct xfrm_id          id;
 145         struct xfrm_selector    sel;
 146         struct xfrm_mark        mark;
 147         u32                     tfcpad;
 148
 149         u32                     genid;
 150
 151         /* Key manager bits */
 152         struct xfrm_state_walk  km;
 153
 154         /* Parameters of this state. */
 155         struct {
 156                 u32             reqid;
 157                 u8              mode;
 158                 u8              replay_window;
 159                 u8              aalgo, ealgo, calgo;
 160                 u8              flags;
 161                 u16             family;
 162                 xfrm_address_t  saddr;
 163                 int             header_len;
 164                 int             trailer_len;
 165         } props;
 166
 167         struct xfrm_lifetime_cfg lft;
 168
 169         /* Data for transformer */
 170         struct xfrm_algo_auth   *aalg;
 171         struct xfrm_algo        *ealg;
 172         struct xfrm_algo        *calg;
 173         struct xfrm_algo_aead   *aead;
 174
 175         /* Data for encapsulator */
 176         struct xfrm_encap_tmpl  *encap;
 177
 178         /* Data for care-of address */
 179         xfrm_address_t  *coaddr;
 180
 181         /* IPComp needs an IPIP tunnel for handling uncompressed packets */
 182         struct xfrm_state       *tunnel;
 183
 184         /* If a tunnel, number of users + 1 */
 185         atomic_t                tunnel_users;
 186
 187         /* State for replay detection */
 188         struct xfrm_replay_state replay;
 189
 190         /* Replay detection state at the time we sent the last notification */
 191         struct xfrm_replay_state preplay;
 192
 193         /* internal flag that only holds state for delayed aevent at the
 194          * moment
 195         */
 196         u32                     xflags;
 197
 198         /* Replay detection notification settings */
 199         u32                     replay_maxage;
 200         u32                     replay_maxdiff;
 201
 202         /* Replay detection notification timer */
 203         struct timer_list       rtimer;
 204
 205         /* Statistics */
 206         struct xfrm_stats       stats;
 207
 208         struct xfrm_lifetime_cur curlft;
 209         struct tasklet_hrtimer  mtimer;
 210
 211         /* Last used time */
 212         unsigned long           lastused;
 213
 214         /* Reference to data common to all the instances of this
 215          * transformer. */
 216         const struct xfrm_type  *type;
 217         struct xfrm_mode        *inner_mode;
 218         struct xfrm_mode        *inner_mode_iaf;
 219         struct xfrm_mode        *outer_mode;
 220
 221         /* Security context */
 222         struct xfrm_sec_ctx     *security;
 223
 224         /* Private data of this transformer, format is opaque,
 225          * interpreted by xfrm_type methods. */
 226         void                    *data;
 227 };
 228
 229 static inline struct net *xs_net(struct xfrm_state *x)
 230 {
 231         return read_pnet(&x->xs_net);
 232 }
 233
 234 /* xflags - make enum if more show up */
 235 #define XFRM_TIME_DEFER 1
 236
 237 enum {
 238         XFRM_STATE_VOID,
 239         XFRM_STATE_ACQ,
 240         XFRM_STATE_VALID,
 241         XFRM_STATE_ERROR,
 242         XFRM_STATE_EXPIRED,
 243         XFRM_STATE_DEAD
 244 };
 245
 246 /* callback structure passed from either netlink or pfkey */
 247 struct km_event {
 248         union {
 249                 u32 hard;
 250                 u32 proto;
 251                 u32 byid;
 252                 u32 aevent;
 253                 u32 type;
 254         } data;
 255
 256         u32     seq;
 257         u32     pid;
 258         u32     event;
 259         struct net *net;
 260 };
 261
 262 struct net_device;
 263 struct xfrm_type;
 264 struct xfrm_dst;
 265 struct xfrm_policy_afinfo {
 266         unsigned short          family;
 267         struct dst_ops          *dst_ops;
 268         void                    (*garbage_collect)(struct net *net);
 269         struct dst_entry        *(*dst_lookup)(struct net *net, int tos,
 270                                                xfrm_address_t *saddr,
 271                                                xfrm_address_t *daddr);
 272         int                     (*get_saddr)(struct net *net, xfrm_address_t *saddr, xfrm_address_t *daddr);
 273         void                    (*decode_session)(struct sk_buff *skb,
 274                                                   struct flowi *fl,
 275                                                   int reverse);
 276         int                     (*get_tos)(struct flowi *fl);
 277         int                     (*init_path)(struct xfrm_dst *path,
 278                                              struct dst_entry *dst,
 279                                              int nfheader_len);
 280         int                     (*fill_dst)(struct xfrm_dst *xdst,
 281                                             struct net_device *dev,
 282                                             struct flowi *fl);
 283 };
 284
 285 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 286 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
 287 extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
 288 extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
 289
 290 struct xfrm_tmpl;
 291 extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
 292 extern void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
 293 extern int __xfrm_state_delete(struct xfrm_state *x);
 294
 295 struct xfrm_state_afinfo {
 296         unsigned int            family;
 297         unsigned int            proto;
 298         __be16                  eth_proto;
 299         struct module           *owner;
 300         const struct xfrm_type  *type_map[IPPROTO_MAX];
 301         struct xfrm_mode        *mode_map[XFRM_MODE_MAX];
 302         int                     (*init_flags)(struct xfrm_state *x);
 303         void                    (*init_tempsel)(struct xfrm_selector *sel, struct flowi *fl);
 304         void                    (*init_temprop)(struct xfrm_state *x, struct xfrm_tmpl *tmpl,
 305                                                 xfrm_address_t *daddr, xfrm_address_t *saddr);
 306         int                     (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
 307         int                     (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
 308         int                     (*output)(struct sk_buff *skb);
 309         int                     (*extract_input)(struct xfrm_state *x,
 310                                                  struct sk_buff *skb);
 311         int                     (*extract_output)(struct xfrm_state *x,
 312                                                   struct sk_buff *skb);
 313         int                     (*transport_finish)(struct sk_buff *skb,
 314                                                     int async);
 315 };
 316
 317 extern int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
 318 extern int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
 319
 320 extern void xfrm_state_delete_tunnel(struct xfrm_state *x);
 321
 322 struct xfrm_type {
 323         char                    *description;
 324         struct module           *owner;
 325         u8                      proto;
 326         u8                      flags;
 327 #define XFRM_TYPE_NON_FRAGMENT  1
 328 #define XFRM_TYPE_REPLAY_PROT   2
 329 #define XFRM_TYPE_LOCAL_COADDR  4
 330 #define XFRM_TYPE_REMOTE_COADDR 8
 331
 332         int                     (*init_state)(struct xfrm_state *x);
 333         void                    (*destructor)(struct xfrm_state *);
 334         int                     (*input)(struct xfrm_state *, struct sk_buff *skb);
 335         int                     (*output)(struct xfrm_state *, struct sk_buff *pskb);
 336         int                     (*reject)(struct xfrm_state *, struct sk_buff *, struct flowi *);
 337         int                     (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
 338         /* Estimate maximal size of result of transformation of a dgram */
 339         u32                     (*get_mtu)(struct xfrm_state *, int size);
 340 };
 341
 342 extern int xfrm_register_type(const struct xfrm_type *type, unsigned short family);
 343 extern int xfrm_unregister_type(const struct xfrm_type *type, unsigned short family);
 344
 345 struct xfrm_mode {
 346         /*
 347          * Remove encapsulation header.
 348          *
 349          * The IP header will be moved over the top of the encapsulation
 350          * header.
 351          *
 352          * On entry, the transport header shall point to where the IP header
 353          * should be and the network header shall be set to where the IP
 354          * header currently is.  skb->data shall point to the start of the
 355          * payload.
 356          */
 357         int (*input2)(struct xfrm_state *x, struct sk_buff *skb);
 358
 359         /*
 360          * This is the actual input entry point.
 361          *
 362          * For transport mode and equivalent this would be identical to
 363          * input2 (which does not need to be set).  While tunnel mode
 364          * and equivalent would set this to the tunnel encapsulation function
 365          * xfrm4_prepare_input that would in turn call input2.
 366          */
 367         int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 368
 369         /*
 370          * Add encapsulation header.
 371          *
 372          * On exit, the transport header will be set to the start of the
 373          * encapsulation header to be filled in by x->type->output and
 374          * the mac header will be set to the nextheader (protocol for
 375          * IPv4) field of the extension header directly preceding the
 376          * encapsulation header, or in its absence, that of the top IP
 377          * header.  The value of the network header will always point
 378          * to the top IP header while skb->data will point to the payload.
 379          */
 380         int (*output2)(struct xfrm_state *x,struct sk_buff *skb);
 381
 382         /*
 383          * This is the actual output entry point.
 384          *
 385          * For transport mode and equivalent this would be identical to
 386          * output2 (which does not need to be set).  While tunnel mode
 387          * and equivalent would set this to a tunnel encapsulation function
 388          * (xfrm4_prepare_output or xfrm6_prepare_output) that would in turn
 389          * call output2.
 390          */
 391         int (*output)(struct xfrm_state *x, struct sk_buff *skb);
 392
 393         struct xfrm_state_afinfo *afinfo;
 394         struct module *owner;
 395         unsigned int encap;
 396         int flags;
 397 };
 398
 399 /* Flags for xfrm_mode. */
 400 enum {
 401         XFRM_MODE_FLAG_TUNNEL = 1,
 402 };
 403
 404 extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
 405 extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
 406
 407 static inline int xfrm_af2proto(unsigned int family)
 408 {
 409         switch(family) {
 410         case AF_INET:
 411                 return IPPROTO_IPIP;
 412         case AF_INET6:
 413                 return IPPROTO_IPV6;
 414         default:
 415                 return 0;
 416         }
 417 }
 418
 419 static inline struct xfrm_mode *xfrm_ip2inner_mode(struct xfrm_state *x, int ipproto)
 420 {
 421         if ((ipproto == IPPROTO_IPIP && x->props.family == AF_INET) ||
 422             (ipproto == IPPROTO_IPV6 && x->props.family == AF_INET6))
 423                 return x->inner_mode;
 424         else
 425                 return x->inner_mode_iaf;
 426 }
 427
 428 struct xfrm_tmpl {
 429 /* id in template is interpreted as:
 430  * daddr - destination of tunnel, may be zero for transport mode.
 431  * spi   - zero to acquire spi. Not zero if spi is static, then
 432  *         daddr must be fixed too.
 433  * proto - AH/ESP/IPCOMP
 434  */
 435         struct xfrm_id          id;
 436
 437 /* Source address of tunnel. Ignored, if it is not a tunnel. */
 438         xfrm_address_t          saddr;
 439
 440         unsigned short          encap_family;
 441
 442         u32                     reqid;
 443
 444 /* Mode: transport, tunnel etc. */
 445         u8                      mode;
 446
 447 /* Sharing mode: unique, this session only, this user only etc. */
 448         u8                      share;
 449
 450 /* May skip this transfomration if no SA is found */
 451         u8                      optional;
 452
 453 /* Skip aalgos/ealgos/calgos checks. */
 454         u8                      allalgs;
 455
 456 /* Bit mask of algos allowed for acquisition */
 457         u32                     aalgos;
 458         u32                     ealgos;
 459         u32                     calgos;
 460 };
 461
 462 #define XFRM_MAX_DEPTH          6
 463
 464 struct xfrm_policy_walk_entry {
 465         struct list_head        all;
 466         u8                      dead;
 467 };
 468
 469 struct xfrm_policy_walk {
 470         struct xfrm_policy_walk_entry walk;
 471         u8 type;
 472         u32 seq;
 473 };
 474
 475 struct xfrm_policy {
 476 #ifdef CONFIG_NET_NS
 477         struct net              *xp_net;
 478 #endif
 479         struct hlist_node       bydst;
 480         struct hlist_node       byidx;
 481
 482         /* This lock only affects elements except for entry. */
 483         rwlock_t                lock;
 484         atomic_t                refcnt;
 485         struct timer_list       timer;
 486
 487         struct flow_cache_object flo;
 488         atomic_t                genid;
 489         u32                     priority;
 490         u32                     index;
 491         struct xfrm_mark        mark;
 492         struct xfrm_selector    selector;
 493         struct xfrm_lifetime_cfg lft;
 494         struct xfrm_lifetime_cur curlft;
 495         struct xfrm_policy_walk_entry walk;
 496         u8                      type;
 497         u8                      action;
 498         u8                      flags;
 499         u8                      xfrm_nr;
 500         u16                     family;
 501         struct xfrm_sec_ctx     *security;
 502         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 503 };
 504
 505 static inline struct net *xp_net(struct xfrm_policy *xp)
 506 {
 507         return read_pnet(&xp->xp_net);
 508 }
 509
 510 struct xfrm_kmaddress {
 511         xfrm_address_t          local;
 512         xfrm_address_t          remote;
 513         u32                     reserved;
 514         u16                     family;
 515 };
 516
 517 struct xfrm_migrate {
 518         xfrm_address_t          old_daddr;
 519         xfrm_address_t          old_saddr;
 520         xfrm_address_t          new_daddr;
 521         xfrm_address_t          new_saddr;
 522         u8                      proto;
 523         u8                      mode;
 524         u16                     reserved;
 525         u32                     reqid;
 526         u16                     old_family;
 527         u16                     new_family;
 528 };
 529
 530 #define XFRM_KM_TIMEOUT                30
 531 /* which seqno */
 532 #define XFRM_REPLAY_SEQ         1
 533 #define XFRM_REPLAY_OSEQ        2
 534 #define XFRM_REPLAY_SEQ_MASK    3
 535 /* what happened */
 536 #define XFRM_REPLAY_UPDATE      XFRM_AE_CR
 537 #define XFRM_REPLAY_TIMEOUT     XFRM_AE_CE
 538
 539 /* default aevent timeout in units of 100ms */
 540 #define XFRM_AE_ETIME                   10
 541 /* Async Event timer multiplier */
 542 #define XFRM_AE_ETH_M                   10
 543 /* default seq threshold size */
 544 #define XFRM_AE_SEQT_SIZE               2
 545
 546 struct xfrm_mgr {
 547         struct list_head        list;
 548         char                    *id;
 549         int                     (*notify)(struct xfrm_state *x, struct km_event *c);
 550         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 551         struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 552         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
 553         int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 554         int                     (*report)(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
 555         int                     (*migrate)(struct xfrm_selector *sel, u8 dir, u8 type, struct xfrm_migrate *m, int num_bundles, struct xfrm_kmaddress *k);
 556 };
 557
 558 extern int xfrm_register_km(struct xfrm_mgr *km);
 559 extern int xfrm_unregister_km(struct xfrm_mgr *km);
 560
 561 /*
 562  * This structure is used for the duration where packets are being
 563  * transformed by IPsec.  As soon as the packet leaves IPsec the
 564  * area beyond the generic IP part may be overwritten.
 565  */
 566 struct xfrm_skb_cb {
 567         union {
 568                 struct inet_skb_parm h4;
 569                 struct inet6_skb_parm h6;
 570         } header;
 571
 572         /* Sequence number for replay protection. */
 573         union {
 574                 u64 output;
 575                 __be32 input;
 576         } seq;
 577 };
 578
 579 #define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
 580
 581 /*
 582  * This structure is used by the afinfo prepare_input/prepare_output functions
 583  * to transmit header information to the mode input/output functions.
 584  */
 585 struct xfrm_mode_skb_cb {
 586         union {
 587                 struct inet_skb_parm h4;
 588                 struct inet6_skb_parm h6;
 589         } header;
 590
 591         /* Copied from header for IPv4, always set to zero and DF for IPv6. */
 592         __be16 id;
 593         __be16 frag_off;
 594
 595         /* IP header length (excluding options or extension headers). */
 596         u8 ihl;
 597
 598         /* TOS for IPv4, class for IPv6. */
 599         u8 tos;
 600
 601         /* TTL for IPv4, hop limitfor IPv6. */
 602         u8 ttl;
 603
 604         /* Protocol for IPv4, NH for IPv6. */
 605         u8 protocol;
 606
 607         /* Option length for IPv4, zero for IPv6. */
 608         u8 optlen;
 609
 610         /* Used by IPv6 only, zero for IPv4. */
 611         u8 flow_lbl[3];
 612 };
 613
 614 #define XFRM_MODE_SKB_CB(__skb) ((struct xfrm_mode_skb_cb *)&((__skb)->cb[0]))
 615
 616 /*
 617  * This structure is used by the input processing to locate the SPI and
 618  * related information.
 619  */
 620 struct xfrm_spi_skb_cb {
 621         union {
 622                 struct inet_skb_parm h4;
 623                 struct inet6_skb_parm h6;
 624         } header;
 625
 626         unsigned int daddroff;
 627         unsigned int family;
 628 };
 629
 630 #define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
 631
 632 /* Audit Information */
 633 struct xfrm_audit {
 634         u32     secid;
 635         uid_t   loginuid;
 636         u32     sessionid;
 637 };
 638
 639 #ifdef CONFIG_AUDITSYSCALL
 640 static inline struct audit_buffer *xfrm_audit_start(const char *op)
 641 {
 642         struct audit_buffer *audit_buf = NULL;
 643
 644         if (audit_enabled == 0)
 645                 return NULL;
 646         audit_buf = audit_log_start(current->audit_context, GFP_ATOMIC,
 647                                     AUDIT_MAC_IPSEC_EVENT);
 648         if (audit_buf == NULL)
 649                 return NULL;
 650         audit_log_format(audit_buf, "op=%s", op);
 651         return audit_buf;
 652 }
 653
 654 static inline void xfrm_audit_helper_usrinfo(uid_t auid, u32 ses, u32 secid,
 655                                              struct audit_buffer *audit_buf)
 656 {
 657         char *secctx;
 658         u32 secctx_len;
 659
 660         audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
 661         if (secid != 0 &&
 662             security_secid_to_secctx(secid, &secctx, &secctx_len) == 0) {
 663                 audit_log_format(audit_buf, " subj=%s", secctx);
 664                 security_release_secctx(secctx, secctx_len);
 665         } else
 666                 audit_log_task_context(audit_buf);
 667 }
 668
 669 extern void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 670                                   u32 auid, u32 ses, u32 secid);
 671 extern void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
 672                                   u32 auid, u32 ses, u32 secid);
 673 extern void xfrm_audit_state_add(struct xfrm_state *x, int result,
 674                                  u32 auid, u32 ses, u32 secid);
 675 extern void xfrm_audit_state_delete(struct xfrm_state *x, int result,
 676                                     u32 auid, u32 ses, u32 secid);
 677 extern void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
 678                                              struct sk_buff *skb);
 679 extern void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family);
 680 extern void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
 681                                       __be32 net_spi, __be32 net_seq);
 682 extern void xfrm_audit_state_icvfail(struct xfrm_state *x,
 683                                      struct sk_buff *skb, u8 proto);
 684 #else
 685
 686 static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 687                                   u32 auid, u32 ses, u32 secid)
 688 {
 689 }
 690
 691 static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
 692                                   u32 auid, u32 ses, u32 secid)
 693 {
 694 }
 695
 696 static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
 697                                  u32 auid, u32 ses, u32 secid)
 698 {
 699 }
 700
 701 static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
 702                                     u32 auid, u32 ses, u32 secid)
 703 {
 704 }
 705
 706 static inline void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
 707                                              struct sk_buff *skb)
 708 {
 709 }
 710
 711 static inline void xfrm_audit_state_notfound_simple(struct sk_buff *skb,
 712                                       u16 family)
 713 {
 714 }
 715
 716 static inline void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
 717                                       __be32 net_spi, __be32 net_seq)
 718 {
 719 }
 720
 721 static inline void xfrm_audit_state_icvfail(struct xfrm_state *x,
 722                                      struct sk_buff *skb, u8 proto)
 723 {
 724 }
 725 #endif /* CONFIG_AUDITSYSCALL */
 726
 727 static inline void xfrm_pol_hold(struct xfrm_policy *policy)
 728 {
 729         if (likely(policy != NULL))
 730                 atomic_inc(&policy->refcnt);
 731 }
 732
 733 extern void xfrm_policy_destroy(struct xfrm_policy *policy);
 734
 735 static inline void xfrm_pol_put(struct xfrm_policy *policy)
 736 {
 737         if (atomic_dec_and_test(&policy->refcnt))
 738                 xfrm_policy_destroy(policy);
 739 }
 740
 741 static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
 742 {
 743         int i;
 744         for (i = npols - 1; i >= 0; --i)
 745                 xfrm_pol_put(pols[i]);
 746 }
 747
 748 extern void __xfrm_state_destroy(struct xfrm_state *);
 749
 750 static inline void __xfrm_state_put(struct xfrm_state *x)
 751 {
 752         atomic_dec(&x->refcnt);
 753 }
 754
 755 static inline void xfrm_state_put(struct xfrm_state *x)
 756 {
 757         if (atomic_dec_and_test(&x->refcnt))
 758                 __xfrm_state_destroy(x);
 759 }
 760
 761 static inline void xfrm_state_hold(struct xfrm_state *x)
 762 {
 763         atomic_inc(&x->refcnt);
 764 }
 765
 766 static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 767 {
 768         __be32 *a1 = token1;
 769         __be32 *a2 = token2;
 770         int pdw;
 771         int pbi;
 772
 773         pdw = prefixlen >> 5;     /* num of whole u32 in prefix */
 774         pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
 775
 776         if (pdw)
 777                 if (memcmp(a1, a2, pdw << 2))
 778                         return 0;
 779
 780         if (pbi) {
 781                 __be32 mask;
 782
 783                 mask = htonl((0xffffffff) << (32 - pbi));
 784
 785                 if ((a1[pdw] ^ a2[pdw]) & mask)
 786                         return 0;
 787         }
 788
 789         return 1;
 790 }
 791
 792 static __inline__
 793 __be16 xfrm_flowi_sport(struct flowi *fl)
 794 {
 795         __be16 port;
 796         switch(fl->proto) {
 797         case IPPROTO_TCP:
 798         case IPPROTO_UDP:
 799         case IPPROTO_UDPLITE:
 800         case IPPROTO_SCTP:
 801                 port = fl->fl_ip_sport;
 802                 break;
 803         case IPPROTO_ICMP:
 804         case IPPROTO_ICMPV6:
 805                 port = htons(fl->fl_icmp_type);
 806                 break;
 807         case IPPROTO_MH:
 808                 port = htons(fl->fl_mh_type);
 809                 break;
 810         case IPPROTO_GRE:
 811                 port = htons(ntohl(fl->fl_gre_key) >> 16);
 812                 break;
 813         default:
 814                 port = 0;       /*XXX*/
 815         }
 816         return port;
 817 }
 818
 819 static __inline__
 820 __be16 xfrm_flowi_dport(struct flowi *fl)
 821 {
 822         __be16 port;
 823         switch(fl->proto) {
 824         case IPPROTO_TCP:
 825         case IPPROTO_UDP:
 826         case IPPROTO_UDPLITE:
 827         case IPPROTO_SCTP:
 828                 port = fl->fl_ip_dport;
 829                 break;
 830         case IPPROTO_ICMP:
 831         case IPPROTO_ICMPV6:
 832                 port = htons(fl->fl_icmp_code);
 833                 break;
 834         case IPPROTO_GRE:
 835                 port = htons(ntohl(fl->fl_gre_key) & 0xffff);
 836                 break;
 837         default:
 838                 port = 0;       /*XXX*/
 839         }
 840         return port;
 841 }
 842
 843 extern int xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
 844                                unsigned short family);
 845
 846 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 847 /*      If neither has a context --> match
 848  *      Otherwise, both must have a context and the sids, doi, alg must match
 849  */
 850 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 851 {
 852         return ((!s1 && !s2) ||
 853                 (s1 && s2 &&
 854                  (s1->ctx_sid == s2->ctx_sid) &&
 855                  (s1->ctx_doi == s2->ctx_doi) &&
 856                  (s1->ctx_alg == s2->ctx_alg)));
 857 }
 858 #else
 859 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 860 {
 861         return 1;
 862 }
 863 #endif
 864
 865 /* A struct encoding bundle of transformations to apply to some set of flow.
 866  *
 867  * dst->child points to the next element of bundle.
 868  * dst->xfrm  points to an instanse of transformer.
 869  *
 870  * Due to unfortunate limitations of current routing cache, which we
 871  * have no time to fix, it mirrors struct rtable and bound to the same
 872  * routing key, including saddr,daddr. However, we can have many of
 873  * bundles differing by session id. All the bundles grow from a parent
 874  * policy rule.
 875  */
 876 struct xfrm_dst {
 877         union {
 878                 struct dst_entry        dst;
 879                 struct rtable           rt;
 880                 struct rt6_info         rt6;
 881         } u;
 882         struct dst_entry *route;
 883         struct flow_cache_object flo;
 884         struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX];
 885         int num_pols, num_xfrms;
 886 #ifdef CONFIG_XFRM_SUB_POLICY
 887         struct flowi *origin;
 888         struct xfrm_selector *partner;
 889 #endif
 890         u32 xfrm_genid;
 891         u32 policy_genid;
 892         u32 route_mtu_cached;
 893         u32 child_mtu_cached;
 894         u32 route_cookie;
 895         u32 path_cookie;
 896 };
 897
 898 #ifdef CONFIG_XFRM
 899 static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 900 {
 901         xfrm_pols_put(xdst->pols, xdst->num_pols);
 902         dst_release(xdst->route);
 903         if (likely(xdst->u.dst.xfrm))
 904                 xfrm_state_put(xdst->u.dst.xfrm);
 905 #ifdef CONFIG_XFRM_SUB_POLICY
 906         kfree(xdst->origin);
 907         xdst->origin = NULL;
 908         kfree(xdst->partner);
 909         xdst->partner = NULL;
 910 #endif
 911 }
 912 #endif
 913
 914 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 915
 916 struct sec_path {
 917         atomic_t                refcnt;
 918         int                     len;
 919         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
 920 };
 921
 922 static inline struct sec_path *
 923 secpath_get(struct sec_path *sp)
 924 {
 925         if (sp)
 926                 atomic_inc(&sp->refcnt);
 927         return sp;
 928 }
 929
 930 extern void __secpath_destroy(struct sec_path *sp);
 931
 932 static inline void
 933 secpath_put(struct sec_path *sp)
 934 {
 935         if (sp && atomic_dec_and_test(&sp->refcnt))
 936                 __secpath_destroy(sp);
 937 }
 938
 939 extern struct sec_path *secpath_dup(struct sec_path *src);
 940
 941 static inline void
 942 secpath_reset(struct sk_buff *skb)
 943 {
 944 #ifdef CONFIG_XFRM
 945         secpath_put(skb->sp);
 946         skb->sp = NULL;
 947 #endif
 948 }
 949
 950 static inline int
 951 xfrm_addr_any(xfrm_address_t *addr, unsigned short family)
 952 {
 953         switch (family) {
 954         case AF_INET:
 955                 return addr->a4 == 0;
 956         case AF_INET6:
 957                 return ipv6_addr_any((struct in6_addr *)&addr->a6);
 958         }
 959         return 0;
 960 }
 961
 962 static inline int
 963 __xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 964 {
 965         return  (tmpl->saddr.a4 &&
 966                  tmpl->saddr.a4 != x->props.saddr.a4);
 967 }
 968
 969 static inline int
 970 __xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 971 {
 972         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
 973                  ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
 974 }
 975
 976 static inline int
 977 xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
 978 {
 979         switch (family) {
 980         case AF_INET:
 981                 return __xfrm4_state_addr_cmp(tmpl, x);
 982         case AF_INET6:
 983                 return __xfrm6_state_addr_cmp(tmpl, x);
 984         }
 985         return !0;
 986 }
 987
 988 #ifdef CONFIG_XFRM
 989 extern int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb, unsigned short family);
 990
 991 static inline int __xfrm_policy_check2(struct sock *sk, int dir,
 992                                        struct sk_buff *skb,
 993                                        unsigned int family, int reverse)
 994 {
 995         struct net *net = dev_net(skb->dev);
 996         int ndir = dir | (reverse ? XFRM_POLICY_MASK + 1 : 0);
 997
 998         if (sk && sk->sk_policy[XFRM_POLICY_IN])
 999                 return __xfrm_policy_check(sk, ndir, skb, family);
1000
1001         return  (!net->xfrm.policy_count[dir] && !skb->sp) ||
1002                 (skb_dst(skb)->flags & DST_NOPOLICY) ||
1003                 __xfrm_policy_check(sk, ndir, skb, family);
1004 }
1005
1006 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1007 {
1008         return __xfrm_policy_check2(sk, dir, skb, family, 0);
1009 }
1010
1011 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1012 {
1013         return xfrm_policy_check(sk, dir, skb, AF_INET);
1014 }
1015
1016 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1017 {
1018         return xfrm_policy_check(sk, dir, skb, AF_INET6);
1019 }
1020
1021 static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1022                                              struct sk_buff *skb)
1023 {
1024         return __xfrm_policy_check2(sk, dir, skb, AF_INET, 1);
1025 }
1026
1027 static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1028                                              struct sk_buff *skb)
1029 {
1030         return __xfrm_policy_check2(sk, dir, skb, AF_INET6, 1);
1031 }
1032
1033 extern int __xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1034                                  unsigned int family, int reverse);
1035
1036 static inline int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl,
1037                                       unsigned int family)
1038 {
1039         return __xfrm_decode_session(skb, fl, family, 0);
1040 }
1041
1042 static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1043                                               struct flowi *fl,
1044                                               unsigned int family)
1045 {
1046         return __xfrm_decode_session(skb, fl, family, 1);
1047 }
1048
1049 extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
1050
1051 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
1052 {
1053         struct net *net = dev_net(skb->dev);
1054
1055         return  !net->xfrm.policy_count[XFRM_POLICY_OUT] ||
1056                 (skb_dst(skb)->flags & DST_NOXFRM) ||
1057                 __xfrm_route_forward(skb, family);
1058 }
1059
1060 static inline int xfrm4_route_forward(struct sk_buff *skb)
1061 {
1062         return xfrm_route_forward(skb, AF_INET);
1063 }
1064
1065 static inline int xfrm6_route_forward(struct sk_buff *skb)
1066 {
1067         return xfrm_route_forward(skb, AF_INET6);
1068 }
1069
1070 extern int __xfrm_sk_clone_policy(struct sock *sk);
1071
1072 static inline int xfrm_sk_clone_policy(struct sock *sk)
1073 {
1074         if (unlikely(sk->sk_policy[0] || sk->sk_policy[1]))
1075                 return __xfrm_sk_clone_policy(sk);
1076         return 0;
1077 }
1078
1079 extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
1080
1081 static inline void xfrm_sk_free_policy(struct sock *sk)
1082 {
1083         if (unlikely(sk->sk_policy[0] != NULL)) {
1084                 xfrm_policy_delete(sk->sk_policy[0], XFRM_POLICY_MAX);
1085                 sk->sk_policy[0] = NULL;
1086         }
1087         if (unlikely(sk->sk_policy[1] != NULL)) {
1088                 xfrm_policy_delete(sk->sk_policy[1], XFRM_POLICY_MAX+1);
1089                 sk->sk_policy[1] = NULL;
1090         }
1091 }
1092
1093 #else
1094
1095 static inline void xfrm_sk_free_policy(struct sock *sk) {}
1096 static inline int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
1097 static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
1098 static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
1099 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1100 {
1101         return 1;
1102 }
1103 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
1104 {
1105         return 1;
1106 }
1107 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
1108 {
1109         return 1;
1110 }
1111 static inline int xfrm_decode_session_reverse(struct sk_buff *skb,
1112                                               struct flowi *fl,
1113                                               unsigned int family)
1114 {
1115         return -ENOSYS;
1116 }
1117 static inline int xfrm4_policy_check_reverse(struct sock *sk, int dir,
1118                                              struct sk_buff *skb)
1119 {
1120         return 1;
1121 }
1122 static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
1123                                              struct sk_buff *skb)
1124 {
1125         return 1;
1126 }
1127 #endif
1128
1129 static __inline__
1130 xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
1131 {
1132         switch (family){
1133         case AF_INET:
1134                 return (xfrm_address_t *)&fl->fl4_dst;
1135         case AF_INET6:
1136                 return (xfrm_address_t *)&fl->fl6_dst;
1137         }
1138         return NULL;
1139 }
1140
1141 static __inline__
1142 xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
1143 {
1144         switch (family){
1145         case AF_INET:
1146                 return (xfrm_address_t *)&fl->fl4_src;
1147         case AF_INET6:
1148                 return (xfrm_address_t *)&fl->fl6_src;
1149         }
1150         return NULL;
1151 }
1152
1153 static __inline__
1154 void xfrm_flowi_addr_get(struct flowi *fl,
1155                          xfrm_address_t *saddr, xfrm_address_t *daddr,
1156                          unsigned short family)
1157 {
1158         switch(family) {
1159         case AF_INET:
1160                 memcpy(&saddr->a4, &fl->fl4_src, sizeof(saddr->a4));
1161                 memcpy(&daddr->a4, &fl->fl4_dst, sizeof(daddr->a4));
1162                 break;
1163         case AF_INET6:
1164                 ipv6_addr_copy((struct in6_addr *)&saddr->a6, &fl->fl6_src);
1165                 ipv6_addr_copy((struct in6_addr *)&daddr->a6, &fl->fl6_dst);
1166                 break;
1167         }
1168 }
1169
1170 static __inline__ int
1171 __xfrm4_state_addr_check(struct xfrm_state *x,
1172                          xfrm_address_t *daddr, xfrm_address_t *saddr)
1173 {
1174         if (daddr->a4 == x->id.daddr.a4 &&
1175             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
1176                 return 1;
1177         return 0;
1178 }
1179
1180 static __inline__ int
1181 __xfrm6_state_addr_check(struct xfrm_state *x,
1182                          xfrm_address_t *daddr, xfrm_address_t *saddr)
1183 {
1184         if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
1185             (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)||
1186              ipv6_addr_any((struct in6_addr *)saddr) ||
1187              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
1188                 return 1;
1189         return 0;
1190 }
1191
1192 static __inline__ int
1193 xfrm_state_addr_check(struct xfrm_state *x,
1194                       xfrm_address_t *daddr, xfrm_address_t *saddr,
1195                       unsigned short family)
1196 {
1197         switch (family) {
1198         case AF_INET:
1199                 return __xfrm4_state_addr_check(x, daddr, saddr);
1200         case AF_INET6:
1201                 return __xfrm6_state_addr_check(x, daddr, saddr);
1202         }
1203         return 0;
1204 }
1205
1206 static __inline__ int
1207 xfrm_state_addr_flow_check(struct xfrm_state *x, struct flowi *fl,
1208                            unsigned short family)
1209 {
1210         switch (family) {
1211         case AF_INET:
1212                 return __xfrm4_state_addr_check(x,
1213                                                 (xfrm_address_t *)&fl->fl4_dst,
1214                                                 (xfrm_address_t *)&fl->fl4_src);
1215         case AF_INET6:
1216                 return __xfrm6_state_addr_check(x,
1217                                                 (xfrm_address_t *)&fl->fl6_dst,
1218                                                 (xfrm_address_t *)&fl->fl6_src);
1219         }
1220         return 0;
1221 }
1222
1223 static inline int xfrm_state_kern(struct xfrm_state *x)
1224 {
1225         return atomic_read(&x->tunnel_users);
1226 }
1227
1228 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
1229 {
1230         return (!userproto || proto == userproto ||
1231                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
1232                                                   proto == IPPROTO_ESP ||
1233                                                   proto == IPPROTO_COMP)));
1234 }
1235
1236 /*
1237  * xfrm algorithm information
1238  */
1239 struct xfrm_algo_aead_info {
1240         u16 icv_truncbits;
1241 };
1242
1243 struct xfrm_algo_auth_info {
1244         u16 icv_truncbits;
1245         u16 icv_fullbits;
1246 };
1247
1248 struct xfrm_algo_encr_info {
1249         u16 blockbits;
1250         u16 defkeybits;
1251 };
1252
1253 struct xfrm_algo_comp_info {
1254         u16 threshold;
1255 };
1256
1257 struct xfrm_algo_desc {
1258         char *name;
1259         char *compat;
1260         u8 available:1;
1261         union {
1262                 struct xfrm_algo_aead_info aead;
1263                 struct xfrm_algo_auth_info auth;
1264                 struct xfrm_algo_encr_info encr;
1265                 struct xfrm_algo_comp_info comp;
1266         } uinfo;
1267         struct sadb_alg desc;
1268 };
1269
1270 /* XFRM tunnel handlers.  */
1271 struct xfrm_tunnel {
1272         int (*handler)(struct sk_buff *skb);
1273         int (*err_handler)(struct sk_buff *skb, u32 info);
1274
1275         struct xfrm_tunnel __rcu *next;
1276         int priority;
1277 };
1278
1279 struct xfrm6_tunnel {
1280         int (*handler)(struct sk_buff *skb);
1281         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
1282                            u8 type, u8 code, int offset, __be32 info);
1283         struct xfrm6_tunnel __rcu *next;
1284         int priority;
1285 };
1286
1287 extern void xfrm_init(void);
1288 extern void xfrm4_init(int rt_hash_size);
1289 extern int xfrm_state_init(struct net *net);
1290 extern void xfrm_state_fini(struct net *net);
1291 extern void xfrm4_state_init(void);
1292 #ifdef CONFIG_XFRM
1293 extern int xfrm6_init(void);
1294 extern void xfrm6_fini(void);
1295 extern int xfrm6_state_init(void);
1296 extern void xfrm6_state_fini(void);
1297 #else
1298 static inline int xfrm6_init(void)
1299 {
1300         return 0;
1301 }
1302 static inline void xfrm6_fini(void)
1303 {
1304         ;
1305 }
1306 #endif
1307
1308 #ifdef CONFIG_XFRM_STATISTICS
1309 extern int xfrm_proc_init(struct net *net);
1310 extern void xfrm_proc_fini(struct net *net);
1311 #endif
1312
1313 extern int xfrm_sysctl_init(struct net *net);
1314 #ifdef CONFIG_SYSCTL
1315 extern void xfrm_sysctl_fini(struct net *net);
1316 #else
1317 static inline void xfrm_sysctl_fini(struct net *net)
1318 {
1319 }
1320 #endif
1321
1322 extern void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto);
1323 extern int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
1324                            int (*func)(struct xfrm_state *, int, void*), void *);
1325 extern void xfrm_state_walk_done(struct xfrm_state_walk *walk);
1326 extern struct xfrm_state *xfrm_state_alloc(struct net *net);
1327 extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
1328                                           struct flowi *fl, struct xfrm_tmpl *tmpl,
1329                                           struct xfrm_policy *pol, int *err,
1330                                           unsigned short family);
1331 extern struct xfrm_state *xfrm_stateonly_find(struct net *net, u32 mark,
1332                                                xfrm_address_t *daddr,
1333                                                xfrm_address_t *saddr,
1334                                                unsigned short family,
1335                                                u8 mode, u8 proto, u32 reqid);
1336 extern int xfrm_state_check_expire(struct xfrm_state *x);
1337 extern void xfrm_state_insert(struct xfrm_state *x);
1338 extern int xfrm_state_add(struct xfrm_state *x);
1339 extern int xfrm_state_update(struct xfrm_state *x);
1340 extern struct xfrm_state *xfrm_state_lookup(struct net *net, u32 mark,
1341                                             xfrm_address_t *daddr, __be32 spi,
1342                                             u8 proto, unsigned short family);
1343 extern struct xfrm_state *xfrm_state_lookup_byaddr(struct net *net, u32 mark,
1344                                                    xfrm_address_t *daddr,
1345                                                    xfrm_address_t *saddr,
1346                                                    u8 proto,
1347                                                    unsigned short family);
1348 #ifdef CONFIG_XFRM_SUB_POLICY
1349 extern int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
1350                           int n, unsigned short family);
1351 extern int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
1352                            int n, unsigned short family);
1353 #else
1354 static inline int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
1355                                  int n, unsigned short family)
1356 {
1357         return -ENOSYS;
1358 }
1359
1360 static inline int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
1361                                   int n, unsigned short family)
1362 {
1363         return -ENOSYS;
1364 }
1365 #endif
1366
1367 struct xfrmk_sadinfo {
1368         u32 sadhcnt; /* current hash bkts */
1369         u32 sadhmcnt; /* max allowed hash bkts */
1370         u32 sadcnt; /* current running count */
1371 };
1372
1373 struct xfrmk_spdinfo {
1374         u32 incnt;
1375         u32 outcnt;
1376         u32 fwdcnt;
1377         u32 inscnt;
1378         u32 outscnt;
1379         u32 fwdscnt;
1380         u32 spdhcnt;
1381         u32 spdhmcnt;
1382 };
1383
1384 extern struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark,
1385                                               u32 seq);
1386 extern int xfrm_state_delete(struct xfrm_state *x);
1387 extern int xfrm_state_flush(struct net *net, u8 proto, struct xfrm_audit *audit_info);
1388 extern void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
1389 extern void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
1390 extern int xfrm_replay_check(struct xfrm_state *x,
1391                              struct sk_buff *skb, __be32 seq);
1392 extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
1393 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
1394 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
1395 extern int xfrm_init_state(struct xfrm_state *x);
1396 extern int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb);
1397 extern int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi,
1398                       int encap_type);
1399 extern int xfrm_input_resume(struct sk_buff *skb, int nexthdr);
1400 extern int xfrm_output_resume(struct sk_buff *skb, int err);
1401 extern int xfrm_output(struct sk_buff *skb);
1402 extern int xfrm_inner_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1403 extern int xfrm4_extract_header(struct sk_buff *skb);
1404 extern int xfrm4_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1405 extern int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi,
1406                            int encap_type);
1407 extern int xfrm4_transport_finish(struct sk_buff *skb, int async);
1408 extern int xfrm4_rcv(struct sk_buff *skb);
1409
1410 static inline int xfrm4_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi)
1411 {
1412         return xfrm4_rcv_encap(skb, nexthdr, spi, 0);
1413 }
1414
1415 extern int xfrm4_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1416 extern int xfrm4_prepare_output(struct xfrm_state *x, struct sk_buff *skb);
1417 extern int xfrm4_output(struct sk_buff *skb);
1418 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1419 extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1420 extern int xfrm6_extract_header(struct sk_buff *skb);
1421 extern int xfrm6_extract_input(struct xfrm_state *x, struct sk_buff *skb);
1422 extern int xfrm6_rcv_spi(struct sk_buff *skb, int nexthdr, __be32 spi);
1423 extern int xfrm6_transport_finish(struct sk_buff *skb, int async);
1424 extern int xfrm6_rcv(struct sk_buff *skb);
1425 extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1426                             xfrm_address_t *saddr, u8 proto);
1427 extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1428 extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1429 extern __be32 xfrm6_tunnel_alloc_spi(struct net *net, xfrm_address_t *saddr);
1430 extern __be32 xfrm6_tunnel_spi_lookup(struct net *net, xfrm_address_t *saddr);
1431 extern int xfrm6_extract_output(struct xfrm_state *x, struct sk_buff *skb);
1432 extern int xfrm6_prepare_output(struct xfrm_state *x, struct sk_buff *skb);
1433 extern int xfrm6_output(struct sk_buff *skb);
1434 extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
1435                                  u8 **prevhdr);
1436
1437 #ifdef CONFIG_XFRM
1438 extern int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1439 extern int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen);
1440 #else
1441 static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1442 {
1443         return -ENOPROTOOPT;
1444 }
1445
1446 static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
1447 {
1448         /* should not happen */
1449         kfree_skb(skb);
1450         return 0;
1451 }
1452 #endif
1453
1454 struct xfrm_policy *xfrm_policy_alloc(struct net *net, gfp_t gfp);
1455
1456 extern void xfrm_policy_walk_init(struct xfrm_policy_walk *walk, u8 type);
1457 extern int xfrm_policy_walk(struct net *net, struct xfrm_policy_walk *walk,
1458         int (*func)(struct xfrm_policy *, int, int, void*), void *);
1459 extern void xfrm_policy_walk_done(struct xfrm_policy_walk *walk);
1460 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1461 struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u32 mark,
1462                                           u8 type, int dir,
1463                                           struct xfrm_selector *sel,
1464                                           struct xfrm_sec_ctx *ctx, int delete,
1465                                           int *err);
1466 struct xfrm_policy *xfrm_policy_byid(struct net *net, u32 mark, u8, int dir, u32 id, int delete, int *err);
1467 int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info);
1468 u32 xfrm_get_acqseq(void);
1469 extern int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1470 struct xfrm_state *xfrm_find_acq(struct net *net, struct xfrm_mark *mark,
1471                                  u8 mode, u32 reqid, u8 proto,
1472                                  xfrm_address_t *daddr,
1473                                  xfrm_address_t *saddr, int create,
1474                                  unsigned short family);
1475 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1476
1477 #ifdef CONFIG_XFRM_MIGRATE
1478 extern int km_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
1479                       struct xfrm_migrate *m, int num_bundles,
1480                       struct xfrm_kmaddress *k);
1481 extern struct xfrm_state * xfrm_migrate_state_find(struct xfrm_migrate *m);
1482 extern struct xfrm_state * xfrm_state_migrate(struct xfrm_state *x,
1483                                               struct xfrm_migrate *m);
1484 extern int xfrm_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
1485                         struct xfrm_migrate *m, int num_bundles,
1486                         struct xfrm_kmaddress *k);
1487 #endif
1488
1489 extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1490 extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
1491 extern int km_report(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
1492
1493 extern void xfrm_input_init(void);
1494 extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1495
1496 extern void xfrm_probe_algs(void);
1497 extern int xfrm_count_auth_supported(void);
1498 extern int xfrm_count_enc_supported(void);
1499 extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1500 extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1501 extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1502 extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1503 extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1504 extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
1505 extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
1506 extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);
1507 extern struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len,
1508                                                    int probe);
1509
1510 struct hash_desc;
1511 struct scatterlist;
1512 typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
1513                               unsigned int);
1514
1515 static inline int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
1516                                 int family)
1517 {
1518         switch (family) {
1519         default:
1520         case AF_INET:
1521                 return (__force u32)a->a4 - (__force u32)b->a4;
1522         case AF_INET6:
1523                 return ipv6_addr_cmp((struct in6_addr *)a,
1524                                      (struct in6_addr *)b);
1525         }
1526 }
1527
1528 static inline int xfrm_policy_id2dir(u32 index)
1529 {
1530         return index & 7;
1531 }
1532
1533 #ifdef CONFIG_XFRM
1534 static inline int xfrm_aevent_is_on(struct net *net)
1535 {
1536         struct sock *nlsk;
1537         int ret = 0;
1538
1539         rcu_read_lock();
1540         nlsk = rcu_dereference(net->xfrm.nlsk);
1541         if (nlsk)
1542                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1543         rcu_read_unlock();
1544         return ret;
1545 }
1546 #endif
1547
1548 static inline int xfrm_alg_len(struct xfrm_algo *alg)
1549 {
1550         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1551 }
1552
1553 static inline int xfrm_alg_auth_len(struct xfrm_algo_auth *alg)
1554 {
1555         return sizeof(*alg) + ((alg->alg_key_len + 7) / 8);
1556 }
1557
1558 #ifdef CONFIG_XFRM_MIGRATE
1559 static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1560 {
1561         return kmemdup(orig, xfrm_alg_len(orig), GFP_KERNEL);
1562 }
1563
1564 static inline struct xfrm_algo_auth *xfrm_algo_auth_clone(struct xfrm_algo_auth *orig)
1565 {
1566         return kmemdup(orig, xfrm_alg_auth_len(orig), GFP_KERNEL);
1567 }
1568
1569 static inline void xfrm_states_put(struct xfrm_state **states, int n)
1570 {
1571         int i;
1572         for (i = 0; i < n; i++)
1573                 xfrm_state_put(*(states + i));
1574 }
1575
1576 static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1577 {
1578         int i;
1579         for (i = 0; i < n; i++)
1580                 xfrm_state_delete(*(states + i));
1581 }
1582 #endif
1583
1584 #ifdef CONFIG_XFRM
1585 static inline struct xfrm_state *xfrm_input_state(struct sk_buff *skb)
1586 {
1587         return skb->sp->xvec[skb->sp->len - 1];
1588 }
1589 #endif
1590
1591 static inline int xfrm_mark_get(struct nlattr **attrs, struct xfrm_mark *m)
1592 {
1593         if (attrs[XFRMA_MARK])
1594                 memcpy(m, nla_data(attrs[XFRMA_MARK]), sizeof(struct xfrm_mark));
1595         else
1596                 m->v = m->m = 0;
1597
1598         return m->v & m->m;
1599 }
1600
1601 static inline int xfrm_mark_put(struct sk_buff *skb, struct xfrm_mark *m)
1602 {
1603         if (m->m | m->v)
1604                 NLA_PUT(skb, XFRMA_MARK, sizeof(struct xfrm_mark), m);
1605         return 0;
1606
1607 nla_put_failure:
1608         return -1;
1609 }
1610
1611 #endif  /* _NET_XFRM_H */