![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chrcv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chncp|
Return to chrcv.c CVS log | Up to [Research Unix] / researchv8dc / sys / chncp |
1.1 ! root 1: #include "../chunix/chsys.h" ! 2: #include "../chunix/chconf.h" ! 3: #include "../chaos/chaos.h" ! 4: ! 5: /* ! 6: * Receive side - basically driven by an incoming packet. ! 7: */ ! 8: ! 9: #define send_los(x,y) sendlos(x,y,sizeof(y) - 1) ! 10: ! 11: /* ! 12: * Receive a packet - called from receiver interrupt level. ! 13: */ ! 14: rcvpkt(pkt) ! 15: register struct packet *pkt; ! 16: { ! 17: register struct connection *conn; ! 18: register unsigned index; ! 19: ! 20: debug(DPKT,printf("Rcvpkt: ")); ! 21: pkt->pk_next = NOPKT; ! 22: if (pkt->pk_op == RUTOP) ! 23: rcvrut(pkt); ! 24: else if (pkt->pk_op >= MAXOP && !ISDATOP(pkt)) ! 25: ch_free((char *)pkt); ! 26: else if (pkt->pk_daddr != Chmyaddr) ! 27: if ((++pkt->pk_fc) == 0) { ! 28: debug(DPKT|DABNOR,printf("Overforwarded packet\n")); ! 29: ignore: ! 30: ch_free((char *)pkt); ! 31: } else if (pkt->pk_saddr == Chmyaddr) { ! 32: debug(DPKT|DABNOR,printf("Got my own packet back\n")); ! 33: ch_free((char *)pkt); ! 34: } else if (Chmyaddr == -1) ! 35: ch_free((char *)pkt); ! 36: else { ! 37: debug(DPKT,printf("Forwarding pkt daddr=%x\n", pkt->pk_daddr)); ! 38: sendctl(pkt); ! 39: } ! 40: else if (pkt->pk_op == MNTOP) ! 41: goto ignore; ! 42: else if (pkt->pk_op == RFCOP) ! 43: rcvrfc(pkt); ! 44: /* ! 45: * Check for various flavors of bad indexes ! 46: */ ! 47: else if ((index = pkt->pk_dtindex) >= CHNCONNS || ! 48: ((conn = Chconntab[index]) == NOCONN) || ! 49: conn->cn_lidx != pkt->pk_didx) { ! 50: debug(DPKT|DABNOR,printf("Packet with bad index: %x, op:%d\n", ! 51: pkt->pk_didx, pkt->pk_op)); ! 52: send_los(pkt, "Connection doesn't exist"); ! 53: /* ! 54: * Handle responses to our RFC ! 55: */ ! 56: } else if (conn->cn_state == CSRFCSENT) ! 57: switch(pkt->pk_op) { ! 58: case OPNOP: ! 59: debug(DCONN,printf("Conn #%x: OPEN received\n", conn->cn_lidx)); ! 60: /* ! 61: * Make the connection open, taking his index ! 62: */ ! 63: conn->cn_state = CSOPEN; ! 64: conn->cn_fidx = pkt->pk_sidx; ! 65: conn->cn_active = Chclock; ! 66: /* ! 67: * Indicate we have received AND "read" the OPEN ! 68: * Read his window size, indicate that he has ! 69: * received and acked the RFC, and acknowledge the OPN ! 70: */ ! 71: conn->cn_rread = conn->cn_rlast = pkt->pk_pkn; ! 72: conn->cn_twsize = pkt->pk_rwsize; ! 73: receipt(conn, pkt->pk_ackn, pkt->pk_ackn); ! 74: /* ! 75: * Wakeup the user waiting for the connection to open. ! 76: */ ! 77: makests(conn, pkt); ! 78: reflect(pkt); ! 79: NEWSTATE(conn); ! 80: break; ! 81: case CLSOP: ! 82: case ANSOP: ! 83: case FWDOP: ! 84: debug(DCONN,printf("Conn #%x: CLOSE/ANS received for RFC\n", conn->cn_lidx)); ! 85: clsconn(conn, CSCLOSED, pkt); ! 86: break; ! 87: default: ! 88: debug(DPKT|DABNOR, ! 89: printf("bad packet type for conn #%x in CSRFCSENT: %d\n", ! 90: conn->cn_lidx, pkt->pk_op)); ! 91: send_los(pkt, "Bad packet type reponse to RFC"); ! 92: } ! 93: /* ! 94: * Process a packet for an open connection ! 95: */ ! 96: else if (conn->cn_state == CSOPEN) { ! 97: conn->cn_active = Chclock; ! 98: if (ISDATOP(pkt)) ! 99: rcvdata(conn, pkt); ! 100: else switch (pkt->pk_op) { ! 101: case OPNOP: ! 102: /* ! 103: * Ignore duplicate opens. ! 104: */ ! 105: debug(DPKT|DABNOR,printf("Duplicate open received\n")); ! 106: ch_free((char *)pkt); ! 107: break; ! 108: case SNSOP: ! 109: debug(DPKT,prpkt(pkt, "SNS")); ! 110: receipt(conn, pkt->pk_ackn, pkt->pk_ackn); ! 111: makests(conn, pkt); ! 112: reflect(pkt); ! 113: break; ! 114: case EOFOP: ! 115: rcvdata(conn, pkt); ! 116: break; ! 117: case LOSOP: ! 118: case CLSOP: ! 119: debug(DCONN, printf("Close rcvd on %x\n", conn->cn_lidx)); ! 120: clsconn(conn, pkt->pk_op == CLSOP ? CSCLOSED : CSLOST, ! 121: pkt); ! 122: break; ! 123: /* ! 124: * Uncontrolled data - que it at the head of the rlist ! 125: */ ! 126: case UNCOP: ! 127: if ((pkt->pk_next = conn->cn_rhead) == NOPKT) ! 128: conn->cn_rtail = pkt; ! 129: conn->cn_rhead = pkt; ! 130: if (pkt == conn->cn_rtail) ! 131: INPUT(conn); ! 132: receipt(conn, pkt->pk_ackn, pkt->pk_ackn); ! 133: break; ! 134: case STSOP: ! 135: debug(DABNOR,prpkt(pkt, "STS")); ! 136: debug(DABNOR,printf("Receipt=%d, Trans Window=%d\n",(unsigned)pkt->pk_idata[0], pkt->pk_idata[1])); ! 137: if (pkt->pk_rwsize > conn->cn_twsize) ! 138: OUTPUT(conn); ! 139: conn->cn_twsize = pkt->pk_rwsize; ! 140: receipt(conn, pkt->pk_ackn, pkt->pk_receipt); ! 141: ch_free((char *)pkt); ! 142: /* could check for very recent packets here */ ! 143: if ((pkt = conn->cn_thead) != NOPKT) { ! 144: conn->cn_thead = conn->cn_ttail = NOPKT; ! 145: senddata(pkt); ! 146: } ! 147: break; ! 148: default: ! 149: debug(DPKT|DABNOR, printf("bad opcode:%d\n", pkt->pk_op)); ! 150: send_los(pkt, "Bad opcode"); ! 151: /* should we do clsconn here? */ ! 152: } ! 153: /* ! 154: * Connection is neither waiting for an OPEN nor OPEN. ! 155: */ ! 156: } else { ! 157: debug(DPKT|DABNOR,printf("Packet for conn #%x (not open) state=%d, op:%d\n", conn->cn_lidx, conn->cn_state, pkt->pk_op)); ! 158: send_los(pkt, "Connection is closed"); ! 159: } ! 160: } ! 161: ! 162: /* ! 163: * Send a control packet back to its source ! 164: */ ! 165: reflect(pkt) ! 166: register struct packet *pkt; ! 167: { ! 168: register short temp; ! 169: ! 170: temp = pkt->pk_sidx; ! 171: pkt->pk_sidx = pkt->pk_didx; ! 172: pkt->pk_didx = temp; ! 173: temp = pkt->pk_saddr; ! 174: pkt->pk_saddr = pkt->pk_daddr; ! 175: pkt->pk_daddr = temp; ! 176: sendctl(pkt); ! 177: } ! 178: ! 179: /* ! 180: * Process a received data packet - or an EOF packet which is mostly treated ! 181: * the same. ! 182: */ ! 183: rcvdata(conn, pkt) ! 184: register struct connection *conn; ! 185: register struct packet *pkt; ! 186: { ! 187: register struct packet *npkt; ! 188: ! 189: debug(DPKT,(prpkt(pkt,"DATA"),printf("\n")) ); ! 190: if (cmp_gt(pkt->pk_pkn, conn->cn_rread + conn->cn_rwsize)) { ! 191: debug(DPKT|DABNOR,printf("Discarding data out of window\n")); ! 192: ch_free((char *)pkt); ! 193: return; ! 194: } ! 195: receipt(conn, pkt->pk_ackn, pkt->pk_ackn); ! 196: if (cmp_le(pkt->pk_pkn, conn->cn_rlast)) { ! 197: debug(DPKT,printf("Duplicate data packet\n")); ! 198: makests(conn, pkt); ! 199: reflect(pkt); ! 200: return; ! 201: } ! 202: ! 203: /* ! 204: * Link the out of order list onto the new packet in case ! 205: * it fills the gap between in-order and out-of-order lists ! 206: * and to make it easy to grab all now-in-order packets from the ! 207: * out-of-order list. ! 208: */ ! 209: pkt->pk_next = conn->cn_routorder; ! 210: /* ! 211: * Now transfer all in-order packets to the in-order list ! 212: */ ! 213: for (npkt = pkt; ! 214: npkt != NOPKT && ! 215: npkt->pk_pkn == (unsigned short)(conn->cn_rlast + 1); ! 216: npkt = npkt->pk_next) { ! 217: if (conn->cn_rhead == NOPKT) ! 218: conn->cn_rhead = npkt; ! 219: else ! 220: conn->cn_rtail->pk_next = npkt; ! 221: conn->cn_rtail = npkt; ! 222: conn->cn_rlast++; ! 223: ! 224: } ! 225: /* ! 226: * If we queued up any in-order pkts, check if spontaneous STS is needed ! 227: */ ! 228: if (pkt != npkt) { ! 229: debug(DPKT,printf("new ordered data packet\n")); ! 230: conn->cn_rtail->pk_next = NOPKT; ! 231: conn->cn_routorder = npkt; ! 232: if (conn->cn_rhead == pkt) ! 233: INPUT(conn); ! 234: /* ! 235: * If we are buffering "many" packets, keep him up to date ! 236: * about the window. The second test can be flushed if it is ! 237: * more important to receipt than to save sending an "extra" ! 238: * STS with no new acknowledgement. ! 239: * Lets do without it for a while. ! 240: if ((short)(conn->cn_rlast - conn->cn_racked) > conn->cn_rsts && ! 241: conn->cn_racked != conn->cn_rread) ! 242: sendsts(conn); ! 243: */ ! 244: /* ! 245: * Here we have received an out of order packet which must be ! 246: * inserted into the out-of-order queue, in packet number order. ! 247: */ ! 248: } else { ! 249: for (npkt = pkt; (npkt = npkt->pk_next) != NOPKT && ! 250: cmp_gt(pkt->pk_pkn, npkt->pk_pkn); ) ! 251: pkt->pk_next = npkt; /* save the last pkt here */ ! 252: if (npkt != NOPKT && pkt->pk_pkn == npkt->pk_pkn) { ! 253: debug(DPKT|DABNOR, ! 254: printf("Duplicate out of order packet\n")); ! 255: pkt->pk_next = NOPKT; ! 256: makests(conn, pkt); ! 257: reflect(pkt); ! 258: } else { ! 259: if (npkt == conn->cn_routorder) ! 260: conn->cn_routorder = pkt; ! 261: else ! 262: pkt->pk_next->pk_next = pkt; ! 263: pkt->pk_next = npkt; ! 264: debug(DPKT|DABNOR, ! 265: printf("New out of order packet\n")); ! 266: } ! 267: } ! 268: } ! 269: ! 270: /* ! 271: * Make a STS packet for a connection, reflecting its current state ! 272: */ ! 273: makests(conn, pkt) ! 274: register struct connection *conn; ! 275: register struct packet *pkt; ! 276: { ! 277: pkt->pk_op = STSOP; ! 278: pkt->pk_lenword = sizeof(struct sts_data); ! 279: pkt->pk_ackn = conn->cn_racked = conn->cn_rread; ! 280: pkt->pk_receipt = conn->cn_rlast; ! 281: pkt->pk_rwsize = conn->cn_rwsize; ! 282: } ! 283: ! 284: /* ! 285: * Process receipts and acknowledgements using recnum as the receipt. ! 286: */ ! 287: receipt(conn, acknum, recnum) ! 288: register struct connection *conn; ! 289: unsigned short acknum, recnum; ! 290: { ! 291: register struct packet *pkt, *pktl; ! 292: ! 293: /* ! 294: * Process a receipt, freeing packets that we now know have been ! 295: * received. ! 296: */ ! 297: if (cmp_gt(recnum, conn->cn_trecvd)) { ! 298: for (pktl = conn->cn_thead; ! 299: pktl != NOPKT && cmp_le(pktl->pk_pkn, recnum); ! 300: pktl = pkt) { ! 301: pkt = pktl->pk_next; ! 302: ch_free((char *)pktl); ! 303: } ! 304: if ((conn->cn_thead = pktl) == NOPKT) ! 305: conn->cn_ttail = NOPKT; ! 306: conn->cn_trecvd = recnum; ! 307: } ! 308: /* ! 309: * If the acknowledgement is new, update our idea of the ! 310: * latest acknowledged packet, and wakeup output that might be blocked ! 311: * on a full transmit window. ! 312: */ ! 313: if (cmp_gt(acknum, conn->cn_tacked)) ! 314: if (cmp_gt(acknum, conn->cn_tlast)) ! 315: debug(DABNOR, (printf("Invalid acknowledgment(%d,%d)\n", ! 316: acknum, conn->cn_tlast))); ! 317: else { ! 318: conn->cn_tacked = acknum; ! 319: OUTPUT(conn); ! 320: } ! 321: } ! 322: ! 323: /* ! 324: * Send a LOS in response to the given packet. ! 325: * Don't bother if the packet is itself a LOS or a CLS since the other ! 326: * end doesn't care anyway and would only return it again. ! 327: * Append the host name to the error message. ! 328: */ ! 329: sendlos(pkt, str, len) ! 330: register struct packet *pkt; ! 331: char *str; ! 332: { ! 333: if (pkt->pk_op == LOSOP || pkt->pk_op == CLSOP) ! 334: ch_free((char *)pkt); ! 335: else { ! 336: register char *cp; ! 337: register int length; ! 338: ! 339: for (cp = Chmyname, length = 0; *cp && length < CHSTATNAME;) { ! 340: length++; ! 341: cp++; ! 342: } ! 343: if (pkt = pktstr(pkt, str, len + length + sizeof("(from )") - 1)) { ! 344: chmove("(from ", &pkt->pk_cdata[len], 6); ! 345: chmove(Chmyname, &pkt->pk_cdata[len + 6], length); ! 346: chmove(")", &pkt->pk_cdata[len + 6 + length], 1); ! 347: pkt->pk_op = LOSOP; ! 348: reflect(pkt); ! 349: } ! 350: } ! 351: } ! 352: ! 353: /* ! 354: * Process a received RFC ! 355: */ ! 356: rcvrfc(pkt) ! 357: register struct packet *pkt; ! 358: { ! 359: register struct connection *conn, **conptr; ! 360: struct packet **opkt, *pktl; ! 361: ! 362: debug(DPKT,prpkt(pkt,"RFC")); ! 363: debug(DPKT,printf("contact = %s\n", pkt->pk_cdata)); ! 364: /* ! 365: * Check if this is a duplicate RFC, and if so throw it away, ! 366: * and retransmit the OPEN. ! 367: */ ! 368: for (conptr = &Chconntab[0]; conptr < &Chconntab[CHNCONNS];) ! 369: if ((conn = *conptr++) != NOCONN && ! 370: conn->cn_fidx == pkt->pk_sidx && ! 371: conn->cn_faddr == pkt->pk_saddr) { ! 372: if (conn->cn_state == CSOPEN) { ! 373: debug(DPKT|DABNOR, ! 374: printf("Rcvrfc: Retransmitting open chan #%x\n", (*conptr)->cn_lidx)); ! 375: sendopn(conn); ! 376: } else { ! 377: debug(DPKT|DABNOR, ! 378: printf("Rcvrfc: Duplicate RFC: %x\n", ! 379: conn->cn_lidx)); ! 380: } ! 381: ch_free((char *)pkt); ! 382: return; ! 383: } ! 384: /* ! 385: * Scan the listen list for a listener and if one is found ! 386: * open the connection and remove the listen packet from the ! 387: * listen list. ! 388: */ ! 389: for (opkt = &Chlsnlist; (pktl = *opkt) != NOPKT; opkt = &pktl->pk_next) ! 390: if(concmp(pkt, pktl->pk_cdata, (int)pktl->pk_len)) { ! 391: conn = Chconntab[pktl->pk_stindex]; ! 392: *opkt = pktl->pk_next; ! 393: ch_free((char *)pktl); ! 394: lsnmatch(pkt, conn); ! 395: NEWSTATE(conn); ! 396: return; ! 397: } ! 398: if (concmp(pkt, "STATUS", 6)) { ! 399: statusrfc(pkt); ! 400: return; ! 401: } ! 402: if (concmp(pkt, "TIME", 4)) { ! 403: timerfc(pkt); ! 404: return; ! 405: } ! 406: if (Chrfcrcv == 0) { ! 407: send_los(pkt, "All servers disabled"); ! 408: return; ! 409: } ! 410: /* ! 411: * There was no listener, so queue the RFC on the unmatched RFC list ! 412: * again checking for duplicates. ! 413: */ ! 414: pkt->pk_ackn = 0; /* this is for ch_rskip, in chuser.c */ ! 415: pkt->pk_next = NOPKT; ! 416: if ((pktl = Chrfclist) == NOPKT) ! 417: Chrfclist = Chrfctail = pkt; ! 418: else { ! 419: do { ! 420: if(pktl->pk_sidx == pkt->pk_sidx && ! 421: pktl->pk_saddr == pkt->pk_saddr) { ! 422: debug(DPKT/*|DABNOR*/,printf("Rcvrfc: Discarding duplicate Rfc on Chrfclist\n")); ! 423: ch_free((char *)pkt); ! 424: return; ! 425: } ! 426: } while ((pktl = pktl->pk_next) != NOPKT); ! 427: Chrfctail->pk_next = pkt; ! 428: Chrfctail = pkt; ! 429: } ! 430: debug(DCONN,printf("Rcvrfc: Queued Rfc on Chrfclist: '%c%c%c%c'\n", ! 431: pkt->pk_cdata[0], pkt->pk_cdata[1], pkt->pk_cdata[2], ! 432: pkt->pk_cdata[3])); ! 433: RFCINPUT; ! 434: } ! 435: /* ! 436: * An RFC has matched a listener, either by an RFC coming and finding a match ! 437: * on the listener list, or by a listen being done and matching an RFC on the ! 438: * unmatched RFC list. So we change the state of the connection to CSRFCRCVD ! 439: */ ! 440: lsnmatch(rfcpkt, conn) ! 441: register struct packet *rfcpkt; ! 442: register struct connection *conn; ! 443: { ! 444: debug(DCONN,printf("Conn #%x: LISTEN matched \n", conn->cn_lidx)); ! 445: /* ! 446: * Initialize the conection ! 447: */ ! 448: conn->cn_active = Chclock; ! 449: conn->cn_state = CSRFCRCVD; ! 450: conn->cn_rwsize = CHDRWSIZE; ! 451: conn->cn_faddr = rfcpkt->pk_saddr; ! 452: conn->cn_fidx = rfcpkt->pk_sidx; ! 453: /* ! 454: * Queue up the RFC for the user to read if he wants it. ! 455: */ ! 456: rfcpkt->pk_next = NOPKT; ! 457: conn->cn_rhead = conn->cn_rtail = rfcpkt; ! 458: /* ! 459: * Indicate to the other end that we have received and "read" ! 460: * the RFC so that the open will truly acknowledge it. ! 461: */ ! 462: conn->cn_rlast = conn->cn_rread = rfcpkt->pk_pkn; ! 463: } ! 464: /* ! 465: * Remove a listener from the listener list, due to the listener bailing out. ! 466: * Called from top level at high priority ! 467: */ ! 468: rmlisten(conn) ! 469: register struct connection *conn; ! 470: { ! 471: register struct packet *opkt, *pkt; ! 472: ! 473: opkt = NOPKT; ! 474: for (pkt = Chlsnlist; pkt != NOPKT; opkt = pkt, pkt = pkt->pk_next) ! 475: if (pkt->pk_stindex == conn->cn_ltidx) { ! 476: if(opkt == NOPKT) ! 477: Chlsnlist = pkt->pk_next; ! 478: else ! 479: opkt->pk_next = pkt->pk_next; ! 480: ch_free((char *)pkt); ! 481: break; ! 482: } ! 483: } ! 484: /* ! 485: * Compare the RFC contact name with the listener name. ! 486: */ ! 487: concmp(rfcpkt, lsnstr, lsnlen) ! 488: struct packet *rfcpkt; ! 489: register char *lsnstr; ! 490: register int lsnlen; ! 491: { ! 492: register char *rfcstr = rfcpkt->pk_cdata; ! 493: register int rfclen; ! 494: ! 495: debug(DPKT,printf("Rcvrfc: Comparing %s and %s\n", rfcstr, lsnstr)); ! 496: for (rfclen = rfcpkt->pk_len; rfclen; rfclen--, lsnlen--) ! 497: if (lsnlen <= 0) ! 498: return ((*rfcstr == ' ') ? 1 : 0); ! 499: else if (*rfcstr++ != *lsnstr++) ! 500: return(0); ! 501: return (lsnlen == 0); ! 502: } ! 503: /* ! 504: * Process a routing packet. ! 505: */ ! 506: rcvrut(pkt) ! 507: struct packet *pkt; ! 508: { ! 509: register int i; ! 510: register struct rut_data *rd; ! 511: register struct chroute *r; ! 512: ! 513: debug(DPKT, ( prpkt(pkt,"RUT"),printf("\n") ) ); ! 514: rd = pkt->pk_rutdata; ! 515: if (pkt->pk_ssubnet >= CHNSUBNET) ! 516: printf("CHAOS: bad subnet %d in RUT pkt\n", pkt->pk_ssubnet); ! 517: else if (Chroutetab[pkt->pk_ssubnet].rt_type != CHDIRECT) ! 518: printf("CHAOS: RUT pkt from unconnected subnet %d\n", ! 519: pkt->pk_ssubnet); ! 520: else for (i = pkt->pk_len; i; i -= sizeof(struct rut_data), rd++) { ! 521: if (rd->pk_subnet >= CHNSUBNET) { ! 522: debug(DABNOR, printf("CHAOS: bad subnet %d in RUT pkt\n", ! 523: rd->pk_subnet)); ! 524: continue; ! 525: } ! 526: r = &Chroutetab[rd->pk_subnet]; ! 527: switch (r->rt_type) { ! 528: case 0: ! 529: case CHBRIDGE: ! 530: if (rd->pk_cost <= r->rt_cost) { ! 531: r->rt_cost = rd->pk_cost; ! 532: r->rt_type = CHBRIDGE; ! 533: r->rt_addr = pkt->pk_saddr; ! 534: } ! 535: break; ! 536: case CHDIRECT: ! 537: case CHFIXED: ! 538: break; ! 539: default: ! 540: printf("CHAOS: Illegal chaos routing table entry %d", ! 541: r->rt_type); ! 542: } ! 543: } ! 544: ch_free((char *)pkt); ! 545: } ! 546: ! 547: /* ! 548: * process a RFC for contact name STATUS ! 549: */ ! 550: statusrfc(rpkt) ! 551: register struct packet *rpkt; ! 552: { ! 553: register struct packet *pkt; ! 554: register struct chroute *r; ! 555: register struct chxcvr *xp; ! 556: register struct statdata *sp; ! 557: register int i; ! 558: ! 559: for (i = 0, r = Chroutetab; r < &Chroutetab[CHNSUBNET]; r++) ! 560: if (r->rt_type == CHDIRECT) ! 561: i++; ! 562: i *= sizeof(struct stathead) + sizeof(struct statxcvr); ! 563: i += CHSTNAME; ! 564: if ((pkt = pkalloc(i, 1)) == NOPKT) { ! 565: ch_free((char *)rpkt); ! 566: return; ! 567: } ! 568: pkt->pk_daddr = rpkt->pk_saddr; ! 569: pkt->pk_didx = rpkt->pk_sidx; ! 570: ch_free((char *)rpkt); ! 571: pkt->pk_type = 0; ! 572: pkt->pk_op = ANSOP; ! 573: pkt->pk_next = NOPKT; ! 574: pkt->pk_saddr = Chmyaddr; ! 575: pkt->pk_sidx = pkt->pk_pkn = pkt->pk_ackn = 0; ! 576: pkt->pk_lenword = i; ! 577: chmove(Chmyname, pkt->pk_status.sb_name, CHSTATNAME); ! 578: sp = &pkt->pk_status.sb_data[0]; ! 579: for (r = Chroutetab; r < &Chroutetab[CHNSUBNET]; r++) ! 580: if (r->rt_type == CHDIRECT) { ! 581: xp = r->rt_xcvr; ! 582: sp->sb_ident = 0400 + xp->xc_subnet; ! 583: sp->sb_nshorts = sizeof(struct statxcvr) / sizeof(short); ! 584: sp->sb_xstat = xp->xc_xstat; ! 585: #ifdef pdp11 ! 586: swaplong(&sp->sb_xstat, ! 587: sizeof(struct statxcvr) / sizeof(long)); ! 588: #endif ! 589: sp = (struct statdata *)((char *)sp + ! 590: sizeof(struct stathead) + ! 591: sizeof(struct statxcvr)); ! 592: } ! 593: sendctl(pkt); ! 594: } ! 595: ! 596: /* ! 597: * process a RFC for contact name TIME ! 598: */ ! 599: timerfc(pkt) ! 600: register struct packet *pkt; ! 601: { ! 602: long t; ! 603: ! 604: pkt->pk_op = ANSOP; ! 605: pkt->pk_next = NOPKT; ! 606: pkt->pk_pkn = pkt->pk_ackn = 0; ! 607: pkt->pk_lenword = sizeof(long); ! 608: ch_time(&t); ! 609: pkt->pk_ldata[0] = t; ! 610: #ifdef pdp11 ! 611: swaplong(&pkt->pk_ldata, 1); ! 612: #endif pdp11 ! 613: reflect(pkt); ! 614: } ! 615: #ifdef DEBUG ! 616: prpkt(pkt, str) ! 617: register struct packet *pkt; ! 618: char *str; ! 619: { ! 620: printf("op=%s(%o) len=%d fc=%d\ndhost=%o didx=%x\nshost=%o sidx=%x\npkn=%d ackn=%d ", ! 621: str, pkt->pk_op, pkt->pk_len, pkt->pk_fc, pkt->pk_dhost, ! 622: pkt->pk_didx, pkt->pk_shost, pkt->pk_sidx, ! 623: (unsigned)pkt->pk_pkn, (unsigned)pkt->pk_ackn); ! 624: } ! 625: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.