SAFE public projects git trees. - safe/jmp/linux-2.6/blob - include/net/xfrm.h

   1 #ifndef _NET_XFRM_H
   2 #define _NET_XFRM_H
   3
   4 #include <linux/compiler.h>
   5 #include <linux/in.h>
   6 #include <linux/xfrm.h>
   7 #include <linux/spinlock.h>
   8 #include <linux/list.h>
   9 #include <linux/skbuff.h>
  10 #include <linux/socket.h>
  11 #include <linux/pfkeyv2.h>
  12 #include <linux/ipsec.h>
  13 #include <linux/in6.h>
  14 #include <linux/mutex.h>
  15
  16 #include <net/sock.h>
  17 #include <net/dst.h>
  18 #include <net/route.h>
  19 #include <net/ipv6.h>
  20 #include <net/ip6_fib.h>
  21
  22 #define XFRM_ALIGN8(len)        (((len) + 7) & ~7)
  23 #define MODULE_ALIAS_XFRM_MODE(family, encap) \
  24         MODULE_ALIAS("xfrm-mode-" __stringify(family) "-" __stringify(encap))
  25
  26 extern struct sock *xfrm_nl;
  27 extern u32 sysctl_xfrm_aevent_etime;
  28 extern u32 sysctl_xfrm_aevent_rseqth;
  29
  30 extern struct mutex xfrm_cfg_mutex;
  31
  32 /* Organization of SPD aka "XFRM rules"
  33    ------------------------------------
  34
  35    Basic objects:
  36    - policy rule, struct xfrm_policy (=SPD entry)
  37    - bundle of transformations, struct dst_entry == struct xfrm_dst (=SA bundle)
  38    - instance of a transformer, struct xfrm_state (=SA)
  39    - template to clone xfrm_state, struct xfrm_tmpl
  40
  41    SPD is plain linear list of xfrm_policy rules, ordered by priority.
  42    (To be compatible with existing pfkeyv2 implementations,
  43    many rules with priority of 0x7fffffff are allowed to exist and
  44    such rules are ordered in an unpredictable way, thanks to bsd folks.)
  45
  46    Lookup is plain linear search until the first match with selector.
  47
  48    If "action" is "block", then we prohibit the flow, otherwise:
  49    if "xfrms_nr" is zero, the flow passes untransformed. Otherwise,
  50    policy entry has list of up to XFRM_MAX_DEPTH transformations,
  51    described by templates xfrm_tmpl. Each template is resolved
  52    to a complete xfrm_state (see below) and we pack bundle of transformations
  53    to a dst_entry returned to requestor.
  54
  55    dst -. xfrm  .-> xfrm_state #1
  56     |---. child .-> dst -. xfrm .-> xfrm_state #2
  57                      |---. child .-> dst -. xfrm .-> xfrm_state #3
  58                                       |---. child .-> NULL
  59
  60    Bundles are cached at xrfm_policy struct (field ->bundles).
  61
  62
  63    Resolution of xrfm_tmpl
  64    -----------------------
  65    Template contains:
  66    1. ->mode            Mode: transport or tunnel
  67    2. ->id.proto        Protocol: AH/ESP/IPCOMP
  68    3. ->id.daddr        Remote tunnel endpoint, ignored for transport mode.
  69       Q: allow to resolve security gateway?
  70    4. ->id.spi          If not zero, static SPI.
  71    5. ->saddr           Local tunnel endpoint, ignored for transport mode.
  72    6. ->algos           List of allowed algos. Plain bitmask now.
  73       Q: ealgos, aalgos, calgos. What a mess...
  74    7. ->share           Sharing mode.
  75       Q: how to implement private sharing mode? To add struct sock* to
  76       flow id?
  77
  78    Having this template we search through SAD searching for entries
  79    with appropriate mode/proto/algo, permitted by selector.
  80    If no appropriate entry found, it is requested from key manager.
  81
  82    PROBLEMS:
  83    Q: How to find all the bundles referring to a physical path for
  84       PMTU discovery? Seems, dst should contain list of all parents...
  85       and enter to infinite locking hierarchy disaster.
  86       No! It is easier, we will not search for them, let them find us.
  87       We add genid to each dst plus pointer to genid of raw IP route,
  88       pmtu disc will update pmtu on raw IP route and increase its genid.
  89       dst_check() will see this for top level and trigger resyncing
  90       metrics. Plus, it will be made via sk->sk_dst_cache. Solved.
  91  */
  92
  93 /* Full description of state of transformer. */
  94 struct xfrm_state
  95 {
  96         /* Note: bydst is re-used during gc */
  97         struct list_head        bydst;
  98         struct list_head        bysrc;
  99         struct list_head        byspi;
 100
 101         atomic_t                refcnt;
 102         spinlock_t              lock;
 103
 104         struct xfrm_id          id;
 105         struct xfrm_selector    sel;
 106
 107         /* Key manger bits */
 108         struct {
 109                 u8              state;
 110                 u8              dying;
 111                 u32             seq;
 112         } km;
 113
 114         /* Parameters of this state. */
 115         struct {
 116                 u32             reqid;
 117                 u8              mode;
 118                 u8              replay_window;
 119                 u8              aalgo, ealgo, calgo;
 120                 u8              flags;
 121                 u16             family;
 122                 xfrm_address_t  saddr;
 123                 int             header_len;
 124                 int             trailer_len;
 125         } props;
 126
 127         struct xfrm_lifetime_cfg lft;
 128
 129         /* Data for transformer */
 130         struct xfrm_algo        *aalg;
 131         struct xfrm_algo        *ealg;
 132         struct xfrm_algo        *calg;
 133
 134         /* Data for encapsulator */
 135         struct xfrm_encap_tmpl  *encap;
 136
 137         /* IPComp needs an IPIP tunnel for handling uncompressed packets */
 138         struct xfrm_state       *tunnel;
 139
 140         /* If a tunnel, number of users + 1 */
 141         atomic_t                tunnel_users;
 142
 143         /* State for replay detection */
 144         struct xfrm_replay_state replay;
 145
 146         /* Replay detection state at the time we sent the last notification */
 147         struct xfrm_replay_state preplay;
 148
 149         /* internal flag that only holds state for delayed aevent at the
 150          * moment
 151         */
 152         u32                     xflags;
 153
 154         /* Replay detection notification settings */
 155         u32                     replay_maxage;
 156         u32                     replay_maxdiff;
 157
 158         /* Replay detection notification timer */
 159         struct timer_list       rtimer;
 160
 161         /* Statistics */
 162         struct xfrm_stats       stats;
 163
 164         struct xfrm_lifetime_cur curlft;
 165         struct timer_list       timer;
 166
 167         /* Reference to data common to all the instances of this
 168          * transformer. */
 169         struct xfrm_type        *type;
 170         struct xfrm_mode        *mode;
 171
 172         /* Security context */
 173         struct xfrm_sec_ctx     *security;
 174
 175         /* Private data of this transformer, format is opaque,
 176          * interpreted by xfrm_type methods. */
 177         void                    *data;
 178 };
 179
 180 /* xflags - make enum if more show up */
 181 #define XFRM_TIME_DEFER 1
 182
 183 enum {
 184         XFRM_STATE_VOID,
 185         XFRM_STATE_ACQ,
 186         XFRM_STATE_VALID,
 187         XFRM_STATE_ERROR,
 188         XFRM_STATE_EXPIRED,
 189         XFRM_STATE_DEAD
 190 };
 191
 192 /* callback structure passed from either netlink or pfkey */
 193 struct km_event
 194 {
 195         union {
 196                 u32 hard;
 197                 u32 proto;
 198                 u32 byid;
 199                 u32 aevent;
 200         } data;
 201
 202         u32     seq;
 203         u32     pid;
 204         u32     event;
 205 };
 206
 207 struct xfrm_type;
 208 struct xfrm_dst;
 209 struct xfrm_policy_afinfo {
 210         unsigned short          family;
 211         struct xfrm_type        *type_map[IPPROTO_MAX];
 212         struct xfrm_mode        *mode_map[XFRM_MODE_MAX];
 213         struct dst_ops          *dst_ops;
 214         void                    (*garbage_collect)(void);
 215         int                     (*dst_lookup)(struct xfrm_dst **dst, struct flowi *fl);
 216         struct dst_entry        *(*find_bundle)(struct flowi *fl, struct xfrm_policy *policy);
 217         int                     (*bundle_create)(struct xfrm_policy *policy,
 218                                                  struct xfrm_state **xfrm,
 219                                                  int nx,
 220                                                  struct flowi *fl,
 221                                                  struct dst_entry **dst_p);
 222         void                    (*decode_session)(struct sk_buff *skb,
 223                                                   struct flowi *fl);
 224 };
 225
 226 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 227 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
 228 extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
 229 extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
 230 #define XFRM_ACQ_EXPIRES        30
 231
 232 struct xfrm_tmpl;
 233 extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
 234 extern void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
 235 extern int __xfrm_state_delete(struct xfrm_state *x);
 236
 237 struct xfrm_state_afinfo {
 238         unsigned short          family;
 239         struct list_head        *state_bydst;
 240         struct list_head        *state_bysrc;
 241         struct list_head        *state_byspi;
 242         int                     (*init_flags)(struct xfrm_state *x);
 243         void                    (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,
 244                                                 struct xfrm_tmpl *tmpl,
 245                                                 xfrm_address_t *daddr, xfrm_address_t *saddr);
 246         struct xfrm_state       *(*state_lookup)(xfrm_address_t *daddr, u32 spi, u8 proto);
 247         struct xfrm_state       *(*state_lookup_byaddr)(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto);
 248         struct xfrm_state       *(*find_acq)(u8 mode, u32 reqid, u8 proto,
 249                                              xfrm_address_t *daddr, xfrm_address_t *saddr,
 250                                              int create);
 251 };
 252
 253 extern int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
 254 extern int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
 255
 256 extern void xfrm_state_delete_tunnel(struct xfrm_state *x);
 257
 258 struct xfrm_type
 259 {
 260         char                    *description;
 261         struct module           *owner;
 262         __u8                    proto;
 263
 264         int                     (*init_state)(struct xfrm_state *x);
 265         void                    (*destructor)(struct xfrm_state *);
 266         int                     (*input)(struct xfrm_state *, struct sk_buff *skb);
 267         int                     (*output)(struct xfrm_state *, struct sk_buff *pskb);
 268         int                     (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
 269         xfrm_address_t          *(*local_addr)(struct xfrm_state *, xfrm_address_t *);
 270         xfrm_address_t          *(*remote_addr)(struct xfrm_state *, xfrm_address_t *);
 271         /* Estimate maximal size of result of transformation of a dgram */
 272         u32                     (*get_max_size)(struct xfrm_state *, int size);
 273 };
 274
 275 extern int xfrm_register_type(struct xfrm_type *type, unsigned short family);
 276 extern int xfrm_unregister_type(struct xfrm_type *type, unsigned short family);
 277 extern struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family);
 278 extern void xfrm_put_type(struct xfrm_type *type);
 279
 280 struct xfrm_mode {
 281         int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 282         int (*output)(struct sk_buff *skb);
 283
 284         struct module *owner;
 285         unsigned int encap;
 286 };
 287
 288 extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
 289 extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
 290 extern struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family);
 291 extern void xfrm_put_mode(struct xfrm_mode *mode);
 292
 293 struct xfrm_tmpl
 294 {
 295 /* id in template is interpreted as:
 296  * daddr - destination of tunnel, may be zero for transport mode.
 297  * spi   - zero to acquire spi. Not zero if spi is static, then
 298  *         daddr must be fixed too.
 299  * proto - AH/ESP/IPCOMP
 300  */
 301         struct xfrm_id          id;
 302
 303 /* Source address of tunnel. Ignored, if it is not a tunnel. */
 304         xfrm_address_t          saddr;
 305
 306         __u32                   reqid;
 307
 308 /* Mode: transport, tunnel etc. */
 309         __u8                    mode;
 310
 311 /* Sharing mode: unique, this session only, this user only etc. */
 312         __u8                    share;
 313
 314 /* May skip this transfomration if no SA is found */
 315         __u8                    optional;
 316
 317 /* Bit mask of algos allowed for acquisition */
 318         __u32                   aalgos;
 319         __u32                   ealgos;
 320         __u32                   calgos;
 321 };
 322
 323 #define XFRM_MAX_DEPTH          6
 324
 325 struct xfrm_policy
 326 {
 327         struct xfrm_policy      *next;
 328         struct list_head        list;
 329
 330         /* This lock only affects elements except for entry. */
 331         rwlock_t                lock;
 332         atomic_t                refcnt;
 333         struct timer_list       timer;
 334
 335         u32                     priority;
 336         u32                     index;
 337         struct xfrm_selector    selector;
 338         struct xfrm_lifetime_cfg lft;
 339         struct xfrm_lifetime_cur curlft;
 340         struct dst_entry       *bundles;
 341         __u16                   family;
 342         __u8                    action;
 343         __u8                    flags;
 344         __u8                    dead;
 345         __u8                    xfrm_nr;
 346         struct xfrm_sec_ctx     *security;
 347         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 348 };
 349
 350 #define XFRM_KM_TIMEOUT                30
 351 /* which seqno */
 352 #define XFRM_REPLAY_SEQ         1
 353 #define XFRM_REPLAY_OSEQ        2
 354 #define XFRM_REPLAY_SEQ_MASK    3
 355 /* what happened */
 356 #define XFRM_REPLAY_UPDATE      XFRM_AE_CR
 357 #define XFRM_REPLAY_TIMEOUT     XFRM_AE_CE
 358
 359 /* default aevent timeout in units of 100ms */
 360 #define XFRM_AE_ETIME                   10
 361 /* Async Event timer multiplier */
 362 #define XFRM_AE_ETH_M                   10
 363 /* default seq threshold size */
 364 #define XFRM_AE_SEQT_SIZE               2
 365
 366 struct xfrm_mgr
 367 {
 368         struct list_head        list;
 369         char                    *id;
 370         int                     (*notify)(struct xfrm_state *x, struct km_event *c);
 371         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 372         struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 373         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
 374         int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 375 };
 376
 377 extern int xfrm_register_km(struct xfrm_mgr *km);
 378 extern int xfrm_unregister_km(struct xfrm_mgr *km);
 379
 380
 381 extern struct xfrm_policy *xfrm_policy_list[XFRM_POLICY_MAX*2];
 382
 383 static inline void xfrm_pol_hold(struct xfrm_policy *policy)
 384 {
 385         if (likely(policy != NULL))
 386                 atomic_inc(&policy->refcnt);
 387 }
 388
 389 extern void __xfrm_policy_destroy(struct xfrm_policy *policy);
 390
 391 static inline void xfrm_pol_put(struct xfrm_policy *policy)
 392 {
 393         if (atomic_dec_and_test(&policy->refcnt))
 394                 __xfrm_policy_destroy(policy);
 395 }
 396
 397 #define XFRM_DST_HSIZE          1024
 398
 399 static __inline__
 400 unsigned __xfrm4_dst_hash(xfrm_address_t *addr)
 401 {
 402         unsigned h;
 403         h = ntohl(addr->a4);
 404         h = (h ^ (h>>16)) % XFRM_DST_HSIZE;
 405         return h;
 406 }
 407
 408 static __inline__
 409 unsigned __xfrm6_dst_hash(xfrm_address_t *addr)
 410 {
 411         unsigned h;
 412         h = ntohl(addr->a6[2]^addr->a6[3]);
 413         h = (h ^ (h>>16)) % XFRM_DST_HSIZE;
 414         return h;
 415 }
 416
 417 static __inline__
 418 unsigned xfrm_dst_hash(xfrm_address_t *addr, unsigned short family)
 419 {
 420         switch (family) {
 421         case AF_INET:
 422                 return __xfrm4_dst_hash(addr);
 423         case AF_INET6:
 424                 return __xfrm6_dst_hash(addr);
 425         }
 426         return 0;
 427 }
 428
 429 static __inline__
 430 unsigned __xfrm4_src_hash(xfrm_address_t *addr)
 431 {
 432         return __xfrm4_dst_hash(addr);
 433 }
 434
 435 static __inline__
 436 unsigned __xfrm6_src_hash(xfrm_address_t *addr)
 437 {
 438         return __xfrm6_dst_hash(addr);
 439 }
 440
 441 static __inline__
 442 unsigned xfrm_src_hash(xfrm_address_t *addr, unsigned short family)
 443 {
 444         switch (family) {
 445         case AF_INET:
 446                 return __xfrm4_src_hash(addr);
 447         case AF_INET6:
 448                 return __xfrm6_src_hash(addr);
 449         }
 450         return 0;
 451 }
 452
 453 static __inline__
 454 unsigned __xfrm4_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto)
 455 {
 456         unsigned h;
 457         h = ntohl(addr->a4^spi^proto);
 458         h = (h ^ (h>>10) ^ (h>>20)) % XFRM_DST_HSIZE;
 459         return h;
 460 }
 461
 462 static __inline__
 463 unsigned __xfrm6_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto)
 464 {
 465         unsigned h;
 466         h = ntohl(addr->a6[2]^addr->a6[3]^spi^proto);
 467         h = (h ^ (h>>10) ^ (h>>20)) % XFRM_DST_HSIZE;
 468         return h;
 469 }
 470
 471 static __inline__
 472 unsigned xfrm_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto, unsigned short family)
 473 {
 474         switch (family) {
 475         case AF_INET:
 476                 return __xfrm4_spi_hash(addr, spi, proto);
 477         case AF_INET6:
 478                 return __xfrm6_spi_hash(addr, spi, proto);
 479         }
 480         return 0;       /*XXX*/
 481 }
 482
 483 extern void __xfrm_state_destroy(struct xfrm_state *);
 484
 485 static inline void __xfrm_state_put(struct xfrm_state *x)
 486 {
 487         atomic_dec(&x->refcnt);
 488 }
 489
 490 static inline void xfrm_state_put(struct xfrm_state *x)
 491 {
 492         if (atomic_dec_and_test(&x->refcnt))
 493                 __xfrm_state_destroy(x);
 494 }
 495
 496 static inline void xfrm_state_hold(struct xfrm_state *x)
 497 {
 498         atomic_inc(&x->refcnt);
 499 }
 500
 501 static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 502 {
 503         __u32 *a1 = token1;
 504         __u32 *a2 = token2;
 505         int pdw;
 506         int pbi;
 507
 508         pdw = prefixlen >> 5;     /* num of whole __u32 in prefix */
 509         pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
 510
 511         if (pdw)
 512                 if (memcmp(a1, a2, pdw << 2))
 513                         return 0;
 514
 515         if (pbi) {
 516                 __u32 mask;
 517
 518                 mask = htonl((0xffffffff) << (32 - pbi));
 519
 520                 if ((a1[pdw] ^ a2[pdw]) & mask)
 521                         return 0;
 522         }
 523
 524         return 1;
 525 }
 526
 527 static __inline__
 528 u16 xfrm_flowi_sport(struct flowi *fl)
 529 {
 530         u16 port;
 531         switch(fl->proto) {
 532         case IPPROTO_TCP:
 533         case IPPROTO_UDP:
 534         case IPPROTO_SCTP:
 535                 port = fl->fl_ip_sport;
 536                 break;
 537         case IPPROTO_ICMP:
 538         case IPPROTO_ICMPV6:
 539                 port = htons(fl->fl_icmp_type);
 540                 break;
 541         default:
 542                 port = 0;       /*XXX*/
 543         }
 544         return port;
 545 }
 546
 547 static __inline__
 548 u16 xfrm_flowi_dport(struct flowi *fl)
 549 {
 550         u16 port;
 551         switch(fl->proto) {
 552         case IPPROTO_TCP:
 553         case IPPROTO_UDP:
 554         case IPPROTO_SCTP:
 555                 port = fl->fl_ip_dport;
 556                 break;
 557         case IPPROTO_ICMP:
 558         case IPPROTO_ICMPV6:
 559                 port = htons(fl->fl_icmp_code);
 560                 break;
 561         default:
 562                 port = 0;       /*XXX*/
 563         }
 564         return port;
 565 }
 566
 567 static inline int
 568 __xfrm4_selector_match(struct xfrm_selector *sel, struct flowi *fl)
 569 {
 570         return  addr_match(&fl->fl4_dst, &sel->daddr, sel->prefixlen_d) &&
 571                 addr_match(&fl->fl4_src, &sel->saddr, sel->prefixlen_s) &&
 572                 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
 573                 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
 574                 (fl->proto == sel->proto || !sel->proto) &&
 575                 (fl->oif == sel->ifindex || !sel->ifindex);
 576 }
 577
 578 static inline int
 579 __xfrm6_selector_match(struct xfrm_selector *sel, struct flowi *fl)
 580 {
 581         return  addr_match(&fl->fl6_dst, &sel->daddr, sel->prefixlen_d) &&
 582                 addr_match(&fl->fl6_src, &sel->saddr, sel->prefixlen_s) &&
 583                 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
 584                 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
 585                 (fl->proto == sel->proto || !sel->proto) &&
 586                 (fl->oif == sel->ifindex || !sel->ifindex);
 587 }
 588
 589 static inline int
 590 xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
 591                     unsigned short family)
 592 {
 593         switch (family) {
 594         case AF_INET:
 595                 return __xfrm4_selector_match(sel, fl);
 596         case AF_INET6:
 597                 return __xfrm6_selector_match(sel, fl);
 598         }
 599         return 0;
 600 }
 601
 602 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 603 /*      If neither has a context --> match
 604  *      Otherwise, both must have a context and the sids, doi, alg must match
 605  */
 606 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 607 {
 608         return ((!s1 && !s2) ||
 609                 (s1 && s2 &&
 610                  (s1->ctx_sid == s2->ctx_sid) &&
 611                  (s1->ctx_doi == s2->ctx_doi) &&
 612                  (s1->ctx_alg == s2->ctx_alg)));
 613 }
 614 #else
 615 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 616 {
 617         return 1;
 618 }
 619 #endif
 620
 621 /* A struct encoding bundle of transformations to apply to some set of flow.
 622  *
 623  * dst->child points to the next element of bundle.
 624  * dst->xfrm  points to an instanse of transformer.
 625  *
 626  * Due to unfortunate limitations of current routing cache, which we
 627  * have no time to fix, it mirrors struct rtable and bound to the same
 628  * routing key, including saddr,daddr. However, we can have many of
 629  * bundles differing by session id. All the bundles grow from a parent
 630  * policy rule.
 631  */
 632 struct xfrm_dst
 633 {
 634         union {
 635                 struct xfrm_dst         *next;
 636                 struct dst_entry        dst;
 637                 struct rtable           rt;
 638                 struct rt6_info         rt6;
 639         } u;
 640         struct dst_entry *route;
 641         u32 route_mtu_cached;
 642         u32 child_mtu_cached;
 643         u32 route_cookie;
 644         u32 path_cookie;
 645 };
 646
 647 static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 648 {
 649         dst_release(xdst->route);
 650         if (likely(xdst->u.dst.xfrm))
 651                 xfrm_state_put(xdst->u.dst.xfrm);
 652 }
 653
 654 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 655
 656 struct sec_path
 657 {
 658         atomic_t                refcnt;
 659         int                     len;
 660         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
 661 };
 662
 663 static inline struct sec_path *
 664 secpath_get(struct sec_path *sp)
 665 {
 666         if (sp)
 667                 atomic_inc(&sp->refcnt);
 668         return sp;
 669 }
 670
 671 extern void __secpath_destroy(struct sec_path *sp);
 672
 673 static inline void
 674 secpath_put(struct sec_path *sp)
 675 {
 676         if (sp && atomic_dec_and_test(&sp->refcnt))
 677                 __secpath_destroy(sp);
 678 }
 679
 680 extern struct sec_path *secpath_dup(struct sec_path *src);
 681
 682 static inline void
 683 secpath_reset(struct sk_buff *skb)
 684 {
 685 #ifdef CONFIG_XFRM
 686         secpath_put(skb->sp);
 687         skb->sp = NULL;
 688 #endif
 689 }
 690
 691 static inline int
 692 __xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 693 {
 694         return  (tmpl->saddr.a4 &&
 695                  tmpl->saddr.a4 != x->props.saddr.a4);
 696 }
 697
 698 static inline int
 699 __xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 700 {
 701         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
 702                  ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
 703 }
 704
 705 static inline int
 706 xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
 707 {
 708         switch (family) {
 709         case AF_INET:
 710                 return __xfrm4_state_addr_cmp(tmpl, x);
 711         case AF_INET6:
 712                 return __xfrm6_state_addr_cmp(tmpl, x);
 713         }
 714         return !0;
 715 }
 716
 717 #ifdef CONFIG_XFRM
 718
 719 extern int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb, unsigned short family);
 720
 721 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 722 {
 723         if (sk && sk->sk_policy[XFRM_POLICY_IN])
 724                 return __xfrm_policy_check(sk, dir, skb, family);
 725
 726         return  (!xfrm_policy_list[dir] && !skb->sp) ||
 727                 (skb->dst->flags & DST_NOPOLICY) ||
 728                 __xfrm_policy_check(sk, dir, skb, family);
 729 }
 730
 731 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 732 {
 733         return xfrm_policy_check(sk, dir, skb, AF_INET);
 734 }
 735
 736 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 737 {
 738         return xfrm_policy_check(sk, dir, skb, AF_INET6);
 739 }
 740
 741 extern int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl, unsigned short family);
 742 extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
 743
 744 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
 745 {
 746         return  !xfrm_policy_list[XFRM_POLICY_OUT] ||
 747                 (skb->dst->flags & DST_NOXFRM) ||
 748                 __xfrm_route_forward(skb, family);
 749 }
 750
 751 static inline int xfrm4_route_forward(struct sk_buff *skb)
 752 {
 753         return xfrm_route_forward(skb, AF_INET);
 754 }
 755
 756 static inline int xfrm6_route_forward(struct sk_buff *skb)
 757 {
 758         return xfrm_route_forward(skb, AF_INET6);
 759 }
 760
 761 extern int __xfrm_sk_clone_policy(struct sock *sk);
 762
 763 static inline int xfrm_sk_clone_policy(struct sock *sk)
 764 {
 765         if (unlikely(sk->sk_policy[0] || sk->sk_policy[1]))
 766                 return __xfrm_sk_clone_policy(sk);
 767         return 0;
 768 }
 769
 770 extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
 771
 772 static inline void xfrm_sk_free_policy(struct sock *sk)
 773 {
 774         if (unlikely(sk->sk_policy[0] != NULL)) {
 775                 xfrm_policy_delete(sk->sk_policy[0], XFRM_POLICY_MAX);
 776                 sk->sk_policy[0] = NULL;
 777         }
 778         if (unlikely(sk->sk_policy[1] != NULL)) {
 779                 xfrm_policy_delete(sk->sk_policy[1], XFRM_POLICY_MAX+1);
 780                 sk->sk_policy[1] = NULL;
 781         }
 782 }
 783
 784 #else
 785
 786 static inline void xfrm_sk_free_policy(struct sock *sk) {}
 787 static inline int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
 788 static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
 789 static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
 790 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 791 {
 792         return 1;
 793 }
 794 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 795 {
 796         return 1;
 797 }
 798 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 799 {
 800         return 1;
 801 }
 802 #endif
 803
 804 static __inline__
 805 xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
 806 {
 807         switch (family){
 808         case AF_INET:
 809                 return (xfrm_address_t *)&fl->fl4_dst;
 810         case AF_INET6:
 811                 return (xfrm_address_t *)&fl->fl6_dst;
 812         }
 813         return NULL;
 814 }
 815
 816 static __inline__
 817 xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
 818 {
 819         switch (family){
 820         case AF_INET:
 821                 return (xfrm_address_t *)&fl->fl4_src;
 822         case AF_INET6:
 823                 return (xfrm_address_t *)&fl->fl6_src;
 824         }
 825         return NULL;
 826 }
 827
 828 static __inline__ int
 829 __xfrm4_state_addr_check(struct xfrm_state *x,
 830                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 831 {
 832         if (daddr->a4 == x->id.daddr.a4 &&
 833             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
 834                 return 1;
 835         return 0;
 836 }
 837
 838 static __inline__ int
 839 __xfrm6_state_addr_check(struct xfrm_state *x,
 840                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 841 {
 842         if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
 843             (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)||
 844              ipv6_addr_any((struct in6_addr *)saddr) ||
 845              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
 846                 return 1;
 847         return 0;
 848 }
 849
 850 static __inline__ int
 851 xfrm_state_addr_check(struct xfrm_state *x,
 852                       xfrm_address_t *daddr, xfrm_address_t *saddr,
 853                       unsigned short family)
 854 {
 855         switch (family) {
 856         case AF_INET:
 857                 return __xfrm4_state_addr_check(x, daddr, saddr);
 858         case AF_INET6:
 859                 return __xfrm6_state_addr_check(x, daddr, saddr);
 860         }
 861         return 0;
 862 }
 863
 864 static inline int xfrm_state_kern(struct xfrm_state *x)
 865 {
 866         return atomic_read(&x->tunnel_users);
 867 }
 868
 869 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
 870 {
 871         return (!userproto || proto == userproto ||
 872                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
 873                                                   proto == IPPROTO_ESP ||
 874                                                   proto == IPPROTO_COMP)));
 875 }
 876
 877 /*
 878  * xfrm algorithm information
 879  */
 880 struct xfrm_algo_auth_info {
 881         u16 icv_truncbits;
 882         u16 icv_fullbits;
 883 };
 884
 885 struct xfrm_algo_encr_info {
 886         u16 blockbits;
 887         u16 defkeybits;
 888 };
 889
 890 struct xfrm_algo_comp_info {
 891         u16 threshold;
 892 };
 893
 894 struct xfrm_algo_desc {
 895         char *name;
 896         char *compat;
 897         u8 available:1;
 898         union {
 899                 struct xfrm_algo_auth_info auth;
 900                 struct xfrm_algo_encr_info encr;
 901                 struct xfrm_algo_comp_info comp;
 902         } uinfo;
 903         struct sadb_alg desc;
 904 };
 905
 906 /* XFRM tunnel handlers.  */
 907 struct xfrm_tunnel {
 908         int (*handler)(struct sk_buff *skb);
 909         int (*err_handler)(struct sk_buff *skb, __u32 info);
 910
 911         struct xfrm_tunnel *next;
 912         int priority;
 913 };
 914
 915 struct xfrm6_tunnel {
 916         int (*handler)(struct sk_buff *skb);
 917         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
 918                            int type, int code, int offset, __u32 info);
 919
 920         struct xfrm6_tunnel *next;
 921         int priority;
 922 };
 923
 924 extern void xfrm_init(void);
 925 extern void xfrm4_init(void);
 926 extern void xfrm6_init(void);
 927 extern void xfrm6_fini(void);
 928 extern void xfrm_state_init(void);
 929 extern void xfrm4_state_init(void);
 930 extern void xfrm6_state_init(void);
 931 extern void xfrm6_state_fini(void);
 932
 933 extern int xfrm_state_walk(u8 proto, int (*func)(struct xfrm_state *, int, void*), void *);
 934 extern struct xfrm_state *xfrm_state_alloc(void);
 935 extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
 936                                           struct flowi *fl, struct xfrm_tmpl *tmpl,
 937                                           struct xfrm_policy *pol, int *err,
 938                                           unsigned short family);
 939 extern int xfrm_state_check_expire(struct xfrm_state *x);
 940 extern void xfrm_state_insert(struct xfrm_state *x);
 941 extern int xfrm_state_add(struct xfrm_state *x);
 942 extern int xfrm_state_update(struct xfrm_state *x);
 943 extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family);
 944 extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
 945 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
 946 extern int xfrm_state_delete(struct xfrm_state *x);
 947 extern void xfrm_state_flush(u8 proto);
 948 extern int xfrm_replay_check(struct xfrm_state *x, u32 seq);
 949 extern void xfrm_replay_advance(struct xfrm_state *x, u32 seq);
 950 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
 951 extern int xfrm_state_check(struct xfrm_state *x, struct sk_buff *skb);
 952 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
 953 extern int xfrm_init_state(struct xfrm_state *x);
 954 extern int xfrm4_rcv(struct sk_buff *skb);
 955 extern int xfrm4_output(struct sk_buff *skb);
 956 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler);
 957 extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler);
 958 extern int xfrm6_rcv_spi(struct sk_buff *skb, u32 spi);
 959 extern int xfrm6_rcv(struct sk_buff **pskb);
 960 extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
 961                             xfrm_address_t *saddr, u8 proto);
 962 extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler);
 963 extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler);
 964 extern u32 xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr);
 965 extern void xfrm6_tunnel_free_spi(xfrm_address_t *saddr);
 966 extern u32 xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr);
 967 extern int xfrm6_output(struct sk_buff *skb);
 968 extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
 969                                  u8 **prevhdr);
 970
 971 #ifdef CONFIG_XFRM
 972 extern int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type);
 973 extern int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen);
 974 extern int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family);
 975 #else
 976 static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
 977 {
 978         return -ENOPROTOOPT;
 979 }
 980
 981 static inline int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type)
 982 {
 983         /* should not happen */
 984         kfree_skb(skb);
 985         return 0;
 986 }
 987 static inline int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family)
 988 {
 989         return -EINVAL;
 990 }
 991 #endif
 992
 993 struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp);
 994 extern int xfrm_policy_walk(int (*func)(struct xfrm_policy *, int, int, void*), void *);
 995 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
 996 struct xfrm_policy *xfrm_policy_bysel_ctx(int dir, struct xfrm_selector *sel,
 997                                           struct xfrm_sec_ctx *ctx, int delete);
 998 struct xfrm_policy *xfrm_policy_byid(int dir, u32 id, int delete);
 999 void xfrm_policy_flush(void);
1000 u32 xfrm_get_acqseq(void);
1001 void xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1002 struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
1003                                   xfrm_address_t *daddr, xfrm_address_t *saddr,
1004                                   int create, unsigned short family);
1005 extern void xfrm_policy_flush(void);
1006 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1007 extern int xfrm_flush_bundles(void);
1008 extern void xfrm_flush_all_bundles(void);
1009 extern int xfrm_bundle_ok(struct xfrm_dst *xdst, struct flowi *fl, int family);
1010 extern void xfrm_init_pmtu(struct dst_entry *dst);
1011
1012 extern wait_queue_head_t km_waitq;
1013 extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
1014 extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
1015
1016 extern void xfrm_input_init(void);
1017 extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq);
1018
1019 extern void xfrm_probe_algs(void);
1020 extern int xfrm_count_auth_supported(void);
1021 extern int xfrm_count_enc_supported(void);
1022 extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1023 extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1024 extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1025 extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1026 extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1027 extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
1028 extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
1029 extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);
1030
1031 struct hash_desc;
1032 struct scatterlist;
1033 typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
1034                               unsigned int);
1035
1036 extern int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *tfm,
1037                         int offset, int len, icv_update_fn_t icv_update);
1038
1039 static inline int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
1040                                 int family)
1041 {
1042         switch (family) {
1043         default:
1044         case AF_INET:
1045                 return a->a4 - b->a4;
1046         case AF_INET6:
1047                 return ipv6_addr_cmp((struct in6_addr *)a,
1048                                      (struct in6_addr *)b);
1049         }
1050 }
1051
1052 static inline int xfrm_policy_id2dir(u32 index)
1053 {
1054         return index & 7;
1055 }
1056
1057 static inline int xfrm_aevent_is_on(void)
1058 {
1059         struct sock *nlsk;
1060         int ret = 0;
1061
1062         rcu_read_lock();
1063         nlsk = rcu_dereference(xfrm_nl);
1064         if (nlsk)
1065                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1066         rcu_read_unlock();
1067         return ret;
1068 }
1069
1070 static inline void xfrm_aevent_doreplay(struct xfrm_state *x)
1071 {
1072         if (xfrm_aevent_is_on())
1073                 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
1074 }
1075
1076
1077 #endif  /* _NET_XFRM_H */