xref: /freebsd/sys/netgraph/ng_eiface.c (revision 3642298923e528d795e3a30ec165d2b469e28b40) 
1 /*-
2  *
3  * Copyright (c) 1999-2001, Vitaly V Belekhov
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice unmodified, this list of conditions, and the following
11  *    disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $FreeBSD$
29  */
30 
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/errno.h>
34 #include <sys/kernel.h>
35 #include <sys/malloc.h>
36 #include <sys/mbuf.h>
37 #include <sys/errno.h>
38 #include <sys/sockio.h>
39 #include <sys/socket.h>
40 #include <sys/syslog.h>
41 
42 #include <net/if.h>
43 #include <net/if_dl.h>
44 #include <net/if_types.h>
45 #include <net/netisr.h>
46 
47 #include <netgraph/ng_message.h>
48 #include <netgraph/netgraph.h>
49 #include <netgraph/ng_parse.h>
50 #include <netgraph/ng_eiface.h>
51 
52 #include <net/bpf.h>
53 #include <net/ethernet.h>
54 #include <net/if_arp.h>
55 
56 static const struct ng_cmdlist ng_eiface_cmdlist[] = {
57 	{
58 	  NGM_EIFACE_COOKIE,
59 	  NGM_EIFACE_GET_IFNAME,
60 	  "getifname",
61 	  NULL,
62 	  &ng_parse_string_type
63 	},
64 	{
65 	  NGM_EIFACE_COOKIE,
66 	  NGM_EIFACE_SET,
67 	  "set",
68 	  &ng_parse_enaddr_type,
69 	  NULL
70 	},
71 	{ 0 }
72 };
73 
74 /* Node private data */
75 struct ng_eiface_private {
76 	struct ifnet	*ifp;		/* per-interface network data */
77 	int		unit;		/* Interface unit number */
78 	node_p		node;		/* Our netgraph node */
79 	hook_p		ether;		/* Hook for ethernet stream */
80 };
81 typedef struct ng_eiface_private *priv_p;
82 
83 /* Interface methods */
84 static void	ng_eiface_init(void *xsc);
85 static void	ng_eiface_start(struct ifnet *ifp);
86 static int	ng_eiface_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
87 #ifdef DEBUG
88 static void	ng_eiface_print_ioctl(struct ifnet *ifp, int cmd, caddr_t data);
89 #endif
90 
91 /* Netgraph methods */
92 static int		ng_eiface_mod_event(module_t, int, void *);
93 static ng_constructor_t	ng_eiface_constructor;
94 static ng_rcvmsg_t	ng_eiface_rcvmsg;
95 static ng_shutdown_t	ng_eiface_rmnode;
96 static ng_newhook_t	ng_eiface_newhook;
97 static ng_rcvdata_t	ng_eiface_rcvdata;
98 static ng_disconnect_t	ng_eiface_disconnect;
99 
100 /* Node type descriptor */
101 static struct ng_type typestruct = {
102 	.version =	NG_ABI_VERSION,
103 	.name =		NG_EIFACE_NODE_TYPE,
104 	.mod_event =	ng_eiface_mod_event,
105 	.constructor =	ng_eiface_constructor,
106 	.rcvmsg =	ng_eiface_rcvmsg,
107 	.shutdown =	ng_eiface_rmnode,
108 	.newhook =	ng_eiface_newhook,
109 	.rcvdata =	ng_eiface_rcvdata,
110 	.disconnect =	ng_eiface_disconnect,
111 	.cmdlist =	ng_eiface_cmdlist
112 };
113 NETGRAPH_INIT(eiface, &typestruct);
114 
115 static struct unrhdr	*ng_eiface_unit;
116 
117 /************************************************************************
118 			INTERFACE STUFF
119  ************************************************************************/
120 
121 /*
122  * Process an ioctl for the virtual interface
123  */
124 static int
125 ng_eiface_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
126 {
127 	struct ifreq *const ifr = (struct ifreq *)data;
128 	int s, error = 0;
129 
130 #ifdef DEBUG
131 	ng_eiface_print_ioctl(ifp, command, data);
132 #endif
133 	s = splimp();
134 	switch (command) {
135 
136 	/* These two are mostly handled at a higher layer */
137 	case SIOCSIFADDR:
138 		error = ether_ioctl(ifp, command, data);
139 		break;
140 	case SIOCGIFADDR:
141 		break;
142 
143 	/* Set flags */
144 	case SIOCSIFFLAGS:
145 		/*
146 		 * If the interface is marked up and stopped, then start it.
147 		 * If it is marked down and running, then stop it.
148 		 */
149 		if (ifr->ifr_flags & IFF_UP) {
150 			if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
151 				ifp->if_drv_flags &= ~(IFF_DRV_OACTIVE);
152 				ifp->if_drv_flags |= IFF_DRV_RUNNING;
153 			}
154 		} else {
155 			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
156 				ifp->if_drv_flags &= ~(IFF_DRV_RUNNING |
157 				    IFF_DRV_OACTIVE);
158 		}
159 		break;
160 
161 	/* Set the interface MTU */
162 	case SIOCSIFMTU:
163 		if (ifr->ifr_mtu > NG_EIFACE_MTU_MAX ||
164 		    ifr->ifr_mtu < NG_EIFACE_MTU_MIN)
165 			error = EINVAL;
166 		else
167 			ifp->if_mtu = ifr->ifr_mtu;
168 		break;
169 
170 	/* Stuff that's not supported */
171 	case SIOCADDMULTI:
172 	case SIOCDELMULTI:
173 		error = 0;
174 		break;
175 	case SIOCSIFPHYS:
176 		error = EOPNOTSUPP;
177 		break;
178 
179 	default:
180 		error = EINVAL;
181 		break;
182 	}
183 	splx(s);
184 	return (error);
185 }
186 
187 static void
188 ng_eiface_init(void *xsc)
189 {
190 	priv_p sc = xsc;
191 	struct ifnet *ifp = sc->ifp;
192 	int s;
193 
194 	s = splimp();
195 
196 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
197 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
198 
199 	splx(s);
200 }
201 
202 /*
203  * We simply relay the packet to the "ether" hook, if it is connected.
204  * We have been through the netgraph locking and are guaranteed to
205  * be the only code running in this node at this time.
206  */
207 static void
208 ng_eiface_start2(node_p node, hook_p hook, void *arg1, int arg2)
209 {
210 	struct ifnet *ifp = arg1;
211 	const priv_p priv = (priv_p)ifp->if_softc;
212 	int len, error = 0;
213 	struct mbuf *m;
214 
215 	/* Check interface flags */
216 
217 	if (!((ifp->if_flags & IFF_UP) &&
218 	    (ifp->if_drv_flags & IFF_DRV_RUNNING)))
219 		return;
220 
221 	/* Don't do anything if output is active */
222 	if (ifp->if_drv_flags & IFF_DRV_OACTIVE)
223 		return;
224 
225 	ifp->if_drv_flags |= IFF_DRV_OACTIVE;
226 
227 	/*
228 	 * Grab a packet to transmit.
229 	 */
230 	IF_DEQUEUE(&ifp->if_snd, m);
231 
232 	/* If there's nothing to send, return. */
233 	if (m == NULL) {
234 		ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
235 		return;
236 	}
237 
238 	/*
239 	 * Berkeley packet filter.
240 	 * Pass packet to bpf if there is a listener.
241 	 * XXX is this safe? locking?
242 	 */
243 	BPF_MTAP(ifp, m);
244 
245 	/* Copy length before the mbuf gets invalidated */
246 	len = m->m_pkthdr.len;
247 
248 	/*
249 	 * Send packet; if hook is not connected, mbuf will get
250 	 * freed.
251 	 */
252 	NG_SEND_DATA_ONLY(error, priv->ether, m);
253 
254 	/* Update stats */
255 	if (error == 0) {
256 		ifp->if_obytes += len;
257 		ifp->if_opackets++;
258 	}
259 
260 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
261 
262 	return;
263 }
264 
265 /*
266  * This routine is called to deliver a packet out the interface.
267  * We simply queue the netgraph version to be called when netgraph locking
268  * allows it to happen.
269  * Until we know what the rest of the networking code is doing for
270  * locking, we don't know how we will interact with it.
271  * Take comfort from the fact that the ifnet struct is part of our
272  * private info and can't go away while we are queued.
273  * [Though we don't know it is still there now....]
274  * it is possible we don't gain anything from this because
275  * we would like to get the mbuf and queue it as data
276  * somehow, but we can't and if we did would we solve anything?
277  */
278 static void
279 ng_eiface_start(struct ifnet *ifp)
280 {
281 
282 	const priv_p priv = (priv_p)ifp->if_softc;
283 
284 	ng_send_fn(priv->node, NULL, &ng_eiface_start2, ifp, 0);
285 }
286 
287 #ifdef DEBUG
288 /*
289  * Display an ioctl to the virtual interface
290  */
291 
292 static void
293 ng_eiface_print_ioctl(struct ifnet *ifp, int command, caddr_t data)
294 {
295 	char *str;
296 
297 	switch (command & IOC_DIRMASK) {
298 	case IOC_VOID:
299 		str = "IO";
300 		break;
301 	case IOC_OUT:
302 		str = "IOR";
303 		break;
304 	case IOC_IN:
305 		str = "IOW";
306 		break;
307 	case IOC_INOUT:
308 		str = "IORW";
309 		break;
310 	default:
311 		str = "IO??";
312 	}
313 	log(LOG_DEBUG, "%s: %s('%c', %d, char[%d])\n",
314 	    ifp->if_xname,
315 	    str,
316 	    IOCGROUP(command),
317 	    command & 0xff,
318 	    IOCPARM_LEN(command));
319 }
320 #endif /* DEBUG */
321 
322 /************************************************************************
323 			NETGRAPH NODE STUFF
324  ************************************************************************/
325 
326 /*
327  * Constructor for a node
328  */
329 static int
330 ng_eiface_constructor(node_p node)
331 {
332 	struct ifnet *ifp;
333 	priv_p priv;
334 	u_char eaddr[6] = {0,0,0,0,0,0};
335 
336 	/* Allocate node and interface private structures */
337 	MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_NOWAIT | M_ZERO);
338 	if (priv == NULL)
339 		return (ENOMEM);
340 
341 	ifp = priv->ifp = if_alloc(IFT_ETHER);
342 	if (ifp == NULL) {
343 		free(priv, M_NETGRAPH);
344 		return (ENOSPC);
345 	}
346 
347 	/* Link them together */
348 	ifp->if_softc = priv;
349 
350 	/* Get an interface unit number */
351 	priv->unit = alloc_unr(ng_eiface_unit);
352 
353 	/* Link together node and private info */
354 	NG_NODE_SET_PRIVATE(node, priv);
355 	priv->node = node;
356 
357 	/* Initialize interface structure */
358 	if_initname(ifp, NG_EIFACE_EIFACE_NAME, priv->unit);
359 	ifp->if_init = ng_eiface_init;
360 	ifp->if_output = ether_output;
361 	ifp->if_start = ng_eiface_start;
362 	ifp->if_ioctl = ng_eiface_ioctl;
363 	ifp->if_watchdog = NULL;
364 	ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
365 	ifp->if_flags = (IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST);
366 
367 #if 0
368 	/* Give this node name */
369 	bzero(ifname, sizeof(ifname));
370 	sprintf(ifname, "if%s", ifp->if_xname);
371 	(void)ng_name_node(node, ifname);
372 #endif
373 
374 	/* Attach the interface */
375 	ether_ifattach(ifp, eaddr);
376 
377 	/* Done */
378 	return (0);
379 }
380 
381 /*
382  * Give our ok for a hook to be added
383  */
384 static int
385 ng_eiface_newhook(node_p node, hook_p hook, const char *name)
386 {
387 	priv_p priv = NG_NODE_PRIVATE(node);
388 	struct ifnet *ifp = priv->ifp;
389 
390 	if (strcmp(name, NG_EIFACE_HOOK_ETHER))
391 		return (EPFNOSUPPORT);
392 	if (priv->ether != NULL)
393 		return (EISCONN);
394 	priv->ether = hook;
395 	NG_HOOK_SET_PRIVATE(hook, &priv->ether);
396 
397 	if_link_state_change(ifp, LINK_STATE_UP);
398 
399 	return (0);
400 }
401 
402 /*
403  * Receive a control message
404  */
405 static int
406 ng_eiface_rcvmsg(node_p node, item_p item, hook_p lasthook)
407 {
408 	const priv_p priv = NG_NODE_PRIVATE(node);
409 	struct ifnet *const ifp = priv->ifp;
410 	struct ng_mesg *resp = NULL;
411 	int error = 0;
412 	struct ng_mesg *msg;
413 
414 	NGI_GET_MSG(item, msg);
415 	switch (msg->header.typecookie) {
416 	case NGM_EIFACE_COOKIE:
417 		switch (msg->header.cmd) {
418 
419 		case NGM_EIFACE_SET:
420 		    {
421 			struct ether_addr *eaddr;
422 			struct ifaddr *ifa;
423 			struct sockaddr_dl *sdl;
424 
425 			if (msg->header.arglen != sizeof(struct ether_addr)) {
426 				error = EINVAL;
427 				break;
428 			}
429 			eaddr = (struct ether_addr *)(msg->data);
430 			bcopy(eaddr, IFP2ENADDR(priv->ifp),
431 			    ETHER_ADDR_LEN);
432 
433 			/* And put it in the ifaddr list */
434 			TAILQ_FOREACH(ifa, &(ifp->if_addrhead), ifa_link) {
435 				sdl = (struct sockaddr_dl *)ifa->ifa_addr;
436 				if (sdl->sdl_type == IFT_ETHER) {
437 					bcopy(IFP2ENADDR(ifp),
438 						LLADDR(sdl), ifp->if_addrlen);
439 					break;
440 				}
441 			}
442 			break;
443 		    }
444 
445 		case NGM_EIFACE_GET_IFNAME:
446 			NG_MKRESPONSE(resp, msg, IFNAMSIZ, M_NOWAIT);
447 			if (resp == NULL) {
448 				error = ENOMEM;
449 				break;
450 			}
451 			strlcpy(resp->data, ifp->if_xname, IFNAMSIZ);
452 			break;
453 
454 		case NGM_EIFACE_GET_IFADDRS:
455 		    {
456 			struct ifaddr *ifa;
457 			caddr_t ptr;
458 			int buflen;
459 
460 #define SA_SIZE(s)	((s)->sa_len<sizeof(*(s))? sizeof(*(s)):(s)->sa_len)
461 
462 			/* Determine size of response and allocate it */
463 			buflen = 0;
464 			TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link)
465 				buflen += SA_SIZE(ifa->ifa_addr);
466 			NG_MKRESPONSE(resp, msg, buflen, M_NOWAIT);
467 			if (resp == NULL) {
468 				error = ENOMEM;
469 				break;
470 			}
471 
472 			/* Add addresses */
473 			ptr = resp->data;
474 			TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
475 				const int len = SA_SIZE(ifa->ifa_addr);
476 
477 				if (buflen < len) {
478 					log(LOG_ERR, "%s: len changed?\n",
479 					    ifp->if_xname);
480 					break;
481 				}
482 				bcopy(ifa->ifa_addr, ptr, len);
483 				ptr += len;
484 				buflen -= len;
485 			}
486 			break;
487 #undef SA_SIZE
488 		    }
489 
490 		default:
491 			error = EINVAL;
492 			break;
493 		} /* end of inner switch() */
494 		break;
495 	case NGM_FLOW_COOKIE:
496 		switch (msg->header.cmd) {
497 		case NGM_LINK_IS_UP:
498 			if_link_state_change(ifp, LINK_STATE_UP);
499 			break;
500 		case NGM_LINK_IS_DOWN:
501 			if_link_state_change(ifp, LINK_STATE_DOWN);
502 			break;
503 		default:
504 			break;
505 		}
506 		break;
507 	default:
508 		error = EINVAL;
509 		break;
510 	}
511 	NG_RESPOND_MSG(error, node, item, resp);
512 	NG_FREE_MSG(msg);
513 	return (error);
514 }
515 
516 /*
517  * Receive data from a hook. Pass the packet to the ether_input routine.
518  */
519 static int
520 ng_eiface_rcvdata(hook_p hook, item_p item)
521 {
522 	const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
523 	struct ifnet *const ifp = priv->ifp;
524 	struct mbuf *m;
525 
526 	NGI_GET_M(item, m);
527 	NG_FREE_ITEM(item);
528 
529 	if (!((ifp->if_flags & IFF_UP) &&
530 	    (ifp->if_drv_flags & IFF_DRV_RUNNING))) {
531 		NG_FREE_M(m);
532 		return (ENETDOWN);
533 	}
534 
535 	if (m->m_len < ETHER_HDR_LEN) {
536 		m = m_pullup(m, ETHER_HDR_LEN);
537 		if (m == NULL)
538 			return (EINVAL);
539 	}
540 
541 	/* Note receiving interface */
542 	m->m_pkthdr.rcvif = ifp;
543 
544 	/* Update interface stats */
545 	ifp->if_ipackets++;
546 
547 	(*ifp->if_input)(ifp, m);
548 
549 	/* Done */
550 	return (0);
551 }
552 
553 /*
554  * Shutdown processing.
555  */
556 static int
557 ng_eiface_rmnode(node_p node)
558 {
559 	const priv_p priv = NG_NODE_PRIVATE(node);
560 	struct ifnet *const ifp = priv->ifp;
561 
562 	ether_ifdetach(ifp);
563 	if_free(ifp);
564 	free_unr(ng_eiface_unit, priv->unit);
565 	FREE(priv, M_NETGRAPH);
566 	NG_NODE_SET_PRIVATE(node, NULL);
567 	NG_NODE_UNREF(node);
568 	return (0);
569 }
570 
571 /*
572  * Hook disconnection
573  */
574 static int
575 ng_eiface_disconnect(hook_p hook)
576 {
577 	const priv_p priv = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
578 
579 	priv->ether = NULL;
580 	return (0);
581 }
582 
583 /*
584  * Handle loading and unloading for this node type.
585  */
586 static int
587 ng_eiface_mod_event(module_t mod, int event, void *data)
588 {
589 	int error = 0;
590 
591 	switch (event) {
592 	case MOD_LOAD:
593 		ng_eiface_unit = new_unrhdr(0, 0xffff, NULL);
594 		break;
595 	case MOD_UNLOAD:
596 		delete_unrhdr(ng_eiface_unit);
597 		break;
598 	default:
599 		error = EOPNOTSUPP;
600 		break;
601 	}
602 	return (error);
603 }
604