![[BACK]](/icons/back.gif){kind=icon}
Return to rtsock.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net|
Return to rtsock.c CVS log | Up to [local] / sys / net |
1.1 nbrk 1: /* $OpenBSD: rtsock.c,v 1.63 2007/02/14 00:53:48 jsg Exp $ */
2: /* $NetBSD: rtsock.c,v 1.18 1996/03/29 00:32:10 cgd Exp $ */
3:
4: /*
5: * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. Neither the name of the project nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: */
32:
33: /*
34: * Copyright (c) 1988, 1991, 1993
35: * The Regents of the University of California. All rights reserved.
36: *
37: * Redistribution and use in source and binary forms, with or without
38: * modification, are permitted provided that the following conditions
39: * are met:
40: * 1. Redistributions of source code must retain the above copyright
41: * notice, this list of conditions and the following disclaimer.
42: * 2. Redistributions in binary form must reproduce the above copyright
43: * notice, this list of conditions and the following disclaimer in the
44: * documentation and/or other materials provided with the distribution.
45: * 3. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)rtsock.c 8.6 (Berkeley) 2/11/95
62: */
63:
64: #include <sys/param.h>
65: #include <sys/systm.h>
66: #include <sys/proc.h>
67: #include <sys/mbuf.h>
68: #include <sys/socket.h>
69: #include <sys/socketvar.h>
70: #include <sys/domain.h>
71: #include <sys/protosw.h>
72:
73: #include <uvm/uvm_extern.h>
74: #include <sys/sysctl.h>
75:
76: #include <net/if.h>
77: #include <net/route.h>
78: #include <net/raw_cb.h>
79:
80: #include <sys/stdarg.h>
81:
82: struct sockaddr route_dst = { 2, PF_ROUTE, };
83: struct sockaddr route_src = { 2, PF_ROUTE, };
84: struct sockproto route_proto = { PF_ROUTE, };
85:
86: struct walkarg {
87: int w_op, w_arg, w_given, w_needed, w_tmemsize;
88: caddr_t w_where, w_tmem;
89: };
90:
91: static struct mbuf
92: *rt_msg1(int, struct rt_addrinfo *);
93: static int rt_msg2(int, struct rt_addrinfo *, caddr_t, struct walkarg *);
94: static void rt_xaddrs(caddr_t, caddr_t, struct rt_addrinfo *);
95:
96: /* Sleazy use of local variables throughout file, warning!!!! */
97: #define dst info.rti_info[RTAX_DST]
98: #define gate info.rti_info[RTAX_GATEWAY]
99: #define netmask info.rti_info[RTAX_NETMASK]
100: #define genmask info.rti_info[RTAX_GENMASK]
101: #define ifpaddr info.rti_info[RTAX_IFP]
102: #define ifaaddr info.rti_info[RTAX_IFA]
103: #define brdaddr info.rti_info[RTAX_BRD]
104:
105: int
106: route_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
107: struct mbuf *control)
108: {
109: int error = 0;
110: struct rawcb *rp = sotorawcb(so);
111: int s;
112:
113: if (req == PRU_ATTACH) {
114: MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK);
115: so->so_pcb = rp;
116: bzero(so->so_pcb, sizeof(*rp));
117: }
118: if (req == PRU_DETACH && rp) {
119: int af = rp->rcb_proto.sp_protocol;
120: if (af == AF_INET)
121: route_cb.ip_count--;
122: else if (af == AF_INET6)
123: route_cb.ip6_count--;
124: route_cb.any_count--;
125: }
126: s = splsoftnet();
127: /*
128: * Don't call raw_usrreq() in the attach case, because
129: * we want to allow non-privileged processes to listen on
130: * and send "safe" commands to the routing socket.
131: */
132: if (req == PRU_ATTACH) {
133: if (curproc == 0)
134: error = EACCES;
135: else
136: error = raw_attach(so, (int)(long)nam);
137: } else
138: error = raw_usrreq(so, req, m, nam, control);
139:
140: rp = sotorawcb(so);
141: if (req == PRU_ATTACH && rp) {
142: int af = rp->rcb_proto.sp_protocol;
143: if (error) {
144: free(rp, M_PCB);
145: splx(s);
146: return (error);
147: }
148: if (af == AF_INET)
149: route_cb.ip_count++;
150: else if (af == AF_INET6)
151: route_cb.ip6_count++;
152: rp->rcb_faddr = &route_src;
153: route_cb.any_count++;
154: soisconnected(so);
155: so->so_options |= SO_USELOOPBACK;
156: }
157: splx(s);
158: return (error);
159: }
160:
161: int
162: route_output(struct mbuf *m, ...)
163: {
164: struct rt_msghdr *rtm = NULL;
165: struct radix_node *rn = NULL;
166: struct rtentry *rt = NULL;
167: struct rtentry *saved_nrt = NULL;
168: struct radix_node_head *rnh;
169: struct rt_addrinfo info;
170: int len, error = 0;
171: struct ifnet *ifp = NULL;
172: struct ifaddr *ifa = NULL;
173: struct socket *so;
174: struct rawcb *rp = NULL;
175: struct sockaddr_rtlabel sa_rt;
176: const char *label;
177: va_list ap;
178: u_int tableid;
179:
180: va_start(ap, m);
181: so = va_arg(ap, struct socket *);
182: va_end(ap);
183:
184: if (m == 0 || ((m->m_len < sizeof(int32_t)) &&
185: (m = m_pullup(m, sizeof(int32_t))) == 0))
186: return (ENOBUFS);
187: if ((m->m_flags & M_PKTHDR) == 0)
188: panic("route_output");
189: len = m->m_pkthdr.len;
190: if (len < sizeof(*rtm) ||
191: len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
192: dst = 0;
193: error = EINVAL;
194: goto flush;
195: }
196: R_Malloc(rtm, struct rt_msghdr *, len);
197: if (rtm == 0) {
198: dst = 0;
199: error = ENOBUFS;
200: goto flush;
201: }
202: m_copydata(m, 0, len, (caddr_t)rtm);
203: if (rtm->rtm_version != RTM_VERSION) {
204: dst = 0;
205: error = EPROTONOSUPPORT;
206: goto flush;
207: }
208: rtm->rtm_pid = curproc->p_pid;
209:
210: tableid = rtm->rtm_tableid;
211: if (!rtable_exists(tableid)) {
212: if (rtm->rtm_type == RTM_ADD) {
213: if (rtable_add(tableid)) {
214: error = EINVAL;
215: goto flush;
216: }
217: } else {
218: error = EINVAL;
219: goto flush;
220: }
221: }
222:
223: bzero(&info, sizeof(info));
224: info.rti_addrs = rtm->rtm_addrs;
225: rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info);
226: info.rti_flags = rtm->rtm_flags;
227: if (dst == 0 || dst->sa_family >= AF_MAX ||
228: (gate != 0 && gate->sa_family >= AF_MAX)) {
229: error = EINVAL;
230: goto flush;
231: }
232: if (genmask) {
233: struct radix_node *t;
234: t = rn_addmask(genmask, 0, 1);
235: if (t && genmask->sa_len >=
236: ((struct sockaddr *)t->rn_key)->sa_len &&
237: Bcmp((caddr_t *)genmask + 1, (caddr_t *)t->rn_key + 1,
238: ((struct sockaddr *)t->rn_key)->sa_len) - 1)
239: genmask = (struct sockaddr *)(t->rn_key);
240: else {
241: error = ENOBUFS;
242: goto flush;
243: }
244: }
245:
246: /*
247: * Verify that the caller has the appropriate privilege; RTM_GET
248: * is the only operation the non-superuser is allowed.
249: */
250: if (rtm->rtm_type != RTM_GET && suser(curproc, 0) != 0) {
251: error = EACCES;
252: goto flush;
253: }
254:
255: switch (rtm->rtm_type) {
256: case RTM_ADD:
257: if (gate == 0) {
258: error = EINVAL;
259: goto flush;
260: }
261: error = rtrequest1(rtm->rtm_type, &info, &saved_nrt, tableid);
262: if (error == 0 && saved_nrt) {
263: rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
264: &saved_nrt->rt_rmx);
265: saved_nrt->rt_refcnt--;
266: saved_nrt->rt_genmask = genmask;
267: rtm->rtm_index = saved_nrt->rt_ifp->if_index;
268: }
269: break;
270: case RTM_DELETE:
271: error = rtrequest1(rtm->rtm_type, &info, &saved_nrt, tableid);
272: if (error == 0) {
273: (rt = saved_nrt)->rt_refcnt++;
274: goto report;
275: }
276: break;
277: case RTM_GET:
278: case RTM_CHANGE:
279: case RTM_LOCK:
280: if ((rnh = rt_gettable(dst->sa_family, tableid)) == NULL) {
281: error = EAFNOSUPPORT;
282: goto flush;
283: }
284: rn = rt_lookup(dst, netmask, tableid);
285: if (rn == NULL || (rn->rn_flags & RNF_ROOT) != 0) {
286: error = ESRCH;
287: goto flush;
288: }
289: rt = (struct rtentry *)rn;
290: #ifndef SMALL_KERNEL
291: /*
292: * for RTM_CHANGE/LOCK, if we got multipath routes,
293: * we require users to specify a matching RTAX_GATEWAY.
294: *
295: * for RTM_GET, gate is optional even with multipath.
296: * if gate == NULL the first match is returned.
297: * (no need to call rt_mpath_matchgate if gate == NULL)
298: */
299: if (rn_mpath_capable(rnh) &&
300: (rtm->rtm_type != RTM_GET || gate)) {
301: rt = rt_mpath_matchgate(rt, gate);
302: rn = (struct radix_node *)rt;
303: if (!rt) {
304: error = ESRCH;
305: goto flush;
306: }
307: }
308: #endif
309: rt->rt_refcnt++;
310:
311: /*
312: * RTM_CHANGE/LOCK need a perfect match, rn_lookup()
313: * returns a perfect match in case a netmask is specified.
314: * For host routes only a longest prefix match is returned
315: * so it is necessary to compare the existence of the netmaks.
316: * If both have a netmask rn_lookup() did a perfect match and
317: * if none of them have a netmask both are host routes which is
318: * also a perfect match.
319: */
320: if (rtm->rtm_type != RTM_GET && !rt_mask(rt) != !netmask) {
321: error = ESRCH;
322: goto flush;
323: }
324:
325: switch (rtm->rtm_type) {
326: case RTM_GET:
327: report:
328: dst = rt_key(rt);
329: gate = rt->rt_gateway;
330: netmask = rt_mask(rt);
331: genmask = rt->rt_genmask;
332:
333: if (rt->rt_labelid) {
334: bzero(&sa_rt, sizeof(sa_rt));
335: sa_rt.sr_len = sizeof(sa_rt);
336: label = rtlabel_id2name(rt->rt_labelid);
337: if (label != NULL)
338: strlcpy(sa_rt.sr_label, label,
339: sizeof(sa_rt.sr_label));
340: info.rti_info[RTAX_LABEL] =
341: (struct sockaddr *)&sa_rt;
342: }
343:
344: ifpaddr = 0;
345: ifaaddr = 0;
346: if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA) &&
347: (ifp = rt->rt_ifp) != NULL) {
348: ifpaddr =
349: TAILQ_FIRST(&ifp->if_addrlist)->ifa_addr;
350: ifaaddr = rt->rt_ifa->ifa_addr;
351: if (ifp->if_flags & IFF_POINTOPOINT)
352: brdaddr = rt->rt_ifa->ifa_dstaddr;
353: else
354: brdaddr = 0;
355: rtm->rtm_index = ifp->if_index;
356: }
357: len = rt_msg2(rtm->rtm_type, &info, NULL, NULL);
358: if (len > rtm->rtm_msglen) {
359: struct rt_msghdr *new_rtm;
360: R_Malloc(new_rtm, struct rt_msghdr *, len);
361: if (new_rtm == 0) {
362: error = ENOBUFS;
363: goto flush;
364: }
365: Bcopy(rtm, new_rtm, rtm->rtm_msglen);
366: Free(rtm); rtm = new_rtm;
367: }
368: rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm, NULL);
369: rtm->rtm_flags = rt->rt_flags;
370: rtm->rtm_use = 0;
371: rt_getmetrics(&rt->rt_rmx, &rtm->rtm_rmx);
372: rtm->rtm_addrs = info.rti_addrs;
373: break;
374:
375: case RTM_CHANGE:
376: /*
377: * new gateway could require new ifaddr, ifp;
378: * flags may also be different; ifp may be specified
379: * by ll sockaddr when protocol address is ambiguous
380: */
381: if ((error = rt_getifa(&info)) != 0)
382: goto flush;
383: if (gate && rt_setgate(rt, rt_key(rt), gate, tableid)) {
384: error = EDQUOT;
385: goto flush;
386: }
387: if (ifpaddr && (ifa = ifa_ifwithnet(ifpaddr)) &&
388: (ifp = ifa->ifa_ifp) && (ifaaddr || gate))
389: ifa = ifaof_ifpforaddr(ifaaddr ? ifaaddr : gate,
390: ifp);
391: else if ((ifaaddr && (ifa = ifa_ifwithaddr(ifaaddr))) ||
392: (gate && (ifa = ifa_ifwithroute(rt->rt_flags,
393: rt_key(rt), gate))))
394: ifp = ifa->ifa_ifp;
395: if (ifa) {
396: struct ifaddr *oifa = rt->rt_ifa;
397: if (oifa != ifa) {
398: if (oifa && oifa->ifa_rtrequest)
399: oifa->ifa_rtrequest(RTM_DELETE, rt,
400: &info);
401: IFAFREE(rt->rt_ifa);
402: rt->rt_ifa = ifa;
403: ifa->ifa_refcnt++;
404: rt->rt_ifp = ifp;
405: }
406: }
407:
408: /* XXX Hack to allow some flags to be toggled */
409: if (rtm->rtm_fmask & RTF_FMASK)
410: rt->rt_flags = (rt->rt_flags &
411: ~rtm->rtm_fmask) |
412: (rtm->rtm_flags & rtm->rtm_fmask);
413:
414: rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
415: &rt->rt_rmx);
416: rtm->rtm_index = rt->rt_ifp->if_index;
417: if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
418: rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, &info);
419: if (genmask)
420: rt->rt_genmask = genmask;
421: if (info.rti_info[RTAX_LABEL] != NULL) {
422: char *rtlabel = ((struct sockaddr_rtlabel *)
423: info.rti_info[RTAX_LABEL])->sr_label;
424: rtlabel_unref(rt->rt_labelid);
425: rt->rt_labelid =
426: rtlabel_name2id(rtlabel);
427: }
428: if_group_routechange(dst, netmask);
429: /* FALLTHROUGH */
430: case RTM_LOCK:
431: rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
432: rt->rt_rmx.rmx_locks |=
433: (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
434: break;
435: }
436: break;
437:
438: default:
439: error = EOPNOTSUPP;
440: break;
441: }
442:
443: flush:
444: if (rtm) {
445: if (error)
446: rtm->rtm_errno = error;
447: else
448: rtm->rtm_flags |= RTF_DONE;
449: }
450: if (rt)
451: rtfree(rt);
452:
453: /*
454: * Check to see if we don't want our own messages.
455: */
456: if (!(so->so_options & SO_USELOOPBACK)) {
457: if (route_cb.any_count <= 1) {
458: if (rtm)
459: Free(rtm);
460: m_freem(m);
461: return (error);
462: }
463: /* There is another listener, so construct message */
464: rp = sotorawcb(so);
465: }
466: if (rp)
467: rp->rcb_proto.sp_family = 0; /* Avoid us */
468: if (dst)
469: route_proto.sp_protocol = dst->sa_family;
470: if (rtm) {
471: m_copyback(m, 0, rtm->rtm_msglen, rtm);
472: if (m->m_pkthdr.len < rtm->rtm_msglen) {
473: m_freem(m);
474: m = NULL;
475: } else if (m->m_pkthdr.len > rtm->rtm_msglen)
476: m_adj(m, rtm->rtm_msglen - m->m_pkthdr.len);
477: Free(rtm);
478: }
479: if (m)
480: raw_input(m, &route_proto, &route_src, &route_dst);
481: if (rp)
482: rp->rcb_proto.sp_family = PF_ROUTE;
483:
484: return (error);
485: }
486:
487: void
488: rt_setmetrics(u_long which, struct rt_metrics *in, struct rt_kmetrics *out)
489: {
490: if (which & RTV_MTU)
491: out->rmx_mtu = in->rmx_mtu;
492: if (which & RTV_EXPIRE)
493: out->rmx_expire = in->rmx_expire;
494: }
495:
496: void
497: rt_getmetrics(struct rt_kmetrics *in, struct rt_metrics *out)
498: {
499: bzero(out, sizeof(*out));
500: out->rmx_locks = in->rmx_locks;
501: out->rmx_mtu = in->rmx_mtu;
502: out->rmx_expire = in->rmx_expire;
503: out->rmx_pksent = in->rmx_pksent;
504: }
505:
506: #define ROUNDUP(a) \
507: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
508: #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
509:
510: static void
511: rt_xaddrs(caddr_t cp, caddr_t cplim, struct rt_addrinfo *rtinfo)
512: {
513: struct sockaddr *sa;
514: int i;
515:
516: bzero(rtinfo->rti_info, sizeof(rtinfo->rti_info));
517: for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
518: if ((rtinfo->rti_addrs & (1 << i)) == 0)
519: continue;
520: rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
521: ADVANCE(cp, sa);
522: }
523: }
524:
525: static struct mbuf *
526: rt_msg1(int type, struct rt_addrinfo *rtinfo)
527: {
528: struct rt_msghdr *rtm;
529: struct mbuf *m;
530: int i;
531: struct sockaddr *sa;
532: int len, dlen;
533:
534: switch (type) {
535: case RTM_DELADDR:
536: case RTM_NEWADDR:
537: len = sizeof(struct ifa_msghdr);
538: break;
539: case RTM_IFINFO:
540: len = sizeof(struct if_msghdr);
541: break;
542: case RTM_IFANNOUNCE:
543: len = sizeof(struct if_announcemsghdr);
544: break;
545: default:
546: len = sizeof(struct rt_msghdr);
547: break;
548: }
549: if (len > MCLBYTES)
550: panic("rt_msg1");
551: m = m_gethdr(M_DONTWAIT, MT_DATA);
552: if (m && len > MHLEN) {
553: MCLGET(m, M_DONTWAIT);
554: if ((m->m_flags & M_EXT) == 0) {
555: m_free(m);
556: m = NULL;
557: }
558: }
559: if (m == 0)
560: return (m);
561: m->m_pkthdr.len = m->m_len = len;
562: m->m_pkthdr.rcvif = NULL;
563: rtm = mtod(m, struct rt_msghdr *);
564: bzero(rtm, len);
565: for (i = 0; i < RTAX_MAX; i++) {
566: if ((sa = rtinfo->rti_info[i]) == NULL)
567: continue;
568: rtinfo->rti_addrs |= (1 << i);
569: dlen = ROUNDUP(sa->sa_len);
570: m_copyback(m, len, dlen, sa);
571: len += dlen;
572: }
573: if (m->m_pkthdr.len != len) {
574: m_freem(m);
575: return (NULL);
576: }
577: rtm->rtm_msglen = len;
578: rtm->rtm_version = RTM_VERSION;
579: rtm->rtm_type = type;
580: return (m);
581: }
582:
583: static int
584: rt_msg2(int type, struct rt_addrinfo *rtinfo, caddr_t cp, struct walkarg *w)
585: {
586: int i;
587: int len, dlen, second_time = 0;
588: caddr_t cp0;
589:
590: rtinfo->rti_addrs = 0;
591: again:
592: switch (type) {
593: case RTM_DELADDR:
594: case RTM_NEWADDR:
595: len = sizeof(struct ifa_msghdr);
596: break;
597: case RTM_IFINFO:
598: len = sizeof(struct if_msghdr);
599: break;
600: default:
601: len = sizeof(struct rt_msghdr);
602: break;
603: }
604: if ((cp0 = cp) != NULL)
605: cp += len;
606: for (i = 0; i < RTAX_MAX; i++) {
607: struct sockaddr *sa;
608:
609: if ((sa = rtinfo->rti_info[i]) == 0)
610: continue;
611: rtinfo->rti_addrs |= (1 << i);
612: dlen = ROUNDUP(sa->sa_len);
613: if (cp) {
614: bcopy(sa, cp, (size_t)dlen);
615: cp += dlen;
616: }
617: len += dlen;
618: }
619: if (cp == 0 && w != NULL && !second_time) {
620: struct walkarg *rw = w;
621:
622: rw->w_needed += len;
623: if (rw->w_needed <= 0 && rw->w_where) {
624: if (rw->w_tmemsize < len) {
625: if (rw->w_tmem)
626: free(rw->w_tmem, M_RTABLE);
627: rw->w_tmem = malloc(len, M_RTABLE, M_NOWAIT);
628: if (rw->w_tmem)
629: rw->w_tmemsize = len;
630: }
631: if (rw->w_tmem) {
632: cp = rw->w_tmem;
633: second_time = 1;
634: goto again;
635: } else
636: rw->w_where = 0;
637: }
638: }
639: if (cp) {
640: struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
641:
642: rtm->rtm_version = RTM_VERSION;
643: rtm->rtm_type = type;
644: rtm->rtm_msglen = len;
645: }
646: return (len);
647: }
648:
649: /*
650: * This routine is called to generate a message from the routing
651: * socket indicating that a redirect has occurred, a routing lookup
652: * has failed, or that a protocol has detected timeouts to a particular
653: * destination.
654: */
655: void
656: rt_missmsg(int type, struct rt_addrinfo *rtinfo, int flags,
657: struct ifnet *ifp, int error, u_int tableid)
658: {
659: struct rt_msghdr *rtm;
660: struct mbuf *m;
661: struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
662:
663: if (route_cb.any_count == 0)
664: return;
665: m = rt_msg1(type, rtinfo);
666: if (m == 0)
667: return;
668: rtm = mtod(m, struct rt_msghdr *);
669: rtm->rtm_flags = RTF_DONE | flags;
670: rtm->rtm_errno = error;
671: rtm->rtm_tableid = tableid;
672: rtm->rtm_addrs = rtinfo->rti_addrs;
673: if (ifp != NULL)
674: rtm->rtm_index = ifp->if_index;
675: if (sa == NULL)
676: route_proto.sp_protocol = 0;
677: else
678: route_proto.sp_protocol = sa->sa_family;
679: raw_input(m, &route_proto, &route_src, &route_dst);
680: }
681:
682: /*
683: * This routine is called to generate a message from the routing
684: * socket indicating that the status of a network interface has changed.
685: */
686: void
687: rt_ifmsg(struct ifnet *ifp)
688: {
689: struct if_msghdr *ifm;
690: struct mbuf *m;
691: struct rt_addrinfo info;
692:
693: if (route_cb.any_count == 0)
694: return;
695: bzero(&info, sizeof(info));
696: m = rt_msg1(RTM_IFINFO, &info);
697: if (m == 0)
698: return;
699: ifm = mtod(m, struct if_msghdr *);
700: ifm->ifm_index = ifp->if_index;
701: ifm->ifm_flags = ifp->if_flags;
702: ifm->ifm_data = ifp->if_data;
703: ifm->ifm_addrs = 0;
704: route_proto.sp_protocol = 0;
705: raw_input(m, &route_proto, &route_src, &route_dst);
706: }
707:
708: /*
709: * This is called to generate messages from the routing socket
710: * indicating a network interface has had addresses associated with it.
711: * if we ever reverse the logic and replace messages TO the routing
712: * socket indicate a request to configure interfaces, then it will
713: * be unnecessary as the routing socket will automatically generate
714: * copies of it.
715: */
716: void
717: rt_newaddrmsg(int cmd, struct ifaddr *ifa, int error, struct rtentry *rt)
718: {
719: struct rt_addrinfo info;
720: struct sockaddr *sa = NULL;
721: int pass;
722: struct mbuf *m = NULL;
723: struct ifnet *ifp = ifa->ifa_ifp;
724:
725: if (route_cb.any_count == 0)
726: return;
727: for (pass = 1; pass < 3; pass++) {
728: bzero(&info, sizeof(info));
729: if ((cmd == RTM_ADD && pass == 1) ||
730: (cmd == RTM_DELETE && pass == 2)) {
731: struct ifa_msghdr *ifam;
732: int ncmd;
733:
734: if (cmd == RTM_ADD)
735: ncmd = RTM_NEWADDR;
736: else
737: ncmd = RTM_DELADDR;
738:
739: ifaaddr = sa = ifa->ifa_addr;
740: ifpaddr = TAILQ_FIRST(&ifp->if_addrlist)->ifa_addr;
741: netmask = ifa->ifa_netmask;
742: brdaddr = ifa->ifa_dstaddr;
743: if ((m = rt_msg1(ncmd, &info)) == NULL)
744: continue;
745: ifam = mtod(m, struct ifa_msghdr *);
746: ifam->ifam_index = ifp->if_index;
747: ifam->ifam_metric = ifa->ifa_metric;
748: ifam->ifam_flags = ifa->ifa_flags;
749: ifam->ifam_addrs = info.rti_addrs;
750: }
751: if ((cmd == RTM_ADD && pass == 2) ||
752: (cmd == RTM_DELETE && pass == 1)) {
753: struct rt_msghdr *rtm;
754:
755: if (rt == 0)
756: continue;
757: netmask = rt_mask(rt);
758: dst = sa = rt_key(rt);
759: gate = rt->rt_gateway;
760: if ((m = rt_msg1(cmd, &info)) == NULL)
761: continue;
762: rtm = mtod(m, struct rt_msghdr *);
763: rtm->rtm_index = ifp->if_index;
764: rtm->rtm_flags |= rt->rt_flags;
765: rtm->rtm_errno = error;
766: rtm->rtm_addrs = info.rti_addrs;
767: }
768: if (sa == NULL)
769: route_proto.sp_protocol = 0;
770: else
771: route_proto.sp_protocol = sa->sa_family;
772: raw_input(m, &route_proto, &route_src, &route_dst);
773: }
774: }
775:
776: /*
777: * This is called to generate routing socket messages indicating
778: * network interface arrival and departure.
779: */
780: void
781: rt_ifannouncemsg(struct ifnet *ifp, int what)
782: {
783: struct if_announcemsghdr *ifan;
784: struct mbuf *m;
785: struct rt_addrinfo info;
786:
787: if (route_cb.any_count == 0)
788: return;
789: bzero(&info, sizeof(info));
790: m = rt_msg1(RTM_IFANNOUNCE, &info);
791: if (m == 0)
792: return;
793: ifan = mtod(m, struct if_announcemsghdr *);
794: ifan->ifan_index = ifp->if_index;
795: strlcpy(ifan->ifan_name, ifp->if_xname, sizeof(ifan->ifan_name));
796: ifan->ifan_what = what;
797: route_proto.sp_protocol = 0;
798: raw_input(m, &route_proto, &route_src, &route_dst);
799: }
800:
801: /*
802: * This is used in dumping the kernel table via sysctl().
803: */
804: int
805: sysctl_dumpentry(struct radix_node *rn, void *v)
806: {
807: struct walkarg *w = v;
808: struct rtentry *rt = (struct rtentry *)rn;
809: int error = 0, size;
810: struct rt_addrinfo info;
811: struct sockaddr_rtlabel sa_rt;
812: const char *label;
813:
814: if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
815: return 0;
816: bzero(&info, sizeof(info));
817: dst = rt_key(rt);
818: gate = rt->rt_gateway;
819: netmask = rt_mask(rt);
820: genmask = rt->rt_genmask;
821: if (rt->rt_ifp) {
822: ifpaddr = TAILQ_FIRST(&rt->rt_ifp->if_addrlist)->ifa_addr;
823: ifaaddr = rt->rt_ifa->ifa_addr;
824: if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
825: brdaddr = rt->rt_ifa->ifa_dstaddr;
826: }
827: if (rt->rt_labelid) {
828: bzero(&sa_rt, sizeof(sa_rt));
829: sa_rt.sr_len = sizeof(sa_rt);
830: label = rtlabel_id2name(rt->rt_labelid);
831: if (label != NULL) {
832: strlcpy(sa_rt.sr_label, label,
833: sizeof(sa_rt.sr_label));
834: info.rti_info[RTAX_LABEL] =
835: (struct sockaddr *)&sa_rt;
836: }
837: }
838:
839: size = rt_msg2(RTM_GET, &info, NULL, w);
840: if (w->w_where && w->w_tmem && w->w_needed <= 0) {
841: struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
842:
843: rtm->rtm_flags = rt->rt_flags;
844: rtm->rtm_use = 0;
845: rt_getmetrics(&rt->rt_rmx, &rtm->rtm_rmx);
846: rtm->rtm_rmx.rmx_refcnt = (u_long)rt->rt_refcnt;
847: rtm->rtm_index = rt->rt_ifp->if_index;
848: rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
849: rtm->rtm_addrs = info.rti_addrs;
850: if ((error = copyout(rtm, w->w_where, size)) != 0)
851: w->w_where = NULL;
852: else
853: w->w_where += size;
854: }
855: return (error);
856: }
857:
858: int
859: sysctl_iflist(int af, struct walkarg *w)
860: {
861: struct ifnet *ifp;
862: struct ifaddr *ifa;
863: struct rt_addrinfo info;
864: int len, error = 0;
865:
866: bzero(&info, sizeof(info));
867: TAILQ_FOREACH(ifp, &ifnet, if_list) {
868: if (w->w_arg && w->w_arg != ifp->if_index)
869: continue;
870: ifa = TAILQ_FIRST(&ifp->if_addrlist);
871: if (!ifa)
872: continue;
873: ifpaddr = ifa->ifa_addr;
874: len = rt_msg2(RTM_IFINFO, &info, 0, w);
875: ifpaddr = 0;
876: if (w->w_where && w->w_tmem && w->w_needed <= 0) {
877: struct if_msghdr *ifm;
878:
879: ifm = (struct if_msghdr *)w->w_tmem;
880: ifm->ifm_index = ifp->if_index;
881: ifm->ifm_flags = ifp->if_flags;
882: ifm->ifm_data = ifp->if_data;
883: ifm->ifm_addrs = info.rti_addrs;
884: error = copyout(ifm, w->w_where, len);
885: if (error)
886: return (error);
887: w->w_where += len;
888: }
889: while ((ifa = TAILQ_NEXT(ifa, ifa_list)) !=
890: TAILQ_END(&ifp->if_addrlist)) {
891: if (af && af != ifa->ifa_addr->sa_family)
892: continue;
893: ifaaddr = ifa->ifa_addr;
894: netmask = ifa->ifa_netmask;
895: brdaddr = ifa->ifa_dstaddr;
896: len = rt_msg2(RTM_NEWADDR, &info, 0, w);
897: if (w->w_where && w->w_tmem && w->w_needed <= 0) {
898: struct ifa_msghdr *ifam;
899:
900: ifam = (struct ifa_msghdr *)w->w_tmem;
901: ifam->ifam_index = ifa->ifa_ifp->if_index;
902: ifam->ifam_flags = ifa->ifa_flags;
903: ifam->ifam_metric = ifa->ifa_metric;
904: ifam->ifam_addrs = info.rti_addrs;
905: error = copyout(w->w_tmem, w->w_where, len);
906: if (error)
907: return (error);
908: w->w_where += len;
909: }
910: }
911: ifaaddr = netmask = brdaddr = 0;
912: }
913: return (0);
914: }
915:
916: int
917: sysctl_rtable(int *name, u_int namelen, void *where, size_t *given, void *new,
918: size_t newlen)
919: {
920: struct radix_node_head *rnh;
921: int i, s, error = EINVAL;
922: u_char af;
923: struct walkarg w;
924: u_int tableid = 0;
925:
926: if (new)
927: return (EPERM);
928: if (namelen < 3 || namelen > 4)
929: return (EINVAL);
930: af = name[0];
931: bzero(&w, sizeof(w));
932: w.w_where = where;
933: w.w_given = *given;
934: w.w_needed = 0 - w.w_given;
935: w.w_op = name[1];
936: w.w_arg = name[2];
937:
938: if (namelen == 4) {
939: tableid = name[3];
940: if (!rtable_exists(tableid))
941: return (EINVAL);
942: }
943:
944: s = splsoftnet();
945: switch (w.w_op) {
946:
947: case NET_RT_DUMP:
948: case NET_RT_FLAGS:
949: for (i = 1; i <= AF_MAX; i++)
950: if ((rnh = rt_gettable(i, tableid)) != NULL &&
951: (af == 0 || af == i) &&
952: (error = (*rnh->rnh_walktree)(rnh,
953: sysctl_dumpentry, &w)))
954: break;
955: break;
956:
957: case NET_RT_IFLIST:
958: error = sysctl_iflist(af, &w);
959: break;
960:
961: case NET_RT_STATS:
962: error = sysctl_rdstruct(where, given, new,
963: &rtstat, sizeof(rtstat));
964: splx(s);
965: return (error);
966: }
967: splx(s);
968: if (w.w_tmem)
969: free(w.w_tmem, M_RTABLE);
970: w.w_needed += w.w_given;
971: if (where) {
972: *given = w.w_where - (caddr_t)where;
973: if (*given < w.w_needed)
974: return (ENOMEM);
975: } else
976: *given = (11 * w.w_needed) / 10;
977:
978: return (error);
979: }
980:
981: /*
982: * Definitions of protocols supported in the ROUTE domain.
983: */
984:
985: extern struct domain routedomain; /* or at least forward */
986:
987: struct protosw routesw[] = {
988: { SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR,
989: raw_input, route_output, raw_ctlinput, 0,
990: route_usrreq,
991: raw_init, 0, 0, 0,
992: sysctl_rtable,
993: }
994: };
995:
996: struct domain routedomain =
997: { PF_ROUTE, "route", route_init, 0, 0,
998: routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] };