source: rubycfg_asp/trunk/asp_dcre/tinet/netinet/tcp_input.c@ 313

Last change on this file since 313 was 313, checked in by coas-nagasima, 7 years ago

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