Ignore:
Timestamp:
Aug 23, 2017, 9:27:43 AM (7 years ago)
Author:
coas-nagasima
Message:

文字コードを設定

File:
1 edited

Legend:

Unmodified
Added
Removed
  • EcnlProtoTool/trunk/asp3_dcre/tinet/netinet/tcp_input.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    55 *                   Tomakomai National College of Technology, JAPAN
    66 *
    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 è²¬ã™ã‚‹ã“と.
     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プロジェクトを免責すること.
    3625 *
    37  *  本ソフトウェアは,無保証で提供されているものである.上記著作権è€
    38 ãŠ
    39  *  よびTOPPERSプロジェクトは,本ソフトウェアに関して,その適用可能性も
    40  *  含めて,いかなる保証も行わない.また,本ソフトウェアの利用により直
    41  *  接的または間接的に生じたいかなる損害に関しても,その責任を負わない.
     26 *  本ソフトウェアは,無保証で提供されているものである.上記著作権者お
     27 *  よびTOPPERSプロジェクトは,本ソフトウェアに関して,その適用可能性も
     28 *  含めて,いかなる保証も行わない.また,本ソフトウェアの利用により直
     29 *  接的または間接的に生じたいかなる損害に関しても,その責任を負わない.
    4230 *
    4331 *  @(#) $Id$
     
    132120
    133121/*
    134  *  戻り値
     122 *  戻り値
    135123 *
    136  *      RET_OK          正常
    137  *      RET_DROP        エラー、セグメントを破棄する。
    138  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     124 *      RET_OK          正常
     125 *      RET_DROP        エラー、セグメントを破棄する。
     126 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    139127 */
    140128
     
    146134
    147135/*
    148  *  関数
     136 *  関数
    149137 */
    150138
     
    165153
    166154/*
    167  *  タスクからの Time Wait 状æ
    168 ‹ CEP 分離機能
    169  */
    170 
    171 /*
    172  *  関数
     155 *  タスクからの Time Wait 状態 CEP 分離機能
     156 */
     157
     158/*
     159 *  関数
    173160 */
    174161
     
    177164
    178165/*
    179  *  変数
     166 *  変数
    180167 */
    181168
     
    183170
    184171/*
    185  *  tcp_find_twcep -- ポート番号から Time Wait 用 TCP 通信端点を得る。
     172 *  tcp_find_twcep -- ポート番号から Time Wait 用 TCP 通信端点を得る。
    186173 *
    187  *    注意: dstaddr は、ネットワークバイトオーダ
     174 *    注意: dstaddr は、ネットワークバイトオーダ
    188175 */
    189176
     
    194181       
    195182        /*
    196          *  状æ
    197 ‹ãŒ TIME WAIT で、
    198          *  IP アドレスとポート番号が一致する通信端点を探索する。
     183         *  状態が TIME WAIT で、
     184         *  IP アドレスとポート番号が一致する通信端点を探索する。
    199185         */
    200186        for (twcep = &tcp_twcep[NUM_TCP_TW_CEP_ENTRY]; twcep -- != tcp_twcep; ) {
     
    211197
    212198/*
    213  *  å¿
    214 è¦ãªæƒ
    215 å ±ã‚’ Time Wait 用 TCP 通信端点に移して、
    216  *  標準の TCP 通信端点を開放する。
     199 *  必要な情報を Time Wait 用 TCP 通信端点に移して、
     200 *  標準の TCP 通信端点を開放する。
    217201 */
    218202
     
    222206        T_TCP_TWCEP*    twcep;
    223207
    224         /* 空きの Time Wait 用 TCP 通信端点を探索する。*/
     208        /* 空きの Time Wait 用 TCP 通信端点を探索する。*/
    225209        for (twcep = &tcp_twcep[NUM_TCP_TW_CEP_ENTRY]; twcep -- != tcp_twcep; ) {
    226210                if (twcep->fsm_state != TCP_FSM_TIME_WAIT) {
    227211
    228212                        /*
    229                          *  通信端点をロックし、
    230                          *  å¿
    231 è¦ãªæƒ
    232 å ±ã‚’ Time Wait 用 TCP 通信端点に移す。
     213                         *  通信端点をロックし、
     214                         *  必要な情報を Time Wait 用 TCP 通信端点に移す。
    233215                         */
    234216                        syscall(wai_sem(cep->semid_lock));
     
    242224                        twcep->timer_2msl       = cep->timer[TCP_TIM_2MSL];
    243225
    244                         /* 通信端点をロックを解除する。*/
     226                        /* 通信端点をロックを解除する。*/
    245227                        syscall(sig_sem(cep->semid_lock));
    246228
    247                         /* 標準 TCP 通信端点を開放する。*/
     229                        /* 標準 TCP 通信端点を開放する。*/
    248230                        tcp_close(cep);
    249231
     
    256238
    257239/*
    258  *  parse_option -- TCP ヘッダのオプションを解析する。
     240 *  parse_option -- TCP ヘッダのオプションを解析する。
    259241 */
    260242
     
    311293
    312294/*
    313  *  set_rexmt_timer -- 新しい往復時間を収集し、再送タイマを更新する。
     295 *  set_rexmt_timer -- 新しい往復時間を収集し、再送タイマを更新する。
    314296 */
    315297
     
    322304        if (cep->srtt != 0) {
    323305                /*
    324                  *  srtt: 平滑化された RTT
     306                 *  srtt: 平滑化された RTT
    325307                 *
    326                  *  計測された RTT (rtt) と現在の平滑化された RTT (srtt) の差 (delta) を求める。
     308                 *  計測された RTT (rtt) と現在の平滑化された RTT (srtt) の差 (delta) を求める。
    327309                 *
    328                  *  delta は 2 ビット左シフト ( 4 倍) した値で保持する。
    329                  *  srtt  は 5 ビット左シフト (32 倍) した値で保持されている。
     310                 *  delta は 2 ビット左シフト ( 4 倍) した値で保持する。
     311                 *  srtt  は 5 ビット左シフト (32 倍) した値で保持されている。
    330312                 *
    331313                 *    delta = rtt / 8 - srtt / 8
    332314                 *
    333                  *  新しい srtt は
     315                 *  新しい srtt は
    334316                 *
    335317                 *    srtt = rtt / 8 + srtt * 7 / 8
    336318                 *         = srtt + (rtt / 8 - srtt / 8)
    337319                 *
    338                  *  で計算する。
    339                  *  このため、rtt を 2 ビット左シフトし、srtt を (5 - 2) ビット右シフトして delta を求める。
     320                 *  で計算する。
     321                 *  このため、rtt を 2 ビット左シフトし、srtt を (5 - 2) ビット右シフトして delta を求める。
    340322                 */
    341323                delta = ((rtt - 1) << TCP_DELTA_SHIFT) - (cep->srtt >> (TCP_SRTT_SHIFT - TCP_DELTA_SHIFT));
     
    345327
    346328                /*
    347                  *  delta の絶対値 | delta | を求める。
     329                 *  delta の絶対値 | delta | を求める。
    348330                 */
    349331                if (delta < 0)
     
    351333
    352334                /*
    353                  *  rttvar: 平滑化された分散
     335                 *  rttvar: 平滑化された分散
    354336                 *
    355                  *  rttvar は 4 ビット左シフト (16 倍) した値で保持されている。
     337                 *  rttvar は 4 ビット左シフト (16 倍) した値で保持されている。
    356338                 *
    357339                 *    delta = |delta| / 4 - rttvar / 4
    358340                 *
    359                  *  新しい rttvar は
     341                 *  新しい rttvar は
    360342                 *
    361343                 *    rttvar = |delta|/ 4 + rttvar * 3 /4
    362344                 *           = rttvar + (|delta| / 4 - rttvar / 4)
    363345                 *
    364                  *  で計算する。
     346                 *  で計算する。
    365347                 */
    366348                delta -= cep->rttvar >> (TCP_RTTVAR_SHIFT - TCP_DELTA_SHIFT);
     
    371353        else {
    372354                /*
    373                  *  まだ srtt の設定が行われていないときは、今回計測された RTT を使用する。
    374                  *  平滑化された RTT (srtt) には、RTT を 5 ビット左シフト (32倍) した値。
    375                  *  平滑化された分散 (rttvar) には、RTT の 1/2 を 4 ビット左シフト (16倍) した値。
     355                 *  まだ srtt の設定が行われていないときは、今回計測された RTT を使用する。
     356                 *  平滑化された RTT (srtt) には、RTT を 5 ビット左シフト (32倍) した値。
     357                 *  平滑化された分散 (rttvar) には、RTT の 1/2 を 4 ビット左シフト (16倍) した値。
    376358                 */
    377359                cep->srtt   = rtt <<  TCP_SRTT_SHIFT;
     
    380362
    381363        /*
    382          *  rtt の測定を終了し、再送回数をリセットする。
     364         *  rtt の測定を終了し、再送回数をリセットする。
    383365         */
    384366        cep->rtt = cep->rxtshift = 0;
    385367
    386368        /*
    387          *  RTT に許される最小値 と rtt + 2 の大きな値の方を再送タイムアウトの最小値にする。
     369         *  RTT に許される最小値 と rtt + 2 の大きな値の方を再送タイムアウトの最小値にする。
    388370         */
    389371        if (rtt + 2 < TCP_TVAL_MIN)
     
    398380
    399381/*
    400  *  reassemble -- 受信セグメントを再構成する。順番通りに受信したときの処理
     382 *  reassemble -- 受信セグメントを再構成する。順番通りに受信したときの処理
    401383 */
    402384
     
    410392        if (tcph->sum > cep->rbufsz - cep->rwbuf_count) {
    411393                /*
    412                  *  受信ウィンドバッファに空きがないときは破棄する。
     394                 *  受信ウィンドバッファに空きがないときは破棄する。
    413395                 */
    414396                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DROP_SEGS], 1);
     
    421403                 cep->fsm_state == TCP_FSM_ESTABLISHED) {
    422404                /*
    423                  *  順番通りにセグメントを受信した時の処理
    424                  *  受信セグメントの並べ替えは不要なので
    425                  *  そのまま受信ウィンドバッファに書き込む。
     405                 *  順番通りにセグメントを受信した時の処理
     406                 *  受信セグメントの並べ替えは不要なので
     407                 *  そのまま受信ウィンドバッファに書き込む。
    426408                 */
    427409
     
    438420                qhdr = GET_TCP_Q_HDR(input, thoff);
    439421
    440                 /*  TCP ヘッダの位置を保存する。*/
     422                /*  TCP ヘッダの位置を保存する。*/
    441423                GET_TCP_IP_Q_HDR(input)->thoff = thoff;
    442424
    443                 /* SDU のオフセット(å
    444 ƒã¯ã‚¦ã‚£ãƒ³ãƒ‰ã‚µã‚¤ã‚ºï¼‰ã‚’リセットする。*/
     425                /* SDU のオフセット(元はウィンドサイズ)をリセットする。*/
    445426                qhdr->soff = 0;
    446427
    447                 /* データを受信ウィンドバッファに書き込む。*/
     428                /* データを受信ウィンドバッファに書き込む。*/
    448429                TCP_WRITE_RWBUF(cep, input, thoff);
    449430                }
     
    456437
    457438/*
    458  *  listening -- 受動オープンして,状æ
    459 ‹ãŒ LISTEN の処理
     439 *  listening -- 受動オープンして,状態が LISTEN の処理
    460440 *
    461  *    戻り値:
    462  *      RET_OK          正常
    463  *      RET_DROP        エラー、セグメントを破棄する。
    464  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     441 *    戻り値:
     442 *      RET_OK          正常
     443 *      RET_DROP        エラー、セグメントを破棄する。
     444 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    465445 */
    466446
     
    475455
    476456        /*
    477          *  フラグに RST がセットされていれば破棄する。
     457         *  フラグに RST がセットされていれば破棄する。
    478458         */
    479459        if (tcph->flags & TCP_FLG_RST)
     
    481461
    482462        /* 
    483          *  フラグに ACK がセットさてれいれば、
    484          *  リセットを送って破棄する。
     463         *  フラグに ACK がセットさてれいれば、
     464         *  リセットを送って破棄する。
    485465         */
    486466        if (tcph->flags & TCP_FLG_ACK)
     
    488468
    489469        /*
    490          *  フラグに SYN がセットされていなければれば破棄する。
     470         *  フラグに SYN がセットされていなければれば破棄する。
    491471         */
    492472        if ((tcph->flags & TCP_FLG_SYN) == 0)
     
    498478
    499479        /*
    500          *  次のときは破棄する。
    501          *    ・ポート番号が同一で、送受信 IP アドレス が同一。
    502          *      ただし、ローカルループバック (127.0.0.1) なら良い。
    503          *    ・マルチキャストアドレス
     480         *  次のときは破棄する。
     481         *    ・ポート番号が同一で、送受信 IP アドレス が同一。
     482         *      ただし、ローカルループバック (127.0.0.1) なら良い。
     483         *    ・マルチキャストアドレス
    504484         */
    505485
     
    511491
    512492        /*
    513          *  次のときは破棄する。
    514          *    ・ポート番号が同一で、送受信 IP アドレス が同一。
    515          *    ・マルチキャストアドレス
     493         *  次のときは破棄する。
     494         *    ・ポート番号が同一で、送受信 IP アドレス が同一。
     495         *    ・マルチキャストアドレス
    516496         */
    517497
     
    526506
    527507        /*
    528          *  次のときは破棄する。
    529          *    ・ポート番号が同一で、送受信 IP アドレス が同一。
    530          *    ・マルチキャストアドレス
     508         *  次のときは破棄する。
     509         *    ・ポート番号が同一で、送受信 IP アドレス が同一。
     510         *    ・マルチキャストアドレス
    531511         */
    532512
     
    539519                return RET_DROP;
    540520
    541         /* 相手のアドレスを記録する。*/
     521        /* 相手のアドレスを記録する。*/
    542522        IN_COPY_TO_HOST(&cep->dstaddr.ipaddr, &iph->src);
    543523        cep->dstaddr.portno = tcph->sport;
    544524
    545         /* オプションを処理する。*/
     525        /* オプションを処理する。*/
    546526        parse_option(tcph, cep);
    547527
    548         /* シーケンス番号を初期化する。*/
     528        /* シーケンス番号を初期化する。*/
    549529        if (tcp_iss == 0)
    550530                tcp_init_iss();
    551531
    552         /* 自分のシーケンス番号の初期値を記録する。*/
     532        /* 自分のシーケンス番号の初期値を記録する。*/
    553533        if (iss != 0)
    554534                cep->iss = iss;
     
    558538        tcp_iss += TCP_ISS_INCR() / 4;
    559539
    560         /* 相手のシーケンス番号の初期値を記録する。*/
     540        /* 相手のシーケンス番号の初期値を記録する。*/
    561541        cep->irs = tcph->seq;
    562542
    563         /* 送受信シーケンス番号を初期化する。*/
     543        /* 送受信シーケンス番号を初期化する。*/
    564544        init_send_seq(cep);
    565545        init_receive_seq(cep);
    566546
    567         /* 送信ウインドサイズを設定する。*/
     547        /* 送信ウインドサイズを設定する。*/
    568548        cep->snd_wnd = tcph->win;
    569549
    570         /* 最終設定 */
     550        /* 最終設定 */
    571551        cep->flags    |= TCP_CEP_FLG_ACK_NOW;
    572552        cep->fsm_state = TCP_FSM_SYN_RECVD;
     
    577557
    578558/*
    579  *  syn_sent -- 能動オープンして、状æ
    580 ‹ãŒ SYN 送信済の処理
     559 *  syn_sent -- 能動オープンして、状態が SYN 送信済の処理
    581560 *
    582  *    戻り値:
    583  *      RET_OK          正常
    584  *      RET_DROP        エラー、セグメントを破棄する。
    585  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     561 *    戻り値:
     562 *      RET_OK          正常
     563 *      RET_DROP        エラー、セグメントを破棄する。
     564 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    586565 */
    587566
     
    592571
    593572        /*
    594          *  相手から受信確認が送られて来ても、
     573         *  相手から受信確認が送られて来ても、
    595574         *
    596          *    ACK <= iss && 送信した最大 SEQ (snd_max) < ACK
     575         *    ACK <= iss && 送信した最大 SEQ (snd_max) < ACK
    597576         *
    598          *  なら、リセットを送ってセグメントを破棄する。
     577         *  なら、リセットを送ってセグメントを破棄する。
    599578         */
    600579        if ((tcph->flags & TCP_FLG_ACK) &&
     
    603582
    604583        /*
    605          *  RST/ACK フラグの応答があれば、ポートが開いていない
    606          *  ことを意味している。
     584         *  RST/ACK フラグの応答があれば、ポートが開いていない
     585         *  ことを意味している。
    607586         */
    608587        if (tcph->flags & TCP_FLG_RST) {
     
    615594
    616595        /*
    617          *  SYN フラグがなければセグメントを破棄する。
     596         *  SYN フラグがなければセグメントを破棄する。
    618597         */
    619598        if ((tcph->flags & TCP_FLG_SYN) == 0)
    620599                return RET_DROP;
    621600
    622         cep->snd_wnd = tcph->win;       /* snd_wnd: 相手の受信可能ウィンドサイズ  */
    623         cep->irs     = tcph->seq;       /* irs:     ç›¸æ‰‹ã®ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ç•ªå·ã®åˆæœŸå€¤  */
    624         init_receive_seq(cep);          /* 送受信シーケンス番号を初期化する。          */
     601        cep->snd_wnd = tcph->win;       /* snd_wnd: 相手の受信可能ウィンドサイズ      */
     602        cep->irs     = tcph->seq;       /* irs:     相手のシーケンス番号の初期値      */
     603        init_receive_seq(cep);          /* 送受信シーケンス番号を初期化する。            */
    625604
    626605        if (tcph->flags & TCP_FLG_ACK) {
    627606                /*
    628                  *  ACK フラグがあるときの処理
     607                 *  ACK フラグがあるときの処理
    629608                 *
    630                  *  受信を期å¾
    631 ã—ている最大の SEQ (rcv_adv) を
    632                  *  受信可能なウィンドサイズ (rcv_wnd) 分進める。
    633                  */
    634                 cep->rcv_adv += cep->rcv_wnd;   /* rcv_adv: 受信を期å¾
    635 ã—ている最大の SEQ       */
    636                                                 /* rcv_wnd: 受信可能なウィンドサイズ                */
    637 
    638                 /* 未確認の最小送信 SEQ (snd_una) を SYN 分 (1 オクテット) 進める。*/
     609                 *  受信を期待している最大の SEQ (rcv_adv) を
     610                 *  受信可能なウィンドサイズ (rcv_wnd) 分進める。
     611                 */
     612                cep->rcv_adv += cep->rcv_wnd;   /* rcv_adv: 受信を期待している最大の SEQ    */
     613                                                /* rcv_wnd: 受信可能なウィンドサイズ                */
     614
     615                /* 未確認の最小送信 SEQ (snd_una) を SYN 分 (1 オクテット) 進める。*/
    639616                cep->snd_una ++;
    640617
    641618#ifdef TCP_CFG_DELAY_ACK
    642619
    643                 if (tcph->sum != 0)             /* tcph->sum は SDU 長 */
     620                if (tcph->sum != 0)             /* tcph->sum は SDU 長 */
    644621                        cep->flags |= TCP_CEP_FLG_DEL_ACK;
    645622                else
     
    654631                if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
    655632                        /*
    656                          *  CEP で FIN 送信が要求されていれば、
    657                          *  切断処理を開始し、
    658                          *  CEP の状æ
    659 ‹ã‚’ FIN Wait 1 にする。
     633                         *  CEP で FIN 送信が要求されていれば、
     634                         *  切断処理を開始し、
     635                         *  CEP の状態を FIN Wait 1 にする。
    660636                         */
    661637                        cep->fsm_state = TCP_FSM_FIN_WAIT_1;
     
    665641                else {
    666642                        /*
    667                          *  相手から ACK が応答されたので、
    668                          *  CEP の状æ
    669 ‹ã‚’ コネクション開設完了状æ
    670 ‹ã«ã™ã‚‹ã€‚
     643                         *  相手から ACK が応答されたので、
     644                         *  CEP の状態を コネクション開設完了状態にする。
    671645                         */
    672646                        cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_IDLE;
     
    679653                        if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
    680654
    681                                 /* 相手のアドレスをコピーする。*/
     655                                /* 相手のアドレスをコピーする。*/
    682656                                *cep->p_dstaddr = cep->dstaddr;
    683657
     
    715689                }
    716690        else {
    717                 /* ACK フラグがないときは、ACK を送って、CEP の状æ
    718 ‹ã‚’ SYN 受信済みにする。*/
     691                /* ACK フラグがないときは、ACK を送って、CEP の状態を SYN 受信済みにする。*/
    719692                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    720693                cep->timer[TCP_TIM_REXMT] = 0;
     
    726699
    727700/*
    728  *  trim_length -- 受信した SDU 長を調整する。
     701 *  trim_length -- 受信した SDU 長を調整する。
    729702 */
    730703
     
    733706{
    734707        tcph->seq ++;
    735         if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
    736                 /*
    737                  *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
    738                  *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
     708        if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
     709                /*
     710                 *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
     711                 *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
    739712                 */
    740713                tcph->sum    = (uint16_t)cep->rcv_wnd;
    741714                tcph->flags &= ~TCP_FLG_FIN;
    742715                }
    743         cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
     716        cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
    744717
    745718#ifdef TCP_CFG_EXTENTIONS
    746         cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ */
     719        cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ     */
    747720#endif
    748721        }
    749722
    750723/*
    751  *  proc_ack2 -- ACK の処理 (2)
     724 *  proc_ack2 -- ACK の処理 (2)
    752725 *
    753  *    戻り値
     726 *    戻り値
    754727 *
    755  *      RET_OK          正常
    756  *      RET_RETURN      正常、リターンする。
    757  *      RET_DROP        エラー、セグメントを破棄する。
    758  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     728 *      RET_OK          正常
     729 *      RET_RETURN      正常、リターンする。
     730 *      RET_DROP        エラー、セグメントを破棄する。
     731 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    759732 */
    760733
     
    770743
    771744        /*
    772          *  相手に受信確認された ACK から、まだ確認されていない
    773          *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
    774          *  削除してよいオクテット数 (acked) になる。
     745         *  相手に受信確認された ACK から、まだ確認されていない
     746         *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
     747         *  削除してよいオクテット数 (acked) になる。
    775748         */
    776749        acked = tcph->ack - cep->snd_una;
     
    778751
    779752        /*
    780          *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
    781          *  後の ACK を受信したら、タイマバックオフをキャンセルし、
    782          *  再送タイマを再設定する。
     753         *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
     754         *  後の ACK を受信したら、タイマバックオフをキャンセルし、
     755         *  再送タイマを再設定する。
    783756         */
    784757        if (cep->rtt && SEQ_GT(tcph->ack, cep->rtseq)) {
     
    787760
    788761        /*
    789          *  å
    790 ¨ã¦ã®æœªç¢ºèªãƒ‡ãƒ¼ã‚¿ãŒ ACK されたら、再送タイマを停止し、
    791          *  再開を記憶する (さらに出力か持続)。
    792          *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
    793          *  現在の再送タイムアウトを設定する。
    794          */
    795         if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
     762         *  全ての未確認データが ACK されたら、再送タイマを停止し、
     763         *  再開を記憶する (さらに出力か持続)。
     764         *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
     765         *  現在の再送タイムアウトを設定する。
     766         */
     767        if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
    796768
    797769#ifdef TCP_CFG_SWBUF_CSAVE
    798770
    799771                /*
    800                  * 送信ウィンドバッファの省コピー機能が有効の場合は、
    801                  * 送信済みで、ACKが完了するまで再送タイマを変更しない。
     772                 * 送信ウィンドバッファの省コピー機能が有効の場合は、
     773                 * 送信済みで、ACKが完了するまで再送タイマを変更しない。
    802774                 */
    803775                if ((cep->flags & TCP_CEP_FLG_WBCS_MASK) == TCP_CEP_FLG_WBCS_ACKED)
     
    813785                }
    814786        else if (cep->timer[TCP_TIM_PERSIST] == 0) {
    815                 cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
    816                 }
    817 
    818         /* 相手が受信確認したデータがあるときの処理 */
     787                cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
     788                }
     789
     790        /* 相手が受信確認したデータがあるときの処理 */
    819791        if (acked) {
    820                 uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ   */
    821                 uint32_t incr = cep->maxseg;            /* cep->maxseg:   æœ€å¤§ã‚»ã‚°ãƒ¡ãƒ³ãƒˆã‚µã‚¤ã‚º        */
    822 
    823                 /*
    824                  *  新たに相手が受信確認したデータがあったときは、
    825                  *  輻輳ウィンドサイズを大きくする。
    826                  *  輻輳ウィンドサイズ (snd_cwnd) が
    827                  *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
    828                  *  輻輳回避制御を行い。
     792                uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ     */
     793                uint32_t incr = cep->maxseg;            /* cep->maxseg:   最大セグメントサイズ    */
     794
     795                /*
     796                 *  新たに相手が受信確認したデータがあったときは、
     797                 *  輻輳ウィンドサイズを大きくする。
     798                 *  輻輳ウィンドサイズ (snd_cwnd) が
     799                 *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
     800                 *  輻輳回避制御を行い。
    829801                 *
    830802                 *    snd_cwnd = snd_cwnd + maxseg * maxseg / snd_cwnd;
    831803                 *
    832                  *  等しいか小さいときは、スロースタート制御を行う。
     804                 *  等しいか小さいときは、スロースタート制御を行う。
    833805                 *
    834806                 *    snd_cwnd = snd_cwnd + maxseg
     
    836808                 */
    837809                if (cw > cep->snd_ssthresh)
    838                         /* 輻輳回避制御 */
     810                        /* 輻輳回避制御 */
    839811                        incr = incr * incr / cw;
    840812
     
    845817
    846818                /*
    847                  *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
     819                 *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
    848820                 */
    849821                if (acked > cep->swbuf_count) {
     
    858830                        }
    859831
    860                 /* 送信ウィンドバッファに空きができたことを知らせる。*/
     832                /* 送信ウィンドバッファに空きができたことを知らせる。*/
    861833                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
    862834
    863835                /*
    864                  *  送達確認されていない最小送信 SEQ (snd_una) を
    865                  *  今回送達確認された ACK まで進め、
    866                  *  次の送信データの SEQ (snd_nxt) も、新しい
    867                  *  送達確認されていない最小送信 SEQ (snd_una)
    868                  *  まで進める。
     836                 *  送達確認されていない最小送信 SEQ (snd_una) を
     837                 *  今回送達確認された ACK まで進め、
     838                 *  次の送信データの SEQ (snd_nxt) も、新しい
     839                 *  送達確認されていない最小送信 SEQ (snd_una)
     840                 *  まで進める。
    869841                 */
    870842                cep->snd_una += acked;
     
    873845
    874846                /*
    875                  *  状æ
    876 ‹ã«ã‚ˆã‚Šåˆ†å²
     847                 *  状態により分岐
    877848                 */
    878849                switch (cep->fsm_state) {
    879                 case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    880 ã¡ */
     850                case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    881851                        if (ourfinisacked) {
    882852                                cep->fsm_state = TCP_FSM_FIN_WAIT_2;
     
    884854                                }
    885855                        break;
    886                 case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK å¾
    887 ã¡ */
     856                case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK 待ち */
    888857                        if (ourfinisacked) {
    889858                                /*
    890                                  *  送信した FIN が確認されていれば状æ
    891 ‹ã‚’変更し、
    892                                  *  すべてのタイマをリセットした後、2MSL タイマを設定する。
     859                                 *  送信した FIN が確認されていれば状態を変更し、
     860                                 *  すべてのタイマをリセットした後、2MSL タイマを設定する。
    893861                                 */
    894862                                cep->fsm_state = TCP_FSM_TIME_WAIT;
     
    897865                                }
    898866                        break;
    899                 case TCP_FSM_LAST_ACK:          /* APP が終了、ACK å¾
    900 ã¡ */
     867                case TCP_FSM_LAST_ACK:          /* APP が終了、ACK 待ち */
    901868                        if (ourfinisacked) {
    902869                                /*
    903                                  *  送信した FIN が確認されていれば、cep をクローズし、
    904                                  *  セグメントを破棄する。
     870                                 *  送信した FIN が確認されていれば、cep をクローズし、
     871                                 *  セグメントを破棄する。
    905872                                 */
    906873                                cep = tcp_close(cep);
     
    908875                                }
    909876                        break;
    910                 case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    911 ã¡ */
     877                case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    912878                        /*
    913                          *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
    914                          *  ACK 送信後、セグメントを破棄する。
     879                         *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
     880                         *  ACK 送信後、セグメントを破棄する。
    915881                         */
    916882                        cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
     
    923889
    924890/*
    925  *  proc_ack1 -- ACK の処理 (1)
     891 *  proc_ack1 -- ACK の処理 (1)
    926892 *
    927  *    戻り値:
    928  *      RET_OK          正常
    929  *      RET_RETURN      正常、リターンする。
    930  *      RET_DROP        エラー、セグメントを破棄する。
    931  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     893 *    戻り値:
     894 *      RET_OK          正常
     895 *      RET_RETURN      正常、リターンする。
     896 *      RET_DROP        エラー、セグメントを破棄する。
     897 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    932898 *
    933899 */
     
    939905
    940906        switch (cep->fsm_state) {
    941         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    942 
    943                 /* 状æ
    944 ‹ã‚’変更する。*/
     907        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     908
     909                /* 状態を変更する。*/
    945910                if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
    946911                        cep->fsm_state  = TCP_FSM_FIN_WAIT_1;
     
    951916                        cep->fsm_state  = TCP_FSM_ESTABLISHED;
    952917
    953                         /* TCP 通信端点からTCP 受付口を解放する。*/
     918                        /* TCP 通信端点からTCP 受付口を解放する。*/
    954919                        cep->rep = NULL;
    955920
     
    960925                        if (cep->rcv_nblk_tfn == TFN_TCP_ACP_CEP) {
    961926
    962                                 /* 相手のアドレスをコピーする。*/
     927                                /* 相手のアドレスをコピーする。*/
    963928                                *cep->p_dstaddr = cep->dstaddr;
    964929
     
    996961                        if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
    997962
    998                                 /* 相手のアドレスをコピーする。*/
     963                                /* 相手のアドレスをコピーする。*/
    999964                                *cep->p_dstaddr = cep->dstaddr;
    1000965
     
    10441009
    10451010                /*
    1046                  *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
    1047                  */
    1048                 if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
     1011                 *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
     1012                 */
     1013                if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
    10491014                        tcph->flags = tcp_move_ra2rw(cep, tcph->flags);
    10501015               
    1051                 cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
    1052 
    1053                 /* break; 下に落ちる。*/
     1016                cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
     1017
     1018                /* break; 下に落ちる。*/
    10541019       
    1055         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
    1056         case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    1057         case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    1058 ã¡*/
    1059         case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    1060 ã¡             */
    1061         case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    1062 ã¡     */
    1063         case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    1064 ã¡     */
    1065         case TCP_FSM_TIME_WAIT:         /* 終了、時間å¾
    1066 ã¡             */
     1020        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
     1021        case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     1022        case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち*/
     1023        case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
     1024        case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     1025        case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
     1026        case TCP_FSM_TIME_WAIT:         /* 終了、時間待ち              */
    10671027
    10681028                if (SEQ_LE(tcph->ack, cep->snd_una)) {
    10691029
    10701030                        /*
    1071                          *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
    1072                          *  つまり、多重に ACK を受信したことを意味している。
     1031                         *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
     1032                         *  つまり、多重に ACK を受信したことを意味している。
    10731033                         */
    10741034
    1075                         if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
     1035                        if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
    10761036
    10771037                                /*
    1078                                  *  SDU がなく、相手のウィンドサイズが変更されていなければ、
    1079                                  *  すでに送信したセグメントの中で、ACK (tcph->ack) と
    1080                                  *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
    1081                                  *  この場合は、高速再転送と高速リカバリを行う。
     1038                                 *  SDU がなく、相手のウィンドサイズが変更されていなければ、
     1039                                 *  すでに送信したセグメントの中で、ACK (tcph->ack) と
     1040                                 *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
     1041                                 *  この場合は、高速再転送と高速リカバリを行う。
    10821042                                 */
    10831043                                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DUP_ACKS], 1);
     
    10861046
    10871047                                        /*
    1088                                          *  再送タイマがセットされていないとき、
    1089                                          *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
    1090                                          *  一致しないときは、多重 ACK 数を 0 にする。
     1048                                         *  再送タイマがセットされていないとき、
     1049                                         *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
     1050                                         *  一致しないときは、多重 ACK 数を 0 にする。
    10911051                                         */
    10921052                                        cep->dupacks = 0;
     
    10961056
    10971057                                        /*
    1098                                          *  多重 ACK 数がしきい値 (標準 3) になったら
    1099                                          *  高速再転送処理を開始する。
     1058                                         *  多重 ACK 数がしきい値 (標準 3) になったら
     1059                                         *  高速再転送処理を開始する。
    11001060                                         */
    11011061                                        uint_t          win;
    11021062
    11031063                                        /*
    1104                                          *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
     1064                                         *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
    11051065                                         *
    1106                                          *    相手の受信可能ウィンドサイズ (snd_wnd) か
    1107                                          *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
    1108                                          *    ただし、2 * maxseg 以上。
     1066                                         *    相手の受信可能ウィンドサイズ (snd_wnd) か
     1067                                         *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
     1068                                         *    ただし、2 * maxseg 以上。
    11091069                                         *
    11101070                                         */
     
    11171077                                        cep->snd_ssthresh = win * cep->maxseg;
    11181078
    1119                                         /* 再送タイマと往復時間をリセットする。*/
     1079                                        /* 再送タイマと往復時間をリセットする。*/
    11201080                                        cep->timer[TCP_TIM_REXMT] = 0;
    11211081                                        cep->rtt = 0;
    11221082
    1123                                         /* 消失したセグメントを送信する。*/
     1083                                        /* 消失したセグメントを送信する。*/
    11241084                                        cep->snd_old_nxt = cep->snd_nxt;
    11251085                                        cep->snd_nxt     = tcph->ack;
     
    11271087
    11281088                                        /*
    1129                                          *  snd_nxt をå
    1130 ƒã«æˆ»ã™ã‚ˆã†ã«è¨­å®šã—て
    1131                                          *  送信を指示する。
     1089                                         *  snd_nxt を元に戻すように設定して
     1090                                         *  送信を指示する。
    11321091                                         */
    11331092                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT |
     
    11371096                                        sig_sem(SEM_TCP_POST_OUTPUT);
    11381097
    1139                                         /* 輻輳ウィンドサイズを更新する。*/
     1098                                        /* 輻輳ウィンドサイズを更新する。*/
    11401099                                        cep->snd_cwnd = (uint16_t)(cep->snd_ssthresh
    11411100                                                           + cep->maxseg * cep->dupacks);
     
    11471106
    11481107                                        /*
    1149                                          *  多重 ACK 数がしきい値 (標準 3) をè¶
    1150 ãˆãŸã‚‰
    1151                                          *  輻輳ウィンドサイズを増加しながら再送する。
     1108                                         *  多重 ACK 数がしきい値 (標準 3) を超えたら
     1109                                         *  輻輳ウィンドサイズを増加しながら再送する。
    11521110                                         */
    11531111                                        cep->snd_cwnd += cep->maxseg;
    11541112
    1155                                         /* 送信を指示する。*/
     1113                                        /* 送信を指示する。*/
    11561114                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    11571115                                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    11661124
    11671125                /*
    1168                  *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
     1126                 *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
    11691127                 */
    11701128                if (cep->dupacks >= MAX_TCP_REXMT_THRESH && cep->snd_cwnd > cep->snd_ssthresh)
    11711129                        /*
    1172                          *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
     1130                         *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
    11731131                         */
    11741132                        cep->snd_cwnd = (uint16_t)cep->snd_ssthresh;
     
    11781136                if (SEQ_GT(tcph->ack, cep->snd_max))
    11791137                        /*
    1180                          *  受信した ACK が送信した最大 SEQ をè¶
    1181 ãˆã¦ã„たときの処理
     1138                         *  受信した ACK が送信した最大 SEQ を超えていたときの処理
    11821139                         */
    11831140                        return drop_after_ack(input, cep, thoff);
     
    11851142                if (cep->flags & TCP_CEP_FLG_NEED_SYN) {
    11861143                        /*
    1187                          *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
     1144                         *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
    11881145                         */
    11891146                        cep->flags &= ~TCP_CEP_FLG_NEED_SYN;
     
    11981155
    11991156/*
    1200  *  update_wnd -- ウィンドサイズを更新する。
     1157 *  update_wnd -- ウィンドサイズを更新する。
    12011158 *
    1202  *    戻り値: 送信がå¿
    1203 è¦ãªã‚‰ true を返す。
     1159 *    戻り値: 送信が必要なら true を返す。
    12041160 */
    12051161
     
    12091165
    12101166        /*
    1211          *  更新条件
     1167         *  更新条件
    12121168         *
    1213          *    ACK フラグがセットされている &&
    1214          *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
    1215          *     å‰å›žã‚¦ã‚£ãƒ³ãƒ‰ã‚’更新した SEQ (snd_wl1) が SEQ と同じ &&
    1216          *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
    1217          *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
    1218          *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
     1169         *    ACK フラグがセットされている &&
     1170         *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
     1171         *     前回ウィンドを更新した SEQ (snd_wl1) が SEQ と同じ &&
     1172         *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
     1173         *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
     1174         *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
    12191175         *       )
    12201176         *      )
     
    12321188
    12331189                if (cep->snd_wnd > cep->max_sndwnd)
    1234                         /* 今までの最大送信ウィンドサイズを更新する。*/
     1190                        /* 今までの最大送信ウィンドサイズを更新する。*/
    12351191                        cep->max_sndwnd = cep->snd_wnd;
    12361192
     
    12401196
    12411197                        /*
    1242                          *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
    1243                          *  相手の受信ウィンドが空くのをå¾
    1244 ã£ã¦ã„るときの処理
     1198                         *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
     1199                         *  相手の受信ウィンドが空くのを待っているときの処理
    12451200                         */
    12461201                        if (cep->snd_wnd > 0) {
    12471202
    12481203                                /*
    1249                                  *  相手の受信ウィンドが空いたときは、
    1250                                  *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
     1204                                 *  相手の受信ウィンドが空いたときは、
     1205                                 *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
    12511206                                 */
    12521207                                cep->flags = (cep->flags & ~TCP_CEP_FLG_WBCS_MASK)
     
    12651220
    12661221/*
    1267  *  proc_urg -- 緊急データつきのセグメントの処理
     1222 *  proc_urg -- 緊急データつきのセグメントの処理
    12681223 */
    12691224
     
    12761231            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    12771232
    1278                 /* 緊急データつきのセグメントの処理 */
     1233                /* 緊急データつきのセグメントの処理 */
    12791234
    12801235                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_URG_SEGS], 1);
     
    12821237
    12831238                        /*
    1284                          *  緊急ポインタの位置が受信ウィンドバッファの
    1285                          *  範囲をè¶
    1286 ãˆã‚‹ã¨ãã¯ä½•ã‚‚しない。
     1239                         *  緊急ポインタの位置が受信ウィンドバッファの
     1240                         *  範囲を超えるときは何もしない。
    12871241                         */
    12881242                        tcph->urp    = 0;
     
    12911245
    12921246                if (SEQ_GT(tcph->seq + tcph->urp, cep->rcv_up))
    1293                         /* 緊急ポインタが更新されたときの処理 */
     1247                        /* 緊急ポインタが更新されたときの処理 */
    12941248                        cep->rcv_up = tcph->seq + tcph->urp;
    12951249
    1296                 if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
     1250                if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
    12971251
    12981252                        /*
    1299                          *  緊急ポインタの位置が、今回受信したセグメントå†
    1300 ã®å ´åˆã¯ã€
    1301                          *  コールバック関数を呼び出す。
     1253                         *  緊急ポインタの位置が、今回受信したセグメント内の場合は、
     1254                         *  コールバック関数を呼び出す。
    13021255                         */
    13031256                        cep->urg_tcph = tcph;
     
    13221275
    13231276                        if (cep->urg_tcph != NULL) {
    1324                                 /* コールバック関数å†
    1325 ã§ tcp_rcv_oob() を呼出さなかった。*/
     1277                                /* コールバック関数内で tcp_rcv_oob() を呼出さなかった。*/
    13261278                                cep->urg_tcph = NULL;
    13271279                                tcph->urp = 0;
     
    13291281                        else {
    13301282                                /*
    1331                                  *  コールバック関数å†
    1332 ã§ tcp_rcv_oob() を呼出した時は、
    1333                                  *  SDU 長の補正値を設定する。
     1283                                 *  コールバック関数内で tcp_rcv_oob() を呼出した時は、
     1284                                 *  SDU 長の補正値を設定する。
    13341285                                 */
    13351286                                tcph->urp = 1;
     
    13581309
    13591310/*
    1360  *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
     1311 *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
    13611312 *
    1362  *    戻り値:
    1363  *      RET_RETURN      正常、リターンする。
    1364  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     1313 *    戻り値:
     1314 *      RET_RETURN      正常、リターンする。
     1315 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    13651316 */
    13661317
     
    13711322
    13721323        /*
    1373          *    SYN 受信状æ
    1374 ‹ã§ã€ACK が送達確認されていない最小送信 SEQ (snd_una) より
    1375          *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
    1376          *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
    1377          *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
     1324         *    SYN 受信状態で、ACK が送達確認されていない最小送信 SEQ (snd_una) より
     1325         *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
     1326         *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
     1327         *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
    13781328         */
    13791329        if (cep->fsm_state == TCP_FSM_SYN_RECVD && (tcph->flags & TCP_FLG_ACK) &&
     
    13841334        syscall(rel_net_buf(input));
    13851335
    1386         /* 送信を指示する。*/
     1336        /* 送信を指示する。*/
    13871337        cep->flags |=  TCP_CEP_FLG_ACK_NOW | TCP_CEP_FLG_POST_OUTPUT;
    13881338        sig_sem(SEM_TCP_POST_OUTPUT);
     
    13911341
    13921342/*
    1393  *  close_connection -- コネクション開放処理、相手から FIN を受信した。
     1343 *  close_connection -- コネクション開放処理、相手から FIN を受信した。
    13941344 */
    13951345
     
    14161366
    14171367        switch (cep->fsm_state) {
    1418         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    1419         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
     1368        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     1369        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
    14201370                cep->fsm_state = TCP_FSM_CLOSE_WAIT;
    14211371                break;
    14221372
    1423         case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    1424 ã¡ */
     1373        case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    14251374                cep->fsm_state = TCP_FSM_CLOSING;
    14261375                break;
    14271376
    1428         case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN å¾
    1429 ã¡ */
     1377        case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN 待ち */
    14301378                cep->fsm_state = TCP_FSM_TIME_WAIT;
    14311379                tcp_cancel_timers(cep);
     
    14331381
    14341382                /*
    1435                  *  FIN WAIT 2 状æ
    1436 ‹ã§ã¯ã€
    1437                  *  受信は可能であるが、すでに送信は終了している。
    1438                  *  相手の送信も終了したので、å
    1439 ¥åŠ›ã‚¿ã‚¹ã‚¯ã®ã¿èµ·åºŠã™ã‚‹ã€‚
     1383                 *  FIN WAIT 2 状態では、
     1384                 *  受信は可能であるが、すでに送信は終了している。
     1385                 *  相手の送信も終了したので、入力タスクのみ起床する。
    14401386                 */
    14411387                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
     
    14431389#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
    14441390
    1445                 /* 相手からの FIN に対して応答を返す。*/
     1391                /* 相手からの FIN に対して応答を返す。*/
    14461392                tcp_respond(NULL, cep, cep->rcv_nxt, cep->snd_una,
    14471393                            cep->rbufsz - cep->rwbuf_count, TCP_FLG_ACK);
     
    14501396
    14511397                /*
    1452                  *  å¿
    1453 è¦ãªæƒ
    1454 å ±ã‚’ Time Wait 用 TCP 通信端点に移して、
    1455                  *  標準の TCP 通信端点を開放する。
     1398                 *  必要な情報を Time Wait 用 TCP 通信端点に移して、
     1399                 *  標準の TCP 通信端点を開放する。
    14561400                 */
    14571401                tcp_move_twcep(cep);
     
    14611405                break;
    14621406
    1463         case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    1464 ã¡ */
     1407        case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    14651408                cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
    14661409                break;
     
    14691412
    14701413/*
    1471  *  tcp_input -- TCP のå
    1472 ¥åŠ›é–¢æ•°
     1414 *  tcp_input -- TCP の入力関数
    14731415 *
    1474  *      注意: input には IF ヘッダと IP ヘッダがå
    1475 ˆé ­ã«ã‚る。
     1416 *      注意: input には IF ヘッダと IP ヘッダが先頭にある。
    14761417 */
    14771418
     
    15001441        NET_COUNT_MIB(tcp_stats.tcpInSegs, 1);
    15011442
    1502         /* ヘッダ長をチェックする。*/
     1443        /* ヘッダ長をチェックする。*/
    15031444        if (input->len < IF_IP_TCP_HDR_SIZE) {
    15041445                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
     
    15091450        tcph = GET_TCP_HDR(input, *offp);
    15101451
    1511         seglen  = input->len - *offp;                           /* TCP のセグメント長 */
     1452        seglen  = input->len - *offp;                           /* TCP のセグメント長 */
    15121453
    15131454        if (IN_CKSUM(input, IPPROTO_TCP, *offp, (uint_t)seglen) != 0) {
     
    15161457                }
    15171458
    1518         /* TCP ヘッダ長をチェックする。*/
     1459        /* TCP ヘッダ長をチェックする。*/
    15191460        if (TCP_HDR_LEN(tcph->doff) < TCP_HDR_SIZE || TCP_HDR_LEN(tcph->doff) > seglen) {
    15201461                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
    15211462                goto drop;
    15221463                }
    1523         tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
    1524 
    1525         /*
    1526          *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
    1527          *  ただし、RFC1644 T/TCP 拡張機能と競合する。
     1464        tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
     1465
     1466        /*
     1467         *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
     1468         *  ただし、RFC1644 T/TCP 拡張機能と競合する。
    15281469         */
    15291470        if ((tcph->flags & (TCP_FLG_SYN | TCP_FLG_FIN)) == (TCP_FLG_SYN | TCP_FLG_FIN))
    15301471                goto drop;
    15311472
    1532         /* ネットワークオーダーからホストオーダーに変換する。*/
     1473        /* ネットワークオーダーからホストオーダーに変換する。*/
    15331474
    15341475        NTOHL(tcph->seq);
     
    15441485
    15451486        /*
    1546          *  状æ
    1547 ‹ãŒ Time Wait 中の CEP を探索する。
     1487         *  状態が Time Wait 中の CEP を探索する。
    15481488         */
    15491489        twcep = tcp_find_twcep(&iph->dst, tcph->dport, &iph->src, tcph->sport);
    15501490        if (twcep != NULL) {
    15511491
    1552                 if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
     1492                if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
    15531493                        goto drop;
    15541494                else {
    15551495
    15561496                        /*
    1557                          *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
    1558                          *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
    1559                          *    損失したことを意味しているので、ACK セグメントを再送する。
     1497                         *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
     1498                         *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
     1499                         *    損失したことを意味しているので、ACK セグメントを再送する。
    15601500                         */
    15611501
    1562                         /* ホストオーダーからネットワークオーダーに戻す。*/
     1502                        /* ホストオーダーからネットワークオーダーに戻す。*/
    15631503                        HTONS(tcph->sport);
    15641504                        HTONS(tcph->dport);
     
    15691509                }
    15701510        else
    1571                 /* 標準の TCP 通信端点を得る。*/
     1511                /* 標準の TCP 通信端点を得る。*/
    15721512                cep = tcp_find_cep(&iph->dst, tcph->dport, &iph->src, tcph->sport);
    15731513
    15741514#else   /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
    15751515
    1576         /* TCP 通信端点を得る。*/
     1516        /* TCP 通信端点を得る。*/
    15771517        cep = tcp_find_cep(&iph->dst, tcph->dport, &iph->src, tcph->sport);
    15781518
     
    15801520
    15811521        /*
    1582          *  TCP 通信端点がない場合と CEP の状æ
    1583 ‹ãŒã‚¯ãƒ­ãƒ¼ã‚ºãªã‚‰ç ´æ£„する。
     1522         *  TCP 通信端点がない場合と CEP の状態がクローズなら破棄する。
    15841523         */
    15851524        if (cep == NULL) {
     
    15991538
    16001539        /*
    1601          *  コネクション開設済みでセグメントを受信したときは、
    1602          *  アイドル時間と生存確認タイマをリセットする。
     1540         *  コネクション開設済みでセグメントを受信したときは、
     1541         *  アイドル時間と生存確認タイマをリセットする。
    16031542         */
    16041543        cep->idle = 0;
     
    16071546                }
    16081547
    1609         /* CEP の状æ
    1610 ‹ãŒ LISTEN 以外の時は、オプションを処理する。*/
     1548        /* CEP の状態が LISTEN 以外の時は、オプションを処理する。*/
    16111549        if (cep->fsm_state != TCP_FSM_LISTEN)
    16121550                parse_option(tcph, cep);
    16131551
    16141552        /*
    1615          *  受信可能ウィンドサイズを計算する。
     1553         *  受信可能ウィンドサイズを計算する。
    16161554         *
    1617          *  rcv_nxt:     å—信を期å¾
    1618 ã—ている最小の SEQ(これ以前は受信済み)
    1619          *  rcv_adv:     å—信を期å¾
    1620 ã—ている最大の SEQ
    1621          *  rbufsz:      受信ウィンドバッファサイズ
    1622          *  rwbuf_count:  受信ウィンドバッファにあるデータ量
    1623          *  tcph->sum:   ä»Šå›žå—信した SDU サイズ
     1555         *  rcv_nxt:     受信を期待している最小の SEQ(これ以前は受信済み)
     1556         *  rcv_adv:     受信を期待している最大の SEQ
     1557         *  rbufsz:      受信ウィンドバッファサイズ
     1558         *  rwbuf_count:  受信ウィンドバッファにあるデータ量
     1559         *  tcph->sum:   今回受信した SDU サイズ
    16241560         *
    1625          *  今回受信したセグメントを順序整列キューに連結する
    1626          *  可能性があるので tcph->sum を考æ
    1627 ®ã™ã‚‹ã€‚
     1561         *  今回受信したセグメントを順序整列キューに連結する
     1562         *  可能性があるので tcph->sum を考慮する。
    16281563         *
    16291564         */
     
    16361571                cep->rcv_wnd = cep->rcv_adv - cep->rcv_nxt;
    16371572
    1638         /* CEP の状æ
    1639 ‹ã«ã‚ˆã‚Šå‡¦ç†ã‚’行う。*/
    1640 
    1641         if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
     1573        /* CEP の状態により処理を行う。*/
     1574
     1575        if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
    16421576                if ((ret = listening(input, cep, *offp, iss)) == RET_RST_DROP)
    16431577                        goto reset_drop;
    16441578                else if (ret == RET_DROP)
    16451579                        goto drop;
    1646                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1647 
    1648                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1580                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1581
     1582                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    16491583                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    16501584                                goto drop;
     
    16551589                        }
    16561590                }
    1657         else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み        */
     1591        else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み      */
    16581592                if ((ret = syn_sent(tcph, cep)) == RET_RST_DROP)
    16591593                        goto reset_drop;
    16601594                else if (ret == RET_DROP)
    16611595                        goto drop;
    1662                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1663 
    1664                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1596                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1597
     1598                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    16651599                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    16661600                                goto drop;
     
    16721606                }
    16731607        else {
    1674                 if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
     1608                if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
    16751609                        /*
    1676                          *  相手から受信確認が送られて来ても、
     1610                         *  相手から受信確認が送られて来ても、
    16771611                         *
    1678                          *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
    1679                          *           é€ä¿¡ã—た最大     SEQ (snd_max) < ACK
     1612                         *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
     1613                         *           送信した最大     SEQ (snd_max) < ACK
    16801614                         *
    1681                          *  なら、リセットを送ってセグメントを破棄する。
     1615                         *  なら、リセットを送ってセグメントを破棄する。
    16821616                         */
    16831617                        if ((tcph->flags & TCP_FLG_ACK) &&
     
    16881622
    16891623                /*
    1690                  *  RST フラグを受信したときの処理 (異常切断)
     1624                 *  RST フラグを受信したときの処理 (異常切断)
    16911625                 */
    16921626                if (tcph->flags & TCP_FLG_RST) {
     
    16941628                            SEQ_LT(tcph->seq, cep->last_ack_sent + cep->rcv_wnd)) {
    16951629                                /*
    1696                                  *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
    1697                                  *  から、受信ウインドウサイズまでの間の処理
     1630                                 *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
     1631                                 *  から、受信ウインドウサイズまでの間の処理
    16981632                                 */
    16991633                                switch (cep->fsm_state) {
    1700                                 case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み          */
    1701 
    1702                                         cep->net_error = EV_CNNRF;      /* 接続不能 */
     1634                                case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み            */
     1635
     1636                                        cep->net_error = EV_CNNRF;      /* 接続不能 */
    17031637                                        cep->error     = E_CLS;
    17041638                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
     
    17071641                                        break;
    17081642
    1709                                 case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                       */
    1710                                 case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    1711 ã¡             */
     1643                                case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                   */
     1644                                case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
    17121645                                        NET_COUNT_MIB(tcp_stats.tcpEstabResets, 1);
    17131646                                        /* fallthrough */
    17141647
    1715                                 case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    1716                                 case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    1717 ã¡     */
    1718 
    1719                                         cep->net_error = EV_CNRST;      /* 接続リセット */
     1648                                case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     1649                                case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち  */
     1650
     1651                                        cep->net_error = EV_CNRST;      /* 接続リセット */
    17201652                                        cep->error     = E_CLS;
    17211653                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
    17221654                                        /* no break; */
    17231655
    1724                                 case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    1725 ã¡     */
    1726                                 case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    1727 ã¡     */
     1656                                case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     1657                                case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
    17281658
    17291659                                        cep = tcp_close(cep);
     
    17351665
    17361666                /*
    1737                  *  CEP の状æ
    1738 ‹ãŒ SYN を受信し、SYN 送信済みの場合は、
    1739                  *  受信ウィンドに収まるようにデータを
    1740                  *  調整する前に、この接続によるパケットかどうかを検証する。
     1667                 *  CEP の状態が SYN を受信し、SYN 送信済みの場合は、
     1668                 *  受信ウィンドに収まるようにデータを
     1669                 *  調整する前に、この接続によるパケットかどうかを検証する。
    17411670                 *
    1742                  *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
     1671                 *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
    17431672                 *
    1744                  *  これは、"LAND" DoS 攻撃の防御である。
     1673                 *  これは、"LAND" DoS 攻撃の防御である。
    17451674                 */
    17461675                if (cep->fsm_state == TCP_FSM_SYN_RECVD && SEQ_LT(tcph->seq, cep->irs)) {
     
    17491678
    17501679                /*
    1751                  *  受信を期å¾
    1752 ã—ている最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
    1753                  *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
    1754                  *  削除する。
     1680                 *  受信を期待している最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
     1681                 *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
     1682                 *  削除する。
    17551683                 *                           <---------- rcv_wnd --------->
    17561684                 *                           rcv_nxt                      rcv_nxt + rcv_wnd
     
    17641692                 *           ^                      ^
    17651693                 *           seq                    seq + len
    1766                  *           <---------------> 削除する。
     1694                 *           <---------------> 削除する。
    17671695                 */
    17681696                todrop = cep->rcv_nxt - tcph->seq;
     
    17701698
    17711699                        /*
    1772                          *  SYN フラグがついているときは、その分 (1 オクテット)
    1773                          *  SEQ を進め、緊急ポインタと削除する長さを調整する。
     1700                         *  SYN フラグがついているときは、その分 (1 オクテット)
     1701                         *  SEQ を進め、緊急ポインタと削除する長さを調整する。
    17741702                         */
    17751703                        if (tcph->flags & TCP_FLG_SYN) {
     
    17841712
    17851713                        /*
    1786                          *  削除する長さが SDU より長い、つまり、受信を期å¾
    1787 ã—ている
    1788                          *  最小の SEQ (rcv_nxt) に達していないか、
    1789                          *  削除する長さが SDU と同じで、FIN フラグがついてなければ
    1790                          *  å
    1791 ¨ã¦å‰Šé™¤ã™ã‚‹ã€‚
     1714                         *  削除する長さが SDU より長い、つまり、受信を期待している
     1715                         *  最小の SEQ (rcv_nxt) に達していないか、
     1716                         *  削除する長さが SDU と同じで、FIN フラグがついてなければ
     1717                         *  全て削除する。
    17921718                         */
    1793                         if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
     1719                        if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
    17941720                            (todrop == tcph->sum && (tcph->flags & TCP_FLG_FIN) == 0)) {
    17951721                                tcph->flags &= ~TCP_FLG_FIN;
    17961722                                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    1797                                 todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
     1723                                todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
    17981724                                }
    17991725
    18001726                        /*
    1801                          *  SDU を前に詰める。
     1727                         *  SDU を前に詰める。
    18021728                         */
    1803                         if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
     1729                        if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
    18041730                                memcpy(GET_TCP_SDU(input, *offp),
    18051731                                       GET_TCP_SDU(input, *offp) + todrop, (size_t)(tcph->sum - todrop));
     
    18071733
    18081734                        /*
    1809                          *  SEQ と SDU 長を調整する。
     1735                         *  SEQ と SDU 長を調整する。
    18101736                         */
    18111737                        tcph->seq +=     todrop;
    1812                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1738                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    18131739
    18141740                        /*
    1815                          *  緊急ポインタを調整する。
     1741                         *  緊急ポインタを調整する。
    18161742                         */
    18171743                        if (tcph->urp > todrop)
     
    18261752
    18271753                /* 
    1828                  *  もしユーザタスクが終了した後に、データを受信した
    1829                  *  場合は、RST を送る。
    1830                  */
    1831                 if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
     1754                 *  もしユーザタスクが終了した後に、データを受信した
     1755                 *  場合は、RST を送る。
     1756                 */
     1757                if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
    18321758                        cep = tcp_close(cep);
    18331759                        goto reset_drop;
     
    18351761
    18361762                /*
    1837                  *  受信セグメントが受信ウィンドをè¶
    1838 ãˆã‚‹å ´åˆã¯ã€
    1839                  *  è¶
    1840 ãˆãŸåˆ†ã‚’削る。
     1763                 *  受信セグメントが受信ウィンドを超える場合は、
     1764                 *  超えた分を削る。
    18411765                 *
    18421766                 *       <---------- rcv_wnd --------->
     
    18511775                 *                    ^                      ^
    18521776                 *                    seq                    seq + len
    1853                  *                                     <-----> 削除する。
    1854                  */
    1855                 todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
     1777                 *                                     <-----> 削除する。
     1778                 */
     1779                todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
    18561780                if (todrop > 0) {
    1857                         if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
     1781                        if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
    18581782                                /*
    1859                                  *  受信した SDU のå
    1860 ¨ã¦ãŒå—信ウィンドをè¶
    1861 ãˆã‚‹å ´åˆã€‚
     1783                                 *  受信した SDU の全てが受信ウィンドを超える場合。
    18621784                                 *
    1863                                  *  TIME_WAIT 中に、新たな接続要求を受信したら
    1864                                  *  古い接続を破棄し、新たな接続を開始する。
    1865                                  *  ただし、SEQ は前より進んでいなければならない。
     1785                                 *  TIME_WAIT 中に、新たな接続要求を受信したら
     1786                                 *  古い接続を破棄し、新たな接続を開始する。
     1787                                 *  ただし、SEQ は前より進んでいなければならない。
    18661788                                 */
    18671789                                if ((tcph->flags & TCP_FLG_SYN) &&
     
    18751797
    18761798                                /*
    1877                                  *  受信ウィンドが 0 で、受信した SEQ と
    1878                                  *  受信を期å¾
    1879 ã—ている最小の SEQ が一致したときは
    1880                                  *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
     1799                                 *  受信ウィンドが 0 で、受信した SEQ と
     1800                                 *  受信を期待している最小の SEQ が一致したときは
     1801                                 *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
    18811802                                 */
    18821803                                if (cep->rcv_wnd == 0 && (tcph->seq == cep->rcv_nxt || tcph->sum == 0)) {
     
    18891810                                        }
    18901811                                }
    1891                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1812                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    18921813                        tcph->flags &= ~(TCP_FLG_PUSH | TCP_FLG_FIN);
    18931814                        }
    18941815
    18951816                /*
    1896                  *  もし、SYN がセットされていれば、
    1897                  *  エラーなので RST を送り、接続を破棄する。
     1817                 *  もし、SYN がセットされていれば、
     1818                 *  エラーなので RST を送り、接続を破棄する。
    18981819                 */
    18991820                if (tcph->flags & TCP_FLG_SYN) {
     
    19041825
    19051826                /*
    1906                  *  もし、ACK がセットされていない場合は、
    1907                  *  状æ
    1908 ‹ãŒ SYN 受信済みか
    1909                  *  SYN を送信しようとしていれば、処理を続けるが、
    1910                  *  それ以外はセグメントを破棄して終了する。
     1827                 *  もし、ACK がセットされていない場合は、
     1828                 *  状態が SYN 受信済みか
     1829                 *  SYN を送信しようとしていれば、処理を続けるが、
     1830                 *  それ以外はセグメントを破棄して終了する。
    19111831                 */
    19121832                if ((tcph->flags & TCP_FLG_ACK) == 0) {
     
    19161836                else {
    19171837                        /*
    1918                          * ACK の処理
     1838                         * ACK の処理
    19191839                         */
    19201840                        ret = proc_ack1(input, cep, *offp, &needoutput);
     
    19301850/* step 6 */
    19311851
    1932         /* 送信ウィンドを更新する。*/
     1852        /* 送信ウィンドを更新する。*/
    19331853        if (update_wnd(tcph, cep) == true)
    19341854                needoutput = true;
    19351855
    1936         /* 緊急データを処理する。*/
     1856        /* 緊急データを処理する。*/
    19371857        proc_urg(tcph, cep);
    19381858
     
    19401860
    19411861        /*
    1942          *  SDU があるか、FIN を未受信の状æ
    1943 ‹ã§ã€æœ€åˆã« FIN を受信したとき、
    1944          *  受信セグメントキューに net_buf を追加する。
    1945          *  それ以外の場合は、セグメントを破棄する。
     1862         *  SDU があるか、FIN を未受信の状態で、最初に FIN を受信したとき、
     1863         *  受信セグメントキューに net_buf を追加する。
     1864         *  それ以外の場合は、セグメントを破棄する。
    19461865         */
    19471866        flags = tcph->flags;
    1948         if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
     1867        if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
    19491868            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    19501869                flags = reassemble(input, cep, *offp, flags);
     
    19561875
    19571876        /*
    1958          *  FIN を受信したらコネクションをクローズする。
     1877         *  FIN を受信したらコネクションをクローズする。
    19591878         */
    19601879        if (flags & TCP_FLG_FIN)
    19611880                close_connection(cep, &needoutput);
    19621881
    1963         /* 出力を行った後終了する。*/
     1882        /* 出力を行った後終了する。*/
    19641883        if (needoutput == true || (cep->flags & TCP_CEP_FLG_ACK_NOW)) {
    1965                 /* 送信を指示する。*/
     1884                /* 送信を指示する。*/
    19661885                cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    19671886                sig_sem(SEM_TCP_POST_OUTPUT);
     
    19721891reset_drop:
    19731892        /*
    1974          *  RST 送信処理
     1893         *  RST 送信処理
    19751894         */
    19761895
     
    19781897                goto drop;
    19791898
    1980         /* ホストオーダーからネットワークオーダーに戻す。*/
     1899        /* ホストオーダーからネットワークオーダーに戻す。*/
    19811900
    19821901        HTONS(tcph->sport);
     
    19931912        else {
    19941913                if (tcph->flags & TCP_FLG_SYN)
    1995                         tcph->sum ++;           /* tcph->sum は SDU 長 */
     1914                        tcph->sum ++;           /* tcph->sum は SDU 長 */
    19961915                tcp_respond(input, cep, tcph->seq + tcph->sum, 0, rbfree, TCP_FLG_RST | TCP_FLG_ACK);
    19971916                }
    19981917
    1999         /* input は tcp_respoond で返却される。*/
     1918        /* input は tcp_respoond で返却される。*/
    20001919        NET_COUNT_TCP(net_count_tcp[NC_TCP_SEND_RSTS], 1);
    20011920        NET_COUNT_MIB(tcp_stats.tcpOutRsts, 1);
Note: See TracChangeset for help on using the changeset viewer.