zebra/kernel_netlink.c

   1 /* Kernel communication using netlink interface.
   2  * Copyright (C) 1999 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <zebra.h>
  22
  23 #ifdef HAVE_NETLINK
  24
  25 #include "linklist.h"
  26 #include "if.h"
  27 #include "log.h"
  28 #include "prefix.h"
  29 #include "connected.h"
  30 #include "table.h"
  31 #include "memory.h"
  32 #include "zebra_memory.h"
  33 #include "rib.h"
  34 #include "thread.h"
  35 #include "privs.h"
  36 #include "nexthop.h"
  37 #include "vrf.h"
  38 #include "mpls.h"
  39
  40 #include "zebra/zserv.h"
  41 #include "zebra/zebra_ns.h"
  42 #include "zebra/zebra_vrf.h"
  43 #include "zebra/debug.h"
  44 #include "zebra/kernel_netlink.h"
  45 #include "zebra/rt_netlink.h"
  46 #include "zebra/if_netlink.h"
  47
  48 #ifndef SO_RCVBUFFORCE
  49 #define SO_RCVBUFFORCE  (33)
  50 #endif
  51
  52 /* Hack for GNU libc version 2. */
  53 #ifndef MSG_TRUNC
  54 #define MSG_TRUNC      0x20
  55 #endif /* MSG_TRUNC */
  56
  57 #ifndef NLMSG_TAIL
  58 #define NLMSG_TAIL(nmsg)                                                       \
  59         ((struct rtattr *)(((u_char *)(nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
  60 #endif
  61
  62 #ifndef RTA_TAIL
  63 #define RTA_TAIL(rta)                                                          \
  64         ((struct rtattr *)(((u_char *)(rta)) + RTA_ALIGN((rta)->rta_len)))
  65 #endif
  66
  67 #ifndef RTNL_FAMILY_IP6MR
  68 #define RTNL_FAMILY_IP6MR 129
  69 #endif
  70
  71 #ifndef RTPROT_MROUTED
  72 #define RTPROT_MROUTED 17
  73 #endif
  74
  75 static const struct message nlmsg_str[] = {{RTM_NEWROUTE, "RTM_NEWROUTE"},
  76                                            {RTM_DELROUTE, "RTM_DELROUTE"},
  77                                            {RTM_GETROUTE, "RTM_GETROUTE"},
  78                                            {RTM_NEWLINK, "RTM_NEWLINK"},
  79                                            {RTM_DELLINK, "RTM_DELLINK"},
  80                                            {RTM_GETLINK, "RTM_GETLINK"},
  81                                            {RTM_NEWADDR, "RTM_NEWADDR"},
  82                                            {RTM_DELADDR, "RTM_DELADDR"},
  83                                            {RTM_GETADDR, "RTM_GETADDR"},
  84                                            {RTM_NEWNEIGH, "RTM_NEWNEIGH"},
  85                                            {RTM_DELNEIGH, "RTM_DELNEIGH"},
  86                                            {RTM_GETNEIGH, "RTM_GETNEIGH"},
  87                                            {0}};
  88
  89 static const struct message rtproto_str[] = {
  90         {RTPROT_REDIRECT, "redirect"},
  91         {RTPROT_KERNEL, "kernel"},
  92         {RTPROT_BOOT, "boot"},
  93         {RTPROT_STATIC, "static"},
  94         {RTPROT_GATED, "GateD"},
  95         {RTPROT_RA, "router advertisement"},
  96         {RTPROT_MRT, "MRT"},
  97         {RTPROT_ZEBRA, "Zebra"},
  98 #ifdef RTPROT_BIRD
  99         {RTPROT_BIRD, "BIRD"},
 100 #endif /* RTPROT_BIRD */
 101         {RTPROT_MROUTED, "mroute"},
 102         {RTPROT_BGP, "BGP"},
 103         {RTPROT_OSPF, "OSPF"},
 104         {RTPROT_ISIS, "IS-IS"},
 105         {RTPROT_RIP, "RIP"},
 106         {RTPROT_RIPNG, "RIPNG"},
 107         {0}};
 108
 109 static const struct message family_str[] = {{AF_INET, "ipv4"},
 110                                             {AF_INET6, "ipv6"},
 111                                             {AF_BRIDGE, "bridge"},
 112                                             {RTNL_FAMILY_IPMR, "ipv4MR"},
 113                                             {RTNL_FAMILY_IP6MR, "ipv6MR"},
 114                                             {0}};
 115
 116 static const struct message rttype_str[] = {{RTN_UNICAST, "unicast"},
 117                                             {RTN_MULTICAST, "multicast"},
 118                                             {0}};
 119
 120 extern struct thread_master *master;
 121 extern u_int32_t nl_rcvbufsize;
 122
 123 extern struct zebra_privs_t zserv_privs;
 124
 125 int netlink_talk_filter(struct sockaddr_nl *snl, struct nlmsghdr *h,
 126                         ns_id_t ns_id, int startup)
 127 {
 128         zlog_warn("netlink_talk: ignoring message type 0x%04x NS %u",
 129                   h->nlmsg_type, ns_id);
 130         return 0;
 131 }
 132
 133 static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 134 {
 135         u_int32_t oldsize;
 136         socklen_t newlen = sizeof(newsize);
 137         socklen_t oldlen = sizeof(oldsize);
 138         int ret;
 139
 140         ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
 141         if (ret < 0) {
 142                 zlog_err("Can't get %s receive buffer size: %s", nl->name,
 143                          safe_strerror(errno));
 144                 return -1;
 145         }
 146
 147         /* Try force option (linux >= 2.6.14) and fall back to normal set */
 148         if (zserv_privs.change(ZPRIVS_RAISE))
 149                 zlog_err("routing_socket: Can't raise privileges");
 150         ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUFFORCE, &nl_rcvbufsize,
 151                          sizeof(nl_rcvbufsize));
 152         if (zserv_privs.change(ZPRIVS_LOWER))
 153                 zlog_err("routing_socket: Can't lower privileges");
 154         if (ret < 0)
 155                 ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF,
 156                                  &nl_rcvbufsize, sizeof(nl_rcvbufsize));
 157         if (ret < 0) {
 158                 zlog_err("Can't set %s receive buffer size: %s", nl->name,
 159                          safe_strerror(errno));
 160                 return -1;
 161         }
 162
 163         ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
 164         if (ret < 0) {
 165                 zlog_err("Can't get %s receive buffer size: %s", nl->name,
 166                          safe_strerror(errno));
 167                 return -1;
 168         }
 169
 170         zlog_info("Setting netlink socket receive buffer size: %u -> %u",
 171                   oldsize, newsize);
 172         return 0;
 173 }
 174
 175 /* Make socket for Linux netlink interface. */
 176 static int netlink_socket(struct nlsock *nl, unsigned long groups,
 177                           ns_id_t ns_id)
 178 {
 179         int ret;
 180         struct sockaddr_nl snl;
 181         int sock;
 182         int namelen;
 183         int save_errno;
 184
 185         if (zserv_privs.change(ZPRIVS_RAISE)) {
 186                 zlog_err("Can't raise privileges");
 187                 return -1;
 188         }
 189
 190         sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 191         if (sock < 0) {
 192                 zlog_err("Can't open %s socket: %s", nl->name,
 193                          safe_strerror(errno));
 194                 return -1;
 195         }
 196
 197         memset(&snl, 0, sizeof snl);
 198         snl.nl_family = AF_NETLINK;
 199         snl.nl_groups = groups;
 200
 201         /* Bind the socket to the netlink structure for anything. */
 202         ret = bind(sock, (struct sockaddr *)&snl, sizeof snl);
 203         save_errno = errno;
 204         if (zserv_privs.change(ZPRIVS_LOWER))
 205                 zlog_err("Can't lower privileges");
 206
 207         if (ret < 0) {
 208                 zlog_err("Can't bind %s socket to group 0x%x: %s", nl->name,
 209                          snl.nl_groups, safe_strerror(save_errno));
 210                 close(sock);
 211                 return -1;
 212         }
 213
 214         /* multiple netlink sockets will have different nl_pid */
 215         namelen = sizeof snl;
 216         ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
 217         if (ret < 0 || namelen != sizeof snl) {
 218                 zlog_err("Can't get %s socket name: %s", nl->name,
 219                          safe_strerror(errno));
 220                 close(sock);
 221                 return -1;
 222         }
 223
 224         nl->snl = snl;
 225         nl->sock = sock;
 226         return ret;
 227 }
 228
 229 static int netlink_information_fetch(struct sockaddr_nl *snl,
 230                                      struct nlmsghdr *h, ns_id_t ns_id,
 231                                      int startup)
 232 {
 233         /* JF: Ignore messages that aren't from the kernel */
 234         if (snl->nl_pid != 0) {
 235                 zlog_err("Ignoring message from pid %u", snl->nl_pid);
 236                 return 0;
 237         }
 238
 239         switch (h->nlmsg_type) {
 240         case RTM_NEWROUTE:
 241                 return netlink_route_change(snl, h, ns_id, startup);
 242                 break;
 243         case RTM_DELROUTE:
 244                 return netlink_route_change(snl, h, ns_id, startup);
 245                 break;
 246         case RTM_NEWLINK:
 247                 return netlink_link_change(snl, h, ns_id, startup);
 248                 break;
 249         case RTM_DELLINK:
 250                 return netlink_link_change(snl, h, ns_id, startup);
 251                 break;
 252         case RTM_NEWADDR:
 253                 return netlink_interface_addr(snl, h, ns_id, startup);
 254                 break;
 255         case RTM_DELADDR:
 256                 return netlink_interface_addr(snl, h, ns_id, startup);
 257                 break;
 258         case RTM_NEWNEIGH:
 259                 return netlink_neigh_change(snl, h, ns_id);
 260                 break;
 261         case RTM_DELNEIGH:
 262                 return netlink_neigh_change(snl, h, ns_id);
 263                 break;
 264         default:
 265                 if (IS_ZEBRA_DEBUG_KERNEL)
 266                         zlog_debug("Unknown netlink nlmsg_type %d vrf %u\n",
 267                                    h->nlmsg_type, ns_id);
 268                 break;
 269         }
 270         return 0;
 271 }
 272
 273 static int kernel_read(struct thread *thread)
 274 {
 275         struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
 276         netlink_parse_info(netlink_information_fetch, &zns->netlink, zns, 5, 0);
 277         zns->t_netlink = NULL;
 278         thread_add_read(zebrad.master, kernel_read, zns, zns->netlink.sock,
 279                         &zns->t_netlink);
 280
 281         return 0;
 282 }
 283
 284 /* Filter out messages from self that occur on listener socket,
 285  * caused by our actions on the command socket
 286  */
 287 static void netlink_install_filter(int sock, __u32 pid)
 288 {
 289         struct sock_filter filter[] = {
 290                 /* 0: ldh [4]             */
 291                 BPF_STMT(BPF_LD | BPF_ABS | BPF_H,
 292                          offsetof(struct nlmsghdr, nlmsg_type)),
 293                 /* 1: jeq 0x18 jt 5 jf next  */
 294                 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_NEWROUTE), 3, 0),
 295                 /* 2: jeq 0x19 jt 5 jf next  */
 296                 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_DELROUTE), 2, 0),
 297                 /* 3: jeq 0x19 jt 5 jf next  */
 298                 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_NEWNEIGH), 1, 0),
 299                 /* 4: jeq 0x19 jt 5 jf 8  */
 300                 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htons(RTM_DELNEIGH), 0, 3),
 301                 /* 5: ldw [12]            */
 302                 BPF_STMT(BPF_LD | BPF_ABS | BPF_W,
 303                          offsetof(struct nlmsghdr, nlmsg_pid)),
 304                 /* 6: jeq XX  jt 7 jf 8   */
 305                 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, htonl(pid), 0, 1),
 306                 /* 7: ret 0    (skip)     */
 307                 BPF_STMT(BPF_RET | BPF_K, 0),
 308                 /* 8: ret 0xffff (keep)   */
 309                 BPF_STMT(BPF_RET | BPF_K, 0xffff),
 310         };
 311
 312         struct sock_fprog prog = {
 313                 .len = array_size(filter), .filter = filter,
 314         };
 315
 316         if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))
 317             < 0)
 318                 zlog_warn("Can't install socket filter: %s\n",
 319                           safe_strerror(errno));
 320 }
 321
 322 void netlink_parse_rtattr(struct rtattr **tb, int max, struct rtattr *rta,
 323                           int len)
 324 {
 325         while (RTA_OK(rta, len)) {
 326                 if (rta->rta_type <= max)
 327                         tb[rta->rta_type] = rta;
 328                 rta = RTA_NEXT(rta, len);
 329         }
 330 }
 331
 332 int addattr_l(struct nlmsghdr *n, unsigned int maxlen, int type, void *data,
 333               unsigned int alen)
 334 {
 335         int len;
 336         struct rtattr *rta;
 337
 338         len = RTA_LENGTH(alen);
 339
 340         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len) > maxlen)
 341                 return -1;
 342
 343         rta = (struct rtattr *)(((char *)n) + NLMSG_ALIGN(n->nlmsg_len));
 344         rta->rta_type = type;
 345         rta->rta_len = len;
 346
 347         if (data)
 348                 memcpy(RTA_DATA(rta), data, alen);
 349         else
 350                 assert(alen == 0);
 351
 352         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len);
 353
 354         return 0;
 355 }
 356
 357 int rta_addattr_l(struct rtattr *rta, unsigned int maxlen, int type, void *data,
 358                   unsigned int alen)
 359 {
 360         unsigned int len;
 361         struct rtattr *subrta;
 362
 363         len = RTA_LENGTH(alen);
 364
 365         if (RTA_ALIGN(rta->rta_len) + RTA_ALIGN(len) > maxlen)
 366                 return -1;
 367
 368         subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
 369         subrta->rta_type = type;
 370         subrta->rta_len = len;
 371
 372         if (data)
 373                 memcpy(RTA_DATA(subrta), data, alen);
 374         else
 375                 assert(alen == 0);
 376
 377         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + RTA_ALIGN(len);
 378
 379         return 0;
 380 }
 381
 382 int addattr16(struct nlmsghdr *n, unsigned int maxlen, int type, u_int16_t data)
 383 {
 384         return addattr_l(n, maxlen, type, &data, sizeof(u_int16_t));
 385 }
 386
 387 int addattr32(struct nlmsghdr *n, unsigned int maxlen, int type, int data)
 388 {
 389         return addattr_l(n, maxlen, type, &data, sizeof(u_int32_t));
 390 }
 391
 392 struct rtattr *addattr_nest(struct nlmsghdr *n, int maxlen, int type)
 393 {
 394         struct rtattr *nest = NLMSG_TAIL(n);
 395
 396         addattr_l(n, maxlen, type, NULL, 0);
 397         return nest;
 398 }
 399
 400 int addattr_nest_end(struct nlmsghdr *n, struct rtattr *nest)
 401 {
 402         nest->rta_len = (u_char *)NLMSG_TAIL(n) - (u_char *)nest;
 403         return n->nlmsg_len;
 404 }
 405
 406 struct rtattr *rta_nest(struct rtattr *rta, int maxlen, int type)
 407 {
 408         struct rtattr *nest = RTA_TAIL(rta);
 409
 410         rta_addattr_l(rta, maxlen, type, NULL, 0);
 411         return nest;
 412 }
 413
 414 int rta_nest_end(struct rtattr *rta, struct rtattr *nest)
 415 {
 416         nest->rta_len = (u_char *)RTA_TAIL(rta) - (u_char *)nest;
 417         return rta->rta_len;
 418 }
 419
 420 const char *nl_msg_type_to_str(uint16_t msg_type)
 421 {
 422         return lookup_msg(nlmsg_str, msg_type, "");
 423 }
 424
 425 const char *nl_rtproto_to_str(u_char rtproto)
 426 {
 427         return lookup_msg(rtproto_str, rtproto, "");
 428 }
 429
 430 const char *nl_family_to_str(u_char family)
 431 {
 432         return lookup_msg(family_str, family, "");
 433 }
 434
 435 const char *nl_rttype_to_str(u_char rttype)
 436 {
 437         return lookup_msg(rttype_str, rttype, "");
 438 }
 439
 440 /*
 441  * netlink_parse_info
 442  *
 443  * Receive message from netlink interface and pass those information
 444  *  to the given function.
 445  *
 446  * filter  -> Function to call to read the results
 447  * nl      -> netlink socket information
 448  * zns     -> The zebra namespace data
 449  * count   -> How many we should read in, 0 means as much as possible
 450  * startup -> Are we reading in under startup conditions? passed to
 451  *            the filter.
 452  */
 453 int netlink_parse_info(int (*filter)(struct sockaddr_nl *, struct nlmsghdr *,
 454                                      ns_id_t, int),
 455                        struct nlsock *nl, struct zebra_ns *zns, int count,
 456                        int startup)
 457 {
 458         int status;
 459         int ret = 0;
 460         int error;
 461         int read_in = 0;
 462
 463         while (1) {
 464                 char buf[NL_PKT_BUF_SIZE];
 465                 struct iovec iov = {.iov_base = buf, .iov_len = sizeof buf};
 466                 struct sockaddr_nl snl;
 467                 struct msghdr msg = {.msg_name = (void *)&snl,
 468                                      .msg_namelen = sizeof snl,
 469                                      .msg_iov = &iov,
 470                                      .msg_iovlen = 1};
 471                 struct nlmsghdr *h;
 472
 473                 if (count && read_in >= count)
 474                         return 0;
 475
 476                 status = recvmsg(nl->sock, &msg, 0);
 477                 if (status < 0) {
 478                         if (errno == EINTR)
 479                                 continue;
 480                         if (errno == EWOULDBLOCK || errno == EAGAIN)
 481                                 break;
 482                         zlog_err("%s recvmsg overrun: %s", nl->name,
 483                                  safe_strerror(errno));
 484                         /*
 485                          *  In this case we are screwed.
 486                          *  There is no good way to
 487                          *  recover zebra at this point.
 488                          */
 489                         exit(-1);
 490                         continue;
 491                 }
 492
 493                 if (status == 0) {
 494                         zlog_err("%s EOF", nl->name);
 495                         return -1;
 496                 }
 497
 498                 if (msg.msg_namelen != sizeof snl) {
 499                         zlog_err("%s sender address length error: length %d",
 500                                  nl->name, msg.msg_namelen);
 501                         return -1;
 502                 }
 503
 504                 if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
 505                         zlog_debug("%s: << netlink message dump [recv]",
 506                                    __func__);
 507                         zlog_hexdump(buf, status);
 508                 }
 509
 510                 read_in++;
 511                 for (h = (struct nlmsghdr *)buf;
 512                      NLMSG_OK(h, (unsigned int)status);
 513                      h = NLMSG_NEXT(h, status)) {
 514                         /* Finish of reading. */
 515                         if (h->nlmsg_type == NLMSG_DONE)
 516                                 return ret;
 517
 518                         /* Error handling. */
 519                         if (h->nlmsg_type == NLMSG_ERROR) {
 520                                 struct nlmsgerr *err =
 521                                         (struct nlmsgerr *)NLMSG_DATA(h);
 522                                 int errnum = err->error;
 523                                 int msg_type = err->msg.nlmsg_type;
 524
 525                                 /* If the error field is zero, then this is an
 526                                  * ACK */
 527                                 if (err->error == 0) {
 528                                         if (IS_ZEBRA_DEBUG_KERNEL) {
 529                                                 zlog_debug(
 530                                                         "%s: %s ACK: type=%s(%u), seq=%u, pid=%u",
 531                                                         __FUNCTION__, nl->name,
 532                                                         nl_msg_type_to_str(
 533                                                                 err->msg.nlmsg_type),
 534                                                         err->msg.nlmsg_type,
 535                                                         err->msg.nlmsg_seq,
 536                                                         err->msg.nlmsg_pid);
 537                                         }
 538
 539                                         /* return if not a multipart message,
 540                                          * otherwise continue */
 541                                         if (!(h->nlmsg_flags & NLM_F_MULTI))
 542                                                 return 0;
 543                                         continue;
 544                                 }
 545
 546                                 if (h->nlmsg_len
 547                                     < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
 548                                         zlog_err("%s error: message truncated",
 549                                                  nl->name);
 550                                         return -1;
 551                                 }
 552
 553                                 /* Deal with errors that occur because of races
 554                                  * in link handling */
 555                                 if (nl == &zns->netlink_cmd
 556                                     && ((msg_type == RTM_DELROUTE
 557                                          && (-errnum == ENODEV
 558                                              || -errnum == ESRCH))
 559                                         || (msg_type == RTM_NEWROUTE
 560                                             && (-errnum == ENETDOWN
 561                                                 || -errnum == EEXIST)))) {
 562                                         if (IS_ZEBRA_DEBUG_KERNEL)
 563                                                 zlog_debug(
 564                                                         "%s: error: %s type=%s(%u), seq=%u, pid=%u",
 565                                                         nl->name,
 566                                                         safe_strerror(-errnum),
 567                                                         nl_msg_type_to_str(
 568                                                                 msg_type),
 569                                                         msg_type,
 570                                                         err->msg.nlmsg_seq,
 571                                                         err->msg.nlmsg_pid);
 572                                         return 0;
 573                                 }
 574
 575                                 /* We see RTM_DELNEIGH when shutting down an
 576                                  * interface with an IPv4
 577                                  * link-local.  The kernel should have already
 578                                  * deleted the neighbor
 579                                  * so do not log these as an error.
 580                                  */
 581                                 if (msg_type == RTM_DELNEIGH
 582                                     || (nl == &zns->netlink_cmd
 583                                         && msg_type == RTM_NEWROUTE
 584                                         && (-errnum == ESRCH
 585                                             || -errnum == ENETUNREACH))) {
 586                                         /* This is known to happen in some
 587                                          * situations, don't log
 588                                          * as error.
 589                                          */
 590                                         if (IS_ZEBRA_DEBUG_KERNEL)
 591                                                 zlog_debug(
 592                                                         "%s error: %s, type=%s(%u), seq=%u, pid=%u",
 593                                                         nl->name,
 594                                                         safe_strerror(-errnum),
 595                                                         nl_msg_type_to_str(
 596                                                                 msg_type),
 597                                                         msg_type,
 598                                                         err->msg.nlmsg_seq,
 599                                                         err->msg.nlmsg_pid);
 600                                 } else
 601                                         zlog_err(
 602                                                 "%s error: %s, type=%s(%u), seq=%u, pid=%u",
 603                                                 nl->name,
 604                                                 safe_strerror(-errnum),
 605                                                 nl_msg_type_to_str(msg_type),
 606                                                 msg_type, err->msg.nlmsg_seq,
 607                                                 err->msg.nlmsg_pid);
 608
 609                                 return -1;
 610                         }
 611
 612                         /* OK we got netlink message. */
 613                         if (IS_ZEBRA_DEBUG_KERNEL)
 614                                 zlog_debug(
 615                                         "netlink_parse_info: %s type %s(%u), len=%d, seq=%u, pid=%u",
 616                                         nl->name,
 617                                         nl_msg_type_to_str(h->nlmsg_type),
 618                                         h->nlmsg_type, h->nlmsg_len,
 619                                         h->nlmsg_seq, h->nlmsg_pid);
 620
 621                         /* skip unsolicited messages originating from command
 622                          * socket
 623                          * linux sets the originators port-id for {NEW|DEL}ADDR
 624                          * messages,
 625                          * so this has to be checked here. */
 626                         if (nl != &zns->netlink_cmd
 627                             && h->nlmsg_pid == zns->netlink_cmd.snl.nl_pid
 628                             && (h->nlmsg_type != RTM_NEWADDR
 629                                 && h->nlmsg_type != RTM_DELADDR)) {
 630                                 if (IS_ZEBRA_DEBUG_KERNEL)
 631                                         zlog_debug(
 632                                                 "netlink_parse_info: %s packet comes from %s",
 633                                                 zns->netlink_cmd.name,
 634                                                 nl->name);
 635                                 continue;
 636                         }
 637
 638                         error = (*filter)(&snl, h, zns->ns_id, startup);
 639                         if (error < 0) {
 640                                 zlog_err("%s filter function error", nl->name);
 641                                 ret = error;
 642                         }
 643                 }
 644
 645                 /* After error care. */
 646                 if (msg.msg_flags & MSG_TRUNC) {
 647                         zlog_err("%s error: message truncated", nl->name);
 648                         continue;
 649                 }
 650                 if (status) {
 651                         zlog_err("%s error: data remnant size %d", nl->name,
 652                                  status);
 653                         return -1;
 654                 }
 655         }
 656         return ret;
 657 }
 658
 659 /*
 660  * netlink_talk
 661  *
 662  * sendmsg() to netlink socket then recvmsg().
 663  * Calls netlink_parse_info to parse returned data
 664  *
 665  * filter   -> The filter to read final results from kernel
 666  * nlmsghdr -> The data to send to the kernel
 667  * nl       -> The netlink socket information
 668  * zns      -> The zebra namespace information
 669  * startup  -> Are we reading in under startup conditions
 670  *             This is passed through eventually to filter.
 671  */
 672 int netlink_talk(int (*filter)(struct sockaddr_nl *, struct nlmsghdr *, ns_id_t,
 673                                int startup),
 674                  struct nlmsghdr *n, struct nlsock *nl, struct zebra_ns *zns,
 675                  int startup)
 676 {
 677         int status;
 678         struct sockaddr_nl snl;
 679         struct iovec iov = {.iov_base = (void *)n, .iov_len = n->nlmsg_len};
 680         struct msghdr msg = {
 681                 .msg_name = (void *)&snl,
 682                 .msg_namelen = sizeof snl,
 683                 .msg_iov = &iov,
 684                 .msg_iovlen = 1,
 685         };
 686         int save_errno;
 687
 688         memset(&snl, 0, sizeof snl);
 689         snl.nl_family = AF_NETLINK;
 690
 691         n->nlmsg_seq = ++nl->seq;
 692         n->nlmsg_pid = nl->snl.nl_pid;
 693
 694         /* Request an acknowledgement by setting NLM_F_ACK */
 695         n->nlmsg_flags |= NLM_F_ACK;
 696
 697         if (IS_ZEBRA_DEBUG_KERNEL)
 698                 zlog_debug(
 699                         "netlink_talk: %s type %s(%u), len=%d seq=%u flags 0x%x",
 700                         nl->name, nl_msg_type_to_str(n->nlmsg_type),
 701                         n->nlmsg_type, n->nlmsg_len, n->nlmsg_seq,
 702                         n->nlmsg_flags);
 703
 704         /* Send message to netlink interface. */
 705         if (zserv_privs.change(ZPRIVS_RAISE))
 706                 zlog_err("Can't raise privileges");
 707         status = sendmsg(nl->sock, &msg, 0);
 708         save_errno = errno;
 709         if (zserv_privs.change(ZPRIVS_LOWER))
 710                 zlog_err("Can't lower privileges");
 711
 712         if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
 713                 zlog_debug("%s: >> netlink message dump [sent]", __func__);
 714                 zlog_hexdump(n, n->nlmsg_len);
 715         }
 716
 717         if (status < 0) {
 718                 zlog_err("netlink_talk sendmsg() error: %s",
 719                          safe_strerror(save_errno));
 720                 return -1;
 721         }
 722
 723
 724         /*
 725          * Get reply from netlink socket.
 726          * The reply should either be an acknowlegement or an error.
 727          */
 728         return netlink_parse_info(filter, nl, zns, 0, startup);
 729 }
 730
 731 /* Issue request message to kernel via netlink socket. GET messages
 732  * are issued through this interface.
 733  */
 734 int netlink_request(struct nlsock *nl, struct nlmsghdr *n)
 735 {
 736         int ret;
 737         struct sockaddr_nl snl;
 738         int save_errno;
 739
 740         /* Check netlink socket. */
 741         if (nl->sock < 0) {
 742                 zlog_err("%s socket isn't active.", nl->name);
 743                 return -1;
 744         }
 745
 746         /* Fill common fields for all requests. */
 747         n->nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 748         n->nlmsg_pid = nl->snl.nl_pid;
 749         n->nlmsg_seq = ++nl->seq;
 750
 751         memset(&snl, 0, sizeof snl);
 752         snl.nl_family = AF_NETLINK;
 753
 754         /* Raise capabilities and send message, then lower capabilities. */
 755         if (zserv_privs.change(ZPRIVS_RAISE)) {
 756                 zlog_err("Can't raise privileges");
 757                 return -1;
 758         }
 759
 760         ret = sendto(nl->sock, (void *)n, n->nlmsg_len, 0,
 761                      (struct sockaddr *)&snl, sizeof snl);
 762         save_errno = errno;
 763
 764         if (zserv_privs.change(ZPRIVS_LOWER))
 765                 zlog_err("Can't lower privileges");
 766
 767         if (ret < 0) {
 768                 zlog_err("%s sendto failed: %s", nl->name,
 769                          safe_strerror(save_errno));
 770                 return -1;
 771         }
 772
 773         return 0;
 774 }
 775
 776 /* Exported interface function.  This function simply calls
 777    netlink_socket (). */
 778 void kernel_init(struct zebra_ns *zns)
 779 {
 780         unsigned long groups;
 781
 782         /* Initialize netlink sockets */
 783         groups = RTMGRP_LINK | RTMGRP_IPV4_ROUTE | RTMGRP_IPV4_IFADDR
 784                  | RTMGRP_IPV6_ROUTE | RTMGRP_IPV6_IFADDR | RTMGRP_IPV4_MROUTE
 785                  | RTMGRP_NEIGH;
 786
 787         snprintf(zns->netlink.name, sizeof(zns->netlink.name),
 788                  "netlink-listen (NS %u)", zns->ns_id);
 789         zns->netlink.sock = -1;
 790         netlink_socket(&zns->netlink, groups, zns->ns_id);
 791
 792         snprintf(zns->netlink_cmd.name, sizeof(zns->netlink_cmd.name),
 793                  "netlink-cmd (NS %u)", zns->ns_id);
 794         zns->netlink_cmd.sock = -1;
 795         netlink_socket(&zns->netlink_cmd, 0, zns->ns_id);
 796
 797         /* Register kernel socket. */
 798         if (zns->netlink.sock > 0) {
 799                 /* Only want non-blocking on the netlink event socket */
 800                 if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
 801                         zlog_err("Can't set %s socket flags: %s",
 802                                  zns->netlink.name, safe_strerror(errno));
 803
 804                 /* Set receive buffer size if it's set from command line */
 805                 if (nl_rcvbufsize)
 806                         netlink_recvbuf(&zns->netlink, nl_rcvbufsize);
 807
 808                 netlink_install_filter(zns->netlink.sock,
 809                                        zns->netlink_cmd.snl.nl_pid);
 810                 zns->t_netlink = NULL;
 811                 thread_add_read(zebrad.master, kernel_read, zns,
 812                                 zns->netlink.sock, &zns->t_netlink);
 813         }
 814
 815         rt_netlink_init();
 816 }
 817
 818 void kernel_terminate(struct zebra_ns *zns)
 819 {
 820         THREAD_READ_OFF(zns->t_netlink);
 821
 822         if (zns->netlink.sock >= 0) {
 823                 close(zns->netlink.sock);
 824                 zns->netlink.sock = -1;
 825         }
 826
 827         if (zns->netlink_cmd.sock >= 0) {
 828                 close(zns->netlink_cmd.sock);
 829                 zns->netlink_cmd.sock = -1;
 830         }
 831 }
 832
 833 #endif /* HAVE_NETLINK */