Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2019 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this file except in compliance with the License.
       5             :  * You may obtain a copy of the License at:
       6             :  *
       7             :  *     http://www.apache.org/licenses/LICENSE-2.0
       8             :  *
       9             :  * Unless required by applicable law or agreed to in writing, software
      10             :  * distributed under the License is distributed on an "AS IS" BASIS,
      11             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             :  * See the License for the specific language governing permissions and
      13             :  * limitations under the License.
      14             :  */
      15             : 
      16             : #include <stdbool.h>
      17             : #include <vlib/vlib.h>
      18             : #include <vnet/crypto/crypto.h>
      19             : 
      20             : u8 *
      21          98 : format_vnet_crypto_alg (u8 * s, va_list * args)
      22             : {
      23          98 :   vnet_crypto_alg_t alg = va_arg (*args, vnet_crypto_alg_t);
      24          98 :   vnet_crypto_main_t *cm = &crypto_main;
      25          98 :   vnet_crypto_alg_data_t *d = vec_elt_at_index (cm->algs, alg);
      26          98 :   return format (s, "%s", d->name);
      27             : }
      28             : 
      29             : uword
      30           0 : unformat_vnet_crypto_alg (unformat_input_t * input, va_list * args)
      31             : {
      32           0 :   vnet_crypto_main_t *cm = &crypto_main;
      33           0 :   vnet_crypto_alg_t *alg = va_arg (*args, vnet_crypto_alg_t *);
      34             :   uword *p;
      35             :   u8 *name;
      36             : 
      37           0 :   if (!unformat (input, "%s", &name))
      38           0 :     return 0;
      39             : 
      40           0 :   p = hash_get_mem (cm->alg_index_by_name, name);
      41           0 :   vec_free (name);
      42           0 :   if (p == 0)
      43           0 :     return 0;
      44             : 
      45           0 :   *alg = p[0];
      46             : 
      47           0 :   return 1;
      48             : }
      49             : 
      50             : u8 *
      51          98 : format_vnet_crypto_op (u8 * s, va_list * args)
      52             : {
      53          98 :   vnet_crypto_main_t *cm = &crypto_main;
      54          98 :   vnet_crypto_op_id_t op = va_arg (*args, int); // vnet_crypto_op_id_t);
      55          98 :   vnet_crypto_op_data_t *otd = cm->opt_data + op;
      56             : 
      57         196 :   return format (s, "%U-%U", format_vnet_crypto_op_type, otd->type,
      58          98 :                  format_vnet_crypto_alg, otd->alg);
      59             : }
      60             : 
      61             : u8 *
      62          98 : format_vnet_crypto_op_type (u8 * s, va_list * args)
      63             : {
      64          98 :   vnet_crypto_op_type_t opt = va_arg (*args, vnet_crypto_op_type_t);
      65          98 :   char *strings[] = {
      66             : #define _(n, s) [VNET_CRYPTO_OP_TYPE_##n] = s,
      67             :     foreach_crypto_op_type
      68             : #undef _
      69             :   };
      70             : 
      71          98 :   if (opt >= VNET_CRYPTO_OP_N_TYPES)
      72           0 :     return format (s, "unknown");
      73             : 
      74          98 :   return format (s, "%s", strings[opt]);
      75             : }
      76             : 
      77             : u8 *
      78           0 : format_vnet_crypto_op_status (u8 * s, va_list * args)
      79             : {
      80           0 :   vnet_crypto_op_status_t st = va_arg (*args, vnet_crypto_op_status_t);
      81           0 :   char *strings[] = {
      82             : #define _(n, s) [VNET_CRYPTO_OP_STATUS_##n] = s,
      83             :     foreach_crypto_op_status
      84             : #undef _
      85             :   };
      86             : 
      87           0 :   if (st >= VNET_CRYPTO_OP_N_STATUS)
      88           0 :     return format (s, "unknown");
      89             : 
      90           0 :   return format (s, "%s", strings[st]);
      91             : }
      92             : 
      93             : u8 *
      94           0 : format_vnet_crypto_engine (u8 * s, va_list * args)
      95             : {
      96           0 :   vnet_crypto_main_t *cm = &crypto_main;
      97           0 :   u32 crypto_engine_index = va_arg (*args, u32);
      98             :   vnet_crypto_engine_t *e;
      99             : 
     100           0 :   if (crypto_engine_index == ~0)
     101           0 :     return s;
     102             : 
     103           0 :   e = vec_elt_at_index (cm->engines, crypto_engine_index);
     104             : 
     105           0 :   return format (s, "%s", e->name);
     106             : }
     107             : 
     108             : u8 *
     109           0 : format_vnet_crypto_async_op_type (u8 * s, va_list * args)
     110             : {
     111           0 :   vnet_crypto_async_op_type_t opt =
     112             :     va_arg (*args, vnet_crypto_async_op_type_t);
     113           0 :   char *strings[] = {
     114             : #define _(n, s) [VNET_CRYPTO_ASYNC_OP_TYPE_##n] = s,
     115             :     foreach_crypto_async_op_type
     116             : #undef _
     117             :   };
     118             : 
     119           0 :   if (opt >= VNET_CRYPTO_ASYNC_OP_N_TYPES)
     120           0 :     return format (s, "unknown");
     121             : 
     122           0 :   return format (s, "%s", strings[opt]);
     123             : }
     124             : 
     125             : u8 *
     126           0 : format_vnet_crypto_async_alg (u8 * s, va_list * args)
     127             : {
     128           0 :   vnet_crypto_async_alg_t alg = va_arg (*args, vnet_crypto_async_alg_t);
     129           0 :   vnet_crypto_main_t *cm = &crypto_main;
     130           0 :   vnet_crypto_async_alg_data_t *d = vec_elt_at_index (cm->async_algs, alg);
     131           0 :   return format (s, "%s", d->name);
     132             : }
     133             : 
     134             : u8 *
     135           0 : format_vnet_crypto_async_op (u8 * s, va_list * args)
     136             : {
     137           0 :   vnet_crypto_main_t *cm = &crypto_main;
     138           0 :   vnet_crypto_async_op_id_t op = va_arg (*args, vnet_crypto_async_op_id_t);
     139           0 :   vnet_crypto_async_op_data_t *otd = cm->async_opt_data + op;
     140             : 
     141           0 :   return format (s, "%U-%U", format_vnet_crypto_async_op_type, otd->type,
     142           0 :                  format_vnet_crypto_async_alg, otd->alg);
     143             : }
     144             : 
     145             : /*
     146             :  * fd.io coding-style-patch-verification: ON
     147             :  *
     148             :  * Local Variables:
     149             :  * eval: (c-set-style "gnu")
     150             :  * End:
     151             :  */