Annotation of embedaddon/libpdel/net/route_msg.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43: #include <sys/socket.h>
! 44: #include <sys/sysctl.h>
! 45: #include <sys/sockio.h>
! 46: #include <sys/ioctl.h>
! 47:
! 48: #include <net/if.h>
! 49: #include <net/if_dl.h>
! 50: #include <net/if_types.h>
! 51: #include <net/route.h>
! 52:
! 53: #include <netinet/in.h>
! 54: #include <arpa/inet.h>
! 55:
! 56: #include <stdio.h>
! 57: #include <stdlib.h>
! 58: #include <stddef.h>
! 59: #include <stdarg.h>
! 60: #include <unistd.h>
! 61: #include <string.h>
! 62: #include <assert.h>
! 63: #include <errno.h>
! 64: #include <time.h>
! 65:
! 66: #include "structs/structs.h"
! 67: #include "structs/type/array.h"
! 68:
! 69: #include "util/typed_mem.h"
! 70: #include "net/route_msg.h"
! 71:
! 72: #define ROUNDUP(a) \
! 73: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
! 74: #define ADVANCE(x, n) ((x) += ROUNDUP((n)->sa_len))
! 75:
! 76: struct route_msg {
! 77: int type; /* message type */
! 78: int index; /* index for associated ifp */
! 79: int flags; /* flags, incl. kern & msg, e.g. DONE */
! 80: pid_t pid; /* for sender to identify action */
! 81: int seq; /* for sender to identify action */
! 82: int error; /* why failed */
! 83: struct sockaddr *dest; /* destination sockaddr */
! 84: struct sockaddr *gateway; /* gateway sockaddr */
! 85: struct sockaddr *netmask; /* netmask sockaddr */
! 86: struct sockaddr *genmask; /* genmask sockaddr */
! 87: struct sockaddr *ifp; /* interface name sockaddr */
! 88: struct sockaddr *ifa; /* interface addr sockaddr */
! 89: struct sockaddr *author; /* author of redirect sockaddr */
! 90: struct sockaddr *brd; /* for NEWADDR, broadcast or p2p dest */
! 91: };
! 92:
! 93: /*
! 94: * Internal variables
! 95: */
! 96:
! 97: /* List of sockaddr's in a route message from the kernel */
! 98: struct msg_sock {
! 99: const char *name;
! 100: u_int offset;
! 101: };
! 102:
! 103: static const struct msg_sock msg_socks[] = {
! 104: { "dest", offsetof(struct route_msg, dest) },
! 105: { "gateway", offsetof(struct route_msg, gateway) },
! 106: { "netmask", offsetof(struct route_msg, netmask) },
! 107: { "genmask", offsetof(struct route_msg, genmask) },
! 108: { "ifp", offsetof(struct route_msg, ifp) },
! 109: { "ifa", offsetof(struct route_msg, ifa) },
! 110: { "author", offsetof(struct route_msg, author) },
! 111: { "brd", offsetof(struct route_msg, brd) },
! 112: { NULL, 0 }
! 113: };
! 114:
! 115: static int prev_seq; /* last used sequence number */
! 116:
! 117: /*
! 118: * Internal functions
! 119: */
! 120: static int route_msg_set_sa(struct route_msg *msg,
! 121: const char *name, const struct sockaddr *sa);
! 122:
! 123: /*
! 124: * Create a new route message.
! 125: */
! 126: struct route_msg *
! 127: route_msg_create(void)
! 128: {
! 129: struct route_msg *msg;
! 130:
! 131: if ((msg = MALLOC("route_msg", sizeof(*msg))) == NULL)
! 132: return (NULL);
! 133: memset(msg, 0, sizeof(*msg));
! 134: msg->seq = ++prev_seq; /* XXX not atomic */
! 135: msg->pid = getpid();
! 136: return (msg);
! 137: }
! 138:
! 139: /*
! 140: * Destroy a routing message.
! 141: */
! 142: void
! 143: route_msg_destroy(struct route_msg **msgp)
! 144: {
! 145: struct route_msg *const msg = *msgp;
! 146:
! 147: if (msg == NULL)
! 148: return;
! 149: FREE("route_msg.dest", msg->dest);
! 150: FREE("route_msg.gateway", msg->gateway);
! 151: FREE("route_msg.netmask", msg->netmask);
! 152: FREE("route_msg.genmask", msg->genmask);
! 153: FREE("route_msg.ifp", msg->ifp);
! 154: FREE("route_msg.ifa", msg->ifa);
! 155: FREE("route_msg.author", msg->author);
! 156: FREE("route_msg.brd", msg->brd);
! 157: FREE("route_msg", msg);
! 158: *msgp = NULL;
! 159: }
! 160:
! 161: /*
! 162: * Get message type.
! 163: */
! 164: int
! 165: route_msg_get_type(struct route_msg *msg)
! 166: {
! 167: return (msg->type);
! 168: }
! 169:
! 170: /*
! 171: * Set message type.
! 172: */
! 173: void
! 174: route_msg_set_type(struct route_msg *msg, int type)
! 175: {
! 176: msg->type = type;
! 177: }
! 178:
! 179: /*
! 180: * Get message index.
! 181: */
! 182: int
! 183: route_msg_get_index(struct route_msg *msg)
! 184: {
! 185: return (msg->index);
! 186: }
! 187:
! 188: /*
! 189: * Set message index.
! 190: */
! 191: void
! 192: route_msg_set_index(struct route_msg *msg, int index)
! 193: {
! 194: msg->index = index;
! 195: }
! 196:
! 197: /*
! 198: * Get message flags.
! 199: */
! 200: int
! 201: route_msg_get_flags(struct route_msg *msg)
! 202: {
! 203: return (msg->flags);
! 204: }
! 205:
! 206: /*
! 207: * Set message flags.
! 208: */
! 209: void
! 210: route_msg_set_flags(struct route_msg *msg, int flags)
! 211: {
! 212: msg->flags = flags;
! 213: }
! 214:
! 215: /*
! 216: * Get message error code.
! 217: */
! 218: int
! 219: route_msg_get_error(struct route_msg *msg)
! 220: {
! 221: return (msg->error);
! 222: }
! 223:
! 224: /*
! 225: * Get message process ID.
! 226: */
! 227: pid_t
! 228: route_msg_get_pid(struct route_msg *msg)
! 229: {
! 230: return (msg->pid);
! 231: }
! 232:
! 233: /*
! 234: * Get message sequence number.
! 235: */
! 236: int
! 237: route_msg_get_seq(struct route_msg *msg)
! 238: {
! 239: return (msg->seq);
! 240: }
! 241:
! 242: /*
! 243: * Get message destination.
! 244: */
! 245: const struct sockaddr *
! 246: route_msg_get_dest(struct route_msg *msg)
! 247: {
! 248: return (msg->dest);
! 249: }
! 250:
! 251: /*
! 252: * Set message destination.
! 253: */
! 254: int
! 255: route_msg_set_dest(struct route_msg *msg, const struct sockaddr *dest)
! 256: {
! 257: return (route_msg_set_sa(msg, "dest", dest));
! 258: }
! 259:
! 260: /*
! 261: * Get message gateway.
! 262: */
! 263: const struct sockaddr *
! 264: route_msg_get_gateway(struct route_msg *msg)
! 265: {
! 266: return (msg->gateway);
! 267: }
! 268:
! 269: /*
! 270: * Set message gateway.
! 271: */
! 272: int
! 273: route_msg_set_gateway(struct route_msg *msg, const struct sockaddr *gateway)
! 274: {
! 275: return (route_msg_set_sa(msg, "gateway", gateway));
! 276: }
! 277:
! 278: /*
! 279: * Get message netmask.
! 280: */
! 281: const struct sockaddr *
! 282: route_msg_get_netmask(struct route_msg *msg)
! 283: {
! 284: return (msg->netmask);
! 285: }
! 286:
! 287: /*
! 288: * Set message netmask.
! 289: */
! 290: int
! 291: route_msg_set_netmask(struct route_msg *msg, const struct sockaddr *netmask)
! 292: {
! 293: return (route_msg_set_sa(msg, "netmask", netmask));
! 294: }
! 295:
! 296: /*
! 297: * Get message cloning netmask.
! 298: */
! 299: const struct sockaddr *
! 300: route_msg_get_genmask(struct route_msg *msg)
! 301: {
! 302: return (msg->genmask);
! 303: }
! 304:
! 305: /*
! 306: * Set message cloning netmask.
! 307: */
! 308: int
! 309: route_msg_set_genmask(struct route_msg *msg, const struct sockaddr *genmask)
! 310: {
! 311: return (route_msg_set_sa(msg, "genmask", genmask));
! 312: }
! 313:
! 314: /*
! 315: * Get message interface name.
! 316: */
! 317: const struct sockaddr *
! 318: route_msg_get_ifp(struct route_msg *msg)
! 319: {
! 320: return (msg->ifp);
! 321: }
! 322:
! 323: /*
! 324: * Set message interface name.
! 325: */
! 326: int
! 327: route_msg_set_ifp(struct route_msg *msg, const struct sockaddr *ifp)
! 328: {
! 329: return (route_msg_set_sa(msg, "ifp", ifp));
! 330: }
! 331:
! 332: /*
! 333: * Get message interface address.
! 334: */
! 335: const struct sockaddr *
! 336: route_msg_get_ifa(struct route_msg *msg)
! 337: {
! 338: return (msg->ifa);
! 339: }
! 340:
! 341: /*
! 342: * Set message interface address.
! 343: */
! 344: int
! 345: route_msg_set_ifa(struct route_msg *msg, const struct sockaddr *ifa)
! 346: {
! 347: return (route_msg_set_sa(msg, "ifa", ifa));
! 348: }
! 349:
! 350: /*
! 351: * Get message author of the redirect message.
! 352: */
! 353: const struct sockaddr *
! 354: route_msg_get_author(struct route_msg *msg)
! 355: {
! 356: return (msg->author);
! 357: }
! 358:
! 359: /*
! 360: * Set message author of the redirect message.
! 361: */
! 362: int
! 363: route_msg_set_author(struct route_msg *msg, const struct sockaddr *author)
! 364: {
! 365: return (route_msg_set_sa(msg, "author", author));
! 366: }
! 367:
! 368: /*
! 369: * Get message broadcast or point-to-point destination address.
! 370: */
! 371: const struct sockaddr *
! 372: route_msg_get_brd(struct route_msg *msg)
! 373: {
! 374: return (msg->brd);
! 375: }
! 376:
! 377: /*
! 378: * Set message broadcast or point-to-point destination address.
! 379: */
! 380: int
! 381: route_msg_set_brd(struct route_msg *msg, const struct sockaddr *brd)
! 382: {
! 383: return (route_msg_set_sa(msg, "brd", brd));
! 384: }
! 385:
! 386: /*
! 387: * Set one of the struct sockaddr fields.
! 388: */
! 389: static int
! 390: route_msg_set_sa(struct route_msg *msg,
! 391: const char *name, const struct sockaddr *sa)
! 392: {
! 393: struct sockaddr *copy;
! 394: struct sockaddr **sp;
! 395: char buf[32];
! 396: int i;
! 397:
! 398: for (i = 0; msg_socks[i].name != NULL
! 399: && strcmp(name, msg_socks[i].name) != 0; i++);
! 400: assert(msg_socks[i].name != NULL);
! 401: sp = (struct sockaddr **)(void *)((u_char *)msg + msg_socks[i].offset);
! 402: snprintf(buf, sizeof(buf), "route_msg.%s", name);
! 403: if (sa != NULL) {
! 404: if ((copy = MALLOC(buf, sa->sa_len)) == NULL)
! 405: return (-1);
! 406: memcpy(copy, sa, sa->sa_len);
! 407: } else
! 408: copy = NULL;
! 409: FREE(buf, *sp);
! 410: *sp = copy;
! 411: return (0);
! 412: }
! 413:
! 414: /*
! 415: * Decode one or more routing messages from raw socket data.
! 416: *
! 417: * Returns the number of decoded messages, or -1 for error.
! 418: * The array of struct route_msg pointers is returned in *listp,
! 419: * in an array allocated with memory type 'mtype'.
! 420: */
! 421: int
! 422: route_msg_decode(const u_char *data, size_t dlen,
! 423: struct route_msg ***listp, const char *mtype)
! 424: {
! 425: struct route_msg **list;
! 426: struct rt_msghdr rtm;
! 427: int posn;
! 428: int num;
! 429: int i;
! 430:
! 431: /* Count number of messages */
! 432: for (num = posn = 0; posn < dlen; num++, posn += rtm.rtm_msglen) {
! 433: if (dlen - posn < sizeof(rtm)) {
! 434: errno = EINVAL;
! 435: return (-1);
! 436: }
! 437: memcpy(&rtm, data + posn, sizeof(rtm.rtm_msglen));
! 438: if (rtm.rtm_msglen < sizeof(rtm)) {
! 439: errno = EINVAL;
! 440: return (-1);
! 441: }
! 442: }
! 443:
! 444: /* Allocate list */
! 445: if ((list = MALLOC(mtype, num * sizeof(*list))) == NULL)
! 446: return (-1);
! 447: memset(list, 0, num * sizeof(*list));
! 448:
! 449: /* Decode each message */
! 450: for (i = posn = 0; i < num; i++, posn += rtm.rtm_msglen) {
! 451: int posn2;
! 452: int j;
! 453:
! 454: /* Create new route_msg object */
! 455: if ((list[i] = route_msg_create()) == NULL)
! 456: goto fail;
! 457:
! 458: /* Copy fields from route message header */
! 459: memcpy(&rtm, data + posn, sizeof(rtm));
! 460: list[i]->type = rtm.rtm_type;
! 461: list[i]->index = rtm.rtm_index;
! 462: list[i]->flags = rtm.rtm_flags;
! 463: list[i]->pid = rtm.rtm_pid;
! 464: list[i]->seq = rtm.rtm_seq;
! 465: list[i]->error = rtm.rtm_errno;
! 466:
! 467: /* Create struct sockaddr's from each appended sockaddr */
! 468: for (posn2 = posn + sizeof(rtm), j = 0;
! 469: msg_socks[j].name != NULL; j++) {
! 470: const struct sockaddr *const sa
! 471: = (struct sockaddr *)(data + posn2);
! 472:
! 473: if ((rtm.rtm_addrs & (1 << j)) == 0)
! 474: continue;
! 475: if (sa->sa_len != 0) {
! 476: if (route_msg_set_sa(list[i],
! 477: msg_socks[j].name, sa) == -1)
! 478: goto fail;
! 479: }
! 480: ADVANCE(posn2, sa);
! 481: }
! 482: }
! 483:
! 484: /* Done */
! 485: *listp = list;
! 486: return (num);
! 487:
! 488: fail:
! 489: /* Cleanup after failure */
! 490: for (i = 0; i < num; i++)
! 491: route_msg_destroy(&list[i]);
! 492: FREE(mtype, list);
! 493: return (-1);
! 494: }
! 495:
! 496: /*
! 497: * Encode a route message into raw binary form.
! 498: *
! 499: * Returns the total encoded length, or -1 for error.
! 500: */
! 501: int
! 502: route_msg_encode(const struct route_msg *msg, u_char *data, size_t dlen)
! 503: {
! 504: struct rt_msghdr rtm;
! 505: int totalLen;
! 506: int i;
! 507:
! 508: /* Prepare header */
! 509: if ((totalLen = sizeof(rtm)) > dlen) {
! 510: errno = EMSGSIZE;
! 511: return (-1);
! 512: }
! 513: memset(&rtm, 0, sizeof(rtm));
! 514: rtm.rtm_version = RTM_VERSION;
! 515: rtm.rtm_type = msg->type;
! 516: rtm.rtm_index = msg->index;
! 517: rtm.rtm_flags = msg->flags;
! 518: rtm.rtm_pid = msg->pid;
! 519: rtm.rtm_seq = msg->seq;
! 520: rtm.rtm_errno = msg->error;
! 521:
! 522: /* Append struct sockaddr's */
! 523: for (i = 0; msg_socks[i].name != NULL; i++) {
! 524: struct sockaddr *const sa = *((struct sockaddr **)(void *)
! 525: ((u_char *)msg + msg_socks[i].offset));
! 526: int len;
! 527:
! 528: if (sa == NULL)
! 529: continue;
! 530: rtm.rtm_addrs |= (1 << i);
! 531: len = ROUNDUP(sa->sa_len);
! 532: if (totalLen + len > dlen) {
! 533: errno = EMSGSIZE;
! 534: return (-1);
! 535: }
! 536: memcpy(data + totalLen, sa, sa->sa_len);
! 537: memset(data + totalLen + sa->sa_len, 0, len - sa->sa_len);
! 538: totalLen += len;
! 539: }
! 540:
! 541: /* Copy in completed header */
! 542: rtm.rtm_msglen = totalLen;
! 543: memcpy(data, &rtm, sizeof(rtm));
! 544:
! 545: /* Done */
! 546: return (totalLen);
! 547: }
! 548:
! 549: /*
! 550: * Send a route message to a socket.
! 551: */
! 552: int
! 553: route_msg_send(struct route_msg *msg, int sock)
! 554: {
! 555: u_char buf[512];
! 556: int count;
! 557: int elen;
! 558: int r;
! 559:
! 560: if ((elen = route_msg_encode(msg, buf, sizeof(buf))) == -1)
! 561: return (-1);
! 562: for (count = 0; count < 32; count++) {
! 563: if ((r = send(sock, buf, elen, 0)) >= 0)
! 564: return (0);
! 565: switch (errno) {
! 566: case ENETUNREACH:
! 567: case ESRCH:
! 568: break;
! 569: default:
! 570: return (-1);
! 571: }
! 572: }
! 573: return (-1);
! 574: }
! 575:
! 576: /*
! 577: * Receive route messages from a socket.
! 578: */
! 579: int
! 580: route_msg_recv(struct route_msg ***listp, int sock, const char *mtype)
! 581: {
! 582: u_char buf[512];
! 583: int r;
! 584:
! 585: /* Read next raw message array */
! 586: if ((r = recv(sock, buf, sizeof(buf), 0)) < 0)
! 587: return (-1);
! 588:
! 589: /* Decode it */
! 590: return (route_msg_decode(buf, r, listp, mtype));
! 591: }
! 592:
! 593: /*
! 594: * Print route message as a string.
! 595: */
! 596: void
! 597: route_msg_print(struct route_msg *msg, FILE *fp)
! 598: {
! 599: const char *typestr = NULL;
! 600:
! 601: fprintf(fp, "type=");
! 602: switch (msg->type) {
! 603: case RTM_ADD: typestr = "ADD"; break;
! 604: case RTM_DELETE: typestr = "DELETE"; break;
! 605: case RTM_CHANGE: typestr = "CHANGE"; break;
! 606: case RTM_GET: typestr = "GET"; break;
! 607: case RTM_LOSING: typestr = "LOSING"; break;
! 608: case RTM_REDIRECT: typestr = "REDIRECT"; break;
! 609: case RTM_MISS: typestr = "MISS"; break;
! 610: case RTM_LOCK: typestr = "LOCK"; break;
! 611: case RTM_OLDADD: typestr = "OLDADD"; break;
! 612: case RTM_OLDDEL: typestr = "OLDDEL"; break;
! 613: case RTM_RESOLVE: typestr = "RESOLVE"; break;
! 614: case RTM_NEWADDR: typestr = "NEWADDR"; break;
! 615: case RTM_DELADDR: typestr = "DELADDR"; break;
! 616: case RTM_IFINFO: typestr = "IFINFO"; break;
! 617: case RTM_NEWMADDR: typestr = "NEWMADDR"; break;
! 618: case RTM_DELMADDR: typestr = "DELMADDR"; break;
! 619: default:
! 620: fprintf(fp, "%d", msg->type);
! 621: break;
! 622: }
! 623: if (typestr != NULL)
! 624: fprintf(fp, "%s", typestr);
! 625: fprintf(fp, " index=%d flags=0x%x pid=%lu seq=%d errno=%d",
! 626: msg->index, msg->flags, (u_long)msg->pid, msg->seq, msg->error);
! 627: if (msg->dest != NULL)
! 628: fprintf(fp, " dest=%p", msg->dest);
! 629: if (msg->gateway != NULL)
! 630: fprintf(fp, " gateway=%p", msg->gateway);
! 631: if (msg->netmask != NULL)
! 632: fprintf(fp, " netmask=%p", msg->netmask);
! 633: if (msg->genmask != NULL)
! 634: fprintf(fp, " genmask=%p", msg->genmask);
! 635: if (msg->ifp != NULL)
! 636: fprintf(fp, " ifp=%p", msg->ifp);
! 637: if (msg->ifa != NULL)
! 638: fprintf(fp, " ifa=%p", msg->ifa);
! 639: if (msg->author != NULL)
! 640: fprintf(fp, " author=%p", msg->author);
! 641: if (msg->brd != NULL)
! 642: fprintf(fp, " brd=%p", msg->brd);
! 643: fflush(fp);
! 644: }
! 645:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to route_msg.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / net