1 /*
2 * $Id: ether_mod.c,v 1.5 1999/02/10 08:03:41 route Exp $
3 *
4 * libnet
5 * FreeBSD ether_mod.c - lkm replacement for ether_output
6 *
7 * Copyright (c) 1998, 1999, 2000 Mike D. Schiffman <mike@infonexus.com>
8 * Original code and idea 1997 Thomas Ptacek <tqbf@pobox.com>
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 #define INET
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/malloc.h>
40 #include <sys/mbuf.h>
41 #include <sys/protosw.h>
42 #include <sys/socket.h>
43 #include <sys/sockio.h>
44 #include <sys/errno.h>
45 #include <sys/syslog.h>
46 #include <sys/sysctl.h>
47
48 #include <net/if.h>
49 #include <net/netisr.h>
50 #include <net/route.h>
51 #include <net/if_llc.h>
52 #include <net/if_dl.h>
53 #include <net/if_types.h>
54 #include <net/ethernet.h>
55
56 #ifdef INET
57 #include <netinet/in.h>
58 #include <netinet/in_var.h>
59 #endif
60 #include <netinet/if_ether.h>
61
62 #ifdef IPX
63 #include <netipx/ipx.h>
64 #include <netipx/ipx_if.h>
65 #endif
66
67 #ifdef NS
68 #include <netns/ns.h>
69 #include <netns/ns_if.h>
70 ushort ns_nettype;
71 int ether_outputdebug = 0;
72 int ether_inputdebug = 0;
73 #endif
74
75 #ifdef ISO
76 #include <netiso/argo_debug.h>
77 #include <netiso/iso.h>
78 #include <netiso/iso_var.h>
79 #include <netiso/iso_snpac.h>
80 #endif
81
82 /*#ifdef LLC
83 #include <netccitt/dll.h>
84 #include <netccitt/llc_var.h>
85 #endif*/
86
87 #if defined(LLC) && defined(CCITT)
88 extern struct ifqueue pkintrq;
89 #endif
90
91 #ifdef NETATALK
92 #include <netatalk/at.h>
93 #include <netatalk/at_var.h>
94 #include <netatalk/at_extern.h>
95
96 #define llc_snap_org_code llc_un.type_snap.org_code
97 #define llc_snap_ether_type llc_un.type_snap.ether_type
98
99 extern u_char at_org_code[ 3 ];
100 extern u_char aarp_org_code[ 3 ];
101 #endif NETATALK
102
103 #define senderr(e) { error = (e); goto bad;}
104
105 int ether_output_spoof(register struct ifnet *, struct mbuf *,
106 struct sockaddr *, struct rtentry *);
107
108 int
ether_output_spoof(ifp,m0,dst,rt0)109 ether_output_spoof(ifp, m0, dst, rt0)
110 register struct ifnet *ifp;
111 struct mbuf *m0;
112 struct sockaddr *dst;
113 struct rtentry *rt0;
114 {
115 short type;
116 int s, error = 0;
117 u_char *cp, edst[6], esrc[6];
118 register struct mbuf *m2, *m = m0;
119 register struct rtentry *rt;
120 struct mbuf *mcopy = (struct mbuf *)0;
121 register struct ether_header *eh;
122 int off, len = m->m_pkthdr.len;
123 struct arpcom *ac = (struct arpcom *)ifp;
124 register struct ifqueue *inq;
125 #ifdef NETATALK
126 struct at_ifaddr *aa;
127 #endif NETATALK
128
129 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
130 senderr(ENETDOWN);
131 rt = rt0;
132 if (rt) {
133 if ((rt->rt_flags & RTF_UP) == 0) {
134 rt0 = rt = rtalloc1(dst, 1, 0UL);
135 if (rt0)
136 rt->rt_refcnt--;
137 else
138 senderr(EHOSTUNREACH);
139 }
140 if (rt->rt_flags & RTF_GATEWAY) {
141 if (rt->rt_gwroute == 0)
142 goto lookup;
143 if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
144 rtfree(rt); rt = rt0;
145 lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1,
146 0UL);
147 if ((rt = rt->rt_gwroute) == 0)
148 senderr(EHOSTUNREACH);
149 }
150 }
151 if (rt->rt_flags & RTF_REJECT)
152 if (rt->rt_rmx.rmx_expire == 0 /*||
153 time.tv_sec < rt->rt_rmx.rmx_expire*/)
154 senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
155 }
156 switch (dst->sa_family) {
157
158 #ifdef INET
159 case AF_INET:
160 if (!arpresolve(ac, rt, m, dst, edst, rt0))
161 return (0); /* if not yet resolved */
162 /* If broadcasting on a simplex interface, loopback a copy */
163 if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
164 mcopy = m_copy(m, 0, (int)M_COPYALL);
165 off = m->m_pkthdr.len - m->m_len;
166 type = htons(ETHERTYPE_IP);
167 break;
168 #endif
169 #ifdef IPX
170 case AF_IPX:
171 {
172 struct ifaddr *ia;
173
174 type = htons(ETHERTYPE_IPX);
175 bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
176 (caddr_t)edst, sizeof (edst));
177
178 for(ia = ifp->if_addrhead.tqh_first; ia != 0;
179 ia = ia->ifa_link.tqe_next) {
180 if(ia->ifa_addr->sa_family == AF_IPX &&
181 !bcmp((caddr_t)edst,
182 (caddr_t)&((struct ipx_ifaddr *)ia)->ia_addr.sipx_addr.x_host,
183 sizeof(edst)) )
184 return (/*looutput(ifp, m, dst, rt)*/1);
185 }
186
187 /* If broadcasting on a simplex interface, loopback a copy */
188 if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX))
189 mcopy = m_copy(m, 0, (int)M_COPYALL);
190 break;
191 }
192 #endif
193 #ifdef NETATALK
194 case AF_APPLETALK:
195 if (!aarpresolve(ac, m, (struct sockaddr_at *)dst, edst)) {
196 #ifdef NETATALKDEBUG
197 extern char *prsockaddr(struct sockaddr *);
198 printf("aarpresolv: failed for %s\n", prsockaddr(dst));
199 #endif NETATALKDEBUG
200 return (0);
201 }
202 /*
203 * ifaddr is the first thing in at_ifaddr
204 */
205 if ((aa = (struct at_ifaddr *)at_ifawithnet(
206 (struct sockaddr_at *)dst, &ifp->if_addrhead))
207 == 0)
208 goto bad;
209
210 /*
211 * In the phase 2 case, we need to prepend an mbuf for the llc header.
212 * Since we must preserve the value of m, which is passed to us by
213 * value, we m_copy() the first mbuf, and use it for our llc header.
214 */
215 if ( aa->aa_flags & AFA_PHASE2 ) {
216 struct llc llc;
217
218 M_PREPEND(m, sizeof(struct llc), M_WAIT);
219 len += sizeof(struct llc);
220 llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
221 llc.llc_control = LLC_UI;
222 bcopy(at_org_code, llc.llc_snap_org_code, sizeof(at_org_code));
223 llc.llc_snap_ether_type = htons( ETHERTYPE_AT );
224 bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
225 type = htons(m->m_pkthdr.len);
226 } else {
227 type = htons(ETHERTYPE_AT);
228 }
229 break;
230 #endif NETATALK
231 #ifdef NS
232 case AF_NS:
233 switch(ns_nettype){
234 default:
235 case 0x8137: /* Novell Ethernet_II Ethernet TYPE II */
236 type = 0x8137;
237 break;
238 case 0x0: /* Novell 802.3 */
239 type = htons( m->m_pkthdr.len);
240 break;
241 case 0xe0e0: /* Novell 802.2 and Token-Ring */
242 M_PREPEND(m, 3, M_WAIT);
243 type = htons( m->m_pkthdr.len);
244 cp = mtod(m, u_char *);
245 *cp++ = 0xE0;
246 *cp++ = 0xE0;
247 *cp++ = 0x03;
248 break;
249 }
250 bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
251 (caddr_t)edst, sizeof (edst));
252 if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst))){
253 m->m_pkthdr.rcvif = ifp;
254 schednetisr(NETISR_NS);
255 inq = &nsintrq;
256 s = splimp();
257 if (IF_QFULL(inq)) {
258 IF_DROP(inq);
259 m_freem(m);
260 } else
261 IF_ENQUEUE(inq, m);
262 splx(s);
263 return (error);
264 }
265 if (!bcmp((caddr_t)edst, (caddr_t)&ns_broadhost, sizeof(edst))){
266 m2 = m_copy(m, 0, (int)M_COPYALL);
267 m2->m_pkthdr.rcvif = ifp;
268 schednetisr(NETISR_NS);
269 inq = &nsintrq;
270 s = splimp();
271 if (IF_QFULL(inq)) {
272 IF_DROP(inq);
273 m_freem(m2);
274 } else
275 IF_ENQUEUE(inq, m2);
276 splx(s);
277 }
278 /* If broadcasting on a simplex interface, loopback a copy */
279 if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX)){
280 mcopy = m_copy(m, 0, (int)M_COPYALL);
281 }
282 break;
283 #endif /* NS */
284 #ifdef ISO
285 case AF_ISO: {
286 int snpalen;
287 struct llc *l;
288 register struct sockaddr_dl *sdl;
289
290 if (rt && (sdl = (struct sockaddr_dl *)rt->rt_gateway) &&
291 sdl->sdl_family == AF_LINK && sdl->sdl_alen > 0) {
292 bcopy(LLADDR(sdl), (caddr_t)edst, sizeof(edst));
293 } else if (error =
294 iso_snparesolve(ifp, (struct sockaddr_iso *)dst,
295 (char *)edst, &snpalen))
296 goto bad; /* Not Resolved */
297 /* If broadcasting on a simplex interface, loopback a copy */
298 if (*edst & 1)
299 m->m_flags |= (M_BCAST|M_MCAST);
300 if ((m->m_flags & M_BCAST) && (ifp->if_flags & IFF_SIMPLEX) &&
301 (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
302 M_PREPEND(mcopy, sizeof (*eh), M_DONETWAIT);
303 if (mcopy) {
304 eh = mtod(mcopy, struct ether_header *);
305 bcopy((caddr_t)edst,
306 (caddr_t)eh->ether_dhost, sizeof (edst));
307 bcopy((caddr_t)ac->ac_enaddr,
308 (caddr_t)eh->ether_shost, sizeof (edst));
309 }
310 }
311 M_PREPEND(m, 3, M_DONETWAIT);
312 if (m == NULL)
313 return (0);
314 type = htons(m->m_pkthdr.len);
315 l = mtod(m, struct llc *);
316 l->llc_dsap = l->llc_ssap = LLC_ISO_LSAP;
317 l->llc_control = LLC_UI;
318 len += 3;
319 IFDEBUG(D_ETHER)
320 int i;
321 printf("unoutput: sending pkt to: ");
322 for (i=0; i<6; i++)
323 printf("%x ", edst[i] & 0xff);
324 printf("\n");
325 ENDDEBUG
326 } break;
327 #endif /* ISO */
328 #ifdef LLC
329 /* case AF_NSAP: */
330 case AF_CCITT: {
331 register struct sockaddr_dl *sdl =
332 (struct sockaddr_dl *) rt -> rt_gateway;
333
334 if (sdl && sdl->sdl_family == AF_LINK
335 && sdl->sdl_alen > 0) {
336 bcopy(LLADDR(sdl), (char *)edst,
337 sizeof(edst));
338 } else goto bad; /* Not a link interface ? Funny ... */
339 if ((ifp->if_flags & IFF_SIMPLEX) && (*edst & 1) &&
340 (mcopy = m_copy(m, 0, (int)M_COPYALL))) {
341 M_PREPEND(mcopy, sizeof (*eh), M_DONETWAIT);
342 if (mcopy) {
343 eh = mtod(mcopy, struct ether_header *);
344 bcopy((caddr_t)edst,
345 (caddr_t)eh->ether_dhost, sizeof (edst));
346 bcopy((caddr_t)ac->ac_enaddr,
347 (caddr_t)eh->ether_shost, sizeof (edst));
348 }
349 }
350 type = htons(m->m_pkthdr.len);
351 #ifdef LLC_DEBUG
352 {
353 int i;
354 register struct llc *l = mtod(m, struct llc *);
355
356 printf("ether_output: sending LLC2 pkt to: ");
357 for (i=0; i<6; i++)
358 printf("%x ", edst[i] & 0xff);
359 printf(" len 0x%x dsap 0x%x ssap 0x%x control 0x%x\n",
360 type & 0xff, l->llc_dsap & 0xff, l->llc_ssap &0xff,
361 l->llc_control & 0xff);
362
363 }
364 #endif /* LLC_DEBUG */
365 } break;
366 #endif /* LLC */
367
368 case AF_UNSPEC:
369 /* XXX */
370 eh = (struct ether_header *)dst->sa_data;
371 (void)memcpy(edst, eh->ether_dhost, sizeof (edst));
372 (void)memcpy(esrc, eh->ether_shost, sizeof (esrc));
373 type = eh->ether_type;
374 break;
375
376 default:
377 printf("%s%d: can't handle af%d\n", ifp->if_name, ifp->if_unit,
378 dst->sa_family);
379 senderr(EAFNOSUPPORT);
380 }
381
382
383 /* if (mcopy)
384 (void) looutput(ifp, mcopy, dst, rt);*/
385 /*
386 * Add local net header. If no space in first mbuf,
387 * allocate another.
388 */
389 M_PREPEND(m, sizeof (struct ether_header), M_DONETWAIT);
390 if (m == 0)
391 senderr(ENOBUFS);
392 eh = mtod(m, struct ether_header *);
393 (void)memcpy(&eh->ether_type, &type,
394 sizeof(eh->ether_type));
395 (void)memcpy(eh->ether_dhost, edst, sizeof (edst));
396 (void)memcpy(eh->ether_shost, esrc, sizeof (esrc));
397 s = splimp();
398 /*
399 * Queue message on interface, and start output if interface
400 * not yet active.
401 */
402 if (IF_QFULL(&ifp->if_snd)) {
403 IF_DROP(&ifp->if_snd);
404 splx(s);
405 senderr(ENOBUFS);
406 }
407 IF_ENQUEUE(&ifp->if_snd, m);
408 if ((ifp->if_flags & IFF_OACTIVE) == 0)
409 (*ifp->if_start)(ifp);
410 splx(s);
411 ifp->if_obytes += len + sizeof (struct ether_header);
412 if (m->m_flags & M_MCAST)
413 ifp->if_omcasts++;
414 return (error);
415
416 bad:
417 if (m)
418 m_freem(m);
419 return (error);
420 }
421
422