VCL: application proxy configuration
[vpp.git] / src / vat / plugin_api.c
1 /*
2  * Copyright (c) 2015 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 #include <vat/vat.h>
16 #include <vnet/ip/ip.h>
17
18 uword
19 unformat_sw_if_index (unformat_input_t * input, va_list * args)
20 {
21   vat_main_t *vam = va_arg (*args, vat_main_t *);
22   u32 *result = va_arg (*args, u32 *);
23   u8 *if_name;
24   uword *p;
25
26   if (!unformat (input, "%s", &if_name))
27     return 0;
28
29   p = hash_get_mem (vam->sw_if_index_by_interface_name, if_name);
30   if (p == 0)
31     return 0;
32   *result = p[0];
33   return 1;
34 }
35
36 /* Parse an IP4 address %d.%d.%d.%d. */
37 uword
38 unformat_ip4_address (unformat_input_t * input, va_list * args)
39 {
40   u8 *result = va_arg (*args, u8 *);
41   unsigned a[4];
42
43   if (!unformat (input, "%d.%d.%d.%d", &a[0], &a[1], &a[2], &a[3]))
44     return 0;
45
46   if (a[0] >= 256 || a[1] >= 256 || a[2] >= 256 || a[3] >= 256)
47     return 0;
48
49   result[0] = a[0];
50   result[1] = a[1];
51   result[2] = a[2];
52   result[3] = a[3];
53
54   return 1;
55 }
56
57 uword
58 unformat_ethernet_address (unformat_input_t * input, va_list * args)
59 {
60   u8 *result = va_arg (*args, u8 *);
61   u32 i, a[6];
62
63   if (!unformat (input, "%_%x:%x:%x:%x:%x:%x%_",
64                  &a[0], &a[1], &a[2], &a[3], &a[4], &a[5]))
65     return 0;
66
67   /* Check range. */
68   for (i = 0; i < 6; i++)
69     if (a[i] >= (1 << 8))
70       return 0;
71
72   for (i = 0; i < 6; i++)
73     result[i] = a[i];
74
75   return 1;
76 }
77
78 /* Returns ethernet type as an int in host byte order. */
79 uword
80 unformat_ethernet_type_host_byte_order (unformat_input_t * input,
81                                         va_list * args)
82 {
83   u16 *result = va_arg (*args, u16 *);
84   int type;
85
86   /* Numeric type. */
87   if (unformat (input, "0x%x", &type) || unformat (input, "%d", &type))
88     {
89       if (type >= (1 << 16))
90         return 0;
91       *result = type;
92       return 1;
93     }
94   return 0;
95 }
96
97 /* Parse an IP6 address. */
98 uword
99 unformat_ip6_address (unformat_input_t * input, va_list * args)
100 {
101   ip6_address_t *result = va_arg (*args, ip6_address_t *);
102   u16 hex_quads[8];
103   uword hex_quad, n_hex_quads, hex_digit, n_hex_digits;
104   uword c, n_colon, double_colon_index;
105
106   n_hex_quads = hex_quad = n_hex_digits = n_colon = 0;
107   double_colon_index = ARRAY_LEN (hex_quads);
108   while ((c = unformat_get_input (input)) != UNFORMAT_END_OF_INPUT)
109     {
110       hex_digit = 16;
111       if (c >= '0' && c <= '9')
112         hex_digit = c - '0';
113       else if (c >= 'a' && c <= 'f')
114         hex_digit = c + 10 - 'a';
115       else if (c >= 'A' && c <= 'F')
116         hex_digit = c + 10 - 'A';
117       else if (c == ':' && n_colon < 2)
118         n_colon++;
119       else
120         {
121           unformat_put_input (input);
122           break;
123         }
124
125       /* Too many hex quads. */
126       if (n_hex_quads >= ARRAY_LEN (hex_quads))
127         return 0;
128
129       if (hex_digit < 16)
130         {
131           hex_quad = (hex_quad << 4) | hex_digit;
132
133           /* Hex quad must fit in 16 bits. */
134           if (n_hex_digits >= 4)
135             return 0;
136
137           n_colon = 0;
138           n_hex_digits++;
139         }
140
141       /* Save position of :: */
142       if (n_colon == 2)
143         {
144           /* More than one :: ? */
145           if (double_colon_index < ARRAY_LEN (hex_quads))
146             return 0;
147           double_colon_index = n_hex_quads;
148         }
149
150       if (n_colon > 0 && n_hex_digits > 0)
151         {
152           hex_quads[n_hex_quads++] = hex_quad;
153           hex_quad = 0;
154           n_hex_digits = 0;
155         }
156     }
157
158   if (n_hex_digits > 0)
159     hex_quads[n_hex_quads++] = hex_quad;
160
161   {
162     word i;
163
164     /* Expand :: to appropriate number of zero hex quads. */
165     if (double_colon_index < ARRAY_LEN (hex_quads))
166       {
167         word n_zero = ARRAY_LEN (hex_quads) - n_hex_quads;
168
169         for (i = n_hex_quads - 1; i >= (signed) double_colon_index; i--)
170           hex_quads[n_zero + i] = hex_quads[i];
171
172         for (i = 0; i < n_zero; i++)
173           hex_quads[double_colon_index + i] = 0;
174
175         n_hex_quads = ARRAY_LEN (hex_quads);
176       }
177
178     /* Too few hex quads given. */
179     if (n_hex_quads < ARRAY_LEN (hex_quads))
180       return 0;
181
182     for (i = 0; i < ARRAY_LEN (hex_quads); i++)
183       result->as_u16[i] = clib_host_to_net_u16 (hex_quads[i]);
184
185     return 1;
186   }
187 }
188
189 u8 *
190 format_ip4_address (u8 * s, va_list * args)
191 {
192   u8 *a = va_arg (*args, u8 *);
193   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
194 }
195
196 u8 *
197 format_ip6_address (u8 * s, va_list * args)
198 {
199   ip6_address_t *a = va_arg (*args, ip6_address_t *);
200   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
201
202   i_max_n_zero = ARRAY_LEN (a->as_u16);
203   max_n_zeros = 0;
204   i_first_zero = i_max_n_zero;
205   n_zeros = 0;
206   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
207     {
208       u32 is_zero = a->as_u16[i] == 0;
209       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
210         {
211           i_first_zero = i;
212           n_zeros = 0;
213         }
214       n_zeros += is_zero;
215       if ((!is_zero && n_zeros > max_n_zeros)
216           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
217         {
218           i_max_n_zero = i_first_zero;
219           max_n_zeros = n_zeros;
220           i_first_zero = ARRAY_LEN (a->as_u16);
221           n_zeros = 0;
222         }
223     }
224
225   last_double_colon = 0;
226   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
227     {
228       if (i == i_max_n_zero && max_n_zeros > 1)
229         {
230           s = format (s, "::");
231           i += max_n_zeros - 1;
232           last_double_colon = 1;
233         }
234       else
235         {
236           s = format (s, "%s%x",
237                       (last_double_colon || i == 0) ? "" : ":",
238                       clib_net_to_host_u16 (a->as_u16[i]));
239           last_double_colon = 0;
240         }
241     }
242
243   return s;
244 }
245
246 /* Format an IP46 address. */
247 u8 *
248 format_ip46_address (u8 * s, va_list * args)
249 {
250   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
251   ip46_type_t type = va_arg (*args, ip46_type_t);
252   int is_ip4 = 1;
253
254   switch (type)
255     {
256     case IP46_TYPE_ANY:
257       is_ip4 = ip46_address_is_ip4 (ip46);
258       break;
259     case IP46_TYPE_IP4:
260       is_ip4 = 1;
261       break;
262     case IP46_TYPE_IP6:
263       is_ip4 = 0;
264       break;
265     }
266
267   return is_ip4 ?
268     format (s, "%U", format_ip4_address, &ip46->ip4) :
269     format (s, "%U", format_ip6_address, &ip46->ip6);
270 }
271
272 u8 *
273 format_ethernet_address (u8 * s, va_list * args)
274 {
275   u8 *a = va_arg (*args, u8 *);
276
277   return format (s, "%02x:%02x:%02x:%02x:%02x:%02x",
278                  a[0], a[1], a[2], a[3], a[4], a[5]);
279 }
280
281 void
282 vat_plugin_api_reference (void)
283 {
284 }
285
286 /*
287  * fd.io coding-style-patch-verification: ON
288  *
289  * Local Variables:
290  * eval: (c-set-style "gnu")
291  * End:
292  */