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