![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aurp_zi.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_zi.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: zi.c
36: */
37: #include <sysglue.h>
38: #include <at/appletalk.h>
39: #include <lap.h>
40: #include <routing_tables.h>
41: #define _AURP
42: #include <at_aurp.h>
43: #include <at/aurp.h>
44:
45: /* */
46: void AURPsndZReq(state)
47: aurp_state_t *state;
48: {
49: gbuf_t *m;
50: int msize;
51: aurp_hdr_t *hdrp;
52: short *net, nets_cnt, net_sent=0, entry_num=0;
53: RT_entry *entry = RT_table;
54:
55: if (!state->get_zi || (state->rcv_state == AURPSTATE_Unconnected))
56: return;
57:
58: l_more:
59: msize = sizeof(aurp_hdr_t);
60: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
61: dPrintf(D_M_AURP, D_L_WARNING, ("AURPsndZReq: node=%d, out of mblk\n",
62: state->rem_node));
63: return;
64: }
65: gbuf_wset(m,msize);
66:
67: /* construct the ZI request packet */
68: hdrp = (aurp_hdr_t *)gbuf_rptr(m);
69: hdrp->connection_id = state->rcv_connection_id;
70: hdrp->sequence_number = 0;
71: hdrp->command_code = AURPCMD_ZReq;
72: hdrp->flags = 0;
73: *(short *)(hdrp+1) = AURPSUBCODE_ZoneInfo1;
74: gbuf_winc(m,sizeof(short));
75:
76: net = (short *)gbuf_wptr(m);
77: nets_cnt = 0;
78:
79: while (entry_num < RT_maxentry) {
80: /*
81: * scan the router table, and build the ZI request packet
82: * with the right entries, i.e.,
83: * - entry in use and not of the net_port
84: * - with no zones and in an active state
85: * - talking to the right router
86: */
87: if ( (entry->NetPort == net_port) && entry->NetStop &&
88: ((entry->EntryState & 0x0F) >= RTE_STATE_SUSPECT) &&
89: (!RT_ALL_ZONES_KNOWN(entry)) ) {
90: *net++ = (entry->NetStart) ? entry->NetStart : entry->NetStop;
91: nets_cnt++;
92: }
93:
94: if (nets_cnt >= 640) {
95: /* query only 640 networks per packet */
96: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndZReq: node=%d\n",
97: state->rem_node));
98: gbuf_winc(m,(nets_cnt * sizeof(short)));
99: AURPsend(m, AUD_AURP, state->rem_node);
100: net_sent = 1;
101: goto l_more;
102: }
103:
104: entry_num++;
105: entry++;
106: }
107:
108: if (nets_cnt) {
109: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndZReq: node=%d\n",
110: state->rem_node));
111: gbuf_winc(m,(nets_cnt * sizeof(short)));
112: AURPsend(m, AUD_AURP, state->rem_node);
113: net_sent = 1;
114: } else
115: gbuf_freeb(m);
116:
117: if (!net_sent)
118: state->get_zi = 0;
119: }
120:
121: /* */
122: void AURPsndZRsp(state, dat_m, flag)
123: aurp_state_t *state;
124: gbuf_t *dat_m;
125: int flag;
126: {
127: short len;
128: int msize, next_entry = 0;
129: gbuf_t *m;
130: aurp_hdr_t *hdrp;
131:
132: if ((state->snd_state == AURPSTATE_Unconnected) || (dat_m == 0))
133: return;
134: msize = sizeof(aurp_hdr_t);
135:
136: do {
137: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
138: dPrintf(D_M_AURP, D_L_WARNING, ("AURPsndZRsp: node=%d, out of mblk\n",
139: state->rem_node));
140: return;
141: }
142: gbuf_wset(m,msize);
143:
144: /* construct the ZI response packet */
145: hdrp = (aurp_hdr_t *)gbuf_rptr(m);
146: hdrp->connection_id = state->snd_connection_id;
147: hdrp->sequence_number = 0;
148: hdrp->command_code = AURPCMD_ZRsp;
149: hdrp->flags = 0;
150:
151: /* get zone info of the local networks */
152: next_entry = AURPgetzi(next_entry, gbuf_wptr(m), &len, dat_m, flag);
153: gbuf_winc(m,len);
154:
155: /* send the packet */
156: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndZRsp: len=%d\n", len));
157: AURPsend(m, AUD_AURP, state->rem_node);
158:
159: } while (next_entry);
160:
161: gbuf_freem(dat_m);
162: }
163:
164: /* */
165: void AURPsndGZN(state, dat_m)
166: aurp_state_t *state;
167: gbuf_t *dat_m;
168: {
169: short zname_len;
170: int msize;
171: gbuf_t *m;
172: aurp_hdr_t *hdrp;
173:
174: if (state->snd_state == AURPSTATE_Unconnected)
175: return;
176:
177: msize = sizeof(aurp_hdr_t);
178: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
179: dPrintf(D_M_AURP, D_L_WARNING, ("AURPsndGZN: node=%d, out of mblk\n",
180: state->rem_node));
181: return;
182: }
183: gbuf_wset(m,msize);
184:
185: /* construct the GZN response packet */
186: hdrp = (aurp_hdr_t *)gbuf_rptr(m);
187: hdrp->connection_id = state->snd_connection_id;
188: hdrp->sequence_number = 0;
189: hdrp->command_code = AURPCMD_ZRsp;
190: hdrp->flags = 0;
191: *(short *)(gbuf_wptr(m)) = AURPSUBCODE_GetZoneNets;
192: gbuf_winc(m,sizeof(short));
193: zname_len = gbuf_len(dat_m);
194: bcopy(gbuf_rptr(dat_m), gbuf_wptr(m), zname_len);
195: gbuf_winc(m,zname_len);
196: *(short *)(gbuf_wptr(m)) = -1; /* number of tuples - proto not supported */
197: gbuf_winc(m,sizeof(short));
198:
199: /* send the packet */
200: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndGZN: count=%d\n", -1));
201: AURPsend(m, AUD_AURP, state->rem_node);
202: }
203:
204: /* */
205: void AURPsndGDZL(state, dat_m)
206: aurp_state_t *state;
207: gbuf_t *dat_m;
208: {
209: int msize;
210: gbuf_t *m;
211: aurp_hdr_t *hdrp;
212:
213: if (state->snd_state == AURPSTATE_Unconnected)
214: return;
215:
216: msize = sizeof(aurp_hdr_t);
217: if ((m = (gbuf_t *)gbuf_alloc(msize+AURP_MaxPktSize, PRI_MED)) == 0) {
218: dPrintf(D_M_AURP, D_L_WARNING, ("AURPsndGDZL: node=%d, out of mblk\n",
219: state->rem_node));
220: return;
221: }
222: gbuf_wset(m,msize);
223:
224: /* construct the GDZL response packet */
225: hdrp = (aurp_hdr_t *)gbuf_rptr(m);
226: hdrp->connection_id = state->snd_connection_id;
227: hdrp->sequence_number = 0;
228: hdrp->command_code = AURPCMD_ZRsp;
229: hdrp->flags = 0;
230: *(short *)(gbuf_wptr(m)) = AURPSUBCODE_GetDomainZoneList;
231: gbuf_winc(m,sizeof(short));
232: *(short *)(gbuf_wptr(m)) = -1; /* start index - proto not supported */
233: gbuf_winc(m,sizeof(short));
234:
235: /* send the packet */
236: dPrintf(D_M_AURP, D_L_INFO, ("AURPsndGDZL: index=%d\n", -1));
237: AURPsend(m, AUD_AURP, state->rem_node);
238: }
239:
240: /* */
241: void AURPrcvZReq(state, m)
242: aurp_state_t *state;
243: gbuf_t *m;
244: {
245: short sub_code;
246: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
247:
248: /* make sure we're in a valid state to accept it */
249: if (state->snd_state == AURPSTATE_Unconnected) {
250: dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvZReq: unexpected response\n"));
251: gbuf_freem(m);
252: return;
253: }
254:
255: /* check for the correct connection id */
256: if (hdrp->connection_id != state->snd_connection_id) {
257: dPrintf(D_M_AURP, D_L_WARNING,
258: ("AURPrcvZReq: invalid connection id, r=%d, m=%d\n",
259: hdrp->connection_id, state->snd_connection_id));
260: gbuf_freem(m);
261: return;
262: }
263:
264: gbuf_rinc(m,sizeof(*hdrp));
265: sub_code = *(short *)gbuf_rptr(m);
266: gbuf_rinc(m,sizeof(short));
267:
268: dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvZReq: len=%d\n", gbuf_len(m)));
269:
270: switch (sub_code) {
271: case AURPSUBCODE_ZoneInfo1:
272: AURPsndZRsp(state, m, 0);
273: return;
274:
275: case AURPSUBCODE_GetZoneNets:
276: AURPsndGZN(state, m);
277: break;
278:
279: case AURPSUBCODE_GetDomainZoneList:
280: AURPsndGDZL(state, m);
281: break;
282: }
283:
284: gbuf_freem(m);
285: }
286:
287: /* */
288: void AURPrcvZRsp(state, m)
289: aurp_state_t *state;
290: gbuf_t *m;
291: {
292: short sub_code, tuples_cnt;
293: aurp_hdr_t *hdrp = (aurp_hdr_t *)gbuf_rptr(m);
294:
295: /* make sure we're in a valid state to accept it */
296: if (state->rcv_state == AURPSTATE_Unconnected) {
297: dPrintf(D_M_AURP, D_L_WARNING, ("AURPrcvZRsp: unexpected response\n"));
298: gbuf_freem(m);
299: return;
300: }
301:
302: /* check for the correct connection id */
303: if (hdrp->connection_id != state->rcv_connection_id) {
304: dPrintf(D_M_AURP, D_L_WARNING,
305: ("AURPrcvZRsp: invalid connection id, r=%d, m=%d\n",
306: hdrp->connection_id, state->rcv_connection_id));
307: gbuf_freem(m);
308: return;
309: }
310:
311: gbuf_rinc(m,sizeof(*hdrp));
312: sub_code = *(short *)gbuf_rptr(m);
313: gbuf_rinc(m,sizeof(short));
314:
315: dPrintf(D_M_AURP, D_L_INFO, ("AURPrcvZRsp: len=%d\n", gbuf_len(m)));
316:
317: switch (sub_code) {
318: case AURPSUBCODE_ZoneInfo1:
319: case AURPSUBCODE_ZoneInfo2:
320: tuples_cnt = *(short *)gbuf_rptr(m);
321: gbuf_rinc(m,sizeof(short));
322: if (AURPsetzi(state->rem_node, m, sub_code, tuples_cnt)) {
323: dPrintf(D_M_AURP, D_L_ERROR,
324: ("AURPrcvZRsp: AURPsetzi() error\n"));
325: }
326: break;
327:
328: case AURPSUBCODE_GetZoneNets:
329: break;
330:
331: case AURPSUBCODE_GetDomainZoneList:
332: break;
333: }
334:
335: gbuf_freem(m);
336: }
337:
338: /* */
339: int AURPgetzi(next_entry, buf, len, dat_m, flag)
340: int next_entry;
341: unsigned char *buf;
342: short *len;
343: gbuf_t *dat_m;
344: int flag;
345: {
346: static int i_sav=ZT_BYTES-1, j_sav=0, idx_sav=-1;
347: unsigned char ev, zname_len, *zmap, *zname_base, *zname_sav, *tuples_ptr;
348: unsigned short net_num, *net, zname_offset;
349: short *sub_codep, *tuples_cntp, tuples_cnt, dat_len;
350: int i, j, idx, nets_cnt;
351: RT_entry *entry;
352:
353: sub_codep = (short *)buf;
354: buf += sizeof(short);
355: tuples_cntp = (short *)buf;
356: buf += sizeof(short);
357: *len = sizeof(short) + sizeof(short);
358: zname_base = buf + sizeof(short);
359: dat_len = 0;
360:
361: /* set the subcode in the ZI response packet */
362: *sub_codep = next_entry ? AURPSUBCODE_ZoneInfo2 : AURPSUBCODE_ZoneInfo1;
363:
364: switch (flag) {
365: case 0: /* zone info in response to ZI request */
366: net = (unsigned short *)gbuf_rptr(dat_m);
367: nets_cnt = (gbuf_len(dat_m))/2;
368: break;
369: case 1: /* zone info in response to Ack of RI response */
370: tuples_ptr = gbuf_rptr(dat_m);
371: nets_cnt = (gbuf_len(dat_m))/3;
372: next_entry = 0;
373: break;
374: case 2: /* zone info in response to Ack of RI update */
375: tuples_ptr = gbuf_rptr(dat_m);
376: nets_cnt = (gbuf_len(dat_m))/4;
377: next_entry = 0;
378: break;
379: }
380:
381: /*
382: * for each network, find all the zones that it belongs to
383: */
384: for (tuples_cnt=0; next_entry < nets_cnt; next_entry++) {
385: switch(flag) {
386: case 0:
387: net_num = net[next_entry];
388: break;
389: case 1:
390: net_num = *(unsigned short *)tuples_ptr;
391: tuples_ptr += 3;
392: gbuf_rinc(dat_m,3);
393: if (tuples_ptr[-1] & 0x80) {
394: tuples_ptr += 3;
395: gbuf_rinc(dat_m,3);
396: next_entry++;
397: }
398: break;
399: case 2:
400: if (gbuf_len(dat_m) <= 0) {
401: next_entry = nets_cnt;
402: goto l_done;
403: }
404: ev = *tuples_ptr++;
405: net_num = *(unsigned short *)tuples_ptr;
406: tuples_ptr += 3;
407: gbuf_rinc(dat_m,4);
408: if (tuples_ptr[-1] & 0x80) {
409: tuples_ptr += 2;
410: gbuf_rinc(dat_m,2);
411: }
412: if (ev != AURPEV_NetAdded)
413: continue;
414: break;
415: }
416:
417: /*
418: * find the RT entry associated with the network
419: */
420: if ((entry = RT_lookup(net_num)) == 0) {
421: dPrintf(D_M_AURP, D_L_WARNING, ("AURPgetzi: invalid net, %d\n",
422: net_num));
423: continue;
424: }
425: if ( ((entry->EntryState & 0x0F) < RTE_STATE_SUSPECT) ||
426: !RT_ALL_ZONES_KNOWN(entry) ||
427: (entry->AURPFlag & AURP_NetHiden) ) {
428: dPrintf(D_M_AURP_LOW, D_L_INFO, ("AURPgetzi: zombie net, net=%d\n",
429: net_num));
430: continue;
431: }
432:
433: if (entry->NetStart == 0) {
434: if ((idx = ZT_get_zindex(entry->ZoneBitMap)) == 0)
435: continue;
436: idx--; /* index in the zone table */
437: zname_len = ZT_table[idx].Zone.len;
438: if (zname_len) {
439: *(unsigned short *)buf = net_num;
440: buf += sizeof(short);
441: if (idx == idx_sav) {
442: /* use the optimized format */
443: zname_offset = zname_sav - zname_base;
444: *(unsigned short *)buf = (0x8000 | zname_offset);
445: buf += sizeof(short);
446: dat_len += 4;
447: } else {
448: /* use the long format */
449: zname_sav = buf;
450: *buf++ = zname_len;
451: bcopy(ZT_table[idx].Zone.str, buf, zname_len);
452: buf += zname_len;
453: dat_len += (3 + zname_len);
454: }
455: tuples_cnt++;
456: idx_sav = idx;
457: }
458:
459: } else {
460: zmap = entry->ZoneBitMap;
461: for (i=i_sav; i >=0; i--) {
462: if (!zmap[i])
463: continue;
464:
465: for (j=j_sav; j < 8; j++) {
466: if (!((zmap[i] << j) & 0x80))
467: continue;
468:
469: idx = i*8 + j; /* index in the zone table */
470: zname_len = ZT_table[idx].Zone.len;
471: if (zname_len) {
472: if ((dat_len+3+zname_len) > AURP_MaxPktSize) {
473: i_sav = i;
474: j_sav = j;
475: goto l_done;
476: }
477:
478: *(unsigned short *)buf = net_num;
479: buf += sizeof(short);
480: if (idx == idx_sav) {
481: /* use the optimized format */
482: zname_offset = zname_sav - zname_base;
483: *(unsigned short *)buf = (0x8000 | zname_offset);
484: buf += sizeof(short);
485: dat_len += 4;
486: } else {
487: /* use the long format */
488: zname_sav = buf;
489: *buf++ = zname_len;
490: bcopy(ZT_table[idx].Zone.str, buf, zname_len);
491: buf += zname_len;
492: dat_len += (3 + zname_len);
493: }
494: tuples_cnt++;
495: idx_sav = idx;
496: }
497: }
498: }
499: }
500: if ((dat_len+3+32) > AURP_MaxPktSize) {
501: next_entry++;
502: break;
503: }
504: }
505: i_sav = ZT_BYTES-1;
506: j_sav = 0;
507:
508: l_done:
509: *len += dat_len;
510: if (next_entry == nets_cnt)
511: next_entry = 0;
512:
513: /* set the subcode in the ZI response packet */
514: if (next_entry)
515: *sub_codep = AURPSUBCODE_ZoneInfo2;
516:
517: /* set the tuples count in the ZI response packet */
518: *tuples_cntp = tuples_cnt;
519:
520: idx_sav = -1;
521: return next_entry;
522: }
523:
524: /* */
525: int AURPsetzi(node, m, sub_code, tuples_cnt)
526: unsigned char node;
527: gbuf_t *m;
528: short sub_code;
529: short tuples_cnt;
530: {
531: int rc, tuple_fmt;
532: unsigned short net_num, zname_offset;
533: unsigned char *buf = gbuf_rptr(m), *zname_base;
534: RT_entry *entry;
535: at_nvestr_t *zname;
536:
537: /* compute the base of the zone names of the optimized tuples */
538: zname_base = buf + sizeof(short);
539:
540: /* process all tuples */
541: while (tuples_cnt-- > 0) {
542: net_num = *(unsigned short *)buf;
543: buf += sizeof(short);
544: if (*buf & 0x80) {
545: /* optimized-format tuple */
546: zname_offset = (*(unsigned short *)buf) & 0x7fff;
547: buf += sizeof(short);
548: zname = (at_nvestr_t *)(zname_base + zname_offset);
549: tuple_fmt = 0;
550: dPrintf(D_M_AURP_LOW, D_L_INFO,
551: ("AURPsetzi: optimized fmt, net=%d. zlen=%d, zoffset=%d\n ",
552: net_num, zname->len, zname_offset));
553: } else {
554: /* long-format tuple */
555: zname = (at_nvestr_t *)buf;
556: tuple_fmt = 1;
557: dPrintf(D_M_AURP_LOW, D_L_INFO,
558: ("AURPsetzi: long fmt, net=%d, zlen=%d\n ",
559: net_num, zname->len));
560: }
561:
562: /*
563: * find the RT entry associated with the specified network
564: */
565: if ((entry = RT_lookup(net_num)) == 0) {
566: dPrintf(D_M_AURP, D_L_WARNING,
567: ("AURPsetzi: invalid net, net=%d\n", net_num));
568: } else { /* entry found */
569: if (entry->EntryState >= RTE_STATE_SUSPECT) {
570: if ((rc = ZT_add_zname(zname)) == ZT_MAXEDOUT) {
571: dPrintf(D_M_AURP, D_L_WARNING,
572: ("AURPsetzi: ZT_table full\n"));
573: } else {
574: ZT_set_zmap(rc, entry->ZoneBitMap);
575: RT_SET_ZONE_KNOWN(entry);
576: }
577: }
578: }
579: if (tuple_fmt)
580: buf += zname->len+1;
581: }
582: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.