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

文字コードを設定

File:
1 edited

Legend:

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

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    55 *                   Tomakomai National College of Technology, JAPAN
    66 *
    7  *  上記著作権è€
    8 ã¯ï¼Œä»¥ä¸‹ã® (1)~(4) の条件か,Free Software Foundation
    9  *  によってå
    10 ¬è¡¨ã•ã‚Œã¦ã„ã‚‹ GNU General Public License の Version 2 に記
    11  *  述されている条件を満たす場合に限り,本ソフトウェア(本ソフトウェア
    12  *  を改変したものを含む.以下同じ)を使用・複製・改変・再é
    13 å¸ƒï¼ˆä»¥ä¸‹ï¼Œ
    14  *  利用と呼ぶ)することを無償で許諾する.
    15  *  (1) 本ソフトウェアをソースコードの形で利用する場合には,上記の著作
    16  *      権表示,この利用条件および下記の無保証規定が,そのままの形でソー
    17  *      スコード中に含まれていること.
    18  *  (2) 本ソフトウェアを,ライブラリ形式など,他のソフトウェア開発に使
    19  *      用できる形で再é
    20 å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é
    21 å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
    22  *      è€
    23 ãƒžãƒ‹ãƒ¥ã‚¢ãƒ«ãªã©ï¼‰ã«ï¼Œä¸Šè¨˜ã®è‘—作権表示,この利用条件および下記
    24  *      の無保証規定を掲載すること.
    25  *  (3) 本ソフトウェアを,機器に組み込むなど,他のソフトウェア開発に使
    26  *      用できない形で再é
    27 å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®æ¡ä»¶ã‚’満たすこと.
    28  *    (a) 再é
    29 å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€
    30 ãƒžãƒ‹ãƒ¥ã‚¢ãƒ«ãªã©ï¼‰ã«ï¼Œä¸Šè¨˜ã®è‘—
    31  *        作権表示,この利用条件および下記の無保証規定を掲載すること.
    32  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
    33  *      害からも,上記著作権è€
    34 ãŠã‚ˆã³TOPPERSプロジェクトをå
    35 è²¬ã™ã‚‹ã“と.
     7 *  上記著作権者は,以下の (1)~(4) の条件か,Free Software Foundation
     8 *  によって公表されている GNU General Public License の Version 2 に記
     9 *  述されている条件を満たす場合に限り,本ソフトウェア(本ソフトウェア
     10 *  を改変したものを含む.以下同じ)を使用・複製・改変・再配布(以下,
     11 *  利用と呼ぶ)することを無償で許諾する.
     12 *  (1) 本ソフトウェアをソースコードの形で利用する場合には,上記の著作
     13 *      権表示,この利用条件および下記の無保証規定が,そのままの形でソー
     14 *      スコード中に含まれていること.
     15 *  (2) 本ソフトウェアを,ライブラリ形式など,他のソフトウェア開発に使
     16 *      用できる形で再配布する場合には,再配布に伴うドキュメント(利用
     17 *      者マニュアルなど)に,上記の著作権表示,この利用条件および下記
     18 *      の無保証規定を掲載すること.
     19 *  (3) 本ソフトウェアを,機器に組み込むなど,他のソフトウェア開発に使
     20 *      用できない形で再配布する場合には,次の条件を満たすこと.
     21 *    (a) 再配布に伴うドキュメント(利用者マニュアルなど)に,上記の著
     22 *        作権表示,この利用条件および下記の無保証規定を掲載すること.
     23 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
     24 *      害からも,上記著作権者およびTOPPERSプロジェクトを免責すること.
    3625 *
    37  *  本ソフトウェアは,無保証で提供されているものである.上記著作権è€
    38 ãŠ
    39  *  よびTOPPERSプロジェクトは,本ソフトウェアに関して,その適用可能性も
    40  *  含めて,いかなる保証も行わない.また,本ソフトウェアの利用により直
    41  *  接的または間接的に生じたいかなる損害に関しても,その責任を負わない.
     26 *  本ソフトウェアは,無保証で提供されているものである.上記著作権者お
     27 *  よびTOPPERSプロジェクトは,本ソフトウェアに関して,その適用可能性も
     28 *  含めて,いかなる保証も行わない.また,本ソフトウェアの利用により直
     29 *  接的または間接的に生じたいかなる損害に関しても,その責任を負わない.
    4230 *
    4331 *  @(#) $Id$
     
    132120
    133121/*
    134  *  IPv4 と IPv6 の切り替えマクロ
     122 *  IPv4 と IPv6 の切り替えマクロ
    135123 */
    136124
     
    152140
    153141/*
    154  *  TINET をライブラリ化しない場合は、å
    155 ¨ã¦ã®æ©Ÿèƒ½ã‚’
    156  *  オブジェクトファイルに出力するため、マクロを有効にする。
     142 *  TINET をライブラリ化しない場合は、全ての機能を
     143 *  オブジェクトファイルに出力するため、マクロを有効にする。
    157144 */
    158145
     
    182169
    183170/*
    184  *  tcp_cre_rep -- TCP 受付口の生成【拡張機能】
     171 *  tcp_cre_rep -- TCP 受付口の生成【拡張機能】
    185172 */
    186173
     
    195182        ER              error;
    196183
    197         /* TCP 受付口 ID をチェックする。*/
     184        /* TCP 受付口 ID をチェックする。*/
    198185        if (!VAID_TCP_REPID(repid))
    199186                return E_ID;
    200187
    201         /* pk_crep が NULL ならエラー */
     188        /* pk_crep が NULL ならエラー */
    202189        if (pk_crep == NULL)
    203190                return E_PAR;
    204191
    205         /* TCP 受付口を得る。*/
     192        /* TCP 受付口を得る。*/
    206193        rep = GET_TCP_REP(repid);
    207194
    208         /* TCP 受付口が、動的生成用でなければエラー */
     195        /* TCP 受付口が、動的生成用でなければエラー */
    209196        if (!DYNAMIC_TCP_REP(rep))
    210197                return E_ID;
    211198
    212         /* 受付口をロックする。*/
     199        /* 受付口をロックする。*/
    213200        syscall(wai_sem(rep->semid_lock));
    214201
    215202        /*
    216          * TCP 受付口をチェックする。生成済みであればエラー
     203         * TCP 受付口をチェックする。生成済みであればエラー
    217204         */
    218205        if (VALID_TCP_REP(rep))
     
    220207        else {
    221208
    222                 /* TCP 受付口生成æƒ
    223 å ±ã‚’コピーする。*/
    224                 rep->repatr = pk_crep->repatr;          /* 受付口属性              */
    225                 rep->myaddr = pk_crep->myaddr;          /* 自分のアドレス        */
    226 
    227                 /* TCP 受付口を生成済みにする。*/
     209                /* TCP 受付口生成情報をコピーする。*/
     210                rep->repatr = pk_crep->repatr;          /* 受付口属性                */
     211                rep->myaddr = pk_crep->myaddr;          /* 自分のアドレス      */
     212
     213                /* TCP 受付口を生成済みにする。*/
    228214                rep->flags |= TCP_REP_FLG_VALID;
    229215                error = E_OK;
    230216                }
    231217
    232         /* 受付口のロックを解除する。*/
     218        /* 受付口のロックを解除する。*/
    233219        syscall(sig_sem(rep->semid_lock));
    234220
     
    245231
    246232/*
    247  *  tcp_find_cep_rep -- TCP 受付口をリンクしている TCP 通信端点を得る。
     233 *  tcp_find_cep_rep -- TCP 受付口をリンクしている TCP 通信端点を得る。
    248234 */
    249235
     
    262248
    263249/*
    264  *  tcp_del_rep -- TCP 受付口の削除【拡張機能】
     250 *  tcp_del_rep -- TCP 受付口の削除【拡張機能】
    265251 */
    266252
     
    273259        ER              error = E_OK;
    274260
    275         /* TCP 受付口 ID をチェックする。*/
     261        /* TCP 受付口 ID をチェックする。*/
    276262        if (!VAID_TCP_REPID(repid))
    277263                return E_ID;
    278264
    279         /* TCP 受付口を得る。*/
     265        /* TCP 受付口を得る。*/
    280266        rep = GET_TCP_REP(repid);
    281267
    282         /* TCP 受付口が、動的生成用でなければエラー */
     268        /* TCP 受付口が、動的生成用でなければエラー */
    283269        if (!DYNAMIC_TCP_REP(rep))
    284270                return E_ID;
    285271
    286         /* 受付口をロックする。*/
     272        /* 受付口をロックする。*/
    287273        syscall(wai_sem(rep->semid_lock));
    288274
    289         /* TCP 受付口をチェックする。未生成の場合はエラー */
     275        /* TCP 受付口をチェックする。未生成の場合はエラー */
    290276        if (!VALID_TCP_REP(rep))
    291277                error = E_NOEXS;
     
    293279                if ((cep = tcp_find_cep_rep(rep)) != NULL) {
    294280                        /*
    295                          * すでに受動オープンしているとき
    296                          *(tcp_acp_cep が呼ばれているとき)は、
    297                          * tcp_acp_cep を終了させる。
     281                         * すでに受動オープンしているとき
     282                         *(tcp_acp_cep が呼ばれているとき)は、
     283                         * tcp_acp_cep を終了させる。
    298284                         */
    299285
    300                         /* 通信端点をロックする。*/
     286                        /* 通信端点をロックする。*/
    301287                        syscall(wai_sem(cep->semid_lock));
    302288
    303289                        /*
    304                          *  通信端点から受付口を解放し、
    305                          *  イベントフラグをクローズに設定する。
     290                         *  通信端点から受付口を解放し、
     291                         *  イベントフラグをクローズに設定する。
    306292                         */
    307293                        cep->rep = NULL;
     
    338324                        cep->rcv_tfn   = TFN_TCP_UNDEF;
    339325
    340                         /* 通信端点のロックを解除する。*/
     326                        /* 通信端点のロックを解除する。*/
    341327                        syscall(sig_sem(cep->semid_lock));
    342328
     
    345331                        error = E_OK;
    346332
    347                 /* TCP 受付口を未生成にする。*/
     333                /* TCP 受付口を未生成にする。*/
    348334                rep->flags &= ~TCP_REP_FLG_VALID;
    349335                }
    350336
    351         /* 受付口のロックを解除する。*/
     337        /* 受付口のロックを解除する。*/
    352338        syscall(sig_sem(rep->semid_lock));
    353339
     
    360346
    361347/*
    362  *  tcp_cre_cep -- TCP 通信端点の生成【拡張機能】
     348 *  tcp_cre_cep -- TCP 通信端点の生成【拡張機能】
    363349 */
    364350
     
    373359        ER              error;
    374360
    375         /* TCP 通信端点 ID をチェックする。*/
     361        /* TCP 通信端点 ID をチェックする。*/
    376362        if (!VAID_TCP_CEPID(cepid))
    377363                return E_ID;
    378364
    379         /* pk_ccep が NULL ならエラー */
     365        /* pk_ccep が NULL ならエラー */
    380366        if (pk_ccep == NULL)
    381367                return E_PAR;
    382368
    383         /* TCP 通信端点を得る。*/
     369        /* TCP 通信端点を得る。*/
    384370        cep = GET_TCP_CEP(cepid);
    385371
    386         /* TCP 通信端点が、動的生成用でなければエラー */
     372        /* TCP 通信端点が、動的生成用でなければエラー */
    387373        if (!DYNAMIC_TCP_CEP(cep))
    388374                return E_ID;
    389375
    390         /* 通信端点をロックする。*/
     376        /* 通信端点をロックする。*/
    391377        syscall(wai_sem(cep->semid_lock));
    392378
    393379        /*
    394          * TCP 通信端点をチェックする。生成済みであればエラー
     380         * TCP 通信端点をチェックする。生成済みであればエラー
    395381         */
    396382        if (VALID_TCP_CEP(cep))
     
    398384        else {
    399385
    400                 /* TCP 通信端点生成æƒ
    401 å ±ã‚’コピーする。*/
    402                 cep->cepatr   = pk_ccep->cepatr;                /* 通信端点属性                   */
    403                 cep->sbuf     = pk_ccep->sbuf;                  /* 送信用ウィンドバッファ    */
    404                 cep->sbufsz   = pk_ccep->sbufsz;                /* 送信用ウィンドバッファサイズ   */
    405                 cep->rbuf     = pk_ccep->rbuf;                  /* 受信用ウィンドバッファ    */
    406                 cep->rbufsz   = pk_ccep->rbufsz;                /* 受信用ウィンドバッファサイズ   */
    407                 cep->callback = (void*)pk_ccep->callback;       /* コールバック                   */
    408 
    409                 /* TCP 通信端点を生成済みにする。*/
     386                /* TCP 通信端点生成情報をコピーする。*/
     387                cep->cepatr   = pk_ccep->cepatr;                /* 通信端点属性                       */
     388                cep->sbuf     = pk_ccep->sbuf;                  /* 送信用ウィンドバッファ  */
     389                cep->sbufsz   = pk_ccep->sbufsz;                /* 送信用ウィンドバッファサイズ       */
     390                cep->rbuf     = pk_ccep->rbuf;                  /* 受信用ウィンドバッファ  */
     391                cep->rbufsz   = pk_ccep->rbufsz;                /* 受信用ウィンドバッファサイズ       */
     392                cep->callback = (void*)pk_ccep->callback;       /* コールバック                       */
     393
     394                /* TCP 通信端点を生成済みにする。*/
    410395                cep->flags |= TCP_CEP_FLG_VALID;
    411396                error = E_OK;
    412397                }
    413398
    414         /* 通信端点のロックを解除する。*/
     399        /* 通信端点のロックを解除する。*/
    415400        syscall(sig_sem(cep->semid_lock));
    416401
     
    423408
    424409/*
    425  *  tcp_del_cep -- TCP 通信端点の削除【拡張機能】
     410 *  tcp_del_cep -- TCP 通信端点の削除【拡張機能】
    426411 */
    427412
     
    436421        ER              error;
    437422
    438         /* TCP 通信端点 ID をチェックする。*/
     423        /* TCP 通信端点 ID をチェックする。*/
    439424        if (!VAID_TCP_CEPID(cepid))
    440425                return E_ID;
    441426
    442         /* TCP 通信端点を得る。*/
     427        /* TCP 通信端点を得る。*/
    443428        cep = GET_TCP_CEP(cepid);
    444429
    445         /* TCP 通信端点が、動的生成用でなければエラー */
     430        /* TCP 通信端点が、動的生成用でなければエラー */
    446431        if (!DYNAMIC_TCP_CEP(cep))
    447432                return E_ID;
    448433
    449         /* 通信端点をロックする。*/
     434        /* 通信端点をロックする。*/
    450435        syscall(wai_sem(cep->semid_lock));
    451436
    452437        /*
    453          * TCP 通信端点をチェックする。以下の場合はエラー
    454          * ・未生成。
    455          * ・使用中。
     438         * TCP 通信端点をチェックする。以下の場合はエラー
     439         * ・未生成。
     440         * ・使用中。
    456441         */
    457442        if (!VALID_TCP_CEP(cep))
     
    461446        else {
    462447
    463                 /* TCP 通信端点を未生成にする。*/
     448                /* TCP 通信端点を未生成にする。*/
    464449                cep->flags &= ~TCP_CEP_FLG_VALID;
    465450                error = E_OK;
    466451                }
    467452
    468         /* 通信端点のロックを解除する。*/
     453        /* 通信端点のロックを解除する。*/
    469454        syscall(sig_sem(cep->semid_lock));
    470455
     
    479464
    480465/*
    481  *  tcp_acp_cep -- 接続要求å¾
    482 ã¡ (受動オープン)【標準機能】
     466 *  tcp_acp_cep -- 接続要求待ち (受動オープン)【標準機能】
    483467 */
    484468
     
    493477        FLGPTN          flag;
    494478
    495         /* TCP 受付口をチェックする。*/
     479        /* TCP 受付口をチェックする。*/
    496480        if (!VAID_TCP_REPID(repid))
    497481                return E_ID;
     
    499483#ifdef TCP_CFG_NON_BLOCKING
    500484
    501         /* p_dstaddr が NULL ならエラー */
     485        /* p_dstaddr が NULL ならエラー */
    502486        if (p_dstaddr == NULL)
    503487                return E_PAR;
     
    505489#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    506490
    507         /* p_dstaddr が NULL か、tmout が TMO_NBLK ならエラー */
     491        /* p_dstaddr が NULL か、tmout が TMO_NBLK ならエラー */
    508492        if (p_dstaddr == NULL || tmout == TMO_NBLK)
    509493                return E_PAR;
     
    512496
    513497        /*
    514          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    515          *  すでに記録されていれば、ペンディング中なのでエラー
     498         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     499         *  すでに記録されていれば、ペンディング中なのでエラー
    516500         */
    517501        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_ACP_CEP)) != E_OK)
    518502                return error;
    519503
    520         /* CEP の FSM がクローズ状æ
    521 ‹ã§ãªã‘ればエラー。*/
     504        /* CEP の FSM がクローズ状態でなければエラー。*/
    522505        if (cep->fsm_state != TCP_FSM_CLOSED) {
    523506                error = E_OBJ;
     
    526509        syscall(clr_flg(cep->est_flgid, (FLGPTN)(~TCP_CEP_EVT_CLOSED)));
    527510
    528         /* TCP 通信端点を初期化する。*/
     511        /* TCP 通信端点を初期化する。*/
    529512        tcp_init_cep(cep);
    530513
    531         /* TCP 受付口を得る。*/
     514        /* TCP 受付口を得る。*/
    532515        rep = GET_TCP_REP(repid);
    533516
    534517#ifdef TCP_CFG_EXTENTIONS
    535518
    536         /* TCP 受付口をロックする。*/
     519        /* TCP 受付口をロックする。*/
    537520        syscall(wai_sem(rep->semid_lock));
    538521
    539         /* TCP 受付口をチェックする。*/
     522        /* TCP 受付口をチェックする。*/
    540523        if (!VALID_TCP_REP(rep)) {
    541524                syscall(sig_sem(rep->semid_lock));
     
    546529#endif  /* of #ifdef TCP_CFG_EXTENTIONS */
    547530
    548         /* TCP 通信端点にTCP受付口を記録する。*/
     531        /* TCP 通信端点にTCP受付口を記録する。*/
    549532        cep->rep = rep;
    550533
    551534#ifdef TCP_CFG_EXTENTIONS
    552535
    553         /* TCP 受付口のロックを解除する。*/
     536        /* TCP 受付口のロックを解除する。*/
    554537        syscall(sig_sem(rep->semid_lock));
    555538
    556539#endif  /* of #ifdef TCP_CFG_EXTENTIONS */
    557540
    558         /* TCP 受付口のアドレスをコピーする。*/
     541        /* TCP 受付口のアドレスをコピーする。*/
    559542        cep->myaddr = rep->myaddr;
    560543
    561         /* 通信端点を設定する。*/
     544        /* 通信端点を設定する。*/
    562545        cep->fsm_state = TCP_FSM_LISTEN;
    563546
    564547#ifdef TCP_CFG_NON_BLOCKING
    565548
    566         /* タイムアウトをチェックする。*/
     549        /* タイムアウトをチェックする。*/
    567550        if (tmout == TMO_NBLK) {
    568                 /* ノンブロッキングコール */
     551                /* ノンブロッキングコール */
    569552                cep->p_dstaddr    = p_dstaddr;
    570553                cep->rcv_nblk_tfn = TFN_TCP_ACP_CEP;
     
    576559
    577560                /*
    578                  *  FSM が ESTABLISHED になるまでå¾
    579 ã¤ã€‚
    580                  *  FSM が CLOSED になった場合は、エラーが発生したことを意味している。
     561                 *  FSM が ESTABLISHED になるまで待つ。
     562                 *  FSM が CLOSED になった場合は、エラーが発生したことを意味している。
    581563                 */
    582564                error = twai_flg(cep->est_flgid, (TCP_CEP_EVT_CLOSED |
     
    592574
    593575                if (error == E_OK) {
    594                         /* 相手のアドレスをコピーする。*/
     576                        /* 相手のアドレスをコピーする。*/
    595577                        *p_dstaddr = cep->dstaddr;
    596578                        }
    597579                else {
    598580                        /*
    599                          *  通信端点から受付口を解放し、
    600                          *  イベントフラグをクローズに設定する。
     581                         *  通信端点から受付口を解放し、
     582                         *  イベントフラグをクローズに設定する。
    601583                         */
    602584                        cep->rep = NULL;
     
    622604
    623605/*
    624  *  tcp_con_cep -- 接続要求 (能動オープン)【標準機能】
     606 *  tcp_con_cep -- 接続要求 (能動オープン)【標準機能】
    625607 */
    626608
     
    637619
    638620        /*
    639          *  p_dstaddr または p_myaddr が NULL か、
    640          *  あてå
    641 ˆãŒãƒžãƒ«ãƒã‚­ãƒ£ã‚¹ãƒˆã‚¢ãƒ‰ãƒ¬ã‚¹ãªã‚‰ã‚¨ãƒ©ãƒ¼
     621         *  p_dstaddr または p_myaddr が NULL か、
     622         *  あて先がマルチキャストアドレスならエラー
    642623         */
    643624        if (p_myaddr == NULL || p_dstaddr == NULL || IN_IS_ADDR_MULTICAST(&p_dstaddr->ipaddr))
     
    647628
    648629        /*
    649          *  p_dstaddr または p_myaddr が NULL 、
    650          *  あてå
    651 ˆãŒãƒžãƒ«ãƒã‚­ãƒ£ã‚¹ãƒˆã‚¢ãƒ‰ãƒ¬ã‚¹ã‹ã€
    652          *  tmout が TMO_NBLK ならエラー
     630         *  p_dstaddr または p_myaddr が NULL 、
     631         *  あて先がマルチキャストアドレスか、
     632         *  tmout が TMO_NBLK ならエラー
    653633         */
    654634        if (p_myaddr == NULL || p_dstaddr == NULL ||
     
    659639
    660640        /*
    661          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    662          *  すでに記録されていれば、ペンディング中なのでエラー
     641         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     642         *  すでに記録されていれば、ペンディング中なのでエラー
    663643         */
    664644        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_CON_CEP)) != E_OK)
    665645                return error;
    666646
    667         /* CEP の FSM がクローズ状æ
    668 ‹ã§ãªã‘ればエラー。*/
     647        /* CEP の FSM がクローズ状態でなければエラー。*/
    669648        if (cep->fsm_state != TCP_FSM_CLOSED) {
    670649                error = E_OBJ;
     
    673652        syscall(clr_flg(cep->est_flgid, (FLGPTN)(~TCP_CEP_EVT_CLOSED)));
    674653
    675         /* シーケンス番号を初期化する。*/
     654        /* シーケンス番号を初期化する。*/
    676655        if (tcp_iss == 0)
    677656                tcp_init_iss();
    678657
    679         /* 通信端点を初期化する。*/
     658        /* 通信端点を初期化する。*/
    680659        tcp_init_cep(cep);
    681660
    682661        /*
    683          *  p_myaddr が NADR (-1) ではなく、自 IP アドレスが ANY でなければ、
    684          *  指定された IP アドレスを割り当てる。
     662         *  p_myaddr が NADR (-1) ではなく、自 IP アドレスが ANY でなければ、
     663         *  指定された IP アドレスを割り当てる。
    685664         */
    686665        if (p_myaddr != NADR && !IN_IS_ADDR_ANY(&p_myaddr->ipaddr))
     
    696675                }
    697676
    698         /* 通信端点を設定する。*/
     677        /* 通信端点を設定する。*/
    699678        cep->fsm_state = TCP_FSM_SYN_SENT;
    700679        cep->dstaddr   = *p_dstaddr;
     
    706685#ifdef TCP_CFG_NON_BLOCKING
    707686
    708         /* タイムアウトをチェックする。*/
     687        /* タイムアウトをチェックする。*/
    709688        if (tmout == TMO_NBLK) {
    710                 /* ノンブロッキングコール */
     689                /* ノンブロッキングコール */
    711690                cep->p_dstaddr    = p_dstaddr;
    712691                cep->p_myaddr     = p_myaddr;
    713692                cep->snd_nblk_tfn = TFN_TCP_CON_CEP;
    714693
    715                 /* コネクションの開設をポストする。*/
     694                /* コネクションの開設をポストする。*/
    716695                cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    717696                sig_sem(SEM_TCP_POST_OUTPUT);
     
    723702
    724703                /*
    725                  *  p_myaddr が NADR (-1) か、
    726                  *  自ポート番号が TCP_PORTANY なら、自動で割り当てる。
     704                 *  p_myaddr が NADR (-1) か、
     705                 *  自ポート番号が TCP_PORTANY なら、自動で割り当てる。
    727706                 */
    728707                if (p_myaddr == NADR || p_myaddr->portno == TCP_PORTANY)
     
    731710                        goto err_ret;
    732711
    733                 /* コネクションの開設をポストする。*/
     712                /* コネクションの開設をポストする。*/
    734713                cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    735714                sig_sem(SEM_TCP_POST_OUTPUT);
    736715
    737716                /*
    738                  *  イベントが ESTABLISHED になるまでå¾
    739 ã¤ã€‚
    740                  *  イベントが CLOSED になった場合は、何らかのエラーが発生したか、
    741                  *  接続要求が拒否されたことを意味している。
     717                 *  イベントが ESTABLISHED になるまで待つ。
     718                 *  イベントが CLOSED になった場合は、何らかのエラーが発生したか、
     719                 *  接続要求が拒否されたことを意味している。
    742720                 */
    743721                error = twai_flg(cep->est_flgid, (TCP_CEP_EVT_CLOSED |
     
    754732                if (error != E_OK) {
    755733                        /*
    756                          *  通信端点から受付口を解放し、
    757                          *  イベントフラグをクローズに設定する。
     734                         *  通信端点から受付口を解放し、
     735                         *  イベントフラグをクローズに設定する。
    758736                         */
    759737                        cep->rep = NULL;
     
    779757
    780758/*
    781  *  tcp_user_closed -- ユーザからのコネクションの開放
     759 *  tcp_user_closed -- ユーザからのコネクションの開放
    782760 */
    783761
     
    787765        switch (cep->fsm_state) {
    788766
    789         case TCP_FSM_CLOSED:            /* クローズ */
    790         case TCP_FSM_LISTEN:            /* 受動オープン   */
     767        case TCP_FSM_CLOSED:            /* クローズ */
     768        case TCP_FSM_LISTEN:            /* 受動オープン       */
    791769                cep->fsm_state = TCP_FSM_CLOSED;
    792770                cep = tcp_close(cep);
    793771                break;
    794772
    795         case TCP_FSM_SYN_SENT:          /* 能動オープン、SYN 送信済み        */
    796         case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み  */
     773        case TCP_FSM_SYN_SENT:          /* 能動オープン、SYN 送信済み      */
     774        case TCP_FSM_SYN_RECVD:         /* SYN を受信し、SYN 送信済み    */
    797775                cep->flags |= TCP_CEP_FLG_NEED_FIN;
    798776                break;
    799777
    800         case TCP_FSM_ESTABLISHED:       /* コネクション開設完了       */
     778        case TCP_FSM_ESTABLISHED:       /* コネクション開設完了   */
    801779                cep->fsm_state = TCP_FSM_FIN_WAIT_1;
    802780                break;
    803781
    804         case TCP_FSM_CLOSE_WAIT:        /* 相手から FIN 受信、APP の終了å¾
    805 ã¡ */
     782        case TCP_FSM_CLOSE_WAIT:        /* 相手から FIN 受信、APP の終了待ち */
    806783                cep->fsm_state = TCP_FSM_LAST_ACK;
    807784                break;
     
    814791
    815792/*
    816  *  tcp_cls_cep -- 通信端点のクローズ【標準機能】
     793 *  tcp_cls_cep -- 通信端点のクローズ【標準機能】
    817794 */
    818795
     
    826803#ifndef TCP_CFG_NON_BLOCKING
    827804
    828         /* tmout が TMO_NBLK ならエラー */
     805        /* tmout が TMO_NBLK ならエラー */
    829806        if (tmout == TMO_NBLK)
    830807                return E_PAR;
     
    833810
    834811        /*
    835          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    836          *  すでに記録されていれば、ペンディング中なのでエラー
     812         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     813         *  すでに記録されていれば、ペンディング中なのでエラー
    837814         */
    838815        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_CLS_CEP)) != E_OK)
     
    841818#ifdef TCP_CFG_NON_BLOCKING
    842819
    843         /* タイムアウトをチェックする。*/
    844         if (tmout == TMO_NBLK) {                                /* ノンブロッキングコール */
     820        /* タイムアウトをチェックする。*/
     821        if (tmout == TMO_NBLK) {                                /* ノンブロッキングコール */
    845822
    846823                if (!IS_PTR_DEFINED(cep->callback))
    847824                        error = E_OBJ;
    848                 else if (cep->fsm_state == TCP_FSM_CLOSED) {    /* すでにクローズされているとき */
     825                else if (cep->fsm_state == TCP_FSM_CLOSED) {    /* すでにクローズされているとき */
    849826
    850827#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
     
    864841                        }
    865842                else {
    866                         /* NBLK のAPI 機能コードを設定する。*/
     843                        /* NBLK のAPI 機能コードを設定する。*/
    867844                        cep->rcv_nblk_tfn = TFN_TCP_CLS_CEP;
    868845
    869                         if ((cep = tcp_user_closed(cep)) != NULL) {     /* コネクションを切断する。*/
    870                                 /* 切断セグメント出力をポストする。*/
     846                        if ((cep = tcp_user_closed(cep)) != NULL) {     /* コネクションを切断する。*/
     847                                /* 切断セグメント出力をポストする。*/
    871848                                cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    872849                                sig_sem(SEM_TCP_POST_OUTPUT);
    873850                                }
    874851
    875                         /*  cep が NULL で戻ってきた場合は、
    876                          *  既にコネクションが切断されていることを意味している。
    877                          *  また、この場合コールバック関数が呼び出されている。
     852                        /*  cep が NULL で戻ってきた場合は、
     853                         *  既にコネクションが切断されていることを意味している。
     854                         *  また、この場合コールバック関数が呼び出されている。
    878855                         */
    879856                        return E_WBLK;
    880857                        }
    881858                }
    882         else {                                                  /* 非ノンブロッキングコール */
    883 
    884 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    885 
    886                 if ((cep = tcp_user_closed(cep)) == NULL) {     /* コネクションを切断する。*/
    887 
    888                         /*  cep が NULL で戻ってきた場合は、
    889                          *  既にコネクションが切断されていることを意味している。
     859        else {                                                  /* 非ノンブロッキングコール */
     860
     861#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     862
     863                if ((cep = tcp_user_closed(cep)) == NULL) {     /* コネクションを切断する。*/
     864
     865                        /*  cep が NULL で戻ってきた場合は、
     866                         *  既にコネクションが切断されていることを意味している。
    890867                         */
    891868                        return error;
    892869                        }
    893870                else {
    894                         /* 切断セグメント出力をポストする。*/
     871                        /* 切断セグメント出力をポストする。*/
    895872                        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    896873                        sig_sem(SEM_TCP_POST_OUTPUT);
    897874
    898                         /* イベントフラグが CLOSED になるまでå¾
    899 ã¤ã€‚*/
     875                        /* イベントフラグが CLOSED になるまで待つ。*/
    900876                        error = twai_flg(cep->est_flgid, TCP_CEP_EVT_CLOSED, TWF_ORW, &flag, tmout);
    901877                        if (error == E_OK && cep->error != E_OK)
     
    904880                        if (error != E_OK) {
    905881                                if (error == E_RLWAI) {
    906                                         /* tcp_cls_cep がキャンセルされたときは、RST を送信する。*/
     882                                        /* tcp_cls_cep がキャンセルされたときは、RST を送信する。*/
    907883                                        tcp_respond(NULL, cep, cep->rcv_nxt, cep->snd_una - 1,
    908884                                                    cep->rbufsz - cep->rwbuf_count, TCP_FLG_RST);
    909885                                        }
    910886
    911                                 /* タイマーを停止する。*/
     887                                /* タイマーを停止する。*/
    912888                                tcp_cancel_timers(cep);
    913889
    914890                                /*
    915                                  *  通信端点をロックし、
    916                                  *  受信再構成キューのネットワークバッファを解放する。
     891                                 *  通信端点をロックし、
     892                                 *  受信再構成キューのネットワークバッファを解放する。
    917893                                 */
    918894                                syscall(wai_sem(cep->semid_lock));
     
    920896                                syscall(sig_sem(cep->semid_lock));
    921897
    922                                 /* 状æ
    923 ‹ã‚’未使用にする。*/
     898                                /* 状態を未使用にする。*/
    924899                                cep->fsm_state = TCP_FSM_CLOSED;
    925900
    926901                                /*
    927                                  * 以下に関係しないフラグをクリアーする。
    928                                  * ・送受信ウィンドバッファの省コピー機能
    929                                  * ・動的な通信端点の生成・削除機能
     902                                 * 以下に関係しないフラグをクリアーする。
     903                                 * ・送受信ウィンドバッファの省コピー機能
     904                                 * ・動的な通信端点の生成・削除機能
    930905                                 */
    931906                                cep->flags &= (TCP_CEP_FLG_WBCS_NBUF_REQ | TCP_CEP_FLG_WBCS_MASK |
     
    933908
    934909                                /*
    935                                  *  通信端点をロックし、
    936                                  *  送受信ウィンドバッファキューのネットワークバッファを解放する。
     910                                 *  通信端点をロックし、
     911                                 *  送受信ウィンドバッファキューのネットワークバッファを解放する。
    937912                                 */
    938913                                cep->rwbuf_count = 0;
     
    962937
    963938/*
    964  *  tcp_sht_cep  -- データ送信の終了【標準機能】
     939 *  tcp_sht_cep  -- データ送信の終了【標準機能】
    965940 */
    966941
     
    972947
    973948        /*
    974          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    975          *  すでに記録されていれば、ペンディング中なのでエラー
     949         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     950         *  すでに記録されていれば、ペンディング中なのでエラー
    976951         */
    977952        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_SHT_CEP)) != E_OK)
    978953                return error;
    979954
    980         /* TCP 通信端点のコネクションが確立状æ
    981 ‹ã§ãªã‘ればエラー */
     955        /* TCP 通信端点のコネクションが確立状態でなければエラー */
    982956        if (!TCP_FSM_HAVE_ESTABLISHED(cep->fsm_state)) {
    983957                if ((error = cep->error) == E_OK)
     
    985959                }
    986960
    987         else if ((cep = tcp_user_closed(cep)) != NULL) {                /* コネクションを切断する。*/
    988 
    989                 /* 切断セグメント出力をポストする。*/
     961        else if ((cep = tcp_user_closed(cep)) != NULL) {                /* コネクションを切断する。*/
     962
     963                /* 切断セグメント出力をポストする。*/
    990964                cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    991965                sig_sem(SEM_TCP_POST_OUTPUT);
     
    1002976
    1003977/*
    1004  *  tcp_snd_dat -- パケットの送信【標準機能】
     978 *  tcp_snd_dat -- パケットの送信【標準機能】
    1005979 */
    1006980
     
    1013987#ifdef TCP_CFG_NON_BLOCKING
    1014988
    1015         /* data が NULL か、len < 0 ならエラー */
     989        /* data が NULL か、len < 0 ならエラー */
    1016990        if (data == NULL || len < 0)
    1017991                return E_PAR;
     
    1019993#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    1020994
    1021         /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
     995        /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
    1022996        if (data == NULL || len < 0 || tmout == TMO_NBLK)
    1023997                return E_PAR;
     
    10261000
    10271001        /*
    1028          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1029          *  すでに記録されていれば、ペンディング中なのでエラー
     1002         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1003         *  すでに記録されていれば、ペンディング中なのでエラー
    10301004         */
    10311005        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_SND_DAT)) != E_OK)
    10321006                return error;
    10331007
    1034         /* 送信できるか、通信端点の状æ
    1035 ‹ã‚’見る。*/
     1008        /* 送信できるか、通信端点の状態を見る。*/
    10361009        if ((error = tcp_can_send_more(cep, TFN_TCP_SND_DAT, tmout)) != E_OK)
    10371010                goto err_ret;
     
    10391012#ifdef TCP_CFG_NON_BLOCKING
    10401013
    1041         /* タイムアウトをチェックする。*/
    1042         if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
    1043 
    1044                 /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
     1014        /* タイムアウトをチェックする。*/
     1015        if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
     1016
     1017                /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
    10451018                if (!TCP_IS_SWBUF_FULL(cep)) {
    10461019
    1047                         /* 送信ウィンドバッファにデータを書き込む。*/
     1020                        /* 送信ウィンドバッファにデータを書き込む。*/
    10481021                        error = TCP_WRITE_SWBUF(cep, data, (uint_t)len);
    10491022
    1050                         /* 出力をポストする。*/
     1023                        /* 出力をポストする。*/
    10511024                        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    10521025                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    10541027#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
    10551028
    1056                         /* コールバック関数を呼び出す。*/
     1029                        /* コールバック関数を呼び出す。*/
    10571030                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_SND_DAT, (void*)error);
    10581031
    10591032#else   /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
    10601033
    1061                         /* コールバック関数を呼び出す。*/
     1034                        /* コールバック関数を呼び出す。*/
    10621035                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_SND_DAT, (void*)&error);
    10631036
     
    10761049                        }
    10771050                }
    1078         else {          /* 非ノンブロッキングコール */
    1079 
    1080 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    1081 
    1082                 /* 送信ウィンドバッファが空くのをå¾
    1083 ã¤ã€‚*/
     1051        else {          /* 非ノンブロッキングコール */
     1052
     1053#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     1054
     1055                /* 送信ウィンドバッファが空くのを待つ。*/
    10841056                if ((error = TCP_WAIT_SWBUF(cep, tmout)) != E_OK)
    10851057                        goto err_ret;
    10861058
    1087                 /* 送信ウィンドバッファにデータを書き込む。*/
     1059                /* 送信ウィンドバッファにデータを書き込む。*/
    10881060                if ((error = TCP_WRITE_SWBUF(cep, data, (uint_t)len)) > 0) {
    10891061
    1090                         /* データを送信する。送信ウィンドバッファがフルのときは強制的に送信する。*/
     1062                        /* データを送信する。送信ウィンドバッファがフルのときは強制的に送信する。*/
    10911063                        if (TCP_IS_SWBUF_FULL(cep))
    10921064                                cep->flags |= TCP_CEP_FLG_FORCE | TCP_CEP_FLG_FORCE_CLEAR;
    10931065
    1094                         /* 出力をポストする。*/
     1066                        /* 出力をポストする。*/
    10951067                        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    10961068                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    11161088
    11171089/*
    1118  *  tcp_snd_oob -- 緊急データの送信【拡張機能】
     1090 *  tcp_snd_oob -- 緊急データの送信【拡張機能】
    11191091 */
    11201092
     
    11271099#ifdef TCP_CFG_NON_BLOCKING
    11281100
    1129         /* data が NULL か、len < 0 ならエラー */
     1101        /* data が NULL か、len < 0 ならエラー */
    11301102        if (data == NULL || len < 0)
    11311103                return E_PAR;
     
    11331105#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    11341106
    1135         /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
     1107        /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
    11361108        if (data == NULL || len < 0 || tmout == TMO_NBLK)
    11371109                return E_PAR;
     
    11401112
    11411113        /*
    1142          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1143          *  すでに記録されていれば、ペンディング中なのでエラー
     1114         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1115         *  すでに記録されていれば、ペンディング中なのでエラー
    11441116         */
    11451117        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_SND_OOB)) != E_OK)
    11461118                return error;
    11471119
    1148         /* 送信できるか、通信端点の状æ
    1149 ‹ã‚’見る。*/
     1120        /* 送信できるか、通信端点の状態を見る。*/
    11501121        if ((error = tcp_can_send_more(cep, TFN_TCP_SND_OOB, tmout)) != E_OK)
    11511122                goto err_ret;
     
    11531124#ifdef TCP_CFG_NON_BLOCKING
    11541125
    1155         /* タイムアウトをチェックする。*/
    1156         if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
    1157 
    1158                 /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
     1126        /* タイムアウトをチェックする。*/
     1127        if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
     1128
     1129                /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
    11591130                if (!TCP_IS_SWBUF_FULL(cep)) {
    11601131
    1161                         /* 送信ウィンドバッファにデータを書き込む。*/
     1132                        /* 送信ウィンドバッファにデータを書き込む。*/
    11621133                        error = TCP_WRITE_SWBUF(cep, data, (uint_t)len);
    11631134
    1164                         /* 送信緊急ポインタを設定する。*/
     1135                        /* 送信緊急ポインタを設定する。*/
    11651136                        cep->snd_up = cep->snd_una + cep->swbuf_count;
    11661137
    1167                         /* 出力をポストする。*/
     1138                        /* 出力をポストする。*/
    11681139                        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    11691140                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    11711142#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
    11721143
    1173                         /* コールバック関数を呼び出す。*/
     1144                        /* コールバック関数を呼び出す。*/
    11741145                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_SND_OOB, (void*)error);
    11751146
    11761147#else   /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
    11771148
    1178                         /* コールバック関数を呼び出す。*/
     1149                        /* コールバック関数を呼び出す。*/
    11791150                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_SND_OOB, (void*)&error);
    11801151
     
    11931164                        }
    11941165                }
    1195         else {          /* 非ノンブロッキングコール */
    1196 
    1197 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    1198 
    1199                 /* 送信ウィンドバッファが空くのをå¾
    1200 ã¤ã€‚*/
     1166        else {          /* 非ノンブロッキングコール */
     1167
     1168#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     1169
     1170                /* 送信ウィンドバッファが空くのを待つ。*/
    12011171                if ((error = TCP_WAIT_SWBUF(cep, tmout)) != E_OK)
    12021172                        goto err_ret;
    12031173
    1204                 /* 送信ウィンドバッファにデータを書き込む。*/
     1174                /* 送信ウィンドバッファにデータを書き込む。*/
    12051175                if ((error = TCP_WRITE_SWBUF(cep, data, (uint_t)len)) > 0) {
    12061176
    1207                         /* 送信緊急ポインタを設定する。*/
     1177                        /* 送信緊急ポインタを設定する。*/
    12081178                        cep->snd_up = cep->snd_una + cep->swbuf_count;
    12091179
    1210                         /* データを送信する。送信ウィンドバッファがフルのときは強制的に送信する。*/
     1180                        /* データを送信する。送信ウィンドバッファがフルのときは強制的に送信する。*/
    12111181                        if (TCP_IS_SWBUF_FULL(cep))
    12121182                                cep->flags |= TCP_CEP_FLG_FORCE | TCP_CEP_FLG_FORCE_CLEAR;
    12131183
    1214                         /* 出力をポストする。*/
     1184                        /* 出力をポストする。*/
    12151185                        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    12161186                        sig_sem(SEM_TCP_POST_OUTPUT);
     
    12361206
    12371207/*
    1238  *  tcp_get_buf -- 送信用バッファの獲得【標準機能】
     1208 *  tcp_get_buf -- 送信用バッファの獲得【標準機能】
    12391209 */
    12401210
     
    12471217#ifdef TCP_CFG_NON_BLOCKING
    12481218
    1249         /* p_buf が NULL ならエラー */
     1219        /* p_buf が NULL ならエラー */
    12501220        if (p_buf == NULL)
    12511221                return E_PAR;
     
    12531223#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    12541224
    1255         /* p_buf が NULL か、tmout が TMO_NBLK ならエラー */
     1225        /* p_buf が NULL か、tmout が TMO_NBLK ならエラー */
    12561226        if (p_buf == NULL || tmout == TMO_NBLK)
    12571227                return E_PAR;
     
    12601230
    12611231        /*
    1262          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1263          *  すでに記録されていれば、ペンディング中なのでエラー
     1232         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1233         *  すでに記録されていれば、ペンディング中なのでエラー
    12641234         */
    12651235        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_GET_BUF)) != E_OK)
    12661236                return error;
    12671237
    1268         /* 送信できるか、通信端点の状æ
    1269 ‹ã‚’見る。*/
     1238        /* 送信できるか、通信端点の状態を見る。*/
    12701239        if ((error = tcp_can_send_more(cep, TFN_TCP_GET_BUF, tmout)) != E_OK)
    12711240                goto err_ret;
     
    12731242#ifdef TCP_CFG_NON_BLOCKING
    12741243
    1275         /* タイムアウトをチェックする。*/
    1276         if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
     1244        /* タイムアウトをチェックする。*/
     1245        if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
    12771246
    12781247                if (!TCP_IS_SWBUF_FULL(cep)) {
    12791248
    1280                         /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
     1249                        /* 送信ウィンドバッファに空きがあればコールバック関数を呼び出す。*/
    12811250                        error = TCP_GET_SWBUF_ADDR(cep, p_buf);
    12821251
    12831252#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
    12841253
    1285                         /* コールバック関数を呼び出す。*/
     1254                        /* コールバック関数を呼び出す。*/
    12861255                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_GET_BUF, (void*)error);
    12871256
    12881257#else   /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
    12891258
    1290                         /* コールバック関数を呼び出す。*/
     1259                        /* コールバック関数を呼び出す。*/
    12911260                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_GET_BUF, (void*)&error);
    12921261
     
    13041273                }
    13051274
    1306         else {          /* 非ノンブロッキングコール */
    1307 
    1308 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    1309 
    1310                 /* 送信ウィンドバッファが空くのをå¾
    1311 ã¤ã€‚*/
     1275        else {          /* 非ノンブロッキングコール */
     1276
     1277#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     1278
     1279                /* 送信ウィンドバッファが空くのを待つ。*/
    13121280                if ((error = TCP_WAIT_SWBUF(cep, tmout)) != E_OK)
    13131281                        goto err_ret;
    13141282
    1315                 /* 送信ウィンドバッファの空アドレスを獲得する。*/
     1283                /* 送信ウィンドバッファの空アドレスを獲得する。*/
    13161284                error = TCP_GET_SWBUF_ADDR(cep, p_buf);
    13171285
     
    13331301
    13341302/*
    1335  *  tcp_snd_buf -- バッファå†
    1336 ã®ãƒ‡ãƒ¼ã‚¿ã®é€ä¿¡ã€æ¨™æº–機能】
     1303 *  tcp_snd_buf -- バッファ内のデータの送信【標準機能】
    13371304 */
    13381305
     
    13431310        ER              error;
    13441311
    1345         /* 送信する長さ len をチェックする。*/
     1312        /* 送信する長さ len をチェックする。*/
    13461313        if (len < 0)
    13471314                return E_PAR;
    13481315
    1349         /* 送信する長さlen が 0 であれば、何もしないで戻る。*/
     1316        /* 送信する長さlen が 0 であれば、何もしないで戻る。*/
    13501317        if (len == 0)
    13511318                return E_OK;
    13521319
    13531320        /*
    1354          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1355          *  すでに記録されていれば、ペンディング中なのでエラー
     1321         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1322         *  すでに記録されていれば、ペンディング中なのでエラー
    13561323         */
    13571324        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_SND_BUF)) != E_OK)
    13581325                return error;
    13591326
    1360         /* 送信する長さ len をチェックする。*/
     1327        /* 送信する長さ len をチェックする。*/
    13611328        if (len > cep->get_buf_len) {
    13621329                error = E_OBJ;
     
    13641331                }
    13651332
    1366         /* 送信できるか、CEP の FSM 状æ
    1367 ‹ã‚’見る。*/
     1333        /* 送信できるか、CEP の FSM 状態を見る。*/
    13681334        if (!TCP_FSM_CAN_SEND_MORE(cep->fsm_state)) {
    13691335                if ((error = cep->error) == E_OK)
     
    13721338                }
    13731339
    1374         /* 送信ウィンドバッファのデータを送信可能にする。*/
     1340        /* 送信ウィンドバッファのデータを送信可能にする。*/
    13751341        TCP_SEND_SWBUF(cep, (uint_t)len);
    13761342
    1377         /* 出力をポストする。*/
     1343        /* 出力をポストする。*/
    13781344        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    13791345        sig_sem(SEM_TCP_POST_OUTPUT);
     
    13901356
    13911357/*
    1392  *  tcp_rcv_dat -- パケットの受信【標準機能】
     1358 *  tcp_rcv_dat -- パケットの受信【標準機能】
    13931359 */
    13941360
     
    14011367#ifdef TCP_CFG_NON_BLOCKING
    14021368
    1403         /* data が NULL か、len < 0 ならエラー */
     1369        /* data が NULL か、len < 0 ならエラー */
    14041370        if (data == NULL || len < 0)
    14051371                return E_PAR;
     
    14071373#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    14081374
    1409         /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
     1375        /* data が NULL、len < 0 か、tmout が TMO_NBLK ならエラー */
    14101376        if (data == NULL || len < 0 || tmout == TMO_NBLK)
    14111377                return E_PAR;
     
    14141380
    14151381        /*
    1416          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1417          *  すでに記録されていれば、ペンディング中なのでエラー
     1382         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1383         *  すでに記録されていれば、ペンディング中なのでエラー
    14181384         */
    14191385        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_RCV_DAT)) != E_OK)
    14201386                return error;
    14211387
    1422         /* 受信できるか、通信端点の状æ
    1423 ‹ã‚’見る。*/
     1388        /* 受信できるか、通信端点の状態を見る。*/
    14241389        if (tcp_can_recv_more(&error, cep, TFN_TCP_RCV_DAT, tmout) != E_OK)
    14251390                goto err_ret;
     
    14271392#ifdef TCP_CFG_NON_BLOCKING
    14281393
    1429         /* タイムアウトをチェックする。*/
    1430         if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
    1431 
    1432                 /* 受信ウィンドバッファにデータがあればコールバック関数を呼び出す。*/
     1394        /* タイムアウトをチェックする。*/
     1395        if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
     1396
     1397                /* 受信ウィンドバッファにデータがあればコールバック関数を呼び出す。*/
    14331398                if (cep->rwbuf_count > 0) {
    14341399
    1435                         /* 受信ウィンドバッファからデータを取り出す。*/
     1400                        /* 受信ウィンドバッファからデータを取り出す。*/
    14361401                        len = TCP_READ_RWBUF(cep, data, (uint_t)len);
    14371402
     
    14561421                        }
    14571422                }
    1458         else {          /* 非ノンブロッキングコール */
    1459 
    1460 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    1461 
    1462                 /* 受信ウィンドバッファにデータがなければ、å
    1463 ¥åŠ›ãŒã‚るまでå¾
    1464 ã¤ã€‚*/
     1423        else {          /* 非ノンブロッキングコール */
     1424
     1425#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     1426
     1427                /* 受信ウィンドバッファにデータがなければ、入力があるまで待つ。*/
    14651428                if ((error = tcp_wait_rwbuf(cep, tmout)) != E_OK)
    14661429                        goto err_ret;
    14671430
    1468                 /* 受信ウィンドバッファからデータを取り出す。*/
     1431                /* 受信ウィンドバッファからデータを取り出す。*/
    14691432                error = TCP_READ_RWBUF(cep, data, (uint_t)len);
    14701433
    1471                 /* 相手にウィンドウサイズが変わったことを知らせるため出力をポストする。*/
     1434                /* 相手にウィンドウサイズが変わったことを知らせるため出力をポストする。*/
    14721435                cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    14731436                sig_sem(SEM_TCP_POST_OUTPUT);
     
    14921455
    14931456/*
    1494  *  tcp_rcv_oob -- 緊急データの受信【拡張機能】
     1457 *  tcp_rcv_oob -- 緊急データの受信【拡張機能】
    14951458 *
    1496  *    注意: 送信側が複数オクテットのデータを送信しても、
    1497  *          緊急ポインタが指す 1 オクテットのデータのみ受信する。
     1459 *    注意: 送信側が複数オクテットのデータを送信しても、
     1460 *          緊急ポインタが指す 1 オクテットのデータのみ受信する。
    14981461 */
    14991462
     
    15041467        uint8_t         *urg;
    15051468
    1506         /* TCP 通信端点 ID をチェックする。*/
     1469        /* TCP 通信端点 ID をチェックする。*/
    15071470        if (!VAID_TCP_CEPID(cepid))
    15081471                return E_ID;
    15091472
    1510         /* data が NULL か、len < 0 ならエラー */
     1473        /* data が NULL か、len < 0 ならエラー */
    15111474        if (data == NULL || len < 0)
    15121475                return E_PAR;
    15131476
    1514         /* TCP 通信端点を得る。*/
     1477        /* TCP 通信端点を得る。*/
    15151478        cep = GET_TCP_CEP(cepid);
    15161479
    1517         /* 受信できるか、通信端点の状æ
    1518 ‹ã‚’見る。*/
    1519         /* 受信できるか、fsm_state を見る。*/
     1480        /* 受信できるか、通信端点の状態を見る。*/
     1481        /* 受信できるか、fsm_state を見る。*/
    15201482        if (!TCP_FSM_CAN_RECV_MORE(cep->fsm_state))
    15211483                return E_OBJ;
    15221484
    15231485        /*
    1524          *  緊急データå
    1525 ¥ã‚Šã®ã‚»ã‚°ãƒ¡ãƒ³ãƒˆã® TCP ヘッダが
    1526          *  設定されていなければ、緊急データを受信していない。
     1486         *  緊急データ入りのセグメントの TCP ヘッダが
     1487         *  設定されていなければ、緊急データを受信していない。
    15271488         */
    15281489        if (cep->urg_tcph == NULL)
    15291490                return E_OBJ;
    15301491
    1531         /* len == 0 ならバッファオーバーフロー */
     1492        /* len == 0 ならバッファオーバーフロー */
    15321493        if (len == 0)
    15331494                return E_BOVR;
    15341495
    1535         /* 緊急ポインタが指す 1 オクテットのデータを読み取る。*/
     1496        /* 緊急ポインタが指す 1 オクテットのデータを読み取る。*/
    15361497        urg = (uint8_t*)cep->urg_tcph + TCP_DATA_OFF(cep->urg_tcph->doff) + cep->urg_tcph->urp + TCP_CFG_URG_OFFSET;
    15371498        *(uint8_t*)data = *urg;
    15381499
    1539         /* 読み取ったデータから後ろの SDU を前に詰める。*/
     1500        /* 読み取ったデータから後ろの SDU を前に詰める。*/
    15401501        memcpy(urg, urg + 1, cep->urg_tcph->sum - (cep->urg_tcph->urp + TCP_CFG_URG_OFFSET) - 1);
    15411502
    1542         /* tcp_rcv_oob() が呼出されたこと知らせるために、NULL を設定する。*/
     1503        /* tcp_rcv_oob() が呼出されたこと知らせるために、NULL を設定する。*/
    15431504        cep->urg_tcph = NULL;
    15441505
     
    15531514
    15541515/*
    1555  *  tcp_rcv_buf -- 受信したデータのå
    1556 ¥ã£ãŸãƒãƒƒãƒ•ã‚¡ã®ç²å¾—【標準機能】
     1516 *  tcp_rcv_buf -- 受信したデータの入ったバッファの獲得【標準機能】
    15571517 */
    15581518
     
    15651525#ifdef TCP_CFG_NON_BLOCKING
    15661526
    1567         /* p_buf が NULL ならエラー */
     1527        /* p_buf が NULL ならエラー */
    15681528        if (p_buf == NULL)
    15691529                return E_PAR;
     
    15711531#else   /* of #ifdef TCP_CFG_NON_BLOCKING */
    15721532
    1573         /* p_buf が NULL か、tmout が TMO_NBLK ならエラー */
     1533        /* p_buf が NULL か、tmout が TMO_NBLK ならエラー */
    15741534        if (p_buf == NULL || tmout == TMO_NBLK)
    15751535                return E_PAR;
     
    15781538
    15791539        /*
    1580          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1581          *  すでに記録されていれば、ペンディング中なのでエラー
     1540         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1541         *  すでに記録されていれば、ペンディング中なのでエラー
    15821542         */
    15831543        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_RCV_BUF)) != E_OK)
    15841544                return error;
    15851545
    1586         /* 受信できるか、通信端点の状æ
    1587 ‹ã‚’見る。*/
     1546        /* 受信できるか、通信端点の状態を見る。*/
    15881547        if (tcp_can_recv_more(&error, cep, TFN_TCP_RCV_DAT, tmout) != E_OK)
    15891548                goto err_ret;
     
    15911550#ifdef TCP_CFG_NON_BLOCKING
    15921551
    1593         /* タイムアウトをチェックする。*/
    1594         if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
    1595 
    1596                 /* 受信ウィンドバッファにデータがあればコールバック関数を呼び出す。*/
     1552        /* タイムアウトをチェックする。*/
     1553        if (tmout == TMO_NBLK) {                /* ノンブロッキングコール */
     1554
     1555                /* 受信ウィンドバッファにデータがあればコールバック関数を呼び出す。*/
    15971556                if (cep->rwbuf_count > 0) {
    15981557
    1599                         /* 受信ウィンドバッファの空アドレスを獲得する。*/
     1558                        /* 受信ウィンドバッファの空アドレスを獲得する。*/
    16001559                        error = TCP_GET_RWBUF_ADDR(cep, p_buf);
    16011560
    16021561#ifdef TCP_CFG_NON_BLOCKING_COMPAT14
    16031562
    1604                         /* コールバック関数を呼び出す。*/
     1563                        /* コールバック関数を呼び出す。*/
    16051564                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_RCV_BUF, (void*)error);
    16061565
    16071566#else   /* of #ifdef TCP_CFG_NON_BLOCKING_COMPAT14 */
    16081567
    1609                         /* コールバック関数を呼び出す。*/
     1568                        /* コールバック関数を呼び出す。*/
    16101569                        (*cep->callback)(GET_TCP_CEPID(cep), TFN_TCP_RCV_BUF, (void*)&error);
    16111570
     
    16211580                        }
    16221581                }
    1623         else {          /* 非ノンブロッキングコール */
    1624 
    1625 #endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
    1626 
    1627                 /* 受信ウィンドバッファにデータがなければ、å
    1628 ¥åŠ›ãŒã‚るまでå¾
    1629 ã¤ã€‚*/
     1582        else {          /* 非ノンブロッキングコール */
     1583
     1584#endif  /* of #ifdef TCP_CFG_NON_BLOCKING */
     1585
     1586                /* 受信ウィンドバッファにデータがなければ、入力があるまで待つ。*/
    16301587                if ((error = tcp_wait_rwbuf(cep, tmout)) != E_OK) {
    16311588                        cep->rwbuf_count = 0;
     
    16331590                        }
    16341591
    1635                 /* 受信ウィンドバッファのアドレスを獲得する。*/
     1592                /* 受信ウィンドバッファのアドレスを獲得する。*/
    16361593                error = TCP_GET_RWBUF_ADDR(cep, p_buf);
    16371594
     
    16531610
    16541611/*
    1655  *  tcp_rel_buf -- 受信用バッファの解放【標準機能】
     1612 *  tcp_rel_buf -- 受信用バッファの解放【標準機能】
    16561613 */
    16571614
     
    16621619        ER              error;
    16631620
    1664         /* 解放する長さ len をチェックする。*/
     1621        /* 解放する長さ len をチェックする。*/
    16651622        if (len < 0)
    16661623                return E_PAR;
    16671624
    16681625        /*
    1669          *  CEP をロックし、API 機能コードとタスク識別子を記録する。
    1670          *  すでに記録されていれば、ペンディング中なのでエラー
     1626         *  CEP をロックし、API 機能コードとタスク識別子を記録する。
     1627         *  すでに記録されていれば、ペンディング中なのでエラー
    16711628         */
    16721629        if ((error = tcp_lock_cep(cepid, &cep, TFN_TCP_REL_BUF)) != E_OK)
    16731630                return error;
    16741631
    1675         /* 解放する長さ len をチェックする。*/
     1632        /* 解放する長さ len をチェックする。*/
    16761633        if (len > cep->rcv_buf_len) {
    16771634                error = E_OBJ;
     
    16791636                }
    16801637
    1681         /* 通信端点をロックする。*/
     1638        /* 通信端点をロックする。*/
    16821639        syscall(wai_sem(cep->semid_lock));
    16831640
    1684         /* 受信ウィンドバッファから受信したオクテットを削除する。*/
     1641        /* 受信ウィンドバッファから受信したオクテットを削除する。*/
    16851642        TCP_DROP_RWBUF(cep, (uint_t)len);
    16861643
    1687         /* tcp_rcv_buf の割当て長をリセットする。*/
     1644        /* tcp_rcv_buf の割当て長をリセットする。*/
    16881645        cep->rcv_buf_len = 0;
    16891646
    1690         /* 通信端点のロックを解除する。*/
     1647        /* 通信端点のロックを解除する。*/
    16911648        syscall(sig_sem(cep->semid_lock));
    16921649
    1693         /* 相手にウィンドウサイズが変わったことを知らせるため出力をポストする。*/
     1650        /* 相手にウィンドウサイズが変わったことを知らせるため出力をポストする。*/
    16941651        cep->flags |= TCP_CEP_FLG_POST_OUTPUT;
    16951652        sig_sem(SEM_TCP_POST_OUTPUT);
     
    17061663
    17071664/*
    1708  *  tcp_can_snd -- ペンディングしている送信のキャンセル
     1665 *  tcp_can_snd -- ペンディングしている送信のキャンセル
    17091666 */
    17101667
     
    17141671        ER      error = E_OK;
    17151672
    1716         /* 通信端点をロックする。*/
     1673        /* 通信端点をロックする。*/
    17171674        syscall(wai_sem(cep->semid_lock));
    17181675
    17191676        /*
    1720          *  snd_tskid が TA_NULL なら、
    1721          *  ペンディングしていないのでエラー
     1677         *  snd_tskid が TA_NULL なら、
     1678         *  ペンディングしていないのでエラー
    17221679         */
    17231680        if (cep->snd_tskid == TA_NULL)
    17241681                error = EV_NOPND;
    17251682
    1726         /* ペンディング中の API 機能コードと一致しなければエラー */
     1683        /* ペンディング中の API 機能コードと一致しなければエラー */
    17271684        else if (fncd != TFN_TCP_ALL && fncd != cep->snd_tfn)
    17281685                error = E_OBJ;
    17291686
    1730         /* 処理をキャンセルする。*/
     1687        /* 処理をキャンセルする。*/
    17311688        else {
    17321689
    1733                 /* 受信再構成キューのネットワークバッファを解放する。*/
     1690                /* 受信再構成キューのネットワークバッファを解放する。*/
    17341691                tcp_free_reassq(cep);
    17351692
    1736                 /* 受信ウィンドバッファキューのネットワークバッファを解放する。*/
     1693                /* 受信ウィンドバッファキューのネットワークバッファを解放する。*/
    17371694                cep->rwbuf_count = 0;
    17381695                TCP_FREE_RWBUFQ(cep);
    17391696
    1740                 /* 送信ウィンドバッファキューのネットワークバッファを解放する。*/
     1697                /* 送信ウィンドバッファキューのネットワークバッファを解放する。*/
    17411698                TCP_FREE_SWBUFQ(cep);
    17421699
    17431700#ifdef TCP_CFG_NON_BLOCKING
    17441701
    1745                 if (cep->snd_nblk_tfn != TFN_TCP_UNDEF) {       /* ノンブロッキングコール */
     1702                if (cep->snd_nblk_tfn != TFN_TCP_UNDEF) {       /* ノンブロッキングコール */
    17461703
    17471704                        switch (cep->snd_nblk_tfn) {
    17481705
    17491706                        case TFN_TCP_CON_CEP:
    1750                                 /*  通信端点から受付口を解放する。*/
     1707                                /*  通信端点から受付口を解放する。*/
    17511708                                cep->rep = NULL;
    17521709                                cep->fsm_state = TCP_FSM_CLOSED;
     
    17891746                }
    17901747
    1791         /* 通信端点のロックを解除する。*/
     1748        /* 通信端点のロックを解除する。*/
    17921749        syscall(sig_sem(cep->semid_lock));
    17931750
     
    17961753
    17971754/*
    1798  *  tcp_can_rcv -- ペンディングしている受信のキャンセル
     1755 *  tcp_can_rcv -- ペンディングしている受信のキャンセル
    17991756 */
    18001757
     
    18041761        ER      error = E_OK;
    18051762
    1806         /* 通信端点をロックする。*/
     1763        /* 通信端点をロックする。*/
    18071764        syscall(wai_sem(cep->semid_lock));
    18081765
    18091766        /*
    1810          *  rcv_tskid が TA_NULL なら、
    1811          *  ペンディングしていないのでエラー
     1767         *  rcv_tskid が TA_NULL なら、
     1768         *  ペンディングしていないのでエラー
    18121769         */
    18131770        if (cep->rcv_tskid == TA_NULL)
    18141771                error = EV_NOPND;
    18151772
    1816         /* ペンディング中の API 機能コードと一致しなければエラー */
     1773        /* ペンディング中の API 機能コードと一致しなければエラー */
    18171774        else if (fncd != TFN_TCP_ALL && fncd != cep->rcv_tfn)
    18181775                error = E_OBJ;
    18191776
    1820         /* 処理をキャンセルする。*/
     1777        /* 処理をキャンセルする。*/
    18211778        else {
    18221779
    1823                 /* 受信再構成キューのネットワークバッファを解放する。*/
     1780                /* 受信再構成キューのネットワークバッファを解放する。*/
    18241781                tcp_free_reassq(cep);
    18251782
    1826                 /* 受信ウィンドバッファキューのネットワークバッファを解放する。*/
     1783                /* 受信ウィンドバッファキューのネットワークバッファを解放する。*/
    18271784                cep->rwbuf_count = 0;
    18281785                TCP_FREE_RWBUFQ(cep);
    18291786
    1830                 /* 送信ウィンドバッファキューのネットワークバッファを解放する。*/
     1787                /* 送信ウィンドバッファキューのネットワークバッファを解放する。*/
    18311788                TCP_FREE_SWBUFQ(cep);
    18321789
    18331790#ifdef TCP_CFG_NON_BLOCKING
    18341791
    1835                 if (cep->rcv_nblk_tfn != TFN_TCP_UNDEF) {       /* ノンブロッキングコール */
     1792                if (cep->rcv_nblk_tfn != TFN_TCP_UNDEF) {       /* ノンブロッキングコール */
    18361793
    18371794                        switch (cep->rcv_nblk_tfn) {
     
    18391796                        case TFN_TCP_ACP_CEP:
    18401797                                /*
    1841                                  *  通信端点から受付口を解放し、
    1842                                  *  イベントフラグをクローズに設定する。
     1798                                 *  通信端点から受付口を解放し、
     1799                                 *  イベントフラグをクローズに設定する。
    18431800                                 */
    18441801                                cep->rep = NULL;
     
    18881845                }
    18891846
    1890         /* 通信端点のロックを解除する。*/
     1847        /* 通信端点のロックを解除する。*/
    18911848        syscall(sig_sem(cep->semid_lock));
    18921849
     
    18951852
    18961853/*
    1897  *  tcp_can_cep -- ペンディングしている処理のキャンセル【標準機能】
     1854 *  tcp_can_cep -- ペンディングしている処理のキャンセル【標準機能】
    18981855 */
    18991856
     
    19041861        ER              error = E_OK, snd_err, rcv_err;
    19051862
    1906         /* API 機能コードをチェックする。*/
     1863        /* API 機能コードをチェックする。*/
    19071864        if (!VALID_TFN_TCP_CAN(fncd))
    19081865                return E_PAR;
    19091866
    1910         /* TCP 通信端点 ID をチェックする。*/
     1867        /* TCP 通信端点 ID をチェックする。*/
    19111868        if (!VAID_TCP_CEPID(cepid))
    19121869                return E_ID;
    19131870
    1914         /* TCP 通信端点を得る。*/
     1871        /* TCP 通信端点を得る。*/
    19151872        cep = GET_TCP_CEP(cepid);
    19161873
    1917         /* TCP 通信端点をチェックする。*/
     1874        /* TCP 通信端点をチェックする。*/
    19181875        if (!VALID_TCP_CEP(cep))
    19191876                return E_NOEXS;
    19201877
    1921         if (fncd == TFN_TCP_ALL) {              /* TFN_TCP_ALL の処理 */
     1878        if (fncd == TFN_TCP_ALL) {              /* TFN_TCP_ALL の処理 */
    19221879                snd_err = tcp_can_snd(cep, fncd);
    19231880                rcv_err = tcp_can_rcv(cep, fncd);
    19241881
    19251882                /*
    1926                  *  snd_err と rcv_err のどちらも EV_NOPND
    1927                  *  なら、ペンディングしていないのでエラー
     1883                 *  snd_err と rcv_err のどちらも EV_NOPND
     1884                 *  なら、ペンディングしていないのでエラー
    19281885                 */
    19291886                if (snd_err == EV_NOPND && rcv_err == EV_NOPND)
     
    19421899                }
    19431900
    1944         else if (IS_TFN_TCP_RCV(fncd)) {        /* 受信処理のキャンセル */
     1901        else if (IS_TFN_TCP_RCV(fncd)) {        /* 受信処理のキャンセル */
    19451902                if ((error = tcp_can_rcv(cep, fncd)) == EV_NOPND)
    19461903                        error = E_OBJ;
    19471904                }
    19481905
    1949         else {                                  /* 送信処理のキャンセル */
     1906        else {                                  /* 送信処理のキャンセル */
    19501907                if ((error = tcp_can_snd(cep, fncd)) == EV_NOPND)
    19511908                        error = E_OBJ;
     
    19581915
    19591916/*
    1960  *  tcp_set_opt -- TCP 通信端点オプションの設定【拡張機能】
     1917 *  tcp_set_opt -- TCP 通信端点オプションの設定【拡張機能】
    19611918 *
    1962  *  注意: 設定可能な TCP 通信端点オプションは無いため、E_PAR が返される。
     1919 *  注意: 設定可能な TCP 通信端点オプションは無いため、E_PAR が返される。
    19631920 */
    19641921
     
    19721929        T_TCP_CEP       *cep;
    19731930
    1974         /* TCP 通信端点 ID をチェックする。*/
     1931        /* TCP 通信端点 ID をチェックする。*/
    19751932        if (!VAID_TCP_CEPID(cepid))
    19761933                return E_ID;
    19771934
    1978         /* TCP 通信端点を得る。*/
     1935        /* TCP 通信端点を得る。*/
    19791936        cep = GET_TCP_CEP(cepid);
    19801937
    1981         /* TCP 通信端点をチェックする。*/
     1938        /* TCP 通信端点をチェックする。*/
    19821939        if (!VALID_TCP_CEP(cep))
    19831940                return E_NOEXS;
     
    19911948
    19921949/*
    1993  *  tcp_get_opt -- TCP 通信端点オプションの設定【拡張機能】
     1950 *  tcp_get_opt -- TCP 通信端点オプションの設定【拡張機能】
    19941951 *
    1995  *  注意: 設定可能な TCP 通信端点オプションは無いため、E_PAR が返される。
     1952 *  注意: 設定可能な TCP 通信端点オプションは無いため、E_PAR が返される。
    19961953 */
    19971954
     
    20051962        T_TCP_CEP       *cep;
    20061963
    2007         /* TCP 通信端点 ID をチェックする。*/
     1964        /* TCP 通信端点 ID をチェックする。*/
    20081965        if (!VAID_TCP_CEPID(cepid))
    20091966                return E_ID;
    20101967
    2011         /* TCP 通信端点を得る。*/
     1968        /* TCP 通信端点を得る。*/
    20121969        cep = GET_TCP_CEP(cepid);
    20131970
    2014         /* TCP 通信端点をチェックする。*/
     1971        /* TCP 通信端点をチェックする。*/
    20151972        if (!VALID_TCP_CEP(cep))
    20161973                return E_NOEXS;
Note: See TracChangeset for help on using the changeset viewer.