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 <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <syslog.h>
  17 #include <fcntl.h>
  18 #include <net/if_arp.h>
  19 #include <sys/socket.h>
  20 #include <netinet/in.h>
  21 #include <string.h>
  22 #include <errno.h>
  23 #include <time.h>
  24 #include <sys/uio.h>
  25
  26 #include "log.h"
  27 #include "libnetlink.h"
  28
  29 #ifndef DEFAULT_RTNL_BUFSIZE
  30 #define DEFAULT_RTNL_BUFSIZE    256 * 1024
  31 #endif
  32
  33 #ifndef RTNL_SND_BUFSIZE
  34 #define RTNL_SND_BUFSIZE        DEFAULT_RTNL_BUFSIZE
  35 #endif
  36 #ifndef RTNL_RCV_BUFSIZE
  37 #define RTNL_RCV_BUFSIZE        DEFAULT_RTNL_BUFSIZE
  38 #endif
  39
  40 void rtnl_close(struct rtnl_handle *rth)
  41 {
  42         close(rth->fd);
  43 }
  44
  45 int rtnl_open_byproto(struct rtnl_handle *rth, unsigned subscriptions,
  46                       int protocol)
  47 {
  48         socklen_t addr_len;
  49         int sndbuf = RTNL_SND_BUFSIZE;
  50         int rcvbuf = RTNL_RCV_BUFSIZE;
  51
  52         memset(rth, 0, sizeof(*rth));
  53
  54         rth->fd = socket(AF_NETLINK, SOCK_RAW, protocol);
  55         if (rth->fd < 0) {
  56                 ERROR("Cannot open netlink socket");
  57                 return -1;
  58         }
  59
  60         if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf))
  61             < 0) {
  62                 ERROR("SO_SNDBUF");
  63                 return -1;
  64         }
  65
  66         if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf))
  67             < 0) {
  68                 ERROR("SO_RCVBUF");
  69                 return -1;
  70         }
  71
  72         memset(&rth->local, 0, sizeof(rth->local));
  73         rth->local.nl_family = AF_NETLINK;
  74         rth->local.nl_groups = subscriptions;
  75
  76         if (bind(rth->fd, (struct sockaddr *)&rth->local, sizeof(rth->local)) <
  77             0) {
  78                 ERROR("Cannot bind netlink socket");
  79                 return -1;
  80         }
  81         addr_len = sizeof(rth->local);
  82         if (getsockname(rth->fd, (struct sockaddr *)&rth->local, &addr_len) < 0) {
  83                 ERROR("Cannot getsockname");
  84                 return -1;
  85         }
  86         if (addr_len != sizeof(rth->local)) {
  87                 ERROR("Wrong address length %d\n", addr_len);
  88                 return -1;
  89         }
  90         if (rth->local.nl_family != AF_NETLINK) {
  91                 ERROR("Wrong address family %d\n",
  92                         rth->local.nl_family);
  93                 return -1;
  94         }
  95         rth->seq = time(NULL);
  96         return 0;
  97 }
  98
  99 int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions)
 100 {
 101         return rtnl_open_byproto(rth, subscriptions, NETLINK_ROUTE);
 102 }
 103
 104 int rtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
 105 {
 106         struct {
 107                 struct nlmsghdr nlh;
 108                 struct rtgenmsg g;
 109         } req;
 110         struct sockaddr_nl nladdr;
 111
 112         memset(&nladdr, 0, sizeof(nladdr));
 113         nladdr.nl_family = AF_NETLINK;
 114
 115         memset(&req, 0, sizeof(req));
 116         req.nlh.nlmsg_len = sizeof(req);
 117         req.nlh.nlmsg_type = type;
 118         req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 119         req.nlh.nlmsg_pid = 0;
 120         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
 121         req.g.rtgen_family = family;
 122
 123         return sendto(rth->fd, (void *)&req, sizeof(req), 0,
 124                       (struct sockaddr *)&nladdr, sizeof(nladdr));
 125 }
 126
 127 int rtnl_send(struct rtnl_handle *rth, const char *buf, int len)
 128 {
 129         struct sockaddr_nl nladdr;
 130
 131         memset(&nladdr, 0, sizeof(nladdr));
 132         nladdr.nl_family = AF_NETLINK;
 133
 134         return sendto(rth->fd, buf, len, 0, (struct sockaddr *)&nladdr,
 135                       sizeof(nladdr));
 136 }
 137
 138 int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
 139 {
 140         struct nlmsghdr nlh;
 141         struct sockaddr_nl nladdr;
 142         struct iovec iov[2] = {
 143                 {.iov_base = &nlh,.iov_len = sizeof(nlh)}
 144                 ,
 145                 {.iov_base = req,.iov_len = len}
 146         };
 147         struct msghdr msg = {
 148                 .msg_name = &nladdr,
 149                 .msg_namelen = sizeof(nladdr),
 150                 .msg_iov = iov,
 151                 .msg_iovlen = 2,
 152         };
 153
 154         memset(&nladdr, 0, sizeof(nladdr));
 155         nladdr.nl_family = AF_NETLINK;
 156
 157         nlh.nlmsg_len = NLMSG_LENGTH(len);
 158         nlh.nlmsg_type = type;
 159         nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 160         nlh.nlmsg_pid = 0;
 161         nlh.nlmsg_seq = rth->dump = ++rth->seq;
 162
 163         return sendmsg(rth->fd, &msg, 0);
 164 }
 165
 166 int rtnl_dump_filter(struct rtnl_handle *rth,
 167                      rtnl_filter_t filter,
 168                      void *arg1, rtnl_filter_t junk, void *arg2)
 169 {
 170         struct sockaddr_nl nladdr;
 171         struct iovec iov;
 172         struct msghdr msg = {
 173                 .msg_name = &nladdr,
 174                 .msg_namelen = sizeof(nladdr),
 175                 .msg_iov = &iov,
 176                 .msg_iovlen = 1,
 177         };
 178         char buf[16384];
 179
 180         iov.iov_base = buf;
 181         while (1) {
 182                 int status;
 183                 struct nlmsghdr *h;
 184
 185                 iov.iov_len = sizeof(buf);
 186                 status = recvmsg(rth->fd, &msg, 0);
 187
 188                 if (status < 0) {
 189                         if (errno == EINTR)
 190                                 continue;
 191                         ERROR("OVERRUN");
 192                         continue;
 193                 }
 194
 195                 if (status == 0) {
 196                         ERROR("EOF on netlink\n");
 197                         return -1;
 198                 }
 199
 200                 h = (struct nlmsghdr *)buf;
 201                 while (NLMSG_OK(h, status)) {
 202                         int err;
 203
 204                         if (nladdr.nl_pid != 0 ||
 205                             h->nlmsg_pid != rth->local.nl_pid ||
 206                             h->nlmsg_seq != rth->dump) {
 207                                 if (junk) {
 208                                         err = junk(&nladdr, h, arg2);
 209                                         if (err < 0)
 210                                                 return err;
 211                                 }
 212                                 goto skip_it;
 213                         }
 214
 215                         if (h->nlmsg_type == NLMSG_DONE)
 216                                 return 0;
 217                         if (h->nlmsg_type == NLMSG_ERROR) {
 218                                 struct nlmsgerr *err =
 219                                     (struct nlmsgerr *)NLMSG_DATA(h);
 220                                 if (h->nlmsg_len <
 221                                     NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
 222                                         ERROR("ERROR truncated\n");
 223                                 } else {
 224                                         errno = -err->error;
 225                                         INFO("RTNETLINK answers");
 226                                 }
 227                                 return -1;
 228                         }
 229                         err = filter(&nladdr, h, arg1);
 230                         if (err < 0)
 231                                 return err;
 232
 233                       skip_it:
 234                         h = NLMSG_NEXT(h, status);
 235                 }
 236                 if (msg.msg_flags & MSG_TRUNC) {
 237                         ERROR("Message truncated\n");
 238                         continue;
 239                 }
 240                 if (status) {
 241                         ERROR("!!!Remnant of size %d\n", status);
 242                         return -1;
 243                 }
 244         }
 245 }
 246
 247 int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
 248               unsigned groups, struct nlmsghdr *answer,
 249               rtnl_filter_t junk, void *jarg)
 250 {
 251         int status;
 252         unsigned seq;
 253         struct nlmsghdr *h;
 254         struct sockaddr_nl nladdr;
 255         struct iovec iov = {
 256                 .iov_base = (void *)n,
 257                 .iov_len = n->nlmsg_len
 258         };
 259         struct msghdr msg = {
 260                 .msg_name = &nladdr,
 261                 .msg_namelen = sizeof(nladdr),
 262                 .msg_iov = &iov,
 263                 .msg_iovlen = 1,
 264         };
 265         char buf[16384];
 266
 267         memset(&nladdr, 0, sizeof(nladdr));
 268         nladdr.nl_family = AF_NETLINK;
 269         nladdr.nl_pid = peer;
 270         nladdr.nl_groups = groups;
 271
 272         n->nlmsg_seq = seq = ++rtnl->seq;
 273
 274         if (answer == NULL)
 275                 n->nlmsg_flags |= NLM_F_ACK;
 276
 277         status = sendmsg(rtnl->fd, &msg, 0);
 278
 279         if (status < 0) {
 280                 ERROR("Cannot talk to rtnetlink");
 281                 return -1;
 282         }
 283
 284         memset(buf, 0, sizeof(buf));
 285
 286         iov.iov_base = buf;
 287
 288         while (1) {
 289                 iov.iov_len = sizeof(buf);
 290                 status = recvmsg(rtnl->fd, &msg, 0);
 291
 292                 if (status < 0) {
 293                         if (errno == EINTR)
 294                                 continue;
 295                         ERROR("OVERRUN");
 296                         continue;
 297                 }
 298                 if (status == 0) {
 299                         ERROR("EOF on netlink\n");
 300                         return -1;
 301                 }
 302                 if (msg.msg_namelen != sizeof(nladdr)) {
 303                         ERROR("sender address length == %d\n",
 304                                 msg.msg_namelen);
 305                         return -1;
 306                 }
 307                 for (h = (struct nlmsghdr *)buf; status >= sizeof(*h);) {
 308                         int err;
 309                         int len = h->nlmsg_len;
 310                         int l = len - sizeof(*h);
 311
 312                         if (l < 0 || len > status) {
 313                                 if (msg.msg_flags & MSG_TRUNC) {
 314                                         ERROR("Truncated message\n");
 315                                         return -1;
 316                                 }
 317                                 ERROR(
 318                                         "!!!malformed message: len=%d\n", len);
 319                                 return -1;
 320                         }
 321
 322                         if (nladdr.nl_pid != peer ||
 323                             h->nlmsg_pid != rtnl->local.nl_pid ||
 324                             h->nlmsg_seq != seq) {
 325                                 if (junk) {
 326                                         err = junk(&nladdr, h, jarg);
 327                                         if (err < 0)
 328                                                 return err;
 329                                 }
 330                                 /* Don't forget to skip that message. */
 331                                 status -= NLMSG_ALIGN(len);
 332                                 h = (struct nlmsghdr *)((char *)h +
 333                                                         NLMSG_ALIGN(len));
 334                                 continue;
 335                         }
 336
 337                         if (h->nlmsg_type == NLMSG_ERROR) {
 338                                 struct nlmsgerr *err =
 339                                     (struct nlmsgerr *)NLMSG_DATA(h);
 340                                 if (l < sizeof(struct nlmsgerr)) {
 341                                         ERROR("ERROR truncated\n");
 342                                 } else {
 343                                         errno = -err->error;
 344                                         if (errno == 0) {
 345                                                 if (answer)
 346                                                         memcpy(answer, h,
 347                                                                h->nlmsg_len);
 348                                                 return 0;
 349                                         }
 350                                         ERROR("RTNETLINK answers");
 351                                 }
 352                                 return -1;
 353                         }
 354                         if (answer) {
 355                                 memcpy(answer, h, h->nlmsg_len);
 356                                 return 0;
 357                         }
 358
 359                         ERROR("Unexpected reply!!!\n");
 360
 361                         status -= NLMSG_ALIGN(len);
 362                         h = (struct nlmsghdr *)((char *)h + NLMSG_ALIGN(len));
 363                 }
 364                 if (msg.msg_flags & MSG_TRUNC) {
 365                         ERROR("Message truncated\n");
 366                         continue;
 367                 }
 368                 if (status) {
 369                         ERROR("!!!Remnant of size %d\n", status);
 370                         return -1;
 371                 }
 372         }
 373 }
 374
 375 int rtnl_listen(struct rtnl_handle *rtnl, rtnl_filter_t handler, void *jarg)
 376 {
 377         int status;
 378         struct nlmsghdr *h;
 379         struct sockaddr_nl nladdr;
 380         struct iovec iov;
 381         struct msghdr msg = {
 382                 .msg_name = &nladdr,
 383                 .msg_namelen = sizeof(nladdr),
 384                 .msg_iov = &iov,
 385                 .msg_iovlen = 1,
 386         };
 387         char buf[8192];
 388
 389         memset(&nladdr, 0, sizeof(nladdr));
 390         nladdr.nl_family = AF_NETLINK;
 391         nladdr.nl_pid = 0;
 392         nladdr.nl_groups = 0;
 393
 394         iov.iov_base = buf;
 395         while (1) {
 396                 iov.iov_len = sizeof(buf);
 397                 status = recvmsg(rtnl->fd, &msg, 0);
 398
 399                 if (status < 0) {
 400                         if (errno == EINTR)
 401                                 continue;
 402                         if (errno == EAGAIN)
 403                                 return 0;
 404                         ERROR("OVERRUN: recvmsg(): error %d : %s\n", errno, strerror(errno));
 405                         return -1;
 406                 }
 407                 if (status == 0) {
 408                         ERROR("EOF on netlink\n");
 409                         return -1;
 410                 }
 411                 if (msg.msg_namelen != sizeof(nladdr)) {
 412                         ERROR("Sender address length == %d\n",
 413                                 msg.msg_namelen);
 414                         return -1;
 415                 }
 416                 for (h = (struct nlmsghdr *)buf; status >= sizeof(*h);) {
 417                         int err;
 418                         int len = h->nlmsg_len;
 419                         int l = len - sizeof(*h);
 420
 421                         if (l < 0 || len > status) {
 422                                 if (msg.msg_flags & MSG_TRUNC) {
 423                                         ERROR("Truncated message\n");
 424                                         return -1;
 425                                 }
 426                                 ERROR(
 427                                         "!!!malformed message: len=%d\n", len);
 428                                 return -1;
 429                         }
 430
 431                         err = handler(&nladdr, h, jarg);
 432                         if (err < 0) {
 433                                 ERROR("Handler returned %d\n", err);
 434                                 return err;
 435                         }
 436
 437                         status -= NLMSG_ALIGN(len);
 438                         h = (struct nlmsghdr *)((char *)h + NLMSG_ALIGN(len));
 439                 }
 440                 if (msg.msg_flags & MSG_TRUNC) {
 441                         ERROR("Message truncated\n");
 442                         continue;
 443                 }
 444                 if (status) {
 445                         ERROR("!!!Remnant of size %d\n", status);
 446                         return -1;
 447                 }
 448         }
 449 }
 450
 451 int rtnl_from_file(FILE * rtnl, rtnl_filter_t handler, void *jarg)
 452 {
 453         int status;
 454         struct sockaddr_nl nladdr;
 455         char buf[8192];
 456         struct nlmsghdr *h = (void *)buf;
 457
 458         memset(&nladdr, 0, sizeof(nladdr));
 459         nladdr.nl_family = AF_NETLINK;
 460         nladdr.nl_pid = 0;
 461         nladdr.nl_groups = 0;
 462
 463         while (1) {
 464                 int err, len;
 465                 int l;
 466
 467                 status = fread(&buf, 1, sizeof(*h), rtnl);
 468
 469                 if (status < 0) {
 470                         if (errno == EINTR)
 471                                 continue;
 472                         ERROR("rtnl_from_file: fread");
 473                         return -1;
 474                 }
 475                 if (status == 0)
 476                         return 0;
 477
 478                 len = h->nlmsg_len;
 479                 l = len - sizeof(*h);
 480
 481                 if (l < 0 || len > sizeof(buf)) {
 482                         ERROR("!!!malformed message: len=%d @%lu\n",
 483                                 len, ftell(rtnl));
 484                         return -1;
 485                 }
 486
 487                 status = fread(NLMSG_DATA(h), 1, NLMSG_ALIGN(l), rtnl);
 488
 489                 if (status < 0) {
 490                         ERROR("rtnl_from_file: fread");
 491                         return -1;
 492                 }
 493                 if (status < l) {
 494                         ERROR("rtnl-from_file: truncated message\n");
 495                         return -1;
 496                 }
 497
 498                 err = handler(&nladdr, h, jarg);
 499                 if (err < 0)
 500                         return err;
 501         }
 502 }
 503
 504 int addattr32(struct nlmsghdr *n, int maxlen, int type, __u32 data)
 505 {
 506         int len = RTA_LENGTH(4);
 507         struct rtattr *rta;
 508         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
 509                 ERROR(
 510                         "addattr32: Error! max allowed bound %d exceeded\n",
 511                         maxlen);
 512                 return -1;
 513         }
 514         rta = NLMSG_TAIL(n);
 515         rta->rta_type = type;
 516         rta->rta_len = len;
 517         memcpy(RTA_DATA(rta), &data, 4);
 518         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 519         return 0;
 520 }
 521
 522 int addattr8(struct nlmsghdr *n, int maxlen, int type, __u8 data)
 523 {
 524         int len = RTA_LENGTH(1);
 525         struct rtattr *rta;
 526         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
 527                 ERROR(
 528                         "addattr8: Error! max allowed bound %d exceeded\n",
 529                         maxlen);
 530                 return -1;
 531         }
 532         rta = NLMSG_TAIL(n);
 533         rta->rta_type = type;
 534         rta->rta_len = len;
 535         memcpy(RTA_DATA(rta), &data, 1);
 536         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 537         return 0;
 538 }
 539
 540 int addattr_l(struct nlmsghdr *n, int maxlen, int type, const void *data,
 541               int alen)
 542 {
 543         int len = RTA_LENGTH(alen);
 544         struct rtattr *rta;
 545
 546         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len) > maxlen) {
 547                 ERROR(
 548                         "addattr_l ERROR: message exceeded bound of %d\n",
 549                         maxlen);
 550                 return -1;
 551         }
 552         rta = NLMSG_TAIL(n);
 553         rta->rta_type = type;
 554         rta->rta_len = len;
 555         memcpy(RTA_DATA(rta), data, alen);
 556         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len);
 557         return 0;
 558 }
 559
 560 int addraw_l(struct nlmsghdr *n, int maxlen, const void *data, int len)
 561 {
 562         if (NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len) > maxlen) {
 563                 ERROR(
 564                         "addraw_l ERROR: message exceeded bound of %d\n",
 565                         maxlen);
 566                 return -1;
 567         }
 568
 569         memcpy(NLMSG_TAIL(n), data, len);
 570         memset((void *)NLMSG_TAIL(n) + len, 0, NLMSG_ALIGN(len) - len);
 571         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len);
 572         return 0;
 573 }
 574
 575 int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data)
 576 {
 577         int len = RTA_LENGTH(4);
 578         struct rtattr *subrta;
 579
 580         if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
 581                 ERROR(
 582                         "rta_addattr32: Error! max allowed bound %d exceeded\n",
 583                         maxlen);
 584                 return -1;
 585         }
 586         subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
 587         subrta->rta_type = type;
 588         subrta->rta_len = len;
 589         memcpy(RTA_DATA(subrta), &data, 4);
 590         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
 591         return 0;
 592 }
 593
 594 int rta_addattr_l(struct rtattr *rta, int maxlen, int type,
 595                   const void *data, int alen)
 596 {
 597         struct rtattr *subrta;
 598         int len = RTA_LENGTH(alen);
 599
 600         if (RTA_ALIGN(rta->rta_len) + RTA_ALIGN(len) > maxlen) {
 601                 ERROR(
 602                         "rta_addattr_l: Error! max allowed bound %d exceeded\n",
 603                         maxlen);
 604                 return -1;
 605         }
 606         subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
 607         subrta->rta_type = type;
 608         subrta->rta_len = len;
 609         memcpy(RTA_DATA(subrta), data, alen);
 610         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + RTA_ALIGN(len);
 611         return 0;
 612 }
 613
 614 int rta_addattr8(struct rtattr *rta, int maxlen, int type, __u8 data)
 615 {
 616         return rta_addattr_l(rta, maxlen, type, &data, sizeof(__u8));
 617 }
 618
 619 int rta_addattr16(struct rtattr *rta, int maxlen, int type, __u16 data)
 620 {
 621         return rta_addattr_l(rta, maxlen, type, &data, sizeof(__u16));
 622 }
 623
 624 int rta_addattr64(struct rtattr *rta, int maxlen, int type, __u64 data)
 625 {
 626         return rta_addattr_l(rta, maxlen, type, &data, sizeof(__u64));
 627 }
 628
 629 struct rtattr *rta_nest(struct rtattr *rta, int maxlen, int type)
 630 {
 631         struct rtattr *nest = RTA_TAIL(rta);
 632
 633         rta_addattr_l(rta, maxlen, type, NULL, 0);
 634         nest->rta_type |= NLA_F_NESTED;
 635
 636         return nest;
 637 }
 638
 639 int rta_nest_end(struct rtattr *rta, struct rtattr *nest)
 640 {
 641         nest->rta_len = (void *)RTA_TAIL(rta) - (void *)nest;
 642
 643         return rta->rta_len;
 644 }
 645
 646 int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
 647 {
 648         memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
 649         while (RTA_OK(rta, len)) {
 650                 if (rta->rta_type <= max)
 651                         tb[rta->rta_type] = rta;
 652                 rta = RTA_NEXT(rta, len);
 653         }
 654         if (len)
 655                 ERROR("!!!Deficit %d, rta_len=%d\n", len,
 656                         rta->rta_len);
 657         return 0;
 658 }
 659
 660 int parse_rtattr_byindex(struct rtattr *tb[], int max, struct rtattr *rta,
 661                          int len)
 662 {
 663         int i = 0;
 664
 665         memset(tb, 0, sizeof(struct rtattr *) * max);
 666         while (RTA_OK(rta, len)) {
 667                 if (rta->rta_type <= max && i < max)
 668                         tb[i++] = rta;
 669                 rta = RTA_NEXT(rta, len);
 670         }
 671         if (len)
 672                 ERROR("!!!Deficit %d, rta_len=%d\n", len,
 673                         rta->rta_len);
 674         return i;
 675 }