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