sbin/ifconfig/af_inet.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1983, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #ifndef lint
  33 static const char rcsid[] =
  34   "$FreeBSD$";
  35 #endif /* not lint */
  36
  37 #include <sys/param.h>
  38 #include <sys/ioctl.h>
  39 #include <sys/socket.h>
  40 #include <net/if.h>
  41
  42 #include <ctype.h>
  43 #include <err.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <ifaddrs.h>
  49
  50 #include <netinet/in.h>
  51 #include <netinet/in_var.h>
  52 #include <arpa/inet.h>
  53 #include <netdb.h>
  54
  55 #include "ifconfig.h"
  56 #include "ifconfig_netlink.h"
  57
  58 #ifdef WITHOUT_NETLINK
  59 static struct in_aliasreq in_addreq;
  60 static struct ifreq in_ridreq;
  61 #else
  62 struct in_px {
  63         struct in_addr          addr;
  64         int                     plen;
  65         bool                    addrset;
  66         bool                    maskset;
  67 };
  68 struct in_pdata {
  69         struct in_px            addr;
  70         struct in_px            dst_addr;
  71         struct in_px            brd_addr;
  72         uint32_t                flags;
  73         uint32_t                vhid;
  74 };
  75 static struct in_pdata in_add, in_del;
  76 #endif
  77
  78 static char addr_buf[NI_MAXHOST];       /*for getnameinfo()*/
  79 extern char *f_inet, *f_addr;
  80
  81 static void
  82 print_addr(struct sockaddr_in *sin)
  83 {
  84         int error, n_flags;
  85
  86         if (f_addr != NULL && strcmp(f_addr, "fqdn") == 0)
  87                 n_flags = 0;
  88         else if (f_addr != NULL && strcmp(f_addr, "host") == 0)
  89                 n_flags = NI_NOFQDN;
  90         else
  91                 n_flags = NI_NUMERICHOST;
  92
  93         error = getnameinfo((struct sockaddr *)sin, sin->sin_len, addr_buf,
  94                             sizeof(addr_buf), NULL, 0, n_flags);
  95
  96         if (error)
  97                 inet_ntop(AF_INET, &sin->sin_addr, addr_buf, sizeof(addr_buf));
  98
  99         printf("\tinet %s", addr_buf);
 100 }
 101
 102 #ifdef WITHOUT_NETLINK
 103 static void
 104 in_status(if_ctx *ctx __unused, const struct ifaddrs *ifa)
 105 {
 106         struct sockaddr_in *sin, null_sin = {};
 107
 108         sin = (struct sockaddr_in *)ifa->ifa_addr;
 109         if (sin == NULL)
 110                 return;
 111
 112         print_addr(sin);
 113
 114         if (ifa->ifa_flags & IFF_POINTOPOINT) {
 115                 sin = (struct sockaddr_in *)ifa->ifa_dstaddr;
 116                 if (sin == NULL)
 117                         sin = &null_sin;
 118                 printf(" --> %s", inet_ntoa(sin->sin_addr));
 119         }
 120
 121         sin = (struct sockaddr_in *)ifa->ifa_netmask;
 122         if (sin == NULL)
 123                 sin = &null_sin;
 124         if (f_inet != NULL && strcmp(f_inet, "cidr") == 0) {
 125                 int cidr = 32;
 126                 unsigned long smask;
 127
 128                 smask = ntohl(sin->sin_addr.s_addr);
 129                 while ((smask & 1) == 0) {
 130                         smask = smask >> 1;
 131                         cidr--;
 132                         if (cidr == 0)
 133                                 break;
 134                 }
 135                 printf("/%d", cidr);
 136         } else if (f_inet != NULL && strcmp(f_inet, "dotted") == 0)
 137                 printf(" netmask %s", inet_ntoa(sin->sin_addr));
 138         else
 139                 printf(" netmask 0x%lx", (unsigned long)ntohl(sin->sin_addr.s_addr));
 140
 141         if (ifa->ifa_flags & IFF_BROADCAST) {
 142                 sin = (struct sockaddr_in *)ifa->ifa_broadaddr;
 143                 if (sin != NULL && sin->sin_addr.s_addr != 0)
 144                         printf(" broadcast %s", inet_ntoa(sin->sin_addr));
 145         }
 146
 147         print_vhid(ifa, " ");
 148
 149         putchar('\n');
 150 }
 151
 152 #else
 153 static struct in_addr
 154 get_mask(int plen)
 155 {
 156         struct in_addr a;
 157
 158         a.s_addr = htonl(plen ? ~((1 << (32 - plen)) - 1) : 0);
 159
 160         return (a);
 161 }
 162
 163 static void
 164 in_status_nl(if_ctx *ctx __unused, if_link_t *link, if_addr_t *ifa)
 165 {
 166         struct sockaddr_in *sin = satosin(ifa->ifa_local);
 167         int plen = ifa->ifa_prefixlen;
 168
 169         print_addr(sin);
 170
 171         if (link->ifi_flags & IFF_POINTOPOINT) {
 172                 struct sockaddr_in *dst = satosin(ifa->ifa_address);
 173
 174                 printf(" --> %s", inet_ntoa(dst->sin_addr));
 175         }
 176         if (f_inet != NULL && strcmp(f_inet, "cidr") == 0) {
 177                 printf("/%d", plen);
 178         } else if (f_inet != NULL && strcmp(f_inet, "dotted") == 0)
 179                 printf(" netmask %s", inet_ntoa(get_mask(plen)));
 180         else
 181                 printf(" netmask 0x%lx", (unsigned long)ntohl(get_mask(plen).s_addr));
 182
 183         if ((link->ifi_flags & IFF_BROADCAST) && plen != 0)  {
 184                 struct sockaddr_in *brd = satosin(ifa->ifa_broadcast);
 185                 if (brd != NULL)
 186                         printf(" broadcast %s", inet_ntoa(brd->sin_addr));
 187         }
 188
 189         if (ifa->ifaf_vhid != 0)
 190                 printf(" vhid %d", ifa->ifaf_vhid);
 191
 192         putchar('\n');
 193 }
 194 #endif
 195
 196
 197 #ifdef WITHOUT_NETLINK
 198 #define SIN(x) ((struct sockaddr_in *) &(x))
 199 static struct sockaddr_in *sintab[] = {
 200         SIN(in_ridreq.ifr_addr), SIN(in_addreq.ifra_addr),
 201         SIN(in_addreq.ifra_mask), SIN(in_addreq.ifra_broadaddr)
 202 };
 203
 204 static void
 205 in_copyaddr(if_ctx *ctx, int to, int from)
 206 {
 207         memcpy(sintab[to], sintab[from], sizeof(struct sockaddr_in));
 208 }
 209
 210 static void
 211 in_getaddr(const char *s, int which)
 212 {
 213         struct sockaddr_in *sin = sintab[which];
 214         struct hostent *hp;
 215         struct netent *np;
 216
 217         sin->sin_len = sizeof(*sin);
 218         sin->sin_family = AF_INET;
 219
 220         if (which == ADDR) {
 221                 char *p = NULL;
 222
 223                 if((p = strrchr(s, '/')) != NULL) {
 224                         const char *errstr;
 225                         /* address is `name/masklen' */
 226                         int masklen = 0;
 227                         struct sockaddr_in *min = sintab[MASK];
 228                         *p = '\0';
 229                         if (!isdigit(*(p + 1)))
 230                                 errstr = "invalid";
 231                         else
 232                                 masklen = (int)strtonum(p + 1, 0, 32, &errstr);
 233                         if (errstr != NULL) {
 234                                 *p = '/';
 235                                 errx(1, "%s: bad value (width %s)", s, errstr);
 236                         }
 237                         min->sin_family = AF_INET;
 238                         min->sin_len = sizeof(*min);
 239                         min->sin_addr.s_addr = htonl(~((1LL << (32 - masklen)) - 1) &
 240                                               0xffffffff);
 241                 }
 242         }
 243
 244         if (inet_aton(s, &sin->sin_addr))
 245                 return;
 246         if ((hp = gethostbyname(s)) != NULL)
 247                 bcopy(hp->h_addr, (char *)&sin->sin_addr,
 248                     MIN((size_t)hp->h_length, sizeof(sin->sin_addr)));
 249         else if ((np = getnetbyname(s)) != NULL)
 250                 sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
 251         else
 252                 errx(1, "%s: bad value", s);
 253 }
 254
 255 #else
 256
 257 static struct in_px *sintab_nl[] = {
 258         &in_del.addr,           /* RIDADDR */
 259         &in_add.addr,           /* ADDR */
 260         NULL,                   /* MASK */
 261         &in_add.dst_addr,       /* DSTADDR*/
 262         &in_add.brd_addr,       /* BRDADDR*/
 263 };
 264
 265 static void
 266 in_copyaddr(if_ctx *ctx __unused, int to, int from)
 267 {
 268         sintab_nl[to]->addr = sintab_nl[from]->addr;
 269         sintab_nl[to]->addrset = sintab_nl[from]->addrset;
 270 }
 271
 272 static void
 273 in_getip(const char *addr_str, struct in_addr *ip)
 274 {
 275         struct hostent *hp;
 276         struct netent *np;
 277
 278         if (inet_aton(addr_str, ip))
 279                 return;
 280         if ((hp = gethostbyname(addr_str)) != NULL)
 281                 bcopy(hp->h_addr, (char *)ip,
 282                     MIN((size_t)hp->h_length, sizeof(ip)));
 283         else if ((np = getnetbyname(addr_str)) != NULL)
 284                 *ip = inet_makeaddr(np->n_net, INADDR_ANY);
 285         else
 286                 errx(1, "%s: bad value", addr_str);
 287 }
 288
 289 static void
 290 in_getaddr(const char *s, int which)
 291 {
 292         struct in_px *px = sintab_nl[which];
 293
 294         if (which == MASK) {
 295                 struct in_px *px_addr = sintab_nl[ADDR];
 296                 struct in_addr mask = {};
 297
 298                 in_getip(s, &mask);
 299                 px_addr->plen = __bitcount32(mask.s_addr);
 300                 px_addr->maskset = true;
 301                 return;
 302         }
 303
 304         if (which == ADDR) {
 305                 char *p = NULL;
 306
 307                 if((p = strrchr(s, '/')) != NULL) {
 308                         const char *errstr;
 309                         /* address is `name/masklen' */
 310                         int masklen;
 311                         *p = '\0';
 312                         if (!isdigit(*(p + 1)))
 313                                 errstr = "invalid";
 314                         else
 315                                 masklen = (int)strtonum(p + 1, 0, 32, &errstr);
 316                         if (errstr != NULL) {
 317                                 *p = '/';
 318                                 errx(1, "%s: bad value (width %s)", s, errstr);
 319                         }
 320                         px->plen = masklen;
 321                         px->maskset = true;
 322                 }
 323         }
 324
 325         in_getip(s, &px->addr);
 326         px->addrset = true;
 327 }
 328
 329 /*
 330  * Deletes the first found IPv4 interface address for the interface.
 331  *
 332  * This function provides SIOCDIFADDR semantics missing in Netlink.
 333  * When no valid IPv4 address is specified (sin_family or sin_len is wrong) to
 334  * the SIOCDIFADDR call, it deletes the first found IPv4 address on the interface.
 335  * 'ifconfig IFNAME inet addr/prefix' relies on that behavior, as it
 336  *  executes empty SIOCDIFADDR before adding a new address.
 337  */
 338 static int
 339 in_delete_first_nl(if_ctx *ctx)
 340 {
 341         struct nlmsghdr *hdr;
 342         struct ifaddrmsg *ifahdr;
 343         uint32_t nlmsg_seq;
 344         struct in_addr addr;
 345         struct snl_writer nw = {};
 346         struct snl_errmsg_data e = {};
 347         struct snl_state *ss = ctx->io_ss;
 348         bool found = false;
 349
 350         uint32_t ifindex = if_nametoindex_nl(ss, name);
 351         if (ifindex == 0) {
 352                 /* No interface with the desired name, nothing to delete */
 353                 return (EADDRNOTAVAIL);
 354         }
 355
 356         snl_init_writer(ss, &nw);
 357         hdr = snl_create_msg_request(&nw, NL_RTM_GETADDR);
 358         hdr->nlmsg_flags |= NLM_F_DUMP;
 359         ifahdr = snl_reserve_msg_object(&nw, struct ifaddrmsg);
 360         ifahdr->ifa_family = AF_INET;
 361         ifahdr->ifa_index = ifindex;
 362
 363         if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr))
 364                 return (EINVAL);
 365
 366         nlmsg_seq = hdr->nlmsg_seq;
 367         while ((hdr = snl_read_reply_multi(ss, nlmsg_seq, &e)) != NULL) {
 368                 struct snl_parsed_addr attrs = {};
 369                 if (snl_parse_nlmsg(ss, hdr, &snl_rtm_addr_parser, &attrs)) {
 370                         addr = satosin(attrs.ifa_local)->sin_addr;
 371                         ifindex = attrs.ifa_index;
 372                         found = true;
 373                         break;
 374                 } else
 375                         return (EINVAL);
 376         }
 377         if (e.error != 0) {
 378                 if (e.error_str != NULL)
 379                         warnx("%s(): %s", __func__, e.error_str);
 380                 return (e.error);
 381         }
 382
 383         if (!found)
 384                 return (0);
 385
 386         /* Try to delete the found address */
 387         snl_init_writer(ss, &nw);
 388         hdr = snl_create_msg_request(&nw, NL_RTM_DELADDR);
 389         ifahdr = snl_reserve_msg_object(&nw, struct ifaddrmsg);
 390         ifahdr->ifa_family = AF_INET;
 391         ifahdr->ifa_index = ifindex;
 392         snl_add_msg_attr_ip4(&nw, IFA_LOCAL, &addr);
 393
 394         if (!snl_finalize_msg(&nw) || !snl_send_message(ss, hdr))
 395                 return (EINVAL);
 396         memset(&e, 0, sizeof(e));
 397         snl_read_reply_code(ss, hdr->nlmsg_seq, &e);
 398         if (e.error_str != NULL)
 399                 warnx("%s(): %s", __func__, e.error_str);
 400
 401         return (e.error);
 402 }
 403
 404
 405 static int
 406 in_exec_nl(if_ctx *ctx, unsigned long action, void *data)
 407 {
 408         struct in_pdata *pdata = (struct in_pdata *)data;
 409         struct snl_writer nw = {};
 410
 411         if (action == NL_RTM_DELADDR && !pdata->addr.addrset)
 412                 return (in_delete_first_nl(ctx));
 413
 414         snl_init_writer(ctx->io_ss, &nw);
 415         struct nlmsghdr *hdr = snl_create_msg_request(&nw, action);
 416         struct ifaddrmsg *ifahdr = snl_reserve_msg_object(&nw, struct ifaddrmsg);
 417
 418         ifahdr->ifa_family = AF_INET;
 419         ifahdr->ifa_prefixlen = pdata->addr.plen;
 420         ifahdr->ifa_index = if_nametoindex_nl(ctx->io_ss, name);
 421
 422         snl_add_msg_attr_ip4(&nw, IFA_LOCAL, &pdata->addr.addr);
 423         if (action == NL_RTM_NEWADDR && pdata->dst_addr.addrset)
 424                 snl_add_msg_attr_ip4(&nw, IFA_ADDRESS, &pdata->dst_addr.addr);
 425         if (action == NL_RTM_NEWADDR && pdata->brd_addr.addrset)
 426                 snl_add_msg_attr_ip4(&nw, IFA_BROADCAST, &pdata->brd_addr.addr);
 427
 428         int off = snl_add_msg_attr_nested(&nw, IFA_FREEBSD);
 429         snl_add_msg_attr_u32(&nw, IFAF_FLAGS, pdata->flags);
 430         if (pdata->vhid != 0)
 431                 snl_add_msg_attr_u32(&nw, IFAF_VHID, pdata->vhid);
 432         snl_end_attr_nested(&nw, off);
 433
 434         if (!snl_finalize_msg(&nw) || !snl_send_message(ctx->io_ss, hdr))
 435                 return (0);
 436
 437         struct snl_errmsg_data e = {};
 438         snl_read_reply_code(ctx->io_ss, hdr->nlmsg_seq, &e);
 439         if (e.error_str != NULL)
 440                 warnx("%s(): %s", __func__, e.error_str);
 441
 442         return (e.error);
 443 }
 444
 445 static void
 446 in_setdefaultmask_nl(void)
 447 {
 448         struct in_px *px = sintab_nl[ADDR];
 449
 450         in_addr_t i = ntohl(px->addr.s_addr);
 451
 452         /*
 453          * If netmask isn't supplied, use historical default.
 454          * This is deprecated for interfaces other than loopback
 455          * or point-to-point; warn in other cases.  In the future
 456          * we should return an error rather than warning.
 457          */
 458         if (IN_CLASSA(i))
 459                 px->plen = IN_CLASSA_NSHIFT;
 460         else if (IN_CLASSB(i))
 461                 px->plen = IN_CLASSB_NSHIFT;
 462         else
 463                 px->plen = IN_CLASSC_NSHIFT;
 464         px->maskset = true;
 465 }
 466 #endif
 467
 468 static void
 469 warn_nomask(int ifflags)
 470 {
 471     if ((ifflags & (IFF_POINTOPOINT | IFF_LOOPBACK)) == 0) {
 472         warnx("WARNING: setting interface address without mask "
 473             "is deprecated,\ndefault mask may not be correct.");
 474     }
 475 }
 476
 477 static void
 478 in_postproc(if_ctx *ctx __unused, int newaddr, int ifflags)
 479 {
 480 #ifdef WITHOUT_NETLINK
 481         if (sintab[ADDR]->sin_len != 0 && sintab[MASK]->sin_len == 0 && newaddr) {
 482                 warn_nomask(ifflags);
 483         }
 484 #else
 485         if (sintab_nl[ADDR]->addrset && !sintab_nl[ADDR]->maskset && newaddr) {
 486                 warn_nomask(ifflags);
 487             in_setdefaultmask_nl();
 488         }
 489 #endif
 490 }
 491
 492 static void
 493 in_status_tunnel(int s)
 494 {
 495         char src[NI_MAXHOST];
 496         char dst[NI_MAXHOST];
 497         struct ifreq ifr;
 498         const struct sockaddr *sa = (const struct sockaddr *) &ifr.ifr_addr;
 499
 500         memset(&ifr, 0, sizeof(ifr));
 501         strlcpy(ifr.ifr_name, name, IFNAMSIZ);
 502
 503         if (ioctl(s, SIOCGIFPSRCADDR, (caddr_t)&ifr) < 0)
 504                 return;
 505         if (sa->sa_family != AF_INET)
 506                 return;
 507         if (getnameinfo(sa, sa->sa_len, src, sizeof(src), 0, 0, NI_NUMERICHOST) != 0)
 508                 src[0] = '\0';
 509
 510         if (ioctl(s, SIOCGIFPDSTADDR, (caddr_t)&ifr) < 0)
 511                 return;
 512         if (sa->sa_family != AF_INET)
 513                 return;
 514         if (getnameinfo(sa, sa->sa_len, dst, sizeof(dst), 0, 0, NI_NUMERICHOST) != 0)
 515                 dst[0] = '\0';
 516
 517         printf("\ttunnel inet %s --> %s\n", src, dst);
 518 }
 519
 520 static void
 521 in_set_tunnel(int s, struct addrinfo *srcres, struct addrinfo *dstres)
 522 {
 523         struct in_aliasreq addreq;
 524
 525         memset(&addreq, 0, sizeof(addreq));
 526         strlcpy(addreq.ifra_name, name, IFNAMSIZ);
 527         memcpy(&addreq.ifra_addr, srcres->ai_addr, srcres->ai_addr->sa_len);
 528         memcpy(&addreq.ifra_dstaddr, dstres->ai_addr, dstres->ai_addr->sa_len);
 529
 530         if (ioctl(s, SIOCSIFPHYADDR, &addreq) < 0)
 531                 warn("SIOCSIFPHYADDR");
 532 }
 533
 534 static void
 535 in_set_vhid(int vhid)
 536 {
 537 #ifdef WITHOUT_NETLINK
 538         in_addreq.ifra_vhid = vhid;
 539 #else
 540         in_add.vhid = (uint32_t)vhid;
 541 #endif
 542 }
 543
 544 static struct afswtch af_inet = {
 545         .af_name        = "inet",
 546         .af_af          = AF_INET,
 547 #ifdef WITHOUT_NETLINK
 548         .af_status      = in_status,
 549 #else
 550         .af_status      = in_status_nl,
 551 #endif
 552         .af_getaddr     = in_getaddr,
 553         .af_copyaddr    = in_copyaddr,
 554         .af_postproc    = in_postproc,
 555         .af_status_tunnel = in_status_tunnel,
 556         .af_settunnel   = in_set_tunnel,
 557         .af_setvhid     = in_set_vhid,
 558 #ifdef WITHOUT_NETLINK
 559         .af_difaddr     = SIOCDIFADDR,
 560         .af_aifaddr     = SIOCAIFADDR,
 561         .af_ridreq      = &in_ridreq,
 562         .af_addreq      = &in_addreq,
 563         .af_exec        = af_exec_ioctl,
 564 #else
 565         .af_difaddr     = NL_RTM_DELADDR,
 566         .af_aifaddr     = NL_RTM_NEWADDR,
 567         .af_ridreq      = &in_del,
 568         .af_addreq      = &in_add,
 569         .af_exec        = in_exec_nl,
 570 #endif
 571 };
 572
 573 static __constructor void
 574 inet_ctor(void)
 575 {
 576
 577 #ifndef RESCUE
 578         if (!feature_present("inet"))
 579                 return;
 580 #endif
 581         af_register(&af_inet);
 582 }