Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 37eea16

Browse files
zb-gongkuba-moo
zb-gong
authored and
kuba-moo
committed
ynl-gen-cpp: add support for generating rt-addr
This patch add basic support for netlink-raw protocol. The support can correctly generate rt-addr. To test that, a rt-addr test added in samples/. Signed-off-by: Zibo Gong <[email protected]>
1 parent bc4ddcc commit 37eea16

File tree

9 files changed

+615
-63
lines changed

9 files changed

+615
-63
lines changed

‎generated/Makefile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ TOOL:=../ynl-gen-cpp.py
1616
GENS_PATHS=$(shell grep -nrI --files-without-match \
1717
'protocol: netlink' ../Documentation/netlink/specs/)
1818
GENS_ALL=$(patsubst ../Documentation/netlink/specs/%.yaml,%,${GENS_PATHS})
19-
GENS=$(filter-out devlink ovs_datapath ovs_flow ovs_vport nlctrl,${GENS_ALL})
19+
GENS=rt-addr $(filter-out devlink ovs_datapath ovs_flow ovs_vport nlctrl,${GENS_ALL})
2020
SRCS=$(patsubst %,%-user.cpp,${GENS})
2121
HDRS=$(patsubst %,%-user.hpp,${GENS})
2222
OBJS=$(patsubst %,%-user.cpp.o,${GENS})

‎generated/rt-addr-user.cpp‎

Lines changed: 337 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,337 @@
1+
// SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause)
2+
/* Do not edit directly, auto-generated from: */
3+
/* */
4+
/* YNL-GEN user source */
5+
6+
#include "rt-addr-user.hpp"
7+
8+
#include <array>
9+
10+
#include <linux/rtnetlink.h>
11+
12+
#include <linux/genetlink.h>
13+
14+
namespace ynl_cpp {
15+
16+
/* Enums */
17+
static constexpr std::array<std::string_view, RTM_GETMULTICAST + 1> rt_addr_op_strmap = []() {
18+
std::array<std::string_view, RTM_GETMULTICAST + 1> arr{};
19+
arr[20] = "getaddr";
20+
arr[RTM_GETMULTICAST] = "getmulticast";
21+
return arr;
22+
} ();
23+
24+
std::string_view rt_addr_op_str(int op)
25+
{
26+
if (op < 0 || op >= (int)(rt_addr_op_strmap.size()))
27+
return "";
28+
return rt_addr_op_strmap[op];
29+
}
30+
31+
static constexpr std::array<std::string_view, 11 + 1> rt_addr_ifa_flags_strmap = []() {
32+
std::array<std::string_view, 11 + 1> arr{};
33+
arr[0] = "secondary";
34+
arr[1] = "nodad";
35+
arr[2] = "optimistic";
36+
arr[3] = "dadfailed";
37+
arr[4] = "homeaddress";
38+
arr[5] = "deprecated";
39+
arr[6] = "tentative";
40+
arr[7] = "permanent";
41+
arr[8] = "managetempaddr";
42+
arr[9] = "noprefixroute";
43+
arr[10] = "mcautojoin";
44+
arr[11] = "stable-privacy";
45+
return arr;
46+
} ();
47+
48+
std::string_view rt_addr_ifa_flags_str(int value)
49+
{
50+
value = (int)(ffs(value) - 1);
51+
if (value < 0 || value >= (int)(rt_addr_ifa_flags_strmap.size()))
52+
return "";
53+
return rt_addr_ifa_flags_strmap[value];
54+
}
55+
56+
/* Policies */
57+
static std::array<ynl_policy_attr,IFA_MAX + 1> rt_addr_addr_attrs_policy = []() {
58+
std::array<ynl_policy_attr,IFA_MAX + 1> arr{};
59+
arr[IFA_ADDRESS].name = "address";
60+
arr[IFA_ADDRESS].type = YNL_PT_BINARY;
61+
arr[IFA_LOCAL].name = "local";
62+
arr[IFA_LOCAL].type = YNL_PT_BINARY;
63+
arr[IFA_LABEL].name = "label";
64+
arr[IFA_LABEL].type = YNL_PT_NUL_STR;
65+
arr[IFA_BROADCAST].name = "broadcast";
66+
arr[IFA_BROADCAST].type = YNL_PT_BINARY;
67+
arr[IFA_ANYCAST].name = "anycast";
68+
arr[IFA_ANYCAST].type = YNL_PT_BINARY;
69+
arr[IFA_CACHEINFO].name = "cacheinfo";
70+
arr[IFA_CACHEINFO].type = YNL_PT_BINARY;
71+
arr[IFA_MULTICAST].name = "multicast";
72+
arr[IFA_MULTICAST].type = YNL_PT_BINARY;
73+
arr[IFA_FLAGS].name = "flags";
74+
arr[IFA_FLAGS].type = YNL_PT_U32;
75+
arr[IFA_RT_PRIORITY].name = "rt-priority";
76+
arr[IFA_RT_PRIORITY].type = YNL_PT_U32;
77+
arr[IFA_TARGET_NETNSID].name = "target-netnsid";
78+
arr[IFA_TARGET_NETNSID].type = YNL_PT_BINARY;
79+
arr[IFA_PROTO].name = "proto";
80+
arr[IFA_PROTO].type = YNL_PT_U8;
81+
return arr;
82+
} ();
83+
84+
struct ynl_policy_nest rt_addr_addr_attrs_nest = {
85+
.max_attr = static_cast<unsigned int>(IFA_MAX),
86+
.table = rt_addr_addr_attrs_policy.data(),
87+
};
88+
89+
/* Common nested types */
90+
/* ============== RTM_NEWADDR ============== */
91+
/* RTM_NEWADDR - do */
92+
int rt_addr_newaddr(ynl_cpp::ynl_socket& ys, rt_addr_newaddr_req& req)
93+
{
94+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
95+
struct nlmsghdr *nlh;
96+
size_t hdr_len;
97+
void *hdr;
98+
int err;
99+
100+
nlh = ynl_msg_start_req(ys, RTM_NEWADDR, req._nlmsg_flags);
101+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
102+
103+
hdr_len = sizeof(req._hdr);
104+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
105+
memcpy(hdr, &req._hdr, hdr_len);
106+
107+
if (req.address.size() > 0)
108+
ynl_attr_put(nlh, IFA_ADDRESS, req.address.data(), req.address.size());
109+
if (req.label.size() > 0)
110+
ynl_attr_put_str(nlh, IFA_LABEL, req.label.data());
111+
if (req.local.size() > 0)
112+
ynl_attr_put(nlh, IFA_LOCAL, req.local.data(), req.local.size());
113+
if (req.cacheinfo)
114+
ynl_attr_put(nlh, IFA_CACHEINFO, &*req.cacheinfo, sizeof(struct ifa_cacheinfo));
115+
116+
err = ynl_exec(ys, nlh, &yrs);
117+
if (err < 0)
118+
return -1;
119+
120+
return 0;
121+
}
122+
123+
/* ============== RTM_DELADDR ============== */
124+
/* RTM_DELADDR - do */
125+
int rt_addr_deladdr(ynl_cpp::ynl_socket& ys, rt_addr_deladdr_req& req)
126+
{
127+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
128+
struct nlmsghdr *nlh;
129+
size_t hdr_len;
130+
void *hdr;
131+
int err;
132+
133+
nlh = ynl_msg_start_req(ys, RTM_DELADDR, req._nlmsg_flags);
134+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
135+
136+
hdr_len = sizeof(req._hdr);
137+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
138+
memcpy(hdr, &req._hdr, hdr_len);
139+
140+
if (req.address.size() > 0)
141+
ynl_attr_put(nlh, IFA_ADDRESS, req.address.data(), req.address.size());
142+
if (req.local.size() > 0)
143+
ynl_attr_put(nlh, IFA_LOCAL, req.local.data(), req.local.size());
144+
145+
err = ynl_exec(ys, nlh, &yrs);
146+
if (err < 0)
147+
return -1;
148+
149+
return 0;
150+
}
151+
152+
/* ============== RTM_GETADDR ============== */
153+
/* RTM_GETADDR - dump */
154+
int rt_addr_getaddr_rsp_dump_parse(const struct nlmsghdr *nlh,
155+
struct ynl_parse_arg *yarg)
156+
{
157+
rt_addr_getaddr_rsp_dump *dst;
158+
const struct nlattr *attr;
159+
void *hdr;
160+
161+
dst = (rt_addr_getaddr_rsp_dump*)yarg->data;
162+
163+
hdr = ynl_nlmsg_data(nlh);
164+
memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
165+
166+
ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
167+
unsigned int type = ynl_attr_type(attr);
168+
169+
if (type == IFA_ADDRESS) {
170+
if (ynl_attr_validate(yarg, attr))
171+
return YNL_PARSE_CB_ERROR;
172+
unsigned int len = ynl_attr_data_len(attr);
173+
__u8 *data = (__u8*)ynl_attr_data(attr);
174+
dst->address.assign(data, data + len);
175+
} else if (type == IFA_LABEL) {
176+
if (ynl_attr_validate(yarg, attr))
177+
return YNL_PARSE_CB_ERROR;
178+
dst->label.assign(ynl_attr_get_str(attr));
179+
} else if (type == IFA_LOCAL) {
180+
if (ynl_attr_validate(yarg, attr))
181+
return YNL_PARSE_CB_ERROR;
182+
unsigned int len = ynl_attr_data_len(attr);
183+
__u8 *data = (__u8*)ynl_attr_data(attr);
184+
dst->local.assign(data, data + len);
185+
} else if (type == IFA_CACHEINFO) {
186+
if (ynl_attr_validate(yarg, attr))
187+
return YNL_PARSE_CB_ERROR;
188+
unsigned int len = ynl_attr_data_len(attr);
189+
unsigned int struct_sz = sizeof(struct ifa_cacheinfo);
190+
dst->cacheinfo.emplace();
191+
memcpy(&*dst->cacheinfo, ynl_attr_data(attr), std::min(struct_sz, len));
192+
}
193+
}
194+
195+
return YNL_PARSE_CB_OK;
196+
}
197+
198+
std::unique_ptr<rt_addr_getaddr_rsp_list>
199+
rt_addr_getaddr_dump(ynl_cpp::ynl_socket& ys, rt_addr_getaddr_req_dump& req)
200+
{
201+
struct ynl_dump_no_alloc_state yds = {};
202+
struct nlmsghdr *nlh;
203+
size_t hdr_len;
204+
void *hdr;
205+
int err;
206+
207+
auto ret = std::make_unique<rt_addr_getaddr_rsp_list>();
208+
yds.yarg.ys = ys;
209+
yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
210+
yds.yarg.data = ret.get();
211+
yds.alloc_cb = [](void* arg)->void*{return &(static_cast<rt_addr_getaddr_rsp_list*>(arg)->objs.emplace_back());};
212+
yds.cb = rt_addr_getaddr_rsp_dump_parse;
213+
yds.rsp_cmd = 20;
214+
215+
nlh = ynl_msg_start_dump(ys, RTM_GETADDR);
216+
hdr_len = sizeof(req._hdr);
217+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
218+
memcpy(hdr, &req._hdr, hdr_len);
219+
220+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
221+
222+
err = ynl_exec_dump_no_alloc(ys, nlh, &yds);
223+
if (err < 0)
224+
return nullptr;
225+
226+
return ret;
227+
}
228+
229+
/* ============== RTM_GETMULTICAST ============== */
230+
/* RTM_GETMULTICAST - do */
231+
int rt_addr_getmulticast_rsp_parse(const struct nlmsghdr *nlh,
232+
struct ynl_parse_arg *yarg)
233+
{
234+
rt_addr_getmulticast_rsp *dst;
235+
const struct nlattr *attr;
236+
void *hdr;
237+
238+
dst = (rt_addr_getmulticast_rsp*)yarg->data;
239+
240+
hdr = ynl_nlmsg_data(nlh);
241+
memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
242+
243+
ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
244+
unsigned int type = ynl_attr_type(attr);
245+
246+
if (type == IFA_MULTICAST) {
247+
if (ynl_attr_validate(yarg, attr))
248+
return YNL_PARSE_CB_ERROR;
249+
unsigned int len = ynl_attr_data_len(attr);
250+
__u8 *data = (__u8*)ynl_attr_data(attr);
251+
dst->multicast.assign(data, data + len);
252+
} else if (type == IFA_CACHEINFO) {
253+
if (ynl_attr_validate(yarg, attr))
254+
return YNL_PARSE_CB_ERROR;
255+
unsigned int len = ynl_attr_data_len(attr);
256+
unsigned int struct_sz = sizeof(struct ifa_cacheinfo);
257+
dst->cacheinfo.emplace();
258+
memcpy(&*dst->cacheinfo, ynl_attr_data(attr), std::min(struct_sz, len));
259+
}
260+
}
261+
262+
return YNL_PARSE_CB_OK;
263+
}
264+
265+
std::unique_ptr<rt_addr_getmulticast_rsp>
266+
rt_addr_getmulticast(ynl_cpp::ynl_socket& ys, rt_addr_getmulticast_req& req)
267+
{
268+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
269+
std::unique_ptr<rt_addr_getmulticast_rsp> rsp;
270+
struct nlmsghdr *nlh;
271+
size_t hdr_len;
272+
void *hdr;
273+
int err;
274+
275+
nlh = ynl_msg_start_req(ys, RTM_GETMULTICAST, req._nlmsg_flags);
276+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
277+
yrs.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
278+
279+
hdr_len = sizeof(req._hdr);
280+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
281+
memcpy(hdr, &req._hdr, hdr_len);
282+
283+
rsp.reset(new rt_addr_getmulticast_rsp());
284+
yrs.yarg.data = rsp.get();
285+
yrs.cb = rt_addr_getmulticast_rsp_parse;
286+
yrs.rsp_cmd = RTM_GETMULTICAST;
287+
288+
err = ynl_exec(ys, nlh, &yrs);
289+
if (err < 0)
290+
return nullptr;
291+
292+
return rsp;
293+
}
294+
295+
/* RTM_GETMULTICAST - dump */
296+
std::unique_ptr<rt_addr_getmulticast_list>
297+
rt_addr_getmulticast_dump(ynl_cpp::ynl_socket& ys,
298+
rt_addr_getmulticast_req_dump& req)
299+
{
300+
struct ynl_dump_no_alloc_state yds = {};
301+
struct nlmsghdr *nlh;
302+
size_t hdr_len;
303+
void *hdr;
304+
int err;
305+
306+
auto ret = std::make_unique<rt_addr_getmulticast_list>();
307+
yds.yarg.ys = ys;
308+
yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
309+
yds.yarg.data = ret.get();
310+
yds.alloc_cb = [](void* arg)->void*{return &(static_cast<rt_addr_getmulticast_list*>(arg)->objs.emplace_back());};
311+
yds.cb = rt_addr_getmulticast_rsp_parse;
312+
yds.rsp_cmd = RTM_GETMULTICAST;
313+
314+
nlh = ynl_msg_start_dump(ys, RTM_GETMULTICAST);
315+
hdr_len = sizeof(req._hdr);
316+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
317+
memcpy(hdr, &req._hdr, hdr_len);
318+
319+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
320+
321+
err = ynl_exec_dump_no_alloc(ys, nlh, &yds);
322+
if (err < 0)
323+
return nullptr;
324+
325+
return ret;
326+
}
327+
328+
const struct ynl_family ynl_rt_addr_family = {
329+
.name = "rt_addr",
330+
.is_classic = true,
331+
.classic_id = 0,
332+
.hdr_len = sizeof(struct ifaddrmsg),
333+
};
334+
const struct ynl_family& get_ynl_rt_addr_family() {
335+
return ynl_rt_addr_family;
336+
};
337+
} //namespace ynl_cpp

0 commit comments

Comments
 (0)