![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddp.save CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to ddp.save CVS log | Up to [Apple XNU] / XNU / bsd / netat |
1.1 ! root 1: /* From ddp.c: ! 2: ! 3: ddp_shrink_hdr() ! 4: ddp_extend_hdr() ! 5: ! 6: Saved from xnu/bsd/bsd/netat/ddp.c on 4/14/99. ! 7: */ ! 8: ! 9: #ifdef NOT_USED ! 10: /* This routine shrinks the ddp header from long to short, ! 11: * It also prepends ALAP header and fills up some of the ! 12: * fields as appropriate. ! 13: */ ! 14: static at_ddp_short_t *ddp_shrink_hdr (mp) ! 15: register gbuf_t *mp; ! 16: { ! 17: register at_ddp_t *ddp; ! 18: register at_ddp_short_t *ddp_short; ! 19: register at_llap_hdr_t *llap; ! 20: gbuf_t *newmp; ! 21: ! 22: if ((newmp = (gbuf_t *)gbuf_copym((gbuf_t *) mp)) == (gbuf_t *)NULL) ! 23: return ((at_ddp_short_t *)NULL); ! 24: gbuf_freem(mp); ! 25: mp = newmp; ! 26: ! 27: ddp = (at_ddp_t *)gbuf_rptr(mp); ! 28: gbuf_rinc(mp,((DDP_X_HDR_SIZE - DDP_HDR_SIZE) - LLAP_HDR_SIZE)); ! 29: llap = (at_llap_hdr_t *)gbuf_rptr(mp); ! 30: ddp_short = (at_ddp_short_t *)(gbuf_rptr(mp) + LLAP_HDR_SIZE); ! 31: ! 32: llap->destination = ddp->dst_node; ! 33: llap->type = LLAP_TYPE_DDP; ! 34: ddp_short->length = ddp->length - (DDP_X_HDR_SIZE - DDP_HDR_SIZE); ! 35: ddp_short->unused = 0; ! 36: return ((at_ddp_short_t *)mp); ! 37: } ! 38: ! 39: ! 40: /* mp points to message of the form {llap, short ddp, ...}. ! 41: * Get rid of llap, extend ddp header to make it of the form ! 42: * {extended ddp, ... } ! 43: */ ! 44: static gbuf_t *ddp_extend_hdr(mp) ! 45: register gbuf_t *mp; ! 46: { ! 47: register at_llap_hdr_t *llap; ! 48: register at_ddp_short_t *ddp_short; ! 49: register at_ddp_t *ddp; ! 50: char buf[DDP_HDR_SIZE + LLAP_HDR_SIZE]; ! 51: gbuf_t *m1, *m2; ! 52: ! 53: /* We need to remove the llap header from the packet and extend the ! 54: * short DDP header in to a long one. 5 bytes of additional space ! 55: * is required in effect, but we can not afford to put these 5 bytes ! 56: * in a separate buffer, since the ddp buffer would end up being ! 57: * fragmented into two pieces, which is a no-no. So, we first get ! 58: * rid of the llap and ddp short headers and then add the extended ! 59: * header. ! 60: */ ! 61: ! 62: /* Assuming that the llap and ddp short headers are placed next ! 63: * to each other in the same buffer ! 64: */ ! 65: bcopy(gbuf_rptr(mp), buf, LLAP_HDR_SIZE + DDP_HDR_SIZE); ! 66: m1 = ddp_adjmsg(mp, LLAP_HDR_SIZE+DDP_HDR_SIZE) ? mp : 0; ! 67: ! 68: /* If the message did not contain any ddp data bytes, then m would ! 69: * be NULL at this point... and we can't just grow a NULL message, ! 70: * we need to ALLOC a new one. ! 71: */ ! 72: if (m1) { ! 73: if ((m2 = (gbuf_t *)ddp_growmsg(m1, -DDP_X_HDR_SIZE)) == NULL) { ! 74: dPrintf(D_M_DDP, D_L_WARNING, ! 75: ("Dropping packet - no bufs to extend hdr")); ! 76: at_ddp_stats.rcv_dropped_nobuf++; ! 77: gbuf_freem(m1); ! 78: return(NULL); ! 79: } ! 80: } else ! 81: /* Original message mp has already been freed by ddp_adjmsg if we ! 82: * managed to arrive here... this case occurs only when the ! 83: * message mp did not contain any ddp data bytes, only lap and ! 84: * ddp headers ! 85: */ ! 86: if ((m2 = gbuf_alloc(AT_WR_OFFSET+DDP_X_HDR_SIZE, PRI_MED)) == NULL) { ! 87: dPrintf(D_M_DDP,D_L_WARNING, ! 88: ("Packet (no data) dropped - no bufs to extend hdr")); ! 89: at_ddp_stats.rcv_dropped_nobuf++; ! 90: return(NULL); ! 91: } else { ! 92: gbuf_rinc(m2,AT_WR_OFFSET); ! 93: gbuf_wset(m2,DDP_X_HDR_SIZE); ! 94: } ! 95: ! 96: /* By the time we arrive here, m2 points to message of the form ! 97: * {Extended DDP, ... } ! 98: * mp and m1 are either non-existent or irrelevant. ! 99: */ ! 100: ddp = (at_ddp_t *)gbuf_rptr(m2); ! 101: llap = (at_llap_hdr_t *)buf; ! 102: ddp_short = (at_ddp_short_t *)(buf + LLAP_HDR_SIZE); ! 103: ! 104: ddp->unused = ddp->hopcount = 0; ! 105: ddp->length = ddp_short->length + DDP_X_HDR_SIZE - DDP_HDR_SIZE; ! 106: UAS_ASSIGN(ddp->checksum, 0); ! 107: NET_NET(ddp->dst_net, ifID_home->ifThisNode.atalk_net); ! 108: NET_NET(ddp->src_net, ifID_home->ifThisNode.atalk_net); ! 109: ddp->src_node = llap->source; ! 110: ddp->dst_node = llap->destination; ! 111: ddp->dst_socket = ddp_short->dst_socket; ! 112: ddp->src_socket = ddp_short->src_socket; ! 113: ddp->type = ddp_short->type; ! 114: return (m2); ! 115: } ! 116: #endif ! 117: ! 118: From sys_dep.c: ! 119: ! 120: #ifdef _AIX /* This AIX code (to the end of this file) is no longer supported. */ ! 121: ! 122: int ATsocket(proto) /* AIX version */ ! 123: int proto; ! 124: { ! 125: int err, rc = -1; ! 126: ! 127: if (sys_ATsocket) ! 128: rc = (*sys_ATsocket)(proto, &err, 0); ! 129: else ! 130: err = ENXIO; ! 131: if (err) ! 132: setuerror(err); ! 133: return rc; ! 134: } ! 135: ! 136: int ATgetmsg(fd, ctlptr, datptr, flags) /* AIX version */ ! 137: int fd; ! 138: void *ctlptr; ! 139: void *datptr; ! 140: int *flags; ! 141: { ! 142: int err, rc = -1; ! 143: ! 144: if (sys_ATgetmsg) ! 145: rc = (*sys_ATgetmsg)(fd, ctlptr, datptr, flags, &err, 0); ! 146: else ! 147: err = ENXIO; ! 148: if (err) ! 149: setuerror(err); ! 150: return rc; ! 151: } ! 152: ! 153: int ATputmsg(fd, ctlptr, datptr, flags) /* AIX version */ ! 154: int fd; ! 155: void *ctlptr; ! 156: void *datptr; ! 157: int flags; ! 158: { ! 159: int err, rc = -1; ! 160: ! 161: if (sys_ATputmsg) ! 162: rc = (*sys_ATputmsg)(fd, ctlptr, datptr, flags, &err, 0); ! 163: else ! 164: err = ENXIO; ! 165: if (err) ! 166: setuerror(err); ! 167: return rc; ! 168: } ! 169: ! 170: int ATPsndreq(fd, buf, len, nowait) /* AIX version */ ! 171: int fd; ! 172: unsigned char *buf; ! 173: int len; ! 174: int nowait; ! 175: { ! 176: int err, rc = -1; ! 177: ! 178: if (sys_ATPsndreq) ! 179: rc = (*sys_ATPsndreq)(fd, buf, len, nowait, &err, 0); ! 180: else ! 181: err = ENXIO; ! 182: if (err) ! 183: setuerror(err); ! 184: return rc; ! 185: } ! 186: ! 187: int ATPsndrsp(fd, respbuff, resplen, datalen) /* AIX version */ ! 188: int fd; ! 189: unsigned char *respbuff; ! 190: int resplen; ! 191: int datalen; ! 192: { ! 193: int err, rc = -1; ! 194: ! 195: if (sys_ATPsndrsp) ! 196: rc = (*sys_ATPsndrsp)(fd, respbuff, resplen, datalen, &err, 0); ! 197: else ! 198: err = ENXIO; ! 199: if (err) ! 200: setuerror(err); ! 201: return rc; ! 202: } ! 203: ! 204: int ATPgetreq(fd, buf, buflen) /* AIX version */ ! 205: int fd; ! 206: unsigned char *buf; ! 207: int buflen; ! 208: { ! 209: int err, rc = -1; ! 210: ! 211: if (sys_ATPgetreq) ! 212: rc = (*sys_ATPgetreq)(fd, buf, buflen, &err, 0); ! 213: else ! 214: err = ENXIO; ! 215: if (err) ! 216: setuerror(err); ! 217: return rc; ! 218: } ! 219: ! 220: int ATPgetrsp(fd, bdsp) /* AIX version */ ! 221: int fd; ! 222: unsigned char *bdsp; ! 223: { ! 224: int err, rc = -1; ! 225: ! 226: if (sys_ATPgetrsp) ! 227: rc = (*sys_ATPgetrsp)(fd, bdsp, &err, 0); ! 228: else ! 229: err = ENXIO; ! 230: if (err) ! 231: setuerror(err); ! 232: return rc; ! 233: } ! 234: ! 235: void *atalk_kalloc(size) /* AIX version */ ! 236: int size; ! 237: { ! 238: return (void *)xmalloc(size, 2, pinned_heap); ! 239: } ! 240: ! 241: void atalk_kfree(buf) /* AIX version */ ! 242: void *buf; ! 243: { ! 244: xmfree(buf, pinned_heap); ! 245: } ! 246: ! 247: int atalk_closeref(fp, grefp) /* AIX version */ ! 248: struct file *fp; ! 249: gref_t **grefp; ! 250: { ! 251: *grefp = (gref_t *)fp->f_data; ! 252: fp->f_data = 0; ! 253: return 0; ! 254: } ! 255: ! 256: int atalk_openref(gref, retfd, proc) /* AIX version */ ! 257: gref_t *gref; ! 258: int *retfd; ! 259: void *proc; ! 260: { ! 261: extern int _ATrw(), _ATioctl(), _ATselect(), _ATclose(), _ATstat(); ! 262: static struct fileops fileops = {_ATrw, _ATioctl, _ATselect, _ATclose, _ATstat}; ! 263: int err, fd; ! 264: struct file *fp; ! 265: void *crp; ! 266: ! 267: crp = (void *)crref(); ! 268: #ifdef _AIX ! 269: if ((err = ufdcreate(FREAD|FWRITE, ! 270: &fileops, 0, DTYPE_OTHER, &fd, crp)) != 0) ! 271: #else ! 272: if ((err = ufdcreate(FREAD|FWRITE, ! 273: &fileops, 0, DTYPE_ATALK, &fd, crp)) != 0) ! 274: #endif ! 275: return err; ! 276: *retfd = fd; ! 277: fp = U.U_ufd[fd].fp; ! 278: fp->f_data = (void *)gref; ! 279: gref->next = (void *)fp; ! 280: return 0; ! 281: } ! 282: ! 283: int atalk_getref(fp, fd, grefp, proc) /* AIX version */ ! 284: struct file *fp; ! 285: int fd; ! 286: gref_t **grefp; ! 287: struct proc *proc; ! 288: { ! 289: if (fp == 0) { ! 290: if ((fd < 0) || (fd > U.U_maxofile) || ((fp = U.U_ufd[fd].fp) == 0)) { ! 291: *grefp = (gref_t *)0; ! 292: return EBADF; ! 293: } ! 294: } ! 295: if ((*grefp = (gref_t *)fp->f_data) == 0) ! 296: return EBADF; ! 297: return 0; ! 298: } ! 299: ! 300: gbuf_t *gbuf_alloc(size, pri) /* AIX version */ ! 301: int size; ! 302: int pri; ! 303: { ! 304: gbuf_t *m; ! 305: ! 306: m = (size > MHLEN) ? (gbuf_t *)m_getclustm(M_DONTWAIT, MSG_DATA, size) ! 307: : (gbuf_t *)m_gethdr(M_DONTWAIT, MSG_DATA); ! 308: #ifdef APPLETALK_DEBUG ! 309: kprintf("gbuf_alloc: for size = %d m=%x\n", size, m); ! 310: #endif ! 311: gbuf_next(m) = 0; ! 312: gbuf_cont(m) = 0; ! 313: gbuf_wset(m,0); ! 314: return m; ! 315: } ! 316: ! 317: void gbuf_freeb(m) /* AIX version */ ! 318: gbuf_t *m; ! 319: { ! 320: if (m) ! 321: m_free(m); ! 322: } ! 323: ! 324: static struct trb *trb_freehead = 0; ! 325: static struct trb *trb_freetail = 0; ! 326: static struct trb *trb_pendhead = 0; ! 327: static int trb_cnt = 0; ! 328: static atlock_t trb_lock; ! 329: ! 330: static void atalk_rem_timeoutcf() /* AIX version */ ! 331: { ! 332: register int s; ! 333: register struct trb *trb; ! 334: register struct trb *tmp_freehead, *tmp_pendhead; ! 335: ! 336: ATDISABLE(s, trb_lock); ! 337: tmp_freehead = trb_freehead; ! 338: trb_freehead = 0; ! 339: tmp_pendhead = trb_pendhead; ! 340: trb_pendhead = 0; ! 341: trb_cnt = 0; ! 342: ATENABLE(s, trb_lock); ! 343: while ((trb = tmp_pendhead) != 0) { ! 344: tmp_pendhead = trb->to_next; ! 345: while (tstop(trb)); ! 346: tfree(trb); ! 347: } ! 348: while ((trb = tmp_freehead) != 0) { ! 349: tmp_freehead = trb->to_next; ! 350: tfree(trb); ! 351: } ! 352: dPrintf(D_M_ATP,D_L_ERROR, "atalk: timer stopped!\n",0,0,0,0,0); ! 353: } ! 354: ! 355: static void atalk_timeoutcf(cnt) /* AIX version */ ! 356: int cnt; ! 357: { ! 358: register int i; ! 359: register struct trb *trb; ! 360: ! 361: if (trb_freehead == 0) { ! 362: for (i=0; i < cnt-1; i++) { ! 363: trb = (struct trb *)talloc(); ! 364: trb->to_next = trb_freehead; ! 365: trb_freehead = trb; ! 366: if (!i) trb_freetail = trb; ! 367: trb_cnt++; ! 368: } ! 369: } ! 370: ATLOCKINIT(trb_lock); ! 371: } ! 372: ! 373: static void atalk_clock(trb) /* AIX version */ ! 374: register struct trb *trb; ! 375: { ! 376: register int s; ! 377: register struct trb *next; ! 378: void (*tof)(); ! 379: void *arg; ! 380: ! 381: ATDISABLE(s, trb_lock); ! 382: if (trb_pendhead && trb->func) { ! 383: /* ! 384: * remove the timeout from the pending queue ! 385: */ ! 386: if (trb_pendhead == trb) ! 387: trb_pendhead = trb->to_next; ! 388: else { ! 389: for (next=trb_pendhead; next->to_next; next=next->to_next) { ! 390: if (next->to_next == trb) { ! 391: next->to_next = trb->to_next; ! 392: trb->func = 0; ! 393: break; ! 394: } ! 395: } ! 396: if (trb->func) { ! 397: dPrintf(D_M_ATP,D_L_WARNING, ! 398: "atalk_clock: %d,%x,%x\n", trb_cnt,trb,trb_pendhead,0,0); ! 399: /* ! 400: * we have not found the trb in the pending list - something ! 401: * has gone wrong here. maybe the trb has been returned to ! 402: * the free list; in which case, we should simply ignore ! 403: * this timeout event! ! 404: */ ! 405: for (next=trb_freehead; next; next=next->to_next) { ! 406: if (next == trb) ! 407: { ! 408: ATENABLE(s, trb_lock); ! 409: return; ! 410: } ! 411: } ! 412: /* ! 413: * the trb is not in the free list either - something has ! 414: * really gone wacky here! all we can do now is put the ! 415: * trb back into the free list and hope that it will be ok. ! 416: */ ! 417: trb->to_next = 0; ! 418: if (trb_freehead) ! 419: trb_freetail->to_next = trb; ! 420: else ! 421: trb_freehead = trb; ! 422: trb_freetail = trb; ! 423: trb_cnt++; ! 424: ATENABLE(s, trb_lock); ! 425: return; ! 426: } ! 427: } ! 428: ! 429: /* ! 430: * process the timeout ! 431: */ ! 432: trb->func = 0; ! 433: trb->to_next = 0; ! 434: tof = trb->tof; ! 435: trb->tof = 0; ! 436: arg = (void *)trb->func_data; ! 437: trb->func_data = 999; ! 438: if (trb_freehead) ! 439: trb_freetail->to_next = trb; ! 440: else ! 441: trb_freehead = trb; ! 442: trb_freetail = trb; ! 443: trb_cnt++; ! 444: ATENABLE(s, trb_lock); ! 445: if (tof) { ! 446: dPrintf(D_M_ATP,D_L_VERBOSE, "atalk_clock: func=%x, arg=%x, %d\n", ! 447: tof,arg,trb_cnt,0,0); ! 448: (*tof)(arg); ! 449: } else { ! 450: dPrintf(D_M_ATP,D_L_ERROR, "atalk_clock: func=%x, arg=%x, %d\n", ! 451: tof,arg,trb_cnt,0,0); ! 452: } ! 453: } else ! 454: ATENABLE(s, trb_lock); ! 455: } ! 456: ! 457: void *atalk_timeout(func, arg, ticks) /* AIX version */ ! 458: void (*func)(); ! 459: void *arg; ! 460: int ticks; ! 461: { ! 462: register int s; ! 463: register struct trb *trb; ! 464: ! 465: dPrintf(D_M_ATP,D_L_VERBOSE, ! 466: "atalk_timeout: func=%x,arg=%x,time=%d, %d,%x\n", func,arg,ticks,trb_cnt,trb_pendhead); ! 467: /* ! 468: * set up the timeout request ! 469: */ ! 470: ATDISABLE(s, trb_lock); ! 471: if ((trb = trb_freehead) == 0) { ! 472: ATENABLE(s, trb_lock); ! 473: dPrintf(D_M_ATP,D_L_WARNING, ! 474: "atalk_timeout: NO TRB! time=%d, %d\n", ticks,trb_cnt,0,0,0); ! 475: return 0; ! 476: } ! 477: trb_freehead = trb->to_next; ! 478: trb->to_next = trb_pendhead; ! 479: trb_pendhead = trb; ! 480: trb_cnt--; ! 481: trb->timeout.it_value.tv_sec = ticks / HZ; ! 482: trb->timeout.it_value.tv_nsec = (ticks % HZ) * (NS_PER_SEC / HZ); ! 483: trb->knext = 0; ! 484: trb->kprev = 0; ! 485: trb->flags = 0; ! 486: trb->tof = func; ! 487: trb->func = (void (*)())atalk_clock; ! 488: trb->func_data = (ulong)arg; ! 489: trb->ipri = PL_IMP; ! 490: trb->id = -1; ! 491: ! 492: /* ! 493: * start the timeout ! 494: */ ! 495: ATENABLE(s, trb_lock); ! 496: tstart(trb); ! 497: return (void *)trb; ! 498: } ! 499: ! 500: void atalk_untimeout(func, arg, trb) /* AIX version */ ! 501: void (*func)(); ! 502: void *arg; ! 503: register struct trb *trb; ! 504: { ! 505: register int s; ! 506: register struct trb *next; ! 507: ! 508: dPrintf(D_M_ATP,D_L_VERBOSE, ! 509: "atalk_untimeout: func=%x,arg=%x, %d\n", func,arg,trb_cnt,0,0); ! 510: ! 511: ATDISABLE(s, trb_lock); ! 512: if (trb == 0) { ! 513: for (trb=trb_pendhead; trb; trb=trb->to_next) { ! 514: if ((func == trb->tof) && (arg == (void *)trb->func_data)) ! 515: break; ! 516: } ! 517: } ! 518: if (trb && (trb->func == (void (*)())atalk_clock) ! 519: && (func == trb->tof) && (arg == (void *)trb->func_data)) { ! 520: trb->func_data = 999; ! 521: if (!(trb->flags & T_PENDING)) ! 522: { ! 523: trb->tof = 0; ! 524: ATENABLE(s, trb_lock); ! 525: return; ! 526: } ! 527: trb->func = 0; ! 528: while (tstop(trb)); ! 529: if (trb_pendhead == trb) ! 530: trb_pendhead = trb->to_next; ! 531: else { ! 532: for (next=trb_pendhead; next->to_next != trb; next=next->to_next) { ! 533: if (next->to_next == 0) { ! 534: ATENABLE(s, trb_lock); ! 535: dPrintf(D_M_ATP,D_L_WARNING, ! 536: "atalk_untimeout: UNKNOWN TRB %x...\n",trb,0,0,0,0); ! 537: return; ! 538: } ! 539: } ! 540: next->to_next = trb->to_next; ! 541: } ! 542: trb->to_next = 0; ! 543: trb_freetail->to_next = trb; ! 544: trb_freetail = trb; ! 545: trb_cnt++; ! 546: } ! 547: ATENABLE(s, trb_lock); ! 548: } ! 549: ! 550: int config_atalk(dev, cmd, uiop) /* AIX only */ ! 551: dev_t dev; ! 552: int cmd; ! 553: void *uiop; ! 554: { ! 555: static int loaded = 0; ! 556: int err, nest; ! 557: ! 558: err = 0; ! 559: nest = lockl(&kernel_lock, LOCK_SHORT); ! 560: ! 561: if (cmd == CFG_INIT) { ! 562: if (loaded) ! 563: goto out; ! 564: vm_protect(0, 4096, 3); ! 565: atalk_timeoutcf(256); ! 566: atalk_load(); ! 567: loaded = 1; ! 568: ! 569: } else if (cmd == CFG_TERM) { ! 570: if (!loaded) ! 571: goto out; ! 572: atalk_rem_timeoutcf(); ! 573: atalk_unload(); ! 574: loaded = 0; ! 575: ! 576: } else ! 577: err = EINVAL; ! 578: ! 579: out: ! 580: if (nest != LOCK_NEST) ! 581: unlockl(&kernel_lock); ! 582: return(err); ! 583: } ! 584: ! 585: #endif ! 586: ! 587: From sys_glue.c: ! 588: ! 589: #ifdef _AIX /* AIX code, to the end of this file, is no longer supported. */ ! 590: ! 591: int _ATselect(fp, corl, reqevents, retevents, notify) /* AIX version */ ! 592: void *fp; ! 593: int corl; ! 594: unsigned short reqevents; ! 595: unsigned short *retevents; ! 596: void (*notify)(); ! 597: { ! 598: int s, err, rc = 0; ! 599: gref_t *gref; ! 600: unsigned short sevents = 0; ! 601: ! 602: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0) ! 603: return err; ! 604: ! 605: ATDISABLE(s, gref->lock); ! 606: if (reqevents & POLLIN) { ! 607: if (gref->rdhead || (gref->readable && (*gref->readable)(gref))) ! 608: sevents |= POLLIN; ! 609: } ! 610: ! 611: if (reqevents & POLLOUT) { ! 612: if (gref->writeable) { ! 613: if ((*gref->writeable)(gref)) ! 614: sevents |= POLLOUT; ! 615: } else ! 616: sevents |= POLLOUT; ! 617: } ! 618: ! 619: if ((sevents == 0) && ((reqevents & POLLSYNC) == 0)) { ! 620: if (rc = selreg(corl, 99, gref, reqevents, notify)) { ! 621: ATENABLE(s, gref->lock); ! 622: goto l_done; ! 623: } ! 624: ! 625: if (reqevents & POLLIN) { ! 626: if (gref->rdhead || (gref->readable && (*gref->readable)(gref))) ! 627: sevents |= POLLIN; ! 628: else ! 629: gref->sevents |= POLLIN; ! 630: } ! 631: ! 632: if (reqevents & POLLOUT) { ! 633: if (gref->writeable) { ! 634: if ((*gref->writeable)(gref)) ! 635: sevents |= POLLOUT; ! 636: else ! 637: gref->sevents |= POLLOUT; ! 638: } else ! 639: sevents |= POLLOUT; ! 640: } ! 641: } ! 642: ATENABLE(s, gref->lock); ! 643: *retevents = sevents; ! 644: ! 645: l_done: ! 646: return rc; ! 647: } ! 648: #endif /* end AIX section */ ! 649: ! 650: From drv_dep.c: ! 651: ! 652: ! 653: ! 654: ! 655: #ifdef _AIX ! 656: /* AIX section to end of file (not supported) */ ! 657: ! 658: /* from beginning of file ... */ ! 659: #include <sys/cdli.h> ! 660: #include <sys/ndd.h> ! 661: static struct ns_8022 elap_link; /* The SNAP header description */ ! 662: static struct ns_user elap_user; /* The interface to the demuxer */ ! 663: ! 664: int ! 665: pat_ifpresent(name) /* AIX */ ! 666: char *name; ! 667: { ! 668: return (int)ifunit(name); ! 669: } ! 670: ! 671: int ! 672: pat_output(pat_id, mlist, dst_addr, type) /* AIX */ ! 673: int pat_id; ! 674: gbuf_t *mlist; ! 675: unsigned char *dst_addr; ! 676: int type; ! 677: { ! 678: int len; ! 679: pat_unit_t *patp; ! 680: gbuf_t *m, *m_prev, *new_mlist, *m_temp; ! 681: struct ndd *nddp; ! 682: short size; ! 683: enet_header_t *enet_header; ! 684: llc_header_t *llc_header; ! 685: ! 686: patp = (pat_unit_t *)&pat_units[pat_id]; ! 687: if (patp->state != PAT_ONLINE) { ! 688: gbuf_freel(mlist); ! 689: return ENOTREADY; ! 690: } ! 691: ! 692: if (patp->xtype == IFTYPE_NULLTALK) { ! 693: gbuf_freel(mlist); ! 694: return 0; ! 695: } ! 696: ! 697: nddp = (void *)patp->nddp; ! 698: new_mlist = 0; ! 699: ! 700: for (m = mlist; m; m = mlist) { ! 701: mlist = gbuf_next(m); ! 702: gbuf_next(m) = 0; ! 703: ! 704: gbuf_prepend(m,ENET_LLC_SIZE); ! 705: if (m == 0) { ! 706: if (mlist) ! 707: gbuf_freel(mlist); ! 708: if (new_mlist) ! 709: gbuf_freel(new_mlist); ! 710: return 0; ! 711: } ! 712: ! 713: enet_header = (enet_header_t *)gbuf_rptr(m); ! 714: bcopy(dst_addr, enet_header->dst, sizeof(enet_header->dst)); ! 715: bcopy(patp->xaddr, enet_header->src, sizeof(enet_header->src)); ! 716: size = gbuf_msgsize(m); ! 717: enet_header->len = size - sizeof(enet_header_t); ! 718: llc_header = (llc_header_t *)(gbuf_rptr(m)+sizeof(enet_header_t)); ! 719: *llc_header = (type == AARP_AT_TYPE) ? snap_hdr_aarp : snap_hdr_at; ! 720: ! 721: m->m_pkthdr.len = size; ! 722: m->m_pkthdr.rcvif = 0; ! 723: ! 724: if (new_mlist) ! 725: gbuf_next(m_prev) = m; ! 726: else ! 727: new_mlist = m; ! 728: m_prev = m; ! 729: pktsOut++; ! 730: } ! 731: ! 732: if (new_mlist) ! 733: (*nddp->ndd_output)(nddp, new_mlist); ! 734: ! 735: return 0; ! 736: } ! 737: ! 738: int ! 739: pat_online (ifName, ifType) /* AIX */ ! 740: char *ifName; ! 741: char *ifType; ! 742: { ! 743: void pat_input(); ! 744: int pat_id; ! 745: pat_unit_t *patp; ! 746: struct ndd *nddp; ! 747: char ns_name[8]; ! 748: ! 749: if ((pat_id = pat_ID(ifName)) == -1) ! 750: return (-1); ! 751: patp = &pat_units[pat_id]; ! 752: ! 753: if (patp->xtype == IFTYPE_ETHERTALK) { ! 754: ns_name[0] = ifName[0]; ! 755: ns_name[1] = 'n'; ! 756: strcpy(&ns_name[2], &ifName[1]); ! 757: } else if (patp->xtype == IFTYPE_NULLTALK) { ! 758: patp->xaddrlen = 6; ! 759: bzero(patp->xaddr, patp->xaddrlen); ! 760: if (ifType) ! 761: *ifType = patp->xtype; ! 762: patp->nddp = (void *)0; ! 763: patp->state = PAT_ONLINE; ! 764: at_statep->flags |= AT_ST_IF_CHANGED; ! 765: return (pat_id); ! 766: } else ! 767: return -1; ! 768: ! 769: if (ns_alloc(ns_name, &nddp)) ! 770: return -1; ! 771: ! 772: bzero(&elap_user, sizeof(elap_user)); ! 773: elap_user.isr = pat_input; ! 774: elap_user.pkt_format = NS_HANDLE_HEADERS|NS_INCLUDE_MAC; ! 775: ! 776: elap_link.filtertype = NS_8022_LLC_DSAP_SNAP; ! 777: elap_link.orgcode[0] = 0; ! 778: elap_link.orgcode[2] = 0; ! 779: elap_link.dsap = DSAP_SNAP; ! 780: elap_link.ethertype = 0x80f3; /* AARP SNAP code */ ! 781: if (ns_add_filter(nddp, &elap_link, sizeof(elap_link), &elap_user)) ! 782: return -1; ! 783: ! 784: elap_link.orgcode[0] = 0x08; ! 785: elap_link.orgcode[2] = 0x07; ! 786: elap_link.ethertype = 0x809b; /* DDP SNAP code */ ! 787: if (ns_add_filter(nddp, &elap_link, sizeof(elap_link), &elap_user)) { ! 788: elap_link.orgcode[0] = 0; ! 789: elap_link.orgcode[2] = 0; ! 790: elap_link.ethertype = 0x80f3; /* AARP SNAP code */ ! 791: (void)ns_del_filter(nddp, &elap_link, sizeof(elap_link)); ! 792: return -1; ! 793: } ! 794: ! 795: patp->xaddrlen = nddp->ndd_addrlen; ! 796: bcopy(nddp->ndd_physaddr, patp->xaddr, patp->xaddrlen); ! 797: ! 798: if (ifType) ! 799: *ifType = patp->xtype; ! 800: ! 801: patp->nddp = (void *)nddp; ! 802: patp->state = PAT_ONLINE; ! 803: at_statep->flags |= AT_ST_IF_CHANGED; ! 804: ! 805: return (pat_id); ! 806: } ! 807: ! 808: void ! 809: pat_offline(pat_id) /* AIX */ ! 810: int pat_id; ! 811: { ! 812: pat_unit_t *patp = &pat_units[pat_id]; ! 813: ! 814: if (patp->state == PAT_ONLINE) { ! 815: if (patp->xtype != IFTYPE_NULLTALK) { ! 816: elap_link.filtertype = NS_8022_LLC_DSAP_SNAP; ! 817: elap_link.orgcode[0] = 0; ! 818: elap_link.orgcode[2] = 0; ! 819: elap_link.dsap = DSAP_SNAP; ! 820: elap_link.ethertype = 0x80f3; /* AARP SNAP code */ ! 821: (void)ns_del_filter(patp->nddp, &elap_link, sizeof(elap_link)); ! 822: elap_link.orgcode[0] = 0x08; ! 823: elap_link.orgcode[2] = 0x07; ! 824: elap_link.ethertype = 0x809b; /* DDP SNAP code */ ! 825: (void)ns_del_filter(patp->nddp, &elap_link, sizeof(elap_link)); ! 826: ns_free(patp->nddp); ! 827: } ! 828: at_statep->flags |= AT_ST_IF_CHANGED; ! 829: bzero(patp, sizeof(pat_unit_t)); ! 830: } ! 831: } ! 832: ! 833: int ! 834: pat_mcast(pat_id, control, data) /* AIX */ ! 835: int pat_id; ! 836: int control; ! 837: unsigned char *data; ! 838: { ! 839: struct ndd *nddp; ! 840: ! 841: nddp = (struct ndd *)pat_units[pat_id].nddp; ! 842: return (*nddp->ndd_ctl)(nddp, (control == PAT_REG_MCAST) ? ! 843: NDD_ENABLE_ADDRESS : NDD_DISABLE_ADDRESS, ! 844: data, nddp->ndd_addrlen); ! 845: } ! 846: ! 847: void ! 848: pat_input(nddp, m, unused) /* AIX */ ! 849: struct ndd *nddp; ! 850: gbuf_t *m; ! 851: void *unused; ! 852: { ! 853: extern int ddprunning_flag; ! 854: llc_header_t *llc_header; ! 855: int pat_id; ! 856: pat_unit_t *patp; ! 857: char src[6]; ! 858: enet_header_t *enet_header = (enet_header_t *)gbuf_rptr(m); ! 859: ! 860: for (pat_id=0, patp = &pat_units[pat_id]; ! 861: pat_id < xpatcnt; pat_id++, patp++) { ! 862: if ((patp->state == PAT_ONLINE) && (patp->nddp == nddp)) ! 863: break; ! 864: } ! 865: if (pat_id == xpatcnt) { ! 866: gbuf_freem(m); ! 867: return; ! 868: } ! 869: ! 870: /* Ignore multicast packets from local station */ ! 871: if (patp->xtype == IFTYPE_ETHERTALK) { ! 872: bcopy((char *)enet_header->src, src, sizeof(src)); ! 873: if ((enet_header->dst[0] & 1) && ! 874: (bcmp(src, patp->xaddr, sizeof(src)) == 0)) { ! 875: gbuf_freem(m); ! 876: return; ! 877: } ! 878: llc_header = (llc_header_t *)(enet_header+1); ! 879: } ! 880: ! 881: gbuf_rinc(m,(ENET_LLC_SIZE)); ! 882: (void)fetch_and_add((atomic_p)&ddprunning_flag, 1); ! 883: pktsIn++; ! 884: if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_aarp)) { ! 885: patp->aarp_func(gbuf_rptr(m), patp->context); ! 886: gbuf_freem(m); ! 887: } else if (LLC_PROTO_EQUAL(llc_header->protocol,snap_proto_ddp)) { ! 888: /* if we're a router take all pkts */ ! 889: if (!ROUTING_MODE) { ! 890: if (patp->addr_check(gbuf_rptr(m), patp->context) ! 891: == AARP_ERR_NOT_OURS) { ! 892: gbuf_freem(m); ! 893: (void)fetch_and_add((atomic_p)&ddprunning_flag, -1); ! 894: return; ! 895: } ! 896: } ! 897: gbuf_set_type(m, MSG_DATA); ! 898: elap_input(m, patp->context, src); ! 899: } else ! 900: gbuf_freem(m); ! 901: (void)fetch_and_add((atomic_p)&ddprunning_flag, -1); ! 902: } ! 903: #endif /* AIX */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.