FD.io VPP  v21.10.1-2-g0a485f517
Vector Packet Processing
netlink.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2017 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17 
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <net/if.h>
22 
23 #include <linux/netlink.h>
24 #include <linux/rtnetlink.h>
25 
26 #include <vlib/vlib.h>
27 #include <vlib/unix/unix.h>
28 #include <vnet/devices/netlink.h>
29 
30 typedef struct
31 {
32  u8 *data;
33 } vnet_netlink_msg_t;
34 
35 static void
36 vnet_netlink_msg_init (vnet_netlink_msg_t * m, u16 type, u16 flags,
37  void *msg_data, int msg_len)
38 {
39  struct nlmsghdr *nh;
40  u8 *p;
41  clib_memset (m, 0, sizeof (vnet_netlink_msg_t));
42  vec_add2 (m->data, p, NLMSG_SPACE (msg_len));
43  ASSERT (m->data == p);
44 
45  nh = (struct nlmsghdr *) p;
46  nh->nlmsg_flags = flags | NLM_F_ACK;
47  nh->nlmsg_type = type;
48  clib_memcpy (m->data + sizeof (struct nlmsghdr), msg_data, msg_len);
49 }
50 
51 static void
52 vnet_netlink_msg_add_rtattr (vnet_netlink_msg_t * m, u16 rta_type,
53  void *rta_data, int rta_data_len)
54 {
55  struct rtattr *rta;
56  u8 *p;
57 
58  vec_add2 (m->data, p, RTA_SPACE (rta_data_len));
59  rta = (struct rtattr *) p;
60  rta->rta_type = rta_type;
61  rta->rta_len = RTA_LENGTH (rta_data_len);
62  clib_memcpy (RTA_DATA (rta), rta_data, rta_data_len);
63 }
64 
65 static clib_error_t *
66 vnet_netlink_msg_send (vnet_netlink_msg_t *m, vnet_netlink_msg_t **replies)
67 {
68  clib_error_t *err = 0;
69  struct sockaddr_nl ra = { 0 };
70  int len, sock;
71  struct nlmsghdr *nh = (struct nlmsghdr *) m->data;
72  nh->nlmsg_len = vec_len (m->data);
73  char buf[4096];
74 
75  if ((sock = socket (AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) == -1)
76  return clib_error_return_unix (0, "socket(AF_NETLINK)");
77 
78  ra.nl_family = AF_NETLINK;
79  ra.nl_pid = 0;
80 
81  if ((bind (sock, (struct sockaddr *) &ra, sizeof (ra))) == -1)
82  {
83  err = clib_error_return_unix (0, "bind");
84  goto done;
85  }
86 
87  if ((send (sock, m->data, vec_len (m->data), 0)) == -1)
88  err = clib_error_return_unix (0, "send");
89 
90  if ((len = recv (sock, buf, sizeof (buf), 0)) == -1)
91  err = clib_error_return_unix (0, "recv");
92 
93  for (nh = (struct nlmsghdr *) buf; NLMSG_OK (nh, len);
94  nh = NLMSG_NEXT (nh, len))
95  {
96  if (nh->nlmsg_type == NLMSG_DONE)
97  goto done;
98 
99  if (nh->nlmsg_type == NLMSG_ERROR)
100  {
101  struct nlmsgerr *e = (struct nlmsgerr *) NLMSG_DATA (nh);
102  if (e->error)
103  err = clib_error_return (0, "netlink error %d", e->error);
104  goto done;
105  }
106 
107  if (replies)
108  {
109  vnet_netlink_msg_t msg = { NULL };
110  u8 *p;
111  vec_add2 (msg.data, p, nh->nlmsg_len);
112  clib_memcpy (p, nh, nh->nlmsg_len);
113  vec_add1 (*replies, msg);
114  }
115  }
116 
117 done:
118  close (sock);
119  vec_free (m->data);
120  return err;
121 }
122 
123 clib_error_t *
124 vnet_netlink_set_link_name (int ifindex, char *new_ifname)
125 {
126  vnet_netlink_msg_t m;
127  struct ifinfomsg ifmsg = { 0 };
128  clib_error_t *err = 0;
129 
130  ifmsg.ifi_index = ifindex;
131  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
132  &ifmsg, sizeof (struct ifinfomsg));
133 
134  vnet_netlink_msg_add_rtattr (&m, IFLA_IFNAME, new_ifname,
135  strlen (new_ifname) + 1);
136 
137  err = vnet_netlink_msg_send (&m, NULL);
138  if (err)
139  err = clib_error_return (0, "set link name %U", format_clib_error, err);
140  return err;
141 }
142 
143 clib_error_t *
144 vnet_netlink_set_link_netns (int ifindex, int netns_fd, char *new_ifname)
145 {
146  vnet_netlink_msg_t m;
147  struct ifinfomsg ifmsg = { 0 };
148  clib_error_t *err = 0;
149 
150  ifmsg.ifi_index = ifindex;
151  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
152  &ifmsg, sizeof (struct ifinfomsg));
153 
154  vnet_netlink_msg_add_rtattr (&m, IFLA_NET_NS_FD, &netns_fd, sizeof (int));
155  if (new_ifname)
156  vnet_netlink_msg_add_rtattr (&m, IFLA_IFNAME, new_ifname,
157  strlen (new_ifname) + 1);
158 
159  err = vnet_netlink_msg_send (&m, NULL);
160  if (err)
161  err = clib_error_return (0, "set link netns %U", format_clib_error, err);
162  return err;
163 }
164 
165 clib_error_t *
166 vnet_netlink_set_link_master (int ifindex, char *master_ifname)
167 {
168  vnet_netlink_msg_t m;
169  struct ifinfomsg ifmsg = { 0 };
170  int i;
171  clib_error_t *err = 0;
172 
173  ifmsg.ifi_index = ifindex;
174 
175  if ((i = if_nametoindex (master_ifname)) == 0)
176  clib_error_return_unix (0, "unknown master interface '%s'",
177  master_ifname);
178 
179  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
180  &ifmsg, sizeof (struct ifinfomsg));
181  vnet_netlink_msg_add_rtattr (&m, IFLA_MASTER, &i, sizeof (int));
182  err = vnet_netlink_msg_send (&m, NULL);
183  if (err)
184  err = clib_error_return (0, "set link master %U", format_clib_error, err);
185  return err;
186 }
187 
188 clib_error_t *
189 vnet_netlink_set_link_addr (int ifindex, u8 * mac)
190 {
191  vnet_netlink_msg_t m;
192  struct ifinfomsg ifmsg = { 0 };
193  clib_error_t *err = 0;
194 
195  ifmsg.ifi_index = ifindex;
196 
197  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
198  &ifmsg, sizeof (struct ifinfomsg));
199  vnet_netlink_msg_add_rtattr (&m, IFLA_ADDRESS, mac, 6);
200  err = vnet_netlink_msg_send (&m, NULL);
201  if (err)
202  err = clib_error_return (0, "set link addr %U", format_clib_error, err);
203  return err;
204 }
205 
206 clib_error_t *
207 vnet_netlink_set_link_state (int ifindex, int up)
208 {
209  vnet_netlink_msg_t m;
210  struct ifinfomsg ifmsg = { 0 };
211  clib_error_t *err = 0;
212 
213  ifmsg.ifi_flags = ((up) ? IFF_UP : 0);
214  ifmsg.ifi_change = IFF_UP;
215  ifmsg.ifi_index = ifindex;
216 
217  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
218  &ifmsg, sizeof (struct ifinfomsg));
219  err = vnet_netlink_msg_send (&m, NULL);
220  if (err)
221  err = clib_error_return (0, "set link state %U", format_clib_error, err);
222  return err;
223 }
224 
225 clib_error_t *
226 vnet_netlink_get_link_mtu (int ifindex, u32 *mtu)
227 {
228  vnet_netlink_msg_t m, *msg;
229  struct ifinfomsg ifmsg = { 0 };
230  struct nlattr *attr;
231  clib_error_t *err = 0;
232  vnet_netlink_msg_t *replies = NULL;
233  int len = 0, offset = 0;
234  u32 msg_mtu;
235 
236  ifmsg.ifi_index = ifindex;
237 
238  vnet_netlink_msg_init (&m, RTM_GETLINK, NLM_F_REQUEST, &ifmsg,
239  sizeof (struct ifinfomsg));
240  // vnet_netlink_msg_add_rtattr (&m, IFLA_MTU, &mtu, sizeof (int));
241  err = vnet_netlink_msg_send (&m, &replies);
242  if (err)
243  {
244  err = clib_error_return (0, "get link mtu %U", format_clib_error, err);
245  goto done;
246  }
247 
248  if (vec_len (replies) != 1)
249  {
250  err = clib_error_return (0, "got %d != 1 netlink reply msg",
251  vec_len (replies));
252  goto done;
253  }
254 
255  struct nlmsghdr *nh = (struct nlmsghdr *) replies[0].data;
256  if (nh->nlmsg_type != RTM_NEWLINK)
257  {
258  err = clib_error_return (
259  0, "netlink reply has wrong type: %d != RTM_NEWLINK", nh->nlmsg_type);
260  goto done;
261  }
262 
263  offset = NLMSG_HDRLEN + NLMSG_ALIGN (sizeof (struct ifinfomsg));
264  attr = (struct nlattr *) ((u8 *) nh + offset);
265  len = nh->nlmsg_len - offset;
266 
267  do
268  {
269  if ((attr->nla_type & NLA_TYPE_MASK) == IFLA_MTU)
270  {
271  msg_mtu = *(u32 *) ((u8 *) attr + NLA_HDRLEN);
272  if (attr->nla_type & NLA_F_NET_BYTEORDER)
273  *mtu = clib_net_to_host_u32 (msg_mtu);
274  else
275  *mtu = msg_mtu;
276  clib_warning ("mtu: %d", *mtu);
277  goto done;
278  }
279  offset = NLA_ALIGN (attr->nla_len);
280  len -= offset;
281  attr = (struct nlattr *) ((u8 *) attr + offset);
282  }
283  while (len > sizeof (struct nlattr));
284 
285  /* not found */
286  err = clib_error_return (0, "mtu not found in netlink message");
287 
288 done:
289  vec_foreach (msg, replies)
290  {
291  vec_free (msg->data);
292  }
293  vec_free (replies);
294 
295  return err;
296 }
297 
298 clib_error_t *
299 vnet_netlink_set_link_mtu (int ifindex, int mtu)
300 {
301  vnet_netlink_msg_t m;
302  struct ifinfomsg ifmsg = { 0 };
303  clib_error_t *err = 0;
304 
305  ifmsg.ifi_index = ifindex;
306 
307  vnet_netlink_msg_init (&m, RTM_SETLINK, NLM_F_REQUEST,
308  &ifmsg, sizeof (struct ifinfomsg));
309  vnet_netlink_msg_add_rtattr (&m, IFLA_MTU, &mtu, sizeof (int));
310  err = vnet_netlink_msg_send (&m, NULL);
311  if (err)
312  err = clib_error_return (0, "set link mtu %U", format_clib_error, err);
313  return err;
314 }
315 
316 clib_error_t *
317 vnet_netlink_add_ip4_addr (int ifindex, void *addr, int pfx_len)
318 {
319  vnet_netlink_msg_t m;
320  struct ifaddrmsg ifa = { 0 };
321  clib_error_t *err = 0;
322 
323  ifa.ifa_family = AF_INET;
324  ifa.ifa_prefixlen = pfx_len;
325  ifa.ifa_index = ifindex;
326 
327  vnet_netlink_msg_init (&m, RTM_NEWADDR,
328  NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE,
329  &ifa, sizeof (struct ifaddrmsg));
330 
331  vnet_netlink_msg_add_rtattr (&m, IFA_LOCAL, addr, 4);
332  vnet_netlink_msg_add_rtattr (&m, IFA_ADDRESS, addr, 4);
333  err = vnet_netlink_msg_send (&m, NULL);
334  if (err)
335  err = clib_error_return (0, "add ip4 addr %U", format_clib_error, err);
336  return err;
337 }
338 
339 clib_error_t *
340 vnet_netlink_add_ip6_addr (int ifindex, void *addr, int pfx_len)
341 {
342  vnet_netlink_msg_t m;
343  struct ifaddrmsg ifa = { 0 };
344  clib_error_t *err = 0;
345 
346  ifa.ifa_family = AF_INET6;
347  ifa.ifa_prefixlen = pfx_len;
348  ifa.ifa_index = ifindex;
349 
350  vnet_netlink_msg_init (&m, RTM_NEWADDR,
351  NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE,
352  &ifa, sizeof (struct ifaddrmsg));
353 
354  vnet_netlink_msg_add_rtattr (&m, IFA_LOCAL, addr, 16);
355  vnet_netlink_msg_add_rtattr (&m, IFA_ADDRESS, addr, 16);
356  err = vnet_netlink_msg_send (&m, NULL);
357  if (err)
358  err = clib_error_return (0, "add ip6 addr %U", format_clib_error, err);
359  return err;
360 }
361 
362 clib_error_t *
363 vnet_netlink_add_ip4_route (void *dst, u8 dst_len, void *gw)
364 {
365  vnet_netlink_msg_t m;
366  struct rtmsg rtm = { 0 };
367  u8 dflt[4] = { 0 };
368  clib_error_t *err = 0;
369 
370  rtm.rtm_family = AF_INET;
371  rtm.rtm_table = RT_TABLE_MAIN;
372  rtm.rtm_type = RTN_UNICAST;
373  rtm.rtm_dst_len = dst_len;
374 
375  vnet_netlink_msg_init (&m, RTM_NEWROUTE,
376  NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE,
377  &rtm, sizeof (struct rtmsg));
378 
379  vnet_netlink_msg_add_rtattr (&m, RTA_GATEWAY, gw, 4);
380  vnet_netlink_msg_add_rtattr (&m, RTA_DST, dst ? dst : dflt, 4);
381  err = vnet_netlink_msg_send (&m, NULL);
382  if (err)
383  err = clib_error_return (0, "add ip4 route %U", format_clib_error, err);
384  return err;
385 }
386 
387 clib_error_t *
388 vnet_netlink_add_ip6_route (void *dst, u8 dst_len, void *gw)
389 {
390  vnet_netlink_msg_t m;
391  struct rtmsg rtm = { 0 };
392  u8 dflt[16] = { 0 };
393  clib_error_t *err = 0;
394 
395  rtm.rtm_family = AF_INET6;
396  rtm.rtm_table = RT_TABLE_MAIN;
397  rtm.rtm_type = RTN_UNICAST;
398  rtm.rtm_dst_len = dst_len;
399 
400  vnet_netlink_msg_init (&m, RTM_NEWROUTE,
401  NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE,
402  &rtm, sizeof (struct rtmsg));
403 
404  vnet_netlink_msg_add_rtattr (&m, RTA_GATEWAY, gw, 16);
405  vnet_netlink_msg_add_rtattr (&m, RTA_DST, dst ? dst : dflt, 16);
406  err = vnet_netlink_msg_send (&m, NULL);
407  if (err)
408  err = clib_error_return (0, "add ip6 route %U", format_clib_error, err);
409  return err;
410 }
411 
412 /*
413  * fd.io coding-style-patch-verification: ON
414  *
415  * Local Variables:
416  * eval: (c-set-style "gnu")
417  * End:
418  */
vlib.h
mac
vl_api_mac_address_t mac
Definition: l2.api:559
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
if_nametoindex
unsigned int if_nametoindex(const char *ifname)
u16
unsigned short u16
Definition: types.h:57
addr
vhost_vring_addr_t addr
Definition: vhost_user.h:130
format_clib_error
__clib_export u8 * format_clib_error(u8 *s, va_list *va)
Definition: error.c:191
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
vnet_netlink_msg_t::data
u8 * data
Definition: netlink.c:32
len
u8 len
Definition: ip_types.api:103
vec_add2
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:644
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
offset
struct clib_bihash_value offset
template key/value backing page structure
nh
vl_api_fib_path_nh_t nh
Definition: fib_types.api:126
data
u8 data[128]
Definition: ipsec_types.api:95
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
clib_bihash_value
template key/value backing page structure
Definition: bihash_doc.h:44
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
buf
u64 buf
Definition: application.c:493
u32
unsigned int u32
Definition: types.h:88
dst
vl_api_ip4_address_t dst
Definition: pnat.api:41
vec_foreach
#define vec_foreach(var, vec)
Vector iterator.
Definition: vec_bootstrap.h:213
clib_error_return_unix
#define clib_error_return_unix(e, args...)
Definition: error.h:102
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
unix.h
i
int i
Definition: flowhash_template.h:376
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
vnet_netlink_msg_t
Definition: netlink.c:30
type
vl_api_fib_path_type_t type
Definition: fib_types.api:123
flags
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105