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