src/plugins/ikev2/ikev2_test.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api_format.c
   4  *
   5  * Copyright (c) 2014-2016 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <vat/vat.h>
  21 #include <vlibapi/api.h>
  22 #include <vlibmemory/api.h>
  23 #include <vppinfra/error.h>
  24 #include <plugins/ikev2/ikev2.h>
  25
  26 #define __plugin_msg_base ikev2_test_main.msg_id_base
  27 #include <vlibapi/vat_helper_macros.h>
  28
  29 /* Declare message IDs */
  30 #include <vnet/format_fns.h>
  31 #include <ikev2/ikev2.api_enum.h>
  32 #include <ikev2/ikev2.api_types.h>
  33
  34 typedef struct
  35 {
  36   /* API message ID base */
  37   u16 msg_id_base;
  38   vat_main_t *vat_main;
  39 } ikev2_test_main_t;
  40
  41 ikev2_test_main_t ikev2_test_main;
  42
  43 uword
  44 unformat_ikev2_auth_method (unformat_input_t * input, va_list * args)
  45 {
  46   u32 *r = va_arg (*args, u32 *);
  47
  48   if (0);
  49 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_AUTH_METHOD_##f;
  50   foreach_ikev2_auth_method
  51 #undef _
  52     else
  53     return 0;
  54   return 1;
  55 }
  56
  57 uword
  58 unformat_ikev2_id_type (unformat_input_t * input, va_list * args)
  59 {
  60   u32 *r = va_arg (*args, u32 *);
  61
  62   if (0);
  63 #define _(v,f,s) else if (unformat (input, s)) *r = IKEV2_ID_TYPE_##f;
  64   foreach_ikev2_id_type
  65 #undef _
  66     else
  67     return 0;
  68   return 1;
  69 }
  70
  71 static int
  72 api_ikev2_plugin_get_version (vat_main_t * vam)
  73 {
  74   ikev2_test_main_t *sm = &ikev2_test_main;
  75   vl_api_ikev2_plugin_get_version_t *mp;
  76   u32 msg_size = sizeof (*mp);
  77   int ret;
  78
  79   vam->result_ready = 0;
  80   mp = vl_msg_api_alloc_as_if_client (msg_size);
  81   clib_memset (mp, 0, msg_size);
  82   mp->_vl_msg_id = ntohs (VL_API_IKEV2_PLUGIN_GET_VERSION + sm->msg_id_base);
  83   mp->client_index = vam->my_client_index;
  84
  85   /* send it... */
  86   S (mp);
  87
  88   /* Wait for a reply... */
  89   W (ret);
  90   return ret;
  91 }
  92
  93 static void vl_api_ikev2_plugin_get_version_reply_t_handler
  94   (vl_api_ikev2_plugin_get_version_reply_t * mp)
  95 {
  96   vat_main_t *vam = ikev2_test_main.vat_main;
  97   clib_warning ("IKEv2 plugin version: %d.%d", ntohl (mp->major),
  98                 ntohl (mp->minor));
  99   vam->result_ready = 1;
 100 }
 101
 102 static int
 103 api_ikev2_profile_add_del (vat_main_t * vam)
 104 {
 105   unformat_input_t *i = vam->input;
 106   vl_api_ikev2_profile_add_del_t *mp;
 107   u8 is_add = 1;
 108   u8 *name = 0;
 109   int ret;
 110
 111   const char *valid_chars = "a-zA-Z0-9_";
 112
 113   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 114     {
 115       if (unformat (i, "del"))
 116         is_add = 0;
 117       else if (unformat (i, "name %U", unformat_token, valid_chars, &name))
 118         vec_add1 (name, 0);
 119       else
 120         {
 121           errmsg ("parse error '%U'", format_unformat_error, i);
 122           return -99;
 123         }
 124     }
 125
 126   if (!vec_len (name))
 127     {
 128       errmsg ("profile name must be specified");
 129       return -99;
 130     }
 131
 132   if (vec_len (name) > 64)
 133     {
 134       errmsg ("profile name too long");
 135       return -99;
 136     }
 137
 138   M (IKEV2_PROFILE_ADD_DEL, mp);
 139
 140   clib_memcpy (mp->name, name, vec_len (name));
 141   mp->is_add = is_add;
 142   vec_free (name);
 143
 144   S (mp);
 145   W (ret);
 146   return ret;
 147 }
 148
 149 static int
 150 api_ikev2_profile_set_auth (vat_main_t * vam)
 151 {
 152   unformat_input_t *i = vam->input;
 153   vl_api_ikev2_profile_set_auth_t *mp;
 154   u8 *name = 0;
 155   u8 *data = 0;
 156   u32 auth_method = 0;
 157   u8 is_hex = 0;
 158   int ret;
 159
 160   const char *valid_chars = "a-zA-Z0-9_";
 161
 162   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 163     {
 164       if (unformat (i, "name %U", unformat_token, valid_chars, &name))
 165         vec_add1 (name, 0);
 166       else if (unformat (i, "auth_method %U",
 167                          unformat_ikev2_auth_method, &auth_method))
 168         ;
 169       else if (unformat (i, "auth_data 0x%U", unformat_hex_string, &data))
 170         is_hex = 1;
 171       else if (unformat (i, "auth_data %v", &data))
 172         ;
 173       else
 174         {
 175           errmsg ("parse error '%U'", format_unformat_error, i);
 176           return -99;
 177         }
 178     }
 179
 180   if (!vec_len (name))
 181     {
 182       errmsg ("profile name must be specified");
 183       return -99;
 184     }
 185
 186   if (vec_len (name) > 64)
 187     {
 188       errmsg ("profile name too long");
 189       return -99;
 190     }
 191
 192   if (!vec_len (data))
 193     {
 194       errmsg ("auth_data must be specified");
 195       return -99;
 196     }
 197
 198   if (!auth_method)
 199     {
 200       errmsg ("auth_method must be specified");
 201       return -99;
 202     }
 203
 204   M (IKEV2_PROFILE_SET_AUTH, mp);
 205
 206   mp->is_hex = is_hex;
 207   mp->auth_method = (u8) auth_method;
 208   mp->data_len = vec_len (data);
 209   clib_memcpy (mp->name, name, vec_len (name));
 210   clib_memcpy (mp->data, data, vec_len (data));
 211   vec_free (name);
 212   vec_free (data);
 213
 214   S (mp);
 215   W (ret);
 216   return ret;
 217 }
 218
 219 static int
 220 api_ikev2_profile_set_id (vat_main_t * vam)
 221 {
 222   unformat_input_t *i = vam->input;
 223   vl_api_ikev2_profile_set_id_t *mp;
 224   u8 *name = 0;
 225   u8 *data = 0;
 226   u8 is_local = 0;
 227   u32 id_type = 0;
 228   ip4_address_t ip4;
 229   int ret;
 230
 231   const char *valid_chars = "a-zA-Z0-9_";
 232
 233   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 234     {
 235       if (unformat (i, "name %U", unformat_token, valid_chars, &name))
 236         vec_add1 (name, 0);
 237       else if (unformat (i, "id_type %U", unformat_ikev2_id_type, &id_type))
 238         ;
 239       else if (unformat (i, "id_data %U", unformat_ip4_address, &ip4))
 240         {
 241           data = vec_new (u8, 4);
 242           clib_memcpy (data, ip4.as_u8, 4);
 243         }
 244       else if (unformat (i, "id_data 0x%U", unformat_hex_string, &data))
 245         ;
 246       else if (unformat (i, "id_data %v", &data))
 247         ;
 248       else if (unformat (i, "local"))
 249         is_local = 1;
 250       else if (unformat (i, "remote"))
 251         is_local = 0;
 252       else
 253         {
 254           errmsg ("parse error '%U'", format_unformat_error, i);
 255           return -99;
 256         }
 257     }
 258
 259   if (!vec_len (name))
 260     {
 261       errmsg ("profile name must be specified");
 262       return -99;
 263     }
 264
 265   if (vec_len (name) > 64)
 266     {
 267       errmsg ("profile name too long");
 268       return -99;
 269     }
 270
 271   if (!vec_len (data))
 272     {
 273       errmsg ("id_data must be specified");
 274       return -99;
 275     }
 276
 277   if (!id_type)
 278     {
 279       errmsg ("id_type must be specified");
 280       return -99;
 281     }
 282
 283   M (IKEV2_PROFILE_SET_ID, mp);
 284
 285   mp->is_local = is_local;
 286   mp->id_type = (u8) id_type;
 287   mp->data_len = vec_len (data);
 288   clib_memcpy (mp->name, name, vec_len (name));
 289   clib_memcpy (mp->data, data, vec_len (data));
 290   vec_free (name);
 291   vec_free (data);
 292
 293   S (mp);
 294   W (ret);
 295   return ret;
 296 }
 297
 298 static int
 299 api_ikev2_profile_set_ts (vat_main_t * vam)
 300 {
 301   unformat_input_t *i = vam->input;
 302   vl_api_ikev2_profile_set_ts_t *mp;
 303   u8 *name = 0;
 304   u8 is_local = 0;
 305   u32 proto = 0, start_port = 0, end_port = (u32) ~ 0;
 306   ip4_address_t start_addr, end_addr;
 307
 308   const char *valid_chars = "a-zA-Z0-9_";
 309   int ret;
 310
 311   start_addr.as_u32 = 0;
 312   end_addr.as_u32 = (u32) ~ 0;
 313
 314   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 315     {
 316       if (unformat (i, "name %U", unformat_token, valid_chars, &name))
 317         vec_add1 (name, 0);
 318       else if (unformat (i, "protocol %d", &proto))
 319         ;
 320       else if (unformat (i, "start_port %d", &start_port))
 321         ;
 322       else if (unformat (i, "end_port %d", &end_port))
 323         ;
 324       else
 325         if (unformat (i, "start_addr %U", unformat_ip4_address, &start_addr))
 326         ;
 327       else if (unformat (i, "end_addr %U", unformat_ip4_address, &end_addr))
 328         ;
 329       else if (unformat (i, "local"))
 330         is_local = 1;
 331       else if (unformat (i, "remote"))
 332         is_local = 0;
 333       else
 334         {
 335           errmsg ("parse error '%U'", format_unformat_error, i);
 336           return -99;
 337         }
 338     }
 339
 340   if (!vec_len (name))
 341     {
 342       errmsg ("profile name must be specified");
 343       return -99;
 344     }
 345
 346   if (vec_len (name) > 64)
 347     {
 348       errmsg ("profile name too long");
 349       return -99;
 350     }
 351
 352   M (IKEV2_PROFILE_SET_TS, mp);
 353
 354   mp->is_local = is_local;
 355   mp->proto = (u8) proto;
 356   mp->start_port = (u16) start_port;
 357   mp->end_port = (u16) end_port;
 358   mp->start_addr = start_addr.as_u32;
 359   mp->end_addr = end_addr.as_u32;
 360   clib_memcpy (mp->name, name, vec_len (name));
 361   vec_free (name);
 362
 363   S (mp);
 364   W (ret);
 365   return ret;
 366 }
 367
 368 static int
 369 api_ikev2_set_local_key (vat_main_t * vam)
 370 {
 371   unformat_input_t *i = vam->input;
 372   vl_api_ikev2_set_local_key_t *mp;
 373   u8 *file = 0;
 374   int ret;
 375
 376   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 377     {
 378       if (unformat (i, "file %v", &file))
 379         vec_add1 (file, 0);
 380       else
 381         {
 382           errmsg ("parse error '%U'", format_unformat_error, i);
 383           return -99;
 384         }
 385     }
 386
 387   if (!vec_len (file))
 388     {
 389       errmsg ("RSA key file must be specified");
 390       return -99;
 391     }
 392
 393   if (vec_len (file) > 256)
 394     {
 395       errmsg ("file name too long");
 396       return -99;
 397     }
 398
 399   M (IKEV2_SET_LOCAL_KEY, mp);
 400
 401   clib_memcpy (mp->key_file, file, vec_len (file));
 402   vec_free (file);
 403
 404   S (mp);
 405   W (ret);
 406   return ret;
 407 }
 408
 409 static int
 410 api_ikev2_set_responder (vat_main_t * vam)
 411 {
 412   unformat_input_t *i = vam->input;
 413   vl_api_ikev2_set_responder_t *mp;
 414   int ret;
 415   u8 *name = 0;
 416   u32 sw_if_index = ~0;
 417   ip4_address_t address;
 418
 419   const char *valid_chars = "a-zA-Z0-9_";
 420
 421   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 422     {
 423       if (unformat
 424           (i, "%U interface %d address %U", unformat_token, valid_chars,
 425            &name, &sw_if_index, unformat_ip4_address, &address))
 426         vec_add1 (name, 0);
 427       else
 428         {
 429           errmsg ("parse error '%U'", format_unformat_error, i);
 430           return -99;
 431         }
 432     }
 433
 434   if (!vec_len (name))
 435     {
 436       errmsg ("profile name must be specified");
 437       return -99;
 438     }
 439
 440   if (vec_len (name) > 64)
 441     {
 442       errmsg ("profile name too long");
 443       return -99;
 444     }
 445
 446   M (IKEV2_SET_RESPONDER, mp);
 447
 448   clib_memcpy (mp->name, name, vec_len (name));
 449   vec_free (name);
 450
 451   mp->sw_if_index = sw_if_index;
 452   clib_memcpy (mp->address, &address, sizeof (address));
 453
 454   S (mp);
 455   W (ret);
 456   return ret;
 457 }
 458
 459 static int
 460 api_ikev2_set_ike_transforms (vat_main_t * vam)
 461 {
 462   unformat_input_t *i = vam->input;
 463   vl_api_ikev2_set_ike_transforms_t *mp;
 464   int ret;
 465   u8 *name = 0;
 466   u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
 467
 468   const char *valid_chars = "a-zA-Z0-9_";
 469
 470   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 471     {
 472       if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
 473                     &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
 474         vec_add1 (name, 0);
 475       else
 476         {
 477           errmsg ("parse error '%U'", format_unformat_error, i);
 478           return -99;
 479         }
 480     }
 481
 482   if (!vec_len (name))
 483     {
 484       errmsg ("profile name must be specified");
 485       return -99;
 486     }
 487
 488   if (vec_len (name) > 64)
 489     {
 490       errmsg ("profile name too long");
 491       return -99;
 492     }
 493
 494   M (IKEV2_SET_IKE_TRANSFORMS, mp);
 495
 496   clib_memcpy (mp->name, name, vec_len (name));
 497   vec_free (name);
 498   mp->crypto_alg = crypto_alg;
 499   mp->crypto_key_size = crypto_key_size;
 500   mp->integ_alg = integ_alg;
 501   mp->dh_group = dh_group;
 502
 503   S (mp);
 504   W (ret);
 505   return ret;
 506 }
 507
 508
 509 static int
 510 api_ikev2_set_esp_transforms (vat_main_t * vam)
 511 {
 512   unformat_input_t *i = vam->input;
 513   vl_api_ikev2_set_esp_transforms_t *mp;
 514   int ret;
 515   u8 *name = 0;
 516   u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
 517
 518   const char *valid_chars = "a-zA-Z0-9_";
 519
 520   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 521     {
 522       if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
 523                     &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
 524         vec_add1 (name, 0);
 525       else
 526         {
 527           errmsg ("parse error '%U'", format_unformat_error, i);
 528           return -99;
 529         }
 530     }
 531
 532   if (!vec_len (name))
 533     {
 534       errmsg ("profile name must be specified");
 535       return -99;
 536     }
 537
 538   if (vec_len (name) > 64)
 539     {
 540       errmsg ("profile name too long");
 541       return -99;
 542     }
 543
 544   M (IKEV2_SET_ESP_TRANSFORMS, mp);
 545
 546   clib_memcpy (mp->name, name, vec_len (name));
 547   vec_free (name);
 548   mp->crypto_alg = crypto_alg;
 549   mp->crypto_key_size = crypto_key_size;
 550   mp->integ_alg = integ_alg;
 551   mp->dh_group = dh_group;
 552
 553   S (mp);
 554   W (ret);
 555   return ret;
 556 }
 557
 558 static int
 559 api_ikev2_set_sa_lifetime (vat_main_t * vam)
 560 {
 561   unformat_input_t *i = vam->input;
 562   vl_api_ikev2_set_sa_lifetime_t *mp;
 563   int ret;
 564   u8 *name = 0;
 565   u64 lifetime, lifetime_maxdata;
 566   u32 lifetime_jitter, handover;
 567
 568   const char *valid_chars = "a-zA-Z0-9_";
 569
 570   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 571     {
 572       if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
 573                     &lifetime, &lifetime_jitter, &handover,
 574                     &lifetime_maxdata))
 575         vec_add1 (name, 0);
 576       else
 577         {
 578           errmsg ("parse error '%U'", format_unformat_error, i);
 579           return -99;
 580         }
 581     }
 582
 583   if (!vec_len (name))
 584     {
 585       errmsg ("profile name must be specified");
 586       return -99;
 587     }
 588
 589   if (vec_len (name) > 64)
 590     {
 591       errmsg ("profile name too long");
 592       return -99;
 593     }
 594
 595   M (IKEV2_SET_SA_LIFETIME, mp);
 596
 597   clib_memcpy (mp->name, name, vec_len (name));
 598   vec_free (name);
 599   mp->lifetime = lifetime;
 600   mp->lifetime_jitter = lifetime_jitter;
 601   mp->handover = handover;
 602   mp->lifetime_maxdata = lifetime_maxdata;
 603
 604   S (mp);
 605   W (ret);
 606   return ret;
 607 }
 608
 609 static int
 610 api_ikev2_initiate_sa_init (vat_main_t * vam)
 611 {
 612   unformat_input_t *i = vam->input;
 613   vl_api_ikev2_initiate_sa_init_t *mp;
 614   int ret;
 615   u8 *name = 0;
 616
 617   const char *valid_chars = "a-zA-Z0-9_";
 618
 619   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 620     {
 621       if (unformat (i, "%U", unformat_token, valid_chars, &name))
 622         vec_add1 (name, 0);
 623       else
 624         {
 625           errmsg ("parse error '%U'", format_unformat_error, i);
 626           return -99;
 627         }
 628     }
 629
 630   if (!vec_len (name))
 631     {
 632       errmsg ("profile name must be specified");
 633       return -99;
 634     }
 635
 636   if (vec_len (name) > 64)
 637     {
 638       errmsg ("profile name too long");
 639       return -99;
 640     }
 641
 642   M (IKEV2_INITIATE_SA_INIT, mp);
 643
 644   clib_memcpy (mp->name, name, vec_len (name));
 645   vec_free (name);
 646
 647   S (mp);
 648   W (ret);
 649   return ret;
 650 }
 651
 652 static int
 653 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
 654 {
 655   unformat_input_t *i = vam->input;
 656   vl_api_ikev2_initiate_del_ike_sa_t *mp;
 657   int ret;
 658   u64 ispi;
 659
 660
 661   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 662     {
 663       if (unformat (i, "%lx", &ispi))
 664         ;
 665       else
 666         {
 667           errmsg ("parse error '%U'", format_unformat_error, i);
 668           return -99;
 669         }
 670     }
 671
 672   M (IKEV2_INITIATE_DEL_IKE_SA, mp);
 673
 674   mp->ispi = ispi;
 675
 676   S (mp);
 677   W (ret);
 678   return ret;
 679 }
 680
 681 static int
 682 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
 683 {
 684   unformat_input_t *i = vam->input;
 685   vl_api_ikev2_initiate_del_child_sa_t *mp;
 686   int ret;
 687   u32 ispi;
 688
 689
 690   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 691     {
 692       if (unformat (i, "%x", &ispi))
 693         ;
 694       else
 695         {
 696           errmsg ("parse error '%U'", format_unformat_error, i);
 697           return -99;
 698         }
 699     }
 700
 701   M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
 702
 703   mp->ispi = ispi;
 704
 705   S (mp);
 706   W (ret);
 707   return ret;
 708 }
 709
 710 static int
 711 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
 712 {
 713   unformat_input_t *i = vam->input;
 714   vl_api_ikev2_initiate_rekey_child_sa_t *mp;
 715   int ret;
 716   u32 ispi;
 717
 718
 719   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 720     {
 721       if (unformat (i, "%x", &ispi))
 722         ;
 723       else
 724         {
 725           errmsg ("parse error '%U'", format_unformat_error, i);
 726           return -99;
 727         }
 728     }
 729
 730   M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
 731
 732   mp->ispi = ispi;
 733
 734   S (mp);
 735   W (ret);
 736   return ret;
 737 }
 738
 739 #include <ikev2/ikev2.api_test.c>
 740
 741 /*
 742  * fd.io coding-style-patch-verification: ON
 743  *
 744  * Local Variables:
 745  * eval: (c-set-style "gnu")
 746  * End:
 747  */