Skip to content

Commit 8609a76

Browse files
zb-gongzb-gong
committed
ynl-gen-cpp: add support for generating rt-addr
1 parent 595ec7e commit 8609a76

File tree

10 files changed

+620
-63
lines changed

10 files changed

+620
-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: 342 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,342 @@
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+
((struct ynl_sock*)ys)->req_hdr_len = ((struct ynl_sock*)ys)->family->hdr_len;
103+
104+
hdr_len = sizeof(req._hdr);
105+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
106+
memcpy(hdr, &req._hdr, hdr_len);
107+
108+
if (req.address.size() > 0)
109+
ynl_attr_put(nlh, IFA_ADDRESS, req.address.data(), req.address.size());
110+
if (req.label.size() > 0)
111+
ynl_attr_put_str(nlh, IFA_LABEL, req.label.data());
112+
if (req.local.size() > 0)
113+
ynl_attr_put(nlh, IFA_LOCAL, req.local.data(), req.local.size());
114+
if (req.cacheinfo.size() > 0)
115+
ynl_attr_put(nlh, IFA_CACHEINFO, req.cacheinfo.data(), req.cacheinfo.size());
116+
117+
err = ynl_exec(ys, nlh, &yrs);
118+
if (err < 0)
119+
return -1;
120+
121+
return 0;
122+
}
123+
124+
/* ============== RTM_DELADDR ============== */
125+
/* RTM_DELADDR - do */
126+
int rt_addr_deladdr(ynl_cpp::ynl_socket& ys, rt_addr_deladdr_req& req)
127+
{
128+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
129+
struct nlmsghdr *nlh;
130+
size_t hdr_len;
131+
void *hdr;
132+
int err;
133+
134+
nlh = ynl_msg_start_req(ys, RTM_DELADDR, req._nlmsg_flags);
135+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
136+
((struct ynl_sock*)ys)->req_hdr_len = ((struct ynl_sock*)ys)->family->hdr_len;
137+
138+
hdr_len = sizeof(req._hdr);
139+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
140+
memcpy(hdr, &req._hdr, hdr_len);
141+
142+
if (req.address.size() > 0)
143+
ynl_attr_put(nlh, IFA_ADDRESS, req.address.data(), req.address.size());
144+
if (req.local.size() > 0)
145+
ynl_attr_put(nlh, IFA_LOCAL, req.local.data(), req.local.size());
146+
147+
err = ynl_exec(ys, nlh, &yrs);
148+
if (err < 0)
149+
return -1;
150+
151+
return 0;
152+
}
153+
154+
/* ============== RTM_GETADDR ============== */
155+
/* RTM_GETADDR - dump */
156+
int rt_addr_getaddr_rsp_dump_parse(const struct nlmsghdr *nlh,
157+
struct ynl_parse_arg *yarg)
158+
{
159+
rt_addr_getaddr_rsp_dump *dst;
160+
const struct nlattr *attr;
161+
void *hdr;
162+
163+
dst = (rt_addr_getaddr_rsp_dump*)yarg->data;
164+
165+
hdr = ynl_nlmsg_data(nlh);
166+
memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
167+
168+
ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
169+
unsigned int type = ynl_attr_type(attr);
170+
171+
if (type == IFA_ADDRESS) {
172+
if (ynl_attr_validate(yarg, attr))
173+
return YNL_PARSE_CB_ERROR;
174+
unsigned int len = ynl_attr_data_len(attr);
175+
__u8 *data = (__u8*)ynl_attr_data(attr);
176+
dst->address.assign(data, data + len);
177+
} else if (type == IFA_LABEL) {
178+
if (ynl_attr_validate(yarg, attr))
179+
return YNL_PARSE_CB_ERROR;
180+
dst->label.assign(ynl_attr_get_str(attr));
181+
} else if (type == IFA_LOCAL) {
182+
if (ynl_attr_validate(yarg, attr))
183+
return YNL_PARSE_CB_ERROR;
184+
unsigned int len = ynl_attr_data_len(attr);
185+
__u8 *data = (__u8*)ynl_attr_data(attr);
186+
dst->local.assign(data, data + len);
187+
} else if (type == IFA_CACHEINFO) {
188+
if (ynl_attr_validate(yarg, attr))
189+
return YNL_PARSE_CB_ERROR;
190+
unsigned int len = ynl_attr_data_len(attr);
191+
__u8 *data = (__u8*)ynl_attr_data(attr);
192+
dst->cacheinfo.assign(data, data + len);
193+
}
194+
}
195+
196+
return YNL_PARSE_CB_OK;
197+
}
198+
199+
std::unique_ptr<rt_addr_getaddr_rsp_list>
200+
rt_addr_getaddr_dump(ynl_cpp::ynl_socket& ys, rt_addr_getaddr_req_dump& req)
201+
{
202+
struct ynl_dump_no_alloc_state yds = {};
203+
struct nlmsghdr *nlh;
204+
size_t hdr_len;
205+
void *hdr;
206+
int err;
207+
208+
auto ret = std::make_unique<rt_addr_getaddr_rsp_list>();
209+
yds.yarg.ys = ys;
210+
yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
211+
yds.yarg.data = ret.get();
212+
yds.alloc_cb = [](void* arg)->void*{return &(static_cast<rt_addr_getaddr_rsp_list*>(arg)->objs.emplace_back());};
213+
yds.cb = rt_addr_getaddr_rsp_dump_parse;
214+
yds.rsp_cmd = 20;
215+
216+
nlh = ynl_msg_start_dump(ys, RTM_GETADDR);
217+
hdr_len = sizeof(req._hdr);
218+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
219+
memcpy(hdr, &req._hdr, hdr_len);
220+
221+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
222+
((struct ynl_sock*)ys)->req_hdr_len = ((struct ynl_sock*)ys)->family->hdr_len;
223+
224+
err = ynl_exec_dump_no_alloc(ys, nlh, &yds);
225+
std::cout << "err = " << err << std::endl;
226+
if (err < 0)
227+
return nullptr;
228+
229+
return ret;
230+
}
231+
232+
/* ============== RTM_GETMULTICAST ============== */
233+
/* RTM_GETMULTICAST - do */
234+
int rt_addr_getmulticast_rsp_parse(const struct nlmsghdr *nlh,
235+
struct ynl_parse_arg *yarg)
236+
{
237+
rt_addr_getmulticast_rsp *dst;
238+
const struct nlattr *attr;
239+
void *hdr;
240+
241+
dst = (rt_addr_getmulticast_rsp*)yarg->data;
242+
243+
hdr = ynl_nlmsg_data(nlh);
244+
memcpy(&dst->_hdr, hdr, sizeof(struct ifaddrmsg));
245+
246+
ynl_attr_for_each(attr, nlh, yarg->ys->family->hdr_len) {
247+
unsigned int type = ynl_attr_type(attr);
248+
249+
if (type == IFA_MULTICAST) {
250+
if (ynl_attr_validate(yarg, attr))
251+
return YNL_PARSE_CB_ERROR;
252+
unsigned int len = ynl_attr_data_len(attr);
253+
__u8 *data = (__u8*)ynl_attr_data(attr);
254+
dst->multicast.assign(data, data + len);
255+
} else if (type == IFA_CACHEINFO) {
256+
if (ynl_attr_validate(yarg, attr))
257+
return YNL_PARSE_CB_ERROR;
258+
unsigned int len = ynl_attr_data_len(attr);
259+
__u8 *data = (__u8*)ynl_attr_data(attr);
260+
dst->cacheinfo.assign(data, data + len);
261+
}
262+
}
263+
264+
return YNL_PARSE_CB_OK;
265+
}
266+
267+
std::unique_ptr<rt_addr_getmulticast_rsp>
268+
rt_addr_getmulticast(ynl_cpp::ynl_socket& ys, rt_addr_getmulticast_req& req)
269+
{
270+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
271+
std::unique_ptr<rt_addr_getmulticast_rsp> rsp;
272+
struct nlmsghdr *nlh;
273+
size_t hdr_len;
274+
void *hdr;
275+
int err;
276+
277+
nlh = ynl_msg_start_req(ys, RTM_GETMULTICAST, req._nlmsg_flags);
278+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
279+
((struct ynl_sock*)ys)->req_hdr_len = ((struct ynl_sock*)ys)->family->hdr_len;
280+
yrs.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
281+
282+
hdr_len = sizeof(req._hdr);
283+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
284+
memcpy(hdr, &req._hdr, hdr_len);
285+
286+
rsp.reset(new rt_addr_getmulticast_rsp());
287+
yrs.yarg.data = rsp.get();
288+
yrs.cb = rt_addr_getmulticast_rsp_parse;
289+
yrs.rsp_cmd = RTM_GETMULTICAST;
290+
291+
err = ynl_exec(ys, nlh, &yrs);
292+
if (err < 0)
293+
return nullptr;
294+
295+
return rsp;
296+
}
297+
298+
/* RTM_GETMULTICAST - dump */
299+
std::unique_ptr<rt_addr_getmulticast_list>
300+
rt_addr_getmulticast_dump(ynl_cpp::ynl_socket& ys,
301+
rt_addr_getmulticast_req_dump& req)
302+
{
303+
struct ynl_dump_no_alloc_state yds = {};
304+
struct nlmsghdr *nlh;
305+
size_t hdr_len;
306+
void *hdr;
307+
int err;
308+
309+
auto ret = std::make_unique<rt_addr_getmulticast_list>();
310+
yds.yarg.ys = ys;
311+
yds.yarg.rsp_policy = &rt_addr_addr_attrs_nest;
312+
yds.yarg.data = ret.get();
313+
yds.alloc_cb = [](void* arg)->void*{return &(static_cast<rt_addr_getmulticast_list*>(arg)->objs.emplace_back());};
314+
yds.cb = rt_addr_getmulticast_rsp_parse;
315+
yds.rsp_cmd = RTM_GETMULTICAST;
316+
317+
nlh = ynl_msg_start_dump(ys, RTM_GETMULTICAST);
318+
hdr_len = sizeof(req._hdr);
319+
hdr = ynl_nlmsg_put_extra_header(nlh, hdr_len);
320+
memcpy(hdr, &req._hdr, hdr_len);
321+
322+
((struct ynl_sock*)ys)->req_policy = &rt_addr_addr_attrs_nest;
323+
((struct ynl_sock*)ys)->req_hdr_len = ((struct ynl_sock*)ys)->family->hdr_len;
324+
325+
err = ynl_exec_dump_no_alloc(ys, nlh, &yds);
326+
std::cout << "err = " << err << std::endl;
327+
if (err < 0)
328+
return nullptr;
329+
330+
return ret;
331+
}
332+
333+
const struct ynl_family ynl_rt_addr_family = {
334+
.name = "rt_addr",
335+
.is_classic = true,
336+
.classic_id = 0,
337+
.hdr_len = sizeof(struct ifaddrmsg),
338+
};
339+
const struct ynl_family& get_ynl_rt_addr_family() {
340+
return ynl_rt_addr_family;
341+
};
342+
} //namespace ynl_cpp

0 commit comments

Comments
 (0)