Ignore:
Timestamp:
Aug 3, 2017, 10:46:41 PM (7 years ago)
Author:
coas-nagasima
Message:

プロパティの文字コードにUTF-8を追加、キーワードを削除

File:
1 edited

Legend:

Unmodified
Added
Removed
  • asp3_gr_sakura/trunk/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
    r317 r318  
    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                                *cep->p_dstaddr = cep->dstaddr;
    544524
     
    576556                }
    577557        else {
    578                 /* ACK フラグがないときは、ACK を送って、CEP の状æ
    579 ‹ã‚’ SYN 受信済みにする。*/
     558                /* ACK フラグがないときは、ACK を送って、CEP の状態を SYN 受信済みにする。*/
    580559                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    581560                cep->timer[TCP_TIM_REXMT] = 0;
     
    587566
    588567/*
    589  *  trim_length -- 受信した SDU 長を調整する。
     568 *  trim_length -- 受信した SDU 長を調整する。
    590569 */
    591570
     
    594573{
    595574        tcph->seq ++;
    596         if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
    597                 /*
    598                  *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
    599                  *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
     575        if (tcph->sum > cep->rcv_wnd) {         /* 注意: tcph->sum は SDU 長 */
     576                /*
     577                 *  SDU 長が受信ウィンドサイズより大きいときは、受信ウィンドサイズ以降は
     578                 *  破棄し、FIN に応答しないことで、破棄したデータを再送させる。
    600579                 */
    601580                tcph->sum    = (uint16_t)cep->rcv_wnd;
    602581                tcph->flags &= ~TCP_FLG_FIN;
    603582                }
    604         cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
     583        cep->snd_wl1 = tcph->seq - 1;           /* cep->snd_wl1: ウィンド更新 SEQ 番号  */
    605584
    606585#ifdef TCP_CFG_EXTENTIONS
    607         cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ */
     586        cep->rcv_up  = tcph->seq;               /* cep->rcv_up : 受信した緊急ポインタ     */
    608587#endif
    609588        }
    610589
    611590/*
    612  *  proc_ack2 -- ACK の処理 (2)
     591 *  proc_ack2 -- ACK の処理 (2)
    613592 *
    614  *    戻り値
     593 *    戻り値
    615594 *
    616  *      RET_OK          正常
    617  *      RET_RETURN      正常、リターンする。
    618  *      RET_DROP        エラー、セグメントを破棄する。
    619  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     595 *      RET_OK          正常
     596 *      RET_RETURN      正常、リターンする。
     597 *      RET_DROP        エラー、セグメントを破棄する。
     598 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    620599 */
    621600
     
    631610
    632611        /*
    633          *  相手に受信確認された ACK から、まだ確認されていない
    634          *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
    635          *  削除してよいオクテット数 (acked) になる。
     612         *  相手に受信確認された ACK から、まだ確認されていない
     613         *  最小送信 SEQ (snd_una) を引くと、送信ウィンドバッファから
     614         *  削除してよいオクテット数 (acked) になる。
    636615         */
    637616        acked = tcph->ack - cep->snd_una;
     
    639618
    640619        /*
    641          *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
    642          *  後の ACK を受信したら、タイマバックオフをキャンセルし、
    643          *  再送タイマを再設定する。
     620         *  往復時間計測 (rtt) が設定されていて、計測開始 SEQ より
     621         *  後の ACK を受信したら、タイマバックオフをキャンセルし、
     622         *  再送タイマを再設定する。
    644623         */
    645624        if (cep->rtt && SEQ_GT(tcph->ack, cep->rtseq)) {
     
    648627
    649628        /*
    650          *  å
    651 ¨ã¦ã®æœªç¢ºèªãƒ‡ãƒ¼ã‚¿ãŒ ACK されたら、再送タイマを停止し、
    652          *  再開を記憶する (さらに出力か持続)。
    653          *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
    654          *  現在の再送タイムアウトを設定する。
    655          */
    656         if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
     629         *  全ての未確認データが ACK されたら、再送タイマを停止し、
     630         *  再開を記憶する (さらに出力か持続)。
     631         *  もし、ACK すべき、さらに多くのデータがあるなら、再送タイマに
     632         *  現在の再送タイムアウトを設定する。
     633         */
     634        if (tcph->ack == cep->snd_max) {        /* cep->snd_max: 送信した最大 SEQ */
    657635
    658636#ifdef TCP_CFG_SWBUF_CSAVE
    659637
    660638                /*
    661                  * 送信ウィンドバッファの省コピー機能が有効の場合は、
    662                  * 送信済みで、ACKが完了するまで再送タイマを変更しない。
     639                 * 送信ウィンドバッファの省コピー機能が有効の場合は、
     640                 * 送信済みで、ACKが完了するまで再送タイマを変更しない。
    663641                 */
    664642                if ((cep->flags & TCP_CEP_FLG_WBCS_MASK) == TCP_CEP_FLG_WBCS_ACKED)
     
    674652                }
    675653        else if (cep->timer[TCP_TIM_PERSIST] == 0) {
    676                 cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
    677                 }
    678 
    679         /* 相手が受信確認したデータがあるときの処理 */
     654                cep->timer[TCP_TIM_REXMT] = cep->rxtcur;        /* cep->rxtcur: 現在の再送タイムアウト */
     655                }
     656
     657        /* 相手が受信確認したデータがあるときの処理 */
    680658        if (acked) {
    681                 uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ   */
    682                 uint32_t incr = cep->maxseg;            /* cep->maxseg:   æœ€å¤§ã‚»ã‚°ãƒ¡ãƒ³ãƒˆã‚µã‚¤ã‚º        */
    683 
    684                 /*
    685                  *  新たに相手が受信確認したデータがあったときは、
    686                  *  輻輳ウィンドサイズを大きくする。
    687                  *  輻輳ウィンドサイズ (snd_cwnd) が
    688                  *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
    689                  *  輻輳回避制御を行い。
     659                uint32_t cw   = cep->snd_cwnd;  /* cep->snd_cwnd: 輻輳ウィンドサイズ     */
     660                uint32_t incr = cep->maxseg;            /* cep->maxseg:   最大セグメントサイズ    */
     661
     662                /*
     663                 *  新たに相手が受信確認したデータがあったときは、
     664                 *  輻輳ウィンドサイズを大きくする。
     665                 *  輻輳ウィンドサイズ (snd_cwnd) が
     666                 *  輻輳ウィンドサイズのしきい値 (snd_ssthresh) より大きいときは
     667                 *  輻輳回避制御を行い。
    690668                 *
    691669                 *    snd_cwnd = snd_cwnd + maxseg * maxseg / snd_cwnd;
    692670                 *
    693                  *  等しいか小さいときは、スロースタート制御を行う。
     671                 *  等しいか小さいときは、スロースタート制御を行う。
    694672                 *
    695673                 *    snd_cwnd = snd_cwnd + maxseg
     
    697675                 */
    698676                if (cw > cep->snd_ssthresh)
    699                         /* 輻輳回避制御 */
     677                        /* 輻輳回避制御 */
    700678                        incr = incr * incr / cw;
    701679
     
    706684
    707685                /*
    708                  *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
     686                 *  送信ウィンドバッファから、相手が受信確認したデータ数 (acked) のデータを削除する。
    709687                 */
    710688                if (acked > cep->swbuf_count) {
     
    719697                        }
    720698
    721                 /* 送信ウィンドバッファに空きができたことを知らせる。*/
     699                /* 送信ウィンドバッファに空きができたことを知らせる。*/
    722700                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
    723701
    724702                /*
    725                  *  送達確認されていない最小送信 SEQ (snd_una) を
    726                  *  今回送達確認された ACK まで進め、
    727                  *  次の送信データの SEQ (snd_nxt) も、新しい
    728                  *  送達確認されていない最小送信 SEQ (snd_una)
    729                  *  まで進める。
     703                 *  送達確認されていない最小送信 SEQ (snd_una) を
     704                 *  今回送達確認された ACK まで進め、
     705                 *  次の送信データの SEQ (snd_nxt) も、新しい
     706                 *  送達確認されていない最小送信 SEQ (snd_una)
     707                 *  まで進める。
    730708                 */
    731709                cep->snd_una += acked;
     
    734712
    735713                /*
    736                  *  状æ
    737 ‹ã«ã‚ˆã‚Šåˆ†å²
     714                 *  状態により分岐
    738715                 */
    739716                switch (cep->fsm_state) {
    740                 case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    741 ã¡ */
     717                case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    742718                        if (ourfinisacked) {
    743719                                cep->fsm_state = TCP_FSM_FIN_WAIT_2;
     
    745721                                }
    746722                        break;
    747                 case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK å¾
    748 ã¡ */
     723                case TCP_FSM_CLOSING:           /* 同時クローズ、FIN 交換済み、ACK 待ち */
    749724                        if (ourfinisacked) {
    750725                                /*
    751                                  *  送信した FIN が確認されていれば状æ
    752 ‹ã‚’変更し、
    753                                  *  すべてのタイマをリセットした後、2MSL タイマを設定する。
     726                                 *  送信した FIN が確認されていれば状態を変更し、
     727                                 *  すべてのタイマをリセットした後、2MSL タイマを設定する。
    754728                                 */
    755729                                cep->fsm_state = TCP_FSM_TIME_WAIT;
     
    758732                                }
    759733                        break;
    760                 case TCP_FSM_LAST_ACK:          /* APP が終了、ACK å¾
    761 ã¡ */
     734                case TCP_FSM_LAST_ACK:          /* APP が終了、ACK 待ち */
    762735                        if (ourfinisacked) {
    763736                                /*
    764                                  *  送信した FIN が確認されていれば、cep をクローズし、
    765                                  *  セグメントを破棄する。
     737                                 *  送信した FIN が確認されていれば、cep をクローズし、
     738                                 *  セグメントを破棄する。
    766739                                 */
    767740                                cep = tcp_close(cep);
     
    769742                                }
    770743                        break;
    771                 case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    772 ã¡ */
     744                case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    773745                        /*
    774                          *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
    775                          *  ACK 送信後、セグメントを破棄する。
     746                         *  相手から FIN が再送された。もう一度2MSL タイマを設定し、
     747                         *  ACK 送信後、セグメントを破棄する。
    776748                         */
    777749                        cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
     
    784756
    785757/*
    786  *  proc_ack1 -- ACK の処理 (1)
     758 *  proc_ack1 -- ACK の処理 (1)
    787759 *
    788  *    戻り値:
    789  *      RET_OK          正常
    790  *      RET_RETURN      正常、リターンする。
    791  *      RET_DROP        エラー、セグメントを破棄する。
    792  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     760 *    戻り値:
     761 *      RET_OK          正常
     762 *      RET_RETURN      正常、リターンする。
     763 *      RET_DROP        エラー、セグメントを破棄する。
     764 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    793765 *
    794766 */
     
    800772
    801773        switch (cep->fsm_state) {
    802         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    803 
    804                 /* 状æ
    805 ‹ã‚’変更する。*/
     774        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     775
     776                /* 状態を変更する。*/
    806777                if (cep->flags & TCP_CEP_FLG_NEED_FIN) {
    807778                        cep->fsm_state  = TCP_FSM_FIN_WAIT_1;
     
    812783                        cep->fsm_state  = TCP_FSM_ESTABLISHED;
    813784
    814                         /* TCP 通信端点からTCP 受付口を解放する。*/
     785                        /* TCP 通信端点からTCP 受付口を解放する。*/
    815786                        cep->rep = NULL;
    816787
     
    825796                        if (cep->rcv_nblk_tfn == TFN_TCP_ACP_CEP) {
    826797
    827                                 /* 相手のアドレスをコピーする。*/
     798                                /* 相手のアドレスをコピーする。*/
    828799
    829800#if defined(_IP6_CFG) && defined(_IP4_CFG)
     
    875846                        if (cep->snd_nblk_tfn == TFN_TCP_CON_CEP) {
    876847
    877                                 /* 相手のアドレスをコピーする。*/
     848                                /* 相手のアドレスをコピーする。*/
    878849                                *cep->p_dstaddr = cep->dstaddr;
    879850
     
    923894
    924895                /*
    925                  *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
    926                  */
    927                 if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
     896                 *  SDU がなく FIN がついていなければ、tcp_move_ra2rw() を呼出す。
     897                 */
     898                if (tcph->sum == 0 && (tcph->flags & TCP_FLG_FIN) == 0)         /* tcph->sum は SDU 長 */
    928899                        tcph->flags = tcp_move_ra2rw(cep, tcph->flags);
    929900               
    930                 cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
    931 
    932                 /* break; 下に落ちる。*/
     901                cep->snd_wl1 = tcph->seq - 1;   /* snd_wl1: ウィンド更新 SEQ */
     902
     903                /* break; 下に落ちる。*/
    933904       
    934         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
    935         case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    936         case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    937 ã¡*/
    938         case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    939 ã¡             */
    940         case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    941 ã¡     */
    942         case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    943 ã¡     */
    944         case TCP_FSM_TIME_WAIT:         /* 終了、時間å¾
    945 ã¡             */
     905        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
     906        case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     907        case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち*/
     908        case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
     909        case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     910        case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
     911        case TCP_FSM_TIME_WAIT:         /* 終了、時間待ち              */
    946912
    947913                if (SEQ_LE(tcph->ack, cep->snd_una)) {
    948914
    949915                        /*
    950                          *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
    951                          *  つまり、多重に ACK を受信したことを意味している。
     916                         *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) と同じか以前のときの処理
     917                         *  つまり、多重に ACK を受信したことを意味している。
    952918                         */
    953919
    954                         if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
     920                        if (tcph->sum == 0 && tcph->win == cep->snd_wnd) {      /* tcph->sum は SDU 長 */
    955921
    956922                                /*
    957                                  *  SDU がなく、相手のウィンドサイズが変更されていなければ、
    958                                  *  すでに送信したセグメントの中で、ACK (tcph->ack) と
    959                                  *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
    960                                  *  この場合は、高速再転送と高速リカバリを行う。
     923                                 *  SDU がなく、相手のウィンドサイズが変更されていなければ、
     924                                 *  すでに送信したセグメントの中で、ACK (tcph->ack) と
     925                                 *  同じ SEQ から始まるセグメントが、途中で消失した可能性がある。
     926                                 *  この場合は、高速再転送と高速リカバリを行う。
    961927                                 */
    962928                                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_DUP_ACKS], 1);
     
    965931
    966932                                        /*
    967                                          *  再送タイマがセットされていないとき、
    968                                          *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
    969                                          *  一致しないときは、多重 ACK 数を 0 にする。
     933                                         *  再送タイマがセットされていないとき、
     934                                         *  または、ACK (tcph->ack) と未確認の最小送信 SEQが
     935                                         *  一致しないときは、多重 ACK 数を 0 にする。
    970936                                         */
    971937                                        cep->dupacks = 0;
     
    975941
    976942                                        /*
    977                                          *  多重 ACK 数がしきい値 (標準 3) になったら
    978                                          *  高速再転送処理を開始する。
     943                                         *  多重 ACK 数がしきい値 (標準 3) になったら
     944                                         *  高速再転送処理を開始する。
    979945                                         */
    980946                                        uint_t          win;
    981947
    982948                                        /*
    983                                          *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
     949                                         *  輻輳ウィンドサイズ(snd_cwnd)のしきい値を設定する。
    984950                                         *
    985                                          *    相手の受信可能ウィンドサイズ (snd_wnd) か
    986                                          *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
    987                                          *    ただし、2 * maxseg 以上。
     951                                         *    相手の受信可能ウィンドサイズ (snd_wnd) か
     952                                         *    輻輳ウィンドサイズ (snd_cwnd) の 1/2。
     953                                         *    ただし、2 * maxseg 以上。
    988954                                         *
    989955                                         */
     
    996962                                        cep->snd_ssthresh = win * cep->maxseg;
    997963
    998                                         /* 再送タイマと往復時間をリセットする。*/
     964                                        /* 再送タイマと往復時間をリセットする。*/
    999965                                        cep->timer[TCP_TIM_REXMT] = 0;
    1000966                                        cep->rtt = 0;
    1001967
    1002                                         /* 消失したセグメントを送信する。*/
     968                                        /* 消失したセグメントを送信する。*/
    1003969                                        cep->snd_old_nxt = cep->snd_nxt;
    1004970                                        cep->snd_nxt     = tcph->ack;
     
    1006972
    1007973                                        /*
    1008                                          *  snd_nxt をå
    1009 ƒã«æˆ»ã™ã‚ˆã†ã«è¨­å®šã—て
    1010                                          *  送信を指示する。
     974                                         *  snd_nxt を元に戻すように設定して
     975                                         *  送信を指示する。
    1011976                                         */
    1012977                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT |
     
    1016981                                        sig_sem(SEM_TCP_POST_OUTPUT);
    1017982
    1018                                         /* 輻輳ウィンドサイズを更新する。*/
     983                                        /* 輻輳ウィンドサイズを更新する。*/
    1019984                                        cep->snd_cwnd = (uint16_t)(cep->snd_ssthresh
    1020985                                                           + cep->maxseg * cep->dupacks);
     
    1026991
    1027992                                        /*
    1028                                          *  多重 ACK 数がしきい値 (標準 3) をè¶
    1029 ãˆãŸã‚‰
    1030                                          *  輻輳ウィンドサイズを増加しながら再送する。
     993                                         *  多重 ACK 数がしきい値 (標準 3) を超えたら
     994                                         *  輻輳ウィンドサイズを増加しながら再送する。
    1031995                                         */
    1032996                                        cep->snd_cwnd += cep->maxseg;
    1033997
    1034                                         /* 送信を指示する。*/
     998                                        /* 送信を指示する。*/
    1035999                                        cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    10361000                                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    10451009
    10461010                /*
    1047                  *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
     1011                 *  受信確認 ACK が 未確認の最小送信 SEQ (snd_una) 以降のときの処理
    10481012                 */
    10491013                if (cep->dupacks >= MAX_TCP_REXMT_THRESH && cep->snd_cwnd > cep->snd_ssthresh)
    10501014                        /*
    1051                          *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
     1015                         *  高速再転送を行っていたときは、輻輳ウィンドサイズをしきい値まで戻す。
    10521016                         */
    10531017                        cep->snd_cwnd = (uint16_t)cep->snd_ssthresh;
     
    10571021                if (SEQ_GT(tcph->ack, cep->snd_max))
    10581022                        /*
    1059                          *  受信した ACK が送信した最大 SEQ をè¶
    1060 ãˆã¦ã„たときの処理
     1023                         *  受信した ACK が送信した最大 SEQ を超えていたときの処理
    10611024                         */
    10621025                        return drop_after_ack(input, cep, thoff);
     
    10641027                if (cep->flags & TCP_CEP_FLG_NEED_SYN) {
    10651028                        /*
    1066                          *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
     1029                         *  SYN 送信要求を取り消して、未確認の最小送信 SEQ を進める。
    10671030                         */
    10681031                        cep->flags &= ~TCP_CEP_FLG_NEED_SYN;
     
    10771040
    10781041/*
    1079  *  update_wnd -- ウィンドサイズを更新する。
     1042 *  update_wnd -- ウィンドサイズを更新する。
    10801043 *
    1081  *    戻り値: 送信がå¿
    1082 è¦ãªã‚‰ true を返す。
     1044 *    戻り値: 送信が必要なら true を返す。
    10831045 */
    10841046
     
    10881050
    10891051        /*
    1090          *  更新条件
     1052         *  更新条件
    10911053         *
    1092          *    ACK フラグがセットされている &&
    1093          *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
    1094          *     å‰å›žã‚¦ã‚£ãƒ³ãƒ‰ã‚’更新した SEQ (snd_wl1) が SEQ と同じ &&
    1095          *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
    1096          *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
    1097          *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
     1054         *    ACK フラグがセットされている &&
     1055         *    (前回ウィンドを更新した SEQ (snd_wl1) が SEQ より前 ||
     1056         *     前回ウィンドを更新した SEQ (snd_wl1) が SEQ と同じ &&
     1057         *     (前回ウィンドを更新した ACK (snd_wl2) が ACK より前 ||
     1058         *      (前回ウィンドを更新した ACK (snd_wl2) が ACK と同じ &&
     1059         *       WIN が相手の受信可能ウィンドサイズ (snd_wnd) より大きい
    10981060         *       )
    10991061         *      )
     
    11111073
    11121074                if (cep->snd_wnd > cep->max_sndwnd)
    1113                         /* 今までの最大送信ウィンドサイズを更新する。*/
     1075                        /* 今までの最大送信ウィンドサイズを更新する。*/
    11141076                        cep->max_sndwnd = cep->snd_wnd;
    11151077
     
    11191081
    11201082                        /*
    1121                          *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
    1122                          *  相手の受信ウィンドが空くのをå¾
    1123 ã£ã¦ã„るときの処理
     1083                         *  送信ウィンドバッファ用のネットワークバッファ割り当て中で、
     1084                         *  相手の受信ウィンドが空くのを待っているときの処理
    11241085                         */
    11251086                        if (cep->snd_wnd > 0) {
    11261087
    11271088                                /*
    1128                                  *  相手の受信ウィンドが空いたときは、
    1129                                  *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
     1089                                 *  相手の受信ウィンドが空いたときは、
     1090                                 *  送信ウィンドバッファ用のネットワークバッファ割り当てを再開する。
    11301091                                 */
    11311092                                cep->flags = (cep->flags & ~TCP_CEP_FLG_WBCS_MASK)
     
    11441105
    11451106/*
    1146  *  proc_urg -- 緊急データつきのセグメントの処理
     1107 *  proc_urg -- 緊急データつきのセグメントの処理
    11471108 */
    11481109
     
    11551116            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    11561117
    1157                 /* 緊急データつきのセグメントの処理 */
     1118                /* 緊急データつきのセグメントの処理 */
    11581119
    11591120                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_URG_SEGS], 1);
     
    11611122
    11621123                        /*
    1163                          *  緊急ポインタの位置が受信ウィンドバッファの
    1164                          *  範囲をè¶
    1165 ãˆã‚‹ã¨ãã¯ä½•ã‚‚しない。
     1124                         *  緊急ポインタの位置が受信ウィンドバッファの
     1125                         *  範囲を超えるときは何もしない。
    11661126                         */
    11671127                        tcph->urp    = 0;
     
    11701130
    11711131                if (SEQ_GT(tcph->seq + tcph->urp, cep->rcv_up))
    1172                         /* 緊急ポインタが更新されたときの処理 */
     1132                        /* 緊急ポインタが更新されたときの処理 */
    11731133                        cep->rcv_up = tcph->seq + tcph->urp;
    11741134
    1175                 if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
     1135                if ((tcph->flags & TCP_FLG_URG) && (tcph->urp + TCP_CFG_URG_OFFSET) < tcph->sum) {      /* tcph->sum は TCP の SDU 長 */
    11761136
    11771137                        /*
    1178                          *  緊急ポインタの位置が、今回受信したセグメントå†
    1179 ã®å ´åˆã¯ã€
    1180                          *  コールバック関数を呼び出す。
     1138                         *  緊急ポインタの位置が、今回受信したセグメント内の場合は、
     1139                         *  コールバック関数を呼び出す。
    11811140                         */
    11821141                        cep->urg_tcph = tcph;
     
    12011160
    12021161                        if (cep->urg_tcph != NULL) {
    1203                                 /* コールバック関数å†
    1204 ã§ tcp_rcv_oob() を呼出さなかった。*/
     1162                                /* コールバック関数内で tcp_rcv_oob() を呼出さなかった。*/
    12051163                                cep->urg_tcph = NULL;
    12061164                                tcph->urp = 0;
     
    12081166                        else {
    12091167                                /*
    1210                                  *  コールバック関数å†
    1211 ã§ tcp_rcv_oob() を呼出した時は、
    1212                                  *  SDU 長の補正値を設定する。
     1168                                 *  コールバック関数内で tcp_rcv_oob() を呼出した時は、
     1169                                 *  SDU 長の補正値を設定する。
    12131170                                 */
    12141171                                tcph->urp = 1;
     
    12371194
    12381195/*
    1239  *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
     1196 *  drop_after_ack -- 受信セグメントを破棄した後、ACK を返す (注意: 名前とは合っていない)。
    12401197 *
    1241  *    戻り値:
    1242  *      RET_RETURN      正常、リターンする。
    1243  *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
     1198 *    戻り値:
     1199 *      RET_RETURN      正常、リターンする。
     1200 *      RET_RST_DROP    エラー、RST を送信し、セグメントを破棄する。
    12441201 */
    12451202
     
    12501207
    12511208        /*
    1252          *    SYN 受信状æ
    1253 ‹ã§ã€ACK が送達確認されていない最小送信 SEQ (snd_una) より
    1254          *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
    1255          *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
    1256          *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
     1209         *    SYN 受信状態で、ACK が送達確認されていない最小送信 SEQ (snd_una) より
     1210         *    前の値か、送信された最大 SEQ (snd_max) より後の値の場合は、相手に RST を
     1211         *    送って終了する。これは、"LAND" DoS 攻撃への防御であり、偽造された SYN
     1212         *    セグメントを送信しつづけるポート間での ACK ストームを防ぐ。
    12571213         */
    12581214        if (cep->fsm_state == TCP_FSM_SYN_RECVD && (tcph->flags & TCP_FLG_ACK) &&
     
    12631219        syscall(rel_net_buf(input));
    12641220
    1265         /* 送信を指示する。*/
     1221        /* 送信を指示する。*/
    12661222        cep->flags |=  TCP_CEP_FLG_ACK_NOW | TCP_CEP_FLG_POST_OUTPUT;
    12671223        sig_sem(SEM_TCP_POST_OUTPUT);
     
    12701226
    12711227/*
    1272  *  close_connection -- コネクション開放処理、相手から FIN を受信した。
     1228 *  close_connection -- コネクション開放処理、相手から FIN を受信した。
    12731229 */
    12741230
     
    12951251
    12961252        switch (cep->fsm_state) {
    1297         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
    1298         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了               */
     1253        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
     1254        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了           */
    12991255                cep->fsm_state = TCP_FSM_CLOSE_WAIT;
    13001256                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_RWBUF_READY));
    13011257                break;
    13021258
    1303         case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK å¾
    1304 ã¡ */
     1259        case TCP_FSM_FIN_WAIT_1:        /* APP が終了、FIN 送信済み、ACK 待ち */
    13051260                cep->fsm_state = TCP_FSM_CLOSING;
    13061261                break;
    13071262
    1308         case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN å¾
    1309 ã¡ */
     1263        case TCP_FSM_FIN_WAIT_2:        /* 相手からの FIN 待ち */
    13101264                cep->fsm_state = TCP_FSM_TIME_WAIT;
    13111265                tcp_cancel_timers(cep);
     
    13131267
    13141268                /*
    1315                  *  FIN WAIT 2 状æ
    1316 ‹ã§ã¯ã€
    1317                  *  受信は可能であるが、すでに送信は終了している。
    1318                  *  相手の送信も終了したので、å
    1319 ¥åŠ›ã‚¿ã‚¹ã‚¯ã®ã¿èµ·åºŠã™ã‚‹ã€‚
     1269                 *  FIN WAIT 2 状態では、
     1270                 *  受信は可能であるが、すでに送信は終了している。
     1271                 *  相手の送信も終了したので、入力タスクのみ起床する。
    13201272                 */
    13211273                syscall(set_flg(cep->snd_flgid, TCP_CEP_EVT_SWBUF_READY));
     
    13231275#if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0
    13241276
    1325                 /* 相手からの FIN に対して応答を返す。*/
     1277                /* 相手からの FIN に対して応答を返す。*/
    13261278                tcp_respond(NULL, cep, cep->rcv_nxt, cep->snd_una,
    13271279                            cep->rbufsz - cep->rwbuf_count, TCP_FLG_ACK);
     
    13301282
    13311283                /*
    1332                  *  å¿
    1333 è¦ãªæƒ
    1334 å ±ã‚’ Time Wait 用 TCP 通信端点に移して、
    1335                  *  標準の TCP 通信端点を開放する。
     1284                 *  必要な情報を Time Wait 用 TCP 通信端点に移して、
     1285                 *  標準の TCP 通信端点を開放する。
    13361286                 */
    13371287                tcp_move_twcep(cep);
     
    13411291                break;
    13421292
    1343         case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間å¾
    1344 ã¡ */
     1293        case TCP_FSM_TIME_WAIT:         /* 相手からの FIN 受信済み、時間待ち */
    13451294                cep->timer[TCP_TIM_2MSL] = 2 * TCP_TVAL_MSL;
    13461295                break;
     
    13491298
    13501299/*
    1351  *  tcp_input -- TCP のå
    1352 ¥åŠ›é–¢æ•°
     1300 *  tcp_input -- TCP の入力関数
    13531301 *
    1354  *      注意: input には IF ヘッダと IP ヘッダがå
    1355 ˆé ­ã«ã‚る。
     1302 *      注意: input には IF ヘッダと IP ヘッダが先頭にある。
    13561303 */
    13571304
     
    13791326        NET_COUNT_MIB(tcp_stats.tcpInSegs, 1);
    13801327
    1381         /* ヘッダ長をチェックする。*/
     1328        /* ヘッダ長をチェックする。*/
    13821329        if (input->len < IF_IP_TCP_HDR_SIZE(input)) {
    13831330                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
     
    13871334        tcph = GET_TCP_HDR(input, *offp);
    13881335
    1389         seglen  = input->len - *offp;                           /* TCP のセグメント長 */
     1336        seglen  = input->len - *offp;                           /* TCP のセグメント長 */
    13901337
    13911338        if (IN_CKSUM(input, IPPROTO_TCP, *offp, (uint_t)seglen) != 0) {
     
    13941341                }
    13951342
    1396         /* TCP ヘッダ長をチェックする。*/
     1343        /* TCP ヘッダ長をチェックする。*/
    13971344        if (TCP_HDR_LEN(tcph->doff) < TCP_HDR_SIZE || TCP_HDR_LEN(tcph->doff) > seglen) {
    13981345                NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_BAD_HEADERS], 1);
    13991346                goto drop;
    14001347                }
    1401         tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
     1348        tcph->sum = seglen - TCP_HDR_LEN(tcph->doff);           /* ここから tcph->sum は TCP の SDU 長 */
    14021349
    14031350        /*
    1404          *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
    1405          *  ただし、RFC1644 T/TCP 拡張機能と競合する。
     1351         *  SYN と FIN の両ビットがセットされていれば破棄する。nmap 等の対策
     1352         *  ただし、RFC1644 T/TCP 拡張機能と競合する。
    14061353         */
    14071354        if ((tcph->flags & (TCP_FLG_SYN | TCP_FLG_FIN)) == (TCP_FLG_SYN | TCP_FLG_FIN))
    14081355                goto drop;
    14091356
    1410         /* ネットワークオーダーからホストオーダーに変換する。*/
     1357        /* ネットワークオーダーからホストオーダーに変換する。*/
    14111358
    14121359        NTOHL(tcph->seq);
     
    14221369
    14231370        /*
    1424          *  状æ
    1425 ‹ãŒ Time Wait 中の CEP を探索する。
     1371         *  状態が Time Wait 中の CEP を探索する。
    14261372         */
    14271373        twcep = tcp_find_twcep(input, *offp);
    14281374        if (twcep != NULL) {
    14291375
    1430                 if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
     1376                if (tcph->flags & TCP_FLG_RST)          /* RST フラグを受信したときは無視する。*/
    14311377                        goto drop;
    14321378                else {
    14331379
    14341380                        /*
    1435                          *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
    1436                          *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
    1437                          *    損失したことを意味しているので、ACK セグメントを再送する。
     1381                         *    TCP 通信端点が Time Wait の時、相手ホストからセグメントが来たときは、
     1382                         *    相手ホストの FIN に対する自ホストの ACK セグメントが途中で
     1383                         *    損失したことを意味しているので、ACK セグメントを再送する。
    14381384                         */
    14391385
    1440                         /* ホストオーダーからネットワークオーダーに戻す。*/
     1386                        /* ホストオーダーからネットワークオーダーに戻す。*/
    14411387                        HTONS(tcph->sport);
    14421388                        HTONS(tcph->dport);
     
    14471393                }
    14481394        else
    1449                 /* 標準の TCP 通信端点を得る。*/
     1395                /* 標準の TCP 通信端点を得る。*/
    14501396                cep = tcp_find_cep(input, *offp);
    14511397
    14521398#else   /* of #if defined(NUM_TCP_TW_CEP_ENTRY) && NUM_TCP_TW_CEP_ENTRY > 0 */
    14531399
    1454         /* TCP 通信端点を得る。*/
     1400        /* TCP 通信端点を得る。*/
    14551401        cep = tcp_find_cep(input, *offp);
    14561402
     
    14581404
    14591405        /*
    1460          *  TCP 通信端点がない場合と CEP の状æ
    1461 ‹ãŒã‚¯ãƒ­ãƒ¼ã‚ºãªã‚‰ç ´æ£„する。
     1406         *  TCP 通信端点がない場合と CEP の状態がクローズなら破棄する。
    14621407         */
    14631408        if (cep == NULL) {
     
    14771422
    14781423        /*
    1479          *  コネクション開設済みでセグメントを受信したときは、
    1480          *  アイドル時間と生存確認タイマをリセットする。
     1424         *  コネクション開設済みでセグメントを受信したときは、
     1425         *  アイドル時間と生存確認タイマをリセットする。
    14811426         */
    14821427        cep->idle = 0;
     
    14851430                }
    14861431
    1487         /* CEP の状æ
    1488 ‹ãŒ LISTEN 以外の時は、オプションを処理する。*/
     1432        /* CEP の状態が LISTEN 以外の時は、オプションを処理する。*/
    14891433        if (cep->fsm_state != TCP_FSM_LISTEN)
    14901434                parse_option(tcph, cep);
    14911435
    14921436        /*
    1493          *  受信可能ウィンドサイズを計算する。
     1437         *  受信可能ウィンドサイズを計算する。
    14941438         *
    1495          *  rcv_nxt:     å—信を期å¾
    1496 ã—ている最小の SEQ(これ以前は受信済み)
    1497          *  rcv_adv:     å—信を期å¾
    1498 ã—ている最大の SEQ
    1499          *  rbufsz:      受信ウィンドバッファサイズ
    1500          *  rwbuf_count:  受信ウィンドバッファにあるデータ量
    1501          *  tcph->sum:   ä»Šå›žå—信した SDU サイズ
     1439         *  rcv_nxt:     受信を期待している最小の SEQ(これ以前は受信済み)
     1440         *  rcv_adv:     受信を期待している最大の SEQ
     1441         *  rbufsz:      受信ウィンドバッファサイズ
     1442         *  rwbuf_count:  受信ウィンドバッファにあるデータ量
     1443         *  tcph->sum:   今回受信した SDU サイズ
    15021444         *
    1503          *  今回受信したセグメントを順序整列キューに連結する
    1504          *  可能性があるので tcph->sum を考æ
    1505 ®ã™ã‚‹ã€‚
     1445         *  今回受信したセグメントを順序整列キューに連結する
     1446         *  可能性があるので tcph->sum を考慮する。
    15061447         *
    15071448         */
     
    15141455                cep->rcv_wnd = cep->rcv_adv - cep->rcv_nxt;
    15151456
    1516         /* CEP の状æ
    1517 ‹ã«ã‚ˆã‚Šå‡¦ç†ã‚’行う。*/
    1518 
    1519         if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
     1457        /* CEP の状態により処理を行う。*/
     1458
     1459        if (cep->fsm_state == TCP_FSM_LISTEN) {         /* 受動オープン (LISTEN) の処理。*/
    15201460                if ((ret = listening(input, cep, *offp, iss)) == RET_RST_DROP)
    15211461                        goto reset_drop;
    15221462                else if (ret == RET_DROP)
    15231463                        goto drop;
    1524                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1525 
    1526                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1464                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1465
     1466                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    15271467                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    15281468                                goto drop;
     
    15331473                        }
    15341474                }
    1535         else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み        */
     1475        else if (cep->fsm_state == TCP_FSM_SYN_SENT) {  /* 能動オープン、SYN 送信済み      */
    15361476                if ((ret = syn_sent(tcph, cep)) == RET_RST_DROP)
    15371477                        goto reset_drop;
    15381478                else if (ret == RET_DROP)
    15391479                        goto drop;
    1540                 trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
    1541 
    1542                 if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
     1480                trim_length(tcph, cep);                 /* 受信した SDU 長を調整する。*/
     1481
     1482                if (tcph->flags & TCP_FLG_ACK) {        /* ACK フラグの処理 */
    15431483                        if ((ret = proc_ack2(input, cep, *offp, &needoutput)) == RET_DROP)
    15441484                                goto drop;
     
    15501490                }
    15511491        else {
    1552                 if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
     1492                if (cep->fsm_state == TCP_FSM_SYN_RECVD) {      /* SYN を受信、SYN 送信済み     */
    15531493                        /*
    1554                          *  相手から受信確認が送られて来ても、
     1494                         *  相手から受信確認が送られて来ても、
    15551495                         *
    1556                          *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
    1557                          *           é€ä¿¡ã—た最大     SEQ (snd_max) < ACK
     1496                         *    ACK <= 未確認の最小送信 SEQ (snd_una) &&
     1497                         *           送信した最大     SEQ (snd_max) < ACK
    15581498                         *
    1559                          *  なら、リセットを送ってセグメントを破棄する。
     1499                         *  なら、リセットを送ってセグメントを破棄する。
    15601500                         */
    15611501                        if ((tcph->flags & TCP_FLG_ACK) &&
     
    15661506
    15671507                /*
    1568                  *  RST フラグを受信したときの処理 (異常切断)
     1508                 *  RST フラグを受信したときの処理 (異常切断)
    15691509                 */
    15701510                if (tcph->flags & TCP_FLG_RST) {
     
    15721512                            SEQ_LT(tcph->seq, cep->last_ack_sent + cep->rcv_wnd)) {
    15731513                                /*
    1574                                  *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
    1575                                  *  から、受信ウインドウサイズまでの間の処理
     1514                                 *  受信したセグメントの SEQ が、最後に送信した ACK (last_ack_sent)
     1515                                 *  から、受信ウインドウサイズまでの間の処理
    15761516                                 */
    15771517                                switch (cep->fsm_state) {
    1578                                 case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み          */
    1579 
    1580                                         cep->net_error = EV_CNNRF;      /* 接続不能 */
     1518                                case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み            */
     1519
     1520                                        cep->net_error = EV_CNNRF;      /* 接続不能 */
    15811521                                        cep->error     = E_CLS;
    15821522                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
     
    15851525                                        break;
    15861526
    1587                                 case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                       */
    1588                                 case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズå¾
    1589 ã¡             */
     1527                                case TCP_FSM_ESTABLISHED:       /* コネクション開設完了                   */
     1528                                case TCP_FSM_CLOSE_WAIT:        /* FIN 受信、クローズ待ち                */
    15901529                                        NET_COUNT_MIB(tcp_stats.tcpEstabResets, 1);
    15911530                                        /* fallthrough */
    15921531
    1593                                 case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み              */
    1594                                 case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FINå¾
    1595 ã¡     */
    1596 
    1597                                         cep->net_error = EV_CNRST;      /* 接続リセット */
     1532                                case TCP_FSM_FIN_WAIT_1:        /* 終了して、FIN 送信済み                */
     1533                                case TCP_FSM_FIN_WAIT_2:        /* 終了、FIN 伝達確認受信、FIN待ち  */
     1534
     1535                                        cep->net_error = EV_CNRST;      /* 接続リセット */
    15981536                                        cep->error     = E_CLS;
    15991537                                        NET_COUNT_TCP(net_count_tcp[NC_TCP_RECV_RSTS], 1);
    16001538                                        /* no break; */
    16011539
    1602                                 case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK å¾
    1603 ã¡     */
    1604                                 case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK å¾
    1605 ã¡     */
     1540                                case TCP_FSM_CLOSING:           /* 終了、FIN 交換済み、ACK 待ち   */
     1541                                case TCP_FSM_LAST_ACK:          /* FIN 受信、終了、ACK 待ち     */
    16061542
    16071543                                        cep = tcp_close(cep);
     
    16131549
    16141550                /*
    1615                  *  CEP の状æ
    1616 ‹ãŒ SYN を受信し、SYN 送信済みの場合は、
    1617                  *  受信ウィンドに収まるようにデータを
    1618                  *  調整する前に、この接続によるパケットかどうかを検証する。
     1551                 *  CEP の状態が SYN を受信し、SYN 送信済みの場合は、
     1552                 *  受信ウィンドに収まるようにデータを
     1553                 *  調整する前に、この接続によるパケットかどうかを検証する。
    16191554                 *
    1620                  *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
     1555                 *    受信した相手の SEQ < 相手の SEQ の初期値 (irs)
    16211556                 *
    1622                  *  これは、"LAND" DoS 攻撃の防御である。
     1557                 *  これは、"LAND" DoS 攻撃の防御である。
    16231558                 */
    16241559                if (cep->fsm_state == TCP_FSM_SYN_RECVD && SEQ_LT(tcph->seq, cep->irs)) {
     
    16271562
    16281563                /*
    1629                  *  受信を期å¾
    1630 ã—ている最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
    1631                  *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
    1632                  *  削除する。
     1564                 *  受信を期待している最小の SEQ (rcv_nxt) - 受信した相手の SEQ が
     1565                 *  正なら、rcv_nxt 以前のデータはすでに受信しているので、その部分を
     1566                 *  削除する。
    16331567                 *                           <---------- rcv_wnd --------->
    16341568                 *                           rcv_nxt                      rcv_nxt + rcv_wnd
     
    16421576                 *           ^                      ^
    16431577                 *           seq                    seq + len
    1644                  *           <---------------> 削除する。
     1578                 *           <---------------> 削除する。
    16451579                 */
    16461580                todrop = cep->rcv_nxt - tcph->seq;
     
    16481582
    16491583                        /*
    1650                          *  SYN フラグがついているときは、その分 (1 オクテット)
    1651                          *  SEQ を進め、緊急ポインタと削除する長さを調整する。
     1584                         *  SYN フラグがついているときは、その分 (1 オクテット)
     1585                         *  SEQ を進め、緊急ポインタと削除する長さを調整する。
    16521586                         */
    16531587                        if (tcph->flags & TCP_FLG_SYN) {
     
    16621596
    16631597                        /*
    1664                          *  削除する長さが SDU より長い、つまり、受信を期å¾
    1665 ã—ている
    1666                          *  最小の SEQ (rcv_nxt) に達していないか、
    1667                          *  削除する長さが SDU と同じで、FIN フラグがついてなければ
    1668                          *  å
    1669 ¨ã¦å‰Šé™¤ã™ã‚‹ã€‚
     1598                         *  削除する長さが SDU より長い、つまり、受信を期待している
     1599                         *  最小の SEQ (rcv_nxt) に達していないか、
     1600                         *  削除する長さが SDU と同じで、FIN フラグがついてなければ
     1601                         *  全て削除する。
    16701602                         */
    1671                         if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
     1603                        if ( todrop >  tcph->sum ||             /* tcph->sum は TCP の SDU 長 */
    16721604                            (todrop == tcph->sum && (tcph->flags & TCP_FLG_FIN) == 0)) {
    16731605                                tcph->flags &= ~TCP_FLG_FIN;
    16741606                                cep->flags |= TCP_CEP_FLG_ACK_NOW;
    1675                                 todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
     1607                                todrop = tcph->sum;             /* tcph->sum は TCP の SDU 長 */
    16761608                                }
    16771609
    16781610                        /*
    1679                          *  SDU を前に詰める。
     1611                         *  SDU を前に詰める。
    16801612                         */
    1681                         if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
     1613                        if (todrop < tcph->sum) {               /* tcph->sum は TCP の SDU 長 */
    16821614                                memcpy(GET_TCP_SDU(input, *offp),
    16831615                                       GET_TCP_SDU(input, *offp) + todrop, (size_t)(tcph->sum - todrop));
     
    16851617
    16861618                        /*
    1687                          *  SEQ と SDU 長を調整する。
     1619                         *  SEQ と SDU 長を調整する。
    16881620                         */
    16891621                        tcph->seq +=     todrop;
    1690                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1622                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    16911623
    16921624                        /*
    1693                          *  緊急ポインタを調整する。
     1625                         *  緊急ポインタを調整する。
    16941626                         */
    16951627                        if (tcph->urp > todrop)
     
    17041636
    17051637                /* 
    1706                  *  もしユーザタスクが終了した後に、データを受信した
    1707                  *  場合は、RST を送る。
    1708                  */
    1709                 if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
     1638                 *  もしユーザタスクが終了した後に、データを受信した
     1639                 *  場合は、RST を送る。
     1640                 */
     1641                if (cep->fsm_state == TCP_FSM_LAST_ACK && tcph->sum > 0) {      /* tcph->sum は TCP の SDU 長 */
    17101642                        cep = tcp_close(cep);
    17111643                        goto reset_drop;
     
    17131645
    17141646                /*
    1715                  *  受信セグメントが受信ウィンドをè¶
    1716 ãˆã‚‹å ´åˆã¯ã€
    1717                  *  è¶
    1718 ãˆãŸåˆ†ã‚’削る。
     1647                 *  受信セグメントが受信ウィンドを超える場合は、
     1648                 *  超えた分を削る。
    17191649                 *
    17201650                 *       <---------- rcv_wnd --------->
     
    17291659                 *                    ^                      ^
    17301660                 *                    seq                    seq + len
    1731                  *                                     <-----> 削除する。
    1732                  */
    1733                 todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
     1661                 *                                     <-----> 削除する。
     1662                 */
     1663                todrop = (tcph->seq + tcph->sum) - (cep->rcv_nxt + cep->rcv_wnd);       /* tcph->sum は TCP の SDU 長 */
    17341664                if (todrop > 0) {
    1735                         if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
     1665                        if (todrop > tcph->sum) {                                       /* tcph->sum は TCP の SDU 長 */
    17361666                                /*
    1737                                  *  受信した SDU のå
    1738 ¨ã¦ãŒå—信ウィンドをè¶
    1739 ãˆã‚‹å ´åˆã€‚
     1667                                 *  受信した SDU の全てが受信ウィンドを超える場合。
    17401668                                 *
    1741                                  *  TIME_WAIT 中に、新たな接続要求を受信したら
    1742                                  *  古い接続を破棄し、新たな接続を開始する。
    1743                                  *  ただし、SEQ は前より進んでいなければならない。
     1669                                 *  TIME_WAIT 中に、新たな接続要求を受信したら
     1670                                 *  古い接続を破棄し、新たな接続を開始する。
     1671                                 *  ただし、SEQ は前より進んでいなければならない。
    17441672                                 */
    17451673                                if ((tcph->flags & TCP_FLG_SYN) &&
     
    17531681
    17541682                                /*
    1755                                  *  受信ウィンドが 0 で、受信した SEQ と
    1756                                  *  受信を期å¾
    1757 ã—ている最小の SEQ が一致したときは
    1758                                  *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
     1683                                 *  受信ウィンドが 0 で、受信した SEQ と
     1684                                 *  受信を期待している最小の SEQ が一致したときは
     1685                                 *  ACK を返す。それ以外はデータを破棄し、ACK を返す。
    17591686                                 */
    17601687                                if (cep->rcv_wnd == 0 && (tcph->seq == cep->rcv_nxt || tcph->sum == 0)) {
     
    17671694                                        }
    17681695                                }
    1769                         tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
     1696                        tcph->sum -= (uint16_t)todrop;  /* tcph->sum は TCP の SDU 長 */
    17701697                        tcph->flags &= ~(TCP_FLG_PUSH | TCP_FLG_FIN);
    17711698                        }
    17721699
    17731700                /*
    1774                  *  もし、SYN がセットされていれば、
    1775                  *  エラーなので RST を送り、接続を破棄する。
     1701                 *  もし、SYN がセットされていれば、
     1702                 *  エラーなので RST を送り、接続を破棄する。
    17761703                 */
    17771704                if (tcph->flags & TCP_FLG_SYN) {
     
    17821709
    17831710                /*
    1784                  *  もし、ACK がセットされていない場合は、
    1785                  *  状æ
    1786 ‹ãŒ SYN 受信済みか
    1787                  *  SYN を送信しようとしていれば、処理を続けるが、
    1788                  *  それ以外はセグメントを破棄して終了する。
     1711                 *  もし、ACK がセットされていない場合は、
     1712                 *  状態が SYN 受信済みか
     1713                 *  SYN を送信しようとしていれば、処理を続けるが、
     1714                 *  それ以外はセグメントを破棄して終了する。
    17891715                 */
    17901716                if ((tcph->flags & TCP_FLG_ACK) == 0) {
     
    17941720                else {
    17951721                        /*
    1796                          * ACK の処理
     1722                         * ACK の処理
    17971723                         */
    17981724                        ret = proc_ack1(input, cep, *offp, &needoutput);
     
    18081734/* step 6 */
    18091735
    1810         /* 送信ウィンドを更新する。*/
     1736        /* 送信ウィンドを更新する。*/
    18111737        if (update_wnd(tcph, cep) == true)
    18121738                needoutput = true;
    18131739
    1814         /* 緊急データを処理する。*/
     1740        /* 緊急データを処理する。*/
    18151741        proc_urg(tcph, cep);
    18161742
     
    18181744
    18191745        /*
    1820          *  SDU があるか、FIN を未受信の状æ
    1821 ‹ã§ã€æœ€åˆã« FIN を受信したとき、
    1822          *  受信セグメントキューに net_buf を追加する。
    1823          *  それ以外の場合は、セグメントを破棄する。
     1746         *  SDU があるか、FIN を未受信の状態で、最初に FIN を受信したとき、
     1747         *  受信セグメントキューに net_buf を追加する。
     1748         *  それ以外の場合は、セグメントを破棄する。
    18241749         */
    18251750        flags = tcph->flags;
    1826         if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
     1751        if ((tcph->sum > 0 || (flags & TCP_FLG_FIN)) &&         /* tcph->sum は TCP の SDU 長 */
    18271752            TCP_FSM_HAVE_RCVD_FIN(cep->fsm_state) == 0) {
    18281753                flags = reassemble(input, cep, *offp, flags);
     
    18341759
    18351760        /*
    1836          *  FIN を受信したらコネクションをクローズする。
     1761         *  FIN を受信したらコネクションをクローズする。
    18371762         */
    18381763        if (flags & TCP_FLG_FIN)
    18391764                close_connection(cep, &needoutput);
    18401765
    1841         /* 出力を行った後終了する。*/
     1766        /* 出力を行った後終了する。*/
    18421767        if (needoutput == true || (cep->flags & TCP_CEP_FLG_ACK_NOW)) {
    1843                 /* 送信を指示する。*/
     1768                /* 送信を指示する。*/
    18441769                cep->flags |=  TCP_CEP_FLG_POST_OUTPUT;
    18451770                sig_sem(SEM_TCP_POST_OUTPUT);
     
    18501775reset_drop:
    18511776        /*
    1852          *  RST 送信処理
     1777         *  RST 送信処理
    18531778         */
    18541779
     
    18561781                goto drop;
    18571782
    1858         /* ホストオーダーからネットワークオーダーに戻す。*/
     1783        /* ホストオーダーからネットワークオーダーに戻す。*/
    18591784
    18601785        HTONS(tcph->sport);
     
    18701795        else {
    18711796                if (tcph->flags & TCP_FLG_SYN)
    1872                         tcph->sum ++;           /* tcph->sum は SDU 長 */
     1797                        tcph->sum ++;           /* tcph->sum は SDU 長 */
    18731798                tcp_respond(input, cep, tcph->seq + tcph->sum, 0, rbfree, TCP_FLG_RST | TCP_FLG_ACK);
    18741799                }
    18751800
    1876         /* input は tcp_respoond で返却される。*/
     1801        /* input は tcp_respoond で返却される。*/
    18771802        NET_COUNT_TCP(net_count_tcp[NC_TCP_SEND_RSTS], 1);
    18781803        NET_COUNT_MIB(tcp_stats.tcpOutRsts, 1);
Note: See TracChangeset for help on using the changeset viewer.