![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chrouteld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chaosld|
Return to chrouteld.c CVS log | Up to [Research Unix] / researchv8dc / sys / chaosld |
1.1 ! root 1: /* ! 2: * C H R O U T E L D ! 3: * ! 4: * Chaosnet packet routing line discipline. ! 5: * ! 6: * ! 7: * (c) Copyright 1985 Nirvonics, Inc. ! 8: * ! 9: * Written by Kurt Gollhardt ! 10: * Last update Tue Mar 12 04:21:35 1985 ! 11: * ! 12: * This software is the property of Nirvonics, Inc. ! 13: * All rights reserved. ! 14: * ! 15: */ ! 16: ! 17: #include "chroute.h" ! 18: #if NCHROUTE > 0 ! 19: #include "../h/param.h" ! 20: #include "../h/systm.h" ! 21: #include "../h/stream.h" ! 22: #include "../h/ioctl.h" ! 23: #include "../h/ttyld.h" ! 24: #include "../h/conf.h" ! 25: #include "../h/order.h" ! 26: #include "../h/ethernet.h" ! 27: #include "../chaosld/types.h" ! 28: #include "../chaosld/constants.h" ! 29: #include "../chaosld/chrouteld.h" ! 30: ! 31: ! 32: struct chif Chif[NCHROUTE]; ! 33: struct chroute Chroute[CHNSUBNET]; ! 34: ! 35: static struct chif *primary; ! 36: ! 37: int NChropen; ! 38: int NChroute = NCHROUTE; ! 39: int NChsubnet = CHNSUBNET; ! 40: ! 41: int Chrtimer; /* Routing timer running */ ! 42: ! 43: int chroute_open(), chroute_close(), chroute_put(), chroute_srv(); ! 44: static struct qinit chroute_init = { ! 45: chroute_put, chroute_srv, chroute_open, chroute_close, 512, 64 ! 46: }; ! 47: struct streamtab chrouteinfo = { &chroute_init, &chroute_init }; ! 48: ! 49: #define DEBUG ! 50: ! 51: #ifdef DEBUG ! 52: int Chrdebug = 0; ! 53: # define debug(x) if (Chrdebug) x ! 54: #else ! 55: # define debug(x) ! 56: #endif ! 57: ! 58: static struct statxcvr zstat; ! 59: ! 60: ! 61: chroute_open(q, dev) ! 62: register struct queue *q; ! 63: dev_t dev; ! 64: { ! 65: register int i; ! 66: register struct chif *ifp; ! 67: ! 68: if (q->ptr) /* If this stream is already open, don't do anything */ ! 69: return 1; ! 70: ! 71: /* Look for a free interface structure */ ! 72: ! 73: if (NChropen++ == NCHROUTE) ! 74: return 0; /* If there are none left, the open fails */ ! 75: for (i = 0, ifp = Chif; ifp->rdq != 0; ++ifp) ! 76: ; ! 77: ! 78: ifp->rdq = q; ! 79: ifp->my_addr.ch_addr = 0; ! 80: ifp->arp = -1; ! 81: ifp->if_dev = dev; ! 82: ifp->if_cost = HIGH_COST / 4; /* We expect this to be set by an ioctl, ! 83: but just in case ... */ ! 84: ifp->if_stat = zstat; ! 85: ! 86: q->flag |= QDELIM|QNOENB; ! 87: WR(q)->flag |= QDELIM|QNOENB; ! 88: q->ptr = WR(q)->ptr = (caddr_t)ifp; ! 89: ! 90: if (!Chrtimer) ! 91: ch_rtimer(); ! 92: ! 93: return 1; ! 94: } ! 95: ! 96: ! 97: chroute_close(q) ! 98: register struct queue *q; ! 99: { ! 100: register struct chif *ifp; ! 101: ! 102: --NChropen; ! 103: ifp = (struct chif *)q->ptr; ! 104: Chroute[ifp->my_addr.ch_subnet].rt_type = CHNOPATH; ! 105: arp_disable(ifp->arp); ! 106: ifp->rdq = (struct queue *)0; ! 107: ifp->my_addr.ch_addr = 0; ! 108: if (ifp == primary) ! 109: primary = (struct chif *)0; ! 110: q->ptr = 0; ! 111: } ! 112: ! 113: ! 114: chroute_put(q, bp) ! 115: register struct queue *q; ! 116: register struct block *bp; ! 117: { ! 118: debug(printf("chroute_put(%s, %d)\n", ! 119: ((q->flag & QREADR)? "RD" : "WR"), bp->type)); ! 120: ! 121: switch (bp->type) { ! 122: case M_DATA: ! 123: putq(q, bp); ! 124: break; ! 125: case M_DELIM: ! 126: putq(q, bp); ! 127: qenable(q); ! 128: break; ! 129: case M_IOCTL: ! 130: /* Process an ioctl only if it's going towards the device */ ! 131: if (!(q->flag & QREADR) && chroute_ioctl(q, bp)) ! 132: break; ! 133: default: /* Anything else, just pass on to the next guy */ ! 134: (*q->next->qinfo->putp)(q->next, bp); ! 135: } ! 136: } ! 137: ! 138: ! 139: chroute_srv(q) ! 140: register struct queue *q; ! 141: { ! 142: register struct block *bp; ! 143: register struct chif *ifp; ! 144: register struct chroute *r; ! 145: int minsize; ! 146: ! 147: /* We have a complete packet in the queue, composed of some number ! 148: of M_DATA's followed by an M_DELIM. ! 149: We know there are no other block types, because chroute_put() ! 150: won't give us anything else. */ ! 151: ! 152: debug(printf("chroute_srv(%s)\n", ((q->flag & QREADR)? "RD" : "WR"))); ! 153: ! 154: if (bp = q->first) { ! 155: if (bp->type == M_DELIM) { ! 156: printf("chroute: delimiter without data\n"); ! 157: flush_packet(q); ! 158: return; ! 159: } ! 160: minsize = sizeof(struct pkt_header); ! 161: if (q->flag & QREADR) { ! 162: /* The packet is coming from the device */ ! 163: minsize += sizeof(struct ether_in); ! 164: } ! 165: if (block_pullup(q, minsize) == 0) { ! 166: flush_packet(q); ! 167: return; ! 168: } ! 169: if (q->flag & QREADR) { ! 170: /* Packet is from device; strip off ethernet header */ ! 171: q->first->rptr += sizeof(struct ether_in); ! 172: ifp = (struct chif *)q->ptr; ! 173: ifp->ist_rcvd++; ! 174: if (ifp->my_addr.ch_addr != 0) { ! 175: r = &Chroute[ifp->my_addr.ch_subnet]; ! 176: r->rt_type = CHDIRECT; ! 177: r->rt_cost = ifp->if_cost; ! 178: r->rt_path.ifp = ifp; ! 179: } ! 180: } ! 181: chroute_dispatch(q); ! 182: ! 183: /* See if there's another packet on the queue */ ! 184: for (bp = q->first; bp != NOBLOCK; bp = bp->next) ! 185: if (bp->type == M_DELIM) { ! 186: qenable(q); /* re-enable queue for the next packet */ ! 187: break; ! 188: } ! 189: } ! 190: } ! 191: ! 192: ! 193: /* Handle an ioctl */ ! 194: ! 195: chroute_ioctl(q, bp) ! 196: register struct queue *q; ! 197: register struct block *bp; ! 198: { ! 199: register union stmsg *sp; ! 200: register struct chif *ifp; ! 201: register struct chroute *rt; ! 202: register struct chaddr_pair *chp; ! 203: ! 204: ifp = (struct chif *)q->ptr; ! 205: sp = (union stmsg *)bp->rptr; ! 206: switch (sp->iocx.com) { ! 207: case CHIOCADDR: ! 208: bp->wptr = bp->rptr; ! 209: if (ifp->my_addr.ch_addr != 0) { ! 210: Chroute[ifp->my_addr.ch_subnet].rt_type = CHNOPATH; ! 211: arp_disable(ifp->arp); ! 212: } ! 213: ifp->my_addr.ch_addr = *(int *)(sp->iocx.xxx); ! 214: if (ifp->my_addr.ch_subnet >= CHNSUBNET ! 215: || ifp->my_addr.ch_subnet == 0) { ! 216: ifp->my_addr.ch_addr = 0; ! 217: bp->type = M_IOCNAK; ! 218: break; ! 219: } ! 220: rt = &Chroute[ifp->my_addr.ch_subnet]; ! 221: rt->rt_type = CHDIRECT; ! 222: rt->rt_cost = ifp->if_cost; ! 223: rt->rt_path.ifp = ifp; ! 224: /* Should we check if this fails? */ ! 225: ifp->arp = arp_enable(ifp->if_dev, ETHERPUP_CHAOSTYPE, ! 226: sizeof(chaddr), 0, &ifp->my_addr); ! 227: bp->type = M_IOCACK; ! 228: break; ! 229: case CRIOCOST: ! 230: ifp->if_cost = *(u_short *)(sp->iocx.xxx); ! 231: bp->wptr = bp->rptr; ! 232: bp->type = M_IOCACK; ! 233: break; ! 234: case CRIOPRIMARY: ! 235: primary = ifp; ! 236: bp->wptr = bp->rptr; ! 237: bp->type = M_IOCACK; ! 238: break; ! 239: default: ! 240: return 0; /* Let someone else deal with it */ ! 241: } ! 242: ! 243: qreply(q, bp); ! 244: return 1; ! 245: } ! 246: ! 247: ! 248: /* We've got a packet to send (or receive); send it to the right place */ ! 249: ! 250: chroute_dispatch(q) ! 251: register struct queue *q; ! 252: { ! 253: register struct block *bp; ! 254: register struct pkt_header *ph; ! 255: register struct chroute *rt; ! 256: register struct chif *ifp; ! 257: register int len, isdelim; ! 258: struct ether_out *ep; ! 259: chaddr dest; ! 260: ! 261: ph = (struct pkt_header *)q->first->rptr; ! 262: ifp = (struct chif *)q->ptr; ! 263: debug(printf("chroute_dispatch: op 0%o len %d\n", ph->ph_op, ph->ph_len)); ! 264: ! 265: if (q->flag & QREADR && ph->ph_op == RUTOP) { ! 266: if (block_pullup(q, ph->ph_len + sizeof(*ph)) == 0) { ! 267: ifp->ist_rej++; ! 268: flush_packet(q); ! 269: return; ! 270: } ! 271: chroute_rcvrut(q->first->rptr); ! 272: flush_packet(q); ! 273: return; ! 274: } ! 275: ! 276: if (primary && (ph->ph_daddr.ch_addr == primary->my_addr.ch_addr ! 277: || (q->flag & QREADR && ph->ph_daddr.ch_addr == 0))) { ! 278: ph->ph_daddr = primary->my_addr; ! 279: if (ph->ph_len > CHMAXDATA) { ! 280: ifp->ist_len++; ! 281: flush_packet(q); ! 282: return; ! 283: } ! 284: len = sizeof(struct pkt_header) + ph->ph_len; ! 285: while (bp = getq(q)) { ! 286: if (bp->type == M_DATA) { ! 287: if (bp->wptr - bp->rptr > len) ! 288: bp->wptr = bp->rptr + len; ! 289: len -= bp->wptr - bp->rptr; ! 290: if (bp->wptr <= bp->rptr) { ! 291: freeb(bp); ! 292: continue; ! 293: } ! 294: } ! 295: debug(print_buf(bp, "rcvd:")); ! 296: isdelim = (bp->type == M_DELIM); ! 297: (*primary->rdq->next->qinfo->putp)(primary->rdq->next, bp); ! 298: if (isdelim) ! 299: break; ! 300: } ! 301: if (len != 0) ! 302: ifp->ist_len++; ! 303: return; ! 304: } ! 305: ! 306: if (q->flag & QREADR) { ! 307: if (ph->ph_daddr.ch_host == 0) { ! 308: ifp->ist_rej++; ! 309: flush_packet(q); ! 310: return; ! 311: } else if (++ph->ph_fc == 0) { ! 312: /* Overforwarded packet */ ! 313: flush_packet(q); ! 314: return; ! 315: } ! 316: } ! 317: ! 318: dest = ph->ph_daddr; ! 319: if (ph->ph_daddr.ch_host == 0) ! 320: ph->ph_daddr.ch_subnet = 0; ! 321: if (dest.ch_subnet >= CHNSUBNET ! 322: || (rt = &Chroute[dest.ch_subnet])->rt_type == CHNOPATH) { ! 323: flush_packet(q); ! 324: return; ! 325: } ! 326: ! 327: if (rt->rt_type == CHFIXED || rt->rt_type == CHBRIDGE) ! 328: dest = rt->rt_path.bridge; ! 329: ifp = Chroute[dest.ch_subnet].rt_path.ifp; ! 330: ! 331: if ((bp = allocb(sizeof(struct ether_out))) == 0) { ! 332: ifp->ist_abrt++; ! 333: flush_packet(q); ! 334: return; ! 335: } ! 336: ep = (struct ether_out *)bp->wptr; ! 337: bp->wptr += sizeof(struct ether_out); ! 338: ep->type = hfirst_short(ETHERPUP_CHAOSTYPE); ! 339: ! 340: if (dest.ch_host == 0) /* If address is 0, broadcast to everyone */ ! 341: arp_broadcast(ep->dhost); ! 342: else if (arp_getaddr(ifp->arp, &dest, ep->dhost) == -1) { ! 343: ifp->ist_abrt++; ! 344: flush_packet(q); ! 345: return; ! 346: } ! 347: ! 348: do { ! 349: debug(print_buf(bp, "xmit:")); ! 350: isdelim = (bp->type == M_DELIM); ! 351: (*(WR(ifp->rdq)->next->qinfo->putp)) (WR(ifp->rdq)->next, bp); ! 352: if (isdelim) ! 353: break; ! 354: } while (bp = getq(q)); ! 355: ! 356: ifp->ist_xmit++; ! 357: } ! 358: ! 359: ! 360: /* Handle RUT (Routing) Packets */ ! 361: chroute_rcvrut(ph) ! 362: register struct pkt_header *ph; ! 363: { ! 364: register struct rut_data *rd; ! 365: register struct chroute *rt; ! 366: register int i; ! 367: ! 368: if ((i = ph->ph_saddr.ch_subnet) >= CHNSUBNET) { ! 369: printf("CHAOS: Bad subnet (%d) in RUT packet\n", i); ! 370: return; ! 371: } ! 372: if (Chroute[i].rt_type != CHDIRECT) { ! 373: printf("CHAOS: RUT packet from unconnected subnet %d\n", i); ! 374: return; ! 375: } ! 376: ! 377: debug(printf("chroute_rcvrut(%d)\n", i)); ! 378: ! 379: rd = (struct rut_data *)((char *)ph + sizeof(struct pkt_header)); ! 380: for (i = ph->ph_len; i > 0; i -= sizeof(struct rut_data), ++rd) { ! 381: if (rd->rd_subnet >= CHNSUBNET) ! 382: continue; ! 383: rt = &Chroute[rd->rd_subnet]; ! 384: switch (rt->rt_type) { ! 385: case CHBRIDGE: ! 386: if (rd->rd_cost > rt->rt_cost) ! 387: break; ! 388: case CHNOPATH: ! 389: rt->rt_cost = rd->rd_cost; ! 390: rt->rt_type = CHBRIDGE; ! 391: rt->rt_path.bridge = ph->ph_saddr; ! 392: break; ! 393: case CHDIRECT: ! 394: case CHFIXED: ! 395: break; ! 396: default: ! 397: printf("CHAOS: Bad entry in routing table, type = %d\n", ! 398: rt->rt_type); ! 399: } ! 400: } ! 401: } ! 402: ! 403: ! 404: #ifdef DEBUG ! 405: ! 406: print_buf(bp, s) ! 407: register struct block *bp; ! 408: register char *s; ! 409: { ! 410: register u_char *p; ! 411: register int i; ! 412: ! 413: printf("%s msg type %d len %d", s, bp->type, bp->wptr - bp->rptr); ! 414: for (i = 0, p = bp->rptr; p < bp->wptr; ++i, ++p) { ! 415: if ((i & 31) == 0) ! 416: printf("\n%s", s); ! 417: printf(" %x", *p); ! 418: } ! 419: printf("\n"); ! 420: } ! 421: ! 422: #endif DEBUG
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.