Annotation of embedaddon/quagga/zebra/kernel_socket.c, revision 1.1
1.1 ! misho 1: /* Kernel communication using routing socket.
! 2: * Copyright (C) 1999 Kunihiro Ishiguro
! 3: *
! 4: * This file is part of GNU Zebra.
! 5: *
! 6: * GNU Zebra is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2, or (at your option) any
! 9: * later version.
! 10: *
! 11: * GNU Zebra is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 14: * General Public License for more details.
! 15: *
! 16: * You should have received a copy of the GNU General Public License
! 17: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 18: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 19: * 02111-1307, USA.
! 20: */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #include "if.h"
! 25: #include "prefix.h"
! 26: #include "sockunion.h"
! 27: #include "connected.h"
! 28: #include "memory.h"
! 29: #include "ioctl.h"
! 30: #include "log.h"
! 31: #include "str.h"
! 32: #include "table.h"
! 33: #include "rib.h"
! 34: #include "privs.h"
! 35:
! 36: #include "zebra/interface.h"
! 37: #include "zebra/zserv.h"
! 38: #include "zebra/debug.h"
! 39: #include "zebra/kernel_socket.h"
! 40:
! 41: extern struct zebra_privs_t zserv_privs;
! 42: extern struct zebra_t zebrad;
! 43:
! 44: /*
! 45: * Given a sockaddr length, round it up to include pad bytes following
! 46: * it. Assumes the kernel pads to sizeof(long).
! 47: *
! 48: * XXX: why is ROUNDUP(0) sizeof(long)? 0 is an illegal sockaddr
! 49: * length anyway (< sizeof (struct sockaddr)), so this shouldn't
! 50: * matter.
! 51: */
! 52: #define ROUNDUP(a) \
! 53: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
! 54:
! 55: /*
! 56: * Given a pointer (sockaddr or void *), return the number of bytes
! 57: * taken up by the sockaddr and any padding needed for alignment.
! 58: */
! 59: #if defined(HAVE_STRUCT_SOCKADDR_SA_LEN)
! 60: #define SAROUNDUP(X) ROUNDUP(((struct sockaddr *)(X))->sa_len)
! 61: #elif defined(HAVE_IPV6)
! 62: /*
! 63: * One would hope all fixed-size structure definitions are aligned,
! 64: * but round them up nonetheless.
! 65: */
! 66: #define SAROUNDUP(X) \
! 67: (((struct sockaddr *)(X))->sa_family == AF_INET ? \
! 68: ROUNDUP(sizeof(struct sockaddr_in)):\
! 69: (((struct sockaddr *)(X))->sa_family == AF_INET6 ? \
! 70: ROUNDUP(sizeof(struct sockaddr_in6)) : \
! 71: (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
! 72: ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr))))
! 73: #else /* HAVE_IPV6 */
! 74: #define SAROUNDUP(X) \
! 75: (((struct sockaddr *)(X))->sa_family == AF_INET ? \
! 76: ROUNDUP(sizeof(struct sockaddr_in)):\
! 77: (((struct sockaddr *)(X))->sa_family == AF_LINK ? \
! 78: ROUNDUP(sizeof(struct sockaddr_dl)) : sizeof(struct sockaddr)))
! 79: #endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
! 80:
! 81: /* We use an additional pointer in following, pdest, rather than (DEST)
! 82: * directly, because gcc will warn if the macro is expanded and DEST is NULL,
! 83: * complaining that memcpy is being passed a NULL value, despite the fact
! 84: * the if (NULL) makes it impossible.
! 85: */
! 86: #define RTA_ADDR_GET(DEST, RTA, RTMADDRS, PNT) \
! 87: if ((RTMADDRS) & (RTA)) \
! 88: { \
! 89: void *pdest = (DEST); \
! 90: int len = SAROUNDUP ((PNT)); \
! 91: if ( ((DEST) != NULL) && \
! 92: af_check (((struct sockaddr *)(PNT))->sa_family)) \
! 93: memcpy (pdest, (PNT), len); \
! 94: (PNT) += len; \
! 95: }
! 96: #define RTA_ATTR_GET(DEST, RTA, RTMADDRS, PNT) \
! 97: if ((RTMADDRS) & (RTA)) \
! 98: { \
! 99: void *pdest = (DEST); \
! 100: int len = SAROUNDUP ((PNT)); \
! 101: if ((DEST) != NULL) \
! 102: memcpy (pdest, (PNT), len); \
! 103: (PNT) += len; \
! 104: }
! 105:
! 106: #define RTA_NAME_GET(DEST, RTA, RTMADDRS, PNT, LEN) \
! 107: if ((RTMADDRS) & (RTA)) \
! 108: { \
! 109: u_char *pdest = (u_char *) (DEST); \
! 110: int len = SAROUNDUP ((PNT)); \
! 111: struct sockaddr_dl *sdl = (struct sockaddr_dl *)(PNT); \
! 112: if (IS_ZEBRA_DEBUG_KERNEL) \
! 113: zlog_debug ("%s: RTA_SDL_GET nlen %d, alen %d", \
! 114: __func__, sdl->sdl_nlen, sdl->sdl_alen); \
! 115: if ( ((DEST) != NULL) && (sdl->sdl_family == AF_LINK) \
! 116: && (sdl->sdl_nlen < IFNAMSIZ) && (sdl->sdl_nlen <= len) ) \
! 117: { \
! 118: memcpy (pdest, sdl->sdl_data, sdl->sdl_nlen); \
! 119: pdest[sdl->sdl_nlen] = '\0'; \
! 120: (LEN) = sdl->sdl_nlen; \
! 121: } \
! 122: (PNT) += len; \
! 123: } \
! 124: else \
! 125: { \
! 126: (LEN) = 0; \
! 127: }
! 128: /* Routing socket message types. */
! 129: const struct message rtm_type_str[] =
! 130: {
! 131: {RTM_ADD, "RTM_ADD"},
! 132: {RTM_DELETE, "RTM_DELETE"},
! 133: {RTM_CHANGE, "RTM_CHANGE"},
! 134: {RTM_GET, "RTM_GET"},
! 135: {RTM_LOSING, "RTM_LOSING"},
! 136: {RTM_REDIRECT, "RTM_REDIRECT"},
! 137: {RTM_MISS, "RTM_MISS"},
! 138: {RTM_LOCK, "RTM_LOCK"},
! 139: #ifdef OLDADD
! 140: {RTM_OLDADD, "RTM_OLDADD"},
! 141: #endif /* RTM_OLDADD */
! 142: #ifdef RTM_OLDDEL
! 143: {RTM_OLDDEL, "RTM_OLDDEL"},
! 144: #endif /* RTM_OLDDEL */
! 145: {RTM_RESOLVE, "RTM_RESOLVE"},
! 146: {RTM_NEWADDR, "RTM_NEWADDR"},
! 147: {RTM_DELADDR, "RTM_DELADDR"},
! 148: {RTM_IFINFO, "RTM_IFINFO"},
! 149: #ifdef RTM_OIFINFO
! 150: {RTM_OIFINFO, "RTM_OIFINFO"},
! 151: #endif /* RTM_OIFINFO */
! 152: #ifdef RTM_NEWMADDR
! 153: {RTM_NEWMADDR, "RTM_NEWMADDR"},
! 154: #endif /* RTM_NEWMADDR */
! 155: #ifdef RTM_DELMADDR
! 156: {RTM_DELMADDR, "RTM_DELMADDR"},
! 157: #endif /* RTM_DELMADDR */
! 158: #ifdef RTM_IFANNOUNCE
! 159: {RTM_IFANNOUNCE, "RTM_IFANNOUNCE"},
! 160: #endif /* RTM_IFANNOUNCE */
! 161: {0, NULL}
! 162: };
! 163:
! 164: static const struct message rtm_flag_str[] =
! 165: {
! 166: {RTF_UP, "UP"},
! 167: {RTF_GATEWAY, "GATEWAY"},
! 168: {RTF_HOST, "HOST"},
! 169: {RTF_REJECT, "REJECT"},
! 170: {RTF_DYNAMIC, "DYNAMIC"},
! 171: {RTF_MODIFIED, "MODIFIED"},
! 172: {RTF_DONE, "DONE"},
! 173: #ifdef RTF_MASK
! 174: {RTF_MASK, "MASK"},
! 175: #endif /* RTF_MASK */
! 176: #ifdef RTF_CLONING
! 177: {RTF_CLONING, "CLONING"},
! 178: #endif /* RTF_CLONING */
! 179: {RTF_XRESOLVE, "XRESOLVE"},
! 180: {RTF_LLINFO, "LLINFO"},
! 181: {RTF_STATIC, "STATIC"},
! 182: {RTF_BLACKHOLE, "BLACKHOLE"},
! 183: #ifdef RTF_PRIVATE
! 184: {RTF_PRIVATE, "PRIVATE"},
! 185: #endif /* RTF_PRIVATE */
! 186: {RTF_PROTO1, "PROTO1"},
! 187: {RTF_PROTO2, "PROTO2"},
! 188: #ifdef RTF_PRCLONING
! 189: {RTF_PRCLONING, "PRCLONING"},
! 190: #endif /* RTF_PRCLONING */
! 191: #ifdef RTF_WASCLONED
! 192: {RTF_WASCLONED, "WASCLONED"},
! 193: #endif /* RTF_WASCLONED */
! 194: #ifdef RTF_PROTO3
! 195: {RTF_PROTO3, "PROTO3"},
! 196: #endif /* RTF_PROTO3 */
! 197: #ifdef RTF_PINNED
! 198: {RTF_PINNED, "PINNED"},
! 199: #endif /* RTF_PINNED */
! 200: #ifdef RTF_LOCAL
! 201: {RTF_LOCAL, "LOCAL"},
! 202: #endif /* RTF_LOCAL */
! 203: #ifdef RTF_BROADCAST
! 204: {RTF_BROADCAST, "BROADCAST"},
! 205: #endif /* RTF_BROADCAST */
! 206: #ifdef RTF_MULTICAST
! 207: {RTF_MULTICAST, "MULTICAST"},
! 208: #endif /* RTF_MULTICAST */
! 209: #ifdef RTF_MULTIRT
! 210: {RTF_MULTIRT, "MULTIRT"},
! 211: #endif /* RTF_MULTIRT */
! 212: #ifdef RTF_SETSRC
! 213: {RTF_SETSRC, "SETSRC"},
! 214: #endif /* RTF_SETSRC */
! 215: {0, NULL}
! 216: };
! 217:
! 218: /* Kernel routing update socket. */
! 219: int routing_sock = -1;
! 220:
! 221: /* Yes I'm checking ugly routing socket behavior. */
! 222: /* #define DEBUG */
! 223:
! 224: /* Supported address family check. */
! 225: static int inline
! 226: af_check (int family)
! 227: {
! 228: if (family == AF_INET)
! 229: return 1;
! 230: #ifdef HAVE_IPV6
! 231: if (family == AF_INET6)
! 232: return 1;
! 233: #endif /* HAVE_IPV6 */
! 234: return 0;
! 235: }
! 236:
! 237: /* Dump routing table flag for debug purpose. */
! 238: static void
! 239: rtm_flag_dump (int flag)
! 240: {
! 241: const struct message *mes;
! 242: static char buf[BUFSIZ];
! 243:
! 244: buf[0] = '\0';
! 245: for (mes = rtm_flag_str; mes->key != 0; mes++)
! 246: {
! 247: if (mes->key & flag)
! 248: {
! 249: strlcat (buf, mes->str, BUFSIZ);
! 250: strlcat (buf, " ", BUFSIZ);
! 251: }
! 252: }
! 253: zlog_debug ("Kernel: %s", buf);
! 254: }
! 255:
! 256: #ifdef RTM_IFANNOUNCE
! 257: /* Interface adding function */
! 258: static int
! 259: ifan_read (struct if_announcemsghdr *ifan)
! 260: {
! 261: struct interface *ifp;
! 262:
! 263: ifp = if_lookup_by_index (ifan->ifan_index);
! 264:
! 265: if (ifp)
! 266: assert ( (ifp->ifindex == ifan->ifan_index)
! 267: || (ifp->ifindex == IFINDEX_INTERNAL) );
! 268:
! 269: if ( (ifp == NULL)
! 270: || ((ifp->ifindex == IFINDEX_INTERNAL)
! 271: && (ifan->ifan_what == IFAN_ARRIVAL)) )
! 272: {
! 273: if (IS_ZEBRA_DEBUG_KERNEL)
! 274: zlog_debug ("%s: creating interface for ifindex %d, name %s",
! 275: __func__, ifan->ifan_index, ifan->ifan_name);
! 276:
! 277: /* Create Interface */
! 278: ifp = if_get_by_name_len(ifan->ifan_name,
! 279: strnlen(ifan->ifan_name,
! 280: sizeof(ifan->ifan_name)));
! 281: ifp->ifindex = ifan->ifan_index;
! 282:
! 283: if_add_update (ifp);
! 284: }
! 285: else if (ifp != NULL && ifan->ifan_what == IFAN_DEPARTURE)
! 286: if_delete_update (ifp);
! 287:
! 288: if_get_flags (ifp);
! 289: if_get_mtu (ifp);
! 290: if_get_metric (ifp);
! 291:
! 292: if (IS_ZEBRA_DEBUG_KERNEL)
! 293: zlog_debug ("%s: interface %s index %d",
! 294: __func__, ifan->ifan_name, ifan->ifan_index);
! 295:
! 296: return 0;
! 297: }
! 298: #endif /* RTM_IFANNOUNCE */
! 299:
! 300: #ifdef HAVE_BSD_LINK_DETECT
! 301: /* BSD link detect translation */
! 302: static void
! 303: bsd_linkdetect_translate (struct if_msghdr *ifm)
! 304: {
! 305: if ((ifm->ifm_data.ifi_link_state >= LINK_STATE_UP) ||
! 306: (ifm->ifm_data.ifi_link_state == LINK_STATE_UNKNOWN))
! 307: SET_FLAG(ifm->ifm_flags, IFF_RUNNING);
! 308: else
! 309: UNSET_FLAG(ifm->ifm_flags, IFF_RUNNING);
! 310: }
! 311: #endif /* HAVE_BSD_LINK_DETECT */
! 312:
! 313: /*
! 314: * Handle struct if_msghdr obtained from reading routing socket or
! 315: * sysctl (from interface_list). There may or may not be sockaddrs
! 316: * present after the header.
! 317: */
! 318: int
! 319: ifm_read (struct if_msghdr *ifm)
! 320: {
! 321: struct interface *ifp = NULL;
! 322: char ifname[IFNAMSIZ];
! 323: short ifnlen = 0;
! 324: caddr_t *cp;
! 325:
! 326: /* terminate ifname at head (for strnlen) and tail (for safety) */
! 327: ifname[IFNAMSIZ - 1] = '\0';
! 328:
! 329: /* paranoia: sanity check structure */
! 330: if (ifm->ifm_msglen < sizeof(struct if_msghdr))
! 331: {
! 332: zlog_err ("ifm_read: ifm->ifm_msglen %d too short\n",
! 333: ifm->ifm_msglen);
! 334: return -1;
! 335: }
! 336:
! 337: /*
! 338: * Check for a sockaddr_dl following the message. First, point to
! 339: * where a socakddr might be if one follows the message.
! 340: */
! 341: cp = (void *)(ifm + 1);
! 342:
! 343: #ifdef SUNOS_5
! 344: /*
! 345: * XXX This behavior should be narrowed to only the kernel versions
! 346: * for which the structures returned do not match the headers.
! 347: *
! 348: * if_msghdr_t on 64 bit kernels in Solaris 9 and earlier versions
! 349: * is 12 bytes larger than the 32 bit version.
! 350: */
! 351: if (((struct sockaddr *) cp)->sa_family == AF_UNSPEC)
! 352: cp = cp + 12;
! 353: #endif
! 354:
! 355: RTA_ADDR_GET (NULL, RTA_DST, ifm->ifm_addrs, cp);
! 356: RTA_ADDR_GET (NULL, RTA_GATEWAY, ifm->ifm_addrs, cp);
! 357: RTA_ATTR_GET (NULL, RTA_NETMASK, ifm->ifm_addrs, cp);
! 358: RTA_ADDR_GET (NULL, RTA_GENMASK, ifm->ifm_addrs, cp);
! 359: RTA_NAME_GET (ifname, RTA_IFP, ifm->ifm_addrs, cp, ifnlen);
! 360: RTA_ADDR_GET (NULL, RTA_IFA, ifm->ifm_addrs, cp);
! 361: RTA_ADDR_GET (NULL, RTA_AUTHOR, ifm->ifm_addrs, cp);
! 362: RTA_ADDR_GET (NULL, RTA_BRD, ifm->ifm_addrs, cp);
! 363:
! 364: if (IS_ZEBRA_DEBUG_KERNEL)
! 365: zlog_debug ("%s: sdl ifname %s", __func__, (ifnlen ? ifname : "(nil)"));
! 366:
! 367: /*
! 368: * Look up on ifindex first, because ifindices are the primary handle for
! 369: * interfaces across the user/kernel boundary, for most systems. (Some
! 370: * messages, such as up/down status changes on NetBSD, do not include a
! 371: * sockaddr_dl).
! 372: */
! 373: if ( (ifp = if_lookup_by_index (ifm->ifm_index)) != NULL )
! 374: {
! 375: /* we have an ifp, verify that the name matches as some systems,
! 376: * eg Solaris, have a 1:many association of ifindex:ifname
! 377: * if they dont match, we dont have the correct ifp and should
! 378: * set it back to NULL to let next check do lookup by name
! 379: */
! 380: if (ifnlen && (strncmp (ifp->name, ifname, IFNAMSIZ) != 0) )
! 381: {
! 382: if (IS_ZEBRA_DEBUG_KERNEL)
! 383: zlog_debug ("%s: ifp name %s doesnt match sdl name %s",
! 384: __func__, ifp->name, ifname);
! 385: ifp = NULL;
! 386: }
! 387: }
! 388:
! 389: /*
! 390: * If we dont have an ifp, try looking up by name. Particularly as some
! 391: * systems (Solaris) have a 1:many mapping of ifindex:ifname - the ifname
! 392: * is therefore our unique handle to that interface.
! 393: *
! 394: * Interfaces specified in the configuration file for which the ifindex
! 395: * has not been determined will have ifindex == IFINDEX_INTERNAL, and such
! 396: * interfaces are found by this search, and then their ifindex values can
! 397: * be filled in.
! 398: */
! 399: if ( (ifp == NULL) && ifnlen)
! 400: ifp = if_lookup_by_name (ifname);
! 401:
! 402: /*
! 403: * If ifp still does not exist or has an invalid index (IFINDEX_INTERNAL),
! 404: * create or fill in an interface.
! 405: */
! 406: if ((ifp == NULL) || (ifp->ifindex == IFINDEX_INTERNAL))
! 407: {
! 408: /*
! 409: * To create or fill in an interface, a sockaddr_dl (via
! 410: * RTA_IFP) is required.
! 411: */
! 412: if (!ifnlen)
! 413: {
! 414: zlog_warn ("Interface index %d (new) missing ifname\n",
! 415: ifm->ifm_index);
! 416: return -1;
! 417: }
! 418:
! 419: #ifndef RTM_IFANNOUNCE
! 420: /* Down->Down interface should be ignored here.
! 421: * See further comment below.
! 422: */
! 423: if (!CHECK_FLAG (ifm->ifm_flags, IFF_UP))
! 424: return 0;
! 425: #endif /* !RTM_IFANNOUNCE */
! 426:
! 427: if (ifp == NULL)
! 428: {
! 429: /* Interface that zebra was not previously aware of, so create. */
! 430: ifp = if_create (ifname, ifnlen);
! 431: if (IS_ZEBRA_DEBUG_KERNEL)
! 432: zlog_debug ("%s: creating ifp for ifindex %d",
! 433: __func__, ifm->ifm_index);
! 434: }
! 435:
! 436: if (IS_ZEBRA_DEBUG_KERNEL)
! 437: zlog_debug ("%s: updated/created ifp, ifname %s, ifindex %d",
! 438: __func__, ifp->name, ifp->ifindex);
! 439: /*
! 440: * Fill in newly created interface structure, or larval
! 441: * structure with ifindex IFINDEX_INTERNAL.
! 442: */
! 443: ifp->ifindex = ifm->ifm_index;
! 444:
! 445: #ifdef HAVE_BSD_LINK_DETECT /* translate BSD kernel msg for link-state */
! 446: bsd_linkdetect_translate(ifm);
! 447: #endif /* HAVE_BSD_LINK_DETECT */
! 448:
! 449: if_flags_update (ifp, ifm->ifm_flags);
! 450: #if defined(__bsdi__)
! 451: if_kvm_get_mtu (ifp);
! 452: #else
! 453: if_get_mtu (ifp);
! 454: #endif /* __bsdi__ */
! 455: if_get_metric (ifp);
! 456:
! 457: if_add_update (ifp);
! 458: }
! 459: else
! 460: /*
! 461: * Interface structure exists. Adjust stored flags from
! 462: * notification. If interface has up->down or down->up
! 463: * transition, call state change routines (to adjust routes,
! 464: * notify routing daemons, etc.). (Other flag changes are stored
! 465: * but apparently do not trigger action.)
! 466: */
! 467: {
! 468: if (ifp->ifindex != ifm->ifm_index)
! 469: {
! 470: zlog_warn ("%s: index mismatch, ifname %s, ifp index %d, "
! 471: "ifm index %d",
! 472: __func__, ifp->name, ifp->ifindex, ifm->ifm_index);
! 473: return -1;
! 474: }
! 475:
! 476: #ifdef HAVE_BSD_LINK_DETECT /* translate BSD kernel msg for link-state */
! 477: bsd_linkdetect_translate(ifm);
! 478: #endif /* HAVE_BSD_LINK_DETECT */
! 479:
! 480: /* update flags and handle operative->inoperative transition, if any */
! 481: if_flags_update (ifp, ifm->ifm_flags);
! 482:
! 483: #ifndef RTM_IFANNOUNCE
! 484: if (!if_is_up (ifp))
! 485: {
! 486: /* No RTM_IFANNOUNCE on this platform, so we can never
! 487: * distinguish between ~IFF_UP and delete. We must presume
! 488: * it has been deleted.
! 489: * Eg, Solaris will not notify us of unplumb.
! 490: *
! 491: * XXX: Fixme - this should be runtime detected
! 492: * So that a binary compiled on a system with IFANNOUNCE
! 493: * will still behave correctly if run on a platform without
! 494: */
! 495: if_delete_update (ifp);
! 496: }
! 497: #endif /* RTM_IFANNOUNCE */
! 498: if (if_is_up (ifp))
! 499: {
! 500: #if defined(__bsdi__)
! 501: if_kvm_get_mtu (ifp);
! 502: #else
! 503: if_get_mtu (ifp);
! 504: #endif /* __bsdi__ */
! 505: if_get_metric (ifp);
! 506: }
! 507: }
! 508:
! 509: #ifdef HAVE_NET_RT_IFLIST
! 510: ifp->stats = ifm->ifm_data;
! 511: #endif /* HAVE_NET_RT_IFLIST */
! 512:
! 513: if (IS_ZEBRA_DEBUG_KERNEL)
! 514: zlog_debug ("%s: interface %s index %d",
! 515: __func__, ifp->name, ifp->ifindex);
! 516:
! 517: return 0;
! 518: }
! 519:
! 520: /* Address read from struct ifa_msghdr. */
! 521: static void
! 522: ifam_read_mesg (struct ifa_msghdr *ifm,
! 523: union sockunion *addr,
! 524: union sockunion *mask,
! 525: union sockunion *brd,
! 526: char *ifname,
! 527: short *ifnlen)
! 528: {
! 529: caddr_t pnt, end;
! 530: union sockunion dst;
! 531: union sockunion gateway;
! 532:
! 533: pnt = (caddr_t)(ifm + 1);
! 534: end = ((caddr_t)ifm) + ifm->ifam_msglen;
! 535:
! 536: /* Be sure structure is cleared */
! 537: memset (mask, 0, sizeof (union sockunion));
! 538: memset (addr, 0, sizeof (union sockunion));
! 539: memset (brd, 0, sizeof (union sockunion));
! 540: memset (&dst, 0, sizeof (union sockunion));
! 541: memset (&gateway, 0, sizeof (union sockunion));
! 542:
! 543: /* We fetch each socket variable into sockunion. */
! 544: RTA_ADDR_GET (&dst, RTA_DST, ifm->ifam_addrs, pnt);
! 545: RTA_ADDR_GET (&gateway, RTA_GATEWAY, ifm->ifam_addrs, pnt);
! 546: RTA_ATTR_GET (mask, RTA_NETMASK, ifm->ifam_addrs, pnt);
! 547: RTA_ADDR_GET (NULL, RTA_GENMASK, ifm->ifam_addrs, pnt);
! 548: RTA_NAME_GET (ifname, RTA_IFP, ifm->ifam_addrs, pnt, *ifnlen);
! 549: RTA_ADDR_GET (addr, RTA_IFA, ifm->ifam_addrs, pnt);
! 550: RTA_ADDR_GET (NULL, RTA_AUTHOR, ifm->ifam_addrs, pnt);
! 551: RTA_ADDR_GET (brd, RTA_BRD, ifm->ifam_addrs, pnt);
! 552:
! 553: if (IS_ZEBRA_DEBUG_KERNEL)
! 554: {
! 555: switch (sockunion_family(addr))
! 556: {
! 557: case AF_INET:
! 558: {
! 559: char buf[4][INET_ADDRSTRLEN];
! 560: zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
! 561: "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
! 562: "gateway %s",
! 563: __func__, ifm->ifam_index,
! 564: (ifnlen ? ifname : "(nil)"), ifm->ifam_addrs,
! 565: ifm->ifam_flags,
! 566: inet_ntop(AF_INET,&addr->sin.sin_addr,
! 567: buf[0],sizeof(buf[0])),
! 568: ip_masklen(mask->sin.sin_addr),
! 569: inet_ntop(AF_INET,&brd->sin.sin_addr,
! 570: buf[1],sizeof(buf[1])),
! 571: inet_ntop(AF_INET,&dst.sin.sin_addr,
! 572: buf[2],sizeof(buf[2])),
! 573: inet_ntop(AF_INET,&gateway.sin.sin_addr,
! 574: buf[3],sizeof(buf[3])));
! 575: }
! 576: break;
! 577: #ifdef HAVE_IPV6
! 578: case AF_INET6:
! 579: {
! 580: char buf[4][INET6_ADDRSTRLEN];
! 581: zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x, "
! 582: "ifam_flags 0x%x, addr %s/%d broad %s dst %s "
! 583: "gateway %s",
! 584: __func__, ifm->ifam_index,
! 585: (ifnlen ? ifname : "(nil)"), ifm->ifam_addrs,
! 586: ifm->ifam_flags,
! 587: inet_ntop(AF_INET6,&addr->sin6.sin6_addr,
! 588: buf[0],sizeof(buf[0])),
! 589: ip6_masklen(mask->sin6.sin6_addr),
! 590: inet_ntop(AF_INET6,&brd->sin6.sin6_addr,
! 591: buf[1],sizeof(buf[1])),
! 592: inet_ntop(AF_INET6,&dst.sin6.sin6_addr,
! 593: buf[2],sizeof(buf[2])),
! 594: inet_ntop(AF_INET6,&gateway.sin6.sin6_addr,
! 595: buf[3],sizeof(buf[3])));
! 596: }
! 597: break;
! 598: #endif /* HAVE_IPV6 */
! 599: default:
! 600: zlog_debug ("%s: ifindex %d, ifname %s, ifam_addrs 0x%x",
! 601: __func__, ifm->ifam_index,
! 602: (ifnlen ? ifname : "(nil)"), ifm->ifam_addrs);
! 603: break;
! 604: }
! 605: }
! 606:
! 607: /* Assert read up end point matches to end point */
! 608: if (pnt != end)
! 609: zlog_warn ("ifam_read() does't read all socket data");
! 610: }
! 611:
! 612: /* Interface's address information get. */
! 613: int
! 614: ifam_read (struct ifa_msghdr *ifam)
! 615: {
! 616: struct interface *ifp = NULL;
! 617: union sockunion addr, mask, brd;
! 618: char ifname[INTERFACE_NAMSIZ];
! 619: short ifnlen = 0;
! 620: char isalias = 0;
! 621: int flags = 0;
! 622:
! 623: ifname[0] = ifname[INTERFACE_NAMSIZ - 1] = '\0';
! 624:
! 625: /* Allocate and read address information. */
! 626: ifam_read_mesg (ifam, &addr, &mask, &brd, ifname, &ifnlen);
! 627:
! 628: if ((ifp = if_lookup_by_index(ifam->ifam_index)) == NULL)
! 629: {
! 630: zlog_warn ("%s: no interface for ifname %s, index %d",
! 631: __func__, ifname, ifam->ifam_index);
! 632: return -1;
! 633: }
! 634:
! 635: if (ifnlen && strncmp (ifp->name, ifname, INTERFACE_NAMSIZ))
! 636: isalias = 1;
! 637:
! 638: /* N.B. The info in ifa_msghdr does not tell us whether the RTA_BRD
! 639: field contains a broadcast address or a peer address, so we are forced to
! 640: rely upon the interface type. */
! 641: if (if_is_pointopoint(ifp))
! 642: SET_FLAG(flags, ZEBRA_IFA_PEER);
! 643:
! 644: #if 0
! 645: /* it might seem cute to grab the interface metric here, however
! 646: * we're processing an address update message, and so some systems
! 647: * (e.g. FBSD) dont bother to fill in ifam_metric. Disabled, but left
! 648: * in deliberately, as comment.
! 649: */
! 650: ifp->metric = ifam->ifam_metric;
! 651: #endif
! 652:
! 653: /* Add connected address. */
! 654: switch (sockunion_family (&addr))
! 655: {
! 656: case AF_INET:
! 657: if (ifam->ifam_type == RTM_NEWADDR)
! 658: connected_add_ipv4 (ifp, flags, &addr.sin.sin_addr,
! 659: ip_masklen (mask.sin.sin_addr),
! 660: &brd.sin.sin_addr,
! 661: (isalias ? ifname : NULL));
! 662: else
! 663: connected_delete_ipv4 (ifp, flags, &addr.sin.sin_addr,
! 664: ip_masklen (mask.sin.sin_addr),
! 665: &brd.sin.sin_addr);
! 666: break;
! 667: #ifdef HAVE_IPV6
! 668: case AF_INET6:
! 669: /* Unset interface index from link-local address when IPv6 stack
! 670: is KAME. */
! 671: if (IN6_IS_ADDR_LINKLOCAL (&addr.sin6.sin6_addr))
! 672: SET_IN6_LINKLOCAL_IFINDEX (addr.sin6.sin6_addr, 0);
! 673:
! 674: if (ifam->ifam_type == RTM_NEWADDR)
! 675: connected_add_ipv6 (ifp, flags, &addr.sin6.sin6_addr,
! 676: ip6_masklen (mask.sin6.sin6_addr),
! 677: &brd.sin6.sin6_addr,
! 678: (isalias ? ifname : NULL));
! 679: else
! 680: connected_delete_ipv6 (ifp,
! 681: &addr.sin6.sin6_addr,
! 682: ip6_masklen (mask.sin6.sin6_addr),
! 683: &brd.sin6.sin6_addr);
! 684: break;
! 685: #endif /* HAVE_IPV6 */
! 686: default:
! 687: /* Unsupported family silently ignore... */
! 688: break;
! 689: }
! 690:
! 691: /* Check interface flag for implicit up of the interface. */
! 692: if_refresh (ifp);
! 693:
! 694: #ifdef SUNOS_5
! 695: /* In addition to lacking IFANNOUNCE, on SUNOS IFF_UP is strange.
! 696: * See comments for SUNOS_5 in interface.c::if_flags_mangle.
! 697: *
! 698: * Here we take care of case where the real IFF_UP was previously
! 699: * unset (as kept in struct zebra_if.primary_state) and the mangled
! 700: * IFF_UP (ie IFF_UP set || listcount(connected) has now transitioned
! 701: * to unset due to the lost non-primary address having DELADDR'd.
! 702: *
! 703: * we must delete the interface, because in between here and next
! 704: * event for this interface-name the administrator could unplumb
! 705: * and replumb the interface.
! 706: */
! 707: if (!if_is_up (ifp))
! 708: if_delete_update (ifp);
! 709: #endif /* SUNOS_5 */
! 710:
! 711: return 0;
! 712: }
! 713:
! 714: /* Interface function for reading kernel routing table information. */
! 715: static int
! 716: rtm_read_mesg (struct rt_msghdr *rtm,
! 717: union sockunion *dest,
! 718: union sockunion *mask,
! 719: union sockunion *gate,
! 720: char *ifname,
! 721: short *ifnlen)
! 722: {
! 723: caddr_t pnt, end;
! 724:
! 725: /* Pnt points out socket data start point. */
! 726: pnt = (caddr_t)(rtm + 1);
! 727: end = ((caddr_t)rtm) + rtm->rtm_msglen;
! 728:
! 729: /* rt_msghdr version check. */
! 730: if (rtm->rtm_version != RTM_VERSION)
! 731: zlog (NULL, LOG_WARNING,
! 732: "Routing message version different %d should be %d."
! 733: "This may cause problem\n", rtm->rtm_version, RTM_VERSION);
! 734:
! 735: /* Be sure structure is cleared */
! 736: memset (dest, 0, sizeof (union sockunion));
! 737: memset (gate, 0, sizeof (union sockunion));
! 738: memset (mask, 0, sizeof (union sockunion));
! 739:
! 740: /* We fetch each socket variable into sockunion. */
! 741: RTA_ADDR_GET (dest, RTA_DST, rtm->rtm_addrs, pnt);
! 742: RTA_ADDR_GET (gate, RTA_GATEWAY, rtm->rtm_addrs, pnt);
! 743: RTA_ATTR_GET (mask, RTA_NETMASK, rtm->rtm_addrs, pnt);
! 744: RTA_ADDR_GET (NULL, RTA_GENMASK, rtm->rtm_addrs, pnt);
! 745: RTA_NAME_GET (ifname, RTA_IFP, rtm->rtm_addrs, pnt, *ifnlen);
! 746: RTA_ADDR_GET (NULL, RTA_IFA, rtm->rtm_addrs, pnt);
! 747: RTA_ADDR_GET (NULL, RTA_AUTHOR, rtm->rtm_addrs, pnt);
! 748: RTA_ADDR_GET (NULL, RTA_BRD, rtm->rtm_addrs, pnt);
! 749:
! 750: /* If there is netmask information set it's family same as
! 751: destination family*/
! 752: if (rtm->rtm_addrs & RTA_NETMASK)
! 753: mask->sa.sa_family = dest->sa.sa_family;
! 754:
! 755: /* Assert read up to the end of pointer. */
! 756: if (pnt != end)
! 757: zlog (NULL, LOG_WARNING, "rtm_read() does't read all socket data.");
! 758:
! 759: return rtm->rtm_flags;
! 760: }
! 761:
! 762: void
! 763: rtm_read (struct rt_msghdr *rtm)
! 764: {
! 765: int flags;
! 766: u_char zebra_flags;
! 767: union sockunion dest, mask, gate;
! 768: char ifname[INTERFACE_NAMSIZ + 1];
! 769: short ifnlen = 0;
! 770:
! 771: zebra_flags = 0;
! 772:
! 773: /* Read destination and netmask and gateway from rtm message
! 774: structure. */
! 775: flags = rtm_read_mesg (rtm, &dest, &mask, &gate, ifname, &ifnlen);
! 776: if (!(flags & RTF_DONE))
! 777: return;
! 778: if (IS_ZEBRA_DEBUG_KERNEL)
! 779: zlog_debug ("%s: got rtm of type %d (%s)", __func__, rtm->rtm_type,
! 780: lookup (rtm_type_str, rtm->rtm_type));
! 781:
! 782: #ifdef RTF_CLONED /*bsdi, netbsd 1.6*/
! 783: if (flags & RTF_CLONED)
! 784: return;
! 785: #endif
! 786: #ifdef RTF_WASCLONED /*freebsd*/
! 787: if (flags & RTF_WASCLONED)
! 788: return;
! 789: #endif
! 790:
! 791: if ((rtm->rtm_type == RTM_ADD) && ! (flags & RTF_UP))
! 792: return;
! 793:
! 794: /* This is connected route. */
! 795: if (! (flags & RTF_GATEWAY))
! 796: return;
! 797:
! 798: if (flags & RTF_PROTO1)
! 799: SET_FLAG (zebra_flags, ZEBRA_FLAG_SELFROUTE);
! 800:
! 801: /* This is persistent route. */
! 802: if (flags & RTF_STATIC)
! 803: SET_FLAG (zebra_flags, ZEBRA_FLAG_STATIC);
! 804:
! 805: /* This is a reject or blackhole route */
! 806: if (flags & RTF_REJECT)
! 807: SET_FLAG (zebra_flags, ZEBRA_FLAG_REJECT);
! 808: if (flags & RTF_BLACKHOLE)
! 809: SET_FLAG (zebra_flags, ZEBRA_FLAG_BLACKHOLE);
! 810:
! 811: if (dest.sa.sa_family == AF_INET)
! 812: {
! 813: struct prefix_ipv4 p;
! 814:
! 815: p.family = AF_INET;
! 816: p.prefix = dest.sin.sin_addr;
! 817: if (flags & RTF_HOST)
! 818: p.prefixlen = IPV4_MAX_PREFIXLEN;
! 819: else
! 820: p.prefixlen = ip_masklen (mask.sin.sin_addr);
! 821:
! 822: /* Catch self originated messages and match them against our current RIB.
! 823: * At the same time, ignore unconfirmed messages, they should be tracked
! 824: * by rtm_write() and kernel_rtm_ipv4().
! 825: */
! 826: if (rtm->rtm_type != RTM_GET && rtm->rtm_pid == pid)
! 827: {
! 828: char buf[INET_ADDRSTRLEN], gate_buf[INET_ADDRSTRLEN];
! 829: int ret;
! 830: if (! IS_ZEBRA_DEBUG_RIB)
! 831: return;
! 832: ret = rib_lookup_ipv4_route (&p, &gate);
! 833: inet_ntop (AF_INET, &p.prefix, buf, INET_ADDRSTRLEN);
! 834: switch (rtm->rtm_type)
! 835: {
! 836: case RTM_ADD:
! 837: case RTM_GET:
! 838: case RTM_CHANGE:
! 839: /* The kernel notifies us about a new route in FIB created by us.
! 840: Do we have a correspondent entry in our RIB? */
! 841: switch (ret)
! 842: {
! 843: case ZEBRA_RIB_NOTFOUND:
! 844: zlog_debug ("%s: %s %s/%d: desync: RR isn't yet in RIB, while already in FIB",
! 845: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen);
! 846: break;
! 847: case ZEBRA_RIB_FOUND_CONNECTED:
! 848: case ZEBRA_RIB_FOUND_NOGATE:
! 849: inet_ntop (AF_INET, &gate.sin.sin_addr, gate_buf, INET_ADDRSTRLEN);
! 850: zlog_debug ("%s: %s %s/%d: desync: RR is in RIB, but gate differs (ours is %s)",
! 851: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen, gate_buf);
! 852: break;
! 853: case ZEBRA_RIB_FOUND_EXACT: /* RIB RR == FIB RR */
! 854: zlog_debug ("%s: %s %s/%d: done Ok",
! 855: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen);
! 856: rib_lookup_and_dump (&p);
! 857: return;
! 858: break;
! 859: }
! 860: break;
! 861: case RTM_DELETE:
! 862: /* The kernel notifies us about a route deleted by us. Do we still
! 863: have it in the RIB? Do we have anything instead? */
! 864: switch (ret)
! 865: {
! 866: case ZEBRA_RIB_FOUND_EXACT:
! 867: zlog_debug ("%s: %s %s/%d: desync: RR is still in RIB, while already not in FIB",
! 868: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen);
! 869: rib_lookup_and_dump (&p);
! 870: break;
! 871: case ZEBRA_RIB_FOUND_CONNECTED:
! 872: case ZEBRA_RIB_FOUND_NOGATE:
! 873: zlog_debug ("%s: %s %s/%d: desync: RR is still in RIB, plus gate differs",
! 874: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen);
! 875: rib_lookup_and_dump (&p);
! 876: break;
! 877: case ZEBRA_RIB_NOTFOUND: /* RIB RR == FIB RR */
! 878: zlog_debug ("%s: %s %s/%d: done Ok",
! 879: __func__, lookup (rtm_type_str, rtm->rtm_type), buf, p.prefixlen);
! 880: rib_lookup_and_dump (&p);
! 881: return;
! 882: break;
! 883: }
! 884: break;
! 885: default:
! 886: zlog_debug ("%s: %s/%d: warning: loopback RTM of type %s received",
! 887: __func__, buf, p.prefixlen, lookup (rtm_type_str, rtm->rtm_type));
! 888: }
! 889: return;
! 890: }
! 891:
! 892: /* Change, delete the old prefix, we have no further information
! 893: * to specify the route really
! 894: */
! 895: if (rtm->rtm_type == RTM_CHANGE)
! 896: rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p,
! 897: NULL, 0, 0);
! 898:
! 899: if (rtm->rtm_type == RTM_GET
! 900: || rtm->rtm_type == RTM_ADD
! 901: || rtm->rtm_type == RTM_CHANGE)
! 902: rib_add_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags,
! 903: &p, &gate.sin.sin_addr, NULL, 0, 0, 0, 0);
! 904: else
! 905: rib_delete_ipv4 (ZEBRA_ROUTE_KERNEL, zebra_flags,
! 906: &p, &gate.sin.sin_addr, 0, 0);
! 907: }
! 908: #ifdef HAVE_IPV6
! 909: if (dest.sa.sa_family == AF_INET6)
! 910: {
! 911: /* One day we might have a debug section here like one in the
! 912: * IPv4 case above. Just ignore own messages at the moment.
! 913: */
! 914: if (rtm->rtm_type != RTM_GET && rtm->rtm_pid == pid)
! 915: return;
! 916: struct prefix_ipv6 p;
! 917: unsigned int ifindex = 0;
! 918:
! 919: p.family = AF_INET6;
! 920: p.prefix = dest.sin6.sin6_addr;
! 921: if (flags & RTF_HOST)
! 922: p.prefixlen = IPV6_MAX_PREFIXLEN;
! 923: else
! 924: p.prefixlen = ip6_masklen (mask.sin6.sin6_addr);
! 925:
! 926: #ifdef KAME
! 927: if (IN6_IS_ADDR_LINKLOCAL (&gate.sin6.sin6_addr))
! 928: {
! 929: ifindex = IN6_LINKLOCAL_IFINDEX (gate.sin6.sin6_addr);
! 930: SET_IN6_LINKLOCAL_IFINDEX (gate.sin6.sin6_addr, 0);
! 931: }
! 932: #endif /* KAME */
! 933:
! 934: /* CHANGE: delete the old prefix, we have no further information
! 935: * to specify the route really
! 936: */
! 937: if (rtm->rtm_type == RTM_CHANGE)
! 938: rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags, &p,
! 939: NULL, 0, 0);
! 940:
! 941: if (rtm->rtm_type == RTM_GET
! 942: || rtm->rtm_type == RTM_ADD
! 943: || rtm->rtm_type == RTM_CHANGE)
! 944: rib_add_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags,
! 945: &p, &gate.sin6.sin6_addr, ifindex, 0, 0, 0);
! 946: else
! 947: rib_delete_ipv6 (ZEBRA_ROUTE_KERNEL, zebra_flags,
! 948: &p, &gate.sin6.sin6_addr, ifindex, 0);
! 949: }
! 950: #endif /* HAVE_IPV6 */
! 951: }
! 952:
! 953: /* Interface function for the kernel routing table updates. Support
! 954: * for RTM_CHANGE will be needed.
! 955: * Exported only for rt_socket.c
! 956: */
! 957: int
! 958: rtm_write (int message,
! 959: union sockunion *dest,
! 960: union sockunion *mask,
! 961: union sockunion *gate,
! 962: unsigned int index,
! 963: int zebra_flags,
! 964: int metric)
! 965: {
! 966: int ret;
! 967: caddr_t pnt;
! 968: struct interface *ifp;
! 969:
! 970: /* Sequencial number of routing message. */
! 971: static int msg_seq = 0;
! 972:
! 973: /* Struct of rt_msghdr and buffer for storing socket's data. */
! 974: struct
! 975: {
! 976: struct rt_msghdr rtm;
! 977: char buf[512];
! 978: } msg;
! 979:
! 980: if (routing_sock < 0)
! 981: return ZEBRA_ERR_EPERM;
! 982:
! 983: /* Clear and set rt_msghdr values */
! 984: memset (&msg, 0, sizeof (struct rt_msghdr));
! 985: msg.rtm.rtm_version = RTM_VERSION;
! 986: msg.rtm.rtm_type = message;
! 987: msg.rtm.rtm_seq = msg_seq++;
! 988: msg.rtm.rtm_addrs = RTA_DST;
! 989: msg.rtm.rtm_addrs |= RTA_GATEWAY;
! 990: msg.rtm.rtm_flags = RTF_UP;
! 991: msg.rtm.rtm_index = index;
! 992:
! 993: if (metric != 0)
! 994: {
! 995: msg.rtm.rtm_rmx.rmx_hopcount = metric;
! 996: msg.rtm.rtm_inits |= RTV_HOPCOUNT;
! 997: }
! 998:
! 999: ifp = if_lookup_by_index (index);
! 1000:
! 1001: if (gate && message == RTM_ADD)
! 1002: msg.rtm.rtm_flags |= RTF_GATEWAY;
! 1003:
! 1004: /* When RTF_CLONING is unavailable on BSD, should we set some
! 1005: * other flag instead?
! 1006: */
! 1007: #ifdef RTF_CLONING
! 1008: if (! gate && message == RTM_ADD && ifp &&
! 1009: (ifp->flags & IFF_POINTOPOINT) == 0)
! 1010: msg.rtm.rtm_flags |= RTF_CLONING;
! 1011: #endif /* RTF_CLONING */
! 1012:
! 1013: /* If no protocol specific gateway is specified, use link
! 1014: address for gateway. */
! 1015: if (! gate)
! 1016: {
! 1017: if (!ifp)
! 1018: {
! 1019: char dest_buf[INET_ADDRSTRLEN] = "NULL", mask_buf[INET_ADDRSTRLEN] = "255.255.255.255";
! 1020: if (dest)
! 1021: inet_ntop (AF_INET, &dest->sin.sin_addr, dest_buf, INET_ADDRSTRLEN);
! 1022: if (mask)
! 1023: inet_ntop (AF_INET, &mask->sin.sin_addr, mask_buf, INET_ADDRSTRLEN);
! 1024: zlog_warn ("%s: %s/%s: gate == NULL and no gateway found for ifindex %d",
! 1025: __func__, dest_buf, mask_buf, index);
! 1026: return -1;
! 1027: }
! 1028: gate = (union sockunion *) & ifp->sdl;
! 1029: }
! 1030:
! 1031: if (mask)
! 1032: msg.rtm.rtm_addrs |= RTA_NETMASK;
! 1033: else if (message == RTM_ADD)
! 1034: msg.rtm.rtm_flags |= RTF_HOST;
! 1035:
! 1036: /* Tagging route with flags */
! 1037: msg.rtm.rtm_flags |= (RTF_PROTO1);
! 1038:
! 1039: /* Additional flags. */
! 1040: if (zebra_flags & ZEBRA_FLAG_BLACKHOLE)
! 1041: msg.rtm.rtm_flags |= RTF_BLACKHOLE;
! 1042: if (zebra_flags & ZEBRA_FLAG_REJECT)
! 1043: msg.rtm.rtm_flags |= RTF_REJECT;
! 1044:
! 1045:
! 1046: #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
! 1047: #define SOCKADDRSET(X,R) \
! 1048: if (msg.rtm.rtm_addrs & (R)) \
! 1049: { \
! 1050: int len = ROUNDUP ((X)->sa.sa_len); \
! 1051: memcpy (pnt, (caddr_t)(X), len); \
! 1052: pnt += len; \
! 1053: }
! 1054: #else
! 1055: #define SOCKADDRSET(X,R) \
! 1056: if (msg.rtm.rtm_addrs & (R)) \
! 1057: { \
! 1058: int len = SAROUNDUP (X); \
! 1059: memcpy (pnt, (caddr_t)(X), len); \
! 1060: pnt += len; \
! 1061: }
! 1062: #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
! 1063:
! 1064: pnt = (caddr_t) msg.buf;
! 1065:
! 1066: /* Write each socket data into rtm message buffer */
! 1067: SOCKADDRSET (dest, RTA_DST);
! 1068: SOCKADDRSET (gate, RTA_GATEWAY);
! 1069: SOCKADDRSET (mask, RTA_NETMASK);
! 1070:
! 1071: msg.rtm.rtm_msglen = pnt - (caddr_t) &msg;
! 1072:
! 1073: ret = write (routing_sock, &msg, msg.rtm.rtm_msglen);
! 1074:
! 1075: if (ret != msg.rtm.rtm_msglen)
! 1076: {
! 1077: if (errno == EEXIST)
! 1078: return ZEBRA_ERR_RTEXIST;
! 1079: if (errno == ENETUNREACH)
! 1080: return ZEBRA_ERR_RTUNREACH;
! 1081: if (errno == ESRCH)
! 1082: return ZEBRA_ERR_RTNOEXIST;
! 1083:
! 1084: zlog_warn ("%s: write : %s (%d)", __func__, safe_strerror (errno), errno);
! 1085: return ZEBRA_ERR_KERNEL;
! 1086: }
! 1087: return ZEBRA_ERR_NOERROR;
! 1088: }
! 1089:
! 1090:
! 1091: #include "thread.h"
! 1092: #include "zebra/zserv.h"
! 1093:
! 1094: /* For debug purpose. */
! 1095: static void
! 1096: rtmsg_debug (struct rt_msghdr *rtm)
! 1097: {
! 1098: zlog_debug ("Kernel: Len: %d Type: %s", rtm->rtm_msglen, lookup (rtm_type_str, rtm->rtm_type));
! 1099: rtm_flag_dump (rtm->rtm_flags);
! 1100: zlog_debug ("Kernel: message seq %d", rtm->rtm_seq);
! 1101: zlog_debug ("Kernel: pid %d, rtm_addrs 0x%x", rtm->rtm_pid, rtm->rtm_addrs);
! 1102: }
! 1103:
! 1104: /* This is pretty gross, better suggestions welcome -- mhandler */
! 1105: #ifndef RTAX_MAX
! 1106: #ifdef RTA_NUMBITS
! 1107: #define RTAX_MAX RTA_NUMBITS
! 1108: #else
! 1109: #define RTAX_MAX 8
! 1110: #endif /* RTA_NUMBITS */
! 1111: #endif /* RTAX_MAX */
! 1112:
! 1113: /* Kernel routing table and interface updates via routing socket. */
! 1114: static int
! 1115: kernel_read (struct thread *thread)
! 1116: {
! 1117: int sock;
! 1118: int nbytes;
! 1119: struct rt_msghdr *rtm;
! 1120:
! 1121: /*
! 1122: * This must be big enough for any message the kernel might send.
! 1123: * Rather than determining how many sockaddrs of what size might be
! 1124: * in each particular message, just use RTAX_MAX of sockaddr_storage
! 1125: * for each. Note that the sockaddrs must be after each message
! 1126: * definition, or rather after whichever happens to be the largest,
! 1127: * since the buffer needs to be big enough for a message and the
! 1128: * sockaddrs together.
! 1129: */
! 1130: union
! 1131: {
! 1132: /* Routing information. */
! 1133: struct
! 1134: {
! 1135: struct rt_msghdr rtm;
! 1136: struct sockaddr_storage addr[RTAX_MAX];
! 1137: } r;
! 1138:
! 1139: /* Interface information. */
! 1140: struct
! 1141: {
! 1142: struct if_msghdr ifm;
! 1143: struct sockaddr_storage addr[RTAX_MAX];
! 1144: } im;
! 1145:
! 1146: /* Interface address information. */
! 1147: struct
! 1148: {
! 1149: struct ifa_msghdr ifa;
! 1150: struct sockaddr_storage addr[RTAX_MAX];
! 1151: } ia;
! 1152:
! 1153: #ifdef RTM_IFANNOUNCE
! 1154: /* Interface arrival/departure */
! 1155: struct
! 1156: {
! 1157: struct if_announcemsghdr ifan;
! 1158: struct sockaddr_storage addr[RTAX_MAX];
! 1159: } ian;
! 1160: #endif /* RTM_IFANNOUNCE */
! 1161:
! 1162: } buf;
! 1163:
! 1164: /* Fetch routing socket. */
! 1165: sock = THREAD_FD (thread);
! 1166:
! 1167: nbytes= read (sock, &buf, sizeof buf);
! 1168:
! 1169: if (nbytes <= 0)
! 1170: {
! 1171: if (nbytes < 0 && errno != EWOULDBLOCK && errno != EAGAIN)
! 1172: zlog_warn ("routing socket error: %s", safe_strerror (errno));
! 1173: return 0;
! 1174: }
! 1175:
! 1176: thread_add_read (zebrad.master, kernel_read, NULL, sock);
! 1177:
! 1178: if (IS_ZEBRA_DEBUG_KERNEL)
! 1179: rtmsg_debug (&buf.r.rtm);
! 1180:
! 1181: rtm = &buf.r.rtm;
! 1182:
! 1183: /*
! 1184: * Ensure that we didn't drop any data, so that processing routines
! 1185: * can assume they have the whole message.
! 1186: */
! 1187: if (rtm->rtm_msglen != nbytes)
! 1188: {
! 1189: zlog_warn ("kernel_read: rtm->rtm_msglen %d, nbytes %d, type %d\n",
! 1190: rtm->rtm_msglen, nbytes, rtm->rtm_type);
! 1191: return -1;
! 1192: }
! 1193:
! 1194: switch (rtm->rtm_type)
! 1195: {
! 1196: case RTM_ADD:
! 1197: case RTM_DELETE:
! 1198: case RTM_CHANGE:
! 1199: rtm_read (rtm);
! 1200: break;
! 1201: case RTM_IFINFO:
! 1202: ifm_read (&buf.im.ifm);
! 1203: break;
! 1204: case RTM_NEWADDR:
! 1205: case RTM_DELADDR:
! 1206: ifam_read (&buf.ia.ifa);
! 1207: break;
! 1208: #ifdef RTM_IFANNOUNCE
! 1209: case RTM_IFANNOUNCE:
! 1210: ifan_read (&buf.ian.ifan);
! 1211: break;
! 1212: #endif /* RTM_IFANNOUNCE */
! 1213: default:
! 1214: if (IS_ZEBRA_DEBUG_KERNEL)
! 1215: zlog_debug("Unprocessed RTM_type: %d", rtm->rtm_type);
! 1216: break;
! 1217: }
! 1218: return 0;
! 1219: }
! 1220:
! 1221: /* Make routing socket. */
! 1222: static void
! 1223: routing_socket (void)
! 1224: {
! 1225: if ( zserv_privs.change (ZPRIVS_RAISE) )
! 1226: zlog_err ("routing_socket: Can't raise privileges");
! 1227:
! 1228: routing_sock = socket (AF_ROUTE, SOCK_RAW, 0);
! 1229:
! 1230: if (routing_sock < 0)
! 1231: {
! 1232: if ( zserv_privs.change (ZPRIVS_LOWER) )
! 1233: zlog_err ("routing_socket: Can't lower privileges");
! 1234: zlog_warn ("Can't init kernel routing socket");
! 1235: return;
! 1236: }
! 1237:
! 1238: /* XXX: Socket should be NONBLOCK, however as we currently
! 1239: * discard failed writes, this will lead to inconsistencies.
! 1240: * For now, socket must be blocking.
! 1241: */
! 1242: /*if (fcntl (routing_sock, F_SETFL, O_NONBLOCK) < 0)
! 1243: zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
! 1244:
! 1245: if ( zserv_privs.change (ZPRIVS_LOWER) )
! 1246: zlog_err ("routing_socket: Can't lower privileges");
! 1247:
! 1248: /* kernel_read needs rewrite. */
! 1249: thread_add_read (zebrad.master, kernel_read, NULL, routing_sock);
! 1250: }
! 1251:
! 1252: /* Exported interface function. This function simply calls
! 1253: routing_socket (). */
! 1254: void
! 1255: kernel_init (void)
! 1256: {
! 1257: routing_socket ();
! 1258: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kernel_socket.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra