![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_device.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / inet|
Return to tcp_device.c CVS log | Up to [Research Unix] / researchv9 / sys / inet |
1.1 ! root 1: /* ! 2: * tcp_device.c ! 3: */ ! 4: ! 5: #include "tcp.h" ! 6: #if NTCP ! 7: #include "../h/param.h" ! 8: #include "../h/systm.h" ! 9: #include "../h/stream.h" ! 10: #include "../h/inio.h" ! 11: #include "../h/ttyio.h" ! 12: #include "../h/ttyld.h" ! 13: #include "../h/buf.h" ! 14: #include "../h/conf.h" ! 15: #include "../h/dir.h" ! 16: #include "../h/user.h" ! 17: #include "../h/inet/in.h" ! 18: #include "../h/inet/mbuf.h" ! 19: #include "../h/inet/tcp.h" ! 20: #include "../h/inet/tcp_timer.h" ! 21: #include "../h/inet/tcp_seq.h" ! 22: #include "../h/inet/tcp_var.h" ! 23: #include "../h/inet/tcp_user.h" ! 24: #include "../h/inet/tcp_fsm.h" ! 25: #include "../h/inet/socket.h" ! 26: ! 27: extern int tcp_busy; /* set to discourage timers & ensuing panics */ ! 28: ! 29: int nodev(), tcpdopen(), tcpdclose(), tcpdput(); ! 30: int tcpdosrv(), tcpdisrv(); ! 31: static struct qinit tcpdrinit = { nodev, tcpdisrv, tcpdopen, tcpdclose, 2048, 64 }; ! 32: struct qinit tcpdwinit = { tcpdput, tcpdosrv, tcpdopen, tcpdclose, 2048,64}; ! 33: struct streamtab tcpdinfo = { &tcpdrinit, &tcpdwinit }; ! 34: ! 35: int Ntcp = NTCP; /* for netstat */ ! 36: struct tcpcb tcpcb[NTCP]; ! 37: struct socket tcpsocks[NTCP]; ! 38: ! 39: tcpdopen(q, dev) ! 40: register struct queue *q; ! 41: dev_t dev; ! 42: { ! 43: struct socket *so; ! 44: ! 45: dev = minor(dev); ! 46: if(dev >= NTCP) ! 47: return(0); ! 48: so = &tcpsocks[dev]; ! 49: if((dev&01) == 0 && (so->so_state&SS_ACTIVE) == 0) ! 50: return(0); ! 51: if(so->so_state&SS_WAITING) ! 52: return(0); ! 53: if((so->so_options&SO_ACCEPTCONN) && (so->so_state&SS_OPEN)) ! 54: return(0); ! 55: if((so->so_state & (SS_ACTIVE|SS_OPEN|SS_PLEASEOPEN)) == SS_ACTIVE) ! 56: return(0); ! 57: if(q->ptr && dev&01) /* re-opening outgoing port */ ! 58: return(0); ! 59: if(q->ptr) ! 60: return(1); ! 61: tcp_busy++; ! 62: if((so->so_state & SS_PLEASEOPEN) == 0){ ! 63: bzero(so, sizeof(struct socket)); ! 64: so->so_state |= SS_WAITING; ! 65: } ! 66: so->so_state |= SS_OPEN; ! 67: so->so_dev = dev; ! 68: so->so_rq = q; ! 69: so->so_wq = WR(q); ! 70: q->ptr = (caddr_t)so; ! 71: WR(q)->flag |= QNOENB|QBIGB; ! 72: WR(q)->ptr = (caddr_t)so; ! 73: --tcp_busy; ! 74: if(so->so_state & SS_PLEASEOPEN){ ! 75: so->so_state &= ~SS_PLEASEOPEN; ! 76: qenable(WR(q)); /* to force out rcv wnd update */ ! 77: } ! 78: return(1); ! 79: } ! 80: ! 81: tcpdclose(q) ! 82: register struct queue *q; ! 83: { ! 84: struct socket *so; ! 85: struct tcpcb *tp; ! 86: ! 87: so = (struct socket *)q->ptr; ! 88: tcp_busy++; ! 89: so->so_state &= ~(SS_OPEN|SS_WAITING); ! 90: so->so_rq = so->so_wq = (struct queue *) 0; ! 91: so->so_wcount = so->so_rcount = 0; ! 92: tp = so->so_tcpcb; ! 93: if(tp == 0){ ! 94: --tcp_busy; ! 95: return; ! 96: } ! 97: if(tp->t_state > TCPS_LISTEN) ! 98: tcp_disconnect(tp); ! 99: else ! 100: tcp_close(tp); ! 101: --tcp_busy; ! 102: } ! 103: ! 104: tcpdput(q, bp) ! 105: register struct queue *q; ! 106: register struct block *bp; ! 107: { ! 108: struct socket *so; ! 109: int s, x; ! 110: register union stmsg *sp; ! 111: struct tcpcb *tp; ! 112: struct block *nbp; ! 113: struct foo { ! 114: int com; ! 115: struct tcpuser rep; ! 116: }; ! 117: struct foo *fp; ! 118: ! 119: so = (struct socket *)q->ptr; ! 120: switch(bp->type){ ! 121: case M_IOCTL: ! 122: sp = (union stmsg *)bp->rptr; ! 123: bp->type = M_IOCACK; ! 124: switch(sp->ioc0.com){ ! 125: case TIOCSETP: ! 126: case TIOCSETN: ! 127: x = sp->ioc1.sb.sg_ispeed; ! 128: bp->wptr = bp->rptr; ! 129: bp->type = M_IOCACK; ! 130: qreply(q, bp); ! 131: if(x == 0) ! 132: tcp_putctl(OTHERQ(q), M_HANGUP); ! 133: return; ! 134: case TIOCGETP: ! 135: sp->ioc1.sb.sg_ispeed = ! 136: sp->ioc1.sb.sg_ospeed = B9600; ! 137: break; ! 138: case TCPGETADDR: ! 139: nbp = allocb(sizeof(struct foo)); ! 140: if (nbp == NULL) { ! 141: bp->type = M_IOCNAK; ! 142: printf("tcpdput: out of blocks\n"); ! 143: break; ! 144: } ! 145: nbp->type = M_IOCACK; ! 146: fp = (struct foo *)nbp->rptr; ! 147: fp->com = sp->ioc1.com; ! 148: fp->rep.lport = so->so_lport; ! 149: fp->rep.fport = so->so_fport; ! 150: fp->rep.laddr = so->so_laddr; ! 151: fp->rep.faddr = so->so_faddr; ! 152: nbp->wptr = nbp->rptr + sizeof(struct foo); ! 153: freeb(bp); ! 154: bp = nbp; ! 155: break; ! 156: case TCPIOHUP: ! 157: so->so_state |= SS_HANGUP; ! 158: bp->wptr = bp->rptr; ! 159: bp->type = M_IOCACK; ! 160: qreply(q, bp); ! 161: return; ! 162: default: ! 163: bp->type = M_IOCNAK; ! 164: } ! 165: qreply(q, bp); ! 166: return; ! 167: case M_DATA: ! 168: if(socantsendmore(so)){ ! 169: freeb(bp); ! 170: return; ! 171: } ! 172: s = spl6(); ! 173: so->so_delimcnt = 0; ! 174: so->so_wcount += BLEN(bp); /* BEFORE the putq */ ! 175: putq(q, bp); ! 176: splx(s); ! 177: if((so->so_options&SO_ACCEPTCONN) == 0 ! 178: && (so->so_state&SS_WAITING) == 0 ! 179: && (tp = so->so_tcpcb)){ ! 180: /* so as to invoke tcp_output() */ ! 181: if(tp->t_state > TCPS_CLOSE_WAIT) ! 182: printf("data after CLOSE_WAIT?\n"); ! 183: qenable(q); ! 184: } ! 185: break; ! 186: case M_DELIM: ! 187: if(so->so_options&SO_ACCEPTCONN){ ! 188: printf("DELIM on listener\n"); ! 189: } else if(so->so_state & SS_WAITING){ ! 190: putq(q, bp); ! 191: /* to invoke tcpduser */ ! 192: qenable(q); ! 193: } else { ! 194: /* two back to back delims constitute logical eof */ ! 195: freeb(bp); ! 196: s = spl6(); ! 197: if(socantsendmore(so)){ ! 198: splx(s); ! 199: return; ! 200: } ! 201: if(++(so->so_delimcnt) > 1){ ! 202: splx(s); ! 203: qenable(q); ! 204: } else ! 205: splx(s); ! 206: } ! 207: break; ! 208: default: ! 209: freeb(bp); ! 210: break; ! 211: } ! 212: } ! 213: ! 214: tcpdosrv(q) ! 215: struct queue *q; ! 216: { ! 217: register struct socket *so; ! 218: register struct tcpcb *tp; ! 219: ! 220: so = (struct socket *)q->ptr; ! 221: if (so->so_state&SS_WCLOSED) ! 222: return; ! 223: tcp_busy++; ! 224: if(so->so_delimcnt > 1){ ! 225: so->so_state |= SS_WCLOSED; ! 226: if((tp = so->so_tcpcb) == 0){ ! 227: printf("delimcnt but no tp\n"); ! 228: --tcp_busy; ! 229: return; ! 230: } ! 231: tp = tcp_usrclosed(tp); ! 232: if(tp) ! 233: tcp_output(tp); ! 234: } else { ! 235: if((so->so_options&SO_ACCEPTCONN) == 0 ! 236: && (so->so_state&SS_WAITING) == 0 ! 237: && (tp = so->so_tcpcb)){ ! 238: tcp_output(tp); ! 239: } else { ! 240: tcpduser(so); ! 241: } ! 242: } ! 243: --tcp_busy; ! 244: } ! 245: ! 246: tcpdrint(bp, so) ! 247: register struct block *bp; ! 248: struct socket *so; ! 249: { ! 250: register struct block *bp1; ! 251: register struct queue *q; ! 252: ! 253: q = so->so_rq; ! 254: if(q){ ! 255: while(bp){ ! 256: bp1 = bp->next; ! 257: so->so_rcount += bp->wptr - bp->rptr; ! 258: if(bp->wptr == bp->rptr) ! 259: freeb(bp); ! 260: else ! 261: putq(q, bp); ! 262: bp = bp1; ! 263: } ! 264: } else { ! 265: printf("tcpdrint but no so->so_rq\n"); ! 266: bp_free(bp); ! 267: } ! 268: } ! 269: ! 270: tcpdisrv(q) ! 271: struct queue *q; ! 272: { ! 273: struct socket *so = (struct socket *)(q->ptr); ! 274: struct block *bp; ! 275: ! 276: while((q->next->flag&QFULL) == 0){ ! 277: if(bp = getq(q)){ ! 278: if(bp->type == M_DATA) ! 279: so->so_rcount -= bp->wptr - bp->rptr; ! 280: if(so->so_rcount < 0) ! 281: panic("so_rcount"); ! 282: (*q->next->qinfo->putp)(q->next, bp); ! 283: } else ! 284: break; ! 285: } ! 286: if(q->count <= q->qinfo->lolimit) ! 287: qenable(OTHERQ(q)); /* update remote send window */ ! 288: } ! 289: ! 290: /* ! 291: * imitation tcp_usrreq ! 292: */ ! 293: tcpduser(so) ! 294: register struct socket *so; ! 295: { ! 296: extern struct ipif *ip_ifwithaddr(); ! 297: struct tcpuser *tu; ! 298: struct block *bp, *bp1, *head; ! 299: register struct tcpcb *tp; ! 300: ! 301: bp = bp1 = head = NULL; ! 302: while(bp = getq(so->so_wq)){ ! 303: if(bp->type != M_DATA){ ! 304: freeb(bp); ! 305: } else if(bp1 == NULL){ ! 306: bp1 = head = bp; ! 307: bp->next = NULL; ! 308: } else { ! 309: bp1->next = bp; ! 310: bp1 = bp; ! 311: bp->next = NULL; ! 312: } ! 313: } ! 314: if(head == NULL) ! 315: return; ! 316: so->so_wcount = 0; ! 317: bp = head; ! 318: if(BLEN(bp) < sizeof(struct tcpuser)){ ! 319: /* ! 320: printf("tcpuser short\n"); ! 321: */ ! 322: bp_free(bp); ! 323: return; ! 324: } ! 325: tu = (struct tcpuser *)bp->rptr; ! 326: if(so->so_tcpcb) ! 327: printf("%d: tcpduser w/ tcpcb\n", so->so_dev); ! 328: switch(tu->code){ ! 329: case TCPC_CONNECT: ! 330: if(so->so_state&SS_ACTIVE) ! 331: goto bad; ! 332: if (tu->laddr != INADDR_ANY) { ! 333: /* has the user has specified a legal local address? */ ! 334: if (ip_ifwithaddr(tu->laddr) == 0) ! 335: goto bad; ! 336: } else { ! 337: /* pick a local address related to the destination */ ! 338: tu->laddr = ip_hoston(tu->faddr); ! 339: if(tu->laddr == INADDR_ANY) ! 340: goto bad; ! 341: } ! 342: if(tcp_attach(so)) ! 343: goto bad; ! 344: if(sobind(so, tu->laddr, tu->lport)) ! 345: goto bad; ! 346: tp = so->so_tcpcb; ! 347: so->so_fport = tu->fport; ! 348: so->so_faddr = tu->faddr; ! 349: so->so_options = tu->param; ! 350: if (so->so_options & SO_KEEPALIVE) ! 351: tcp_timers(tp, TCPT_KEEP); ! 352: tp->t_template = tcp_template(tp); ! 353: if(tp->t_template == 0) ! 354: goto bad; ! 355: soisconnecting(so); ! 356: tp->t_state = TCPS_SYN_SENT; ! 357: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP; ! 358: tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2; ! 359: tcp_sendseqinit(tp); ! 360: so->so_state &= ~SS_WAITING; ! 361: tcp_output(tp); ! 362: break; ! 363: case TCPC_LISTEN: ! 364: if(so->so_state&SS_ACTIVE) ! 365: goto bad; ! 366: if (tu->laddr != INADDR_ANY) { ! 367: /* has the user has specified a legal local address? */ ! 368: if (ip_ifwithaddr(tu->laddr) == 0) ! 369: goto bad; ! 370: } ! 371: if(tcp_attach(so)) ! 372: goto bad; ! 373: if(sobind(so, tu->laddr, tu->lport)) ! 374: goto bad; ! 375: tp = so->so_tcpcb; ! 376: tp->t_state = TCPS_LISTEN; ! 377: so->so_options |= SO_ACCEPTCONN; ! 378: so->so_fport = tu->fport==0 ? TCPPORT_ANY : tu->fport; ! 379: so->so_faddr = tu->faddr; ! 380: so->so_state &= ~SS_WAITING; ! 381: tcp_isconnected(so); ! 382: break; ! 383: default: ! 384: goto bad; ! 385: } ! 386: bp_free(bp); ! 387: return; ! 388: bad: ! 389: bp_free(bp); ! 390: tcp_hungup(so); ! 391: } ! 392: ! 393: tcp_attach(so) ! 394: struct socket *so; ! 395: { ! 396: register struct tcpcb *tp; ! 397: extern struct tcpcb *tcp_newtcpcb(); ! 398: ! 399: tp = tcp_newtcpcb(so); ! 400: if(tp == 0) ! 401: return(1); ! 402: tp->t_socket = so; ! 403: tp->t_state = TCPS_CLOSED; ! 404: return(0); ! 405: } ! 406: ! 407: struct tcpcb * ! 408: tcp_disconnect(tp) ! 409: register struct tcpcb *tp; ! 410: { ! 411: struct socket *so = tp->t_socket; ! 412: ! 413: if(tp->t_state < TCPS_ESTABLISHED) ! 414: tp = tcp_close(tp); ! 415: else { ! 416: soisdisconnecting(so); ! 417: tp = tcp_usrclosed(tp); ! 418: if(tp) ! 419: tcp_output(tp); ! 420: } ! 421: return(tp); ! 422: } ! 423: ! 424: struct tcpcb * ! 425: tcp_usrclosed(tp) ! 426: register struct tcpcb *tp; ! 427: { ! 428: ! 429: switch(tp->t_state){ ! 430: ! 431: case TCPS_CLOSED: ! 432: case TCPS_LISTEN: ! 433: case TCPS_SYN_SENT: ! 434: tp->t_state = TCPS_CLOSED; ! 435: tp = tcp_close(tp); ! 436: break; ! 437: ! 438: case TCPS_SYN_RECEIVED: ! 439: case TCPS_ESTABLISHED: ! 440: tp->t_state = TCPS_FIN_WAIT_1; ! 441: tp->t_socket->so_options |= SO_KEEPALIVE; ! 442: tcp_timers(tp, TCPT_KEEP); ! 443: break; ! 444: ! 445: case TCPS_CLOSE_WAIT: ! 446: tp->t_state = TCPS_LAST_ACK; ! 447: tp->t_socket->so_options |= SO_KEEPALIVE; ! 448: tcp_timers(tp, TCPT_KEEP); ! 449: break; ! 450: } ! 451: if(tp && tp->t_state >= TCPS_FIN_WAIT_2) ! 452: soisdisconnected(tp->t_socket); ! 453: return(tp); ! 454: } ! 455: ! 456: tcp_isconnected(so) ! 457: struct socket *so; ! 458: { ! 459: struct block *bp; ! 460: struct tcpuser *tu; ! 461: struct socket *rso; ! 462: ! 463: if(so->so_head) ! 464: rso = so->so_head; ! 465: else ! 466: rso = so; ! 467: if((rso->so_state & SS_OPEN) == 0){ ! 468: printf("isconnected, no fd ref\n"); ! 469: return; ! 470: } ! 471: bp = allocb(64); ! 472: if(bp == 0) ! 473: return; ! 474: bp->next = NULL; ! 475: bp->type = M_DATA; ! 476: bp->wptr += sizeof(struct tcpuser); ! 477: tu = (struct tcpuser *)bp->rptr; ! 478: tu->code = TCPC_OK; ! 479: tu->fport = so->so_fport; ! 480: tu->faddr = so->so_faddr; ! 481: tu->lport = so->so_lport; ! 482: tu->laddr = so->so_laddr; ! 483: tu->param = so->so_dev; ! 484: tcpdrint(bp, rso); ! 485: } ! 486: ! 487: tcp_hungup(so) ! 488: register struct socket *so; ! 489: { ! 490: register struct queue *q; ! 491: ! 492: q = so->so_rq; ! 493: if(q == 0) ! 494: return; ! 495: tcp_putctl(q, M_HANGUP); ! 496: } ! 497: ! 498: /* ! 499: * find a spare odd tcp device for a new passive-end ! 500: * connection. ! 501: */ ! 502: struct socket * ! 503: tcp_newconn(so) ! 504: struct socket *so; ! 505: { ! 506: struct socket *nso; ! 507: ! 508: if(so->so_rq && (so->so_rq->flag&QFULL)){ ! 509: printf("listen %d q full\n", so->so_lport); ! 510: return(0); ! 511: } ! 512: for(nso = &tcpsocks[0]; nso < &tcpsocks[NTCP]; nso += 2){ ! 513: if((nso->so_state & (SS_OPEN|SS_ACTIVE)) == 0){ ! 514: bzero(nso, sizeof(struct socket)); ! 515: nso->so_head = so; ! 516: nso->so_dev = nso - tcpsocks; ! 517: return(nso); ! 518: } ! 519: } ! 520: return(0); ! 521: } ! 522: ! 523: struct socket * ! 524: so_lookup(faddr, fport, laddr, lport) ! 525: in_addr faddr, laddr; ! 526: tcp_port fport, lport; ! 527: { ! 528: register struct socket *so, *match = 0; ! 529: int highscore = 0, score; ! 530: ! 531: for(so = &tcpsocks[0]; so < &tcpsocks[NTCP]; so++){ ! 532: if(so->so_tcpcb == 0) ! 533: continue; ! 534: if((so->so_state&(SS_OPEN|SS_ACTIVE)) == 0) ! 535: continue; ! 536: if(so->so_state & SS_WAITING) ! 537: continue; ! 538: score = 11; ! 539: if(so->so_faddr != faddr) { ! 540: if(so->so_faddr != INADDR_ANY) ! 541: continue; ! 542: else ! 543: score -=4; ! 544: } ! 545: if(so->so_fport != fport) { ! 546: if(so->so_fport != TCPPORT_ANY) ! 547: continue; ! 548: else ! 549: score -=4; ! 550: } ! 551: if(so->so_laddr != laddr) { ! 552: if(so->so_laddr != INADDR_ANY) ! 553: continue; ! 554: else ! 555: score -=1; ! 556: } ! 557: if(so->so_lport != lport) { ! 558: if(so->so_lport != TCPPORT_ANY) ! 559: continue; ! 560: else ! 561: score -=2; ! 562: } ! 563: if (score==11) ! 564: return so; ! 565: if (score<highscore) ! 566: continue; ! 567: match = so; ! 568: highscore = score; ! 569: } ! 570: return(match); ! 571: } ! 572: ! 573: /* n chars were acked; drop them now */ ! 574: sbsnddrop(so, n) ! 575: register struct socket *so; ! 576: register int n; ! 577: { ! 578: register struct queue *q; ! 579: register int i; ! 580: register struct block *bp; ! 581: ! 582: q = so->so_wq; ! 583: if(q == 0) ! 584: return; ! 585: bp = 0; ! 586: while(n > 0 && (bp = getq(q))){ ! 587: i = MIN(BLEN(bp), n); ! 588: bp->rptr += i; ! 589: n -= i; ! 590: so->so_wcount -= i; ! 591: if(bp->rptr >= bp->wptr){ ! 592: freeb(bp); ! 593: bp = 0; ! 594: } else if(n > 0){ ! 595: panic("sbsnddrop"); ! 596: } ! 597: } ! 598: if(bp) ! 599: putbq(q, bp); ! 600: } ! 601: ! 602: static tcp_port portnext[] = { 600, 1024 }; ! 603: static tcp_port portlow[] = { 600, 1024 }; ! 604: static tcp_port porthigh[] = { 1024, 2048 }; ! 605: ! 606: sobind(so, addr, port) ! 607: register struct socket *so; ! 608: register in_addr addr; ! 609: register tcp_port port; ! 610: { ! 611: register struct socket *sp; ! 612: register int i; ! 613: ! 614: so->so_lport = 0; ! 615: if(port){ ! 616: /* what about, for instance, restarting rlogind when ! 617: * people are rlogin'd here? ! 618: */ ! 619: for(sp = &tcpsocks[0]; sp < &tcpsocks[NTCP]; sp++){ ! 620: if(sp->so_tcpcb == 0) ! 621: continue; ! 622: if((sp->so_state&(SS_OPEN|SS_ACTIVE)) == 0) ! 623: continue; ! 624: if(sp->so_lport == port && sp->so_laddr == addr) { ! 625: return(1); ! 626: } ! 627: } ! 628: so->so_lport = port; ! 629: so->so_laddr = addr; ! 630: return(0); ! 631: } ! 632: /* pick one for him */ ! 633: i = u.u_uid==0 ? 0 : 1; ! 634: if(portnext[i] >= porthigh[i]) ! 635: portnext[i] = portlow[i]; ! 636: port = portnext[i]; ! 637: while(1){ ! 638: if(sobind(so, addr, portnext[i]) == 0){ ! 639: portnext[i]++; ! 640: return(0); ! 641: } ! 642: portnext[i]++; ! 643: if(portnext[i] >= porthigh[i]) ! 644: portnext[i] = portlow[i]; ! 645: if(portnext[i] == port) /* tried them all */ ! 646: break; ! 647: } ! 648: return(1); ! 649: } ! 650: ! 651: tcp_cantrcvmore(so) ! 652: register struct socket *so; ! 653: { ! 654: register struct queue *q; ! 655: ! 656: q = so->so_rq; ! 657: if(q == NULL) ! 658: return; ! 659: if(so->so_state & SS_HANGUP) ! 660: tcp_putctl(q, M_HANGUP); ! 661: else { ! 662: /* two delims ensure a zero length read at the process */ ! 663: tcp_putctl(q, M_DELIM); ! 664: tcp_putctl(q, M_DELIM); ! 665: } ! 666: } ! 667: ! 668: tcp_putctl(q, c) ! 669: register struct queue *q; ! 670: { ! 671: register struct block *bp; ! 672: ! 673: if ((bp = allocb(0)) == NULL) { ! 674: printf("tcp_putctl: no more blocks\n"); ! 675: return(0); ! 676: } ! 677: bp->type = c; ! 678: putq(q, bp); ! 679: return(1); ! 680: } ! 681: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.