Context Navigation

source: asp3_tinet_ecnl_arm/trunk/asp3_dcre/tinet/netinet/tcp_input.c@ 364

Last change on this file since 364 was 364, checked in by coas-nagasima, 5 years ago
TINETとSocket APIなどを更新
Property svn:eol-style set to `native` Property svn:mime-type set to `text/x-csrc;charset=UTF-8`
File size: 54.6 KB

Line
1	/*
2	* TINET (TCP/IP Protocol Stack)
3	*
4	* Copyright (C) 2001-2017 by Dep. of Computer Science and Engineering
5	* Tomakomai National College of Technology, JAPAN
6	*
7	* 上記著作権者は，以下の (1)～(4) の条件か，Free Software Foundation
8	* によって公表されている GNU General Public License の Version 2 に記
9	* 述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
10	* を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
11	* 利用と呼ぶ）することを無償で許諾する．
12	* (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
13	* 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
14	* スコード中に含まれていること．
15	* (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
16	* 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
17	* 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
18	* の無保証規定を掲載すること．
19	* (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
20	* 用できない形で再配布する場合には，次の条件を満たすこと．
21	* (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
22	* 作権表示，この利用条件および下記の無保証規定を掲載すること．
23	* (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
24	* 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
25	*
26	* 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
27	* よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
28	* 含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
29	* 接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
30	*
31	* @(#) $Id$
32	*/
33
34	/*
35	* Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994, 1995
36	* The Regents of the University of California. All rights reserved.
37	*
38	* Redistribution and use in source and binary forms, with or without
39	* modification, are permitted provided that the following conditions
40	* are met:
41	* 1. Redistributions of source code must retain the above copyright
42	* notice, this list of conditions and the following disclaimer.
43	* 2. Redistributions in binary form must reproduce the above copyright
44	* notice, this list of conditions and the following disclaimer in the
45	* documentation and/or other materials provided with the distribution.
46	* 3. All advertising materials mentioning features or use of this software
47	* must display the following acknowledgement:
48	* This product includes software developed by the University of
49	* California, Berkeley and its contributors.
50	* 4. Neither the name of the University nor the names of its contributors
51	* may be used to endorse or promote products derived from this software
52	* without specific prior written permission.
53	*
54	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64	* SUCH DAMAGE.
65	*
66	* @(#)tcp_input.c 8.12 (Berkeley) 5/24/95
67	* $FreeBSD: src/sys/netinet/tcp_input.c,v 1.82.2.3 1999/10/14 11:49:38 des Exp $
68	*/
69
70	#include <string.h>
71
72	#ifdef TARGET_KERNEL_ASP
73
74	#include <kernel.h>
75	#include <sil.h>
76	#include <t_syslog.h>
77	#include "kernel_cfg.h"
78
79	#endif /* of #ifdef TARGET_KERNEL_ASP */
80
81	#ifdef TARGET_KERNEL_JSP
82
83	#include <s_services.h>
84	#include <t_services.h>
85	#include "kernel_id.h"
86
87	#endif /* of #ifdef TARGET_KERNEL_JSP */
88
89	#include <tinet_defs.h>
90	#include <tinet_config.h>
91
92	#include <net/if.h>
93	#include <net/if_ppp.h>
94	#include <net/if_loop.h>
95	#include <net/ethernet.h>
96	#include <net/net.h>
97	#include <net/net_endian.h>
98	#include <net/net_var.h>
99	#include <net/net_buf.h>
100	#include <net/net_timer.h>
101	#include <net/net_count.h>
102
103	#include <netinet/in.h>
104	#include <netinet/in_var.h>
105	#include <netinet/in_itron.h>
106	#include <netinet/ip.h>
107	#include <netinet/ip_var.h>
108	#include <netinet/ip_icmp.h>
109	#include <netinet/tcp.h>
110	#include <netinet/tcp_var.h>
111	#include <netinet/tcp_fsm.h>
112	#include <netinet/tcp_seq.h>
113	#include <netinet/tcp_timer.h>
114
115	#ifdef SUPPORT_TCP
116
117	/*
118	* 戻り値
119	*
120	* RET_OK 正常
121	* RET_DROP エラー、セグメントを破棄する。
122	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
123	*/
124
125	#define RET_OK (0)
126	#define RET_NEED_OUTPUT (1)
127	#define RET_RETURN (2)
128	#define RET_DROP (-1)
129	#define RET_RST_DROP (-2)
130
131	/*
132	* 関数
133	*/
134
135	static void close_connection (T_TCP_CEP cep, bool_t needoutput);
136	static void set_rexmt_timer (T_TCP_CEP *cep, T_TCP_TIME rtt);
137	static uint8_t reassemble (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, uint8_t flags);
138	static ER drop_after_ack (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff);
139	static ER listening (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, T_TCP_SEQ iss);
140	static ER proc_ack1 (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, bool_t *needoutput);
141	static ER proc_ack2 (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, bool_t *needoutput);
142	static ER syn_sent (T_TCP_HDR tcph, T_TCP_CEP cep);
143	static void trim_length (T_TCP_HDR tcph, T_TCP_CEP cep);
144	static void parse_option (T_TCP_HDR tcph, T_TCP_CEP cep);
145	static bool_t update_wnd (T_TCP_HDR tcph, T_TCP_CEP cep);
146	static void proc_urg (T_TCP_HDR tcph, T_TCP_CEP cep);
147
148	/*
149	* parse_option -- TCP ヘッダのオプションを解析する。
150	*/
151
152	static void
153	parse_option (T_TCP_HDR tcph, T_TCP_CEP cep)
154	{
155	uint8_t *opt, type = 0;
156	uint_t len, ol, ssize;
157
158	opt = (uint8_t*)tcph + TCP_HDR_SIZE;
159	len = (uint_t)(TCP_HDR_LEN(tcph->doff) - TCP_HDR_SIZE);
160	while (len > 0 && (type = *opt) != TCP_OPT_EOL) {
161	if (type == TCP_OPT_NOP)
162	ol = 1u;
163	else {
164	if (len < 2)
165	break;
166	ol = *(opt + 1);
167	if (ol < 2 \|\| ol > len)
168	break;
169	}
170	switch (type) {
171	case TCP_OPT_NOP:
172	break;
173	case TCP_OPT_MAXSEG:
174	if ((ol == TCP_OPT_LEN_MAXSEG) && (tcph->flags & TCP_FLG_SYN)) {
175	ssize = ntohs((uint16_t)(opt + 2));
176	if (ssize > MAX_TCP_SND_SEG)
177	cep->maxseg = MAX_TCP_SND_SEG;
178	else if (ssize < TCP_MINMSS)
179	cep->maxseg = TCP_MINMSS;
180	else
181	cep->maxseg = ssize;
182	}
183	break;
184
185	case TCP_OPT_WINDOW:
186	case TCP_OPT_SACK_PERM:
187	case TCP_OPT_TIMESTAMP:
188	case TCP_OPT_CC:
189	case TCP_OPT_CCNEW:
190	case TCP_OPT_CCECHO:
191	syslog(LOG_INFO, "[TCP] unsup opt: %d.", type);
192	break;
193
194	default:
195	syslog(LOG_NOTICE, "[TCP] unexp opt: %d.", type);
196	break;
197	}
198	opt += ol;
199	len -= ol;
200	}
201	}
202
203	/*
204	* set_rexmt_timer -- 新しい往復時間を収集し、再送タイマを更新する。
205	*/
206
207	static void
208	set_rexmt_timer (T_TCP_CEP *cep, T_TCP_TIME rtt)
209	{
210	T_TCP_TIME delta;
211
212	NET_COUNT_TCP(net_count_tcp[NC_TCP_RTT_UPDATES], 1);
213	if (cep->srtt != 0) {
214	/*
215	* srtt: 平滑化された RTT
216	*
217	* 計測された RTT (rtt) と現在の平滑化された RTT (srtt) の差 (delta) を求める。
218	*
219	* delta は 2 ビット左シフト ( 4 倍) した値で保持する。
220	* srtt は 5 ビット左シフト (32 倍) した値で保持されている。
221	*
222	* delta = rtt / 8 - srtt / 8
223	*
224	* 新しい srtt は
225	*
226	* srtt = rtt / 8 + srtt * 7 / 8
227	* = srtt + (rtt / 8 - srtt / 8)
228	*
229	* で計算する。
230	* このため、rtt を 2 ビット左シフトし、srtt を (5 - 2) ビット右シフトして delta を求める。
231	*/
232	delta = ((rtt - 1) << TCP_DELTA_SHIFT) - (cep->srtt >> (TCP_SRTT_SHIFT - TCP_DELTA_SHIFT));
233	cep->srtt += delta;
234	if (cep->srtt <= 0)
235	cep->srtt = 1;
236
237	/*
238	* delta の絶対値 \| delta \| を求める。
239	*/
240	if (delta < 0)
241	delta = - delta;
242
243	/*
244	* rttvar: 平滑化された分散
245	*
246	* rttvar は 4 ビット左シフト (16 倍) した値で保持されている。
247	*
248	* delta = \|delta\| / 4 - rttvar / 4
249	*
250	* 新しい rttvar は
251	*
252	* rttvar = \|delta\|/ 4 + rttvar * 3 /4
253	* = rttvar + (\|delta\| / 4 - rttvar / 4)
254	*
255	* で計算する。
256	*/
257	delta -= cep->rttvar >> (TCP_RTTVAR_SHIFT - TCP_DELTA_SHIFT);
258	cep->rttvar += delta;
259	if (cep->rttvar <= 0)
260	cep->rttvar = 1;
261	}
262	else {
263	/*
264	* まだ srtt の設定が行われていないときは、今回計測された RTT を使用する。
265	* 平滑化された RTT (srtt) には、RTT を 5 ビット左シフト (32倍) した値。
266	* 平滑化された分散 (rttvar) には、RTT の 1/2 を 4 ビット左シフト (16倍) した値。
267	*/
268	cep->srtt = rtt << TCP_SRTT_SHIFT;
269	cep->rttvar = rtt << (TCP_RTTVAR_SHIFT - 1);
270	}
271
272	/*
273	* rtt の測定を終了し、再送回数をリセットする。
274	*/
275	cep->rtt = cep->rxtshift = 0;
276
277	/*
278	* RTT に許される最小値と rtt + 2 の大きな値の方を再送タイムアウトの最小値にする。
279	*/
280	if (rtt + 2 < TCP_TVAL_MIN)
281	cep->rxtcur = tcp_range_set(tcp_rexmt_val(cep),
282	(T_TCP_TIME)TCP_TVAL_MIN,
283	(T_TCP_TIME)TCP_TVAL_MAX_REXMT);
284	else
285	cep->rxtcur = tcp_range_set(tcp_rexmt_val(cep),
286	(T_TCP_TIME)(rtt + 2),
287	(T_TCP_TIME)TCP_TVAL_MAX_REXMT);
288	}
289
290	/*
291	* reassemble -- 受信セグメントを再構成する。順番通りに受信したときの処理
292	*/
293
294	static uint8_t
295	reassemble (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, uint8_t flags)
296	{
297	T_TCP_Q_HDR *qhdr;
298	T_TCP_HDR *tcph;
299
300	tcph = GET_TCP_HDR(input, thoff);
301	if (tcph->sum > cep->rbufsz - cep->rwbuf_count) {
302	/*
303	* 受信ウィンドバッファに空きがないときは破棄する。
304	*/
305	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DROP_SEGS], 1);
306	syscall(rel_net_buf(input));
307	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
308	flags &= ~TCP_FLG_FIN;
309	}
310	else if (tcph->seq == cep->rcv_nxt &&
311	cep->reassq == NULL &&
312	cep->fsm_state == TCP_FSM_ESTABLISHED) {
313	/*
314	* 順番通りにセグメントを受信した時の処理
315	* 受信セグメントの並べ替えは不要なので
316	* そのまま受信ウィンドバッファに書き込む。
317	*/
318
319	#ifdef TCP_CFG_DELAY_ACK
320
321	cep->flags \|= TCP_CEP_FLG_DEL_ACK;
322
323	#else/* of #ifdef TCP_CFG_DELAY_ACK */
324
325	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
326
327	#endif/* of #ifdef TCP_CFG_DELAY_ACK */
328
329	qhdr = GET_TCP_Q_HDR(input, thoff);
330
331	/* TCP ヘッダの位置を保存する。*/
332	SET_IP_TCP_Q_HDR_OFFSET(input, thoff);
333
334	/* SDU のオフセット（元はウィンドサイズ）をリセットする。*/
335	qhdr->soff = 0;
336
337	/* データを受信ウィンドバッファに書き込む。*/
338	TCP_WRITE_RWBUF(cep, input, thoff);
339	}
340	else {
341	flags = tcp_write_raque(input, cep, thoff, flags);
342	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
343	}
344	return flags;
345	}
346
347	/*
348	* listening -- 受動オープンして，状態が LISTEN の処理
349	*
350	* 戻り値:
351	* RET_OK 正常
352	* RET_DROP エラー、セグメントを破棄する。
353	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
354	*/
355
356	static ER
357	listening (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, T_TCP_SEQ iss)
358	{
359	T_TCP_HDR *tcph;
360
361	tcph = GET_TCP_HDR(input, thoff);
362
363	/*
364	* フラグに RST がセットされていれば破棄する。
365	*/
366	if (tcph->flags & TCP_FLG_RST)
367	return RET_DROP;
368
369	/*
370	* フラグに ACK がセットさてれいれば、
371	* リセットを送って破棄する。
372	*/
373	if (tcph->flags & TCP_FLG_ACK)
374	return RET_RST_DROP;
375
376	/*
377	* フラグに SYN がセットされていなければれば破棄する。
378	*/
379	if ((tcph->flags & TCP_FLG_SYN) == 0)
380	return RET_DROP;
381
382	/*
383	* 受信可能な IP アドレスとポート番号であることを確認する。
384	*/
385	if (!tcp_is_addr_accept(input, thoff))
386	return RET_DROP;
387
388	/* 相手のアドレスを記録する。*/
389	IN_COPY_TO_HOST(&cep->dstaddr.ipaddr, input);
390	cep->dstaddr.portno = tcph->sport;
391
392	/* オプションを処理する。*/
393	parse_option(tcph, cep);
394
395	/* シーケンス番号を初期化する。*/
396	if (tcp_iss == 0)
397	tcp_init_iss();
398
399	/* 自分のシーケンス番号の初期値を記録する。*/
400	if (iss != 0)
401	cep->iss = iss;
402	else
403	cep->iss = tcp_iss;
404
405	tcp_iss += TCP_ISS_INCR() / 4;
406
407	/* 相手のシーケンス番号の初期値を記録する。*/
408	cep->irs = tcph->seq;
409
410	/* 送受信シーケンス番号を初期化する。*/
411	init_send_seq(cep);
412	init_receive_seq(cep);
413
414	/* 送信ウインドサイズを設定する。*/
415	cep->snd_wnd = tcph->win;
416
417	/* 最終設定 */
418	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
419	cep->fsm_state = TCP_FSM_SYN_RECVD;
420	cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_INIT;
421
422	return RET_OK;
423	}
424
425	/*
426	* syn_sent -- 能動オープンして、状態が SYN 送信済の処理
427	*
428	* 戻り値:
429	* RET_OK 正常
430	* RET_DROP エラー、セグメントを破棄する。
431	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
432	*/
433
434	static ER
435	syn_sent (T_TCP_HDR tcph, T_TCP_CEP cep)
436	{
437	ER error = RET_OK;
438
439	/*
440	* 相手から受信確認が送られて来ても、
441	*
442	* ACK <= iss && 送信した最大 SEQ (snd_max) < ACK
443	*
444	* なら、リセットを送ってセグメントを破棄する。
445	*/
446	if ((tcph->flags & TCP_FLG_ACK) &&
447	(SEQ_LE(tcph->ack, cep->iss) \|\| SEQ_GT(tcph->ack, cep->snd_max)))
448	return RET_RST_DROP;
449
450	/*
451	* RST/ACK フラグの応答があれば、ポートが開いていない
452	* ことを意味している。
453	*/
454	if (tcph->flags & TCP_FLG_RST) {
455	if (tcph->flags & TCP_FLG_ACK) {
456	cep->net_error = EV_CNNRF;
457	cep = tcp_drop(cep, E_CLS);
458	}
459	return RET_DROP;
460	}
461
462	/*
463	* SYN フラグがなければセグメントを破棄する。
464	*/
465	if ((tcph->flags & TCP_FLG_SYN) == 0)
466	return RET_DROP;
467
468	cep->snd_wnd = tcph->win; /* snd_wnd: 相手の受信可能ウィンドサイズ */
469	cep->irs = tcph->seq; /* irs: 相手のシーケンス番号の初期値 */
470	init_receive_seq(cep); /* 送受信シーケンス番号を初期化する。 */
471
472	if (tcph->flags & TCP_FLG_ACK) {
473	/*
474	* ACK フラグがあるときの処理
475	*
476	* 受信を期待している最大の SEQ (rcv_adv) を
477	* 受信可能なウィンドサイズ (rcv_wnd) 分進める。
478	*/
479	cep->rcv_adv += cep->rcv_wnd; /* rcv_adv: 受信を期待している最大の SEQ */
480	/* rcv_wnd: 受信可能なウィンドサイズ */
481
482	/* 未確認の最小送信 SEQ (snd_una) を SYN 分 (1 オクテット) 進める。*/
483	cep->snd_una ++;
484
485	#ifdef TCP_CFG_DELAY_ACK
486
487	if (tcph->sum != 0) /* tcph->sum は SDU 長 */
488	cep->flags \|= TCP_CEP_FLG_DEL_ACK;
489	else
490	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
491
492	#else/* of #ifdef TCP_CFG_DELAY_ACK */
493
494	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
495
496	#endif/* of #ifdef TCP_CFG_DELAY_ACK */
497
498	if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
499	/*
500	* CEP で FIN 送信が要求されていれば、
501	* 切断処理を開始し、
502	* CEP の状態を FIN Wait 1 にする。
503	*/
504	cep->fsm_state = TCP_FSM_FIN_WAIT_1;
505	cep->flags &= ~TCP_CEP_FLG_NEED_FIN;
506	tcph->flags &= ~TCP_FLG_SYN;
507	}
508	else {
509	/*
510	* 相手から ACK が応答されたので、
511	* CEP の状態をコネクション開設完了状態にする。
512	*/
513	cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_IDLE;
514	cep->fsm_state = TCP_FSM_ESTABLISHED;
515	NET_COUNT_MIB(tcp_stats.tcpActiveOpens, 1);
516	syscall(set_flg(cep->est_flgid, TCP_CEP_EVT_ESTABLISHED));
517
518	#ifdef TCP_CFG_NON_BLOCKING
519
520	if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
521
522	/* 相手のアドレスをコピーする。*/
523	*cep->p_dstaddr = cep->dstaddr;
524
525	if (IS_PTR_DEFINED(cep->callback)) {
526
527	#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
528
529	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
530	(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, E_OK);
531
532	#else /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
533
534	ER error = E_OK;
535
536	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
537	(cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void)&error);
538
539	#endif /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
540
541	}
542	else {
543	syslog(LOG_WARNING, "[TCP] no call back, CEP: %d.", GET_TCP_CEPID(cep));
544	error = RET_RST_DROP;
545	}
546	cep->p_dstaddr = NULL;
547	cep->snd_tskid = TA_NULL;
548	cep->snd_tfn = cep->snd_nblk_tfn = TFN_TCP_UNDEF;
549	}
550	else
551
552	#endif /* of #ifdef TCP_CFG_NON_BLOCKING */
553
554	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
555	}
556	}
557	else {
558	/* ACK フラグがないときは、ACK を送って、CEP の状態を SYN 受信済みにする。*/
559	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
560	cep->timer[TCP_TIM_REXMT] = 0;
561	cep->fsm_state = TCP_FSM_SYN_RECVD;
562	}
563
564	return error;
565	}
566
567	/*
568	* trim_length -- 受信した SDU 長を調整する。
569	*/
570
571	static void
572	trim_length (T_TCP_HDR tcph, T_TCP_CEP cep)
573	{
574	tcph->seq ++;
575	if (tcph->sum > cep->rcv_wnd) { /* 注意: tcph->sum は SDU 長 */
576	/*
577	* SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
578	* 破棄し、FIN に応答しないことで、破棄したデータを再送させる。
579	*/
580	tcph->sum = (uint16_t)cep->rcv_wnd;
581	tcph->flags &= ~TCP_FLG_FIN;
582	}
583	cep->snd_wl1 = tcph->seq - 1; /* cep->snd_wl1: ウィンド更新 SEQ 番号 */
584
585	#ifdef TCP_CFG_EXTENTIONS
586	cep->rcv_up = tcph->seq; /* cep->rcv_up : 受信した緊急ポインタ */
587	#endif
588	}
589
590	/*
591	* proc_ack2 -- ACK の処理 (2)
592	*
593	* 戻り値
594	*
595	* RET_OK 正常
596	* RET_RETURN 正常、リターンする。
597	* RET_DROP エラー、セグメントを破棄する。
598	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
599	*/
600
601	static ER
602	proc_ack2 (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, bool_t *needoutput)
603	{
604	T_TCP_HDR *tcph;
605	ER ret = RET_OK;
606	uint32_t acked;
607	bool_t ourfinisacked = false;
608
609	tcph = GET_TCP_HDR(input, thoff);
610
611	/*
612	* 相手に受信確認された ACK から、まだ確認されていない
613	* 最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
614	* 削除してよいオクテット数 (acked) になる。
615	*/
616	acked = tcph->ack - cep->snd_una;
617	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_ACKS], 1);
618
619	/*
620	* 往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
621	* 後の ACK を受信したら、タイマバックオフをキャンセルし、
622	* 再送タイマを再設定する。
623	*/
624	if (cep->rtt && SEQ_GT(tcph->ack, cep->rtseq)) {
625	set_rexmt_timer(cep, cep->rtt);
626	}
627
628	/*
629	* 全ての未確認データが ACK されたら、再送タイマを停止し、
630	* 再開を記憶する (さらに出力か持続)。
631	* もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
632	* 現在の再送タイムアウトを設定する。
633	*/
634	if (tcph->ack == cep->snd_max) { /* cep->snd_max: 送信した最大 SEQ */
635
636	#ifdef TCP_CFG_SWBUF_CSAVE
637
638	/*
639	* 送信ウィンドバッファの省コピー機能が有効の場合は、
640	* 送信済みで、ACKが完了するまで再送タイマを変更しない。
641	*/
642	if ((cep->flags & TCP_CEP_FLG_WBCS_MASK) == TCP_CEP_FLG_WBCS_ACKED)
643	cep->timer[TCP_TIM_REXMT] = 0;
644
645	#else /* of #ifdef TCP_CFG_SWBUF_CSAVE */
646
647	cep->timer[TCP_TIM_REXMT] = 0;
648
649	#endif /* of #ifdef TCP_CFG_SWBUF_CSAVE */
650
651	*needoutput = true;
652	}
653	else if (cep->timer[TCP_TIM_PERSIST] == 0) {
654	cep->timer[TCP_TIM_REXMT] = cep->rxtcur; /* cep->rxtcur: 現在の再送タイムアウト */
655	}
656
657	/* 相手が受信確認したデータがあるときの処理 */
658	if (acked) {
659	uint32_t cw = cep->snd_cwnd; /* cep->snd_cwnd: 輻輳ウィンドサイズ */
660	uint32_t incr = cep->maxseg; /* cep->maxseg: 最大セグメントサイズ */
661
662	/*
663	* 新たに相手が受信確認したデータがあったときは、
664	* 輻輳ウィンドサイズを大きくする。
665	* 輻輳ウィンドサイズ (snd_cwnd) が
666	* 輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
667	* 輻輳回避制御を行い。
668	*
669	* snd_cwnd = snd_cwnd + maxseg * maxseg / snd_cwnd;
670	*
671	* 等しいか小さいときは、スロースタート制御を行う。
672	*
673	* snd_cwnd = snd_cwnd + maxseg
674	*
675	*/
676	if (cw > cep->snd_ssthresh)
677	/* 輻輳回避制御 */
678	incr = incr * incr / cw;
679
680	if (cw + incr < MAX_TCP_WIN_SIZE)
681	cep->snd_cwnd = (uint16_t)(cw + incr);
682	else
683	cep->snd_cwnd = MAX_TCP_WIN_SIZE;
684
685	/*
686	* 送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
687	*/
688	if (acked > cep->swbuf_count) {
689	cep->snd_wnd -= cep->swbuf_count;
690	TCP_DROP_SWBUF(cep, (uint_t)cep->swbuf_count);
691	ourfinisacked = true;
692	}
693	else {
694	cep->snd_wnd -= (uint16_t)acked;
695	TCP_DROP_SWBUF(cep, (uint_t)acked);
696	ourfinisacked = false;
697	}
698
699	/* 送信ウィンドバッファに空きができたことを知らせる。*/
700	syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
701
702	/*
703	* 送達確認されていない最小送信 SEQ (snd_una) を
704	* 今回送達確認された ACK まで進め、
705	* 次の送信データの SEQ (snd_nxt) も、新しい
706	* 送達確認されていない最小送信 SEQ (snd_una)
707	* まで進める。
708	*/
709	cep->snd_una += acked;
710	if (SEQ_LT(cep->snd_nxt, cep->snd_una))
711	cep->snd_nxt = cep->snd_una;
712
713	/*
714	* 状態により分岐
715	*/
716	switch (cep->fsm_state) {
717	case TCP_FSM_FIN_WAIT_1: /* APP が終了、FIN 送信済み、ACK 待ち */
718	if (ourfinisacked) {
719	cep->fsm_state = TCP_FSM_FIN_WAIT_2;
720	cep->timer[TCP_TIM_2MSL] = TCP_TVAL_KEEP_COUNT * TCP_TVAL_KEEP_INTERVAL;
721	}
722	break;
723	case TCP_FSM_CLOSING: /* 同時クローズ、FIN 交換済み、ACK 待ち */
724	if (ourfinisacked) {
725	/*
726	* 送信した FIN が確認されていれば状態を変更し、
727	* すべてのタイマをリセットした後、2MSL タイマを設定する。
728	*/
729	cep->fsm_state = TCP_FSM_TIME_WAIT;
730	tcp_cancel_timers(cep);
731	cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
732	}
733	break;
734	case TCP_FSM_LAST_ACK: /* APP が終了、ACK 待ち */
735	if (ourfinisacked) {
736	/*
737	* 送信した FIN が確認されていれば、cep をクローズし、
738	* セグメントを破棄する。
739	*/
740	cep = tcp_close(cep);
741	ret = RET_DROP;
742	}
743	break;
744	case TCP_FSM_TIME_WAIT: /* 相手からの FIN 受信済み、時間待ち */
745	/*
746	* 相手から FIN が再送された。もう一度2MSL タイマを設定し、
747	* ACK 送信後、セグメントを破棄する。
748	*/
749	cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
750	return drop_after_ack(input, cep, thoff);
751	}
752	}
753
754	return ret;
755	}
756
757	/*
758	* proc_ack1 -- ACK の処理 (1)
759	*
760	* 戻り値:
761	* RET_OK 正常
762	* RET_RETURN 正常、リターンする。
763	* RET_DROP エラー、セグメントを破棄する。
764	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
765	*
766	*/
767
768	static ER
769	proc_ack1 (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff, bool_t *needoutput)
770	{
771	T_TCP_HDR *tcph = GET_TCP_HDR(input, thoff);
772
773	switch (cep->fsm_state) {
774	case TCP_FSM_SYN_RECVD: /* SYN を受信し、SYN 送信済み */
775
776	/* 状態を変更する。*/
777	if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
778	cep->fsm_state = TCP_FSM_FIN_WAIT_1;
779	cep->flags &= ~TCP_CEP_FLG_NEED_FIN;
780	}
781	else {
782	cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_IDLE;
783	cep->fsm_state = TCP_FSM_ESTABLISHED;
784
785	/* TCP 通信端点からTCP 受付口を解放する。*/
786	cep->rep = NULL;
787
788	#if defined(_IP6_CFG) && defined(_IP4_CFG)
789	cep->rep4 = NULL;
790	#endif
791
792	syscall(set_flg(cep->est_flgid, TCP_CEP_EVT_ESTABLISHED));
793
794	#ifdef TCP_CFG_NON_BLOCKING
795
796	if (cep->rcv_nblk_tfn == TFN_TCP_ACP_CEP) {
797
798	/* 相手のアドレスをコピーする。*/
799
800	#if defined(_IP6_CFG) && defined(_IP4_CFG)
801
802	if (cep->flags & TCP_CEP_FLG_IPV4) {
803	(*cep->p_dstaddr4).ipaddr = ntohl(cep->dstaddr.ipaddr.s6_addr32[3]);
804	(*cep->p_dstaddr4).portno = cep->dstaddr.portno;
805	}
806	else
807	*cep->p_dstaddr = cep->dstaddr;
808
809	#else /* of #if defined(_IP6_CFG) && defined(_IP4_CFG) */
810
811	*cep->p_dstaddr = cep->dstaddr;
812
813	#endif /* of #if defined(_IP6_CFG) && defined(_IP4_CFG) */
814
815	if (IS_PTR_DEFINED(cep->callback)) {
816
817	#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
818
819	NET_COUNT_MIB(tcp_stats.tcpPassiveOpens, 1);
820	NET_COUNT_TCP(net_count_tcp[NC_TCP_ACCEPTS], 1);
821	(*cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, E_OK);
822
823	#else /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
824
825	ER error = E_OK;
826
827	NET_COUNT_MIB(tcp_stats.tcpPassiveOpens, 1);
828	NET_COUNT_TCP(net_count_tcp[NC_TCP_ACCEPTS], 1);
829	(cep->callback)(GET_TCP_CEPID(cep), cep->rcv_nblk_tfn, (void)&error);
830
831	#endif /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
832
833	cep->p_dstaddr = NULL;
834	cep->rcv_tskid = TA_NULL;
835	cep->rcv_tfn = cep->rcv_nblk_tfn = TFN_TCP_UNDEF;
836	}
837	else {
838	syslog(LOG_WARNING, "[TCP] no call back, CEP: %d.", GET_TCP_CEPID(cep));
839	cep->p_dstaddr = NULL;
840	cep->rcv_tskid = TA_NULL;
841	cep->rcv_tfn = cep->rcv_nblk_tfn = TFN_TCP_UNDEF;
842	return RET_RST_DROP;
843	}
844	}
845
846	if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
847
848	/* 相手のアドレスをコピーする。*/
849	*cep->p_dstaddr = cep->dstaddr;
850
851	if (IS_PTR_DEFINED(cep->callback)) {
852
853	#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
854
855	NET_COUNT_MIB(tcp_stats.tcpActiveOpens, 1);
856	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
857	(*cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, E_OK);
858
859	#else /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
860
861	ER error = E_OK;
862
863	NET_COUNT_MIB(tcp_stats.tcpActiveOpens, 1);
864	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
865	(cep->callback)(GET_TCP_CEPID(cep), cep->snd_nblk_tfn, (void)&error);
866
867	#endif /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
868
869	cep->p_dstaddr = NULL;
870	cep->snd_tskid = TA_NULL;
871	cep->snd_tfn = cep->snd_nblk_tfn = TFN_TCP_UNDEF;
872	}
873	else {
874	syslog(LOG_WARNING, "[TCP] no call back, CEP: %d.", GET_TCP_CEPID(cep));
875	cep->p_dstaddr = NULL;
876	cep->snd_tskid = TA_NULL;
877	cep->snd_tfn = cep->snd_nblk_tfn = TFN_TCP_UNDEF;
878	return RET_RST_DROP;
879	}
880	}
881
882	#endif /* of #ifdef TCP_CFG_NON_BLOCKING */
883
884	if (cep->rcv_tfn == TFN_TCP_ACP_CEP) {
885	NET_COUNT_MIB(tcp_stats.tcpPassiveOpens, 1);
886	NET_COUNT_TCP(net_count_tcp[NC_TCP_ACCEPTS], 1);
887	}
888
889	if (cep->snd_tfn == TFN_TCP_CON_CEP) {
890	NET_COUNT_MIB(tcp_stats.tcpActiveOpens, 1);
891	NET_COUNT_TCP(net_count_tcp[NC_TCP_CONNECTS], 1);
892	}
893	}
894
895	/*
896	* SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
897	*/
898	if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0) /* tcph->sum は SDU 長 */
899	tcph->flags = tcp_move_ra2rw(cep, tcph->flags);
900
901	cep->snd_wl1 = tcph->seq - 1; /* snd_wl1: ウィンド更新 SEQ */
902
903	/* break; 下に落ちる。*/
904
905	case TCP_FSM_ESTABLISHED: /* コネクション開設完了 */
906	case TCP_FSM_FIN_WAIT_1: /* 終了して、FIN 送信済み */
907	case TCP_FSM_FIN_WAIT_2: /* 終了、FIN 伝達確認受信、FIN待ち*/
908	case TCP_FSM_CLOSE_WAIT: /* FIN 受信、クローズ待ち */
909	case TCP_FSM_CLOSING: /* 終了、FIN 交換済み、ACK 待ち */
910	case TCP_FSM_LAST_ACK: /* FIN 受信、終了、ACK 待ち */
911	case TCP_FSM_TIME_WAIT: /* 終了、時間待ち */
912
913	if (SEQ_LE(tcph->ack, cep->snd_una)) {
914
915	/*
916	* 受信確認 ACK が未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
917	* つまり、多重に ACK を受信したことを意味している。
918	*/
919
920	if (tcph->sum == 0 && tcph->win == cep->snd_wnd) { /* tcph->sum は SDU 長 */
921
922	/*
923	* SDU がなく、相手のウィンドサイズが変更されていなければ、
924	* すでに送信したセグメントの中で、ACK (tcph->ack) と
925	* 同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
926	* この場合は、高速再転送と高速リカバリを行う。
927	*/
928	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DUP_ACKS], 1);
929
930	if (cep->timer[TCP_TIM_REXMT] == 0 \|\| tcph->ack != cep->snd_una) {
931
932	/*
933	* 再送タイマがセットされていないとき、
934	* または、ACK (tcph->ack) と未確認の最小送信 SEQが
935	* 一致しないときは、多重 ACK 数を 0 にする。
936	*/
937	cep->dupacks = 0;
938	}
939
940	else if (++ cep->dupacks == MAX_TCP_REXMT_THRESH) {
941
942	/*
943	* 多重 ACK 数がしきい値 (標準 3) になったら
944	* 高速再転送処理を開始する。
945	*/
946	uint_t win;
947
948	/*
949	* 輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
950	*
951	* 相手の受信可能ウィンドサイズ (snd_wnd) か
952	* 輻輳ウィンドサイズ (snd_cwnd) の 1/2。
953	* ただし、2 * maxseg 以上。
954	*
955	*/
956	if (cep->snd_wnd < cep->snd_cwnd)
957	win = cep->snd_wnd / 2 / cep->maxseg;
958	else
959	win = cep->snd_cwnd / 2 / cep->maxseg;
960	if (win < 2)
961	win = 2;
962	cep->snd_ssthresh = win * cep->maxseg;
963
964	/* 再送タイマと往復時間をリセットする。*/
965	cep->timer[TCP_TIM_REXMT] = 0;
966	cep->rtt = 0;
967
968	/* 消失したセグメントを送信する。*/
969	cep->snd_old_nxt = cep->snd_nxt;
970	cep->snd_nxt = tcph->ack;
971	cep->snd_cwnd = cep->maxseg;
972
973	/*
974	* snd_nxt を元に戻すように設定して
975	* 送信を指示する。
976	*/
977	cep->flags \|= TCP_CEP_FLG_POST_OUTPUT \|
978	TCP_CEP_FLG_FORCE \|
979	TCP_CEP_FLG_FORCE_CLEAR \|
980	TCP_CEP_FLG_RESTORE_NEXT_OUTPUT;
981	sig_sem(SEM_TCP_POST_OUTPUT);
982
983	/* 輻輳ウィンドサイズを更新する。*/
984	cep->snd_cwnd = (uint16_t)(cep->snd_ssthresh
985	+ cep->maxseg * cep->dupacks);
986
987	return RET_DROP;
988	}
989
990	else if (cep->dupacks > MAX_TCP_REXMT_THRESH) {
991
992	/*
993	* 多重 ACK 数がしきい値 (標準 3) を超えたら
994	* 輻輳ウィンドサイズを増加しながら再送する。
995	*/
996	cep->snd_cwnd += cep->maxseg;
997
998	/* 送信を指示する。*/
999	cep->flags \|= TCP_CEP_FLG_POST_OUTPUT;
1000	sig_sem(SEM_TCP_POST_OUTPUT);
1001
1002	return RET_DROP;
1003	}
1004	}
1005	else
1006	cep->dupacks = 0;
1007	break;
1008	}
1009
1010	/*
1011	* 受信確認 ACK が未確認の最小送信 SEQ (snd_una) 以降のときの処理
1012	*/
1013	if (cep->dupacks >= MAX_TCP_REXMT_THRESH && cep->snd_cwnd > cep->snd_ssthresh)
1014	/*
1015	* 高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
1016	*/
1017	cep->snd_cwnd = (uint16_t)cep->snd_ssthresh;
1018
1019	cep->dupacks = 0;
1020
1021	if (SEQ_GT(tcph->ack, cep->snd_max))
1022	/*
1023	* 受信した ACK が送信した最大 SEQ を超えていたときの処理
1024	*/
1025	return drop_after_ack(input, cep, thoff);
1026
1027	if (cep->flags & TCP_CEP_FLG_NEED_SYN) {
1028	/*
1029	* SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
1030	*/
1031	cep->flags &= ~TCP_CEP_FLG_NEED_SYN;
1032	cep->snd_una ++;
1033	}
1034
1035	return proc_ack2(input, cep, thoff, needoutput);
1036	break;
1037	}
1038	return RET_OK;
1039	}
1040
1041	/*
1042	* update_wnd -- ウィンドサイズを更新する。
1043	*
1044	* 戻り値: 送信が必要なら true を返す。
1045	*/
1046
1047	static bool_t
1048	update_wnd (T_TCP_HDR tcph, T_TCP_CEP cep)
1049	{
1050
1051	/*
1052	* 更新条件
1053	*
1054	* ACK フラグがセットされている &&
1055	* (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 \|\|
1056	* 前回ウィンドを更新した SEQ (snd_wl1) が SEQ と同じ &&
1057	* (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 \|\|
1058	* (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
1059	* WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
1060	* )
1061	* )
1062	* )
1063	*/
1064	if ((tcph->flags & TCP_FLG_ACK) &&
1065	(SEQ_LT(cep->snd_wl1, tcph->seq) \|\|
1066	(cep->snd_wl1 == tcph->seq &&
1067	(SEQ_LT(cep->snd_wl2, tcph->ack) \|\|
1068	(cep->snd_wl2 == tcph->ack && tcph->win > cep->snd_wnd))))) {
1069
1070	cep->snd_wnd = tcph->win;
1071	cep->snd_wl1 = tcph->seq;
1072	cep->snd_wl2 = tcph->ack;
1073
1074	if (cep->snd_wnd > cep->max_sndwnd)
1075	/* 今までの最大送信ウィンドサイズを更新する。*/
1076	cep->max_sndwnd = cep->snd_wnd;
1077
1078	#ifdef TCP_CFG_SWBUF_CSAVE
1079
1080	if ((cep->flags & TCP_CEP_FLG_WBCS_MASK) == TCP_CEP_FLG_WBCS_WOPEN_PEND) {
1081
1082	/*
1083	* 送信ウィンドバッファ用のネットワークバッファ割り当て中で、
1084	* 相手の受信ウィンドが空くのを待っているときの処理
1085	*/
1086	if (cep->snd_wnd > 0) {
1087
1088	/*
1089	* 相手の受信ウィンドが空いたときは、
1090	* 送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
1091	*/
1092	cep->flags = (cep->flags & ~TCP_CEP_FLG_WBCS_MASK)
1093	\| TCP_CEP_FLG_WBCS_FREE \| TCP_CEP_FLG_POST_OUTPUT;
1094	sig_sem(SEM_TCP_POST_OUTPUT);
1095	}
1096	}
1097
1098	#endif /* of #ifdef TCP_CFG_SWBUF_CSAVE */
1099
1100	return true;
1101	}
1102	else
1103	return false;
1104	}
1105
1106	/*
1107	* proc_urg -- 緊急データつきのセグメントの処理
1108	*/
1109
1110	#ifdef TCP_CFG_EXTENTIONS
1111
1112	static void
1113	proc_urg (T_TCP_HDR tcph, T_TCP_CEP cep)
1114	{
1115	if ((tcph->flags & TCP_FLG_URG) && VALID_URG_POINTER(tcph->urp) &&
1116	TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
1117
1118	/* 緊急データつきのセグメントの処理 */
1119
1120	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_URG_SEGS], 1);
1121	if (tcph->urp + cep->rwbuf_count > cep->rbufsz) {
1122
1123	/*
1124	* 緊急ポインタの位置が受信ウィンドバッファの
1125	* 範囲を超えるときは何もしない。
1126	*/
1127	tcph->urp = 0;
1128	tcph->flags &= ~TCP_FLG_URG;
1129	}
1130
1131	if (SEQ_GT(tcph->seq + tcph->urp, cep->rcv_up))
1132	/* 緊急ポインタが更新されたときの処理 */
1133	cep->rcv_up = tcph->seq + tcph->urp;
1134
1135	if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) { /* tcph->sum は TCP の SDU 長 */
1136
1137	/*
1138	* 緊急ポインタの位置が、今回受信したセグメント内の場合は、
1139	* コールバック関数を呼び出す。
1140	*/
1141	cep->urg_tcph = tcph;
1142	if (IS_PTR_DEFINED(cep->callback)) {
1143
1144	#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
1145
1146	(cep->callback)(GET_TCP_CEPID(cep), TEV_TCP_RCV_OOB, (void)(uint32_t)1);
1147
1148	#else /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
1149
1150	uint32_t len = 1;
1151
1152	(cep->callback)(GET_TCP_CEPID(cep), TEV_TCP_RCV_OOB, (void)&len);
1153
1154	#endif /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
1155
1156	}
1157	else {
1158	syslog(LOG_WARNING, "[TCP] no call back for OOB, CEP: %d.", GET_TCP_CEPID(cep));
1159	}
1160
1161	if (cep->urg_tcph != NULL) {
1162	/* コールバック関数内で tcp_rcv_oob() を呼出さなかった。*/
1163	cep->urg_tcph = NULL;
1164	tcph->urp = 0;
1165	}
1166	else {
1167	/*
1168	* コールバック関数内で tcp_rcv_oob() を呼出した時は、
1169	* SDU 長の補正値を設定する。
1170	*/
1171	tcph->urp = 1;
1172	}
1173	}
1174	else if (tcph->urp > 0) {
1175	tcph->urp = 0;
1176	}
1177
1178	}
1179	else if (SEQ_GT(cep->rcv_nxt, cep->rcv_up)) {
1180	cep->rcv_up = cep->rcv_nxt;
1181	tcph->urp = 0;
1182	}
1183	}
1184
1185	#else /* of #ifdef TCP_CFG_EXTENTIONS */
1186
1187	static void
1188	proc_urg (T_TCP_HDR tcph, T_TCP_CEP cep)
1189	{
1190	tcph->urp = 0;
1191	}
1192
1193	#endif /* of #ifdef TCP_CFG_EXTENTIONS */
1194
1195	/*
1196	* drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
1197	*
1198	* 戻り値:
1199	* RET_RETURN 正常、リターンする。
1200	* RET_RST_DROP エラー、RST を送信し、セグメントを破棄する。
1201	*/
1202
1203	static ER
1204	drop_after_ack (T_NET_BUF input, T_TCP_CEP cep, uint_t thoff)
1205	{
1206	T_TCP_HDR *tcph = GET_TCP_HDR(input, thoff);
1207
1208	/*
1209	* SYN 受信状態で、ACK が送達確認されていない最小送信 SEQ (snd_una) より
1210	* 前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
1211	* 送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
1212	* セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
1213	*/
1214	if (cep->fsm_state == TCP_FSM_SYN_RECVD && (tcph->flags & TCP_FLG_ACK) &&
1215	(SEQ_GT(cep->snd_una, tcph->ack) \|\|
1216	SEQ_GT(tcph->ack, cep->snd_max)))
1217	return RET_RST_DROP;
1218
1219	syscall(rel_net_buf(input));
1220
1221	/* 送信を指示する。*/
1222	cep->flags \|= TCP_CEP_FLG_ACK_NOW \| TCP_CEP_FLG_POST_OUTPUT;
1223	sig_sem(SEM_TCP_POST_OUTPUT);
1224	return RET_RETURN;
1225	}
1226
1227	/*
1228	* close_connection -- コネクション開放処理、相手から FIN を受信した。
1229	*/
1230
1231	static void
1232	close_connection (T_TCP_CEP cep, bool_t needoutput)
1233	{
1234	if (TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
1235
1236	#ifdef TCP_CFG_DELAY_ACK
1237
1238	if (cep->flags & TCP_CEP_FLG_NEED_SYN)
1239	cep->flags \|= TCP_CEP_FLG_DEL_ACK;
1240	else
1241	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
1242
1243	#else/* of #ifdef TCP_CFG_DELAY_ACK */
1244
1245	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
1246
1247	#endif/* of #ifdef TCP_CFG_DELAY_ACK */
1248
1249	cep->rcv_nxt ++;
1250	}
1251
1252	switch (cep->fsm_state) {
1253	case TCP_FSM_SYN_RECVD: /* SYN を受信し、SYN 送信済み */
1254	case TCP_FSM_ESTABLISHED: /* コネクション開設完了 */
1255	cep->fsm_state = TCP_FSM_CLOSE_WAIT;
1256	syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_RWBUF_READY));
1257	break;
1258
1259	case TCP_FSM_FIN_WAIT_1: /* APP が終了、FIN 送信済み、ACK 待ち */
1260	cep->fsm_state = TCP_FSM_CLOSING;
1261	break;
1262
1263	case TCP_FSM_FIN_WAIT_2: /* 相手からの FIN 待ち */
1264	cep->fsm_state = TCP_FSM_TIME_WAIT;
1265	tcp_cancel_timers(cep);
1266	cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
1267
1268	/*
1269	* FIN WAIT 2 状態では、
1270	* 受信は可能であるが、すでに送信は終了している。
1271	* 相手の送信も終了したので、入力タスクのみ起床する。
1272	*/
1273	syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
1274
1275	#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
1276
1277	/* 相手からの FIN に対して応答を返す。*/
1278	tcp_respond(NULL, cep, cep->rcv_nxt, cep->snd_una,
1279	cep->rbufsz - cep->rwbuf_count, TCP_FLG_ACK);
1280	cep->flags &= ~TCP_CEP_FLG_ACK_NOW;
1281	*needoutput = false;
1282
1283	/*
1284	* 必要な情報を Time Wait 用 TCP 通信端点に移して、
1285	* 標準の TCP 通信端点を開放する。
1286	*/
1287	tcp_move_twcep(cep);
1288
1289	#endif /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
1290
1291	break;
1292
1293	case TCP_FSM_TIME_WAIT: /* 相手からの FIN 受信済み、時間待ち */
1294	cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
1295	break;
1296	}
1297	}
1298
1299	/*
1300	* tcp_input -- TCP の入力関数
1301	*
1302	* 注意: input には IF ヘッダと IP ヘッダが先頭にある。
1303	*/
1304
1305	uint_t
1306	tcp_input (T_NET_BUF *inputp, uint_t offp, uint_t *nextp)
1307	{
1308	T_NET_BUF input = inputp;
1309	T_TCP_HDR *tcph;
1310	T_TCP_CEP *cep = NULL;
1311	T_TCP_SEQ iss = 0;
1312	ER ret;
1313	bool_t needoutput = false;
1314	int_t rbfree;
1315	int32_t todrop, win;
1316	uint16_t seglen;
1317	uint8_t flags;
1318
1319	#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
1320	T_TCP_TWCEP *twcep;
1321	#endif /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
1322
1323	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_OCTETS],
1324	input->len - GET_IF_IP_HDR_SIZE(input));
1325	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_SEGS], 1);
1326	NET_COUNT_MIB(tcp_stats.tcpInSegs, 1);
1327
1328	/* ヘッダ長をチェックする。*/
1329	if (input->len < IF_IP_TCP_HDR_SIZE(input)) {
1330	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
1331	goto drop;
1332	}
1333
1334	tcph = GET_TCP_HDR(input, *offp);
1335
1336	seglen = input->len - offp; / TCP のセグメント長 */
1337
1338	if (IN_CKSUM(input, IPPROTO_TCP, *offp, (uint_t)seglen) != 0) {
1339	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_CKSUMS], 1);
1340	goto drop;
1341	}
1342
1343	/* TCP ヘッダ長をチェックする。*/
1344	if (TCP_HDR_LEN(tcph->doff) < TCP_HDR_SIZE \|\| TCP_HDR_LEN(tcph->doff) > seglen) {
1345	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
1346	goto drop;
1347	}
1348	tcph->sum = seglen - TCP_HDR_LEN(tcph->doff); /* ここから tcph->sum は TCP の SDU 長 */
1349
1350	/*
1351	* SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
1352	* ただし、RFC1644 T/TCP 拡張機能と競合する。
1353	*/
1354	if ((tcph->flags & (TCP_FLG_SYN \| TCP_FLG_FIN)) == (TCP_FLG_SYN \| TCP_FLG_FIN))
1355	goto drop;
1356
1357	/* ネットワークオーダーからホストオーダーに変換する。*/
1358
1359	NTOHL(tcph->seq);
1360	NTOHL(tcph->ack);
1361	NTOHS(tcph->win);
1362	NTOHS(tcph->urp);
1363	NTOHS(tcph->sport);
1364	NTOHS(tcph->dport);
1365
1366	/* SDU 長より緊急ポインタが大きい場合 */
1367	if (tcph->urp > tcph->sum)
1368	goto drop;
1369
1370	find_cep:
1371
1372	#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
1373
1374	/*
1375	* 状態が Time Wait 中の CEP を探索する。
1376	*/
1377	twcep = tcp_find_twcep(input, *offp);
1378	if (twcep != NULL) {
1379
1380	if (tcph->flags & TCP_FLG_RST) /* RST フラグを受信したときは無視する。*/
1381	goto drop;
1382	else {
1383
1384	/*
1385	* TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
1386	* 相手ホストの FIN に対する自ホストの ACK セグメントが途中で
1387	* 損失したことを意味しているので、ACK セグメントを再送する。
1388	*/
1389
1390	/* ホストオーダーからネットワークオーダーに戻す。*/
1391	HTONS(tcph->sport);
1392	HTONS(tcph->dport);
1393
1394	tcp_respond(input, NULL, twcep->rcv_nxt, twcep->snd_una, twcep->rbufsz - twcep->rwbuf_count, TCP_FLG_ACK);
1395	}
1396	return IPPROTO_DONE;
1397	}
1398	else
1399	/* 標準の TCP 通信端点を得る。*/
1400	cep = tcp_find_cep(input, *offp);
1401
1402	#else /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
1403
1404	/* TCP 通信端点を得る。*/
1405	cep = tcp_find_cep(input, *offp);
1406
1407	#endif /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
1408
1409	/*
1410	* TCP 通信端点がない場合と CEP の状態がクローズなら破棄する。
1411	*/
1412	if (cep == NULL) {
1413	syslog(LOG_INFO, "[TCP] unexp port: %d.", tcph->dport);
1414	goto reset_drop;
1415	}
1416
1417	#ifdef TCP_CFG_TRACE
1418
1419	tcp_input_trace(input, cep);
1420
1421	#endif /* of #ifdef TCP_CFG_TRACE */
1422
1423
1424	if (cep->fsm_state == TCP_FSM_CLOSED)
1425	goto drop;
1426
1427	/*
1428	* コネクション開設済みでセグメントを受信したときは、
1429	* アイドル時間と生存確認タイマをリセットする。
1430	*/
1431	cep->idle = 0;
1432	if (TCP_FSM_HAVE_ESTABLISHED(cep->fsm_state)) {
1433	cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_IDLE;
1434	}
1435
1436	/* CEP の状態が LISTEN 以外の時は、オプションを処理する。*/
1437	if (cep->fsm_state != TCP_FSM_LISTEN)
1438	parse_option(tcph, cep);
1439
1440	/*
1441	* 受信可能ウィンドサイズを計算する。
1442	*
1443	* rcv_nxt: 受信を期待している最小の SEQ（これ以前は受信済み）
1444	* rcv_adv: 受信を期待している最大の SEQ
1445	* rbufsz: 受信ウィンドバッファサイズ
1446	* rwbuf_count: 受信ウィンドバッファにあるデータ量
1447	* tcph->sum: 今回受信した SDU サイズ
1448	*
1449	* 今回受信したセグメントを順序整列キューに連結する
1450	* 可能性があるので tcph->sum を考慮する。
1451	*
1452	*/
1453	win = cep->rbufsz - (cep->rwbuf_count + tcph->sum);
1454	if (win < 0)
1455	win = 0;
1456	if (win > (int32_t)(cep->rcv_adv - cep->rcv_nxt))
1457	cep->rcv_wnd = win;
1458	else
1459	cep->rcv_wnd = cep->rcv_adv - cep->rcv_nxt;
1460
1461	/* CEP の状態により処理を行う。*/
1462
1463	if (cep->fsm_state == TCP_FSM_LISTEN) { /* 受動オープン (LISTEN) の処理。*/
1464	if ((ret = listening(input, cep, *offp, iss)) == RET_RST_DROP)
1465	goto reset_drop;
1466	else if (ret == RET_DROP)
1467	goto drop;
1468	trim_length(tcph, cep); /* 受信した SDU 長を調整する。*/
1469
1470	if (tcph->flags & TCP_FLG_ACK) { /* ACK フラグの処理 */
1471	if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
1472	goto drop;
1473	else if (ret == RET_RST_DROP)
1474	goto reset_drop;
1475	else if (ret == RET_RETURN)
1476	return IPPROTO_DONE;
1477	}
1478	}
1479	else if (cep->fsm_state == TCP_FSM_SYN_SENT) { /* 能動オープン、SYN 送信済み */
1480	if ((ret = syn_sent(tcph, cep)) == RET_RST_DROP)
1481	goto reset_drop;
1482	else if (ret == RET_DROP)
1483	goto drop;
1484	trim_length(tcph, cep); /* 受信した SDU 長を調整する。*/
1485
1486	if (tcph->flags & TCP_FLG_ACK) { /* ACK フラグの処理 */
1487	if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
1488	goto drop;
1489	else if (ret == RET_RST_DROP)
1490	goto reset_drop;
1491	else if (ret == RET_RETURN)
1492	return IPPROTO_DONE;
1493	}
1494	}
1495	else {
1496	if (cep->fsm_state == TCP_FSM_SYN_RECVD) { /* SYN を受信、SYN 送信済み */
1497	/*
1498	* 相手から受信確認が送られて来ても、
1499	*
1500	* ACK <= 未確認の最小送信 SEQ (snd_una) &&
1501	* 送信した最大 SEQ (snd_max) < ACK
1502	*
1503	* なら、リセットを送ってセグメントを破棄する。
1504	*/
1505	if ((tcph->flags & TCP_FLG_ACK) &&
1506	(SEQ_LE(tcph->ack, cep->snd_una) \|\|
1507	SEQ_GT(tcph->ack, cep->snd_max)))
1508	goto reset_drop;
1509	}
1510
1511	/*
1512	* RST フラグを受信したときの処理 (異常切断)
1513	*/
1514	if (tcph->flags & TCP_FLG_RST) {
1515	if (SEQ_GE(tcph->seq, cep->last_ack_sent) &&
1516	SEQ_LT(tcph->seq, cep->last_ack_sent + cep->rcv_wnd)) {
1517	/*
1518	* 受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
1519	* から、受信ウインドウサイズまでの間の処理
1520	*/
1521	switch (cep->fsm_state) {
1522	case TCP_FSM_SYN_RECVD: /* SYN を受信し、SYN 送信済み */
1523
1524	cep->net_error = EV_CNNRF; /* 接続不能 */
1525	cep->error = E_CLS;
1526	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
1527	NET_COUNT_MIB(tcp_stats.tcpAttemptFails, 1);
1528	cep = tcp_close(cep);
1529	break;
1530
1531	case TCP_FSM_ESTABLISHED: /* コネクション開設完了 */
1532	case TCP_FSM_CLOSE_WAIT: /* FIN 受信、クローズ待ち */
1533	NET_COUNT_MIB(tcp_stats.tcpEstabResets, 1);
1534	/* fallthrough */
1535
1536	case TCP_FSM_FIN_WAIT_1: /* 終了して、FIN 送信済み */
1537	case TCP_FSM_FIN_WAIT_2: /* 終了、FIN 伝達確認受信、FIN待ち */
1538
1539	cep->net_error = EV_CNRST; /* 接続リセット */
1540	cep->error = E_CLS;
1541	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
1542	/* no break; */
1543
1544	case TCP_FSM_CLOSING: /* 終了、FIN 交換済み、ACK 待ち */
1545	case TCP_FSM_LAST_ACK: /* FIN 受信、終了、ACK 待ち */
1546
1547	cep = tcp_close(cep);
1548	break;
1549	}
1550	}
1551	goto drop;
1552	}
1553
1554	/*
1555	* CEP の状態が SYN を受信し、SYN 送信済みの場合は、
1556	* 受信ウィンドに収まるようにデータを
1557	* 調整する前に、この接続によるパケットかどうかを検証する。
1558	*
1559	* 受信した相手の SEQ < 相手の SEQ の初期値 (irs)
1560	*
1561	* これは、"LAND" DoS 攻撃の防御である。
1562	*/
1563	if (cep->fsm_state == TCP_FSM_SYN_RECVD && SEQ_LT(tcph->seq, cep->irs)) {
1564	goto reset_drop;
1565	}
1566
1567	/*
1568	* 受信を期待している最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
1569	* 正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
1570	* 削除する。
1571	* <---------- rcv_wnd --------->
1572	* rcv_nxt rcv_nxt + rcv_wnd
1573	* v v
1574	* -----+----------------------------+-----
1575	* \| \|
1576	* -----+----------------------------+-----
1577	* +----------------------+
1578	* \|***************\| \|
1579	* +----------------------+
1580	* ^ ^
1581	* seq seq + len
1582	* <---------------> 削除する。
1583	*/
1584	todrop = cep->rcv_nxt - tcph->seq;
1585	if (todrop > 0) {
1586
1587	/*
1588	* SYN フラグがついているときは、その分 (1 オクテット)
1589	* SEQ を進め、緊急ポインタと削除する長さを調整する。
1590	*/
1591	if (tcph->flags & TCP_FLG_SYN) {
1592	tcph->flags &= ~TCP_FLG_SYN;
1593	tcph->seq ++;
1594	if (tcph->urp > 1)
1595	tcph->urp --;
1596	else
1597	tcph->flags &= ~TCP_FLG_URG;
1598	todrop --;
1599	}
1600
1601	/*
1602	* 削除する長さが SDU より長い、つまり、受信を期待している
1603	* 最小の SEQ (rcv_nxt) に達していないか、
1604	* 削除する長さが SDU と同じで、FIN フラグがついてなければ
1605	* 全て削除する。
1606	*/
1607	if ( todrop > tcph->sum \|\| /* tcph->sum は TCP の SDU 長 */
1608	(todrop == tcph->sum && (tcph->flags & TCP_FLG_FIN) == 0)) {
1609	tcph->flags &= ~TCP_FLG_FIN;
1610	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
1611	todrop = tcph->sum; /* tcph->sum は TCP の SDU 長 */
1612	}
1613
1614	/*
1615	* SDU を前に詰める。
1616	*/
1617	if (todrop < tcph->sum) { /* tcph->sum は TCP の SDU 長 */
1618	memcpy(GET_TCP_SDU(input, *offp),
1619	GET_TCP_SDU(input, *offp) + todrop, (size_t)(tcph->sum - todrop));
1620	}
1621
1622	/*
1623	* SEQ と SDU 長を調整する。
1624	*/
1625	tcph->seq += todrop;
1626	tcph->sum -= (uint16_t)todrop; /* tcph->sum は TCP の SDU 長 */
1627
1628	/*
1629	* 緊急ポインタを調整する。
1630	*/
1631	if (tcph->urp > todrop)
1632	tcph->urp -= (uint16_t)todrop;
1633	else {
1634	tcph->flags &= ~TCP_FLG_URG;
1635	tcph->urp = 0;
1636	}
1637
1638	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DUP_SEGS], 1);
1639	}
1640
1641	/*
1642	* もしユーザタスクが終了した後に、データを受信した
1643	* 場合は、RST を送る。
1644	*/
1645	if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) { /* tcph->sum は TCP の SDU 長 */
1646	cep = tcp_close(cep);
1647	goto reset_drop;
1648	}
1649
1650	/*
1651	* 受信セグメントが受信ウィンドを超える場合は、
1652	* 超えた分を削る。
1653	*
1654	* <---------- rcv_wnd --------->
1655	* rcv_nxt (rcv_nxt + rcv_wnd)
1656	* v v
1657	* -----+----------------------------+-----
1658	* \| \|
1659	* -----+----------------------------+-----
1660	* +----------------------+
1661	* \| \|******\|
1662	* +----------------------+
1663	* ^ ^
1664	* seq seq + len
1665	* <-----> 削除する。
1666	*/
1667	todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd); /* tcph->sum は TCP の SDU 長 */
1668	if (todrop > 0) {
1669	if (todrop > tcph->sum) { /* tcph->sum は TCP の SDU 長 */
1670	/*
1671	* 受信した SDU の全てが受信ウィンドを超える場合。
1672	*
1673	* TIME_WAIT 中に、新たな接続要求を受信したら
1674	* 古い接続を破棄し、新たな接続を開始する。
1675	* ただし、SEQ は前より進んでいなければならない。
1676	*/
1677	if ((tcph->flags & TCP_FLG_SYN) &&
1678	cep->fsm_state == TCP_FSM_TIME_WAIT &&
1679	SEQ_GT(tcph->seq, cep->rcv_nxt)) {
1680	iss = cep->snd_nxt + TCP_ISS_INCR();
1681	tcp_close(cep);
1682	syscall(dly_tsk(0));
1683	goto find_cep;
1684	}
1685
1686	/*
1687	* 受信ウィンドが 0 で、受信した SEQ と
1688	* 受信を期待している最小の SEQ が一致したときは
1689	* ACK を返す。それ以外はデータを破棄し、ACK を返す。
1690	*/
1691	if (cep->rcv_wnd == 0 && (tcph->seq == cep->rcv_nxt \|\| tcph->sum == 0)) {
1692	cep->flags \|= TCP_CEP_FLG_ACK_NOW;
1693	}
1694	else if (drop_after_ack(input, cep, *offp) == RET_RST_DROP)
1695	goto reset_drop;
1696	else {
1697	return IPPROTO_DONE;
1698	}
1699	}
1700	tcph->sum -= (uint16_t)todrop; /* tcph->sum は TCP の SDU 長 */
1701	tcph->flags &= ~(TCP_FLG_PUSH \| TCP_FLG_FIN);
1702	}
1703
1704	/*
1705	* もし、SYN がセットされていれば、
1706	* エラーなので RST を送り、接続を破棄する。
1707	*/
1708	if (tcph->flags & TCP_FLG_SYN) {
1709	cep->net_error = EV_CNRST;
1710	cep = tcp_drop(cep, E_CLS);
1711	goto reset_drop;
1712	}
1713
1714	/*
1715	* もし、ACK がセットされていない場合は、
1716	* 状態が SYN 受信済みか
1717	* SYN を送信しようとしていれば、処理を続けるが、
1718	* それ以外はセグメントを破棄して終了する。
1719	*/
1720	if ((tcph->flags & TCP_FLG_ACK) == 0) {
1721	if (!(cep->fsm_state == TCP_FSM_SYN_RECVD \|\| (cep->flags & TCP_CEP_FLG_NEED_SYN)))
1722	goto drop;
1723	}
1724	else {
1725	/*
1726	* ACK の処理
1727	*/
1728	ret = proc_ack1(input, cep, *offp, &needoutput);
1729	if (ret == RET_DROP)
1730	goto drop;
1731	else if (ret == RET_RST_DROP)
1732	goto reset_drop;
1733	else if (ret == RET_RETURN)
1734	return IPPROTO_DONE;
1735	}
1736	}
1737
1738	/* step 6 */
1739
1740	/* 送信ウィンドを更新する。*/
1741	if (update_wnd(tcph, cep) == true)
1742	needoutput = true;
1743
1744	/* 緊急データを処理する。*/
1745	proc_urg(tcph, cep);
1746
1747	/* do data */
1748
1749	/*
1750	* SDU があるか、FIN を未受信の状態で、最初に FIN を受信したとき、
1751	* 受信セグメントキューに net_buf を追加する。
1752	* それ以外の場合は、セグメントを破棄する。
1753	*/
1754	flags = tcph->flags;
1755	if ((tcph->sum > 0 \|\| (flags & TCP_FLG_FIN)) && /* tcph->sum は TCP の SDU 長 */
1756	TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
1757	flags = reassemble(input, cep, *offp, flags);
1758	}
1759	else {
1760	syscall(rel_net_buf(input));
1761	flags &= ~TCP_FLG_FIN;
1762	}
1763
1764	/*
1765	* FIN を受信したらコネクションをクローズする。
1766	*/
1767	if (flags & TCP_FLG_FIN)
1768	close_connection(cep, &needoutput);
1769
1770	/* 出力を行った後終了する。*/
1771	if (needoutput == true \|\| (cep->flags & TCP_CEP_FLG_ACK_NOW)) {
1772	/* 送信を指示する。*/
1773	cep->flags \|= TCP_CEP_FLG_POST_OUTPUT;
1774	sig_sem(SEM_TCP_POST_OUTPUT);
1775	}
1776
1777	return IPPROTO_DONE;
1778
1779	reset_drop:
1780	/*
1781	* RST 送信処理
1782	*/
1783
1784	if ((tcph->flags & TCP_FLG_RST) \|\| IN_IS_NET_ADDR_MULTICAST(input))
1785	goto drop;
1786
1787	/* ホストオーダーからネットワークオーダーに戻す。*/
1788
1789	HTONS(tcph->sport);
1790	HTONS(tcph->dport);
1791
1792	if (cep == NULL)
1793	rbfree = 0;
1794	else
1795	rbfree = cep->rbufsz - cep->rwbuf_count;
1796
1797	if (tcph->flags & TCP_FLG_ACK)
1798	tcp_respond(input, cep, 0, tcph->ack, rbfree, TCP_FLG_RST);
1799	else {
1800	if (tcph->flags & TCP_FLG_SYN)
1801	tcph->sum ++; /* tcph->sum は SDU 長 */
1802	tcp_respond(input, cep, tcph->seq + tcph->sum, 0, rbfree, TCP_FLG_RST \| TCP_FLG_ACK);
1803	}
1804
1805	/* input は tcp_respoond で返却される。*/
1806	NET_COUNT_TCP(net_count_tcp[NC_TCP_SEND_RSTS], 1);
1807	NET_COUNT_MIB(tcp_stats.tcpOutRsts, 1);
1808	return IPPROTO_DONE;
1809
1810	drop:
1811	NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DROP_SEGS], 1);
1812	NET_COUNT_MIB(tcp_stats.tcpInErrs, 1);
1813	syscall(rel_net_buf(input));
1814	return IPPROTO_DONE;
1815	}
1816
1817	#endif /* of #ifdef SUPPORT_TCP */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: