![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aurp_ri.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to aurp_ri.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1996 Apple Computer, Inc. ! 24: * ! 25: * Created April 8, 1996 by Tuyen Nguyen ! 26: * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX. ! 27: * ! 28: * File: ri.c ! 29: */ ! 30: #include <sys/errno.h> ! 31: #include <sys/types.h> ! 32: #include <sys/param.h> ! 33: #include <machine/spl.h> ! 34: #include <sys/systm.h> ! 35: #include <sys/kernel.h> ! 36: #include <sys/proc.h> ! 37: #include <sys/filedesc.h> ! 38: #include <sys/fcntl.h> ! 39: #include <sys/mbuf.h> ! 40: #include <sys/socket.h> ! 41: #include <sys/socketvar.h> ! 42: #include <net/if.h> ! 43: ! 44: #include <netat/sysglue.h> ! 45: #include <netat/appletalk.h> ! 46: #include <netat/at_var.h> ! 47: #include <netat/rtmp.h> ! 48: #include <netat/routing_tables.h> ! 49: #include <netat/at_pcb.h> ! 50: #include <netat/aurp.h> ! 51: #include <netat/debug.h> ! 52: ! 53: /* */ ! 54: void AURPsndRIAck(state, m, flags) ! 55: aurp_state_t *state; ! 56: gbuf_t *m; ! 57: unsigned short flags; ! 58: { ! 59: unsigned short sequence_number; ! 60: aurp_hdr_t *hdrp; ! 61: int msize = sizeof(aurp_hdr_t); ! 62: ! 63: if (m) { ! 64: sequence_number = ((aurp_hdr_t *)gbuf_rptr(m))->sequence_number; ! 65: gbuf_wset(m,sizeof(aurp_hdr_t)); ! 66: } else { ! 67: sequence_number = state->rcv_sequence_number; ! 68: if ((m = (gbuf_t *)gbuf_alloc(msize, PRI_MED)) == 0) ! 69: return; ! 70: gbuf_wset(m,msize); ! 71: } ! 72: ! 73: /* construct the RI Ack packet */ ! 74: hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 75: hdrp->connection_id = state->rcv_connection_id; ! 76: hdrp->sequence_number = sequence_number; ! 77: hdrp->command_code = AURPCMD_RIAck; ! 78: hdrp->flags = flags; ! 79: ! 80: /* send the packet */ ! 81: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndRIAck: node=%d\n", ! 82: state->rem_node)); ! 83: AURPsend(m, AUD_AURP, state->rem_node); ! 84: } ! 85: ! 86: /* */ ! 87: void AURPsndRIReq(state) ! 88: aurp_state_t *state; ! 89: { ! 90: int msize; ! 91: gbuf_t *m; ! 92: aurp_hdr_t *hdrp; ! 93: ! 94: if (state->rcv_state == AURPSTATE_Unconnected) ! 95: return; ! 96: if (state->rcv_tmo && (state->rcv_state != AURPSTATE_WaitingForRIRsp)) ! 97: return; ! 98: ! 99: msize = sizeof(aurp_hdr_t); ! 100: if ((m = (gbuf_t *)gbuf_alloc(msize, PRI_MED)) != 0) { ! 101: gbuf_wset(m,msize); ! 102: ! 103: /* construct the RI request packet */ ! 104: hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 105: hdrp->connection_id = state->rcv_connection_id; ! 106: hdrp->sequence_number = 0; ! 107: hdrp->command_code = AURPCMD_RIReq; ! 108: hdrp->flags = 0; ! 109: ! 110: /* update state info */ ! 111: state->rcv_state = AURPSTATE_WaitingForRIRsp; ! 112: ! 113: /* send the packet */ ! 114: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndRIReq: node=%d\n", ! 115: state->rem_node)); ! 116: AURPsend(m, AUD_AURP, state->rem_node); ! 117: } ! 118: ! 119: /* start the retry timer */ ! 120: timeout(AURPsndRIReq, state, AURP_RetryInterval*HZ); ! 121: state->rcv_tmo = 1; ! 122: } ! 123: ! 124: /* */ ! 125: void AURPsndRIRsp(state) ! 126: aurp_state_t *state; ! 127: { ! 128: gbuf_t *m; ! 129: aurp_hdr_t *hdrp; ! 130: short len = 0; ! 131: int s, msize = 0; ! 132: ! 133: ATDISABLE(s, aurpgen_lock); ! 134: ! 135: /* make sure we're in a valid state to send RI response */ ! 136: if ((state->snd_state == AURPSTATE_Unconnected) || ! 137: (state->snd_state == AURPSTATE_WaitingForRIAck2)) { ! 138: ATENABLE(s, aurpgen_lock); ! 139: return; ! 140: } ! 141: ! 142: /* update state info */ ! 143: state->snd_state = AURPSTATE_WaitingForRIAck1; ! 144: ! 145: if (state->rsp_m == 0) { ! 146: ATENABLE(s, aurpgen_lock); ! 147: msize = sizeof(aurp_hdr_t); ! 148: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) { ! 149: timeout(AURPsndRIRsp, state, AURP_RetryInterval*HZ); ! 150: state->snd_tmo = 1; ! 151: return; ! 152: } ! 153: gbuf_wset(m,msize); ! 154: state->rsp_m = m; ! 155: ! 156: /* construct the RI response packet */ ! 157: hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 158: hdrp->connection_id = state->snd_connection_id; ! 159: hdrp->sequence_number = state->snd_sequence_number; ! 160: hdrp->command_code = AURPCMD_RIRsp; ! 161: hdrp->flags = 0; ! 162: ! 163: /* get routing info of the local networks */ ! 164: state->snd_next_entry = AURPgetri( ! 165: state->snd_next_entry, gbuf_wptr(m), &len); ! 166: gbuf_winc(m,len); ! 167: ! 168: /* set the last flag if this is the last response packet */ ! 169: if (!state->snd_next_entry) ! 170: hdrp->flags = AURPFLG_LAST; ! 171: } ! 172: ! 173: /* keep a copy of the packet for retry */ ! 174: m = (gbuf_t *)gbuf_dupb(state->rsp_m); ! 175: ! 176: /* start the retry timer */ ! 177: timeout(AURPsndRIRsp, state, AURP_RetryInterval*HZ); ! 178: state->snd_tmo = 1; ! 179: ! 180: if (msize == 0) ! 181: ATENABLE(s, aurpgen_lock); ! 182: ! 183: /* send the packet */ ! 184: if (m) { ! 185: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndRIRsp: len=%d\n", len)); ! 186: AURPsend(m, AUD_AURP, state->rem_node); ! 187: } ! 188: } ! 189: ! 190: /* */ ! 191: void AURPsndRIUpd(state) ! 192: aurp_state_t *state; ! 193: { ! 194: gbuf_t *m; ! 195: aurp_hdr_t *hdrp; ! 196: short len = 0; ! 197: int s, msize = 0; ! 198: ! 199: ATDISABLE(s, aurpgen_lock); ! 200: ! 201: /* make sure we're in a valid state to send update */ ! 202: if (state->snd_next_entry || (state->upd_m == 0) || ! 203: (state->snd_state == AURPSTATE_Unconnected) || ! 204: (state->snd_state == AURPSTATE_WaitingForRIAck1)) { ! 205: ATENABLE(s, aurpgen_lock); ! 206: return; ! 207: } ! 208: ! 209: /* update state info */ ! 210: state->snd_state = AURPSTATE_WaitingForRIAck2; ! 211: ! 212: if (state->snd_tmo == 0) { ! 213: ATENABLE(s, aurpgen_lock); ! 214: msize = sizeof(aurp_hdr_t); ! 215: m = state->upd_m; ! 216: len = gbuf_len(m); ! 217: gbuf_rdec(m,msize); ! 218: ! 219: /* construct the RI update packet */ ! 220: hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 221: hdrp->connection_id = state->snd_connection_id; ! 222: hdrp->sequence_number = state->snd_sequence_number; ! 223: hdrp->command_code = AURPCMD_RIUpd; ! 224: hdrp->flags = 0; ! 225: } ! 226: ! 227: /* keep a copy of the packet for retry */ ! 228: m = (gbuf_t *)gbuf_dupb(state->upd_m); ! 229: ! 230: /* start the retry timer */ ! 231: timeout(AURPsndRIUpd, state, AURP_RetryInterval*HZ); ! 232: state->snd_tmo = 1; ! 233: ! 234: if (msize == 0) ! 235: ATENABLE(s, aurpgen_lock); ! 236: ! 237: /* send the packet */ ! 238: if (m) { ! 239: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndRIUpd: len=%d\n", len)); ! 240: AURPsend(m, AUD_AURP, state->rem_node); ! 241: } ! 242: } ! 243: ! 244: /* */ ! 245: void AURPrcvRIReq(state, m) ! 246: aurp_state_t *state; ! 247: gbuf_t *m; ! 248: { ! 249: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 250: int s; ! 251: ! 252: ATDISABLE(s, aurpgen_lock); ! 253: ! 254: /* make sure we're in a valid state to accept it */ ! 255: if ((state->snd_state == AURPSTATE_Unconnected) || ! 256: (state->snd_state == AURPSTATE_WaitingForRIAck2)) { ! 257: ATENABLE(s, aurpgen_lock); ! 258: dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIReq: unexpected request\n")); ! 259: gbuf_freem(m); ! 260: return; ! 261: } ! 262: ! 263: /* check for the correct connection id */ ! 264: if (hdrp->connection_id != state->snd_connection_id) { ! 265: ATENABLE(s, aurpgen_lock); ! 266: dPrintf(D_M_AURP, D_L_WARNING, ! 267: ("AURPrcvRIReq: invalid connection id, r=%d, m=%d\n", ! 268: hdrp->connection_id, state->snd_connection_id)); ! 269: gbuf_freem(m); ! 270: return; ! 271: } ! 272: ! 273: if (state->snd_state != AURPSTATE_WaitingForRIAck1) { ! 274: state->snd_next_entry = 0; ! 275: if (state->rsp_m) { ! 276: gbuf_freem(state->rsp_m); ! 277: state->rsp_m = 0; ! 278: } ! 279: ATENABLE(s, aurpgen_lock); ! 280: AURPsndRIRsp(state); ! 281: } else ! 282: ATENABLE(s, aurpgen_lock); ! 283: ! 284: gbuf_freem(m); ! 285: } ! 286: ! 287: /* */ ! 288: void AURPrcvRIRsp(state, m) ! 289: aurp_state_t *state; ! 290: gbuf_t *m; ! 291: { ! 292: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 293: int s; ! 294: ! 295: ATDISABLE(s, aurpgen_lock); ! 296: ! 297: /* make sure we're in a valid state to accept it */ ! 298: if (state->rcv_state != AURPSTATE_WaitingForRIRsp) { ! 299: ATENABLE(s, aurpgen_lock); ! 300: dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIRsp: unexpected response\n")); ! 301: gbuf_freem(m); ! 302: return; ! 303: } ! 304: ! 305: /* check for the correct connection id */ ! 306: if (hdrp->connection_id != state->rcv_connection_id) { ! 307: ATENABLE(s, aurpgen_lock); ! 308: dPrintf(D_M_AURP, D_L_WARNING, ! 309: ("AURPrcvRIRsp: invalid connection id, r=%d, m=%d\n", ! 310: hdrp->connection_id, state->rcv_connection_id)); ! 311: gbuf_freem(m); ! 312: return; ! 313: } ! 314: ! 315: /* check for the correct sequence number */ ! 316: if (hdrp->sequence_number != state->rcv_sequence_number) { ! 317: ATENABLE(s, aurpgen_lock); ! 318: if ( ((state->rcv_sequence_number == AURP_FirstSeqNum) && ! 319: (hdrp->sequence_number == AURP_LastSeqNum)) || ! 320: (hdrp->sequence_number == (state->rcv_sequence_number-1)) ) { ! 321: AURPsndRIAck(state, m, AURPFLG_SZI); ! 322: } else { ! 323: dPrintf(D_M_AURP, D_L_WARNING, ! 324: ("AURPrcvRIRsp: invalid sequence number, r=%d, m=%d\n", ! 325: hdrp->sequence_number, state->rcv_sequence_number)); ! 326: gbuf_freem(m); ! 327: } ! 328: return; ! 329: } ! 330: gbuf_rinc(m,sizeof(*hdrp)); ! 331: if (hdrp->flags & AURPFLG_LAST) ! 332: state->rcv_state = AURPSTATE_Connected; ! 333: ATENABLE(s, aurpgen_lock); ! 334: ! 335: dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIRsp: len=%ld\n", gbuf_len(m))); ! 336: ! 337: /* cancel the retry timer */ ! 338: untimeout(AURPsndRIReq, state); ! 339: state->rcv_tmo = 0; ! 340: ! 341: /* send RI ack */ ! 342: AURPsndRIAck(state, 0, AURPFLG_SZI); ! 343: ! 344: /* update state info */ ! 345: if (++state->rcv_sequence_number == 0) ! 346: state->rcv_sequence_number = AURP_FirstSeqNum; ! 347: ! 348: /* process routing info of the tunnel peer */ ! 349: if (AURPsetri(state->rem_node, m)) { ! 350: dPrintf(D_M_AURP, D_L_ERROR, ("AURPrcvRIRsp: AURPsetri() error\n")); ! 351: } ! 352: gbuf_freem(m); ! 353: ! 354: /* set the get zone flag to get zone info later if required */ ! 355: if (state->rcv_state == AURPSTATE_Connected) ! 356: state->get_zi = 1; ! 357: } ! 358: ! 359: /* */ ! 360: void AURPrcvRIUpd(state, m) ! 361: aurp_state_t *state; ! 362: gbuf_t *m; ! 363: { ! 364: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 365: ! 366: /* make sure we're in a valid state to accept it */ ! 367: if (state->rcv_state == AURPSTATE_Unconnected) { ! 368: dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvRIUpd: unexpected response\n")); ! 369: gbuf_freem(m); ! 370: return; ! 371: } ! 372: ! 373: /* check for the correct connection id */ ! 374: if (hdrp->connection_id != state->rcv_connection_id) { ! 375: dPrintf(D_M_AURP, D_L_WARNING, ! 376: ("AURPrcvRIUpd: invalid connection id, r=%d, m=%d\n", ! 377: hdrp->connection_id, state->rcv_connection_id)); ! 378: gbuf_freem(m); ! 379: return; ! 380: } ! 381: ! 382: /* check for the correct sequence number */ ! 383: if (hdrp->sequence_number != state->rcv_sequence_number) { ! 384: if ( ((state->rcv_sequence_number == AURP_FirstSeqNum) && ! 385: (hdrp->sequence_number == AURP_LastSeqNum)) || ! 386: (hdrp->sequence_number == (state->rcv_sequence_number-1)) ) { ! 387: AURPsndRIAck(state, m, AURPFLG_SZI); ! 388: } else { ! 389: dPrintf(D_M_AURP, D_L_WARNING, ! 390: ("AURPrcvRIUpd: invalid sequence number, r=%d, m=%d\n", ! 391: hdrp->sequence_number, state->rcv_sequence_number)); ! 392: gbuf_freem(m); ! 393: } ! 394: return; ! 395: } ! 396: gbuf_rinc(m,sizeof(*hdrp)); ! 397: ! 398: dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIUpd: len=%ld\n", gbuf_len(m))); ! 399: ! 400: /* send RI ack */ ! 401: AURPsndRIAck(state, 0, AURPFLG_SZI); ! 402: ! 403: /* update state info */ ! 404: if (++state->rcv_sequence_number == 0) ! 405: state->rcv_sequence_number = AURP_FirstSeqNum; ! 406: ! 407: /* process update routing info of the tunnel peer */ ! 408: if (AURPupdateri(state->rem_node, m)) { ! 409: dPrintf(D_M_AURP, D_L_ERROR, ("AURPrcvRIUpd: AURPupdateri() error\n")); ! 410: } ! 411: ! 412: /* set the get zone flag to get zone info later if required */ ! 413: state->get_zi = 1; ! 414: ! 415: gbuf_freem(m); ! 416: } ! 417: ! 418: /* */ ! 419: void AURPrcvRIAck(state, m) ! 420: aurp_state_t *state; ! 421: gbuf_t *m; ! 422: { ! 423: gbuf_t *dat_m; ! 424: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m); ! 425: unsigned char snd_state; ! 426: int s; ! 427: int flag; ! 428: ! 429: dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvRIAck: state=%d\n", ! 430: state->snd_state)); ! 431: ATDISABLE(s, aurpgen_lock); ! 432: ! 433: /* make sure we're in a valid state to accept it */ ! 434: snd_state = state->snd_state; ! 435: if (((snd_state == AURPSTATE_WaitingForRIAck1) || ! 436: (snd_state == AURPSTATE_WaitingForRIAck2)) && ! 437: (hdrp->sequence_number == state->snd_sequence_number)) { ! 438: ! 439: if (snd_state == AURPSTATE_WaitingForRIAck1) { ! 440: /* ack from the tunnel peer to our RI response */ ! 441: untimeout(AURPsndRIRsp, state); ! 442: dat_m = state->rsp_m; ! 443: state->rsp_m = 0; ! 444: flag = 1; ! 445: } else { ! 446: /* ack from the tunnel peer to our RI update */ ! 447: untimeout(AURPsndRIUpd, state); ! 448: dat_m = state->upd_m; ! 449: state->upd_m = 0; ! 450: flag = 2; ! 451: } ! 452: state->snd_tmo = 0; ! 453: gbuf_rinc(dat_m,sizeof(aurp_hdr_t)); ! 454: ! 455: /* increment the sequence number */ ! 456: if (++state->snd_sequence_number == 0) ! 457: state->snd_sequence_number = AURP_FirstSeqNum; ! 458: ! 459: /* update state info */ ! 460: state->snd_state = AURPSTATE_Connected; ! 461: ATENABLE(s, aurpgen_lock); ! 462: ! 463: if (state->snd_next_entry) /* more RI responses to send? */ ! 464: AURPsndRIRsp(state); ! 465: ! 466: /* check to see if we need to send ZI responses */ ! 467: if (hdrp->flags & AURPFLG_SZI) ! 468: AURPsndZRsp(state, dat_m, flag); ! 469: else if (dat_m) ! 470: gbuf_freem(dat_m); ! 471: } else ! 472: ATENABLE(s, aurpgen_lock); ! 473: ! 474: gbuf_freem(m); ! 475: } ! 476: ! 477: /* */ ! 478: int AURPgetri(next_entry, buf, len) ! 479: short next_entry; ! 480: unsigned char *buf; ! 481: short *len; ! 482: { ! 483: short entry_num = next_entry; ! 484: RT_entry *entry = (RT_entry *)&RT_table[next_entry]; ! 485: ! 486: for (*len=0; entry_num < RT_maxentry; entry_num++,entry++) { ! 487: if ((net_port != entry->NetPort) && ! 488: !(entry->AURPFlag & AURP_NetHiden)) { ! 489: if ((entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) { ! 490: if (entry->NetStart) { ! 491: /* route info for extended network */ ! 492: *(short *)buf = entry->NetStart; ! 493: buf += sizeof(short); ! 494: *buf++ = 0x80 | (entry->NetDist & 0x1F); ! 495: *(short *)buf = entry->NetStop; ! 496: buf += sizeof(short); ! 497: *buf++ = 0; ! 498: *len += 6; ! 499: } else { ! 500: /* route info for non-extended network */ ! 501: *(short *)buf = entry->NetStop; ! 502: buf += sizeof(short); ! 503: *buf++ = (entry->NetDist & 0x1F); ! 504: *len += 3; ! 505: } ! 506: } ! 507: } ! 508: if (*len > AURP_MaxPktSize) ! 509: break; ! 510: } ! 511: ! 512: return (entry_num == RT_maxentry) ? 0 : entry_num; ! 513: } ! 514: ! 515: /* */ ! 516: int AURPsetri(node, m) ! 517: unsigned char node; ! 518: gbuf_t *m; ! 519: { ! 520: int tuples_cnt; ! 521: unsigned char *tuples_ptr; ! 522: RT_entry new_rt, *curr_rt; ! 523: ! 524: new_rt.NextIRNet = 0; ! 525: new_rt.NextIRNode = node; ! 526: new_rt.NetPort = net_port; ! 527: ! 528: /* ! 529: * Process all the tuples against our routing table ! 530: */ ! 531: tuples_ptr = (char *)gbuf_rptr(m); ! 532: tuples_cnt = (gbuf_len(m))/3; ! 533: ! 534: while (tuples_cnt--) { ! 535: new_rt.NetDist = TUPLEDIST(tuples_ptr) + 1; ! 536: new_rt.EntryState = RTE_STATE_GOOD; ! 537: new_rt.NetStart = TUPLENET(tuples_ptr); ! 538: tuples_ptr += 3; ! 539: if (tuples_ptr[-1] & 0x80) { ! 540: new_rt.NetStop = TUPLENET((tuples_ptr)); ! 541: tuples_ptr += 3; ! 542: tuples_cnt--; ! 543: } else { ! 544: new_rt.NetStop = new_rt.NetStart; ! 545: new_rt.NetStart = 0; ! 546: } ! 547: if ((new_rt.NetStop == 0) || (new_rt.NetStop < new_rt.NetStart)) { ! 548: dPrintf(D_M_AURP, D_L_WARNING, ! 549: ("AURPsetri: %d, invalid tuple received [%d-%d]\n", ! 550: net_port, new_rt.NetStart, new_rt.NetStop)); ! 551: continue; ! 552: } ! 553: ! 554: if ((curr_rt = rt_blookup(new_rt.NetStop)) != 0) { /* found? */ ! 555: /* ignore loop if present */ ! 556: if (curr_rt->NetPort != net_port) ! 557: continue; ! 558: ! 559: if (new_rt.NetDist < 16) { ! 560: /* ! 561: * check if the definition of the route has changed ! 562: */ ! 563: if ((new_rt.NetStop != curr_rt->NetStop) || ! 564: (new_rt.NetStart != curr_rt->NetStart)) { ! 565: if ((new_rt.NetStop == curr_rt->NetStop) && ! 566: (new_rt.NetStop == curr_rt->NetStart) && ! 567: (new_rt.NetStart == 0)) { ! 568: new_rt.NetStart = new_rt.NetStop; ! 569: } else if ((new_rt.NetStop == curr_rt->NetStop) && ! 570: (new_rt.NetStart == new_rt.NetStop) && ! 571: (curr_rt->NetStart == 0)) { ! 572: dPrintf(D_M_AURP, D_L_WARNING, ! 573: ("AURPsetri: [%d-%d] has changed to [%d-%d], Dist=%d\n", ! 574: curr_rt->NetStart, curr_rt->NetStop, ! 575: new_rt.NetStart, new_rt.NetStop, new_rt.NetDist)); ! 576: new_rt.NetStart = 0; ! 577: } else { ! 578: dPrintf(D_M_AURP, D_L_WARNING, ! 579: ("AURPsetri: Net Conflict, Curr=[%d-%d], New=[%d-%d]\n", ! 580: curr_rt->NetStart,curr_rt->NetStop, ! 581: new_rt.NetStart,new_rt.NetStop)); ! 582: zt_remove_zones(curr_rt->ZoneBitMap); ! 583: rt_delete(curr_rt->NetStop, curr_rt->NetStart); ! 584: continue; ! 585: } ! 586: } ! 587: } ! 588: ! 589: if ((new_rt.NetDist <= curr_rt->NetDist) && ! 590: (new_rt.NetDist < 16)) { ! 591: /* ! 592: * found a shorter or more recent route, ! 593: * replace with the new entry ! 594: */ ! 595: curr_rt->NetDist = new_rt.NetDist; ! 596: curr_rt->NextIRNode = new_rt.NextIRNode; ! 597: dPrintf(D_M_AURP_LOW,D_L_INFO, ! 598: ("AURPsetri: shorter route found [%d-%d], update\n", ! 599: new_rt.NetStart,new_rt.NetStop)); ! 600: } ! 601: ! 602: } else { /* no entry found */ ! 603: if (new_rt.NetDist < 16) { ! 604: new_rt.EntryState = RTE_STATE_GOOD; ! 605: dPrintf(D_M_AURP, D_L_INFO, ! 606: ("AURPsetri: new_rt [%d-%d], tuple #%d\n", ! 607: new_rt.NetStart, new_rt.NetStop, tuples_cnt)); ! 608: if (rt_insert(new_rt.NetStop, new_rt.NetStart, ! 609: new_rt.NextIRNet, new_rt.NextIRNode, ! 610: new_rt.NetDist, new_rt.NetPort, ! 611: new_rt.EntryState) == (RT_entry *)0) { ! 612: dPrintf(D_M_AURP,D_L_ERROR, ! 613: ("AURPsetri: RTMP table full [%d-%d]\n", ! 614: new_rt.NetStart,new_rt.NetStop)); ! 615: return -1; ! 616: } ! 617: } ! 618: } ! 619: } /* end of main while */ ! 620: ! 621: return 0; ! 622: } ! 623: ! 624: /* */ ! 625: int AURPupdateri(node, m) ! 626: unsigned char node; ! 627: gbuf_t *m; ! 628: { ! 629: char ev, ev_len; ! 630: RT_entry new_rt, *old_rt; ! 631: ! 632: while (gbuf_len(m) > 0) { ! 633: ev = *gbuf_rptr(m); /* event code */ ! 634: gbuf_rinc(m,1); ! 635: if (gbuf_rptr(m)[2] & 0x80) { ! 636: /* event tuple for extended network */ ! 637: new_rt.NetStart = *(unsigned short *)gbuf_rptr(m); ! 638: new_rt.NetStop = *(unsigned short *)&gbuf_rptr(m)[3]; ! 639: new_rt.NetDist = gbuf_rptr(m)[2] & 0x7f; ! 640: ev_len = 5; ! 641: } else { ! 642: /* event tuple for non-extended network */ ! 643: new_rt.NetStart = 0; ! 644: new_rt.NetStop = *(unsigned short *)gbuf_rptr(m); ! 645: new_rt.NetDist = gbuf_rptr(m)[2]; ! 646: ev_len = 3; ! 647: } ! 648: ! 649: switch (ev) { ! 650: case AURPEV_Null: ! 651: break; ! 652: ! 653: case AURPEV_NetAdded: ! 654: gbuf_rinc(m,ev_len); ! 655: new_rt.NextIRNet = 0; ! 656: new_rt.NextIRNode = node; ! 657: new_rt.NetPort = net_port; ! 658: if ((new_rt.NetDist == 0) || (new_rt.NetStop == 0) || ! 659: (new_rt.NetStop < new_rt.NetStart)) { ! 660: dPrintf(D_M_AURP,D_L_WARNING, ! 661: ("AURPupdateri: %d, invalid NetAdded received [%d-%d]\n", ! 662: net_port, new_rt.NetStart, new_rt.NetStop)); ! 663: break; ! 664: } ! 665: ! 666: if ((old_rt = rt_blookup(new_rt.NetStop)) != 0) { /* found? */ ! 667: if (old_rt->NetPort == net_port) { ! 668: /* ! 669: * process this event as if it was an NDC event; ! 670: * update the route's distance ! 671: */ ! 672: old_rt->NetDist = new_rt.NetDist; ! 673: } ! 674: } else { ! 675: l_add: if ((new_rt.NetDist < 16) && (new_rt.NetDist != NOTIFY_N_DIST)) { ! 676: new_rt.EntryState = RTE_STATE_GOOD; ! 677: dPrintf(D_M_AURP, D_L_INFO, ! 678: ("AURPupdateri: NetAdded [%d-%d]\n", ! 679: new_rt.NetStart, new_rt.NetStop)); ! 680: if (rt_insert(new_rt.NetStop, new_rt.NetStart, ! 681: new_rt.NextIRNet, new_rt.NextIRNode, ! 682: new_rt.NetDist, new_rt.NetPort, ! 683: new_rt.EntryState) == (RT_entry *)0) { ! 684: dPrintf(D_M_AURP, D_L_WARNING, ! 685: ("AURPupdateri: RTMP table full [%d-%d]\n", ! 686: new_rt.NetStart,new_rt.NetStop)); ! 687: return 0; ! 688: } ! 689: } ! 690: } ! 691: break; ! 692: ! 693: case AURPEV_NetDeleted: ! 694: case AURPEV_NetRouteChange: ! 695: gbuf_rinc(m,ev_len); ! 696: l_delete: if ((old_rt = rt_blookup(new_rt.NetStop)) != 0) { /* found? */ ! 697: if (old_rt->NetPort == net_port) { ! 698: zt_remove_zones(old_rt->ZoneBitMap); ! 699: rt_delete(old_rt->NetStop, old_rt->NetStart); ! 700: } ! 701: } ! 702: break; ! 703: ! 704: case AURPEV_NetDistChange: ! 705: gbuf_rinc(m,ev_len); ! 706: if (new_rt.NetDist == 15) ! 707: goto l_delete; /* process this event as if was an ND event */ ! 708: if ((old_rt = rt_blookup(new_rt.NetStop)) != 0) { /* found? */ ! 709: if (old_rt->NetPort == net_port) { ! 710: /* ! 711: * update the route's distance ! 712: */ ! 713: old_rt->NetDist = new_rt.NetDist; ! 714: } ! 715: } else ! 716: goto l_add; /* process this event as if was an NA event */ ! 717: break; ! 718: ! 719: case AURPEV_NetZoneChange: ! 720: break; ! 721: } ! 722: } ! 723: ! 724: return 0; ! 725: } ! 726: ! 727: /* */ ! 728: void AURPpurgeri(node) ! 729: unsigned char node; ! 730: { ! 731: short entry_num; ! 732: RT_entry *entry = (RT_entry *)RT_table; ! 733: ! 734: /* ! 735: * purge all routes associated with the tunnel peer ! 736: */ ! 737: for (entry_num=0; entry_num < RT_maxentry; entry_num++,entry++) { ! 738: if ((net_port == entry->NetPort) && (node == entry->NextIRNode)) { ! 739: zt_remove_zones(entry->ZoneBitMap); ! 740: rt_delete(entry->NetStop, entry->NetStart); ! 741: } ! 742: } ! 743: } ! 744: ! 745: /* */ ! 746: void AURPrtupdate(entry, ev) ! 747: RT_entry *entry; ! 748: unsigned char ev; ! 749: { ! 750: unsigned char i, node, ev_len, ev_tuple[6]; ! 751: gbuf_t *m; ! 752: aurp_state_t *state = (aurp_state_t *)&aurp_state[1]; ! 753: int s, msize = sizeof(aurp_hdr_t); ! 754: ! 755: dPrintf(D_M_AURP, D_L_TRACE, ("AURPrtupdate: event=%d, net=[%d-%d]\n", ! 756: ev, entry->NetStart, entry->NetStop)); ! 757: ! 758: /* ! 759: * check that the network can be exported; if not, ! 760: * we must not make it visible beyond the local networks ! 761: */ ! 762: if (net_export) { ! 763: for (i=0; i < net_access_cnt; i++) { ! 764: if ((net_access[i] == entry->NetStart) || ! 765: (net_access[i] == entry->NetStop)) ! 766: break; ! 767: } ! 768: if (i == net_access_cnt) ! 769: return; ! 770: } else { ! 771: for (i=0; i < net_access_cnt; i++) { ! 772: if ((net_access[i] == entry->NetStart) || ! 773: (net_access[i] == entry->NetStop)) ! 774: return; ! 775: } ! 776: } ! 777: ! 778: /* ! 779: * create the update event tuple ! 780: */ ! 781: ev_tuple[0] = ev; /* event code */ ! 782: if (entry->NetStart) { ! 783: *(unsigned short *)&ev_tuple[1] = entry->NetStart; ! 784: ev_tuple[3] = 0x80 | (entry->NetDist & 0x1F); ! 785: *(unsigned short *)&ev_tuple[4] = entry->NetStop; ! 786: ev_len = 6; ! 787: } else { ! 788: *(unsigned short *)&ev_tuple[1] = entry->NetStop; ! 789: ev_tuple[3] = (entry->NetDist & 0x1F); ! 790: ev_len = 4; ! 791: } ! 792: ! 793: for (node=1; node <= dst_addr_cnt; node++, state++) { ! 794: if ((ev == AURPEV_NetAdded) && ! 795: (!(state->snd_sui & AURPFLG_NA))) continue; ! 796: if ((ev == AURPEV_NetDeleted) && ! 797: (!(state->snd_sui & AURPFLG_ND))) continue; ! 798: if ((ev == AURPEV_NetDistChange) && ! 799: (!(state->snd_sui & AURPFLG_NDC))) continue; ! 800: ATDISABLE(s, aurpgen_lock); ! 801: if ((state->snd_state != AURPSTATE_Unconnected) && ! 802: (state->snd_state != AURPSTATE_WaitingForRIAck2)) { ! 803: if ((m = state->upd_m) == 0) { ! 804: /* ! 805: * we don't have the RI update buffer yet, allocate one ! 806: */ ! 807: ATENABLE(s, aurpgen_lock); ! 808: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_HI)) == 0) ! 809: continue; ! 810: ATDISABLE(s, aurpgen_lock); ! 811: state->upd_m = m; ! 812: gbuf_rinc(m,msize); ! 813: gbuf_wset(m,0); ! 814: } ! 815: ! 816: /* ! 817: * add the update event tuple to the RI update buffer; ! 818: * the RI update buffer will be sent when the periodic update ! 819: * timer expires ! 820: */ ! 821: bcopy(ev_tuple, gbuf_wptr(m), ev_len); ! 822: gbuf_winc(m,ev_len); ! 823: ! 824: /* ! 825: * if the RI update buffer is full, send the RI update now ! 826: */ ! 827: if (gbuf_len(m) > (AURP_MaxPktSize-6)) { ! 828: ATENABLE(s, aurpgen_lock); ! 829: AURPsndRIUpd(state); ! 830: continue; ! 831: } ! 832: } ! 833: ATENABLE(s, aurpgen_lock); ! 834: } ! 835: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.