src/vnet/devices/netlink.c

   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  */