![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / inet|
Return to tcp_subr.c CVS log | Up to [Research Unix] / researchv10no / sys / inet |
1.1 root 1: /* tcp_subr.c 6.1 83/07/29 */
2:
3: #include "sys/param.h"
4: #include "sys/systm.h"
5: #include "sys/stream.h"
6: #include "sys/inet/in.h"
7: #include "sys/inet/ip.h"
8: #include "sys/inet/ip_var.h"
9: #include "sys/inet/tcp.h"
10: #include "sys/inet/tcp_fsm.h"
11: #include "sys/inet/tcp_seq.h"
12: #include "sys/inet/tcp_timer.h"
13: #include "sys/inet/tcp_var.h"
14: #include "sys/inet/tcpip.h"
15: #include "sys/inet/tcpdebug.h"
16:
17: extern int tcp_maxseg;
18:
19: /*
20: * Create template to be used to send tcp packets on a connection.
21: * Call after host entry created, allocates a block and fills
22: * in a skeletal tcp/ip header, minimizing the amount of work
23: * necessary when the connection is used.
24: */
25: tcp_template(tp)
26: struct tcpcb *tp;
27: {
28: register struct block *bp;
29: register struct tcpiphdr *n;
30:
31: if ((bp=tp->t_template) == (struct block *)0)
32: bp = bp_get();
33: if (bp == NULL)
34: return;
35: tp->t_template = bp;
36: bp->next = 0;
37: bp->wptr += sizeof (struct tcpiphdr);
38: n = (struct tcpiphdr *)bp->rptr;
39: n->ti_bp = 0;
40: n->ti_next = 0;
41: n->ti_x1 = 0;
42: n->ti_pr = 6; /* tcp protocol number */
43: n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
44: n->ti_src = tp->so_laddr;
45: n->ti_dst = tp->so_faddr;
46: n->ti_sport = tp->so_lport;
47: n->ti_dport = tp->so_fport;
48: n->ti_seq = 0;
49: n->ti_ack = 0;
50: n->ti_x2 = 0;
51: n->ti_off = 5;
52: n->ti_flags = 0;
53: n->ti_win = 0;
54: n->ti_sum = 0;
55: n->ti_urp = 0;
56: }
57:
58: /*
59: * Send a single message to the TCP at address specified by
60: * the given TCP/IP header. If flags==0, then we make a copy
61: * of the tcpiphdr at ti and send directly to the addressed host.
62: * This is used to force keep alive messages out using the TCP
63: * template for a connection tp->t_template. If flags are given
64: * then we send a message back to the TCP which originated the
65: * segment ti, and discard the block containing it and any other
66: * attached blocks.
67: *
68: * In any case the ack and sequence number of the transmitted
69: * segment are as specified by the parameters.
70: */
71: tcp_respond(tp, ti, ack, seq, flags)
72: struct tcpcb *tp;
73: register struct tcpiphdr *ti;
74: tcp_seq ack, seq;
75: int flags;
76: {
77: struct block *tibp;
78: int win = 0, tlen;
79:
80: if (tp) {
81: win = sbrcvspace(tp);
82: }
83: if (flags == 0) {
84: tibp = bp_get();
85: if (tibp == NULL)
86: return;
87: tibp->next = 0;
88: tibp->wptr += sizeof (struct tcpiphdr) + 1;
89: *(struct tcpiphdr *)(tibp->rptr) = *ti;
90: ti = (struct tcpiphdr *)(tibp->rptr);
91: ti->ti_bp = tibp;
92: flags = TH_ACK;
93: tlen = 1;
94: } else {
95: in_addr taddr;
96: tcp_port tport;
97:
98: tibp = ti->ti_bp;
99: bp_check(tibp);
100: bp_free(tibp->next);
101: tibp->next = 0;
102: tibp->rptr = (u_char *)ti;
103: tibp->wptr = tibp->rptr + sizeof (struct tcpiphdr);
104: taddr = ti->ti_src;
105: ti->ti_src = ti->ti_dst;
106: ti->ti_dst = taddr;
107: tport = ti->ti_sport;
108: ti->ti_sport = ti->ti_dport;
109: ti->ti_dport = tport;
110: tlen = 0;
111: }
112: ti->ti_next = 0;
113: ti->ti_bp = 0;
114: ti->ti_x1 = 0;
115: ti->ti_pr = 6; /* tcp protocol number */
116: ti->ti_len = (u_short)(sizeof (struct tcphdr) + tlen);
117: ti->ti_len = htons(ti->ti_len);
118: ti->ti_seq = htonl(seq);
119: ti->ti_ack = htonl(ack);
120: ti->ti_x2 = 0;
121: ti->ti_off = sizeof (struct tcphdr) >> 2;
122: ti->ti_flags = flags;
123: ti->ti_win = htons((u_short)win);
124: ti->ti_urp = 0;
125: ti->ti_src = htonl(ti->ti_src);
126: ti->ti_dst = htonl(ti->ti_dst);
127: ti->ti_sport = htons(ti->ti_sport);
128: ti->ti_dport = htons(ti->ti_dport);
129: ti->ti_sum = 0;
130: ti->ti_sum = in_cksum(tibp, sizeof(struct tcpiphdr) + tlen);
131: tcp_debug(ti, 1);
132: ((struct ip *)ti)->ip_len = sizeof (struct tcpiphdr) + tlen;
133: ((struct ip *)ti)->ip_ttl = TCP_TTL;
134: ti->ti_dst = ntohl(ti->ti_dst);
135: ti->ti_src = ntohl(ti->ti_src);
136: tcp_ldout(tibp);
137: }
138:
139: /*
140: * Drop a TCP connection.
141: * If connection is synchronized,
142: * then send a RST to peer.
143: */
144: struct tcpcb *
145: tcp_drop(tp)
146: register struct tcpcb *tp;
147: {
148:
149: if (TCPS_HAVERCVDSYN(tp->t_state)) {
150: tp->t_state = TCPS_CLOSED;
151: (void) tcp_output(tp);
152: }
153: return (tcp_close(tp));
154: }
155:
156: /*
157: * Close a TCP control block:
158: * discard all space held by the tcp
159: * discard internet protocol block
160: * wake up any sleepers
161: */
162: struct tcpcb *
163: tcp_close(tp)
164: register struct tcpcb *tp;
165: {
166: register struct tcpiphdr *ti, *nextti;
167:
168: if(!tp)
169: panic("tcp_close");
170: tcp_canceltimers(tp);
171: ti = tp->seg_next;
172: while (ti != (struct tcpiphdr *)0) {
173: nextti = ti->ti_next;
174: bp_free(ti->ti_bp);
175: ti = nextti;
176: }
177: tp->seg_next = 0;
178: if (tp->t_template)
179: freeb(tp->t_template);
180: tp->t_template = 0;
181: if (tp->t_tcpopt)
182: freeb(tp->t_tcpopt);
183: tp->t_tcpopt = 0;
184: if (tp->t_ipopt)
185: freeb(tp->t_ipopt);
186: tp->t_ipopt = 0;
187:
188: /* soisdisconnected(tp); */
189: tp->so_state &= ~(SS_PLEASEOPEN|SS_RCVATMARK);
190: if(tp->so_state&SS_OPEN && !(tp->so_state&SS_HUNGUP)) {
191: tp->so_state |= SS_HUNGUP;
192: tcp_hungup(tp);
193: }
194: tp->so_laddr = tp->so_faddr = 0;
195: tp->so_lport = tp->so_fport = 0;
196: tp->t_state = TCPS_CLOSED;
197: return ((struct tcpcb *)0);
198: }
199:
200: /*
201: * For debugging save time event occurred, the direction of the message,
202: * and the tcp header. Then increment the pointer to the tcp
203: * debug queue.
204: */
205: int Nbugarr=SIZDEBUG;
206: struct tcpdebug bugarr[SIZDEBUG]; /* buffer to store the debug info in */
207: int tcpdbg_ind=0; /* index into bugarr at last entry */
208: unsigned long tcpdbg_seq = 0; /* sequence number */
209:
210: tcp_debug(ti, code)
211: struct tcpiphdr *ti;
212: {
213: register int i;
214: i = tcpdbg_ind;
215: bugarr[i].seq = tcpdbg_seq++;
216: bugarr[i].stamp = time;
217: bugarr[i].inout = code;
218: bugarr[i].hdr = *ti;
219: tcpdbg_ind = (i + 1) % SIZDEBUG;
220: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.