if_srt.c revision 1.26.4.1
1 /* $NetBSD: if_srt.c,v 1.26.4.1 2017/04/29 09:17:59 pgoyette Exp $ */ 2 /* This file is in the public domain. */ 3 4 #include <sys/cdefs.h> 5 __KERNEL_RCSID(0, "$NetBSD: if_srt.c,v 1.26.4.1 2017/04/29 09:17:59 pgoyette Exp $"); 6 7 #ifdef _KERNEL_OPT 8 #include "opt_inet.h" 9 #endif 10 11 #if !defined(INET) && !defined(INET6) 12 #error "srt without INET/INET6?" 13 #endif 14 15 #ifndef SRT_MAXUNIT 16 #define SRT_MAXUNIT 255 17 #endif 18 19 /* include-file bug workarounds */ 20 #include <sys/types.h> /* sys/conf.h */ 21 #include <sys/resource.h> /* sys/resourcevar.h 22 * (uvm/uvm_param.h, sys/mbuf.h) 23 */ 24 #include <netinet/in.h> /* netinet/ip.h */ 25 #include <sys/param.h> /* sys/mbuf.h */ 26 #include <netinet/in_systm.h> /* netinet/ip.h */ 27 28 #include <sys/localcount.h> 29 #include <sys/conf.h> 30 #include <sys/mbuf.h> 31 #include <sys/errno.h> 32 #include <sys/fcntl.h> 33 #include <sys/param.h> 34 #include <sys/ioctl.h> 35 #include <sys/module.h> 36 #include <sys/device.h> 37 #include <netinet/ip.h> 38 #include <netinet/ip6.h> 39 #include <netinet6/in6_var.h> 40 #include <netinet6/ip6_var.h> 41 #include <netinet6/nd6.h> 42 #include <netinet6/scope6_var.h> 43 #include <net/if_types.h> 44 45 #include "if_srt.h" 46 47 /* until we know what to pass to bpfattach.... */ 48 /* #define BPFILTER_NOW_AVAILABLE */ 49 50 struct srt_softc { 51 struct ifnet intf; /* XXX interface botch */ 52 int unit; 53 int nrt; 54 struct srt_rt **rts; 55 unsigned int flags; /* SSF_* values from if_srt.h */ 56 #define SSF_UCHG (SSF_MTULOCK) /* userland-changeable bits */ 57 unsigned int kflags; /* bits private to this file */ 58 #define SKF_CDEVOPEN 0x00000001 59 }; 60 61 #include "ioconf.h" 62 63 static struct srt_softc *softcv[SRT_MAXUNIT+1]; 64 static unsigned int global_flags; 65 66 static u_int srt_count; 67 68 /* Internal routines. */ 69 70 static unsigned int ipv4_masks[33] = { 71 0x00000000, /* /0 */ 72 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, /* /1 - /4 */ 73 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000, /* /5 - /8 */ 74 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000, /* /9 - /12 */ 75 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, /* /13 - /16 */ 76 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000, /* /17 - /20 */ 77 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00, /* /21 - /24 */ 78 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, /* /25 - /28 */ 79 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff /* /29 - /32 */ 80 }; 81 82 static void 83 update_mtu(struct srt_softc *sc) 84 { 85 int mtu; 86 int i; 87 struct srt_rt *r; 88 89 if (sc->flags & SSF_MTULOCK) 90 return; 91 mtu = 65535; 92 for (i=sc->nrt-1;i>=0;i--) { 93 r = sc->rts[i]; 94 if (r->u.dstifp->if_mtu < mtu) 95 mtu = r->u.dstifp->if_mtu; 96 } 97 sc->intf.if_mtu = mtu; 98 } 99 100 static struct srt_rt * 101 find_rt(struct srt_softc *sc, int af, ...) 102 { 103 int i; 104 struct srt_rt *r; 105 struct in_addr ia; 106 struct in6_addr ia6; 107 va_list ap; 108 109 ia.s_addr = 0; ia6.s6_addr[0] = 0; /* shut up incorrect -Wuninitialized */ 110 va_start(ap,af); 111 switch (af) { 112 case AF_INET: 113 ia = va_arg(ap,struct in_addr); 114 break; 115 case AF_INET6: 116 ia6 = va_arg(ap,struct in6_addr); 117 break; 118 default: 119 panic("if_srt find_rt: impossible address family"); 120 break; 121 } 122 va_end(ap); 123 for (i=0; i < sc->nrt; i++) { 124 r = sc->rts[i]; 125 if (r->af != af) 126 continue; 127 switch (af) { 128 case AF_INET: 129 if ((ia.s_addr & htonl(ipv4_masks[r->srcmask])) == 130 r->srcmatch.v4.s_addr) 131 return r; 132 break; 133 case AF_INET6: 134 if ((r->srcmask >= 8) && 135 memcmp(&ia6,&r->srcmatch.v6,r->srcmask / 8) != 0) 136 continue; 137 if ((r->srcmask % 8) && 138 ((ia6.s6_addr[r->srcmask / 8] ^ 139 r->srcmatch.v6.s6_addr[r->srcmask / 8]) & 140 0xff & (0xff00 >> (r->srcmask % 8)))) 141 continue; 142 return r; 143 default: 144 panic("if_srt find_rt: impossible address family 2"); 145 break; 146 } 147 } 148 return 0; 149 } 150 151 /* Network device interface. */ 152 153 static int 154 srt_if_ioctl(struct ifnet *ifp, u_long cmd, void *data) 155 { 156 struct ifaddr *ifa; 157 int s; 158 int err; 159 160 err = 0; 161 s = splnet(); 162 switch (cmd) { 163 case SIOCINITIFADDR: 164 ifa = (void *) data; 165 switch (ifa->ifa_addr->sa_family) { 166 #ifdef INET 167 case AF_INET: 168 break; 169 #endif 170 #ifdef INET6 171 case AF_INET6: 172 break; 173 #endif 174 default: 175 err = EAFNOSUPPORT; 176 break; 177 } 178 break; 179 default: 180 if ((err = ifioctl_common(ifp, cmd, data)) == ENETRESET) 181 err = 0; 182 break; 183 } 184 splx(s); 185 return err; 186 } 187 188 static int 189 srt_if_output( 190 struct ifnet *ifp, 191 struct mbuf *m, 192 const struct sockaddr *to, 193 const struct rtentry *rtp) 194 { 195 struct srt_softc *sc; 196 struct srt_rt *r; 197 198 sc = ifp->if_softc; 199 if (! (ifp->if_flags & IFF_UP)) { 200 m_freem(m); 201 return ENETDOWN; 202 } 203 switch (to->sa_family) { 204 #ifdef INET 205 case AF_INET: { 206 struct ip *ip; 207 ip = mtod(m,struct ip *); 208 r = find_rt(sc,AF_INET,ip->ip_src); 209 break; 210 } 211 #endif 212 #ifdef INET6 213 case AF_INET6: { 214 struct ip6_hdr *ip; 215 ip = mtod(m,struct ip6_hdr *); 216 r = find_rt(sc,AF_INET6,ip->ip6_src); 217 break; 218 } 219 #endif 220 default: 221 IF_DROP(&ifp->if_snd); 222 m_freem(m); 223 return EAFNOSUPPORT; 224 } 225 /* XXX Do we need to bpf_tap? Or do higher layers now handle that? */ 226 /* if_gif.c seems to imply the latter. */ 227 ifp->if_opackets ++; 228 if (! r) { 229 ifp->if_oerrors ++; 230 m_freem(m); 231 return 0; 232 } 233 if (! (m->m_flags & M_PKTHDR)) { 234 printf("srt_if_output no PKTHDR\n"); 235 m_freem(m); 236 return 0; 237 } 238 ifp->if_obytes += m->m_pkthdr.len; 239 if (! (r->u.dstifp->if_flags & IFF_UP)) { 240 m_freem(m); 241 return 0; /* XXX ENETDOWN? */ 242 } 243 /* XXX is 0 the right last arg here? */ 244 if (to->sa_family == AF_INET6) 245 return ip6_if_output(r->u.dstifp, r->u.dstifp, m, &r->dst.sin6, 0); 246 return if_output_lock(r->u.dstifp, r->u.dstifp, m, &r->dst.sa, 0); 247 } 248 249 static int 250 srt_clone_create(struct if_clone *cl, int unit) 251 { 252 struct srt_softc *sc; 253 254 if (unit < 0 || unit > SRT_MAXUNIT) 255 return ENXIO; 256 if (softcv[unit]) 257 return EBUSY; 258 sc = malloc(sizeof(struct srt_softc), M_DEVBUF, M_WAITOK|M_ZERO); 259 sc->unit = unit; 260 sc->nrt = 0; 261 sc->rts = 0; 262 sc->flags = 0; 263 sc->kflags = 0; 264 if_initname(&sc->intf,cl->ifc_name,unit); 265 sc->intf.if_softc = sc; 266 sc->intf.if_mtu = 65535; 267 sc->intf.if_flags = IFF_POINTOPOINT; 268 sc->intf.if_type = IFT_OTHER; 269 sc->intf.if_ioctl = &srt_if_ioctl; 270 sc->intf.if_output = &srt_if_output; 271 sc->intf.if_dlt = DLT_RAW; 272 if_attach(&sc->intf); 273 if_alloc_sadl(&sc->intf); 274 #ifdef BPFILTER_NOW_AVAILABLE 275 bpf_attach(&sc->intf, 0, 0); 276 #endif 277 softcv[unit] = sc; 278 atomic_inc_uint(&srt_count); 279 return 0; 280 } 281 282 static int 283 srt_clone_destroy(struct ifnet *ifp) 284 { 285 struct srt_softc *sc; 286 287 sc = ifp->if_softc; 288 if ((ifp->if_flags & IFF_UP) || (sc->kflags & SKF_CDEVOPEN)) 289 return EBUSY; 290 #ifdef BPFILTER_NOW_AVAILABLE 291 bpf_detach(ifp); 292 #endif 293 if_detach(ifp); 294 if (sc->unit < 0 || sc->unit > SRT_MAXUNIT) { 295 panic("srt_clone_destroy: impossible unit %d\n",sc->unit); 296 } 297 if (softcv[sc->unit] != sc) { 298 panic("srt_clone_destroy: bad backpointer ([%d]=%p not %p)\n", 299 sc->unit,(void *)softcv[sc->unit],(void *)sc); 300 } 301 softcv[sc->unit] = 0; 302 free(sc,M_DEVBUF); 303 atomic_inc_uint(&srt_count); 304 return 0; 305 } 306 307 struct if_clone srt_clone = 308 IF_CLONE_INITIALIZER("srt",&srt_clone_create,&srt_clone_destroy); 309 310 void 311 srtattach(int n) 312 { 313 314 /* 315 * Nothing to do here, initialization is handled by the 316 * module initialization code in srtinit() below). 317 */ 318 } 319 320 static void 321 srtinit(void) 322 { 323 int i; 324 325 for (i = SRT_MAXUNIT; i >= 0; i--) 326 softcv[i] = 0; 327 global_flags = 0; 328 if_clone_attach(&srt_clone); 329 } 330 331 static int 332 srtdetach(void) 333 { 334 int error = 0; 335 int i; 336 337 for (i = SRT_MAXUNIT; i >= 0; i--) 338 if(softcv[i]) { 339 error = EBUSY; 340 break; 341 } 342 343 if (error == 0) 344 if_clone_detach(&srt_clone); 345 346 return error; 347 } 348 349 /* Special-device interface. */ 350 351 static int 352 srt_open(dev_t dev, int flag, int mode, struct lwp *l) 353 { 354 int unit; 355 struct srt_softc *sc; 356 357 unit = minor(dev); 358 if (unit < 0 || unit > SRT_MAXUNIT) 359 return ENXIO; 360 sc = softcv[unit]; 361 if (! sc) 362 return ENXIO; 363 sc->kflags |= SKF_CDEVOPEN; 364 return 0; 365 } 366 367 static int 368 srt_close(dev_t dev, int flag, int mode, struct lwp *l) 369 { 370 int unit; 371 struct srt_softc *sc; 372 373 unit = minor(dev); 374 if (unit < 0 || unit > SRT_MAXUNIT) 375 return ENXIO; 376 sc = softcv[unit]; 377 if (! sc) 378 return ENXIO; 379 sc->kflags &= ~SKF_CDEVOPEN; 380 return 0; 381 } 382 383 static int 384 srt_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 385 { 386 unsigned int f, i, n, o; 387 struct srt_softc *sc; 388 struct srt_rt *dr; 389 struct srt_rt *scr; 390 struct ifnet *ifp; 391 char nbuf[IFNAMSIZ]; 392 393 sc = softcv[minor(dev)]; 394 if (! sc) 395 panic("srt_ioctl: softc disappeared"); 396 switch (cmd) { 397 case SRT_GETNRT: 398 if (! (flag & FREAD)) 399 return EBADF; 400 *(unsigned int *)data = sc->nrt; 401 return 0; 402 case SRT_GETRT: 403 if (! (flag & FREAD)) 404 return EBADF; 405 dr = (struct srt_rt *) data; 406 if (dr->inx >= sc->nrt) 407 return EDOM; 408 scr = sc->rts[dr->inx]; 409 dr->af = scr->af; 410 dr->srcmatch = scr->srcmatch; 411 dr->srcmask = scr->srcmask; 412 strlcpy(&dr->u.dstifn[0],&scr->u.dstifp->if_xname[0],IFNAMSIZ); 413 memcpy(&dr->dst,&scr->dst,scr->dst.sa.sa_len); 414 return 0; 415 case SRT_SETRT: 416 if (! (flag & FWRITE)) 417 return EBADF; 418 dr = (struct srt_rt *) data; 419 if (dr->inx > sc->nrt) 420 return EDOM; 421 strlcpy(&nbuf[0],&dr->u.dstifn[0],IFNAMSIZ); 422 nbuf[IFNAMSIZ-1] = '\0'; 423 if (dr->dst.sa.sa_family != dr->af) 424 return EIO; 425 switch (dr->af) { 426 #ifdef INET 427 case AF_INET: 428 if (dr->dst.sa.sa_len != sizeof(dr->dst.sin)) 429 return EIO; 430 if (dr->srcmask > 32) 431 return EIO; 432 break; 433 #endif 434 #ifdef INET6 435 case AF_INET6: 436 if (dr->dst.sa.sa_len != sizeof(dr->dst.sin6)) 437 return EIO; 438 if (dr->srcmask > 128) 439 return EIO; 440 break; 441 #endif 442 default: 443 return EAFNOSUPPORT; 444 } 445 ifp = ifunit(&nbuf[0]); 446 if (ifp == 0) 447 return ENXIO; /* needs translation */ 448 if (dr->inx == sc->nrt) { 449 struct srt_rt **tmp; 450 tmp = malloc((sc->nrt+1)*sizeof(*tmp), M_DEVBUF, 451 M_WAITOK); 452 if (tmp == 0) 453 return ENOBUFS; 454 tmp[sc->nrt] = 0; 455 if (sc->nrt > 0) { 456 memcpy(tmp, sc->rts, sc->nrt*sizeof(*tmp)); 457 free(sc->rts, M_DEVBUF); 458 } 459 sc->rts = tmp; 460 sc->nrt ++; 461 } 462 scr = sc->rts[dr->inx]; 463 if (scr == 0) { 464 scr = malloc(sizeof(struct srt_rt),M_DEVBUF,M_WAITOK); 465 if (scr == 0) 466 return ENOBUFS; 467 scr->inx = dr->inx; 468 scr->af = AF_UNSPEC; 469 sc->rts[dr->inx] = scr; 470 } 471 scr->af = dr->af; 472 scr->srcmatch = dr->srcmatch; 473 scr->srcmask = dr->srcmask; 474 scr->u.dstifp = ifp; 475 memcpy(&scr->dst,&dr->dst,dr->dst.sa.sa_len); 476 if (dr->af == AF_INET6) 477 in6_setzoneid(&scr->dst.sin6.sin6_addr, ifp->if_index); 478 update_mtu(sc); 479 return 0; 480 case SRT_DELRT: 481 if (! (flag & FWRITE)) 482 return EBADF; 483 i = *(unsigned int *)data; 484 if (i >= sc->nrt) 485 return EDOM; 486 scr = sc->rts[i]; 487 sc->rts[i] = 0; 488 free(scr, M_DEVBUF); 489 sc->nrt--; 490 if (i < sc->nrt) { 491 memcpy(sc->rts+i, sc->rts+i+1, 492 (sc->nrt-i)*sizeof(*sc->rts)); 493 } 494 if (sc->nrt == 0) { 495 free(sc->rts, M_DEVBUF); 496 sc->rts = 0; 497 sc->intf.if_flags &= ~IFF_UP; 498 } 499 update_mtu(sc); 500 return 0; 501 case SRT_SFLAGS: 502 if (! (flag & FWRITE)) 503 return EBADF; 504 f = *(unsigned int *)data & SSF_UCHG; 505 global_flags = (global_flags & ~SSF_UCHG) | (f & SSF_GLOBAL); 506 sc->flags = (sc->flags & ~SSF_UCHG) | (f & ~SSF_GLOBAL); 507 return 0; 508 case SRT_GFLAGS: 509 if (! (flag & FREAD)) 510 return EBADF; 511 *(unsigned int *)data = sc->flags | global_flags; 512 return 0; 513 case SRT_SGFLAGS: 514 if ((flag & (FWRITE|FREAD)) != (FWRITE|FREAD)) 515 return EBADF; 516 o = sc->flags | global_flags; 517 n = *(unsigned int *)data & SSF_UCHG; 518 global_flags = (global_flags & ~SSF_UCHG) | (n & SSF_GLOBAL); 519 sc->flags = (sc->flags & ~SSF_UCHG) | (n & ~SSF_GLOBAL); 520 *(unsigned int *)data = o; 521 return 0; 522 case SRT_DEBUG: 523 return 0; 524 break; 525 } 526 return ENOTTY; 527 } 528 529 const struct cdevsw srt_cdevsw = { 530 DEVSW_MODULE_INIT 531 .d_open = srt_open, 532 .d_close = srt_close, 533 .d_read = nullread, 534 .d_write = nullwrite, 535 .d_ioctl = srt_ioctl, 536 .d_stop = nullstop, 537 .d_tty = notty, 538 .d_poll = nullpoll, 539 .d_mmap = nommap, 540 .d_kqfilter = nullkqfilter, 541 .d_discard = nodiscard, 542 .d_flag = D_OTHER 543 }; 544 545 /* 546 * Module infrastructure 547 */ 548 #include "if_module.h" 549 550 IF_MODULE(MODULE_CLASS_DRIVER, srt, "") 551
Indexes created Fri Oct 03 02:09:57 GMT 2025