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