include/net/xfrm.h

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