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