Annotation of sys/lib/libsa/netif.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: netif.c,v 1.8 2003/08/11 06:23:09 deraadt Exp $ */
! 2: /* $NetBSD: netif.c,v 1.7 1996/10/13 02:29:03 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1993 Adam Glass
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed by Adam Glass.
! 19: * 4. The name of the Author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission.
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY Adam Glass ``AS IS'' AND
! 23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 32: * SUCH DAMAGE.
! 33: */
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/types.h>
! 37: #include <sys/cdefs.h>
! 38: #include <sys/mount.h>
! 39:
! 40: #include <netinet/in.h>
! 41: #include <netinet/in_systm.h>
! 42:
! 43: #include "stand.h"
! 44: #include "net.h"
! 45: #include "netif.h"
! 46:
! 47: struct iodesc sockets[SOPEN_MAX];
! 48: #ifdef NETIF_DEBUG
! 49: int netif_debug = 0;
! 50: #endif
! 51:
! 52: /*
! 53: * netif_init:
! 54: *
! 55: * initialize the generic network interface layer
! 56: */
! 57:
! 58: void
! 59: netif_init(void)
! 60: {
! 61: struct netif_driver *drv;
! 62: int d, i;
! 63:
! 64: #ifdef NETIF_DEBUG
! 65: if (netif_debug)
! 66: printf("netif_init: called\n");
! 67: #endif
! 68: for (d = 0; d < n_netif_drivers; d++) {
! 69: drv = netif_drivers[d];
! 70: for (i = 0; i < drv->netif_nifs; i++)
! 71: drv->netif_ifs[i].dif_used = 0;
! 72: }
! 73: }
! 74:
! 75: static int
! 76: netif_match(struct netif *nif, void *machdep_hint)
! 77: {
! 78: struct netif_driver *drv = nif->nif_driver;
! 79:
! 80: #if 0
! 81: if (netif_debug)
! 82: printf("%s%d: netif_match (%d)\n", drv->netif_bname,
! 83: nif->nif_unit, nif->nif_sel);
! 84: #endif
! 85: return drv->netif_match(nif, machdep_hint);
! 86: }
! 87:
! 88: struct netif *
! 89: netif_select(void *machdep_hint)
! 90: {
! 91: int d, u, unit_done, s;
! 92: struct netif_driver *drv;
! 93: struct netif cur_if;
! 94: static struct netif best_if;
! 95: int best_val;
! 96: int val;
! 97:
! 98: best_val = 0;
! 99: best_if.nif_driver = NULL;
! 100:
! 101: #ifdef NETIF_DEBUG
! 102: if (netif_debug)
! 103: printf("netif_select: %d interfaces\n", n_netif_drivers);
! 104: #endif
! 105:
! 106: for (d = 0; d < n_netif_drivers; d++) {
! 107: cur_if.nif_driver = netif_drivers[d];
! 108: drv = cur_if.nif_driver;
! 109:
! 110: for (u = 0; u < drv->netif_nifs; u++) {
! 111: cur_if.nif_unit = u;
! 112: unit_done = 0;
! 113:
! 114: #ifdef NETIF_DEBUG
! 115: if (netif_debug)
! 116: printf("\t%s%d:", drv->netif_bname,
! 117: cur_if.nif_unit);
! 118: #endif
! 119:
! 120: for (s = 0; s < drv->netif_ifs[u].dif_nsel; s++) {
! 121: cur_if.nif_sel = s;
! 122:
! 123: if (drv->netif_ifs[u].dif_used & (1 << s)) {
! 124: #ifdef NETIF_DEBUG
! 125: if (netif_debug)
! 126: printf(" [%d used]", s);
! 127: #endif
! 128: continue;
! 129: }
! 130:
! 131: val = netif_match(&cur_if, machdep_hint);
! 132: #ifdef NETIF_DEBUG
! 133: if (netif_debug)
! 134: printf(" [%d -> %d]", s, val);
! 135: #endif
! 136: if (val > best_val) {
! 137: best_val = val;
! 138: best_if = cur_if;
! 139: }
! 140: }
! 141: #ifdef NETIF_DEBUG
! 142: if (netif_debug)
! 143: printf("\n");
! 144: #endif
! 145: }
! 146: }
! 147:
! 148: if (best_if.nif_driver == NULL)
! 149: return NULL;
! 150:
! 151: best_if.nif_driver->netif_ifs[best_if.nif_unit].dif_used |=
! 152: (1 << best_if.nif_sel);
! 153:
! 154: #ifdef NETIF_DEBUG
! 155: if (netif_debug)
! 156: printf("netif_select: %s%d(%d) wins\n",
! 157: best_if.nif_driver->netif_bname,
! 158: best_if.nif_unit, best_if.nif_sel);
! 159: #endif
! 160: return &best_if;
! 161: }
! 162:
! 163: int
! 164: netif_probe(struct netif *nif, void *machdep_hint)
! 165: {
! 166: struct netif_driver *drv = nif->nif_driver;
! 167:
! 168: #ifdef NETIF_DEBUG
! 169: if (netif_debug)
! 170: printf("%s%d: netif_probe\n", drv->netif_bname, nif->nif_unit);
! 171: #endif
! 172: return drv->netif_probe(nif, machdep_hint);
! 173: }
! 174:
! 175: void
! 176: netif_attach(struct netif *nif, struct iodesc *desc, void *machdep_hint)
! 177: {
! 178: struct netif_driver *drv = nif->nif_driver;
! 179:
! 180: #ifdef NETIF_DEBUG
! 181: if (netif_debug)
! 182: printf("%s%d: netif_attach\n", drv->netif_bname, nif->nif_unit);
! 183: #endif
! 184: desc->io_netif = nif;
! 185: #ifdef PARANOID
! 186: if (drv->netif_init == NULL)
! 187: panic("%s%d: no netif_init support", drv->netif_bname,
! 188: nif->nif_unit);
! 189: #endif
! 190: drv->netif_init(desc, machdep_hint);
! 191: bzero(drv->netif_ifs[nif->nif_unit].dif_stats,
! 192: sizeof(struct netif_stats));
! 193: }
! 194:
! 195: void
! 196: netif_detach(struct netif *nif)
! 197: {
! 198: struct netif_driver *drv = nif->nif_driver;
! 199:
! 200: #ifdef NETIF_DEBUG
! 201: if (netif_debug)
! 202: printf("%s%d: netif_detach\n", drv->netif_bname, nif->nif_unit);
! 203: #endif
! 204: #ifdef PARANOID
! 205: if (drv->netif_end == NULL)
! 206: panic("%s%d: no netif_end support", drv->netif_bname,
! 207: nif->nif_unit);
! 208: #endif
! 209: drv->netif_end(nif);
! 210: }
! 211:
! 212: ssize_t
! 213: netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timo)
! 214: {
! 215: #ifdef NETIF_DEBUG
! 216: struct netif *nif = desc->io_netif;
! 217: #endif
! 218: struct netif_driver *drv = desc->io_netif->nif_driver;
! 219: ssize_t rv;
! 220:
! 221: #ifdef NETIF_DEBUG
! 222: if (netif_debug)
! 223: printf("%s%d: netif_get\n", drv->netif_bname, nif->nif_unit);
! 224: #endif
! 225: #ifdef PARANOID
! 226: if (drv->netif_get == NULL)
! 227: panic("%s%d: no netif_get support", drv->netif_bname,
! 228: nif->nif_unit);
! 229: #endif
! 230: rv = drv->netif_get(desc, pkt, len, timo);
! 231: #ifdef NETIF_DEBUG
! 232: if (netif_debug)
! 233: printf("%s%d: netif_get returning %d\n", drv->netif_bname,
! 234: nif->nif_unit, rv);
! 235: #endif
! 236: return rv;
! 237: }
! 238:
! 239: ssize_t
! 240: netif_put(struct iodesc *desc, void *pkt, size_t len)
! 241: {
! 242: #ifdef NETIF_DEBUG
! 243: struct netif *nif = desc->io_netif;
! 244: #endif
! 245: struct netif_driver *drv = desc->io_netif->nif_driver;
! 246: ssize_t rv;
! 247:
! 248: #ifdef NETIF_DEBUG
! 249: if (netif_debug)
! 250: printf("%s%d: netif_put\n", drv->netif_bname, nif->nif_unit);
! 251: #endif
! 252: #ifdef PARANOID
! 253: if (drv->netif_put == NULL)
! 254: panic("%s%d: no netif_put support", drv->netif_bname,
! 255: nif->nif_unit);
! 256: #endif
! 257: rv = drv->netif_put(desc, pkt, len);
! 258: #ifdef NETIF_DEBUG
! 259: if (netif_debug)
! 260: printf("%s%d: netif_put returning %d\n", drv->netif_bname,
! 261: nif->nif_unit, rv);
! 262: #endif
! 263: return rv;
! 264: }
! 265:
! 266: struct iodesc *
! 267: socktodesc(sock)
! 268: int sock;
! 269: {
! 270: if (sock >= SOPEN_MAX) {
! 271: errno = EBADF;
! 272: return (NULL);
! 273: }
! 274: return (&sockets[sock]);
! 275: }
! 276:
! 277: int
! 278: netif_open(void *machdep_hint)
! 279: {
! 280: int fd;
! 281: struct iodesc *s;
! 282: struct netif *nif;
! 283:
! 284: /* find a free socket */
! 285: for (fd = 0, s = sockets; fd < SOPEN_MAX; fd++, s++)
! 286: if (s->io_netif == (struct netif *)0)
! 287: goto fnd;
! 288: errno = EMFILE;
! 289: return (-1);
! 290:
! 291: fnd:
! 292: bzero(s, sizeof(*s));
! 293: netif_init();
! 294: nif = netif_select(machdep_hint);
! 295: if (!nif)
! 296: panic("netboot: no interfaces left untried");
! 297: if (netif_probe(nif, machdep_hint)) {
! 298: printf("netboot: couldn't probe %s%d\n",
! 299: nif->nif_driver->netif_bname, nif->nif_unit);
! 300: errno = EINVAL;
! 301: return(-1);
! 302: }
! 303: netif_attach(nif, s, machdep_hint);
! 304:
! 305: return(fd);
! 306: }
! 307:
! 308: int
! 309: netif_close(int sock)
! 310: {
! 311: if (sock >= SOPEN_MAX) {
! 312: errno = EBADF;
! 313: return(-1);
! 314: }
! 315: netif_detach(sockets[sock].io_netif);
! 316: sockets[sock].io_netif = (struct netif *)0;
! 317:
! 318: return(0);
! 319: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to netif.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / lib / libsa