Ignore:
Timestamp:
May 22, 2019, 10:03:37 PM (5 years ago)
Author:
coas-nagasima
Message:

ビルドが通るよう更新

File:
1 edited

Legend:

Unmodified
Added
Removed
  • azure_iot_hub/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
    r388 r389  
    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$
     
    128116
    129117/*
    130  *  戻り値
     118 *  戻り値
    131119 *
    132  *      RET_OK          正常
    133  *      RET_DROP        エラー、セグメントを破棄する。
    134  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     120 *      RET_OK          正常
     121 *      RET_DROP        エラー、セグメントを破棄する。
     122 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    135123 */
    136124
     
    142130
    143131/*
    144  *  関数
     132 *  関数
    145133 */
    146134
     
    159147
    160148/*
    161  *  parse_option -- TCP ヘッダのオプションを解析する。
     149 *  parse_option -- TCP ヘッダのオプションを解析する。
    162150 */
    163151
     
    214202
    215203/*
    216  *  set_rexmt_timer -- 新しい往復時間を収集し、再送タイマを更新する。
     204 *  set_rexmt_timer -- 新しい往復時間を収集し、再送タイマを更新する。
    217205 */
    218206
     
    225213        if (cep->srtt != 0) {
    226214                /*
    227                  *  srtt: 平滑化された RTT
     215                 *  srtt: 平滑化された RTT
    228216                 *
    229                  *  計測された RTT (rtt) と現在の平滑化された RTT (srtt) の差 (delta) を求める。
     217                 *  計測された RTT (rtt) と現在の平滑化された RTT (srtt) の差 (delta) を求める。
    230218                 *
    231                  *  delta は 2 ビット左シフト ( 4 倍) した値で保持する。
    232                  *  srtt  は 5 ビット左シフト (32 倍) した値で保持されている。
     219                 *  delta は 2 ビット左シフト ( 4 倍) した値で保持する。
     220                 *  srtt  は 5 ビット左シフト (32 倍) した値で保持されている。
    233221                 *
    234222                 *    delta = rtt / 8 - srtt / 8
    235223                 *
    236                  *  新しい srtt は
     224                 *  新しい srtt は
    237225                 *
    238226                 *    srtt = rtt / 8 + srtt * 7 / 8
    239227                 *         = srtt + (rtt / 8 - srtt / 8)
    240228                 *
    241                  *  で計算する。
    242                  *  このため、rtt を 2 ビット左シフトし、srtt を (5 - 2) ビット右シフトして delta を求める。
     229                 *  で計算する。
     230                 *  このため、rtt を 2 ビット左シフトし、srtt を (5 - 2) ビット右シフトして delta を求める。
    243231                 */
    244232                delta = ((rtt - 1) << TCP_DELTA_SHIFT) - (cep->srtt >> (TCP_SRTT_SHIFT - TCP_DELTA_SHIFT));
     
    248236
    249237                /*
    250                  *  delta の絶対値 | delta | を求める。
     238                 *  delta の絶対値 | delta | を求める。
    251239                 */
    252240                if (delta < 0)
     
    254242
    255243                /*
    256                  *  rttvar: 平滑化された分散
     244                 *  rttvar: 平滑化された分散
    257245                 *
    258                  *  rttvar は 4 ビット左シフト (16 倍) した値で保持されている。
     246                 *  rttvar は 4 ビット左シフト (16 倍) した値で保持されている。
    259247                 *
    260248                 *    delta = |delta| / 4 - rttvar / 4
    261249                 *
    262                  *  新しい rttvar は
     250                 *  新しい rttvar は
    263251                 *
    264252                 *    rttvar = |delta|/ 4 + rttvar * 3 /4
    265253                 *           = rttvar + (|delta| / 4 - rttvar / 4)
    266254                 *
    267                  *  で計算する。
     255                 *  で計算する。
    268256                 */
    269257                delta -= cep->rttvar >> (TCP_RTTVAR_SHIFT - TCP_DELTA_SHIFT);
     
    274262        else {
    275263                /*
    276                  *  まだ srtt の設定が行われていないときは、今回計測された RTT を使用する。
    277                  *  平滑化された RTT (srtt) には、RTT を 5 ビット左シフト (32倍) した値。
    278                  *  平滑化された分散 (rttvar) には、RTT の 1/2 を 4 ビット左シフト (16倍) した値。
     264                 *  まだ srtt の設定が行われていないときは、今回計測された RTT を使用する。
     265                 *  平滑化された RTT (srtt) には、RTT を 5 ビット左シフト (32倍) した値。
     266                 *  平滑化された分散 (rttvar) には、RTT の 1/2 を 4 ビット左シフト (16倍) した値。
    279267                 */
    280268                cep->srtt   = rtt <<  TCP_SRTT_SHIFT;
     
    283271
    284272        /*
    285          *  rtt の測定を終了し、再送回数をリセットする。
     273         *  rtt の測定を終了し、再送回数をリセットする。
    286274         */
    287275        cep->rtt = cep->rxtshift = 0;
    288276
    289277        /*
    290          *  RTT に許される最小値 と rtt + 2 の大きな値の方を再送タイムアウトの最小値にする。
     278         *  RTT に許される最小値 と rtt + 2 の大きな値の方を再送タイムアウトの最小値にする。
    291279         */
    292280        if (rtt + 2 < TCP_TVAL_MIN)
     
    301289
    302290/*
    303  *  reassemble -- 受信セグメントを再構成する。順番通りに受信したときの処理
     291 *  reassemble -- 受信セグメントを再構成する。順番通りに受信したときの処理
    304292 */
    305293
     
    313301        if (tcph->sum > cep->rbufsz - cep->rwbuf_count) {
    314302                /*
    315                  *  受信ウィンドバッファに空きがないときは破棄する。
     303                 *  受信ウィンドバッファに空きがないときは破棄する。
    316304                 */
    317305                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DROP_SEGS], 1);
     
    324312                 cep->fsm_state == TCP_FSM_ESTABLISHED) {
    325313                /*
    326                  *  順番通りにセグメントを受信した時の処理
    327                  *  受信セグメントの並べ替えは不要なので
    328                  *  そのまま受信ウィンドバッファに書き込む。
     314                 *  順番通りにセグメントを受信した時の処理
     315                 *  受信セグメントの並べ替えは不要なので
     316                 *  そのまま受信ウィンドバッファに書き込む。
    329317                 */
    330318
     
    341329                qhdr = GET_TCP_Q_HDR(input, thoff);
    342330
    343                 /*  TCP ヘッダの位置を保存する。*/
     331                /*  TCP ヘッダの位置を保存する。*/
    344332                SET_IP_TCP_Q_HDR_OFFSET(input, thoff);
    345333
    346                 /* SDU のオフセット(å
    347 ƒã¯ã‚¦ã‚£ãƒ³ãƒ‰ã‚µã‚¤ã‚ºï¼‰ã‚’リセットする。*/
     334                /* SDU のオフセット(元はウィンドサイズ)をリセットする。*/
    348335                qhdr->soff = 0;
    349336
    350                 /* データを受信ウィンドバッファに書き込む。*/
     337                /* データを受信ウィンドバッファに書き込む。*/
    351338                TCP_WRITE_RWBUF(cep, input, thoff);
    352339                }
     
    359346
    360347/*
    361  *  listening -- 受動オープンして,状æ
    362 ‹ãŒ LISTEN の処理
     348 *  listening -- 受動オープンして,状態が LISTEN の処理
    363349 *
    364  *    戻り値:
    365  *      RET_OK          正常
    366  *      RET_DROP        エラー、セグメントを破棄する。
    367  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     350 *    戻り値:
     351 *      RET_OK          正常
     352 *      RET_DROP        エラー、セグメントを破棄する。
     353 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    368354 */
    369355
     
    376362
    377363        /*
    378          *  フラグに RST がセットされていれば破棄する。
     364         *  フラグに RST がセットされていれば破棄する。
    379365         */
    380366        if (tcph->flags & TCP_FLG_RST)
     
    382368
    383369        /* 
    384          *  フラグに ACK がセットさてれいれば、
    385          *  リセットを送って破棄する。
     370         *  フラグに ACK がセットさてれいれば、
     371         *  リセットを送って破棄する。
    386372         */
    387373        if (tcph->flags & TCP_FLG_ACK)
     
    389375
    390376        /*
    391          *  フラグに SYN がセットされていなければれば破棄する。
     377         *  フラグに SYN がセットされていなければれば破棄する。
    392378         */
    393379        if ((tcph->flags & TCP_FLG_SYN) == 0)
     
    395381
    396382        /*
    397          *  受信可能な IP アドレスとポート番号であることを確認する。
     383         *  受信可能な IP アドレスとポート番号であることを確認する。
    398384         */
    399385        if (!tcp_is_addr_accept(input, thoff))
    400386                return RET_DROP;
    401387
    402         /* 相手のアドレスを記録する。*/
     388        /* 相手のアドレスを記録する。*/
    403389        IN_COPY_TO_HOST(&cep->dstaddr.ipaddr, input);
    404390        cep->dstaddr.portno = tcph->sport;
    405391
    406         /* オプションを処理する。*/
     392        /* オプションを処理する。*/
    407393        parse_option(tcph, cep);
    408394
    409         /* シーケンス番号を初期化する。*/
     395        /* シーケンス番号を初期化する。*/
    410396        if (tcp_iss == 0)
    411397                tcp_init_iss();
    412398
    413         /* 自分のシーケンス番号の初期値を記録する。*/
     399        /* 自分のシーケンス番号の初期値を記録する。*/
    414400        if (iss != 0)
    415401                cep->iss = iss;
     
    419405        tcp_iss += TCP_ISS_INCR() / 4;
    420406
    421         /* 相手のシーケンス番号の初期値を記録する。*/
     407        /* 相手のシーケンス番号の初期値を記録する。*/
    422408        cep->irs = tcph->seq;
    423409
    424         /* 送受信シーケンス番号を初期化する。*/
     410        /* 送受信シーケンス番号を初期化する。*/
    425411        init_send_seq(cep);
    426412        init_receive_seq(cep);
    427413
    428         /* 送信ウインドサイズを設定する。*/
     414        /* 送信ウインドサイズを設定する。*/
    429415        cep->snd_wnd = tcph->win;
    430416
    431         /* 最終設定 */
     417        /* 最終設定 */
    432418        cep->flags    |= TCP_CEP_FLG_ACK_NOW;
    433419        cep->fsm_state = TCP_FSM_SYN_RECVD;
     
    438424
    439425/*
    440  *  syn_sent -- 能動オープンして、状æ
    441 ‹ãŒ SYN 送信済の処理
     426 *  syn_sent -- 能動オープンして、状態が SYN 送信済の処理
    442427 *
    443  *    戻り値:
    444  *      RET_OK          正常
    445  *      RET_DROP        エラー、セグメントを破棄する。
    446  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     428 *    戻り値:
     429 *      RET_OK          正常
     430 *      RET_DROP        エラー、セグメントを破棄する。
     431 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    447432 */
    448433
     
    453438
    454439        /*
    455          *  相手から受信確認が送られて来ても、
     440         *  相手から受信確認が送られて来ても、
    456441         *
    457          *    ACK <= iss && 送信した最大 SEQ (snd_max) < ACK
     442         *    ACK <= iss && 送信した最大 SEQ (snd_max) < ACK
    458443         *
    459          *  なら、リセットを送ってセグメントを破棄する。
     444         *  なら、リセットを送ってセグメントを破棄する。
    460445         */
    461446        if ((tcph->flags & TCP_FLG_ACK) &&
     
    464449
    465450        /*
    466          *  RST/ACK フラグの応答があれば、ポートが開いていない
    467          *  ことを意味している。
     451         *  RST/ACK フラグの応答があれば、ポートが開いていない
     452         *  ことを意味している。
    468453         */
    469454        if (tcph->flags & TCP_FLG_RST) {
     
    476461
    477462        /*
    478          *  SYN フラグがなければセグメントを破棄する。
     463         *  SYN フラグがなければセグメントを破棄する。
    479464         */
    480465        if ((tcph->flags & TCP_FLG_SYN) == 0)
    481466                return RET_DROP;
    482467
    483         cep->snd_wnd = tcph->win;       /* snd_wnd: 相手の受信可能ウィンドサイズ  */
    484         cep->irs     = tcph->seq;       /* irs:     ç›¸æ‰‹ã®ã‚·ãƒ¼ã‚±ãƒ³ã‚¹ç•ªå·ã®åˆæœŸå€¤  */
    485         init_receive_seq(cep);          /* 送受信シーケンス番号を初期化する。          */
     468        cep->snd_wnd = tcph->win;       /* snd_wnd: 相手の受信可能ウィンドサイズ      */
     469        cep->irs     = tcph->seq;       /* irs:     相手のシーケンス番号の初期値      */
     470        init_receive_seq(cep);          /* 送受信シーケンス番号を初期化する。            */
    486471
    487472        if (tcph->flags & TCP_FLG_ACK) {
    488473                /*
    489                  *  ACK フラグがあるときの処理
     474                 *  ACK フラグがあるときの処理
    490475                 *
    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 オクテット) 進める。*/
     476                 *  受信を期待している最大の SEQ (rcv_adv) を
     477                 *  受信可能なウィンドサイズ (rcv_wnd) 分進める。
     478                 */
     479                cep->rcv_adv += cep->rcv_wnd;   /* rcv_adv: 受信を期待している最大の SEQ    */
     480                                                /* rcv_wnd: 受信可能なウィンドサイズ                */
     481
     482                /* 未確認の最小送信 SEQ (snd_una) を SYN 分 (1 オクテット) 進める。*/
    500483                cep->snd_una ++;
    501484
    502485#ifdef TCP_CFG_DELAY_ACK
    503486
    504                 if (tcph->sum != 0)             /* tcph->sum は SDU 長 */
     487                if (tcph->sum != 0)             /* tcph->sum は SDU 長 */
    505488                        cep->flags |= TCP_CEP_FLG_DEL_ACK;
    506489                else
     
    515498                if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
    516499                        /*
    517                          *  CEP で FIN 送信が要求されていれば、
    518                          *  切断処理を開始し、
    519                          *  CEP の状æ
    520 ‹ã‚’ FIN Wait 1 にする。
     500                         *  CEP で FIN 送信が要求されていれば、
     501                         *  切断処理を開始し、
     502                         *  CEP の状態を FIN Wait 1 にする。
    521503                         */
    522504                        cep->fsm_state = TCP_FSM_FIN_WAIT_1;
     
    526508                else {
    527509                        /*
    528                          *  相手から ACK が応答されたので、
    529                          *  CEP の状æ
    530 ‹ã‚’ コネクション開設完了状æ
    531 ‹ã«ã™ã‚‹ã€‚
     510                         *  相手から ACK が応答されたので、
     511                         *  CEP の状態を コネクション開設完了状態にする。
    532512                         */
    533513                        cep->timer[TCP_TIM_KEEP] = TCP_TVAL_KEEP_IDLE;
     
    540520                        if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
    541521
    542                                 /* 相手のアドレスをコピーする。*/
     522                                /* 相手のアドレスをコピーする。*/
    543523
    544524#if defined(_IP6_CFG) && defined(_IP4_CFG)
     
    590570                }
    591571        else {
    592                 /* ACK フラグがないときは、ACK を送って、CEP の状æ
    593 ‹ã‚’ SYN 受信済みにする。*/
     572                /* ACK フラグがないときは、ACK を送って、CEP の状態を SYN 受信済みにする。*/
    594573                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    595574                cep->timer[TCP_TIM_REXMT] = 0;
     
    601580
    602581/*
    603  *  trim_length -- 受信した SDU 長を調整する。
     582 *  trim_length -- 受信した SDU 長を調整する。
    604583 */
    605584
     
    608587{
    609588        tcph->seq ++;
    610         if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
    611                 /*
    612                  *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
    613                  *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
     589        if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
     590                /*
     591                 *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
     592                 *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
    614593                 */
    615594                tcph->sum    = (uint16_t)cep->rcv_wnd;
    616595                tcph->flags &= ~TCP_FLG_FIN;
    617596                }
    618         cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
     597        cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
    619598
    620599#ifdef TCP_CFG_EXTENTIONS
    621         cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ */
     600        cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ     */
    622601#endif
    623602        }
    624603
    625604/*
    626  *  proc_ack2 -- ACK の処理 (2)
     605 *  proc_ack2 -- ACK の処理 (2)
    627606 *
    628  *    戻り値
     607 *    戻り値
    629608 *
    630  *      RET_OK          正常
    631  *      RET_RETURN      正常、リターンする。
    632  *      RET_DROP        エラー、セグメントを破棄する。
    633  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     609 *      RET_OK          正常
     610 *      RET_RETURN      正常、リターンする。
     611 *      RET_DROP        エラー、セグメントを破棄する。
     612 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    634613 */
    635614
     
    645624
    646625        /*
    647          *  相手に受信確認された ACK から、まだ確認されていない
    648          *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
    649          *  削除してよいオクテット数 (acked) になる。
     626         *  相手に受信確認された ACK から、まだ確認されていない
     627         *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
     628         *  削除してよいオクテット数 (acked) になる。
    650629         */
    651630        acked = tcph->ack - cep->snd_una;
     
    653632
    654633        /*
    655          *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
    656          *  後の ACK を受信したら、タイマバックオフをキャンセルし、
    657          *  再送タイマを再設定する。
     634         *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
     635         *  後の ACK を受信したら、タイマバックオフをキャンセルし、
     636         *  再送タイマを再設定する。
    658637         */
    659638        if (cep->rtt && SEQ_GT(tcph->ack, cep->rtseq)) {
     
    662641
    663642        /*
    664          *  å
    665 ¨ã¦ã®æœªç¢ºèªãƒ‡ãƒ¼ã‚¿ãŒ ACK されたら、再送タイマを停止し、
    666          *  再開を記憶する (さらに出力か持続)。
    667          *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
    668          *  現在の再送タイムアウトを設定する。
    669          */
    670         if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
     643         *  全ての未確認データが ACK されたら、再送タイマを停止し、
     644         *  再開を記憶する (さらに出力か持続)。
     645         *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
     646         *  現在の再送タイムアウトを設定する。
     647         */
     648        if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
    671649
    672650#ifdef TCP_CFG_SWBUF_CSAVE
    673651
    674652                /*
    675                  * 送信ウィンドバッファの省コピー機能が有効の場合は、
    676                  * 送信済みで、ACKが完了するまで再送タイマを変更しない。
     653                 * 送信ウィンドバッファの省コピー機能が有効の場合は、
     654                 * 送信済みで、ACKが完了するまで再送タイマを変更しない。
    677655                 */
    678656                if ((cep->flags & TCP_CEP_FLG_WBCS_MASK) == TCP_CEP_FLG_WBCS_ACKED)
     
    688666                }
    689667        else if (cep->timer[TCP_TIM_PERSIST] == 0) {
    690                 cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
    691                 }
    692 
    693         /* 相手が受信確認したデータがあるときの処理 */
     668                cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
     669                }
     670
     671        /* 相手が受信確認したデータがあるときの処理 */
    694672        if (acked) {
    695                 uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ   */
    696                 uint32_t incr = cep->maxseg;            /* cep->maxseg:   æœ€å¤§ã‚»ã‚°ãƒ¡ãƒ³ãƒˆã‚µã‚¤ã‚º        */
    697 
    698                 /*
    699                  *  新たに相手が受信確認したデータがあったときは、
    700                  *  輻輳ウィンドサイズを大きくする。
    701                  *  輻輳ウィンドサイズ (snd_cwnd) が
    702                  *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
    703                  *  輻輳回避制御を行い。
     673                uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ     */
     674                uint32_t incr = cep->maxseg;            /* cep->maxseg:   最大セグメントサイズ    */
     675
     676                /*
     677                 *  新たに相手が受信確認したデータがあったときは、
     678                 *  輻輳ウィンドサイズを大きくする。
     679                 *  輻輳ウィンドサイズ (snd_cwnd) が
     680                 *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
     681                 *  輻輳回避制御を行い。
    704682                 *
    705683                 *    snd_cwnd = snd_cwnd + maxseg * maxseg / snd_cwnd;
    706684                 *
    707                  *  等しいか小さいときは、スロースタート制御を行う。
     685                 *  等しいか小さいときは、スロースタート制御を行う。
    708686                 *
    709687                 *    snd_cwnd = snd_cwnd + maxseg
     
    711689                 */
    712690                if (cw > cep->snd_ssthresh)
    713                         /* 輻輳回避制御 */
     691                        /* 輻輳回避制御 */
    714692                        incr = incr * incr / cw;
    715693
     
    720698
    721699                /*
    722                  *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
     700                 *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
    723701                 */
    724702                if (acked > cep->swbuf_count) {
     
    733711                        }
    734712
    735                 /* 送信ウィンドバッファに空きができたことを知らせる。*/
     713                /* 送信ウィンドバッファに空きができたことを知らせる。*/
    736714                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
    737715
    738716                /*
    739                  *  送達確認されていない最小送信 SEQ (snd_una) を
    740                  *  今回送達確認された ACK まで進め、
    741                  *  次の送信データの SEQ (snd_nxt) も、新しい
    742                  *  送達確認されていない最小送信 SEQ (snd_una)
    743                  *  まで進める。
     717                 *  送達確認されていない最小送信 SEQ (snd_una) を
     718                 *  今回送達確認された ACK まで進め、
     719                 *  次の送信データの SEQ (snd_nxt) も、新しい
     720                 *  送達確認されていない最小送信 SEQ (snd_una)
     721                 *  まで進める。
    744722                 */
    745723                cep->snd_una += acked;
     
    748726
    749727                /*
    750                  *  状æ
    751 ‹ã«ã‚ˆã‚Šåˆ†å²
     728                 *  状態により分岐
    752729                 */
    753730                switch (cep->fsm_state) {
    754                 case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    755 ã¡ */
     731                case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    756732                        if (ourfinisacked) {
    757733                                cep->fsm_state = TCP_FSM_FIN_WAIT_2;
     
    759735                                }
    760736                        break;
    761                 case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK å¾
    762 ã¡ */
     737                case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK 待ち */
    763738                        if (ourfinisacked) {
    764739                                /*
    765                                  *  送信した FIN が確認されていれば状æ
    766 ‹ã‚’変更し、
    767                                  *  すべてのタイマをリセットした後、2MSL タイマを設定する。
     740                                 *  送信した FIN が確認されていれば状態を変更し、
     741                                 *  すべてのタイマをリセットした後、2MSL タイマを設定する。
    768742                                 */
    769743                                cep->fsm_state = TCP_FSM_TIME_WAIT;
     
    772746                                }
    773747                        break;
    774                 case TCP_FSM_LAST_ACK:          /* APP が終了、ACK å¾
    775 ã¡ */
     748                case TCP_FSM_LAST_ACK:          /* APP が終了、ACK 待ち */
    776749                        if (ourfinisacked) {
    777750                                /*
    778                                  *  送信した FIN が確認されていれば、cep をクローズし、
    779                                  *  セグメントを破棄する。
     751                                 *  送信した FIN が確認されていれば、cep をクローズし、
     752                                 *  セグメントを破棄する。
    780753                                 */
    781754                                cep = tcp_close(cep);
     
    783756                                }
    784757                        break;
    785                 case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    786 ã¡ */
     758                case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    787759                        /*
    788                          *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
    789                          *  ACK 送信後、セグメントを破棄する。
     760                         *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
     761                         *  ACK 送信後、セグメントを破棄する。
    790762                         */
    791763                        cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
     
    798770
    799771/*
    800  *  proc_ack1 -- ACK の処理 (1)
     772 *  proc_ack1 -- ACK の処理 (1)
    801773 *
    802  *    戻り値:
    803  *      RET_OK          正常
    804  *      RET_RETURN      正常、リターンする。
    805  *      RET_DROP        エラー、セグメントを破棄する。
    806  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     774 *    戻り値:
     775 *      RET_OK          正常
     776 *      RET_RETURN      正常、リターンする。
     777 *      RET_DROP        エラー、セグメントを破棄する。
     778 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    807779 *
    808780 */
     
    814786
    815787        switch (cep->fsm_state) {
    816         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    817 
    818                 /* 状æ
    819 ‹ã‚’変更する。*/
     788        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     789
     790                /* 状態を変更する。*/
    820791                if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
    821792                        cep->fsm_state  = TCP_FSM_FIN_WAIT_1;
     
    826797                        cep->fsm_state  = TCP_FSM_ESTABLISHED;
    827798
    828                         /* TCP 通信端点からTCP 受付口を解放する。*/
     799                        /* TCP 通信端点からTCP 受付口を解放する。*/
    829800                        cep->rep = NULL;
    830801
     
    839810                        if (cep->rcv_nblk_tfn == TFN_TCP_ACP_CEP) {
    840811
    841                                 /* 相手のアドレスをコピーする。*/
     812                                /* 相手のアドレスをコピーする。*/
    842813
    843814#if defined(_IP6_CFG) && defined(_IP4_CFG)
     
    889860                        if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
    890861
    891                                 /* 相手のアドレスをコピーする。*/
     862                                /* 相手のアドレスをコピーする。*/
    892863
    893864#if defined(_IP6_CFG) && defined(_IP4_CFG)
     
    951922
    952923                /*
    953                  *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
    954                  */
    955                 if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
     924                 *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
     925                 */
     926                if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
    956927                        tcph->flags = tcp_move_ra2rw(cep, tcph->flags);
    957928               
    958                 cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
    959 
    960                 /* break; 下に落ちる。*/
     929                cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
     930
     931                /* break; 下に落ちる。*/
    961932       
    962         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
    963         case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    964         case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    965 ã¡*/
    966         case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    967 ã¡             */
    968         case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    969 ã¡     */
    970         case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    971 ã¡     */
    972         case TCP_FSM_TIME_WAIT:         /* 終了、時間å¾
    973 ã¡             */
     933        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
     934        case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     935        case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち*/
     936        case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
     937        case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     938        case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
     939        case TCP_FSM_TIME_WAIT:         /* 終了、時間待ち              */
    974940
    975941                if (SEQ_LE(tcph->ack, cep->snd_una)) {
    976942
    977943                        /*
    978                          *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
    979                          *  つまり、多重に ACK を受信したことを意味している。
     944                         *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
     945                         *  つまり、多重に ACK を受信したことを意味している。
    980946                         */
    981947
    982                         if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
     948                        if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
    983949
    984950                                /*
    985                                  *  SDU がなく、相手のウィンドサイズが変更されていなければ、
    986                                  *  すでに送信したセグメントの中で、ACK (tcph->ack) と
    987                                  *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
    988                                  *  この場合は、高速再転送と高速リカバリを行う。
     951                                 *  SDU がなく、相手のウィンドサイズが変更されていなければ、
     952                                 *  すでに送信したセグメントの中で、ACK (tcph->ack) と
     953                                 *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
     954                                 *  この場合は、高速再転送と高速リカバリを行う。
    989955                                 */
    990956                                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DUP_ACKS], 1);
     
    993959
    994960                                        /*
    995                                          *  再送タイマがセットされていないとき、
    996                                          *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
    997                                          *  一致しないときは、多重 ACK 数を 0 にする。
     961                                         *  再送タイマがセットされていないとき、
     962                                         *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
     963                                         *  一致しないときは、多重 ACK 数を 0 にする。
    998964                                         */
    999965                                        cep->dupacks = 0;
     
    1003969
    1004970                                        /*
    1005                                          *  多重 ACK 数がしきい値 (標準 3) になったら
    1006                                          *  高速再転送処理を開始する。
     971                                         *  多重 ACK 数がしきい値 (標準 3) になったら
     972                                         *  高速再転送処理を開始する。
    1007973                                         */
    1008974                                        uint_t          win;
    1009975
    1010976                                        /*
    1011                                          *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
     977                                         *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
    1012978                                         *
    1013                                          *    相手の受信可能ウィンドサイズ (snd_wnd) か
    1014                                          *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
    1015                                          *    ただし、2 * maxseg 以上。
     979                                         *    相手の受信可能ウィンドサイズ (snd_wnd) か
     980                                         *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
     981                                         *    ただし、2 * maxseg 以上。
    1016982                                         *
    1017983                                         */
     
    1024990                                        cep->snd_ssthresh = win * cep->maxseg;
    1025991
    1026                                         /* 再送タイマと往復時間をリセットする。*/
     992                                        /* 再送タイマと往復時間をリセットする。*/
    1027993                                        cep->timer[TCP_TIM_REXMT] = 0;
    1028994                                        cep->rtt = 0;
    1029995
    1030                                         /* 消失したセグメントを送信する。*/
     996                                        /* 消失したセグメントを送信する。*/
    1031997                                        cep->snd_old_nxt = cep->snd_nxt;
    1032998                                        cep->snd_nxt     = tcph->ack;
     
    10341000
    10351001                                        /*
    1036                                          *  snd_nxt をå
    1037 ƒã«æˆ»ã™ã‚ˆã†ã«è¨­å®šã—て
    1038                                          *  送信を指示する。
     1002                                         *  snd_nxt を元に戻すように設定して
     1003                                         *  送信を指示する。
    10391004                                         */
    10401005                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT |
     
    10441009                                        sig_sem(SEM_TCP_POST_OUTPUT);
    10451010
    1046                                         /* 輻輳ウィンドサイズを更新する。*/
     1011                                        /* 輻輳ウィンドサイズを更新する。*/
    10471012                                        cep->snd_cwnd = (uint16_t)(cep->snd_ssthresh
    10481013                                                           + cep->maxseg * cep->dupacks);
     
    10541019
    10551020                                        /*
    1056                                          *  多重 ACK 数がしきい値 (標準 3) をè¶
    1057 ãˆãŸã‚‰
    1058                                          *  輻輳ウィンドサイズを増加しながら再送する。
     1021                                         *  多重 ACK 数がしきい値 (標準 3) を超えたら
     1022                                         *  輻輳ウィンドサイズを増加しながら再送する。
    10591023                                         */
    10601024                                        cep->snd_cwnd += cep->maxseg;
    10611025
    1062                                         /* 送信を指示する。*/
     1026                                        /* 送信を指示する。*/
    10631027                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    10641028                                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    10731037
    10741038                /*
    1075                  *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
     1039                 *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
    10761040                 */
    10771041                if (cep->dupacks >= MAX_TCP_REXMT_THRESH && cep->snd_cwnd > cep->snd_ssthresh)
    10781042                        /*
    1079                          *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
     1043                         *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
    10801044                         */
    10811045                        cep->snd_cwnd = (uint16_t)cep->snd_ssthresh;
     
    10851049                if (SEQ_GT(tcph->ack, cep->snd_max))
    10861050                        /*
    1087                          *  受信した ACK が送信した最大 SEQ をè¶
    1088 ãˆã¦ã„たときの処理
     1051                         *  受信した ACK が送信した最大 SEQ を超えていたときの処理
    10891052                         */
    10901053                        return drop_after_ack(input, cep, thoff);
     
    10921055                if (cep->flags & TCP_CEP_FLG_NEED_SYN) {
    10931056                        /*
    1094                          *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
     1057                         *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
    10951058                         */
    10961059                        cep->flags &= ~TCP_CEP_FLG_NEED_SYN;
     
    11051068
    11061069/*
    1107  *  update_wnd -- ウィンドサイズを更新する。
     1070 *  update_wnd -- ウィンドサイズを更新する。
    11081071 *
    1109  *    戻り値: 送信がå¿
    1110 è¦ãªã‚‰ true を返す。
     1072 *    戻り値: 送信が必要なら true を返す。
    11111073 */
    11121074
     
    11161078
    11171079        /*
    1118          *  更新条件
     1080         *  更新条件
    11191081         *
    1120          *    ACK フラグがセットされている &&
    1121          *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
    1122          *     å‰å›žã‚¦ã‚£ãƒ³ãƒ‰ã‚’更新した SEQ (snd_wl1) が SEQ と同じ &&
    1123          *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
    1124          *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
    1125          *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
     1082         *    ACK フラグがセットされている &&
     1083         *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
     1084         *     前回ウィンドを更新した SEQ (snd_wl1) が SEQ と同じ &&
     1085         *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
     1086         *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
     1087         *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
    11261088         *       )
    11271089         *      )
     
    11391101
    11401102                if (cep->snd_wnd > cep->max_sndwnd)
    1141                         /* 今までの最大送信ウィンドサイズを更新する。*/
     1103                        /* 今までの最大送信ウィンドサイズを更新する。*/
    11421104                        cep->max_sndwnd = cep->snd_wnd;
    11431105
     
    11471109
    11481110                        /*
    1149                          *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
    1150                          *  相手の受信ウィンドが空くのをå¾
    1151 ã£ã¦ã„るときの処理
     1111                         *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
     1112                         *  相手の受信ウィンドが空くのを待っているときの処理
    11521113                         */
    11531114                        if (cep->snd_wnd > 0) {
    11541115
    11551116                                /*
    1156                                  *  相手の受信ウィンドが空いたときは、
    1157                                  *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
     1117                                 *  相手の受信ウィンドが空いたときは、
     1118                                 *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
    11581119                                 */
    11591120                                cep->flags = (cep->flags & ~TCP_CEP_FLG_WBCS_MASK)
     
    11721133
    11731134/*
    1174  *  proc_urg -- 緊急データつきのセグメントの処理
     1135 *  proc_urg -- 緊急データつきのセグメントの処理
    11751136 */
    11761137
     
    11831144            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    11841145
    1185                 /* 緊急データつきのセグメントの処理 */
     1146                /* 緊急データつきのセグメントの処理 */
    11861147
    11871148                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_URG_SEGS], 1);
     
    11891150
    11901151                        /*
    1191                          *  緊急ポインタの位置が受信ウィンドバッファの
    1192                          *  範囲をè¶
    1193 ãˆã‚‹ã¨ãã¯ä½•ã‚‚しない。
     1152                         *  緊急ポインタの位置が受信ウィンドバッファの
     1153                         *  範囲を超えるときは何もしない。
    11941154                         */
    11951155                        tcph->urp    = 0;
     
    11981158
    11991159                if (SEQ_GT(tcph->seq + tcph->urp, cep->rcv_up))
    1200                         /* 緊急ポインタが更新されたときの処理 */
     1160                        /* 緊急ポインタが更新されたときの処理 */
    12011161                        cep->rcv_up = tcph->seq + tcph->urp;
    12021162
    1203                 if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
     1163                if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
    12041164
    12051165                        /*
    1206                          *  緊急ポインタの位置が、今回受信したセグメントå†
    1207 ã®å ´åˆã¯ã€
    1208                          *  コールバック関数を呼び出す。
     1166                         *  緊急ポインタの位置が、今回受信したセグメント内の場合は、
     1167                         *  コールバック関数を呼び出す。
    12091168                         */
    12101169                        cep->urg_tcph = tcph;
     
    12291188
    12301189                        if (cep->urg_tcph != NULL) {
    1231                                 /* コールバック関数å†
    1232 ã§ tcp_rcv_oob() を呼出さなかった。*/
     1190                                /* コールバック関数内で tcp_rcv_oob() を呼出さなかった。*/
    12331191                                cep->urg_tcph = NULL;
    12341192                                tcph->urp = 0;
     
    12361194                        else {
    12371195                                /*
    1238                                  *  コールバック関数å†
    1239 ã§ tcp_rcv_oob() を呼出した時は、
    1240                                  *  SDU 長の補正値を設定する。
     1196                                 *  コールバック関数内で tcp_rcv_oob() を呼出した時は、
     1197                                 *  SDU 長の補正値を設定する。
    12411198                                 */
    12421199                                tcph->urp = 1;
     
    12651222
    12661223/*
    1267  *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
     1224 *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
    12681225 *
    1269  *    戻り値:
    1270  *      RET_RETURN      正常、リターンする。
    1271  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     1226 *    戻り値:
     1227 *      RET_RETURN      正常、リターンする。
     1228 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    12721229 */
    12731230
     
    12781235
    12791236        /*
    1280          *    SYN 受信状æ
    1281 ‹ã§ã€ACK が送達確認されていない最小送信 SEQ (snd_una) より
    1282          *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
    1283          *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
    1284          *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
     1237         *    SYN 受信状態で、ACK が送達確認されていない最小送信 SEQ (snd_una) より
     1238         *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
     1239         *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
     1240         *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
    12851241         */
    12861242        if (cep->fsm_state == TCP_FSM_SYN_RECVD && (tcph->flags & TCP_FLG_ACK) &&
     
    12911247        syscall(rel_net_buf(input));
    12921248
    1293         /* 送信を指示する。*/
     1249        /* 送信を指示する。*/
    12941250        cep->flags |=  TCP_CEP_FLG_ACK_NOW | TCP_CEP_FLG_POST_OUTPUT;
    12951251        sig_sem(SEM_TCP_POST_OUTPUT);
     
    12981254
    12991255/*
    1300  *  close_connection -- コネクション開放処理、相手から FIN を受信した。
     1256 *  close_connection -- コネクション開放処理、相手から FIN を受信した。
    13011257 */
    13021258
     
    13231279
    13241280        switch (cep->fsm_state) {
    1325         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    1326         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
     1281        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     1282        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
    13271283                cep->fsm_state = TCP_FSM_CLOSE_WAIT;
    13281284                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_RWBUF_READY));
    13291285                break;
    13301286
    1331         case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    1332 ã¡ */
     1287        case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    13331288                cep->fsm_state = TCP_FSM_CLOSING;
    13341289                break;
    13351290
    1336         case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN å¾
    1337 ã¡ */
     1291        case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN 待ち */
    13381292                cep->fsm_state = TCP_FSM_TIME_WAIT;
    13391293                tcp_cancel_timers(cep);
     
    13411295
    13421296                /*
    1343                  *  FIN WAIT 2 状æ
    1344 ‹ã§ã¯ã€
    1345                  *  受信は可能であるが、すでに送信は終了している。
    1346                  *  相手の送信も終了したので、å
    1347 ¥åŠ›ã‚¿ã‚¹ã‚¯ã®ã¿èµ·åºŠã™ã‚‹ã€‚
     1297                 *  FIN WAIT 2 状態では、
     1298                 *  受信は可能であるが、すでに送信は終了している。
     1299                 *  相手の送信も終了したので、入力タスクのみ起床する。
    13481300                 */
    13491301                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
     
    13511303#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
    13521304
    1353                 /* 相手からの FIN に対して応答を返す。*/
     1305                /* 相手からの FIN に対して応答を返す。*/
    13541306                tcp_respond(NULL, cep, cep->rcv_nxt, cep->snd_una,
    13551307                            cep->rbufsz - cep->rwbuf_count, TCP_FLG_ACK);
     
    13581310
    13591311                /*
    1360                  *  å¿
    1361 è¦ãªæƒ
    1362 å ±ã‚’ Time Wait 用 TCP 通信端点に移して、
    1363                  *  標準の TCP 通信端点を開放する。
     1312                 *  必要な情報を Time Wait 用 TCP 通信端点に移して、
     1313                 *  標準の TCP 通信端点を開放する。
    13641314                 */
    13651315                tcp_move_twcep(cep);
     
    13691319                break;
    13701320
    1371         case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    1372 ã¡ */
     1321        case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    13731322                cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
    13741323                break;
     
    13771326
    13781327/*
    1379  *  tcp_input -- TCP のå
    1380 ¥åŠ›é–¢æ•°
     1328 *  tcp_input -- TCP の入力関数
    13811329 *
    1382  *      注意: input には IF ヘッダと IP ヘッダがå
    1383 ˆé ­ã«ã‚る。
     1330 *      注意: input には IF ヘッダと IP ヘッダが先頭にある。
    13841331 */
    13851332
     
    14071354        NET_COUNT_MIB(tcp_stats.tcpInSegs, 1);
    14081355
    1409         /* ヘッダ長をチェックする。*/
     1356        /* ヘッダ長をチェックする。*/
    14101357        if (input->len < IF_IP_TCP_HDR_SIZE(input)) {
    14111358                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
     
    14151362        tcph = GET_TCP_HDR(input, *offp);
    14161363
    1417         seglen  = input->len - *offp;                           /* TCP のセグメント長 */
     1364        seglen  = input->len - *offp;                           /* TCP のセグメント長 */
    14181365
    14191366        if (IN_CKSUM(input, IPPROTO_TCP, *offp, (uint_t)seglen) != 0) {
     
    14221369                }
    14231370
    1424         /* TCP ヘッダ長をチェックする。*/
     1371        /* TCP ヘッダ長をチェックする。*/
    14251372        if (TCP_HDR_LEN(tcph->doff) < TCP_HDR_SIZE || TCP_HDR_LEN(tcph->doff) > seglen) {
    14261373                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
    14271374                goto drop;
    14281375                }
    1429         tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
     1376        tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
    14301377
    14311378        /*
    1432          *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
    1433          *  ただし、RFC1644 T/TCP 拡張機能と競合する。
     1379         *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
     1380         *  ただし、RFC1644 T/TCP 拡張機能と競合する。
    14341381         */
    14351382        if ((tcph->flags & (TCP_FLG_SYN | TCP_FLG_FIN)) == (TCP_FLG_SYN | TCP_FLG_FIN))
    14361383                goto drop;
    14371384
    1438         /* ネットワークオーダーからホストオーダーに変換する。*/
     1385        /* ネットワークオーダーからホストオーダーに変換する。*/
    14391386
    14401387        NTOHL(tcph->seq);
     
    14451392        NTOHS(tcph->dport);
    14461393
    1447         /* SDU 長 より 緊急ポインタが大きい場合 */
     1394        /* SDU 長 より 緊急ポインタが大きい場合 */
    14481395        if (tcph->urp > tcph->sum)
    14491396                goto drop;
     
    14541401
    14551402        /*
    1456          *  状æ
    1457 ‹ãŒ Time Wait 中の CEP を探索する。
     1403         *  状態が Time Wait 中の CEP を探索する。
    14581404         */
    14591405        twcep = tcp_find_twcep(input, *offp);
    14601406        if (twcep != NULL) {
    14611407
    1462                 if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
     1408                if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
    14631409                        goto drop;
    14641410                else {
    14651411
    14661412                        /*
    1467                          *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
    1468                          *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
    1469                          *    損失したことを意味しているので、ACK セグメントを再送する。
     1413                         *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
     1414                         *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
     1415                         *    損失したことを意味しているので、ACK セグメントを再送する。
    14701416                         */
    14711417
    1472                         /* ホストオーダーからネットワークオーダーに戻す。*/
     1418                        /* ホストオーダーからネットワークオーダーに戻す。*/
    14731419                        HTONS(tcph->sport);
    14741420                        HTONS(tcph->dport);
     
    14791425                }
    14801426        else
    1481                 /* 標準の TCP 通信端点を得る。*/
     1427                /* 標準の TCP 通信端点を得る。*/
    14821428                cep = tcp_find_cep(input, *offp);
    14831429
    14841430#else   /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
    14851431
    1486         /* TCP 通信端点を得る。*/
     1432        /* TCP 通信端点を得る。*/
    14871433        cep = tcp_find_cep(input, *offp);
    14881434
     
    14901436
    14911437        /*
    1492          *  TCP 通信端点がない場合と CEP の状æ
    1493 ‹ãŒã‚¯ãƒ­ãƒ¼ã‚ºãªã‚‰ç ´æ£„する。
     1438         *  TCP 通信端点がない場合と CEP の状態がクローズなら破棄する。
    14941439         */
    14951440        if (cep == NULL) {
     
    15091454
    15101455        /*
    1511          *  コネクション開設済みでセグメントを受信したときは、
    1512          *  アイドル時間と生存確認タイマをリセットする。
     1456         *  コネクション開設済みでセグメントを受信したときは、
     1457         *  アイドル時間と生存確認タイマをリセットする。
    15131458         */
    15141459        cep->idle = 0;
     
    15171462                }
    15181463
    1519         /* CEP の状æ
    1520 ‹ãŒ LISTEN 以外の時は、オプションを処理する。*/
     1464        /* CEP の状態が LISTEN 以外の時は、オプションを処理する。*/
    15211465        if (cep->fsm_state != TCP_FSM_LISTEN)
    15221466                parse_option(tcph, cep);
    15231467
    15241468        /*
    1525          *  受信可能ウィンドサイズを計算する。
     1469         *  受信可能ウィンドサイズを計算する。
    15261470         *
    1527          *  rcv_nxt:     å—信を期å¾
    1528 ã—ている最小の SEQ(これ以前は受信済み)
    1529          *  rcv_adv:     å—信を期å¾
    1530 ã—ている最大の SEQ
    1531          *  rbufsz:      受信ウィンドバッファサイズ
    1532          *  rwbuf_count:  受信ウィンドバッファにあるデータ量
    1533          *  tcph->sum:   ä»Šå›žå—信した SDU サイズ
     1471         *  rcv_nxt:     受信を期待している最小の SEQ(これ以前は受信済み)
     1472         *  rcv_adv:     受信を期待している最大の SEQ
     1473         *  rbufsz:      受信ウィンドバッファサイズ
     1474         *  rwbuf_count:  受信ウィンドバッファにあるデータ量
     1475         *  tcph->sum:   今回受信した SDU サイズ
    15341476         *
    1535          *  今回受信したセグメントを順序整列キューに連結する
    1536          *  可能性があるので tcph->sum を考æ
    1537 ®ã™ã‚‹ã€‚
     1477         *  今回受信したセグメントを順序整列キューに連結する
     1478         *  可能性があるので tcph->sum を考慮する。
    15381479         *
    15391480         */
     
    15461487                cep->rcv_wnd = cep->rcv_adv - cep->rcv_nxt;
    15471488
    1548         /* CEP の状æ
    1549 ‹ã«ã‚ˆã‚Šå‡¦ç†ã‚’行う。*/
    1550 
    1551         if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
     1489        /* CEP の状態により処理を行う。*/
     1490
     1491        if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
    15521492                if ((ret = listening(input, cep, *offp, iss)) == RET_RST_DROP)
    15531493                        goto reset_drop;
    15541494                else if (ret == RET_DROP)
    15551495                        goto drop;
    1556                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1557 
    1558                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1496                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1497
     1498                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    15591499                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    15601500                                goto drop;
     
    15651505                        }
    15661506                }
    1567         else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み        */
     1507        else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み      */
    15681508                if ((ret = syn_sent(tcph, cep)) == RET_RST_DROP)
    15691509                        goto reset_drop;
    15701510                else if (ret == RET_DROP)
    15711511                        goto drop;
    1572                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1573 
    1574                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1512                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1513
     1514                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    15751515                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    15761516                                goto drop;
     
    15821522                }
    15831523        else {
    1584                 if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
     1524                if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
    15851525                        /*
    1586                          *  相手から受信確認が送られて来ても、
     1526                         *  相手から受信確認が送られて来ても、
    15871527                         *
    1588                          *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
    1589                          *           é€ä¿¡ã—た最大     SEQ (snd_max) < ACK
     1528                         *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
     1529                         *           送信した最大     SEQ (snd_max) < ACK
    15901530                         *
    1591                          *  なら、リセットを送ってセグメントを破棄する。
     1531                         *  なら、リセットを送ってセグメントを破棄する。
    15921532                         */
    15931533                        if ((tcph->flags & TCP_FLG_ACK) &&
     
    15981538
    15991539                /*
    1600                  *  RST フラグを受信したときの処理 (異常切断)
     1540                 *  RST フラグを受信したときの処理 (異常切断)
    16011541                 */
    16021542                if (tcph->flags & TCP_FLG_RST) {
     
    16041544                            SEQ_LT(tcph->seq, cep->last_ack_sent + cep->rcv_wnd)) {
    16051545                                /*
    1606                                  *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
    1607                                  *  から、受信ウインドウサイズまでの間の処理
     1546                                 *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
     1547                                 *  から、受信ウインドウサイズまでの間の処理
    16081548                                 */
    16091549                                switch (cep->fsm_state) {
    1610                                 case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み          */
    1611 
    1612                                         cep->net_error = EV_CNNRF;      /* 接続不能 */
     1550                                case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み            */
     1551
     1552                                        cep->net_error = EV_CNNRF;      /* 接続不能 */
    16131553                                        cep->error     = E_CLS;
    16141554                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
     
    16171557                                        break;
    16181558
    1619                                 case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                       */
    1620                                 case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    1621 ã¡             */
     1559                                case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                   */
     1560                                case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
    16221561                                        NET_COUNT_MIB(tcp_stats.tcpEstabResets, 1);
    16231562                                        /* fallthrough */
    16241563
    1625                                 case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    1626                                 case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    1627 ã¡     */
    1628 
    1629                                         cep->net_error = EV_CNRST;      /* 接続リセット */
     1564                                case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     1565                                case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち  */
     1566
     1567                                        cep->net_error = EV_CNRST;      /* 接続リセット */
    16301568                                        cep->error     = E_CLS;
    16311569                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
    16321570                                        /* no break; */
    16331571
    1634                                 case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    1635 ã¡     */
    1636                                 case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    1637 ã¡     */
     1572                                case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     1573                                case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
    16381574
    16391575                                        cep = tcp_close(cep);
     
    16451581
    16461582                /*
    1647                  *  CEP の状æ
    1648 ‹ãŒ SYN を受信し、SYN 送信済みの場合は、
    1649                  *  受信ウィンドに収まるようにデータを
    1650                  *  調整する前に、この接続によるパケットかどうかを検証する。
     1583                 *  CEP の状態が SYN を受信し、SYN 送信済みの場合は、
     1584                 *  受信ウィンドに収まるようにデータを
     1585                 *  調整する前に、この接続によるパケットかどうかを検証する。
    16511586                 *
    1652                  *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
     1587                 *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
    16531588                 *
    1654                  *  これは、"LAND" DoS 攻撃の防御である。
     1589                 *  これは、"LAND" DoS 攻撃の防御である。
    16551590                 */
    16561591                if (cep->fsm_state == TCP_FSM_SYN_RECVD && SEQ_LT(tcph->seq, cep->irs)) {
     
    16591594
    16601595                /*
    1661                  *  受信を期å¾
    1662 ã—ている最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
    1663                  *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
    1664                  *  削除する。
     1596                 *  受信を期待している最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
     1597                 *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
     1598                 *  削除する。
    16651599                 *                           <---------- rcv_wnd --------->
    16661600                 *                           rcv_nxt                      rcv_nxt + rcv_wnd
     
    16741608                 *           ^                      ^
    16751609                 *           seq                    seq + len
    1676                  *           <---------------> 削除する。
     1610                 *           <---------------> 削除する。
    16771611                 */
    16781612                todrop = cep->rcv_nxt - tcph->seq;
     
    16801614
    16811615                        /*
    1682                          *  SYN フラグがついているときは、その分 (1 オクテット)
    1683                          *  SEQ を進め、緊急ポインタと削除する長さを調整する。
     1616                         *  SYN フラグがついているときは、その分 (1 オクテット)
     1617                         *  SEQ を進め、緊急ポインタと削除する長さを調整する。
    16841618                         */
    16851619                        if (tcph->flags & TCP_FLG_SYN) {
     
    16941628
    16951629                        /*
    1696                          *  削除する長さが SDU より長い、つまり、受信を期å¾
    1697 ã—ている
    1698                          *  最小の SEQ (rcv_nxt) に達していないか、
    1699                          *  削除する長さが SDU と同じで、FIN フラグがついてなければ
    1700                          *  å
    1701 ¨ã¦å‰Šé™¤ã™ã‚‹ã€‚
     1630                         *  削除する長さが SDU より長い、つまり、受信を期待している
     1631                         *  最小の SEQ (rcv_nxt) に達していないか、
     1632                         *  削除する長さが SDU と同じで、FIN フラグがついてなければ
     1633                         *  全て削除する。
    17021634                         */
    1703                         if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
     1635                        if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
    17041636                            (todrop == tcph->sum && (tcph->flags & TCP_FLG_FIN) == 0)) {
    17051637                                tcph->flags &= ~TCP_FLG_FIN;
    17061638                                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    1707                                 todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
     1639                                todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
    17081640                                }
    17091641
    17101642                        /*
    1711                          *  SDU を前に詰める。
     1643                         *  SDU を前に詰める。
    17121644                         */
    1713                         if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
     1645                        if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
    17141646                                memcpy(GET_TCP_SDU(input, *offp),
    17151647                                       GET_TCP_SDU(input, *offp) + todrop, (size_t)(tcph->sum - todrop));
     
    17171649
    17181650                        /*
    1719                          *  SEQ と SDU 長を調整する。
     1651                         *  SEQ と SDU 長を調整する。
    17201652                         */
    17211653                        tcph->seq +=     todrop;
    1722                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1654                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    17231655
    17241656                        /*
    1725                          *  緊急ポインタを調整する。
     1657                         *  緊急ポインタを調整する。
    17261658                         */
    17271659                        if (tcph->urp > todrop)
     
    17361668
    17371669                /* 
    1738                  *  もしユーザタスクが終了した後に、データを受信した
    1739                  *  場合は、RST を送る。
    1740                  */
    1741                 if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
     1670                 *  もしユーザタスクが終了した後に、データを受信した
     1671                 *  場合は、RST を送る。
     1672                 */
     1673                if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
    17421674                        cep = tcp_close(cep);
    17431675                        goto reset_drop;
     
    17451677
    17461678                /*
    1747                  *  受信セグメントが受信ウィンドをè¶
    1748 ãˆã‚‹å ´åˆã¯ã€
    1749                  *  è¶
    1750 ãˆãŸåˆ†ã‚’削る。
     1679                 *  受信セグメントが受信ウィンドを超える場合は、
     1680                 *  超えた分を削る。
    17511681                 *
    17521682                 *       <---------- rcv_wnd --------->
     
    17611691                 *                    ^                      ^
    17621692                 *                    seq                    seq + len
    1763                  *                                     <-----> 削除する。
    1764                  */
    1765                 todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
     1693                 *                                     <-----> 削除する。
     1694                 */
     1695                todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
    17661696                if (todrop > 0) {
    1767                         if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
     1697                        if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
    17681698                                /*
    1769                                  *  受信した SDU のå
    1770 ¨ã¦ãŒå—信ウィンドをè¶
    1771 ãˆã‚‹å ´åˆã€‚
     1699                                 *  受信した SDU の全てが受信ウィンドを超える場合。
    17721700                                 *
    1773                                  *  TIME_WAIT 中に、新たな接続要求を受信したら
    1774                                  *  古い接続を破棄し、新たな接続を開始する。
    1775                                  *  ただし、SEQ は前より進んでいなければならない。
     1701                                 *  TIME_WAIT 中に、新たな接続要求を受信したら
     1702                                 *  古い接続を破棄し、新たな接続を開始する。
     1703                                 *  ただし、SEQ は前より進んでいなければならない。
    17761704                                 */
    17771705                                if ((tcph->flags & TCP_FLG_SYN) &&
     
    17851713
    17861714                                /*
    1787                                  *  受信ウィンドが 0 で、受信した SEQ と
    1788                                  *  受信を期å¾
    1789 ã—ている最小の SEQ が一致したときは
    1790                                  *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
     1715                                 *  受信ウィンドが 0 で、受信した SEQ と
     1716                                 *  受信を期待している最小の SEQ が一致したときは
     1717                                 *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
    17911718                                 */
    17921719                                if (cep->rcv_wnd == 0 && (tcph->seq == cep->rcv_nxt || tcph->sum == 0)) {
     
    17991726                                        }
    18001727                                }
    1801                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1728                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    18021729                        tcph->flags &= ~(TCP_FLG_PUSH | TCP_FLG_FIN);
    18031730                        }
    18041731
    18051732                /*
    1806                  *  もし、SYN がセットされていれば、
    1807                  *  エラーなので RST を送り、接続を破棄する。
     1733                 *  もし、SYN がセットされていれば、
     1734                 *  エラーなので RST を送り、接続を破棄する。
    18081735                 */
    18091736                if (tcph->flags & TCP_FLG_SYN) {
     
    18141741
    18151742                /*
    1816                  *  もし、ACK がセットされていない場合は、
    1817                  *  状æ
    1818 ‹ãŒ SYN 受信済みか
    1819                  *  SYN を送信しようとしていれば、処理を続けるが、
    1820                  *  それ以外はセグメントを破棄して終了する。
     1743                 *  もし、ACK がセットされていない場合は、
     1744                 *  状態が SYN 受信済みか
     1745                 *  SYN を送信しようとしていれば、処理を続けるが、
     1746                 *  それ以外はセグメントを破棄して終了する。
    18211747                 */
    18221748                if ((tcph->flags & TCP_FLG_ACK) == 0) {
     
    18261752                else {
    18271753                        /*
    1828                          * ACK の処理
     1754                         * ACK の処理
    18291755                         */
    18301756                        ret = proc_ack1(input, cep, *offp, &needoutput);
     
    18401766/* step 6 */
    18411767
    1842         /* 送信ウィンドを更新する。*/
     1768        /* 送信ウィンドを更新する。*/
    18431769        if (update_wnd(tcph, cep) == true)
    18441770                needoutput = true;
    18451771
    1846         /* 緊急データを処理する。*/
     1772        /* 緊急データを処理する。*/
    18471773        proc_urg(tcph, cep);
    18481774
     
    18501776
    18511777        /*
    1852          *  SDU があるか、FIN を未受信の状æ
    1853 ‹ã§ã€æœ€åˆã« FIN を受信したとき、
    1854          *  受信セグメントキューに net_buf を追加する。
    1855          *  それ以外の場合は、セグメントを破棄する。
     1778         *  SDU があるか、FIN を未受信の状態で、最初に FIN を受信したとき、
     1779         *  受信セグメントキューに net_buf を追加する。
     1780         *  それ以外の場合は、セグメントを破棄する。
    18561781         */
    18571782        flags = tcph->flags;
    1858         if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
     1783        if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
    18591784            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    18601785                flags = reassemble(input, cep, *offp, flags);
     
    18661791
    18671792        /*
    1868          *  FIN を受信したらコネクションをクローズする。
     1793         *  FIN を受信したらコネクションをクローズする。
    18691794         */
    18701795        if (flags & TCP_FLG_FIN)
    18711796                close_connection(cep, &needoutput);
    18721797
    1873         /* 出力を行った後終了する。*/
     1798        /* 出力を行った後終了する。*/
    18741799        if (needoutput == true || (cep->flags & TCP_CEP_FLG_ACK_NOW)) {
    1875                 /* 送信を指示する。*/
     1800                /* 送信を指示する。*/
    18761801                cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    18771802                sig_sem(SEM_TCP_POST_OUTPUT);
     
    18821807reset_drop:
    18831808        /*
    1884          *  RST 送信処理
     1809         *  RST 送信処理
    18851810         */
    18861811
     
    18881813                goto drop;
    18891814
    1890         /* ホストオーダーからネットワークオーダーに戻す。*/
     1815        /* ホストオーダーからネットワークオーダーに戻す。*/
    18911816
    18921817        HTONS(tcph->sport);
     
    19021827        else {
    19031828                if (tcph->flags & TCP_FLG_SYN)
    1904                         tcph->sum ++;           /* tcph->sum は SDU 長 */
     1829                        tcph->sum ++;           /* tcph->sum は SDU 長 */
    19051830                tcp_respond(input, cep, tcph->seq + tcph->sum, 0, rbfree, TCP_FLG_RST | TCP_FLG_ACK);
    19061831                }
    19071832
    1908         /* input は tcp_respoond で返却される。*/
     1833        /* input は tcp_respoond で返却される。*/
    19091834        NET_COUNT_TCP(net_count_tcp[NC_TCP_SEND_RSTS], 1);
    19101835        NET_COUNT_MIB(tcp_stats.tcpOutRsts, 1);
Note: See TracChangeset for help on using the changeset viewer.