Annotation of embedaddon/pimd/rsrr.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 1993, 1998-2001.
! 3: * The University of Southern California/Information Sciences Institute.
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: * 2. Redistributions in binary form must reproduce the above copyright
! 12: * notice, this list of conditions and the following disclaimer in the
! 13: * documentation and/or other materials provided with the distribution.
! 14: * 3. Neither the name of the project nor the names of its contributors
! 15: * may be used to endorse or promote products derived from this software
! 16: * without specific prior written permission.
! 17: *
! 18: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
! 19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 21: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
! 22: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 28: * SUCH DAMAGE.
! 29: */
! 30:
! 31: /* RSRR code written by Daniel Zappala, USC Information Sciences Institute,
! 32: * April 1995.
! 33: */
! 34:
! 35: /* May 1995 -- Added support for Route Change Notification */
! 36:
! 37: #ifdef RSRR
! 38:
! 39: #include "defs.h"
! 40: #include <sys/param.h>
! 41: #ifdef HAVE_SA_LEN
! 42: #include <stddef.h> /* for offsetof */
! 43: #endif
! 44:
! 45: /*
! 46: * Local RSRR variables.
! 47: */
! 48: static int rsrr_socket; /* interface to reservation protocol */
! 49: static char *rsrr_recv_buf; /* RSRR receive buffer */
! 50: static char *rsrr_send_buf; /* RSRR send buffer */
! 51:
! 52: static struct sockaddr_un client_addr;
! 53: static socklen_t client_length = sizeof(client_addr);
! 54:
! 55: /*
! 56: * Procedure definitions needed internally.
! 57: */
! 58: static void rsrr_accept (size_t recvlen);
! 59: static void rsrr_accept_iq (void);
! 60: static int rsrr_accept_rq (struct rsrr_rq *route_query, uint8_t flags, struct gtable *gt_notify);
! 61: static void rsrr_read (int, fd_set *);
! 62: static int rsrr_send (int sendlen);
! 63: static void rsrr_cache (struct gtable *gt, struct rsrr_rq *route_query);
! 64:
! 65: /* Initialize RSRR socket */
! 66: void rsrr_init(void)
! 67: {
! 68: int servlen;
! 69: struct sockaddr_un serv_addr;
! 70:
! 71: rsrr_recv_buf = (char *)calloc(1, RSRR_MAX_LEN);
! 72: rsrr_send_buf = (char *)calloc(1, RSRR_MAX_LEN);
! 73: if (!rsrr_recv_buf || !rsrr_send_buf)
! 74: logit(LOG_ERR, 0, "Ran out of memory in rsrr_init()");
! 75:
! 76: if ((rsrr_socket = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
! 77: logit(LOG_ERR, errno, "Cannot create RSRR socket");
! 78:
! 79: unlink(RSRR_SERV_PATH);
! 80: memset(&serv_addr, 0, sizeof(serv_addr));
! 81: serv_addr.sun_family = AF_UNIX;
! 82: strlcpy(serv_addr.sun_path, RSRR_SERV_PATH, sizeof(serv_addr.sun_path));
! 83: #ifdef HAVE_SA_LEN
! 84: servlen = offsetof(struct sockaddr_un, sun_path) + strlen(serv_addr.sun_path);
! 85: serv_addr.sun_len = servlen;
! 86: #else
! 87: servlen = sizeof(serv_addr.sun_family) + strlen(serv_addr.sun_path);
! 88: #endif
! 89:
! 90: if (bind(rsrr_socket, (struct sockaddr *) &serv_addr, servlen) < 0)
! 91: logit(LOG_ERR, errno, "Cannot bind RSRR socket");
! 92:
! 93: if (register_input_handler(rsrr_socket, rsrr_read) < 0)
! 94: logit(LOG_ERR, 0, "Could not register RSRR as an input handler");
! 95: }
! 96:
! 97: /* Read a message from the RSRR socket */
! 98: static void rsrr_read(int fd, fd_set *rfd __attribute__ ((unused)))
! 99: {
! 100: ssize_t len;
! 101:
! 102: memset(&client_addr, 0, sizeof(client_addr));
! 103: while ((len = recvfrom(fd, rsrr_recv_buf, sizeof(rsrr_recv_buf),
! 104: 0, (struct sockaddr *)&client_addr, &client_length)) < 0) {
! 105: if (errno == EINTR)
! 106: continue; /* Received signal, retry syscall. */
! 107:
! 108: logit(LOG_ERR, errno, "Failed recvfrom() in rsrr_read()");
! 109: return;
! 110: }
! 111:
! 112: rsrr_accept(len);
! 113: }
! 114:
! 115: /* Accept a message from the reservation protocol and take
! 116: * appropriate action.
! 117: */
! 118: static void rsrr_accept(size_t recvlen)
! 119: {
! 120: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_recv_buf;
! 121: struct rsrr_rq *route_query;
! 122:
! 123: if (recvlen < RSRR_HEADER_LEN) {
! 124: logit(LOG_WARNING, 0, "Received RSRR packet of %d bytes, which is less than MIN size %d.",
! 125: recvlen, RSRR_HEADER_LEN);
! 126: return;
! 127: }
! 128:
! 129: if (rsrr->version > RSRR_MAX_VERSION || rsrr->version != 1) {
! 130: logit(LOG_WARNING, 0, "Received RSRR packet version %d, which I don't understand",
! 131: rsrr->version);
! 132: return;
! 133: }
! 134:
! 135: switch (rsrr->type) {
! 136: case RSRR_INITIAL_QUERY:
! 137: /* Send Initial Reply to client */
! 138: IF_DEBUG(DEBUG_RSRR) {
! 139: logit(LOG_DEBUG, 0, "Received Initial Query\n");
! 140: }
! 141: rsrr_accept_iq();
! 142: break;
! 143:
! 144: case RSRR_ROUTE_QUERY:
! 145: /* Check size */
! 146: if (recvlen < RSRR_RQ_LEN) {
! 147: logit(LOG_WARNING, 0, "Received Route Query of %d bytes, which is too small", recvlen);
! 148: break;
! 149: }
! 150: /* Get the query */
! 151: route_query = (struct rsrr_rq *) (rsrr_recv_buf + RSRR_HEADER_LEN);
! 152: IF_DEBUG(DEBUG_RSRR) {
! 153: logit(LOG_DEBUG, 0,
! 154: "Received Route Query for src %s grp %s notification %d",
! 155: inet_fmt(route_query->source_addr, s1, sizeof(s1)),
! 156: inet_fmt(route_query->dest_addr, s2, sizeof(s2)),
! 157: BIT_TST(rsrr->flags,RSRR_NOTIFICATION_BIT));
! 158: }
! 159: /* Send Route Reply to client */
! 160: rsrr_accept_rq(route_query, rsrr->flags, NULL);
! 161: break;
! 162:
! 163: default:
! 164: logit(LOG_WARNING, 0, "Received RSRR packet type %d, which I don't handle", rsrr->type);
! 165: break;
! 166: }
! 167: }
! 168:
! 169: /* Send an Initial Reply to the reservation protocol. */
! 170: /*
! 171: * TODO: XXX: if a new interfaces come up and _IF_ the multicast routing
! 172: * daemon automatically include it, have to inform the RSVP daemon.
! 173: * However, this is not in the RSRRv1 draft (just expired and is not
! 174: * available anymore from the internet-draft ftp sites). Probably has to
! 175: * be included in RSRRv2.
! 176: */
! 177: static void rsrr_accept_iq(void)
! 178: {
! 179: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
! 180: struct rsrr_vif *vif_list;
! 181: struct uvif *v;
! 182: vifi_t vifi;
! 183: int sendlen;
! 184:
! 185: /* Check for space. There should be room for plenty of vifs,
! 186: * but we should check anyway.
! 187: */
! 188: if (numvifs > RSRR_MAX_VIFS) {
! 189: logit(LOG_WARNING, 0,
! 190: "Cannot send RSRR Route Reply because %d is too many vifs %d",
! 191: numvifs);
! 192: return;
! 193: }
! 194:
! 195: /* Set up message */
! 196: rsrr->version = 1;
! 197: rsrr->type = RSRR_INITIAL_REPLY;
! 198: rsrr->flags = 0;
! 199: rsrr->num = numvifs;
! 200:
! 201: vif_list = (struct rsrr_vif *)(rsrr_send_buf + RSRR_HEADER_LEN);
! 202:
! 203: /* Include the vif list. */
! 204: for (vifi = 0, v = uvifs; vifi < numvifs; vifi++, v++) {
! 205: vif_list[vifi].id = vifi;
! 206: vif_list[vifi].status = 0;
! 207: if (v->uv_flags & VIFF_DISABLED)
! 208: BIT_SET(vif_list[vifi].status,RSRR_DISABLED_BIT);
! 209: vif_list[vifi].threshold = v->uv_threshold;
! 210: vif_list[vifi].local_addr = v->uv_lcl_addr;
! 211: }
! 212:
! 213: /* Get the size. */
! 214: sendlen = RSRR_HEADER_LEN + numvifs*RSRR_VIF_LEN;
! 215:
! 216: /* Send it. */
! 217: IF_DEBUG(DEBUG_RSRR) {
! 218: logit(LOG_DEBUG, 0, "Send RSRR Initial Reply");
! 219: }
! 220: rsrr_send(sendlen);
! 221: }
! 222:
! 223: /* Send a Route Reply to the reservation protocol. The Route Query
! 224: * contains the query to which we are responding. The flags contain
! 225: * the incoming flags from the query or, for route change
! 226: * notification, the flags that should be set for the reply. The
! 227: * kernel table entry contains the routing info to use for a route
! 228: * change notification.
! 229: */
! 230: /* XXX: must modify if your routing table structure/search is different */
! 231: static int rsrr_accept_rq(struct rsrr_rq *route_query, uint8_t flags, struct gtable *gt_notify)
! 232: {
! 233: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
! 234: struct rsrr_rr *route_reply;
! 235: int sendlen;
! 236: struct gtable *gt;
! 237: int status_ok;
! 238: #ifdef PIM
! 239: int found;
! 240: uint8_t tmp_flags;
! 241: rp_grp_entry_t *rp_grp_entry;
! 242: grpentry_t *grpentry_ptr;
! 243: #else
! 244: struct gtable local_g;
! 245: struct rtentry *r;
! 246: uint32_t mcastgrp;
! 247: #endif /* PIM */
! 248:
! 249: /* Set up message */
! 250: rsrr->version = 1;
! 251: rsrr->type = RSRR_ROUTE_REPLY;
! 252: rsrr->flags = flags;
! 253: rsrr->num = 0;
! 254:
! 255: route_reply = (struct rsrr_rr *) (rsrr_send_buf + RSRR_HEADER_LEN);
! 256: route_reply->dest_addr = route_query->dest_addr;
! 257: route_reply->source_addr = route_query->source_addr;
! 258: route_reply->query_id = route_query->query_id;
! 259:
! 260: /* Blank routing entry for error. */
! 261: route_reply->in_vif = 0;
! 262: route_reply->reserved = 0;
! 263: route_reply->out_vif_bm = 0;
! 264:
! 265: /* Get the size. */
! 266: sendlen = RSRR_RR_LEN;
! 267:
! 268: /* If routing table entry is defined, then we are sending a Route Reply
! 269: * due to a Route Change Notification event. Use the routing table entry
! 270: * to supply the routing info.
! 271: */
! 272: status_ok = FALSE;
! 273: #ifdef PIM
! 274: if (gt_notify) {
! 275: /* Include the routing entry. */
! 276: route_reply->in_vif = gt_notify->incoming;
! 277: route_reply->out_vif_bm = gt_notify->oifs;
! 278: gt = gt_notify;
! 279: status_ok = TRUE;
! 280: } else if ((gt = find_route(route_query->source_addr,
! 281: route_query->dest_addr,
! 282: MRTF_SG | MRTF_WC | MRTF_PMBR,
! 283: DONT_CREATE)) != (struct gtable *)NULL) {
! 284: status_ok = TRUE;
! 285: route_reply->in_vif = gt->incoming;
! 286: route_reply->out_vif_bm = gt->oifs;
! 287: }
! 288: if (status_ok != TRUE) {
! 289: /* Set error bit. */
! 290: rsrr->flags = 0;
! 291: BIT_SET(rsrr->flags, RSRR_ERROR_BIT);
! 292: }
! 293: else {
! 294: if (gt->flags & (MRTF_WC | MRTF_PMBR)) {
! 295: tmp_flags = 0;
! 296: BIT_SET(tmp_flags, RSRR_THIS_SENDER_SHARED_TREE);
! 297: BIT_SET(tmp_flags, RSRR_ALL_SENDERS_SHARED_TREE);
! 298: if (!(flags & tmp_flags)) {
! 299: /* Check whether need to setup the (*,G) related flags */
! 300: found = FALSE;
! 301: if (gt->flags & MRTF_PMBR) {
! 302: /* Check whether there is at least one (S,G) entry which is
! 303: * a longer match than this (*,*,RP) entry.
! 304: */
! 305: for (rp_grp_entry = gt->source->cand_rp->rp_grp_next;
! 306: rp_grp_entry != (rp_grp_entry_t *)NULL;
! 307: rp_grp_entry = rp_grp_entry->rp_grp_next) {
! 308: for (grpentry_ptr = rp_grp_entry->grplink;
! 309: grpentry_ptr != (grpentry_t *)NULL;
! 310: grpentry_ptr = grpentry_ptr->rpnext) {
! 311: if (grpentry_ptr->mrtlink != (mrtentry_t *)NULL) {
! 312: found = TRUE;
! 313: break;
! 314: }
! 315: }
! 316: if (found == TRUE)
! 317: break;
! 318: }
! 319: }
! 320: else if (gt->flags & MRTF_WC) {
! 321: if (gt->group->mrtlink != (mrtentry_t *)NULL)
! 322: found = TRUE;
! 323: }
! 324: if (found == TRUE) {
! 325: RSRR_THIS_SENDER_SHARED_TREE_SOME_OTHER_NOT(rsrr->flags);
! 326: }
! 327: else {
! 328: RSRR_SET_ALL_SENDERS_SHARED_TREE(rsrr->flags);
! 329: }
! 330: }
! 331: }
! 332: /* Cache reply if using route change notification. */
! 333: if (BIT_TST(flags, RSRR_NOTIFICATION_BIT)) {
! 334: /* TODO: XXX: Originally the rsrr_cache() call was first, but
! 335: * I think this is incorrect, because rsrr_cache() checks the
! 336: * rsrr_send_buf "flag" first.
! 337: */
! 338: BIT_SET(rsrr->flags, RSRR_NOTIFICATION_BIT);
! 339: rsrr_cache(gt, route_query);
! 340: }
! 341: }
! 342: #else /* Not PIM */
! 343: if (gt_notify) {
! 344: /* Set flags */
! 345: rsrr->flags = flags;
! 346: /* Include the routing entry. */
! 347: /* The original code from mrouted-3.9b2 */
! 348: route_reply->in_vif = gt_notify->gt_route->rt_parent;
! 349: /* TODO: XXX: bug? See the PIM code above */
! 350: if (BIT_TST(flags, RSRR_NOTIFICATION_BIT))
! 351: route_reply->out_vif_bm = gt_notify->gt_grpmems;
! 352: else
! 353: route_reply->out_vif_bm = 0;
! 354: } else if (find_src_grp(route_query->source_addr, 0,
! 355: route_query->dest_addr)) {
! 356:
! 357: /* Found kernel entry. Code taken from add_table_entry() */
! 358: gt = gtp ? gtp->gt_gnext : kernel_table;
! 359:
! 360: /* Include the routing entry. */
! 361: route_reply->in_vif = gt->gt_route->rt_parent;
! 362: route_reply->out_vif_bm = gt->gt_grpmems;
! 363:
! 364: /* Cache reply if using route change notification. */
! 365: if (BIT_TST(flags, RSRR_NOTIFICATION_BIT)) {
! 366: /* TODO: XXX: Originally the rsrr_cache() call was first, but
! 367: * I think this is incorrect, because rsrr_cache() checks the
! 368: * rsrr_send_buf "flag" first.
! 369: */
! 370: BIT_SET(rsrr->flags, RSRR_NOTIFICATION_BIT);
! 371: rsrr_cache(gt, route_query);
! 372: }
! 373: } else {
! 374: /* No kernel entry; use routing table. */
! 375: r = determine_route(route_query->source_addr);
! 376:
! 377: if (r != NULL) {
! 378: /* We need to mimic what will happen if a data packet
! 379: * is forwarded by multicast routing -- the kernel will
! 380: * make an upcall and mrouted will install a route in the kernel.
! 381: * Our outgoing vif bitmap should reflect what that table
! 382: * will look like. Grab code from add_table_entry().
! 383: * This is gross, but it's probably better to be accurate.
! 384: */
! 385:
! 386: gt = &local_g;
! 387: mcastgrp = route_query->dest_addr;
! 388:
! 389: gt->gt_mcastgrp = mcastgrp;
! 390: gt->gt_grpmems = 0;
! 391: gt->gt_scope = 0;
! 392: gt->gt_route = r;
! 393:
! 394: /* obtain the multicast group membership list */
! 395: determine_forwvifs(gt);
! 396:
! 397: /* Include the routing entry. */
! 398: route_reply->in_vif = gt->gt_route->rt_parent;
! 399: route_reply->out_vif_bm = gt->gt_grpmems;
! 400: } else {
! 401: /* Set error bit. */
! 402: BIT_SET(rsrr->flags, RSRR_ERROR_BIT);
! 403: }
! 404: }
! 405: #endif /* pimd - mrouted specific code */
! 406:
! 407: IF_DEBUG(DEBUG_RSRR) {
! 408: logit(LOG_DEBUG, 0, "%sSend RSRR Route Reply for src %s dst %s in vif %d out vif %d\n",
! 409: gt_notify ? "Route Change: " : "",
! 410: inet_fmt(route_reply->source_addr, s1, sizeof(s1)),
! 411: inet_fmt(route_reply->dest_addr, s2, sizeof(s2)),
! 412: route_reply->in_vif,route_reply->out_vif_bm);
! 413: }
! 414:
! 415: /* Send it. */
! 416: return rsrr_send(sendlen);
! 417: }
! 418:
! 419: /* Send an RSRR message. */
! 420: static int rsrr_send(int sendlen)
! 421: {
! 422: int error;
! 423:
! 424: while ((error = sendto(rsrr_socket, rsrr_send_buf, sendlen, 0,
! 425: (struct sockaddr *)&client_addr, client_length)) < 0)
! 426: {
! 427: if (errno == EINTR)
! 428: continue; /* Received signal, retry syscall. */
! 429:
! 430: logit(LOG_WARNING, errno, "Failed sendto() in rsrr_send()");
! 431:
! 432: return error;
! 433: }
! 434:
! 435: if (error != sendlen)
! 436: logit(LOG_WARNING, 0, "Sent only %d out of %d bytes on RSRR socket", error, sendlen);
! 437:
! 438: return error;
! 439: }
! 440:
! 441: /* TODO: need to sort the rsrr_cache entries for faster access */
! 442: /* Cache a message being sent to a client. Currently only used for
! 443: * caching Route Reply messages for route change notification.
! 444: */
! 445: static void rsrr_cache(struct gtable *gt, struct rsrr_rq *route_query)
! 446: {
! 447: struct rsrr_cache *rc, **rcnp;
! 448: struct rsrr_header *rsrr = (struct rsrr_header *)rsrr_send_buf;
! 449:
! 450: #ifdef PIM
! 451: rcnp = >->rsrr_cache;
! 452: #else
! 453: rcnp = >->gt_rsrr_cache;
! 454: #endif /* PIM */
! 455: while ((rc = *rcnp) != NULL) {
! 456: if ((rc->route_query.source_addr ==
! 457: route_query->source_addr) &&
! 458: (rc->route_query.dest_addr ==
! 459: route_query->dest_addr) &&
! 460: (!strcmp(rc->client_addr.sun_path,client_addr.sun_path))) {
! 461: /* Cache entry already exists.
! 462: * Check if route notification bit has been cleared.
! 463: */
! 464: if (!BIT_TST(rsrr->flags, RSRR_NOTIFICATION_BIT)) {
! 465: /* Delete cache entry. */
! 466: *rcnp = rc->next;
! 467: free(rc);
! 468: } else {
! 469: /* Update */
! 470: /* TODO: XXX: No need to update iif, oifs, flags */
! 471: rc->route_query.query_id = route_query->query_id;
! 472: IF_DEBUG(DEBUG_RSRR) {
! 473: logit(LOG_DEBUG, 0,
! 474: "Update cached query id %ld from client %s\n",
! 475: rc->route_query.query_id, rc->client_addr.sun_path);
! 476: }
! 477: }
! 478: return;
! 479: }
! 480: rcnp = &rc->next;
! 481: }
! 482:
! 483: /* Cache entry doesn't already exist. Create one and insert at
! 484: * front of list.
! 485: */
! 486: rc = (struct rsrr_cache *)calloc(1, sizeof(struct rsrr_cache));
! 487: if (rc == NULL)
! 488: logit(LOG_ERR, 0, "Ran out of memory in rsrr_cache()");
! 489:
! 490: rc->route_query.source_addr = route_query->source_addr;
! 491: rc->route_query.dest_addr = route_query->dest_addr;
! 492: rc->route_query.query_id = route_query->query_id;
! 493: strlcpy(rc->client_addr.sun_path, client_addr.sun_path, sizeof(rc->client_addr.sun_path));
! 494: rc->client_length = client_length;
! 495: #ifdef PIM
! 496: rc->next = gt->rsrr_cache;
! 497: gt->rsrr_cache = rc;
! 498: #else
! 499: rc->next = gt->gt_rsrr_cache;
! 500: gt->gt_rsrr_cache = rc;
! 501: #endif /* PIM */
! 502: IF_DEBUG(DEBUG_RSRR) {
! 503: logit(LOG_DEBUG, 0, "Cached query id %ld from client %s\n",
! 504: rc->route_query.query_id, rc->client_addr.sun_path);
! 505: }
! 506: }
! 507:
! 508: /* Send all the messages in the cache for particular routing entry.
! 509: * Currently this is used to send all the cached Route Reply messages
! 510: * for route change notification.
! 511: */
! 512: void rsrr_cache_send(struct gtable *gt, int notify)
! 513: {
! 514: struct rsrr_cache *rc, **rcnp;
! 515: uint8_t flags = 0;
! 516:
! 517: if (notify) {
! 518: BIT_SET(flags, RSRR_NOTIFICATION_BIT);
! 519: }
! 520:
! 521: #ifdef PIM
! 522: rcnp = >->rsrr_cache;
! 523: #else
! 524: rcnp = >->gt_rsrr_cache;
! 525: #endif /* PIM */
! 526:
! 527: while ((rc = *rcnp) != NULL) {
! 528: if (rsrr_accept_rq(&rc->route_query, flags, gt) < 0) {
! 529: IF_DEBUG(DEBUG_RSRR) {
! 530: logit(LOG_DEBUG, 0, "Deleting cached query id %ld from client %s\n",
! 531: rc->route_query.query_id,rc->client_addr.sun_path);
! 532: }
! 533: /* Delete cache entry. */
! 534: *rcnp = rc->next;
! 535: free(rc);
! 536: } else {
! 537: rcnp = &rc->next;
! 538: }
! 539: }
! 540: }
! 541:
! 542: /* Bring "up" the RSRR cache entries: the (S,G) entry brings up any
! 543: * matching entry from (*,*,RP) or (*,G). The (*,G) entry brings up
! 544: * any matching entries from (*,*,RP)
! 545: */
! 546: void rsrr_cache_bring_up(struct gtable *gt)
! 547: {
! 548: struct gtable *gt_rp, *gt_wide;
! 549: uint8_t flags = 0;
! 550: struct rsrr_cache *rc, **rcnp;
! 551:
! 552: if (gt == (struct gtable *)NULL)
! 553: return;
! 554: if (gt->flags & MRTF_PMBR)
! 555: /* (*,*,RP) */
! 556: return;
! 557: if (gt->flags & MRTF_WC) {
! 558: /* (*,G) */
! 559: if (((gt_rp = gt->group->active_rp_grp->rp->rpentry->mrtlink) ==
! 560: (struct gtable *)NULL)
! 561: || (gt_rp->rsrr_cache == (struct rsrr_cache *)NULL))
! 562: return;
! 563: if ((gt_rp->incoming == gt->incoming)
! 564: && (VIFM_SAME(gt->oifs, gt_rp->oifs))) {
! 565: /* The (iif, oifs) are the same. Just link to the new routing
! 566: * table entry. No need to send message to rsvpd */
! 567: rcnp = >_rp->rsrr_cache;
! 568: while ((rc = *rcnp) != NULL) {
! 569: if (rc->route_query.dest_addr == gt->group->group) {
! 570: *rcnp = rc->next;
! 571: rc->next = gt->rsrr_cache;
! 572: gt->rsrr_cache = rc;
! 573: }
! 574: else {
! 575: rcnp = &rc->next;
! 576: }
! 577: }
! 578: }
! 579: else {
! 580: /* Have to move the entries and at the same time
! 581: * send an update message to rsvpd for each of them.
! 582: */
! 583: /* TODO: XXX: this can be done faster */
! 584: rcnp = >_rp->rsrr_cache;
! 585: BIT_SET(flags, RSRR_NOTIFICATION_BIT);
! 586: if (gt->group->mrtlink != (mrtentry_t *)NULL) {
! 587: RSRR_THIS_SENDER_SHARED_TREE_SOME_OTHER_NOT(flags);
! 588: }
! 589: else {
! 590: RSRR_SET_ALL_SENDERS_SHARED_TREE(flags);
! 591: }
! 592: while ((rc = *rcnp) != NULL) {
! 593: if (rc->route_query.dest_addr == gt->group->group) {
! 594: *rcnp = rc->next;
! 595: if (rsrr_accept_rq(&rc->route_query, flags, gt) < 0) {
! 596: IF_DEBUG(DEBUG_RSRR) {
! 597: logit(LOG_DEBUG, 0,
! 598: "Deleting cached query id %ld from client %s\n",
! 599: rc->route_query.query_id,
! 600: rc->client_addr.sun_path);
! 601: }
! 602: }
! 603: /* Even on success have to delete it. */
! 604: *rcnp = rc->next;
! 605: free(rc);
! 606: }
! 607: }
! 608: }
! 609: return;
! 610: } /* end of (*,G) */
! 611:
! 612: if (gt->flags & MRTF_SG) {
! 613: /* (S,G) */
! 614: /* Check first (*,*,RP) */
! 615: if (((gt_wide = gt->group->active_rp_grp->rp->rpentry->mrtlink) ==
! 616: (struct gtable *)NULL)
! 617: || (gt_wide->rsrr_cache == (struct rsrr_cache *)NULL)) {
! 618: if (((gt_wide = gt->group->grp_route) == (struct gtable *)NULL)
! 619: || (gt_wide->rsrr_cache == (struct rsrr_cache *)NULL))
! 620: return;
! 621: }
! 622: BIT_SET(flags, RSRR_NOTIFICATION_BIT);
! 623: try_again:
! 624: rcnp = >_wide->rsrr_cache;
! 625: while((rc = *rcnp) != NULL) {
! 626: if ((rc->route_query.dest_addr == gt->group->group)
! 627: && (rc->route_query.source_addr ==
! 628: gt->source->address)) {
! 629: /* Found it. Need just this entry */
! 630: *rcnp = rc->next; /* Free from the original chain */
! 631: if ((gt_wide->incoming == gt->incoming)
! 632: && (VIFM_SAME(gt_wide->oifs, gt->oifs))) {
! 633: /* The (iif, oifs) are the same. Just link to the
! 634: * new routing table entry. No need to send
! 635: * message to rsvpd
! 636: */
! 637: rc->next = gt->rsrr_cache;
! 638: gt->rsrr_cache = rc;
! 639: }
! 640: else {
! 641: /* The iif and/or oifs are different. Send a message
! 642: * to rsvpd
! 643: */
! 644: if (rsrr_accept_rq(&rc->route_query, flags, gt) < 0) {
! 645: IF_DEBUG(DEBUG_RSRR) {
! 646: logit(LOG_DEBUG, 0,
! 647: "Deleting cached query id %ld from client %s\n",
! 648: rc->route_query.query_id,
! 649: rc->client_addr.sun_path);
! 650: }
! 651: }
! 652: /* Even on success have to delete it. */
! 653: free(rc);
! 654: }
! 655: return;
! 656: }
! 657: }
! 658: if (gt_wide->flags & MRTF_PMBR) {
! 659: if (((gt_wide = gt->group->grp_route) == (struct gtable *)NULL)
! 660: || (gt_wide->rsrr_cache == (struct rsrr_cache *)NULL))
! 661: return;
! 662: goto try_again;
! 663: }
! 664: }
! 665: }
! 666:
! 667: /* Clean the cache by deleting or moving all entries. */
! 668: /* XXX: for PIM, if the routing entry is (S,G), will try first to
! 669: * "transfer" the RSRR cache entry to the (*,G) or (*,*,RP) routing entry
! 670: * (if any). If the current routing entry is (*,G), it will move the
! 671: * cache entries to the (*,*,RP) routing entry (if existing).
! 672: * If the old and the new (iif, oifs) are the same, then no need to send
! 673: * route change message to the reservation daemon: just plug all entries at
! 674: * the front of the rsrr_cache chain.
! 675: */
! 676: void rsrr_cache_clean(struct gtable *gt)
! 677: {
! 678: struct rsrr_cache *rc, *rc_next, **rcnp;
! 679: struct gtable *gt_wide;
! 680: #ifdef PIM
! 681: uint8_t flags = 0;
! 682:
! 683: IF_DEBUG(DEBUG_RSRR) {
! 684: if (gt->flags & MRTF_SG)
! 685: logit(LOG_DEBUG, 0, "cleaning cache for source %s and group %s",
! 686: inet_fmt(gt->source->address, s1, sizeof(s1)),
! 687: inet_fmt(gt->group->group, s2, sizeof(s2)));
! 688: else if (gt->flags & MRTF_WC)
! 689: logit(LOG_DEBUG, 0, "cleaning cache for group %s and ANY sources",
! 690: inet_fmt(gt->group->group, s1, sizeof(s1)));
! 691: else if (gt->flags & MRTF_PMBR)
! 692: logit(LOG_DEBUG, 0,
! 693: "cleaning cache for ALL groups matching to RP %s",
! 694: inet_fmt(gt->source->address, s1, sizeof(s1)));
! 695: }
! 696: rc = gt->rsrr_cache;
! 697: if (rc == (struct rsrr_cache *)NULL)
! 698: return;
! 699: if (gt->flags & MRTF_SG) {
! 700: if ((gt_wide = gt->group->grp_route) == (struct gtable *)NULL)
! 701: gt_wide = gt->group->active_rp_grp->rp->rpentry->mrtlink;
! 702: }
! 703: else if (gt->flags & MRTF_WC)
! 704: gt_wide = gt->group->active_rp_grp->rp->rpentry->mrtlink;
! 705: else
! 706: gt_wide = (struct gtable *)NULL;
! 707:
! 708: if (gt_wide == (struct gtable *)NULL) {
! 709: /* No routing entry where to move down the rsrr cache entry.
! 710: * Send a message with "cannot_notify" bit set.
! 711: */
! 712: rsrr_cache_send(gt, 0);
! 713: while (rc) {
! 714: rc_next = rc->next;
! 715: free(rc);
! 716: rc = rc_next;
! 717: }
! 718: } else if ((gt_wide->incoming == gt->incoming)
! 719: && (VIFM_SAME(gt->oifs, gt_wide->oifs))) {
! 720: /* The (iif, oifs) are the same. Just move to the beginning of the
! 721: * RSRR cache chain. No need to send message */
! 722: while (rc->next != (struct rsrr_cache *)NULL)
! 723: rc = rc->next;
! 724: rc->next = gt_wide->rsrr_cache;
! 725: gt_wide->rsrr_cache = gt->rsrr_cache;
! 726: }
! 727: else {
! 728: /* Have to move to the RSRR cache entries and at the same time
! 729: * send an update for each of them.
! 730: */
! 731: rcnp = >->rsrr_cache;
! 732: BIT_SET(flags, RSRR_NOTIFICATION_BIT);
! 733: if (gt->group->mrtlink != (mrtentry_t *)NULL) {
! 734: RSRR_THIS_SENDER_SHARED_TREE_SOME_OTHER_NOT(flags);
! 735: }
! 736: else {
! 737: RSRR_SET_ALL_SENDERS_SHARED_TREE(flags);
! 738: }
! 739: while ((rc = *rcnp) != NULL) {
! 740: if (rsrr_accept_rq(&rc->route_query, flags, gt_wide) < 0) {
! 741: IF_DEBUG(DEBUG_RSRR) {
! 742: logit(LOG_DEBUG, 0,
! 743: "Deleting cached query id %ld from client %s\n",
! 744: rc->route_query.query_id, rc->client_addr.sun_path);
! 745: }
! 746: /* Delete cache entry. */
! 747: *rcnp = rc->next;
! 748: free(rc);
! 749: } else {
! 750: rcnp = &rc->next;
! 751: }
! 752: }
! 753: }
! 754: gt->rsrr_cache = (struct rsrr_cache *)NULL;
! 755:
! 756: #else
! 757: IF_DEBUG(DEBUG_RSRR) {
! 758: logit(LOG_DEBUG, 0, "cleaning cache for group %s\n",
! 759: inet_fmt(gt->gt_mcastgrp, s1, sizeof(s1)));
! 760: }
! 761: rc = gt->gt_rsrr_cache;
! 762: while (rc) {
! 763: rc_next = rc->next;
! 764: free(rc);
! 765: rc = rc_next;
! 766: }
! 767: gt->gt_rsrr_cache = NULL;
! 768: #endif /* PIM */
! 769: }
! 770:
! 771: void rsrr_clean(void)
! 772: {
! 773: unlink(RSRR_SERV_PATH);
! 774: }
! 775:
! 776: #else /* !RSRR */
! 777: static int dummy __attribute__((unused));
! 778: #endif /* RSRR */
! 779:
! 780: /**
! 781: * Local Variables:
! 782: * version-control: t
! 783: * indent-tabs-mode: t
! 784: * c-file-style: "ellemtel"
! 785: * c-basic-offset: 4
! 786: * End:
! 787: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rsrr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimd