FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
abf_api.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 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 <stddef.h>
17 
18 #include <vnet/vnet.h>
19 #include <vnet/plugin/plugin.h>
20 #include <abf/abf_policy.h>
21 #include <abf/abf_itf_attach.h>
22 #include <vnet/mpls/mpls_types.h>
23 #include <vnet/fib/fib_path_list.h>
24 #include <vnet/fib/fib_api.h>
25 
26 #include <vpp/app/version.h>
27 
28 #include <vlibapi/api.h>
29 #include <vlibmemory/api.h>
30 
31 /* define message IDs */
32 #include <abf/abf_msg_enum.h>
33 
34 /* define message structures */
35 #define vl_typedefs
36 #include <abf/abf_all_api_h.h>
37 #undef vl_typedefs
38 
39 /* define generated endian-swappers */
40 #define vl_endianfun
41 #include <abf/abf_all_api_h.h>
42 #undef vl_endianfun
43 
44 /* instantiate all the print functions we know about */
45 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
46 #define vl_printfun
47 #include <abf/abf_all_api_h.h>
48 #undef vl_printfun
49 
50 /* Get the API version number */
51 #define vl_api_version(n,v) static u32 api_version=(v);
52 #include <abf/abf_all_api_h.h>
53 #undef vl_api_version
54 
55 /**
56  * Base message ID fot the plugin
57  */
59 
61 
62 /* List of message types that this plugin understands */
63 
64 #define foreach_abf_plugin_api_msg \
65 _(ABF_PLUGIN_GET_VERSION, abf_plugin_get_version) \
66 _(ABF_POLICY_ADD_DEL, abf_policy_add_del) \
67 _(ABF_POLICY_DUMP, abf_policy_dump) \
68 _(ABF_ITF_ATTACH_ADD_DEL, abf_itf_attach_add_del) \
69 _(ABF_ITF_ATTACH_DUMP, abf_itf_attach_dump)
70 
71 static void
73 {
76 
78  if (rp == 0)
79  return;
80 
81  rmp = vl_msg_api_alloc (sizeof (*rmp));
82  rmp->_vl_msg_id =
83  ntohs (VL_API_ABF_PLUGIN_GET_VERSION_REPLY + abf_base_msg_id);
84  rmp->context = mp->context;
85  rmp->major = htonl (ABF_PLUGIN_VERSION_MAJOR);
86  rmp->minor = htonl (ABF_PLUGIN_VERSION_MINOR);
87 
88  vl_api_send_msg (rp, (u8 *) rmp);
89 }
90 
91 static void
93 {
94  vl_api_abf_policy_add_del_reply_t *rmp;
95  fib_route_path_t *paths = NULL, *path;
96  int rv = 0;
97  u8 pi;
98 
99  vec_validate (paths, mp->policy.n_paths - 1);
100 
101  for (pi = 0; pi < mp->policy.n_paths; pi++)
102  {
103  path = &paths[pi];
104  rv = fib_path_api_parse (&mp->policy.paths[pi], path);
105 
106  if (0 != rv)
107  {
108  goto done;
109  }
110  }
111 
112  if (mp->is_add)
113  {
114  abf_policy_update (ntohl (mp->policy.policy_id),
115  ntohl (mp->policy.acl_index), paths);
116  }
117  else
118  {
119  abf_policy_delete (ntohl (mp->policy.policy_id), paths);
120  }
121 done:
122  vec_free (paths);
123 
124  REPLY_MACRO (VL_API_ABF_POLICY_ADD_DEL_REPLY + abf_base_msg_id);
125 }
126 
127 static void
129 {
130  vl_api_abf_itf_attach_add_del_reply_t *rmp;
131  fib_protocol_t fproto = (mp->attach.is_ipv6 ?
133  int rv = 0;
134 
135  if (mp->is_add)
136  {
137  abf_itf_attach (fproto,
138  ntohl (mp->attach.policy_id),
139  ntohl (mp->attach.priority),
140  ntohl (mp->attach.sw_if_index));
141  }
142  else
143  {
144  abf_itf_detach (fproto,
145  ntohl (mp->attach.policy_id),
146  ntohl (mp->attach.sw_if_index));
147  }
148 
149  REPLY_MACRO (VL_API_ABF_ITF_ATTACH_ADD_DEL_REPLY + abf_base_msg_id);
150 }
151 
152 typedef struct abf_dump_walk_ctx_t_
153 {
157 
158 static int
160 {
161  fib_route_path_encode_t *api_rpaths = NULL, *api_rpath;
164  vl_api_fib_path_t *fp;
165  size_t msg_size;
166  abf_policy_t *ap;
167  u8 n_paths;
168 
169  ctx = args;
170  ap = abf_policy_get (api);
171  n_paths = fib_path_list_get_n_paths (ap->ap_pl);
172  msg_size = sizeof (*mp) + sizeof (mp->policy.paths[0]) * n_paths;
173 
174  mp = vl_msg_api_alloc (msg_size);
175  clib_memset (mp, 0, msg_size);
176  mp->_vl_msg_id = ntohs (VL_API_ABF_POLICY_DETAILS + abf_base_msg_id);
177 
178  /* fill in the message */
179  mp->context = ctx->context;
180  mp->policy.n_paths = n_paths;
181  mp->policy.acl_index = htonl (ap->ap_acl);
182  mp->policy.policy_id = htonl (ap->ap_id);
183 
184  fib_path_list_walk_w_ext (ap->ap_pl, NULL, fib_path_encode, &api_rpaths);
185 
186  fp = mp->policy.paths;
187  vec_foreach (api_rpath, api_rpaths)
188  {
189  fib_api_path_encode (api_rpath, fp);
190  fp++;
191  }
192 
193  vl_api_send_msg (ctx->rp, (u8 *) mp);
194 
195  return (1);
196 }
197 
198 static void
200 {
202 
204  if (rp == 0)
205  return;
206 
208  .rp = rp,
209  .context = mp->context,
210  };
211 
213 }
214 
215 static int
217 {
220  abf_itf_attach_t *aia;
221  abf_policy_t *ap;
222 
223  ctx = args;
224  aia = abf_itf_attach_get (aiai);
225  ap = abf_policy_get (aia->aia_abf);
226 
227  mp = vl_msg_api_alloc (sizeof (*mp));
228  mp->_vl_msg_id = ntohs (VL_API_ABF_ITF_ATTACH_DETAILS + abf_base_msg_id);
229 
230  mp->context = ctx->context;
231  mp->attach.policy_id = htonl (ap->ap_id);
232  mp->attach.sw_if_index = htonl (aia->aia_sw_if_index);
233  mp->attach.priority = htonl (aia->aia_prio);
234  mp->attach.is_ipv6 = (aia->aia_proto == FIB_PROTOCOL_IP6);
235 
236  vl_api_send_msg (ctx->rp, (u8 *) mp);
237 
238  return (1);
239 }
240 
241 static void
243 {
245 
247  if (rp == 0)
248  return;
249 
251  .rp = rp,
252  .context = mp->context,
253  };
254 
256 }
257 
258 #define vl_msg_name_crc_list
259 #include <abf/abf_all_api_h.h>
260 #undef vl_msg_name_crc_list
261 
262 /* Set up the API message handling tables */
263 static clib_error_t *
265 {
266 #define _(N,n) \
267  vl_msg_api_set_handlers((VL_API_##N + abf_base_msg_id), \
268  #n, \
269  vl_api_##n##_t_handler, \
270  vl_noop_handler, \
271  vl_api_##n##_t_endian, \
272  vl_api_##n##_t_print, \
273  sizeof(vl_api_##n##_t), 1);
275 #undef _
276 
277  return 0;
278 }
279 
280 static void
282 {
283 #define _(id,n,crc) \
284  vl_msg_api_add_msg_name_crc (apim, #n "_" #crc, id + abf_base_msg_id);
285  foreach_vl_msg_name_crc_abf;
286 #undef _
287 }
288 
289 static clib_error_t *
291 {
292  clib_error_t *error = 0;
293 
294  u8 *name = format (0, "abf_%08x%c", api_version, 0);
295 
296  /* Ask for a correctly-sized block of API message decode slots */
297  abf_base_msg_id = vl_msg_api_get_msg_ids ((char *) name,
299 
300  error = abf_plugin_api_hookup (vm);
301 
302  /* Add our API messages to the global name_crc hash table */
304 
305  vec_free (name);
306 
307  return error;
308 }
309 
311 
312 /* *INDENT-OFF* */
314  .version = VPP_BUILD_VER,
315  .description = "Access Control List (ACL) Based Forwarding",
316 };
317 /* *INDENT-ON* */
318 
319 /*
320  * fd.io coding-style-patch-verification: ON
321  *
322  * Local Variables:
323  * eval: (c-set-style "gnu")
324  * End:
325  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
Add or delete a policy attachment to an interface.
Definition: abf.api:108
import vnet fib fib_types api
Definition: bier.api:22
fib_protocol_t aia_proto
The protocol for the attachment.
struct abf_dump_walk_ctx_t_ abf_dump_walk_ctx_t
A representation of a fib path for fib_path_encode to convey the information to the caller...
Definition: fib_types.h:594
A representation of a path as described by a route producer.
Definition: fib_types.h:476
vl_api_abf_policy_t policy
Definition: abf.api:80
u32 ap_id
The policy ID - as configured by the client.
Definition: abf_policy.h:58
abf_policy_t * abf_policy_get(u32 index)
Get an ABF object from its VPP index.
Definition: abf_policy.c:41
static void vl_api_abf_policy_add_del_t_handler(vl_api_abf_policy_add_del_t *mp)
Definition: abf_api.c:92
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static u32 abf_base_msg_id
Base message ID fot the plugin.
Definition: abf_api.c:58
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:34
static void vl_api_abf_policy_dump_t_handler(vl_api_abf_policy_dump_t *mp)
Definition: abf_api.c:199
int abf_itf_detach(fib_protocol_t fproto, u32 policy_id, u32 sw_if_index)
vl_api_fib_path_t paths[n_paths]
Definition: abf.api:58
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
void * vl_msg_api_alloc(int nbytes)
unsigned char u8
Definition: types.h:56
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
Policy description returned in the dump.
Definition: abf.api:77
u32 aia_abf
The VPP index of the ABF policy.
Attachment details from a dump.
Definition: abf.api:118
static int abf_policy_send_details(u32 api, void *args)
Definition: abf_api.c:159
static clib_error_t * abf_api_init(vlib_main_t *vm)
Definition: abf_api.c:290
static int abf_itf_attach_send_details(u32 aiai, void *args)
Definition: abf_api.c:216
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
vl_api_abf_itf_attach_t attach
Definition: abf.api:121
static abf_itf_attach_t * abf_itf_attach_get(u32 index)
static void vl_api_abf_itf_attach_dump_t_handler(vl_api_abf_itf_attach_dump_t *mp)
Definition: abf_api.c:242
VLIB_PLUGIN_REGISTER()
unsigned int u32
Definition: types.h:88
Get the plugin version.
Definition: abf.api:29
static void vl_api_abf_plugin_get_version_t_handler(vl_api_abf_plugin_get_version_t *mp)
Definition: abf_api.c:72
#define ABF_PLUGIN_VERSION_MAJOR
Definition: abf_policy.h:21
void abf_policy_update(u32 policy_id, u32 acl_index, const fib_route_path_t *rpaths)
Create or update an ABF Policy.
Definition: abf_policy.c:80
long ctx[MAX_CONNS]
Definition: main.c:144
vl_api_registration_t * rp
Definition: abf_api.c:154
u32 aia_sw_if_index
The interface for the attachment.
#define REPLY_MACRO(t)
void abf_policy_walk(abf_policy_walk_cb_t cb, void *ctx)
Walk/visit each of the ABF policies.
Definition: abf_policy.c:330
u8 name[64]
Definition: memclnt.api:152
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:202
An API client registration, only in vpp/vlib.
Definition: api_common.h:45
fib_node_index_t ap_pl
The path-list describing how to forward in case of a match.
Definition: abf_policy.h:48
Attachment data for an ABF policy to an interface.
vlib_main_t * vm
Definition: buffer.c:312
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
vl_api_abf_policy_t policy
Definition: abf.api:72
u32 fib_path_list_get_n_paths(fib_node_index_t path_list_index)
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:56
u32 aia_prio
The priority of this policy for attachment.
A description of an ABF policy.
Definition: abf.api:67
An ACL based Forwarding &#39;policy&#39;.
Definition: abf_policy.h:33
FIB path.
Definition: fib_types.api:47
void abf_itf_attach_walk(abf_itf_attach_walk_cb_t cb, void *ctx)
int abf_itf_attach(fib_protocol_t fproto, u32 policy_id, u32 priority, u32 sw_if_index)
#define foreach_abf_plugin_api_msg
Definition: abf_api.c:64
static void vl_api_abf_itf_attach_add_del_t_handler(vl_api_abf_itf_attach_add_del_t *mp)
Definition: abf_api.c:128
void fib_api_path_encode(const fib_route_path_encode_t *api_rpath, vl_api_fib_path_t *out)
Definition: fib_api.c:218
u32 ap_acl
ACL index to match.
Definition: abf_policy.h:43
Dump all the policy attachments.
Definition: abf.api:126
static clib_error_t * abf_plugin_api_hookup(vlib_main_t *vm)
Definition: abf_api.c:264
Reply to get the plugin version.
Definition: abf.api:40
#define ABF_PLUGIN_VERSION_MINOR
Definition: abf_policy.h:22
int fib_path_api_parse(const vl_api_fib_path_t *in, fib_route_path_t *out)
Definition: fib_api.c:43
int abf_policy_delete(u32 policy_id, const fib_route_path_t *rpaths)
Delete paths from an ABF Policy.
Definition: abf_policy.c:175
#define vec_foreach(var, vec)
Vector iterator.
fib_path_list_walk_rc_t fib_path_encode(fib_node_index_t path_list_index, fib_node_index_t path_index, const fib_path_ext_t *path_ext, void *ctx)
Definition: fib_path.c:2627
void fib_path_list_walk_w_ext(fib_node_index_t path_list_index, const fib_path_ext_list_t *ext_list, fib_path_list_walk_w_ext_fn_t func, void *ctx)
api_main_t api_main
Definition: api_shared.c:35
vl_api_abf_itf_attach_t attach
Definition: abf.api:113
static void setup_message_id_table(api_main_t *apim)
Definition: abf_api.c:281
Dump all ABF policies.
Definition: abf.api:85
u16 vl_msg_api_get_msg_ids(const char *name, int n)
Definition: api_shared.c:880