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