FD.io VPP
v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
l2e_api.c
Go to the documentation of this file.
1
/*
2
*------------------------------------------------------------------
3
* l2e_api.c - layer 2 emulation api
4
*
5
* Copyright (c) 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 <
vnet/vnet.h
>
21
#include <
vnet/plugin/plugin.h
>
22
23
#include <
vnet/interface.h
>
24
#include <
vnet/api_errno.h
>
25
#include <vpp/app/version.h>
26
27
#include <
l2e/l2e.h
>
28
29
#include <
vlibapi/api.h
>
30
#include <
vlibmemory/api.h
>
31
32
/* define message IDs */
33
#include <
l2e/l2e_msg_enum.h
>
34
35
#define vl_typedefs
/* define message structures */
36
#include <
l2e/l2e_all_api_h.h
>
37
#undef vl_typedefs
38
39
#define vl_endianfun
/* define message structures */
40
#include <
l2e/l2e_all_api_h.h
>
41
#undef vl_endianfun
42
43
/* instantiate all the print functions we know about */
44
#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
45
#define vl_printfun
46
#include <
l2e/l2e_all_api_h.h
>
47
#undef vl_printfun
48
49
/* Get the API version number */
50
#define vl_api_version(n,v) static u32 api_version=(v);
51
#include <
l2e/l2e_all_api_h.h
>
52
#undef vl_api_version
53
54
#include <
vlibapi/api_helper_macros.h
>
55
56
#define foreach_l2e_api_msg \
57
_(L2_EMULATION, l2_emulation)
58
59
#define L2E_MSG_BASE l2em->msg_id_base
60
61
static
void
62
vl_api_l2_emulation_t_handler
(
vl_api_l2_emulation_t
* mp)
63
{
64
l2_emulation_main_t
*l2em = &
l2_emulation_main
;
65
vl_api_l2_emulation_reply_t *rmp;
66
int
rv = 0;
67
68
VALIDATE_SW_IF_INDEX
(mp);
69
70
u32
sw_if_index
= ntohl (mp->
sw_if_index
);
71
72
if
(mp->
enable
)
73
l2_emulation_enable
(sw_if_index);
74
else
75
l2_emulation_disable
(sw_if_index);
76
77
BAD_SW_IF_INDEX_LABEL
;
78
79
REPLY_MACRO
(VL_API_L2_EMULATION_REPLY +
L2E_MSG_BASE
);
80
}
81
82
/*
83
* l2_api_hookup
84
* Add vpe's API message handlers to the table.
85
* vlib has already mapped shared memory and
86
* added the client registration handlers.
87
* See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
88
*/
89
#define vl_msg_name_crc_list
90
#include <
l2e/l2e_all_api_h.h
>
91
#undef vl_msg_name_crc_list
92
93
static
void
94
setup_message_id_table
(
api_main_t
* am)
95
{
96
l2_emulation_main_t
*l2em = &
l2_emulation_main
;
97
#define _(id,n,crc) \
98
vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id + L2E_MSG_BASE);
99
foreach_vl_msg_name_crc_l2e;
100
#undef _
101
}
102
103
static
void
104
l2e_api_hookup
(
vlib_main_t
*
vm
)
105
{
106
l2_emulation_main_t
*l2em = &
l2_emulation_main
;
107
#define _(N,n) \
108
vl_msg_api_set_handlers(VL_API_##N + L2E_MSG_BASE, \
109
#n, \
110
vl_api_##n##_t_handler, \
111
vl_noop_handler, \
112
vl_api_##n##_t_endian, \
113
vl_api_##n##_t_print, \
114
sizeof(vl_api_##n##_t), 1);
115
foreach_l2e_api_msg
;
116
#undef _
117
}
118
119
static
clib_error_t
*
120
l2e_init
(
vlib_main_t
*
vm
)
121
{
122
api_main_t
*am = &
api_main
;
123
l2_emulation_main_t
*l2em = &
l2_emulation_main
;
124
u8
*
name
=
format
(0,
"l2e_%08x%c"
, api_version, 0);
125
126
/* Ask for a correctly-sized block of API message decode slots */
127
l2em->
msg_id_base
=
vl_msg_api_get_msg_ids
((
char
*) name,
128
VL_MSG_FIRST_AVAILABLE
);
129
130
l2e_api_hookup
(vm);
131
132
/* Add our API messages to the global name_crc hash table */
133
setup_message_id_table
(am);
134
135
vec_free
(name);
136
return
(
NULL
);
137
}
138
139
VLIB_API_INIT_FUNCTION
(
l2e_init
);
140
141
/* *INDENT-OFF* */
142
VLIB_PLUGIN_REGISTER
() = {
143
.version = VPP_BUILD_VER,
144
.description =
"Layer 2 (L2) Emulation"
,
145
};
146
/* *INDENT-ON* */
147
148
149
/*
150
* fd.io coding-style-patch-verification: ON
151
*
152
* Local Variables:
153
* eval: (c-set-style "gnu")
154
* End:
155
*/
sw_if_index
u32 sw_if_index
Definition:
ipsec_gre.api:37
foreach_l2e_api_msg
#define foreach_l2e_api_msg
Definition:
l2e_api.c:56
l2e_all_api_h.h
NULL
#define NULL
Definition:
clib.h:58
l2_emulation_main_t_
Grouping of global data for the L2 emulation feature.
Definition:
l2e.h:46
l2_emulation_disable
void l2_emulation_disable(u32 sw_if_index)
Definition:
l2e.c:53
format
u8 * format(u8 *s, const char *fmt,...)
Definition:
format.c:424
u8
unsigned char u8
Definition:
types.h:56
plugin.h
api.h
VL_MSG_FIRST_AVAILABLE
Definition:
vnet_msg_enum.h:25
api_errno.h
u32
unsigned int u32
Definition:
types.h:88
api_helper_macros.h
interface.h
VLIB_PLUGIN_REGISTER
VLIB_PLUGIN_REGISTER()
l2_emulation_main
l2_emulation_main_t l2_emulation_main
Definition:
l2e.c:23
REPLY_MACRO
#define REPLY_MACRO(t)
Definition:
api_helper_macros.h:30
vl_api_l2_emulation_t::enable
u8 enable
Definition:
l2e.api:30
l2e.h
name
u8 name[64]
Definition:
memclnt.api:152
vnet.h
api_main_t
API main structure, used by both vpp and binary API clients.
Definition:
api_common.h:202
l2_emulation_main_t_::msg_id_base
u16 msg_id_base
Definition:
l2e.h:48
BAD_SW_IF_INDEX_LABEL
#define BAD_SW_IF_INDEX_LABEL
Definition:
api_helper_macros.h:125
l2e_init
static clib_error_t * l2e_init(vlib_main_t *vm)
Definition:
l2e_api.c:120
vm
vlib_main_t * vm
Definition:
buffer.c:312
setup_message_id_table
static void setup_message_id_table(api_main_t *am)
Definition:
l2e_api.c:94
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition:
vec.h:341
VLIB_API_INIT_FUNCTION
VLIB_API_INIT_FUNCTION(l2e_init)
l2e_api_hookup
static void l2e_api_hookup(vlib_main_t *vm)
Definition:
l2e_api.c:104
l2_emulation_enable
void l2_emulation_enable(u32 sw_if_index)
L2 Emulation is a feautre that is applied to L2 ports to 'extract' IP packets from the L2 path and in...
Definition:
l2e.c:31
l2e_msg_enum.h
clib_error_t
Definition:
clib_error.h:21
api.h
vlib_main_t
Definition:
main.h:68
vl_api_l2_emulation_t
L2 emulation at L3.
Definition:
l2e.api:25
L2E_MSG_BASE
#define L2E_MSG_BASE
Definition:
l2e_api.c:59
vl_api_l2_emulation_t_handler
static void vl_api_l2_emulation_t_handler(vl_api_l2_emulation_t *mp)
Definition:
l2e_api.c:62
api_main
api_main_t api_main
Definition:
api_shared.c:35
vl_api_l2_emulation_t::sw_if_index
u32 sw_if_index
Definition:
l2e.api:29
VALIDATE_SW_IF_INDEX
#define VALIDATE_SW_IF_INDEX(mp)
Definition:
api_helper_macros.h:117
vl_msg_api_get_msg_ids
u16 vl_msg_api_get_msg_ids(const char *name, int n)
Definition:
api_shared.c:880
src
plugins
l2e
l2e_api.c
Generated on Mon Jun 29 2020 14:36:09 for FD.io VPP by
1.8.13