]>
Commit | Line | Data |
---|---|---|
1c79356b | 1 | /* |
8ad349bb | 2 | * Copyright (c) 2006 Apple Computer, Inc. All Rights Reserved. |
1c79356b | 3 | * |
8ad349bb | 4 | * @APPLE_LICENSE_OSREFERENCE_HEADER_START@ |
1c79356b | 5 | * |
8ad349bb A |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License | |
8 | * Version 2.0 (the 'License'). You may not use this file except in | |
9 | * compliance with the License. The rights granted to you under the | |
10 | * License may not be used to create, or enable the creation or | |
11 | * redistribution of, unlawful or unlicensed copies of an Apple operating | |
12 | * system, or to circumvent, violate, or enable the circumvention or | |
13 | * violation of, any terms of an Apple operating system software license | |
14 | * agreement. | |
15 | * | |
16 | * Please obtain a copy of the License at | |
17 | * http://www.opensource.apple.com/apsl/ and read it before using this | |
18 | * file. | |
19 | * | |
20 | * The Original Code and all software distributed under the License are | |
21 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER | |
22 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, | |
23 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, | |
24 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. | |
25 | * Please see the License for the specific language governing rights and | |
26 | * limitations under the License. | |
27 | * | |
28 | * @APPLE_LICENSE_OSREFERENCE_HEADER_END@ | |
1c79356b A |
29 | */ |
30 | /* | |
31 | * Copyright (c) 1988, 1989, 1997, 1998 Apple Computer, Inc. | |
32 | * | |
33 | * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX. | |
34 | */ | |
35 | ||
36 | #include <string.h> | |
37 | ||
38 | #include <sys/errno.h> | |
39 | #include <sys/types.h> | |
40 | #include <sys/param.h> | |
41 | #include <machine/spl.h> | |
42 | #include <sys/systm.h> | |
43 | #include <sys/kernel.h> | |
44 | #include <sys/proc.h> | |
45 | #include <sys/filedesc.h> | |
46 | #include <sys/fcntl.h> | |
47 | #include <sys/mbuf.h> | |
48 | #include <sys/ioctl.h> | |
49 | #include <sys/malloc.h> | |
50 | #include <sys/socket.h> | |
51 | #include <sys/socketvar.h> | |
52 | ||
53 | #include <net/if.h> | |
54 | #include <net/if_types.h> | |
55 | ||
56 | #include <netat/sysglue.h> | |
57 | #include <netat/appletalk.h> | |
58 | #include <netat/at_var.h> | |
59 | #include <netat/ddp.h> | |
60 | #include <netat/nbp.h> | |
61 | #include <netat/zip.h> | |
62 | #include <netat/rtmp.h> | |
63 | #include <netat/routing_tables.h> /* router */ | |
64 | #include <netat/at_snmp.h> | |
65 | #include <netat/at_pcb.h> | |
66 | #include <netat/debug.h> | |
67 | ||
68 | /* reaching for DDP and NBP headers in the datagram */ | |
69 | #define DATA_DDP(mp) ((at_ddp_t *)(gbuf_rptr(mp))) | |
70 | #define DATA_NBP(mp) ((at_nbp_t *)((DATA_DDP(mp))->data)) | |
71 | ||
72 | /* Get to the nve_entry_t part ofthe buffer */ | |
73 | #define NVE_ENTRY(mp) (nve_entry_t *)(gbuf_rptr(mp)) | |
74 | ||
75 | #ifndef MIN | |
76 | #define MIN(a,b) ((a)>(b)?(b):(a)) | |
77 | #endif | |
78 | ||
79 | #define errno nbperrno | |
1c79356b A |
80 | |
81 | /* externs */ | |
82 | extern at_ifaddr_t *ifID_table[]; | |
83 | extern at_ifaddr_t *ifID_home; | |
84 | ||
85 | TAILQ_HEAD(name_registry, _nve_) name_registry; | |
86 | ||
8ad349bb | 87 | atlock_t nve_lock; |
1c79356b A |
88 | |
89 | /* statics */ | |
90 | static int errno; | |
91 | static gbuf_t *lzones=0; /* head of local zones list */ | |
92 | static int lzonecnt=0; /* # zones stored in lzones */ | |
93 | static u_int hzonehash=0; /* hash val of home zone */ | |
94 | static int nve_lock_pri; | |
95 | ||
96 | static int nbp_lkup_reply(nbp_req_t *, nve_entry_t *); | |
97 | static int nbp_strcmp(at_nvestr_t *, at_nvestr_t *, u_char); | |
98 | static int nbp_setup_resp(nbp_req_t *, int); | |
99 | static int nbp_send_resp(nbp_req_t *); | |
100 | static int nbp_validate_n_hash(nbp_req_t *, int, int); | |
101 | static nve_entry_t *nbp_search_nve(); | |
102 | static int isZoneLocal(at_nvestr_t *); | |
103 | ||
104 | /* macros */ | |
105 | #define NVE_LOCK nve_lock | |
106 | ||
107 | /* prototypes */ | |
108 | void nbp_delete_entry(); | |
109 | extern int at_reg_mcast(); | |
110 | extern at_nvestr_t *getRTRLocalZone(zone_usage_t *); | |
111 | extern void nbp_add_multicast( at_nvestr_t *, at_ifaddr_t *); | |
112 | ||
113 | static long nbp_id_count = 0; | |
114 | ||
115 | void sethzonehash(elapp) | |
116 | at_ifaddr_t *elapp; | |
117 | { | |
118 | if (elapp->startup_zone.len) { | |
119 | hzonehash = nbp_strhash(&elapp->startup_zone); | |
120 | } | |
121 | } | |
122 | ||
123 | void nbp_shutdown() | |
124 | { | |
125 | /* delete all NVE's and release buffers */ | |
0b4e3aa0 | 126 | register nve_entry_t *nve_entry, *nve_next; |
1c79356b | 127 | |
8ad349bb A |
128 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
129 | for ((nve_entry = TAILQ_FIRST(&name_registry)); nve_entry; nve_entry = nve_next) { | |
130 | nve_next = TAILQ_NEXT(nve_entry, nve_link); | |
0b4e3aa0 A |
131 | |
132 | /* NB: nbp_delete_entry calls TAILQ_REMOVE */ | |
1c79356b A |
133 | nbp_delete_entry(nve_entry); |
134 | } | |
8ad349bb | 135 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
136 | |
137 | if (lzones) { | |
138 | gbuf_freem(lzones); | |
139 | lzonecnt = 0; | |
140 | lzones = NULL; | |
141 | } | |
142 | } /* nbp_shutdown */ | |
143 | ||
144 | static | |
145 | u_char *nbp2zone(nbp, maxp) | |
146 | at_nbp_t *nbp; | |
147 | u_char *maxp; | |
148 | { | |
149 | ||
150 | u_char *p; | |
151 | ||
152 | p = (u_char*)&nbp->tuple[0].enu_entity; /* p -> object */ | |
153 | if (p >= maxp) return NULL; | |
154 | p += (*p +1); /* p -> type */ | |
155 | if (p >= maxp) return NULL; | |
156 | p += (*p +1); /* p -> zone */ | |
157 | if (p >= maxp) return NULL; | |
158 | if ((p + *p) >= maxp) return NULL; | |
159 | return(p); | |
160 | } | |
161 | ||
162 | void nbp_input(m, ifID) | |
163 | register gbuf_t *m; | |
164 | register at_ifaddr_t *ifID; | |
165 | ||
166 | { | |
167 | register at_ddp_t *ddp = DATA_DDP(m); | |
168 | register at_nbp_t *nbp = DATA_NBP(m); | |
169 | register nve_entry_t *nve_entry, *next_nve; | |
170 | register RT_entry *rt; | |
171 | register int ddpSent = FALSE; /* true if we re-sent this pkt (don't free) */ | |
172 | struct etalk_addr mcastAddr; | |
173 | nbp_req_t nbp_req; | |
174 | u_char *p; | |
175 | ||
176 | /* from original nbp_input() when this function was nbp_handler() */ | |
177 | if ((gbuf_type(m) != MT_DATA && gbuf_type(m) != MSG_DATA) || | |
178 | ddp->type != DDP_NBP) { | |
179 | gbuf_freem(m); | |
180 | return; | |
181 | } | |
182 | ||
183 | /* Some initializations */ | |
184 | nbp_req.response = NULL; | |
185 | nbp_req.request = m; | |
186 | nbp_req.space_unused = nbp_req.flags = 0; | |
187 | ||
188 | dPrintf(D_M_NBP_LOW, D_L_USR1, | |
189 | ("nbp_input control:%d tuplecount:%d id:%d\n", | |
190 | nbp->control, nbp->tuple_count, nbp->at_nbp_id)); | |
191 | switch (nbp->control) { | |
192 | case NBP_LKUP : | |
193 | { | |
194 | at_net_al dst_net; | |
195 | ||
196 | dst_net = NET_VALUE(ddp->dst_net); | |
197 | dPrintf(D_M_NBP_LOW, D_L_USR2, (" LKUP %s\n", | |
198 | ifID != ifID_home ? "non-home" : "home")); | |
199 | if ( ROUTING_MODE && (NET_VALUE(ddp->dst_net) != 0) | |
200 | && ((dst_net < ifID->ifThisCableStart) | |
201 | || (dst_net > ifID->ifThisCableEnd)) ) { | |
202 | routing_needed(m, ifID, TRUE); | |
203 | ddpSent = TRUE; | |
204 | break; | |
205 | } | |
206 | } | |
207 | ||
208 | if (nbp_validate_n_hash (&nbp_req, TRUE, FALSE) == 0) { | |
209 | nbp_req.func = nbp_lkup_reply; | |
210 | (void) nbp_search_nve(&nbp_req, ifID); | |
211 | if (nbp_req.response) { | |
212 | nbp_send_resp(&nbp_req); | |
213 | } | |
214 | } | |
215 | #ifdef NBP_DEBUG | |
216 | { | |
217 | char zone[35],object[35],type[35]; | |
218 | strncpy(zone,nbp_req.nve.zone.str, nbp_req.nve.zone.len); | |
219 | strncpy(object,nbp_req.nve.object.str, nbp_req.nve.object.len); | |
220 | strncpy(type,nbp_req.nve.type.str, nbp_req.nve.type.len); | |
221 | object[nbp_req.nve.object.len] = '\0'; | |
222 | zone[nbp_req.nve.zone.len] = '\0'; | |
223 | type[nbp_req.nve.type.len] = '\0'; | |
224 | if (ifID != ifID_home) | |
225 | dPrintf(D_M_NBP_LOW,D_L_USR2, | |
226 | ("nbp_LKUP for:%s:%s@%s", object, type, zone)); | |
227 | } | |
228 | #endif /* NBP_DEBUG */ | |
229 | ||
230 | break; | |
231 | case NBP_FWDRQ: | |
232 | { | |
233 | register int zhome=0; | |
234 | /* true if home zone == destination zone */ | |
235 | register int zno, i; | |
236 | register gbuf_t *m2; | |
91447636 | 237 | register int error_found =0; |
1c79356b A |
238 | register at_ifaddr_t *ifIDorig; |
239 | ||
240 | if (!ROUTING_MODE) /* for routers only! */ | |
241 | break; | |
242 | ||
243 | ifIDorig = ifID; | |
244 | ifID= NULL; | |
245 | for (i = 0 ; i < RT_maxentry; i++) { | |
246 | rt = &RT_table[i]; | |
247 | if ((rt->EntryState & RTE_STATE_PERMANENT) && | |
248 | NET_VALUE(ddp->dst_net) >= rt->NetStart && | |
249 | NET_VALUE(ddp->dst_net) <= rt->NetStop | |
250 | ) { | |
251 | /* sanity check */ | |
252 | if (rt->NetPort >= IF_TOTAL_MAX) { | |
253 | dPrintf(D_M_NBP,D_L_ERROR, | |
254 | ("nbp_input:FWDREQ: bad port# from RT_table\n")); | |
255 | error_found = TRUE; | |
256 | break; | |
257 | } | |
258 | ifID = ifID_table[rt->NetPort]; | |
259 | if (!ifID) { | |
260 | dPrintf(D_M_NBP,D_L_ERROR, | |
261 | ("nbp_input:FWDREQ: ifID %s\n", | |
262 | !ifID ? "not found" : "invalid")); | |
263 | error_found = TRUE; | |
264 | break; | |
265 | } | |
266 | if (ifID->ifState == LAP_OFFLINE) { | |
267 | dPrintf(D_M_NBP,D_L_ERROR, | |
268 | ("nbp_input:FWDREQ: ifID offline (port %d)\n", | |
269 | rt->NetPort)); | |
270 | error_found = TRUE; | |
271 | break; | |
272 | } | |
273 | break; | |
274 | } | |
275 | } | |
276 | if (error_found) /* the port is not correct */ | |
277 | break; | |
278 | ||
279 | if (!ifID) { /* this packet is not for us, let the routing engine handle it */ | |
280 | routing_needed(m, ifIDorig, TRUE); | |
281 | ddpSent= TRUE; | |
282 | break; | |
283 | } | |
284 | ||
285 | /* | |
286 | * At this point, we have a valid Forward request for one of our | |
287 | * directly connected port. Convert it to a NBP Lookup | |
288 | */ | |
289 | ||
290 | nbp->control = NBP_LKUP; | |
291 | NET_ASSIGN(ddp->dst_net, 0); | |
292 | ddp->dst_node = 255; | |
293 | ||
294 | ||
295 | /*### LD 01/18/94 Check if the dest is also the home zone. */ | |
296 | ||
297 | p = nbp2zone(nbp, gbuf_wptr(m)); | |
298 | if ((p == NULL) || !(zno = zt_find_zname(p))) { | |
299 | dPrintf(D_M_NBP,D_L_WARNING, | |
300 | ("nbp_input: FWDRQ:zone not found\n")); | |
301 | break; | |
302 | } | |
303 | if (isZoneLocal((at_nvestr_t*)p)) | |
304 | zhome = TRUE; /* one of our ports is in destination zone */ | |
305 | if (!zt_get_zmcast(ifID, p, &mcastAddr)) { | |
306 | dPrintf(D_M_NBP,D_L_ERROR, | |
307 | ("nbp_input: FDWREQ:zt_get_zmcast error\n")); | |
308 | break; | |
309 | } | |
310 | ||
311 | ||
312 | if (zhome) { /*### LD 01/18/95 In case our home is here, call back nbp */ | |
313 | ||
314 | if (!(m2 = (gbuf_t *)gbuf_copym((gbuf_t *)m))) { | |
315 | dPrintf(D_M_NBP,D_L_ERROR, | |
316 | ("nbp_input: FWDRQ:gbuf_copym failed\n")); | |
317 | break; | |
318 | } | |
319 | ||
320 | ddp = DATA_DDP(m2); | |
321 | nbp = DATA_NBP(m2); | |
322 | nbp->control = NBP_LKUP; | |
323 | NET_ASSIGN(ddp->dst_net, 0); | |
324 | ddp->dst_node = 255; | |
325 | dPrintf(D_M_NBP,D_L_INFO, | |
326 | ("nbp_input: FWDRQ:loop back for us\n")); | |
327 | nbp_input(m2, ifID_home); | |
328 | } | |
329 | ||
330 | if (FDDI_OR_TOKENRING(ifID->aa_ifp->if_type)) | |
331 | ddp_bit_reverse(&mcastAddr); | |
332 | ddp_router_output(m, ifID, ET_ADDR,NULL,NULL, &mcastAddr); | |
333 | ddpSent = TRUE; | |
334 | } | |
335 | break; | |
336 | ||
337 | case NBP_BRRQ: | |
338 | { | |
339 | register int zno; /* zone table entry numb */ | |
340 | register int ztind; /* zone bitmap index into RT_entry */ | |
341 | register int ztbit; /* zone bit to check within above index */ | |
342 | register int zhome=0; /* true if home zone == destination zone */ | |
343 | register int i; | |
344 | register gbuf_t *m2, *m3; | |
345 | register int fromUs = FALSE; | |
346 | register at_socket ourSkt; /* originating skt */ | |
347 | ||
348 | /* for router & MH local only */ | |
349 | if ((!(MULTIHOME_MODE && FROM_US(ddp))) && !ROUTING_MODE) { | |
350 | dPrintf(D_M_NBP,D_L_USR2, | |
351 | ("nbp_input: BRREQ:non router or MH local\n")); | |
352 | ||
353 | break; | |
354 | } | |
355 | p = nbp2zone(nbp, gbuf_wptr(m)); | |
356 | if ((p == NULL) || !(zno = zt_find_zname(p))) { | |
357 | break; | |
358 | } | |
359 | if (MULTIHOME_MODE && ifID->ifRouterState == NO_ROUTER) { | |
360 | ((at_nvestr_t*)p)->len = 1; | |
361 | ((at_nvestr_t*)p)->str[0] = '*'; | |
362 | } | |
363 | if (isZoneLocal((at_nvestr_t*)p)) { | |
364 | zhome = TRUE; /* one of our ports is in destination zone */ | |
365 | } | |
366 | if (FROM_US(ddp)){ /* save, before we munge it */ | |
367 | fromUs = TRUE; | |
368 | ourSkt = ddp->src_socket; | |
369 | dPrintf(D_M_NBP,D_L_USR2, | |
370 | ("nbp_input:BRRQ from us net:%d\n", | |
371 | (int)NET_VALUE(ddp->src_net))); | |
372 | } | |
373 | /* from ZT_CLR_ZMAP */ | |
374 | i = zno - 1; | |
375 | ztind = i >> 3; | |
376 | ztbit = 0x80 >> (i % 8); | |
377 | for (i=0,rt=RT_table; i<RT_maxentry; i++,rt++) { | |
378 | if (!(rt->ZoneBitMap[ztind] & ztbit)) /* if zone not in route, skip*/ | |
379 | continue; | |
380 | /* dPrintf(D_M_NBP, D_L_USR3, | |
381 | ("nbp_input: BRREQ: port:%d, entry %d\n", | |
382 | rt->NetPort, i)); | |
383 | */ | |
384 | ||
385 | ifID = ifID_table[rt->NetPort]; | |
386 | if (!ifID) { | |
387 | dPrintf(D_M_NBP, D_L_ERROR, | |
388 | ("nbp_input:BRRQ: ifID %s\n", | |
389 | !ifID ? "not found" : "invalid")); | |
390 | break; | |
391 | } | |
392 | ||
393 | ddp = DATA_DDP(m); | |
394 | ddp->src_node = ifID->ifThisNode.s_node; | |
395 | NET_ASSIGN(ddp->src_net, ifID->ifThisNode.s_net); | |
396 | ddp->src_socket = NBP_SOCKET; | |
397 | if (!(m2 = (gbuf_t *)gbuf_copym((gbuf_t *)m))) { | |
398 | dPrintf(D_M_NBP,D_L_ERROR, | |
399 | ("nbp_input: BRREQ:gbuf_copym failed\n")); | |
400 | break; | |
401 | } | |
402 | ||
403 | ddp = DATA_DDP(m2); | |
404 | nbp = DATA_NBP(m2); | |
405 | /* nbp->tuple[0].enu_addr.socket = NBP_SOCKET; */ | |
406 | if (MULTIHOME_MODE && fromUs ) { | |
407 | /* set the return address of the lookup to that of the | |
408 | interface it's going out on so that replies come back | |
409 | on that net */ | |
410 | dPrintf(D_M_NBP,D_L_USR3, | |
411 | ("nbp_input: BRREQ: src changed to %d.%d.%d\n", | |
412 | ifID->ifThisNode.s_net, | |
413 | ifID->ifThisNode.s_node, ourSkt)); | |
8ad349bb | 414 | nbp->tuple[0].enu_addr.net = ifID->ifThisNode.s_net; |
1c79356b A |
415 | nbp->tuple[0].enu_addr.node = ifID->ifThisNode.s_node; |
416 | nbp->tuple[0].enu_addr.socket = ourSkt; | |
417 | ddp->src_socket = NBP_SOCKET; | |
418 | } | |
419 | else | |
420 | dPrintf(D_M_NBP, D_L_USR3, | |
421 | ("nbp_input: BRREQ: not from us\n")); | |
422 | ||
423 | dPrintf(D_M_NBP, D_L_USR3, | |
424 | ("nbp_input dist:%d\n", rt->NetDist)); | |
425 | if (rt->NetDist == 0) { /* if direct connect, *we* do the LKUP */ | |
426 | nbp->control = NBP_LKUP; | |
427 | NET_ASSIGN(ddp->dst_net, 0); | |
428 | ddp->dst_node = 255; | |
429 | if (!zt_get_zmcast(ifID, p, &mcastAddr)) { | |
430 | dPrintf(D_M_NBP,D_L_ERROR, | |
431 | ("nbp_input: BRRQ:zt_get_zmcast error\n")); | |
432 | break; | |
433 | } | |
434 | if (FDDI_OR_TOKENRING(ifID->aa_ifp->if_type)) | |
435 | ddp_bit_reverse(&mcastAddr); | |
436 | ddp_router_output(m2, ifID, ET_ADDR, NULL, NULL, &mcastAddr); | |
437 | } | |
438 | else { /* else fwd to router */ | |
439 | ddp->dst_node = 0; | |
440 | if (rt->NetStart == 0) /* if Ltalk */ | |
441 | NET_ASSIGN(ddp->dst_net, rt->NetStop); | |
442 | else | |
443 | NET_ASSIGN(ddp->dst_net, rt->NetStart); | |
444 | nbp->control = NBP_FWDRQ; | |
445 | ddp_router_output(m2, ifID, AT_ADDR, | |
446 | rt->NextIRNet, rt->NextIRNode, | |
447 | NULL); | |
448 | } | |
449 | } | |
450 | if (!zhome) | |
451 | break; | |
452 | ||
453 | if (!(m3 = (gbuf_t *)gbuf_copym((gbuf_t *)m))) { | |
454 | dPrintf(D_M_NBP,D_L_ERROR, | |
455 | ("nbp_input: BRREQ:gbuf_copym failed\n")); | |
456 | break; | |
457 | } | |
458 | ||
459 | ddp = DATA_DDP(m3); | |
460 | nbp = DATA_NBP(m3); | |
461 | ||
462 | nbp->control = NBP_LKUP; | |
463 | NET_ASSIGN(ddp->dst_net, 0); | |
464 | ddp->dst_node = 255; | |
465 | dPrintf(D_M_NBP,D_L_INFO, ("nbp_input: BRRQ:loop back for us\n")); | |
466 | nbp_input(m3, ifID_home); | |
467 | break; | |
468 | } | |
469 | ||
470 | case NBP_LKUP_REPLY: | |
471 | ||
472 | if (!ROUTING_MODE) /* for routers only! */ | |
473 | break; | |
474 | ||
475 | dPrintf(D_M_NBP,D_L_WARNING, | |
476 | ("nbp_input: routing needed for LKUP_REPLY: from %d.%d\n", | |
477 | NET_VALUE(ddp->src_net), ddp->src_node)); | |
478 | routing_needed(m, ifID, TRUE); | |
479 | ddpSent = TRUE; | |
480 | break; | |
481 | ||
482 | default : | |
483 | dPrintf(D_M_NBP,D_L_ERROR, | |
484 | ("nbp_input: unhandled pkt: type:%d\n", nbp->control)); | |
485 | ||
486 | routing_needed(m, ifID, TRUE); | |
487 | ddpSent = TRUE; | |
488 | break; | |
489 | } /* switch control */ | |
490 | ||
491 | if (!ddpSent) | |
492 | gbuf_freem(m); | |
493 | return; | |
494 | } /* nbp_input */ | |
495 | ||
496 | static int nbp_validate_n_hash (nbp_req, wild_ok, checkLocal) | |
497 | register nbp_req_t *nbp_req; | |
498 | register int wild_ok; | |
499 | register int checkLocal; /* if true check if local zone */ | |
500 | { | |
501 | register at_nvestr_t *object, *type, *zone; | |
502 | at_nbptuple_t *tuple; | |
503 | register int i, part_wild; | |
504 | ||
505 | tuple = DATA_NBP(nbp_req->request)->tuple; | |
506 | nbp_req->flags = 0; | |
507 | #ifdef COMMENTED_OUT | |
508 | { | |
509 | int net,node,skt; | |
8ad349bb | 510 | net = tuple->enu_addr.net; |
1c79356b A |
511 | node = tuple->enu_addr.node; |
512 | skt = tuple->enu_addr.socket; | |
513 | dPrintf(D_M_NBP_LOW,D_L_USR4, | |
514 | ("nbp_validate: tuple addr:%d:%d:%d\n",net,node,skt)); | |
515 | } | |
516 | #endif /* COMMENTED_OUT */ | |
517 | ||
518 | /* tuple is in the compressed (no "filler") format */ | |
519 | object = (at_nvestr_t *)&tuple->enu_entity; | |
520 | type = (at_nvestr_t *)(&object->str[object->len]); | |
521 | zone = (at_nvestr_t *)(&type->str[type->len]); | |
522 | ||
523 | if (object->len > NBP_NVE_STR_SIZE || type->len > NBP_NVE_STR_SIZE || | |
524 | zone->len > NBP_NVE_STR_SIZE) { | |
525 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
526 | ("nbp_val_n_hash: bad str len\n")); | |
527 | errno = EINVAL; | |
528 | return (-1); | |
529 | } | |
530 | ||
531 | #ifdef NBP_DEBUG | |
532 | { | |
533 | char xzone[35],xobject[35],xtype[35]; | |
534 | strncpy(xzone,zone->str, zone->len); | |
535 | strncpy(xobject,object->str, object->len); | |
536 | strncpy(xtype,type->str, type->len); | |
537 | xobject[object->len] = '\0'; | |
538 | xzone[zone->len] = '\0'; | |
539 | xtype[type->len] = '\0'; | |
540 | dPrintf(D_M_NBP_LOW, D_L_USR4, | |
541 | ("nbp_validate: looking for %s:%s@%s\n", | |
542 | xobject, xtype, xzone)); | |
543 | } | |
544 | #endif /* NBP_DEBUG */ | |
545 | /* Is this request for our zone ?? */ | |
546 | nbp_req->nve.zone.len = zone->len; | |
547 | nbp_req->nve.zone_hash = 0; | |
548 | bcopy(zone->str,nbp_req->nve.zone.str, zone->len); | |
549 | ||
550 | if (checkLocal && !isZoneLocal(zone)) { | |
551 | char str[35]; | |
552 | strncpy(str,zone->str,zone->len); | |
553 | str[zone->len] = '\0'; | |
554 | dPrintf(D_M_NBP_LOW,D_L_WARNING, | |
555 | ("nbp_val_n_hash bad zone: %s\n", str)); | |
556 | errno = EINVAL; | |
557 | return(-1); | |
558 | } | |
559 | ||
560 | if (!DEFAULT_ZONE(zone)) { | |
561 | nbp_req->nve.zone_hash = nbp_strhash(& nbp_req->nve.zone); | |
562 | } | |
563 | ||
564 | nbp_req->nve.address = tuple->enu_addr; | |
565 | nbp_req->nve.object.len = object->len; | |
566 | nbp_req->nve.object_hash = 0; | |
567 | if (object->len == 1 && (object->str[0] == NBP_ORD_WILDCARD || | |
568 | object->str[0] == NBP_SPL_WILDCARD)) { | |
569 | if (wild_ok) | |
570 | nbp_req->flags |= NBP_WILD_OBJECT; | |
571 | else { | |
572 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
573 | ("nbp_val_n_hash: wild not okay\n")); | |
574 | errno = EINVAL; | |
575 | return (-1); | |
576 | } | |
577 | } else{ | |
578 | for (i = part_wild = 0; (unsigned) i<object->len; i++) { | |
579 | if (object->str[i] == NBP_SPL_WILDCARD) | |
580 | if (wild_ok) | |
581 | if (part_wild) { | |
582 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
583 | ("nbp_val_n_hash: too many parts wild\n")); | |
584 | errno = EINVAL; | |
585 | return (-1); | |
586 | } else | |
587 | part_wild++; | |
588 | else { | |
589 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
590 | ("nbp_val_n_hash: wild not okay2\n")); | |
591 | errno = EINVAL; | |
592 | return (-1); | |
593 | } | |
594 | nbp_req->nve.object.str[i] = object->str[i]; | |
595 | } | |
596 | if (!part_wild) | |
597 | nbp_req->nve.object_hash = | |
598 | nbp_strhash(&nbp_req->nve.object); | |
599 | } | |
600 | ||
601 | nbp_req->nve.type.len = type->len; | |
602 | nbp_req->nve.type_hash = 0; | |
603 | if (type->len == 1 && (type->str[0] == NBP_ORD_WILDCARD || | |
604 | type->str[0] == NBP_SPL_WILDCARD)) { | |
605 | if (wild_ok) | |
606 | nbp_req->flags |= NBP_WILD_TYPE; | |
607 | else { | |
608 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
609 | ("nbp_val_n_hash: wild not okay3\n")); | |
610 | errno = EINVAL; | |
611 | return (-1); | |
612 | } | |
613 | } else { | |
614 | for (i = part_wild = 0; (unsigned) i<type->len; i++) { | |
615 | if (type->str[i] == NBP_SPL_WILDCARD) | |
616 | if (wild_ok) | |
617 | if (part_wild) { | |
618 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
619 | ("nbp_val_n_hash: too many parts wild2\n")); | |
620 | errno = EINVAL; | |
621 | return (-1); | |
622 | } else | |
623 | part_wild++; | |
624 | else { | |
625 | errno = EINVAL; | |
626 | return (-1); | |
627 | } | |
628 | nbp_req->nve.type.str[i] = type->str[i]; | |
629 | } | |
630 | if (!part_wild) | |
631 | nbp_req->nve.type_hash = | |
632 | nbp_strhash(&nbp_req->nve.type); | |
633 | } | |
634 | #ifdef NBP_DEBUG | |
635 | { | |
636 | char zone[35],object[35],type[35]; | |
637 | strncpy(zone,nbp_req->nve.zone.str, nbp_req->nve.zone.len); | |
638 | strncpy(object,nbp_req->nve.object.str, nbp_req->nve.object.len); | |
639 | strncpy(type,nbp_req->nve.type.str, nbp_req->nve.type.len); | |
640 | object[nbp_req->nve.object.len] = '\0'; | |
641 | zone[nbp_req->nve.zone.len] = '\0'; | |
642 | type[nbp_req->nve.type.len] = '\0'; | |
643 | dPrintf(D_M_NBP_LOW,D_L_USR4, | |
644 | ("nbp_validate: after hash: %s:%s@%s\n", | |
645 | object, type, zone)); | |
646 | } | |
647 | #endif /* NBP_DEBUG */ | |
648 | return(0); | |
649 | } /* nbp_validate_n_hash */ | |
650 | ||
651 | ||
652 | /* Upshifts in place */ | |
653 | static void nbp_upshift (str, count) | |
654 | register u_char *str; | |
655 | register int count; | |
656 | { | |
657 | register int i, j; | |
658 | register u_char ch; | |
659 | static unsigned char lower_case[] = | |
660 | {0x8a, 0x8c, 0x8d, 0x8e, 0x96, 0x9a, 0x9f, 0xbe, | |
661 | 0xbf, 0xcf, 0x9b, 0x8b, 0x88, 0}; | |
662 | static unsigned char upper_case[] = | |
663 | {0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0xae, | |
664 | 0xaf, 0xce, 0xcd, 0xcc, 0xcb, 0}; | |
665 | ||
666 | for (j=0 ; j<count ; j++) { | |
667 | ch = str[j]; | |
668 | if (ch >= 'a' && ch <= 'z') | |
669 | str[j] = ch + 'A' - 'a'; | |
670 | else if (ch & 0x80) | |
671 | for (i=0; lower_case[i]; i++) | |
672 | if (ch == lower_case[i]) | |
673 | str[j] = upper_case[i]; | |
674 | } | |
675 | } | |
676 | ||
677 | ||
678 | u_int nbp_strhash (nvestr) | |
679 | register at_nvestr_t *nvestr; | |
680 | { | |
681 | /* upshift while hashing */ | |
682 | register u_int hash = 0; | |
683 | register int i, len; | |
684 | union { | |
685 | u_char h_4char[4]; | |
686 | int h_int; | |
687 | } un; | |
688 | ||
689 | for (i=0; (unsigned) i < nvestr->len; i+=sizeof(int)) { | |
690 | len = MIN((nvestr->len-i), sizeof(int)); | |
691 | if (len == sizeof(int)) | |
692 | bcopy(&(nvestr->str[i]), &un, sizeof(un)); | |
693 | else { | |
694 | un.h_int = -1; | |
695 | for ( ; (unsigned) i<nvestr->len; i++) | |
696 | un.h_4char[i % sizeof(int)] = nvestr->str[i]; | |
697 | } | |
698 | nbp_upshift (un.h_4char, len); | |
699 | hash ^= un.h_int; | |
700 | } | |
701 | ||
702 | return (hash); | |
703 | } /* nbp_strhash */ | |
704 | ||
705 | static nve_entry_t *nbp_search_nve (nbp_req, ifID) | |
706 | register nbp_req_t *nbp_req; | |
707 | register at_ifaddr_t *ifID; /* NULL ok */ | |
708 | { | |
709 | register nve_entry_t *nve_entry; | |
710 | ||
711 | #ifdef NBP_DEBUG | |
712 | { | |
713 | char zone[35],object[35],type[35]; | |
714 | strncpy(zone,nbp_req->nve.zone.str, nbp_req->nve.zone.len); | |
715 | strncpy(object,nbp_req->nve.object.str, nbp_req->nve.object.len); | |
716 | strncpy(type,nbp_req->nve.type.str, nbp_req->nve.type.len); | |
717 | object[nbp_req->nve.object.len] = '\0'; | |
718 | zone[nbp_req->nve.zone.len] = '\0'; | |
719 | type[nbp_req->nve.type.len] = '\0'; | |
720 | dPrintf(D_M_NBP_LOW, D_L_USR4, | |
721 | ("nbp_search: looking for %s:%s@%s resp:0x%x\n",object,type,zone, | |
722 | (u_int) nbp_req->response)); | |
723 | } | |
724 | #endif /* NBP_DEBUG */ | |
8ad349bb | 725 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
726 | TAILQ_FOREACH(nve_entry, &name_registry, nve_link) { |
727 | if ((nbp_req->nve.zone_hash) && | |
728 | ((nbp_req->nve.zone_hash != | |
729 | nve_entry->zone_hash) && | |
730 | (nbp_req->nve.zone_hash != hzonehash) | |
731 | ) | |
732 | ) { | |
733 | dPrintf(D_M_NBP_LOW,D_L_USR4, | |
734 | ("nbp_search: no match for zone, req hash:%x\n", | |
735 | nbp_req->nve.zone_hash)); | |
736 | continue; | |
737 | } | |
738 | else { /* for this entry's zone OR no zone in request or entry */ | |
739 | /* only in singleport mode (!MULTIPORT_MODE) with | |
740 | empty PRAM can an entry have '*' for it's zone | |
741 | */ | |
742 | at_nvestr_t *ezone=&nve_entry->zone; | |
743 | at_nvestr_t *rzone=&nbp_req->nve.zone; | |
744 | if (!DEFAULT_ZONE(rzone) && !DEFAULT_ZONE(ezone)) { | |
745 | if (nbp_strcmp (rzone, ezone, 0) != 0) | |
746 | continue; | |
747 | } | |
748 | else { | |
749 | if (MULTIHOME_MODE && ifID && | |
750 | (nve_entry->address.net != | |
751 | ifID->ifThisNode.s_net)) { | |
752 | dPrintf(D_M_NBP, D_L_USR4, | |
753 | ("nbp search ifID (%d) & req net (%d) not eq\n", | |
754 | nve_entry->address.net, | |
755 | ifID->ifThisNode.s_net)); | |
756 | continue; | |
757 | } | |
758 | if (ifID) | |
759 | dPrintf(D_M_NBP, D_L_USR4, | |
760 | ("nbp search ifID (%d) & req net (%d) equal\n", | |
761 | nve_entry->address.net, | |
762 | ifID->ifThisNode.s_net)); | |
763 | } | |
764 | ||
765 | } | |
766 | if (!(nbp_req->flags & NBP_WILD_OBJECT)) { | |
767 | if ((nbp_req->nve.object_hash) && | |
768 | (nbp_req->nve.object_hash != | |
769 | nve_entry->object_hash)) | |
770 | continue; | |
771 | else { | |
772 | if (nbp_strcmp (&nbp_req->nve.object, | |
773 | &nve_entry->object, | |
774 | NBP_SPL_WILDCARD) != 0) | |
775 | continue; | |
776 | } | |
777 | } | |
778 | ||
779 | ||
780 | if (!(nbp_req->flags & NBP_WILD_TYPE)) { | |
781 | if ((nbp_req->nve.type_hash) && | |
782 | (nbp_req->nve.type_hash !=nve_entry->type_hash)) | |
783 | continue; | |
784 | else { | |
785 | if (nbp_strcmp (&nbp_req->nve.type, | |
786 | &nve_entry->type, | |
787 | NBP_SPL_WILDCARD) != 0) | |
788 | continue; | |
789 | } | |
790 | } | |
791 | ||
792 | /* Found a match! */ | |
793 | #ifdef NBP_DEBUG | |
794 | { | |
795 | char zone[35],object[35],type[35]; | |
796 | ||
797 | strncpy(zone,nbp_req->nve.zone.str, nbp_req->nve.zone.len); | |
798 | strncpy(object,nbp_req->nve.object.str, nbp_req->nve.object.len); | |
799 | strncpy(type,nbp_req->nve.type.str, nbp_req->nve.type.len); | |
800 | object[nbp_req->nve.object.len] = '\0'; | |
801 | zone[nbp_req->nve.zone.len] = '\0'; | |
802 | type[nbp_req->nve.type.len] = '\0'; | |
803 | dPrintf(D_M_NBP_LOW, D_L_USR2, | |
804 | ("nbp_search: found %s:%s@%s net:%d\n", | |
805 | object, type, zone, (int)nve_entry->address.net)); | |
806 | } | |
807 | #endif /* NBP_DEBUG */ | |
808 | if (nbp_req->func != NULL) { | |
809 | if ((*(nbp_req->func))(nbp_req, nve_entry) != 0) { | |
810 | /* errno expected to be set by func */ | |
8ad349bb | 811 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
812 | return (NULL); |
813 | } | |
8ad349bb A |
814 | } else { |
815 | ATENABLE(nve_lock_pri,NVE_LOCK); | |
1c79356b | 816 | return (nve_entry); |
8ad349bb | 817 | } |
1c79356b | 818 | } |
8ad349bb | 819 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
820 | |
821 | errno = 0; | |
822 | return (NULL); | |
823 | } /* nbp_search_nve */ | |
824 | ||
825 | static int nbp_lkup_reply (nbp_req, nve_entry) | |
826 | register nbp_req_t *nbp_req; | |
827 | register nve_entry_t *nve_entry; | |
828 | { | |
829 | register at_nbptuple_t *tuple; | |
830 | register int tuple_size, buf_len; | |
831 | register int obj_len, type_len; | |
832 | u_char *p; | |
833 | ||
834 | /* size of the current tuple we want to write... */ | |
835 | tuple_size = nve_entry->object.len + 1 + /* object */ | |
836 | nve_entry->type.len + 1 + /* type */ | |
837 | 2 + /* zone */ | |
838 | sizeof (at_inet_t) + 1; /* addr + enum */ | |
839 | ||
840 | buf_len = ((nbp_req->flags & NBP_WILD_MASK) ? DDP_DATA_SIZE:tuple_size); | |
841 | if (nbp_req->response == NULL) { | |
842 | if (nbp_setup_resp (nbp_req, buf_len) != 0) | |
843 | /* errno expected to be set by nbp_setup_resp() */ | |
844 | return (-1); | |
845 | } | |
846 | ||
847 | if ((nbp_req->space_unused < tuple_size) || | |
848 | (DATA_NBP(nbp_req->response)->tuple_count == NBP_TUPLE_MAX)) { | |
849 | if (nbp_send_resp (nbp_req) != 0) | |
850 | return (-1); | |
851 | if (nbp_setup_resp (nbp_req, buf_len) != 0) | |
852 | return (-1); | |
853 | } | |
854 | ||
855 | /* At this point, we have a response buffer that can accommodate the | |
856 | * tuple we want to write. Write it! | |
857 | */ | |
858 | tuple = (at_nbptuple_t *)gbuf_wptr(nbp_req->response); | |
8ad349bb | 859 | tuple->enu_addr = nve_entry->address; |
1c79356b A |
860 | tuple->enu_enum = nve_entry->enumerator; |
861 | ||
862 | /* tuple is in the compressed (no "filler") format */ | |
863 | p = (u_char *)&tuple->enu_entity.object; | |
864 | obj_len = nve_entry->object.len + 1; | |
865 | bcopy(&nve_entry->object, p, obj_len); | |
866 | p += obj_len; | |
867 | type_len = nve_entry->type.len + 1; | |
868 | bcopy(&nve_entry->type, p, type_len); | |
869 | p += type_len; | |
870 | p[0] = (u_char)1; | |
871 | p[1] = '*'; | |
872 | ||
873 | nbp_req->space_unused -= tuple_size; | |
874 | gbuf_winc(nbp_req->response, tuple_size); | |
875 | ||
876 | /* increment the tuple count in header by 1 */ | |
877 | DATA_NBP(nbp_req->response)->tuple_count++; | |
878 | ||
879 | return (0); | |
880 | } | |
881 | ||
882 | ||
883 | static int nbp_strcmp (str1, str2, embedded_wildcard) | |
884 | register at_nvestr_t *str1, *str2; | |
885 | register u_char embedded_wildcard; /* If str1 may contain a character | |
886 | * that's to be treated as an | |
887 | * embedded wildcard, this character | |
888 | * is it. Making this special case | |
889 | * since for zone names, squiggly | |
890 | * equal is not to be treated as a | |
891 | * wildcard. | |
892 | */ | |
893 | { | |
894 | u_char ch1,ch2; | |
895 | register int i1, i2; | |
896 | register int reverse = 0; | |
897 | register int left_index; | |
898 | ||
899 | /* Embedded wildcard, if any, could only be in the first string (str1). | |
900 | * returns 0 if two strings are equal (modulo case), -1 otherwise | |
901 | */ | |
902 | ||
903 | if (str1->len == 0 || str2->len == 0) { | |
904 | return (-1); | |
905 | } | |
906 | ||
907 | /* Wildcards are not allowed in str2. | |
908 | * | |
909 | * If str1 could potentially contain an embedded wildcard, since the | |
910 | * embedded wildcard matches ZERO OR MORE characters, str1 can not be | |
911 | * more than 1 character longer than str2. | |
912 | * | |
913 | * If str1 is not supposed to have embedded wildcards, the two strs | |
914 | * must be of equal length. | |
915 | */ | |
916 | if ((embedded_wildcard && (str2->len < (unsigned) (str1->len-1))) || | |
917 | (!embedded_wildcard && (str2->len != str1->len))) { | |
918 | return (-1); | |
919 | } | |
920 | ||
921 | for (i1 = i2 = left_index = 0; (unsigned) i1 < str1->len ;) { | |
922 | ch1 = str1->str[i1]; | |
923 | ch2 = str2->str[i2]; | |
924 | ||
925 | if (embedded_wildcard && (ch1==embedded_wildcard)) { | |
926 | /* hit the embedded wild card... start comparing from | |
927 | * the other end of the string. | |
928 | */ | |
929 | reverse++; | |
930 | /* But, if embedded wildcard was the last character of | |
931 | * the string, the two strings match, so return okay. | |
932 | */ | |
933 | if (i1 == str1->len-1) { | |
934 | return (0); | |
935 | } | |
936 | ||
937 | i1 = str1->len - 1; | |
938 | i2 = str2->len - 1; | |
939 | ||
940 | continue; | |
941 | } | |
942 | ||
943 | nbp_upshift(&ch1, 1); | |
944 | nbp_upshift(&ch2, 1); | |
945 | ||
946 | if (ch1 != ch2) { | |
947 | return (-1); | |
948 | } | |
949 | ||
950 | if (reverse) { | |
951 | i1--; i2--; | |
952 | if (i1 == left_index) { | |
953 | return (0); | |
954 | } | |
955 | } else { | |
956 | i1++; i2++; left_index++; | |
957 | } | |
958 | } | |
959 | return (0); | |
960 | } | |
961 | ||
962 | ||
963 | static void nbp_setup_hdr (nbp_req) | |
964 | register nbp_req_t *nbp_req; | |
965 | { | |
966 | register at_ddp_t *ddp; | |
967 | register at_nbp_t *nbp; | |
968 | ||
969 | ddp = DATA_DDP(nbp_req->response); | |
970 | nbp = DATA_NBP(nbp_req->response); | |
971 | ||
972 | ddp->type = DDP_NBP; | |
973 | UAS_ASSIGN(ddp->checksum, 0); | |
974 | ddp->unused = ddp->hopcount = 0; | |
975 | ||
976 | switch(DATA_NBP(nbp_req->request)->control) { | |
977 | case NBP_LKUP : | |
978 | ddp->dst_socket = nbp_req->nve.address.socket; | |
979 | ddp->dst_node = nbp_req->nve.address.node; | |
8ad349bb | 980 | NET_ASSIGN(ddp->dst_net, nbp_req->nve.address.net); |
1c79356b A |
981 | nbp->control = NBP_LKUP_REPLY; |
982 | break; | |
983 | } | |
984 | nbp->at_nbp_id = DATA_NBP(nbp_req->request)->at_nbp_id; | |
985 | return; | |
986 | } | |
987 | ||
988 | ||
989 | static int nbp_setup_resp (nbp_req, tuples_size) | |
990 | register nbp_req_t *nbp_req; | |
991 | register int tuples_size; | |
992 | { | |
993 | int buf_size = tuples_size + DDP_X_HDR_SIZE + NBP_HDR_SIZE; | |
994 | nbp_req->response = gbuf_alloc(AT_WR_OFFSET+buf_size, PRI_MED); | |
995 | if (nbp_req->response == NULL) { | |
996 | errno = ENOBUFS; | |
997 | return(-1); | |
998 | } | |
999 | gbuf_rinc(nbp_req->response, AT_WR_OFFSET); | |
1000 | gbuf_wset(nbp_req->response, DDP_X_HDR_SIZE + NBP_HDR_SIZE); | |
1001 | nbp_setup_hdr(nbp_req); | |
1002 | ||
1003 | DATA_NBP(nbp_req->response)->tuple_count = 0; | |
1004 | nbp_req->space_unused = tuples_size; | |
1005 | ||
1006 | return (0); | |
1007 | } /* nbp_setup_resp */ | |
1008 | ||
1009 | ||
1010 | static int nbp_send_resp (nbp_req) | |
1011 | register nbp_req_t *nbp_req; | |
1012 | { | |
1013 | int status; | |
1014 | ||
1015 | status = ddp_output(&nbp_req->response, (at_socket)NBP_SOCKET, FALSE); | |
1016 | nbp_req->response = NULL; | |
1017 | errno = status; | |
1018 | return(errno?-1:0); | |
1019 | } | |
1020 | ||
1021 | void nbp_add_multicast(zone, ifID) | |
1022 | at_nvestr_t *zone; | |
1023 | at_ifaddr_t *ifID; | |
1024 | { | |
1025 | char data[ETHERNET_ADDR_LEN]; | |
1026 | int i; | |
1027 | ||
1028 | if (zone->str[0] == '*') | |
1029 | return; | |
1030 | ||
1031 | { | |
1032 | char str[35]; | |
1033 | strncpy(str,zone->str,zone->len); | |
1034 | str[zone->len] = '\0'; | |
1035 | dPrintf(D_M_NBP_LOW, D_L_USR3, | |
1036 | ("nbp_add_multi getting mc for %s\n", str)); | |
1037 | } | |
1038 | zt_get_zmcast(ifID, zone, data); | |
1039 | if (FDDI_OR_TOKENRING(ifID->aa_ifp->if_type)) | |
1040 | ddp_bit_reverse(data); | |
1041 | dPrintf(D_M_NBP_LOW,D_L_USR3, | |
1042 | ("nbp_add_multi adding 0x%x%x port:%d ifID:0x%x if:%s\n", | |
1043 | *(unsigned*)data, (*(unsigned *)(data+2))&0x0000ffff, | |
1044 | i, (u_int) ifID, ifID->ifName)); | |
1045 | ||
1046 | bcopy((caddr_t)data, (caddr_t)&ifID->ZoneMcastAddr, ETHERNET_ADDR_LEN); | |
1047 | (void)at_reg_mcast(ifID, (caddr_t)&ifID->ZoneMcastAddr); | |
1048 | } | |
1049 | ||
1050 | ||
1051 | getNbpTableSize() | |
1052 | ||
1053 | /* for SNMP, returns size in # of entries */ | |
1054 | { | |
1055 | register nve_entry_t *nve; | |
1056 | register int i=0; | |
1057 | ||
8ad349bb | 1058 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1059 | for (nve = TAILQ_FIRST(&name_registry); nve; nve = TAILQ_NEXT(nve, nve_link), i++) |
1060 | i++; | |
8ad349bb | 1061 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1062 | return(i); |
1063 | } | |
1064 | ||
1065 | getNbpTable(p, s, c) | |
1066 | snmpNbpEntry_t *p; | |
1067 | int s; /* starting entry */ | |
1068 | int c; /* # entries to copy */ | |
1069 | ||
1070 | /* for SNMP, returns section of nbp table */ | |
1071 | { | |
1072 | register nve_entry_t *nve; | |
1073 | register int i=0; | |
1074 | static int nextNo=0; /* entry that *next points to */ | |
1075 | static nve_entry_t *next = (nve_entry_t*)NULL; | |
1076 | ||
1077 | if (s && next && nextNo == s) { | |
1078 | nve = next; | |
1079 | i = nextNo; | |
1080 | } | |
1081 | else | |
1082 | nve = TAILQ_FIRST(&name_registry); | |
1083 | ||
8ad349bb | 1084 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1085 | for ( ; nve && c ; nve = TAILQ_NEXT(nve, nve_link), p++,i++) { |
1086 | if (i>= s) { | |
1087 | p->nbpe_object = nve->object; | |
1088 | p->nbpe_type = nve->type; | |
1089 | c--; | |
1090 | } | |
1091 | } | |
8ad349bb | 1092 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1093 | if (nve) { |
1094 | next = nve; | |
1095 | nextNo = i; | |
1096 | } else { | |
1097 | next = (nve_entry_t*)NULL; | |
1098 | nextNo = 0; | |
1099 | } | |
1100 | } | |
1101 | ||
1102 | ||
1103 | #define ZONES_PER_BLK 31 /* 31 fits within a 1k blk) */ | |
1104 | #define ZONE_BLK_SIZE ZONES_PER_BLK * sizeof(at_nvestr_t) | |
1105 | ||
1106 | int setLocalZones(newzones, size) | |
1107 | at_nvestr_t *newzones; | |
1108 | int size; | |
1109 | /* updates list of zones which are local to all active ports | |
1110 | missing zones are not deleted, only missing zones are added. | |
1111 | */ | |
1112 | { | |
1113 | int bytesread=0; /* #bytes read from tuple */ | |
1114 | int i=0, dupe; | |
1115 | gbuf_t *m; | |
1116 | at_nvestr_t *pnve, *pnew = newzones; | |
1117 | ||
1118 | if (!lzones) { | |
1119 | if(!(lzones = gbuf_alloc(ZONE_BLK_SIZE, PRI_MED))) | |
1120 | return(ENOBUFS); | |
1121 | gbuf_wset(lzones,0); | |
1122 | } | |
1123 | while (bytesread < size) { /* for each new zone */ | |
1124 | { | |
1125 | char str[35]; | |
1126 | strncpy(str,pnew->str,pnew->len); | |
1127 | str[pnew->len] = '\0'; | |
1128 | } | |
1129 | m = lzones; | |
1130 | pnve = (at_nvestr_t*)gbuf_rptr(m); | |
1131 | dupe = 0; | |
1132 | for (i=0; i<lzonecnt && !dupe; i++,pnve++) { | |
1133 | if (i && !(i%ZONES_PER_BLK)) | |
1134 | if (gbuf_cont(m)) { | |
1135 | m = gbuf_cont(m); | |
1136 | pnve = (at_nvestr_t*)gbuf_rptr(m); | |
1137 | } | |
1138 | else | |
1139 | break; | |
1140 | if (pnew->len != pnve->len) | |
1141 | continue; | |
1142 | if (pnew->len > NBP_NVE_STR_SIZE) { | |
1143 | return(0); | |
1144 | } | |
1145 | if (!strncmp(pnew->str, pnve->str, pnew->len)) { | |
1146 | dupe=1; | |
1147 | continue; | |
1148 | } | |
1149 | } | |
1150 | if (!dupe) { | |
1151 | /* add new zone */ | |
1152 | if (lzonecnt && !(lzonecnt%ZONES_PER_BLK)) { | |
1153 | if(!(gbuf_cont(m) = gbuf_alloc(ZONE_BLK_SIZE, PRI_MED))) | |
1154 | return(ENOBUFS); | |
1155 | gbuf_wset(gbuf_cont(m),0); | |
1156 | pnve = (at_nvestr_t*)gbuf_rptr(gbuf_cont(m)); | |
1157 | } | |
1158 | strncpy(pnve->str,pnew->str,pnew->len); | |
1159 | pnve->len = pnew->len; | |
1160 | lzonecnt++; | |
1161 | } | |
1162 | bytesread += (pnew->len+1); | |
1163 | pnew = (at_nvestr_t*) (((char *)pnew) + pnew->len + 1); | |
1164 | } | |
1165 | /* showLocalZones1(); */ | |
1166 | return(0); | |
1167 | } | |
1168 | ||
1169 | /********** | |
1170 | showLocalZones1() | |
1171 | { | |
1172 | int i; | |
1173 | at_nvestr_t *pnve; | |
1174 | gbuf_t *m; | |
1175 | char str[35]; | |
1176 | ||
1177 | for (i=0; ; i++) { | |
1178 | if (!(pnve = getLocalZone(i))) { | |
1179 | break; | |
1180 | } | |
1181 | strncpy(str,pnve->str,pnve->len); | |
1182 | str[pnve->len] = '\0'; | |
1183 | } | |
1184 | } | |
1185 | ||
1186 | *********/ | |
1187 | ||
1188 | isZoneLocal(zone) | |
1189 | at_nvestr_t *zone; | |
1190 | { | |
1191 | at_nvestr_t *pnve; | |
1192 | int i; | |
1193 | if (DEFAULT_ZONE(zone)) | |
1194 | return(1); | |
1195 | for (i=0; ; i++) { | |
1196 | if (!(pnve = getLocalZone(i))) | |
1197 | break; | |
1198 | if (!nbp_strcmp(pnve,zone,0)) | |
1199 | return(1); | |
1200 | } | |
1201 | return(0); | |
1202 | } | |
1203 | ||
1204 | ||
1205 | #define NULL_PNVESTR (at_nvestr_t *) 0 | |
1206 | ||
1207 | at_nvestr_t *getLocalZone(zno) | |
1208 | int zno; /* zone number in virtual list to | |
1209 | return, 0 for first zone */ | |
1210 | /* returns pointer to a new local zone number zno, | |
1211 | returns null when no zones left. | |
1212 | */ | |
1213 | { | |
1214 | zone_usage_t ifz; | |
1215 | ifz.zone_index = zno; | |
1216 | if (MULTIPORT_MODE) | |
1217 | return(getRTRLocalZone(&ifz)); | |
1218 | else | |
1219 | return(getSPLocalZone(zno)); | |
1220 | } | |
1221 | ||
1222 | ||
1223 | at_nvestr_t *getSPLocalZone(zno) | |
1224 | int zno; /* zone number in virtual list to | |
1225 | return, 0 for first zone */ | |
1226 | /* single port mode version */ | |
1227 | { | |
1228 | int curz=0; /* current zone */ | |
1229 | gbuf_t *m; | |
1230 | at_nvestr_t *pnve; | |
1231 | ||
1232 | if (lzones) { | |
1233 | m = lzones; | |
1234 | pnve = (at_nvestr_t*)gbuf_rptr(m); | |
1235 | } | |
1236 | else | |
1237 | return(NULL_PNVESTR); | |
1238 | if ( zno>=lzonecnt ) | |
1239 | return(NULL_PNVESTR); | |
1240 | for (curz=0; curz<zno; curz++,pnve++ ) { | |
1241 | if ( curz<lzonecnt ) { | |
1242 | if (curz && !(curz%ZONES_PER_BLK) ) { | |
1243 | if (gbuf_cont(m)) { | |
1244 | m = gbuf_cont(m); | |
1245 | pnve = (at_nvestr_t*)gbuf_rptr(m); | |
1246 | } | |
1247 | else { | |
1248 | return(NULL_PNVESTR); | |
1249 | } | |
1250 | } | |
1251 | if (pnve->len > NBP_NVE_STR_SIZE) { | |
1252 | return(NULL_PNVESTR); | |
1253 | } | |
1254 | } | |
1255 | else | |
1256 | return(NULL_PNVESTR); | |
1257 | } | |
1258 | return(pnve); | |
1259 | } | |
1260 | \f | |
1261 | /* The following functions are used in name registration and removal */ | |
1262 | ||
1263 | int nbp_fillin_nve(entity, nve) | |
1264 | at_entity_t *entity; | |
1265 | nve_entry_t *nve; | |
1266 | { | |
1267 | register int i; | |
1268 | ||
1269 | if (entity->object.len > NBP_NVE_STR_SIZE || | |
1270 | entity->type.len > NBP_NVE_STR_SIZE || | |
1271 | entity->zone.len > NBP_NVE_STR_SIZE) { | |
1272 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1273 | ("nbp_fillin_nve: bad str len\n")); | |
1274 | errno = EINVAL; | |
1275 | return (-1); | |
1276 | } | |
1277 | ||
1278 | nve->zone = entity->zone; | |
1279 | nve->zone_hash = 0; | |
1280 | if (!isZoneLocal(&entity->zone)) { | |
1281 | errno = EINVAL; | |
1282 | return(-1); | |
1283 | } | |
1284 | /* if there's no zone, '*' gets filled in when entry is created */ | |
1285 | if (!DEFAULT_ZONE(&entity->zone)) | |
1286 | nve->zone_hash = nbp_strhash(&nve->zone); | |
1287 | ||
1288 | nve->object = entity->object; | |
1289 | nve->object_hash = 0; | |
1290 | if (entity->object.len == 1 && | |
1291 | (entity->object.str[0] == NBP_ORD_WILDCARD || | |
1292 | entity->object.str[0] == NBP_SPL_WILDCARD)) { | |
1293 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1294 | ("nbp_fillin_nve: wildcard\n")); | |
1295 | errno = EINVAL; | |
1296 | return (-1); | |
1297 | } | |
1298 | for (i = 0; i < entity->object.len; i++) { | |
1299 | if (entity->object.str[i] == NBP_SPL_WILDCARD) { | |
1300 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1301 | ("nbp_fillin_nve: wildcard2\n")); | |
1302 | errno = EINVAL; | |
1303 | return (-1); | |
1304 | } | |
1305 | } | |
1306 | nve->object_hash = nbp_strhash(&nve->object); | |
1307 | ||
1308 | nve->type = entity->type; | |
1309 | nve->type_hash = 0; | |
1310 | if (entity->type.len == 1 && | |
1311 | (entity->type.str[0] == NBP_ORD_WILDCARD || | |
1312 | entity->type.str[0] == NBP_SPL_WILDCARD)) { | |
1313 | errno = EINVAL; | |
1314 | return (-1); | |
1315 | } | |
1316 | for (i = 0; i < entity->type.len; i++) { | |
1317 | if (entity->type.str[i] == NBP_SPL_WILDCARD) { | |
1318 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1319 | ("nbp_fillin_nve: wildcard3\n")); | |
1320 | errno = EINVAL; | |
1321 | return (-1); | |
1322 | } | |
1323 | } | |
1324 | nve->type_hash = nbp_strhash(&nve->type); | |
1325 | ||
1326 | return(0); | |
1327 | } /* nbp_fillin_nve */ | |
1328 | ||
1329 | nve_entry_t *nbp_find_nve(nve) | |
1330 | nve_entry_t *nve; | |
1331 | { | |
1332 | register nve_entry_t *nve_entry; | |
1333 | ||
8ad349bb | 1334 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1335 | TAILQ_FOREACH(nve_entry, &name_registry, nve_link) { |
1336 | if (nve->zone_hash && | |
1337 | ((nve->zone_hash != nve_entry->zone_hash) && | |
1338 | (nve->zone_hash != hzonehash))) { | |
1339 | dPrintf(D_M_NBP_LOW,D_L_USR4, | |
1340 | ("nbp_find_nve: no match for zone, req hash:%x\n", | |
1341 | nve->zone_hash)); | |
1342 | continue; | |
1343 | } | |
1344 | ||
1345 | if ((nve->object_hash) && | |
1346 | (nve->object_hash != nve_entry->object_hash)) | |
1347 | continue; | |
1348 | ||
1349 | if ((nve->type_hash) && | |
1350 | (nve->type_hash != nve_entry->type_hash)) | |
1351 | continue; | |
1352 | ||
1353 | /* Found a match! */ | |
8ad349bb | 1354 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1355 | return (nve_entry); |
1356 | } | |
8ad349bb | 1357 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1358 | |
1359 | return (NULL); | |
1360 | } /* nbp_find_nve */ | |
1361 | ||
1362 | static int nbp_enum_gen (nve_entry) | |
1363 | register nve_entry_t *nve_entry; | |
1364 | { | |
1365 | register int new_enum = 0; | |
1366 | register nve_entry_t *ne; | |
1367 | ||
8ad349bb | 1368 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1369 | re_do: |
1370 | TAILQ_FOREACH(ne, &name_registry, nve_link) { | |
1371 | if ((*(int *)&ne->address == *(int *)&nve_entry->address) && | |
1372 | (ne->enumerator == new_enum)) { | |
8ad349bb A |
1373 | if (new_enum == 255) { |
1374 | ATENABLE(nve_lock_pri,NVE_LOCK); | |
1c79356b | 1375 | return(EADDRNOTAVAIL); |
8ad349bb | 1376 | } else { |
1c79356b A |
1377 | new_enum++; |
1378 | goto re_do; | |
1379 | } | |
1380 | } | |
1381 | } | |
1382 | ||
8ad349bb | 1383 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1384 | nve_entry->enumerator = new_enum; |
1385 | return (0); | |
1386 | } | |
1387 | ||
1388 | int nbp_new_nve_entry(nve_entry, ifID) | |
1389 | nve_entry_t *nve_entry; | |
1390 | at_ifaddr_t *ifID; | |
1391 | { | |
1392 | gbuf_t *tag; | |
1393 | nve_entry_t *new_entry; | |
1394 | at_nvestr_t *zone; | |
1395 | int error; | |
1396 | ||
1397 | if (!(valid_at_addr((at_inet_t *)&nve_entry->address))) { | |
1398 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1399 | ("nbp_new_nve_entry: valid_at_addr\n")); | |
1400 | return(EINVAL); | |
1401 | } | |
1402 | if ((error = nbp_enum_gen(nve_entry))) | |
1403 | return(error); | |
1404 | ||
1405 | nve_entry->unique_nbp_id = ++nbp_id_count; | |
1406 | ||
1407 | /* Got an nve entry on hand.... allocate a buffer, copy the entry | |
1408 | * on to it and stick it in the registry. | |
1409 | */ | |
1410 | if ((tag = gbuf_alloc(sizeof(nve_entry_t), PRI_HI)) == NULL){ | |
1411 | return(ENOBUFS); | |
1412 | } | |
1413 | gbuf_wset(tag, sizeof(nve_entry_t)); | |
1414 | new_entry = (nve_entry_t *)gbuf_rptr(tag); | |
1415 | bcopy(nve_entry, new_entry, sizeof(nve_entry_t)); | |
1416 | ||
1417 | if (DEFAULT_ZONE(&nve_entry->zone)) { | |
1418 | /* put actual zone name in entry instead of "*" */ | |
1419 | /* if single port mode and no zone name, then a router | |
1420 | is down, so use pram zone name hint from elap cfg */ | |
1421 | if (!MULTIPORT_MODE && ifID_home->ifZoneName.str[0] == '*') { | |
1422 | zone = &ifID_home->startup_zone; | |
1423 | } else { | |
1424 | zone = &ifID_home->ifZoneName; | |
1425 | } | |
1426 | new_entry->zone = *zone; | |
1427 | if ( new_entry->zone.len == 0 ) { | |
1428 | new_entry->zone.str[0] = '*'; | |
1429 | new_entry->zone.len = 1; | |
1430 | } | |
1431 | new_entry->zone_hash = nbp_strhash(&new_entry->zone); | |
1432 | } | |
1433 | new_entry->tag = tag; | |
91447636 | 1434 | new_entry->pid = proc_selfpid(); |
1c79356b | 1435 | |
8ad349bb | 1436 | ATDISABLE(nve_lock_pri,NVE_LOCK); |
1c79356b | 1437 | TAILQ_INSERT_TAIL(&name_registry, new_entry, nve_link); |
8ad349bb | 1438 | ATENABLE(nve_lock_pri,NVE_LOCK); |
1c79356b A |
1439 | at_state.flags |= AT_ST_NBP_CHANGED; |
1440 | ||
1441 | #ifdef NBP_DEBUG | |
1442 | { | |
1443 | char zone[35],object[35],type[35]; | |
1444 | strncpy(zone,new_entry->zone.str, new_entry->zone.len); | |
1445 | strncpy(object,new_entry->object.str, new_entry->object.len); | |
1446 | strncpy(type,new_entry->type.str, new_entry->type.len); | |
1447 | object[new_entry->object.len] = '\0'; | |
1448 | zone[new_entry->zone.len] = '\0'; | |
1449 | type[new_entry->type.len] = '\0'; | |
1450 | dPrintf(D_M_NBP_LOW, D_L_USR4, | |
1451 | ("nbp_insert: adding %s:%s@%s addr:%d.%d ", | |
1452 | object, type, zone, | |
1453 | new_entry->address.net, new_entry->address.node)); | |
1454 | } | |
1455 | #endif /* NBP_DEBUG */ | |
1456 | ||
1457 | nbp_add_multicast(&new_entry->zone, ifID); | |
1458 | return (0); | |
1459 | } /* nbp_new_nve_entry */ | |
1460 | ||
1461 | void nbp_delete_entry (nve_entry) | |
1462 | nve_entry_t *nve_entry; | |
1463 | { | |
1464 | TAILQ_REMOVE(&name_registry, nve_entry, nve_link); | |
1465 | gbuf_freem(nve_entry->tag); | |
1466 | at_state.flags |= AT_ST_NBP_CHANGED; | |
1467 | } | |
1468 | ||
1469 | /* Registration of an NBP entity in multihoming mode, from AIOCNBPREG | |
1470 | in at.c */ | |
1471 | int nbp_mh_reg(nbpP) | |
1472 | at_nbp_reg_t *nbpP; | |
1473 | { | |
1474 | nve_entry_t nve; | |
1475 | at_ifaddr_t *ifID = 0; | |
1476 | int registered = 0; | |
1477 | int finished = FALSE; | |
1478 | ||
1479 | if (nbp_fillin_nve(&nbpP->name, &nve) != 0) { | |
1480 | /* bad tuple... */ | |
1481 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1482 | ("nbp_mh_reg: bad tuple\n")); | |
1483 | return(EINVAL); | |
1484 | } | |
1485 | nve.address = nbpP->addr; | |
1486 | nve.ddptype = nbpP->ddptype; | |
1487 | ||
1488 | if (DEFAULT_ZONE(&nbpP->name.zone)) { | |
1489 | /* multihoming mode with the default zone specified */ | |
1490 | ||
1491 | /* now find the matching interfaces */ | |
1492 | TAILQ_FOREACH(ifID, &at_ifQueueHd, aa_link) { | |
1493 | if (nbpP->addr.net || nbpP->addr.node) { | |
1494 | /* if address is specified */ | |
1495 | if ((nbpP->addr.net != ifID->ifThisNode.s_net || | |
1496 | nbpP->addr.node != ifID->ifThisNode.s_node)) | |
1497 | continue; | |
1498 | else | |
1499 | /* the address was specified, and | |
1500 | we found the matching interface */ | |
1501 | finished = TRUE; | |
1502 | } else { | |
1503 | /* address is not specified, so fill in | |
1504 | the address for the interface */ | |
1505 | nve.address.net = ifID->ifThisNode.s_net; | |
1506 | nve.address.node = ifID->ifThisNode.s_node; | |
1507 | } | |
1508 | nve.zone = ifID->ifZoneName; | |
1509 | nve.zone_hash = nbp_strhash(&nve.zone); | |
1510 | if (nbp_find_nve(&nve)) | |
1511 | continue; | |
1512 | if (nbp_new_nve_entry(&nve, ifID) == 0) | |
1513 | registered++; | |
1514 | } | |
1515 | if (registered && !nbpP->addr.net && !nbpP->addr.node) { | |
1516 | nbpP->addr.net = ifID_home->ifThisNode.s_net; | |
1517 | nbpP->addr.node = ifID_home->ifThisNode.s_node; | |
1518 | } | |
1519 | } else { | |
1520 | /* multihoming mode with a specific zone specified */ | |
1521 | /* see which segments (interfaces) are seeded for this zone */ | |
1522 | int zno; | |
9bccf70c | 1523 | at_ifnames_t ifs_in_zone; |
1c79356b A |
1524 | if (!(zno = zt_find_zname(&nve.zone))) { |
1525 | dPrintf(D_M_NBP_LOW, D_L_WARNING, | |
1526 | ("nbp_mh_reg: didn't find zone name\n")); | |
1527 | return(EINVAL); | |
1528 | } | |
9bccf70c | 1529 | getIfUsage(zno-1, &ifs_in_zone); |
1c79356b | 1530 | |
9bccf70c | 1531 | /* now find the matching interfaces */ |
1c79356b | 1532 | TAILQ_FOREACH(ifID, &at_ifQueueHd, aa_link) { |
9bccf70c | 1533 | if (!ifs_in_zone.at_if[ifID->ifPort]) |
1c79356b A |
1534 | /* zone doesn't match */ |
1535 | continue; | |
1536 | else | |
1537 | /* the zone matches, so unless the | |
1538 | address is specified and doesn't | |
1539 | match, we only need to do this once */ | |
1540 | finished = TRUE; | |
1541 | ||
1542 | if (nbpP->addr.net || nbpP->addr.node) { | |
1543 | /* address is specified */ | |
1544 | finished = FALSE; | |
1545 | if ((nbpP->addr.net != ifID->ifThisNode.s_net || | |
1546 | nbpP->addr.node != ifID->ifThisNode.s_node)) | |
1547 | continue; | |
1548 | else | |
1549 | /* the address was specified, and | |
1550 | we found the matching interface */ | |
1551 | finished = TRUE; | |
1552 | } else { | |
1553 | /* address is not specified, so fill in | |
1554 | the address for the interface */ | |
1555 | nve.address.net = ifID->ifThisNode.s_net; | |
1556 | nve.address.node = ifID->ifThisNode.s_node; | |
1557 | } | |
1558 | if (nbp_find_nve(&nve)) | |
1559 | continue; | |
1560 | if (nbp_new_nve_entry(&nve, ifID) == 0) | |
1561 | registered++; | |
9bccf70c A |
1562 | if (registered && !nbpP->addr.net && !nbpP->addr.node) { |
1563 | nbpP->addr.net = ifID->ifThisNode.s_net; | |
1564 | nbpP->addr.node = ifID->ifThisNode.s_node; | |
1565 | } | |
1566 | ||
1c79356b A |
1567 | } |
1568 | } | |
1569 | nbpP->unique_nbp_id = (registered > 1)? 0: nve.unique_nbp_id; | |
1570 | ||
1571 | if (registered) | |
1572 | return(0); | |
1573 | else | |
1574 | return(EADDRNOTAVAIL); | |
1575 | ||
1576 | } /* nbp_mh_reg */ |