net/xfrm/xfrm_algo.c

   1 /*
   2  * xfrm algorithm interface
   3  *
   4  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/pfkeyv2.h>
  15 #include <linux/crypto.h>
  16 #include <linux/scatterlist.h>
  17 #include <net/xfrm.h>
  18 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
  19 #include <net/ah.h>
  20 #endif
  21 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
  22 #include <net/esp.h>
  23 #endif
  24
  25 /*
  26  * Algorithms supported by IPsec.  These entries contain properties which
  27  * are used in key negotiation and xfrm processing, and are used to verify
  28  * that instantiated crypto transforms have correct parameters for IPsec
  29  * purposes.
  30  */
  31 static struct xfrm_algo_desc aead_list[] = {
  32 {
  33         .name = "rfc4106(gcm(aes))",
  34
  35         .uinfo = {
  36                 .aead = {
  37                         .icv_truncbits = 64,
  38                 }
  39         },
  40
  41         .desc = {
  42                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV8,
  43                 .sadb_alg_ivlen = 8,
  44                 .sadb_alg_minbits = 128,
  45                 .sadb_alg_maxbits = 256
  46         }
  47 },
  48 {
  49         .name = "rfc4106(gcm(aes))",
  50
  51         .uinfo = {
  52                 .aead = {
  53                         .icv_truncbits = 96,
  54                 }
  55         },
  56
  57         .desc = {
  58                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV12,
  59                 .sadb_alg_ivlen = 8,
  60                 .sadb_alg_minbits = 128,
  61                 .sadb_alg_maxbits = 256
  62         }
  63 },
  64 {
  65         .name = "rfc4106(gcm(aes))",
  66
  67         .uinfo = {
  68                 .aead = {
  69                         .icv_truncbits = 128,
  70                 }
  71         },
  72
  73         .desc = {
  74                 .sadb_alg_id = SADB_X_EALG_AES_GCM_ICV16,
  75                 .sadb_alg_ivlen = 8,
  76                 .sadb_alg_minbits = 128,
  77                 .sadb_alg_maxbits = 256
  78         }
  79 },
  80 {
  81         .name = "rfc4309(ccm(aes))",
  82
  83         .uinfo = {
  84                 .aead = {
  85                         .icv_truncbits = 64,
  86                 }
  87         },
  88
  89         .desc = {
  90                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV8,
  91                 .sadb_alg_ivlen = 8,
  92                 .sadb_alg_minbits = 128,
  93                 .sadb_alg_maxbits = 256
  94         }
  95 },
  96 {
  97         .name = "rfc4309(ccm(aes))",
  98
  99         .uinfo = {
 100                 .aead = {
 101                         .icv_truncbits = 96,
 102                 }
 103         },
 104
 105         .desc = {
 106                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV12,
 107                 .sadb_alg_ivlen = 8,
 108                 .sadb_alg_minbits = 128,
 109                 .sadb_alg_maxbits = 256
 110         }
 111 },
 112 {
 113         .name = "rfc4309(ccm(aes))",
 114
 115         .uinfo = {
 116                 .aead = {
 117                         .icv_truncbits = 128,
 118                 }
 119         },
 120
 121         .desc = {
 122                 .sadb_alg_id = SADB_X_EALG_AES_CCM_ICV16,
 123                 .sadb_alg_ivlen = 8,
 124                 .sadb_alg_minbits = 128,
 125                 .sadb_alg_maxbits = 256
 126         }
 127 },
 128 };
 129
 130 static struct xfrm_algo_desc aalg_list[] = {
 131 {
 132         .name = "hmac(digest_null)",
 133         .compat = "digest_null",
 134
 135         .uinfo = {
 136                 .auth = {
 137                         .icv_truncbits = 0,
 138                         .icv_fullbits = 0,
 139                 }
 140         },
 141
 142         .desc = {
 143                 .sadb_alg_id = SADB_X_AALG_NULL,
 144                 .sadb_alg_ivlen = 0,
 145                 .sadb_alg_minbits = 0,
 146                 .sadb_alg_maxbits = 0
 147         }
 148 },
 149 {
 150         .name = "hmac(md5)",
 151         .compat = "md5",
 152
 153         .uinfo = {
 154                 .auth = {
 155                         .icv_truncbits = 96,
 156                         .icv_fullbits = 128,
 157                 }
 158         },
 159
 160         .desc = {
 161                 .sadb_alg_id = SADB_AALG_MD5HMAC,
 162                 .sadb_alg_ivlen = 0,
 163                 .sadb_alg_minbits = 128,
 164                 .sadb_alg_maxbits = 128
 165         }
 166 },
 167 {
 168         .name = "hmac(sha1)",
 169         .compat = "sha1",
 170
 171         .uinfo = {
 172                 .auth = {
 173                         .icv_truncbits = 96,
 174                         .icv_fullbits = 160,
 175                 }
 176         },
 177
 178         .desc = {
 179                 .sadb_alg_id = SADB_AALG_SHA1HMAC,
 180                 .sadb_alg_ivlen = 0,
 181                 .sadb_alg_minbits = 160,
 182                 .sadb_alg_maxbits = 160
 183         }
 184 },
 185 {
 186         .name = "hmac(sha256)",
 187         .compat = "sha256",
 188
 189         .uinfo = {
 190                 .auth = {
 191                         .icv_truncbits = 96,
 192                         .icv_fullbits = 256,
 193                 }
 194         },
 195
 196         .desc = {
 197                 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
 198                 .sadb_alg_ivlen = 0,
 199                 .sadb_alg_minbits = 256,
 200                 .sadb_alg_maxbits = 256
 201         }
 202 },
 203 {
 204         .name = "hmac(ripemd160)",
 205         .compat = "ripemd160",
 206
 207         .uinfo = {
 208                 .auth = {
 209                         .icv_truncbits = 96,
 210                         .icv_fullbits = 160,
 211                 }
 212         },
 213
 214         .desc = {
 215                 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
 216                 .sadb_alg_ivlen = 0,
 217                 .sadb_alg_minbits = 160,
 218                 .sadb_alg_maxbits = 160
 219         }
 220 },
 221 {
 222         .name = "xcbc(aes)",
 223
 224         .uinfo = {
 225                 .auth = {
 226                         .icv_truncbits = 96,
 227                         .icv_fullbits = 128,
 228                 }
 229         },
 230
 231         .desc = {
 232                 .sadb_alg_id = SADB_X_AALG_AES_XCBC_MAC,
 233                 .sadb_alg_ivlen = 0,
 234                 .sadb_alg_minbits = 128,
 235                 .sadb_alg_maxbits = 128
 236         }
 237 },
 238 };
 239
 240 static struct xfrm_algo_desc ealg_list[] = {
 241 {
 242         .name = "ecb(cipher_null)",
 243         .compat = "cipher_null",
 244
 245         .uinfo = {
 246                 .encr = {
 247                         .blockbits = 8,
 248                         .defkeybits = 0,
 249                 }
 250         },
 251
 252         .desc = {
 253                 .sadb_alg_id =  SADB_EALG_NULL,
 254                 .sadb_alg_ivlen = 0,
 255                 .sadb_alg_minbits = 0,
 256                 .sadb_alg_maxbits = 0
 257         }
 258 },
 259 {
 260         .name = "cbc(des)",
 261         .compat = "des",
 262
 263         .uinfo = {
 264                 .encr = {
 265                         .blockbits = 64,
 266                         .defkeybits = 64,
 267                 }
 268         },
 269
 270         .desc = {
 271                 .sadb_alg_id = SADB_EALG_DESCBC,
 272                 .sadb_alg_ivlen = 8,
 273                 .sadb_alg_minbits = 64,
 274                 .sadb_alg_maxbits = 64
 275         }
 276 },
 277 {
 278         .name = "cbc(des3_ede)",
 279         .compat = "des3_ede",
 280
 281         .uinfo = {
 282                 .encr = {
 283                         .blockbits = 64,
 284                         .defkeybits = 192,
 285                 }
 286         },
 287
 288         .desc = {
 289                 .sadb_alg_id = SADB_EALG_3DESCBC,
 290                 .sadb_alg_ivlen = 8,
 291                 .sadb_alg_minbits = 192,
 292                 .sadb_alg_maxbits = 192
 293         }
 294 },
 295 {
 296         .name = "cbc(cast128)",
 297         .compat = "cast128",
 298
 299         .uinfo = {
 300                 .encr = {
 301                         .blockbits = 64,
 302                         .defkeybits = 128,
 303                 }
 304         },
 305
 306         .desc = {
 307                 .sadb_alg_id = SADB_X_EALG_CASTCBC,
 308                 .sadb_alg_ivlen = 8,
 309                 .sadb_alg_minbits = 40,
 310                 .sadb_alg_maxbits = 128
 311         }
 312 },
 313 {
 314         .name = "cbc(blowfish)",
 315         .compat = "blowfish",
 316
 317         .uinfo = {
 318                 .encr = {
 319                         .blockbits = 64,
 320                         .defkeybits = 128,
 321                 }
 322         },
 323
 324         .desc = {
 325                 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
 326                 .sadb_alg_ivlen = 8,
 327                 .sadb_alg_minbits = 40,
 328                 .sadb_alg_maxbits = 448
 329         }
 330 },
 331 {
 332         .name = "cbc(aes)",
 333         .compat = "aes",
 334
 335         .uinfo = {
 336                 .encr = {
 337                         .blockbits = 128,
 338                         .defkeybits = 128,
 339                 }
 340         },
 341
 342         .desc = {
 343                 .sadb_alg_id = SADB_X_EALG_AESCBC,
 344                 .sadb_alg_ivlen = 8,
 345                 .sadb_alg_minbits = 128,
 346                 .sadb_alg_maxbits = 256
 347         }
 348 },
 349 {
 350         .name = "cbc(serpent)",
 351         .compat = "serpent",
 352
 353         .uinfo = {
 354                 .encr = {
 355                         .blockbits = 128,
 356                         .defkeybits = 128,
 357                 }
 358         },
 359
 360         .desc = {
 361                 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
 362                 .sadb_alg_ivlen = 8,
 363                 .sadb_alg_minbits = 128,
 364                 .sadb_alg_maxbits = 256,
 365         }
 366 },
 367 {
 368         .name = "cbc(camellia)",
 369
 370         .uinfo = {
 371                 .encr = {
 372                         .blockbits = 128,
 373                         .defkeybits = 128,
 374                 }
 375         },
 376
 377         .desc = {
 378                 .sadb_alg_id = SADB_X_EALG_CAMELLIACBC,
 379                 .sadb_alg_ivlen = 8,
 380                 .sadb_alg_minbits = 128,
 381                 .sadb_alg_maxbits = 256
 382         }
 383 },
 384 {
 385         .name = "cbc(twofish)",
 386         .compat = "twofish",
 387
 388         .uinfo = {
 389                 .encr = {
 390                         .blockbits = 128,
 391                         .defkeybits = 128,
 392                 }
 393         },
 394
 395         .desc = {
 396                 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
 397                 .sadb_alg_ivlen = 8,
 398                 .sadb_alg_minbits = 128,
 399                 .sadb_alg_maxbits = 256
 400         }
 401 },
 402 };
 403
 404 static struct xfrm_algo_desc calg_list[] = {
 405 {
 406         .name = "deflate",
 407         .uinfo = {
 408                 .comp = {
 409                         .threshold = 90,
 410                 }
 411         },
 412         .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
 413 },
 414 {
 415         .name = "lzs",
 416         .uinfo = {
 417                 .comp = {
 418                         .threshold = 90,
 419                 }
 420         },
 421         .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
 422 },
 423 {
 424         .name = "lzjh",
 425         .uinfo = {
 426                 .comp = {
 427                         .threshold = 50,
 428                 }
 429         },
 430         .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
 431 },
 432 };
 433
 434 static inline int aead_entries(void)
 435 {
 436         return ARRAY_SIZE(aead_list);
 437 }
 438
 439 static inline int aalg_entries(void)
 440 {
 441         return ARRAY_SIZE(aalg_list);
 442 }
 443
 444 static inline int ealg_entries(void)
 445 {
 446         return ARRAY_SIZE(ealg_list);
 447 }
 448
 449 static inline int calg_entries(void)
 450 {
 451         return ARRAY_SIZE(calg_list);
 452 }
 453
 454 struct xfrm_algo_list {
 455         struct xfrm_algo_desc *algs;
 456         int entries;
 457         u32 type;
 458         u32 mask;
 459 };
 460
 461 static const struct xfrm_algo_list xfrm_aead_list = {
 462         .algs = aead_list,
 463         .entries = ARRAY_SIZE(aead_list),
 464         .type = CRYPTO_ALG_TYPE_AEAD,
 465         .mask = CRYPTO_ALG_TYPE_MASK,
 466 };
 467
 468 static const struct xfrm_algo_list xfrm_aalg_list = {
 469         .algs = aalg_list,
 470         .entries = ARRAY_SIZE(aalg_list),
 471         .type = CRYPTO_ALG_TYPE_HASH,
 472         .mask = CRYPTO_ALG_TYPE_HASH_MASK,
 473 };
 474
 475 static const struct xfrm_algo_list xfrm_ealg_list = {
 476         .algs = ealg_list,
 477         .entries = ARRAY_SIZE(ealg_list),
 478         .type = CRYPTO_ALG_TYPE_BLKCIPHER,
 479         .mask = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
 480 };
 481
 482 static const struct xfrm_algo_list xfrm_calg_list = {
 483         .algs = calg_list,
 484         .entries = ARRAY_SIZE(calg_list),
 485         .type = CRYPTO_ALG_TYPE_COMPRESS,
 486         .mask = CRYPTO_ALG_TYPE_MASK,
 487 };
 488
 489 static struct xfrm_algo_desc *xfrm_find_algo(
 490         const struct xfrm_algo_list *algo_list,
 491         int match(const struct xfrm_algo_desc *entry, const void *data),
 492         const void *data, int probe)
 493 {
 494         struct xfrm_algo_desc *list = algo_list->algs;
 495         int i, status;
 496
 497         for (i = 0; i < algo_list->entries; i++) {
 498                 if (!match(list + i, data))
 499                         continue;
 500
 501                 if (list[i].available)
 502                         return &list[i];
 503
 504                 if (!probe)
 505                         break;
 506
 507                 status = crypto_has_alg(list[i].name, algo_list->type,
 508                                         algo_list->mask);
 509                 if (!status)
 510                         break;
 511
 512                 list[i].available = status;
 513                 return &list[i];
 514         }
 515         return NULL;
 516 }
 517
 518 static int xfrm_alg_id_match(const struct xfrm_algo_desc *entry,
 519                              const void *data)
 520 {
 521         return entry->desc.sadb_alg_id == (unsigned long)data;
 522 }
 523
 524 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
 525 {
 526         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_id_match,
 527                               (void *)(unsigned long)alg_id, 1);
 528 }
 529 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
 530
 531 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
 532 {
 533         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_id_match,
 534                               (void *)(unsigned long)alg_id, 1);
 535 }
 536 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
 537
 538 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
 539 {
 540         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_id_match,
 541                               (void *)(unsigned long)alg_id, 1);
 542 }
 543 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
 544
 545 static int xfrm_alg_name_match(const struct xfrm_algo_desc *entry,
 546                                const void *data)
 547 {
 548         const char *name = data;
 549
 550         return name && (!strcmp(name, entry->name) ||
 551                         (entry->compat && !strcmp(name, entry->compat)));
 552 }
 553
 554 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
 555 {
 556         return xfrm_find_algo(&xfrm_aalg_list, xfrm_alg_name_match, name,
 557                               probe);
 558 }
 559 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
 560
 561 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
 562 {
 563         return xfrm_find_algo(&xfrm_ealg_list, xfrm_alg_name_match, name,
 564                               probe);
 565 }
 566 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
 567
 568 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
 569 {
 570         return xfrm_find_algo(&xfrm_calg_list, xfrm_alg_name_match, name,
 571                               probe);
 572 }
 573 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
 574
 575 struct xfrm_aead_name {
 576         const char *name;
 577         int icvbits;
 578 };
 579
 580 static int xfrm_aead_name_match(const struct xfrm_algo_desc *entry,
 581                                 const void *data)
 582 {
 583         const struct xfrm_aead_name *aead = data;
 584         const char *name = aead->name;
 585
 586         return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
 587                !strcmp(name, entry->name);
 588 }
 589
 590 struct xfrm_algo_desc *xfrm_aead_get_byname(char *name, int icv_len, int probe)
 591 {
 592         struct xfrm_aead_name data = {
 593                 .name = name,
 594                 .icvbits = icv_len,
 595         };
 596
 597         return xfrm_find_algo(&xfrm_aead_list, xfrm_aead_name_match, &data,
 598                               probe);
 599 }
 600 EXPORT_SYMBOL_GPL(xfrm_aead_get_byname);
 601
 602 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
 603 {
 604         if (idx >= aalg_entries())
 605                 return NULL;
 606
 607         return &aalg_list[idx];
 608 }
 609 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
 610
 611 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
 612 {
 613         if (idx >= ealg_entries())
 614                 return NULL;
 615
 616         return &ealg_list[idx];
 617 }
 618 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
 619
 620 /*
 621  * Probe for the availability of crypto algorithms, and set the available
 622  * flag for any algorithms found on the system.  This is typically called by
 623  * pfkey during userspace SA add, update or register.
 624  */
 625 void xfrm_probe_algs(void)
 626 {
 627         int i, status;
 628
 629         BUG_ON(in_softirq());
 630
 631         for (i = 0; i < aalg_entries(); i++) {
 632                 status = crypto_has_hash(aalg_list[i].name, 0,
 633                                          CRYPTO_ALG_ASYNC);
 634                 if (aalg_list[i].available != status)
 635                         aalg_list[i].available = status;
 636         }
 637
 638         for (i = 0; i < ealg_entries(); i++) {
 639                 status = crypto_has_blkcipher(ealg_list[i].name, 0,
 640                                               CRYPTO_ALG_ASYNC);
 641                 if (ealg_list[i].available != status)
 642                         ealg_list[i].available = status;
 643         }
 644
 645         for (i = 0; i < calg_entries(); i++) {
 646                 status = crypto_has_comp(calg_list[i].name, 0,
 647                                          CRYPTO_ALG_ASYNC);
 648                 if (calg_list[i].available != status)
 649                         calg_list[i].available = status;
 650         }
 651 }
 652 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
 653
 654 int xfrm_count_auth_supported(void)
 655 {
 656         int i, n;
 657
 658         for (i = 0, n = 0; i < aalg_entries(); i++)
 659                 if (aalg_list[i].available)
 660                         n++;
 661         return n;
 662 }
 663 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
 664
 665 int xfrm_count_enc_supported(void)
 666 {
 667         int i, n;
 668
 669         for (i = 0, n = 0; i < ealg_entries(); i++)
 670                 if (ealg_list[i].available)
 671                         n++;
 672         return n;
 673 }
 674 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
 675
 676 /* Move to common area: it is shared with AH. */
 677
 678 int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
 679                  int offset, int len, icv_update_fn_t icv_update)
 680 {
 681         int start = skb_headlen(skb);
 682         int i, copy = start - offset;
 683         int err;
 684         struct scatterlist sg;
 685
 686         /* Checksum header. */
 687         if (copy > 0) {
 688                 if (copy > len)
 689                         copy = len;
 690
 691                 sg_init_one(&sg, skb->data + offset, copy);
 692
 693                 err = icv_update(desc, &sg, copy);
 694                 if (unlikely(err))
 695                         return err;
 696
 697                 if ((len -= copy) == 0)
 698                         return 0;
 699                 offset += copy;
 700         }
 701
 702         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
 703                 int end;
 704
 705                 BUG_TRAP(start <= offset + len);
 706
 707                 end = start + skb_shinfo(skb)->frags[i].size;
 708                 if ((copy = end - offset) > 0) {
 709                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 710
 711                         if (copy > len)
 712                                 copy = len;
 713
 714                         sg_init_table(&sg, 1);
 715                         sg_set_page(&sg, frag->page, copy,
 716                                     frag->page_offset + offset-start);
 717
 718                         err = icv_update(desc, &sg, copy);
 719                         if (unlikely(err))
 720                                 return err;
 721
 722                         if (!(len -= copy))
 723                                 return 0;
 724                         offset += copy;
 725                 }
 726                 start = end;
 727         }
 728
 729         if (skb_shinfo(skb)->frag_list) {
 730                 struct sk_buff *list = skb_shinfo(skb)->frag_list;
 731
 732                 for (; list; list = list->next) {
 733                         int end;
 734
 735                         BUG_TRAP(start <= offset + len);
 736
 737                         end = start + list->len;
 738                         if ((copy = end - offset) > 0) {
 739                                 if (copy > len)
 740                                         copy = len;
 741                                 err = skb_icv_walk(list, desc, offset-start,
 742                                                    copy, icv_update);
 743                                 if (unlikely(err))
 744                                         return err;
 745                                 if ((len -= copy) == 0)
 746                                         return 0;
 747                                 offset += copy;
 748                         }
 749                         start = end;
 750                 }
 751         }
 752         BUG_ON(len);
 753         return 0;
 754 }
 755 EXPORT_SYMBOL_GPL(skb_icv_walk);
 756
 757 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
 758
 759 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
 760 {
 761         if (tail != skb) {
 762                 skb->data_len += len;
 763                 skb->len += len;
 764         }
 765         return skb_put(tail, len);
 766 }
 767 EXPORT_SYMBOL_GPL(pskb_put);
 768 #endif