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