1/*-
2 * Copyright (c) 2012 Gleb Smirnoff <glebius@FreeBSD.org>
3 * Copyright (c) 1980, 1986, 1993
4 *	The Regents of the University of California.  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, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 4. Neither the name of the University nor the names of its contributors
15 *    may be used to endorse or promote products derived from this software
16 *    without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 *	@(#)if.c	8.5 (Berkeley) 1/9/95
31 * $FreeBSD: stable/10/sys/net/if_clone.c 324813 2017-10-21 10:48:06Z avos $
32 */
33
34#include <sys/param.h>
35#include <sys/malloc.h>
36#include <sys/limits.h>
37#include <sys/lock.h>
38#include <sys/mutex.h>
39#include <sys/kernel.h>
40#include <sys/systm.h>
41#include <sys/types.h>
42#include <sys/socket.h>
43
44#include <net/if.h>
45#include <net/if_clone.h>
46#include <net/if_var.h>
47#include <net/radix.h>
48#include <net/route.h>
49#include <net/vnet.h>
50
51/* Current IF_MAXUNIT expands maximum to 5 characters. */
52#define	IFCLOSIZ	(IFNAMSIZ - 5)
53
54/*
55 * Structure describing a `cloning' interface.
56 *
57 * List of locks
58 * (c)		const until freeing
59 * (d)		driver specific data, may need external protection.
60 * (e)		locked by if_cloners_mtx
61 * (i)		locked by ifc_mtx mtx
62 */
63struct if_clone {
64	char ifc_name[IFCLOSIZ];	/* (c) Name of device, e.g. `gif' */
65	struct unrhdr *ifc_unrhdr;	/* (c) alloc_unr(9) header */
66	int ifc_maxunit;		/* (c) maximum unit number */
67	long ifc_refcnt;		/* (i) Reference count. */
68	LIST_HEAD(, ifnet) ifc_iflist;	/* (i) List of cloned interfaces */
69	struct mtx ifc_mtx;		/* Mutex to protect members. */
70
71	enum { SIMPLE, ADVANCED } ifc_type; /* (c) */
72
73	/* (c) Driver specific cloning functions.  Called with no locks held. */
74	union {
75		struct {	/* advanced cloner */
76			ifc_match_t	*_ifc_match;
77			ifc_create_t	*_ifc_create;
78			ifc_destroy_t	*_ifc_destroy;
79		} A;
80		struct {	/* simple cloner */
81			ifcs_create_t	*_ifcs_create;
82			ifcs_destroy_t	*_ifcs_destroy;
83			int		_ifcs_minifs;	/* minimum ifs */
84
85		} S;
86	} U;
87#define	ifc_match	U.A._ifc_match
88#define	ifc_create	U.A._ifc_create
89#define	ifc_destroy	U.A._ifc_destroy
90#define	ifcs_create	U.S._ifcs_create
91#define	ifcs_destroy	U.S._ifcs_destroy
92#define	ifcs_minifs	U.S._ifcs_minifs
93
94	LIST_ENTRY(if_clone) ifc_list;	/* (e) On list of cloners */
95};
96
97static void	if_clone_free(struct if_clone *ifc);
98static int	if_clone_createif(struct if_clone *ifc, char *name, size_t len,
99		    caddr_t params);
100
101static int     ifc_simple_match(struct if_clone *, const char *);
102static int     ifc_simple_create(struct if_clone *, char *, size_t, caddr_t);
103static int     ifc_simple_destroy(struct if_clone *, struct ifnet *);
104
105static struct mtx	if_cloners_mtx;
106static VNET_DEFINE(int, if_cloners_count);
107VNET_DEFINE(LIST_HEAD(, if_clone), if_cloners);
108
109#define	V_if_cloners_count	VNET(if_cloners_count)
110#define	V_if_cloners		VNET(if_cloners)
111
112#define IF_CLONERS_LOCK_INIT()		\
113    mtx_init(&if_cloners_mtx, "if_cloners lock", NULL, MTX_DEF)
114#define IF_CLONERS_LOCK_ASSERT()	mtx_assert(&if_cloners_mtx, MA_OWNED)
115#define IF_CLONERS_LOCK()		mtx_lock(&if_cloners_mtx)
116#define IF_CLONERS_UNLOCK()		mtx_unlock(&if_cloners_mtx)
117
118#define IF_CLONE_LOCK_INIT(ifc)		\
119    mtx_init(&(ifc)->ifc_mtx, "if_clone lock", NULL, MTX_DEF)
120#define IF_CLONE_LOCK_DESTROY(ifc)	mtx_destroy(&(ifc)->ifc_mtx)
121#define IF_CLONE_LOCK_ASSERT(ifc)	mtx_assert(&(ifc)->ifc_mtx, MA_OWNED)
122#define IF_CLONE_LOCK(ifc)		mtx_lock(&(ifc)->ifc_mtx)
123#define IF_CLONE_UNLOCK(ifc)		mtx_unlock(&(ifc)->ifc_mtx)
124
125#define IF_CLONE_ADDREF(ifc)						\
126	do {								\
127		IF_CLONE_LOCK(ifc);					\
128		IF_CLONE_ADDREF_LOCKED(ifc);				\
129		IF_CLONE_UNLOCK(ifc);					\
130	} while (0)
131#define IF_CLONE_ADDREF_LOCKED(ifc)					\
132	do {								\
133		IF_CLONE_LOCK_ASSERT(ifc);				\
134		KASSERT((ifc)->ifc_refcnt >= 0,				\
135		    ("negative refcnt %ld", (ifc)->ifc_refcnt));	\
136		(ifc)->ifc_refcnt++;					\
137	} while (0)
138#define IF_CLONE_REMREF(ifc)						\
139	do {								\
140		IF_CLONE_LOCK(ifc);					\
141		IF_CLONE_REMREF_LOCKED(ifc);				\
142	} while (0)
143#define IF_CLONE_REMREF_LOCKED(ifc)					\
144	do {								\
145		IF_CLONE_LOCK_ASSERT(ifc);				\
146		KASSERT((ifc)->ifc_refcnt > 0,				\
147		    ("bogus refcnt %ld", (ifc)->ifc_refcnt));		\
148		if (--(ifc)->ifc_refcnt == 0) {				\
149			IF_CLONE_UNLOCK(ifc);				\
150			if_clone_free(ifc);				\
151		} else {						\
152			/* silently free the lock */			\
153			IF_CLONE_UNLOCK(ifc);				\
154		}							\
155	} while (0)
156
157#define IFC_IFLIST_INSERT(_ifc, _ifp)					\
158	LIST_INSERT_HEAD(&_ifc->ifc_iflist, _ifp, if_clones)
159#define IFC_IFLIST_REMOVE(_ifc, _ifp)					\
160	LIST_REMOVE(_ifp, if_clones)
161
162static MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework");
163
164void
165vnet_if_clone_init(void)
166{
167
168	LIST_INIT(&V_if_cloners);
169}
170
171void
172if_clone_init(void)
173{
174
175	IF_CLONERS_LOCK_INIT();
176}
177
178/*
179 * Lookup and create a clone network interface.
180 */
181int
182if_clone_create(char *name, size_t len, caddr_t params)
183{
184	struct if_clone *ifc;
185
186	/* Try to find an applicable cloner for this request */
187	IF_CLONERS_LOCK();
188	LIST_FOREACH(ifc, &V_if_cloners, ifc_list)
189		if (ifc->ifc_type == SIMPLE) {
190			if (ifc_simple_match(ifc, name))
191				break;
192		} else {
193			if (ifc->ifc_match(ifc, name))
194				break;
195		}
196#ifdef VIMAGE
197	if (ifc == NULL && !IS_DEFAULT_VNET(curvnet)) {
198		CURVNET_SET_QUIET(vnet0);
199		LIST_FOREACH(ifc, &V_if_cloners, ifc_list)
200			if (ifc->ifc_type == SIMPLE) {
201				if (ifc_simple_match(ifc, name))
202					break;
203			} else {
204				if (ifc->ifc_match(ifc, name))
205					break;
206			}
207		CURVNET_RESTORE();
208	}
209#endif
210	IF_CLONERS_UNLOCK();
211
212	if (ifc == NULL)
213		return (EINVAL);
214
215	return (if_clone_createif(ifc, name, len, params));
216}
217
218/*
219 * Create a clone network interface.
220 */
221static int
222if_clone_createif(struct if_clone *ifc, char *name, size_t len, caddr_t params)
223{
224	int err;
225	struct ifnet *ifp;
226
227	if (ifunit(name) != NULL)
228		return (EEXIST);
229
230	if (ifc->ifc_type == SIMPLE)
231		err = ifc_simple_create(ifc, name, len, params);
232	else
233		err = (*ifc->ifc_create)(ifc, name, len, params);
234
235	if (!err) {
236		ifp = ifunit(name);
237		if (ifp == NULL)
238			panic("%s: lookup failed for %s", __func__, name);
239
240		if_addgroup(ifp, ifc->ifc_name);
241
242		IF_CLONE_LOCK(ifc);
243		IFC_IFLIST_INSERT(ifc, ifp);
244		IF_CLONE_UNLOCK(ifc);
245	}
246
247	return (err);
248}
249
250/*
251 * Lookup and destroy a clone network interface.
252 */
253int
254if_clone_destroy(const char *name)
255{
256	int err;
257	struct if_clone *ifc;
258	struct ifnet *ifp;
259
260	ifp = ifunit_ref(name);
261	if (ifp == NULL)
262		return (ENXIO);
263
264	/* Find the cloner for this interface */
265	IF_CLONERS_LOCK();
266	LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
267		if (strcmp(ifc->ifc_name, ifp->if_dname) == 0) {
268			break;
269		}
270	}
271#ifdef VIMAGE
272	if (ifc == NULL && !IS_DEFAULT_VNET(curvnet)) {
273		CURVNET_SET_QUIET(vnet0);
274		LIST_FOREACH(ifc, &V_if_cloners, ifc_list)
275			if (ifc->ifc_type == SIMPLE) {
276				if (ifc_simple_match(ifc, name))
277					break;
278			} else {
279				if (ifc->ifc_match(ifc, name))
280					break;
281			}
282		CURVNET_RESTORE();
283	}
284#endif
285	IF_CLONERS_UNLOCK();
286	if (ifc == NULL) {
287		if_rele(ifp);
288		return (EINVAL);
289	}
290
291	err = if_clone_destroyif(ifc, ifp);
292	if_rele(ifp);
293	return err;
294}
295
296/*
297 * Destroy a clone network interface.
298 */
299int
300if_clone_destroyif(struct if_clone *ifc, struct ifnet *ifp)
301{
302	int err;
303	struct ifnet *ifcifp;
304
305	if (ifc->ifc_type == ADVANCED && ifc->ifc_destroy == NULL)
306		return(EOPNOTSUPP);
307
308	/*
309	 * Given that the cloned ifnet might be attached to a different
310	 * vnet from where its cloner was registered, we have to
311	 * switch to the vnet context of the target vnet.
312	 */
313	CURVNET_SET_QUIET(ifp->if_vnet);
314
315	IF_CLONE_LOCK(ifc);
316	LIST_FOREACH(ifcifp, &ifc->ifc_iflist, if_clones) {
317		if (ifcifp == ifp) {
318			IFC_IFLIST_REMOVE(ifc, ifp);
319			break;
320		}
321	}
322	IF_CLONE_UNLOCK(ifc);
323	if (ifcifp == NULL) {
324		CURVNET_RESTORE();
325		return (ENXIO);		/* ifp is not on the list. */
326	}
327
328	if_delgroup(ifp, ifc->ifc_name);
329
330	if (ifc->ifc_type == SIMPLE)
331		err = ifc_simple_destroy(ifc, ifp);
332	else
333		err = (*ifc->ifc_destroy)(ifc, ifp);
334
335	if (err != 0) {
336		if_addgroup(ifp, ifc->ifc_name);
337
338		IF_CLONE_LOCK(ifc);
339		IFC_IFLIST_INSERT(ifc, ifp);
340		IF_CLONE_UNLOCK(ifc);
341	}
342	CURVNET_RESTORE();
343	return (err);
344}
345
346static struct if_clone *
347if_clone_alloc(const char *name, int maxunit)
348{
349	struct if_clone *ifc;
350
351	KASSERT(name != NULL, ("%s: no name\n", __func__));
352
353	ifc = malloc(sizeof(struct if_clone), M_CLONE, M_WAITOK | M_ZERO);
354	strncpy(ifc->ifc_name, name, IFCLOSIZ-1);
355	IF_CLONE_LOCK_INIT(ifc);
356	IF_CLONE_ADDREF(ifc);
357	ifc->ifc_maxunit = maxunit ? maxunit : IF_MAXUNIT;
358	ifc->ifc_unrhdr = new_unrhdr(0, ifc->ifc_maxunit, &ifc->ifc_mtx);
359	LIST_INIT(&ifc->ifc_iflist);
360
361	return (ifc);
362}
363
364static int
365if_clone_attach(struct if_clone *ifc)
366{
367	struct if_clone *ifc1;
368
369	IF_CLONERS_LOCK();
370	LIST_FOREACH(ifc1, &V_if_cloners, ifc_list)
371		if (strcmp(ifc->ifc_name, ifc1->ifc_name) == 0) {
372			IF_CLONERS_UNLOCK();
373			IF_CLONE_REMREF(ifc);
374			return (EEXIST);
375		}
376	LIST_INSERT_HEAD(&V_if_cloners, ifc, ifc_list);
377	V_if_cloners_count++;
378	IF_CLONERS_UNLOCK();
379
380	return (0);
381}
382
383struct if_clone *
384if_clone_advanced(const char *name, u_int maxunit, ifc_match_t match,
385	ifc_create_t create, ifc_destroy_t destroy)
386{
387	struct if_clone *ifc;
388
389	ifc = if_clone_alloc(name, maxunit);
390	ifc->ifc_type = ADVANCED;
391	ifc->ifc_match = match;
392	ifc->ifc_create = create;
393	ifc->ifc_destroy = destroy;
394
395	if (if_clone_attach(ifc) != 0) {
396		if_clone_free(ifc);
397		return (NULL);
398	}
399
400	EVENTHANDLER_INVOKE(if_clone_event, ifc);
401
402	return (ifc);
403}
404
405struct if_clone *
406if_clone_simple(const char *name, ifcs_create_t create, ifcs_destroy_t destroy,
407	u_int minifs)
408{
409	struct if_clone *ifc;
410	u_int unit;
411
412	ifc = if_clone_alloc(name, 0);
413	ifc->ifc_type = SIMPLE;
414	ifc->ifcs_create = create;
415	ifc->ifcs_destroy = destroy;
416	ifc->ifcs_minifs = minifs;
417
418	if (if_clone_attach(ifc) != 0) {
419		if_clone_free(ifc);
420		return (NULL);
421	}
422
423	for (unit = 0; unit < minifs; unit++) {
424		char name[IFNAMSIZ];
425		int error;
426
427		snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
428		error = if_clone_createif(ifc, name, IFNAMSIZ, NULL);
429		KASSERT(error == 0,
430		    ("%s: failed to create required interface %s",
431		    __func__, name));
432	}
433
434	EVENTHANDLER_INVOKE(if_clone_event, ifc);
435
436	return (ifc);
437}
438
439/*
440 * Unregister a network interface cloner.
441 */
442void
443if_clone_detach(struct if_clone *ifc)
444{
445
446	IF_CLONERS_LOCK();
447	LIST_REMOVE(ifc, ifc_list);
448	V_if_cloners_count--;
449	IF_CLONERS_UNLOCK();
450
451	/* Allow all simples to be destroyed */
452	if (ifc->ifc_type == SIMPLE)
453		ifc->ifcs_minifs = 0;
454
455	/* destroy all interfaces for this cloner */
456	while (!LIST_EMPTY(&ifc->ifc_iflist))
457		if_clone_destroyif(ifc, LIST_FIRST(&ifc->ifc_iflist));
458
459	IF_CLONE_REMREF(ifc);
460}
461
462static void
463if_clone_free(struct if_clone *ifc)
464{
465
466	KASSERT(LIST_EMPTY(&ifc->ifc_iflist),
467	    ("%s: ifc_iflist not empty", __func__));
468
469	IF_CLONE_LOCK_DESTROY(ifc);
470	delete_unrhdr(ifc->ifc_unrhdr);
471	free(ifc, M_CLONE);
472}
473
474/*
475 * Provide list of interface cloners to userspace.
476 */
477int
478if_clone_list(struct if_clonereq *ifcr)
479{
480	char *buf, *dst, *outbuf = NULL;
481	struct if_clone *ifc;
482	int buf_count, count, err = 0;
483
484	if (ifcr->ifcr_count < 0)
485		return (EINVAL);
486
487	IF_CLONERS_LOCK();
488	/*
489	 * Set our internal output buffer size.  We could end up not
490	 * reporting a cloner that is added between the unlock and lock
491	 * below, but that's not a major problem.  Not caping our
492	 * allocation to the number of cloners actually in the system
493	 * could be because that would let arbitrary users cause us to
494	 * allocate abritrary amounts of kernel memory.
495	 */
496	buf_count = (V_if_cloners_count < ifcr->ifcr_count) ?
497	    V_if_cloners_count : ifcr->ifcr_count;
498	IF_CLONERS_UNLOCK();
499
500	outbuf = malloc(IFNAMSIZ*buf_count, M_CLONE, M_WAITOK | M_ZERO);
501
502	IF_CLONERS_LOCK();
503
504	ifcr->ifcr_total = V_if_cloners_count;
505	if ((dst = ifcr->ifcr_buffer) == NULL) {
506		/* Just asking how many there are. */
507		goto done;
508	}
509	count = (V_if_cloners_count < buf_count) ?
510	    V_if_cloners_count : buf_count;
511
512	for (ifc = LIST_FIRST(&V_if_cloners), buf = outbuf;
513	    ifc != NULL && count != 0;
514	    ifc = LIST_NEXT(ifc, ifc_list), count--, buf += IFNAMSIZ) {
515		strlcpy(buf, ifc->ifc_name, IFNAMSIZ);
516	}
517
518done:
519	IF_CLONERS_UNLOCK();
520	if (err == 0)
521		err = copyout(outbuf, dst, buf_count*IFNAMSIZ);
522	if (outbuf != NULL)
523		free(outbuf, M_CLONE);
524	return (err);
525}
526
527/*
528 * if_clone_findifc() looks up ifnet from the current
529 * cloner list, and returns ifc if found.  Note that ifc_refcnt
530 * is incremented.
531 */
532struct if_clone *
533if_clone_findifc(struct ifnet *ifp)
534{
535	struct if_clone *ifc, *ifc0;
536	struct ifnet *ifcifp;
537
538	ifc0 = NULL;
539	IF_CLONERS_LOCK();
540	LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
541		IF_CLONE_LOCK(ifc);
542		LIST_FOREACH(ifcifp, &ifc->ifc_iflist, if_clones) {
543			if (ifp == ifcifp) {
544				ifc0 = ifc;
545				IF_CLONE_ADDREF_LOCKED(ifc);
546				break;
547			}
548		}
549		IF_CLONE_UNLOCK(ifc);
550		if (ifc0 != NULL)
551			break;
552	}
553	IF_CLONERS_UNLOCK();
554
555	return (ifc0);
556}
557
558/*
559 * if_clone_addgroup() decrements ifc_refcnt because it is called after
560 * if_clone_findifc().
561 */
562void
563if_clone_addgroup(struct ifnet *ifp, struct if_clone *ifc)
564{
565
566	if_addgroup(ifp, ifc->ifc_name);
567	IF_CLONE_REMREF(ifc);
568}
569
570/*
571 * A utility function to extract unit numbers from interface names of
572 * the form name###.
573 *
574 * Returns 0 on success and an error on failure.
575 */
576int
577ifc_name2unit(const char *name, int *unit)
578{
579	const char	*cp;
580	int		cutoff = INT_MAX / 10;
581	int		cutlim = INT_MAX % 10;
582
583	for (cp = name; *cp != '\0' && (*cp < '0' || *cp > '9'); cp++);
584	if (*cp == '\0') {
585		*unit = -1;
586	} else if (cp[0] == '0' && cp[1] != '\0') {
587		/* Disallow leading zeroes. */
588		return (EINVAL);
589	} else {
590		for (*unit = 0; *cp != '\0'; cp++) {
591			if (*cp < '0' || *cp > '9') {
592				/* Bogus unit number. */
593				return (EINVAL);
594			}
595			if (*unit > cutoff ||
596			    (*unit == cutoff && *cp - '0' > cutlim))
597				return (EINVAL);
598			*unit = (*unit * 10) + (*cp - '0');
599		}
600	}
601
602	return (0);
603}
604
605static int
606ifc_alloc_unit_specific(struct if_clone *ifc, int *unit)
607{
608	char name[IFNAMSIZ];
609
610	if (*unit > ifc->ifc_maxunit)
611		return (ENOSPC);
612
613	if (alloc_unr_specific(ifc->ifc_unrhdr, *unit) == -1)
614		return (EEXIST);
615
616	snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, *unit);
617	if (ifunit(name) != NULL) {
618		free_unr(ifc->ifc_unrhdr, *unit);
619		return (EEXIST);
620	}
621
622	IF_CLONE_ADDREF(ifc);
623
624	return (0);
625}
626
627static int
628ifc_alloc_unit_next(struct if_clone *ifc, int *unit)
629{
630	int error;
631
632	*unit = alloc_unr(ifc->ifc_unrhdr);
633	if (*unit == -1)
634		return (ENOSPC);
635
636	free_unr(ifc->ifc_unrhdr, *unit);
637	for (;;) {
638		error = ifc_alloc_unit_specific(ifc, unit);
639		if (error != EEXIST)
640			break;
641
642		(*unit)++;
643	}
644
645	return (error);
646}
647
648int
649ifc_alloc_unit(struct if_clone *ifc, int *unit)
650{
651	if (*unit < 0)
652		return (ifc_alloc_unit_next(ifc, unit));
653	else
654		return (ifc_alloc_unit_specific(ifc, unit));
655}
656
657void
658ifc_free_unit(struct if_clone *ifc, int unit)
659{
660
661	free_unr(ifc->ifc_unrhdr, unit);
662	IF_CLONE_REMREF(ifc);
663}
664
665static int
666ifc_simple_match(struct if_clone *ifc, const char *name)
667{
668	const char *cp;
669	int i;
670
671	/* Match the name */
672	for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
673		if (ifc->ifc_name[i] != *cp)
674			return (0);
675	}
676
677	/* Make sure there's a unit number or nothing after the name */
678	for (; *cp != '\0'; cp++) {
679		if (*cp < '0' || *cp > '9')
680			return (0);
681	}
682
683	return (1);
684}
685
686static int
687ifc_simple_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
688{
689	char *dp;
690	int wildcard;
691	int unit;
692	int err;
693
694	err = ifc_name2unit(name, &unit);
695	if (err != 0)
696		return (err);
697
698	wildcard = (unit < 0);
699
700	err = ifc_alloc_unit(ifc, &unit);
701	if (err != 0)
702		return (err);
703
704	err = ifc->ifcs_create(ifc, unit, params);
705	if (err != 0) {
706		ifc_free_unit(ifc, unit);
707		return (err);
708	}
709
710	/* In the wildcard case, we need to update the name. */
711	if (wildcard) {
712		for (dp = name; *dp != '\0'; dp++);
713		if (snprintf(dp, len - (dp-name), "%d", unit) >
714		    len - (dp-name) - 1) {
715			/*
716			 * This can only be a programmer error and
717			 * there's no straightforward way to recover if
718			 * it happens.
719			 */
720			panic("if_clone_create(): interface name too long");
721		}
722
723	}
724
725	return (0);
726}
727
728static int
729ifc_simple_destroy(struct if_clone *ifc, struct ifnet *ifp)
730{
731	int unit;
732
733	unit = ifp->if_dunit;
734
735	if (unit < ifc->ifcs_minifs)
736		return (EINVAL);
737
738	ifc->ifcs_destroy(ifp);
739
740	ifc_free_unit(ifc, unit);
741
742	return (0);
743}
744