__P() removal
[dragonfly.git] / sys / net / if_arcsubr.c
CommitLineData
984263bc
MD
1/* $NetBSD: if_arcsubr.c,v 1.36 2001/06/14 05:44:23 itojun Exp $ */
2/* $FreeBSD: src/sys/net/if_arcsubr.c,v 1.1.2.5 2003/02/05 18:42:15 fjoe Exp $ */
158abb01 3/* $DragonFly: src/sys/net/Attic/if_arcsubr.c,v 1.4 2003/08/26 20:49:47 rob Exp $ */
984263bc
MD
4
5/*
6 * Copyright (c) 1994, 1995 Ignatios Souvatzis
7 * Copyright (c) 1982, 1989, 1993
8 * The Regents of the University of California. All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * from: NetBSD: if_ethersubr.c,v 1.9 1994/06/29 06:36:11 cgd Exp
39 * @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93
40 *
41 */
42#include "opt_inet.h"
43#include "opt_inet6.h"
44#include "opt_ipx.h"
45
46#include <sys/param.h>
47#include <sys/systm.h>
48#include <sys/kernel.h>
49#include <sys/malloc.h>
50#include <sys/mbuf.h>
51#include <sys/protosw.h>
52#include <sys/socket.h>
53#include <sys/sockio.h>
54#include <sys/errno.h>
55#include <sys/syslog.h>
56
57#include <machine/cpu.h>
58
59#include <net/if.h>
60#include <net/netisr.h>
61#include <net/route.h>
62#include <net/if_dl.h>
63#include <net/if_types.h>
64#include <net/if_arc.h>
65#include <net/if_arp.h>
66#include <net/bpf.h>
67
68#if defined(INET) || defined(INET6)
69#include <netinet/in.h>
70#include <netinet/in_var.h>
71#include <netinet/if_ether.h>
72#endif
73
74#ifdef INET6
75#include <netinet6/nd6.h>
76#endif
77
78#ifdef IPX
d2438d69
MD
79#include <netproto/ipx/ipx.h>
80#include <netproto/ipx/ipx_if.h>
984263bc
MD
81#endif
82
83MODULE_VERSION(arcnet, 1);
84
85#define ARCNET_ALLOW_BROKEN_ARP
86
158abb01
RG
87static struct mbuf *arc_defrag (struct ifnet *, struct mbuf *);
88static int arc_resolvemulti (struct ifnet *, struct sockaddr **,
89 struct sockaddr *);
984263bc
MD
90
91#define ARC_LLADDR(ifp) (*(u_int8_t *)IF_LLADDR(ifp))
92
93#define senderr(e) { error = (e); goto bad;}
94#define SIN(s) ((struct sockaddr_in *)s)
95#define SIPX(s) ((struct sockaddr_ipx *)s)
96
97/*
98 * ARCnet output routine.
99 * Encapsulate a packet of type family for the local net.
100 * Assumes that ifp is actually pointer to arccom structure.
101 */
102int
103arc_output(ifp, m, dst, rt0)
104 struct ifnet *ifp;
105 struct mbuf *m;
106 struct sockaddr *dst;
107 struct rtentry *rt0;
108{
109 struct rtentry *rt;
110 struct arccom *ac;
111 struct arc_header *ah;
112 int error;
113 u_int8_t atype, adst;
114 int loop_copy = 0;
115 int isphds;
116
117 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
118 return(ENETDOWN); /* m, m1 aren't initialized yet */
119
120 error = 0;
121 ac = (struct arccom *)ifp;
122
123 if ((rt = rt0)) {
124 if ((rt->rt_flags & RTF_UP) == 0) {
125 if ((rt0 = rt = rtalloc1(dst, 1, 0UL)))
126 rt->rt_refcnt--;
127 else
128 senderr(EHOSTUNREACH);
129 }
130 if (rt->rt_flags & RTF_GATEWAY) {
131 if (rt->rt_gwroute == 0)
132 goto lookup;
133 if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
134 rtfree(rt); rt = rt0;
135 lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1, 0UL);
136 if ((rt = rt->rt_gwroute) == 0)
137 senderr(EHOSTUNREACH);
138 }
139 }
140 if (rt->rt_flags & RTF_REJECT)
141 if (rt->rt_rmx.rmx_expire == 0 ||
142 time_second < rt->rt_rmx.rmx_expire)
143 senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
144 }
145
146 switch (dst->sa_family) {
147#ifdef INET
148 case AF_INET:
149
150 /*
151 * For now, use the simple IP addr -> ARCnet addr mapping
152 */
153 if (m->m_flags & (M_BCAST|M_MCAST))
154 adst = arcbroadcastaddr; /* ARCnet broadcast address */
155 else if (ifp->if_flags & IFF_NOARP)
156 adst = ntohl(SIN(dst)->sin_addr.s_addr) & 0xFF;
157 else if (!arpresolve(ifp, rt, m, dst, &adst, rt0))
158 return 0; /* not resolved yet */
159
160 atype = (ifp->if_flags & IFF_LINK0) ?
161 ARCTYPE_IP_OLD : ARCTYPE_IP;
162 break;
163#endif
164#ifdef INET6
165 case AF_INET6:
166#ifdef OLDIP6OUTPUT
167 if (!nd6_resolve(ifp, rt, m, dst, (u_char *)&adst))
168 return(0); /* if not yet resolves */
169#else
170 if (!nd6_storelladdr(ifp, rt, m, dst, (u_char *)&adst))
171 return(0); /* it must be impossible, but... */
172#endif /* OLDIP6OUTPUT */
173 atype = ARCTYPE_INET6;
174 break;
175#endif
176#ifdef IPX
177 case AF_IPX:
178 adst = SIPX(dst)->sipx_addr.x_host.c_host[5];
179 atype = ARCTYPE_IPX;
180 if (adst == 0xff)
181 adst = arcbroadcastaddr;
182 break;
183#endif
184
185 case AF_UNSPEC:
186 loop_copy = -1;
187 ah = (struct arc_header *)dst->sa_data;
188 adst = ah->arc_dhost;
189 atype = ah->arc_type;
190
191 if (atype == ARCTYPE_ARP) {
192 atype = (ifp->if_flags & IFF_LINK0) ?
193 ARCTYPE_ARP_OLD: ARCTYPE_ARP;
194
195#ifdef ARCNET_ALLOW_BROKEN_ARP
196 /*
197 * XXX It's not clear per RFC826 if this is needed, but
198 * "assigned numbers" say this is wrong.
199 * However, e.g., AmiTCP 3.0Beta used it... we make this
200 * switchable for emergency cases. Not perfect, but...
201 */
202 if (ifp->if_flags & IFF_LINK2)
203 mtod(m, struct arphdr *)->ar_pro = atype - 1;
204#endif
205 }
206 break;
207
208 default:
209 printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
210 dst->sa_family);
211 senderr(EAFNOSUPPORT);
212 }
213
214 isphds = arc_isphds(atype);
215 M_PREPEND(m, isphds ? ARC_HDRNEWLEN : ARC_HDRLEN, M_DONTWAIT);
216 if (m == 0)
217 senderr(ENOBUFS);
218 ah = mtod(m, struct arc_header *);
219 ah->arc_type = atype;
220 ah->arc_dhost = adst;
221 ah->arc_shost = *IF_LLADDR(ifp);
222 ah->arc_shost = ARC_LLADDR(ifp);
223 if (isphds) {
224 ah->arc_flag = 0;
225 ah->arc_seqid = 0;
226 }
227
228 if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
229 if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
230 struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
231
232 (void) if_simloop(ifp, n, dst->sa_family, ARC_HDRLEN);
233 } else if (ah->arc_dhost == ah->arc_shost) {
234 (void) if_simloop(ifp, m, dst->sa_family, ARC_HDRLEN);
235 return (0); /* XXX */
236 }
237 }
238
239 if (ifp->if_bpf)
240 bpf_mtap(ifp, m);
241
242 if (!IF_HANDOFF(&ifp->if_snd, m, ifp)) {
243 m = 0;
244 senderr(ENOBUFS);
245 }
246
247 return (error);
248
249bad:
250 if (m)
251 m_freem(m);
252 return (error);
253}
254
255void
256arc_frag_init(ifp)
257 struct ifnet *ifp;
258{
259 struct arccom *ac;
260
261 ac = (struct arccom *)ifp;
262 ac->curr_frag = 0;
263}
264
265struct mbuf *
266arc_frag_next(ifp)
267 struct ifnet *ifp;
268{
269 struct arccom *ac;
270 struct mbuf *m;
271 struct arc_header *ah;
272
273 ac = (struct arccom *)ifp;
274 if ((m = ac->curr_frag) == 0) {
275 int tfrags;
276
277 /* dequeue new packet */
278 IF_DEQUEUE(&ifp->if_snd, m);
279 if (m == 0)
280 return 0;
281
282 ah = mtod(m, struct arc_header *);
283 if (!arc_isphds(ah->arc_type))
284 return m;
285
286 ++ac->ac_seqid; /* make the seqid unique */
287 tfrags = (m->m_pkthdr.len + ARC_MAX_DATA - 1) / ARC_MAX_DATA;
288 ac->fsflag = 2 * tfrags - 3;
289 ac->sflag = 0;
290 ac->rsflag = ac->fsflag;
291 ac->arc_dhost = ah->arc_dhost;
292 ac->arc_shost = ah->arc_shost;
293 ac->arc_type = ah->arc_type;
294
295 m_adj(m, ARC_HDRNEWLEN);
296 ac->curr_frag = m;
297 }
298
299 /* split out next fragment and return it */
300 if (ac->sflag < ac->fsflag) {
301 /* we CAN'T have short packets here */
302 ac->curr_frag = m_split(m, ARC_MAX_DATA, M_DONTWAIT);
303 if (ac->curr_frag == 0) {
304 m_freem(m);
305 return 0;
306 }
307
308 M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT);
309 if (m == 0) {
310 m_freem(ac->curr_frag);
311 ac->curr_frag = 0;
312 return 0;
313 }
314
315 ah = mtod(m, struct arc_header *);
316 ah->arc_flag = ac->rsflag;
317 ah->arc_seqid = ac->ac_seqid;
318
319 ac->sflag += 2;
320 ac->rsflag = ac->sflag;
321 } else if ((m->m_pkthdr.len >=
322 ARC_MIN_FORBID_LEN - ARC_HDRNEWLEN + 2) &&
323 (m->m_pkthdr.len <=
324 ARC_MAX_FORBID_LEN - ARC_HDRNEWLEN + 2)) {
325 ac->curr_frag = 0;
326
327 M_PREPEND(m, ARC_HDRNEWLEN_EXC, M_DONTWAIT);
328 if (m == 0)
329 return 0;
330
331 ah = mtod(m, struct arc_header *);
332 ah->arc_flag = 0xFF;
333 ah->arc_seqid = 0xFFFF;
334 ah->arc_type2 = ac->arc_type;
335 ah->arc_flag2 = ac->sflag;
336 ah->arc_seqid2 = ac->ac_seqid;
337 } else {
338 ac->curr_frag = 0;
339
340 M_PREPEND(m, ARC_HDRNEWLEN, M_DONTWAIT);
341 if (m == 0)
342 return 0;
343
344 ah = mtod(m, struct arc_header *);
345 ah->arc_flag = ac->sflag;
346 ah->arc_seqid = ac->ac_seqid;
347 }
348
349 ah->arc_dhost = ac->arc_dhost;
350 ah->arc_shost = ac->arc_shost;
351 ah->arc_type = ac->arc_type;
352
353 return m;
354}
355
356/*
357 * Defragmenter. Returns mbuf if last packet found, else
358 * NULL. frees imcoming mbuf as necessary.
359 */
360
361__inline struct mbuf *
362arc_defrag(ifp, m)
363 struct ifnet *ifp;
364 struct mbuf *m;
365{
366 struct arc_header *ah, *ah1;
367 struct arccom *ac;
368 struct ac_frag *af;
369 struct mbuf *m1;
370 char *s;
371 int newflen;
372 u_char src,dst,typ;
373
374 ac = (struct arccom *)ifp;
375
376 if (m->m_len < ARC_HDRNEWLEN) {
377 m = m_pullup(m, ARC_HDRNEWLEN);
378 if (m == NULL) {
379 ++ifp->if_ierrors;
380 return NULL;
381 }
382 }
383
384 ah = mtod(m, struct arc_header *);
385 typ = ah->arc_type;
386
387 if (!arc_isphds(typ))
388 return m;
389
390 src = ah->arc_shost;
391 dst = ah->arc_dhost;
392
393 if (ah->arc_flag == 0xff) {
394 m_adj(m, 4);
395
396 if (m->m_len < ARC_HDRNEWLEN) {
397 m = m_pullup(m, ARC_HDRNEWLEN);
398 if (m == NULL) {
399 ++ifp->if_ierrors;
400 return NULL;
401 }
402 }
403
404 ah = mtod(m, struct arc_header *);
405 }
406
407 af = &ac->ac_fragtab[src];
408 m1 = af->af_packet;
409 s = "debug code error";
410
411 if (ah->arc_flag & 1) {
412 /*
413 * first fragment. We always initialize, which is
414 * about the right thing to do, as we only want to
415 * accept one fragmented packet per src at a time.
416 */
417 if (m1 != NULL)
418 m_freem(m1);
419
420 af->af_packet = m;
421 m1 = m;
422 af->af_maxflag = ah->arc_flag;
423 af->af_lastseen = 0;
424 af->af_seqid = ah->arc_seqid;
425
426 return NULL;
427 /* notreached */
428 } else {
429 /* check for unfragmented packet */
430 if (ah->arc_flag == 0)
431 return m;
432
433 /* do we have a first packet from that src? */
434 if (m1 == NULL) {
435 s = "no first frag";
436 goto outofseq;
437 }
438
439 ah1 = mtod(m1, struct arc_header *);
440
441 if (ah->arc_seqid != ah1->arc_seqid) {
442 s = "seqid differs";
443 goto outofseq;
444 }
445
446 if (typ != ah1->arc_type) {
447 s = "type differs";
448 goto outofseq;
449 }
450
451 if (dst != ah1->arc_dhost) {
452 s = "dest host differs";
453 goto outofseq;
454 }
455
456 /* typ, seqid and dst are ok here. */
457
458 if (ah->arc_flag == af->af_lastseen) {
459 m_freem(m);
460 return NULL;
461 }
462
463 if (ah->arc_flag == af->af_lastseen + 2) {
464 /* ok, this is next fragment */
465 af->af_lastseen = ah->arc_flag;
466 m_adj(m,ARC_HDRNEWLEN);
467
468 /*
469 * m_cat might free the first mbuf (with pkthdr)
470 * in 2nd chain; therefore:
471 */
472
473 newflen = m->m_pkthdr.len;
474
475 m_cat(m1,m);
476
477 m1->m_pkthdr.len += newflen;
478
479 /* is it the last one? */
480 if (af->af_lastseen > af->af_maxflag) {
481 af->af_packet = NULL;
482 return(m1);
483 } else
484 return NULL;
485 }
486 s = "other reason";
487 /* if all else fails, it is out of sequence, too */
488 }
489outofseq:
490 if (m1) {
491 m_freem(m1);
492 af->af_packet = NULL;
493 }
494
495 if (m)
496 m_freem(m);
497
498 log(LOG_INFO,"%s%d: got out of seq. packet: %s\n",
499 ifp->if_name, ifp->if_unit, s);
500
501 return NULL;
502}
503
504/*
505 * return 1 if Packet Header Definition Standard, else 0.
506 * For now: old IP, old ARP aren't obviously. Lacking correct information,
507 * we guess that besides new IP and new ARP also IPX and APPLETALK are PHDS.
508 * (Apple and Novell corporations were involved, among others, in PHDS work).
509 * Easiest is to assume that everybody else uses that, too.
510 */
511int
512arc_isphds(type)
513 u_int8_t type;
514{
515 return (type != ARCTYPE_IP_OLD &&
516 type != ARCTYPE_ARP_OLD &&
517 type != ARCTYPE_DIAGNOSE);
518}
519
520/*
521 * Process a received Arcnet packet;
522 * the packet is in the mbuf chain m with
523 * the ARCnet header.
524 */
525void
526arc_input(ifp, m)
527 struct ifnet *ifp;
528 struct mbuf *m;
529{
530 struct arc_header *ah;
531 struct ifqueue *inq;
532 u_int8_t atype;
533
534 if ((ifp->if_flags & IFF_UP) == 0) {
535 m_freem(m);
536 return;
537 }
538
539 /* possibly defragment: */
540 m = arc_defrag(ifp, m);
541 if (m == NULL)
542 return;
543
544 if (ifp->if_bpf)
545 bpf_mtap(ifp, m);
546
547 ah = mtod(m, struct arc_header *);
548 /* does this belong to us? */
549 if ((ifp->if_flags & IFF_PROMISC) == 0
550 && ah->arc_dhost != arcbroadcastaddr
551 && ah->arc_dhost != ARC_LLADDR(ifp)) {
552 m_freem(m);
553 return;
554 }
555
556 ifp->if_ibytes += m->m_pkthdr.len;
557
558 if (ah->arc_dhost == arcbroadcastaddr) {
559 m->m_flags |= M_BCAST|M_MCAST;
560 ifp->if_imcasts++;
561 }
562
563 atype = ah->arc_type;
564 switch (atype) {
565#ifdef INET
566 case ARCTYPE_IP:
567 m_adj(m, ARC_HDRNEWLEN);
568 if (ipflow_fastforward(m))
569 return;
570 schednetisr(NETISR_IP);
571 inq = &ipintrq;
572 break;
573
574 case ARCTYPE_IP_OLD:
575 m_adj(m, ARC_HDRLEN);
576 if (ipflow_fastforward(m))
577 return;
578 schednetisr(NETISR_IP);
579 inq = &ipintrq;
580 break;
581
582 case ARCTYPE_ARP:
583 if (ifp->if_flags & IFF_NOARP) {
584 /* Discard packet if ARP is disabled on interface */
585 m_freem(m);
586 return;
587 }
588 m_adj(m, ARC_HDRNEWLEN);
589 schednetisr(NETISR_ARP);
590 inq = &arpintrq;
591#ifdef ARCNET_ALLOW_BROKEN_ARP
592 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
593#endif
594 break;
595
596 case ARCTYPE_ARP_OLD:
597 if (ifp->if_flags & IFF_NOARP) {
598 /* Discard packet if ARP is disabled on interface */
599 m_freem(m);
600 return;
601 }
602 m_adj(m, ARC_HDRLEN);
603 schednetisr(NETISR_ARP);
604 inq = &arpintrq;
605#ifdef ARCNET_ALLOW_BROKEN_ARP
606 mtod(m, struct arphdr *)->ar_pro = htons(ETHERTYPE_IP);
607#endif
608 break;
609#endif
610#ifdef INET6
611 case ARCTYPE_INET6:
612 m_adj(m, ARC_HDRNEWLEN);
613 schednetisr(NETISR_IPV6);
614 inq = &ip6intrq;
615 break;
616#endif
617#ifdef IPX
618 case ARCTYPE_IPX:
619 m_adj(m, ARC_HDRNEWLEN);
620 schednetisr(NETISR_IPX);
621 inq = &ipxintrq;
622 break;
623#endif
624 default:
625 m_freem(m);
626 return;
627 }
628
629 IF_HANDOFF(inq, m, NULL);
630}
631
632/*
633 * Register (new) link level address.
634 */
635void
636arc_storelladdr(ifp, lla)
637 struct ifnet *ifp;
638 u_int8_t lla;
639{
640 ARC_LLADDR(ifp) = lla;
641}
642
643/*
644 * Perform common duties while attaching to interface list
645 */
646void
647arc_ifattach(ifp, lla)
648 struct ifnet *ifp;
649 u_int8_t lla;
650{
651 struct ifaddr *ifa;
652 struct sockaddr_dl *sdl;
653 struct arccom *ac;
654
655 if_attach(ifp);
656 ifp->if_type = IFT_ARCNET;
657 ifp->if_addrlen = 1;
658 ifp->if_hdrlen = ARC_HDRLEN;
659 ifp->if_mtu = 1500;
660 ifp->if_resolvemulti = arc_resolvemulti;
661 if (ifp->if_baudrate == 0)
662 ifp->if_baudrate = 2500000;
663#if __FreeBSD_version < 500000
664 ifa = ifnet_addrs[ifp->if_index - 1];
665#else
666 ifa = ifaddr_byindex(ifp->if_index);
667#endif
668 KASSERT(ifa != NULL, ("%s: no lladdr!\n", __FUNCTION__));
669 sdl = (struct sockaddr_dl *)ifa->ifa_addr;
670 sdl->sdl_type = IFT_ARCNET;
671 sdl->sdl_alen = ifp->if_addrlen;
672
673 if (ifp->if_flags & IFF_BROADCAST)
674 ifp->if_flags |= IFF_MULTICAST|IFF_ALLMULTI;
675
676 ac = (struct arccom *)ifp;
677 ac->ac_seqid = (time_second) & 0xFFFF; /* try to make seqid unique */
678 if (lla == 0) {
679 /* XXX this message isn't entirely clear, to me -- cgd */
680 log(LOG_ERR,"%s%d: link address 0 reserved for broadcasts. Please change it and ifconfig %s%d down up\n",
681 ifp->if_name, ifp->if_unit, ifp->if_name, ifp->if_unit);
682 }
683 arc_storelladdr(ifp, lla);
684
685 bpfattach(ifp, DLT_ARCNET, ARC_HDRLEN);
686}
687
688void
689arc_ifdetach(ifp)
690 struct ifnet *ifp;
691{
692 bpfdetach(ifp);
693 if_detach(ifp);
694}
695
696int
697arc_ioctl(ifp, command, data)
698 struct ifnet *ifp;
699 int command;
700 caddr_t data;
701{
702 struct ifaddr *ifa = (struct ifaddr *) data;
703 struct ifreq *ifr = (struct ifreq *) data;
704 int error = 0;
705
706 switch (command) {
707 case SIOCSIFADDR:
708 ifp->if_flags |= IFF_UP;
709 switch (ifa->ifa_addr->sa_family) {
710#ifdef INET
711 case AF_INET:
712 ifp->if_init(ifp->if_softc); /* before arpwhohas */
713 arp_ifinit(ifp, ifa);
714 break;
715#endif
716#ifdef IPX
717 /*
718 * XXX This code is probably wrong
719 */
720 case AF_IPX:
721 {
722 struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
723
724 if (ipx_nullhost(*ina))
725 ina->x_host.c_host[5] = ARC_LLADDR(ifp);
726 else
727 arc_storelladdr(ifp, ina->x_host.c_host[5]);
728
729 /*
730 * Set new address
731 */
732 ifp->if_init(ifp->if_softc);
733 break;
734 }
735#endif
736 default:
737 ifp->if_init(ifp->if_softc);
738 break;
739 }
740 break;
741
742 case SIOCGIFADDR:
743 {
744 struct sockaddr *sa;
745
746 sa = (struct sockaddr *) &ifr->ifr_data;
747 *(u_int8_t *)sa->sa_data = ARC_LLADDR(ifp);
748 }
749 break;
750
751 case SIOCADDMULTI:
752 case SIOCDELMULTI:
753 if (ifr == NULL)
754 error = EAFNOSUPPORT;
755 else {
756 switch (ifr->ifr_addr.sa_family) {
757 case AF_INET:
758 case AF_INET6:
759 error = 0;
760 break;
761 default:
762 error = EAFNOSUPPORT;
763 break;
764 }
765 }
766 break;
767
768 case SIOCSIFMTU:
769 /*
770 * Set the interface MTU.
771 * mtu can't be larger than ARCMTU for RFC1051
772 * and can't be larger than ARC_PHDS_MTU
773 */
774 if (((ifp->if_flags & IFF_LINK0) && ifr->ifr_mtu > ARCMTU) ||
775 ifr->ifr_mtu > ARC_PHDS_MAXMTU)
776 error = EINVAL;
777 else
778 ifp->if_mtu = ifr->ifr_mtu;
779 break;
780 }
781
782 return (error);
783}
784
785/* based on ether_resolvemulti() */
786int
787arc_resolvemulti(ifp, llsa, sa)
788 struct ifnet *ifp;
789 struct sockaddr **llsa;
790 struct sockaddr *sa;
791{
792 struct sockaddr_dl *sdl;
793 struct sockaddr_in *sin;
794#ifdef INET6
795 struct sockaddr_in6 *sin6;
796#endif
797
798 switch(sa->sa_family) {
799 case AF_LINK:
800 /*
801 * No mapping needed. Just check that it's a valid MC address.
802 */
803 sdl = (struct sockaddr_dl *)sa;
804 if (*LLADDR(sdl) != arcbroadcastaddr)
805 return EADDRNOTAVAIL;
806 *llsa = 0;
807 return 0;
808#ifdef INET
809 case AF_INET:
810 sin = (struct sockaddr_in *)sa;
811 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
812 return EADDRNOTAVAIL;
813 MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
814 M_WAITOK|M_ZERO);
815 sdl->sdl_len = sizeof *sdl;
816 sdl->sdl_family = AF_LINK;
817 sdl->sdl_index = ifp->if_index;
818 sdl->sdl_type = IFT_ARCNET;
819 sdl->sdl_alen = ARC_ADDR_LEN;
820 *LLADDR(sdl) = 0;
821 *llsa = (struct sockaddr *)sdl;
822 return 0;
823#endif
824#ifdef INET6
825 case AF_INET6:
826 sin6 = (struct sockaddr_in6 *)sa;
827 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
828 /*
829 * An IP6 address of 0 means listen to all
830 * of the Ethernet multicast address used for IP6.
831 * (This is used for multicast routers.)
832 */
833 ifp->if_flags |= IFF_ALLMULTI;
834 *llsa = 0;
835 return 0;
836 }
837 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
838 return EADDRNOTAVAIL;
839 MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
840 M_WAITOK|M_ZERO);
841 sdl->sdl_len = sizeof *sdl;
842 sdl->sdl_family = AF_LINK;
843 sdl->sdl_index = ifp->if_index;
844 sdl->sdl_type = IFT_ARCNET;
845 sdl->sdl_alen = ARC_ADDR_LEN;
846 *LLADDR(sdl) = 0;
847 *llsa = (struct sockaddr *)sdl;
848 return 0;
849#endif
850
851 default:
852 /*
853 * Well, the text isn't quite right, but it's the name
854 * that counts...
855 */
856 return EAFNOSUPPORT;
857 }
858}