1fb535254Ssklower /*
2f46d860eSbostic * Copyright (c) 1988, 1991, 1993
3f46d860eSbostic * The Regents of the University of California. All rights reserved.
4fb535254Ssklower *
59c0eca3fSbostic * %sccs.include.redist.c%
6fb535254Ssklower *
7*414f0486Ssklower * @(#)rtsock.c 8.6.1.1 (Berkeley) 02/23/95
8fb535254Ssklower */
9fb535254Ssklower
108c2b5e40Sbostic #include <sys/param.h>
118c2b5e40Sbostic #include <sys/systm.h>
128c2b5e40Sbostic #include <sys/proc.h>
138c2b5e40Sbostic #include <sys/mbuf.h>
148c2b5e40Sbostic #include <sys/socket.h>
158c2b5e40Sbostic #include <sys/socketvar.h>
168c2b5e40Sbostic #include <sys/domain.h>
178c2b5e40Sbostic #include <sys/protosw.h>
18fb535254Ssklower
198c2b5e40Sbostic #include <net/if.h>
208c2b5e40Sbostic #include <net/route.h>
218c2b5e40Sbostic #include <net/raw_cb.h>
22fb535254Ssklower
23d40b2f9cSsklower struct sockaddr route_dst = { 2, PF_ROUTE, };
24d40b2f9cSsklower struct sockaddr route_src = { 2, PF_ROUTE, };
25a18e9fd3Ssklower struct sockproto route_proto = { PF_ROUTE, };
26a18e9fd3Ssklower
27119428f9Ssklower struct walkarg {
28119428f9Ssklower int w_op, w_arg, w_given, w_needed, w_tmemsize;
29119428f9Ssklower caddr_t w_where, w_tmem;
30119428f9Ssklower };
31119428f9Ssklower
32dba6ed9fSbostic static struct mbuf *
33dba6ed9fSbostic rt_msg1 __P((int, struct rt_addrinfo *));
34dba6ed9fSbostic static int rt_msg2 __P((int,
35dba6ed9fSbostic struct rt_addrinfo *, caddr_t, struct walkarg *));
36*414f0486Ssklower void rt_xaddrs __P((caddr_t, caddr_t, struct rt_addrinfo *));
37*414f0486Ssklower void m_copyback __P((struct mbuf *, int, int, caddr_t));
38119428f9Ssklower
39119428f9Ssklower /* Sleazy use of local variables throughout file, warning!!!! */
40119428f9Ssklower #define dst info.rti_info[RTAX_DST]
41119428f9Ssklower #define gate info.rti_info[RTAX_GATEWAY]
42119428f9Ssklower #define netmask info.rti_info[RTAX_NETMASK]
43119428f9Ssklower #define genmask info.rti_info[RTAX_GENMASK]
44119428f9Ssklower #define ifpaddr info.rti_info[RTAX_IFP]
45119428f9Ssklower #define ifaaddr info.rti_info[RTAX_IFA]
46119428f9Ssklower #define brdaddr info.rti_info[RTAX_BRD]
47119428f9Ssklower
48fb535254Ssklower /*ARGSUSED*/
49dba6ed9fSbostic int
route_usrreq(so,req,m,nam,control)5056c9ebd9Ssklower route_usrreq(so, req, m, nam, control)
51fb535254Ssklower register struct socket *so;
52fb535254Ssklower int req;
5356c9ebd9Ssklower struct mbuf *m, *nam, *control;
54fb535254Ssklower {
55fb535254Ssklower register int error = 0;
56fb535254Ssklower register struct rawcb *rp = sotorawcb(so);
570c9210b5Ssklower int s;
584a6e0ac3Ssklower
59a18e9fd3Ssklower if (req == PRU_ATTACH) {
60a18e9fd3Ssklower MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK);
61a18e9fd3Ssklower if (so->so_pcb = (caddr_t)rp)
62a18e9fd3Ssklower bzero(so->so_pcb, sizeof(*rp));
63a18e9fd3Ssklower
64a18e9fd3Ssklower }
65fb535254Ssklower if (req == PRU_DETACH && rp) {
66fb535254Ssklower int af = rp->rcb_proto.sp_protocol;
67fb535254Ssklower if (af == AF_INET)
68fb535254Ssklower route_cb.ip_count--;
69fb535254Ssklower else if (af == AF_NS)
70fb535254Ssklower route_cb.ns_count--;
71fb535254Ssklower else if (af == AF_ISO)
72fb535254Ssklower route_cb.iso_count--;
73fb535254Ssklower route_cb.any_count--;
74fb535254Ssklower }
750c9210b5Ssklower s = splnet();
7656c9ebd9Ssklower error = raw_usrreq(so, req, m, nam, control);
77fb535254Ssklower rp = sotorawcb(so);
78a18e9fd3Ssklower if (req == PRU_ATTACH && rp) {
79fb535254Ssklower int af = rp->rcb_proto.sp_protocol;
80a18e9fd3Ssklower if (error) {
81a18e9fd3Ssklower free((caddr_t)rp, M_PCB);
820c9210b5Ssklower splx(s);
83a18e9fd3Ssklower return (error);
84a18e9fd3Ssklower }
85fb535254Ssklower if (af == AF_INET)
86fb535254Ssklower route_cb.ip_count++;
87fb535254Ssklower else if (af == AF_NS)
88fb535254Ssklower route_cb.ns_count++;
89fb535254Ssklower else if (af == AF_ISO)
90fb535254Ssklower route_cb.iso_count++;
91a18e9fd3Ssklower rp->rcb_faddr = &route_src;
92fb535254Ssklower route_cb.any_count++;
93fb535254Ssklower soisconnected(so);
94a3858138Ssklower so->so_options |= SO_USELOOPBACK;
95fb535254Ssklower }
960c9210b5Ssklower splx(s);
97fb535254Ssklower return (error);
98fb535254Ssklower }
99fb535254Ssklower
100a18e9fd3Ssklower /*ARGSUSED*/
101dba6ed9fSbostic int
route_output(m,so)102fb535254Ssklower route_output(m, so)
103fb535254Ssklower register struct mbuf *m;
104fb535254Ssklower struct socket *so;
105fb535254Ssklower {
1060c9210b5Ssklower register struct rt_msghdr *rtm = 0;
107fb535254Ssklower register struct rtentry *rt = 0;
10856c9ebd9Ssklower struct rtentry *saved_nrt = 0;
1094a6e0ac3Ssklower struct radix_node_head *rnh;
110119428f9Ssklower struct rt_addrinfo info;
111a18e9fd3Ssklower int len, error = 0;
11207c1dabdSsklower struct ifnet *ifp = 0;
113af0a4232Ssklower struct ifaddr *ifa = 0;
114fb535254Ssklower
11556c9ebd9Ssklower #define senderr(e) { error = e; goto flush;}
116a1e152e7Ssklower if (m == 0 || ((m->m_len < sizeof(long)) &&
117a1e152e7Ssklower (m = m_pullup(m, sizeof(long))) == 0))
118c7087cbbSsklower return (ENOBUFS);
119fb535254Ssklower if ((m->m_flags & M_PKTHDR) == 0)
120c7087cbbSsklower panic("route_output");
121fb535254Ssklower len = m->m_pkthdr.len;
1220c9210b5Ssklower if (len < sizeof(*rtm) ||
12389d98884Sralph len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
12489d98884Sralph dst = 0;
12556c9ebd9Ssklower senderr(EINVAL);
12689d98884Sralph }
127fb535254Ssklower R_Malloc(rtm, struct rt_msghdr *, len);
12889d98884Sralph if (rtm == 0) {
12989d98884Sralph dst = 0;
13056c9ebd9Ssklower senderr(ENOBUFS);
13189d98884Sralph }
132fb535254Ssklower m_copydata(m, 0, len, (caddr_t)rtm);
13389d98884Sralph if (rtm->rtm_version != RTM_VERSION) {
13489d98884Sralph dst = 0;
13556c9ebd9Ssklower senderr(EPROTONOSUPPORT);
13689d98884Sralph }
137bddb4192Ssklower rtm->rtm_pid = curproc->p_pid;
138119428f9Ssklower info.rti_addrs = rtm->rtm_addrs;
1394a6e0ac3Ssklower rt_xaddrs((caddr_t)(rtm + 1), len + (caddr_t)rtm, &info);
140*414f0486Ssklower info.rti_flags = rtm->rtm_flags;
141119428f9Ssklower if (dst == 0)
1424b69c13bSsklower senderr(EINVAL);
143119428f9Ssklower if (genmask) {
144dba6ed9fSbostic struct radix_node *t;
1454a6e0ac3Ssklower t = rn_addmask((caddr_t)genmask, 0, 1);
14607c1dabdSsklower if (t && Bcmp(genmask, t->rn_key, *(u_char *)genmask) == 0)
14707c1dabdSsklower genmask = (struct sockaddr *)(t->rn_key);
14807c1dabdSsklower else
14907c1dabdSsklower senderr(ENOBUFS);
15007c1dabdSsklower }
151fb535254Ssklower switch (rtm->rtm_type) {
152119428f9Ssklower
153*414f0486Ssklower case RTM_ADDPKT:
154fb535254Ssklower case RTM_ADD:
1554b69c13bSsklower if (gate == 0)
1564b69c13bSsklower senderr(EINVAL);
157*414f0486Ssklower error = rtrequest1(rtm->rtm_type, &info, &saved_nrt);
1584b69c13bSsklower if (error == 0 && saved_nrt) {
1594b69c13bSsklower rt_setmetrics(rtm->rtm_inits,
1604b69c13bSsklower &rtm->rtm_rmx, &saved_nrt->rt_rmx);
16156c9ebd9Ssklower saved_nrt->rt_refcnt--;
16207c1dabdSsklower saved_nrt->rt_genmask = genmask;
1634b69c13bSsklower }
164fb535254Ssklower break;
165fb535254Ssklower
166*414f0486Ssklower case RTM_DELPKT:
167fb535254Ssklower case RTM_DELETE:
168*414f0486Ssklower error = rtrequest1(rtm->rtm_type, &info, &saved_nrt);
1694a6e0ac3Ssklower if (error == 0) {
1704a6e0ac3Ssklower (rt = saved_nrt)->rt_refcnt++;
1714a6e0ac3Ssklower goto report;
172a25cb883Ssklower }
1734a6e0ac3Ssklower break;
1744a6e0ac3Ssklower
1754a6e0ac3Ssklower case RTM_GET:
1764a6e0ac3Ssklower case RTM_CHANGE:
1774a6e0ac3Ssklower case RTM_LOCK:
1784a6e0ac3Ssklower if ((rnh = rt_tables[dst->sa_family]) == 0) {
1794a6e0ac3Ssklower senderr(EAFNOSUPPORT);
1804a6e0ac3Ssklower } else if (rt = (struct rtentry *)
1814a6e0ac3Ssklower rnh->rnh_lookup(dst, netmask, rnh))
1824a6e0ac3Ssklower rt->rt_refcnt++;
1834a6e0ac3Ssklower else
1844a6e0ac3Ssklower senderr(ESRCH);
185fb535254Ssklower switch(rtm->rtm_type) {
186fb535254Ssklower
187fb535254Ssklower case RTM_GET:
1884a6e0ac3Ssklower report:
189119428f9Ssklower dst = rt_key(rt);
190119428f9Ssklower gate = rt->rt_gateway;
191119428f9Ssklower netmask = rt_mask(rt);
192119428f9Ssklower genmask = rt->rt_genmask;
19316ee7d90Ssklower if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) {
194119428f9Ssklower if (ifp = rt->rt_ifp) {
195119428f9Ssklower ifpaddr = ifp->if_addrlist->ifa_addr;
19616ee7d90Ssklower ifaaddr = rt->rt_ifa->ifa_addr;
1974a6e0ac3Ssklower if (ifp->if_flags & IFF_POINTOPOINT)
1984a6e0ac3Ssklower brdaddr = rt->rt_ifa->ifa_dstaddr;
1994a6e0ac3Ssklower else
2004a6e0ac3Ssklower brdaddr = 0;
201119428f9Ssklower rtm->rtm_index = ifp->if_index;
20216ee7d90Ssklower } else {
203119428f9Ssklower ifpaddr = 0;
204119428f9Ssklower ifaaddr = 0;
20516ee7d90Ssklower }
20616ee7d90Ssklower }
2074a6e0ac3Ssklower len = rt_msg2(rtm->rtm_type, &info, (caddr_t)0,
208119428f9Ssklower (struct walkarg *)0);
209fb535254Ssklower if (len > rtm->rtm_msglen) {
210fb535254Ssklower struct rt_msghdr *new_rtm;
211fb535254Ssklower R_Malloc(new_rtm, struct rt_msghdr *, len);
212fb535254Ssklower if (new_rtm == 0)
21356c9ebd9Ssklower senderr(ENOBUFS);
214fb535254Ssklower Bcopy(rtm, new_rtm, rtm->rtm_msglen);
215fb535254Ssklower Free(rtm); rtm = new_rtm;
216fb535254Ssklower }
2174a6e0ac3Ssklower (void)rt_msg2(rtm->rtm_type, &info, (caddr_t)rtm,
218119428f9Ssklower (struct walkarg *)0);
219da615975Ssklower rtm->rtm_flags = rt->rt_flags;
220da615975Ssklower rtm->rtm_rmx = rt->rt_rmx;
221f2a98e66Ssklower rtm->rtm_addrs = info.rti_addrs;
222fb535254Ssklower break;
223fb535254Ssklower
224fb535254Ssklower case RTM_CHANGE:
22507c1dabdSsklower /* new gateway could require new ifaddr, ifp;
22607c1dabdSsklower flags may also be different; ifp may be specified
22707c1dabdSsklower by ll sockaddr when protocol address is ambiguous */
228*414f0486Ssklower if (error = rt_getifa(&info))
229*414f0486Ssklower senderr(error);
230*414f0486Ssklower if (gate && rt_setgate(rt, rt_key(rt), gate))
231*414f0486Ssklower senderr(EDQUOT);
232*414f0486Ssklower if (ifa = info.rti_ifa) {
233af0a4232Ssklower register struct ifaddr *oifa = rt->rt_ifa;
234af0a4232Ssklower if (oifa != ifa) {
235af0a4232Ssklower if (oifa && oifa->ifa_rtrequest)
236af0a4232Ssklower oifa->ifa_rtrequest(RTM_DELETE,
237*414f0486Ssklower rt, &info);
2388ac7a5b0Ssklower IFAFREE(rt->rt_ifa);
239af0a4232Ssklower rt->rt_ifa = ifa;
2408ac7a5b0Ssklower ifa->ifa_refcnt++;
241*414f0486Ssklower rt->rt_ifp = info.rti_ifp;
242af0a4232Ssklower }
24307c1dabdSsklower }
244af0a4232Ssklower rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
245af0a4232Ssklower &rt->rt_rmx);
24607c1dabdSsklower if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
247*414f0486Ssklower rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, &info);
24807c1dabdSsklower if (genmask)
24907c1dabdSsklower rt->rt_genmask = genmask;
250fb535254Ssklower /*
251fb535254Ssklower * Fall into
252fb535254Ssklower */
2534b69c13bSsklower case RTM_LOCK:
2540866c4a9Ssklower rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
2554b69c13bSsklower rt->rt_rmx.rmx_locks |=
2564b69c13bSsklower (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
257fb535254Ssklower break;
258fb535254Ssklower }
259119428f9Ssklower break;
260fb535254Ssklower
261fb535254Ssklower default:
26256c9ebd9Ssklower senderr(EOPNOTSUPP);
263fb535254Ssklower }
264fb535254Ssklower
265fb535254Ssklower flush:
266fb535254Ssklower if (rtm) {
267fb535254Ssklower if (error)
268fb535254Ssklower rtm->rtm_errno = error;
269fb535254Ssklower else
270fb535254Ssklower rtm->rtm_flags |= RTF_DONE;
271fb535254Ssklower }
272fb535254Ssklower if (rt)
273fb535254Ssklower rtfree(rt);
274a3858138Ssklower {
275a3858138Ssklower register struct rawcb *rp = 0;
276a3858138Ssklower /*
277a3858138Ssklower * Check to see if we don't want our own messages.
278a3858138Ssklower */
279a3858138Ssklower if ((so->so_options & SO_USELOOPBACK) == 0) {
280a3858138Ssklower if (route_cb.any_count <= 1) {
281a3858138Ssklower if (rtm)
282a3858138Ssklower Free(rtm);
283a3858138Ssklower m_freem(m);
284a3858138Ssklower return (error);
285a3858138Ssklower }
286a3858138Ssklower /* There is another listener, so construct message */
287a3858138Ssklower rp = sotorawcb(so);
288a3858138Ssklower }
28916ee7d90Ssklower if (rtm) {
29016ee7d90Ssklower m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm);
291c7087cbbSsklower Free(rtm);
292c7087cbbSsklower }
293a3858138Ssklower if (rp)
294a3858138Ssklower rp->rcb_proto.sp_family = 0; /* Avoid us */
295da615975Ssklower if (dst)
296fb535254Ssklower route_proto.sp_protocol = dst->sa_family;
297c7087cbbSsklower raw_input(m, &route_proto, &route_src, &route_dst);
298a3858138Ssklower if (rp)
299a3858138Ssklower rp->rcb_proto.sp_family = PF_ROUTE;
300a3858138Ssklower }
301fb535254Ssklower return (error);
302fb535254Ssklower }
303fb535254Ssklower
304dba6ed9fSbostic void
rt_setmetrics(which,in,out)30507c1dabdSsklower rt_setmetrics(which, in, out)
3064b69c13bSsklower u_long which;
3074b69c13bSsklower register struct rt_metrics *in, *out;
3084b69c13bSsklower {
3094b69c13bSsklower #define metric(f, e) if (which & (f)) out->e = in->e;
3104b69c13bSsklower metric(RTV_RPIPE, rmx_recvpipe);
3114b69c13bSsklower metric(RTV_SPIPE, rmx_sendpipe);
3124b69c13bSsklower metric(RTV_SSTHRESH, rmx_ssthresh);
3134b69c13bSsklower metric(RTV_RTT, rmx_rtt);
3144b69c13bSsklower metric(RTV_RTTVAR, rmx_rttvar);
3154b69c13bSsklower metric(RTV_HOPCOUNT, rmx_hopcount);
3164b69c13bSsklower metric(RTV_MTU, rmx_mtu);
31796ba4273Ssklower metric(RTV_EXPIRE, rmx_expire);
3184b69c13bSsklower #undef metric
3194b69c13bSsklower }
3204b69c13bSsklower
321119428f9Ssklower #define ROUNDUP(a) \
322119428f9Ssklower ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
323119428f9Ssklower #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
324119428f9Ssklower
325*414f0486Ssklower void
rt_xaddrs(cp,cplim,rtinfo)326119428f9Ssklower rt_xaddrs(cp, cplim, rtinfo)
327119428f9Ssklower register caddr_t cp, cplim;
328119428f9Ssklower register struct rt_addrinfo *rtinfo;
329119428f9Ssklower {
330119428f9Ssklower register struct sockaddr *sa;
331*414f0486Ssklower register int i, addrs = rtinfo->rti_addrs;
332119428f9Ssklower
333*414f0486Ssklower bzero(rtinfo, sizeof(*rtinfo));
334*414f0486Ssklower rtinfo->rti_addrs = addrs;
335119428f9Ssklower for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
336*414f0486Ssklower if ((addrs & (1 << i)) == 0)
337119428f9Ssklower continue;
338119428f9Ssklower rtinfo->rti_info[i] = sa = (struct sockaddr *)cp;
339119428f9Ssklower ADVANCE(cp, sa);
340119428f9Ssklower }
341*414f0486Ssklower rtinfo->rti_pkthdr = cp;
342119428f9Ssklower }
34389d98884Sralph
344fb535254Ssklower /*
345fb535254Ssklower * Copy data from a buffer back into the indicated mbuf chain,
346fb535254Ssklower * starting "off" bytes from the beginning, extending the mbuf
347fb535254Ssklower * chain if necessary.
348fb535254Ssklower */
349dba6ed9fSbostic void
m_copyback(m0,off,len,cp)350fb535254Ssklower m_copyback(m0, off, len, cp)
351fb535254Ssklower struct mbuf *m0;
352fb535254Ssklower register int off;
353fb535254Ssklower register int len;
354fb535254Ssklower caddr_t cp;
355fb535254Ssklower {
356fb535254Ssklower register int mlen;
357fb535254Ssklower register struct mbuf *m = m0, *n;
358fb535254Ssklower int totlen = 0;
359fb535254Ssklower
360fb535254Ssklower if (m0 == 0)
361fb535254Ssklower return;
362bddb4192Ssklower while (off > (mlen = m->m_len)) {
363fb535254Ssklower off -= mlen;
364fb535254Ssklower totlen += mlen;
365fb535254Ssklower if (m->m_next == 0) {
366fb535254Ssklower n = m_getclr(M_DONTWAIT, m->m_type);
367fb535254Ssklower if (n == 0)
368fb535254Ssklower goto out;
369fb535254Ssklower n->m_len = min(MLEN, len + off);
370fb535254Ssklower m->m_next = n;
371fb535254Ssklower }
372fb535254Ssklower m = m->m_next;
373fb535254Ssklower }
374fb535254Ssklower while (len > 0) {
375fb535254Ssklower mlen = min (m->m_len - off, len);
376a18e9fd3Ssklower bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen);
377fb535254Ssklower cp += mlen;
378fb535254Ssklower len -= mlen;
379fb535254Ssklower mlen += off;
380fb535254Ssklower off = 0;
381fb535254Ssklower totlen += mlen;
382fb535254Ssklower if (len == 0)
383fb535254Ssklower break;
384fb535254Ssklower if (m->m_next == 0) {
385fb535254Ssklower n = m_get(M_DONTWAIT, m->m_type);
386fb535254Ssklower if (n == 0)
387fb535254Ssklower break;
388fb535254Ssklower n->m_len = min(MLEN, len);
389fb535254Ssklower m->m_next = n;
390fb535254Ssklower }
391fb535254Ssklower m = m->m_next;
392fb535254Ssklower }
393fb535254Ssklower out: if (((m = m0)->m_flags & M_PKTHDR) && (m->m_pkthdr.len < totlen))
394fb535254Ssklower m->m_pkthdr.len = totlen;
395fb535254Ssklower }
396fb535254Ssklower
397119428f9Ssklower static struct mbuf *
rt_msg1(type,rtinfo)398119428f9Ssklower rt_msg1(type, rtinfo)
399119428f9Ssklower int type;
400119428f9Ssklower register struct rt_addrinfo *rtinfo;
401fb535254Ssklower {
402fb535254Ssklower register struct rt_msghdr *rtm;
403fb535254Ssklower register struct mbuf *m;
404119428f9Ssklower register int i;
405119428f9Ssklower register struct sockaddr *sa;
406119428f9Ssklower int len, dlen;
407fb535254Ssklower
408fb535254Ssklower m = m_gethdr(M_DONTWAIT, MT_DATA);
409fb535254Ssklower if (m == 0)
410119428f9Ssklower return (m);
411119428f9Ssklower switch (type) {
412119428f9Ssklower
413119428f9Ssklower case RTM_DELADDR:
414119428f9Ssklower case RTM_NEWADDR:
415119428f9Ssklower len = sizeof(struct ifa_msghdr);
416119428f9Ssklower break;
417119428f9Ssklower
418119428f9Ssklower case RTM_IFINFO:
419119428f9Ssklower len = sizeof(struct if_msghdr);
420119428f9Ssklower break;
421119428f9Ssklower
422119428f9Ssklower default:
423119428f9Ssklower len = sizeof(struct rt_msghdr);
424119428f9Ssklower }
425119428f9Ssklower if (len > MHLEN)
426119428f9Ssklower panic("rt_msg1");
427119428f9Ssklower m->m_pkthdr.len = m->m_len = len;
428fb535254Ssklower m->m_pkthdr.rcvif = 0;
429fb535254Ssklower rtm = mtod(m, struct rt_msghdr *);
430119428f9Ssklower bzero((caddr_t)rtm, len);
431119428f9Ssklower for (i = 0; i < RTAX_MAX; i++) {
432119428f9Ssklower if ((sa = rtinfo->rti_info[i]) == NULL)
433119428f9Ssklower continue;
434119428f9Ssklower rtinfo->rti_addrs |= (1 << i);
435119428f9Ssklower dlen = ROUNDUP(sa->sa_len);
436119428f9Ssklower m_copyback(m, len, dlen, (caddr_t)sa);
437fb535254Ssklower len += dlen;
438fb535254Ssklower }
439fb535254Ssklower if (m->m_pkthdr.len != len) {
440fb535254Ssklower m_freem(m);
441119428f9Ssklower return (NULL);
442fb535254Ssklower }
443fb535254Ssklower rtm->rtm_msglen = len;
444119428f9Ssklower rtm->rtm_version = RTM_VERSION;
445119428f9Ssklower rtm->rtm_type = type;
446119428f9Ssklower return (m);
447119428f9Ssklower }
448119428f9Ssklower
449119428f9Ssklower static int
rt_msg2(type,rtinfo,cp,w)450119428f9Ssklower rt_msg2(type, rtinfo, cp, w)
451119428f9Ssklower int type;
452119428f9Ssklower register struct rt_addrinfo *rtinfo;
453119428f9Ssklower caddr_t cp;
454119428f9Ssklower struct walkarg *w;
455119428f9Ssklower {
456119428f9Ssklower register int i;
457119428f9Ssklower int len, dlen, second_time = 0;
458119428f9Ssklower caddr_t cp0;
459119428f9Ssklower
460119428f9Ssklower rtinfo->rti_addrs = 0;
461119428f9Ssklower again:
462119428f9Ssklower switch (type) {
463119428f9Ssklower
464119428f9Ssklower case RTM_DELADDR:
465119428f9Ssklower case RTM_NEWADDR:
466119428f9Ssklower len = sizeof(struct ifa_msghdr);
467119428f9Ssklower break;
468119428f9Ssklower
469119428f9Ssklower case RTM_IFINFO:
470119428f9Ssklower len = sizeof(struct if_msghdr);
471119428f9Ssklower break;
472119428f9Ssklower
473119428f9Ssklower default:
474119428f9Ssklower len = sizeof(struct rt_msghdr);
475119428f9Ssklower }
476119428f9Ssklower if (cp0 = cp)
477119428f9Ssklower cp += len;
478119428f9Ssklower for (i = 0; i < RTAX_MAX; i++) {
479119428f9Ssklower register struct sockaddr *sa;
480119428f9Ssklower
481119428f9Ssklower if ((sa = rtinfo->rti_info[i]) == 0)
482119428f9Ssklower continue;
483119428f9Ssklower rtinfo->rti_addrs |= (1 << i);
484119428f9Ssklower dlen = ROUNDUP(sa->sa_len);
485119428f9Ssklower if (cp) {
486119428f9Ssklower bcopy((caddr_t)sa, cp, (unsigned)dlen);
487119428f9Ssklower cp += dlen;
488119428f9Ssklower }
489119428f9Ssklower len += dlen;
490119428f9Ssklower }
491119428f9Ssklower if (cp == 0 && w != NULL && !second_time) {
492119428f9Ssklower register struct walkarg *rw = w;
493119428f9Ssklower
494119428f9Ssklower rw->w_needed += len;
495119428f9Ssklower if (rw->w_needed <= 0 && rw->w_where) {
496119428f9Ssklower if (rw->w_tmemsize < len) {
497119428f9Ssklower if (rw->w_tmem)
498119428f9Ssklower free(rw->w_tmem, M_RTABLE);
499119428f9Ssklower if (rw->w_tmem = (caddr_t)
500119428f9Ssklower malloc(len, M_RTABLE, M_NOWAIT))
501119428f9Ssklower rw->w_tmemsize = len;
502119428f9Ssklower }
503119428f9Ssklower if (rw->w_tmem) {
504119428f9Ssklower cp = rw->w_tmem;
505119428f9Ssklower second_time = 1;
506119428f9Ssklower goto again;
507119428f9Ssklower } else
508119428f9Ssklower rw->w_where = 0;
509119428f9Ssklower }
510119428f9Ssklower }
511119428f9Ssklower if (cp) {
512119428f9Ssklower register struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
513119428f9Ssklower
514119428f9Ssklower rtm->rtm_version = RTM_VERSION;
515119428f9Ssklower rtm->rtm_type = type;
516119428f9Ssklower rtm->rtm_msglen = len;
517119428f9Ssklower }
518119428f9Ssklower return (len);
519119428f9Ssklower }
520119428f9Ssklower
521119428f9Ssklower /*
522119428f9Ssklower * This routine is called to generate a message from the routing
523119428f9Ssklower * socket indicating that a redirect has occured, a routing lookup
524119428f9Ssklower * has failed, or that a protocol has detected timeouts to a particular
525119428f9Ssklower * destination.
526119428f9Ssklower */
527dba6ed9fSbostic void
rt_missmsg(type,rtinfo,flags,error)528119428f9Ssklower rt_missmsg(type, rtinfo, flags, error)
529119428f9Ssklower int type, flags, error;
530119428f9Ssklower register struct rt_addrinfo *rtinfo;
531119428f9Ssklower {
532119428f9Ssklower register struct rt_msghdr *rtm;
533119428f9Ssklower register struct mbuf *m;
534119428f9Ssklower struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
535119428f9Ssklower
536119428f9Ssklower if (route_cb.any_count == 0)
537119428f9Ssklower return;
538119428f9Ssklower m = rt_msg1(type, rtinfo);
539119428f9Ssklower if (m == 0)
540119428f9Ssklower return;
541119428f9Ssklower rtm = mtod(m, struct rt_msghdr *);
542119428f9Ssklower rtm->rtm_flags = RTF_DONE | flags;
543119428f9Ssklower rtm->rtm_errno = error;
544119428f9Ssklower rtm->rtm_addrs = rtinfo->rti_addrs;
545119428f9Ssklower route_proto.sp_protocol = sa ? sa->sa_family : 0;
546fb535254Ssklower raw_input(m, &route_proto, &route_src, &route_dst);
547fb535254Ssklower }
548fb535254Ssklower
549119428f9Ssklower /*
550119428f9Ssklower * This routine is called to generate a message from the routing
551119428f9Ssklower * socket indicating that the status of a network interface has changed.
552119428f9Ssklower */
553dba6ed9fSbostic void
rt_ifmsg(ifp)554119428f9Ssklower rt_ifmsg(ifp)
555119428f9Ssklower register struct ifnet *ifp;
556119428f9Ssklower {
557119428f9Ssklower register struct if_msghdr *ifm;
558119428f9Ssklower struct mbuf *m;
559119428f9Ssklower struct rt_addrinfo info;
560119428f9Ssklower
561119428f9Ssklower if (route_cb.any_count == 0)
562119428f9Ssklower return;
563119428f9Ssklower bzero((caddr_t)&info, sizeof(info));
564119428f9Ssklower m = rt_msg1(RTM_IFINFO, &info);
565119428f9Ssklower if (m == 0)
566119428f9Ssklower return;
567119428f9Ssklower ifm = mtod(m, struct if_msghdr *);
568119428f9Ssklower ifm->ifm_index = ifp->if_index;
569119428f9Ssklower ifm->ifm_flags = ifp->if_flags;
570119428f9Ssklower ifm->ifm_data = ifp->if_data;
571119428f9Ssklower ifm->ifm_addrs = 0;
572119428f9Ssklower route_proto.sp_protocol = 0;
573119428f9Ssklower raw_input(m, &route_proto, &route_src, &route_dst);
574119428f9Ssklower }
575119428f9Ssklower
576119428f9Ssklower /*
577119428f9Ssklower * This is called to generate messages from the routing socket
578119428f9Ssklower * indicating a network interface has had addresses associated with it.
579119428f9Ssklower * if we ever reverse the logic and replace messages TO the routing
580119428f9Ssklower * socket indicate a request to configure interfaces, then it will
581119428f9Ssklower * be unnecessary as the routing socket will automatically generate
582119428f9Ssklower * copies of it.
583119428f9Ssklower */
584dba6ed9fSbostic void
rt_newaddrmsg(cmd,ifa,error,rt)585119428f9Ssklower rt_newaddrmsg(cmd, ifa, error, rt)
586119428f9Ssklower int cmd, error;
587119428f9Ssklower register struct ifaddr *ifa;
588119428f9Ssklower register struct rtentry *rt;
589119428f9Ssklower {
590119428f9Ssklower struct rt_addrinfo info;
591119428f9Ssklower struct sockaddr *sa;
592119428f9Ssklower int pass;
593119428f9Ssklower struct mbuf *m;
594119428f9Ssklower struct ifnet *ifp = ifa->ifa_ifp;
595119428f9Ssklower
596119428f9Ssklower if (route_cb.any_count == 0)
597119428f9Ssklower return;
598119428f9Ssklower for (pass = 1; pass < 3; pass++) {
599119428f9Ssklower bzero((caddr_t)&info, sizeof(info));
600119428f9Ssklower if ((cmd == RTM_ADD && pass == 1) ||
601119428f9Ssklower (cmd == RTM_DELETE && pass == 2)) {
602119428f9Ssklower register struct ifa_msghdr *ifam;
603119428f9Ssklower int ncmd = cmd == RTM_ADD ? RTM_NEWADDR : RTM_DELADDR;
604119428f9Ssklower
605119428f9Ssklower ifaaddr = sa = ifa->ifa_addr;
606119428f9Ssklower ifpaddr = ifp->if_addrlist->ifa_addr;
607119428f9Ssklower netmask = ifa->ifa_netmask;
608119428f9Ssklower brdaddr = ifa->ifa_dstaddr;
609119428f9Ssklower if ((m = rt_msg1(ncmd, &info)) == NULL)
610119428f9Ssklower continue;
611119428f9Ssklower ifam = mtod(m, struct ifa_msghdr *);
612119428f9Ssklower ifam->ifam_index = ifp->if_index;
613119428f9Ssklower ifam->ifam_metric = ifa->ifa_metric;
614f184e5f0Ssklower ifam->ifam_flags = ifa->ifa_flags;
615119428f9Ssklower ifam->ifam_addrs = info.rti_addrs;
616119428f9Ssklower }
617119428f9Ssklower if ((cmd == RTM_ADD && pass == 2) ||
618119428f9Ssklower (cmd == RTM_DELETE && pass == 1)) {
619119428f9Ssklower register struct rt_msghdr *rtm;
620119428f9Ssklower
621119428f9Ssklower if (rt == 0)
622119428f9Ssklower continue;
623119428f9Ssklower netmask = rt_mask(rt);
624119428f9Ssklower dst = sa = rt_key(rt);
625119428f9Ssklower gate = rt->rt_gateway;
626119428f9Ssklower if ((m = rt_msg1(cmd, &info)) == NULL)
627119428f9Ssklower continue;
628119428f9Ssklower rtm = mtod(m, struct rt_msghdr *);
629119428f9Ssklower rtm->rtm_index = ifp->if_index;
630119428f9Ssklower rtm->rtm_flags |= rt->rt_flags;
631119428f9Ssklower rtm->rtm_errno = error;
632119428f9Ssklower rtm->rtm_addrs = info.rti_addrs;
633119428f9Ssklower }
634119428f9Ssklower route_proto.sp_protocol = sa ? sa->sa_family : 0;
635119428f9Ssklower raw_input(m, &route_proto, &route_src, &route_dst);
636119428f9Ssklower }
637119428f9Ssklower }
638119428f9Ssklower
63956c9ebd9Ssklower /*
640396f7653Smckusick * This is used in dumping the kernel table via sysctl().
64156c9ebd9Ssklower */
642dba6ed9fSbostic int
sysctl_dumpentry(rn,w)643396f7653Smckusick sysctl_dumpentry(rn, w)
64456c9ebd9Ssklower struct radix_node *rn;
64556c9ebd9Ssklower register struct walkarg *w;
64656c9ebd9Ssklower {
64756c9ebd9Ssklower register struct rtentry *rt = (struct rtentry *)rn;
6484a6e0ac3Ssklower int error = 0, size;
649119428f9Ssklower struct rt_addrinfo info;
65056c9ebd9Ssklower
651396f7653Smckusick if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
6527def6cddSsklower return 0;
653119428f9Ssklower bzero((caddr_t)&info, sizeof(info));
654119428f9Ssklower dst = rt_key(rt);
655119428f9Ssklower gate = rt->rt_gateway;
656119428f9Ssklower netmask = rt_mask(rt);
657119428f9Ssklower genmask = rt->rt_genmask;
6584a6e0ac3Ssklower if (rt->rt_ifp) {
6594a6e0ac3Ssklower ifpaddr = rt->rt_ifp->if_addrlist->ifa_addr;
6604a6e0ac3Ssklower ifaaddr = rt->rt_ifa->ifa_addr;
6614a6e0ac3Ssklower if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
6624a6e0ac3Ssklower brdaddr = rt->rt_ifa->ifa_dstaddr;
6634a6e0ac3Ssklower }
664119428f9Ssklower size = rt_msg2(RTM_GET, &info, 0, w);
665119428f9Ssklower if (w->w_where && w->w_tmem) {
666119428f9Ssklower register struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
66756c9ebd9Ssklower
668119428f9Ssklower rtm->rtm_flags = rt->rt_flags;
669119428f9Ssklower rtm->rtm_use = rt->rt_use;
670119428f9Ssklower rtm->rtm_rmx = rt->rt_rmx;
671119428f9Ssklower rtm->rtm_index = rt->rt_ifp->if_index;
672119428f9Ssklower rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
673119428f9Ssklower rtm->rtm_addrs = info.rti_addrs;
674119428f9Ssklower if (error = copyout((caddr_t)rtm, w->w_where, size))
675119428f9Ssklower w->w_where = NULL;
676119428f9Ssklower else
677119428f9Ssklower w->w_where += size;
67856c9ebd9Ssklower }
679119428f9Ssklower return (error);
680119428f9Ssklower }
681119428f9Ssklower
682dba6ed9fSbostic int
sysctl_iflist(af,w)683396f7653Smckusick sysctl_iflist(af, w)
684119428f9Ssklower int af;
685119428f9Ssklower register struct walkarg *w;
686119428f9Ssklower {
687119428f9Ssklower register struct ifnet *ifp;
688119428f9Ssklower register struct ifaddr *ifa;
689119428f9Ssklower struct rt_addrinfo info;
690119428f9Ssklower int len, error = 0;
691119428f9Ssklower
692119428f9Ssklower bzero((caddr_t)&info, sizeof(info));
693119428f9Ssklower for (ifp = ifnet; ifp; ifp = ifp->if_next) {
694a046f474Ssklower if (w->w_arg && w->w_arg != ifp->if_index)
695a046f474Ssklower continue;
696119428f9Ssklower ifa = ifp->if_addrlist;
697119428f9Ssklower ifpaddr = ifa->ifa_addr;
698119428f9Ssklower len = rt_msg2(RTM_IFINFO, &info, (caddr_t)0, w);
699119428f9Ssklower ifpaddr = 0;
700119428f9Ssklower if (w->w_where && w->w_tmem) {
701119428f9Ssklower register struct if_msghdr *ifm;
702119428f9Ssklower
703119428f9Ssklower ifm = (struct if_msghdr *)w->w_tmem;
704119428f9Ssklower ifm->ifm_index = ifp->if_index;
705119428f9Ssklower ifm->ifm_flags = ifp->if_flags;
706119428f9Ssklower ifm->ifm_data = ifp->if_data;
707119428f9Ssklower ifm->ifm_addrs = info.rti_addrs;
708119428f9Ssklower if (error = copyout((caddr_t)ifm, w->w_where, len))
709119428f9Ssklower return (error);
710119428f9Ssklower w->w_where += len;
711119428f9Ssklower }
712119428f9Ssklower while (ifa = ifa->ifa_next) {
713a046f474Ssklower if (af && af != ifa->ifa_addr->sa_family)
714a046f474Ssklower continue;
715119428f9Ssklower ifaaddr = ifa->ifa_addr;
716119428f9Ssklower netmask = ifa->ifa_netmask;
717119428f9Ssklower brdaddr = ifa->ifa_dstaddr;
718119428f9Ssklower len = rt_msg2(RTM_NEWADDR, &info, 0, w);
719119428f9Ssklower if (w->w_where && w->w_tmem) {
720119428f9Ssklower register struct ifa_msghdr *ifam;
721119428f9Ssklower
722119428f9Ssklower ifam = (struct ifa_msghdr *)w->w_tmem;
723119428f9Ssklower ifam->ifam_index = ifa->ifa_ifp->if_index;
724119428f9Ssklower ifam->ifam_flags = ifa->ifa_flags;
725119428f9Ssklower ifam->ifam_metric = ifa->ifa_metric;
726119428f9Ssklower ifam->ifam_addrs = info.rti_addrs;
727119428f9Ssklower if (error = copyout(w->w_tmem, w->w_where, len))
728119428f9Ssklower return (error);
729119428f9Ssklower w->w_where += len;
730119428f9Ssklower }
731119428f9Ssklower }
732a046f474Ssklower ifaaddr = netmask = brdaddr = 0;
733119428f9Ssklower }
73456c9ebd9Ssklower return (0);
73556c9ebd9Ssklower }
73656c9ebd9Ssklower
737dba6ed9fSbostic int
sysctl_rtable(name,namelen,where,given,new,newlen)738396f7653Smckusick sysctl_rtable(name, namelen, where, given, new, newlen)
739396f7653Smckusick int *name;
740396f7653Smckusick int namelen;
74156c9ebd9Ssklower caddr_t where;
74234ac4d2aSbostic size_t *given;
743396f7653Smckusick caddr_t *new;
74434ac4d2aSbostic size_t newlen;
74556c9ebd9Ssklower {
74656c9ebd9Ssklower register struct radix_node_head *rnh;
747119428f9Ssklower int i, s, error = EINVAL;
748396f7653Smckusick u_char af;
74956c9ebd9Ssklower struct walkarg w;
75056c9ebd9Ssklower
751396f7653Smckusick if (new)
752396f7653Smckusick return (EPERM);
753396f7653Smckusick if (namelen != 3)
754396f7653Smckusick return (EINVAL);
755396f7653Smckusick af = name[0];
75656c9ebd9Ssklower Bzero(&w, sizeof(w));
757396f7653Smckusick w.w_where = where;
75856c9ebd9Ssklower w.w_given = *given;
75956c9ebd9Ssklower w.w_needed = 0 - w.w_given;
760396f7653Smckusick w.w_op = name[1];
761396f7653Smckusick w.w_arg = name[2];
76256c9ebd9Ssklower
76356c9ebd9Ssklower s = splnet();
764396f7653Smckusick switch (w.w_op) {
765119428f9Ssklower
766396f7653Smckusick case NET_RT_DUMP:
767396f7653Smckusick case NET_RT_FLAGS:
768119428f9Ssklower for (i = 1; i <= AF_MAX; i++)
769119428f9Ssklower if ((rnh = rt_tables[i]) && (af == 0 || af == i) &&
770425e2571Ssklower (error = rnh->rnh_walktree(rnh,
771396f7653Smckusick sysctl_dumpentry, &w)))
77256c9ebd9Ssklower break;
773119428f9Ssklower break;
774119428f9Ssklower
775396f7653Smckusick case NET_RT_IFLIST:
776396f7653Smckusick error = sysctl_iflist(af, &w);
77756c9ebd9Ssklower }
778119428f9Ssklower splx(s);
779119428f9Ssklower if (w.w_tmem)
780119428f9Ssklower free(w.w_tmem, M_RTABLE);
78156c9ebd9Ssklower w.w_needed += w.w_given;
782396f7653Smckusick if (where) {
78356c9ebd9Ssklower *given = w.w_where - where;
784396f7653Smckusick if (*given < w.w_needed)
785396f7653Smckusick return (ENOMEM);
786396f7653Smckusick } else {
787396f7653Smckusick *given = (11 * w.w_needed) / 10;
788396f7653Smckusick }
78956c9ebd9Ssklower return (error);
79056c9ebd9Ssklower }
79156c9ebd9Ssklower
792fb535254Ssklower /*
793fb535254Ssklower * Definitions of protocols supported in the ROUTE domain.
794fb535254Ssklower */
795fb535254Ssklower
796fb535254Ssklower extern struct domain routedomain; /* or at least forward */
797fb535254Ssklower
798fb535254Ssklower struct protosw routesw[] = {
799fb535254Ssklower { SOCK_RAW, &routedomain, 0, PR_ATOMIC|PR_ADDR,
800fb535254Ssklower raw_input, route_output, raw_ctlinput, 0,
801fb535254Ssklower route_usrreq,
802fb535254Ssklower raw_init, 0, 0, 0,
803396f7653Smckusick sysctl_rtable,
804fb535254Ssklower }
805fb535254Ssklower };
806fb535254Ssklower
807fb535254Ssklower struct domain routedomain =
808acc82a8cSsklower { PF_ROUTE, "route", route_init, 0, 0,
809fb535254Ssklower routesw, &routesw[sizeof(routesw)/sizeof(routesw[0])] };
810