abf_api.c revision 9f3d2117
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 <vnet/format_fns.h>
33#include <abf/abf.api_enum.h>
34#include <abf/abf.api_types.h>
35
36/**
37 * Base message ID fot the plugin
38 */
39static u32 abf_base_msg_id;
40
41#include <vlibapi/api_helper_macros.h>
42
43static void
44vl_api_abf_plugin_get_version_t_handler (vl_api_abf_plugin_get_version_t * mp)
45{
46  vl_api_abf_plugin_get_version_reply_t *rmp;
47  vl_api_registration_t *rp;
48
49  rp = vl_api_client_index_to_registration (mp->client_index);
50  if (rp == 0)
51    return;
52
53  rmp = vl_msg_api_alloc (sizeof (*rmp));
54  rmp->_vl_msg_id =
55    ntohs (VL_API_ABF_PLUGIN_GET_VERSION_REPLY + abf_base_msg_id);
56  rmp->context = mp->context;
57  rmp->major = htonl (ABF_PLUGIN_VERSION_MAJOR);
58  rmp->minor = htonl (ABF_PLUGIN_VERSION_MINOR);
59
60  vl_api_send_msg (rp, (u8 *) rmp);
61}
62
63static void
64vl_api_abf_policy_add_del_t_handler (vl_api_abf_policy_add_del_t * mp)
65{
66  vl_api_abf_policy_add_del_reply_t *rmp;
67  fib_route_path_t *paths = NULL, *path;
68  int rv = 0;
69  u8 pi;
70
71  vec_validate (paths, mp->policy.n_paths - 1);
72
73  for (pi = 0; pi < mp->policy.n_paths; pi++)
74    {
75      path = &paths[pi];
76      rv = fib_api_path_decode (&mp->policy.paths[pi], path);
77
78      if (0 != rv)
79	{
80	  goto done;
81	}
82    }
83
84  if (mp->is_add)
85    {
86      rv = abf_policy_update (ntohl (mp->policy.policy_id),
87			      ntohl (mp->policy.acl_index), paths);
88    }
89  else
90    {
91      rv = abf_policy_delete (ntohl (mp->policy.policy_id), paths);
92    }
93done:
94  vec_free (paths);
95
96  REPLY_MACRO (VL_API_ABF_POLICY_ADD_DEL_REPLY + abf_base_msg_id);
97}
98
99static void
100vl_api_abf_itf_attach_add_del_t_handler (vl_api_abf_itf_attach_add_del_t * mp)
101{
102  vl_api_abf_itf_attach_add_del_reply_t *rmp;
103  fib_protocol_t fproto = (mp->attach.is_ipv6 ?
104			   FIB_PROTOCOL_IP6 : FIB_PROTOCOL_IP4);
105  int rv = 0;
106
107  if (mp->is_add)
108    {
109      abf_itf_attach (fproto,
110		      ntohl (mp->attach.policy_id),
111		      ntohl (mp->attach.priority),
112		      ntohl (mp->attach.sw_if_index));
113    }
114  else
115    {
116      abf_itf_detach (fproto,
117		      ntohl (mp->attach.policy_id),
118		      ntohl (mp->attach.sw_if_index));
119    }
120
121  REPLY_MACRO (VL_API_ABF_ITF_ATTACH_ADD_DEL_REPLY + abf_base_msg_id);
122}
123
124typedef struct abf_dump_walk_ctx_t_
125{
126  vl_api_registration_t *rp;
127  u32 context;
128} abf_dump_walk_ctx_t;
129
130static int
131abf_policy_send_details (u32 api, void *args)
132{
133  fib_path_encode_ctx_t walk_ctx = {
134    .rpaths = NULL,
135  };
136  vl_api_abf_policy_details_t *mp;
137  abf_dump_walk_ctx_t *ctx;
138  fib_route_path_t *rpath;
139  vl_api_fib_path_t *fp;
140  size_t msg_size;
141  abf_policy_t *ap;
142  u8 n_paths;
143
144  ctx = args;
145  ap = abf_policy_get (api);
146  n_paths = fib_path_list_get_n_paths (ap->ap_pl);
147  msg_size = sizeof (*mp) + sizeof (mp->policy.paths[0]) * n_paths;
148
149  mp = vl_msg_api_alloc (msg_size);
150  clib_memset (mp, 0, msg_size);
151  mp->_vl_msg_id = ntohs (VL_API_ABF_POLICY_DETAILS + abf_base_msg_id);
152
153  /* fill in the message */
154  mp->context = ctx->context;
155  mp->policy.n_paths = n_paths;
156  mp->policy.acl_index = htonl (ap->ap_acl);
157  mp->policy.policy_id = htonl (ap->ap_id);
158
159  fib_path_list_walk_w_ext (ap->ap_pl, NULL, fib_path_encode, &walk_ctx);
160
161  fp = mp->policy.paths;
162  vec_foreach (rpath, walk_ctx.rpaths)
163  {
164    fib_api_path_encode (rpath, fp);
165    fp++;
166  }
167
168  vl_api_send_msg (ctx->rp, (u8 *) mp);
169
170  vec_free (walk_ctx.rpaths);
171
172  return (1);
173}
174
175static void
176vl_api_abf_policy_dump_t_handler (vl_api_abf_policy_dump_t * mp)
177{
178  vl_api_registration_t *rp;
179
180  rp = vl_api_client_index_to_registration (mp->client_index);
181  if (rp == 0)
182    return;
183
184  abf_dump_walk_ctx_t ctx = {
185    .rp = rp,
186    .context = mp->context,
187  };
188
189  abf_policy_walk (abf_policy_send_details, &ctx);
190}
191
192static int
193abf_itf_attach_send_details (u32 aiai, void *args)
194{
195  vl_api_abf_itf_attach_details_t *mp;
196  abf_dump_walk_ctx_t *ctx;
197  abf_itf_attach_t *aia;
198  abf_policy_t *ap;
199
200  ctx = args;
201  aia = abf_itf_attach_get (aiai);
202  ap = abf_policy_get (aia->aia_abf);
203
204  mp = vl_msg_api_alloc (sizeof (*mp));
205  mp->_vl_msg_id = ntohs (VL_API_ABF_ITF_ATTACH_DETAILS + abf_base_msg_id);
206
207  mp->context = ctx->context;
208  mp->attach.policy_id = htonl (ap->ap_id);
209  mp->attach.sw_if_index = htonl (aia->aia_sw_if_index);
210  mp->attach.priority = htonl (aia->aia_prio);
211  mp->attach.is_ipv6 = (aia->aia_proto == FIB_PROTOCOL_IP6);
212
213  vl_api_send_msg (ctx->rp, (u8 *) mp);
214
215  return (1);
216}
217
218static void
219vl_api_abf_itf_attach_dump_t_handler (vl_api_abf_itf_attach_dump_t * mp)
220{
221  vl_api_registration_t *rp;
222
223  rp = vl_api_client_index_to_registration (mp->client_index);
224  if (rp == 0)
225    return;
226
227  abf_dump_walk_ctx_t ctx = {
228    .rp = rp,
229    .context = mp->context,
230  };
231
232  abf_itf_attach_walk (abf_itf_attach_send_details, &ctx);
233}
234
235#include <abf/abf.api.c>
236
237static clib_error_t *
238abf_api_init (vlib_main_t * vm)
239{
240  /* Ask for a correctly-sized block of API message decode slots */
241  abf_base_msg_id = setup_message_id_table ();
242
243  return 0;
244}
245
246VLIB_INIT_FUNCTION (abf_api_init);
247
248/* *INDENT-OFF* */
249VLIB_PLUGIN_REGISTER () = {
250    .version = VPP_BUILD_VER,
251    .description = "Access Control List (ACL) Based Forwarding",
252};
253/* *INDENT-ON* */
254
255/*
256 * fd.io coding-style-patch-verification: ON
257 *
258 * Local Variables:
259 * eval: (c-set-style "gnu")
260 * End:
261 */
262