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