busybox/networking/libiproute/libnetlink.c

   1 /*
   2  * libnetlink.c RTnetlink service routines.
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  *
  11  */
  12
  13 #include <sys/socket.h>
  14
  15 #include <errno.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <time.h>
  19 #include <unistd.h>
  20
  21 #include <sys/uio.h>
  22
  23 #include "libnetlink.h"
  24 #include "libbb.h"
  25
  26 void rtnl_close(struct rtnl_handle *rth)
  27 {
  28         close(rth->fd);
  29 }
  30
  31 int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions)
  32 {
  33         int addr_len;
  34
  35         memset(rth, 0, sizeof(rth));
  36
  37         rth->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  38         if (rth->fd < 0) {
  39                 bb_perror_msg("Cannot open netlink socket");
  40                 return -1;
  41         }
  42
  43         memset(&rth->local, 0, sizeof(rth->local));
  44         rth->local.nl_family = AF_NETLINK;
  45         rth->local.nl_groups = subscriptions;
  46
  47         if (bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local)) < 0) {
  48                 bb_perror_msg("Cannot bind netlink socket");
  49                 return -1;
  50         }
  51         addr_len = sizeof(rth->local);
  52         if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0) {
  53                 bb_perror_msg("Cannot getsockname");
  54                 return -1;
  55         }
  56         if (addr_len != sizeof(rth->local)) {
  57                 bb_error_msg("Wrong address length %d", addr_len);
  58                 return -1;
  59         }
  60         if (rth->local.nl_family != AF_NETLINK) {
  61                 bb_error_msg("Wrong address family %d", rth->local.nl_family);
  62                 return -1;
  63         }
  64         rth->seq = time(NULL);
  65         return 0;
  66 }
  67
  68 int rtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
  69 {
  70         struct {
  71                 struct nlmsghdr nlh;
  72                 struct rtgenmsg g;
  73         } req;
  74         struct sockaddr_nl nladdr;
  75
  76         memset(&nladdr, 0, sizeof(nladdr));
  77         nladdr.nl_family = AF_NETLINK;
  78
  79         req.nlh.nlmsg_len = sizeof(req);
  80         req.nlh.nlmsg_type = type;
  81         req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
  82         req.nlh.nlmsg_pid = 0;
  83         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
  84         req.g.rtgen_family = family;
  85
  86         return sendto(rth->fd, (void*)&req, sizeof(req), 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
  87 }
  88
  89 int rtnl_send(struct rtnl_handle *rth, char *buf, int len)
  90 {
  91         struct sockaddr_nl nladdr;
  92
  93         memset(&nladdr, 0, sizeof(nladdr));
  94         nladdr.nl_family = AF_NETLINK;
  95
  96         return sendto(rth->fd, buf, len, 0, (struct sockaddr*)&nladdr, sizeof(nladdr));
  97 }
  98
  99 int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
 100 {
 101         struct nlmsghdr nlh;
 102         struct sockaddr_nl nladdr;
 103         struct iovec iov[2] = { { &nlh, sizeof(nlh) }, { req, len } };
 104         struct msghdr msg = {
 105                 (void*)&nladdr, sizeof(nladdr),
 106                 iov,    2,
 107                 NULL,   0,
 108                 0
 109         };
 110
 111         memset(&nladdr, 0, sizeof(nladdr));
 112         nladdr.nl_family = AF_NETLINK;
 113
 114         nlh.nlmsg_len = NLMSG_LENGTH(len);
 115         nlh.nlmsg_type = type;
 116         nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
 117         nlh.nlmsg_pid = 0;
 118         nlh.nlmsg_seq = rth->dump = ++rth->seq;
 119
 120         return sendmsg(rth->fd, &msg, 0);
 121 }
 122
 123 int rtnl_dump_filter(struct rtnl_handle *rth,
 124                      int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
 125                      void *arg1,
 126                      int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
 127                      void *arg2)
 128 {
 129         char    buf[8192];
 130         struct sockaddr_nl nladdr;
 131         struct iovec iov = { buf, sizeof(buf) };
 132
 133         while (1) {
 134                 int status;
 135                 struct nlmsghdr *h;
 136
 137                 struct msghdr msg = {
 138                         (void*)&nladdr, sizeof(nladdr),
 139                         &iov,   1,
 140                         NULL,   0,
 141                         0
 142                 };
 143
 144                 status = recvmsg(rth->fd, &msg, 0);
 145
 146                 if (status < 0) {
 147                         if (errno == EINTR)
 148                                 continue;
 149                         bb_perror_msg("OVERRUN");
 150                         continue;
 151                 }
 152                 if (status == 0) {
 153                         bb_error_msg("EOF on netlink");
 154                         return -1;
 155                 }
 156                 if (msg.msg_namelen != sizeof(nladdr)) {
 157                         bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
 158                 }
 159
 160                 h = (struct nlmsghdr*)buf;
 161                 while (NLMSG_OK(h, status)) {
 162                         int err;
 163
 164                         if (nladdr.nl_pid != 0 ||
 165                             h->nlmsg_pid != rth->local.nl_pid ||
 166                             h->nlmsg_seq != rth->dump) {
 167                                 if (junk) {
 168                                         err = junk(&nladdr, h, arg2);
 169                                         if (err < 0) {
 170                                                 return err;
 171                                         }
 172                                 }
 173                                 goto skip_it;
 174                         }
 175
 176                         if (h->nlmsg_type == NLMSG_DONE) {
 177                                 return 0;
 178                         }
 179                         if (h->nlmsg_type == NLMSG_ERROR) {
 180                                 struct nlmsgerr *l_err = (struct nlmsgerr*)NLMSG_DATA(h);
 181                                 if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
 182                                         bb_error_msg("ERROR truncated");
 183                                 } else {
 184                                         errno = -l_err->error;
 185                                         bb_perror_msg("RTNETLINK answers");
 186                                 }
 187                                 return -1;
 188                         }
 189                         err = filter(&nladdr, h, arg1);
 190                         if (err < 0) {
 191                                 return err;
 192                         }
 193
 194 skip_it:
 195                         h = NLMSG_NEXT(h, status);
 196                 }
 197                 if (msg.msg_flags & MSG_TRUNC) {
 198                         bb_error_msg("Message truncated");
 199                         continue;
 200                 }
 201                 if (status) {
 202                         bb_error_msg_and_die("!!!Remnant of size %d", status);
 203                 }
 204         }
 205 }
 206
 207 int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
 208               unsigned groups, struct nlmsghdr *answer,
 209               int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
 210               void *jarg)
 211 {
 212         int status;
 213         unsigned seq;
 214         struct nlmsghdr *h;
 215         struct sockaddr_nl nladdr;
 216         struct iovec iov = { (void*)n, n->nlmsg_len };
 217         char   buf[8192];
 218         struct msghdr msg = {
 219                 (void*)&nladdr, sizeof(nladdr),
 220                 &iov,   1,
 221                 NULL,   0,
 222                 0
 223         };
 224
 225         memset(&nladdr, 0, sizeof(nladdr));
 226         nladdr.nl_family = AF_NETLINK;
 227         nladdr.nl_pid = peer;
 228         nladdr.nl_groups = groups;
 229
 230         n->nlmsg_seq = seq = ++rtnl->seq;
 231         if (answer == NULL) {
 232                 n->nlmsg_flags |= NLM_F_ACK;
 233         }
 234         status = sendmsg(rtnl->fd, &msg, 0);
 235
 236         if (status < 0) {
 237                 bb_perror_msg("Cannot talk to rtnetlink");
 238                 return -1;
 239         }
 240
 241         iov.iov_base = buf;
 242
 243         while (1) {
 244                 iov.iov_len = sizeof(buf);
 245                 status = recvmsg(rtnl->fd, &msg, 0);
 246
 247                 if (status < 0) {
 248                         if (errno == EINTR) {
 249                                 continue;
 250                         }
 251                         bb_perror_msg("OVERRUN");
 252                         continue;
 253                 }
 254                 if (status == 0) {
 255                         bb_error_msg("EOF on netlink");
 256                         return -1;
 257                 }
 258                 if (msg.msg_namelen != sizeof(nladdr)) {
 259                         bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
 260                 }
 261                 for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
 262                         int l_err;
 263                         int len = h->nlmsg_len;
 264                         int l = len - sizeof(*h);
 265
 266                         if (l<0 || len>status) {
 267                                 if (msg.msg_flags & MSG_TRUNC) {
 268                                         bb_error_msg("Truncated message");
 269                                         return -1;
 270                                 }
 271                                 bb_error_msg_and_die("!!!malformed message: len=%d", len);
 272                         }
 273
 274                         if (nladdr.nl_pid != peer ||
 275                             h->nlmsg_pid != rtnl->local.nl_pid ||
 276                             h->nlmsg_seq != seq) {
 277                                 if (junk) {
 278                                         l_err = junk(&nladdr, h, jarg);
 279                                         if (l_err < 0) {
 280                                                 return l_err;
 281                                         }
 282                                 }
 283                                 continue;
 284                         }
 285
 286                         if (h->nlmsg_type == NLMSG_ERROR) {
 287                                 struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
 288                                 if (l < sizeof(struct nlmsgerr)) {
 289                                         bb_error_msg("ERROR truncated");
 290                                 } else {
 291                                         errno = -err->error;
 292                                         if (errno == 0) {
 293                                                 if (answer) {
 294                                                         memcpy(answer, h, h->nlmsg_len);
 295                                                 }
 296                                                 return 0;
 297                                         }
 298                                         bb_perror_msg("RTNETLINK answers");
 299                                 }
 300                                 return -1;
 301                         }
 302                         if (answer) {
 303                                 memcpy(answer, h, h->nlmsg_len);
 304                                 return 0;
 305                         }
 306
 307                         bb_error_msg("Unexpected reply!!!");
 308
 309                         status -= NLMSG_ALIGN(len);
 310                         h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
 311                 }
 312                 if (msg.msg_flags & MSG_TRUNC) {
 313                         bb_error_msg("Message truncated");
 314                         continue;
 315                 }
 316                 if (status) {
 317                         bb_error_msg_and_die("!!!Remnant of size %d", status);
 318                 }
 319         }
 320 }
 321
 322 int rtnl_listen(struct rtnl_handle *rtnl,
 323               int (*handler)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
 324               void *jarg)
 325 {
 326         int status;
 327         struct nlmsghdr *h;
 328         struct sockaddr_nl nladdr;
 329         struct iovec iov;
 330         char   buf[8192];
 331         struct msghdr msg = {
 332                 (void*)&nladdr, sizeof(nladdr),
 333                 &iov,   1,
 334                 NULL,   0,
 335                 0
 336         };
 337
 338         memset(&nladdr, 0, sizeof(nladdr));
 339         nladdr.nl_family = AF_NETLINK;
 340         nladdr.nl_pid = 0;
 341         nladdr.nl_groups = 0;
 342
 343
 344         iov.iov_base = buf;
 345
 346         while (1) {
 347                 iov.iov_len = sizeof(buf);
 348                 status = recvmsg(rtnl->fd, &msg, 0);
 349
 350                 if (status < 0) {
 351                         if (errno == EINTR)
 352                                 continue;
 353                         bb_perror_msg("OVERRUN");
 354                         continue;
 355                 }
 356                 if (status == 0) {
 357                         bb_error_msg("EOF on netlink");
 358                         return -1;
 359                 }
 360                 if (msg.msg_namelen != sizeof(nladdr)) {
 361                         bb_error_msg_and_die("Sender address length == %d", msg.msg_namelen);
 362                 }
 363                 for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
 364                         int err;
 365                         int len = h->nlmsg_len;
 366                         int l = len - sizeof(*h);
 367
 368                         if (l<0 || len>status) {
 369                                 if (msg.msg_flags & MSG_TRUNC) {
 370                                         bb_error_msg("Truncated message");
 371                                         return -1;
 372                                 }
 373                                 bb_error_msg_and_die("!!!malformed message: len=%d", len);
 374                         }
 375
 376                         err = handler(&nladdr, h, jarg);
 377                         if (err < 0) {
 378                                 return err;
 379                         }
 380
 381                         status -= NLMSG_ALIGN(len);
 382                         h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
 383                 }
 384                 if (msg.msg_flags & MSG_TRUNC) {
 385                         bb_error_msg("Message truncated");
 386                         continue;
 387                 }
 388                 if (status) {
 389                         bb_error_msg_and_die("!!!Remnant of size %d", status);
 390                 }
 391         }
 392 }
 393
 394 int rtnl_from_file(FILE *rtnl,
 395               int (*handler)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
 396               void *jarg)
 397 {
 398         int status;
 399         struct sockaddr_nl nladdr;
 400         char   buf[8192];
 401         struct nlmsghdr *h = (void*)buf;
 402
 403         memset(&nladdr, 0, sizeof(nladdr));
 404         nladdr.nl_family = AF_NETLINK;
 405         nladdr.nl_pid = 0;
 406         nladdr.nl_groups = 0;
 407
 408         while (1) {
 409                 int err, len, type;
 410                 int l;
 411
 412                 status = fread(&buf, 1, sizeof(*h), rtnl);
 413
 414                 if (status < 0) {
 415                         if (errno == EINTR)
 416                                 continue;
 417                         bb_perror_msg("rtnl_from_file: fread");
 418                         return -1;
 419                 }
 420                 if (status == 0)
 421                         return 0;
 422
 423                 len = h->nlmsg_len;
 424                 type= h->nlmsg_type;
 425                 l = len - sizeof(*h);
 426
 427                 if (l<0 || len>sizeof(buf)) {
 428                         bb_error_msg("!!!malformed message: len=%d @%lu",
 429                                 len, ftell(rtnl));
 430                         return -1;
 431                 }
 432
 433                 status = fread(NLMSG_DATA(h), 1, NLMSG_ALIGN(l), rtnl);
 434
 435                 if (status < 0) {
 436                         bb_perror_msg("rtnl_from_file: fread");
 437                         return -1;
 438                 }
 439                 if (status < l) {
 440                         bb_error_msg("rtnl-from_file: truncated message");
 441                         return -1;
 442                 }
 443
 444                 err = handler(&nladdr, h, jarg);
 445                 if (err < 0)
 446                         return err;
 447         }
 448 }
 449
 450 int addattr32(struct nlmsghdr *n, int maxlen, int type, __u32 data)
 451 {
 452         int len = RTA_LENGTH(4);
 453         struct rtattr *rta;
 454         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
 455                 return -1;
 456         rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
 457         rta->rta_type = type;
 458         rta->rta_len = len;
 459         memcpy(RTA_DATA(rta), &data, 4);
 460         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 461         return 0;
 462 }
 463
 464 int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
 465 {
 466         int len = RTA_LENGTH(alen);
 467         struct rtattr *rta;
 468
 469         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
 470                 return -1;
 471         rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
 472         rta->rta_type = type;
 473         rta->rta_len = len;
 474         memcpy(RTA_DATA(rta), data, alen);
 475         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 476         return 0;
 477 }
 478
 479 int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data)
 480 {
 481         int len = RTA_LENGTH(4);
 482         struct rtattr *subrta;
 483
 484         if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
 485                 return -1;
 486         }
 487         subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
 488         subrta->rta_type = type;
 489         subrta->rta_len = len;
 490         memcpy(RTA_DATA(subrta), &data, 4);
 491         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
 492         return 0;
 493 }
 494
 495 int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
 496 {
 497         struct rtattr *subrta;
 498         int len = RTA_LENGTH(alen);
 499
 500         if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
 501                 return -1;
 502         }
 503         subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
 504         subrta->rta_type = type;
 505         subrta->rta_len = len;
 506         memcpy(RTA_DATA(subrta), data, alen);
 507         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
 508         return 0;
 509 }
 510
 511
 512 int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
 513 {
 514         while (RTA_OK(rta, len)) {
 515                 if (rta->rta_type <= max) {
 516                         tb[rta->rta_type] = rta;
 517                 }
 518                 rta = RTA_NEXT(rta,len);
 519         }
 520         if (len) {
 521                 bb_error_msg("!!!Deficit %d, rta_len=%d", len, rta->rta_len);
 522         }
 523         return 0;
 524 }