networking/libiproute/libnetlink.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * libnetlink.c RTnetlink service routines.
   4  *
   5  *              This program is free software; you can redistribute it and/or
   6  *              modify it under the terms of the GNU General Public License
   7  *              as published by the Free Software Foundation; either version
   8  *              2 of the License, or (at your option) any later version.
   9  *
  10  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  11  *
  12  */
  13
  14 #include <sys/socket.h>
  15 #include <sys/uio.h>
  16
  17 #include "libbb.h"
  18 #include "libnetlink.h"
  19
  20 void rtnl_close(struct rtnl_handle *rth)
  21 {
  22         close(rth->fd);
  23 }
  24
  25 int xrtnl_open(struct rtnl_handle *rth/*, unsigned subscriptions*/)
  26 {
  27         socklen_t addr_len;
  28
  29         memset(rth, 0, sizeof(rth));
  30
  31         rth->fd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  32
  33         memset(&rth->local, 0, sizeof(rth->local));
  34         rth->local.nl_family = AF_NETLINK;
  35         /*rth->local.nl_groups = subscriptions;*/
  36
  37         xbind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local));
  38         addr_len = sizeof(rth->local);
  39         if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0)
  40                 bb_perror_msg_and_die("cannot getsockname");
  41         if (addr_len != sizeof(rth->local))
  42                 bb_error_msg_and_die("wrong address length %d", addr_len);
  43         if (rth->local.nl_family != AF_NETLINK)
  44                 bb_error_msg_and_die("wrong address family %d", rth->local.nl_family);
  45         rth->seq = time(NULL);
  46         return 0;
  47 }
  48
  49 int xrtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
  50 {
  51         struct {
  52                 struct nlmsghdr nlh;
  53                 struct rtgenmsg g;
  54         } req;
  55         struct sockaddr_nl nladdr;
  56
  57         memset(&nladdr, 0, sizeof(nladdr));
  58         nladdr.nl_family = AF_NETLINK;
  59
  60         req.nlh.nlmsg_len = sizeof(req);
  61         req.nlh.nlmsg_type = type;
  62         req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
  63         req.nlh.nlmsg_pid = 0;
  64         req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
  65         req.g.rtgen_family = family;
  66
  67         return xsendto(rth->fd, (void*)&req, sizeof(req),
  68                                  (struct sockaddr*)&nladdr, sizeof(nladdr));
  69 }
  70
  71 int rtnl_send(struct rtnl_handle *rth, char *buf, int len)
  72 {
  73         struct sockaddr_nl nladdr;
  74
  75         memset(&nladdr, 0, sizeof(nladdr));
  76         nladdr.nl_family = AF_NETLINK;
  77
  78         return xsendto(rth->fd, buf, len, (struct sockaddr*)&nladdr, sizeof(nladdr));
  79 }
  80
  81 int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
  82 {
  83         struct nlmsghdr nlh;
  84         struct sockaddr_nl nladdr;
  85         struct iovec iov[2] = { { &nlh, sizeof(nlh) }, { req, len } };
  86         struct msghdr msg = {
  87                 (void*)&nladdr, sizeof(nladdr),
  88                 iov,    2,
  89                 NULL,   0,
  90                 0
  91         };
  92
  93         memset(&nladdr, 0, sizeof(nladdr));
  94         nladdr.nl_family = AF_NETLINK;
  95
  96         nlh.nlmsg_len = NLMSG_LENGTH(len);
  97         nlh.nlmsg_type = type;
  98         nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
  99         nlh.nlmsg_pid = 0;
 100         nlh.nlmsg_seq = rth->dump = ++rth->seq;
 101
 102         return sendmsg(rth->fd, &msg, 0);
 103 }
 104
 105 static int rtnl_dump_filter(struct rtnl_handle *rth,
 106                 int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
 107                 void *arg1/*,
 108                 int (*junk)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
 109                 void *arg2*/)
 110 {
 111         char buf[8192];
 112         struct sockaddr_nl nladdr;
 113         struct iovec iov = { buf, sizeof(buf) };
 114
 115         while (1) {
 116                 int status;
 117                 struct nlmsghdr *h;
 118
 119                 struct msghdr msg = {
 120                         (void*)&nladdr, sizeof(nladdr),
 121                         &iov,   1,
 122                         NULL,   0,
 123                         0
 124                 };
 125
 126                 status = recvmsg(rth->fd, &msg, 0);
 127
 128                 if (status < 0) {
 129                         if (errno == EINTR)
 130                                 continue;
 131                         bb_perror_msg("OVERRUN");
 132                         continue;
 133                 }
 134                 if (status == 0) {
 135                         bb_error_msg("EOF on netlink");
 136                         return -1;
 137                 }
 138                 if (msg.msg_namelen != sizeof(nladdr)) {
 139                         bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
 140                 }
 141
 142                 h = (struct nlmsghdr*)buf;
 143                 while (NLMSG_OK(h, status)) {
 144                         int err;
 145
 146                         if (nladdr.nl_pid != 0 ||
 147                             h->nlmsg_pid != rth->local.nl_pid ||
 148                             h->nlmsg_seq != rth->dump) {
 149 /*                              if (junk) {
 150                                         err = junk(&nladdr, h, arg2);
 151                                         if (err < 0)
 152                                                 return err;
 153                                 } */
 154                                 goto skip_it;
 155                         }
 156
 157                         if (h->nlmsg_type == NLMSG_DONE) {
 158                                 return 0;
 159                         }
 160                         if (h->nlmsg_type == NLMSG_ERROR) {
 161                                 struct nlmsgerr *l_err = (struct nlmsgerr*)NLMSG_DATA(h);
 162                                 if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
 163                                         bb_error_msg("ERROR truncated");
 164                                 } else {
 165                                         errno = -l_err->error;
 166                                         bb_perror_msg("RTNETLINK answers");
 167                                 }
 168                                 return -1;
 169                         }
 170                         err = filter(&nladdr, h, arg1);
 171                         if (err < 0)
 172                                 return err;
 173
 174 skip_it:
 175                         h = NLMSG_NEXT(h, status);
 176                 }
 177                 if (msg.msg_flags & MSG_TRUNC) {
 178                         bb_error_msg("message truncated");
 179                         continue;
 180                 }
 181                 if (status) {
 182                         bb_error_msg_and_die("remnant of size %d!", status);
 183                 }
 184         }
 185 }
 186
 187 int xrtnl_dump_filter(struct rtnl_handle *rth,
 188                 int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
 189                 void *arg1)
 190 {
 191         int ret = rtnl_dump_filter(rth, filter, arg1/*, NULL, NULL*/);
 192         if (ret < 0)
 193                 bb_error_msg_and_die("dump terminated");
 194         return ret;
 195 }
 196
 197 int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
 198               unsigned groups, struct nlmsghdr *answer,
 199               int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
 200               void *jarg)
 201 {
 202         int status;
 203         unsigned seq;
 204         struct nlmsghdr *h;
 205         struct sockaddr_nl nladdr;
 206         struct iovec iov = { (void*)n, n->nlmsg_len };
 207         char   buf[8192];
 208         struct msghdr msg = {
 209                 (void*)&nladdr, sizeof(nladdr),
 210                 &iov,   1,
 211                 NULL,   0,
 212                 0
 213         };
 214
 215         memset(&nladdr, 0, sizeof(nladdr));
 216         nladdr.nl_family = AF_NETLINK;
 217         nladdr.nl_pid = peer;
 218         nladdr.nl_groups = groups;
 219
 220         n->nlmsg_seq = seq = ++rtnl->seq;
 221         if (answer == NULL) {
 222                 n->nlmsg_flags |= NLM_F_ACK;
 223         }
 224         status = sendmsg(rtnl->fd, &msg, 0);
 225
 226         if (status < 0) {
 227                 bb_perror_msg("cannot talk to rtnetlink");
 228                 return -1;
 229         }
 230
 231         iov.iov_base = buf;
 232
 233         while (1) {
 234                 iov.iov_len = sizeof(buf);
 235                 status = recvmsg(rtnl->fd, &msg, 0);
 236
 237                 if (status < 0) {
 238                         if (errno == EINTR) {
 239                                 continue;
 240                         }
 241                         bb_perror_msg("OVERRUN");
 242                         continue;
 243                 }
 244                 if (status == 0) {
 245                         bb_error_msg("EOF on netlink");
 246                         return -1;
 247                 }
 248                 if (msg.msg_namelen != sizeof(nladdr)) {
 249                         bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
 250                 }
 251                 for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
 252                         int l_err;
 253                         int len = h->nlmsg_len;
 254                         int l = len - sizeof(*h);
 255
 256                         if (l<0 || len>status) {
 257                                 if (msg.msg_flags & MSG_TRUNC) {
 258                                         bb_error_msg("truncated message");
 259                                         return -1;
 260                                 }
 261                                 bb_error_msg_and_die("malformed message: len=%d!", len);
 262                         }
 263
 264                         if (nladdr.nl_pid != peer ||
 265                             h->nlmsg_pid != rtnl->local.nl_pid ||
 266                             h->nlmsg_seq != seq) {
 267                                 if (junk) {
 268                                         l_err = junk(&nladdr, h, jarg);
 269                                         if (l_err < 0) {
 270                                                 return l_err;
 271                                         }
 272                                 }
 273                                 continue;
 274                         }
 275
 276                         if (h->nlmsg_type == NLMSG_ERROR) {
 277                                 struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
 278                                 if (l < sizeof(struct nlmsgerr)) {
 279                                         bb_error_msg("ERROR truncated");
 280                                 } else {
 281                                         errno = -err->error;
 282                                         if (errno == 0) {
 283                                                 if (answer) {
 284                                                         memcpy(answer, h, h->nlmsg_len);
 285                                                 }
 286                                                 return 0;
 287                                         }
 288                                         bb_perror_msg("RTNETLINK answers");
 289                                 }
 290                                 return -1;
 291                         }
 292                         if (answer) {
 293                                 memcpy(answer, h, h->nlmsg_len);
 294                                 return 0;
 295                         }
 296
 297                         bb_error_msg("unexpected reply!");
 298
 299                         status -= NLMSG_ALIGN(len);
 300                         h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
 301                 }
 302                 if (msg.msg_flags & MSG_TRUNC) {
 303                         bb_error_msg("message truncated");
 304                         continue;
 305                 }
 306                 if (status) {
 307                         bb_error_msg_and_die("remnant of size %d!", status);
 308                 }
 309         }
 310 }
 311
 312 int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
 313 {
 314         int len = RTA_LENGTH(4);
 315         struct rtattr *rta;
 316         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
 317                 return -1;
 318         rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
 319         rta->rta_type = type;
 320         rta->rta_len = len;
 321         memcpy(RTA_DATA(rta), &data, 4);
 322         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 323         return 0;
 324 }
 325
 326 int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
 327 {
 328         int len = RTA_LENGTH(alen);
 329         struct rtattr *rta;
 330
 331         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
 332                 return -1;
 333         rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
 334         rta->rta_type = type;
 335         rta->rta_len = len;
 336         memcpy(RTA_DATA(rta), data, alen);
 337         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
 338         return 0;
 339 }
 340
 341 int rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data)
 342 {
 343         int len = RTA_LENGTH(4);
 344         struct rtattr *subrta;
 345
 346         if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
 347                 return -1;
 348         }
 349         subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
 350         subrta->rta_type = type;
 351         subrta->rta_len = len;
 352         memcpy(RTA_DATA(subrta), &data, 4);
 353         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
 354         return 0;
 355 }
 356
 357 int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
 358 {
 359         struct rtattr *subrta;
 360         int len = RTA_LENGTH(alen);
 361
 362         if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
 363                 return -1;
 364         }
 365         subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
 366         subrta->rta_type = type;
 367         subrta->rta_len = len;
 368         memcpy(RTA_DATA(subrta), data, alen);
 369         rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
 370         return 0;
 371 }
 372
 373
 374 int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
 375 {
 376         while (RTA_OK(rta, len)) {
 377                 if (rta->rta_type <= max) {
 378                         tb[rta->rta_type] = rta;
 379                 }
 380                 rta = RTA_NEXT(rta,len);
 381         }
 382         if (len) {
 383                 bb_error_msg("deficit %d, rta_len=%d!", len, rta->rta_len);
 384         }
 385         return 0;
 386 }