1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
5 * 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 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29#include <sys/param.h>
30#include <sys/socket.h>
31#include <netinet/in.h>
32#include <net/if.h>
33#include <net/if_dl.h>
34#include <net/route.h>
35#include <netinet/in_systm.h>
36#include <netinet/in_var.h>
37#include <netinet/ip.h>
38#ifndef NOINET6
39#include <netinet6/nd6.h>
40#endif
41#include <sys/un.h>
42
43#include <errno.h>
44#include <string.h>
45#include <stdarg.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <sys/ioctl.h>
49#include <sys/sysctl.h>
50#include <termios.h>
51#include <unistd.h>
52
53#include "layer.h"
54#include "defs.h"
55#include "command.h"
56#include "mbuf.h"
57#include "log.h"
58#include "id.h"
59#include "timer.h"
60#include "fsm.h"
61#include "iplist.h"
62#include "lqr.h"
63#include "hdlc.h"
64#include "throughput.h"
65#include "slcompress.h"
66#include "descriptor.h"
67#include "ncpaddr.h"
68#include "ipcp.h"
69#include "filter.h"
70#include "lcp.h"
71#include "ccp.h"
72#include "link.h"
73#include "mp.h"
74#ifndef NORADIUS
75#include "radius.h"
76#endif
77#include "ipv6cp.h"
78#include "ncp.h"
79#include "bundle.h"
80#include "prompt.h"
81#include "iface.h"
82
83#define IN6MASK128	{{{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, \
84			    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}}
85static const struct in6_addr in6mask128 = IN6MASK128;
86
87
88struct iface *
89iface_Create(const char *name)
90{
91  int mib[6], maxtries, err;
92  size_t needed, namelen;
93  char *buf, *ptr, *end;
94  struct if_msghdr *ifm;
95  struct ifa_msghdr *ifam;
96  struct sockaddr_dl *dl;
97  struct sockaddr *sa[RTAX_MAX];
98  struct iface *iface;
99  struct iface_addr *addr;
100
101  mib[0] = CTL_NET;
102  mib[1] = PF_ROUTE;
103  mib[2] = 0;
104  mib[3] = 0;
105  mib[4] = NET_RT_IFLIST;
106  mib[5] = 0;
107
108  maxtries = 20;
109  err = 0;
110  do {
111    if (maxtries-- == 0 || (err && err != ENOMEM)) {
112      fprintf(stderr, "iface_Create: sysctl: %s\n", strerror(err));
113      return NULL;
114    }
115
116    if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0) {
117      fprintf(stderr, "iface_Create: sysctl: estimate: %s\n",
118                strerror(errno));
119      return NULL;
120    }
121
122    if ((buf = (char *)malloc(needed)) == NULL) {
123      fprintf(stderr, "iface_Create: malloc failed: %s\n", strerror(errno));
124      return NULL;
125    }
126
127    if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
128      err = errno;
129      free(buf);
130      buf = NULL;
131    }
132  } while (buf == NULL);
133
134  ptr = buf;
135  end = buf + needed;
136  iface = NULL;
137  namelen = strlen(name);
138
139  while (ptr < end && iface == NULL) {
140    ifm = (struct if_msghdr *)ptr;			/* On if_msghdr */
141    if (ifm->ifm_type != RTM_IFINFO)
142      break;
143    dl = (struct sockaddr_dl *)(ifm + 1);		/* Single _dl at end */
144    if (dl->sdl_nlen == namelen && !strncmp(name, dl->sdl_data, namelen)) {
145      iface = (struct iface *)malloc(sizeof *iface);
146      if (iface == NULL) {
147        fprintf(stderr, "iface_Create: malloc: %s\n", strerror(errno));
148	free(buf);
149        return NULL;
150      }
151      iface->name = strdup(name);
152      iface->descr = NULL;
153      iface->index = ifm->ifm_index;
154      iface->flags = ifm->ifm_flags;
155      iface->mtu = 0;
156      iface->addrs = 0;
157      iface->addr = NULL;
158    }
159    ptr += ifm->ifm_msglen;				/* First ifa_msghdr */
160    for (; ptr < end; ptr += ifam->ifam_msglen) {
161      ifam = (struct ifa_msghdr *)ptr;			/* Next if address */
162
163      if (ifam->ifam_type != RTM_NEWADDR)		/* finished this if */
164        break;
165
166      if (iface != NULL && ifam->ifam_addrs & RTA_IFA) {
167        /* Found a configured interface ! */
168        iface_ParseHdr(ifam, sa);
169
170        if (sa[RTAX_IFA] && (sa[RTAX_IFA]->sa_family == AF_INET
171#ifndef NOINET6
172                             || sa[RTAX_IFA]->sa_family == AF_INET6
173#endif
174                             )) {
175          /* Record the address */
176
177          addr = (struct iface_addr *)
178            realloc(iface->addr, (iface->addrs + 1) * sizeof iface->addr[0]);
179          if (addr == NULL)
180            break;
181          iface->addr = addr;
182
183          addr += iface->addrs;
184          iface->addrs++;
185
186          ncprange_setsa(&addr->ifa, sa[RTAX_IFA], sa[RTAX_NETMASK]);
187          if (sa[RTAX_BRD])
188            ncpaddr_setsa(&addr->peer, sa[RTAX_BRD]);
189          else
190            ncpaddr_init(&addr->peer);
191        }
192      }
193    }
194  }
195
196  free(buf);
197
198  return iface;
199}
200
201static int
202iface_addr_Zap(const char *name, struct iface_addr *addr, int s)
203{
204  struct ifaliasreq ifra;
205#ifndef NOINET6
206  struct in6_aliasreq ifra6;
207#endif
208  struct sockaddr_in *me4, *msk4, *peer4;
209  struct sockaddr_storage ssme, sspeer, ssmsk;
210  int res, saved_errno;
211
212  ncprange_getsa(&addr->ifa, &ssme, &ssmsk);
213  ncpaddr_getsa(&addr->peer, &sspeer);
214  res = 0;
215
216  switch (ncprange_family(&addr->ifa)) {
217  case AF_INET:
218    memset(&ifra, '\0', sizeof ifra);
219    strncpy(ifra.ifra_name, name, sizeof ifra.ifra_name - 1);
220
221    me4 = (struct sockaddr_in *)&ifra.ifra_addr;
222    memcpy(me4, &ssme, sizeof *me4);
223
224    msk4 = (struct sockaddr_in *)&ifra.ifra_mask;
225    memcpy(msk4, &ssmsk, sizeof *msk4);
226
227    peer4 = (struct sockaddr_in *)&ifra.ifra_broadaddr;
228    if (ncpaddr_family(&addr->peer) == AF_UNSPEC) {
229      peer4->sin_family = AF_INET;
230      peer4->sin_len = sizeof(*peer4);
231      peer4->sin_addr.s_addr = INADDR_NONE;
232    } else
233      memcpy(peer4, &sspeer, sizeof *peer4);
234
235    res = ID0ioctl(s, SIOCDIFADDR, &ifra);
236    saved_errno = errno;
237    if (log_IsKept(LogDEBUG)) {
238      char buf[NCP_ASCIIBUFFERSIZE];
239
240      snprintf(buf, sizeof buf, "%s", ncprange_ntoa(&addr->ifa));
241      log_Printf(LogWARN, "%s: DIFADDR %s -> %s returns %d\n",
242                 ifra.ifra_name, buf, ncpaddr_ntoa(&addr->peer), res);
243    }
244    break;
245
246#ifndef NOINET6
247  case AF_INET6:
248    memset(&ifra6, '\0', sizeof ifra6);
249    strncpy(ifra6.ifra_name, name, sizeof ifra6.ifra_name - 1);
250
251    memcpy(&ifra6.ifra_addr, &ssme, sizeof ifra6.ifra_addr);
252    memcpy(&ifra6.ifra_prefixmask, &ssmsk, sizeof ifra6.ifra_prefixmask);
253    ifra6.ifra_prefixmask.sin6_family = AF_UNSPEC;
254    if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
255      ifra6.ifra_dstaddr.sin6_family = AF_UNSPEC;
256    else
257      memcpy(&ifra6.ifra_dstaddr, &sspeer, sizeof ifra6.ifra_dstaddr);
258    ifra6.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
259    ifra6.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
260
261    res = ID0ioctl(s, SIOCDIFADDR_IN6, &ifra6);
262    saved_errno = errno;
263    break;
264#endif
265  }
266
267  if (res == -1) {
268    char dst[NCP_ASCIIBUFFERSIZE];
269    const char *end =
270#ifndef NOINET6
271      ncprange_family(&addr->ifa) == AF_INET6 ? "_IN6" :
272#endif
273      "";
274
275    if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
276      log_Printf(LogWARN, "iface rm: ioctl(SIOCDIFADDR%s, %s): %s\n",
277                 end, ncprange_ntoa(&addr->ifa), strerror(saved_errno));
278    else {
279      snprintf(dst, sizeof dst, "%s", ncpaddr_ntoa(&addr->peer));
280      log_Printf(LogWARN, "iface rm: ioctl(SIOCDIFADDR%s, %s -> %s): %s\n",
281                 end, ncprange_ntoa(&addr->ifa), dst, strerror(saved_errno));
282    }
283  }
284
285  return res != -1;
286}
287
288static int
289iface_addr_Add(const char *name, struct iface_addr *addr, int s)
290{
291  struct ifaliasreq ifra;
292#ifndef NOINET6
293  struct in6_aliasreq ifra6;
294#endif
295  struct sockaddr_in *me4, *msk4, *peer4;
296  struct sockaddr_storage ssme, sspeer, ssmsk;
297  int res, saved_errno;
298
299  ncprange_getsa(&addr->ifa, &ssme, &ssmsk);
300  ncpaddr_getsa(&addr->peer, &sspeer);
301  res = 0;
302
303  switch (ncprange_family(&addr->ifa)) {
304  case AF_INET:
305    memset(&ifra, '\0', sizeof ifra);
306    strncpy(ifra.ifra_name, name, sizeof ifra.ifra_name - 1);
307
308    me4 = (struct sockaddr_in *)&ifra.ifra_addr;
309    memcpy(me4, &ssme, sizeof *me4);
310
311    msk4 = (struct sockaddr_in *)&ifra.ifra_mask;
312    memcpy(msk4, &ssmsk, sizeof *msk4);
313
314    peer4 = (struct sockaddr_in *)&ifra.ifra_broadaddr;
315    if (ncpaddr_family(&addr->peer) == AF_UNSPEC) {
316      peer4->sin_family = AF_INET;
317      peer4->sin_len = sizeof(*peer4);
318      peer4->sin_addr.s_addr = INADDR_NONE;
319    } else
320      memcpy(peer4, &sspeer, sizeof *peer4);
321
322    res = ID0ioctl(s, SIOCAIFADDR, &ifra);
323    saved_errno = errno;
324    if (log_IsKept(LogDEBUG)) {
325      char buf[NCP_ASCIIBUFFERSIZE];
326
327      snprintf(buf, sizeof buf, "%s", ncprange_ntoa(&addr->ifa));
328      log_Printf(LogWARN, "%s: AIFADDR %s -> %s returns %d\n",
329                 ifra.ifra_name, buf, ncpaddr_ntoa(&addr->peer), res);
330    }
331    break;
332
333#ifndef NOINET6
334  case AF_INET6:
335    memset(&ifra6, '\0', sizeof ifra6);
336    strncpy(ifra6.ifra_name, name, sizeof ifra6.ifra_name - 1);
337
338    memcpy(&ifra6.ifra_addr, &ssme, sizeof ifra6.ifra_addr);
339    memcpy(&ifra6.ifra_prefixmask, &ssmsk, sizeof ifra6.ifra_prefixmask);
340    if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
341      ifra6.ifra_dstaddr.sin6_family = AF_UNSPEC;
342    else if (memcmp(&((struct sockaddr_in6 *)&ssmsk)->sin6_addr, &in6mask128,
343		    sizeof in6mask128) == 0)
344      memcpy(&ifra6.ifra_dstaddr, &sspeer, sizeof ifra6.ifra_dstaddr);
345    ifra6.ifra_lifetime.ia6t_vltime = ND6_INFINITE_LIFETIME;
346    ifra6.ifra_lifetime.ia6t_pltime = ND6_INFINITE_LIFETIME;
347
348    res = ID0ioctl(s, SIOCAIFADDR_IN6, &ifra6);
349    saved_errno = errno;
350    break;
351#endif
352  }
353
354  if (res == -1) {
355    char dst[NCP_ASCIIBUFFERSIZE];
356    const char *end =
357#ifndef NOINET6
358      ncprange_family(&addr->ifa) == AF_INET6 ? "_IN6" :
359#endif
360      "";
361
362    if (ncpaddr_family(&addr->peer) == AF_UNSPEC)
363      log_Printf(LogWARN, "iface add: ioctl(SIOCAIFADDR%s, %s): %s\n",
364                 end, ncprange_ntoa(&addr->ifa), strerror(saved_errno));
365    else {
366      snprintf(dst, sizeof dst, "%s", ncpaddr_ntoa(&addr->peer));
367      log_Printf(LogWARN, "iface add: ioctl(SIOCAIFADDR%s, %s -> %s): %s\n",
368                 end, ncprange_ntoa(&addr->ifa), dst, strerror(saved_errno));
369    }
370  }
371
372  return res != -1;
373}
374
375int
376iface_Name(struct iface *iface, const char *name)
377{
378  struct ifreq ifr;
379  int s;
380  char *newname;
381
382  if ((newname = strdup(name)) == NULL) {
383    log_Printf(LogWARN, "iface name: strdup failed: %s\n", strerror(errno));
384    return 0;
385  }
386
387  if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
388    log_Printf(LogERROR, "iface name: socket(): %s\n", strerror(errno));
389    free(newname);
390    return 0;
391  }
392
393  strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
394  ifr.ifr_data = newname;
395  if (ID0ioctl(s, SIOCSIFNAME, (caddr_t)&ifr) < 0) {
396    log_Printf(LogWARN, "iface name: ioctl(SIOCSIFNAME, %s -> %s): %s\n",
397               name, newname, strerror(errno));
398    free(newname);
399    return 0;
400  }
401
402  free(iface->name);
403  iface->name = newname;
404
405  return 1;
406}
407
408int
409iface_Descr(struct cmdargs const *arg)
410{
411  struct ifreq ifr;
412  struct iface *iface;
413  size_t sz, len;
414  int s, n, ifdescr_maxlen;
415  char *descr;
416
417  sz = sizeof(int);
418  if (sysctlbyname("net.ifdescr_maxlen", &ifdescr_maxlen, &sz, NULL, 0) < 0) {
419    log_Printf(LogERROR, "iface descr: sysctl failed: %s\n", strerror(errno));
420    return 1;
421  }
422
423  if (ifdescr_maxlen < 1) {
424    log_Printf(LogERROR, "iface descr: sysctl net.ifdescr_maxlen < 1\n");
425    return 1;
426  }
427
428  sz = sizeof(char) * ifdescr_maxlen;
429  if ((descr = malloc(sz)) == NULL) {
430    log_Printf(LogERROR, "iface descr: malloc failed: %s\n", strerror(errno));
431    return 1;
432  }
433
434  *descr = '\0';
435  n = arg->argn;
436  while (n < arg->argc) {
437    if (n > arg->argn && (len = strlcat(descr, " ", sz)) >= sz)
438      break;
439    if ((len = strlcat(descr, arg->argv[n], sz)) >= sz)
440      break;
441    ++n;
442  }
443  if (len >= sz) {
444    log_Printf(LogERROR, "iface descr: description exceeds maximum (%d)\n",
445               ifdescr_maxlen-1);
446    free(descr);
447    return 1;
448  }
449
450  if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
451    log_Printf(LogERROR, "iface descr: socket(): %s\n", strerror(errno));
452    free(descr);
453    return 1;
454  }
455
456  iface = arg->bundle->iface;
457  strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
458  ifr.ifr_buffer.length = strlen(descr) + 1;
459  ifr.ifr_buffer.buffer = descr;
460  if (ID0ioctl(s, SIOCSIFDESCR, (caddr_t)&ifr) < 0) {
461    log_Printf(LogWARN, "iface descr: ioctl(SIOCSIFDESCR, %s): %s\n",
462               descr, strerror(errno));
463    free(descr);
464    return 1;
465  }
466
467  free(iface->descr);
468  iface->descr = descr;
469
470  return 0;
471}
472
473void
474iface_Clear(struct iface *iface, struct ncp *ncp, int family, int how)
475{
476  int af, inskip, in6skip, s4 = -1, s6 = -1, *s;
477  unsigned n;
478
479  if (iface->addrs) {
480    inskip = in6skip = how == IFACE_CLEAR_ALL ? 0 : 1;
481
482    for (n = 0; n < iface->addrs; n++) {
483      af = ncprange_family(&iface->addr[n].ifa);
484      if (family == 0 || family == af) {
485        if (!iface->addr[n].system && (how & IFACE_SYSTEM))
486          continue;
487        switch (af) {
488        case AF_INET:
489          if (inskip) {
490            inskip = 0;
491            continue;
492          }
493          s = &s4;
494          break;
495
496#ifndef NOINET6
497        case AF_INET6:
498          if (in6skip) {
499            in6skip = 0;
500            continue;
501          }
502          s = &s6;
503          break;
504#endif
505        default:
506          continue;
507        }
508
509        if (*s == -1 && (*s = ID0socket(af, SOCK_DGRAM, 0)) == -1)
510          log_Printf(LogERROR, "iface_Clear: socket(): %s\n", strerror(errno));
511        else if (iface_addr_Zap(iface->name, iface->addr + n, *s)) {
512          ncp_IfaceAddrDeleted(ncp, iface->addr + n);
513          bcopy(iface->addr + n + 1, iface->addr + n,
514                (iface->addrs - n - 1) * sizeof *iface->addr);
515          iface->addrs--;
516          n--;
517        }
518      }
519    }
520
521    /* Don't bother realloc()ing - we have little to gain */
522
523    if (s4)
524      close(s4);
525    if (s6)
526      close(s6);
527  }
528}
529
530int
531iface_Add(struct iface *iface, struct ncp *ncp, const struct ncprange *ifa,
532          const struct ncpaddr *peer, int how)
533{
534  int af, removed, s;
535  unsigned n;
536  struct ncpaddr ncplocal;
537  struct iface_addr *addr, newaddr;
538
539  af = ncprange_family(ifa);
540  if ((s = ID0socket(af, SOCK_DGRAM, 0)) == -1) {
541    log_Printf(LogERROR, "iface_Add: socket(): %s\n", strerror(errno));
542    return 0;
543  }
544  ncprange_getaddr(ifa, &ncplocal);
545
546  for (n = 0; n < iface->addrs; n++) {
547    if (ncprange_contains(&iface->addr[n].ifa, &ncplocal) ||
548        ncpaddr_equal(&iface->addr[n].peer, peer)) {
549      /* Replace this sockaddr */
550      if (!(how & IFACE_FORCE_ADD)) {
551        close(s);
552        return 0;	/* errno = EEXIST; */
553      }
554
555      if (ncprange_equal(&iface->addr[n].ifa, ifa) &&
556          ncpaddr_equal(&iface->addr[n].peer, peer)) {
557        close(s);
558        ncp_IfaceAddrAdded(ncp, iface->addr + n);
559        return 1;	/* Already there */
560      }
561
562      removed = iface_addr_Zap(iface->name, iface->addr + n, s);
563      if (removed)
564        ncp_IfaceAddrDeleted(ncp, iface->addr + n);
565      ncprange_copy(&iface->addr[n].ifa, ifa);
566      ncpaddr_copy(&iface->addr[n].peer, peer);
567      if (!iface_addr_Add(iface->name, iface->addr + n, s)) {
568        if (removed) {
569          bcopy(iface->addr + n + 1, iface->addr + n,
570                (iface->addrs - n - 1) * sizeof *iface->addr);
571          iface->addrs--;
572          n--;
573        }
574        close(s);
575        return 0;
576      }
577      close(s);
578      ncp_IfaceAddrAdded(ncp, iface->addr + n);
579      return 1;
580    }
581  }
582
583  addr = (struct iface_addr *)realloc
584    (iface->addr, (iface->addrs + 1) * sizeof iface->addr[0]);
585  if (addr == NULL) {
586    log_Printf(LogERROR, "iface_inAdd: realloc: %s\n", strerror(errno));
587    close(s);
588    return 0;
589  }
590  iface->addr = addr;
591
592  ncprange_copy(&newaddr.ifa, ifa);
593  ncpaddr_copy(&newaddr.peer, peer);
594  newaddr.system = !!(how & IFACE_SYSTEM);
595  if (!iface_addr_Add(iface->name, &newaddr, s)) {
596    close(s);
597    return 0;
598  }
599
600  if (how & IFACE_ADD_FIRST) {
601    /* Stuff it at the start of our list */
602    n = 0;
603    bcopy(iface->addr, iface->addr + 1, iface->addrs * sizeof *iface->addr);
604  } else
605    n = iface->addrs;
606
607  iface->addrs++;
608  memcpy(iface->addr + n, &newaddr, sizeof(*iface->addr));
609
610  close(s);
611  ncp_IfaceAddrAdded(ncp, iface->addr + n);
612
613  return 1;
614}
615
616int
617iface_Delete(struct iface *iface, struct ncp *ncp, const struct ncpaddr *del)
618{
619  struct ncpaddr found;
620  unsigned n;
621  int res, s;
622
623  if ((s = ID0socket(ncpaddr_family(del), SOCK_DGRAM, 0)) == -1) {
624    log_Printf(LogERROR, "iface_Delete: socket(): %s\n", strerror(errno));
625    return 0;
626  }
627
628  for (n = res = 0; n < iface->addrs; n++) {
629    ncprange_getaddr(&iface->addr[n].ifa, &found);
630    if (ncpaddr_equal(&found, del)) {
631      if (iface_addr_Zap(iface->name, iface->addr + n, s)) {
632        ncp_IfaceAddrDeleted(ncp, iface->addr + n);
633        bcopy(iface->addr + n + 1, iface->addr + n,
634              (iface->addrs - n - 1) * sizeof *iface->addr);
635        iface->addrs--;
636        res = 1;
637      }
638      break;
639    }
640  }
641
642  close(s);
643
644  return res;
645}
646
647#define IFACE_ADDFLAGS 1
648#define IFACE_DELFLAGS 2
649
650static int
651iface_ChangeFlags(const char *ifname, int flags, int how)
652{
653  struct ifreq ifrq;
654  int s, new_flags;
655
656  s = ID0socket(PF_INET, SOCK_DGRAM, 0);
657  if (s < 0) {
658    log_Printf(LogERROR, "iface_ChangeFlags: socket: %s\n", strerror(errno));
659    return 0;
660  }
661
662  memset(&ifrq, '\0', sizeof ifrq);
663  strncpy(ifrq.ifr_name, ifname, sizeof ifrq.ifr_name - 1);
664  ifrq.ifr_name[sizeof ifrq.ifr_name - 1] = '\0';
665  if (ID0ioctl(s, SIOCGIFFLAGS, &ifrq) < 0) {
666    log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCGIFFLAGS): %s\n",
667       strerror(errno));
668    close(s);
669    return 0;
670  }
671#ifdef __FreeBSD__
672  new_flags = (ifrq.ifr_flags & 0xffff) | (ifrq.ifr_flagshigh << 16);
673#else
674  new_flags = ifrq.ifr_flags & 0xffff;
675#endif
676
677  if (how == IFACE_ADDFLAGS)
678    new_flags |= flags;
679  else
680    new_flags &= ~flags;
681  ifrq.ifr_flags = new_flags & 0xffff;
682#ifdef __FreeBSD__
683  ifrq.ifr_flagshigh = new_flags >> 16;
684#endif
685
686  if (ID0ioctl(s, SIOCSIFFLAGS, &ifrq) < 0) {
687    log_Printf(LogERROR, "iface_ChangeFlags: ioctl(SIOCSIFFLAGS): %s\n",
688       strerror(errno));
689    close(s);
690    return 0;
691  }
692  close(s);
693
694  return 1;	/* Success */
695}
696
697int
698iface_SetFlags(const char *ifname, int flags)
699{
700  return iface_ChangeFlags(ifname, flags, IFACE_ADDFLAGS);
701}
702
703int
704iface_ClearFlags(const char *ifname, int flags)
705{
706  return iface_ChangeFlags(ifname, flags, IFACE_DELFLAGS);
707}
708
709void
710iface_Free(struct iface *iface)
711{
712    free(iface->name);
713    free(iface->descr);
714    free(iface->addr);
715    free(iface);
716}
717
718void
719iface_Destroy(struct iface *iface)
720{
721  struct ifreq ifr;
722  int s;
723
724  if (iface != NULL) {
725    if ((s = ID0socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
726      log_Printf(LogERROR, "iface_Destroy: socket(): %s\n", strerror(errno));
727    } else {
728      strlcpy(ifr.ifr_name, iface->name, sizeof(ifr.ifr_name));
729      if (ID0ioctl(s, SIOCIFDESTROY, (caddr_t)&ifr) < 0)
730        log_Printf(LogWARN, "iface_Destroy: ioctl(SIOCIFDESTROY, %s): %s\n",
731               iface->name, strerror(errno));
732    }
733    iface_Free(iface);
734  }
735}
736
737#define if_entry(x) { IFF_##x, #x }
738
739struct {
740  int flag;
741  const char *value;
742} if_flags[] = {
743  if_entry(UP),
744  if_entry(BROADCAST),
745  if_entry(DEBUG),
746  if_entry(LOOPBACK),
747  if_entry(POINTOPOINT),
748  if_entry(RUNNING),
749  if_entry(NOARP),
750  if_entry(PROMISC),
751  if_entry(ALLMULTI),
752  if_entry(OACTIVE),
753  if_entry(SIMPLEX),
754  if_entry(LINK0),
755  if_entry(LINK1),
756  if_entry(LINK2),
757  if_entry(MULTICAST),
758  { 0, "???" }
759};
760
761int
762iface_Show(struct cmdargs const *arg)
763{
764  struct ncpaddr ncpaddr;
765  struct iface *iface = arg->bundle->iface, *current;
766  unsigned f;
767  int flags;
768#ifndef NOINET6
769  int scopeid, width;
770#endif
771  struct in_addr mask;
772
773  current = iface_Create(iface->name);
774  flags = iface->flags = current->flags;
775  iface_Free(current);
776
777  prompt_Printf(arg->prompt, "%s (idx %d) <", iface->name, iface->index);
778  for (f = 0; f < sizeof if_flags / sizeof if_flags[0]; f++)
779    if ((if_flags[f].flag & flags)) {
780      prompt_Printf(arg->prompt, "%s%s", flags == iface->flags ? "" : ",",
781                    if_flags[f].value);
782      flags &= ~if_flags[f].flag;
783    }
784
785#if 0
786  if (flags)
787    prompt_Printf(arg->prompt, "%s0x%x", flags == iface->flags ? "" : ",",
788                  flags);
789#endif
790
791  prompt_Printf(arg->prompt, "> mtu %lu has %d address%s:\n", iface->mtu,
792                iface->addrs, iface->addrs == 1 ? "" : "es");
793
794  for (f = 0; f < iface->addrs; f++) {
795    ncprange_getaddr(&iface->addr[f].ifa, &ncpaddr);
796    switch (ncprange_family(&iface->addr[f].ifa)) {
797    case AF_INET:
798      prompt_Printf(arg->prompt, "  inet %s --> ", ncpaddr_ntoa(&ncpaddr));
799      if (ncpaddr_family(&iface->addr[f].peer) == AF_UNSPEC)
800        prompt_Printf(arg->prompt, "255.255.255.255");
801      else
802        prompt_Printf(arg->prompt, "%s", ncpaddr_ntoa(&iface->addr[f].peer));
803      ncprange_getip4mask(&iface->addr[f].ifa, &mask);
804      prompt_Printf(arg->prompt, " netmask 0x%08lx", (long)ntohl(mask.s_addr));
805      break;
806
807#ifndef NOINET6
808    case AF_INET6:
809      prompt_Printf(arg->prompt, "  inet6 %s", ncpaddr_ntoa(&ncpaddr));
810      if (ncpaddr_family(&iface->addr[f].peer) != AF_UNSPEC)
811        prompt_Printf(arg->prompt, " --> %s",
812                      ncpaddr_ntoa(&iface->addr[f].peer));
813      ncprange_getwidth(&iface->addr[f].ifa, &width);
814      if (ncpaddr_family(&iface->addr[f].peer) == AF_UNSPEC)
815        prompt_Printf(arg->prompt, " prefixlen %d", width);
816      if ((scopeid = ncprange_scopeid(&iface->addr[f].ifa)) != -1)
817        prompt_Printf(arg->prompt, " scopeid 0x%x", (unsigned)scopeid);
818      break;
819#endif
820    }
821    prompt_Printf(arg->prompt, "\n");
822  }
823
824  return 0;
825}
826
827void
828iface_ParseHdr(struct ifa_msghdr *ifam, struct sockaddr *sa[RTAX_MAX])
829{
830  char *wp;
831  int rtax;
832
833  wp = (char *)(ifam + 1);
834
835  for (rtax = 0; rtax < RTAX_MAX; rtax++)
836    if (ifam->ifam_addrs & (1 << rtax)) {
837      sa[rtax] = (struct sockaddr *)wp;
838      wp += ROUNDUP(sa[rtax]->sa_len);
839    } else
840      sa[rtax] = NULL;
841}
842