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