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        *mode;
 190
 191         /* Security context */
 192         struct xfrm_sec_ctx     *security;
 193
 194         /* Private data of this transformer, format is opaque,
 195          * interpreted by xfrm_type methods. */
 196         void                    *data;
 197 };
 198
 199 /* xflags - make enum if more show up */
 200 #define XFRM_TIME_DEFER 1
 201
 202 enum {
 203         XFRM_STATE_VOID,
 204         XFRM_STATE_ACQ,
 205         XFRM_STATE_VALID,
 206         XFRM_STATE_ERROR,
 207         XFRM_STATE_EXPIRED,
 208         XFRM_STATE_DEAD
 209 };
 210
 211 /* callback structure passed from either netlink or pfkey */
 212 struct km_event
 213 {
 214         union {
 215                 u32 hard;
 216                 u32 proto;
 217                 u32 byid;
 218                 u32 aevent;
 219                 u32 type;
 220         } data;
 221
 222         u32     seq;
 223         u32     pid;
 224         u32     event;
 225 };
 226
 227 struct xfrm_type;
 228 struct xfrm_dst;
 229 struct xfrm_policy_afinfo {
 230         unsigned short          family;
 231         struct xfrm_type        *type_map[IPPROTO_MAX];
 232         struct xfrm_mode        *mode_map[XFRM_MODE_MAX];
 233         struct dst_ops          *dst_ops;
 234         void                    (*garbage_collect)(void);
 235         int                     (*dst_lookup)(struct xfrm_dst **dst, struct flowi *fl);
 236         int                     (*get_saddr)(xfrm_address_t *saddr, xfrm_address_t *daddr);
 237         struct dst_entry        *(*find_bundle)(struct flowi *fl, struct xfrm_policy *policy);
 238         int                     (*bundle_create)(struct xfrm_policy *policy,
 239                                                  struct xfrm_state **xfrm,
 240                                                  int nx,
 241                                                  struct flowi *fl,
 242                                                  struct dst_entry **dst_p);
 243         void                    (*decode_session)(struct sk_buff *skb,
 244                                                   struct flowi *fl);
 245 };
 246
 247 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 248 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
 249 extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
 250 extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
 251
 252 struct xfrm_tmpl;
 253 extern int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
 254 extern void km_state_expired(struct xfrm_state *x, int hard, u32 pid);
 255 extern int __xfrm_state_delete(struct xfrm_state *x);
 256
 257 struct xfrm_state_afinfo {
 258         unsigned short          family;
 259         int                     (*init_flags)(struct xfrm_state *x);
 260         void                    (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,
 261                                                 struct xfrm_tmpl *tmpl,
 262                                                 xfrm_address_t *daddr, xfrm_address_t *saddr);
 263         int                     (*tmpl_sort)(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n);
 264         int                     (*state_sort)(struct xfrm_state **dst, struct xfrm_state **src, int n);
 265         int                     (*output)(struct sk_buff *skb);
 266 };
 267
 268 extern int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo);
 269 extern int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo);
 270 extern struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned short family);
 271 extern void xfrm_state_put_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 extern struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family);
 299 extern void xfrm_put_type(struct xfrm_type *type);
 300
 301 struct xfrm_mode {
 302         int (*input)(struct xfrm_state *x, struct sk_buff *skb);
 303         int (*output)(struct xfrm_state *x,struct sk_buff *skb);
 304
 305         struct module *owner;
 306         unsigned int encap;
 307 };
 308
 309 extern int xfrm_register_mode(struct xfrm_mode *mode, int family);
 310 extern int xfrm_unregister_mode(struct xfrm_mode *mode, int family);
 311 extern struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family);
 312 extern void xfrm_put_mode(struct xfrm_mode *mode);
 313
 314 struct xfrm_tmpl
 315 {
 316 /* id in template is interpreted as:
 317  * daddr - destination of tunnel, may be zero for transport mode.
 318  * spi   - zero to acquire spi. Not zero if spi is static, then
 319  *         daddr must be fixed too.
 320  * proto - AH/ESP/IPCOMP
 321  */
 322         struct xfrm_id          id;
 323
 324 /* Source address of tunnel. Ignored, if it is not a tunnel. */
 325         xfrm_address_t          saddr;
 326
 327         unsigned short          encap_family;
 328
 329         __u32                   reqid;
 330
 331 /* Mode: transport, tunnel etc. */
 332         __u8                    mode;
 333
 334 /* Sharing mode: unique, this session only, this user only etc. */
 335         __u8                    share;
 336
 337 /* May skip this transfomration if no SA is found */
 338         __u8                    optional;
 339
 340 /* Bit mask of algos allowed for acquisition */
 341         __u32                   aalgos;
 342         __u32                   ealgos;
 343         __u32                   calgos;
 344 };
 345
 346 #define XFRM_MAX_DEPTH          6
 347
 348 struct xfrm_policy
 349 {
 350         struct xfrm_policy      *next;
 351         struct hlist_node       bydst;
 352         struct hlist_node       byidx;
 353
 354         /* This lock only affects elements except for entry. */
 355         rwlock_t                lock;
 356         atomic_t                refcnt;
 357         struct timer_list       timer;
 358
 359         u32                     priority;
 360         u32                     index;
 361         struct xfrm_selector    selector;
 362         struct xfrm_lifetime_cfg lft;
 363         struct xfrm_lifetime_cur curlft;
 364         struct dst_entry       *bundles;
 365         u16                     family;
 366         u8                      type;
 367         u8                      action;
 368         u8                      flags;
 369         u8                      dead;
 370         u8                      xfrm_nr;
 371         /* XXX 1 byte hole, try to pack */
 372         struct xfrm_sec_ctx     *security;
 373         struct xfrm_tmpl        xfrm_vec[XFRM_MAX_DEPTH];
 374 };
 375
 376 struct xfrm_migrate {
 377         xfrm_address_t          old_daddr;
 378         xfrm_address_t          old_saddr;
 379         xfrm_address_t          new_daddr;
 380         xfrm_address_t          new_saddr;
 381         u8                      proto;
 382         u8                      mode;
 383         u16                     reserved;
 384         u32                     reqid;
 385         u16                     old_family;
 386         u16                     new_family;
 387 };
 388
 389 #define XFRM_KM_TIMEOUT                30
 390 /* which seqno */
 391 #define XFRM_REPLAY_SEQ         1
 392 #define XFRM_REPLAY_OSEQ        2
 393 #define XFRM_REPLAY_SEQ_MASK    3
 394 /* what happened */
 395 #define XFRM_REPLAY_UPDATE      XFRM_AE_CR
 396 #define XFRM_REPLAY_TIMEOUT     XFRM_AE_CE
 397
 398 /* default aevent timeout in units of 100ms */
 399 #define XFRM_AE_ETIME                   10
 400 /* Async Event timer multiplier */
 401 #define XFRM_AE_ETH_M                   10
 402 /* default seq threshold size */
 403 #define XFRM_AE_SEQT_SIZE               2
 404
 405 struct xfrm_mgr
 406 {
 407         struct list_head        list;
 408         char                    *id;
 409         int                     (*notify)(struct xfrm_state *x, struct km_event *c);
 410         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
 411         struct xfrm_policy      *(*compile_policy)(struct sock *sk, int opt, u8 *data, int len, int *dir);
 412         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
 413         int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 414         int                     (*report)(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
 415         int                     (*migrate)(struct xfrm_selector *sel, u8 dir, u8 type, struct xfrm_migrate *m, int num_bundles);
 416 };
 417
 418 extern int xfrm_register_km(struct xfrm_mgr *km);
 419 extern int xfrm_unregister_km(struct xfrm_mgr *km);
 420
 421 extern unsigned int xfrm_policy_count[XFRM_POLICY_MAX*2];
 422
 423 /*
 424  * This structure is used for the duration where packets are being
 425  * transformed by IPsec.  As soon as the packet leaves IPsec the
 426  * area beyond the generic IP part may be overwritten.
 427  */
 428 struct xfrm_skb_cb {
 429         union {
 430                 struct inet_skb_parm h4;
 431                 struct inet6_skb_parm h6;
 432         } header;
 433
 434         /* Sequence number for replay protection. */
 435         u64 seq;
 436 };
 437
 438 #define XFRM_SKB_CB(__skb) ((struct xfrm_skb_cb *)&((__skb)->cb[0]))
 439
 440 /* Audit Information */
 441 struct xfrm_audit
 442 {
 443         u32     loginuid;
 444         u32     secid;
 445 };
 446
 447 #ifdef CONFIG_AUDITSYSCALL
 448 static inline struct audit_buffer *xfrm_audit_start(u32 auid, u32 sid)
 449 {
 450         struct audit_buffer *audit_buf = NULL;
 451         char *secctx;
 452         u32 secctx_len;
 453
 454         audit_buf = audit_log_start(current->audit_context, GFP_ATOMIC,
 455                               AUDIT_MAC_IPSEC_EVENT);
 456         if (audit_buf == NULL)
 457                 return NULL;
 458
 459         audit_log_format(audit_buf, "auid=%u", auid);
 460
 461         if (sid != 0 &&
 462             security_secid_to_secctx(sid, &secctx, &secctx_len) == 0) {
 463                 audit_log_format(audit_buf, " subj=%s", secctx);
 464                 security_release_secctx(secctx, secctx_len);
 465         } else
 466                 audit_log_task_context(audit_buf);
 467         return audit_buf;
 468 }
 469
 470 extern void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
 471                                   u32 auid, u32 sid);
 472 extern void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
 473                                   u32 auid, u32 sid);
 474 extern void xfrm_audit_state_add(struct xfrm_state *x, int result,
 475                                  u32 auid, u32 sid);
 476 extern void xfrm_audit_state_delete(struct xfrm_state *x, int result,
 477                                     u32 auid, u32 sid);
 478 #else
 479 #define xfrm_audit_policy_add(x, r, a, s)       do { ; } while (0)
 480 #define xfrm_audit_policy_delete(x, r, a, s)    do { ; } while (0)
 481 #define xfrm_audit_state_add(x, r, a, s)        do { ; } while (0)
 482 #define xfrm_audit_state_delete(x, r, a, s)     do { ; } while (0)
 483 #endif /* CONFIG_AUDITSYSCALL */
 484
 485 static inline void xfrm_pol_hold(struct xfrm_policy *policy)
 486 {
 487         if (likely(policy != NULL))
 488                 atomic_inc(&policy->refcnt);
 489 }
 490
 491 extern void __xfrm_policy_destroy(struct xfrm_policy *policy);
 492
 493 static inline void xfrm_pol_put(struct xfrm_policy *policy)
 494 {
 495         if (atomic_dec_and_test(&policy->refcnt))
 496                 __xfrm_policy_destroy(policy);
 497 }
 498
 499 #ifdef CONFIG_XFRM_SUB_POLICY
 500 static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
 501 {
 502         int i;
 503         for (i = npols - 1; i >= 0; --i)
 504                 xfrm_pol_put(pols[i]);
 505 }
 506 #else
 507 static inline void xfrm_pols_put(struct xfrm_policy **pols, int npols)
 508 {
 509         xfrm_pol_put(pols[0]);
 510 }
 511 #endif
 512
 513 extern void __xfrm_state_destroy(struct xfrm_state *);
 514
 515 static inline void __xfrm_state_put(struct xfrm_state *x)
 516 {
 517         atomic_dec(&x->refcnt);
 518 }
 519
 520 static inline void xfrm_state_put(struct xfrm_state *x)
 521 {
 522         if (atomic_dec_and_test(&x->refcnt))
 523                 __xfrm_state_destroy(x);
 524 }
 525
 526 static inline void xfrm_state_hold(struct xfrm_state *x)
 527 {
 528         atomic_inc(&x->refcnt);
 529 }
 530
 531 static __inline__ int addr_match(void *token1, void *token2, int prefixlen)
 532 {
 533         __be32 *a1 = token1;
 534         __be32 *a2 = token2;
 535         int pdw;
 536         int pbi;
 537
 538         pdw = prefixlen >> 5;     /* num of whole __u32 in prefix */
 539         pbi = prefixlen &  0x1f;  /* num of bits in incomplete u32 in prefix */
 540
 541         if (pdw)
 542                 if (memcmp(a1, a2, pdw << 2))
 543                         return 0;
 544
 545         if (pbi) {
 546                 __be32 mask;
 547
 548                 mask = htonl((0xffffffff) << (32 - pbi));
 549
 550                 if ((a1[pdw] ^ a2[pdw]) & mask)
 551                         return 0;
 552         }
 553
 554         return 1;
 555 }
 556
 557 static __inline__
 558 __be16 xfrm_flowi_sport(struct flowi *fl)
 559 {
 560         __be16 port;
 561         switch(fl->proto) {
 562         case IPPROTO_TCP:
 563         case IPPROTO_UDP:
 564         case IPPROTO_UDPLITE:
 565         case IPPROTO_SCTP:
 566                 port = fl->fl_ip_sport;
 567                 break;
 568         case IPPROTO_ICMP:
 569         case IPPROTO_ICMPV6:
 570                 port = htons(fl->fl_icmp_type);
 571                 break;
 572         case IPPROTO_MH:
 573                 port = htons(fl->fl_mh_type);
 574                 break;
 575         default:
 576                 port = 0;       /*XXX*/
 577         }
 578         return port;
 579 }
 580
 581 static __inline__
 582 __be16 xfrm_flowi_dport(struct flowi *fl)
 583 {
 584         __be16 port;
 585         switch(fl->proto) {
 586         case IPPROTO_TCP:
 587         case IPPROTO_UDP:
 588         case IPPROTO_UDPLITE:
 589         case IPPROTO_SCTP:
 590                 port = fl->fl_ip_dport;
 591                 break;
 592         case IPPROTO_ICMP:
 593         case IPPROTO_ICMPV6:
 594                 port = htons(fl->fl_icmp_code);
 595                 break;
 596         default:
 597                 port = 0;       /*XXX*/
 598         }
 599         return port;
 600 }
 601
 602 extern int xfrm_selector_match(struct xfrm_selector *sel, struct flowi *fl,
 603                                unsigned short family);
 604
 605 #ifdef CONFIG_SECURITY_NETWORK_XFRM
 606 /*      If neither has a context --> match
 607  *      Otherwise, both must have a context and the sids, doi, alg must match
 608  */
 609 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 610 {
 611         return ((!s1 && !s2) ||
 612                 (s1 && s2 &&
 613                  (s1->ctx_sid == s2->ctx_sid) &&
 614                  (s1->ctx_doi == s2->ctx_doi) &&
 615                  (s1->ctx_alg == s2->ctx_alg)));
 616 }
 617 #else
 618 static inline int xfrm_sec_ctx_match(struct xfrm_sec_ctx *s1, struct xfrm_sec_ctx *s2)
 619 {
 620         return 1;
 621 }
 622 #endif
 623
 624 /* A struct encoding bundle of transformations to apply to some set of flow.
 625  *
 626  * dst->child points to the next element of bundle.
 627  * dst->xfrm  points to an instanse of transformer.
 628  *
 629  * Due to unfortunate limitations of current routing cache, which we
 630  * have no time to fix, it mirrors struct rtable and bound to the same
 631  * routing key, including saddr,daddr. However, we can have many of
 632  * bundles differing by session id. All the bundles grow from a parent
 633  * policy rule.
 634  */
 635 struct xfrm_dst
 636 {
 637         union {
 638                 struct dst_entry        dst;
 639                 struct rtable           rt;
 640                 struct rt6_info         rt6;
 641         } u;
 642         struct dst_entry *route;
 643 #ifdef CONFIG_XFRM_SUB_POLICY
 644         struct flowi *origin;
 645         struct xfrm_selector *partner;
 646 #endif
 647         u32 genid;
 648         u32 route_mtu_cached;
 649         u32 child_mtu_cached;
 650         u32 route_cookie;
 651         u32 path_cookie;
 652 };
 653
 654 static inline void xfrm_dst_destroy(struct xfrm_dst *xdst)
 655 {
 656         dst_release(xdst->route);
 657         if (likely(xdst->u.dst.xfrm))
 658                 xfrm_state_put(xdst->u.dst.xfrm);
 659 #ifdef CONFIG_XFRM_SUB_POLICY
 660         kfree(xdst->origin);
 661         xdst->origin = NULL;
 662         kfree(xdst->partner);
 663         xdst->partner = NULL;
 664 #endif
 665 }
 666
 667 extern void xfrm_dst_ifdown(struct dst_entry *dst, struct net_device *dev);
 668
 669 struct sec_path
 670 {
 671         atomic_t                refcnt;
 672         int                     len;
 673         struct xfrm_state       *xvec[XFRM_MAX_DEPTH];
 674 };
 675
 676 static inline struct sec_path *
 677 secpath_get(struct sec_path *sp)
 678 {
 679         if (sp)
 680                 atomic_inc(&sp->refcnt);
 681         return sp;
 682 }
 683
 684 extern void __secpath_destroy(struct sec_path *sp);
 685
 686 static inline void
 687 secpath_put(struct sec_path *sp)
 688 {
 689         if (sp && atomic_dec_and_test(&sp->refcnt))
 690                 __secpath_destroy(sp);
 691 }
 692
 693 extern struct sec_path *secpath_dup(struct sec_path *src);
 694
 695 static inline void
 696 secpath_reset(struct sk_buff *skb)
 697 {
 698 #ifdef CONFIG_XFRM
 699         secpath_put(skb->sp);
 700         skb->sp = NULL;
 701 #endif
 702 }
 703
 704 static inline int
 705 xfrm_addr_any(xfrm_address_t *addr, unsigned short family)
 706 {
 707         switch (family) {
 708         case AF_INET:
 709                 return addr->a4 == 0;
 710         case AF_INET6:
 711                 return ipv6_addr_any((struct in6_addr *)&addr->a6);
 712         }
 713         return 0;
 714 }
 715
 716 static inline int
 717 __xfrm4_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 718 {
 719         return  (tmpl->saddr.a4 &&
 720                  tmpl->saddr.a4 != x->props.saddr.a4);
 721 }
 722
 723 static inline int
 724 __xfrm6_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x)
 725 {
 726         return  (!ipv6_addr_any((struct in6_addr*)&tmpl->saddr) &&
 727                  ipv6_addr_cmp((struct in6_addr *)&tmpl->saddr, (struct in6_addr*)&x->props.saddr));
 728 }
 729
 730 static inline int
 731 xfrm_state_addr_cmp(struct xfrm_tmpl *tmpl, struct xfrm_state *x, unsigned short family)
 732 {
 733         switch (family) {
 734         case AF_INET:
 735                 return __xfrm4_state_addr_cmp(tmpl, x);
 736         case AF_INET6:
 737                 return __xfrm6_state_addr_cmp(tmpl, x);
 738         }
 739         return !0;
 740 }
 741
 742 #ifdef CONFIG_XFRM
 743
 744 extern int __xfrm_policy_check(struct sock *, int dir, struct sk_buff *skb, unsigned short family);
 745
 746 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 747 {
 748         if (sk && sk->sk_policy[XFRM_POLICY_IN])
 749                 return __xfrm_policy_check(sk, dir, skb, family);
 750
 751         return  (!xfrm_policy_count[dir] && !skb->sp) ||
 752                 (skb->dst->flags & DST_NOPOLICY) ||
 753                 __xfrm_policy_check(sk, dir, skb, family);
 754 }
 755
 756 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 757 {
 758         return xfrm_policy_check(sk, dir, skb, AF_INET);
 759 }
 760
 761 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 762 {
 763         return xfrm_policy_check(sk, dir, skb, AF_INET6);
 764 }
 765
 766 extern int xfrm_decode_session(struct sk_buff *skb, struct flowi *fl, unsigned short family);
 767 extern int __xfrm_route_forward(struct sk_buff *skb, unsigned short family);
 768
 769 static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
 770 {
 771         return  !xfrm_policy_count[XFRM_POLICY_OUT] ||
 772                 (skb->dst->flags & DST_NOXFRM) ||
 773                 __xfrm_route_forward(skb, family);
 774 }
 775
 776 static inline int xfrm4_route_forward(struct sk_buff *skb)
 777 {
 778         return xfrm_route_forward(skb, AF_INET);
 779 }
 780
 781 static inline int xfrm6_route_forward(struct sk_buff *skb)
 782 {
 783         return xfrm_route_forward(skb, AF_INET6);
 784 }
 785
 786 extern int __xfrm_sk_clone_policy(struct sock *sk);
 787
 788 static inline int xfrm_sk_clone_policy(struct sock *sk)
 789 {
 790         if (unlikely(sk->sk_policy[0] || sk->sk_policy[1]))
 791                 return __xfrm_sk_clone_policy(sk);
 792         return 0;
 793 }
 794
 795 extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
 796
 797 static inline void xfrm_sk_free_policy(struct sock *sk)
 798 {
 799         if (unlikely(sk->sk_policy[0] != NULL)) {
 800                 xfrm_policy_delete(sk->sk_policy[0], XFRM_POLICY_MAX);
 801                 sk->sk_policy[0] = NULL;
 802         }
 803         if (unlikely(sk->sk_policy[1] != NULL)) {
 804                 xfrm_policy_delete(sk->sk_policy[1], XFRM_POLICY_MAX+1);
 805                 sk->sk_policy[1] = NULL;
 806         }
 807 }
 808
 809 #else
 810
 811 static inline void xfrm_sk_free_policy(struct sock *sk) {}
 812 static inline int xfrm_sk_clone_policy(struct sock *sk) { return 0; }
 813 static inline int xfrm6_route_forward(struct sk_buff *skb) { return 1; }
 814 static inline int xfrm4_route_forward(struct sk_buff *skb) { return 1; }
 815 static inline int xfrm6_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 816 {
 817         return 1;
 818 }
 819 static inline int xfrm4_policy_check(struct sock *sk, int dir, struct sk_buff *skb)
 820 {
 821         return 1;
 822 }
 823 static inline int xfrm_policy_check(struct sock *sk, int dir, struct sk_buff *skb, unsigned short family)
 824 {
 825         return 1;
 826 }
 827 #endif
 828
 829 static __inline__
 830 xfrm_address_t *xfrm_flowi_daddr(struct flowi *fl, unsigned short family)
 831 {
 832         switch (family){
 833         case AF_INET:
 834                 return (xfrm_address_t *)&fl->fl4_dst;
 835         case AF_INET6:
 836                 return (xfrm_address_t *)&fl->fl6_dst;
 837         }
 838         return NULL;
 839 }
 840
 841 static __inline__
 842 xfrm_address_t *xfrm_flowi_saddr(struct flowi *fl, unsigned short family)
 843 {
 844         switch (family){
 845         case AF_INET:
 846                 return (xfrm_address_t *)&fl->fl4_src;
 847         case AF_INET6:
 848                 return (xfrm_address_t *)&fl->fl6_src;
 849         }
 850         return NULL;
 851 }
 852
 853 static __inline__ int
 854 __xfrm4_state_addr_check(struct xfrm_state *x,
 855                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 856 {
 857         if (daddr->a4 == x->id.daddr.a4 &&
 858             (saddr->a4 == x->props.saddr.a4 || !saddr->a4 || !x->props.saddr.a4))
 859                 return 1;
 860         return 0;
 861 }
 862
 863 static __inline__ int
 864 __xfrm6_state_addr_check(struct xfrm_state *x,
 865                          xfrm_address_t *daddr, xfrm_address_t *saddr)
 866 {
 867         if (!ipv6_addr_cmp((struct in6_addr *)daddr, (struct in6_addr *)&x->id.daddr) &&
 868             (!ipv6_addr_cmp((struct in6_addr *)saddr, (struct in6_addr *)&x->props.saddr)||
 869              ipv6_addr_any((struct in6_addr *)saddr) ||
 870              ipv6_addr_any((struct in6_addr *)&x->props.saddr)))
 871                 return 1;
 872         return 0;
 873 }
 874
 875 static __inline__ int
 876 xfrm_state_addr_check(struct xfrm_state *x,
 877                       xfrm_address_t *daddr, xfrm_address_t *saddr,
 878                       unsigned short family)
 879 {
 880         switch (family) {
 881         case AF_INET:
 882                 return __xfrm4_state_addr_check(x, daddr, saddr);
 883         case AF_INET6:
 884                 return __xfrm6_state_addr_check(x, daddr, saddr);
 885         }
 886         return 0;
 887 }
 888
 889 static __inline__ int
 890 xfrm_state_addr_flow_check(struct xfrm_state *x, struct flowi *fl,
 891                            unsigned short family)
 892 {
 893         switch (family) {
 894         case AF_INET:
 895                 return __xfrm4_state_addr_check(x,
 896                                                 (xfrm_address_t *)&fl->fl4_dst,
 897                                                 (xfrm_address_t *)&fl->fl4_src);
 898         case AF_INET6:
 899                 return __xfrm6_state_addr_check(x,
 900                                                 (xfrm_address_t *)&fl->fl6_dst,
 901                                                 (xfrm_address_t *)&fl->fl6_src);
 902         }
 903         return 0;
 904 }
 905
 906 static inline int xfrm_state_kern(struct xfrm_state *x)
 907 {
 908         return atomic_read(&x->tunnel_users);
 909 }
 910
 911 static inline int xfrm_id_proto_match(u8 proto, u8 userproto)
 912 {
 913         return (!userproto || proto == userproto ||
 914                 (userproto == IPSEC_PROTO_ANY && (proto == IPPROTO_AH ||
 915                                                   proto == IPPROTO_ESP ||
 916                                                   proto == IPPROTO_COMP)));
 917 }
 918
 919 /*
 920  * xfrm algorithm information
 921  */
 922 struct xfrm_algo_auth_info {
 923         u16 icv_truncbits;
 924         u16 icv_fullbits;
 925 };
 926
 927 struct xfrm_algo_encr_info {
 928         u16 blockbits;
 929         u16 defkeybits;
 930 };
 931
 932 struct xfrm_algo_comp_info {
 933         u16 threshold;
 934 };
 935
 936 struct xfrm_algo_desc {
 937         char *name;
 938         char *compat;
 939         u8 available:1;
 940         union {
 941                 struct xfrm_algo_auth_info auth;
 942                 struct xfrm_algo_encr_info encr;
 943                 struct xfrm_algo_comp_info comp;
 944         } uinfo;
 945         struct sadb_alg desc;
 946 };
 947
 948 /* XFRM tunnel handlers.  */
 949 struct xfrm_tunnel {
 950         int (*handler)(struct sk_buff *skb);
 951         int (*err_handler)(struct sk_buff *skb, __u32 info);
 952
 953         struct xfrm_tunnel *next;
 954         int priority;
 955 };
 956
 957 struct xfrm6_tunnel {
 958         int (*handler)(struct sk_buff *skb);
 959         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
 960                            int type, int code, int offset, __be32 info);
 961         struct xfrm6_tunnel *next;
 962         int priority;
 963 };
 964
 965 extern void xfrm_init(void);
 966 extern void xfrm4_init(void);
 967 extern void xfrm6_init(void);
 968 extern void xfrm6_fini(void);
 969 extern void xfrm_state_init(void);
 970 extern void xfrm4_state_init(void);
 971 extern void xfrm6_state_init(void);
 972 extern void xfrm6_state_fini(void);
 973
 974 extern int xfrm_state_walk(u8 proto, int (*func)(struct xfrm_state *, int, void*), void *);
 975 extern struct xfrm_state *xfrm_state_alloc(void);
 976 extern struct xfrm_state *xfrm_state_find(xfrm_address_t *daddr, xfrm_address_t *saddr,
 977                                           struct flowi *fl, struct xfrm_tmpl *tmpl,
 978                                           struct xfrm_policy *pol, int *err,
 979                                           unsigned short family);
 980 extern struct xfrm_state * xfrm_stateonly_find(xfrm_address_t *daddr,
 981                                                xfrm_address_t *saddr,
 982                                                unsigned short family,
 983                                                u8 mode, u8 proto, u32 reqid);
 984 extern int xfrm_state_check_expire(struct xfrm_state *x);
 985 extern void xfrm_state_insert(struct xfrm_state *x);
 986 extern int xfrm_state_add(struct xfrm_state *x);
 987 extern int xfrm_state_update(struct xfrm_state *x);
 988 extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, __be32 spi, u8 proto, unsigned short family);
 989 extern struct xfrm_state *xfrm_state_lookup_byaddr(xfrm_address_t *daddr, xfrm_address_t *saddr, u8 proto, unsigned short family);
 990 #ifdef CONFIG_XFRM_SUB_POLICY
 991 extern int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
 992                           int n, unsigned short family);
 993 extern int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
 994                            int n, unsigned short family);
 995 #else
 996 static inline int xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src,
 997                                  int n, unsigned short family)
 998 {
 999         return -ENOSYS;
1000 }
1001
1002 static inline int xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src,
1003                                   int n, unsigned short family)
1004 {
1005         return -ENOSYS;
1006 }
1007 #endif
1008
1009 struct xfrmk_sadinfo {
1010         u32 sadhcnt; /* current hash bkts */
1011         u32 sadhmcnt; /* max allowed hash bkts */
1012         u32 sadcnt; /* current running count */
1013 };
1014
1015 struct xfrmk_spdinfo {
1016         u32 incnt;
1017         u32 outcnt;
1018         u32 fwdcnt;
1019         u32 inscnt;
1020         u32 outscnt;
1021         u32 fwdscnt;
1022         u32 spdhcnt;
1023         u32 spdhmcnt;
1024 };
1025
1026 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
1027 extern int xfrm_state_delete(struct xfrm_state *x);
1028 extern int xfrm_state_flush(u8 proto, struct xfrm_audit *audit_info);
1029 extern void xfrm_sad_getinfo(struct xfrmk_sadinfo *si);
1030 extern void xfrm_spd_getinfo(struct xfrmk_spdinfo *si);
1031 extern int xfrm_replay_check(struct xfrm_state *x, __be32 seq);
1032 extern void xfrm_replay_advance(struct xfrm_state *x, __be32 seq);
1033 extern void xfrm_replay_notify(struct xfrm_state *x, int event);
1034 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
1035 extern int xfrm_init_state(struct xfrm_state *x);
1036 extern int xfrm_output(struct sk_buff *skb);
1037 extern int xfrm4_rcv(struct sk_buff *skb);
1038 extern int xfrm4_output(struct sk_buff *skb);
1039 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler, unsigned short family);
1040 extern int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler, unsigned short family);
1041 extern int xfrm6_rcv_spi(struct sk_buff *skb, __be32 spi);
1042 extern int xfrm6_rcv(struct sk_buff **pskb);
1043 extern int xfrm6_input_addr(struct sk_buff *skb, xfrm_address_t *daddr,
1044                             xfrm_address_t *saddr, u8 proto);
1045 extern int xfrm6_tunnel_register(struct xfrm6_tunnel *handler, unsigned short family);
1046 extern int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler, unsigned short family);
1047 extern __be32 xfrm6_tunnel_alloc_spi(xfrm_address_t *saddr);
1048 extern void xfrm6_tunnel_free_spi(xfrm_address_t *saddr);
1049 extern __be32 xfrm6_tunnel_spi_lookup(xfrm_address_t *saddr);
1050 extern int xfrm6_output(struct sk_buff *skb);
1051 extern int xfrm6_find_1stfragopt(struct xfrm_state *x, struct sk_buff *skb,
1052                                  u8 **prevhdr);
1053
1054 #ifdef CONFIG_XFRM
1055 extern int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb);
1056 extern int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen);
1057 extern int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family);
1058 #else
1059 static inline int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
1060 {
1061         return -ENOPROTOOPT;
1062 }
1063
1064 static inline int xfrm4_udp_encap_rcv(struct sock *sk, struct sk_buff *skb)
1065 {
1066         /* should not happen */
1067         kfree_skb(skb);
1068         return 0;
1069 }
1070
1071 static inline int xfrm_dst_lookup(struct xfrm_dst **dst, struct flowi *fl, unsigned short family)
1072 {
1073         return -EINVAL;
1074 }
1075 #endif
1076
1077 struct xfrm_policy *xfrm_policy_alloc(gfp_t gfp);
1078 extern int xfrm_policy_walk(u8 type, int (*func)(struct xfrm_policy *, int, int, void*), void *);
1079 int xfrm_policy_insert(int dir, struct xfrm_policy *policy, int excl);
1080 struct xfrm_policy *xfrm_policy_bysel_ctx(u8 type, int dir,
1081                                           struct xfrm_selector *sel,
1082                                           struct xfrm_sec_ctx *ctx, int delete,
1083                                           int *err);
1084 struct xfrm_policy *xfrm_policy_byid(u8, int dir, u32 id, int delete, int *err);
1085 int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info);
1086 u32 xfrm_get_acqseq(void);
1087 void xfrm_alloc_spi(struct xfrm_state *x, __be32 minspi, __be32 maxspi);
1088 struct xfrm_state * xfrm_find_acq(u8 mode, u32 reqid, u8 proto,
1089                                   xfrm_address_t *daddr, xfrm_address_t *saddr,
1090                                   int create, unsigned short family);
1091 extern int xfrm_policy_flush(u8 type, struct xfrm_audit *audit_info);
1092 extern int xfrm_sk_policy_insert(struct sock *sk, int dir, struct xfrm_policy *pol);
1093 extern int xfrm_bundle_ok(struct xfrm_policy *pol, struct xfrm_dst *xdst,
1094                           struct flowi *fl, int family, int strict);
1095 extern void xfrm_init_pmtu(struct dst_entry *dst);
1096
1097 #ifdef CONFIG_XFRM_MIGRATE
1098 extern int km_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
1099                       struct xfrm_migrate *m, int num_bundles);
1100 extern struct xfrm_state * xfrm_migrate_state_find(struct xfrm_migrate *m);
1101 extern struct xfrm_state * xfrm_state_migrate(struct xfrm_state *x,
1102                                               struct xfrm_migrate *m);
1103 extern int xfrm_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
1104                         struct xfrm_migrate *m, int num_bundles);
1105 #endif
1106
1107 extern wait_queue_head_t km_waitq;
1108 extern int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport);
1109 extern void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 pid);
1110 extern int km_report(u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr);
1111
1112 extern void xfrm_input_init(void);
1113 extern int xfrm_parse_spi(struct sk_buff *skb, u8 nexthdr, __be32 *spi, __be32 *seq);
1114
1115 extern void xfrm_probe_algs(void);
1116 extern int xfrm_count_auth_supported(void);
1117 extern int xfrm_count_enc_supported(void);
1118 extern struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx);
1119 extern struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx);
1120 extern struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id);
1121 extern struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id);
1122 extern struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id);
1123 extern struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe);
1124 extern struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe);
1125 extern struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe);
1126
1127 struct hash_desc;
1128 struct scatterlist;
1129 typedef int (icv_update_fn_t)(struct hash_desc *, struct scatterlist *,
1130                               unsigned int);
1131
1132 extern int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *tfm,
1133                         int offset, int len, icv_update_fn_t icv_update);
1134
1135 static inline int xfrm_addr_cmp(xfrm_address_t *a, xfrm_address_t *b,
1136                                 int family)
1137 {
1138         switch (family) {
1139         default:
1140         case AF_INET:
1141                 return (__force __u32)a->a4 - (__force __u32)b->a4;
1142         case AF_INET6:
1143                 return ipv6_addr_cmp((struct in6_addr *)a,
1144                                      (struct in6_addr *)b);
1145         }
1146 }
1147
1148 static inline int xfrm_policy_id2dir(u32 index)
1149 {
1150         return index & 7;
1151 }
1152
1153 static inline int xfrm_aevent_is_on(void)
1154 {
1155         struct sock *nlsk;
1156         int ret = 0;
1157
1158         rcu_read_lock();
1159         nlsk = rcu_dereference(xfrm_nl);
1160         if (nlsk)
1161                 ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS);
1162         rcu_read_unlock();
1163         return ret;
1164 }
1165
1166 static inline void xfrm_aevent_doreplay(struct xfrm_state *x)
1167 {
1168         if (xfrm_aevent_is_on())
1169                 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
1170 }
1171
1172 #ifdef CONFIG_XFRM_MIGRATE
1173 static inline struct xfrm_algo *xfrm_algo_clone(struct xfrm_algo *orig)
1174 {
1175         return (struct xfrm_algo *)kmemdup(orig, sizeof(*orig) + orig->alg_key_len, GFP_KERNEL);
1176 }
1177
1178 static inline void xfrm_states_put(struct xfrm_state **states, int n)
1179 {
1180         int i;
1181         for (i = 0; i < n; i++)
1182                 xfrm_state_put(*(states + i));
1183 }
1184
1185 static inline void xfrm_states_delete(struct xfrm_state **states, int n)
1186 {
1187         int i;
1188         for (i = 0; i < n; i++)
1189                 xfrm_state_delete(*(states + i));
1190 }
1191 #endif
1192
1193 #endif  /* _NET_XFRM_H */