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_tunnel_interface (vat_main_t * vam)
 411 {
 412   return (0);
 413 }
 414
 415 static int
 416 api_ikev2_set_responder (vat_main_t * vam)
 417 {
 418   unformat_input_t *i = vam->input;
 419   vl_api_ikev2_set_responder_t *mp;
 420   int ret;
 421   u8 *name = 0;
 422   u32 sw_if_index = ~0;
 423   ip4_address_t address;
 424
 425   const char *valid_chars = "a-zA-Z0-9_";
 426
 427   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 428     {
 429       if (unformat
 430           (i, "%U interface %d address %U", unformat_token, valid_chars,
 431            &name, &sw_if_index, unformat_ip4_address, &address))
 432         vec_add1 (name, 0);
 433       else
 434         {
 435           errmsg ("parse error '%U'", format_unformat_error, i);
 436           return -99;
 437         }
 438     }
 439
 440   if (!vec_len (name))
 441     {
 442       errmsg ("profile name must be specified");
 443       return -99;
 444     }
 445
 446   if (vec_len (name) > 64)
 447     {
 448       errmsg ("profile name too long");
 449       return -99;
 450     }
 451
 452   M (IKEV2_SET_RESPONDER, mp);
 453
 454   clib_memcpy (mp->name, name, vec_len (name));
 455   vec_free (name);
 456
 457   mp->sw_if_index = sw_if_index;
 458   clib_memcpy (mp->address, &address, sizeof (address));
 459
 460   S (mp);
 461   W (ret);
 462   return ret;
 463 }
 464
 465 static int
 466 api_ikev2_set_ike_transforms (vat_main_t * vam)
 467 {
 468   unformat_input_t *i = vam->input;
 469   vl_api_ikev2_set_ike_transforms_t *mp;
 470   int ret;
 471   u8 *name = 0;
 472   u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
 473
 474   const char *valid_chars = "a-zA-Z0-9_";
 475
 476   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 477     {
 478       if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
 479                     &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
 480         vec_add1 (name, 0);
 481       else
 482         {
 483           errmsg ("parse error '%U'", format_unformat_error, i);
 484           return -99;
 485         }
 486     }
 487
 488   if (!vec_len (name))
 489     {
 490       errmsg ("profile name must be specified");
 491       return -99;
 492     }
 493
 494   if (vec_len (name) > 64)
 495     {
 496       errmsg ("profile name too long");
 497       return -99;
 498     }
 499
 500   M (IKEV2_SET_IKE_TRANSFORMS, mp);
 501
 502   clib_memcpy (mp->name, name, vec_len (name));
 503   vec_free (name);
 504   mp->crypto_alg = crypto_alg;
 505   mp->crypto_key_size = crypto_key_size;
 506   mp->integ_alg = integ_alg;
 507   mp->dh_group = dh_group;
 508
 509   S (mp);
 510   W (ret);
 511   return ret;
 512 }
 513
 514
 515 static int
 516 api_ikev2_set_esp_transforms (vat_main_t * vam)
 517 {
 518   unformat_input_t *i = vam->input;
 519   vl_api_ikev2_set_esp_transforms_t *mp;
 520   int ret;
 521   u8 *name = 0;
 522   u32 crypto_alg, crypto_key_size, integ_alg, dh_group;
 523
 524   const char *valid_chars = "a-zA-Z0-9_";
 525
 526   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 527     {
 528       if (unformat (i, "%U %d %d %d %d", unformat_token, valid_chars, &name,
 529                     &crypto_alg, &crypto_key_size, &integ_alg, &dh_group))
 530         vec_add1 (name, 0);
 531       else
 532         {
 533           errmsg ("parse error '%U'", format_unformat_error, i);
 534           return -99;
 535         }
 536     }
 537
 538   if (!vec_len (name))
 539     {
 540       errmsg ("profile name must be specified");
 541       return -99;
 542     }
 543
 544   if (vec_len (name) > 64)
 545     {
 546       errmsg ("profile name too long");
 547       return -99;
 548     }
 549
 550   M (IKEV2_SET_ESP_TRANSFORMS, mp);
 551
 552   clib_memcpy (mp->name, name, vec_len (name));
 553   vec_free (name);
 554   mp->crypto_alg = crypto_alg;
 555   mp->crypto_key_size = crypto_key_size;
 556   mp->integ_alg = integ_alg;
 557   mp->dh_group = dh_group;
 558
 559   S (mp);
 560   W (ret);
 561   return ret;
 562 }
 563
 564 static int
 565 api_ikev2_set_sa_lifetime (vat_main_t * vam)
 566 {
 567   unformat_input_t *i = vam->input;
 568   vl_api_ikev2_set_sa_lifetime_t *mp;
 569   int ret;
 570   u8 *name = 0;
 571   u64 lifetime, lifetime_maxdata;
 572   u32 lifetime_jitter, handover;
 573
 574   const char *valid_chars = "a-zA-Z0-9_";
 575
 576   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 577     {
 578       if (unformat (i, "%U %lu %u %u %lu", unformat_token, valid_chars, &name,
 579                     &lifetime, &lifetime_jitter, &handover,
 580                     &lifetime_maxdata))
 581         vec_add1 (name, 0);
 582       else
 583         {
 584           errmsg ("parse error '%U'", format_unformat_error, i);
 585           return -99;
 586         }
 587     }
 588
 589   if (!vec_len (name))
 590     {
 591       errmsg ("profile name must be specified");
 592       return -99;
 593     }
 594
 595   if (vec_len (name) > 64)
 596     {
 597       errmsg ("profile name too long");
 598       return -99;
 599     }
 600
 601   M (IKEV2_SET_SA_LIFETIME, mp);
 602
 603   clib_memcpy (mp->name, name, vec_len (name));
 604   vec_free (name);
 605   mp->lifetime = lifetime;
 606   mp->lifetime_jitter = lifetime_jitter;
 607   mp->handover = handover;
 608   mp->lifetime_maxdata = lifetime_maxdata;
 609
 610   S (mp);
 611   W (ret);
 612   return ret;
 613 }
 614
 615 static int
 616 api_ikev2_initiate_sa_init (vat_main_t * vam)
 617 {
 618   unformat_input_t *i = vam->input;
 619   vl_api_ikev2_initiate_sa_init_t *mp;
 620   int ret;
 621   u8 *name = 0;
 622
 623   const char *valid_chars = "a-zA-Z0-9_";
 624
 625   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 626     {
 627       if (unformat (i, "%U", unformat_token, valid_chars, &name))
 628         vec_add1 (name, 0);
 629       else
 630         {
 631           errmsg ("parse error '%U'", format_unformat_error, i);
 632           return -99;
 633         }
 634     }
 635
 636   if (!vec_len (name))
 637     {
 638       errmsg ("profile name must be specified");
 639       return -99;
 640     }
 641
 642   if (vec_len (name) > 64)
 643     {
 644       errmsg ("profile name too long");
 645       return -99;
 646     }
 647
 648   M (IKEV2_INITIATE_SA_INIT, mp);
 649
 650   clib_memcpy (mp->name, name, vec_len (name));
 651   vec_free (name);
 652
 653   S (mp);
 654   W (ret);
 655   return ret;
 656 }
 657
 658 static int
 659 api_ikev2_initiate_del_ike_sa (vat_main_t * vam)
 660 {
 661   unformat_input_t *i = vam->input;
 662   vl_api_ikev2_initiate_del_ike_sa_t *mp;
 663   int ret;
 664   u64 ispi;
 665
 666
 667   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 668     {
 669       if (unformat (i, "%lx", &ispi))
 670         ;
 671       else
 672         {
 673           errmsg ("parse error '%U'", format_unformat_error, i);
 674           return -99;
 675         }
 676     }
 677
 678   M (IKEV2_INITIATE_DEL_IKE_SA, mp);
 679
 680   mp->ispi = ispi;
 681
 682   S (mp);
 683   W (ret);
 684   return ret;
 685 }
 686
 687 static int
 688 api_ikev2_initiate_del_child_sa (vat_main_t * vam)
 689 {
 690   unformat_input_t *i = vam->input;
 691   vl_api_ikev2_initiate_del_child_sa_t *mp;
 692   int ret;
 693   u32 ispi;
 694
 695
 696   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 697     {
 698       if (unformat (i, "%x", &ispi))
 699         ;
 700       else
 701         {
 702           errmsg ("parse error '%U'", format_unformat_error, i);
 703           return -99;
 704         }
 705     }
 706
 707   M (IKEV2_INITIATE_DEL_CHILD_SA, mp);
 708
 709   mp->ispi = ispi;
 710
 711   S (mp);
 712   W (ret);
 713   return ret;
 714 }
 715
 716 static int
 717 api_ikev2_initiate_rekey_child_sa (vat_main_t * vam)
 718 {
 719   unformat_input_t *i = vam->input;
 720   vl_api_ikev2_initiate_rekey_child_sa_t *mp;
 721   int ret;
 722   u32 ispi;
 723
 724
 725   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 726     {
 727       if (unformat (i, "%x", &ispi))
 728         ;
 729       else
 730         {
 731           errmsg ("parse error '%U'", format_unformat_error, i);
 732           return -99;
 733         }
 734     }
 735
 736   M (IKEV2_INITIATE_REKEY_CHILD_SA, mp);
 737
 738   mp->ispi = ispi;
 739
 740   S (mp);
 741   W (ret);
 742   return ret;
 743 }
 744
 745 #include <ikev2/ikev2.api_test.c>
 746
 747 /*
 748  * fd.io coding-style-patch-verification: ON
 749  *
 750  * Local Variables:
 751  * eval: (c-set-style "gnu")
 752  * End:
 753  */