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         __u8                    flags;
 264 #define XFRM_TYPE_NON_FRAGMENT  1
 265
 266         int                     (*init_state)(struct xfrm_state *x);
 267         void                    (*destructor)(struct xfrm_state *);
 268         int                     (*input)(struct xfrm_state *, struct sk_buff *skb);
 269         int                     (*output)(struct xfrm_state *, struct sk_buff *pskb);
 270         int                     (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **);
 271         xfrm_address_t          *(*local_addr)(struct xfrm_state *, xfrm_address_t *);
 272         xfrm_address_t          *(*remote_addr)(struct xfrm_state *, xfrm_address_t *);
 273         /* Estimate maximal size of result of transformation of a dgram */
 274         u32                     (*get_max_size)(struct xfrm_state *, int size);
 275 };
 276
 277 extern int xfrm_register_type(struct xfrm_type *type, unsigned short family);
 278 extern int xfrm_unregister_type(struct xfrm_type *type, unsigned short family);
 279 extern struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family);
 280 extern void xfrm_put_type(struct xfrm_type *type);
 281
 282 struct xfrm_mode {
 283         int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 284         int (*output)(struct sk_buff *skb);
 285
 286         struct module *owner;
 287         unsigned int encap;
 288 };
 289
 290 extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
 291 extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
 292 extern struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family);
 293 extern void xfrm_put_mode(struct xfrm_mode *mode);
 294
 295 struct xfrm_tmpl
 296 {
 297 /* id in template is interpreted as:
 298  * daddr - destination of tunnel, may be zero for transport mode.
 299  * spi   - zero to acquire spi. Not zero if spi is static, then
 300  *         daddr must be fixed too.
 301  * proto - AH/ESP/IPCOMP
 302  */
 303         struct xfrm_id          id;
 304
 305 /* Source address of tunnel. Ignored, if it is not a tunnel. */
 306         xfrm_address_t          saddr;
 307
 308         __u32                   reqid;
 309
 310 /* Mode: transport, tunnel etc. */
 311         __u8                    mode;
 312
 313 /* Sharing mode: unique, this session only, this user only etc. */
 314         __u8                    share;
 315
 316 /* May skip this transfomration if no SA is found */
 317         __u8                    optional;
 318
 319 /* Bit mask of algos allowed for acquisition */
 320         __u32                   aalgos;
 321         __u32                   ealgos;
 322         __u32                   calgos;
 323 };
 324
 325 #define XFRM_MAX_DEPTH          6
 326
 327 struct xfrm_policy
 328 {
 329         struct xfrm_policy      *next;
 330         struct list_head        list;
 331
 332         /* This lock only affects elements except for entry. */
 333         rwlock_t                lock;
 334         atomic_t                refcnt;
 335         struct timer_list       timer;
 336
 337         u32                     priority;
 338         u32                     index;
 339         struct xfrm_selector    selector;
 340         struct xfrm_lifetime_cfg lft;
 341         struct xfrm_lifetime_cur curlft;
 342         struct dst_entry       *bundles;
 343         __u16                   family;
 344         __u8                    action;
 345         __u8                    flags;
 346         __u8                    dead;
 347         __u8                    xfrm_nr;
 348         struct xfrm_sec_ctx     *security;
 349         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 350 };
 351
 352 #define XFRM_KM_TIMEOUT                30
 353 /* which seqno */
 354 #define XFRM_REPLAY_SEQ         1
 355 #define XFRM_REPLAY_OSEQ        2
 356 #define XFRM_REPLAY_SEQ_MASK    3
 357 /* what happened */
 358 #define XFRM_REPLAY_UPDATE      XFRM_AE_CR
 359 #define XFRM_REPLAY_TIMEOUT     XFRM_AE_CE
 360
 361 /* default aevent timeout in units of 100ms */
 362 #define XFRM_AE_ETIME                   10
 363 /* Async Event timer multiplier */
 364 #define XFRM_AE_ETH_M                   10
 365 /* default seq threshold size */
 366 #define XFRM_AE_SEQT_SIZE               2
 367
 368 struct xfrm_mgr
 369 {
 370         struct list_head        list;
 371         char                    *id;
 372         int                     (*notify)(struct xfrm_state *x, struct km_event *c);
 373         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 374         struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 375         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
 376         int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 377 };
 378
 379 extern int xfrm_register_km(struct xfrm_mgr *km);
 380 extern int xfrm_unregister_km(struct xfrm_mgr *km);
 381
 382
 383 extern struct xfrm_policy *xfrm_policy_list[XFRM_POLICY_MAX*2];
 384
 385 static inline void xfrm_pol_hold(struct xfrm_policy *policy)
 386 {
 387         if (likely(policy != NULL))
 388                 atomic_inc(&policy->refcnt);
 389 }
 390
 391 extern void __xfrm_policy_destroy(struct xfrm_policy *policy);
 392
 393 static inline void xfrm_pol_put(struct xfrm_policy *policy)
 394 {
 395         if (atomic_dec_and_test(&policy->refcnt))
 396                 __xfrm_policy_destroy(policy);
 397 }
 398
 399 #define XFRM_DST_HSIZE          1024
 400
 401 static __inline__
 402 unsigned __xfrm4_dst_hash(xfrm_address_t *addr)
 403 {
 404         unsigned h;
 405         h = ntohl(addr->a4);
 406         h = (h ^ (h>>16)) % XFRM_DST_HSIZE;
 407         return h;
 408 }
 409
 410 static __inline__
 411 unsigned __xfrm6_dst_hash(xfrm_address_t *addr)
 412 {
 413         unsigned h;
 414         h = ntohl(addr->a6[2]^addr->a6[3]);
 415         h = (h ^ (h>>16)) % XFRM_DST_HSIZE;
 416         return h;
 417 }
 418
 419 static __inline__
 420 unsigned xfrm_dst_hash(xfrm_address_t *addr, unsigned short family)
 421 {
 422         switch (family) {
 423         case AF_INET:
 424                 return __xfrm4_dst_hash(addr);
 425         case AF_INET6:
 426                 return __xfrm6_dst_hash(addr);
 427         }
 428         return 0;
 429 }
 430
 431 static __inline__
 432 unsigned __xfrm4_src_hash(xfrm_address_t *addr)
 433 {
 434         return __xfrm4_dst_hash(addr);
 435 }
 436
 437 static __inline__
 438 unsigned __xfrm6_src_hash(xfrm_address_t *addr)
 439 {
 440         return __xfrm6_dst_hash(addr);
 441 }
 442
 443 static __inline__
 444 unsigned xfrm_src_hash(xfrm_address_t *addr, unsigned short family)
 445 {
 446         switch (family) {
 447         case AF_INET:
 448                 return __xfrm4_src_hash(addr);
 449         case AF_INET6:
 450                 return __xfrm6_src_hash(addr);
 451         }
 452         return 0;
 453 }
 454
 455 static __inline__
 456 unsigned __xfrm4_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto)
 457 {
 458         unsigned h;
 459         h = ntohl(addr->a4^spi^proto);
 460         h = (h ^ (h>>10) ^ (h>>20)) % XFRM_DST_HSIZE;
 461         return h;
 462 }
 463
 464 static __inline__
 465 unsigned __xfrm6_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto)
 466 {
 467         unsigned h;
 468         h = ntohl(addr->a6[2]^addr->a6[3]^spi^proto);
 469         h = (h ^ (h>>10) ^ (h>>20)) % XFRM_DST_HSIZE;
 470         return h;
 471 }
 472
 473 static __inline__
 474 unsigned xfrm_spi_hash(xfrm_address_t *addr, u32 spi, u8 proto, unsigned short family)
 475 {
 476         switch (family) {
 477         case AF_INET:
 478                 return __xfrm4_spi_hash(addr, spi, proto);
 479         case AF_INET6:
 480                 return __xfrm6_spi_hash(addr, spi, proto);
 481         }
 482         return 0;       /*XXX*/
 483 }
 484
 485 extern void __xfrm_state_destroy(struct xfrm_state *);
 486
 487 static inline void __xfrm_state_put(struct xfrm_state *x)
 488 {
 489         atomic_dec(&x->refcnt);
 490 }
 491
 492 static inline void xfrm_state_put(struct xfrm_state *x)
 493 {
 494         if (atomic_dec_and_test(&x->refcnt))
 495                 __xfrm_state_destroy(x);
 496 }
 497
 498 static inline void xfrm_state_hold(struct xfrm_state *x)
 499 {
 500         atomic_inc(&x->refcnt);
 501 }
 502
 503 static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 504 {
 505         __u32 *a1 = token1;
 506         __u32 *a2 = token2;
 507         int pdw;
 508         int pbi;
 509
 510         pdw = prefixlen >> 5;     /* num of whole __u32 in prefix */
 511         pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
 512
 513         if (pdw)
 514                 if (memcmp(a1, a2, pdw << 2))
 515                         return 0;
 516
 517         if (pbi) {
 518                 __u32 mask;
 519
 520                 mask = htonl((0xffffffff) << (32 - pbi));
 521
 522                 if ((a1[pdw] ^ a2[pdw]) & mask)
 523                         return 0;
 524         }
 525
 526         return 1;
 527 }
 528
 529 static __inline__
 530 u16 xfrm_flowi_sport(struct flowi *fl)
 531 {
 532         u16 port;
 533         switch(fl->proto) {
 534         case IPPROTO_TCP:
 535         case IPPROTO_UDP:
 536         case IPPROTO_SCTP:
 537                 port = fl->fl_ip_sport;
 538                 break;
 539         case IPPROTO_ICMP:
 540         case IPPROTO_ICMPV6:
 541                 port = htons(fl->fl_icmp_type);
 542                 break;
 543         default:
 544                 port = 0;       /*XXX*/
 545         }
 546         return port;
 547 }
 548
 549 static __inline__
 550 u16 xfrm_flowi_dport(struct flowi *fl)
 551 {
 552         u16 port;
 553         switch(fl->proto) {
 554         case IPPROTO_TCP:
 555         case IPPROTO_UDP:
 556         case IPPROTO_SCTP:
 557                 port = fl->fl_ip_dport;
 558                 break;
 559         case IPPROTO_ICMP:
 560         case IPPROTO_ICMPV6:
 561                 port = htons(fl->fl_icmp_code);
 562                 break;
 563         default:
 564                 port = 0;       /*XXX*/
 565         }
 566         return port;
 567 }
 568
 569 static inline int
 570 __xfrm4_selector_match(struct xfrm_selector *sel, struct flowi *fl)
 571 {
 572         return  addr_match(&fl->fl4_dst, &sel->daddr, sel->prefixlen_d) &&
 573                 addr_match(&fl->fl4_src, &sel->saddr, sel->prefixlen_s) &&
 574                 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
 575                 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
 576                 (fl->proto == sel->proto || !sel->proto) &&
 577                 (fl->oif == sel->ifindex || !sel->ifindex);
 578 }
 579
 580 static inline int
 581 __xfrm6_selector_match(struct xfrm_selector *sel, struct flowi *fl)
 582 {
 583         return  addr_match(&fl->fl6_dst, &sel->daddr, sel->prefixlen_d) &&
 584                 addr_match(&fl->fl6_src, &sel->saddr, sel->prefixlen_s) &&
 585                 !((xfrm_flowi_dport(fl) ^ sel->dport) & sel->dport_mask) &&
 586                 !((xfrm_flowi_sport(fl) ^ sel->sport) & sel->sport_mask) &&
 587                 (fl->proto == sel->proto || !sel->proto) &&
 588                 (fl->oif == sel->ifindex || !sel->ifindex);
 589 }
 590
 591 static inline int
 592 xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
 593                     unsigned short family)
 594 {
 595         switch (family) {
 596         case AF_INET:
 597                 return __xfrm4_selector_match(sel, fl);
 598         case AF_INET6:
 599                 return __xfrm6_selector_match(sel, fl);
 600         }
 601         return 0;
 602 }
 603
 604 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 605 /*      If neither has a context --> match
 606  *      Otherwise, both must have a context and the sids, doi, alg must match
 607  */
 608 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 609 {
 610         return ((!s1 && !s2) ||
 611                 (s1 && s2 &&
 612                  (s1->ctx_sid == s2->ctx_sid) &&
 613                  (s1->ctx_doi == s2->ctx_doi) &&
 614                  (s1->ctx_alg == s2->ctx_alg)));
 615 }
 616 #else
 617 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 618 {
 619         return 1;
 620 }
 621 #endif
 622
 623 /* A struct encoding bundle of transformations to apply to some set of flow.
 624  *
 625  * dst->child points to the next element of bundle.
 626  * dst->xfrm  points to an instanse of transformer.
 627  *
 628  * Due to unfortunate limitations of current routing cache, which we
 629  * have no time to fix, it mirrors struct rtable and bound to the same
 630  * routing key, including saddr,daddr. However, we can have many of
 631  * bundles differing by session id. All the bundles grow from a parent
 632  * policy rule.
 633  */
 634 struct xfrm_dst
 635 {
 636         union {
 637                 struct xfrm_dst         *next;
 638                 struct dst_entry        dst;
 639                 struct rtable           rt;
 640                 struct rt6_info         rt6;
 641         } u;
 642         struct dst_entry *route;
 643         u32 route_mtu_cached;
 644         u32 child_mtu_cached;
 645         u32 route_cookie;
 646         u32 path_cookie;
 647 };
 648
 649 static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 650 {
 651         dst_release(xdst->route);
 652         if (likely(xdst->u.dst.xfrm))
 653                 xfrm_state_put(xdst->u.dst.xfrm);
 654 }
 655
 656 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 657
 658 struct sec_path
 659 {
 660         atomic_t                refcnt;
 661         int                     len;
 662         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
 663 };
 664
 665 static inline struct sec_path *
 666 secpath_get(struct sec_path *sp)
 667 {
 668         if (sp)
 669                 atomic_inc(&sp->refcnt);
 670         return sp;
 671 }
 672
 673 extern void __secpath_destroy(struct sec_path *sp);
 674
 675 static inline void
 676 secpath_put(struct sec_path *sp)
 677 {
 678         if (sp && atomic_dec_and_test(&sp->refcnt))
 679                 __secpath_destroy(sp);
 680 }
 681
 682 extern struct sec_path *secpath_dup(struct sec_path *src);
 683
 684 static inline void
 685 secpath_reset(struct sk_buff *skb)
 686 {
 687 #ifdef CONFIG_XFRM
 688         secpath_put(skb->sp);
 689         skb->sp = NULL;
 690 #endif
 691 }
 692
 693 static inline int
 694 __xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 695 {
 696         return  (tmpl->saddr.a4 &&
 697                  tmpl->saddr.a4 != x->props.saddr.a4);
 698 }
 699
 700 static inline int
 701 __xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 702 {
 703         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
 704                  ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
 705 }
 706
 707 static inline int
 708 xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
 709 {
 710         switch (family) {
 711         case AF_INET:
 712                 return __xfrm4_state_addr_cmp(tmpl, x);
 713         case AF_INET6:
 714                 return __xfrm6_state_addr_cmp(tmpl, x);
 715         }
 716         return !0;
 717 }
 718
 719 #ifdef CONFIG_XFRM
 720
 721 extern int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb, unsigned short family);
 722
 723 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 724 {
 725         if (sk && sk->sk_policy[XFRM_POLICY_IN])
 726                 return __xfrm_policy_check(sk, dir, skb, family);
 727
 728         return  (!xfrm_policy_list[dir] && !skb->sp) ||
 729                 (skb->dst->flags & DST_NOPOLICY) ||
 730                 __xfrm_policy_check(sk, dir, skb, family);
 731 }
 732
 733 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 734 {
 735         return xfrm_policy_check(sk, dir, skb, AF_INET);
 736 }
 737
 738 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 739 {
 740         return xfrm_policy_check(sk, dir, skb, AF_INET6);
 741 }
 742
 743 extern int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl, unsigned short family);
 744 extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
 745
 746 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
 747 {
 748         return  !xfrm_policy_list[XFRM_POLICY_OUT] ||
 749                 (skb->dst->flags & DST_NOXFRM) ||
 750                 __xfrm_route_forward(skb, family);
 751 }
 752
 753 static inline int xfrm4_route_forward(struct sk_buff *skb)
 754 {
 755         return xfrm_route_forward(skb, AF_INET);
 756 }
 757
 758 static inline int xfrm6_route_forward(struct sk_buff *skb)
 759 {
 760         return xfrm_route_forward(skb, AF_INET6);
 761 }
 762
 763 extern int __xfrm_sk_clone_policy(struct sock *sk);
 764
 765 static inline int xfrm_sk_clone_policy(struct sock *sk)
 766 {
 767         if (unlikely(sk->sk_policy[0] || sk->sk_policy[1]))
 768                 return __xfrm_sk_clone_policy(sk);
 769         return 0;
 770 }
 771
 772 extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
 773
 774 static inline void xfrm_sk_free_policy(struct sock *sk)
 775 {
 776         if (unlikely(sk->sk_policy[0] != NULL)) {
 777                 xfrm_policy_delete(sk->sk_policy[0], XFRM_POLICY_MAX);
 778                 sk->sk_policy[0] = NULL;
 779         }
 780         if (unlikely(sk->sk_policy[1] != NULL)) {
 781                 xfrm_policy_delete(sk->sk_policy[1], XFRM_POLICY_MAX+1);
 782                 sk->sk_policy[1] = NULL;
 783         }
 784 }
 785
 786 #else
 787
 788 static inline void xfrm_sk_free_policy(struct sock *sk) {}
 789 static inline int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
 790 static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
 791 static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
 792 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 793 {
 794         return 1;
 795 }
 796 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 797 {
 798         return 1;
 799 }
 800 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 801 {
 802         return 1;
 803 }
 804 #endif
 805
 806 static __inline__
 807 xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
 808 {
 809         switch (family){
 810         case AF_INET:
 811                 return (xfrm_address_t *)&fl->fl4_dst;
 812         case AF_INET6:
 813                 return (xfrm_address_t *)&fl->fl6_dst;
 814         }
 815         return NULL;
 816 }
 817
 818 static __inline__
 819 xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
 820 {
 821         switch (family){
 822         case AF_INET:
 823                 return (xfrm_address_t *)&fl->fl4_src;
 824         case AF_INET6:
 825                 return (xfrm_address_t *)&fl->fl6_src;
 826         }
 827         return NULL;
 828 }
 829
 830 static __inline__ int
 831 __xfrm4_state_addr_check(struct xfrm_state *x,
 832                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 833 {
 834         if (daddr->a4 == x->id.daddr.a4 &&
 835             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
 836                 return 1;
 837         return 0;
 838 }
 839
 840 static __inline__ int
 841 __xfrm6_state_addr_check(struct xfrm_state *x,
 842                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 843 {
 844         if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
 845             (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)||
 846              ipv6_addr_any((struct in6_addr *)saddr) ||
 847              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
 848                 return 1;
 849         return 0;
 850 }
 851
 852 static __inline__ int
 853 xfrm_state_addr_check(struct xfrm_state *x,
 854                       xfrm_address_t *daddr, xfrm_address_t *saddr,
 855                       unsigned short family)
 856 {
 857         switch (family) {
 858         case AF_INET:
 859                 return __xfrm4_state_addr_check(x, daddr, saddr);
 860         case AF_INET6:
 861                 return __xfrm6_state_addr_check(x, daddr, saddr);
 862         }
 863         return 0;
 864 }
 865
 866 static inline int xfrm_state_kern(struct xfrm_state *x)
 867 {
 868         return atomic_read(&x->tunnel_users);
 869 }
 870
 871 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
 872 {
 873         return (!userproto || proto == userproto ||
 874                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
 875                                                   proto == IPPROTO_ESP ||
 876                                                   proto == IPPROTO_COMP)));
 877 }
 878
 879 /*
 880  * xfrm algorithm information
 881  */
 882 struct xfrm_algo_auth_info {
 883         u16 icv_truncbits;
 884         u16 icv_fullbits;
 885 };
 886
 887 struct xfrm_algo_encr_info {
 888         u16 blockbits;
 889         u16 defkeybits;
 890 };
 891
 892 struct xfrm_algo_comp_info {
 893         u16 threshold;
 894 };
 895
 896 struct xfrm_algo_desc {
 897         char *name;
 898         char *compat;
 899         u8 available:1;
 900         union {
 901                 struct xfrm_algo_auth_info auth;
 902                 struct xfrm_algo_encr_info encr;
 903                 struct xfrm_algo_comp_info comp;
 904         } uinfo;
 905         struct sadb_alg desc;
 906 };
 907
 908 /* XFRM tunnel handlers.  */
 909 struct xfrm_tunnel {
 910         int (*handler)(struct sk_buff *skb);
 911         int (*err_handler)(struct sk_buff *skb, __u32 info);
 912
 913         struct xfrm_tunnel *next;
 914         int priority;
 915 };
 916
 917 struct xfrm6_tunnel {
 918         int (*handler)(struct sk_buff *skb);
 919         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
 920                            int type, int code, int offset, __u32 info);
 921
 922         struct xfrm6_tunnel *next;
 923         int priority;
 924 };
 925
 926 extern void xfrm_init(void);
 927 extern void xfrm4_init(void);
 928 extern void xfrm6_init(void);
 929 extern void xfrm6_fini(void);
 930 extern void xfrm_state_init(void);
 931 extern void xfrm4_state_init(void);
 932 extern void xfrm6_state_init(void);
 933 extern void xfrm6_state_fini(void);
 934
 935 extern int xfrm_state_walk(u8 proto, int (*func)(struct xfrm_state *, int, void*), void *);
 936 extern struct xfrm_state *xfrm_state_alloc(void);
 937 extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
 938                                           struct flowi *fl, struct xfrm_tmpl *tmpl,
 939                                           struct xfrm_policy *pol, int *err,
 940                                           unsigned short family);
 941 extern int xfrm_state_check_expire(struct xfrm_state *x);
 942 extern void xfrm_state_insert(struct xfrm_state *x);
 943 extern int xfrm_state_add(struct xfrm_state *x);
 944 extern int xfrm_state_update(struct xfrm_state *x);
 945 extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family);
 946 extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
 947 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
 948 extern int xfrm_state_delete(struct xfrm_state *x);
 949 extern void xfrm_state_flush(u8 proto);
 950 extern int xfrm_replay_check(struct xfrm_state *x, u32 seq);
 951 extern void xfrm_replay_advance(struct xfrm_state *x, u32 seq);
 952 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
 953 extern int xfrm_state_check(struct xfrm_state *x, struct sk_buff *skb);
 954 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
 955 extern int xfrm_init_state(struct xfrm_state *x);
 956 extern int xfrm4_rcv(struct sk_buff *skb);
 957 extern int xfrm4_output(struct sk_buff *skb);
 958 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler);
 959 extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler);
 960 extern int xfrm6_rcv_spi(struct sk_buff *skb, u32 spi);
 961 extern int xfrm6_rcv(struct sk_buff **pskb);
 962 extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
 963                             xfrm_address_t *saddr, u8 proto);
 964 extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler);
 965 extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler);
 966 extern u32 xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr);
 967 extern void xfrm6_tunnel_free_spi(xfrm_address_t *saddr);
 968 extern u32 xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr);
 969 extern int xfrm6_output(struct sk_buff *skb);
 970 extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
 971                                  u8 **prevhdr);
 972
 973 #ifdef CONFIG_XFRM
 974 extern int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type);
 975 extern int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen);
 976 extern int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family);
 977 #else
 978 static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
 979 {
 980         return -ENOPROTOOPT;
 981 }
 982
 983 static inline int xfrm4_rcv_encap(struct sk_buff *skb, __u16 encap_type)
 984 {
 985         /* should not happen */
 986         kfree_skb(skb);
 987         return 0;
 988 }
 989 static inline int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family)
 990 {
 991         return -EINVAL;
 992 }
 993 #endif
 994
 995 struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp);
 996 extern int xfrm_policy_walk(int (*func)(struct xfrm_policy *, int, int, void*), void *);
 997 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
 998 struct xfrm_policy *xfrm_policy_bysel_ctx(int dir, struct xfrm_selector *sel,
 999                                           struct xfrm_sec_ctx *ctx, int delete);
1000 struct xfrm_policy *xfrm_policy_byid(int dir, u32 id, int delete);
1001 void xfrm_policy_flush(void);
1002 u32 xfrm_get_acqseq(void);
1003 void xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
1004 struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
1005                                   xfrm_address_t *daddr, xfrm_address_t *saddr,
1006                                   int create, unsigned short family);
1007 extern void xfrm_policy_flush(void);
1008 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1009 extern int xfrm_flush_bundles(void);
1010 extern void xfrm_flush_all_bundles(void);
1011 extern int xfrm_bundle_ok(struct xfrm_dst *xdst, struct flowi *fl, int family);
1012 extern void xfrm_init_pmtu(struct dst_entry *dst);
1013
1014 extern wait_queue_head_t km_waitq;
1015 extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
1016 extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
1017
1018 extern void xfrm_input_init(void);
1019 extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, u32 *spi, u32 *seq);
1020
1021 extern void xfrm_probe_algs(void);
1022 extern int xfrm_count_auth_supported(void);
1023 extern int xfrm_count_enc_supported(void);
1024 extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1025 extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1026 extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1027 extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1028 extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1029 extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
1030 extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
1031 extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);
1032
1033 struct hash_desc;
1034 struct scatterlist;
1035 typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
1036                               unsigned int);
1037
1038 extern int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *tfm,
1039                         int offset, int len, icv_update_fn_t icv_update);
1040
1041 static inline int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
1042                                 int family)
1043 {
1044         switch (family) {
1045         default:
1046         case AF_INET:
1047                 return a->a4 - b->a4;
1048         case AF_INET6:
1049                 return ipv6_addr_cmp((struct in6_addr *)a,
1050                                      (struct in6_addr *)b);
1051         }
1052 }
1053
1054 static inline int xfrm_policy_id2dir(u32 index)
1055 {
1056         return index & 7;
1057 }
1058
1059 static inline int xfrm_aevent_is_on(void)
1060 {
1061         struct sock *nlsk;
1062         int ret = 0;
1063
1064         rcu_read_lock();
1065         nlsk = rcu_dereference(xfrm_nl);
1066         if (nlsk)
1067                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1068         rcu_read_unlock();
1069         return ret;
1070 }
1071
1072 static inline void xfrm_aevent_doreplay(struct xfrm_state *x)
1073 {
1074         if (xfrm_aevent_is_on())
1075                 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
1076 }
1077
1078
1079 #endif  /* _NET_XFRM_H */