luna - wolfssl/doc/dox_comments/header

    1/*!
    2    \brief この関数はDTLS v1.2クライアントメソッドを初期化します。
    3
    4    \return pointer この関数は新しいWOLFSSL_METHOD構造体へのポインタを返します。
    5
    6    \param none パラメータはありません。
    7
    8    _Example_
    9    \code
   10    wolfSSL_Init();
   11    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfDTLSv1_2_client_method());
   12    …
   13    WOLFSSL* ssl = wolfSSL_new(ctx);
   14    …
   15    \endcode
   16
   17    \sa wolfSSL_Init
   18    \sa wolfSSL_CTX_new
   19*/
   20WOLFSSL_METHOD *wolfDTLSv1_2_client_method_ex(void* heap);
   21
   22/*!
   23    \ingroup Setup
   24
   25    \brief この関数はwolfSSLv23_client_methodに似たWOLFSSL_METHODを返しますが、どちら側(サーバ/クライアント)であるかがまだ決定されていない点が異なります。
   26
   27    \return WOLFSSL_METHOD* 正常に作成された場合、WOLFSSL_METHODポインタを返します
   28    \return NULL メモリ割り当てエラーまたはメソッド作成失敗の場合はNullを返します
   29
   30    \param none パラメータはありません。
   31
   32    _Example_
   33    \code
   34    WOLFSSL* ctx;
   35    ctx  = wolfSSL_CTX_new(wolfSSLv23_method());
   36    // ret値をチェック
   37    \endcode
   38
   39    \sa wolfSSL_new
   40    \sa wolfSSL_free
   41*/
   42WOLFSSL_METHOD *wolfSSLv23_method(void);
   43
   44/*!
   45    \ingroup Setup
   46
   47    \brief wolfSSLv3_server_method()関数は、アプリケーションがサーバであり、SSL 3.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
   48
   49    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
   50    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
   51
   52    \param none パラメータはありません。
   53
   54    _Example_
   55    \code
   56    #include <wolfssl/ssl.h>
   57
   58    WOLFSSL_METHOD* method;
   59    WOLFSSL_CTX* ctx;
   60
   61    method = wolfSSLv3_server_method();
   62    if (method == NULL) {
   63	    メソッドを取得できません
   64    }
   65
   66    ctx = wolfSSL_CTX_new(method);
   67    ...
   68    \endcode
   69
   70    \sa wolfTLSv1_server_method
   71    \sa wolfTLSv1_1_server_method
   72    \sa wolfTLSv1_2_server_method
   73    \sa wolfTLSv1_3_server_method
   74    \sa wolfDTLSv1_server_method
   75    \sa wolfSSLv23_server_method
   76    \sa wolfSSL_CTX_new
   77
   78*/
   79WOLFSSL_METHOD *wolfSSLv3_server_method(void);
   80
   81/*!
   82    \ingroup Setup
   83
   84    \brief wolfSSLv3_client_method()関数は、アプリケーションがクライアントであり、SSL 3.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
   85
   86    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
   87    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
   88
   89    \param none パラメータはありません。
   90
   91    _Example_
   92    \code
   93    #include <wolfssl/ssl.h>
   94
   95    WOLFSSL_METHOD* method;
   96    WOLFSSL_CTX* ctx;
   97
   98    method = wolfSSLv3_client_method();
   99    if (method == NULL) {
  100	    メソッドを取得できません
  101    }
  102
  103    ctx = wolfSSL_CTX_new(method);
  104    ...
  105    \endcode
  106
  107    \sa wolfTLSv1_client_method
  108    \sa wolfTLSv1_1_client_method
  109    \sa wolfTLSv1_2_client_method
  110    \sa wolfTLSv1_3_client_method
  111    \sa wolfDTLSv1_client_method
  112    \sa wolfSSLv23_client_method
  113    \sa wolfSSL_CTX_new
  114*/
  115WOLFSSL_METHOD *wolfSSLv3_client_method(void);
  116
  117/*!
  118    \ingroup Setup
  119
  120    \brief wolfTLSv1_server_method()関数は、アプリケーションがサーバであり、TLS 1.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  121
  122    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  123    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  124
  125    \param none パラメータはありません。
  126
  127    _Example_
  128    \code
  129    #include <wolfssl/ssl.h>
  130
  131    WOLFSSL_METHOD* method;
  132    WOLFSSL_CTX* ctx;
  133
  134    method = wolfTLSv1_server_method();
  135    if (method == NULL) {
  136	    メソッドを取得できません
  137    }
  138
  139    ctx = wolfSSL_CTX_new(method);
  140    ...
  141    \endcode
  142
  143    \sa wolfSSLv3_server_method
  144    \sa wolfTLSv1_1_server_method
  145    \sa wolfTLSv1_2_server_method
  146    \sa wolfTLSv1_3_server_method
  147    \sa wolfDTLSv1_server_method
  148    \sa wolfSSLv23_server_method
  149    \sa wolfSSL_CTX_new
  150*/
  151WOLFSSL_METHOD *wolfTLSv1_server_method(void);
  152
  153/*!
  154    \ingroup Setup
  155
  156    \brief wolfTLSv1_client_method()関数は、アプリケーションがクライアントであり、TLS 1.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  157
  158    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  159    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  160
  161    \param none パラメータはありません。
  162
  163    _Example_
  164    \code
  165    #include <wolfssl/ssl.h>
  166
  167    WOLFSSL_METHOD* method;
  168    WOLFSSL_CTX* ctx;
  169
  170    method = wolfTLSv1_client_method();
  171    if (method == NULL) {
  172	    メソッドを取得できません
  173    }
  174
  175    ctx = wolfSSL_CTX_new(method);
  176    ...
  177    \endcode
  178
  179    \sa wolfSSLv3_client_method
  180    \sa wolfTLSv1_1_client_method
  181    \sa wolfTLSv1_2_client_method
  182    \sa wolfTLSv1_3_client_method
  183    \sa wolfDTLSv1_client_method
  184    \sa wolfSSLv23_client_method
  185    \sa wolfSSL_CTX_new
  186*/
  187WOLFSSL_METHOD *wolfTLSv1_client_method(void);
  188
  189/*!
  190    \ingroup Setup
  191
  192    \brief wolfTLSv1_1_server_method()関数は、アプリケーションがサーバであり、TLS 1.1プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  193
  194    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  195    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  196
  197    \param none パラメータはありません。
  198
  199    _Example_
  200    \code
  201    #include <wolfssl/ssl.h>
  202
  203    WOLFSSL_METHOD* method;
  204    WOLFSSL_CTX* ctx;
  205
  206    method = wolfTLSv1_1_server_method();
  207    if (method == NULL) {
  208        // メソッドを取得できません
  209    }
  210
  211    ctx = wolfSSL_CTX_new(method);
  212    ...
  213    \endcode
  214
  215    \sa wolfSSLv3_server_method
  216    \sa wolfTLSv1_server_method
  217    \sa wolfTLSv1_2_server_method
  218    \sa wolfTLSv1_3_server_method
  219    \sa wolfDTLSv1_server_method
  220    \sa wolfSSLv23_server_method
  221    \sa wolfSSL_CTX_new
  222*/
  223WOLFSSL_METHOD *wolfTLSv1_1_server_method(void);
  224
  225/*!
  226    \ingroup Setup
  227
  228    \brief wolfTLSv1_1_client_method()関数は、アプリケーションがクライアントであり、TLS 1.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  229
  230    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  231    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  232
  233    \param none パラメータはありません。
  234
  235    _Example_
  236    \code
  237    #include <wolfssl/ssl.h>
  238
  239    WOLFSSL_METHOD* method;
  240    WOLFSSL_CTX* ctx;
  241
  242    method = wolfTLSv1_1_client_method();
  243    if (method == NULL) {
  244        // メソッドを取得できません
  245    }
  246
  247    ctx = wolfSSL_CTX_new(method);
  248    ...
  249    \endcode
  250
  251    \sa wolfSSLv3_client_method
  252    \sa wolfTLSv1_client_method
  253    \sa wolfTLSv1_2_client_method
  254    \sa wolfTLSv1_3_client_method
  255    \sa wolfDTLSv1_client_method
  256    \sa wolfSSLv23_client_method
  257    \sa wolfSSL_CTX_new
  258*/
  259WOLFSSL_METHOD *wolfTLSv1_1_client_method(void);
  260
  261/*!
  262    \ingroup Setup
  263
  264    \brief wolfTLSv1_2_server_method()関数は、アプリケーションがサーバであり、TLS 1.2プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  265
  266    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  267    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  268
  269    \param none パラメータはありません。
  270
  271    _Example_
  272    \code
  273    #include <wolfssl/ssl.h>
  274
  275    WOLFSSL_METHOD* method;
  276    WOLFSSL_CTX* ctx;
  277
  278    method = wolfTLSv1_2_server_method();
  279    if (method == NULL) {
  280	    // メソッドを取得できません
  281    }
  282
  283    ctx = wolfSSL_CTX_new(method);
  284    ...
  285    \endcode
  286
  287    \sa wolfSSLv3_server_method
  288    \sa wolfTLSv1_server_method
  289    \sa wolfTLSv1_1_server_method
  290    \sa wolfTLSv1_3_server_method
  291    \sa wolfDTLSv1_server_method
  292    \sa wolfSSLv23_server_method
  293    \sa wolfSSL_CTX_new
  294*/
  295WOLFSSL_METHOD *wolfTLSv1_2_server_method(void);
  296
  297/*!
  298    \ingroup Setup
  299
  300    \brief wolfTLSv1_2_client_method()関数は、アプリケーションがクライアントであり、TLS 1.2プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のためのメモリを割り当てて初期化します。
  301
  302    \return ＊ 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  303    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
  304
  305    \param none パラメータはありません。
  306
  307    _Example_
  308    \code
  309    #include <wolfssl/ssl.h>
  310
  311    WOLFSSL_METHOD* method;
  312    WOLFSSL_CTX* ctx;
  313
  314    method = wolfTLSv1_2_client_method();
  315    if (method == NULL) {
  316	    // メソッドを取得できません
  317    }
  318
  319    ctx = wolfSSL_CTX_new(method);
  320    ...
  321    \endcode
  322
  323    \sa wolfSSLv3_client_method
  324    \sa wolfTLSv1_client_method
  325    \sa wolfTLSv1_1_client_method
  326    \sa wolfTLSv1_3_client_method
  327    \sa wolfDTLSv1_client_method
  328    \sa wolfSSLv23_client_method
  329    \sa wolfSSL_CTX_new
  330*/
  331WOLFSSL_METHOD *wolfTLSv1_2_client_method(void);
  332
  333/*!
  334    \ingroup Setup
  335    \brief wolfDTLSv1_client_method()関数は、アプリケーションがクライアントであり、DTLS 1.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSサポート付きでコンパイルされている場合(--enable-dtls、またはwolfSSL_DTLSを定義することによって)にのみ利用可能です。
  336    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  337    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  338
  339    \param none パラメータはありません。
  340
  341    _Example_
  342    \code
  343    WOLFSSL_METHOD* method;
  344    WOLFSSL_CTX* ctx;
  345
  346    method = wolfDTLSv1_client_method();
  347    if (method == NULL) {
  348	    // メソッドを取得できません
  349    }
  350
  351    ctx = wolfSSL_CTX_new(method);
  352    ...
  353    \endcode
  354
  355    \sa wolfSSLv3_client_method
  356    \sa wolfTLSv1_client_method
  357    \sa wolfTLSv1_1_client_method
  358    \sa wolfTLSv1_2_client_method
  359    \sa wolfTLSv1_3_client_method
  360    \sa wolfSSLv23_client_method
  361    \sa wolfSSL_CTX_new
  362*/
  363WOLFSSL_METHOD *wolfDTLSv1_client_method(void);
  364
  365/*!
  366    \ingroup Setup
  367
  368    \brief wolfDTLSv1_server_method()関数は、アプリケーションがサーバーであり、DTLS 1.0プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSサポートを有効にしてコンパイルされている場合にのみ使用可能です（--enable-dtls、またはwolfSSL_DTLSを定義することによって）。
  369
  370    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  371    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  372
  373    \param none パラメータはありません。
  374
  375    _Example_
  376    \code
  377    WOLFSSL_METHOD* method;
  378    WOLFSSL_CTX* ctx;
  379
  380    method = wolfDTLSv1_server_method();
  381    if (method == NULL) {
  382	    // メソッドを取得できません
  383    }
  384
  385    ctx = wolfSSL_CTX_new(method);
  386    ...
  387    \endcode
  388
  389    \sa wolfSSLv3_server_method
  390    \sa wolfTLSv1_server_method
  391    \sa wolfTLSv1_1_server_method
  392    \sa wolfTLSv1_2_server_method
  393    \sa wolfTLSv1_3_server_method
  394    \sa wolfSSLv23_server_method
  395    \sa wolfSSL_CTX_new
  396*/
  397WOLFSSL_METHOD *wolfDTLSv1_server_method(void);
  398/*!
  399    \ingroup Setup
  400
  401    \brief wolfDTLSv1_3_server_method()関数は、アプリケーションがサーバーであり、DTLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSv1.3サポートを有効にしてコンパイルされている場合にのみ使用可能です（--enable-dtls13、またはwolfSSL_DTLS13を定義することによって）。
  402
  403    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  404    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  405
  406    \param none パラメータはありません。
  407
  408    _Example_
  409    \code
  410    WOLFSSL_METHOD* method;
  411    WOLFSSL_CTX* ctx;
  412
  413    method = wolfDTLSv1_3_server_method();
  414    if (method == NULL) {
  415	    // メソッドを取得できません
  416    }
  417
  418    ctx = wolfSSL_CTX_new(method);
  419    ...
  420    \endcode
  421
  422
  423    \sa wolfDTLSv1_3_client_method
  424*/
  425
  426WOLFSSL_METHOD *wolfDTLSv1_3_server_method(void);
  427/*!
  428    \ingroup Setup
  429
  430    \brief wolfDTLSv1_3_client_method()関数は、アプリケーションがクライアントであり、DTLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSv1.3サポートを有効にしてコンパイルされている場合にのみ使用可能です（--enable-dtls13、またはwolfSSL_DTLS13を定義することによって）。
  431
  432    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  433    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  434
  435    \param none パラメータはありません。
  436
  437    _Example_
  438    \code
  439    WOLFSSL_METHOD* method;
  440    WOLFSSL_CTX* ctx;
  441
  442    method = wolfDTLSv1_3_client_method();
  443    if (method == NULL) {
  444	    // メソッドを取得できません
  445    }
  446
  447    ctx = wolfSSL_CTX_new(method);
  448    ...
  449    \endcode
  450
  451
  452    \sa wolfDTLSv1_3_server_method
  453*/
  454WOLFSSL_METHOD* wolfDTLSv1_3_client_method(void);
  455/*!
  456    \ingroup Setup
  457
  458    \brief wolfDTLS_server_method()関数は、アプリケーションがサーバーであり、利用可能な最新バージョンのDTLSおよび許可される最小バージョンまでのすべてのバージョンをサポートすることを示すために使用されます。デフォルトの許可される最小バージョンは、WOLFSSL_MIN_DTLS_DOWNGRADEの定義に基づいており、wolfSSL_SetMinVersion()を使用して実行時に変更できます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSサポートを有効にしてコンパイルされている場合にのみ使用可能です（--enable-dtls、またはwolfSSL_DTLSを定義することによって）。
  459
  460    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  461    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  462
  463    \param none パラメータはありません。
  464
  465    _Example_
  466    \code
  467    WOLFSSL_METHOD* method;
  468    WOLFSSL_CTX* ctx;
  469
  470    method = wolfDTLS_server_method();
  471    if (method == NULL) {
  472	    // メソッドを取得できません
  473    }
  474
  475    ctx = wolfSSL_CTX_new(method);
  476    ...
  477    \endcode
  478
  479
  480    \sa wolfDTLS_client_method
  481    \sa wolfSSL_SetMinVersion
  482*/
  483WOLFSSL_METHOD *wolfDTLS_server_method(void);
  484/*!
  485    \ingroup Setup
  486
  487    \brief wolfDTLS_client_method()関数は、アプリケーションがクライアントであり、利用可能な最新バージョンのDTLSおよび許可される最小バージョンまでのすべてのバージョンをサポートすることを示すために使用されます。デフォルトの許可される最小バージョンは、WOLFSSL_MIN_DTLS_DOWNGRADEの定義に基づいており、wolfSSL_SetMinVersion()を使用して実行時に変更できます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。この関数は、wolfSSLがDTLSサポートを有効にしてコンパイルされている場合にのみ使用可能です（--enable-dtls、またはwolfSSL_DTLSを定義することによって）。
  488
  489    \return ＊ 成功した場合、この呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
  490    \return FAIL XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます（通常はNULLで、errnoがENOMEMに設定されます）。
  491
  492    \param none パラメータはありません。
  493
  494    _Example_
  495    \code
  496    WOLFSSL_METHOD* method;
  497    WOLFSSL_CTX* ctx;
  498
  499    method = wolfDTLS_client_method();
  500    if (method == NULL) {
  501	    // メソッドを取得できません
  502    }
  503
  504    ctx = wolfSSL_CTX_new(method);
  505    ...
  506    \endcode
  507
  508
  509    \sa wolfDTLS_server_method
  510    \sa wolfSSL_SetMinVersion
  511*/
  512WOLFSSL_METHOD *wolfDTLS_client_method(void);
  513/*!
  514    \brief この関数は、サーバー側用のWOLFSSL_METHODを作成し、初期化します。
  515
  516    \return この関数はWOLFSSL_METHODポインタを返します。
  517
  518    \param none パラメータはありません。
  519
  520    _Example_
  521    \code
  522    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfDTLSv1_2_server_method());
  523    WOLFSSL* ssl = WOLFSSL_new(ctx);
  524    …
  525    \endcode
  526
  527    \sa wolfSSL_CTX_new
  528*/
  529WOLFSSL_METHOD *wolfDTLSv1_2_server_method(void);
  530
  531/*!
  532    \ingroup Setup
  533
  534    \brief chacha-poly AEAD構築の最初のリリースと新しいバージョンの間にはいくつかの違いがあるため、古いバージョンを使用するサーバー/クライアントと通信するためのオプションを追加しました。デフォルトでは、wolfSSLは新しいバージョンを使用します。
  535
  536    \return 0 成功時
  537
  538    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
  539    \param value poly1305の情報を設定する際に古いバージョンを使用するかどうか。フラグ値1を渡すと古いpoly AEADを使用することを示し、新しいバージョンの使用に戻すにはフラグ値0を渡します。
  540
  541    _Example_
  542    \code
  543    int ret = 0;
  544    WOLFSSL* ssl;
  545    ...
  546
  547    ret = wolfSSL_use_old_poly(ssl, 1);
  548    if (ret != 0) {
  549        // poly1305 AEADバージョンの設定に失敗しました
  550    }
  551    \endcode
  552
  553    \sa none
  554*/
  555int wolfSSL_use_old_poly(WOLFSSL* ssl, int value);
  556
  557/*!
  558    \brief wolfSSL_dtls_import()関数は、シリアル化されたセッション状態を解析するために使用されます。これにより、ハンドシェイクが完了した後に接続を再開できます。
  559
  560    \return Success 成功した場合、読み取られたバッファの量が返されます。
  561    \return Failure すべての失敗した戻り値は0未満になります。
  562    \return VERSION_ERROR バージョンの不一致が見つかった場合、つまりDTLS v1でctxがDTLS v1.2用に設定されている場合、VERSION_ERRORが返されます。
  563
  564    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
  565    \param buf インポートするシリアル化されたセッション。
  566    \param sz シリアル化されたセッションバッファのサイズ。
  567
  568    _Example_
  569    \code
  570    WOLFSSL* ssl;
  571    int ret;
  572    unsigned char buf[MAX];
  573    bufSz = MAX;
  574    ...
  575    // wc_dtls_export関数から送信された情報を取得し、bufに配置します
  576    fread(buf, 1, bufSz, input);
  577    ret = wolfSSL_dtls_import(ssl, buf, bufSz);
  578    if (ret < 0) {
  579        // エラーケースを処理します
  580    }
  581    // ハンドシェイクが既に完了しているため、wolfSSL_acceptは不要です
  582    ...
  583    ret = wolfSSL_write(ssl) および wolfSSL_read(ssl);
  584    ...
  585    \endcode
  586
  587    \sa wolfSSL_new
  588    \sa wolfSSL_CTX_new
  589    \sa wolfSSL_CTX_dtls_set_export
  590*/
  591int wolfSSL_dtls_import(WOLFSSL* ssl, const unsigned char* buf,
  592                                                               unsigned int sz);
  593
  594
  595/*!
  596    \brief シリアル化されたTLSセッションをインポートするために使用されます。この関数は、接続の状態をインポートするためのものです。警告：bufには状態に関する機密情報が含まれており、保存する場合は暗号化してから保存するのが最善です。マクロWOLFSSL_SESSION_EXPORT_DEBUGを定義することで、追加のデバッグ情報を表示できます。
  597
  598    \return バッファ'buf'から読み取られたバイト数
  599
  600    \param ssl セッションをインポートするWOLFSSL構造体
  601    \param buf シリアル化されたセッション
  602    \param sz  バッファ'buf'のサイズ
  603
  604    \sa wolfSSL_dtls_import
  605    \sa wolfSSL_tls_export
  606 */
  607int wolfSSL_tls_import(WOLFSSL* ssl, const unsigned char* buf,
  608        unsigned int sz);
  609
  610/*!
  611    \brief wolfSSL_CTX_dtls_set_export()関数は、セッションをエクスポートするためのコールバック関数を設定するために使用されます。以前に保存されたエクスポート関数をクリアするために、パラメータfuncとしてNULLを渡すことができます。サーバー側で使用され、ハンドシェイクが完了した直後に呼び出されます。
  612
  613    \return SSL_SUCCESS 成功時。
  614    \return BAD_FUNC_ARG nullまたは期待されない引数が渡された場合
  615
  616    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
  617    \param func セッションをエクスポートする際に使用するwc_dtls_export関数。
  618
  619    _Example_
  620    \code
  621    int send_session(WOLFSSL* ssl, byte* buf, word32 sz, void* userCtx);
  622    // buf（シリアル化されたセッション）を宛先に渡すsend session（wc_dtls_export）の本体
  623    WOLFSSL_CTX* ctx;
  624    int ret;
  625    ...
  626    ret = wolfSSL_CTX_dtls_set_export(ctx, send_session);
  627    if (ret != SSL_SUCCESS) {
  628        // エラーケースを処理します
  629    }
  630    ...
  631    ret = wolfSSL_accept(ssl);
  632    ...
  633    \endcode
  634
  635    \sa wolfSSL_new
  636    \sa wolfSSL_CTX_new
  637    \sa wolfSSL_dtls_set_export
  638    \sa Static buffer use
  639*/
  640int wolfSSL_CTX_dtls_set_export(WOLFSSL_CTX* ctx,
  641                                                           wc_dtls_export func);
  642
  643/*!
  644    \brief wolfSSL_dtls_set_export()関数は、セッションをエクスポートするためのコールバック関数を設定するために使用されます。以前に保存されたエクスポート関数をクリアするために、パラメータfuncとしてNULLを渡すことができます。サーバー側で使用され、ハンドシェイクが完了した直後に呼び出されます。
  645
  646    \return SSL_SUCCESS 成功時。
  647    \return BAD_FUNC_ARG nullまたは期待されない引数が渡された場合
  648
  649    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
  650    \param func セッションをエクスポートする際に使用するwc_dtls_export関数。
  651
  652    _Example_
  653    \code    int send_session(WOLFSSL* ssl, byte* buf, word32 sz, void* userCtx);
  654    // send sessionの本体(wc_dtls_export)
  655    // buf(シリアライズされたセッション)を宛先に渡す
  656    WOLFSSL* ssl;
  657    int ret;
  658    ...
  659    ret = wolfSSL_dtls_set_export(ssl, send_session);
  660    if (ret != SSL_SUCCESS) {
  661        // エラーケースの処理
  662    }
  663    ...
  664    ret = wolfSSL_accept(ssl);
  665    ...
  666    \endcode
  667
  668    \sa wolfSSL_new
  669    \sa wolfSSL_CTX_new
  670    \sa wolfSSL_CTX_dtls_set_export
  671*/
  672int wolfSSL_dtls_set_export(WOLFSSL* ssl, wc_dtls_export func);
  673
  674/*!
  675    \brief wolfSSL_dtls_export()関数は、WOLFSSLセッションを提供されたバッファにシリアライズするために使用されます。セッションを送信するための関数コールバックを使用するよりもメモリオーバーヘッドが少なく、セッションをシリアライズするタイミングを選択できます。関数に渡されたときにbufferがNULLの場合、szはWOLFSSLセッションをシリアライズするために必要なバッファのサイズに設定されます。
  676
  677    \return Success 成功した場合、使用されたバッファの量が返されます。
  678    \return Failure すべての失敗時の戻り値は0未満になります。
  679
  680    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
  681    \param buf シリアライズされたセッションを保持するバッファ。
  682    \param sz バッファのサイズ。
  683
  684    _Example_
  685    \code
  686    WOLFSSL* ssl;
  687    int ret;
  688    unsigned char buf[MAX];
  689    bufSz = MAX;
  690    ...
  691    ret = wolfSSL_dtls_export(ssl, buf, bufSz);
  692    if (ret < 0) {
  693        // エラーケースの処理
  694    }
  695    ...
  696    \endcode
  697
  698    \sa wolfSSL_new
  699    \sa wolfSSL_CTX_new
  700    \sa wolfSSL_CTX_dtls_set_export
  701    \sa wolfSSL_dtls_import
  702*/
  703int wolfSSL_dtls_export(WOLFSSL* ssl, unsigned char* buf,
  704                                                              unsigned int* sz);
  705
  706/*!
  707    \brief シリアライズされたTLSセッションをエクスポートするために使用されます。この関数は接続のシリアライズされた状態をエクスポートするためのものです。
  708    ほとんどの場合、wolfSSL_tls_exportの代わりにwolfSSL_get1_sessionを使用する必要があります。
  709    追加のデバッグ情報は、マクロWOLFSSL_SESSION_EXPORT_DEBUGが定義されている場合に表示できます。
  710    警告: bufには状態に関する機密情報が含まれているため、保存する場合は暗号化してから保存することが最善です。
  711
  712    \return バッファ'buf'に書き込まれたバイト数
  713
  714    \param ssl セッションをエクスポートするWOLFSSL構造体
  715    \param buf シリアライズされたセッションの出力
  716    \param sz  'buf'に設定されたバイト単位のサイズ
  717
  718    \sa wolfSSL_dtls_import
  719    \sa wolfSSL_tls_import
  720 */
  721int wolfSSL_tls_export(WOLFSSL* ssl, unsigned char* buf,
  722        unsigned int* sz);
  723
  724/*!
  725    \brief この関数は、CTX用の静的メモリを確保するために使用されます。確保されたメモリは、CTXのライフタイム中およびCTXから作成されたSSLオブジェクトに使用されます。NULLのctxポインタとwolfSSL_method_func関数を渡すことで、CTX自体の作成も静的メモリを使用します。wolfSSL_method_funcは、WOLFSSL_METHOD* (*wolfSSL_method_func)(void* heap);という関数シグネチャを持ちます。maxに0を渡すと、設定されていないかのように動作し、最大同時使用制限は適用されません。渡されたflag値は、メモリの使用方法と動作中の挙動を決定します。利用可能なフラグは次のとおりです: 0 - デフォルトの一般メモリ、WOLFMEM_IO_POOL - メッセージの送受信時の入出力バッファに使用され、一般メモリをオーバーライドするため、渡されたバッファ内のすべてのメモリがIOに使用されます、WOLFMEM_IO_FIXED - WOLFMEM_IO_POOLと同じですが、各SSLがライフタイム中に2つのバッファを保持します、WOLFMEM_TRACK_STATS - 各SSLが実行中にメモリ統計を追跡します。
  726
  727    \return SSL_SUCCESS 成功時。
  728    \return SSL_FAILURE 失敗時。
  729
  730    \param ctx WOLFSSL_CTX構造体へのポインタのアドレス。
  731    \param method プロトコルを作成する関数。(ctxもNULLでない場合はNULLであるべきです)
  732    \param buf すべての操作に使用するメモリ。
  733    \param sz 渡されるメモリバッファのサイズ。
  734    \param flag メモリのタイプ。
  735    \param max 最大同時操作数。
  736
  737    _Example_
  738    \code
  739    WOLFSSL_CTX* ctx;
  740    WOLFSSL* ssl;
  741    int ret;
  742    unsigned char memory[MAX];
  743    int memorySz = MAX;
  744    unsigned char IO[MAX];
  745    int IOSz = MAX;
  746    int flag = WOLFMEM_IO_FIXED | WOLFMEM_TRACK_STATS;
  747    ...
  748    // 静的メモリを使用してctxも作成、使用する一般メモリから開始
  749    ctx = NULL:
  750    ret = wolfSSL_CTX_load_static_memory(&ctx, wolfSSLv23_server_method_ex,
  751    memory, memorySz, 0,    MAX_CONCURRENT_HANDSHAKES);
  752    if (ret != SSL_SUCCESS) {
  753        // エラーケースの処理
  754    }
  755    // IOで使用するメモリをロード
  756    ret = wolfSSL_CTX_load_static_memory(&ctx, NULL, IO, IOSz, flag,
  757    MAX_CONCURRENT_IO);
  758    if (ret != SSL_SUCCESS) {
  759        // エラーケースの処理
  760    }
  761    ...
  762    \endcode
  763
  764    \sa wolfSSL_CTX_new
  765    \sa wolfSSL_CTX_is_static_memory
  766    \sa wolfSSL_is_static_memory
  767*/
  768int wolfSSL_CTX_load_static_memory(WOLFSSL_CTX** ctx,
  769                                            wolfSSL_method_func method,
  770                                            unsigned char* buf, unsigned int sz,
  771                                            int flag, int max);
  772
  773/*!
  774    \brief この関数は接続の動作を変更せず、静的メモリの使用状況に関する情報を収集するためにのみ使用されます。
  775
  776    \return 1 CTXが静的メモリを使用している場合にtrueとして返されます。
  777    \return 0 静的メモリを使用していない場合に返されます。
  778
  779    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
  780    \param mem_stats 静的メモリの使用状況に関する情報を保持する構造体。
  781
  782    _Example_
  783    \code
  784    WOLFSSL_CTX* ctx;
  785    int ret;
  786    WOLFSSL_MEM_STATS mem_stats;
  787    ...
  788    //CTXによる静的メモリに関する情報を取得
  789    ret = wolfSSL_CTX_is_static_memory(ctx, &mem_stats);
  790    if (ret == 1) {
  791        // 静的メモリを使用しているケースの処理
  792        // mem_statsの要素を出力または検査
  793    }
  794    if (ret == 0) {
  795        //ctxが静的メモリを使用していないケースの処理
  796    }
  797    …
  798    \endcode
  799
  800    \sa wolfSSL_CTX_new
  801    \sa wolfSSL_CTX_load_static_memory
  802    \sa wolfSSL_is_static_memory
  803*/
  804int wolfSSL_CTX_is_static_memory(WOLFSSL_CTX* ctx,
  805                                                 WOLFSSL_MEM_STATS* mem_stats);
  806
  807/*!
  808    \brief wolfSSL_is_static_memoryは、SSLの静的メモリ使用状況に関する情報を収集するために使用されます。戻り値は静的メモリが使用されているかどうかを示し、WOLFSSL_MEM_CONN_STATSは、静的メモリをロードする際に親CTXにWOLFMEM_TRACK_STATSフラグが渡された場合にのみ入力されます。
  809
  810    \return 1 CTXが静的メモリを使用している場合にtrueとして返されます。
  811    \return 0 静的メモリを使用していない場合に返されます。
  812
  813    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
  814    \param mem_stats 静的メモリの使用状況を含む構造体。
  815
  816    _Example_
  817    \code
  818    WOLFSSL* ssl;
  819    int ret;
  820    WOLFSSL_MEM_CONN_STATS mem_stats;
  821    ...
  822    ret = wolfSSL_is_static_memory(ssl, mem_stats);
  823    if (ret == 1) {
  824        // 静的メモリの場合のケースを処理
  825        // WOLFMEM_TRACK_STATSフラグがある場合、mem_stats内の要素を調査
  826    }
  827    ...
  828    \endcode
  829
  830    \sa wolfSSL_new
  831    \sa wolfSSL_CTX_is_static_memory
  832*/
  833int wolfSSL_is_static_memory(WOLFSSL* ssl,
  834                                            WOLFSSL_MEM_CONN_STATS* mem_stats);
  835
  836/*!
  837    \ingroup CertsKeys
  838
  839    \brief この関数は、証明書ファイルをSSLコンテキスト(WOLFSSL_CTX)にロードします。ファイルはfile引数によって提供されます。format引数はファイルのフォーマットタイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMのいずれかです。適切な使用方法については、exampleを参照してください。
  840
  841    \return SSL_SUCCESS 成功時。
  842    \return SSL_FAILURE 関数呼び出しが失敗した場合、考えられる原因には、ファイルが間違ったフォーマットである、または"format"引数を使用して間違ったフォーマットが指定されている、ファイルが存在しない、読み取れない、または破損している、メモリ不足の状態が発生している、ファイルのBase16デコードが失敗したことなどが含まれます。
  843
  844    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ
  845    \param file wolfSSL SSLコンテキストにロードされる証明書を含むファイルの名前へのポインタ。
  846    \param format - fileが指す証明書のフォーマット。可能なオプションはSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。
  847
  848    _Example_
  849    \code
  850    int ret = 0;
  851    WOLFSSL_CTX* ctx;
  852    ...
  853    ret = wolfSSL_CTX_use_certificate_file(ctx, "./client-cert.pem",
  854                                     SSL_FILETYPE_PEM);
  855    if (ret != SSL_SUCCESS) {
  856	    // 証明書ファイルのロードエラー
  857    }
  858    ...
  859    \endcode
  860
  861    \sa wolfSSL_CTX_use_certificate_buffer
  862    \sa wolfSSL_use_certificate_file
  863    \sa wolfSSL_use_certificate_buffer
  864*/
  865int wolfSSL_CTX_use_certificate_file(WOLFSSL_CTX* ctx, const char* file,
  866                                     int format);
  867
  868/*!
  869    \ingroup CertsKeys
  870
  871    \brief この関数は、秘密鍵ファイルをSSLコンテキスト(WOLFSSL_CTX)にロードします。ファイルはfile引数によって提供されます。format引数はファイルのフォーマットタイプを指定します - SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。適切な使用方法については、exampleを参照してください。
  872
  873    外部キーストアを使用していて秘密鍵を持っていない場合、代わりに公開鍵を提供し、署名を処理するための暗号コールバックを登録できます。これには、暗号コールバックまたはPKコールバックのいずれかでビルドできます。暗号コールバックを有効にするには、--enable-cryptocbまたはWOLF_CRYPTO_CBでビルドし、wc_CryptoCb_RegisterDeviceを使用して暗号コールバックを登録し、wolfSSL_CTX_SetDevIdを使用して関連するdevIdを設定します。
  874
  875    \return SSL_SUCCESS 成功時。
  876    \return SSL_FAILURE ファイルが間違ったフォーマットである、または"format"引数を使用して間違ったフォーマットが指定されている。ファイルが存在しない、読み取れない、または破損している。メモリ不足の状態が発生している。ファイルのBase16デコードが失敗した。キーファイルが暗号化されているが、パスワードが提供されていない。
  877
  878    \param none パラメータなし。
  879
  880    _Example_
  881    \code
  882    int ret = 0;
  883    WOLFSSL_CTX* ctx;
  884    ...
  885    ret = wolfSSL_CTX_use_PrivateKey_file(ctx, "./server-key.pem",
  886                                    SSL_FILETYPE_PEM);
  887    if (ret != SSL_SUCCESS) {
  888	    // 鍵ファイルのロードエラー
  889    }
  890    ...
  891    \endcode
  892
  893    \sa wolfSSL_CTX_use_PrivateKey_buffer
  894    \sa wolfSSL_use_PrivateKey_file
  895    \sa wolfSSL_use_PrivateKey_buffer
  896    \sa wc_CryptoCb_RegisterDevice
  897    \sa wolfSSL_CTX_SetDevId
  898*/
  899int wolfSSL_CTX_use_PrivateKey_file(WOLFSSL_CTX* ctx, const char* file, int format);
  900
  901/*!
  902    \ingroup CertsKeys
  903
  904    \brief この関数は、PEM形式のCA証明書ファイルをSSLコンテキスト(WOLFSSL_CTX)にロードします。これらの証明書は信頼されたルート証明書として扱われ、SSLハンドシェイク中にピアから受信した証明書を検証するために使用されます。file引数によって提供されるルート証明書ファイルは、単一の証明書または複数の証明書を含むファイルである場合があります。
  905    同じファイルに複数のCA証明書が含まれている場合、wolfSSLはファイル内に提示された順序でそれらをロードします。path引数は、信頼されたルートCAの証明書を含むディレクトリの名前へのポインタです。fileの値がNULLでない場合、必要でなければpathをNULLとして指定できます。pathが指定され、ライブラリのビルド時にNO_WOLFSSL_DIRが定義されていない場合、wolfSSLは指定されたディレクトリにあるすべてのCA証明書をロードします。この関数はディレクトリ内のすべてのファイルをロードしようとします。この関数は、ヘッダー"-----BEGIN CERTIFICATE-----"を持つPEM形式のCERT_TYPEファイルを想定しています。
  906
  907    \return SSL_SUCCESS 成功時。
  908    \return SSL_FAILURE ctxがNULLの場合、またはfileとpathの両方がNULLの場合に返されます。
  909    \return SSL_BAD_FILETYPE ファイルが間違ったフォーマットの場合に返されます。
  910    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
  911    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
  912    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
  913    \return ASN_BEFORE_DATE_E 現在の日付がbefore dateより前の場合に返されます。
  914    \return ASN_AFTER_DATE_E 現在の日付がafter dateより後の場合に返されます。
  915    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
  916    \return BAD_PATH_ERROR pathを開こうとしたときにopendir()が失敗した場合に返されます。
  917
  918    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
  919    \param file PEM形式のCA証明書を含むファイルの名前へのポインタ。
  920    \param path PEM形式の証明書をロードするディレクトリの名前へのポインタ。
  921
  922    _Example_
  923    \code
  924    int ret = 0;
  925    WOLFSSL_CTX* ctx;
  926    ...
  927    ret = wolfSSL_CTX_load_verify_locations(ctx, "./ca-cert.pem", NULL);
  928    if (ret != WOLFSSL_SUCCESS) {
  929    	// CA証明書のロードエラー
  930    }
  931    ...
  932    \endcode
  933
  934    \sa wolfSSL_CTX_load_verify_locations_ex
  935    \sa wolfSSL_CTX_load_verify_buffer
  936    \sa wolfSSL_CTX_use_certificate_file
  937    \sa wolfSSL_CTX_use_PrivateKey_file
  938    \sa wolfSSL_CTX_use_certificate_chain_file
  939    \sa wolfSSL_use_certificate_file
  940    \sa wolfSSL_use_PrivateKey_file
  941    \sa wolfSSL_use_certificate_chain_file
  942*/
  943int wolfSSL_CTX_load_verify_locations(WOLFSSL_CTX* ctx, const char* file,
  944                                                const char* path);
  945
  946/*!
  947    \ingroup CertsKeys
  948
  949    \brief この関数は、PEM形式のCA証明書ファイルをSSLコンテキスト(WOLFSSL_CTX)にロードします。これらの証明書は信頼されたルート証明書として扱われ、SSLハンドシェイク中にピアから受信した証明書を検証するために使用されます。file引数によって提供されるルート証明書ファイルは、単一の証明書または複数の証明書を含むファイルである場合があります。
  950    同じファイルに複数のCA証明書が含まれている場合、wolfSSLはファイル内に提示された順序でそれらをロードします。path引数は、信頼されたルートCAの証明書を含むディレクトリの名前へのポインタです。fileの値がNULLでない場合、必要でなければpathをNULLとして指定できます。pathが指定され、ライブラリのビルド時にNO_WOLFSSL_DIRが定義されていない場合、wolfSSLは指定されたディレクトリにあるすべてのCA証明書をロードします。この関数は、指定されたフラグに基づいてディレクトリ内のすべてのファイルをロードしようとします。この関数は、ヘッダー"-----BEGIN CERTIFICATE-----"を持つPEM形式のCERT_TYPEファイルを想定しています。
  951
  952    \return SSL_SUCCESS 成功時。
  953    \return SSL_FAILURE ctxがNULLの場合、またはfileとpathの両方がNULLの場合に返されます。少なくとも1つの証明書が正常にロードされたが、1つ以上が失敗した場合もこれが返されます。理由についてはエラースタックを確認してください。
  954    \return SSL_BAD_FILETYPE ファイルが間違ったフォーマットの場合に返されます。
  955    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
  956    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
  957    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
  958    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
  959    \return BAD_PATH_ERROR pathを開こうとしたときにopendir()が失敗した場合に返されます。    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
  960    \param file PEM形式のCA証明書を含むファイル名へのポインタ。
  961    \param path PEM形式の証明書を読み込むディレクトリ名へのポインタ。
  962    \param flags 指定可能なマスク値: WOLFSSL_LOAD_FLAG_IGNORE_ERR、
  963    WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY、WOLFSSL_LOAD_FLAG_PEM_CA_ONLY
  964
  965    _Example_
  966    \code
  967    int ret = 0;
  968    WOLFSSL_CTX* ctx;
  969    ...
  970    ret = wolfSSL_CTX_load_verify_locations_ex(ctx, NULL, "./certs/external",
  971        WOLFSSL_LOAD_FLAG_PEM_CA_ONLY);
  972    if (ret != WOLFSSL_SUCCESS) {
  973        // CA証明書の読み込みエラー
  974    }
  975    ...
  976    \endcode
  977
  978    \sa wolfSSL_CTX_load_verify_locations
  979    \sa wolfSSL_CTX_load_verify_buffer
  980    \sa wolfSSL_CTX_use_certificate_file
  981    \sa wolfSSL_CTX_use_PrivateKey_file
  982    \sa wolfSSL_CTX_use_certificate_chain_file
  983    \sa wolfSSL_use_certificate_file
  984    \sa wolfSSL_use_PrivateKey_file
  985    \sa wolfSSL_use_certificate_chain_file
  986*/
  987int wolfSSL_CTX_load_verify_locations_ex(WOLFSSL_CTX* ctx, const char* file,
  988                                         const char* path, word32 flags);
  989
  990/*!
  991    \ingroup CertsKeys
  992
  993    \brief この関数は、wolfSSL_CTX_load_system_CA_certsが呼び出されたときにwolfSSLがシステムCA証明書を検索するディレクトリを表す文字列の配列へのポインタを返します。証明書をアクセス可能なシステムディレクトリに保存しないシステム(Appleプラットフォームなど)では、この関数は常にNULLを返します。
  994
  995    \return 成功時は有効なポインタ。
  996    \return 失敗時はNULLポインタ。
  997
  998    \param num 文字列配列の長さが格納されるword32へのポインタ。
  999
 1000    _Example_
 1001    \code
 1002    WOLFSSL_CTX* ctx;
 1003    const char** dirs;
 1004    word32 numDirs;
 1005
 1006    dirs = wolfSSL_get_system_CA_dirs(&numDirs);
 1007    for (int i = 0; i < numDirs; ++i) {
 1008        printf("Potential system CA dir: %s\n", dirs[i]);
 1009    }
 1010    ...
 1011    \endcode
 1012
 1013    \sa wolfSSL_CTX_load_system_CA_certs
 1014    \sa wolfSSL_CTX_load_verify_locations
 1015    \sa wolfSSL_CTX_load_verify_locations_ex
 1016*/
 1017const char** wolfSSL_get_system_CA_dirs(word32* num);
 1018
 1019/*!
 1020    \ingroup CertsKeys
 1021
 1022    \brief ほとんどのプラットフォーム(LinuxおよびWindowsを含む)において、この関数はOS依存のCA証明書ストアからWOLFSSL_CTXへCA証明書を読み込もうと試みます。読み込まれた証明書は信頼されます。
 1023
 1024    Appleプラットフォーム(macOSを除く)では、証明書をシステムから取得できないため、wolfSSL証明書マネージャに読み込むことができません。これらのプラットフォームでは、この関数は、WOLFSSL_CTXにバインドされたTLS接続において、ユーザーによって読み込まれた証明書に対してピア証明書の信頼性を最初に認証できない場合に、ネイティブシステムの信頼APIを使用してピア証明書チェーンの信頼性を検証できるようにします。
 1025
 1026    サポートおよびテストされているプラットフォームは、Linux(Debian、Ubuntu、
 1027    Gentoo、Fedora、RHEL)、Windows 10/11、Android、macOS、およびiOSです。
 1028
 1029    \return 成功時はWOLFSSL_SUCCESS。
 1030    \return システムCA証明書が読み込まれなかった場合はWOLFSSL_BAD_PATH。
 1031    \return その他の失敗タイプの場合はWOLFSSL_FAILURE(例: Windows証明書ストアが適切に閉じられなかった場合)。
 1032
 1033    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 1034
 1035    _Example_
 1036    \code
 1037    int ret = 0;
 1038    WOLFSSL_CTX* ctx;
 1039    ...
 1040    ret = wolfSSL_CTX_load_system_CA_certs(ctx,);
 1041    if (ret != WOLFSSL_SUCCESS) {
 1042        // システムCA証明書の読み込みエラー
 1043    }
 1044    ...
 1045    \endcode
 1046
 1047    \sa wolfSSL_get_system_CA_dirs
 1048    \sa wolfSSL_CTX_load_verify_locations
 1049    \sa wolfSSL_CTX_load_verify_locations_ex
 1050*/
 1051int wolfSSL_CTX_load_system_CA_certs(WOLFSSL_CTX* ctx);
 1052
 1053/*!
 1054    \ingroup Setup
 1055
 1056    \brief この関数は、TLS/SSLハンドシェイクを実行する際にピアを検証するために使用する証明書を読み込みます。ハンドシェイク中に送信されるピア証明書は、利用可能な場合はSKIDを使用し、署名を使用して比較されます。これら2つが一致しない場合は、読み込まれたCAが使用されます。この機能はマクロWOLFSSL_TRUST_PEER_CERTを定義することで有効になります。適切な使用方法については、examplesを参照してください。
 1057
 1058    \return 成功時はSSL_SUCCES。
 1059    \return ctxがNULLの場合、またはfileとtypeの両方が無効な場合はSSL_FAILUREが返されます。
 1060    \return ファイルの形式が間違っている場合はSSL_BAD_FILETYPEが返されます。
 1061    \return ファイルが存在しない、読み取れない、または破損している場合はSSL_BAD_FILEが返されます。
 1062    \return メモリ不足状態が発生した場合はMEMORY_Eが返されます。
 1063    \return ファイルに対するBase16デコードが失敗した場合はASN_INPUT_Eが返されます。
 1064
 1065    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 1066    \param file 証明書を含むファイル名へのポインタ。
 1067    \param type 読み込まれる証明書のタイプ、すなわちSSL_FILETYPE_ASN1
 1068    またはSSL_FILETYPE_PEM。
 1069
 1070    _Example_
 1071    \code
 1072    int ret = 0;
 1073    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 1074    ...
 1075
 1076    ret = wolfSSL_CTX_trust_peer_cert(ctx, "./peer-cert.pem",
 1077    SSL_FILETYPE_PEM);
 1078    if (ret != SSL_SUCCESS) {
 1079        // 信頼されたピア証明書の読み込みエラー
 1080    }
 1081    ...
 1082    \endcode
 1083
 1084    \sa wolfSSL_CTX_load_verify_buffer
 1085    \sa wolfSSL_CTX_use_certificate_file
 1086    \sa wolfSSL_CTX_use_PrivateKey_file
 1087    \sa wolfSSL_CTX_use_certificate_chain_file
 1088    \sa wolfSSL_CTX_trust_peer_buffer
 1089    \sa wolfSSL_CTX_Unload_trust_peers
 1090    \sa wolfSSL_use_certificate_file
 1091    \sa wolfSSL_use_PrivateKey_file
 1092    \sa wolfSSL_use_certificate_chain_file
 1093*/
 1094int wolfSSL_CTX_trust_peer_cert(WOLFSSL_CTX* ctx, const char* file, int type);
 1095
 1096/*!
 1097    \ingroup CertsKeys
 1098
 1099    \brief この関数は、証明書チェーンをSSLコンテキスト(WOLFSSL_CTX)に読み込みます。証明書チェーンを含むファイルはfile引数によって提供され、PEM形式の証明書を含む必要があります。この関数は、MAX_CHAIN_DEPTH(デフォルト = 9、internal.hで定義)個までの証明書と、サブジェクト証明書を処理します。
 1100
 1101    \return 成功時はSSL_SUCCESS。
 1102    \return 関数呼び出しが失敗した場合はSSL_FAILURE。考えられる原因には、ファイルの形式が間違っている、または「format」引数を使用して間違った形式が指定されている、ファイルが存在しない、読み取れない、または破損している、メモリ不足状態が発生した、などがあります。
 1103
 1104    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 1105    \param file wolfSSL SSLコンテキストに読み込まれる証明書チェーンを含むファイルの名前へのポインタ。証明書はPEM形式である必要があります。
 1106
 1107    _Example_
 1108    \code
 1109    int ret = 0;
 1110    WOLFSSL_CTX* ctx;
 1111    ...
 1112    ret = wolfSSL_CTX_use_certificate_chain_file(ctx, "./cert-chain.pem");
 1113    if (ret != SSL_SUCCESS) {
 1114	    // 証明書ファイルの読み込みエラー
 1115    }
 1116    ...
 1117    \endcode
 1118
 1119    \sa wolfSSL_CTX_use_certificate_file
 1120    \sa wolfSSL_CTX_use_certificate_buffer
 1121    \sa wolfSSL_use_certificate_file
 1122    \sa wolfSSL_use_certificate_buffer
 1123*/
 1124int wolfSSL_CTX_use_certificate_chain_file(WOLFSSL_CTX *ctx,
 1125                                                     const char *file);
 1126
 1127/*!
 1128    \ingroup openSSL
 1129
 1130    \brief この関数は、SSL接続で使用されるプライベートRSA鍵をSSLコンテキスト(WOLFSSL_CTX)に読み込みます。この関数は、wolfSSLがOpenSSL互換レイヤーを有効にしてコンパイルされた場合(--enable-opensslExtra、#define OPENSSL_EXTRA)にのみ利用可能であり、より一般的に使用されるwolfSSL_CTX_use_PrivateKey_file()関数と同一です。file引数には、format引数で指定された形式のRSAプライベート鍵ファイルへのポインタが含まれます。
 1131
 1132    \return 成功時はSSL_SUCCESS。
 1133    \return 関数呼び出しが失敗した場合はSSL_FAILURE。考えられる原因には、入力鍵ファイルの形式が間違っている、または「format」引数を使用して間違った形式が指定されている、ファイルが存在しない、読み取れない、または破損している、メモリ不足状態が発生した、などがあります。
 1134
 1135    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 1136    \param file wolfSSL SSLコンテキストに読み込まれるRSAプライベート鍵を含むファイルの名前へのポインタ。形式はformat引数で指定されます。
 1137    \param format file引数で指定されたRSAプライベート鍵のエンコーディングタイプ。指定可能な値には、SSL_FILETYPE_PEMおよびSSL_FILETYPE_ASN1が含まれます。
 1138
 1139    _Example_
 1140    \code
 1141    int ret = 0;
 1142    WOLFSSL_CTX* ctx;
 1143    ...
 1144    ret = wolfSSL_CTX_use_RSAPrivateKey_file(ctx, "./server-key.pem",
 1145                                       SSL_FILETYPE_PEM);
 1146    if (ret != SSL_SUCCESS) {
 1147	    // プライベート鍵ファイルの読み込みエラー
 1148    }
 1149    ...
 1150    \endcode
 1151
 1152    \sa wolfSSL_CTX_use_PrivateKey_buffer
 1153    \sa wolfSSL_CTX_use_PrivateKey_file
 1154    \sa wolfSSL_use_RSAPrivateKey_file
 1155    \sa wolfSSL_use_PrivateKey_buffer
 1156    \sa wolfSSL_use_PrivateKey_file
 1157*/
 1158int wolfSSL_CTX_use_RSAPrivateKey_file(WOLFSSL_CTX* ctx, const char* file, int format);
 1159
 1160/*!
 1161    \ingroup IO
 1162
 1163    \brief この関数は、有効なセッション(つまり、非NULLのセッションオブジェクト(ssl)が存在する場合)に対して許可される最大チェーン深度を返します。デフォルトは9です。
 1164
 1165    \return WOLFSSL構造体がNULLでない場合はMAX_CHAIN_DEPTHが返されます。デフォルトでは値は9です。
 1166    \return WOLFSSL構造体がNULLの場合はBAD_FUNC_ARGが返されます。
 1167
 1168    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 1169
 1170    _Example_
 1171    \code
 1172    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 1173    WOLFSSL* ssl = wolfSSL_new(ctx);
 1174    ...
 1175    long sslDep = wolfSSL_get_verify_depth(ssl);
 1176
 1177    if(sslDep > EXPECTED){
 1178    	// 検証された深度は期待値よりも大きい
 1179    } else {
 1180    	// 検証された深度は期待値以下
 1181    }
 1182    \endcode
 1183
 1184    \sa wolfSSL_CTX_get_verify_depth
 1185*/
 1186long wolfSSL_get_verify_depth(WOLFSSL* ssl);
 1187
 1188/*!
 1189    \ingroup Setup
 1190
 1191    \brief この関数は、CTX構造体を使用して証明書チェーンの深度を取得します。
 1192
 1193    \return CTX構造体がNULLでない場合はMAX_CHAIN_DEPTHが返されます。最大証明書チェーンピア深度の定数表現です。
 1194    \return CTX構造体がNULLの場合はBAD_FUNC_ARGが返されます。
 1195
 1196    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 1197
 1198    _Example_
 1199    \code
 1200    WOLFSSL_METHOD method; // プロトコルメソッド
 1201    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(method);
 1202    …
 1203    long ret = wolfSSL_CTX_get_verify_depth(ctx);
 1204
 1205    if(ret == EXPECTED){
 1206    	//  期待値を取得しました
 1207    } else {
 1208    	//  予期しない深度を処理
 1209    }
 1210    \endcode
 1211
 1212    \sa wolfSSL_CTX_use_certificate_chain_file
 1213    \sa wolfSSL_get_verify_depth
 1214*/
 1215long wolfSSL_CTX_get_verify_depth(WOLFSSL_CTX* ctx);
 1216
 1217/*!
 1218    \ingroup openSSL
 1219
 1220    \brief この関数は、証明書ファイルをSSLセッション(WOLFSSL構造体)に読み込みます。証明書ファイルはfile引数によって提供されます。format引数は、ファイルの形式タイプ(SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM)を指定します。
 1221
 1222    \return 成功時はSSL_SUCCESS。
 1223    \return 関数呼び出しが失敗した場合はSSL_FAILURE。考えられる原因には、ファイルの形式が間違っている、または「format」引数を使用して間違った形式が指定されている、ファイルが存在しない、読み取れない、または破損している、メモリ不足状態が発生した、ファイルに対するBase16デコードが失敗した、などがあります。
 1224
 1225    \param ssl wolfSSL_new()で作成されたWOLFSSL構造体へのポインタ。
 1226    \param file wolfSSL SSLセッションに読み込まれる証明書を含むファイルの名前へのポインタ。形式はformat引数で指定されます。
 1227    \param format file引数で指定された証明書のエンコーディングタイプ。指定可能な値には、SSL_FILETYPE_PEMおよびSSL_FILETYPE_ASN1が含まれます。
 1228
 1229    _Example_
 1230    \code
 1231    int ret = 0;
 1232    WOLFSSL* ssl;
 1233    ...
 1234    ret = wolfSSL_use_certificate_file(ssl, "./client-cert.pem",
 1235                                 SSL_FILETYPE_PEM);
 1236    if (ret != SSL_SUCCESS) {
 1237    	// 証明書ファイルの読み込みエラー
 1238    }
 1239    ...
 1240    \endcode
 1241
 1242    \sa wolfSSL_CTX_use_certificate_buffer
 1243    \sa wolfSSL_CTX_use_certificate_file
 1244    \sa wolfSSL_use_certificate_buffer
 1245*/
 1246int wolfSSL_use_certificate_file(WOLFSSL* ssl, const char* file, int format);
 1247
 1248/*!
 1249    \ingroup openSSL
 1250
 1251    \brief この関数は、プライベート鍵ファイルをSSLセッション(WOLFSSL構造体)に読み込みます。鍵ファイルはfile引数によって提供されます。format引数は、ファイルの形式タイプ(SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM)を指定します。
 1252
 1253    外部鍵ストアを使用していてプライベート鍵を持っていない場合は、代わりに公開鍵を提供し、署名を処理するための暗号コールバックを登録することができます。これには、暗号コールバックまたはPKコールバックのいずれかを有効にしてビルドします。暗号コールバックを有効にするには、--enable-cryptocbまたはWOLF_CRYPTO_CBを使用し、wc_CryptoCb_RegisterDeviceを使用して暗号コールバックを登録し、wolfSSL_SetDevIdを使用して関連するdevIdを設定します。
 1254
 1255    \return 成功時はSSL_SUCCESS。
 1256    \return 関数呼び出しが失敗した場合はSSL_FAILURE。考えられる原因には、ファイルの形式が間違っている、または「format」引数を使用して間違った形式が指定されている、ファイルが存在しない、読み取れない、または破損している、メモリ不足状態が発生した、ファイルに対するBase16デコードが失敗した、鍵ファイルが暗号化されているがパスワードが提供されていない、などがあります。
 1257
 1258    \param ssl wolfSSL_new()で作成されたWOLFSSL構造体へのポインタ。
 1259    \param file wolfSSL SSLセッションに読み込まれる鍵ファイルを含むファイルの名前へのポインタ。形式はformat引数で指定されます。
 1260    \param format file引数で指定された鍵のエンコーディングタイプ。指定可能な値には、SSL_FILETYPE_PEMおよびSSL_FILETYPE_ASN1が含まれます。
 1261
 1262    _Example_
 1263    \code
 1264    int ret = 0;
 1265    WOLFSSL* ssl;
 1266    ...
 1267    ret = wolfSSL_use_PrivateKey_file(ssl, "./server-key.pem",
 1268                                SSL_FILETYPE_PEM);
 1269    if (ret != SSL_SUCCESS) {
 1270	    // 鍵ファイルの読み込みエラー
 1271    }
 1272    ...
 1273    \endcode
 1274
 1275    \sa wolfSSL_CTX_use_PrivateKey_buffer
 1276    \sa wolfSSL_CTX_use_PrivateKey_file
 1277    \sa wolfSSL_use_PrivateKey_buffer
 1278    \sa wc_CryptoCb_RegisterDevice
 1279    \sa wolfSSL_SetDevId
 1280*/
 1281int wolfSSL_use_PrivateKey_file(WOLFSSL* ssl, const char* file, int format);
 1282
 1283/*!
 1284    \ingroup openSSL
 1285    \brief この関数は、証明書のチェーンをSSLセッション(WOLFSSL構造体)にロードします。証明書チェーンを含むファイルはfile引数で指定され、PEM形式の証明書を含んでいる必要があります。この関数は、MAX_CHAIN_DEPTH(デフォルト = 9、internal.hで定義)個までの証明書と、サブジェクト証明書を処理します。
 1286
 1287    \return SSL_SUCCESS 成功時。
 1288    \return SSL_FAILURE 関数呼び出しが失敗した場合、考えられる原因は次のとおりです:ファイルの形式が間違っている、または"format"引数で与えられた形式が間違っている、ファイルが存在しない、読み取れない、または破損している、メモリ不足の状態が発生した
 1289
 1290    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ
 1291    \param file wolfSSL SSLセッションにロードする証明書のチェーンを含むファイルの名前へのポインタ。証明書はPEM形式でなければなりません。
 1292
 1293    _Example_
 1294    \code
 1295    int ret = 0;
 1296    WOLFSSL* ctx;
 1297    ...
 1298    ret = wolfSSL_use_certificate_chain_file(ssl, "./cert-chain.pem");
 1299    if (ret != SSL_SUCCESS) {
 1300    	// 証明書ファイルのロードエラー
 1301    }
 1302    ...
 1303    \endcode
 1304
 1305    \sa wolfSSL_CTX_use_certificate_chain_file
 1306    \sa wolfSSL_CTX_use_certificate_chain_buffer
 1307    \sa wolfSSL_use_certificate_chain_buffer
 1308*/
 1309int wolfSSL_use_certificate_chain_file(WOLFSSL* ssl, const char *file);
 1310
 1311/*!
 1312    \ingroup openSSL
 1313
 1314    \brief この関数は、SSL接続で使用されるプライベートRSA鍵をSSLセッション(WOLFSSL構造体)にロードします。この関数は、wolfSSLがOpenSSL互換レイヤーを有効にしてコンパイルされている場合(--enable-opensslExtra、#define OPENSSL_EXTRA)にのみ利用可能であり、より一般的に使用されるwolfSSL_use_PrivateKey_file()関数と同一です。file引数は、formatで指定された形式のRSAプライベート鍵ファイルへのポインタを含みます。
 1315
 1316    \return SSL_SUCCESS 成功時
 1317    \return SSL_FAILURE 関数呼び出しが失敗した場合、考えられる原因は次のとおりです:入力鍵ファイルの形式が間違っている、または"format"引数で与えられた形式が間違っている、ファイルが存在しない、読み取れない、または破損している、メモリ不足の状態が発生した
 1318
 1319    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ
 1320    \param file wolfSSL SSLセッションにロードするRSAプライベート鍵を含むファイルの名前へのポインタ、形式はformatで指定されます。
 1321    \param format fileで指定されたRSAプライベート鍵のエンコーディングタイプ。指定可能な値はSSL_FILETYPE_PEMとSSL_FILETYPE_ASN1です。
 1322
 1323    _Example_
 1324    \code
 1325    int ret = 0;
 1326    WOLFSSL* ssl;
 1327    ...
 1328    ret = wolfSSL_use_RSAPrivateKey_file(ssl, "./server-key.pem",
 1329                                   SSL_FILETYPE_PEM);
 1330    if (ret != SSL_SUCCESS) {
 1331	    // プライベート鍵ファイルのロードエラー
 1332    }
 1333    ...
 1334    \endcode
 1335
 1336    \sa wolfSSL_CTX_use_RSAPrivateKey_file
 1337    \sa wolfSSL_CTX_use_PrivateKey_buffer
 1338    \sa wolfSSL_CTX_use_PrivateKey_file
 1339    \sa wolfSSL_use_PrivateKey_buffer
 1340    \sa wolfSSL_use_PrivateKey_file
 1341*/
 1342int wolfSSL_use_RSAPrivateKey_file(WOLFSSL* ssl, const char* file, int format);
 1343
 1344/*!
 1345    \ingroup CertsKeys
 1346
 1347    \brief この関数はwolfSSL_CTX_load_verify_locationsに似ていますが、DER形式のCAファイルをSSLコンテキスト(WOLFSSL_CTX)にロードできます。PEM形式のCAファイルをロードするためにも使用できます。これらの証明書は信頼されたルート証明書として扱われ、SSLハンドシェイク中にピアから受信した証明書を検証するために使用されます。file引数で指定されるルート証明書ファイルは、単一の証明書または複数の証明書を含むファイルである可能性があります。複数のCA証明書が同じファイルに含まれている場合、wolfSSLはファイル内で提示された順序でそれらをロードします。format引数は、証明書の形式がSSL_FILETYPE_PEMまたはSSL_FILETYPE_ASN1(DER)のいずれかであることを指定します。wolfSSL_CTX_load_verify_locationsとは異なり、この関数は指定されたディレクトリパスからのCA証明書のロードを許可しません。この関数は、wolfSSLライブラリがWOLFSSL_DER_LOADを定義してコンパイルされている場合にのみ利用可能です。
 1348
 1349    \return SSL_SUCCESS 成功時。
 1350    \return SSL_FAILURE 失敗時。
 1351
 1352    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ
 1353    \param file wolfSSL SSLコンテキストにロードするCA証明書を含むファイルの名前へのポインタ、形式はformatで指定されます。
 1354    \param format fileで指定された証明書のエンコーディングタイプ。指定可能な値はSSL_FILETYPE_PEMとSSL_FILETYPE_ASN1です。
 1355
 1356    _Example_
 1357    \code
 1358    int ret = 0;
 1359    WOLFSSL_CTX* ctx;
 1360    ...
 1361    ret = wolfSSL_CTX_der_load_verify_locations(ctx, "./ca-cert.der",
 1362                                          SSL_FILETYPE_ASN1);
 1363    if (ret != SSL_SUCCESS) {
 1364	    // CA証明書のロードエラー
 1365    }
 1366    ...
 1367    \endcode
 1368
 1369    \sa wolfSSL_CTX_load_verify_locations
 1370    \sa wolfSSL_CTX_load_verify_buffer
 1371*/
 1372int wolfSSL_CTX_der_load_verify_locations(WOLFSSL_CTX* ctx,
 1373                                          const char* file, int format);
 1374
 1375/*!
 1376    \ingroup Setup
 1377
 1378    \brief この関数は、入力として希望するSSL/TLSプロトコルメソッドを取り、新しいSSLコンテキストを作成します。
 1379
 1380    \return pointer 成功した場合、呼び出しは新しく作成されたWOLFSSL_CTXへのポインタを返します。
 1381    \return NULL 失敗時。
 1382
 1383    \param method SSLコンテキストに使用する希望のWOLFSSL_METHODへのポインタ。これは、SSL/TLS/DTLSプロトコルレベルを指定するためのwolfSSLvXX_XXXX_method()関数のいずれかを使用して作成されます。
 1384
 1385    _Example_
 1386    \code
 1387    WOLFSSL_CTX*    ctx    = 0;
 1388    WOLFSSL_METHOD* method = 0;
 1389
 1390    method = wolfSSLv3_client_method();
 1391    if (method == NULL) {
 1392    	// メソッドを取得できません
 1393    }
 1394
 1395    ctx = wolfSSL_CTX_new(method);
 1396    if (ctx == NULL) {
 1397    	// コンテキストの作成に失敗しました
 1398    }
 1399    \endcode
 1400
 1401    \sa wolfSSL_new
 1402*/
 1403WOLFSSL_CTX* wolfSSL_CTX_new(WOLFSSL_METHOD*);
 1404
 1405/*!
 1406    \ingroup Setup
 1407
 1408    \brief この関数は、既に作成されたSSLコンテキストを入力として取り、新しいSSLセッションを作成します。
 1409
 1410    \return ＊ 成功した場合、呼び出しは新しく作成されたwolfSSL構造体へのポインタを返します。
 1411    \return NULL 失敗時。
 1412
 1413    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 1414
 1415    _Example_
 1416    \code
 1417    #include <wolfssl/ssl.h>
 1418
 1419    WOLFSSL*     ssl = NULL;
 1420    WOLFSSL_CTX* ctx = 0;
 1421
 1422    ctx = wolfSSL_CTX_new(method);
 1423    if (ctx == NULL) {
 1424	    // コンテキストの作成に失敗しました
 1425    }
 1426
 1427    ssl = wolfSSL_new(ctx);
 1428    if (ssl == NULL) {
 1429	    // SSLオブジェクトの作成に失敗しました
 1430    }
 1431    \endcode
 1432
 1433    \sa wolfSSL_CTX_new
 1434*/
 1435WOLFSSL* wolfSSL_new(WOLFSSL_CTX*);
 1436
 1437/*!
 1438    \ingroup Setup
 1439
 1440    \brief この関数は、ファイルディスクリプタ(fd)をSSL接続の入出力機能として割り当てます。通常、これはソケットファイルディスクリプタになります。
 1441
 1442    \return SSL_SUCCESS 成功時。
 1443    \return BAD_FUNC_ARG 失敗時。
 1444
 1445    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1446    \param fd SSL/TLS接続で使用するファイルディスクリプタ。
 1447
 1448    _Example_
 1449    \code
 1450    int sockfd;
 1451    WOLFSSL* ssl = 0;
 1452    ...
 1453
 1454    ret = wolfSSL_set_fd(ssl, sockfd);
 1455    if (ret != SSL_SUCCESS) {
 1456    	// SSLファイルディスクリプタの設定に失敗しました
 1457    }
 1458    \endcode
 1459
 1460    \sa wolfSSL_CTX_SetIOSend
 1461    \sa wolfSSL_CTX_SetIORecv
 1462    \sa wolfSSL_SetIOReadCtx
 1463    \sa wolfSSL_SetIOWriteCtx
 1464*/
 1465int  wolfSSL_set_fd(WOLFSSL* ssl, int fd);
 1466
 1467/*!
 1468    \ingroup Setup
 1469
 1470    \brief この関数は、ファイルディスクリプタ(fd)をSSL接続の入出力機能として割り当てます。通常、これはソケットファイルディスクリプタになります。これは、ソケットが接続されていることをマークするため、DTLS固有のAPIです。このfdに対するrecvfromおよびsendto呼び出しは、addrおよびaddr_lenパラメータがNULLに設定されます。
 1471
 1472    \return SSL_SUCCESS 成功時。
 1473    \return BAD_FUNC_ARG 失敗時。
 1474
 1475    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1476    \param fd SSL/TLS接続で使用するファイルディスクリプタ。
 1477
 1478    _Example_
 1479    \code
 1480    int sockfd;
 1481    WOLFSSL* ssl = 0;
 1482    ...
 1483    if (connect(sockfd, peer_addr, peer_addr_len) != 0) {
 1484        // 接続エラーを処理
 1485    }
 1486    ...
 1487    ret = wolfSSL_set_dtls_fd_connected(ssl, sockfd);
 1488    if (ret != SSL_SUCCESS) {
 1489        // SSLファイルディスクリプタの設定に失敗しました
 1490    }
 1491    \endcode
 1492
 1493    \sa wolfSSL_CTX_SetIOSend
 1494    \sa wolfSSL_CTX_SetIORecv
 1495    \sa wolfSSL_SetIOReadCtx
 1496    \sa wolfSSL_SetIOWriteCtx
 1497    \sa wolfDTLS_SetChGoodCb
 1498*/
 1499int wolfSSL_set_dtls_fd_connected(WOLFSSL* ssl, int fd);
 1500
 1501/*!
 1502    \ingroup Setup
 1503
 1504    \brief 正しく処理および検証されたDTLSクライアントhelloに対するコールバックを設定できます。クッキー交換メカニズム(DTLS 1.2のHelloVerifyRequestまたはクッキー拡張を伴うDTLS 1.3のHelloRetryRequest)を使用する場合、このコールバックはクッキー交換が成功した後に呼び出されます。これは、1つのWOLFSSLオブジェクトを新しい接続のリスナーとして使用し、ClientHelloが検証された後(クッキー交換を通じて、またはClientHelloが正しい形式であるかをチェックするだけで)にWOLFSSLオブジェクトを分離できるようにするのに役立ちます。
 1505           DTLS 1.2:
 1506           https://datatracker.ietf.org/doc/html/rfc6347#section-4.2.1
 1507           DTLS 1.3:
 1508           https://www.rfc-editor.org/rfc/rfc8446#section-4.2.2
 1509
 1510    \return SSL_SUCCESS 成功時。
 1511    \return BAD_FUNC_ARG 失敗時。
 1512
 1513    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1514    \param fd SSL/TLS接続で使用するファイルディスクリプタ。
 1515
 1516    _Example_
 1517    \code
 1518
 1519    // 接続を検証したときに呼び出されます
 1520    static int chGoodCb(WOLFSSL* ssl, void* arg)
 1521    {
 1522        // ピアとファイルディスクリプタを設定
 1523
 1524    }
 1525
 1526    if (wolfDTLS_SetChGoodCb(ssl, chGoodCb, NULL) != WOLFSSL_SUCCESS) {
 1527         // コールバック設定エラー
 1528    }
 1529    \endcode
 1530
 1531    \sa wolfSSL_set_dtls_fd_connected
 1532*/
 1533int wolfDTLS_SetChGoodCb(WOLFSSL* ssl, ClientHelloGoodCb cb, void* user_ctx);
 1534
 1535/*!
 1536    \ingroup IO
 1537
 1538    \brief 渡された優先度レベルでの暗号の名前を取得します。
 1539
 1540    \return string 成功
 1541    \return 0 優先度が範囲外または無効です。
 1542
 1543    \param priority 暗号の優先度レベルを表す整数。
 1544
 1545    _Example_
 1546    \code
 1547    printf("The cipher at 1 is %s", wolfSSL_get_cipher_list(1));
 1548    \endcode
 1549
 1550    \sa wolfSSL_CIPHER_get_name
 1551    \sa wolfSSL_get_current_cipher
 1552*/
 1553char* wolfSSL_get_cipher_list(int priority);
 1554
 1555/*!
 1556    \ingroup IO
 1557
 1558    \brief この関数は、wolfSSLで有効になっている暗号を取得します。
 1559
 1560    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
 1561    \return BAD_FUNC_ARG bufパラメータがNULLまたはlen引数がゼロ以下の場合に返されます。
 1562    \return BUFFER_E バッファが十分に大きくなくオーバーフローする場合に返されます。
 1563
 1564    \param buf バッファを表すcharポインタ。
 1565    \param len バッファの長さ。
 1566
 1567    _Example_
 1568    \code
 1569    static void ShowCiphers(void){
 1570        char* ciphers;
 1571        int ret = wolfSSL_get_ciphers(ciphers, (int)sizeof(ciphers));
 1572
 1573	    if(ret == SSL_SUCCESS){
 1574	    	printf("%s\n", ciphers);
 1575	    }
 1576    }
 1577    \endcode
 1578
 1579    \sa GetCipherNames
 1580    \sa wolfSSL_get_cipher_list
 1581    \sa ShowCiphers
 1582*/
 1583int  wolfSSL_get_ciphers(char* buf, int len);
 1584
 1585/*!
 1586    \ingroup IO
 1587
 1588    \brief この関数は、引数をwolfSSL_get_cipher_name_internalに渡すことによって、DHE-RSA形式で暗号名を取得します。
 1589
 1590    \return string この関数は、マッチした暗号スイートの文字列表現を返します。
 1591    \return NULL エラーまたは暗号が見つかりません。
 1592
 1593    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 1594
 1595    _Example_
 1596    \code
 1597    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 1598    WOLFSSL* ssl = wolfSSL_new(ctx);
 1599    …
 1600    char* cipher = wolfSSL_get_cipher_name(ssl);
 1601
 1602    if(cipher == NULL){
 1603	    // 暗号スイートがマッチしませんでした
 1604    } else {
 1605	    // 暗号スイートがマッチしました
 1606	    printf("%s\n", cipherS);
 1607    }
 1608    \endcode
 1609
 1610    \sa wolfSSL_CIPHER_get_name
 1611    \sa wolfSSL_get_current_cipher
 1612    \sa wolfSSL_get_cipher_name_internal
 1613*/
 1614const char* wolfSSL_get_cipher_name(WOLFSSL* ssl);
 1615
 1616/*!
 1617    \ingroup IO
 1618
 1619    \brief この関数は、SSL接続の入力機能として使用される読み取りファイル記述子(fd)を返します。通常、これはソケットファイル記述子になります。
 1620    \return fd 成功した場合、この関数はSSLセッションファイルディスクリプタを返します。
 1621
 1622    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1623
 1624    _Example_
 1625    \code
 1626    int sockfd;
 1627    WOLFSSL* ssl = 0;
 1628    ...
 1629    sockfd = wolfSSL_get_fd(ssl);
 1630    ...
 1631    \endcode
 1632
 1633    \sa wolfSSL_set_fd
 1634    \sa wolfSSL_set_read_fd
 1635    \sa wolfSSL_set_write_fd
 1636*/
 1637int  wolfSSL_get_fd(const WOLFSSL* ssl);
 1638
 1639/*!
 1640    \ingroup IO
 1641
 1642    \brief この関数は、SSL接続の出力機能として使用される書き込みファイルディスクリプタ(fd)を返します。通常はソケットファイルディスクリプタになります。
 1643
 1644    \return fd 成功した場合、この関数はSSLセッションファイルディスクリプタを返します。
 1645
 1646    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1647
 1648    _Example_
 1649    \code
 1650    int sockfd;
 1651    WOLFSSL* ssl = 0;
 1652    ...
 1653    sockfd = wolfSSL_get_wfd(ssl);
 1654    ...
 1655    \endcode
 1656
 1657    \sa wolfSSL_set_fd
 1658    \sa wolfSSL_set_read_fd
 1659    \sa wolfSSL_set_write_fd
 1660*/
 1661int  wolfSSL_get_wfd(const WOLFSSL* ssl);
 1662
 1663/*!
 1664    \ingroup Setup
 1665
 1666    \brief この関数は、WOLFSSLオブジェクトに対して、下層のI/Oがノンブロッキングであることを通知します。アプリケーションがWOLFSSLオブジェクトを作成した後、それをノンブロッキングソケットと共に使用する場合は、wolfSSL_set_using_nonblock()を呼び出してください。これにより、WOLFSSLオブジェクトは、EWOULDBLOCKを受け取ることがタイムアウトではなく、recvfrom呼び出しがブロックすることを意味すると認識できます。
 1667
 1668    \return none 戻り値はありません。
 1669
 1670    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1671    \param nonblock WOLFSSLオブジェクトのノンブロッキングフラグを設定するための値。ノンブロッキングを指定する場合は1を、そうでない場合は0を使用してください。
 1672
 1673    _Example_
 1674    \code
 1675    WOLFSSL* ssl = 0;
 1676    ...
 1677    wolfSSL_set_using_nonblock(ssl, 1);
 1678    \endcode
 1679
 1680    \sa wolfSSL_get_using_nonblock
 1681    \sa wolfSSL_dtls_got_timeout
 1682    \sa wolfSSL_dtls_get_current_timeout
 1683*/
 1684void wolfSSL_set_using_nonblock(WOLFSSL* ssl, int nonblock);
 1685
 1686/*!
 1687    \ingroup IO
 1688
 1689    \brief この関数により、アプリケーションはwolfSSLがノンブロッキングI/Oを使用しているかどうかを判定できます。wolfSSLがノンブロッキングI/Oを使用している場合、この関数は1を返し、それ以外の場合は0を返します。アプリケーションがWOLFSSLオブジェクトを作成した後、それをノンブロッキングソケットと共に使用する場合は、wolfSSL_set_using_nonblock()を呼び出してください。これにより、WOLFSSLオブジェクトは、EWOULDBLOCKを受け取ることがタイムアウトではなく、recvfrom呼び出しがブロックすることを意味すると認識できます。
 1690
 1691    \return 0 下層のI/Oがブロッキングです。
 1692    \return 1 下層のI/Oがノンブロッキングです。
 1693
 1694    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1695
 1696    _Example_
 1697    \code
 1698    int ret = 0;
 1699    WOLFSSL* ssl = 0;
 1700    ...
 1701    ret = wolfSSL_get_using_nonblock(ssl);
 1702    if (ret == 1) {
 1703    	// 下層のI/Oはノンブロッキング
 1704    }
 1705    ...
 1706    \endcode
 1707
 1708    \sa wolfSSL_set_session
 1709*/
 1710int  wolfSSL_get_using_nonblock(WOLFSSL*);
 1711
 1712/*!
 1713    \ingroup IO
 1714
 1715    \brief この関数は、バッファdataからszバイトをSSL接続sslに書き込みます。必要に応じて、wolfSSL_connect()またはwolfSSL_accept()によってハンドシェイクがまだ実行されていない場合、wolfSSL_write()はSSL/TLSセッションをネゴシエートします。(D)TLSv1.3を使用していてearly data機能がコンパイルされている場合、この関数はデータ送信が可能になるまでハンドシェイクを進めます。次のwolfSSL_Connect()、wolfSSL_Accept()、wolfSSL_read()の呼び出しでハンドシェイクが完了します。wolfSSL_write()は、ブロッキングとノンブロッキングの両方のI/Oで動作します。下層のI/Oがノンブロッキングの場合、wolfSSL_write()は、下層のI/OがwolfSSL_write()を継続するために必要な要求を満たせなくなった時点で返されます。この場合、wolfSSL_get_error()を呼び出すと、SSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、下層のI/Oの準備ができたら、wolfSSL_write()の呼び出しを繰り返す必要があります。下層のI/Oがブロッキングの場合、wolfSSL_write()は、サイズszのバッファデータが完全に書き込まれるか、エラーが発生するまで返されません。
 1716
 1717    \return ＞0 成功時に書き込まれたバイト数。
 1718    \return 0 失敗時に返されます。具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1719    \return SSL_FATAL_ERROR エラーが発生した場合、またはノンブロッキングソケットを使用している場合にSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーを受け取り、アプリケーションがwolfSSL_write()を再度呼び出す必要がある場合に返されます。具体的なエラーコードを取得するには、wolfSSL_get_error()を使用してください。
 1720
 1721    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1722    \param data ピアに送信されるデータバッファ。
 1723    \param sz ピアに送信するデータ(data)のサイズ(バイト単位)。
 1724
 1725    _Example_
 1726    \code
 1727    WOLFSSL* ssl = 0;
 1728    char msg[64] = "hello wolfssl!";
 1729    int msgSz = (int)strlen(msg);
 1730    int flags;
 1731    int ret;
 1732    ...
 1733
 1734    ret = wolfSSL_write(ssl, msg, msgSz);
 1735    if (ret <= 0) {
 1736    	// wolfSSL_write()が失敗、wolfSSL_get_error()を呼び出す
 1737    }
 1738    \endcode
 1739
 1740    \sa wolfSSL_send
 1741    \sa wolfSSL_read
 1742    \sa wolfSSL_recv
 1743*/
 1744int  wolfSSL_write(WOLFSSL* ssl, const void* data, int sz);
 1745
 1746/*!
 1747    \ingroup IO
 1748
 1749    \brief この関数は、SSLセッション(ssl)の内部読み取りバッファからszバイトをバッファdataに読み込みます。読み取られたバイトは内部受信バッファから削除されます。必要に応じて、wolfSSL_connect()またはwolfSSL_accept()によってハンドシェイクがまだ実行されていない場合、wolfSSL_read()はSSL/TLSセッションをネゴシエートします。SSL/TLSプロトコルは、最大サイズが16kBのSSLレコードを使用します(最大レコードサイズは、<wolfssl_root>/wolfssl/internal.h内のMAX_RECORD_SIZE定義で制御できます)。そのため、wolfSSLは、レコードを処理および復号できるようになる前に、SSLレコード全体を内部的に読み取る必要があります。このため、wolfSSL_read()の呼び出しは、呼び出し時に復号された最大バッファサイズのみを返すことができます。内部wolfSSL受信バッファには、まだ復号されていない追加データが待機している可能性があり、これは次のwolfSSL_read()呼び出しで取得および復号されます。szが内部読み取りバッファ内のバイト数よりも大きい場合、SSL_read()は内部読み取りバッファ内で利用可能なバイトを返します。内部読み取りバッファにまだバイトがバッファリングされていない場合、wolfSSL_read()の呼び出しは次のレコードの処理をトリガします。
 1750
 1751    \return ＞0 成功時に読み取られたバイト数。
 1752    \return 0 失敗時に返されます。これは、クリーンシャットダウン(close notifyアラート)またはピアが接続を閉じたことが原因である可能性があります。具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1753    \return SSL_FATAL_ERROR エラーが発生した場合、またはノンブロッキングソケットを使用している場合にSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーを受け取り、アプリケーションがwolfSSL_read()を再度呼び出す必要がある場合に返されます。具体的なエラーコードを取得するには、wolfSSL_get_error()を使用してください。
 1754
 1755    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1756    \param data wolfSSL_read()が読み取ったデータを格納するバッファ。
 1757    \param sz dataに読み込むバイト数。
 1758
 1759    _Example_
 1760    \code
 1761    WOLFSSL* ssl = 0;
 1762    char reply[1024];
 1763    ...
 1764
 1765    input = wolfSSL_read(ssl, reply, sizeof(reply));
 1766    if (input > 0) {
 1767    	// バッファ"reply"に"input"バイトが返された
 1768    }
 1769
 1770    wolfSSL_read()のより完全な例については、wolfSSLの例(client、server、echoclient、echoserver)を参照してください。
 1771    \endcode
 1772
 1773    \sa wolfSSL_recv
 1774    \sa wolfSSL_write
 1775    \sa wolfSSL_peek
 1776    \sa wolfSSL_pending
 1777*/
 1778int  wolfSSL_read(WOLFSSL* ssl, void* data, int sz);
 1779
 1780/*!
 1781    \ingroup IO
 1782
 1783    \brief この関数は、SSLセッション(ssl)の内部読み取りバッファからszバイトをバッファdataにコピーします。この関数は、内部SSLセッション受信バッファ内のデータが削除または変更されない点を除いて、wolfSSL_read()と同じです。wolfSSL_read()と同様に、必要に応じて、wolfSSL_connect()またはwolfSSL_accept()によってハンドシェイクがまだ実行されていない場合、wolfSSL_peek()はSSL/TLSセッションをネゴシエートします。SSL/TLSプロトコルは、最大サイズが16kBのSSLレコードを使用します(最大レコードサイズは、<wolfssl_root>/wolfssl/internal.h内のMAX_RECORD_SIZE定義で制御できます)。そのため、wolfSSLは、レコードを処理および復号できるようになる前に、SSLレコード全体を内部的に読み取る必要があります。このため、wolfSSL_peek()の呼び出しは、呼び出し時に復号された最大バッファサイズのみを返すことができます。内部wolfSSL受信バッファには、まだ復号されていない追加データが待機している可能性があり、これは次のwolfSSL_peek()またはwolfSSL_read()呼び出しで取得および復号されます。szが内部読み取りバッファ内のバイト数よりも大きい場合、SSL_peek()は内部読み取りバッファ内で利用可能なバイトを返します。内部読み取りバッファにまだバイトがバッファリングされていない場合、wolfSSL_peek()の呼び出しは次のレコードの処理をトリガします。
 1784
 1785    \return ＞0 成功時に読み取られたバイト数。
 1786    \return 0 失敗時に返されます。これは、クリーンシャットダウン(close notifyアラート)またはピアが接続を閉じたことが原因である可能性があります。具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1787    \return SSL_FATAL_ERROR エラーが発生した場合、またはノンブロッキングソケットを使用している場合にSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーを受け取り、アプリケーションがwolfSSL_peek()を再度呼び出す必要がある場合に返されます。具体的なエラーコードを取得するには、wolfSSL_get_error()を使用してください。
 1788
 1789    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1790    \param data wolfSSL_peek()が読み取ったデータを格納するバッファ。
 1791    \param sz dataに読み込むバイト数。
 1792
 1793    _Example_
 1794    \code
 1795    WOLFSSL* ssl = 0;
 1796    char reply[1024];
 1797    ...
 1798
 1799    input = wolfSSL_peek(ssl, reply, sizeof(reply));
 1800    if (input > 0) {
 1801	    // バッファ"reply"に"input"バイトが返された
 1802    }
 1803    \endcode
 1804
 1805    \sa wolfSSL_read
 1806*/
 1807int  wolfSSL_peek(WOLFSSL* ssl, void* data, int sz);
 1808
 1809/*!
 1810    \ingroup IO
 1811
 1812    \brief この関数はサーバ側で呼び出され、SSLクライアントがSSL/TLSハンドシェイクを開始するのを待機します。この関数が呼び出されるとき、下層の通信チャネルはすでに設定されています。wolfSSL_accept()は、ブロッキングとノンブロッキングの両方のI/Oで動作します。下層のI/Oがノンブロッキングの場合、wolfSSL_accept()は、下層のI/OがwolfSSL_acceptがハンドシェイクを継続するために必要な要求を満たせなくなった時点で返されます。この場合、wolfSSL_get_error()を呼び出すと、SSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、データの読み取りが可能になったらwolfSSL_accept()の呼び出しを繰り返す必要があり、wolfSSLは中断した箇所から再開します。ノンブロッキングソケットを使用する場合、何もする必要はありませんが、select()を使用して必要な条件を確認できます。下層のI/Oがブロッキングの場合、wolfSSL_accept()は、ハンドシェイクが完了するか、エラーが発生するまで返されません。
 1813
 1814    \return SSL_SUCCESS 成功時。
 1815    \return SSL_FATAL_ERROR エラーが発生した場合に返されます。より詳細なエラーコードを取得するには、wolfSSL_get_error()を呼び出してください。
 1816
 1817    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 1818
 1819    _Example_
 1820    \code
 1821    int ret = 0;
 1822    int err = 0;
 1823    WOLFSSL* ssl;
 1824    char buffer[80];
 1825    ...
 1826
 1827    ret = wolfSSL_accept(ssl);
 1828    if (ret != SSL_SUCCESS) {
 1829        err = wolfSSL_get_error(ssl, ret);
 1830        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
 1831    }
 1832    \endcode
 1833
 1834    \sa wolfSSL_get_error
 1835    \sa wolfSSL_connect
 1836*/
 1837int  wolfSSL_accept(WOLFSSL* ssl);
 1838
 1839/*!
 1840    \ingroup IO
 1841
 1842    \brief この関数はサーバ側で呼び出され、SSLクライアントがDTLSハンドシェイクを開始するのをステートレスに待機します。
 1843
 1844    \return WOLFSSL_SUCCESS 有効なクッキーを含むClientHelloが受信されました。wolfSSL_accept()で接続を続行できます。
 1845    \return WOLFSSL_FAILURE I/O層がWANT_READを返しました。これは、読み取るデータがなくノンブロッキングソケットを使用しているか、クッキーリクエストを送信して応答を待っているためです。ユーザは、I/O層でデータが利用可能になった後、wolfDTLS_accept_statelessを再度呼び出す必要があります。
 1846    \return WOLFSSL_FATAL_ERROR 致命的なエラーが発生しました。sslオブジェクトを解放して再割り当てしてから続行する必要があります。
 1847
 1848    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 1849
 1850    _Example_
 1851    \code
 1852    int ret = 0;
 1853    int err = 0;
 1854    WOLFSSL* ssl;
 1855    ...
 1856    do {
 1857        ret = wolfDTLS_accept_stateless(ssl);
 1858        if (ret == WOLFSSL_FATAL_ERROR)
 1859            // wolfSSL_free()とwolfSSL_new()でsslオブジェクトを再割り当て
 1860    } while (ret != WOLFSSL_SUCCESS);
 1861    ret = wolfSSL_accept(ssl);
 1862    if (ret != SSL_SUCCESS) {
 1863        err = wolfSSL_get_error(ssl, ret);
 1864        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
 1865    }
 1866    \endcode
 1867
 1868    \sa wolfSSL_accept
 1869    \sa wolfSSL_get_error
 1870    \sa wolfSSL_connect
 1871*/
 1872int  wolfDTLS_accept_stateless(WOLFSSL* ssl);
 1873
 1874/*!
 1875    \ingroup Setup
 1876
 1877    \brief この関数は、割り当てられたWOLFSSL_CTXオブジェクトを解放します。この関数はCTX参照カウントをデクリメントし、参照カウントが0になった場合にのみコンテキストを解放します。
 1878
 1879    \return none 戻り値はありません。
 1880
 1881    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 1882
 1883    _Example_
 1884    \code
 1885    WOLFSSL_CTX* ctx = 0;
 1886    ...
 1887    wolfSSL_CTX_free(ctx);
 1888    \endcode
 1889
 1890    \sa wolfSSL_CTX_new
 1891    \sa wolfSSL_new
 1892    \sa wolfSSL_free
 1893*/
 1894void wolfSSL_CTX_free(WOLFSSL_CTX* ctx);
 1895
 1896/*!
 1897    \ingroup Setup
 1898
 1899    \brief この関数は、割り当てられたwolfSSLオブジェクトを解放します。
 1900
 1901    \return none 戻り値はありません。
 1902
 1903    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 1904
 1905    _Example_
 1906    \code
 1907    #include <wolfssl/ssl.h>
 1908
 1909    WOLFSSL* ssl = 0;
 1910    ...
 1911    wolfSSL_free(ssl);
 1912    \endcode
 1913
 1914    \sa wolfSSL_CTX_new
 1915    \sa wolfSSL_new
 1916    \sa wolfSSL_CTX_free
 1917*/
 1918void wolfSSL_free(WOLFSSL* ssl);
 1919
 1920/*!
 1921    \ingroup TLS
 1922
 1923    \brief この関数は、SSLセッションsslを使用してアクティブなSSL/TLS接続をシャットダウンします。この関数は、ピアに「close notify」アラートを送信しようと試みます。呼び出し側のアプリケーションは、ピアからの応答として「close notify」アラートが送信されるのを待つか、wolfSSL_shutdown()を直接呼び出した後に基盤となる接続をシャットダウンするか(リソースを節約するため)を選択できます。TLS仕様では、どちらのオプションも許可されています。基盤となる接続を将来再び使用する場合は、ピア間の同期を維持するために、完全な双方向シャットダウン手順を実行する必要があります。wolfSSL_shutdown()は、ブロッキングI/OとノンブロッキングI/Oの両方で動作します。基盤となるI/Oがノンブロッキングの場合、基盤となるI/OがwolfSSL_shutdown()の継続に必要な要求を満たせなかった場合、wolfSSL_shutdown()はエラーを返します。この場合、wolfSSL_get_error()を呼び出すと、SSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、基盤となるI/Oの準備ができたときに、wolfSSL_shutdown()の呼び出しを繰り返す必要があります。
 1924
 1925    \return SSL_SUCCESSが成功時に返されます。
 1926    \return SSL_SHUTDOWN_NOT_DONEは、シャットダウンが完了していない場合に返され、関数を再度呼び出す必要があります。
 1927    \return SSL_FATAL_ERRORは、失敗時に返されます。より具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1928
 1929    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1930
 1931    _Example_
 1932    \code
 1933    #include <wolfssl/ssl.h>
 1934
 1935    int ret = 0;
 1936    WOLFSSL* ssl = 0;
 1937    ...
 1938    ret = wolfSSL_shutdown(ssl);
 1939    if (ret != 0) {
 1940	    // SSL接続のシャットダウンに失敗しました
 1941    }
 1942    \endcode
 1943
 1944    \sa wolfSSL_free
 1945    \sa wolfSSL_CTX_free
 1946*/
 1947int  wolfSSL_shutdown(WOLFSSL* ssl);
 1948
 1949/*!
 1950    \ingroup IO
 1951
 1952    \brief この関数は、指定されたフラグを使用して、バッファdataからszバイトをSSL接続sslに書き込みます。必要に応じて、wolfSSL_connect()またはwolfSSL_accept()によってハンドシェイクがまだ実行されていない場合、wolfSSL_send()はSSL/TLSセッションをネゴシエートします。wolfSSL_send()は、ブロッキングI/OとノンブロッキングI/Oの両方で動作します。基盤となるI/Oがノンブロッキングの場合、基盤となるI/OがwolfSSL_sendの継続に必要な要求を満たせなかった場合、wolfSSL_send()は戻ります。この場合、wolfSSL_get_error()を呼び出すと、SSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、基盤となるI/Oの準備ができたときに、wolfSSL_send()の呼び出しを繰り返す必要があります。基盤となるI/Oがブロッキングの場合、wolfSSL_send()は、サイズszのバッファdataが完全に書き込まれるか、エラーが発生するまで戻りません。
 1953
 1954    \return ＞0は、成功時に書き込まれたバイト数です。
 1955    \return 0は、失敗時に返されます。具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1956    \return SSL_FATAL_ERRORは、エラーが発生した場合、またはノンブロッキングソケットを使用している場合にSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーが発生し、アプリケーションがwolfSSL_send()を再度呼び出す必要がある場合に返されます。具体的なエラーコードを取得するには、wolfSSL_get_error()を使用してください。
 1957
 1958    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1959    \param data ピアに送信するデータバッファ。
 1960    \param sz ピアに送信するデータのサイズ(バイト単位)。
 1961    \param flags 基盤となる送信操作に使用する送信フラグ。
 1962
 1963    _Example_
 1964    \code
 1965    WOLFSSL* ssl = 0;
 1966    char msg[64] = "hello wolfssl!";
 1967    int msgSz = (int)strlen(msg);
 1968    int flags = ... ;
 1969    ...
 1970
 1971    input = wolfSSL_send(ssl, msg, msgSz, flags);
 1972    if (input != msgSz) {
 1973    	// wolfSSL_send()が失敗しました
 1974    }
 1975    \endcode
 1976
 1977    \sa wolfSSL_write
 1978    \sa wolfSSL_read
 1979    \sa wolfSSL_recv
 1980*/
 1981int  wolfSSL_send(WOLFSSL* ssl, const void* data, int sz, int flags);
 1982
 1983/*!
 1984    \ingroup IO
 1985
 1986    \brief この関数は、指定されたフラグを使用して、SSLセッション(ssl)の内部読み取りバッファからszバイトをバッファdataに読み込みます。読み取られたバイトは、内部受信バッファから削除されます。この関数は、基盤となる読み取り操作のrecvフラグをアプリケーションが設定できる点を除いて、wolfSSL_read()と同じです。必要に応じて、wolfSSL_connect()またはwolfSSL_accept()によってハンドシェイクがまだ実行されていない場合、wolfSSL_recv()はSSL/TLSセッションをネゴシエートします。SSL/TLSプロトコルは、最大サイズ16kBのSSLレコードを使用します(最大レコードサイズは、<wolfssl_root>/wolfssl/internal.hのMAX_RECORD_SIZE定義で制御できます)。そのため、wolfSSLは、レコードを処理および復号する前に、内部でSSLレコード全体を読み取る必要があります。このため、wolfSSL_recv()の呼び出しは、呼び出し時に復号された最大バッファサイズのみを返すことができます。まだ復号されていない追加データが内部wolfSSL受信バッファで待機している可能性があり、次回のwolfSSL_recv()呼び出しで取得および復号されます。szが内部読み取りバッファのバイト数より大きい場合、SSL_recv()は内部読み取りバッファで利用可能なバイトを返します。内部読み取りバッファにまだバッファリングされているバイトがない場合、wolfSSL_recv()の呼び出しは次のレコードの処理をトリガーします。
 1987
 1988    \return ＞0は、成功時に読み取られたバイト数です。
 1989    \return 0は、失敗時に返されます。これは、クリーンな(close notifyアラート)シャットダウンによって引き起こされる場合もあれば、単にピアが接続を閉じた場合もあります。具体的なエラーコードについては、wolfSSL_get_error()を呼び出してください。
 1990    \return SSL_FATAL_ERRORは、エラーが発生した場合、またはノンブロッキングソケットを使用している場合にSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーが発生し、アプリケーションがwolfSSL_recv()を再度呼び出す必要がある場合に返されます。具体的なエラーコードを取得するには、wolfSSL_get_error()を使用してください。
 1991
 1992    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 1993    \param data wolfSSL_recv()が読み取ったデータを配置するバッファ。
 1994    \param sz dataに読み込むバイト数。
 1995    \param flags 基盤となる受信操作に使用する受信フラグ。
 1996
 1997    _Example_
 1998    \code
 1999    WOLFSSL* ssl = 0;
 2000    char reply[1024];
 2001    int flags = ... ;
 2002    ...
 2003
 2004    input = wolfSSL_recv(ssl, reply, sizeof(reply), flags);
 2005    if (input > 0) {
 2006    	// バッファ"reply"に"input"バイトが返されました
 2007    }
 2008    \endcode
 2009
 2010    \sa wolfSSL_read
 2011    \sa wolfSSL_write
 2012    \sa wolfSSL_peek
 2013    \sa wolfSSL_pending
 2014*/
 2015int  wolfSSL_recv(WOLFSSL* ssl, void* data, int sz, int flags);
 2016
 2017/*!
 2018    \ingroup Debug
 2019
 2020    \brief この関数は、前回のAPI関数呼び出し(wolfSSL_connect、wolfSSL_accept、wolfSSL_read、wolfSSL_write等)がエラーリターンコード(SSL_FAILURE)になった理由を説明する一意のエラーコードを返します。前回の関数の戻り値は、retを通じてwolfSSL_get_errorに渡されます。wolfSSL_get_errorが呼び出されて一意のエラーコードを返した後、wolfSSL_ERR_error_string()を呼び出して、人間が読めるエラー文字列を取得できます。詳細については、wolfSSL_ERR_error_string()を参照してください。
 2021
 2022    \return 正常に完了した場合、この関数は前回のAPI関数が失敗した理由を説明する一意のエラーコードを返します。
 2023    \return SSL_ERROR_NONEは、ret > 0の場合に返されます。ret <= 0の場合、前回のAPIがエラーコードを返したように見えても実際にはエラーが発生していなかった場合に、この値が返されることがあります。例えば、szパラメータがゼロのwolfSSL_read()を呼び出した場合です。wolfSSL_read()からの0の戻り値は通常エラーを示しますが、この場合はエラーは発生していません。その後wolfSSL_get_error()を呼び出すと、SSL_ERROR_NONEが返されます。
 2024
 2025    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 2026    \param ret エラーリターンコードになった前回の関数の戻り値。
 2027
 2028    _Example_
 2029    \code
 2030    int err = 0;
 2031    WOLFSSL* ssl;
 2032    char buffer[80];
 2033    ...
 2034    err = wolfSSL_get_error(ssl, 0);
 2035    wolfSSL_ERR_error_string(err, buffer);
 2036    printf("err = %d, %s\n", err, buffer);
 2037    \endcode
 2038
 2039    \sa wolfSSL_ERR_error_string
 2040    \sa wolfSSL_ERR_error_string_n
 2041    \sa wolfSSL_ERR_print_errors_fp
 2042    \sa wolfSSL_load_error_strings
 2043*/
 2044int  wolfSSL_get_error(WOLFSSL* ssl, int ret);
 2045
 2046/*!
 2047    \ingroup IO
 2048
 2049    \brief この関数はアラート履歴を取得します。
 2050
 2051    \return SSL_SUCCESSは、関数が正常に完了したときに返されます。アラート履歴があってもなくても、いずれの場合も戻り値はSSL_SUCCESSです。
 2052
 2053    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 2054    \param h WOLFSSL構造体のalert_historyメンバーの値を保持するWOLFSSL_ALERT_HISTORY構造体へのポインタ。
 2055
 2056    _Example_
 2057    \code
 2058    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 2059    WOLFSSL* ssl = wolfSSL_new(ctx);
 2060    WOLFSSL_ALERT_HISTORY* h;
 2061    ...
 2062    wolfSSL_get_alert_history(ssl, h);
 2063    // hにssl->alert_historyの内容のコピーが格納されました
 2064    \endcode
 2065
 2066    \sa wolfSSL_get_error
 2067*/
 2068int  wolfSSL_get_alert_history(WOLFSSL* ssl, WOLFSSL_ALERT_HISTORY *h);
 2069
 2070/*!
 2071    \ingroup Setup
 2072
 2073    \brief この関数は、SSLオブジェクトsslがSSL/TLS接続を確立するために使用されるときに使用されるセッションを設定します。セッション再開の場合、セッションオブジェクトでwolfSSL_shutdown()を呼び出す前に、アプリケーションはwolfSSL_get1_session()を呼び出してオブジェクトからセッションIDを保存する必要があります。これはセッションへのポインタを返します。後で、アプリケーションは新しいWOLFSSLオブジェクトを作成し、wolfSSL_set_session()を使用して保存されたセッションを割り当てる必要があります。この時点で、アプリケーションはwolfSSL_connect()を呼び出すことができ、wolfSSLはセッションの再開を試みます。wolfSSLサーバーコードは、デフォルトでセッション再開を許可します。wolfSSL_get1_session()によって返されたオブジェクトは、アプリケーションが使用を終えた後、wolfSSL_SESSION_free()を呼び出して解放する必要があります。
 2074
 2075    \return SSL_SUCCESSは、セッションの設定に成功した場合に返されます。
 2076    \return SSL_FAILUREは、失敗時に返されます。これは、セッションキャッシュが無効になっている場合、またはセッションがタイムアウトした場合に発生する可能性があります。
 2077
 2078    \return OPENSSL_EXTRAとWOLFSSL_ERROR_CODE_OPENSSLが定義されている場合、セッションがタイムアウトしてもSSL_SUCCESSが返されます。
 2079
 2080    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 2081    \param session sslのセッションを設定するために使用されるWOLFSSL_SESSIONへのポインタ。
 2082
 2083    _Example_
 2084    \code
 2085    int ret;
 2086    WOLFSSL* ssl;
 2087    WOLFSSL_SESSION* session;
 2088    ...
 2089    session = wolfSSL_get1_session(ssl);
 2090    if (session == NULL) {
 2091        // sslオブジェクトからセッションオブジェクトの取得に失敗しました
 2092    }
 2093    ...
 2094    ret = wolfSSL_set_session(ssl, session);
 2095    if (ret != SSL_SUCCESS) {
 2096    	// SSLセッションの設定に失敗しました
 2097    }
 2098    wolfSSL_SESSION_free(session);
 2099    ...
 2100    \endcode
 2101
 2102    \sa wolfSSL_get1_session
 2103*/
 2104int        wolfSSL_set_session(WOLFSSL* ssl, WOLFSSL_SESSION* session);
 2105
 2106/*!
 2107    \ingroup IO
 2108
 2109    \brief NO_SESSION_CACHE_REFが定義されている場合、この関数はsslで使用されている現在のセッション(WOLFSSL_SESSION)へのポインタを返します。この関数は、WOLFSSL_SESSIONオブジェクトへの非永続的なポインタを返します。返されたポインタは、wolfSSL_freeが呼び出されたときに解放されます。この呼び出しは、現在のセッションを検査または変更するためにのみ使用する必要があります。セッション再開には、wolfSSL_get1_session()を使用することをお勧めします。後方互換性のため、NO_SESSION_CACHE_REFが定義されていない場合、この関数はローカルキャッシュに格納されている永続的なセッションオブジェクトポインタを返します。キャッシュサイズは有限であり、アプリケーションがwolfSSL_set_session()を呼び出すまでに、別のssl接続によってセッションオブジェクトが上書きされるリスクがあります。アプリケーションでNO_SESSION_CACHE_REFを定義し、セッション再開にwolfSSL_get1_session()を使用することをお勧めします。
 2110
 2111    \return pointer 呼び出しが成功した場合、現在のSSLセッションオブジェクトへのポインタを返します。
 2112    \return NULLは、sslがNULLの場合、SSLセッションキャッシュが無効になっている場合、wolfSSLがセッションIDを利用できない場合、またはミューテックス関数が失敗した場合に返されます。
 2113
 2114    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 2115
 2116    _Example_
 2117    \code
 2118    WOLFSSL* ssl;
 2119    WOLFSSL_SESSION* session;
 2120    ...
 2121    session = wolfSSL_get_session(ssl);
 2122    if (session == NULL) {
 2123	    // セッションポインタの取得に失敗しました
 2124    }
 2125    ...
 2126    \endcode
 2127
 2128    \sa wolfSSL_get1_session
 2129    \sa wolfSSL_set_session
 2130*/
 2131WOLFSSL_SESSION* wolfSSL_get_session(WOLFSSL* ssl);
 2132
 2133/*!
 2134    \ingroup IO
 2135
 2136    \brief この関数は、期限切れのセッションをセッションキャッシュからフラッシュします。時刻tmは、時刻比較に使用されます。wolfSSLは現在セッションに静的テーブルを使用しているため、フラッシュは不要です。そのため、この関数は現在スタブにすぎません。この関数は、wolfSSLがOpenSSL互換レイヤーでコンパイルされている場合、OpenSSL互換性(SSL_flush_sessions)を提供します。
 2137
 2138    \return none 戻り値はありません。
 2139
 2140    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 2141    \param tm セッション有効期限比較に使用される時刻。
 2142
 2143    _Example_
 2144    \code
 2145    WOLFSSL_CTX* ssl;
 2146    ...
 2147    wolfSSL_flush_sessions(ctx, time(0));
 2148    \endcode
 2149
 2150    \sa wolfSSL_get1_session
 2151    \sa wolfSSL_set_session
 2152*/
 2153void       wolfSSL_flush_sessions(WOLFSSL_CTX* ctx, long tm);
 2154
 2155/*!
 2156    \ingroup TLS
 2157
 2158    \brief この関数は、クライアントセッションをサーバーIDに関連付けます。newSessionフラグがオンの場合、既存のセッションは再利用されません。
 2159
 2160    \return SSL_SUCCESSは、関数がエラーなく実行された場合に返されます。
 2161    \return BAD_FUNC_ARGは、WOLFSSL構造体またはidパラメータがNULLの場合、またはlenが0より大きくない場合に返されます。
 2162
 2163    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 2164    \param id WOLFSSL_SESSION構造体のserverIDメンバーにコピーされる定数バイトポインタ。
 2165    \param len セッションidパラメータの長さを表すint型。
 2166    \param newSession セッションを再利用するかどうかを示すフラグを表すint型。
 2167
 2168    _Example_
 2169    \code
 2170    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol );
 2171    WOLFSSL* ssl = WOLFSSL_new(ctx);
 2172    const byte id[MAX_SIZE];  // または動的にスペースを作成
 2173    int len = 0; // 長さを初期化
 2174    int newSession = 0; // 許可するフラグ
 2175    …
 2176    int ret = wolfSSL_SetServerID(ssl, id, len, newSession);
 2177
 2178    if (ret == WOLFSSL_SUCCESS) {
 2179	    // IDが正常に設定されました
 2180    }
 2181    \endcode
 2182
 2183    \sa wolfSSL_set_session
 2184*/
 2185int        wolfSSL_SetServerID(WOLFSSL* ssl, const unsigned char* id,
 2186                                         int len, int newSession);
 2187
 2188/*!
 2189    \ingroup IO
 2190
 2191    \brief この関数は、WOLFSSL構造体のセッションインデックスを取得します。
 2192
 2193    \return int この関数は、WOLFSSL構造体内のsessionIndexを表すint型を返します。
 2194    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 2195
 2196    _Example_
 2197    \code
 2198    WOLFSSL_CTX_new( protocol method );
 2199    WOLFSSL* ssl = WOLFSSL_new(ctx);
 2200    ...
 2201    int sesIdx = wolfSSL_GetSessionIndex(ssl);
 2202
 2203    if(sesIdx < 0 || sesIdx > sizeof(ssl->sessionIndex)/sizeof(int)){
 2204    	// インデックス番号が範囲外であり、何かが正しくありません。
 2205    }
 2206    \endcode
 2207
 2208    \sa wolfSSL_GetSessionAtIndex
 2209*/
 2210int wolfSSL_GetSessionIndex(WOLFSSL* ssl);
 2211
 2212/*!
 2213    \ingroup IO
 2214
 2215    \brief この関数はセッションキャッシュの指定されたインデックスにあるセッションを取得し、メモリにコピーします。WOLFSSL_SESSION構造体はセッション情報を保持します。
 2216
 2217    \return SSL_SUCCESS 関数が正常に実行され、エラーが発生しなかった場合に返されます。
 2218    \return BAD_MUTEX_E mutexのアンロックまたはロックエラーがあった場合に返されます。
 2219    \return SSL_FAILURE 関数が正常に実行されなかった場合に返されます。
 2220
 2221    \param index セッションインデックスを表すint型。
 2222    \param session WOLFSSL_SESSION構造体へのポインタ。
 2223
 2224    _Example_
 2225    \code
 2226    int idx; // セッションを特定するインデックス。
 2227    WOLFSSL_SESSION* session;  // コピー先のバッファ。
 2228    ...
 2229    if(wolfSSL_GetSessionAtIndex(idx, session) != SSL_SUCCESS){
 2230    	// 失敗ケース。
 2231    }
 2232    \endcode
 2233
 2234    \sa UnLockMutex
 2235    \sa LockMutex
 2236    \sa wolfSSL_GetSessionIndex
 2237*/
 2238int wolfSSL_GetSessionAtIndex(int index, WOLFSSL_SESSION* session);
 2239
 2240/*!
 2241    \ingroup IO
 2242
 2243    \brief WOLFSSL_SESSION構造体からピア証明書チェーンを返します。
 2244
 2245    \return pointer ピア証明書チェーンを含むWOLFSSL_X509_CHAIN構造体へのポインタ。
 2246
 2247    \param session WOLFSSL_SESSION構造体へのポインタ。
 2248
 2249    _Example_
 2250    \code
 2251    WOLFSSL_SESSION* session;
 2252    WOLFSSL_X509_CHAIN* chain;
 2253    ...
 2254    chain = wolfSSL_SESSION_get_peer_chain(session);
 2255    if(!chain){
 2256    	// チェーンがありませんでした。失敗ケース。
 2257    }
 2258    \endcode
 2259
 2260    \sa wolfSSL_GetSessionAtIndex
 2261    \sa wolfSSL_GetSessionIndex
 2262    \sa AddSession
 2263*/
 2264
 2265    WOLFSSL_X509_CHAIN* wolfSSL_SESSION_get_peer_chain(WOLFSSL_SESSION* session);
 2266
 2267/*!
 2268    \ingroup Setup
 2269
 2270    \brief この関数はリモートピアの検証方法を設定し、また検証コールバックをSSLコンテキストに登録できるようにします。検証コールバックは検証失敗が発生した場合にのみ呼び出されます。検証コールバックが不要な場合は、verify_callbackにNULLポインタを使用できます。ピア証明書の検証モードは論理OR演算されたフラグのリストです。可能なフラグ値は以下の通りです。SSL_VERIFY_NONE クライアントモード：クライアントはサーバーから受信した証明書を検証せず、ハンドシェイクは通常通り続行されます。サーバーモード：サーバーはクライアントに証明書要求を送信しません。したがって、クライアント検証は有効になりません。SSL_VERIFY_PEER クライアントモード：クライアントはハンドシェイク中にサーバーから受信した証明書を検証します。これはwolfSSLではデフォルトで有効になっているため、このオプションを使用しても効果はありません。サーバーモード：サーバーはクライアントに証明書要求を送信し、受信したクライアント証明書を検証します。SSL_VERIFY_FAIL_IF_NO_PEER_CERT クライアントモード：クライアント側で使用しても効果はありません。サーバーモード：クライアントが要求されたときに証明書の送信に失敗した場合（SSLサーバーでSSL_VERIFY_PEERを使用している場合）、サーバー側で検証が失敗します。SSL_VERIFY_FAIL_EXCEPT_PSK クライアントモード：クライアント側で使用しても効果はありません。サーバーモード：検証はSSL_VERIFY_FAIL_IF_NO_PEER_CERTと同じですが、PSK接続の場合を除きます。PSK接続が行われている場合、接続はピア証明書なしで続行されます。
 2271
 2272    \return none 返り値はありません。
 2273
 2274    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 2275    \param mode ピアの証明書の検証モードを示すフラグ。
 2276    \param verify_callback 検証が失敗したときに呼び出されるコールバック。コールバックが不要な場合は、verify_callbackにNULLポインタを使用できます。
 2277
 2278    _Example_
 2279    \code
 2280    WOLFSSL_CTX*    ctx    = 0;
 2281    ...
 2282    wolfSSL_CTX_set_verify(ctx, (WOLFSSL_VERIFY_PEER |
 2283                           WOLFSSL_VERIFY_FAIL_IF_NO_PEER_CERT), NULL);
 2284    \endcode
 2285
 2286    \sa wolfSSL_set_verify
 2287*/
 2288void wolfSSL_CTX_set_verify(WOLFSSL_CTX* ctx, int mode,
 2289                                      VerifyCallback verify_callback);
 2290
 2291/*!
 2292    \ingroup Setup
 2293
 2294    \brief この関数はリモートピアの検証方法を設定し、また検証コールバックをSSLセッションに登録できるようにします。検証コールバックは検証失敗が発生した場合にのみ呼び出されます。検証コールバックが不要な場合は、verify_callbackにNULLポインタを使用できます。ピア証明書の検証モードは論理OR演算されたフラグのリストです。可能なフラグ値は以下の通りです。SSL_VERIFY_NONE クライアントモード：クライアントはサーバーから受信した証明書を検証せず、ハンドシェイクは通常通り続行されます。サーバーモード：サーバーはクライアントに証明書要求を送信しません。したがって、クライアント検証は有効になりません。SSL_VERIFY_PEER クライアントモード：クライアントはハンドシェイク中にサーバーから受信した証明書を検証します。これはwolfSSLではデフォルトで有効になっているため、このオプションを使用しても効果はありません。サーバーモード：サーバーはクライアントに証明書要求を送信し、受信したクライアント証明書を検証します。SSL_VERIFY_FAIL_IF_NO_PEER_CERT クライアントモード：クライアント側で使用しても効果はありません。サーバーモード：クライアントが要求されたときに証明書の送信に失敗した場合（SSLサーバーでSSL_VERIFY_PEERを使用している場合）、サーバー側で検証が失敗します。SSL_VERIFY_FAIL_EXCEPT_PSK クライアントモード：クライアント側で使用しても効果はありません。サーバーモード：検証はSSL_VERIFY_FAIL_IF_NO_PEER_CERTと同じですが、PSK接続の場合を除きます。PSK接続が行われている場合、接続はピア証明書なしで続行されます。
 2295
 2296    \return none 返り値はありません。
 2297
 2298    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 2299    \param mode ピアの証明書の検証モードを示すフラグ。
 2300    \param verify_callback 検証が失敗したときに呼び出されるコールバック。コールバックが不要な場合は、verify_callbackにNULLポインタを使用できます。
 2301
 2302    _Example_
 2303    \code
 2304    WOLFSSL* ssl = 0;
 2305    ...
 2306    wolfSSL_set_verify(ssl, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, 0);
 2307    \endcode
 2308
 2309    \sa wolfSSL_CTX_set_verify
 2310*/
 2311void wolfSSL_set_verify(WOLFSSL* ssl, int mode, VerifyCallback verify_callback);
 2312
 2313/*!
 2314    \ingroup CertsKeys
 2315
 2316    \brief この関数は検証コールバック用のユーザーCTXオブジェクト情報を格納します。
 2317
 2318    \return none 返り値はありません。
 2319
 2320    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 2321    \param ctx WOLFSSL構造体のverifyCbCtxメンバの値に設定されるvoidポインタ。
 2322
 2323    _Example_
 2324    \code
 2325    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 2326    WOLFSSL* ssl = wolfSSL_new(ctx);
 2327    (void*)ctx;
 2328    ...
 2329    if(ssl != NULL){
 2330        wolfSSL_SetCertCbCtx(ssl, ctx);
 2331    } else {
 2332	    // エラーケース、SSLが適切に初期化されていません。
 2333    }
 2334    \endcode
 2335
 2336    \sa wolfSSL_CTX_save_cert_cache
 2337    \sa wolfSSL_CTX_restore_cert_cache
 2338    \sa wolfSSL_CTX_set_verify
 2339*/
 2340void wolfSSL_SetCertCbCtx(WOLFSSL* ssl, void* ctx);
 2341
 2342/*!
 2343    \ingroup CertsKeys
 2344
 2345    \brief この関数は検証コールバック用のユーザーCTXオブジェクト情報を格納します。
 2346
 2347    \return none 返り値はありません。
 2348
 2349    \param ctx WOLFSSL_CTX構造体へのポインタ。
 2350    \param userCtx WOLFSSL_CTX構造体のverifyCbCtxメンバの値を設定するために使用されるvoidポインタ。
 2351
 2352    _Example_
 2353    \code
 2354    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 2355    void* userCtx = NULL; // ユーザー定義のコンテキストを割り当て
 2356    ...
 2357    if(ctx != NULL){
 2358        wolfSSL_SetCertCbCtx(ctx, userCtx);
 2359    } else {
 2360        // エラーケース、SSLが適切に初期化されていません。
 2361    }
 2362    \endcode
 2363
 2364    \sa wolfSSL_CTX_save_cert_cache
 2365    \sa wolfSSL_CTX_restore_cert_cache
 2366    \sa wolfSSL_CTX_set_verify
 2367*/
 2368void wolfSSL_CTX_SetCertCbCtx(WOLFSSL_CTX* ctx, void* userCtx);
 2369
 2370/*!
 2371    \ingroup IO
 2372
 2373    \brief この関数はSSLオブジェクト内でバッファリングされ、wolfSSL_read()によって読み取り可能な利用可能なバイト数を返します。
 2374
 2375    \return int この関数は保留中のバイト数を返します。
 2376
 2377    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 2378
 2379    _Example_
 2380    \code
 2381    int pending = 0;
 2382    WOLFSSL* ssl = 0;
 2383    ...
 2384
 2385    pending = wolfSSL_pending(ssl);
 2386    printf("バッファリングされ読み取り可能な%dバイトがあります", pending);
 2387    \endcode
 2388
 2389    \sa wolfSSL_recv
 2390    \sa wolfSSL_read
 2391    \sa wolfSSL_peek
 2392*/
 2393int  wolfSSL_pending(WOLFSSL* ssl);
 2394
 2395/*!
 2396    \ingroup Debug
 2397
 2398    \brief この関数はOpenSSL互換性（SSL_load_error_string）のためのものであり、何も動作を行いません。
 2399
 2400    \return none 返り値はありません。
 2401
 2402    \param none パラメータはありません。
 2403
 2404    _Example_
 2405    \code
 2406    wolfSSL_load_error_strings();
 2407    \endcode
 2408
 2409    \sa wolfSSL_get_error
 2410    \sa wolfSSL_ERR_error_string
 2411    \sa wolfSSL_ERR_error_string_n
 2412    \sa wolfSSL_ERR_print_errors_fp
 2413    \sa wolfSSL_load_error_strings
 2414*/
 2415void wolfSSL_load_error_strings(void);
 2416
 2417/*!
 2418    \ingroup TLS
 2419
 2420    \brief この関数はwolfSSL_CTX_new()内で内部的に呼び出されます。この関数はwolfSSL_Init()のラッパーであり、wolfSSLがOpenSSL互換性レイヤーでコンパイルされた場合のOpenSSL互換性（SSL_library_init）のために存在します。wolfSSL_Init()は、より一般的に使用されるwolfSSL初期化関数です。
 2421
 2422    \return SSL_SUCCESS 呼び出しが成功した場合に返されます。
 2423    \return SSL_FATAL_ERROR 失敗時に返されます。
 2424
 2425    \param none パラメータはありません。
 2426
 2427    _Example_
 2428    \code
 2429    int ret = 0;
 2430    ret = wolfSSL_library_init();
 2431    if (ret != SSL_SUCCESS) {
 2432	    // wolfSSLの初期化に失敗しました
 2433    }
 2434    ...
 2435    \endcode
 2436
 2437    \sa wolfSSL_Init
 2438    \sa wolfSSL_Cleanup
 2439*/
 2440int  wolfSSL_library_init(void);
 2441
 2442/*!
 2443    \brief この関数はWOLFSSLセッションレベルでDevice Idを設定します。
 2444
 2445    \return WOLFSSL_SUCCESS 成功時。
 2446    \return BAD_FUNC_ARG sslがNULLの場合。
 2447
 2448    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 2449    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定します。
 2450
 2451    _Example_
 2452    \code
 2453    WOLFSSL* ssl;
 2454    int DevId = -2;
 2455
 2456    wolfSSL_SetDevId(ssl, devId);
 2457
 2458    \endcode
 2459
 2460    \sa wolfSSL_CTX_SetDevId
 2461    \sa wolfSSL_CTX_GetDevId
 2462*/
 2463int wolfSSL_SetDevId(WOLFSSL* ssl, int devId);
 2464
 2465/*!
 2466    \brief この関数はWOLFSSL_CTXコンテキストレベルでDevice Idを設定します。
 2467
 2468    \return WOLFSSL_SUCCESS 成功時。
 2469    \return BAD_FUNC_ARG sslがNULLの場合。
 2470
 2471    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 2472    \param devId 暗号コールバックまたは非同期ハードウェアで使用するID。使用しない場合はINVALID_DEVID（-2）に設定します。
 2473
 2474    _Example_
 2475    \code
 2476    WOLFSSL_CTX* ctx;
 2477    int DevId = -2;
 2478
 2479    wolfSSL_CTX_SetDevId(ctx, devId);
 2480
 2481    \endcode
 2482
 2483    \sa wolfSSL_SetDevId
 2484    \sa wolfSSL_CTX_GetDevId
 2485*/
 2486int wolfSSL_CTX_SetDevId(WOLFSSL_CTX* ctx, int devId);
 2487
 2488/*!
 2489    \brief この関数はDevice Idを取得します。
 2490
 2491    \return devId 成功時。
 2492    \return INVALID_DEVID sslとctxの両方がNULLの場合。
 2493
 2494    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 2495    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 2496
 2497    _Example_
 2498    \code
 2499    WOLFSSL_CTX* ctx;
 2500
 2501    wolfSSL_CTX_GetDevId(ctx, ssl);
 2502
 2503    \endcode
 2504
 2505    \sa wolfSSL_SetDevId
 2506    \sa wolfSSL_CTX_SetDevId
 2507
 2508*/
 2509int wolfSSL_CTX_GetDevId(WOLFSSL_CTX* ctx, WOLFSSL* ssl);
 2510
 2511/*!
 2512    \ingroup Setup
 2513
 2514    \brief この関数はSSLセッションキャッシングを有効または無効にします。動作はmodeに使用される値に依存します。modeに使用できる値は以下の通りです。SSL_SESS_CACHE_OFF - セッションキャッシングを無効にします。セッションキャッシングはデフォルトで有効になっています。SSL_SESS_CACHE_NO_AUTO_CLEAR - セッションキャッシュの自動フラッシュを無効にします。自動フラッシュはデフォルトで有効になっています。
 2515
 2516    \return SSL_SUCCESS 成功時に返されます。
 2517
 2518    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 2519    \param mode セッションキャッシュの動作を変更するために使用される修飾子。
 2520
 2521    _Example_
 2522    \code
 2523    WOLFSSL_CTX* ctx = 0;
 2524    ...
 2525    ret = wolfSSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
 2526    if (ret != SSL_SUCCESS) {
 2527        // SSLセッションキャッシングをオフにすることができませんでした。
 2528    }
 2529    \endcode
 2530
 2531    \sa wolfSSL_flush_sessions
 2532    \sa wolfSSL_get1_session
 2533    \sa wolfSSL_set_session
 2534    \sa wolfSSL_get_sessionID
 2535    \sa wolfSSL_CTX_set_timeout
 2536*/
 2537long wolfSSL_CTX_set_session_cache_mode(WOLFSSL_CTX* ctx, long mode);
 2538
 2539/*!
 2540    \brief この関数は、セッションシークレットコールバック関数を設定します。SessionSecretCb型は次のシグネチャを持ちます:int (*SessionSecretCb)(WOLFSSL* ssl, void* secret, int* secretSz, void* ctx)。WOLFSSL構造体のsessionSecretCbメンバが、パラメータcbに設定されます。
 2541
 2542    \return SSL_SUCCESS 関数の実行がエラーを返さなかった場合に返されます。
 2543    \return SSL_FATAL_ERROR WOLFSSL構造体がNULLの場合に返されます。
 2544
 2545    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 2546    \param cb 上記のシグネチャを持つ関数ポインタであるSessionSecretCb型。
 2547    \param ctx 保存されるユーザコンテキストへのポインタ。
 2548
 2549    _Example_
 2550    \code
 2551    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 2552    WOLFSSL* ssl = wolfSSL_new(ctx);
 2553    // SessionSecretCbのシグネチャ
 2554    int SessionSecretCB (WOLFSSL* ssl, void* secret, int* secretSz,
 2555    void* ctx) = SessionSecretCb;
 2556    …
 2557    int wolfSSL_set_session_secret_cb(ssl, SessionSecretCB, (void*)ssl->ctx){
 2558	    // 関数本体。
 2559    }
 2560    \endcode
 2561
 2562    \sa SessionSecretCb
 2563*/
 2564int  wolfSSL_set_session_secret_cb(WOLFSSL* ssl, SessionSecretCb cb, void* ctx);
 2565
 2566/*!
 2567    \ingroup IO
 2568
 2569    \brief この関数は、セッションキャッシュをファイルに永続化します。追加のメモリ使用量のため、memsaveは使用しません。
 2570
 2571    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。セッションキャッシュがファイルに書き込まれました。
 2572    \return SSL_BAD_FILE fnameを開くことができないか、またはそれ以外の理由で破損している場合に返されます。
 2573    \return FWRITE_ERROR XFWRITEがファイルへの書き込みに失敗した場合に返されます。
 2574    \return BAD_MUTEX_E mutexロックの失敗があった場合に返されます。
 2575
 2576    \param fname 書き込み用ファイルを指す定数char型ポインタ。
 2577
 2578    _Example_
 2579    \code
 2580    const char* fname;
 2581    ...
 2582    if(wolfSSL_save_session_cache(fname) != SSL_SUCCESS){
 2583    	// ファイルへの書き込みに失敗しました。
 2584    }
 2585    \endcode
 2586
 2587    \sa XFWRITE
 2588    \sa wolfSSL_restore_session_cache
 2589    \sa wolfSSL_memrestore_session_cache
 2590*/
 2591int  wolfSSL_save_session_cache(const char* fname);
 2592
 2593/*!
 2594    \ingroup IO
 2595
 2596    \brief この関数は、永続的なセッションキャッシュをファイルから復元します。追加のメモリ使用量のため、memstoreは使用しません。
 2597
 2598    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
 2599    \return SSL_BAD_FILE 関数に渡されたファイルが破損しており、XFOPENで開くことができなかった場合に返されます。
 2600    \return FREAD_ERROR ファイルがXFREADからの読み取りエラーを持っていた場合に返されます。
 2601    \return CACHE_MATCH_ERROR セッションキャッシュヘッダのマッチングに失敗した場合に返されます。
 2602    \return BAD_MUTEX_E mutexロックの失敗があった場合に返されます。
 2603
 2604    \param fname 読み取られる定数char型ポインタファイル入力。
 2605
 2606    _Example_
 2607    \code
 2608    const char *fname;
 2609    ...
 2610    if(wolfSSL_restore_session_cache(fname) != SSL_SUCCESS){
 2611        // 失敗ケースです。関数はSSL_SUCCESSを返しませんでした。
 2612    }
 2613    \endcode
 2614
 2615    \sa XFREAD
 2616    \sa XFOPEN
 2617*/
 2618int  wolfSSL_restore_session_cache(const char* fname);
 2619
 2620/*!
 2621    \ingroup IO
 2622
 2623    \brief この関数は、セッションキャッシュをメモリに永続化します。
 2624
 2625    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。セッションキャッシュがメモリに正常に永続化されました。
 2626    \return BAD_MUTEX_E mutexロックエラーがあった場合に返されます。
 2627    \return BUFFER_E バッファサイズが小さすぎた場合に返されます。
 2628
 2629    \param mem メモリコピーXMEMCPY()の宛先を表すvoid型ポインタ。
 2630    \param sz memのサイズを表すint型。
 2631
 2632    _Example_
 2633    \code
 2634    void* mem;
 2635    int sz; // メモリバッファの最大サイズ。
 2636    …
 2637    if(wolfSSL_memsave_session_cache(mem, sz) != SSL_SUCCESS){
 2638    	// 失敗ケースです。セッションキャッシュをメモリに永続化できませんでした。
 2639    }
 2640    \endcode
 2641
 2642    \sa XMEMCPY
 2643    \sa wolfSSL_get_session_cache_memsize
 2644*/
 2645int  wolfSSL_memsave_session_cache(void* mem, int sz);
 2646
 2647/*!
 2648    \ingroup IO
 2649
 2650    \brief この関数は、永続的なセッションキャッシュをメモリから復元します。
 2651
 2652    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
 2653    \return BUFFER_E メモリバッファが小さすぎる場合に返されます。
 2654    \return BAD_MUTEX_E セッションキャッシュのmutexロックに失敗した場合に返されます。
 2655    \return CACHE_MATCH_ERROR セッションキャッシュヘッダのマッチングに失敗した場合に返されます。
 2656
 2657    \param mem 復元のソースを含む定数void型ポインタ。
 2658    \param sz メモリバッファのサイズを表す整数。
 2659
 2660    _Example_
 2661    \code
 2662    const void* memoryFile;
 2663    int szMf;
 2664    ...
 2665    if(wolfSSL_memrestore_session_cache(memoryFile, szMf) != SSL_SUCCESS){
 2666    	// 失敗ケースです。SSL_SUCCESSが返されませんでした。
 2667    }
 2668    \endcode
 2669
 2670    \sa wolfSSL_save_session_cache
 2671*/
 2672int  wolfSSL_memrestore_session_cache(const void* mem, int sz);
 2673
 2674/*!
 2675    \ingroup IO
 2676
 2677    \brief この関数は、セッションキャッシュの保存バッファがどのくらい大きくあるべきかを返します。
 2678
 2679    \return int この関数は、セッションキャッシュの保存バッファのサイズを表す整数を返します。
 2680
 2681    \param none パラメータなし。
 2682
 2683    _Example_
 2684    \code
 2685    int sz = // エラーチェックのための最小サイズ;
 2686    ...
 2687    if(sz < wolfSSL_get_session_cache_memsize()){
 2688        // メモリバッファが小さすぎます。
 2689    }
 2690    \endcode
 2691
 2692    \sa wolfSSL_memrestore_session_cache
 2693*/
 2694int  wolfSSL_get_session_cache_memsize(void);
 2695
 2696/*!
 2697    \ingroup CertsKeys
 2698
 2699    \brief この関数は、証明書キャッシュをメモリからファイルに書き込みます。
 2700
 2701    \return SSL_SUCCESS CM_SaveCertCacheが正常に終了した場合に返されます。
 2702    \return BAD_FUNC_ARG いずれかの引数がNULLの場合に返されます。
 2703    \return SSL_BAD_FILE 証明書キャッシュ保存ファイルを開くことができなかった場合に返されます。
 2704    \return BAD_MUTEX_E ロックmutexが失敗した場合に返されます。
 2705    \return MEMORY_E メモリの割り当てに失敗した場合に返されます。
 2706    \return FWRITE_ERROR 証明書キャッシュファイルの書き込みに失敗しました。
 2707
 2708    \param ctx 証明書情報を保持するWOLFSSL_CTX構造体へのポインタ。
 2709    \param fname 書き込み用ファイルを指す定数char型ポインタ。
 2710
 2711    _Example_
 2712    \code
 2713    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol def );
 2714    const char* fname;
 2715    ...
 2716    if(wolfSSL_CTX_save_cert_cache(ctx, fname)){
 2717	    // ファイルが書き込まれました。
 2718    }
 2719    \endcode
 2720
 2721    \sa CM_SaveCertCache
 2722    \sa DoMemSaveCertCache
 2723*/
 2724int  wolfSSL_CTX_save_cert_cache(WOLFSSL_CTX* ctx, const char* fname);
 2725
 2726/*!
 2727    \ingroup CertsKeys
 2728
 2729    \brief この関数は、証明書キャッシュをファイルから永続化します。
 2730
 2731    \return SSL_SUCCESS 関数CM_RestoreCertCacheが正常に実行された場合に返されます。
 2732    \return SSL_BAD_FILE XFOPENがXBADFILEを返した場合に返されます。ファイルが破損しています。
 2733    \return MEMORY_E 一時バッファに割り当てられたメモリが失敗した場合に返されます。
 2734    \return BAD_FUNC_ARG fnameまたはctxがNULL値を持つ場合に返されます。
 2735
 2736    \param ctx 証明書情報を保持するWOLFSSL_CTX構造体へのポインタ。
 2737    \param fname 読み取り用ファイルを指す定数char型ポインタ。
 2738
 2739    _Example_
 2740    \code
 2741    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 2742    WOLFSSL* ssl = wolfSSL_new(ctx);
 2743    const char* fname = "ファイルへのパス";
 2744    ...
 2745    if(wolfSSL_CTX_restore_cert_cache(ctx, fname)){
 2746    	// 実行が成功したかどうかを確認します。
 2747    }
 2748    \endcode
 2749
 2750    \sa CM_RestoreCertCache
 2751    \sa XFOPEN
 2752*/
 2753int  wolfSSL_CTX_restore_cert_cache(WOLFSSL_CTX* ctx, const char* fname);
 2754
 2755/*!
 2756    \ingroup CertsKeys
 2757
 2758    \brief この関数は、証明書キャッシュをメモリに永続化します。
 2759
 2760    \return SSL_SUCCESS 関数の実行が成功し、エラーが発生しなかった場合に返されます。
 2761    \return BAD_MUTEX_E WOLFSSL_CERT_MANAGERメンバcaLockが0(ゼロ)でなかったmutexエラー。
 2762    \return BAD_FUNC_ARG ctx、mem、またはusedがNULLの場合、またはszが0(ゼロ)以下の場合に返されます。
 2763    \return BUFFER_E 出力バッファmemが小さすぎました。
 2764
 2765    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 2766    \param mem 宛先(出力バッファ)へのvoid型ポインタ。
 2767    \param sz 出力バッファのサイズ。
 2768    \param used 証明書キャッシュヘッダのサイズへのポインタ。
 2769
 2770    _Example_
 2771    \code
 2772    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol );
 2773    void* mem;
 2774    int sz;
 2775    int* used;
 2776    ...
 2777    if(wolfSSL_CTX_memsave_cert_cache(ctx, mem, sz, used) != SSL_SUCCESS){
 2778	    // 関数がエラーを返しました。
 2779    }
 2780    \endcode
 2781
 2782    \sa DoMemSaveCertCache
 2783    \sa GetCertCacheMemSize
 2784    \sa CM_MemRestoreCertCache
 2785    \sa CM_GetCertCacheMemSize
 2786*/
 2787int  wolfSSL_CTX_memsave_cert_cache(WOLFSSL_CTX* ctx, void* mem, int sz, int* used);
 2788
 2789/*!
 2790    \ingroup Setup
 2791
 2792    \brief この関数は、証明書キャッシュをメモリから復元します。
 2793
 2794    \return SSL_SUCCESS 関数とサブルーチンがエラーなく実行された場合に返されます。
 2795    \return BAD_FUNC_ARG ctxまたはmemパラメータがNULLの場合、またはszパラメータが0以下の場合に返されます。
 2796    \return BUFFER_E 証明書キャッシュのメモリバッファが小さすぎる場合に返されます。
 2797    \return CACHE_MATCH_ERROR 証明書キャッシュヘッダの不一致があった場合に返されます。
 2798    \return BAD_MUTEX_E ロックmutexが失敗した場合に返されます。
 2799
 2800    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 2801    \param mem 証明書キャッシュに復元される値を持つvoid型ポインタ。
 2802    \param sz memパラメータのサイズを表すint型。
 2803
 2804    _Example_
 2805    \code
 2806    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol method );
 2807    WOLFSSL* ssl = WOLFSSL_new(ctx);
 2808    void* mem;
 2809    int sz = (*int) sizeof(mem);
 2810    …
 2811    if(wolfSSL_CTX_memrestore_cert_cache(ssl->ctx, mem, sz)){
 2812    	// 成功ケース
 2813    }
 2814    \endcode
 2815
 2816    \sa CM_MemRestoreCertCache
 2817*/
 2818int  wolfSSL_CTX_memrestore_cert_cache(WOLFSSL_CTX* ctx, const void* mem, int sz);
 2819
 2820/*!
 2821    \ingroup CertsKeys
 2822
 2823    \brief 証明書キャッシュの保存バッファに必要なサイズを返します。
 2824
 2825    \return int 成功時にメモリサイズを表す整数値が返されます。
 2826    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合に返されます。
 2827    \return BAD_MUTEX_E mutexロックエラーがあった場合に返されます。
 2828
 2829    \param ctx wolfSSL_CTX_new()を使用して作成されたwolfSSL_CTX構造体へのポインタ。
 2830
 2831    _Example_
 2832    \code
 2833    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(protocol);
 2834    ...
 2835    int certCacheSize = wolfSSL_CTX_get_cert_cache_memsize(ctx);
 2836
 2837    if(certCacheSize != BAD_FUNC_ARG || certCacheSize != BAD_MUTEX_E){
 2838	// メモリサイズの取得に成功しました。
 2839    }
 2840    \endcode
 2841
 2842    \sa CM_GetCertCacheMemSize
 2843*/
 2844int  wolfSSL_CTX_get_cert_cache_memsize(WOLFSSL_CTX* ctx);
 2845
 2846/*!
 2847    \ingroup Setup
 2848
 2849    \brief この関数は、指定された WOLFSSL_CTX に対する暗号スイートリストを設定します。設定したリストは、本コンテキストから新規に作成されるすべての WOLFSSL セッションのデフォルトリストとなり、文字列内の順序がそのまま優先順位（高い順から低い順）として用いられます。本関数を呼び出すたびに前回のリストは置き換えられます。リストは null 終端のテキスト文字列で、暗号スイート名および／または OpenSSL 互換のキーワードをコロンで区切って指定します（例: "TLS13-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-SHA256"）。
 2850
 2851    リスト中の各トークンには次のいずれかを指定できます。
 2852
 2853    1. 個別の暗号スイート名。wolfSSL は独自の短縮名と IANA 名（WOLFSSL_NO_ERROR_STRINGS が定義されていない場合）の両方を受理します。たとえば "ECDHE-RSA-AES128-GCM-SHA256" と "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" は等価です。受理される名前の完全なリストは src/internal.c の cipher_names[] 配列にあります。実行時に現在のビルドに含まれるスイートを列挙するには wolfSSL_get_ciphers() を使用してください。
 2854
 2855    2. OpenSSL 互換のキーワード（下表参照）。スイート群を一括で選択したり、特定クラスを on/off するために使用します。一部のキーワードには OPENSSL_EXTRA または OPENSSL_ALL の定義が必要です。
 2856
 2857    3. 否定キーワード "!keyword"（OPENSSL_EXTRA または OPENSSL_ALL が必要）。例: "HIGH:!aNULL"。
 2858
 2859    "+" 演算子（例: "ECDHE+AESGCM"）は、先頭の公開鍵ファミリトークン（"ECDHE", "RSA", "DHE"）の抽出にのみ使用されます。"+" の後の部分は wolfSSL では無視されます。特定のスイートを指定したい場合は完全なスイート名を直接指定してください。
 2860
 2861    OpenSSL 互換のグループキーワード:
 2862
 2863    | キーワード        | 効果                                                         | 必要なビルドオプション |
 2864    | ----------------- | ------------------------------------------------------------ | --------------------- |
 2865    | DEFAULT / ALL     | ビルドされている全スイートを含める。"ALL" は匿名（aNULL）も有効化 | OPENSSL_EXTRA / OPENSSL_ALL（他トークンを伴わない単独指定も可） |
 2866    | HIGH              | 静的・匿名・NULL を除く全スイート                            | OPENSSL_EXTRA / OPENSSL_ALL（単独指定も可） |
 2867    | LOW / MEDIUM      | 受理されるが鍵長による制限はかからず "RSA" 相当として扱われる | OPENSSL_EXTRA / OPENSSL_ALL |
 2868    | aNULL             | 匿名（認証なし）スイート                                     | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は HAVE_ANON が必要） |
 2869    | eNULL / NULL      | NULL 暗号化スイート                                          | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は HAVE_NULL_CIPHER が必要） |
 2870    | kDH               | 静的 DH 鍵交換                                               | OPENSSL_EXTRA / OPENSSL_ALL |
 2871    | DHE / EDH         | エフェメラル DH 鍵交換                                       | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は !NO_DH が必要） |
 2872    | ECDHE / EECDH     | エフェメラル ECDH 鍵交換                                     | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は HAVE_ECC が必要） |
 2873    | kRSA / RSA        | 静的 RSA 鍵交換                                              | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は !NO_RSA が必要） |
 2874    | PSK               | PSK スイート                                                 | OPENSSL_EXTRA / OPENSSL_ALL（スイート自体は !NO_PSK が必要） |
 2875    | DSS               | 黙って無視される（wolfSSL は DSA スイート非対応）            | OPENSSL_EXTRA / OPENSSL_ALL |
 2876    | EXP / EXPORT      | 黙って無視される（export 等級は非対応）                      | OPENSSL_EXTRA / OPENSSL_ALL |
 2877    | AES128 / SHA1 / RC4 | 否定指定（"!AES128" 等）でそのクラスを無効化                | WOLFSSL_SYS_CRYPTO_POLICY |
 2878    | @SECLEVEL=n       | OpenSSL 互換のセキュリティレベル設定                         | WOLFSSL_SYS_CRYPTO_POLICY |
 2879
 2880    代表的な TLS 1.3 暗号スイート名（各々個別の BUILD_* マクロでガードされる。多くは --enable-tls13 で自動有効化）:
 2881
 2882    | 名前（wolfSSL）              | IANA 名                         | 必要なビルドオプション |
 2883    | ---------------------------- | ------------------------------- | ---------------------- |
 2884    | TLS13-AES128-GCM-SHA256      | TLS_AES_128_GCM_SHA256          | BUILD_TLS_AES_128_GCM_SHA256（TLS 1.3 既定） |
 2885    | TLS13-AES256-GCM-SHA384      | TLS_AES_256_GCM_SHA384          | BUILD_TLS_AES_256_GCM_SHA384 |
 2886    | TLS13-CHACHA20-POLY1305-SHA256 | TLS_CHACHA20_POLY1305_SHA256  | BUILD_TLS_CHACHA20_POLY1305_SHA256（HAVE_CHACHA + HAVE_POLY1305） |
 2887    | TLS13-AES128-CCM-SHA256      | TLS_AES_128_CCM_SHA256          | BUILD_TLS_AES_128_CCM_SHA256（HAVE_AESCCM） |
 2888    | TLS13-AES128-CCM-8-SHA256    | TLS_AES_128_CCM_8_SHA256        | BUILD_TLS_AES_128_CCM_8_SHA256（HAVE_AESCCM） |
 2889    | TLS13-SM4-GCM-SM3            | TLS_SM4_GCM_SM3                 | BUILD_TLS_SM4_GCM_SM3（WOLFSSL_SM4_GCM + WOLFSSL_SM3） |
 2890    | TLS13-SM4-CCM-SM3            | TLS_SM4_CCM_SM3                 | BUILD_TLS_SM4_CCM_SM3（WOLFSSL_SM4_CCM + WOLFSSL_SM3） |
 2891    | TLS13-SHA256-SHA256          | TLS_SHA256_SHA256               | BUILD_TLS_SHA256_SHA256（integrity-only） |
 2892    | TLS13-SHA384-SHA384          | TLS_SHA384_SHA384               | BUILD_TLS_SHA384_SHA384 |
 2893
 2894    代表的な TLS 1.2 暗号スイート名のファミリ（各スイートは IANA 名から派生する個別の BUILD_* マクロでガードされる）:
 2895
 2896    | スイート名のファミリ／例                       | 一般的な必要オプション |
 2897    | ---------------------------------------------- | ---------------------- |
 2898    | ECDHE-ECDSA-AES128-GCM-SHA256, ECDHE-ECDSA-AES256-GCM-SHA384, ECDHE-ECDSA-CHACHA20-POLY1305 | HAVE_ECC, HAVE_AESGCM（または HAVE_CHACHA + HAVE_POLY1305） |
 2899    | ECDHE-RSA-AES128-GCM-SHA256, ECDHE-RSA-AES256-GCM-SHA384, ECDHE-RSA-CHACHA20-POLY1305 | HAVE_ECC, !NO_RSA, HAVE_AESGCM（または HAVE_CHACHA + HAVE_POLY1305） |
 2900    | DHE-RSA-AES128-GCM-SHA256, DHE-RSA-AES256-GCM-SHA384, DHE-RSA-CHACHA20-POLY1305 | !NO_DH, !NO_RSA, HAVE_AESGCM（または HAVE_CHACHA + HAVE_POLY1305） |
 2901    | AES128-SHA, AES256-SHA, AES128-SHA256, AES256-SHA256, AES128-GCM-SHA256, AES256-GCM-SHA384（静的 RSA） | !NO_RSA, !NO_AES_CBC および／または HAVE_AESGCM |
 2902    | DES-CBC3-SHA, RC4-SHA, RC4-MD5                 | レガシー: !NO_DES3 / !NO_RC4, !NO_OLD_TLS |
 2903    | NULL-SHA, NULL-SHA256, NULL-MD5                | HAVE_NULL_CIPHER |
 2904    | PSK-AES128-CBC-SHA256, PSK-AES256-GCM-SHA384, ECDHE-PSK-AES128-CBC-SHA256, DHE-PSK-AES256-GCM-SHA384 | !NO_PSK（ECDHE-PSK は HAVE_ECC、DHE-PSK は !NO_DH も必要） |
 2905    | ADH-AES128-SHA, ADH-AES256-SHA                 | HAVE_ANON |
 2906    | ECDHE-ECDSA-SM4-GCM-SM3, ECDHE-ECDSA-SM4-CCM-SM3 | WOLFSSL_SM2, WOLFSSL_SM3, WOLFSSL_SM4_GCM/WOLFSSL_SM4_CCM |
 2907
 2908    注意事項:
 2909    - TLS 1.3 と TLS 1.2 のスイート名は同一リスト内で混在指定できます。wolfSSL は内部でバージョンごとに振り分けます。
 2910    - DTLS では、リスト中の RC4 ベースのストリーム暗号は黙って除外されます。
 2911    - リスト全体が "DEFAULT"、"ALL"、"HIGH"、または空文字列の場合、wolfSSL は組み込みのデフォルトスイートリストを設定して成功を返し、それ以上のトークン解析は行いません。
 2912
 2913    \return WOLFSSL_SUCCESS 関数が正常に完了した場合に返されます。
 2914    \return WOLFSSL_FAILURE 失敗した場合に返されます。
 2915
 2916    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 2917    \param list 指定された SSL コンテキストで使用する暗号スイートおよび／またはキーワードの null 終端テキスト文字列（コロン区切り）。
 2918
 2919    _Example_
 2920    \code
 2921    WOLFSSL_CTX* ctx = 0;
 2922    ...
 2923    ret = wolfSSL_CTX_set_cipher_list(ctx,
 2924        "TLS13-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:"
 2925        "DHE-RSA-AES256-SHA256");
 2926    if (ret != WOLFSSL_SUCCESS) {
 2927        // 暗号スイートリストの設定に失敗しました。
 2928    }
 2929    \endcode
 2930
 2931    \sa wolfSSL_set_cipher_list
 2932    \sa wolfSSL_get_ciphers
 2933    \sa wolfSSL_get_cipher_list
 2934    \sa wolfSSL_CTX_new
 2935*/
 2936int  wolfSSL_CTX_set_cipher_list(WOLFSSL_CTX* ctx, const char* list);
 2937
 2938/*!
 2939    \ingroup Setup
 2940
 2941    \brief この関数は、指定された WOLFSSL セッション（SSL セッション）に対する暗号スイートリストを設定します。リストの形式、認識される暗号スイート名およびキーワードは wolfSSL_CTX_set_cipher_list() と同一です。利用可能なキーワード／スイート一覧および必要なビルドオプションについては wolfSSL_CTX_set_cipher_list() の説明を参照してください。本関数を呼び出すたびに、当該セッションのリストは置き換えられます。
 2942
 2943    \return WOLFSSL_SUCCESS 関数が正常に完了すると返されます。
 2944    \return WOLFSSL_FAILURE 失敗時に返されます。
 2945
 2946    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 2947    \param list 指定された SSL セッションで使用する暗号スイートおよび／またはキーワードの null 終端テキスト文字列（コロン区切り）。
 2948
 2949    _Example_
 2950    \code
 2951    int ret = 0;
 2952    WOLFSSL* ssl = 0;
 2953    ...
 2954    ret = wolfSSL_set_cipher_list(ssl,
 2955        "TLS13-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:"
 2956        "DHE-RSA-AES256-SHA256");
 2957    if (ret != WOLFSSL_SUCCESS) {
 2958        // 暗号スイートリストの設定に失敗
 2959    }
 2960    \endcode
 2961
 2962    \sa wolfSSL_CTX_set_cipher_list
 2963    \sa wolfSSL_get_ciphers
 2964    \sa wolfSSL_get_cipher_list
 2965    \sa wolfSSL_new
 2966*/
 2967int  wolfSSL_set_cipher_list(WOLFSSL* ssl, const char* list);
 2968
 2969/*!
 2970    \brief この関数は、WOLFSSL DTLSオブジェクトに対して、下層のUDP I/Oがノンブロッキングであることを通知します。アプリケーションがWOLFSSLオブジェクトを作成した後、それをノンブロッキングUDPソケットと共に使用する場合は、wolfSSL_dtls_set_using_nonblock()を呼び出してください。これにより、WOLFSSLオブジェクトは、EWOULDBLOCKを受け取ることがタイムアウトではなく、recvfrom呼び出しがブロックすることを意味すると認識できます。
 2971
 2972    \return none 戻り値はありません。
 2973
 2974    \param ssl wolfSSL_new()で作成されたDTLSセッションへのポインタ。
 2975    \param nonblock WOLFSSLオブジェクトのノンブロッキングフラグを設定するための値。ノンブロッキングを指定する場合は1を、そうでない場合は0を使用してください。
 2976
 2977    _Example_
 2978    \code
 2979    WOLFSSL* ssl = 0;
 2980    ...
 2981    wolfSSL_dtls_set_using_nonblock(ssl, 1);
 2982    \endcode
 2983
 2984    \sa wolfSSL_dtls_get_using_nonblock
 2985    \sa wolfSSL_dtls_got_timeout
 2986    \sa wolfSSL_dtls_get_current_timeout
 2987*/
 2988void wolfSSL_dtls_set_using_nonblock(WOLFSSL* ssl, int nonblock);
 2989/*!
 2990    \brief この関数により、アプリケーションはwolfSSLがUDPでノンブロッキングI/Oを使用しているかどうかを判定できます。wolfSSLがノンブロッキングI/Oを使用している場合、この関数は1を返し、それ以外の場合は0を返します。アプリケーションがWOLFSSLオブジェクトを作成した後、それをノンブロッキングUDPソケットと共に使用する場合は、wolfSSL_dtls_set_using_nonblock()を呼び出してください。これにより、WOLFSSLオブジェクトは、EWOULDBLOCKを受け取ることがタイムアウトではなく、recvfrom呼び出しがブロックすることを意味すると認識できます。この関数はDTLSセッションにのみ意味があります。
 2991
 2992    \return 0 下層のI/Oがブロッキングです。
 2993    \return 1 下層のI/Oがノンブロッキングです。
 2994
 2995    \param ssl wolfSSL_new()で作成されたDTLSセッションへのポインタ。
 2996
 2997    _Example_
 2998    \code
 2999    int ret = 0;
 3000    WOLFSSL* ssl = 0;
 3001    ...
 3002    ret = wolfSSL_dtls_get_using_nonblock(ssl);
 3003    if (ret == 1) {
 3004    	// 下層のI/Oはノンブロッキング
 3005    }
 3006    ...
 3007    \endcode
 3008
 3009    \sa wolfSSL_dtls_set_using_nonblock
 3010    \sa wolfSSL_dtls_got_timeout
 3011    \sa wolfSSL_dtls_set_using_nonblock
 3012*/
 3013int  wolfSSL_dtls_get_using_nonblock(WOLFSSL* ssl);
 3014/*!
 3015    \brief この関数は、WOLFSSLオブジェクトの現在のタイムアウト値を秒単位で返します。ノンブロッキングソケットを使用する場合、ユーザコード内の何かが、利用可能な受信データをいつチェックするか、およびどのくらい待機しているかを決定する必要があります。この関数が返す値は、アプリケーションがどのくらい待機すべきかを示します。
 3016
 3017    \return seconds 現在のDTLSタイムアウト値(秒単位)。
 3018    \return NOT_COMPILED_IN wolfSSLがDTLSサポート付きでビルドされていない場合。
 3019
 3020    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3021
 3022    _Example_
 3023    \code
 3024    int timeout = 0;
 3025    WOLFSSL* ssl;
 3026    ...
 3027    timeout = wolfSSL_get_dtls_current_timeout(ssl);
 3028    printf("DTLS timeout (sec) = %d\n", timeout);
 3029    \endcode
 3030
 3031    \sa wolfSSL_dtls
 3032    \sa wolfSSL_dtls_get_peer
 3033    \sa wolfSSL_dtls_got_timeout
 3034    \sa wolfSSL_dtls_set_peer
 3035*/
 3036int  wolfSSL_dtls_get_current_timeout(WOLFSSL* ssl);
 3037/*!
 3038    \brief この関数は、アプリケーションがより短いタイムアウトを設定すべき場合にtrueを返します。ノンブロッキングソケットを使用する場合、ユーザコード内の何かが、利用可能なデータをいつチェックするか、およびどのくらい待機する必要があるかを決定する必要があります。この関数がtrueを返す場合、ライブラリはすでに通信の中断を検出していますが、他のピアからのメッセージがまだ転送中である可能性に備えて、もう少し待機したいことを意味します。このタイマーの値を微調整するのはアプリケーション次第であり、適切な値はdtls_get_current_timeout() / 4かもしれません。
 3039
 3040    \return true アプリケーションコードがより短いタイムアウトを設定すべき場合。
 3041
 3042    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3043
 3044    \sa wolfSSL_dtls
 3045    \sa wolfSSL_dtls_get_peer
 3046    \sa wolfSSL_dtls_got_timeout
 3047    \sa wolfSSL_dtls_set_peer
 3048    \sa wolfSSL_dtls13_set_send_more_acks
 3049*/
 3050int  wolfSSL_dtls13_use_quick_timeout(WOLFSSL *ssl);
 3051/*!
 3052  \ingroup Setup
 3053
 3054    \brief この関数は、中断を検出したときにライブラリがACKを他のピアに即座に送信すべきかどうかを設定します。ACKを即座に送信すると最小のレイテンシが保証されますが、必要以上に帯域幅を消費する可能性があります。アプリケーションが自分でタイマーを管理し、このオプションが0に設定されている場合、アプリケーションコードはwolfSSL_dtls13_use_quick_timeout()を使用して、これらの遅延ACKを送信するためにより短いタイムアウトを設定すべきかどうかを判定できます。
 3055
 3056    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3057    \param value オプションを設定する場合は1、オプションを無効にする場合は0。
 3058
 3059    \sa wolfSSL_dtls
 3060    \sa wolfSSL_dtls_get_peer
 3061    \sa wolfSSL_dtls_got_timeout
 3062    \sa wolfSSL_dtls_set_peer
 3063    \sa wolfSSL_dtls13_use_quick_timeout
 3064*/
 3065void  wolfSSL_dtls13_set_send_more_acks(WOLFSSL *ssl, int value);
 3066
 3067/*!
 3068    \ingroup Setup
 3069
 3070    \brief この関数はdtlsタイムアウトを設定します。
 3071
 3072    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。SSLのdtls_timeout_initおよびdtls_timeoutメンバが設定されています。
 3073    \return BAD_FUNC_ARG WOLFSSL構造体がNULLであるか、またはタイムアウトが0より大きくない場合に返されます。また、timeout引数が許容される最大値を超える場合にも返されます。
 3074
 3075    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3076    \param timeout WOLFSSL構造体のdtls_timeout_initメンバに設定されるint型の値。
 3077
 3078    _Example_
 3079    \code
 3080    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 3081    WOLFSSL* ssl = wolfSSL_new(ctx);
 3082    int timeout = TIMEOUT;
 3083    ...
 3084    if(wolfSSL_dtls_set_timeout_init(ssl, timeout)){
 3085    	// dtlsタイムアウトが設定された
 3086    } else {
 3087    	// DTLSタイムアウトの設定に失敗
 3088    }
 3089    \endcode
 3090
 3091    \sa wolfSSL_dtls_set_timeout_max
 3092    \sa wolfSSL_dtls_got_timeout
 3093*/
 3094int  wolfSSL_dtls_set_timeout_init(WOLFSSL* ssl, int timeout);
 3095
 3096/*!
 3097    \brief この関数は最大dtlsタイムアウトを設定します。
 3098
 3099    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
 3100    \return BAD_FUNC_ARG WOLFSSL構造体がNULLであるか、timeout引数が0より大きくないか、またはWOLFSSL構造体のdtls_timeout_initメンバより小さい場合に返されます。
 3101
 3102    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3103    \param timeout dtls最大タイムアウトを表すint型の値。
 3104
 3105    _Example_
 3106    \code
 3107    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 3108    WOLFSSL* ssl = wolfSSL_new(ctx);
 3109    int timeout = TIMEOUTVAL;
 3110    ...
 3111    int ret = wolfSSL_dtls_set_timeout_max(ssl);
 3112    if(!ret){
 3113    	// 最大タイムアウトの設定に失敗
 3114    }
 3115    \endcode
 3116
 3117    \sa wolfSSL_dtls_set_timeout_init
 3118    \sa wolfSSL_dtls_got_timeout
 3119*/
 3120int  wolfSSL_dtls_set_timeout_max(WOLFSSL* ssl, int timeout);
 3121
 3122/*!
 3123    \brief DTLSでノンブロッキングソケットを使用する場合、制御コードが送信がタイムアウトしたと判断したときに、この関数をWOLFSSLオブジェクトに対して呼び出す必要があります。この関数は、タイムアウト値の調整を含め、最後の送信を再試行するために必要なアクションを実行します。時間が経過しすぎた場合、失敗が返されます。
 3124
 3125    \return SSL_SUCCESS 成功時に返されます。
 3126    \return SSL_FATAL_ERROR ピアからの応答なしで再送信またはタイムアウトが多すぎた場合に返されます。
 3127    \return NOT_COMPILED_IN wolfSSLがDTLSサポート付きでコンパイルされていない場合に返されます。
 3128
 3129    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3130
 3131    _Example_
 3132    \code
 3133    使用例については以下のファイルを参照してください:
 3134    <wolfssl_root>/examples/client/client.c
 3135    <wolfssl_root>/examples/server/server.c
 3136    \endcode
 3137
 3138    \sa wolfSSL_dtls_get_current_timeout
 3139    \sa wolfSSL_dtls_get_peer
 3140    \sa wolfSSL_dtls_set_peer
 3141    \sa wolfSSL_dtls
 3142*/
 3143int  wolfSSL_dtls_got_timeout(WOLFSSL* ssl);
 3144
 3145/*!
 3146    \brief DTLSでノンブロッキングソケットを使用する場合、この関数は予想されるタイムアウト値と再送信カウントを無視して、最後のハンドシェイクフライトを再送信します。これは、DTLSを使用していて、タイムアウトと再試行回数さえも管理する必要があるアプリケーションに役立ちます。
 3147
 3148    \return SSL_SUCCESS 成功時に返されます。
 3149    \return SSL_FATAL_ERROR ピアからの応答なしで再送信またはタイムアウトが多すぎた場合に返されます。
 3150
 3151    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3152
 3153    _Example_
 3154    \code
 3155    int ret = 0;
 3156    WOLFSSL* ssl;
 3157    ...
 3158    ret = wolfSSL_dtls_retransmit(ssl);
 3159    \endcode
 3160
 3161    \sa wolfSSL_dtls_get_current_timeout
 3162    \sa wolfSSL_dtls_got_timeout
 3163    \sa wolfSSL_dtls
 3164*/
 3165int wolfSSL_dtls_retransmit(WOLFSSL* ssl);
 3166
 3167/*!
 3168    \brief この関数は、SSLセッションがDTLSを使用するように設定されているかどうかを判定するために使用されます。
 3169
 3170    \return 1 SSLセッション(ssl)がDTLSを使用するように設定されている場合、この関数は1を返します。
 3171    \return 0 それ以外の場合。
 3172
 3173    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3174
 3175    _Example_
 3176    \code
 3177    int ret = 0;
 3178    WOLFSSL* ssl;
 3179    ...
 3180    ret = wolfSSL_dtls(ssl);
 3181    if (ret) {
 3182    	// SSLセッションはDTLSを使用するように設定されている
 3183    }
 3184    \endcode
 3185
 3186    \sa wolfSSL_dtls_get_current_timeout
 3187    \sa wolfSSL_dtls_get_peer
 3188    \sa wolfSSL_dtls_got_timeout
 3189    \sa wolfSSL_dtls_set_peer
 3190*/
 3191int  wolfSSL_dtls(WOLFSSL* ssl);
 3192
 3193/*!
 3194    \brief この関数は、DTLSピアpeer(sockaddr_in)をサイズpeerSzで設定します。
 3195
 3196    \return SSL_SUCCESS 成功時に返されます。
 3197    \return SSL_FAILURE 失敗時に返されます。
 3198    \return SSL_NOT_IMPLEMENTED wolfSSLがDTLSサポート付きでコンパイルされていない場合に返されます。
 3199
 3200    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3201    \param peer ピアのsockaddr_in構造体へのポインタ。NULLの場合、ssl内のピア情報がクリアされます。
 3202    \param peerSz peerが指すsockaddr_in構造体のサイズ。0の場合、ssl内のピア情報がクリアされます。
 3203
 3204    _Example_
 3205    \code
 3206    int ret = 0;
 3207    WOLFSSL* ssl;
 3208    sockaddr_in addr;
 3209    ...
 3210    ret = wolfSSL_dtls_set_peer(ssl, &addr, sizeof(addr));
 3211    if (ret != SSL_SUCCESS) {
 3212	    // DTLSピアの設定に失敗
 3213    }
 3214    \endcode
 3215
 3216    \sa wolfSSL_dtls_get_current_timeout
 3217    \sa wolfSSL_dtls_set_pending_peer
 3218    \sa wolfSSL_dtls_get_peer
 3219    \sa wolfSSL_dtls_got_timeout
 3220    \sa wolfSSL_dtls
 3221*/
 3222int  wolfSSL_dtls_set_peer(WOLFSSL* ssl, void* peer, unsigned int peerSz);
 3223
 3224/*!
 3225    \brief この関数は、保留中のDTLSピアpeer(sockaddr_in)をサイズpeerSzで設定します。これにより、次のレコードの保護を正常に解除したときに通常のピアにアップグレードされる保留中のピアが設定されます。これは、ピアのアドレスが変更される可能性があるシナリオで、オフパス攻撃者がピアアドレスを変更するのを防ぐのに役立ちます。これは、新しいピアアドレスへのシームレスで安全な移行を可能にするために、Connection IDと共に使用する必要があります。
 3226
 3227    \return SSL_SUCCESS 成功時に返されます。
 3228    \return SSL_FAILURE 失敗時に返されます。
 3229    \return SSL_NOT_IMPLEMENTED wolfSSLがDTLSサポート付きでコンパイルされていない場合に返されます。
 3230
 3231    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3232    \param peer ピアのsockaddr_in構造体へのポインタ。NULLの場合、ssl内のピア情報がクリアされます。
 3233    \param peerSz peerが指すsockaddr_in構造体のサイズ。0の場合、ssl内のピア情報がクリアされます。
 3234
 3235    _Example_
 3236    \code
 3237    int ret = 0;
 3238    WOLFSSL* ssl;
 3239    sockaddr_in addr;
 3240    ...
 3241    ret = wolfSSL_dtls_set_pending_peer(ssl, &addr, sizeof(addr));
 3242    if (ret != SSL_SUCCESS) {
 3243	    // DTLSピアの設定に失敗
 3244    }
 3245    \endcode
 3246
 3247    \sa wolfSSL_dtls_get_current_timeout
 3248    \sa wolfSSL_dtls_set_peer
 3249    \sa wolfSSL_dtls_get_peer
 3250    \sa wolfSSL_dtls_got_timeout
 3251    \sa wolfSSL_dtls
 3252*/
 3253int  wolfSSL_dtls_set_pending_peer(WOLFSSL* ssl, void* peer,
 3254                                   unsigned int peerSz);
 3255
 3256/*!
 3257    \brief この関数は、現在のDTLSピアのsockaddr_in(サイズpeerSz)を取得します。この関数はpeerSzを、SSLセッションに格納されている実際のDTLSピアサイズと比較します。ピアがpeerに収まる場合、ピアのsockaddr_inがpeerにコピーされ、peerSzがpeerのサイズに設定されます。
 3258
 3259    \return SSL_SUCCESS 成功時に返されます。
 3260    \return SSL_FAILURE 失敗時に返されます。
 3261    \return SSL_NOT_IMPLEMENTED wolfSSLがDTLSサポート付きでコンパイルされていない場合に返されます。
 3262
 3263    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3264    \param peer ピアのsockaddr_in構造体を格納するメモリ位置へのポインタ。
 3265    \param peerSz 入出力サイズ。入力として、peerが指す割り当てられたメモリのサイズ。出力として、peerが指す実際のsockaddr_in構造体のサイズ。
 3266
 3267    _Example_
 3268    \code
 3269    int ret = 0;
 3270    WOLFSSL* ssl;
 3271    sockaddr_in addr;
 3272    ...    ret = wolfSSL_dtls_get_peer(ssl, &addr, sizeof(addr));
 3273    if (ret != SSL_SUCCESS) {
 3274	    // DTLSピアの取得に失敗しました
 3275    }
 3276    \endcode
 3277
 3278    \sa wolfSSL_dtls_get_current_timeout
 3279    \sa wolfSSL_dtls_got_timeout
 3280    \sa wolfSSL_dtls_set_peer
 3281    \sa wolfSSL_dtls
 3282*/
 3283int  wolfSSL_dtls_get_peer(WOLFSSL* ssl, void* peer, unsigned int* peerSz);
 3284
 3285/*!
 3286    \brief この関数は現在のDTLSピアのsockaddr_in（サイズpeerSz）を取得します。これはwolfSSL_dtls_get_peer()のゼロコピー代替です。
 3287
 3288    \return SSL_SUCCESS 成功時に返されます。
 3289    \return SSL_FAILURE 失敗時に返されます。
 3290    \return SSL_NOT_IMPLEMENTED wolfSSLがDTLSサポートでコンパイルされていない場合に返されます。
 3291
 3292    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3293    \param peer ピアアドレスを保持する内部バッファを返すためのポインタ。
 3294    \param peerSz peerが指す実際のsockaddr_in構造体のサイズを出力します。
 3295
 3296    _Example_
 3297    \code
 3298    int ret = 0;
 3299    WOLFSSL* ssl;
 3300    sockaddr_in* addr;
 3301    unsigned int addrSz;
 3302    ...
 3303    ret = wolfSSL_dtls_get_peer(ssl, &addr, &addrSz);
 3304    if (ret != SSL_SUCCESS) {
 3305	    // DTLSピアの取得に失敗しました
 3306    }
 3307    \endcode
 3308
 3309    \sa wolfSSL_dtls_get_current_timeout
 3310    \sa wolfSSL_dtls_got_timeout
 3311    \sa wolfSSL_dtls_set_peer
 3312    \sa wolfSSL_dtls
 3313*/
 3314int  wolfSSL_dtls_get0_peer(WOLFSSL* ssl, const void** peer,
 3315                            unsigned int* peerSz);
 3316
 3317/*!
 3318    \ingroup Debug
 3319
 3320    \brief この関数はwolfSSL_get_error()によって返されたエラーコードを、より人間が読みやすいエラー文字列に変換します。errNumberはwolfSSL_get_error()によって返されたエラーコードであり、dataはエラー文字列が配置される格納バッファです。dataの最大長はデフォルトで80文字であり、wolfssl/wolfcrypt/error.hのMAX_ERROR_SZで定義されています。
 3321
 3322    \return success 正常に完了した場合、この関数はdataで返されるのと同じ文字列を返します。
 3323    \return failure 失敗時には、この関数は適切な失敗理由msgを含む文字列を返します。
 3324
 3325    \param errNumber wolfSSL_get_error()によって返されたエラーコード。
 3326    \param data errNumberに一致する人間が読みやすいエラー文字列を含む出力バッファ。
 3327
 3328    _Example_
 3329    \code
 3330    int err = 0;
 3331    WOLFSSL* ssl;
 3332    char buffer[80];
 3333    ...
 3334    err = wolfSSL_get_error(ssl, 0);
 3335    wolfSSL_ERR_error_string(err, buffer);
 3336    printf("err = %d, %s\n", err, buffer);
 3337    \endcode
 3338
 3339    \sa wolfSSL_get_error
 3340    \sa wolfSSL_ERR_error_string_n
 3341    \sa wolfSSL_ERR_print_errors_fp
 3342    \sa wolfSSL_load_error_strings
 3343*/
 3344char* wolfSSL_ERR_error_string(unsigned long errNumber, char* data);
 3345
 3346/*!
 3347    \ingroup Debug
 3348
 3349    \brief この関数はwolfSSL_ERR_error_string()のバージョンであり、lenはbufに書き込まれる最大文字数を指定します。wolfSSL_ERR_error_string()と同様に、この関数はwolfSSL_get_error()から返されたエラーコードをより人間が読みやすいエラー文字列に変換します。人間が読みやすい文字列はbufに配置されます。
 3350
 3351    \return none 返り値はありません。
 3352
 3353    \param e wolfSSL_get_error()によって返されたエラーコード。
 3354    \param buff eに一致する人間が読みやすいエラー文字列を含む出力バッファ。
 3355    \param len bufに書き込まれる最大文字数。
 3356
 3357    _Example_
 3358    \code
 3359    int err = 0;
 3360    WOLFSSL* ssl;
 3361    char buffer[80];
 3362    ...
 3363    err = wolfSSL_get_error(ssl, 0);
 3364    wolfSSL_ERR_error_string_n(err, buffer, 80);
 3365    printf("err = %d, %s\n", err, buffer);
 3366    \endcode
 3367
 3368    \sa wolfSSL_get_error
 3369    \sa wolfSSL_ERR_error_string
 3370    \sa wolfSSL_ERR_print_errors_fp
 3371    \sa wolfSSL_load_error_strings
 3372*/
 3373void  wolfSSL_ERR_error_string_n(unsigned long e, char* buf,
 3374                                           unsigned long len);
 3375
 3376/*!
 3377    \ingroup TLS
 3378
 3379    \brief この関数はOptions構造体のcloseNotify、connReset、またはsentNotifyメンバのシャットダウン条件をチェックします。Options構造体はWOLFSSL構造体内にあります。
 3380
 3381    \return 1 SSL_SENT_SHUTDOWNが返されます。
 3382    \return 2 SSL_RECEIVED_SHUTDOWNが返されます。
 3383
 3384    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体への定数ポインタ。
 3385
 3386    _Example_
 3387    \code
 3388    #include <wolfssl/ssl.h>
 3389
 3390    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol method );
 3391    WOLFSSL* ssl = WOLFSSL_new(ctx);
 3392    …
 3393    int ret;
 3394    ret = wolfSSL_get_shutdown(ssl);
 3395
 3396    if(ret == 1){
 3397	    // SSL_SENT_SHUTDOWN
 3398    } else if(ret == 2){
 3399	    // SSL_RECEIVED_SHUTDOWN
 3400    } else {
 3401	    // 致命的エラー。
 3402    }
 3403    \endcode
 3404
 3405    \sa wolfSSL_SESSION_free
 3406*/
 3407int  wolfSSL_get_shutdown(const WOLFSSL* ssl);
 3408
 3409/*!
 3410    \ingroup IO
 3411
 3412    \brief この関数はoptions構造体のresumingメンバを返します。このフラグはセッションを再利用するかどうかを示します。再利用しない場合、新しいセッションを確立する必要があります。
 3413
 3414    \return この関数はセッション再利用のフラグを表すOptions構造体に保持されたint型を返します。
 3415
 3416    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3417
 3418    _Example_
 3419    \code
 3420    WOLFSSL* ssl = wolfSSL_new(ctx);
 3421    …
 3422    if(!wolfSSL_session_reused(sslResume)){
 3423	    // セッション再利用は許可されていません。
 3424    }
 3425    \endcode
 3426
 3427    \sa wolfSSL_SESSION_free
 3428    \sa wolfSSL_GetSessionIndex
 3429    \sa wolfSSL_memsave_session_cache
 3430*/
 3431int  wolfSSL_session_reused(WOLFSSL* ssl);
 3432
 3433/*!
 3434    \ingroup TLS
 3435
 3436    \brief この関数は接続が確立されているかどうかをチェックします。
 3437
 3438    \return 0 接続が確立されていない場合に返されます、つまりWOLFSSL構造体がNULLまたはハンドシェイクが完了していない場合。
 3439    \return 1 接続が確立されている場合に返されます、つまりWOLFSSLハンドシェイクが完了している場合。
 3440
 3441    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3442
 3443    _EXAMPLE_
 3444    \code
 3445    #include <wolfssl/ssl.h>
 3446
 3447    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 3448    WOLFSSL* ssl = wolfSSL_new(ctx);
 3449    ...
 3450    if(wolfSSL_is_init_finished(ssl)){
 3451	    // ハンドシェイクが完了し、接続が確立されています
 3452    }
 3453    \endcode
 3454
 3455    \sa wolfSSL_set_accept_state
 3456    \sa wolfSSL_get_keys
 3457    \sa wolfSSL_set_shutdown
 3458*/
 3459int  wolfSSL_is_init_finished(const WOLFSSL* ssl);
 3460
 3461/*!
 3462    \ingroup IO
 3463
 3464    \brief 使用されているSSLバージョンを文字列として返します。
 3465
 3466    \return "SSLv3" SSLv3を使用しています
 3467    \return "TLSv1" TLSv1を使用しています
 3468    \return "TLSv1.1" TLSv1.1を使用しています
 3469    \return "TLSv1.2" TLSv1.2を使用しています
 3470    \return "TLSv1.3" TLSv1.3を使用しています
 3471    \return "DTLS" DTLSを使用しています
 3472    \return "DTLSv1.2" DTLSv1.2を使用しています
 3473    \return "unknown" 使用されているTLSのバージョンを判定する際に問題が発生しました。
 3474
 3475    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3476
 3477    _Example_
 3478    \code
 3479    wolfSSL_Init();
 3480    WOLFSSL_CTX* ctx;
 3481    WOLFSSL* ssl;
 3482    WOLFSSL_METHOD method = // 何らかのwolfSSLメソッド
 3483    ctx = wolfSSL_CTX_new(method);
 3484    ssl = wolfSSL_new(ctx);
 3485    printf(wolfSSL_get_version("Using version: %s", ssl));
 3486    \endcode
 3487
 3488    \sa wolfSSL_lib_version
 3489*/
 3490const char*  wolfSSL_get_version(WOLFSSL* ssl);
 3491
 3492/*!
 3493    \ingroup IO
 3494
 3495    \brief sslセッションが使用している現在の暗号スイートを返します。
 3496
 3497    \return ssl->options.cipherSuite 現在の暗号スイートを表す整数。
 3498    \return 0 提供されたsslセッションがnullです。
 3499
 3500    \param ssl チェックするSSLセッション。
 3501
 3502    _Example_
 3503    \code
 3504    wolfSSL_Init();
 3505    WOLFSSL_CTX* ctx;
 3506    WOLFSSL* ssl;
 3507    WOLFSSL_METHOD method = // 何らかのwolfSSLメソッド
 3508    ctx = wolfSSL_CTX_new(method);
 3509    ssl = wolfSSL_new(ctx);
 3510
 3511    if(wolfSSL_get_current_cipher_suite(ssl) == 0)
 3512    {
 3513        // 暗号スイートの取得エラー
 3514    }
 3515    \endcode
 3516
 3517    \sa wolfSSL_CIPHER_get_name
 3518    \sa wolfSSL_get_current_cipher
 3519    \sa wolfSSL_get_cipher_list
 3520*/
 3521int  wolfSSL_get_current_cipher_suite(WOLFSSL* ssl);
 3522
 3523/*!
 3524    \ingroup IO
 3525
 3526    \brief この関数はsslセッション内の現在の暗号へのポインタを返します。
 3527
 3528    \return この関数はWOLFSSL構造体のcipherメンバのアドレスを返します。これはWOLFSSL_CIPHER構造体へのポインタです。
 3529    \return NULL WOLFSSL構造体がNULLの場合に返されます。
 3530
 3531    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3532
 3533    _Example_
 3534    \code
 3535    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 3536    WOLFSSL* ssl = wolfSSL_new(ctx);
 3537    …
 3538    WOLFSSL_CIPHER* cipherCurr = wolfSSL_get_current_cipher;
 3539
 3540    if(!cipherCurr){
 3541    	// 失敗ケース。
 3542    } else {
 3543    	// 暗号がcipherCurrに返されました
 3544    }
 3545    \endcode
 3546
 3547    \sa wolfSSL_get_cipher
 3548    \sa wolfSSL_get_cipher_name_internal
 3549    \sa wolfSSL_get_cipher_name
 3550*/
 3551WOLFSSL_CIPHER*  wolfSSL_get_current_cipher(WOLFSSL* ssl);
 3552
 3553/*!
 3554    \ingroup IO
 3555
 3556    \brief この関数はSSLオブジェクト内の暗号スイートを利用可能なスイートと照合し、文字列表現を返します。
 3557
 3558    \return string この関数は一致した暗号スイートの文字列表現を返します。
 3559    \return none 一致するスイートがない場合は"None"を返します。
 3560
 3561    \param cipher WOLFSSL_CIPHER構造体への定数ポインタ。
 3562
 3563    _Example_
 3564    \code
 3565    // DHE_RSA ...の形式で暗号名を取得します
 3566    const char* wolfSSL_get_cipher_name_internal(WOLFSSL* ssl){
 3567	WOLFSSL_CIPHER* cipher;
 3568	const char* fullName;
 3569    …
 3570	cipher = wolfSSL_get_curent_cipher(ssl);
 3571	fullName = wolfSSL_CIPHER_get_name(cipher);
 3572
 3573	if(fullName){
 3574		// 返された暗号の健全性チェック
 3575	}
 3576    \endcode
 3577
 3578    \sa wolfSSL_get_cipher
 3579    \sa wolfSSL_get_current_cipher
 3580    \sa wolfSSL_get_cipher_name_internal
 3581    \sa wolfSSL_get_cipher_name
 3582*/
 3583const char*  wolfSSL_CIPHER_get_name(const WOLFSSL_CIPHER* cipher);
 3584
 3585/*!
 3586    \ingroup IO
 3587
 3588    \brief この関数はSSLオブジェクト内の暗号スイートを利用可能なスイートと照合します。
 3589
 3590    \return この関数は一致したスイートの文字列値を返します。一致するスイートがない場合は"None"を返します。
 3591
 3592    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 3593
 3594    _Example_
 3595    \code
 3596    #ifdef WOLFSSL_DTLS
 3597    …
 3598    // 有効なスイートが使用されていることを確認
 3599    if(wolfSSL_get_cipher(ssl) == NULL){
 3600	    WOLFSSL_MSG("インポートされた暗号スイートと一致しません");
 3601	    return MATCH_SUITE_ERROR;
 3602    }
 3603    …
 3604    #endif // WOLFSSL_DTLS
 3605    \endcode
 3606
 3607    \sa wolfSSL_CIPHER_get_name
 3608    \sa wolfSSL_get_current_cipher
 3609*/
 3610const char*  wolfSSL_get_cipher(WOLFSSL*);
 3611
 3612/*!
 3613    \ingroup Setup
 3614
 3615    \brief この関数はWOLFSSL構造体からWOLFSSL_SESSIONを参照型として返します。これにはwolfSSL_SESSION_freeを呼び出してセッション参照を解放する必要があります。指されるWOLFSSL_SESSIONには、セッション再開を実行し、新しいハンドシェイクなしで接続を再確立するために必要なすべての情報が含まれています。セッション再開のために、セッションオブジェクトでwolfSSL_shutdown()を呼び出す前に、アプリケーションはwolfSSL_get1_session()の呼び出しでオブジェクトからセッションIDを保存する必要があります、これはセッションへのポインタを返します。後で、アプリケーションは新しいWOLFSSLオブジェクトを作成し、wolfSSL_set_session()で保存されたセッションを割り当てる必要があります。この時点で、アプリケーションはwolfSSL_connect()を呼び出すことができ、wolfSSLはセッションの再開を試みます。wolfSSLサーバーコードはデフォルトでセッション再開を許可します。wolfSSL_get1_session()によって返されたオブジェクトは、アプリケーションが使用を終えた後、wolfSSL_SESSION_free()を呼び出すことによって解放する必要があります。
 3616
 3617    \return WOLFSSL_SESSION 成功時にセッションポインタを返します。
 3618    \return NULL sslがNULL、SSLセッションキャッシュが無効、wolfSSLがセッションIDを利用できない、またはmutex関数が失敗した場合に返されます。
 3619
 3620    \param ssl セッションを取得するWOLFSSL構造体。
 3621
 3622    _Example_
 3623    \code
 3624    WOLFSSL* ssl;
 3625    WOLFSSL_SESSION* ses;    // ハンドシェイクを試行/完了
 3626    wolfSSL_connect(ssl);
 3627    ses  = wolfSSL_get1_session(ssl);
 3628    // ses情報を確認
 3629    // 切断/新しいSSLインスタンスをセットアップ
 3630    wolfSSL_set_session(ssl, ses);
 3631    // ハンドシェイクを試行/再開
 3632    wolfSSL_SESSION_free(ses);
 3633    \endcode
 3634
 3635    \sa wolfSSL_new
 3636    \sa wolfSSL_free
 3637    \sa wolfSSL_SESSION_free
 3638*/
 3639WOLFSSL_SESSION* wolfSSL_get1_session(WOLFSSL* ssl);
 3640
 3641/*!
 3642    \ingroup Setup
 3643
 3644    \brief wolfSSLv23_client_method()関数は、アプリケーションがクライアントであり、SSL 3.0からTLS 1.3までの間でサーバがサポートする最も高いプロトコルバージョンをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいWOLFSSL_METHOD構造体のためのメモリを割り当て、初期化します。wolfSSLのクライアントとサーバの両方は、堅牢なバージョンダウングレード機能を持っています。どちらか一方で特定のプロトコルバージョンメソッドが使用された場合、そのバージョンのみがネゴシエートされるか、エラーが返されます。例えば、TLSv1を使用するクライアントがSSLv3のみのサーバに接続しようとすると失敗し、同様にTLSv1.1への接続も失敗します。この問題を解決するために、wolfSSLv23_client_method()関数を使用するクライアントは、サーバがサポートする最も高いプロトコルバージョンを使用し、必要に応じてSSLv3までダウングレードします。この場合、クライアントはSSLv3からTLSv1.3までを実行しているサーバに接続できます。
 3645
 3646    \return pointer 成功時、WOLFSSL_METHODへのポインタ。
 3647    \return Failure XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
 3648
 3649    \param none パラメータなし。
 3650
 3651    _Example_
 3652    \code
 3653    WOLFSSL_METHOD* method;
 3654    WOLFSSL_CTX* ctx;
 3655    method = wolfSSLv23_client_method();
 3656    if (method == NULL) {
 3657	    // メソッドを取得できませんでした
 3658    }
 3659
 3660    ctx = wolfSSL_CTX_new(method);
 3661    ...
 3662    \endcode
 3663
 3664    \sa wolfSSLv3_client_method
 3665    \sa wolfTLSv1_client_method
 3666    \sa wolfTLSv1_1_client_method
 3667    \sa wolfTLSv1_2_client_method
 3668    \sa wolfTLSv1_3_client_method
 3669    \sa wolfDTLSv1_client_method
 3670    \sa wolfSSL_CTX_new
 3671*/
 3672WOLFSSL_METHOD* wolfSSLv23_client_method(void);
 3673
 3674/*!
 3675    \ingroup IO
 3676
 3677    \brief これは、内部メモリバッファの先頭にバイトポインタを設定するために使用されます。
 3678
 3679    \return size 成功時、バッファのサイズが返されます。
 3680    \return SSL_FATAL_ERROR エラーケースが発生した場合。
 3681
 3682    \param bio メモリバッファを取得するWOLFSSL_BIO構造体。
 3683    \param p メモリバッファに設定するバイトポインタ。
 3684
 3685    _Example_
 3686    \code
 3687    WOLFSSL_BIO* bio;
 3688    const byte* p;
 3689    int ret;
 3690    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
 3691    ret  = wolfSSL_BIO_get_mem_data(bio, &p);
 3692    // ret値を確認
 3693    \endcode
 3694
 3695    \sa wolfSSL_BIO_new
 3696    \sa wolfSSL_BIO_s_mem
 3697    \sa wolfSSL_BIO_set_fp
 3698    \sa wolfSSL_BIO_free
 3699*/
 3700int wolfSSL_BIO_get_mem_data(WOLFSSL_BIO* bio,void* p);
 3701
 3702/*!
 3703    \ingroup IO
 3704
 3705    \brief bioが使用するファイルディスクリプタを設定します。
 3706
 3707    \return SSL_SUCCESS(1) 成功時。
 3708
 3709    \param bio fdを設定するWOLFSSL_BIO構造体。
 3710    \param fd 使用するファイルディスクリプタ。
 3711    \param closeF fdをクローズする際の動作フラグ。
 3712
 3713    _Example_
 3714    \code
 3715    WOLFSSL_BIO* bio;
 3716    int fd;
 3717    // bioをセットアップ
 3718    wolfSSL_BIO_set_fd(bio, fd, BIO_NOCLOSE);
 3719    \endcode
 3720
 3721    \sa wolfSSL_BIO_new
 3722    \sa wolfSSL_BIO_free
 3723*/
 3724long wolfSSL_BIO_set_fd(WOLFSSL_BIO* b, int fd, int flag);
 3725
 3726/*!
 3727    \ingroup IO
 3728
 3729    \brief クローズフラグを設定します。これは、BIOが解放される際にI/Oストリームをクローズすべきかを示すために使用されます。
 3730
 3731    \return SSL_SUCCESS(1) 成功時。
 3732
 3733    \param bio WOLFSSL_BIO構造体。
 3734    \param flag I/Oストリームをクローズする際の動作フラグ。
 3735
 3736    _Example_
 3737    \code
 3738    WOLFSSL_BIO* bio;
 3739    // bioをセットアップ
 3740    wolfSSL_BIO_set_close(bio, BIO_NOCLOSE);
 3741    \endcode
 3742
 3743    \sa wolfSSL_BIO_new
 3744    \sa wolfSSL_BIO_free
 3745*/
 3746int wolfSSL_BIO_set_close(WOLFSSL_BIO *b, long flag);
 3747
 3748/*!
 3749    \ingroup IO
 3750
 3751    \brief これは、BIO_SOCKETタイプのWOLFSSL_BIO_METHODを取得するために使用されます。
 3752
 3753    \return WOLFSSL_BIO_METHOD ソケットタイプであるWOLFSSL_BIO_METHOD構造体へのポインタ。
 3754
 3755    \param none パラメータなし。
 3756
 3757    _Example_
 3758    \code
 3759    WOLFSSL_BIO* bio;
 3760    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_socket);
 3761    \endcode
 3762
 3763    \sa wolfSSL_BIO_new
 3764    \sa wolfSSL_BIO_s_mem
 3765*/
 3766WOLFSSL_BIO_METHOD *wolfSSL_BIO_s_socket(void);
 3767
 3768/*!
 3769    \ingroup IO
 3770
 3771    \brief これは、WOLFSSL_BIOの書き込みバッファのサイズを設定するために使用されます。書き込みバッファが以前に設定されていた場合、この関数はサイズをリセットする際にそれを解放します。これは、読み取りと書き込みのインデックスを0にリセットする点でwolfSSL_BIO_resetに似ています。
 3772
 3773    \return SSL_SUCCESS 書き込みバッファの設定に成功した場合。
 3774    \return SSL_FAILURE エラーケースが発生した場合。
 3775
 3776    \param bio fdを設定するWOLFSSL_BIO構造体。
 3777    \param size 割り当てるバッファのサイズ。
 3778
 3779    _Example_
 3780    \code
 3781    WOLFSSL_BIO* bio;
 3782    int ret;
 3783    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
 3784    ret = wolfSSL_BIO_set_write_buf_size(bio, 15000);
 3785    // 戻り値を確認
 3786    \endcode
 3787
 3788    \sa wolfSSL_BIO_new
 3789    \sa wolfSSL_BIO_s_mem
 3790    \sa wolfSSL_BIO_free
 3791*/
 3792int  wolfSSL_BIO_set_write_buf_size(WOLFSSL_BIO *b, long size);
 3793
 3794/*!
 3795    \ingroup IO
 3796
 3797    \brief これは、2つのbioをペアにするために使用されます。ペアになったbioは双方向パイプのように動作し、一方への書き込みはもう一方から読み取ることができ、その逆も同様です。両方のbioが同じスレッドにあることが期待されます。この関数はスレッドセーフではありません。2つのbioのうちの1つを解放すると、両方のペアが解除されます。いずれかのbioに書き込みバッファサイズが以前に設定されていなかった場合、ペアになる前にデフォルトサイズの17000(WOLFSSL_BIO_SIZE)に設定されます。
 3798
 3799    \return SSL_SUCCESS 2つのbioのペア化に成功した場合。
 3800    \return SSL_FAILURE エラーケースが発生した場合。
 3801
 3802    \param b1 ペアを設定するWOLFSSL_BIO構造体。
 3803    \param b2 ペアを完成させる2番目のWOLFSSL_BIO構造体。
 3804
 3805    _Example_
 3806    \code
 3807    WOLFSSL_BIO* bio;
 3808    WOLFSSL_BIO* bio2;
 3809    int ret;
 3810    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_bio());
 3811    bio2 = wolfSSL_BIO_new(wolfSSL_BIO_s_bio());
 3812    ret = wolfSSL_BIO_make_bio_pair(bio, bio2);
 3813    // ret値を確認
 3814    \endcode
 3815
 3816    \sa wolfSSL_BIO_new
 3817    \sa wolfSSL_BIO_s_mem
 3818    \sa wolfSSL_BIO_free
 3819*/
 3820int  wolfSSL_BIO_make_bio_pair(WOLFSSL_BIO *b1, WOLFSSL_BIO *b2);
 3821
 3822/*!
 3823    \ingroup IO
 3824
 3825    \brief これは、読み取り要求フラグを0に戻すために使用されます。
 3826
 3827    \return SSL_SUCCESS 値の設定に成功した場合。
 3828    \return SSL_FAILURE エラーケースが発生した場合。
 3829
 3830    \param b 読み取り要求フラグを設定するWOLFSSL_BIO構造体。
 3831
 3832    _Example_
 3833    \code
 3834    WOLFSSL_BIO* bio;
 3835    int ret;
 3836    ...
 3837    ret = wolfSSL_BIO_ctrl_reset_read_request(bio);
 3838    // ret値を確認
 3839    \endcode
 3840
 3841    \sa wolfSSL_BIO_new, wolfSSL_BIO_s_mem
 3842    \sa wolfSSL_BIO_new, wolfSSL_BIO_free
 3843*/
 3844int  wolfSSL_BIO_ctrl_reset_read_request(WOLFSSL_BIO *b);
 3845
 3846/*!
 3847    \ingroup IO
 3848
 3849    \brief これは、読み取り用のバッファポインタを取得するために使用されます。wolfSSL_BIO_nreadとは異なり、内部読み取りインデックスは関数呼び出しから返される数だけ進められません。返される値を超えて読み取ると、配列の境界外を読み取る結果になる可能性があります。
 3850
 3851    \return ＞=0 成功時、読み取るバイト数を返します。
 3852
 3853    \param bio 読み取るWOLFSSL_BIO構造体。
 3854    \param buf 読み取り配列の先頭に設定するポインタ。
 3855
 3856    _Example_
 3857    \code
 3858    WOLFSSL_BIO* bio;
 3859    char* bufPt;
 3860    int ret;
 3861    // bioをセットアップ
 3862    ret = wolfSSL_BIO_nread0(bio, &bufPt); // 可能な限り多くのバイトを読み取り
 3863    // 負のret値を確認
 3864    // bufPtからretバイトを読み取り
 3865    \endcode
 3866
 3867    \sa wolfSSL_BIO_new
 3868*/
 3869int  wolfSSL_BIO_nread0(WOLFSSL_BIO *bio, char **buf);
 3870
 3871/*!
 3872    \ingroup IO
 3873
 3874    \brief これは、読み取り用のバッファポインタを取得するために使用されます。内部読み取りインデックスは、関数呼び出しから返される数だけ進められ、bufは読み取るバッファの先頭を指します。読み取りバッファ内のバイト数がnumで要求された値より少ない場合、より小さい値が返されます。返される値を超えて読み取ると、配列の境界外を読み取る結果になる可能性があります。
 3875
 3876    \return ＞=0 成功時、読み取るバイト数を返します。
 3877    \return WOLFSSL_BIO_ERROR(-1) 読み取るものがない場合のエラーケースで-1を返します。
 3878
 3879    \param bio 読み取るWOLFSSL_BIO構造体。
 3880    \param buf 読み取り配列の先頭に設定するポインタ。
 3881    \param num 読み取りを試みるバイト数。
 3882
 3883    _Example_
 3884    \code
 3885    WOLFSSL_BIO* bio;
 3886    char* bufPt;
 3887    int ret;
 3888
 3889    // bioをセットアップ
 3890    ret = wolfSSL_BIO_nread(bio, &bufPt, 10); // 10バイトの読み取りを試行
 3891    // 負のret値を確認
 3892    // bufPtからretバイトを読み取り
 3893    \endcode
 3894
 3895    \sa wolfSSL_BIO_new
 3896    \sa wolfSSL_BIO_nwrite
 3897*/
 3898int  wolfSSL_BIO_nread(WOLFSSL_BIO *bio, char **buf, int num);
 3899
 3900/*!
 3901    \ingroup IO
 3902
 3903    \brief 関数が返す数だけのバイトを書き込むためのバッファへのポインタを取得します。返される値よりも多くのバイトを返されたポインタに書き込むと、境界外への書き込みになる可能性があります。
 3904
 3905    \return int バッファポインタに書き込むことができるバイト数を返します。
 3906    \return WOLFSSL_BIO_UNSET(-2) bioペアの一部ではない場合。
 3907    \return WOLFSSL_BIO_ERROR(-1) 書き込むスペースがこれ以上ない場合。
 3908
 3909    \param bio 書き込むWOLFSSL_BIO構造体。
 3910    \param buf 書き込むバッファへのポインタ。
 3911    \param num 書き込みたいバイト数。
 3912
 3913    _Example_
 3914    \code
 3915    WOLFSSL_BIO* bio;
 3916    char* bufPt;
 3917    int ret;
 3918    // bioをセットアップ
 3919    ret = wolfSSL_BIO_nwrite(bio, &bufPt, 10); // 10バイトの書き込みを試行
 3920    // 負のret値を確認
 3921    // bufPtにretバイトを書き込み
 3922    \endcode
 3923
 3924    \sa wolfSSL_BIO_new
 3925    \sa wolfSSL_BIO_free
 3926    \sa wolfSSL_BIO_nread
 3927*/
 3928int  wolfSSL_BIO_nwrite(WOLFSSL_BIO *bio, char **buf, int num);
 3929
 3930/*!
 3931    \ingroup IO
 3932
 3933    \brief bioを初期状態にリセットします。例えば、BIO_BIOタイプの場合、これは読み取りと書き込みのインデックスをリセットします。
 3934
 3935    \return 0 bioのリセットに成功した場合。
 3936    \return WOLFSSL_BIO_ERROR(-1) 不正な入力またはリセットに失敗した場合に返されます。
 3937
 3938    \param bio リセットするWOLFSSL_BIO構造体。
 3939
 3940    _Example_
 3941    \code
 3942    WOLFSSL_BIO* bio;
 3943    // bioをセットアップ
 3944    wolfSSL_BIO_reset(bio);
 3945    //ptを使用
 3946    \endcode
 3947
 3948    \sa wolfSSL_BIO_new
 3949    \sa wolfSSL_BIO_free
 3950*/
 3951int  wolfSSL_BIO_reset(WOLFSSL_BIO *bio);
 3952
 3953/*!
 3954    \ingroup IO
 3955
 3956    \brief この関数は、ファイルポインタを指定されたオフセットに調整します。これはファイルの先頭からのオフセットです。
 3957
 3958    \return 0 シークに成功した場合。
 3959    \return -1 エラーケースが発生した場合。
 3960
 3961    \param bio 設定するWOLFSSL_BIO構造体。
 3962    \param ofs ファイルへのオフセット。
 3963
 3964    _Example_
 3965    \code
 3966    WOLFSSL_BIO* bio;
 3967    XFILE fp;
 3968    int ret;
 3969    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
 3970    ret  = wolfSSL_BIO_set_fp(bio, &fp);
 3971    // ret値を確認
 3972    ret  = wolfSSL_BIO_seek(bio, 3);
 3973    // ret値を確認
 3974    \endcode
 3975
 3976    \sa wolfSSL_BIO_new
 3977    \sa wolfSSL_BIO_s_mem
 3978    \sa wolfSSL_BIO_set_fp
 3979    \sa wolfSSL_BIO_free
 3980*/
 3981int  wolfSSL_BIO_seek(WOLFSSL_BIO *bio, int ofs);/*!
 3982    \ingroup IO
 3983
 3984    \brief ファイルを設定し、書き込むために使用されます。ファイル内の既存データを上書きし、bioが解放される際にファイルを閉じるよう設定されます。
 3985
 3986    \return SSL_SUCCESS ファイルのオープンと設定が成功した場合。
 3987    \return SSL_FAILURE エラーが発生した場合。
 3988
 3989    \param bio ファイルを設定するWOLFSSL_BIO構造体。
 3990    \param name 書き込み先のファイル名。
 3991
 3992    _Example_
 3993    \code
 3994    WOLFSSL_BIO* bio;
 3995    int ret;
 3996    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
 3997    ret  = wolfSSL_BIO_write_filename(bio, "test.txt");
 3998    // ret値を確認
 3999    \endcode
 4000
 4001    \sa wolfSSL_BIO_new
 4002    \sa wolfSSL_BIO_s_file
 4003    \sa wolfSSL_BIO_set_fp
 4004    \sa wolfSSL_BIO_free
 4005*/
 4006int  wolfSSL_BIO_write_filename(WOLFSSL_BIO *bio, char *name);
 4007
 4008/*!
 4009    \ingroup IO
 4010
 4011    \brief ファイル終端値を設定するために使用されます。一般的な値は-1で、期待される正の値と混同しないようにします。
 4012
 4013    \return 0 完了時に返されます。
 4014
 4015    \param bio ファイル終端値を設定するWOLFSSL_BIO構造体。
 4016    \param v bioに設定する値。
 4017
 4018    _Example_
 4019    \code
 4020    WOLFSSL_BIO* bio;
 4021    int ret;
 4022    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
 4023    ret  = wolfSSL_BIO_set_mem_eof_return(bio, -1);
 4024    // ret値を確認
 4025    \endcode
 4026
 4027    \sa wolfSSL_BIO_new
 4028    \sa wolfSSL_BIO_s_mem
 4029    \sa wolfSSL_BIO_set_fp
 4030    \sa wolfSSL_BIO_free
 4031*/
 4032long wolfSSL_BIO_set_mem_eof_return(WOLFSSL_BIO *bio, int v);
 4033
 4034/*!
 4035    \ingroup IO
 4036
 4037    \brief WOLFSSL_BIOメモリポインタのgetter関数です。
 4038
 4039    \return SSL_SUCCESS ポインタの取得に成功した場合、SSL_SUCCESSが返されます(現在の値は1)。
 4040    \return SSL_FAILURE NULL引数が渡された場合に返されます(現在の値は0)。
 4041
 4042    \param bio メモリポインタを取得するためのWOLFSSL_BIO構造体へのポインタ。
 4043    \param ptr 現在char*である構造体。bioのメモリを指すように設定されます。
 4044
 4045    _Example_
 4046    \code
 4047    WOLFSSL_BIO* bio;
 4048    WOLFSSL_BUF_MEM* pt;
 4049    // bioをセットアップ
 4050    wolfSSL_BIO_get_mem_ptr(bio, &pt);
 4051    // ptを使用
 4052    \endcode
 4053
 4054    \sa wolfSSL_BIO_new
 4055    \sa wolfSSL_BIO_s_mem
 4056*/
 4057long wolfSSL_BIO_get_mem_ptr(WOLFSSL_BIO *bio, WOLFSSL_BUF_MEM **m);
 4058
 4059/*!
 4060    \ingroup CertsKeys
 4061
 4062    \brief この関数はx509の名前をバッファにコピーします。
 4063
 4064    \return 関数が正常に実行された場合、WOLFSSL_X509_NAME構造体のnameメンバーのデータを持つバッファへのcharポインタが返されます。
 4065
 4066    \param name WOLFSSL_X509構造体へのポインタ。
 4067    \param in WOLFSSL_X509_NAME構造体からコピーされた名前を保持するバッファ。
 4068    \param sz バッファの最大サイズ。
 4069
 4070    _Example_
 4071    \code
 4072    WOLFSSL_X509 x509;
 4073    char* name;
 4074    ...
 4075    name = wolfSSL_X509_NAME_oneline(wolfSSL_X509_get_issuer_name(x509), 0, 0);
 4076
 4077    if(name <= 0){
 4078    	// バッファに何もありません
 4079    }
 4080    \endcode
 4081
 4082    \sa wolfSSL_X509_get_subject_name
 4083    \sa wolfSSL_X509_get_issuer_name
 4084    \sa wolfSSL_X509_get_isCA
 4085    \sa wolfSSL_get_peer_certificate
 4086    \sa wolfSSL_X509_version
 4087*/
 4088char*       wolfSSL_X509_NAME_oneline(WOLFSSL_X509_NAME* name, char* in, int sz);
 4089
 4090/*!
 4091    \ingroup CertsKeys
 4092
 4093    \brief この関数は証明書の発行者名を返します。
 4094
 4095    \return point 渡されたcertがNULLでない場合、WOLFSSL_X509構造体のissuerメンバーへのポインタが返されます。
 4096    \return NULL 渡されたcertがNULLの場合。
 4097
 4098    \param cert WOLFSSL_X509構造体へのポインタ。
 4099
 4100    _Example_
 4101    \code
 4102    WOLFSSL_X509* x509;
 4103    WOLFSSL_X509_NAME issuer;
 4104    ...
 4105    issuer = wolfSSL_X509_NAME_oneline(wolfSSL_X509_get_issuer_name(x509), 0, 0);
 4106
 4107    if(!issuer){
 4108    	// NULLが返されました
 4109    } else {
 4110    	// issuerは証明書の発行者名を保持しています
 4111    }
 4112    \endcode
 4113
 4114    \sa wolfSSL_X509_get_subject_name
 4115    \sa wolfSSL_X509_get_isCA
 4116    \sa wolfSSL_get_peer_certificate
 4117    \sa wolfSSL_X509_NAME_oneline
 4118*/
 4119WOLFSSL_X509_NAME*  wolfSSL_X509_get_issuer_name(WOLFSSL_X509* cert);
 4120
 4121/*!
 4122    \ingroup CertsKeys
 4123
 4124    \brief この関数はWOLFSSL_X509構造体のsubjectメンバーを返します。
 4125
 4126    \return pointer WOLFSSL_X509_NAME構造体へのポインタ。WOLFSSL_X509構造体がNULLの場合、または構造体のsubjectメンバーがNULLの場合、ポインタはNULLになる可能性があります。
 4127
 4128    \param cert WOLFSSL_X509構造体へのポインタ。
 4129
 4130    _Example_
 4131    \code
 4132    WOLFSSL_X509* cert;
 4133    WOLFSSL_X509_NAME name;
 4134    …
 4135    name = wolfSSL_X509_get_subject_name(cert);
 4136    if(name == NULL){
 4137	    // NULLケースを処理
 4138    }
 4139    \endcode
 4140
 4141    \sa wolfSSL_X509_get_issuer_name
 4142    \sa wolfSSL_X509_get_isCA
 4143    \sa wolfSSL_get_peer_certificate
 4144*/
 4145WOLFSSL_X509_NAME*  wolfSSL_X509_get_subject_name(WOLFSSL_X509* cert);
 4146
 4147/*!
 4148    \ingroup CertsKeys
 4149
 4150    \brief WOLFSSL_X509構造体のisCaメンバーをチェックし、その値を返します。
 4151
 4152    \return isCA WOLFSSL_X509構造体のisCaメンバーの値が返されます。
 4153    \return 0 有効なx509構造体が渡されなかった場合に返されます。
 4154
 4155    \param x509 WOLFSSL_X509構造体へのポインタ。
 4156
 4157    _Example_
 4158    \code
 4159    WOLFSSL* ssl;
 4160    ...
 4161    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 4162    WOLFSSL* ssl = wolfSSL_new(ctx);
 4163    ...
 4164    if(wolfSSL_X509_get_isCA(ssl)){
 4165    	// これはCAです
 4166    }else {
 4167    	// 失敗ケース
 4168    }
 4169    \endcode
 4170
 4171    \sa wolfSSL_X509_get_issuer_name
 4172    \sa wolfSSL_X509_get_isCA
 4173*/
 4174int  wolfSSL_X509_get_isCA(WOLFSSL_X509* x509);
 4175
 4176/*!
 4177    \ingroup CertsKeys
 4178
 4179    \brief この関数は渡されたNID値に関連するテキストを取得します。
 4180
 4181    \return int テキストバッファのサイズを返します。
 4182
 4183    \param name テキストを検索するWOLFSSL_X509_NAME。
 4184    \param nid 検索するNID。
 4185    \param buf 見つかったテキストを保持するバッファ。
 4186    \param len バッファの長さ。
 4187
 4188    _Example_
 4189    \code
 4190    WOLFSSL_X509_NAME* name;
 4191    char buffer[100];
 4192    int bufferSz;
 4193    int ret;
 4194    // WOLFSSL_X509_NAMEを取得
 4195    ret = wolfSSL_X509_NAME_get_text_by_NID(name, NID_commonName,
 4196    buffer, bufferSz);
 4197
 4198    // ret値を確認
 4199    \endcode
 4200
 4201    \sa none
 4202*/
 4203int wolfSSL_X509_NAME_get_text_by_NID(WOLFSSL_X509_NAME* name, int nid,
 4204                                      char* buf, int len);
 4205
 4206/*!
 4207    \ingroup CertsKeys
 4208
 4209    \brief この関数はWOLFSSL_X509構造体のsigOIDメンバーに格納されている値を返します。
 4210
 4211    \return 0 WOLFSSL_X509構造体がNULLの場合に返されます。
 4212    \return int x509オブジェクトから取得された整数値が返されます。
 4213
 4214    \param x509 WOLFSSL_X509構造体へのポインタ。
 4215
 4216    _Example_
 4217    \code
 4218    WOLFSSL_X509 x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 4219							DYNAMIC_TYPE_X509);
 4220    ...
 4221    int x509SigType = wolfSSL_X509_get_signature_type(x509);
 4222
 4223    if(x509SigType != EXPECTED){
 4224	    // 予期しない値を処理
 4225    }
 4226    \endcode
 4227
 4228    \sa wolfSSL_X509_get_signature
 4229    \sa wolfSSL_X509_version
 4230    \sa wolfSSL_X509_get_der
 4231    \sa wolfSSL_X509_get_serial_number
 4232    \sa wolfSSL_X509_notBefore
 4233    \sa wolfSSL_X509_notAfter
 4234    \sa wolfSSL_X509_free
 4235*/
 4236int wolfSSL_X509_get_signature_type(WOLFSSL_X509* x509);
 4237
 4238/*!
 4239    \brief この関数はWOLFSSL_X509構造体を解放します。
 4240
 4241    \param x509 WOLFSSL_X509構造体へのポインタ。
 4242
 4243    _Example_
 4244    \code
 4245    WOLFSSL_X509* x509 = (WOLFSSL_X509*)XMALOC(sizeof(WOLFSSL_X509), NULL,
 4246    DYNAMIC_TYPE_X509) ;
 4247
 4248    wolfSSL_X509_free(x509);
 4249
 4250    \endcode
 4251
 4252    \sa wolfSSL_X509_get_signature
 4253    \sa wolfSSL_X509_version
 4254    \sa wolfSSL_X509_get_der
 4255    \sa wolfSSL_X509_get_serial_number
 4256    \sa wolfSSL_X509_notBefore
 4257    \sa wolfSSL_X509_notAfter
 4258
 4259*/
 4260void wolfSSL_X509_free(WOLFSSL_X509* x509);
 4261
 4262/*!
 4263    \ingroup CertsKeys
 4264
 4265    \brief X509署名を取得し、バッファに格納します。
 4266
 4267    \return SSL_SUCCESS 関数が正常に実行された場合に返されます。署名はバッファに読み込まれます。
 4268    \return SSL_FATAL_ERRROR x509構造体またはbufSzメンバーがNULLの場合に返されます。sig構造体のlengthメンバー(sigはx509のメンバー)のチェックもあります。
 4269
 4270    \param x509 WOLFSSL_X509構造体へのポインタ。
 4271    \param buf バッファへのcharポインタ。
 4272    \param bufSz バッファのサイズへの整数ポインタ。
 4273
 4274    _Example_
 4275    \code
 4276    WOLFSSL_X509* x509 = (WOLFSSL_X509)XMALOC(sizeof(WOLFSSL_X509), NULL,
 4277    DYNAMIC_TYPE_X509);
 4278    unsigned char* buf; // 初期化
 4279    int* bufSz = sizeof(buf)/sizeof(unsigned char);
 4280    ...
 4281    if(wolfSSL_X509_get_signature(x509, buf, bufSz) != SSL_SUCCESS){
 4282	    // 関数は正常に実行されませんでした
 4283    } else{
 4284	    // バッファは正しく書き込まれました
 4285    }
 4286    \endcode
 4287
 4288    \sa wolfSSL_X509_get_serial_number
 4289    \sa wolfSSL_X509_get_signature_type
 4290    \sa wolfSSL_X509_get_device_type
 4291*/
 4292int wolfSSL_X509_get_signature(WOLFSSL_X509* x509, unsigned char* buf, int* bufSz);
 4293
 4294/*!
 4295    \ingroup CertsKeys
 4296
 4297    \brief この関数はWOLFSSL_X509_STORE構造体に証明書を追加します。
 4298
 4299    \return SSL_SUCCESS 証明書が正常に追加された場合。
 4300    \return SSL_FATAL_ERROR 証明書が正常に追加されなかった場合。
 4301
 4302    \param str 証明書を追加する証明書ストア。
 4303    \param x509 追加する証明書。
 4304
 4305    _Example_
 4306    \code
 4307    WOLFSSL_X509_STORE* str;
 4308    WOLFSSL_X509* x509;
 4309    int ret;
 4310    ret = wolfSSL_X509_STORE_add_cert(str, x509);
 4311    // ret値を確認
 4312    \endcode
 4313
 4314    \sa wolfSSL_X509_free
 4315*/
 4316int wolfSSL_X509_STORE_add_cert(WOLFSSL_X509_STORE* store, WOLFSSL_X509* x509);
 4317
 4318/*!
 4319    \ingroup CertsKeys
 4320
 4321    \brief この関数はWOLFSSL_X509_STORE_CTX構造体のchain変数のgetter関数です。現在、chainは入力されていません。
 4322
 4323    \return pointer 成功した場合、WOLFSSL_STACK(STACK_OF(WOLFSSL_X509)と同じ)ポインタを返します。
 4324    \return Null 失敗時。
 4325
 4326    \param ctx 解析チェーンを取得する証明書ストアコンテキスト。
 4327
 4328    _Example_
 4329    \code
 4330    WOLFSSL_STACK* sk;
 4331    WOLFSSL_X509_STORE_CTX* ctx;
 4332    sk = wolfSSL_X509_STORE_CTX_get_chain(ctx);
 4333    // skがNULLでないか確認してから使用。使用後はskを解放する必要があります
 4334    \endcode
 4335
 4336    \sa wolfSSL_sk_X509_free
 4337*/
 4338WOLFSSL_STACK* wolfSSL_X509_STORE_CTX_get_chain(
 4339                                                   WOLFSSL_X509_STORE_CTX* ctx);
 4340
 4341/*!
 4342    \ingroup CertsKeys
 4343
 4344    \brief この関数は渡されたWOLFSSL_X509_STORE構造体の動作を変更するためのフラグを受け取ります。使用されるフラグの例としてWOLFSSL_CRL_CHECKがあります。
 4345
 4346    \return SSL_SUCCESS フラグの設定時にエラーが発生しなかった場合。
 4347    \return <0 失敗時に負の値が返されます。
 4348
 4349    \param str フラグを設定する証明書ストア。
 4350    \param flag 動作のためのフラグ。
 4351
 4352    _Example_
 4353    \code
 4354    WOLFSSL_X509_STORE* str;
 4355    int ret;
 4356    // strを作成して設定
 4357    ret = wolfSSL_X509_STORE_set_flags(str, WOLFSSL_CRL_CHECKALL);
 4358    if (ret != SSL_SUCCESS) {
 4359    	//ret値を確認してエラーケースを処理する
 4360    }
 4361    \endcode
 4362
 4363    \sa wolfSSL_X509_STORE_new
 4364    \sa wolfSSL_X509_STORE_free
 4365*/
 4366int wolfSSL_X509_STORE_set_flags(WOLFSSL_X509_STORE* store,
 4367                                                            unsigned long flag);
 4368
 4369/*!
 4370    \ingroup CertsKeys
 4371
 4372    \brief この関数は、バイト配列としてエンコードされた証明書の「not before」有効期限を返します。
 4373
 4374    \return NULL WOLFSSL_X509構造体がNULLの場合に返されます。
 4375    \return byte notBeforeDataを含むバイトが返されます。
 4376
 4377    \param x509 WOLFSSL_X509構造体へのポインタ。
 4378
 4379    _Example_
 4380    \code
 4381    WOLFSSL_X509* x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 4382							DYNAMIC_TYPE_X509);
 4383    ...
 4384    byte* notBeforeData = wolfSSL_X509_notBefore(x509);
 4385
 4386
 4387    \endcode
 4388
 4389    \sa wolfSSL_X509_get_signature
 4390    \sa wolfSSL_X509_version
 4391    \sa wolfSSL_X509_get_der
 4392    \sa wolfSSL_X509_get_serial_number
 4393    \sa wolfSSL_X509_notAfter
 4394    \sa wolfSSL_X509_free
 4395*/
 4396const byte* wolfSSL_X509_notBefore(WOLFSSL_X509* x509);
 4397
 4398/*!
 4399    \ingroup CertsKeys
 4400
 4401    \brief この関数は、バイト配列としてエンコードされた証明書の「not after」有効期限を返します。
 4402
 4403    \return NULL WOLFSSL_X509構造体がNULLの場合に返されます。
 4404    \return byte notAfterDataを含むバイトが返されます。
 4405
 4406    \param x509 WOLFSSL_X509構造体へのポインタ。
 4407
 4408    _Example_
 4409    \code
 4410    WOLFSSL_X509* x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 4411							DYNAMIC_TYPE_X509);
 4412    ...
 4413    byte* notAfterData = wolfSSL_X509_notAfter(x509);
 4414
 4415
 4416    \endcode
 4417
 4418    \sa wolfSSL_X509_get_signature
 4419    \sa wolfSSL_X509_version
 4420    \sa wolfSSL_X509_get_der
 4421    \sa wolfSSL_X509_get_serial_number
 4422    \sa wolfSSL_X509_notBefore
 4423    \sa wolfSSL_X509_free
 4424*/
 4425const byte* wolfSSL_X509_notAfter(WOLFSSL_X509* x509);
 4426
 4427/*!
 4428    \ingroup Setup
 4429
 4430    \brief この関数は、WOLFSSL_ASN1_INTEGER値をWOLFSSL_BIGNUM構造体にコピーするために使用されます。
 4431
 4432    \return pointer WOLFSSL_ASN1_INTEGER値のコピーに成功すると、WOLFSSL_BIGNUMポインタが返されます。
 4433    \return Null 失敗時にはNullが返されます。
 4434
 4435    \param ai コピー元のWOLFSSL_ASN1_INTEGER構造体。
 4436    \param bn 既存のWOLFSSL_BIGNUM構造体にコピーしたい場合は、そのポインタを渡します。オプションとして、これをNULLにすることで新しいWOLFSSL_BIGNUM構造体が作成されます。
 4437
 4438    _Example_
 4439    \code
 4440    WOLFSSL_ASN1_INTEGER* ai;
 4441    WOLFSSL_BIGNUM* bn;
 4442    // aiを作成
 4443    bn = wolfSSL_ASN1_INTEGER_to_BN(ai, NULL);
 4444
 4445    // または既にbnを作成済みで構造体を再利用したい場合
 4446    // wolfSSL_ASN1_INTEGER_to_BN(ai, bn);
 4447    // bnまたは戻り値がNULLでないことを確認
 4448    \endcode
 4449
 4450    \sa none
 4451*/
 4452WOLFSSL_BIGNUM *wolfSSL_ASN1_INTEGER_to_BN(const WOLFSSL_ASN1_INTEGER *ai,
 4453                                       WOLFSSL_BIGNUM *bn);
 4454
 4455/*!
 4456    \ingroup Setup
 4457
 4458    \brief この関数は、WOLFSSL_CTX構造体内で構築中の内部チェーンに証明書を追加します。
 4459
 4460    \return SSL_SUCCESS 証明書の追加に成功した後に返されます。
 4461    \return SSL_FAILURE 証明書のチェーンへの追加に失敗した場合に返されます。
 4462
 4463    \param ctx 証明書を追加するWOLFSSL_CTX構造体。
 4464    \param x509 チェーンに追加する証明書。
 4465
 4466    _Example_
 4467    \code
 4468    WOLFSSL_CTX* ctx;
 4469    WOLFSSL_X509* x509;
 4470    int ret;
 4471    // ctxを作成
 4472    ret = wolfSSL_CTX_add_extra_chain_cert(ctx, x509);
 4473    // ret値を確認
 4474    \endcode
 4475
 4476    \sa wolfSSL_CTX_new
 4477    \sa wolfSSL_CTX_free
 4478*/
 4479long wolfSSL_CTX_add_extra_chain_cert(WOLFSSL_CTX* ctx, WOLFSSL_X509* x509);
 4480
 4481/*!
 4482    \ingroup Setup
 4483
 4484    \brief この関数は、WOLFSSL_CTX構造体からリードアヘッドフラグを取得して返します。
 4485
 4486    \return flag 成功時にはリードアヘッドフラグが返されます。
 4487    \return SSL_FAILURE ctxがNULLの場合、SSL_FAILUREが返されます。
 4488
 4489    \param ctx リードアヘッドフラグを取得するWOLFSSL_CTX構造体。
 4490
 4491    _Example_
 4492    \code
 4493    WOLFSSL_CTX* ctx;
 4494    int flag;
 4495    // ctxをセットアップ
 4496    flag = wolfSSL_CTX_get_read_ahead(ctx);
 4497    //flagを確認
 4498    \endcode
 4499
 4500    \sa wolfSSL_CTX_new
 4501    \sa wolfSSL_CTX_free
 4502    \sa wolfSSL_CTX_set_read_ahead
 4503*/
 4504int  wolfSSL_CTX_get_read_ahead(WOLFSSL_CTX* ctx);
 4505
 4506/*!
 4507    \ingroup Setup
 4508
 4509    \brief この関数は、WOLFSSL_CTX構造体内のリードアヘッドフラグを設定します。
 4510
 4511    \return SSL_SUCCESS ctxのリードアヘッドフラグが設定された場合。
 4512    \return SSL_FAILURE ctxがNULLの場合、SSL_FAILUREが返されます。
 4513
 4514    \param ctx リードアヘッドフラグを設定するWOLFSSL_CTX構造体。
 4515    \param v リードアヘッドフラグ。
 4516
 4517    _Example_
 4518    \code
 4519    WOLFSSL_CTX* ctx;
 4520    int flag;
 4521    int ret;
 4522    // ctxをセットアップ
 4523    ret = wolfSSL_CTX_set_read_ahead(ctx, flag);
 4524    // 戻り値を確認
 4525    \endcode
 4526
 4527    \sa wolfSSL_CTX_new
 4528    \sa wolfSSL_CTX_free
 4529    \sa wolfSSL_CTX_get_read_ahead
 4530*/
 4531int  wolfSSL_CTX_set_read_ahead(WOLFSSL_CTX* ctx, int v);
 4532
 4533/*!
 4534    \ingroup Setup
 4535
 4536    \brief この関数は、OCSPで使用するオプション引数を設定します。
 4537
 4538    \return SSL_FAILURE ctxまたはその証明書マネージャがNULLの場合。
 4539    \return SSL_SUCCESS 正常に設定された場合。
 4540
 4541    \param ctx ユーザー引数を設定するWOLFSSL_CTX構造体。
 4542    \param arg ユーザー引数。
 4543
 4544    _Example_
 4545    \code
 4546    WOLFSSL_CTX* ctx;
 4547    void* data;
 4548    int ret;
 4549    // ctxをセットアップ
 4550    ret = wolfSSL_CTX_set_tlsext_status_arg(ctx, data);
 4551
 4552    //ret値を確認
 4553    \endcode
 4554
 4555    \sa wolfSSL_CTX_new
 4556    \sa wolfSSL_CTX_free
 4557*/
 4558long wolfSSL_CTX_set_tlsext_status_arg(WOLFSSL_CTX* ctx, void* arg);
 4559
 4560/*!
 4561    \ingroup CertsKeys
 4562
 4563    \brief クライアント証明書と秘密鍵を選択するコールバックを設定します。
 4564
 4565    この関数は、ハンドシェイク中にクライアント証明書が要求されたときに呼び出されるコールバックをアプリケーションが登録できるようにします。コールバックは、使用する証明書と鍵を選択して提供できます。
 4566
 4567    \param ctx WOLFSSL_CTXオブジェクト。
 4568    \param cb クライアント証明書と鍵を選択するコールバック関数。
 4569
 4570    \return void
 4571
 4572    _Example_
 4573    \code
 4574    int my_client_cert_cb(WOLFSSL *ssl, WOLFSSL_X509 **x509, WOLFSSL_EVP_PKEY **pkey) { ... }
 4575    wolfSSL_CTX_set_client_cert_cb(ctx, my_client_cert_cb);
 4576    \endcode
 4577
 4578    \sa wolfSSL_CTX_set_cert_cb
 4579*/
 4580void wolfSSL_CTX_set_client_cert_cb(WOLFSSL_CTX *ctx, client_cert_cb cb);
 4581
 4582/*!
 4583    \ingroup CertsKeys
 4584
 4585    \brief 汎用証明書セットアップコールバックを設定します。
 4586
 4587    この関数は、証明書セットアップ中に呼び出されるコールバックをアプリケーションが登録できるようにします。コールバックは、カスタム証明書選択またはロードロジックを実行できます。
 4588
 4589    \param ctx WOLFSSL_CTXオブジェクト。
 4590    \param cb 証明書セットアップ用のコールバック関数。
 4591    \param arg コールバックに渡すユーザー引数。
 4592
 4593    \return void
 4594
 4595    _Example_
 4596    \code
 4597    int my_cert_setup_cb(WOLFSSL* ssl, void* arg) { ... }
 4598    wolfSSL_CTX_set_cert_cb(ctx, my_cert_setup_cb, NULL);
 4599    \endcode
 4600
 4601    \sa wolfSSL_CTX_set_client_cert_cb
 4602*/
 4603void wolfSSL_CTX_set_cert_cb(WOLFSSL_CTX* ctx, CertSetupCallback cb, void *arg);
 4604
 4605/*!
 4606    \ingroup OCSP
 4607
 4608    \brief OCSPステータス要求(OCSPステープリング)を処理するために使用されるコールバックを設定します。
 4609
 4610    この関数は、TLSハンドシェイク中にOCSPステータス要求を受信したときに呼び出されるコールバックをアプリケーションが登録できるようにします。コールバックは、ハンドシェイクにステープルされるOCSPレスポンスを提供できます。このAPIはサーバー側でのみ有用です。
 4611
 4612    \param ctx WOLFSSL_CTXオブジェクト。
 4613    \param cb OCSPステータス要求を処理するコールバック関数。
 4614
 4615    \return SSL_SUCCESS 成功時、それ以外の場合はSSL_FAILURE。
 4616
 4617    _Example_
 4618    \code
 4619    int my_ocsp_status_cb(WOLFSSL* ssl, void* arg) { ... }
 4620    wolfSSL_CTX_set_tlsext_status_cb(ctx, my_ocsp_status_cb);
 4621    \endcode
 4622
 4623    \sa wolfSSL_CTX_get_tlsext_status_cb
 4624    \sa wolfSSL_CTX_set_tlsext_status_arg
 4625*/
 4626int wolfSSL_CTX_set_tlsext_status_cb(WOLFSSL_CTX* ctx, tlsextStatusCb cb);
 4627
 4628/*!
 4629    \ingroup OCSP
 4630
 4631    \brief コンテキストに現在設定されているOCSPステータスコールバックを取得します。
 4632
 4633    \param ctx WOLFSSL_CTXオブジェクト。
 4634    \param cb コールバック関数を受け取るポインタ。
 4635
 4636    \return SSL_SUCCESS 成功時、それ以外の場合はSSL_FAILURE。
 4637
 4638    \sa wolfSSL_CTX_set_tlsext_status_cb
 4639*/
 4640int wolfSSL_CTX_get_tlsext_status_cb(WOLFSSL_CTX* ctx, tlsextStatusCb* cb);
 4641
 4642/*!
 4643    \ingroup OCSP
 4644
 4645    \brief OCSPステータスコールバックに渡される引数を設定します。
 4646
 4647    \param ctx WOLFSSL_CTXオブジェクト。
 4648    \param arg コールバックに渡すユーザー引数。
 4649
 4650    \return SSL_SUCCESS 成功時、それ以外の場合はSSL_FAILURE。
 4651
 4652    \sa wolfSSL_CTX_set_tlsext_status_cb
 4653*/
 4654long wolfSSL_CTX_set_tlsext_status_arg(WOLFSSL_CTX* ctx, void* arg);
 4655
 4656/*!
 4657    \ingroup OCSP
 4658
 4659    \brief ピアに送信(ステープル)されるOCSPレスポンスを取得します。
 4660
 4661    \param ssl WOLFSSLセッション。
 4662    \param resp レスポンスバッファを受け取るポインタ。
 4663
 4664    \return Length レスポンスの長さ、またはエラー時は負の値。
 4665
 4666    \sa wolfSSL_set_tlsext_status_ocsp_resp
 4667*/
 4668long wolfSSL_get_tlsext_status_ocsp_resp(WOLFSSL *ssl, unsigned char **resp);
 4669
 4670/*!
 4671    \ingroup OCSP
 4672
 4673    \brief ピアに送信(ステープル)されるOCSPレスポンスを設定します。
 4674
 4675    respのバッファはwolfSSLによって所有され、wolfSSLによって解放されます。アプリケーションは、この関数を呼び出した後、バッファを解放してはいけません。
 4676
 4677    \param ssl WOLFSSLセッション。
 4678    \param resp レスポンスバッファへのポインタ。
 4679    \param len レスポンスバッファの長さ。
 4680
 4681    \return SSL_SUCCESS 成功時、それ以外の場合はSSL_FAILURE。
 4682
 4683    \sa wolfSSL_get_tlsext_status_ocsp_resp
 4684*/
 4685long wolfSSL_set_tlsext_status_ocsp_resp(WOLFSSL *ssl, unsigned char *resp, int len);
 4686
 4687/*!
 4688    \ingroup OCSP
 4689
 4690    \brief TLSマルチ証明書チェーン用の複数のOCSPレスポンスを設定します。
 4691
 4692    respのバッファはwolfSSLによって所有され、wolfSSLによって解放されます。アプリケーションは、この関数を呼び出した後、バッファを解放してはいけません。
 4693
 4694    \param ssl WOLFSSLセッション。
 4695    \param resp レスポンスバッファへのポインタ。
 4696    \param len レスポンスバッファの長さ。
 4697    \param idx 証明書チェーンのインデックス。
 4698
 4699    \return SSL_SUCCESS 成功時、それ以外の場合はSSL_FAILURE。
 4700*/
 4701int wolfSSL_set_tlsext_status_ocsp_resp_multi(WOLFSSL* ssl, unsigned char *resp, int len, word32 idx);
 4702
 4703/*!
 4704    \ingroup OCSP
 4705
 4706    \brief OCSPステータスレスポンスを検証するコールバックを設定します。
 4707
 4708    OCSP検証中にピアの証明書チェーンにアクセスできるようにするため、SESSION_CERTSを有効にすることを推奨します。
 4709
 4710    \param ctx WOLFSSL_CTXオブジェクト。
 4711    \param cb コールバック関数。
 4712    \param cbArg コールバックに渡すユーザー引数。
 4713
 4714    \return void
 4715
 4716    _Example_
 4717    \code
 4718    void my_ocsp_verify_cb(WOLFSSL* ssl, int err, byte* resp, word32 respSz, word32 idx, void* arg)
 4719    {
 4720        (void)arg;
 4721        if (err == 0 && staple && stapleSz > 0) {
 4722            printf("Client: OCSP staple received, size=%u\n", stapleSz);
 4723            return 0;
 4724        }
 4725        // err != 0の場合、手動OCSPステープル検証
 4726        if (err != 0 && staple && stapleSz > 0) {
 4727            WOLFSSL_CERT_MANAGER* cm = NULL;
 4728            DecodedCert cert;
 4729            byte certInit = 0;
 4730            WOLFSSL_OCSP* ocsp = NULL;
 4731            WOLFSSL_X509_CHAIN* peerCerts;
 4732            int i;
 4733
 4734            cm = wolfSSL_CertManagerNew();
 4735            if (cm == NULL)
 4736                goto cleanup;
 4737            if (wolfSSL_CertManagerLoadCA(cm, CA_CERT, NULL) != WOLFSSL_SUCCESS)
 4738                goto cleanup;
 4739
 4740            peerCerts = wolfSSL_get_peer_chain(ssl);
 4741            if (peerCerts == NULL || wolfSSL_get_chain_count(peerCerts) <= (int)idx)
 4742                goto cleanup;
 4743
 4744            for (i = idx + 1; i < wolfSSL_get_chain_count(peerCerts); i++) {
 4745                if (wolfSSL_CertManagerLoadCABuffer(cm, wolfSSL_get_chain_cert(peerCerts, i),
 4746                        wolfSSL_get_chain_length(peerCerts, i), WOLFSSL_FILETYPE_ASN1) != WOLFSSL_SUCCESS)
 4747                    goto cleanup;
 4748            }
 4749
 4750            wc_InitDecodedCert(&cert, wolfSSL_get_chain_cert(peerCerts, idx), wolfSSL_get_chain_length(peerCerts, idx), NULL);
 4751            certInit = 1;
 4752            if (wc_ParseCert(&cert, CERT_TYPE, VERIFY, cm) != 0)
 4753                goto cleanup;
 4754            if ((ocsp = wc_NewOCSP(cm)) == NULL)
 4755                goto cleanup;
 4756            if (wc_CheckCertOcspResponse(ocsp, &cert, staple, stapleSz, NULL) != 0)
 4757                goto cleanup;
 4758
 4759            printf("Client: Manual OCSP staple verification succeeded for idx=%u\n", idx);
 4760            err = 0;
 4761    cleanup:
 4762            wc_FreeOCSP(ocsp);
 4763            if (certInit)
 4764                wc_FreeDecodedCert(&cert);
 4765            wolfSSL_CertManagerFree(cm);
 4766            if (err == 0)
 4767                return 0;
 4768            printf("Client: Manual OCSP staple verification failed for idx=%u\n", idx);
 4769        }
 4770        printf("Client: OCSP staple verify error=%d\n", err);
 4771        return err;
 4772    }
 4773    wolfSSL_CTX_set_ocsp_status_verify_cb(ctx, my_ocsp_verify_cb, NULL);
 4774    \endcode
 4775*/
 4776void wolfSSL_CTX_set_ocsp_status_verify_cb(WOLFSSL_CTX* ctx, ocspVerifyStatusCb cb, void* cbArg);
 4777
 4778/*!
 4779    \ingroup Setup
 4780
 4781    \brief この関数は、PRFコールバックに渡されるオプション引数を設定します。
 4782
 4783    \return SSL_FAILURE ctxがNULLの場合。
 4784    \return SSL_SUCCESS 正常に設定された場合。
 4785
 4786    \param ctx ユーザ引数を設定するWOLFSSL_CTX構造体。
 4787    \param arg ユーザ引数。
 4788
 4789    _Example_
 4790    \code
 4791    WOLFSSL_CTX* ctx;
 4792    void* data;
 4793    int ret;
 4794    // ctxをセットアップ
 4795    ret = wolfSSL_CTX_set_tlsext_opaques_prf_input_callback_arg(ctx, data);
 4796    //ret値を確認
 4797    \endcode
 4798
 4799    \sa wolfSSL_CTX_new
 4800    \sa wolfSSL_CTX_free
 4801*/
 4802long wolfSSL_CTX_set_tlsext_opaque_prf_input_callback_arg(
 4803        WOLFSSL_CTX* ctx, void* arg);
 4804
 4805/*!
 4806    \ingroup Setup
 4807
 4808    \brief この関数は、指定された WOLFSSL_CTX のオプションマスクに \p opt のビットを OR で追加します。設定したオプションマスクは、本コンテキストから後に作成されるすべての WOLFSSL セッションに継承されます。ビットは累積されるため、特定のオプションを解除するには wolfSSL_CTX_clear_options() を使用してください。OpenSSL 形式の "SSL_OP_*" マクロは対応する "WOLFSSL_OP_*" 値の別名であり、どちらの表記でも使用できます。
 4809
 4810    実効を持つオプション:
 4811
 4812    | マクロ                                | 効果 |
 4813    | ------------------------------------ | ---- |
 4814    | SSL_OP_NO_SSLv2                      | SSLv2 を無効化（wolfSSL は SSLv2 を一切サポートしない。OpenSSL 互換のため受け付けるのみ） |
 4815    | SSL_OP_NO_SSLv3                      | SSLv3 を無効化 |
 4816    | SSL_OP_NO_TLSv1                      | TLS 1.0 を無効化 |
 4817    | SSL_OP_NO_TLSv1_1                    | TLS 1.1 を無効化 |
 4818    | SSL_OP_NO_TLSv1_2                    | TLS 1.2 を無効化 |
 4819    | SSL_OP_NO_TLSv1_3                    | TLS 1.3 を無効化（WOLFSSL_TLS13 が必要） |
 4820    | SSL_OP_NO_COMPRESSION                | レコード層圧縮を無効化（HAVE_LIBZ 未定義時は何もしない） |
 4821    | SSL_OP_NO_TICKET                     | RFC 5077 セッションチケットを無効化（TLS 1.2 のみ。TLS 1.3 では本フラグは無視される）。HAVE_SESSION_TICKET と OPENSSL_EXTRA／HAVE_WEBSERVER／WOLFSSL_WPAS_SMALL のいずれかが必要 |
 4822    | SSL_OP_NO_RENEGOTIATION              | 相手主導の再ネゴシエーションを拒否 |
 4823    | SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION | 再ネゴシエーション時のセッション再利用を無効化 |
 4824    | SSL_OP_COOKIE_EXCHANGE               | HelloVerifyRequest クッキー交換を有効化（DTLS では既定で有効） |
 4825    | SSL_OP_NO_QUERY_MTU                  | DTLS: 経路 MTU を問い合わせない |
 4826    | SSL_OP_CIPHER_SERVER_PREFERENCE      | サーバ側の暗号スイート優先順位をクライアントの順序より優先 |
 4827    | SSL_OP_SINGLE_DH_USE                 | ハンドシェイクごとに新しい DH 鍵を生成 |
 4828    | SSL_OP_SINGLE_ECDH_USE               | ハンドシェイクごとに新しい ECDH 鍵を生成 |
 4829    | SSL_OP_EPHEMERAL_RSA                 | エフェメラル RSA を使用（レガシー。OpenSSL 互換のため受け付けるのみ） |
 4830    | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS   | レコード前の空フラグメント挿入を抑制（CBC BEAST 回避策） |
 4831    | SSL_OP_PKCS1_CHECK_1 / _2            | OpenSSL 互換のため受け付けるのみ |
 4832    | SSL_OP_LEGACY_SERVER_CONNECT         | 安全でない初回接続を常に許可。定義値は 0 のため実質無効化（openssl/ssl.h 互換ヘッダが必要） |
 4833
 4834    便宜マクロ・バグ回避フラグ（すべて SSL_OP_ALL の構成要素。OpenSSL 互換のため受け付けるが wolfSSL では実質 no-op）:
 4835
 4836    - SSL_OP_ALL（下記バグ回避フラグのビット OR）
 4837    - SSL_OP_MICROSOFT_SESS_ID_BUG
 4838    - SSL_OP_NETSCAPE_CHALLENGE_BUG
 4839    - SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
 4840    - SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
 4841    - SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
 4842    - SSL_OP_MSIE_SSLV2_RSA_PADDING
 4843    - SSL_OP_SSLEAY_080_CLIENT_DH_BUG
 4844    - SSL_OP_TLS_D5_BUG
 4845    - SSL_OP_TLS_BLOCK_PADDING_BUG
 4846    - SSL_OP_TLS_ROLLBACK_BUG
 4847    - SSL_OP_NETSCAPE_CA_DN_BUG
 4848    - SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG
 4849
 4850    複合マクロ:
 4851
 4852    - SSL_OP_NO_SSL_MASK = SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_TLSv1_3
 4853
 4854    \param ctx オプションマスクを設定する WOLFSSL_CTX 構造体。
 4855    \param opt 現在のマスクに OR で追加する SSL_OP_* / WOLFSSL_OP_* フラグのビットマスク。
 4856
 4857    \return BAD_FUNC_ARG \p ctx が NULL の場合。
 4858    \return 成功時、\p ctx に格納された更新後のオプションマスク値。
 4859
 4860    _Example_
 4861    \code
 4862    WOLFSSL_CTX* ctx;
 4863    long mask;
 4864    mask = wolfSSL_CTX_set_options(ctx,
 4865        SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 |
 4866        SSL_OP_NO_COMPRESSION | SSL_OP_CIPHER_SERVER_PREFERENCE);
 4867    // mask には ctx に蓄積されたオプション値が反映される
 4868    \endcode
 4869
 4870    \sa wolfSSL_CTX_clear_options
 4871    \sa wolfSSL_CTX_get_options
 4872    \sa wolfSSL_set_options
 4873    \sa wolfSSL_get_options
 4874*/
 4875long wolfSSL_CTX_set_options(WOLFSSL_CTX* ctx, long opt);
 4876
 4877/*!
 4878    \ingroup Setup
 4879
 4880    \brief この関数は、指定された WOLFSSL セッションのオプションマスクに \p op のビットを OR で追加します。認識される "SSL_OP_*" / "WOLFSSL_OP_*" フラグの集合は wolfSSL_CTX_set_options() と同一です。各フラグの効果および必要なビルドオプションについては wolfSSL_CTX_set_options() の説明を参照してください。親 WOLFSSL_CTX から継承したフラグはそのまま保持されます。本関数で SSL_OP_NO_TLSv1_3 を設定した場合、当該セッションのネゴシエーション可能なバージョンは TLS 1.2 まで引き下げられます。
 4881
 4882    \param s オプションマスクを設定する WOLFSSL セッション。
 4883    \param op 現在のマスクに OR で追加する SSL_OP_* / WOLFSSL_OP_* フラグのビットマスク。
 4884
 4885    \return 成功時、\p s に格納された更新後のオプションマスク値。\p s が NULL の場合は 0 を返します。
 4886
 4887    _Example_
 4888    \code
 4889    WOLFSSL* ssl;
 4890    long mask;
 4891    mask = wolfSSL_set_options(ssl, SSL_OP_NO_TLSv1_3);
 4892    // mask には ssl に蓄積されたオプション値が反映される
 4893    \endcode
 4894
 4895    \sa wolfSSL_CTX_set_options
 4896    \sa wolfSSL_clear_options
 4897    \sa wolfSSL_get_options
 4898    \sa wolfSSL_new
 4899    \sa wolfSSL_free
 4900*/
 4901long wolfSSL_set_options(WOLFSSL *s, long op);
 4902
 4903/*!
 4904    \ingroup Setup
 4905
 4906    \brief この関数は、現在のオプションマスクを返します。
 4907
 4908    \return val sslに格納されているマスク値を返します。
 4909
 4910    \param s オプションマスクを取得するWOLFSSL構造体。
 4911
 4912    _Example_
 4913    \code
 4914    WOLFSSL* ssl;
 4915    unsigned long mask;
 4916    mask  = wolfSSL_get_options(ssl);
 4917    // maskを確認
 4918    \endcode
 4919
 4920    \sa wolfSSL_new
 4921    \sa wolfSSL_free
 4922    \sa wolfSSL_set_options
 4923*/
 4924long wolfSSL_get_options(const WOLFSSL *s);
 4925
 4926/*!
 4927    \ingroup Setup
 4928
 4929    \brief これは、渡されるデバッグ引数を設定するために使用されます。
 4930
 4931    \return SSL_SUCCESS 引数の設定に成功した場合。
 4932    \return SSL_FAILURE NULLのsslが渡された場合。
 4933
 4934    \param s 引数を設定するWOLFSSL構造体。
 4935    \param arg 使用する引数。
 4936
 4937    _Example_
 4938    \code
 4939    WOLFSSL* ssl;
 4940    void* args;
 4941    int ret;
 4942    // sslオブジェクトを作成
 4943    ret  = wolfSSL_set_tlsext_debug_arg(ssl, args);
 4944    // ret値を確認
 4945    \endcode
 4946
 4947    \sa wolfSSL_new
 4948    \sa wolfSSL_free
 4949*/
 4950long wolfSSL_set_tlsext_debug_arg(WOLFSSL *s, void *arg);
 4951
 4952/*!
 4953    \ingroup openSSL
 4954
 4955    \brief この関数は、クライアントアプリケーションがサーバにOCSPステータスレスポンス(OCSPステープリングとも呼ばれます)を返送するよう要求する際に呼び出されます。現在、サポートされている唯一のタイプはTLSEXT_STATUSTYPE_ocspです。
 4956
 4957    \return 1 成功時。
 4958    \return 0 エラー時。
 4959
 4960    \param s SSL_new()関数によって作成されたWOLFSSL構造体へのポインタ。
 4961    \param type TLSEXT_STATUSTYPE_ocspのみがサポートされているSSL拡張タイプ。
 4962
 4963    _Example_
 4964    \code
 4965    WOLFSSL *ssl;
 4966    WOLFSSL_CTX *ctx;
 4967    int ret;
 4968    ctx = wolfSSL_CTX_new(wolfSSLv23_server_method());
 4969    ssl = wolfSSL_new(ctx);
 4970    ret = WolfSSL_set_tlsext_status_type(ssl,TLSEXT_STATUSTYPE_ocsp);
 4971    wolfSSL_free(ssl);
 4972    wolfSSL_CTX_free(ctx);
 4973    \endcode
 4974
 4975    \sa wolfSSL_new
 4976    \sa wolfSSL_CTX_new
 4977    \sa wolfSSL_free
 4978    \sa wolfSSL_CTX_free
 4979*/
 4980long wolfSSL_set_tlsext_status_type(WOLFSSL *s, int type);
 4981
 4982/*!
 4983    \ingroup Setup
 4984
 4985    \brief これは、ピアの証明書の検証を試みた後の結果を取得するために使用されます。
 4986
 4987    \return X509_V_OK 検証が成功した場合。
 4988    \return SSL_FAILURE NULLのsslが渡された場合。
 4989
 4990    \param ssl 検証結果を取得するWOLFSSL構造体。
 4991
 4992    _Example_
 4993    \code
 4994    WOLFSSL* ssl;
 4995    long ret;
 4996    // ハンドシェイクを試行/完了
 4997    ret  = wolfSSL_get_verify_result(ssl);
 4998    // ret値を確認
 4999    \endcode
 5000
 5001    \sa wolfSSL_new
 5002    \sa wolfSSL_free
 5003*/
 5004long wolfSSL_get_verify_result(const WOLFSSL *ssl);
 5005
 5006/*!
 5007    \ingroup Debug
 5008
 5009    \brief この関数は、wolfSSL_get_error()によって返されたエラーコードを、より人間が読みやすいエラー文字列に変換し、その文字列を出力ファイルfpに出力します。errはwolfSSL_get_error()によって返されたエラーコードであり、fpはエラー文字列が配置されるファイルです。
 5010
 5011    \return none 戻り値なし。
 5012
 5013    \param fp 人間が読みやすいエラー文字列が書き込まれる出力ファイル。
 5014    \param err wolfSSL_get_error()によって返されたエラーコード。
 5015
 5016    _Example_
 5017    \code
 5018    int err = 0;
 5019    WOLFSSL* ssl;
 5020    FILE* fp = ...
 5021    ...
 5022    err = wolfSSL_get_error(ssl, 0);
 5023    wolfSSL_ERR_print_errors_fp(fp, err);
 5024    \endcode
 5025
 5026    \sa wolfSSL_get_error
 5027    \sa wolfSSL_ERR_error_string
 5028    \sa wolfSSL_ERR_error_string_n
 5029    \sa wolfSSL_load_error_strings
 5030*/
 5031void  wolfSSL_ERR_print_errors_fp(XFILE fp, int err);
 5032
 5033/*!
 5034    \ingroup Debug
 5035
 5036    \brief この関数は、提供されたコールバックを使用してエラーレポートを処理します。コールバック関数は、各エラー行に対して実行されます。文字列、長さ、およびユーザデータがコールバックパラメータに渡されます。
 5037
 5038    \return none 戻り値なし。
 5039
 5040    \param cb コールバック関数。
 5041    \param u コールバック関数に渡すユーザデータ。
 5042
 5043    _Example_
 5044    \code
 5045    int error_cb(const char *str, size_t len, void *u)
 5046    { fprintf((FILE*)u, "%-*.*s\n", (int)len, (int)len, str); return 0; }
 5047    ...
 5048    FILE* fp = ...
 5049    wolfSSL_ERR_print_errors_cb(error_cb, fp);
 5050    \endcode
 5051
 5052    \sa wolfSSL_get_error
 5053    \sa wolfSSL_ERR_error_string
 5054    \sa wolfSSL_ERR_error_string_n
 5055    \sa wolfSSL_load_error_strings
 5056*/
 5057void  wolfSSL_ERR_print_errors_cb (
 5058        int (*cb)(const char *str, size_t len, void *u), void *u);
 5059
 5060/*!
 5061    \brief この関数は、WOLFSSL_CTX構造体のclient_psk_cbメンバを設定します。
 5062
 5063    \return none 戻り値なし。
 5064
 5065    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 5066    \param cb WOLFSSL_CTX構造体に格納される関数ポインタであるwc_psk_client_callback。戻り値は、成功時には鍵の長さ、エラー時にはゼロです。
 5067    unsigned int (*wc_psk_client_callback)
 5068    PSKクライアントコールバックのパラメータ:
 5069    WOLFSSL* ssl - wolfSSL構造体へのポインタ
 5070    const char* hint - ユーザへのヒントを表示するために使用できる格納された文字列。
 5071    char* identity - IDがここに格納されます。
 5072    unsigned int id_max_len - IDバッファのサイズ。
 5073    unsigned char* key - 鍵がここに格納されます。
 5074    unsigned int key_max_len - 鍵の最大サイズ。
 5075
 5076    _Example_
 5077    \code
 5078    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol def );
 5079    …
 5080    static WC_INLINE unsigned int my_psk_client_cb(WOLFSSL* ssl, const char* hint,
 5081        char* identity, unsigned int id_max_len, unsigned char* key,
 5082        Unsigned int key_max_len){
 5083        …
 5084        wolfSSL_CTX_set_psk_client_callback(ctx, my_psk_client_cb);
 5085    \endcode
 5086
 5087    \sa wolfSSL_set_psk_client_callback
 5088    \sa wolfSSL_set_psk_server_callback
 5089    \sa wolfSSL_CTX_set_psk_server_callback
 5090    \sa wolfSSL_CTX_set_psk_client_callback
 5091*/
 5092void wolfSSL_CTX_set_psk_client_callback(WOLFSSL_CTX* ctx,
 5093                                                    wc_psk_client_callback cb);
 5094
 5095/*!
 5096    \brief PSKクライアント側コールバックを設定します。
 5097
 5098    \return none 戻り値なし。
 5099
 5100    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5101    \param cb wc_psk_client_callback型への関数ポインタ。戻り値は、成功時には鍵の長さ、エラー時にはゼロです。
 5102    unsigned int (*wc_psk_client_callback)
 5103    PSKクライアントコールバックのパラメータ:
 5104    WOLFSSL* ssl - wolfSSL構造体へのポインタ
 5105    const char* hint - ユーザへのヒントを表示するために使用できる格納された文字列。
 5106    char* identity - IDがここに格納されます。
 5107    unsigned int id_max_len - IDバッファのサイズ。
 5108    unsigned char* key - 鍵がここに格納されます。
 5109    unsigned int key_max_len - 鍵の最大サイズ。
 5110
 5111    _Example_
 5112    \code
 5113    WOLFSSL* ssl;
 5114    static WC_INLINE unsigned int my_psk_client_cb(WOLFSSL* ssl, const char* hint,
 5115        char* identity, unsigned int id_max_len, unsigned char* key,
 5116        Unsigned int key_max_len){
 5117        …
 5118        if(ssl){
 5119            wolfSSL_set_psk_client_callback(ssl, my_psk_client_cb);
 5120        } else {
 5121            // コールバックを設定できませんでした。
 5122        }
 5123    \endcode
 5124
 5125    \sa wolfSSL_CTX_set_psk_client_callback
 5126    \sa wolfSSL_CTX_set_psk_server_callback
 5127    \sa wolfSSL_set_psk_server_callback
 5128*/
 5129void wolfSSL_set_psk_client_callback(WOLFSSL* ssl,
 5130                                                    wc_psk_client_callback cb);
 5131
 5132/*!
 5133    \ingroup CertsKeys
 5134
 5135    \brief この関数は、PSKアイデンティティヒントを返します。
 5136
 5137    \return pointer WOLFSSL構造体のarraysメンバに格納されていた値へのconst char型ポインタが返されます。
 5138    \return NULL WOLFSSLまたはArrays構造体がNULLの場合に返されます。
 5139
 5140    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5141
 5142    _Example_
 5143    \code
 5144    WOLFSSL* ssl = wolfSSL_new(ctx);
 5145    char* idHint;
 5146    ...
 5147    idHint = wolfSSL_get_psk_identity_hint(ssl);
 5148    if(idHint){
 5149    	// ヒントが取得されました。
 5150    	return idHint;
 5151    } else {
 5152    	// ヒントの取得に成功しませんでした。
 5153    }
 5154    \endcode
 5155
 5156    \sa wolfSSL_get_psk_identity
 5157*/
 5158const char* wolfSSL_get_psk_identity_hint(const WOLFSSL*);
 5159
 5160/*!
 5161    \ingroup CertsKeys
 5162
 5163    \brief この関数は、Arrays構造体のclient_identityメンバへの定数ポインタを返します。
 5164
 5165    \return string Arrays構造体のclient_identityメンバの文字列値。
 5166    \return NULL WOLFSSL構造体がNULL、またはWOLFSSL構造体のArraysメンバがNULLの場合。
 5167
 5168    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5169
 5170    _Example_
 5171    \code
 5172    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 5173    WOLFSSL* ssl = wolfSSL_new(ctx);    const char* pskID;
 5174    ...
 5175    pskID = wolfSSL_get_psk_identity(ssl);
 5176
 5177    if(pskID == NULL){
 5178	    // pskIDに値がありません
 5179    }
 5180    \endcode
 5181
 5182    \sa wolfSSL_get_psk_identity_hint
 5183    \sa wolfSSL_use_psk_identity_hint
 5184*/
 5185const char* wolfSSL_get_psk_identity(const WOLFSSL*);
 5186
 5187/*!
 5188    \ingroup CertsKeys
 5189
 5190    \brief この関数は、hint引数をWOLFSSL_CTX構造体のserver_hintメンバに格納します。
 5191
 5192    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。
 5193
 5194    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 5195    \param hint WOLFSSL_CTX構造体にコピーされる定数charポインタ。
 5196
 5197    _Example_
 5198    \code
 5199    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 5200    const char* hint;
 5201    int ret;
 5202    …
 5203    ret = wolfSSL_CTX_use_psk_identity_hint(ctx, hint);
 5204    if(ret == SSL_SUCCESS){
 5205    	// 関数は成功しました
 5206	return ret;
 5207    } else {
 5208    	// 失敗ケース
 5209    }
 5210    \endcode
 5211
 5212    \sa wolfSSL_use_psk_identity_hint
 5213*/
 5214int wolfSSL_CTX_use_psk_identity_hint(WOLFSSL_CTX* ctx, const char* hint);
 5215
 5216/*!
 5217    \ingroup CertsKeys
 5218
 5219    \brief この関数は、hint引数をWOLFSSL構造体内のArrays構造体のserver_hintメンバに格納します。
 5220
 5221    \return SSL_SUCCESS hintがWOLFSSL構造体に正常に格納された場合に返されます。
 5222    \return SSL_FAILURE WOLFSSLまたはArrays構造体がNULLの場合に返されます。
 5223
 5224    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5225    \param hint メモリに保存されるヒントを保持する定数文字ポインタ。
 5226
 5227    _Example_
 5228    \code
 5229    WOLFSSL* ssl = wolfSSL_new(ctx);
 5230    const char* hint;
 5231    ...
 5232    if(wolfSSL_use_psk_identity_hint(ssl, hint) != SSL_SUCCESS){
 5233    	// 失敗ケースを処理
 5234    }
 5235    \endcode
 5236
 5237    \sa wolfSSL_CTX_use_psk_identity_hint
 5238*/
 5239int wolfSSL_use_psk_identity_hint(WOLFSSL* ssl, const char* hint);
 5240
 5241/*!
 5242    \brief この関数は、WOLFSSL_CTX構造体にサーバ側のpskコールバックを設定します。
 5243
 5244    \return none 戻り値なし。
 5245
 5246    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5247    \param cb コールバック用の関数ポインタで、WOLFSSL_CTX構造体に格納されます。戻り値は成功時は鍵の長さ、エラー時は0です。
 5248    unsigned int (*wc_psk_server_callback)
 5249    PSKサーバコールバックのパラメータ
 5250    WOLFSSL* ssl - wolfSSL構造体へのポインタ
 5251    char* identity - IDがここに格納されます
 5252    unsigned char* key - 鍵がここに格納されます
 5253    unsigned int key_max_len - 鍵の最大サイズ
 5254
 5255    _Example_
 5256    \code
 5257    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 5258    WOLFSSL* ssl = wolfSSL_new(ctx);
 5259    …
 5260    static unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
 5261                           unsigned char* key, unsigned int key_max_len)
 5262    {
 5263        // 関数本体
 5264    }
 5265    …
 5266    if(ctx != NULL){
 5267        wolfSSL_CTX_set_psk_server_callback(ctx, my_psk_server_cb);
 5268    } else {
 5269    	// CTXオブジェクトが適切に初期化されませんでした
 5270    }
 5271    \endcode
 5272
 5273    \sa wc_psk_server_callback
 5274    \sa wolfSSL_set_psk_client_callback
 5275    \sa wolfSSL_set_psk_server_callback
 5276    \sa wolfSSL_CTX_set_psk_client_callback
 5277*/
 5278void wolfSSL_CTX_set_psk_server_callback(WOLFSSL_CTX* ctx,
 5279                                                    wc_psk_server_callback cb);
 5280
 5281/*!
 5282    \brief WOLFSSL構造体のoptionsメンバを設定することにより、サーバ側のpskコールバックを設定します。
 5283
 5284    \return none 戻り値なし。
 5285
 5286    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5287    \param cb コールバック用の関数ポインタで、WOLFSSL構造体に格納されます。戻り値は成功時は鍵の長さ、エラー時は0です。
 5288    unsigned int (*wc_psk_server_callback)
 5289    PSKサーバコールバックのパラメータ
 5290    WOLFSSL* ssl - wolfSSL構造体へのポインタ
 5291    char* identity - IDがここに格納されます
 5292    unsigned char* key - 鍵がここに格納されます
 5293    unsigned int key_max_len - 鍵の最大サイズ
 5294
 5295
 5296    _Example_
 5297    \code
 5298    WOLFSSL_CTX* ctx;
 5299    WOLFSSL* ssl;
 5300    …
 5301    static unsigned int my_psk_server_cb(WOLFSSL* ssl, const char* identity,
 5302                           unsigned char* key, unsigned int key_max_len)
 5303    {
 5304        // 関数本体
 5305    }
 5306    …
 5307    if(ssl != NULL && cb != NULL){
 5308        wolfSSL_set_psk_server_callback(ssl, my_psk_server_cb);
 5309    }
 5310    \endcode
 5311
 5312    \sa wolfSSL_set_psk_client_callback
 5313    \sa wolfSSL_CTX_set_psk_server_callback
 5314    \sa wolfSSL_CTX_set_psk_client_callback
 5315    \sa wolfSSL_get_psk_identity_hint
 5316    \sa wc_psk_server_callback
 5317    \sa InitSuites
 5318*/
 5319void wolfSSL_set_psk_server_callback(WOLFSSL* ssl,
 5320                                                    wc_psk_server_callback cb);
 5321
 5322
 5323/*!
 5324    \brief WOLFSSL構造体のoptionsメンバにPSKユーザコンテキストを設定します。
 5325
 5326    \return WOLFSSL_SUCCESSまたはWOLFSSL_FAILURE
 5327
 5328    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5329    \param psk_ctx ユーザPSKコンテキストへのvoidポインタ。
 5330
 5331    \sa wolfSSL_get_psk_callback_ctx
 5332    \sa wolfSSL_CTX_set_psk_callback_ctx
 5333    \sa wolfSSL_CTX_get_psk_callback_ctx
 5334*/
 5335int wolfSSL_set_psk_callback_ctx(WOLFSSL* ssl, void* psk_ctx);
 5336
 5337/*!
 5338    \brief WOLFSSL_CTX構造体にPSKユーザコンテキストを設定します。
 5339
 5340    \return WOLFSSL_SUCCESSまたはWOLFSSL_FAILURE
 5341
 5342    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 5343    \param psk_ctx ユーザPSKコンテキストへのvoidポインタ。
 5344
 5345    \sa wolfSSL_set_psk_callback_ctx
 5346    \sa wolfSSL_get_psk_callback_ctx
 5347    \sa wolfSSL_CTX_get_psk_callback_ctx
 5348*/
 5349int wolfSSL_CTX_set_psk_callback_ctx(WOLFSSL_CTX* ctx, void* psk_ctx);
 5350
 5351/*!
 5352    \brief WOLFSSL構造体のoptionsメンバからPSKユーザコンテキストを取得します。
 5353
 5354    \return ユーザPSKコンテキストへのvoidポインタ。
 5355
 5356    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5357
 5358    \sa wolfSSL_set_psk_callback_ctx
 5359    \sa wolfSSL_CTX_set_psk_callback_ctx
 5360    \sa wolfSSL_CTX_get_psk_callback_ctx
 5361*/
 5362void* wolfSSL_get_psk_callback_ctx(WOLFSSL* ssl);
 5363
 5364/*!
 5365    \brief WOLFSSL_CTX構造体からPSKユーザコンテキストを取得します。
 5366
 5367    \return ユーザPSKコンテキストへのvoidポインタ。
 5368
 5369    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 5370
 5371    \sa wolfSSL_CTX_set_psk_callback_ctx
 5372    \sa wolfSSL_set_psk_callback_ctx
 5373    \sa wolfSSL_get_psk_callback_ctx
 5374*/
 5375void* wolfSSL_CTX_get_psk_callback_ctx(WOLFSSL_CTX* ctx);
 5376
 5377/*!
 5378    \ingroup Setup
 5379
 5380    \brief この関数は、コンパイル時にHAVE_ANONが定義されている場合、CTX構造体のhavAnonメンバを有効にします。
 5381
 5382    \return SSL_SUCCESS 関数が正常に実行され、CTXのhaveAnnonメンバが1に設定された場合に返されます。
 5383    \return SSL_FAILURE CTX構造体がNULLの場合に返されます。
 5384
 5385    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 5386
 5387    _Example_
 5388    \code
 5389    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 5390    WOLFSSL* ssl = wolfSSL_new(ctx);
 5391    ...
 5392    #ifdef HAVE_ANON
 5393	if(cipherList == NULL){
 5394	    wolfSSL_CTX_allow_anon_cipher(ctx);
 5395	    if(wolfSSL_CTX_set_cipher_list(ctx, "ADH_AES128_SHA") != SSL_SUCCESS){
 5396		    // 失敗ケース
 5397	    }
 5398    }
 5399    #endif
 5400    \endcode
 5401
 5402    \sa none
 5403*/
 5404int wolfSSL_CTX_allow_anon_cipher(WOLFSSL_CTX* ctx);
 5405
 5406/*!
 5407    \ingroup Setup
 5408
 5409    \brief wolfSSLv23_server_method()関数は、アプリケーションがサーバであり、SSL 3.0からTLS 1.3までのプロトコルバージョンで接続するクライアントをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいWOLFSSL_METHOD構造体のためのメモリを割り当て、初期化します。
 5410
 5411    \return pointer 成功時、新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
 5412    \return Failure XMALLOCを呼び出す際にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
 5413
 5414    \param none パラメータなし。
 5415
 5416    _Example_
 5417    \code
 5418    WOLFSSL_METHOD* method;
 5419    WOLFSSL_CTX* ctx;
 5420
 5421    method = wolfSSLv23_server_method();
 5422    if (method == NULL) {
 5423    	// メソッドを取得できませんでした
 5424    }
 5425
 5426    ctx = wolfSSL_CTX_new(method);
 5427    ...
 5428    \endcode
 5429
 5430    \sa wolfSSLv3_server_method
 5431    \sa wolfTLSv1_server_method
 5432    \sa wolfTLSv1_1_server_method
 5433    \sa wolfTLSv1_2_server_method
 5434    \sa wolfTLSv1_3_server_method
 5435    \sa wolfDTLSv1_server_method
 5436    \sa wolfSSL_CTX_new
 5437*/
 5438WOLFSSL_METHOD *wolfSSLv23_server_method(void);
 5439
 5440/*!
 5441    \ingroup Setup
 5442
 5443    \brief これは、WOLFSSL構造体の内部エラー状態を取得するために使用されます。
 5444
 5445    \return wolfssl_error sslエラー状態を返します。通常は負の値です。
 5446    \return BAD_FUNC_ARG sslがNULLの場合。
 5447
 5448    \return ssl 状態を取得するWOLFSSL構造体。
 5449
 5450    _Example_
 5451    \code
 5452    WOLFSSL* ssl;
 5453    int ret;
 5454    // sslオブジェクトを作成
 5455    ret  = wolfSSL_state(ssl);
 5456    // ret値を確認
 5457    \endcode
 5458
 5459    \sa wolfSSL_new
 5460    \sa wolfSSL_free
 5461*/
 5462int  wolfSSL_state(WOLFSSL* ssl);
 5463
 5464/*!
 5465    \ingroup CertsKeys
 5466
 5467    \brief この関数は、ピアの証明書を取得します。
 5468
 5469    \return pointer 存在する場合、WOLFSSL_X509構造体のpeerCertメンバへのポインタ。
 5470    \return 0 ピア証明書発行者のサイズが定義されていない場合に返されます。
 5471
 5472    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5473
 5474    _Example_
 5475    \code
 5476    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 5477    WOLFSSL* ssl = wolfSSL_new(ctx);
 5478    ...
 5479    WOLFSSL_X509* peerCert = wolfSSL_get_peer_certificate(ssl);
 5480
 5481    if(peerCert){
 5482    	// ピア証明書へのポインタpeerCertがあります
 5483    }
 5484    \endcode
 5485
 5486    \sa wolfSSL_X509_get_issuer_name
 5487    \sa wolfSSL_X509_get_subject_name
 5488    \sa wolfSSL_X509_get_isCA
 5489*/
 5490WOLFSSL_X509* wolfSSL_get_peer_certificate(WOLFSSL* ssl);
 5491
 5492/*!
 5493    \ingroup Debug
 5494
 5495    \brief この関数は、wolfSSL_get_error()を呼び出してSSL_ERROR_WANT_READが返される場合と同様です。基礎となるエラー状態がSSL_ERROR_WANT_READの場合、この関数は1を返し、それ以外の場合は0を返します。
 5496
 5497    \return 1 wolfSSL_get_error()がSSL_ERROR_WANT_READを返す場合。基礎となるI/Oに読み取り可能なデータがあります。
 5498    \return 0 SSL_ERROR_WANT_READエラー状態がない場合。
 5499
 5500    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 5501
 5502    _Example_
 5503    \code
 5504    int ret;
 5505    WOLFSSL* ssl = 0;
 5506    ...
 5507
 5508    ret = wolfSSL_want_read(ssl);
 5509    if (ret == 1) {
 5510    	// 基礎となるI/Oに読み取り可能なデータがあります(SSL_ERROR_WANT_READ)
 5511    }
 5512    \endcode
 5513
 5514    \sa wolfSSL_want_write
 5515    \sa wolfSSL_get_error
 5516*/
 5517int wolfSSL_want_read(WOLFSSL* ssl);
 5518
 5519/*!
 5520    \ingroup Debug
 5521
 5522    \brief この関数は、wolfSSL_get_error()を呼び出してSSL_ERROR_WANT_WRITEが返される場合と同様です。基礎となるエラー状態がSSL_ERROR_WANT_WRITEの場合、この関数は1を返し、それ以外の場合は0を返します。
 5523
 5524    \return 1 wolfSSL_get_error()がSSL_ERROR_WANT_WRITEを返す場合。基礎となるSSL接続で進行するために、基礎となるI/Oにデータを書き込む必要があります。
 5525    \return 0 SSL_ERROR_WANT_WRITEエラー状態がない場合。
 5526
 5527    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 5528
 5529    _Example_
 5530    \code
 5531    int ret;
 5532    WOLFSSL* ssl = 0;
 5533    ...
 5534    ret = wolfSSL_want_write(ssl);
 5535    if (ret == 1) {
 5536    	// 基礎となるI/Oにデータを書き込む必要があります(SSL_ERROR_WANT_WRITE)
 5537    }
 5538    \endcode
 5539
 5540    \sa wolfSSL_want_read
 5541    \sa wolfSSL_get_error
 5542*/int wolfSSL_want_write(WOLFSSL* ssl);
 5543
 5544/*!
 5545    \ingroup Setup
 5546
 5547    \brief wolfSSLはデフォルトでピア証明書の有効な日付範囲と検証済み署名をチェックします。wolfSSL_connect()またはwolfSSL_accept()の前にこの関数を呼び出すと、実行するチェックのリストにドメイン名チェックが追加されます。dnは、受信したピア証明書に対してチェックするドメイン名を保持します。
 5548
 5549    \return SSL_SUCCESS 成功時。
 5550    \return SSL_FAILURE メモリエラーが発生した場合に返されます。
 5551
 5552    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 5553    \param dn 受信したピア証明書に対してチェックするドメイン名。
 5554
 5555    _Example_
 5556    \code
 5557    int ret = 0;
 5558    WOLFSSL* ssl;
 5559    char* domain = (char*) "www.yassl.com";
 5560    ...
 5561
 5562    ret = wolfSSL_check_domain_name(ssl, domain);
 5563    if (ret != SSL_SUCCESS) {
 5564       // ドメイン名チェックの有効化に失敗しました
 5565    }
 5566    \endcode
 5567
 5568    \sa none
 5569*/
 5570int wolfSSL_check_domain_name(WOLFSSL* ssl, const char* dn);
 5571
 5572/*!
 5573    \ingroup Setup
 5574
 5575    \brief wolfSSL_connect() または wolfSSL_accept() の前にこの関数を呼ぶと、
 5576    ピア証明書の SAN iPAddress エントリに対する IP アドレス検証を追加します。
 5577
 5578    \return SSL_SUCCESS 成功。
 5579    \return SSL_FAILURE パラメータ不正またはメモリ確保失敗。
 5580
 5581    \param ssl wolfSSL_new() で作成された WOLFSSL 構造体へのポインタ。
 5582    \param ipaddr 検証する NULL 終端 ASCII IP アドレス文字列。
 5583
 5584    \sa wolfSSL_check_domain_name
 5585*/
 5586int wolfSSL_check_ip_address(WOLFSSL* ssl, const char* ipaddr);
 5587
 5588/*!
 5589    \ingroup TLS
 5590
 5591    \brief 使用するためにwolfSSLライブラリを初期化します。アプリケーションごとに1回、ライブラリへの他の呼び出しの前に呼び出す必要があります。
 5592
 5593    \return SSL_SUCCESS 成功した場合に返されます。
 5594    \return BAD_MUTEX_E 返される可能性のあるエラーです。
 5595    \return WC_INIT_E wolfCrypt初期化エラーが返されます。
 5596
 5597    _Example_
 5598    \code
 5599    int ret = 0;
 5600    ret = wolfSSL_Init();
 5601    if (ret != SSL_SUCCESS) {
 5602	    wolfSSLライブラリの初期化に失敗しました
 5603    }
 5604
 5605    \endcode
 5606
 5607    \sa wolfSSL_Cleanup
 5608*/
 5609int wolfSSL_Init(void);
 5610
 5611/*!
 5612    \ingroup TLS
 5613
 5614    \brief wolfSSLライブラリをこれ以上使用しないように初期化を解除します。呼び出す必要はありませんが、ライブラリが使用したリソースを解放します。
 5615
 5616    \return SSL_SUCCESS エラーなしで返されます。
 5617    \return BAD_MUTEX_E mutexエラーが返されます。
 5618
 5619    _Example_
 5620    \code
 5621    wolfSSL_Cleanup();
 5622    \endcode
 5623
 5624    \sa wolfSSL_Init
 5625*/
 5626int wolfSSL_Cleanup(void);
 5627
 5628/*!
 5629    \ingroup IO
 5630
 5631    \brief この関数は現在のライブラリバージョンを返します。
 5632
 5633    \return LIBWOLFSSL_VERSION_STRING バージョンを定義するconst charポインタ。
 5634
 5635    \param none パラメータなし。
 5636
 5637    _Example_
 5638    \code
 5639    char version[MAXSIZE];
 5640    version = wolfSSL_KeepArrays();
 5641    …
 5642    if(version != ExpectedVersion){
 5643	    // 不一致ケースを処理
 5644    }
 5645    \endcode
 5646
 5647    \sa word32_wolfSSL_lib_version_hex
 5648*/
 5649const char* wolfSSL_lib_version(void);
 5650
 5651/*!
 5652    \ingroup IO
 5653
 5654    \brief この関数は現在のライブラリバージョンを16進表記で返します。
 5655
 5656    \return LILBWOLFSSL_VERSION_HEX wolfssl/version.hで定義された16進バージョンを返します。
 5657
 5658    \param none パラメータなし。
 5659
 5660    _Example_
 5661    \code
 5662    word32 libV;
 5663    libV = wolfSSL_lib_version_hex();
 5664
 5665    if(libV != EXPECTED_HEX){
 5666	    // 予期しない値の処理方法
 5667    } else {
 5668	    // libVの期待される結果
 5669    }
 5670    \endcode
 5671
 5672    \sa wolfSSL_lib_version
 5673*/
 5674word32 wolfSSL_lib_version_hex(void);
 5675
 5676/*!
 5677    \ingroup IO
 5678
 5679    \brief SSLメソッドの側面に基づいて実際の接続または受け入れを実行します。クライアント側から呼び出された場合はwolfSSL_connect()が実行され、サーバー側から呼び出された場合はwolfSSL_accept()が実行されます。
 5680
 5681    \return SSL_SUCCESS 成功した場合に返されます(注:古いバージョンでは0が返されます)。
 5682    \return SSL_FATAL_ERROR 基礎となる呼び出しがエラーになった場合に返されます。特定のエラーコードを取得するにはwolfSSL_get_error()を使用してください。
 5683
 5684    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 5685
 5686    _Example_
 5687    \code
 5688    int ret = SSL_FATAL_ERROR;
 5689    WOLFSSL* ssl = 0;
 5690    ...
 5691    ret = wolfSSL_negotiate(ssl);
 5692    if (ret == SSL_FATAL_ERROR) {
 5693    	// SSL確立に失敗しました
 5694        int error_code = wolfSSL_get_error(ssl);
 5695        ...
 5696    }
 5697    ...
 5698    \endcode
 5699
 5700    \sa SSL_connect
 5701    \sa SSL_accept
 5702*/
 5703int wolfSSL_negotiate(WOLFSSL* ssl);
 5704
 5705/*!
 5706    \ingroup Setup
 5707
 5708    \brief SSL接続で圧縮を使用する機能をオンにします。両側で圧縮をオンにする必要があります。そうでない場合、圧縮は使用されません。zlibライブラリが実際のデータ圧縮を実行します。ライブラリにコンパイルするには、configureシステムで--with-libzを使用し、HAVE_LIBZを定義してください。送信前にデータを圧縮すると送受信されるメッセージの実際のサイズは減少しますが、圧縮によって節約されるデータの量は、最も遅いネットワークを除いて、生データで送信するよりも解析に時間がかかることに注意してください。
 5709
 5710    \return SSL_SUCCESS 成功時。
 5711    \return NOT_COMPILED_IN 圧縮サポートがライブラリにビルドされていない場合に返されます。
 5712
 5713    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 5714
 5715    _Example_
 5716    \code
 5717    int ret = 0;
 5718    WOLFSSL* ssl = 0;
 5719    ...
 5720    ret = wolfSSL_set_compression(ssl);
 5721    if (ret == SSL_SUCCESS) {
 5722    	// SSLセッションの圧縮を正常に有効化しました
 5723    }
 5724    \endcode
 5725
 5726    \sa none
 5727*/
 5728int wolfSSL_set_compression(WOLFSSL* ssl);
 5729
 5730/*!
 5731    \ingroup Setup
 5732
 5733    \brief この関数はSSLセッションのタイムアウト値を秒単位で設定します。
 5734
 5735    \return SSL_SUCCESS セッションの設定に成功した場合に返されます。
 5736    \return BAD_FUNC_ARG sslがNULLの場合に返されます。
 5737
 5738    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 5739    \param to SSLセッションタイムアウトの設定に使用される秒単位の値。
 5740
 5741    _Example_
 5742    \code
 5743    int ret = 0;
 5744    WOLFSSL* ssl = 0;
 5745    ...
 5746
 5747    ret = wolfSSL_set_timeout(ssl, 500);
 5748    if (ret != SSL_SUCCESS) {
 5749    	// セッションタイムアウト値の設定に失敗しました
 5750    }
 5751    ...
 5752    \endcode
 5753
 5754    \sa wolfSSL_get1_session
 5755    \sa wolfSSL_set_session
 5756*/
 5757int wolfSSL_set_timeout(WOLFSSL* ssl, unsigned int to);
 5758
 5759/*!
 5760    \ingroup Setup
 5761
 5762    \brief この関数は、指定されたSSLコンテキストのSSLセッションのタイムアウト値を秒単位で設定します。
 5763
 5764    \return WOLFSSL_ERROR_CODE_OPENSSLが定義されている場合、成功時に以前のタイムアウト値が返されます。定義されていない場合、SSL_SUCCESSが返されます。
 5765    \return BAD_FUNC_ARG 入力コンテキスト(ctx)がnullの場合に返されます。
 5766
 5767    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 5768    \param to セッションタイムアウト値(秒単位)。
 5769
 5770    _Example_
 5771    \code
 5772    WOLFSSL_CTX*    ctx    = 0;
 5773    ...
 5774    ret = wolfSSL_CTX_set_timeout(ctx, 500);
 5775    if (ret != SSL_SUCCESS) {
 5776	    // セッションタイムアウト値の設定に失敗しました
 5777    }
 5778    \endcode
 5779
 5780    \sa wolfSSL_flush_sessions
 5781    \sa wolfSSL_get1_session
 5782    \sa wolfSSL_set_session
 5783    \sa wolfSSL_get_sessionID
 5784    \sa wolfSSL_CTX_set_session_cache_mode
 5785*/
 5786int wolfSSL_CTX_set_timeout(WOLFSSL_CTX* ctx, unsigned int to);
 5787
 5788/*!
 5789    \ingroup openSSL
 5790
 5791    \brief ピアの証明書チェーンを取得します。
 5792
 5793    \return chain 成功した場合、呼び出しはピアの証明書チェーンを返します。
 5794    \return 0 無効なWOLFSSLポインタが関数に渡された場合に返されます。
 5795
 5796    \param ssl 有効なWOLFSSL構造体へのポインタ。
 5797
 5798    _Example_
 5799    \code
 5800    none
 5801    \endcode
 5802
 5803    \sa wolfSSL_get_chain_count
 5804    \sa wolfSSL_get_chain_length
 5805    \sa wolfSSL_get_chain_cert
 5806    \sa wolfSSL_get_chain_cert_pem
 5807*/
 5808WOLFSSL_X509_CHAIN* wolfSSL_get_peer_chain(WOLFSSL* ssl);
 5809
 5810/*!
 5811    \ingroup openSSL
 5812
 5813    \brief ピアの証明書チェーン数を取得します。
 5814
 5815    \return Success 成功した場合、呼び出しはピアの証明書チェーン数を返します。
 5816    \return 0 無効なchainポインタが関数に渡された場合に返されます。
 5817
 5818    \param chain 有効なWOLFSSL_X509_CHAIN構造体へのポインタ。
 5819
 5820    _Example_
 5821    \code
 5822    none
 5823    \endcode
 5824
 5825    \sa wolfSSL_get_peer_chain
 5826    \sa wolfSSL_get_chain_length
 5827    \sa wolfSSL_get_chain_cert
 5828    \sa wolfSSL_get_chain_cert_pem
 5829*/
 5830int  wolfSSL_get_chain_count(WOLFSSL_X509_CHAIN* chain);
 5831
 5832/*!
 5833    \ingroup openSSL
 5834
 5835    \brief インデックス(idx)におけるピアのASN1.DER証明書の長さをバイト単位で取得します。
 5836
 5837    \return Success 成功した場合、呼び出しはインデックスによるピアの証明書の長さをバイト単位で返します。
 5838    \return 0 無効なchainポインタが関数に渡された場合に返されます。
 5839
 5840    \param chain 有効なWOLFSSL_X509_CHAIN構造体へのポインタ。
 5841    \param idx チェーンの開始インデックス。
 5842
 5843    _Example_
 5844    \code
 5845    none
 5846    \endcode
 5847
 5848    \sa wolfSSL_get_peer_chain
 5849    \sa wolfSSL_get_chain_count
 5850    \sa wolfSSL_get_chain_cert
 5851    \sa wolfSSL_get_chain_cert_pem
 5852*/
 5853int  wolfSSL_get_chain_length(WOLFSSL_X509_CHAIN* chain, int idx);
 5854
 5855/*!
 5856    \ingroup openSSL
 5857
 5858    \brief インデックス(idx)におけるピアのASN1.DER証明書を取得します。
 5859
 5860    \return Success 成功した場合、呼び出しはインデックスによるピアの証明書を返します。
 5861    \return 0 無効なchainポインタが関数に渡された場合に返されます。
 5862
 5863    \param chain 有効なWOLFSSL_X509_CHAIN構造体へのポインタ。
 5864    \param idx チェーンの開始インデックス。
 5865
 5866    _Example_
 5867    \code
 5868    none
 5869    \endcode
 5870
 5871    \sa wolfSSL_get_peer_chain
 5872    \sa wolfSSL_get_chain_count
 5873    \sa wolfSSL_get_chain_length
 5874    \sa wolfSSL_get_chain_cert_pem
 5875*/
 5876unsigned char* wolfSSL_get_chain_cert(WOLFSSL_X509_CHAIN* chain, int idx);
 5877
 5878/*!
 5879    \ingroup CertsKeys
 5880
 5881    \brief この関数は証明書チェーンからインデックス(idx)にあるピアのwolfSSL_X509_certificateを取得します。
 5882
 5883    \return pointer WOLFSSL_X509構造体へのポインタを返します。
 5884
 5885    \param chain 動的メモリを使用しないSESSION_CACHEに使用されるWOLFSSL_X509_CHAINへのポインタ。
 5886    \param idx WOLFSSL_X509証明書のインデックス。
 5887
 5888    返されたメモリをwolfSSL_FreeX509()を呼び出して解放することはユーザーの責任です。
 5889
 5890    _Example_
 5891    \code
 5892    WOLFSSL_X509_CHAIN* chain = &session->chain;
 5893    int idx = 999; // idxを設定
 5894    ...
 5895    WOLFSSL_X509_CHAIN ptr;
 5896    prt = wolfSSL_get_chain_X509(chain, idx);
 5897
 5898    if(ptr != NULL){
 5899        // ptrは指定されたインデックスの証明書を含みます
 5900        wolfSSL_FreeX509(ptr);
 5901    } else {
 5902        // ptrはNULLです
 5903    }
 5904    \endcode
 5905
 5906    \sa InitDecodedCert
 5907    \sa ParseCertRelative
 5908    \sa CopyDecodedToX509
 5909*/
 5910WOLFSSL_X509* wolfSSL_get_chain_X509(WOLFSSL_X509_CHAIN* chain, int idx);
 5911
 5912/*!
 5913    \ingroup openSSL
 5914
 5915    \brief インデックス(idx)におけるピアのPEM証明書を取得します。
 5916
 5917    \return Success 成功した場合、呼び出しはインデックスによるピアの証明書を返します。
 5918    \return 0 無効なchainポインタが関数に渡された場合に返されます。
 5919
 5920    \param chain 有効なWOLFSSL_X509_CHAIN構造体へのポインタ。    \param idx チェーンの開始インデックス。
 5921
 5922    _Example_
 5923    \code
 5924    none
 5925    \endcode
 5926
 5927    \sa wolfSSL_get_peer_chain
 5928    \sa wolfSSL_get_chain_count
 5929    \sa wolfSSL_get_chain_length
 5930    \sa wolfSSL_get_chain_cert
 5931*/
 5932int  wolfSSL_get_chain_cert_pem(WOLFSSL_X509_CHAIN* chain, int idx,
 5933                                unsigned char* buf, int inLen, int* outLen);
 5934
 5935/*!
 5936    \ingroup openSSL
 5937
 5938    \brief セッションIDを取得します。セッションIDは常に32バイト長です。
 5939
 5940    \return id セッションID。
 5941
 5942    \param session 有効なwolfsslセッションへのポインタ。
 5943
 5944    _Example_
 5945    \code
 5946    none
 5947    \endcode
 5948
 5949    \sa SSL_get_session
 5950*/
 5951const unsigned char* wolfSSL_get_sessionID(const WOLFSSL_SESSION* s);
 5952
 5953/*!
 5954    \ingroup openSSL
 5955
 5956    \brief ピアの証明書シリアル番号を取得します。シリアル番号バッファ(in)は少なくとも32バイト長であり、入力として*inOutSz引数として提供される必要があります。関数を呼び出した後、*inOutSzにはinバッファに書き込まれた実際の長さ(バイト単位)が保持されます。
 5957
 5958    \return SSL_SUCCESS 成功時。
 5959    \return BAD_FUNC_ARG 不正な関数引数が検出された場合に返されます。
 5960
 5961    \param in シリアル番号バッファで、少なくとも32バイト長である必要があります。
 5962    \param inOutSz inバッファに書き込まれた実際の長さ(バイト単位)を保持します。
 5963
 5964    _Example_
 5965    \code
 5966    none
 5967    \endcode
 5968
 5969    \sa SSL_get_peer_certificate
 5970*/
 5971int  wolfSSL_X509_get_serial_number(WOLFSSL_X509* x509, unsigned char* in,
 5972                                    int* inOutSz);
 5973
 5974/*!
 5975    \ingroup CertsKeys
 5976
 5977    \brief 証明書からサブジェクトのコモンネームを返します。
 5978
 5979    \return NULL x509構造体がnullの場合に返されます。
 5980    \return string 成功時にはサブジェクトのコモンネームの文字列表現が返されます。
 5981
 5982    \param x509 証明書情報を含むWOLFSSL_X509構造体へのポインタ。
 5983
 5984    _Example_
 5985    \code
 5986    WOLFSSL_X509 x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 5987							DYNAMIC_TYPE_X509);
 5988    ...
 5989    int x509Cn = wolfSSL_X509_get_subjectCN(x509);
 5990    if(x509Cn == NULL){
 5991	    // NULLケースを処理
 5992    } else {
 5993	    // x509Cnにはコモンネームが含まれる
 5994    }
 5995    \endcode
 5996
 5997    \sa wolfSSL_X509_Name_get_entry
 5998    \sa wolfSSL_X509_get_next_altname
 5999    \sa wolfSSL_X509_get_issuer_name
 6000    \sa wolfSSL_X509_get_subject_name
 6001
 6002*/
 6003char*  wolfSSL_X509_get_subjectCN(WOLFSSL_X509*);
 6004
 6005/*!
 6006    \ingroup CertsKeys
 6007
 6008    \brief この関数は、WOLFSSL_X509構造体内のDERエンコードされた証明書を取得します。
 6009
 6010    \return buffer この関数は、DerBuffer構造体のbufferメンバを返します。これはbyte型です。
 6011    \return NULL x509またはoutSzパラメータがNULLの場合に返されます。
 6012
 6013    \param x509 証明書情報を含むWOLFSSL_X509構造体へのポインタ。
 6014    \param outSz WOLFSSL_X509構造体のderBufferメンバの長さ。
 6015
 6016    _Example_
 6017    \code
 6018    WOLFSSL_X509 x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 6019							DYNAMIC_TYPE_X509);
 6020    int* outSz; // 初期化
 6021    ...
 6022    byte* x509Der = wolfSSL_X509_get_der(x509, outSz);
 6023    if(x509Der == NULL){
 6024	    // 失敗ケース、パラメータの1つがNULLだった
 6025    }
 6026    \endcode
 6027
 6028    \sa wolfSSL_X509_version
 6029    \sa wolfSSL_X509_Name_get_entry
 6030    \sa wolfSSL_X509_get_next_altname
 6031    \sa wolfSSL_X509_get_issuer_name
 6032    \sa wolfSSL_X509_get_subject_name
 6033*/
 6034const unsigned char* wolfSSL_X509_get_der(WOLFSSL_X509* x509, int* outSz);
 6035
 6036/*!
 6037    \ingroup CertsKeys
 6038
 6039    \brief この関数は、x509がNULLであるかどうかをチェックし、そうでない場合はx509構造体のnotAfterメンバを返します。
 6040
 6041    \return pointer x509構造体のnotAfterメンバへのASN1_TIMEを持つ構造体へのポインタ。
 6042    \return NULL x509オブジェクトがNULLの場合に返されます。
 6043
 6044    \param x509 WOLFSSL_X509構造体へのポインタ。
 6045
 6046    _Example_
 6047    \code
 6048    WOLFSSL_X509* x509 = (WOLFSSL_X509)XMALOC(sizeof(WOLFSSL_X509), NULL,
 6049    DYNAMIC_TYPE_X509) ;
 6050    ...
 6051    const WOLFSSL_ASN1_TIME* notAfter = wolfSSL_X509_get_notAfter(x509);
 6052    if(notAfter == NULL){
 6053        // 失敗ケース、x509オブジェクトがnull
 6054    }
 6055    \endcode
 6056
 6057    \sa wolfSSL_X509_get_notBefore
 6058*/
 6059WOLFSSL_ASN1_TIME* wolfSSL_X509_get_notAfter(WOLFSSL_X509*);
 6060
 6061/*!
 6062    \ingroup CertsKeys
 6063
 6064    \brief この関数は、X509証明書のバージョンを取得します。
 6065
 6066    \return 0 x509構造体がNULLの場合に返されます。
 6067    \return version x509構造体に格納されているバージョンが返されます。
 6068
 6069    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6070
 6071    _Example_
 6072    \code
 6073    WOLFSSL_X509* x509;
 6074    int version;
 6075    ...
 6076    version = wolfSSL_X509_version(x509);
 6077    if(!version){
 6078	    // 関数は0を返した、失敗ケース
 6079    }
 6080    \endcode
 6081
 6082    \sa wolfSSL_X509_get_subject_name
 6083    \sa wolfSSL_X509_get_issuer_name
 6084    \sa wolfSSL_X509_get_isCA
 6085    \sa wolfSSL_get_peer_certificate
 6086*/
 6087int wolfSSL_X509_version(WOLFSSL_X509* x509);
 6088
 6089/*!
 6090    \ingroup CertsKeys
 6091
 6092    \brief NO_STDIO_FILESYSTEMが定義されている場合、この関数はヒープメモリを割り当て、WOLFSSL_X509構造体を初期化し、そのポインタを返します。
 6093
 6094    \return *WOLFSSL_X509 関数が正常に実行された場合、WOLFSSL_X509構造体ポインタが返されます。
 6095    \return NULL XFTELLマクロの呼び出しが負の値を返した場合。
 6096
 6097    \param x509 WOLFSSL_X509ポインタへのポインタ。
 6098    \param file FILEへのポインタである定義された型。
 6099
 6100    _Example_
 6101    \code
 6102    WOLFSSL_X509* x509a = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
 6103    DYNAMIC_TYPE_X509);
 6104    WOLFSSL_X509** x509 = x509a;
 6105    XFILE file;  // (struct fs_file*にマップされる)
 6106    ...
 6107    WOLFSSL_X509* newX509 = wolfSSL_X509_d2i_fp(x509, file);
 6108    if(newX509 == NULL){
 6109	    // 関数はNULLを返した
 6110    }
 6111    \endcode
 6112
 6113    \sa wolfSSL_X509_d2i
 6114    \sa XFTELL
 6115    \sa XREWIND
 6116    \sa XFSEEK
 6117*/
 6118WOLFSSL_X509*
 6119        wolfSSL_X509_d2i_fp(WOLFSSL_X509** x509, FILE* file);
 6120
 6121/*!
 6122    \ingroup CertsKeys
 6123
 6124    \brief この関数は、x509証明書をメモリにロードします。
 6125
 6126    \return pointer 正常に実行されると、WOLFSSL_X509構造体へのポインタが返されます。
 6127    \return NULL 証明書を書き込むことができなかった場合に返されます。
 6128
 6129    \param fname ロードする証明書ファイル。
 6130    \param format 証明書のフォーマット。
 6131
 6132    _Example_
 6133    \code
 6134    #define cliCert    "certs/client-cert.pem"
 6135    …
 6136    X509* x509;
 6137    …
 6138    x509 = wolfSSL_X509_load_certificate_file(cliCert, SSL_FILETYPE_PEM);
 6139    AssertNotNull(x509);
 6140    \endcode
 6141
 6142    \sa InitDecodedCert
 6143    \sa PemToDer
 6144    \sa wolfSSL_get_certificate
 6145    \sa AssertNotNull
 6146*/
 6147WOLFSSL_X509*
 6148    wolfSSL_X509_load_certificate_file(const char* fname, int format);
 6149
 6150/*!
 6151    \ingroup CertsKeys
 6152
 6153    \brief この関数は、x509構造体からデバイスタイプをバッファにコピーします。
 6154
 6155    \return pointer x509構造体からデバイスタイプを保持するバイトポインタが返されます。
 6156    \return NULL バッファサイズがNULLの場合に返されます。
 6157
 6158    \param x509 WOLFSSL_X509_new()で作成されたWOLFSSL_X509構造体へのポインタ。
 6159    \param in デバイスタイプ(バッファ)を保持するバイト型へのポインタ。
 6160    \param inOutSz パラメータinOutSzまたはx509構造体のdeviceTypeSzメンバのいずれか小さい方。
 6161
 6162    _Example_
 6163    \code
 6164    WOLFSSL_X509* x509 = (WOLFSSL_X509)XMALOC(sizeof(WOLFSSL_X509), NULL,
 6165    DYNAMIC_TYPE_X509);
 6166    byte* in;
 6167    int* inOutSz;
 6168    ...
 6169    byte* deviceType = wolfSSL_X509_get_device_type(x509, in, inOutSz);
 6170
 6171    if(!deviceType){
 6172	    // 失敗ケース、NULLが返された
 6173    }
 6174    \endcode
 6175
 6176    \sa wolfSSL_X509_get_hw_type
 6177    \sa wolfSSL_X509_get_hw_serial_number
 6178    \sa wolfSSL_X509_d2i
 6179*/
 6180unsigned char*
 6181           wolfSSL_X509_get_device_type(WOLFSSL_X509* x509, unsigned char* in,
 6182                                        int* inOutSz);
 6183
 6184/*!
 6185    \ingroup CertsKeys
 6186
 6187    \brief この関数は、WOLFSSL_X509構造体のhwTypeメンバをバッファにコピーします。
 6188
 6189    \return byte 関数は、以前にWOLFSSL_X509構造体のhwTypeメンバに保持されていたデータのバイト型を返します。
 6190    \return NULL inOutSzがNULLの場合に返されます。
 6191
 6192    \param x509 証明書情報を含むWOLFSSL_X509構造体へのポインタ。
 6193    \param in バッファを表すbyte型へのポインタ。
 6194    \param inOutSz バッファのサイズを表すint型へのポインタ。
 6195
 6196    _Example_
 6197    \code
 6198    WOLFSSL_X509* x509;  // X509証明書
 6199    byte* in;  // バッファを初期化
 6200    int* inOutSz;  // バッファのサイズを保持
 6201    ...
 6202    byte* hwType = wolfSSL_X509_get_hw_type(x509, in, inOutSz);
 6203
 6204    if(hwType == NULL){
 6205	    // 失敗ケース、関数はNULLを返した
 6206    }
 6207    \endcode
 6208
 6209    \sa wolfSSL_X509_get_hw_serial_number
 6210    \sa wolfSSL_X509_get_device_type
 6211*/
 6212unsigned char*
 6213           wolfSSL_X509_get_hw_type(WOLFSSL_X509* x509, unsigned char* in,
 6214                                    int* inOutSz);
 6215
 6216/*!
 6217    \ingroup CertsKeys
 6218
 6219    \brief この関数は、x509オブジェクトのhwSerialNumメンバを返します。
 6220
 6221    \return pointer 関数は、x509オブジェクトからロードされたシリアル番号を含むinバッファへのバイトポインタを返します。
 6222
 6223    \param x509 証明書情報を含むWOLFSSL_X509構造体へのポインタ。
 6224    \param in コピー先のバッファへのポインタ。
 6225    \param inOutSz バッファのサイズへのポインタ。
 6226
 6227    _Example_
 6228    \code
 6229    char* serial;
 6230    byte* in;
 6231    int* inOutSz;
 6232    WOLFSSL_X509 x509;
 6233    ...
 6234    serial = wolfSSL_X509_get_hw_serial_number(x509, in, inOutSz);
 6235
 6236    if(serial == NULL || serial <= 0){
 6237    	// 失敗ケース
 6238    }
 6239    \endcode
 6240
 6241    \sa wolfSSL_X509_get_subject_name
 6242    \sa wolfSSL_X509_get_issuer_name
 6243    \sa wolfSSL_X509_get_isCA
 6244    \sa wolfSSL_get_peer_certificate
 6245    \sa wolfSSL_X509_version
 6246*/
 6247unsigned char*
 6248           wolfSSL_X509_get_hw_serial_number(WOLFSSL_X509* x509,
 6249                                             unsigned char* in, int* inOutSz);
 6250
 6251/*!
 6252    \ingroup IO
 6253
 6254    \brief この関数はクライアント側で呼び出され、ピアの証明書チェーンを取得するのに十分な長さだけサーバーとのSSL/TLSハンドシェイクを開始します。この関数が呼び出されるとき、基礎となる通信チャネルはすでに設定されています。wolfSSL_connect_cert()は、ブロッキングI/Oと非ブロッキングI/Oの両方で動作します。基礎となるI/Oが非ブロッキングの場合、wolfSSL_connect_cert()は、基礎となるI/OがwolfSSL_connect_cert()がハンドシェイクを続行するために必要な処理を満たせないときに戻ります。この場合、wolfSSL_get_error()の呼び出しはSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかを生成します。呼び出しプロセスは、基礎となるI/Oが準備できたときにwolfSSL_connect_cert()の呼び出しを繰り返す必要があり、wolfSSLは中断した場所から再開します。非ブロッキングソケットを使用する場合、何もする必要はありませんが、select()を使用して必要な条件をチェックできます。基礎となるI/OがブロッキングI/Oの場合、wolfSSL_connect_cert()はピアの証明書チェーンが受信されたときにのみ戻ります。
 6255
 6256    \return SSL_SUCCESS 成功時。
 6257    \return SSL_FAILURE SSLセッションパラメータがNULLの場合に返されます。
 6258    \return SSL_FATAL_ERROR エラーが発生した場合に返されます。より詳細なエラーコードを取得するには、wolfSSL_get_error()を呼び出してください。
 6259
 6260    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6261
 6262    _Example_
 6263    \code
 6264    int ret = 0;
 6265    int err = 0;
 6266    WOLFSSL* ssl;
 6267    char buffer[80];
 6268    ...
 6269    ret = wolfSSL_connect_cert(ssl);
 6270    if (ret != SSL_SUCCESS) {
 6271        err = wolfSSL_get_error(ssl, ret);
 6272        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
 6273    }
 6274    \endcode
 6275
 6276    \sa wolfSSL_get_error
 6277    \sa wolfSSL_connect
 6278    \sa wolfSSL_accept
 6279*/int  wolfSSL_connect_cert(WOLFSSL* ssl);
 6280
 6281/*!
 6282    \ingroup openSSL
 6283
 6284    \brief wolfSSL_d2i_PKCS12_bio(d2i_PKCS12_bio)は、WOLFSSL_BIOからWC_PKCS12構造体へPKCS12情報をコピーします。情報は、構造体内でコンテンツ情報のリストとして分割され、オプションのMAC情報を保持する構造体も含まれます。情報がWC_PKCS12構造体内でチャンク(ただし復号されていない)に分割された後、呼び出すことによって解析および復号できます。
 6285
 6286    \return WC_PKCS12 WC_PKCS12構造体へのポインタ。
 6287    \return Failure 関数が失敗した場合、NULLを返します。
 6288
 6289    \param bio PKCS12バッファを読み取るWOLFSSL_BIO構造体。
 6290    \param pkcs12 作成された新しいPKCS12構造体用のWC_PKCS12構造体ポインタ。NULLでも可。
 6291
 6292    _Example_
 6293    \code
 6294    WC_PKCS12* pkcs;
 6295    WOLFSSL_BIO* bio;
 6296    WOLFSSL_X509* cert;
 6297    WOLFSSL_EVP_PKEY* pkey;
 6298    STACK_OF(X509) certs;
 6299    //bioはPKCS12ファイルを読み込みます。
 6300    wolfSSL_d2i_PKCS12_bio(bio, &pkcs);
 6301    wolfSSL_PKCS12_parse(pkcs, "a password", &pkey, &cert, &certs)
 6302    wc_PKCS12_free(pkcs)
 6303    //cert、pkey、およびオプションでcertsスタックを使用します。
 6304    \endcode
 6305
 6306    \sa wolfSSL_PKCS12_parse
 6307    \sa wc_PKCS12_free
 6308*/
 6309WC_PKCS12* wolfSSL_d2i_PKCS12_bio(WOLFSSL_BIO* bio,
 6310                                       WC_PKCS12** pkcs12);
 6311
 6312/*!
 6313    \ingroup openSSL
 6314
 6315    \brief wolfSSL_i2d_PKCS12_bio(i2d_PKCS12_bio)は、WC_PKCS12構造体からWOLFSSL_BIOへ証明書情報をコピーします。
 6316
 6317    \return 1 成功時。
 6318    \return Failure 0。
 6319
 6320    \param bio PKCS12バッファを書き込むWOLFSSL_BIO構造体。
 6321    \param pkcs12 入力としてのPKCS12構造体用のWC_PKCS12構造体。
 6322
 6323    _Example_
 6324    \code
 6325    WC_PKCS12 pkcs12;
 6326    FILE *f;
 6327    byte buffer[5300];
 6328    char file[] = "./test.p12";
 6329    int bytes;
 6330    WOLFSSL_BIO* bio;
 6331    pkcs12 = wc_PKCS12_new();
 6332    f = fopen(file, "rb");
 6333    bytes = (int)fread(buffer, 1, sizeof(buffer), f);
 6334    fclose(f);
 6335    //DERファイルを内部構造に変換します。
 6336    wc_d2i_PKCS12(buffer, bytes, pkcs12);
 6337    bio = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
 6338    //PKCS12構造体をbioに変換します。
 6339    wolfSSL_i2d_PKCS12_bio(bio, pkcs12);
 6340    wc_PKCS12_free(pkcs)
 6341    //bioを使用します。
 6342    \endcode
 6343
 6344    \sa wolfSSL_PKCS12_parse
 6345    \sa wc_PKCS12_free
 6346*/
 6347WC_PKCS12* wolfSSL_i2d_PKCS12_bio(WOLFSSL_BIO* bio,
 6348                                       WC_PKCS12* pkcs12);
 6349
 6350/*!
 6351    \ingroup openSSL
 6352
 6353    \brief PKCS12は、configureコマンドに--enable-opensslextraを追加することで有効にできます。復号にトリプルDESとRC4を使用できるため、opensslextraを有効にする際にこれらの機能も有効にすることを推奨します(--enable-des3 --enable-arc4)。wolfSSLは現在RC2をサポートしていないため、RC2での復号は現在利用できません。これは、OpenSSLコマンドラインで.p12ファイルを作成する際に使用されるデフォルトの暗号化スキームで顕著になる可能性があります。wolfSSL_PKCS12_parse(PKCS12_parse)。この関数が最初に行うことは、存在する場合にMACが正しいかどうかを確認することです。MACが失敗した場合、関数は返され、保存されているコンテンツ情報の復号を試みません。この関数は、各コンテンツ情報を解析してバッグタイプを探し、バッグタイプが既知の場合、必要に応じて復号され、構築中の証明書リストまたは見つかった鍵として保存されます。すべてのバッグを解析した後、見つかった鍵は証明書リストと比較され、一致するペアが見つかります。この一致するペアは、鍵と証明書として返されます。オプションで、見つかった証明書リストはSTACK_OFの証明書として返されます。現時点では、CRL、Secret、またはSafeContentsバッグはスキップされ、解析されません。これらまたは他の「不明な」バッグがスキップされているかどうかは、デバッグ出力を表示することで確認できます。フレンドリ名などの追加属性は、PKCS12ファイルを解析する際にスキップされます。
 6354
 6355    \return SSL_SUCCESS PKCS12の解析が成功した場合。
 6356    \return SSL_FAILURE エラーケースに遭遇した場合。
 6357
 6358    \param pkcs12 解析するWC_PKCS12構造体。
 6359    \param paswd PKCS12を復号するためのパスワード。
 6360    \param pkey PKCS12から復号された秘密鍵を保持する構造体。
 6361    \param cert PKCS12から復号された証明書を保持する構造体。
 6362    \param stack 追加の証明書のオプションスタック。
 6363
 6364    _Example_
 6365    \code
 6366    WC_PKCS12* pkcs;
 6367    WOLFSSL_BIO* bio;
 6368    WOLFSSL_X509* cert;
 6369    WOLFSSL_EVP_PKEY* pkey;
 6370    STACK_OF(X509) certs;
 6371    //bioはPKCS12ファイルを読み込みます。
 6372    wolfSSL_d2i_PKCS12_bio(bio, &pkcs);
 6373    wolfSSL_PKCS12_parse(pkcs, "a password", &pkey, &cert, &certs)
 6374    wc_PKCS12_free(pkcs)
 6375    //cert、pkey、およびオプションでcertsスタックを使用します。
 6376    \endcode
 6377
 6378    \sa wolfSSL_d2i_PKCS12_bio
 6379    \sa wc_PKCS12_free
 6380*/
 6381int wolfSSL_PKCS12_parse(WC_PKCS12* pkcs12, const char* psw,
 6382     WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert, WOLF_STACK_OF(WOLFSSL_X509)** ca);
 6383
 6384/*!
 6385    \ingroup CertsKeys
 6386
 6387    \brief サーバDiffie-Hellmanエフェメラルパラメータの設定。この関数は、サーバがDHEを使用する暗号スイートをネゴシエートする場合に使用されるグループパラメータを設定します。
 6388
 6389    \return SSL_SUCCESS 成功時。
 6390    \return MEMORY_ERROR メモリエラーが発生した場合に返されます。
 6391    \return SIDE_ERROR この関数がSSLサーバではなくSSLクライアントで呼び出された場合に返されます。
 6392
 6393    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6394    \param p Diffie-Hellman素数パラメータ。
 6395    \param pSz pのサイズ。
 6396    \param g Diffie-Hellman「生成元」パラメータ。
 6397    \param gSz gのサイズ。
 6398
 6399    _Example_
 6400    \code
 6401    WOLFSSL* ssl;
 6402    static unsigned char p[] = {...};
 6403    static unsigned char g[] = {...};
 6404    ...
 6405    wolfSSL_SetTmpDH(ssl, p, sizeof(p), g, sizeof(g));
 6406    \endcode
 6407
 6408    \sa SSL_accept
 6409*/
 6410int  wolfSSL_SetTmpDH(WOLFSSL* ssl, const unsigned char* p, int pSz,
 6411                                const unsigned char* g, int gSz);
 6412
 6413/*!
 6414    \ingroup CertsKeys
 6415
 6416    \brief この関数は、Diffie-HellmanパラメータのラッパーであるwolfSSL_SetTMpDH_buffer_wrapperを呼び出します。
 6417
 6418    \return SSL_SUCCESS 実行が成功した場合。
 6419    \return SSL_BAD_FILETYPE ファイルタイプがPEMでなく、ASN.1でもない場合。また、wc_DhParamsLoadが正常に返されなかった場合にも返されます。
 6420    \return SSL_NO_PEM_HEADER PEMヘッダが存在しない場合、PemToDerから返されます。
 6421    \return SSL_BAD_FILE PemToDerでファイルエラーがあった場合に返されます。
 6422    \return SSL_FATAL_ERROR コピーエラーがあった場合、PemToDerから返されます。
 6423    \return MEMORY_E メモリ割り当てエラーがあった場合。
 6424    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合、またはサブルーチンにNULL引数が渡された場合に返されます。
 6425    \return DH_KEY_SIZE_E wolfSSL_SetTmpDH()またはwolfSSL_CTX_SetTmpDH()でキーサイズエラーがある場合に返されます。
 6426    \return SIDE_ERROR wolfSSL_SetTmpDHでサーバ側でない場合に返されます。
 6427
 6428    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6429    \param buf wolfSSL_SetTMpDH_file_wrapperから渡される割り当てられたバッファ。
 6430    \param sz ファイル(wolfSSL_SetTmpDH_file_wrapper内のfname)のサイズを保持するlong int型。
 6431    \param format wolfSSL_SetTmpDH_file_wrapper()から渡される証明書形式の表現である整数型。
 6432
 6433    _Example_
 6434    \code
 6435    Static int wolfSSL_SetTmpDH_file_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
 6436    Const char* fname, int format);
 6437    long sz = 0;
 6438    byte* myBuffer = staticBuffer[FILE_BUFFER_SIZE];
 6439    …
 6440    if(ssl)
 6441        ret = wolfSSL_SetTmpDH_buffer(ssl, myBuffer, sz, format);
 6442    \endcode
 6443
 6444    \sa wolfSSL_SetTmpDH_buffer_wrapper
 6445    \sa wc_DhParamsLoad
 6446    \sa wolfSSL_SetTmpDH
 6447    \sa PemToDer
 6448    \sa wolfSSL_CTX_SetTmpDH
 6449    \sa wolfSSL_CTX_SetTmpDH_file
 6450*/
 6451int  wolfSSL_SetTmpDH_buffer(WOLFSSL* ssl, const unsigned char* b, long sz,
 6452                                       int format);
 6453
 6454/*!
 6455    \ingroup CertsKeys
 6456
 6457    \brief この関数は、wolfSSL_SetTmpDH_file_wrapperを呼び出してサーバDiffie-Hellmanパラメータを設定します。
 6458
 6459    \return SSL_SUCCESS この関数とそのサブルーチンが正常に完了した場合に返されます。
 6460    \return MEMORY_E この関数またはサブルーチンでメモリ割り当てが失敗した場合に返されます。
 6461    \return SIDE_ERROR WOLFSSL構造体内のOptions構造体のsideメンバがサーバ側でない場合。
 6462    \return SSL_BAD_FILETYPE 証明書が一連のチェックに失敗した場合に返されます。
 6463    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL構造体のminDhKeySzメンバの値より小さい場合に返されます。
 6464    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL構造体のmaxDhKeySzメンバの値より大きい場合に返されます。
 6465    \return BAD_FUNC_ARG WOLFSSL構造体など、許可されていない引数値がNULLの場合に返されます。
 6466
 6467    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6468    \param fname 証明書を保持する定数char型ポインタ。
 6469    \param format 証明書の形式を保持する整数型。
 6470
 6471    _Example_
 6472    \code
 6473    WOLFSSL* ssl = wolfSSL_new(ctx);
 6474    const char* dhParam;
 6475    …
 6476    AssertIntNE(SSL_SUCCESS,
 6477        wolfSSL_SetTmpDH_file(ssl, dhParam, SSL_FILETYPE_PEM));
 6478    \endcode
 6479
 6480    \sa wolfSSL_CTX_SetTmpDH_file
 6481    \sa wolfSSL_SetTmpDH_file_wrapper
 6482    \sa wolfSSL_SetTmpDH_buffer
 6483    \sa wolfSSL_CTX_SetTmpDH_buffer
 6484    \sa wolfSSL_SetTmpDH_buffer_wrapper
 6485    \sa wolfSSL_SetTmpDH
 6486    \sa wolfSSL_CTX_SetTmpDH
 6487*/
 6488int  wolfSSL_SetTmpDH_file(WOLFSSL* ssl, const char* f, int format);
 6489
 6490/*!
 6491    \ingroup CertsKeys
 6492
 6493    \brief サーバCTX Diffie-Hellmanのパラメータを設定します。
 6494
 6495    \return SSL_SUCCESS 関数とすべてのサブルーチンがエラーなく返された場合に返されます。
 6496    \return BAD_FUNC_ARG CTX、pまたはgパラメータがNULLの場合に返されます。
 6497    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL_CTX構造体のminDhKeySzメンバの値より小さい場合に返されます。
 6498    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL_CTX構造体のmaxDhKeySzメンバの値より大きい場合に返されます。
 6499    \return MEMORY_E この関数またはサブルーチンでメモリ割り当てが失敗した場合に返されます。
 6500
 6501    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6502    \param p serverDH_P構造体のbufferメンバに読み込まれる定数unsigned char型ポインタ。
 6503    \param pSz pのサイズを表すint型で、MAX_DH_SIZEに初期化されます。
 6504    \param g serverDH_G構造体のbufferメンバに読み込まれる定数unsigned char型ポインタ。
 6505    \param gSz gのサイズを表すint型で、MAX_DH_SIZEに初期化されます。
 6506
 6507    _Exmaple_
 6508    \code
 6509    WOLFSSL_CTX* ctx =  WOLFSSL_CTX_new( protocol );
 6510    byte* p;
 6511    byte* g;
 6512    word32 pSz = (word32)sizeof(p)/sizeof(byte);
 6513    word32 gSz = (word32)sizeof(g)/sizeof(byte);
 6514    …
 6515    int ret =  wolfSSL_CTX_SetTmpDH(ctx, p, pSz, g, gSz);
 6516
 6517    if(ret != SSL_SUCCESS){
 6518    	// 失敗ケース
 6519    }
 6520    \endcode
 6521
 6522    \sa wolfSSL_SetTmpDH
 6523    \sa wc_DhParamsLoad
 6524*/
 6525int  wolfSSL_CTX_SetTmpDH(WOLFSSL_CTX* ctx, const unsigned char* p,
 6526                                    int pSz, const unsigned char* g, int gSz);
 6527
 6528/*!
 6529    \ingroup CertsKeys
 6530
 6531    \brief wolfSSL_SetTmpDH_buffer_wrapperを呼び出すラッパー関数です。
 6532
 6533    \return 0 実行が成功した場合に返されます。
 6534    \return BAD_FUNC_ARG ctxまたはbufパラメータがNULLの場合に返されます。
 6535    \return MEMORY_E メモリ割り当てエラーがある場合。
 6536    \return SSL_BAD_FILETYPE formatが正しくない場合に返されます。
 6537
 6538    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6539    \param buf バッファとして割り当てられ、wolfSSL_SetTmpDH_buffer_wrapperに渡される定数unsigned char型へのポインタ。
 6540    \param sz wolfSSL_SetTmpDH_file_wrapper()のfnameパラメータから導出されるlong整数型。
 6541    \param format wolfSSL_SetTmpDH_file_wrapper()から渡される整数型。
 6542
 6543    _Example_
 6544    \code
 6545    static int wolfSSL_SetTmpDH_file_wrapper(WOLFSSL_CTX* ctx, WOLFSSL* ssl,
 6546        Const char* fname, int format);
 6547    #ifdef WOLFSSL_SMALL_STACK
 6548    byte staticBuffer[1]; // ヒープ使用を強制
 6549    #else
 6550    byte* staticBuffer;
 6551    long sz = 0;
 6552    …
 6553    if(ssl){
 6554    	ret = wolfSSL_SetTmpDH_buffer(ssl, myBuffer, sz, format);
 6555    } else {
 6556        ret = wolfSSL_CTX_SetTmpDH_buffer(ctx, myBuffer, sz, format);
 6557    }
 6558    \endcode
 6559
 6560    \sa wolfSSL_SetTmpDH_buffer_wrapper
 6561    \sa wolfSSL_SetTMpDH_buffer
 6562    \sa wolfSSL_SetTmpDH_file_wrapper
 6563    \sa wolfSSL_CTX_SetTmpDH_file
 6564*/
 6565int  wolfSSL_CTX_SetTmpDH_buffer(WOLFSSL_CTX* ctx, const unsigned char* b,
 6566                                           long sz, int format);
 6567
 6568/*!
 6569    \ingroup CertsKeys
 6570
 6571    \brief この関数は、wolfSSL_SetTmpDH_file_wrapperを呼び出してサーバDiffie-Hellmanパラメータを設定します。
 6572
 6573    \return SSL_SUCCESS wolfSSL_SetTmpDH_file_wrapperまたはそのサブルーチンのいずれかが正常に返された場合に返されます。
 6574    \return MEMORY_E サブルーチンで動的メモリの割り当てが失敗した場合に返されます。
 6575    \return BAD_FUNC_ARG ctxまたはfnameパラメータがNULLの場合、またはサブルーチンにNULL引数が渡された場合に返されます。
 6576    \return SSL_BAD_FILE 証明書ファイルを開けない場合、またはwolfSSL_SetTmpDH_file_wrapperからのファイルに対する一連のチェックが失敗した場合に返されます。
 6577    \return SSL_BAD_FILETYPE wolfSSL_SetTmpDH_buffer_wrapper()から、形式がPEMでもASN.1でもない場合に返されます。
 6578    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL_CTX構造体のminDhKeySzメンバの値より小さい場合に返されます。
 6579    \return DH_KEY_SIZE_E DHパラメータの鍵サイズがWOLFSSL_CTX構造体のmaxDhKeySzメンバの値より大きい場合に返されます。
 6580    \return SIDE_ERROR サーバ側でない場合、wolfSSL_SetTmpDH()で返されます。
 6581    \return SSL_NO_PEM_HEADER PEMヘッダがない場合、PemToDerから返されます。
 6582    \return SSL_FATAL_ERROR メモリコピーの失敗がある場合、PemToDerから返されます。
 6583
 6584    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6585    \param fname 証明書ファイルへの定数文字ポインタ。
 6586    \param format 証明書形式の表現である、wolfSSL_SetTmpDH_file_wrapper()から渡される整数型。
 6587
 6588    _Example_
 6589    \code
 6590    #define dhParam     "certs/dh2048.pem"
 6591    #DEFINE aSSERTiNTne(x, y)     AssertInt(x, y, !=, ==)
 6592    WOLFSSL_CTX* ctx;
 6593    …
 6594    AssertNotNull(ctx = wolfSSL_CTX_new(wolfSSLv23_client_method()))
 6595    …
 6596    AssertIntNE(SSL_SUCCESS, wolfSSL_CTX_SetTmpDH_file(NULL, dhParam,
 6597        SSL_FILETYPE_PEM));
 6598    \endcode
 6599
 6600    \sa wolfSSL_SetTmpDH_buffer_wrapper
 6601    \sa wolfSSL_SetTmpDH
 6602    \sa wolfSSL_CTX_SetTmpDH
 6603    \sa wolfSSL_SetTmpDH_buffer
 6604    \sa wolfSSL_CTX_SetTmpDH_buffer    \sa wolfSSL_SetTmpDH_file_wrapper
 6605    \sa AllocDer
 6606    \sa PemToDer
 6607*/
 6608int  wolfSSL_CTX_SetTmpDH_file(WOLFSSL_CTX* ctx, const char* f,
 6609                                             int format);
 6610
 6611/*!
 6612    \ingroup CertsKeys
 6613
 6614    \brief この関数は、WOLFSSL_CTX構造体のminDhKeySzメンバにアクセスして、Diffie-Hellman鍵サイズの最小サイズ(ビット単位)を設定します。
 6615
 6616    \return SSL_SUCCESS 関数が正常に完了した場合に返されます。
 6617    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはkeySz_bitsが16,000より大きいか8で割り切れない場合に返されます。
 6618
 6619    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6620    \param keySz_bits 最小DH鍵サイズをビット単位で設定するために使用されるword16型。WOLFSSL_CTX構造体はこの情報をminDhKeySzメンバに保持します。
 6621
 6622    _Example_
 6623    \code
 6624    public static int CTX_SetMinDhKey_Sz(IntPtr ctx, short minDhKey){
 6625        …
 6626        return wolfSSL_CTX_SetMinDhKey_Sz(local_ctx, minDhKeyBits);
 6627    \endcode
 6628
 6629    \sa wolfSSL_SetMinDhKey_Sz
 6630    \sa wolfSSL_CTX_SetMaxDhKey_Sz
 6631    \sa wolfSSL_SetMaxDhKey_Sz
 6632    \sa wolfSSL_GetDhKey_Sz
 6633    \sa wolfSSL_CTX_SetTMpDH_file
 6634*/
 6635int wolfSSL_CTX_SetMinDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz_bits);
 6636
 6637/*!
 6638    \ingroup CertsKeys
 6639
 6640    \brief WOLFSSL構造体内のDiffie-Hellman鍵の最小サイズ(ビット単位)を設定します。
 6641
 6642    \return SSL_SUCCESS 最小サイズが正常に設定されました。
 6643    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合、またはkeySz_bitsが16,000より大きいか8で割り切れない場合。
 6644
 6645    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6646    \param keySz_bits 最小DH鍵サイズをビット単位で設定するために使用されるword16型。WOLFSSL_CTX構造体はこの情報をminDhKeySzメンバに保持します。
 6647
 6648    _Example_
 6649    \code
 6650    WOLFSSL* ssl = wolfSSL_new(ctx);
 6651    word16 keySz_bits;
 6652    ...
 6653    if(wolfSSL_SetMinDhKey_Sz(ssl, keySz_bits) != SSL_SUCCESS){
 6654	    // 設定に失敗しました
 6655    }
 6656    \endcode
 6657
 6658    \sa wolfSSL_CTX_SetMinDhKey_Sz
 6659    \sa wolfSSL_GetDhKey_Sz
 6660*/
 6661int wolfSSL_SetMinDhKey_Sz(WOLFSSL* ssl, word16 keySz_bits);
 6662
 6663/*!
 6664    \ingroup CertsKeys
 6665
 6666    \brief この関数は、WOLFSSL_CTX構造体のmaxDhKeySzメンバにアクセスして、Diffie-Hellman鍵サイズの最大サイズ(ビット単位)を設定します。
 6667
 6668    \return SSL_SUCCESS 関数が正常に完了した場合に返されます。
 6669    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはkeySz_bitsが16,000より大きいか8で割り切れない場合に返されます。
 6670
 6671    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6672    \param keySz_bits 最大DH鍵サイズをビット単位で設定するために使用されるword16型。WOLFSSL_CTX構造体はこの情報をmaxDhKeySzメンバに保持します。
 6673
 6674    _Example_
 6675    \code
 6676    public static int CTX_SetMaxDhKey_Sz(IntPtr ctx, short maxDhKey){
 6677        …
 6678        return wolfSSL_CTX_SetMaxDhKey_Sz(local_ctx, keySz_bits);
 6679    \endcode
 6680
 6681    \sa wolfSSL_SetMinDhKey_Sz
 6682    \sa wolfSSL_CTX_SetMinDhKey_Sz
 6683    \sa wolfSSL_SetMaxDhKey_Sz
 6684    \sa wolfSSL_GetDhKey_Sz
 6685    \sa wolfSSL_CTX_SetTMpDH_file
 6686*/
 6687int wolfSSL_CTX_SetMaxDhKey_Sz(WOLFSSL_CTX* ctx, word16 keySz_bits);
 6688
 6689/*!
 6690    \ingroup CertsKeys
 6691
 6692    \brief WOLFSSL構造体内のDiffie-Hellman鍵の最大サイズ(ビット単位)を設定します。
 6693
 6694    \return SSL_SUCCESS 最大サイズが正常に設定されました。
 6695    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合、またはkeySzパラメータが許容サイズより大きいか8で割り切れない場合。
 6696
 6697    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6698    \param keySz 最大DH鍵のビットサイズを表すword16型。
 6699
 6700    _Example_
 6701    \code
 6702    WOLFSSL* ssl = wolfSSL_new(ctx);
 6703    word16 keySz;
 6704    ...
 6705    if(wolfSSL_SetMaxDhKey(ssl, keySz) != SSL_SUCCESS){
 6706	    // 設定に失敗しました
 6707    }
 6708    \endcode
 6709
 6710    \sa wolfSSL_CTX_SetMaxDhKey_Sz
 6711    \sa wolfSSL_GetDhKey_Sz
 6712*/
 6713int wolfSSL_SetMaxDhKey_Sz(WOLFSSL* ssl, word16 keySz_bits);
 6714
 6715/*!
 6716    \ingroup CertsKeys
 6717
 6718    \brief options構造体のメンバであるdhKeySzの値(ビット単位)を返します。この値は、Diffie-Hellman鍵サイズをバイト単位で表します。
 6719
 6720    \return dhKeySz ssl->options.dhKeySzに保持されている値を返します。これはビット単位のサイズを表す整数値です。
 6721    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
 6722
 6723    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6724
 6725    _Example_
 6726    \code
 6727    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 6728    WOLFSSL* ssl = wolfSSL_new(ctx);
 6729    int dhKeySz;
 6730    ...
 6731    dhKeySz = wolfSSL_GetDhKey_Sz(ssl);
 6732
 6733    if(dhKeySz == BAD_FUNC_ARG || dhKeySz <= 0){
 6734    	// 失敗ケース
 6735    } else {
 6736    	// dhKeySzは鍵のサイズを保持しています
 6737    }
 6738    \endcode
 6739
 6740    \sa wolfSSL_SetMinDhKey_sz
 6741    \sa wolfSSL_CTX_SetMinDhKey_Sz
 6742    \sa wolfSSL_CTX_SetTmpDH
 6743    \sa wolfSSL_SetTmpDH
 6744    \sa wolfSSL_CTX_SetTmpDH_file
 6745*/
 6746int wolfSSL_GetDhKey_Sz(WOLFSSL* ssl);
 6747
 6748/*!
 6749    \ingroup CertsKeys
 6750
 6751    \brief WOLFSSL_CTX構造体とWOLFSSL_CERT_MANAGER構造体の両方で最小RSA鍵サイズを設定します。
 6752
 6753    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。
 6754    \return BAD_FUNC_ARG ctx構造体がNULLの場合、またはkeySzがゼロ未満か8で割り切れない場合に返されます。
 6755
 6756    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6757    \param keySz ctx構造体とcm構造体のminRsaKeySzに格納され、バイトに変換されるshort整数型。
 6758
 6759    _Example_
 6760    \code
 6761    WOLFSSL_CTX* ctx = SSL_CTX_new(method);
 6762    (void)minDhKeyBits;
 6763    ourCert = myoptarg;
 6764    …
 6765    minDhKeyBits = atoi(myoptarg);
 6766    …
 6767    if(wolfSSL_CTX_SetMinRsaKey_Sz(ctx, minRsaKeyBits) != SSL_SUCCESS){
 6768        …
 6769    \endcode
 6770
 6771    \sa wolfSSL_SetMinRsaKey_Sz
 6772*/
 6773int wolfSSL_CTX_SetMinRsaKey_Sz(WOLFSSL_CTX* ctx, short keySz);
 6774
 6775/*!
 6776    \ingroup CertsKeys
 6777
 6778    \brief WOLFSSL構造体にあるRSAの最小許容鍵サイズをビット単位で設定します。
 6779
 6780    \return SSL_SUCCESS 最小値が正常に設定されました。
 6781    \return BAD_FUNC_ARG ssl構造体がNULLの場合、またはksySzがゼロ未満か8で割り切れない場合に返されます。
 6782
 6783    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6784    \param keySz 最小鍵をビット単位で表すshort整数値。
 6785
 6786    _Example_
 6787    \code
 6788    WOLFSSL* ssl = wolfSSL_new(ctx);
 6789    short keySz;
 6790    …
 6791
 6792    int isSet =  wolfSSL_SetMinRsaKey_Sz(ssl, keySz);
 6793    if(isSet != SSL_SUCCESS){
 6794	    設定に失敗しました
 6795    }
 6796    \endcode
 6797
 6798    \sa wolfSSL_CTX_SetMinRsaKey_Sz
 6799*/
 6800int wolfSSL_SetMinRsaKey_Sz(WOLFSSL* ssl, short keySz);
 6801
 6802/*!
 6803    \ingroup CertsKeys
 6804
 6805    \brief WOLF_CTX構造体とWOLFSSL_CERT_MANAGER構造体でECC鍵の最小サイズをビット単位で設定します。
 6806
 6807    \return SSL_SUCCESS 実行が成功し、minEccKeySzメンバが設定された場合に返されます。
 6808    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはkeySzが負の値か8で割り切れない場合に返されます。
 6809
 6810    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6811    \param keySz 最小ECC鍵サイズをビット単位で表すshort整数型。
 6812
 6813    _Example_
 6814    \code
 6815    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 6816    short keySz; // 最小鍵サイズ
 6817    …
 6818    if(wolfSSL_CTX_SetMinEccKey(ctx, keySz) != SSL_SUCCESS){
 6819	    // 最小鍵サイズの設定に失敗しました
 6820    }
 6821    \endcode
 6822
 6823    \sa wolfSSL_SetMinEccKey_Sz
 6824*/
 6825int wolfSSL_CTX_SetMinEccKey_Sz(WOLFSSL_CTX* ctx, short keySz);
 6826
 6827/*!
 6828    \ingroup CertsKeys
 6829
 6830    \brief options構造体のminEccKeySzメンバの値を設定します。options構造体はWOLFSSL構造体のメンバであり、sslパラメータを通じてアクセスされます。
 6831
 6832    \return SSL_SUCCESS 関数がoptions構造体のminEccKeySzメンバを正常に設定した場合。
 6833    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、または鍵サイズ(keySz)が0未満か8で割り切れない場合。
 6834
 6835    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6836    \param keySz 最小ECC鍵サイズを設定するために使用される値。options構造体に値を設定します。
 6837
 6838    _Example_
 6839    \code
 6840    WOLFSSL* ssl = wolfSSL_new(ctx); // 新しいセッション
 6841    short keySz = 999; // 許容される最小鍵サイズに設定すべきです
 6842    ...
 6843    if(wolfSSL_SetMinEccKey_Sz(ssl, keySz) != SSL_SUCCESS){
 6844	    // 失敗ケース
 6845    }
 6846    \endcode
 6847
 6848    \sa wolfSSL_CTX_SetMinEccKey_Sz
 6849    \sa wolfSSL_CTX_SetMinRsaKey_Sz
 6850    \sa wolfSSL_SetMinRsaKey_Sz
 6851*/
 6852int wolfSSL_SetMinEccKey_Sz(WOLFSSL* ssl, short keySz);
 6853
 6854/*!
 6855    \ingroup CertsKeys
 6856
 6857    \brief この関数は、マスターシークレットから鍵材料を導出するためにEAP_TLSとEAP-TTLSによって使用されます。
 6858
 6859    \return BUFFER_E バッファの実際のサイズが許容される最大サイズを超えた場合に返されます。
 6860    \return MEMORY_E メモリ割り当てでエラーが発生した場合に返されます。
 6861
 6862    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 6863    \param key p_hash関数の結果を保持するvoidポインタ変数。
 6864    \param len key変数の長さを表すunsigned整数。
 6865    \param label wc_PRF()でコピーされる定数charポインタ。
 6866
 6867    _Example_
 6868    \code
 6869    WOLFSSL* ssl = wolfSSL_new(ctx);;
 6870    void* key;
 6871    unsigned int len;
 6872    const char* label;
 6873    …
 6874    return wolfSSL_make_eap_keys(ssl, key, len, label);
 6875    \endcode
 6876
 6877    \sa wc_PRF
 6878    \sa wc_HmacFinal
 6879    \sa wc_HmacUpdate
 6880*/
 6881int wolfSSL_make_eap_keys(WOLFSSL* ssl, void* key, unsigned int len,
 6882                                                             const char* label);
 6883
 6884/*!
 6885    \ingroup IO
 6886
 6887    \brief writevのセマンティクスをシミュレートしますが、SSL_write()の動作とフロント追加が小さい場合があるため、実際には一度にブロック単位では行いません。writevを使用するソフトウェアへの移植を容易にします。
 6888
 6889    \return ＞0 成功時、書き込まれたバイト数。
 6890    \return 0 失敗時に返されます。wolfSSL_get_error()を呼び出して特定のエラーコードを取得してください。
 6891    \return MEMORY_ERROR メモリエラーが発生した場合に返されます。
 6892    \return SSL_FATAL_ERROR エラーが発生した場合、またはノンブロッキングソケットを使用しているときにSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEエラーを受信し、アプリケーションがwolfSSL_write()を再度呼び出す必要がある場合に返されます。wolfSSL_get_error()を使用して特定のエラーコードを取得してください。
 6893
 6894    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 6895    \param iov 書き込むI/Oベクトルの配列。
 6896    \param iovcnt iov配列内のベクトル数。
 6897
 6898    _Example_
 6899    \code
 6900    WOLFSSL* ssl = 0;
 6901    char *bufA = "hello\n";
 6902    char *bufB = "hello world\n";
 6903    int iovcnt;
 6904    struct iovec iov[2];
 6905
 6906    iov[0].iov_base = buffA;
 6907    iov[0].iov_len = strlen(buffA);
 6908    iov[1].iov_base = buffB;
 6909    iov[1].iov_len = strlen(buffB);
 6910    iovcnt = 2;
 6911    ...
 6912    ret = wolfSSL_writev(ssl, iov, iovcnt);
 6913    // "ret"バイトを書き込みました。または<=0の場合はエラー
 6914    \endcode
 6915
 6916    \sa wolfSSL_write
 6917*/
 6918int wolfSSL_writev(WOLFSSL* ssl, const struct iovec* iov,
 6919                                     int iovcnt);
 6920
 6921/*!
 6922    \ingroup Setup
 6923
 6924    \brief この関数は、CA署名者リストをアンロードし、署名者テーブル全体を解放します。
 6925
 6926    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。
 6927    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはサブルーチンで許可されない引数値が渡された場合に返されます。
 6928    \return BAD_MUTEX_E mutexエラーが発生した場合に返されます。LockMutex()が0を返しませんでした。
 6929
 6930    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6931
 6932    _Example_
 6933    \code
 6934    WOLFSSL_METHOD method = wolfTLSv1_2_client_method();
 6935    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(method);
 6936    …
 6937    if(wolfSSL_CTX_UnloadCAs(ctx) != SSL_SUCCESS){
 6938    	// 関数はCAをアンロードしませんでした
 6939    }
 6940    \endcode
 6941
 6942    \sa wolfSSL_CertManagerUnloadCAs
 6943    \sa LockMutex
 6944    \sa UnlockMutex
 6945*/
 6946int wolfSSL_CTX_UnloadCAs(WOLFSSL_CTX* ctx);
 6947
 6948
 6949/*!
 6950    \ingroup Setup
 6951
 6952    \brief この関数は、CA署名者リストに追加された中間証明書をアンロードし、解放します。
 6953
 6954    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。
 6955    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはサブルーチンで許可されない引数値が渡された場合に返されます。
 6956    \return BAD_STATE_E WOLFSSL_CTXの参照カウントが1より大きい場合に返されます。    \return BAD_MUTEX_E mutexエラーが発生した場合に返されます。LockMutex()が0を返しませんでした。
 6957
 6958    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 6959
 6960    _Example_
 6961    \code
 6962    WOLFSSL_METHOD method = wolfTLSv1_2_client_method();
 6963    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(method);
 6964    …
 6965    if(wolfSSL_CTX_UnloadIntermediateCerts(ctx) != NULL){
 6966        // 関数はCAをアンロードしませんでした
 6967    }
 6968    \endcode
 6969
 6970    \sa wolfSSL_CTX_UnloadCAs
 6971    \sa wolfSSL_CertManagerUnloadIntermediateCerts
 6972*/
 6973int wolfSSL_CTX_UnloadIntermediateCerts(WOLFSSL_CTX* ctx);
 6974
 6975/*!
 6976    \ingroup Setup
 6977
 6978    \brief この関数は以前にロードされたすべての信頼されたピア証明書をアンロードするために使用されます。この機能は、マクロWOLFSSL_TRUST_PEER_CERTを定義することで有効になります。
 6979
 6980    \return SSL_SUCCESS 成功時。
 6981    \return BAD_FUNC_ARG ctxがNULLの場合に返されます。
 6982    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 6983    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 6984
 6985    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 6986
 6987    _Example_
 6988    \code
 6989    int ret = 0;
 6990    WOLFSSL_CTX* ctx;
 6991    ...
 6992    ret = wolfSSL_CTX_Unload_trust_peers(ctx);
 6993    if (ret != SSL_SUCCESS) {
 6994        // 信頼されたピア証明書のアンロードエラー
 6995    }
 6996    ...
 6997    \endcode
 6998
 6999    \sa wolfSSL_CTX_trust_peer_buffer
 7000    \sa wolfSSL_CTX_trust_peer_cert
 7001*/
 7002int wolfSSL_CTX_Unload_trust_peers(WOLFSSL_CTX* ctx);
 7003
 7004/*!
 7005    \ingroup Setup
 7006
 7007    \brief この関数は、TLS/SSLハンドシェイクを実行する際にピアを検証するために使用する証明書をロードします。ハンドシェイク中に送信されるピア証明書は、利用可能な場合はSKIDと署名を使用して比較されます。これら2つが一致しない場合は、ロードされたCAが使用されます。ファイルではなくバッファからの入力である点を除いて、wolfSSL_CTX_trust_peer_certと同じ機能です。この機能は、マクロWOLFSSL_TRUST_PEER_CERTを定義することで有効になります。適切な使用方法については例を参照してください。
 7008
 7009    \return SSL_SUCCESS 成功時。
 7010    \return SSL_FAILURE ctxがNULL、またはfileとtypeの両方が無効な場合に返されます。
 7011    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7012    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7013    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7014    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7015
 7016    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7017    \param buffer 証明書を含むバッファへのポインタ。
 7018    \param sz 入力バッファの長さ。
 7019    \param type ロードされる証明書のタイプ、すなわちSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 7020
 7021    _Example_
 7022    \code
 7023    int ret = 0;
 7024    WOLFSSL_CTX* ctx;
 7025    ...
 7026
 7027    ret = wolfSSL_CTX_trust_peer_buffer(ctx, bufferPtr, bufferSz,
 7028    SSL_FILETYPE_PEM);
 7029    if (ret != SSL_SUCCESS) {
 7030        // 信頼されたピア証明書のロードエラー
 7031    }
 7032    ...
 7033    \endcode
 7034
 7035    \sa wolfSSL_CTX_load_verify_buffer
 7036    \sa wolfSSL_CTX_use_certificate_file
 7037    \sa wolfSSL_CTX_use_PrivateKey_file
 7038    \sa wolfSSL_CTX_use_certificate_chain_file
 7039    \sa wolfSSL_CTX_trust_peer_cert
 7040    \sa wolfSSL_CTX_Unload_trust_peers
 7041    \sa wolfSSL_use_certificate_file
 7042    \sa wolfSSL_use_PrivateKey_file
 7043    \sa wolfSSL_use_certificate_chain_file
 7044*/
 7045int wolfSSL_CTX_trust_peer_buffer(WOLFSSL_CTX* ctx, const unsigned char* in,
 7046                                  long sz, int format);
 7047
 7048/*!
 7049    \ingroup CertsKeys
 7050
 7051    \brief この関数はCA証明書バッファをWOLFSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファの形式タイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。形式がPEMであれば、1つのバッファに複数のCA証明書をロードできます。適切な使用方法については例を参照してください。
 7052
 7053    \return SSL_SUCCESS 成功時。
 7054    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7055    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7056    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7057    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7058    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
 7059
 7060    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7061    \param in CA証明書バッファへのポインタ。
 7062    \param sz 入力CA証明書バッファ(in)のサイズ。
 7063    \param format バッファ証明書の形式、SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 7064
 7065    _Example_
 7066    \code
 7067    int ret = 0;
 7068    WOLFSSL_CTX* ctx;
 7069    byte certBuff[...];
 7070    long sz = sizeof(certBuff);
 7071    ...
 7072
 7073    ret = wolfSSL_CTX_load_verify_buffer(ctx, certBuff, sz, SSL_FILETYPE_PEM);
 7074    if (ret != SSL_SUCCESS) {
 7075    	// バッファからのCA証明書のロードエラー
 7076    }
 7077    ...
 7078    \endcode
 7079
 7080    \sa wolfSSL_CTX_load_verify_locations
 7081    \sa wolfSSL_CTX_use_certificate_buffer
 7082    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7083    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7084    \sa wolfSSL_use_certificate_buffer
 7085    \sa wolfSSL_use_PrivateKey_buffer
 7086    \sa wolfSSL_use_certificate_chain_buffer
 7087*/
 7088int wolfSSL_CTX_load_verify_buffer(WOLFSSL_CTX* ctx, const unsigned char* in,
 7089                                   long sz, int format);
 7090
 7091
 7092/*!
 7093    \ingroup CertsKeys
 7094
 7095    \brief この関数はCA証明書バッファをWOLFSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファの形式タイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。形式がPEMであれば、1つのバッファに複数のCA証明書をロードできます。_ex版はPR 2413で追加され、userChainとflagsの追加引数をサポートします。
 7096
 7097    \return SSL_SUCCESS 成功時。
 7098    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7099    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7100    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7101    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7102    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
 7103
 7104    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7105    \param in CA証明書バッファへのポインタ。
 7106    \param sz 入力CA証明書バッファ(in)のサイズ。
 7107    \param format バッファ証明書の形式、SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 7108    \param userChain 形式WOLFSSL_FILETYPE_ASN1を使用している場合、これを非ゼロに設定すると、DERのチェーンが提示されていることを示します。
 7109    \param flags ssl.hのWOLFSSL_LOAD_VERIFY_DEFAULT_FLAGS付近を参照してください。
 7110
 7111    _Example_
 7112    \code
 7113    int ret = 0;
 7114    WOLFSSL_CTX* ctx;
 7115    byte certBuff[...];
 7116    long sz = sizeof(certBuff);
 7117    ...
 7118
 7119    // 期限切れ証明書を強制的にロードする例
 7120    ret = wolfSSL_CTX_load_verify_buffer_ex(ctx, certBuff, sz, SSL_FILETYPE_PEM,
 7121        0, (WOLFSSL_LOAD_FLAG_DATE_ERR_OKAY));
 7122    if (ret != SSL_SUCCESS) {
 7123    	// バッファからのCA証明書のロードエラー
 7124    }
 7125    ...
 7126    \endcode
 7127
 7128    \sa wolfSSL_CTX_load_verify_buffer
 7129    \sa wolfSSL_CTX_load_verify_locations
 7130    \sa wolfSSL_CTX_use_certificate_buffer
 7131    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7132    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7133    \sa wolfSSL_use_certificate_buffer
 7134    \sa wolfSSL_use_PrivateKey_buffer
 7135    \sa wolfSSL_use_certificate_chain_buffer
 7136*/
 7137int wolfSSL_CTX_load_verify_buffer_ex(WOLFSSL_CTX* ctx,
 7138                                      const unsigned char* in, long sz,
 7139                                      int format, int userChain, word32 flags);
 7140
 7141/*!
 7142    \ingroup CertsKeys
 7143
 7144    \brief この関数はCA証明書チェーンバッファをWOLFSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファの形式タイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。形式がPEMであれば、1つのバッファに複数のCA証明書をロードできます。適切な使用方法については例を参照してください。
 7145
 7146    \return SSL_SUCCESS 成功時。
 7147    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7148    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7149    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7150    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7151    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
 7152
 7153    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7154    \param in CA証明書バッファへのポインタ。
 7155    \param sz 入力CA証明書バッファ(in)のサイズ。
 7156    \param format バッファ証明書の形式、SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 7157
 7158    _Example_
 7159    \code
 7160    int ret = 0;
 7161    WOLFSSL_CTX* ctx;
 7162    byte certBuff[...];
 7163    long sz = sizeof(certBuff);
 7164    ...
 7165
 7166    ret = wolfSSL_CTX_load_verify_chain_buffer_format(ctx,
 7167                         certBuff, sz, WOLFSSL_FILETYPE_ASN1);
 7168    if (ret != SSL_SUCCESS) {
 7169        // バッファからのCA証明書のロードエラー
 7170    }
 7171    ...
 7172    \endcode
 7173
 7174    \sa wolfSSL_CTX_load_verify_locations
 7175    \sa wolfSSL_CTX_use_certificate_buffer
 7176    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7177    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7178    \sa wolfSSL_use_certificate_buffer
 7179    \sa wolfSSL_use_PrivateKey_buffer
 7180    \sa wolfSSL_use_certificate_chain_buffer
 7181*/
 7182int wolfSSL_CTX_load_verify_chain_buffer_format(WOLFSSL_CTX* ctx,
 7183                                               const unsigned char* in,
 7184                                               long sz, int format);
 7185
 7186/*!
 7187    \ingroup CertsKeys
 7188
 7189    \brief この関数は証明書バッファをWOLFSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファの形式タイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。適切な使用方法については例を参照してください。
 7190
 7191    \return SSL_SUCCESS 成功時。
 7192    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7193    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7194    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7195    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7196
 7197    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7198    \param in ロードする証明書を含む入力バッファ。
 7199    \param sz 入力バッファのサイズ。
 7200    \param format 入力バッファ(in)に格納されている証明書の形式。指定可能な値はSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。
 7201
 7202    _Example_
 7203    \code
 7204    int ret = 0;
 7205    WOLFSSL_CTX* ctx;
 7206    byte certBuff[...];
 7207    long sz = sizeof(certBuff);
 7208    ...
 7209    ret = wolfSSL_CTX_use_certificate_buffer(ctx, certBuff, sz, SSL_FILETYPE_PEM);
 7210    if (ret != SSL_SUCCESS) {
 7211	    // バッファからの証明書のロードエラー
 7212    }
 7213    ...
 7214    \endcode
 7215
 7216    \sa wolfSSL_CTX_load_verify_buffer
 7217    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7218    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7219    \sa wolfSSL_use_certificate_buffer
 7220    \sa wolfSSL_use_PrivateKey_buffer
 7221    \sa wolfSSL_use_certificate_chain_buffer
 7222*/
 7223int wolfSSL_CTX_use_certificate_buffer(WOLFSSL_CTX* ctx,
 7224                                       const unsigned char* in, long sz,
 7225                                       int format);
 7226
 7227/*!
 7228    \ingroup CertsKeys
 7229
 7230    \brief この関数は秘密鍵バッファをSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファの形式タイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。適切な使用方法については例を参照してください。
 7231
 7232    \return SSL_SUCCESS 成功時。
 7233    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7234    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7235    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7236    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7237    \return NO_PASSWORD 鍵ファイルが暗号化されているがパスワードが提供されていない場合に返されます。
 7238
 7239    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7240    \param in ロードする秘密鍵を含む入力バッファ。
 7241    \param sz 入力バッファのサイズ。
 7242    \param format 入力バッファ(in)に格納されている秘密鍵の形式。指定可能な値はSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。
 7243
 7244    _Example_
 7245    \code
 7246    int ret = 0;
 7247    WOLFSSL_CTX* ctx;
 7248    byte keyBuff[...];
 7249    long sz = sizeof(certBuff);
 7250    ...
 7251    ret = wolfSSL_CTX_use_PrivateKey_buffer(ctx, keyBuff, sz, SSL_FILETYPE_PEM);
 7252    if (ret != SSL_SUCCESS) {
 7253    	// バッファからの秘密鍵のロードエラー
 7254    }
 7255    ...
 7256    \endcode
 7257
 7258    \sa wolfSSL_CTX_load_verify_buffer
 7259    \sa wolfSSL_CTX_use_certificate_buffer
 7260    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7261    \sa wolfSSL_use_certificate_buffer
 7262    \sa wolfSSL_use_PrivateKey_buffer
 7263    \sa wolfSSL_use_certificate_chain_buffer
 7264*/
 7265int wolfSSL_CTX_use_PrivateKey_buffer(WOLFSSL_CTX* ctx,
 7266                                      const unsigned char* in, long sz,
 7267                                      int format);
 7268
 7269/*!
 7270    \ingroup CertsKeys
 7271
 7272    \brief この関数は証明書チェーンバッファをWOLFSSLコンテキストにロードします。バッファ非対応版と同様に動作しますが、ファイルの代わりにバッファを入力として呼び出せる点が異なります。バッファはサイズszのin引数によって提供されます。バッファはPEM形式で、サブジェクトの証明書から始まり、ルート証明書で終わる必要があります。適切な使用方法については例を参照してください。
 7273
 7274    \return SSL_SUCCESS 成功時。
 7275    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 7276    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7277    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 7278    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 7279    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
 7280
 7281    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7282    \param in ロードするPEM形式の証明書チェーンを含む入力バッファ。
 7283    \param sz 入力バッファのサイズ。
 7284
 7285    _Example_
 7286    \code
 7287    int ret = 0;
 7288    WOLFSSL_CTX* ctx;
 7289    byte certChainBuff[...];
 7290    long sz = sizeof(certBuff);
 7291    ...
 7292    ret = wolfSSL_CTX_use_certificate_chain_buffer(ctx, certChainBuff, sz);
 7293    if (ret != SSL_SUCCESS) {
 7294    	// バッファから証明書チェーンの読み込みに失敗
 7295    }
 7296    ...
 7297    \endcode
 7298
 7299    \sa wolfSSL_CTX_load_verify_buffer
 7300    \sa wolfSSL_CTX_use_certificate_buffer
 7301    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7302    \sa wolfSSL_use_certificate_buffer
 7303    \sa wolfSSL_use_PrivateKey_buffer
 7304    \sa wolfSSL_use_certificate_chain_buffer
 7305*/
 7306int wolfSSL_CTX_use_certificate_chain_buffer(WOLFSSL_CTX* ctx,
 7307                                             const unsigned char* in, long sz);
 7308
 7309/*!
 7310    \ingroup CertsKeys
 7311
 7312    \brief この関数は、証明書バッファをWOLFSSLオブジェクトにロードします。バッファなしバージョンと同様に動作しますが、ファイルの代わりにバッファを入力として呼び出すことができる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファのフォーマットタイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。適切な使用方法については例を参照してください。
 7313
 7314    \return SSL_SUCCESS 成功時。
 7315    \return SSL_BAD_FILETYPE ファイルのフォーマットが間違っている場合に返されます。
 7316    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7317    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 7318    \return ASN_INPUT_E ファイルのBase16デコードに失敗した場合に返されます。
 7319
 7320    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 7321    \param in ロードする証明書を含むバッファ。
 7322    \param sz バッファ内の証明書のサイズ。
 7323    \param format ロードする証明書のフォーマット。指定可能な値はSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。
 7324
 7325    _Example_
 7326    \code
 7327    int ret;
 7328    byte certBuff[...];
 7329    WOLFSSL* ssl = 0;
 7330    long buffSz = sizeof(certBuff);
 7331    ...
 7332
 7333    ret = wolfSSL_use_certificate_buffer(ssl, certBuff, buffSz, SSL_FILETYPE_PEM);
 7334    if (ret != SSL_SUCCESS) {
 7335    	// バッファから証明書の読み込みに失敗
 7336    }
 7337    \endcode
 7338
 7339    \sa wolfSSL_CTX_load_verify_buffer
 7340    \sa wolfSSL_CTX_use_certificate_buffer
 7341    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7342    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7343    \sa wolfSSL_use_PrivateKey_buffer
 7344    \sa wolfSSL_use_certificate_chain_buffer
 7345*/
 7346int wolfSSL_use_certificate_buffer(WOLFSSL* ssl, const unsigned char* in,
 7347                                               long sz, int format);
 7348
 7349/*!
 7350    \ingroup CertsKeys
 7351
 7352    \brief この関数は、秘密鍵バッファをWOLFSSLオブジェクトにロードします。バッファなしバージョンと同様に動作しますが、ファイルの代わりにバッファを入力として呼び出すことができる点が異なります。バッファはサイズszのin引数によって提供されます。formatはバッファのフォーマットタイプを指定します。SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。適切な使用方法については例を参照してください。
 7353
 7354    \return SSL_SUCCESS 成功時。
 7355    \return SSL_BAD_FILETYPE ファイルのフォーマットが間違っている場合に返されます。
 7356    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7357    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 7358    \return ASN_INPUT_E ファイルのBase16デコードに失敗した場合に返されます。
 7359    \return NO_PASSWORD 鍵ファイルが暗号化されているがパスワードが提供されていない場合に返されます。
 7360
 7361    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 7362    \param in ロードする秘密鍵を含むバッファ。
 7363    \param sz バッファ内の秘密鍵のサイズ。
 7364    \param format ロードする秘密鍵のフォーマット。指定可能な値はSSL_FILETYPE_ASN1またはSSL_FILETYPE_PEMです。
 7365
 7366    _Example_
 7367    \code
 7368    int ret;
 7369    byte keyBuff[...];
 7370    WOLFSSL* ssl = 0;
 7371    long buffSz = sizeof(certBuff);
 7372    ...
 7373    ret = wolfSSL_use_PrivateKey_buffer(ssl, keyBuff, buffSz, SSL_FILETYPE_PEM);
 7374    if (ret != SSL_SUCCESS) {
 7375    	// バッファから秘密鍵の読み込みに失敗
 7376    }
 7377    \endcode
 7378
 7379    \sa wolfSSL_use_PrivateKey
 7380    \sa wolfSSL_CTX_load_verify_buffer
 7381    \sa wolfSSL_CTX_use_certificate_buffer
 7382    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7383    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7384    \sa wolfSSL_use_certificate_buffer
 7385    \sa wolfSSL_use_certificate_chain_buffer
 7386*/
 7387int wolfSSL_use_PrivateKey_buffer(WOLFSSL* ssl, const unsigned char* in,
 7388                                               long sz, int format);
 7389
 7390/*!
 7391    \ingroup CertsKeys
 7392
 7393    \brief この関数は、証明書チェーンバッファをWOLFSSLオブジェクトにロードします。バッファなしバージョンと同様に動作しますが、ファイルの代わりにバッファを入力として呼び出すことができる点が異なります。バッファはサイズszのin引数によって提供されます。バッファはPEMフォーマットである必要があり、サブジェクトの証明書から始まり、ルート証明書で終わる必要があります。適切な使用方法については例を参照してください。
 7394
 7395    \return SSL_SUCCES 成功時。
 7396    \return SSL_BAD_FILETYPE ファイルのフォーマットが間違っている場合に返されます。
 7397    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 7398    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 7399    \return ASN_INPUT_E ファイルのBase16デコードに失敗した場合に返されます。
 7400    \return BUFFER_E チェーンバッファが受信バッファより大きい場合に返されます。
 7401
 7402    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 7403    \param in ロードする証明書を含むバッファ。
 7404    \param sz バッファ内の証明書のサイズ。
 7405
 7406    _Example_
 7407    \code
 7408    int ret;
 7409    byte certChainBuff[...];
 7410    WOLFSSL* ssl = 0;
 7411    long buffSz = sizeof(certBuff);
 7412    ...
 7413    ret = wolfSSL_use_certificate_chain_buffer(ssl, certChainBuff, buffSz);
 7414    if (ret != SSL_SUCCESS) {
 7415    	// バッファから証明書チェーンの読み込みに失敗
 7416    }
 7417    \endcode
 7418
 7419    \sa wolfSSL_CTX_load_verify_buffer
 7420    \sa wolfSSL_CTX_use_certificate_buffer
 7421    \sa wolfSSL_CTX_use_PrivateKey_buffer
 7422    \sa wolfSSL_CTX_use_certificate_chain_buffer
 7423    \sa wolfSSL_use_certificate_buffer
 7424    \sa wolfSSL_use_PrivateKey_buffer
 7425*/
 7426int wolfSSL_use_certificate_chain_buffer(WOLFSSL* ssl,
 7427                                         const unsigned char* in, long sz);
 7428
 7429/*!
 7430    \ingroup CertsKeys
 7431
 7432    \brief この関数は、SSLが所有する証明書または鍵をアンロードします。
 7433
 7434    \return SSL_SUCCESS 関数が正常に実行された場合に返されます。
 7435    \return BAD_FUNC_ARG WOLFSSLオブジェクトがNULLの場合に返されます。
 7436
 7437    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7438
 7439    _Example_
 7440    \code
 7441    WOLFSSL* ssl = wolfSSL_new(ctx);
 7442    ...
 7443    int unloadKeys = wolfSSL_UnloadCertsKeys(ssl);
 7444    if(unloadKeys != SSL_SUCCESS){
 7445	    // 失敗ケース
 7446    }
 7447    \endcode
 7448
 7449    \sa wolfSSL_CTX_UnloadCAs
 7450*/
 7451int wolfSSL_UnloadCertsKeys(WOLFSSL* ssl);
 7452
 7453/*!
 7454    \ingroup Setup
 7455
 7456    \brief この関数は、可能な場合にハンドシェイクメッセージのグループ化をオンにします。
 7457
 7458    \return SSL_SUCCESS 成功時に返されます。
 7459    \return BAD_FUNC_ARG 入力コンテキストがnullの場合に返されます。
 7460
 7461    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 7462
 7463    _Example_
 7464    \code
 7465    WOLFSSL_CTX* ctx = 0;
 7466    ...
 7467    ret = wolfSSL_CTX_set_group_messages(ctx);
 7468    if (ret != SSL_SUCCESS) {
 7469	    // ハンドシェイクメッセージのグループ化の設定に失敗
 7470    }
 7471    \endcode
 7472
 7473    \sa wolfSSL_set_group_messages
 7474    \sa wolfSSL_CTX_new
 7475*/
 7476int wolfSSL_CTX_set_group_messages(WOLFSSL_CTX* ctx);
 7477
 7478/*!
 7479    \ingroup Setup
 7480
 7481    \brief この関数は、可能な場合にハンドシェイクメッセージのグループ化をオンにします。
 7482
 7483    \return SSL_SUCCESS 成功時に返されます。
 7484    \return BAD_FUNC_ARG 入力コンテキストがnullの場合に返されます。
 7485
 7486    \param ssl wolfSSL_new()で作成されたSSLセッションへのポインタ。
 7487
 7488    _Example_
 7489    \code
 7490    WOLFSSL* ssl = 0;
 7491    ...
 7492    ret = wolfSSL_set_group_messages(ssl);
 7493    if (ret != SSL_SUCCESS) {
 7494	    // ハンドシェイクメッセージのグループ化の設定に失敗
 7495    }
 7496    \endcode
 7497
 7498    \sa wolfSSL_CTX_set_group_messages
 7499    \sa wolfSSL_new
 7500*/
 7501int wolfSSL_set_group_messages(WOLFSSL* ssl);
 7502
 7503/*!
 7504    \brief この関数はファザーコールバックを設定します。
 7505
 7506    \return none 戻り値はありません。
 7507
 7508    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7509    \param cbf 次の形式の関数ポインタであるCallbackFuzzer型: int (*CallbackFuzzer)(WOLFSSL* ssl, const unsigned char* buf, int sz, int type, void* fuzzCtx);
 7510    \param fCtx WOLFSSL構造体のfuzzerCtxメンバに設定されるvoidポインタ型。
 7511
 7512    _Example_
 7513    \code
 7514    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 7515    WOLFSSL* ssl = wolfSSL_new(ctx);
 7516    void* fCtx;
 7517
 7518    int callbackFuzzerCB(WOLFSSL* ssl, const unsigned char* buf, int sz,
 7519				int type, void* fuzzCtx){
 7520        // 関数定義
 7521    }
 7522    …
 7523    wolfSSL_SetFuzzerCb(ssl, callbackFuzzerCB, fCtx);
 7524    \endcode
 7525
 7526    \sa CallbackFuzzer
 7527*/
 7528void wolfSSL_SetFuzzerCb(WOLFSSL* ssl, CallbackFuzzer cbf, void* fCtx);
 7529
 7530/*!
 7531    \brief この関数は新しいdtls cookieシークレットを設定します。
 7532
 7533    \return 0 関数がエラーなく実行された場合に返されます。
 7534    \return BAD_FUNC_ARG 関数に許容できない値を持つ引数が渡された場合に返されます。
 7535    \return COOKIE_SECRET_SZ シークレットサイズが0の場合に返されます。
 7536    \return MEMORY_ERROR 新しいcookieシークレット用のメモリ割り当てに問題があった場合に返されます。
 7537
 7538    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7539    \param secret シークレットバッファを表す定数バイトポインタ。
 7540    \param secretSz バッファのサイズ。
 7541
 7542    _Example_
 7543    \code
 7544    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 7545    WOLFSSL* ssl = wolfSSL_new(ctx);
 7546    const* byte secret;
 7547    word32 secretSz; // secretのサイズ
 7548    …
 7549    if(!wolfSSL_DTLS_SetCookieSecret(ssl, secret, secretSz)){
 7550    	// DTLSクッキーシークレットの設定失敗のコードブロック
 7551    } else {
 7552    	// 成功！クッキーシークレットが設定されました
 7553    }
 7554    \endcode
 7555
 7556    \sa ForceZero
 7557    \sa wc_RNG_GenerateBlock
 7558*/
 7559int   wolfSSL_DTLS_SetCookieSecret(WOLFSSL* ssl,
 7560                                               const byte* secret,
 7561                                               word32 secretSz);
 7562
 7563/*!
 7564    \brief この関数は乱数を取得します。
 7565
 7566    \return rng 成功時。
 7567    \return NULL sslがNULLの場合。
 7568
 7569    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 7570
 7571    _Example_
 7572    \code
 7573    WOLFSSL* ssl;
 7574
 7575    wolfSSL_GetRNG(ssl);
 7576
 7577    \endcode
 7578
 7579    \sa  wolfSSL_CTX_new_rng
 7580
 7581*/
 7582WC_RNG* wolfSSL_GetRNG(WOLFSSL* ssl);
 7583
 7584/*!
 7585    \ingroup Setup
 7586
 7587    \brief この関数は、許可される最小ダウングレードバージョンを設定します。ダウングレードを許可する接続(wolfSSLv23_client_methodまたはwolfSSLv23_server_method)を使用する場合にのみ適用されます。
 7588
 7589    \return SSL_SUCCESS 関数がエラーなく戻り、最小バージョンが設定された場合に返されます。
 7590    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、または最小バージョンがサポートされていない場合に返されます。
 7591
 7592    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 7593    \param version 最小値として設定されるバージョンの整数表現: WOLFSSL_SSLV3 = 0、WOLFSSL_TLSV1 = 1、WOLFSSL_TLSV1_1 = 2、またはWOLFSSL_TLSV1_2 = 3。
 7594
 7595    _Example_
 7596    \code
 7597    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol method );
 7598    WOLFSSL* ssl = WOLFSSL_new(ctx);
 7599    int version; // マクロ表現
 7600    …
 7601    if(wolfSSL_CTX_SetMinVersion(ssl->ctx, version) != SSL_SUCCESS){
 7602    	// 最小バージョンの設定に失敗
 7603    }
 7604    \endcode
 7605
 7606    \sa SetMinVersionHelper
 7607*/
 7608int wolfSSL_CTX_SetMinVersion(WOLFSSL_CTX* ctx, int version);
 7609
 7610/*!
 7611    \ingroup TLS
 7612
 7613    \brief この関数は、許可される最小ダウングレードバージョンを設定します。ダウングレードを許可する接続(wolfSSLv23_client_methodまたはwolfSSLv23_server_method)を使用する場合にのみ適用されます。
 7614
 7615    \return SSL_SUCCESS この関数とそのサブルーチンがエラーなく実行された場合に返されます。
 7616    \return BAD_FUNC_ARG SSLオブジェクトがNULLの場合に返されます。サブルーチンでは、バージョンマッチが良好でない場合にこのエラーがスローされます。
 7617
 7618    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7619    \param version 最小値として設定されるバージョンの整数表現: WOLFSSL_SSLV3 = 0、WOLFSSL_TLSV1 = 1、WOLFSSL_TLSV1_1 = 2、またはWOLFSSL_TLSV1_2 = 3。
 7620
 7621    _Example_
 7622    \code
 7623    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(protocol method);
 7624    WOLFSSL* ssl = WOLFSSL_new(ctx);
 7625    int version;  // マクロ表現
 7626    …
 7627    if(wolfSSL_CTX_SetMinVersion(ssl->ctx, version) != SSL_SUCCESS){
 7628	    // 最小バージョンの設定に失敗
 7629    }
 7630    \endcode
 7631
 7632    \sa SetMinVersionHelper
 7633*/
 7634int wolfSSL_SetMinVersion(WOLFSSL* ssl, int version);
 7635
 7636/*!
 7637    \brief この関数はWOLFSSLオブジェクトのサイズを返し、ビルドオプションと設定に依存します。wolfSSLをビルドする際にSHOW_SIZESが定義されている場合、この関数はWOLFSSLオブジェクト内の個々のオブジェクト(Suites、Ciphersなど)のサイズもstdoutに出力します。
 7638
 7639    \return size この関数はWOLFSSLオブジェクトのサイズを返します。
 7640
 7641    \param none パラメータはありません。
 7642
 7643    _Example_
 7644    \code
 7645    int size = 0;
 7646    size = wolfSSL_GetObjectSize();
 7647    printf("sizeof(WOLFSSL) = %d\n", size);
 7648    \endcode
 7649
 7650    \sa wolfSSL_new
 7651*/
 7652int wolfSSL_GetObjectSize(void);  /* ビルドに基づくオブジェクトサイズ */
 7653/*!
 7654    \brief 平文入力のレコード層サイズを返します。これは、アプリケーションが指定された平文入力サイズに対して、トランスポート層を介して送信されるバイト数を知りたい場合に役立ちます。この関数は、SSL/TLSハンドシェイクが完了した後に呼び出す必要があります。
 7655
 7656    \return size 成功時には、要求されたサイズが返されます。
 7657    \return INPUT_SIZE_E 入力サイズが最大TLSフラグメントサイズより大きい場合に返されます(wolfSSL_GetMaxOutputSize()を参照)。
 7658    \return BAD_FUNC_ARG 無効な関数引数が渡された場合、またはSSL/TLSハンドシェイクがまだ完了していない場合に返されます。
 7659
 7660    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7661    \param inSz 平文データのサイズ。
 7662
 7663    _Example_
 7664    \code
 7665    none
 7666    \endcode
 7667
 7668    \sa wolfSSL_GetMaxOutputSize
 7669*/
 7670int wolfSSL_GetOutputSize(WOLFSSL* ssl, int inSz);
 7671
 7672/*!
 7673    \brief 平文データの最大レコード層サイズを返します。これは、プロトコル標準で指定されている最大SSL/TLSレコードサイズ、またはTLS最大フラグメント長拡張によって設定された最大TLSフラグメントサイズのいずれかに対応します。この関数は、アプリケーションがwolfSSL_GetOutputSize()を呼び出してINPUT_SIZE_Eエラーを受け取った場合に役立ちます。この関数は、SSL/TLSハンドシェイクが完了した後に呼び出す必要があります。
 7674
 7675    \return size 成功時には、最大出力サイズが返されます。
 7676    \return BAD_FUNC_ARG 無効な関数引数が渡された場合、またはSSL/TLSハンドシェイクがまだ完了していない場合に返されます。
 7677
 7678    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7679
 7680    _Example_
 7681    \code
 7682    none
 7683    \endcode
 7684
 7685    \sa wolfSSL_GetOutputSize
 7686*/
 7687int wolfSSL_GetMaxOutputSize(WOLFSSL* ssl);
 7688
 7689/*!
 7690    \ingroup Setup
 7691
 7692    \brief この関数は、versionで指定されたバージョンを使用して、指定されたSSLセッション(WOLFSSLオブジェクト)のSSL/TLSプロトコルバージョンを設定します。これにより、SSLセッション(ssl)のプロトコル設定が上書きされます。これは元々SSLコンテキスト(wolfSSL_CTX_new())のメソッドタイプによって定義および設定されたものです。
 7693
 7694    \return SSL_SUCCESS 成功時。
 7695    \return BAD_FUNC_ARG 入力されたSSLオブジェクトがNULLの場合、またはversionに不正なプロトコルバージョンが指定された場合に返されます。
 7696
 7697    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7698    \param version SSL/TLSプロトコルバージョン。指定可能な値には、WOLFSSL_SSLV3、WOLFSSL_TLSV1、WOLFSSL_TLSV1_1、WOLFSSL_TLSV1_2があります。
 7699
 7700    _Example_
 7701    \code
 7702    int ret = 0;
 7703    WOLFSSL* ssl;
 7704    ...
 7705
 7706    ret = wolfSSL_SetVersion(ssl, WOLFSSL_TLSV1);
 7707    if (ret != SSL_SUCCESS) {
 7708        // SSLセッションのプロトコルバージョンの設定に失敗しました。
 7709    }
 7710    \endcode
 7711
 7712    \sa wolfSSL_CTX_new
 7713*/
 7714int wolfSSL_SetVersion(WOLFSSL* ssl, int version);
 7715
 7716/*!
 7717    \brief 呼び出し元がアトミックユーザレコード処理Mac/暗号化コールバックを設定できるようにします。コールバックは、成功時には0、エラー時には<0を返す必要があります。sslとctxポインタは、ユーザの利便性のために利用可能です。macOutは、macの結果を格納する出力バッファです。macInはmac入力バッファであり、macInSzはバッファのサイズを示します。macContentとmacVerifyは、wolfSSL_SetTlsHmacInner()に必要であり、そのまま渡す必要があります。encOutは、暗号化の結果を格納する出力バッファです。encInは暗号化する入力バッファであり、encSzは入力のサイズです。コールバックの例は、wolfssl/test.hのmyMacEncryptCb()にあります。
 7718
 7719    \return none 戻り値なし。
 7720
 7721    \param none パラメータなし。
 7722
 7723    _Example_
 7724    \code
 7725    none
 7726    \endcode
 7727
 7728    \sa wolfSSL_SetMacEncryptCtx
 7729    \sa wolfSSL_GetMacEncryptCtx
 7730*/
 7731void  wolfSSL_CTX_SetMacEncryptCb(WOLFSSL_CTX* ctx, CallbackMacEncrypt cb);
 7732
 7733/*!
 7734    \brief 呼び出し元がアトミックユーザレコード処理Mac/暗号化コールバックコンテキストをctxに設定できるようにします。
 7735
 7736    \return none 戻り値なし。
 7737
 7738    \param none パラメータなし。
 7739
 7740    _Example_
 7741    \code
 7742    none
 7743    \endcode
 7744
 7745    \sa wolfSSL_CTX_SetMacEncryptCb
 7746    \sa wolfSSL_GetMacEncryptCtx
 7747*/
 7748void  wolfSSL_SetMacEncryptCtx(WOLFSSL* ssl, void *ctx);
 7749
 7750/*!
 7751    \brief 呼び出し元が、wolfSSL_SetMacEncryptCtx()で以前に保存されたアトミックユーザレコード処理Mac/暗号化コールバックコンテキストを取得できるようにします。
 7752
 7753    \return pointer 成功した場合、呼び出しはコンテキストへの有効なポインタを返します。
 7754    \return NULL 空のコンテキストの場合に返されます。
 7755
 7756    \param none パラメータなし。
 7757
 7758    _Example_
 7759    \code
 7760    none
 7761    \endcode
 7762
 7763    \sa wolfSSL_CTX_SetMacEncryptCb
 7764    \sa wolfSSL_SetMacEncryptCtx
 7765*/
 7766void* wolfSSL_GetMacEncryptCtx(WOLFSSL* ssl);
 7767
 7768/*!
 7769    \brief 呼び出し元がアトミックユーザレコード処理復号/検証コールバックを設定できるようにします。コールバックは、成功時には0、エラー時には<0を返す必要があります。sslとctxポインタは、ユーザの利便性のために利用可能です。decOutは、復号の結果を格納する出力バッファです。decInは暗号化された入力バッファであり、decInSzはバッファのサイズを示します。contentとverifyは、wolfSSL_SetTlsHmacInner()に必要であり、そのまま渡す必要があります。padSzは、パディングの合計値を設定する必要がある出力変数です。つまり、macサイズに加えて、パディングとパディングバイトです。コールバックの例は、wolfssl/test.hのmyDecryptVerifyCb()にあります。
 7770
 7771    \return none 戻り値なし。
 7772
 7773    \param none パラメータなし。
 7774
 7775    _Example_
 7776    \code
 7777    none
 7778    \endcode
 7779
 7780    \sa wolfSSL_SetMacEncryptCtx
 7781    \sa wolfSSL_GetMacEncryptCtx
 7782*/
 7783void  wolfSSL_CTX_SetDecryptVerifyCb(WOLFSSL_CTX* ctx,
 7784                                               CallbackDecryptVerify cb);
 7785
 7786/*!
 7787    \brief 呼び出し元がアトミックユーザレコード処理復号/検証コールバックコンテキストをctxに設定できるようにします。
 7788
 7789    \return none 戻り値なし。
 7790
 7791    \param none パラメータなし。
 7792
 7793    _Example_
 7794    \code
 7795    none
 7796    \endcode
 7797
 7798    \sa wolfSSL_CTX_SetDecryptVerifyCb
 7799    \sa wolfSSL_GetDecryptVerifyCtx
 7800*/
 7801void  wolfSSL_SetDecryptVerifyCtx(WOLFSSL* ssl, void *ctx);
 7802
 7803/*!
 7804    \brief 呼び出し元が、wolfSSL_SetDecryptVerifyCtx()で以前に保存されたアトミックユーザレコード処理復号/検証コールバックコンテキストを取得できるようにします。
 7805
 7806    \return pointer 成功した場合、呼び出しはコンテキストへの有効なポインタを返します。
 7807    \return NULL 空のコンテキストの場合に返されます。
 7808
 7809    \param none パラメータなし。
 7810
 7811    _Example_
 7812    \code
 7813    none
 7814    \endcode
 7815
 7816    \sa wolfSSL_CTX_SetDecryptVerifyCb
 7817    \sa wolfSSL_SetDecryptVerifyCtx
 7818*/
 7819void* wolfSSL_GetDecryptVerifyCtx(WOLFSSL* ssl);
 7820
 7821/*!
 7822    \brief ハンドシェイクプロセスからHmac/Macシークレットの取得を可能にします。verifyパラメータは、これがピアメッセージの検証用であるかどうかを指定します。
 7823
 7824    \return pointer 成功した場合、呼び出しはシークレットへの有効なポインタを返します。シークレットのサイズは、wolfSSL_GetHmacSize()から取得できます。
 7825    \return NULL エラー状態の場合に返されます。
 7826
 7827    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7828    \param verify これがピアメッセージの検証用であるかどうかを指定します。
 7829
 7830    _Example_
 7831    \code
 7832    none
 7833    \endcode
 7834
 7835    \sa wolfSSL_GetHmacSize
 7836*/
 7837const unsigned char* wolfSSL_GetMacSecret(WOLFSSL* ssl, int verify);
 7838
 7839/*!
 7840    \brief ハンドシェイクプロセスからクライアント書き込み鍵の取得を可能にします。
 7841
 7842    \return pointer 成功した場合、呼び出しは鍵への有効なポインタを返します。鍵のサイズは、wolfSSL_GetKeySize()から取得できます。
 7843    \return NULL エラー状態の場合に返されます。
 7844
 7845    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7846
 7847    _Example_
 7848    \code
 7849    none
 7850    \endcode
 7851
 7852    \sa wolfSSL_GetKeySize
 7853    \sa wolfSSL_GetClientWriteIV
 7854*/
 7855const unsigned char* wolfSSL_GetClientWriteKey(WOLFSSL*);
 7856
 7857/*!
 7858    \brief ハンドシェイクプロセスからクライアント書き込みIV(初期化ベクトル)の取得を可能にします。
 7859
 7860    \return pointer 成功した場合、呼び出しはIVへの有効なポインタを返します。IVのサイズは、wolfSSL_GetCipherBlockSize()から取得できます。
 7861    \return NULL エラー状態の場合に返されます。
 7862
 7863    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7864
 7865    _Example_
 7866    \code
 7867    none
 7868    \endcode
 7869
 7870    \sa wolfSSL_GetCipherBlockSize()
 7871    \sa wolfSSL_GetClientWriteKey()
 7872*/
 7873const unsigned char* wolfSSL_GetClientWriteIV(WOLFSSL*);
 7874
 7875/*!
 7876    \brief ハンドシェイクプロセスからサーバ書き込み鍵の取得を可能にします。
 7877
 7878    \return pointer 成功した場合、呼び出しは鍵への有効なポインタを返します。鍵のサイズは、wolfSSL_GetKeySize()から取得できます。
 7879    \return NULL エラー状態の場合に返されます。
 7880
 7881    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7882
 7883    _Example_
 7884    \code
 7885    none
 7886    \endcode
 7887
 7888    \sa wolfSSL_GetKeySize
 7889    \sa wolfSSL_GetServerWriteIV
 7890*/
 7891const unsigned char* wolfSSL_GetServerWriteKey(WOLFSSL*);
 7892
 7893/*!
 7894    \brief ハンドシェイクプロセスからサーバ書き込みIV(初期化ベクトル)の取得を可能にします。
 7895
 7896    \return pointer 成功した場合、呼び出しはIVへの有効なポインタを返します。IVのサイズは、wolfSSL_GetCipherBlockSize()から取得できます。
 7897    \return NULL エラー状態の場合に返されます。
 7898
 7899    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7900
 7901    \sa wolfSSL_GetCipherBlockSize
 7902    \sa wolfSSL_GetClientWriteKey
 7903*/
 7904const unsigned char* wolfSSL_GetServerWriteIV(WOLFSSL*);
 7905
 7906/*!
 7907    \brief ハンドシェイクプロセスから鍵サイズの取得を可能にします。
 7908
 7909    \return size 成功した場合、呼び出しは鍵サイズをバイト単位で返します。
 7910    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 7911
 7912    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7913
 7914    _Example_
 7915    \code
 7916    none
 7917    \endcode
 7918
 7919    \sa wolfSSL_GetClientWriteKey
 7920    \sa wolfSSL_GetServerWriteKey
 7921*/
 7922int                  wolfSSL_GetKeySize(WOLFSSL* ssl);
 7923
 7924/*!
 7925    \ingroup CertsKeys
 7926
 7927    \brief WOLFSSL構造体に保持されているspecs構造体のiv_sizeメンバを返します。
 7928
 7929    \return iv_size ssl->specs.iv_sizeに保持されている値を返します。
 7930    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
 7931
 7932    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 7933
 7934    _Example_
 7935    \code
 7936    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 7937    WOLFSSL* ssl = wolfSSL_new(ctx);
 7938    int ivSize;
 7939    ...
 7940    ivSize = wolfSSL_GetIVSize(ssl);
 7941
 7942    if(ivSize > 0){
 7943    	// ivSizeはspecs.iv_size値を保持しています。
 7944    }
 7945    \endcode
 7946
 7947    \sa wolfSSL_GetKeySize
 7948    \sa wolfSSL_GetClientWriteIV
 7949    \sa wolfSSL_GetServerWriteIV
 7950*/
 7951int                  wolfSSL_GetIVSize(WOLFSSL* ssl);
 7952
 7953/*!
 7954    \brief このWOLFSSL接続のサイド(側)の取得を可能にします。
 7955
 7956    \return success 成功した場合、呼び出しはWOLFSSLオブジェクトのサイドに応じて、WOLFSSL_SERVER_ENDまたはWOLFSSL_CLIENT_ENDのいずれかを返します。
 7957    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 7958
 7959    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7960
 7961    _Example_
 7962    \code
 7963    none
 7964    \endcode
 7965
 7966    \sa wolfSSL_GetClientWriteKey
 7967    \sa wolfSSL_GetServerWriteKey
 7968*/
 7969int                  wolfSSL_GetSide(WOLFSSL* ssl);
 7970
 7971/*!
 7972    \brief 呼び出し元が、ネゴシエートされたプロトコルバージョンが少なくともTLSバージョン1.1以上であるかどうかを判断できるようにします。
 7973
 7974    \return true/false 成功した場合、呼び出しは真の場合は1、偽の場合は0を返します。
 7975    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 7976
 7977    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7978
 7979    _Example_
 7980    \code
 7981    none
 7982    \endcode
 7983
 7984    \sa wolfSSL_GetSide
 7985*/
 7986int                  wolfSSL_IsTLSv1_1(WOLFSSL* ssl);
 7987
 7988/*!
 7989    \brief 呼び出し元がハンドシェイクからネゴシエートされたバルク暗号アルゴリズムを判定できるようにします。
 7990
 7991    \return 成功時、以下のいずれかを返します。
 7992    wolfssl_cipher_null、wolfssl_des、wolfssl_triple_des、wolfssl_aes、
 7993    wolfssl_aes_gcm、wolfssl_aes_ccm、wolfssl_camellia。
 7994    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 7995
 7996    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 7997
 7998    _Example_
 7999    \code
 8000    none
 8001    \endcode
 8002
 8003    \sa wolfSSL_GetCipherBlockSize
 8004    \sa wolfSSL_GetKeySize
 8005*/
 8006int                  wolfSSL_GetBulkCipher(WOLFSSL* ssl);
 8007
 8008/*!
 8009    \brief 呼び出し元がハンドシェイクからネゴシエートされた暗号ブロックサイズを判定できるようにします。
 8010
 8011    \return size 成功時、暗号ブロックサイズのバイト数を返します。
 8012    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 8013
 8014    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8015
 8016    _Example_
 8017    \code
 8018    none
 8019    \endcode
 8020
 8021    \sa wolfSSL_GetBulkCipher
 8022    \sa wolfSSL_GetKeySize
 8023*/
 8024int                  wolfSSL_GetCipherBlockSize(WOLFSSL* ssl);
 8025
 8026/*!
 8027    \brief 呼び出し元がハンドシェイクからネゴシエートされたaead macサイズを判定できるようにします。暗号タイプWOLFSSL_AEAD_TYPE用。
 8028
 8029    \return size 成功時、aead macサイズのバイト数を返します。
 8030    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 8031
 8032    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8033
 8034    _Example_
 8035    \code
 8036    none
 8037    \endcode
 8038
 8039    \sa wolfSSL_GetBulkCipher
 8040    \sa wolfSSL_GetKeySize
 8041*/
 8042int                  wolfSSL_GetAeadMacSize(WOLFSSL* ssl);
 8043
 8044/*!
 8045    \brief 呼び出し元がハンドシェイクからネゴシエートされた(h)macサイズを判定できるようにします。WOLFSSL_AEAD_TYPE以外の暗号タイプ用。
 8046
 8047    \return size 成功時、(h)macサイズのバイト数を返します。
 8048    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 8049
 8050    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8051
 8052    _Example_
 8053    \code
 8054    none
 8055    \endcode
 8056
 8057    \sa wolfSSL_GetBulkCipher
 8058    \sa wolfSSL_GetHmacType
 8059*/
 8060int                  wolfSSL_GetHmacSize(WOLFSSL* ssl);
 8061
 8062/*!
 8063    \brief 呼び出し元がハンドシェイクからネゴシエートされた(h)macタイプを判定できるようにします。WOLFSSL_AEAD_TYPE以外の暗号タイプ用。
 8064
 8065    \return 成功時、以下のいずれかを返します。
 8066    MD5、SHA、SHA256、SHA384。
 8067    \return BAD_FUNC_ARG エラー状態の場合に返される可能性があります。
 8068    \return SSL_FATAL_ERROR エラー状態の場合に返される可能性があります。
 8069
 8070    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8071
 8072    _Example_
 8073    \code
 8074    none
 8075    \endcode
 8076
 8077    \sa wolfSSL_GetBulkCipher
 8078    \sa wolfSSL_GetHmacSize
 8079*/
 8080int                  wolfSSL_GetHmacType(WOLFSSL* ssl);
 8081
 8082/*!
 8083    \brief 呼び出し元がハンドシェイクからネゴシエートされた暗号タイプを判定できるようにします。
 8084
 8085    \return 成功時、以下のいずれかを返します。
 8086    WOLFSSL_BLOCK_TYPE、WOLFSSL_STREAM_TYPE、WOLFSSL_AEAD_TYPE。
 8087    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 8088
 8089    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8090
 8091    _Example_
 8092    \code
 8093    none
 8094    \endcode
 8095
 8096    \sa wolfSSL_GetBulkCipher
 8097    \sa wolfSSL_GetHmacType
 8098*/
 8099int                  wolfSSL_GetCipherType(WOLFSSL* ssl);
 8100
 8101/*!
 8102    \brief 呼び出し元がメッセージの送受信のためにHmac Innerベクトルを設定できるようにします。結果はinnerに書き込まれ、少なくともwolfSSL_GetHmacSize()バイトである必要があります。メッセージのサイズはszで指定され、contentはメッセージのタイプ、verifyはこれがピアメッセージの検証であるかを指定します。WOLFSSL_AEAD_TYPEを除く暗号タイプで有効です。
 8103
 8104    \return 1 成功時。
 8105    \return BAD_FUNC_ARG エラー状態の場合に返されます。
 8106
 8107    \param none パラメータなし。
 8108
 8109    _Example_
 8110    \code
 8111    none
 8112    \endcode
 8113
 8114    \sa wolfSSL_GetBulkCipher
 8115    \sa wolfSSL_GetHmacType
 8116*/
 8117int wolfSSL_SetTlsHmacInner(WOLFSSL* ssl, byte* inner,
 8118                            word32 sz, int content, int verify);
 8119
 8120/*!
 8121    \brief 呼び出し元がECC署名用の公開鍵コールバックを設定できるようにします。コールバックは成功時に0、エラー時に0未満を返す必要があります。sslとctxポインタはユーザの便宜のために利用可能です。inは署名する入力バッファで、inSzは入力の長さを示します。outは署名の結果を格納する出力バッファです。outSzは入出力変数で、呼び出し時の出力バッファのサイズを指定し、返す前に署名の実際のサイズをそこに格納する必要があります。keyDerはASN1形式のECC秘密鍵で、keySzは鍵の長さをバイト単位で表します。コールバックの例はwolfssl/test.h myEccSign()にあります。
 8122
 8123    \return none 戻り値なし。
 8124
 8125    \param none パラメータなし。
 8126
 8127    _Example_
 8128    \code
 8129    none
 8130    \endcode
 8131
 8132    \sa wolfSSL_SetEccSignCtx
 8133    \sa wolfSSL_GetEccSignCtx
 8134*/
 8135void  wolfSSL_CTX_SetEccSignCb(WOLFSSL_CTX* ctx, CallbackEccSign cb);
 8136
 8137/*!
 8138    \brief 呼び出し元が公開鍵ECC署名コールバックコンテキストをctxに設定できるようにします。
 8139
 8140    \return none 戻り値なし。
 8141
 8142    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8143    \param ctx 格納するユーザコンテキストへのポインタ。
 8144
 8145    _Example_
 8146    \code
 8147    none
 8148    \endcode
 8149
 8150    \sa wolfSSL_CTX_SetEccSignCb
 8151    \sa wolfSSL_GetEccSignCtx
 8152*/
 8153void  wolfSSL_SetEccSignCtx(WOLFSSL* ssl, void *ctx);
 8154
 8155/*!
 8156    \brief 呼び出し元が以前にwolfSSL_SetEccSignCtx()で格納された公開鍵ECC署名コールバックコンテキストを取得できるようにします。
 8157
 8158    \return pointer 成功時、コンテキストへの有効なポインタを返します。
 8159    \return NULL 空のコンテキストの場合に返されます。
 8160
 8161    \param ssl wolfSSL_new()を使用して作成されたWOLFSSLオブジェクトへのポインタ。
 8162
 8163    _Example_
 8164    \code
 8165    none
 8166    \endcode
 8167
 8168    \sa wolfSSL_CTX_SetEccSignCb
 8169    \sa wolfSSL_SetEccSignCtx
 8170*/
 8171void* wolfSSL_GetEccSignCtx(WOLFSSL* ssl);
 8172
 8173/*!
 8174    \brief 呼び出し元が公開鍵ECC署名コールバックコンテキストをctxに設定できるようにします。
 8175
 8176    \return none 戻り値なし。
 8177
 8178    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
 8179    \param ctx 格納するユーザコンテキストへのポインタ。
 8180
 8181    _Example_
 8182    \code
 8183    none
 8184    \endcode
 8185
 8186    \sa wolfSSL_CTX_SetEccSignCb
 8187    \sa wolfSSL_CTX_GetEccSignCtx
 8188*/
 8189void  wolfSSL_CTX_SetEccSignCtx(WOLFSSL_CTX* ctx, void *userCtx);
 8190
 8191/*!
 8192    \brief 呼び出し元が以前にwolfSSL_SetEccSignCtx()で格納された公開鍵ECC署名コールバックコンテキストを取得できるようにします。
 8193
 8194    \return pointer 成功時、コンテキストへの有効なポインタを返します。
 8195    \return NULL 空のコンテキストの場合に返されます。
 8196
 8197    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
 8198
 8199    _Example_
 8200    \code
 8201    none
 8202    \endcode
 8203
 8204    \sa wolfSSL_CTX_SetEccSignCb
 8205    \sa wolfSSL_CTX_SetEccSignCtx
 8206*/
 8207void* wolfSSL_CTX_GetEccSignCtx(WOLFSSL_CTX* ctx);
 8208
 8209/*!
 8210    \brief 呼び出し元がECC検証用の公開鍵コールバックを設定できるようにします。コールバックは成功時に0、エラー時に0未満を返す必要があります。sslとctxポインタはユーザの便宜のために利用可能です。sigは検証する署名で、sigSzは署名の長さを示します。hashはメッセージのダイジェストを含む入力バッファで、hashSzはハッシュの長さをバイト単位で示します。resultは検証の結果を格納する出力変数で、成功時は1、失敗時は0です。keyDerはASN1形式のECC秘密鍵で、keySzは鍵の長さをバイト単位で表します。コールバックの例はwolfssl/test.h myEccVerify()にあります。
 8211
 8212    \return none 戻り値なし。
 8213
 8214    \param none パラメータなし。
 8215
 8216    _Example_
 8217    \code
 8218    none
 8219    \endcode
 8220
 8221    \sa wolfSSL_SetEccVerifyCtx
 8222    \sa wolfSSL_GetEccVerifyCtx
 8223*/
 8224void  wolfSSL_CTX_SetEccVerifyCb(WOLFSSL_CTX* ctx, CallbackEccVerify cb);
 8225
 8226/*!
 8227    \brief 呼び出し元が公開鍵ECC検証コールバックコンテキストをctxに設定できるようにします。
 8228
 8229    \return none 戻り値なし。
 8230
 8231    \param none パラメータなし。
 8232
 8233    _Example_
 8234    \code
 8235    none
 8236    \endcode
 8237
 8238    \sa wolfSSL_CTX_SetEccVerifyCb
 8239    \sa wolfSSL_GetEccVerifyCtx
 8240*/
 8241void  wolfSSL_SetEccVerifyCtx(WOLFSSL* ssl, void *ctx);
 8242
 8243/*!
 8244    \brief 呼び出し元が以前にwolfSSL_SetEccVerifyCtx()で格納された公開鍵ECC検証コールバックコンテキストを取得できるようにします。
 8245
 8246    \return pointer 成功時、コンテキストへの有効なポインタを返します。
 8247    \return NULL 空のコンテキストの場合に返されます。
 8248
 8249    \param none パラメータなし。
 8250
 8251    _Example_
 8252    \code
 8253    none
 8254    \endcode
 8255
 8256    \sa wolfSSL_CTX_SetEccVerifyCb
 8257    \sa wolfSSL_SetEccVerifyCtx
 8258*/
 8259void* wolfSSL_GetEccVerifyCtx(WOLFSSL* ssl);
 8260
 8261/*!
 8262    \brief 呼び出し元がRSA署名用の公開鍵コールバックを設定できるようにします。コールバックは成功時に0、エラー時に0未満を返す必要があります。sslとctxポインタはユーザの便宜のために利用可能です。inは署名する入力バッファで、inSzは入力の長さを示します。outは署名の結果を格納する出力バッファです。outSzは入出力変数で、呼び出し時の出力バッファのサイズを指定し、返す前に署名の実際のサイズをそこに格納する必要があります。keyDerはASN1形式のRSA秘密鍵で、keySzは鍵の長さをバイト単位で表します。コールバックの例はwolfssl/test.h myRsaSign()にあります。
 8263
 8264    \return none 戻り値なし。
 8265
 8266    \param none パラメータなし。
 8267
 8268    _Example_
 8269    \code
 8270    none
 8271    \endcode
 8272
 8273    \sa wolfSSL_SetRsaSignCtx
 8274    \sa wolfSSL_GetRsaSignCtx
 8275*/
 8276void  wolfSSL_CTX_SetRsaSignCb(WOLFSSL_CTX* ctx, CallbackRsaSign cb);
 8277
 8278/*!
 8279    \brief 呼び出し元が公開鍵RSA署名コールバックコンテキストをctxに設定できるようにします。
 8280
 8281    \return none 戻り値なし。
 8282
 8283    \param none パラメータなし。
 8284
 8285    _Example_
 8286    \code
 8287    none
 8288    \endcode
 8289
 8290    \sa wolfSSL_CTX_SetRsaSignCb
 8291    \sa wolfSSL_GetRsaSignCtx
 8292*/
 8293void  wolfSSL_SetRsaSignCtx(WOLFSSL* ssl, void *ctx);
 8294
 8295/*!
 8296    \brief 呼び出し元が以前にwolfSSL_SetRsaSignCtx()で格納された公開鍵RSA署名コールバックコンテキストを取得できるようにします。
 8297
 8298    \return pointer 成功時、コンテキストへの有効なポインタを返します。
 8299    \return NULL 空のコンテキストの場合に返されます。
 8300
 8301    \param none パラメータなし。
 8302    \param none パラメータなし。
 8303
 8304    _Example_
 8305    \code
 8306    none
 8307    \endcode
 8308
 8309    \sa wolfSSL_CTX_SetRsaSignCb
 8310    \sa wolfSSL_SetRsaSignCtx
 8311*/
 8312void* wolfSSL_GetRsaSignCtx(WOLFSSL* ssl);
 8313
 8314/*!
 8315    \brief 呼び出し元がRSA検証用の公開鍵コールバックを設定できるようにします。コールバックは成功時に平文のバイト数、エラー時に0未満を返す必要があります。sslとctxポインタはユーザの便宜のために利用可能です。sigは検証する署名で、sigSzは署名の長さを示します。outは復号プロセスとパディングの後、検証バッファの先頭に設定する必要があります。keyDerはASN1形式のRSA公開鍵で、keySzは鍵の長さをバイト単位で表します。コールバックの例はwolfssl/test.h myRsaVerify()にあります。
 8316
 8317    \return none 戻り値なし。
 8318
 8319    \param none パラメータなし。
 8320
 8321    \sa wolfSSL_SetRsaVerifyCtx
 8322    \sa wolfSSL_GetRsaVerifyCtx
 8323*/
 8324void  wolfSSL_CTX_SetRsaVerifyCb(WOLFSSL_CTX* ctx, CallbackRsaVerify cb);/*!
 8325    \brief 呼び出し元が公開鍵RSA検証コールバックコンテキストをctxに設定できるようにします。
 8326
 8327    \return none 戻り値なし。
 8328
 8329    \param none パラメータなし。
 8330
 8331    _Example_
 8332    \code
 8333    none
 8334    \endcode
 8335
 8336    \sa wolfSSL_CTX_SetRsaVerifyCb
 8337    \sa wolfSSL_GetRsaVerifyCtx
 8338*/
 8339void  wolfSSL_SetRsaVerifyCtx(WOLFSSL* ssl, void *ctx);
 8340
 8341/*!
 8342    \brief 呼び出し元がwolfSSL_SetRsaVerifyCtx()で以前に保存された公開鍵RSA検証コールバックコンテキストを取得できるようにします。
 8343
 8344    \return pointer 成功した場合、呼び出しはコンテキストへの有効なポインタを返します。
 8345    \return NULL 空のコンテキストに対して返されます。
 8346
 8347    \param none パラメータなし。
 8348
 8349    _Example_
 8350    \code
 8351    none
 8352    \endcode
 8353
 8354    \sa wolfSSL_CTX_SetRsaVerifyCb
 8355    \sa wolfSSL_SetRsaVerifyCtx
 8356*/
 8357void* wolfSSL_GetRsaVerifyCtx(WOLFSSL* ssl);
 8358
 8359/*!
 8360    \brief 呼び出し元がRSA公開暗号化のための公開鍵コールバックを設定できるようにします。コールバックは成功の場合は0を、エラーの場合は0未満を返す必要があります。sslとctxポインタはユーザーの利便性のために利用可能です。inは暗号化する入力バッファで、inSzは入力の長さを示します。outは暗号化の結果を格納する出力バッファです。outSzは入出力変数で、呼び出し時に出力バッファのサイズを指定し、戻る前に暗号化の実際のサイズを格納する必要があります。keyDerはASN1形式のRSA公開鍵で、keySzはバイト単位の鍵の長さです。コールバックの例はwolfssl/test.hのmyRsaEnc()にあります。
 8361
 8362    \return none 戻り値なし。
 8363
 8364    \param none パラメータなし。
 8365
 8366    _Examples_
 8367    \code
 8368    none
 8369    \endcode
 8370
 8371    \sa wolfSSL_SetRsaEncCtx
 8372    \sa wolfSSL_GetRsaEncCtx
 8373*/
 8374void  wolfSSL_CTX_SetRsaEncCb(WOLFSSL_CTX* ctx, CallbackRsaEnc cb);
 8375
 8376/*!
 8377    \brief 呼び出し元が公開鍵RSA公開暗号化コールバックコンテキストをctxに設定できるようにします。
 8378
 8379    \return none 戻り値なし。
 8380
 8381    \param none パラメータなし。
 8382
 8383    _Example_
 8384    \code
 8385    none
 8386    \endcode
 8387
 8388    \sa wolfSSL_CTX_SetRsaEncCb
 8389    \sa wolfSSL_GetRsaEncCtx
 8390*/
 8391void  wolfSSL_SetRsaEncCtx(WOLFSSL* ssl, void *ctx);
 8392
 8393/*!
 8394    \brief 呼び出し元がwolfSSL_SetRsaEncCtx()で以前に保存された公開鍵RSA公開暗号化コールバックコンテキストを取得できるようにします。
 8395
 8396    \return pointer 成功した場合、呼び出しはコンテキストへの有効なポインタを返します。
 8397    \return NULL 空のコンテキストに対して返されます。
 8398
 8399    \param none パラメータなし。
 8400
 8401    _Example_
 8402    \code
 8403    none
 8404    \endcode
 8405
 8406    \sa wolfSSL_CTX_SetRsaEncCb
 8407    \sa wolfSSL_SetRsaEncCtx
 8408*/
 8409void* wolfSSL_GetRsaEncCtx(WOLFSSL* ssl);
 8410
 8411/*!
 8412    \brief 呼び出し元がRSA秘密復号のための公開鍵コールバックを設定できるようにします。コールバックは成功の場合は平文のバイト数を、エラーの場合は0未満を返す必要があります。sslとctxポインタはユーザーの利便性のために利用可能です。inは復号する入力バッファで、inSzは入力の長さを示します。outは復号処理とパディングの後、復号バッファの先頭に設定する必要があります。keyDerはASN1形式のRSA秘密鍵で、keySzはバイト単位の鍵の長さです。コールバックの例はwolfssl/test.hのmyRsaDec()にあります。
 8413
 8414    \return none 戻り値なし。
 8415
 8416    \param none パラメータなし。
 8417
 8418    _Example_
 8419    \code
 8420    none
 8421    \endcode
 8422
 8423    \sa wolfSSL_SetRsaDecCtx
 8424    \sa wolfSSL_GetRsaDecCtx
 8425*/
 8426void  wolfSSL_CTX_SetRsaDecCb(WOLFSSL_CTX* ctx, CallbackRsaDec cb);
 8427
 8428/*!
 8429    \brief 呼び出し元が公開鍵RSA秘密復号コールバックコンテキストをctxに設定できるようにします。
 8430
 8431    \return none 戻り値なし。
 8432
 8433    \param none パラメータなし。
 8434
 8435    _Example_
 8436    \code
 8437    none
 8438    \endcode
 8439
 8440    \sa wolfSSL_CTX_SetRsaDecCb
 8441    \sa wolfSSL_GetRsaDecCtx
 8442*/
 8443void  wolfSSL_SetRsaDecCtx(WOLFSSL* ssl, void *ctx);
 8444
 8445/*!
 8446    \brief 呼び出し元がwolfSSL_SetRsaDecCtx()で以前に保存された公開鍵RSA秘密復号コールバックコンテキストを取得できるようにします。
 8447
 8448    \return pointer 成功した場合、呼び出しはコンテキストへの有効なポインタを返します。
 8449    \return NULL 空のコンテキストに対して返されます。
 8450
 8451    \param none パラメータなし。
 8452
 8453    _Example_
 8454    \code
 8455    none
 8456    \endcode
 8457
 8458    \sa wolfSSL_CTX_SetRsaDecCb
 8459    \sa wolfSSL_SetRsaDecCtx
 8460*/
 8461void* wolfSSL_GetRsaDecCtx(WOLFSSL* ssl);
 8462
 8463/*!
 8464    \brief この関数は、新しいCA証明書がwolfSSLにロードされたときに呼び出されるコールバックをSSLコンテキスト(WOLFSSL_CTX)に登録します。コールバックにはDERエンコードされた証明書を含むバッファが渡されます。
 8465
 8466    \return none 戻り値なし。
 8467
 8468    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 8469    \param callback wolfSSLコンテキストctxのCAコールバックとして登録される関数。この関数のシグネチャは、上記の概要セクションに示されているものに従う必要があります。
 8470
 8471    _Example_
 8472    \code
 8473    WOLFSSL_CTX* ctx = 0;
 8474
 8475    // CAコールバックのプロトタイプ
 8476    int MyCACallback(unsigned char *der, int sz, int type);
 8477
 8478    // SSLコンテキストにカスタムCAコールバックを登録
 8479    wolfSSL_CTX_SetCACb(ctx, MyCACallback);
 8480
 8481    int MyCACallback(unsigned char* der, int sz, int type)
 8482    {
 8483    	// カスタムCAコールバック関数、DERエンコードされた証明書は
 8484        // サイズszの"der"に格納され、タイプは"type"
 8485    }
 8486    \endcode
 8487
 8488    \sa wolfSSL_CTX_load_verify_locations
 8489*/
 8490void wolfSSL_CTX_SetCACb(WOLFSSL_CTX* ctx, CallbackCACache cb);
 8491
 8492/*!
 8493    \ingroup CertManager
 8494    \brief 新しい証明書マネージャーコンテキストを割り当て、初期化します。このコンテキストはSSLの必要性とは独立して使用できます。証明書のロード、証明書の検証、失効ステータスのチェックに使用できます。
 8495
 8496    \return WOLFSSL_CERT_MANAGER 成功した場合、呼び出しは有効なWOLFSSL_CERT_MANAGERポインタを返します。
 8497    \return NULL エラー状態の場合に返されます。
 8498
 8499    \param none パラメータなし。
 8500
 8501    \sa wolfSSL_CertManagerFree
 8502*/
 8503WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew_ex(void* heap);
 8504
 8505/*!
 8506    \ingroup CertManager
 8507    \brief 新しい証明書マネージャーコンテキストを割り当て、初期化します。このコンテキストはSSLの必要性とは独立して使用できます。証明書のロード、証明書の検証、失効ステータスのチェックに使用できます。
 8508
 8509    \return WOLFSSL_CERT_MANAGER 成功した場合、呼び出しは有効なWOLFSSL_CERT_MANAGERポインタを返します。
 8510    \return NULL エラー状態の場合に返されます。
 8511
 8512    \param none パラメータなし。
 8513
 8514    _Example_
 8515    \code
 8516    #import <wolfssl/ssl.h>
 8517
 8518    WOLFSSL_CERT_MANAGER* cm;
 8519    cm = wolfSSL_CertManagerNew();
 8520    if (cm == NULL) {
 8521	    // 新しい証明書マネージャーの作成エラー
 8522    }
 8523    \endcode
 8524
 8525    \sa wolfSSL_CertManagerFree
 8526*/
 8527WOLFSSL_CERT_MANAGER* wolfSSL_CertManagerNew(void);
 8528
 8529/*!
 8530    \ingroup CertManager
 8531    \brief 証明書マネージャーコンテキストに関連するすべてのリソースを解放します。証明書マネージャーを使用する必要がなくなったときにこれを呼び出します。
 8532
 8533    \return none 戻り値なし。
 8534
 8535    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8536
 8537    _Example_
 8538    \code
 8539    #include <wolfssl/ssl.h>
 8540
 8541    WOLFSSL_CERT_MANAGER* cm;
 8542    ...
 8543    wolfSSL_CertManagerFree(cm);
 8544    \endcode
 8545
 8546    \sa wolfSSL_CertManagerNew
 8547*/
 8548void wolfSSL_CertManagerFree(WOLFSSL_CERT_MANAGER* cm);
 8549
 8550/*!
 8551    \ingroup CertManager
 8552    \brief マネージャーコンテキストへのCA証明書ロードの場所を指定します。PEM証明書CAfileには複数の信頼されたCA証明書を含めることができます。CApathがNULLでない場合、PEM形式のCA証明書を含むディレクトリを指定します。
 8553
 8554    \return SSL_SUCCESS 成功した場合に返されます。
 8555    \return SSL_BAD_FILETYPE ファイルの形式が間違っている場合に返されます。
 8556    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 8557    \return MEMORY_E メモリ不足の状態が発生した場合に返されます。
 8558    \return ASN_INPUT_E ファイルのBase16デコードが失敗した場合に返されます。
 8559    \return BAD_FUNC_ARG ポインタが提供されていない場合に返されるエラーです。
 8560    \return SSL_FATAL_ERROR 失敗時に返されます。
 8561
 8562    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8563    \param file ロードするCA証明書を含むファイル名へのポインタ。
 8564    \param path ロードするCA証明書を含むディレクトリパスの名前へのポインタ。証明書ディレクトリが不要な場合はNULLポインタを使用できます。
 8565
 8566    _Example_
 8567    \code
 8568    #include <wolfssl/ssl.h>
 8569
 8570    int ret = 0;
 8571    WOLFSSL_CERT_MANAGER* cm;
 8572    ...
 8573    ret = wolfSSL_CertManagerLoadCA(cm, "path/to/cert-file.pem", 0);
 8574    if (ret != SSL_SUCCESS) {
 8575	    // 証明書マネージャーへのCA証明書のロードエラー
 8576    }
 8577    \endcode
 8578
 8579    \sa wolfSSL_CertManagerVerify
 8580*/
 8581int wolfSSL_CertManagerLoadCA(WOLFSSL_CERT_MANAGER* cm, const char* f,
 8582                                                                 const char* d);
 8583
 8584/*!
 8585    \ingroup CertManager
 8586    \brief wolfSSL_CTX_load_verify_bufferを呼び出し、関数に渡されたcmの情報を失わないように一時的なcmを使用してその結果を返すことで、CAバッファをロードします。
 8587
 8588    \return SSL_FATAL_ERROR WOLFSSL_CERT_MANAGER構造体がNULL、またはwolfSSL_CTX_new()がNULLを返した場合に返されます。
 8589    \return SSL_SUCCESS 正常に実行された場合に返されます。
 8590
 8591    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8592    \param in 証明書情報のバッファ。
 8593    \param sz バッファの長さ。
 8594    \param format 証明書の形式、PEMまたはDER。
 8595
 8596    _Example_
 8597    \code
 8598    WOLFSSL_CERT_MANAGER* cm = (WOLFSSL_CERT_MANAGER*)vp;
 8599    …
 8600    const unsigned char* in;
 8601    long sz;
 8602    int format;
 8603    …
 8604    if(wolfSSL_CertManagerLoadCABuffer(vp, sz, format) != SSL_SUCCESS){
 8605	    // エラーが返されました。失敗ケースのコードブロック。
 8606    }
 8607    \endcode
 8608
 8609    \sa wolfSSL_CTX_load_verify_buffer
 8610    \sa ProcessChainBuffer
 8611    \sa ProcessBuffer
 8612    \sa cm_pick_method
 8613*/
 8614int wolfSSL_CertManagerLoadCABuffer(WOLFSSL_CERT_MANAGER* cm,
 8615                                  const unsigned char* buff, long sz,
 8616                                  int format);
 8617
 8618/*!
 8619    \ingroup CertManager
 8620    \brief この関数はCA署名者リストをアンロードします。
 8621
 8622    \return SSL_SUCCESS 関数の正常な実行時に返されます。
 8623    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合に返されます。
 8624    \return BAD_MUTEX_E mutexエラーが発生した場合に返されます。
 8625
 8626    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8627
 8628    _Example_
 8629    \code
 8630    #include <wolfssl/ssl.h>
 8631
 8632    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 8633    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CTX_GetCertManager(ctx);
 8634    ...
 8635    if(wolfSSL_CertManagerUnloadCAs(cm) != SSL_SUCCESS){
 8636        // 失敗ケース。
 8637    }
 8638    \endcode
 8639
 8640    \sa UnlockMutex
 8641*/
 8642int wolfSSL_CertManagerUnloadCAs(WOLFSSL_CERT_MANAGER* cm);
 8643
 8644/*!
 8645    \ingroup CertManager
 8646    \brief この関数はCA署名者リストに追加された中間証明書をアンロードします。
 8647
 8648    \return SSL_SUCCESS 関数の正常な実行時に返されます。
 8649    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合に返されます。
 8650    \return BAD_MUTEX_E mutexエラーが発生した場合に返されます。
 8651
 8652    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8653
 8654    _Example_
 8655    \code
 8656    #include <wolfssl/ssl.h>
 8657
 8658    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 8659    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CTX_GetCertManager(ctx);
 8660    ...
 8661    if(wolfSSL_CertManagerUnloadIntermediateCerts(cm) != SSL_SUCCESS){
 8662    	// 失敗ケース。
 8663    }
 8664    \endcode
 8665
 8666    \sa UnlockMutex
 8667*/
 8668int wolfSSL_CertManagerUnloadIntermediateCerts(WOLFSSL_CERT_MANAGER* cm);/*!
 8669    \ingroup CertManager
 8670    \brief この関数は、Trusted Peerリンクリストを解放し、トラステッドピアリストのロックを解除します。
 8671
 8672    \return SSL_SUCCESS 関数が正常に完了した場合。
 8673    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合。
 8674    \return BAD_MUTEX_E WOLFSSL_CERT_MANAGER構造体のメンバであるtpLockが0(null)の場合、mutexエラー。
 8675
 8676    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8677
 8678    _Example_
 8679    \code
 8680    #include <wolfssl/ssl.h>
 8681
 8682    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(Protocol define);
 8683    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CertManagerNew();
 8684    ...
 8685    if(wolfSSL_CertManagerUnload_trust_peers(cm) != SSL_SUCCESS){
 8686	    // 関数は正常に実行されませんでした。
 8687    }
 8688    \endcode
 8689
 8690    \sa UnLockMutex
 8691*/
 8692int wolfSSL_CertManagerUnload_trust_peers(WOLFSSL_CERT_MANAGER* cm);
 8693
 8694/*!
 8695    \ingroup CertManager
 8696    \brief Certificate Managerコンテキストで検証する証明書を指定します。フォーマットはSSL_FILETYPE_PEMまたはSSL_FILETYPE_ASN1を指定できます。
 8697
 8698    \return SSL_SUCCESS 成功時。
 8699    \return ASN_SIG_CONFIRM_E 署名を検証できなかった場合に返されます。
 8700    \return ASN_SIG_OID_E 署名タイプがサポートされていない場合に返されます。
 8701    \return CRL_CERT_REVOKED この証明書が失効している場合に返されるエラー。
 8702    \return CRL_MISSING 現在の発行者CRLが利用できない場合に返されるエラー。
 8703    \return ASN_BEFORE_DATE_E 現在の日付がbefore dateより前の場合に返されます。
 8704    \return ASN_AFTER_DATE_E 現在の日付がafter dateより後の場合に返されます。
 8705    \return SSL_BAD_FILETYPE ファイルのフォーマットが間違っている場合に返されます。
 8706    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 8707    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 8708    \return ASN_INPUT_E ファイルのBase16デコードに失敗した場合に返されます。
 8709    \return BAD_FUNC_ARG ポインタが提供されていない場合に返されるエラー。
 8710
 8711    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8712    \param fname 検証する証明書を含むファイルの名前へのポインタ。
 8713    \param format 検証する証明書のフォーマット - SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 8714
 8715    _Example_
 8716    \code
 8717    int ret = 0;
 8718    WOLFSSL_CERT_MANAGER* cm;
 8719    ...
 8720
 8721    ret = wolfSSL_CertManagerVerify(cm, "path/to/cert-file.pem",
 8722    SSL_FILETYPE_PEM);
 8723    if (ret != SSL_SUCCESS) {
 8724	    // 証明書の検証エラー
 8725    }
 8726    \endcode
 8727
 8728    \sa wolfSSL_CertManagerLoadCA
 8729    \sa wolfSSL_CertManagerVerifyBuffer
 8730*/
 8731int wolfSSL_CertManagerVerify(WOLFSSL_CERT_MANAGER* cm, const char* f,
 8732                                                                    int format);
 8733
 8734/*!
 8735    \ingroup CertManager
 8736    \brief Certificate Managerコンテキストで検証する証明書バッファを指定します。フォーマットはSSL_FILETYPE_PEMまたはSSL_FILETYPE_ASN1を指定できます。
 8737
 8738    \return SSL_SUCCESS 成功時。
 8739    \return ASN_SIG_CONFIRM_E 署名を検証できなかった場合に返されます。
 8740    \return ASN_SIG_OID_E 署名タイプがサポートされていない場合に返されます。
 8741    \return CRL_CERT_REVOKED この証明書が失効している場合に返されるエラー。
 8742    \return CRL_MISSING 現在の発行者CRLが利用できない場合に返されるエラー。
 8743    \return ASN_BEFORE_DATE_E 現在の日付がbefore dateより前の場合に返されます。
 8744    \return ASN_AFTER_DATE_E 現在の日付がafter dateより後の場合に返されます。
 8745    \return SSL_BAD_FILETYPE ファイルのフォーマットが間違っている場合に返されます。
 8746    \return SSL_BAD_FILE ファイルが存在しない、読み取れない、または破損している場合に返されます。
 8747    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 8748    \return ASN_INPUT_E ファイルのBase16デコードに失敗した場合に返されます。
 8749    \return BAD_FUNC_ARG ポインタが提供されていない場合に返されるエラー。
 8750
 8751    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8752    \param buff 検証する証明書を含むバッファ。
 8753    \param sz バッファbufのサイズ。
 8754    \param format buf内にある検証する証明書のフォーマット - SSL_FILETYPE_ASN1またはSSL_FILETYPE_PEM。
 8755
 8756    _Example_
 8757    \code
 8758    #include <wolfssl/ssl.h>
 8759
 8760    int ret = 0;
 8761    int sz = 0;
 8762    WOLFSSL_CERT_MANAGER* cm;
 8763    byte certBuff[...];
 8764    ...
 8765
 8766    ret = wolfSSL_CertManagerVerifyBuffer(cm, certBuff, sz, SSL_FILETYPE_PEM);
 8767    if (ret != SSL_SUCCESS) {
 8768    	// 証明書の検証エラー
 8769    }
 8770
 8771    \endcode
 8772
 8773    \sa wolfSSL_CertManagerLoadCA
 8774    \sa wolfSSL_CertManagerVerify
 8775*/
 8776int wolfSSL_CertManagerVerifyBuffer(WOLFSSL_CERT_MANAGER* cm,
 8777                                const unsigned char* buff, long sz, int format);
 8778
 8779/*!
 8780    \ingroup CertManager
 8781    \brief この関数は、Certificate Manager内にverifyCallback関数を設定します。存在する場合、ロードされた各証明書に対して呼び出されます。検証エラーがある場合、verify callbackを使用してエラーをオーバーライドできます。
 8782
 8783    \return none 戻り値はありません。
 8784
 8785    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8786    \param verify_callback コールバックルーチンへのVerifyCallback関数ポインタ。
 8787
 8788    _Example_
 8789    \code
 8790    #include <wolfssl/ssl.h>
 8791
 8792    int myVerify(int preverify, WOLFSSL_X509_STORE_CTX* store)
 8793    { // 証明書のカスタム検証を実行 }
 8794
 8795    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new(Protocol define);
 8796    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CertManagerNew();
 8797    ...
 8798    wolfSSL_CertManagerSetVerify(cm, myVerify);
 8799
 8800    \endcode
 8801
 8802    \sa wolfSSL_CertManagerVerify
 8803*/
 8804void wolfSSL_CertManagerSetVerify(WOLFSSL_CERT_MANAGER* cm,
 8805        VerifyCallback verify_callback);
 8806
 8807/*!
 8808    \brief オプションが有効な場合、CRLをチェックし、証明書をCRLリストと比較します。
 8809
 8810    \return SSL_SUCCESS 関数が期待どおりに戻った場合に返されます。WOLFSSL_CERT_MANAGER構造体のcrlEnabledメンバがオンになっている場合。
 8811    \return MEMORY_E 割り当てられたメモリが失敗した場合に返されます。
 8812    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合。
 8813
 8814    \param cm WOLFSSL_CERT_MANAGER構造体へのポインタ。
 8815    \param der DERフォーマットの証明書へのポインタ。
 8816    \param sz 証明書のサイズ。
 8817
 8818    _Example_
 8819    \code
 8820    WOLFSSL_CERT_MANAGER* cm;
 8821    byte* der;
 8822    int sz; // derのサイズ
 8823    ...
 8824    if(wolfSSL_CertManagerCheckCRL(cm, der, sz) != SSL_SUCCESS){
 8825    	// エラーが返されました。失敗ケースを処理。
 8826    }
 8827    \endcode
 8828
 8829    \sa CheckCertCRL
 8830    \sa ParseCertRelative
 8831    \sa wolfSSL_CertManagerSetCRL_CB
 8832    \sa InitDecodedCert
 8833*/
 8834int wolfSSL_CertManagerCheckCRL(WOLFSSL_CERT_MANAGER* cm,
 8835                                const unsigned char* der, int sz);
 8836
 8837/*!
 8838    \ingroup CertManager
 8839    \brief Certificate Managerで証明書を検証する際に、Certificate Revocation Listチェックをオンにします。デフォルトでは、CRLチェックはオフです。optionsには、リーフ証明書のみ(デフォルト)ではなくチェーン内の各証明書に対してCRLチェックを実行するWOLFSSL_CRL_CHECKALLが含まれます。
 8840
 8841    \return SSL_SUCCESS 成功した場合、呼び出しは戻ります。
 8842    \return NOT_COMPILED_IN wolfSSLがCRLを有効にしてビルドされていない場合に返されます。
 8843    \return MEMORY_E メモリ不足状態が発生した場合に返されます。
 8844    \return BAD_FUNC_ARG ポインタが提供されていない場合に返されるエラー。
 8845    \return SSL_FAILURE CRLコンテキストを適切に初期化できない場合に返されます。
 8846
 8847    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8848    \param options Certification Manager(cm)を有効にする際に使用するオプション。
 8849
 8850    _Example_
 8851    \code
 8852    #include <wolfssl/ssl.h>
 8853
 8854    int ret = 0;
 8855    WOLFSSL_CERT_MANAGER* cm;
 8856    ...
 8857
 8858    ret = wolfSSL_CertManagerEnableCRL(cm, 0);
 8859    if (ret != SSL_SUCCESS) {
 8860    	// cert managerの有効化エラー
 8861    }
 8862
 8863    ...
 8864    \endcode
 8865
 8866    \sa wolfSSL_CertManagerDisableCRL
 8867*/
 8868int wolfSSL_CertManagerEnableCRL(WOLFSSL_CERT_MANAGER* cm,
 8869                                                                   int options);
 8870
 8871/*!
 8872    \ingroup CertManager
 8873    \brief Certificate Managerで証明書を検証する際に、Certificate Revocation Listチェックをオフにします。デフォルトでは、CRLチェックはオフです。この関数を使用して、以前にCRLチェックを有効にしていたこのCertificate Managerコンテキストに対して、CRLチェックを一時的または永続的に無効にできます。
 8874
 8875    \return SSL_SUCCESS 成功した場合、呼び出しは戻ります。
 8876    \return BAD_FUNC_ARG 関数ポインタが提供されていない場合に返されるエラー。
 8877
 8878    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8879
 8880    _Example_
 8881    \code
 8882    #include <wolfssl/ssl.h>
 8883
 8884    int ret = 0;
 8885    WOLFSSL_CERT_MANAGER* cm;
 8886    ...
 8887    ret = wolfSSL_CertManagerDisableCRL(cm);
 8888    if (ret != SSL_SUCCESS) {
 8889    	// cert managerの無効化エラー
 8890    }
 8891    ...
 8892    \endcode
 8893
 8894    \sa wolfSSL_CertManagerEnableCRL
 8895*/
 8896int wolfSSL_CertManagerDisableCRL(WOLFSSL_CERT_MANAGER* cm);
 8897
 8898/*!
 8899    \ingroup CertManager
 8900    \brief エラーチェックを行い、LoadCRL()に渡して失効チェックのためにCRLに証明書をロードします。更新されたCRLをロードするには、まずwolfSSL_CertManagerFreeCRLを呼び出してから、新しいCRLをロードします。
 8901
 8902    \return SSL_SUCCESS wolfSSL_CertManagerLoadCRLにエラーがなく、LoadCRLが正常に戻った場合。
 8903    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合。
 8904    \return SSL_FATAL_ERROR wolfSSL_CertManagerEnableCRLがSSL_SUCCESS以外を返した場合。
 8905    \return BAD_PATH_ERROR pathがNULLの場合。
 8906    \return MEMORY_E LoadCRLがヒープメモリの割り当てに失敗した場合。
 8907
 8908    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 8909    \param path CRLパスを保持する定数char型ポインタ。
 8910    \param type ロードする証明書のタイプ。
 8911    \param monitor LoadCRL()での監視を要求します。
 8912
 8913    _Example_
 8914    \code
 8915    #include <wolfssl/ssl.h>
 8916
 8917    int wolfSSL_LoadCRL(WOLFSSL* ssl, const char* path, int type,
 8918    int monitor);
 8919    …
 8920    wolfSSL_CertManagerLoadCRL(SSL_CM(ssl), path, type, monitor);
 8921    \endcode
 8922
 8923    \sa wolfSSL_CertManagerEnableCRL
 8924    \sa wolfSSL_LoadCRL
 8925    \sa wolfSSL_CertManagerFreeCRL
 8926*/
 8927int wolfSSL_CertManagerLoadCRL(WOLFSSL_CERT_MANAGER* cm,
 8928                               const char* path, int type, int monitor);
 8929
 8930/*!
 8931    \ingroup CertManager
 8932    \brief この関数は、BufferLoadCRLを呼び出してCRLファイルをロードします。
 8933
 8934    \return SSL_SUCCESS 関数がエラーなく完了した場合に返されます。
 8935    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合に返されます。
 8936    \return SSL_FATAL_ERROR WOLFSSL_CERT_MANAGERに関連するエラーがある場合に返されます。
 8937
 8938    \param cm WOLFSSL_CERT_MANAGER構造体へのポインタ。
 8939    \param buff 定数byte型でバッファです。
 8940    \param sz バッファのサイズを表すlong int型。
 8941    \param type 証明書タイプを保持するlong integer型。
 8942
 8943    _Example_
 8944    \code
 8945    #include <wolfssl/ssl.h>
 8946
 8947    WOLFSSL_CERT_MANAGER* cm;
 8948    const unsigned char* buff;
 8949    long sz; バッファのサイズ
 8950    int type;  証明書タイプ
 8951    ...
 8952    int ret = wolfSSL_CertManagerLoadCRLBuffer(cm, buff, sz, type);
 8953    if(ret == SSL_SUCCESS){
 8954	    return ret;
 8955    } else {
 8956    	// 失敗ケース。
 8957    }
 8958    \endcode
 8959
 8960    \sa BufferLoadCRL
 8961    \sa wolfSSL_CertManagerEnableCRL
 8962*/
 8963int wolfSSL_CertManagerLoadCRLBuffer(WOLFSSL_CERT_MANAGER* cm,
 8964                                     const unsigned char* buff, long sz,
 8965                                     int type);
 8966
 8967/*!
 8968    \ingroup CertManager
 8969    \brief この関数は、CRL Certificate Managerコールバックを設定します。HAVE_CRLが定義されており、一致するCRLレコードが見つからない場合、cbMissingCRLが呼び出されます(wolfSSL_CertManagerSetCRL_Cbで設定)。これにより、外部からCRLを取得してロードできます。
 8970
 8971    \return SSL_SUCCESS 関数とサブルーチンの実行が成功した場合に返されます。
 8972    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 8973
 8974    \param cm 証明書の情報を保持するWOLFSSL_CERT_MANAGER構造体。
 8975    \param cb WOLFSSL_CERT_MANAGERのcbMissingCRLメンバに設定される(*CbMissingCRL)への関数ポインタ。
 8976
 8977    _Example_
 8978    \code
 8979    #include <wolfssl/ssl.h>
 8980
 8981    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 8982    WOLFSSL* ssl = wolfSSL_new(ctx);
 8983    …
 8984    void cb(const char* url){
 8985	    // 関数本体。
 8986    }
 8987    …
 8988    CbMissingCRL cb = CbMissingCRL;
 8989    …
 8990    if(ctx){
 8991        return wolfSSL_CertManagerSetCRL_Cb(SSL_CM(ssl), cb);
 8992    }
 8993    \endcode
 8994
 8995    \sa CbMissingCRL
 8996    \sa wolfSSL_SetCRL_Cb
 8997*/
 8998int wolfSSL_CertManagerSetCRL_Cb(WOLFSSL_CERT_MANAGER* cm,
 8999                                 CbMissingCRL cb);
 9000
 9001/*!
 9002    \ingroup CertManager
 9003    \brief この関数は、CRL更新コールバックを設定します。HAVE_CRLとHAVE_CRL_UPDATE_CBが定義されており、CRLが追加されるときに同じ発行者でより低いCRL番号を持つエントリが存在する場合、既存のエントリと、それを置き換える新しいエントリの詳細と共にCbUpdateCRLが呼び出されます。
 9004
 9005    \return SSL_SUCCESS 関数とサブルーチンが正常に実行された場合に返されます。
 9006    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9007
 9008    \param cm 証明書の情報を保持するWOLFSSL_CERT_MANAGER構造体。
 9009    \param cb WOLFSSL_CERT_MANAGERのcbUpdateCRLメンバに設定される(*CbUpdateCRL)への関数ポインタ。
 9010    シグネチャ要件:
 9011	void (*CbUpdateCRL)(CrlInfo *old, CrlInfo *new);
 9012
 9013    _Example_
 9014    \code
 9015    #include <wolfssl/ssl.h>
 9016
 9017    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 9018    WOLFSSL* ssl = wolfSSL_new(ctx);
 9019    …
 9020    void cb(CrlInfo *old, CrlInfo *new){
 9021	    // 関数本体。
 9022    }
 9023    …
 9024    CbUpdateCRL cb = CbUpdateCRL;
 9025    …
 9026    if(ctx){
 9027        return wolfSSL_CertManagerSetCRLUpdate_Cb(SSL_CM(ssl), cb);
 9028    }
 9029    \endcode
 9030
 9031    \sa CbUpdateCRL
 9032*/
 9033int wolfSSL_CertManagerSetCRLUpdate_Cb(WOLFSSL_CERT_MANAGER* cm,
 9034                                       CbUpdateCRL cb);
 9035
 9036/*!
 9037    \ingroup CertManager
 9038    \brief この関数は、エンコードされたCRLバッファから解析されたCRL情報を含む構造体を生成します。
 9039
 9040    \return SSL_SUCCESS 関数とサブルーチンが正常に実行された場合に返されます。
 9041    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9042
 9043    \param cm   WOLFSSL_CERT_MANAGER構造体。
 9044    \param info CRL情報を受け取る呼び出し元管理のCrlInfo構造体へのポインタ。
 9045    \param buff エンコードされたCRLを含む入力バッファ。
 9046    \param sz   buff内の入力CRLデータの長さ(バイト単位)。
 9047    \param type WOLFSSL_FILETYPE_PEMまたはWOLFSSL_FILETYPE_DER
 9048
 9049    _Example_
 9050    \code
 9051    #include <wolfssl/ssl.h>
 9052
 9053    CrlInfo info;
 9054    WOLFSSL_CERT_MANAGER* cm = NULL;
 9055
 9056    cm = wolfSSL_CertManagerNew();
 9057
 9058    // ファイルからバッファへcrlデータを読み込む
 9059
 9060    wolfSSL_CertManagerGetCRLInfo(cm, &info, crlData, crlDataLen,
 9061                                  WOLFSSL_FILETYPE_PEM);
 9062    \endcode
 9063
 9064    \sa CbUpdateCRL
 9065    \sa wolfSSL_SetCRL_Cb
 9066*/
 9067int wolfSSL_CertManagerGetCRLInfo(WOLFSSL_CERT_MANAGER* cm, CrlInfo* info,
 9068    const byte* buff, long sz, int type)
 9069
 9070/*!
 9071    \ingroup CertManager
 9072    \brief この関数は、証明書マネージャに保存されているCRLを解放します。アプリケーションは、wolfSSL_CertManagerFreeCRLを呼び出してから新しいCRLを読み込むことで、CRLを更新できます。
 9073
 9074    \return SSL_SUCCESS 関数とサブルーチンが正常に実行された場合に返されます。
 9075    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9076
 9077    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 9078
 9079    _Example_
 9080    \code
 9081    #include <wolfssl/ssl.h>
 9082
 9083    const char* crl1     = "./certs/crl/crl.pem";
 9084    WOLFSSL_CERT_MANAGER* cm = NULL;
 9085
 9086    cm = wolfSSL_CertManagerNew();
 9087    wolfSSL_CertManagerLoadCRL(cm, crl1, WOLFSSL_FILETYPE_PEM, 0);
 9088    …
 9089    wolfSSL_CertManagerFreeCRL(cm);
 9090    \endcode
 9091
 9092    \sa wolfSSL_CertManagerLoadCRL
 9093*/
 9094int wolfSSL_CertManagerFreeCRL(WOLFSSL_CERT_MANAGER* cm);
 9095
 9096/*!
 9097    \ingroup CertManager
 9098    \brief この関数は、WOLFSSL_CERT_MANAGERのメンバであるocspEnabledを有効にして、OCSPチェックオプションが有効になっていることを示します。
 9099
 9100    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。WOLFSSL_CERT_MANAGERのocspEnabledメンバが有効になります。
 9101    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合、またはサブルーチンに許可されていない引数値が渡された場合に返されます。
 9102    \return MEMORY_E この関数またはサブルーチン内でメモリの割り当てにエラーがある場合に返されます。
 9103
 9104    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 9105    \param der 証明書へのbyteポインタ。
 9106    \param sz DER証明書のサイズを表すint型。
 9107
 9108    _Example_
 9109    \code
 9110    #import <wolfssl/ssl.h>
 9111
 9112    WOLFSSL* ssl = wolfSSL_new(ctx);
 9113    byte* der;
 9114    int sz; // derのサイズ
 9115    ...
 9116    if(wolfSSL_CertManagerCheckOCSP(cm, der, sz) != SSL_SUCCESS){
 9117	    // 失敗ケース。
 9118    }
 9119    \endcode
 9120
 9121    \sa ParseCertRelative
 9122    \sa CheckCertOCSP
 9123*/
 9124int wolfSSL_CertManagerCheckOCSP(WOLFSSL_CERT_MANAGER* cm,
 9125                                 const unsigned char* der, int sz);
 9126
 9127/*!
 9128    \ingroup CertManager
 9129    \brief OCSPがオフになっている場合にオンにし、設定オプションでコンパイルされている場合に有効にします。
 9130
 9131    \return SSL_SUCCESS 関数呼び出しが成功した場合に返されます。
 9132    \return BAD_FUNC_ARG cm構造体がNULLの場合。
 9133    \return MEMORY_E WOLFSSL_OCSP構造体の値がNULLの場合。
 9134    \return SSL_FAILURE WOLFSSL_OCSP構造体の初期化が失敗した場合。
 9135    \return NOT_COMPILED_IN 正しい機能を有効にしてコンパイルされていないビルド。
 9136
 9137    \param cm wolfSSL_CertManagerNew()を使用して作成されたWOLFSSL_CERT_MANAGER構造体へのポインタ。
 9138    \param options WOLFSSL_CERT_MANAGER構造体の値を設定するために使用されます。
 9139
 9140    _Example_
 9141    \code
 9142    #include <wolfssl/ssl.h>
 9143
 9144    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(protocol method);
 9145    WOLFSSL* ssl = wolfSSL_new(ctx);
 9146    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CertManagerNew();
 9147    int options;
 9148    …
 9149    if(wolfSSL_CertManagerEnableOCSP(SSL_CM(ssl), options) != SSL_SUCCESS){
 9150	    // 失敗ケース。
 9151    }
 9152    \endcode
 9153
 9154    \sa wolfSSL_CertManagerNew
 9155*/
 9156int wolfSSL_CertManagerEnableOCSP(WOLFSSL_CERT_MANAGER* cm,
 9157                                                                   int options);
 9158
 9159/*!
 9160    \ingroup CertManager
 9161    \brief OCSP証明書失効を無効にします。
 9162
 9163    \return SSL_SUCCESS wolfSSL_CertMangerDisableCRLがWOLFSSL_CERT_MANAGER構造体のcrlEnabledメンバを正常に無効にしました。
 9164    \return BAD_FUNC_ARG WOLFSSL構造体がNULLでした。
 9165
 9166    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9167
 9168    _Example_
 9169    \code
 9170    #include <wolfssl/ssl.h>
 9171
 9172    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(method);
 9173    WOLFSSL* ssl = wolfSSL_new(ctx);
 9174    ...
 9175    if(wolfSSL_CertManagerDisableOCSP(ssl) != SSL_SUCCESS){
 9176	    // 失敗ケース。
 9177    }
 9178    \endcode
 9179
 9180    \sa wolfSSL_DisableCRL
 9181*/
 9182int wolfSSL_CertManagerDisableOCSP(WOLFSSL_CERT_MANAGER* cm);
 9183
 9184/*!
 9185    \ingroup CertManager
 9186    \brief この関数は、URLをWOLFSSL_CERT_MANAGER構造体のocspOverrideURLメンバにコピーします。
 9187
 9188    \return SSL_SUCCESS 関数が期待通りに実行できた場合。
 9189    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合。
 9190    \return MEMEORY_E 証明書マネージャのocspOverrideURLメンバにメモリを割り当てることができなかった場合。
 9191
 9192    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9193
 9194    _Example_
 9195    \code
 9196    #include <wolfssl/ssl.h>
 9197    WOLFSSL_CERT_MANAGER* cm = wolfSSL_CertManagerNew();
 9198    const char* url;
 9199    …
 9200    int wolfSSL_SetOCSP_OverrideURL(WOLFSSL* ssl, const char* url)
 9201    …
 9202    if(wolfSSL_CertManagerSetOCSPOverrideURL(SSL_CM(ssl), url) != SSL_SUCCESS){
 9203	    // 失敗ケース。
 9204    }
 9205    \endcode
 9206
 9207    \sa ocspOverrideURL
 9208    \sa wolfSSL_SetOCSP_OverrideURL
 9209*/
 9210int wolfSSL_CertManagerSetOCSPOverrideURL(WOLFSSL_CERT_MANAGER* cm,
 9211                                          const char* url);
 9212
 9213/*!
 9214    \ingroup CertManager
 9215    \brief この関数は、WOLFSSL_CERT_MANAGER内のOCSPコールバックを設定します。
 9216
 9217    \return SSL_SUCCESS 実行が成功した場合に返されます。引数はWOLFSSL_CERT_MANAGER構造体に保存されます。
 9218    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERがNULLの場合に返されます。
 9219
 9220    \param cm WOLFSSL_CERT_MANAGER構造体へのポインタ。
 9221    \param ioCb CbOCSPIO型の関数ポインタ。
 9222    \param respFreeCb CbOCSPRespFree型の関数ポインタ。
 9223    \param ioCbCtx I/Oコールバックユーザ登録コンテキストへのvoidポインタ変数。
 9224
 9225    _Example_
 9226    \code
 9227    #include <wolfssl/ssl.h>
 9228
 9229    wolfSSL_SetOCSP_Cb(WOLFSSL* ssl, CbOCSPIO ioCb,
 9230    CbOCSPRespFree respFreeCb, void* ioCbCtx){
 9231        …
 9232        return wolfSSL_CertManagerSetOCSP_Cb(SSL_CM(ssl), ioCb, respFreeCb, ioCbCtx);
 9233    \endcode
 9234
 9235    \sa wolfSSL_CertManagerSetOCSPOverrideURL
 9236    \sa wolfSSL_CertManagerCheckOCSP
 9237    \sa wolfSSL_CertManagerEnableOCSPStapling
 9238    \sa wolfSSL_EnableOCSP
 9239    \sa wolfSSL_DisableOCSP
 9240    \sa wolfSSL_SetOCSP_Cb
 9241*/
 9242int wolfSSL_CertManagerSetOCSP_Cb(WOLFSSL_CERT_MANAGER* cm,
 9243                                  CbOCSPIO ioCb, CbOCSPRespFree respFreeCb,
 9244                                  void* ioCbCtx);
 9245
 9246/*!
 9247    \ingroup CertManager
 9248    \brief この関数は、OCSPステープリングがオンになっていない場合にオンにし、オプションを設定します。
 9249
 9250    \return SSL_SUCCESS エラーがなく、関数が正常に実行された場合に返されます。
 9251    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGER構造体がNULLの場合、またはサブルーチンに許可されていない引数値が渡された場合に返されます。
 9252    \return MEMORY_E メモリの割り当てに問題があった場合に返されます。
 9253    \return SSL_FAILURE OCSP構造体の初期化が失敗した場合に返されます。
 9254    \return NOT_COMPILED_IN wolfSSLがHAVE_CERTIFICATE_STATUS_REQUESTオプションでコンパイルされていない場合に返されます。
 9255
 9256    \param cm WOLFSSL_CTX構造体のメンバであるWOLFSSL_CERT_MANAGER構造体へのポインタ。
 9257
 9258    _Example_
 9259    \code
 9260    int wolfSSL_CTX_EnableOCSPStapling(WOLFSSL_CTX* ctx){
 9261        …
 9262        return wolfSSL_CertManagerEnableOCSPStapling(ctx->cm);
 9263    \endcode
 9264
 9265    \sa wolfSSL_CTX_EnableOCSPStapling
 9266*/
 9267int wolfSSL_CertManagerEnableOCSPStapling(
 9268                                                      WOLFSSL_CERT_MANAGER* cm);
 9269
 9270/*!
 9271    \brief CRL証明書失効を有効にします。
 9272
 9273    \return SSL_SUCCESS 関数とサブルーチンがエラーなく返された場合。
 9274    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
 9275    \return MEMORY_E メモリの割り当てが失敗した場合に返されます。
 9276    \return SSL_FAILURE InitCRL関数が正常に返されなかった場合に返されます。
 9277    \return NOT_COMPILED_IN コンパイル時にHAVE_CRLが有効になっていませんでした。
 9278
 9279    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9280    \param options WOLFSSL_CERT_MANAGER構造体のcrlCheckAllメンバの設定を決定するために使用される整数。
 9281
 9282    _Example_
 9283    \code
 9284    WOLFSSL* ssl = wolfSSL_new(ctx);
 9285    …
 9286    if (wolfSSL_EnableCRL(ssl, WOLFSSL_CRL_CHECKALL) != SSL_SUCCESS){
 9287	    // 失敗ケース。この関数またはサブルーチンがSSL_SUCCESSを返しませんでした。
 9288    }
 9289    \endcode
 9290
 9291    \sa wolfSSL_CertManagerEnableCRL
 9292    \sa InitCRL
 9293*/
 9294int wolfSSL_EnableCRL(WOLFSSL* ssl, int options);
 9295
 9296/*!
 9297    \brief CRL証明書失効を無効にします。
 9298
 9299    \return SSL_SUCCESS wolfSSL_CertMangerDisableCRLがWOLFSSL_CERT_MANAGER構造体のcrlEnabledメンバを正常に無効にしました。
 9300    \return BAD_FUNC_ARG WOLFSSL構造体がNULLでした。
 9301
 9302    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9303
 9304    _Example_
 9305    \code
 9306    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9307    WOLFSSL* ssl = wolfSSL_new(ctx);
 9308    ...
 9309    if(wolfSSL_DisableCRL(ssl) != SSL_SUCCESS){
 9310    	// 失敗ケース
 9311    }
 9312    \endcode
 9313
 9314    \sa wolfSSL_CertManagerDisableCRL
 9315    \sa wolfSSL_CertManagerDisableOCSP
 9316*/
 9317int wolfSSL_DisableCRL(WOLFSSL* ssl);
 9318
 9319/*!
 9320    \brief 失効チェックのための証明書を読み込むためにLoadCRLを最終的に呼び出すラッパー関数です。
 9321
 9322    \return WOLFSSL_SUCCESS 関数とすべてのサブルーチンがエラーなく実行された場合に返されます。
 9323    \return SSL_FATAL_ERROR サブルーチンの1つが正常に返されなかった場合に返されます。
 9324    \return BAD_FUNC_ARG WOLFSSL_CERT_MANAGERまたはWOLFSSL構造体がNULLの場合。
 9325
 9326    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9327    \param path crlファイルへのパスを保持する定数文字ポインタ。
 9328    \param type 証明書のタイプを表す整数。
 9329    \param monitor 要求された場合にモニタパスを検証するために使用される整数変数。
 9330
 9331    _Example_
 9332    \code
 9333    WOLFSSL* ssl = wolfSSL_new(ctx);
 9334    const char* crlPemDir;
 9335    …
 9336    if(wolfSSL_LoadCRL(ssl, crlPemDir, SSL_FILETYPE_PEM, 0) != SSL_SUCCESS){
 9337    	// 失敗ケース。SSL_SUCCESSを返しませんでした。
 9338    }
 9339    \endcode
 9340
 9341    \sa wolfSSL_CertManagerLoadCRL
 9342    \sa wolfSSL_CertManagerEnableCRL
 9343    \sa LoadCRL
 9344*/
 9345int wolfSSL_LoadCRL(WOLFSSL* ssl, const char* path, int type, int monitor);
 9346
 9347/*!
 9348    \brief WOLFSSL_CERT_MANAGER構造体内のCRLコールバックを設定します。
 9349
 9350    \return SSL_SUCCESS 関数またはサブルーチンがエラーなく実行された場合に返されます。WOLFSSL_CERT_MANAGERのcbMissingCRLメンバが設定されます。
 9351    \return BAD_FUNC_ARG WOLFSSLまたはWOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9352
 9353    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9354    \param cb CbMissingCRLへの関数ポインタ。
 9355
 9356    _Example_
 9357    \code
 9358    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 9359    WOLFSSL* ssl = wolfSSL_new(ctx);
 9360    …
 9361    void cb(const char* url) // 必要なシグネチャ
 9362    {
 9363        // 関数本体
 9364    }
 9365    …
 9366    int crlCb = wolfSSL_SetCRL_Cb(ssl, cb);
 9367    if(crlCb != SSL_SUCCESS){
 9368    	// コールバックが正しく設定されませんでした
 9369    }
 9370    \endcode
 9371
 9372    \sa CbMissingCRL
 9373    \sa wolfSSL_CertManagerSetCRL_Cb
 9374*/
 9375int wolfSSL_SetCRL_Cb(WOLFSSL* ssl, CbMissingCRL cb);
 9376
 9377/*!
 9378    \brief この関数は、OCSP証明書検証を有効にします。optionsの値は、以下のオプションの1つ以上をOR演算することで形成されます。
 9379    WOLFSSL_OCSP_URL_OVERRIDE - 証明書内のURLの代わりにオーバーライドURLを使用します。オーバーライドURLはwolfSSL_CTX_SetOCSP_OverrideURL()関数を使用して指定されます。
 9380    WOLFSSL_OCSP_CHECKALL - すべてのOCSPチェックをオンに設定します。
 9381    WOLFSSL_OCSP_NO_NONCE - OCSP要求作成時のnonceオプションを設定します。
 9382
 9383    \return SSL_SUCCESS 関数とサブルーチンがエラーなしで実行された場合に返されます。
 9384    \return BAD_FUNC_ARG この関数またはサブルーチンの引数が無効な引数値を受け取った場合に返されます。
 9385    \return MEMORY_E 構造体または他の変数のメモリ割り当てでエラーが発生した場合に返されます。
 9386    \return NOT_COMPILED_IN wolfSSLがHAVE_OCSPオプション付きでコンパイルされていない場合に返されます。
 9387
 9388    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9389    \param options 設定チェックに使用されるwolfSSL_CertMangerENableOCSP()に渡される整数型。
 9390
 9391    _Example_
 9392    \code
 9393    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9394    WOLFSSL* ssl = wolfSSL_new(ctx);
 9395    int options; // オプション定数で初期化
 9396    …
 9397    int ret = wolfSSL_EnableOCSP(ssl, options);
 9398    if(ret != SSL_SUCCESS){
 9399    	// OCSPが有効になっていません
 9400    }
 9401    \endcode
 9402
 9403    \sa wolfSSL_CertManagerEnableOCSP
 9404*/
 9405int wolfSSL_EnableOCSP(WOLFSSL* ssl, int options);
 9406
 9407/*!
 9408    \brief OCSP証明書失効オプションを無効にします。
 9409
 9410    \return SSL_SUCCESS 関数とそのサブルーチンがエラーなしで返された場合に返されます。WOLFSSL_CERT_MANAGER構造体のocspEnabledメンバが正常に設定されました。
 9411    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
 9412
 9413    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9414
 9415    _Example_
 9416    \code
 9417    WOLFSSL* ssl = wolfSSL_new(ctx);
 9418    …
 9419    if(wolfSSL_DisableOCSP(ssl) != SSL_SUCCESS){
 9420	    // エラーで返されました。このブロック内が失敗ケースです
 9421    }
 9422    \endcode
 9423
 9424    \sa wolfSSL_CertManagerDisableOCSP
 9425*/
 9426int wolfSSL_DisableOCSP(WOLFSSL* ssl);
 9427
 9428/*!
 9429    \brief この関数は、WOLFSSL_CERT_MANAGER構造体のocspOverrideURLメンバを設定します。
 9430
 9431    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。
 9432    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合、またはサブルーチンに許可されていない引数が渡された場合に返されます。
 9433    \return MEMORY_E サブルーチンでメモリ割り当てエラーが発生した場合に返されます。
 9434
 9435    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9436    \param url WOLFSSL_CERT_MANAGER構造体のocspOverrideURLメンバに格納されるURLへの定数charポインタ。
 9437
 9438    _Example_
 9439    \code
 9440    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9441    WOLFSSL* ssl = wolfSSL_new(ctx);
 9442    char url[URLSZ];
 9443    ...
 9444    if(wolfSSL_SetOCSP_OverrideURL(ssl, url)){
 9445    	// オーバーライドURLが新しい値に設定されました
 9446    }
 9447    \endcode
 9448
 9449    \sa wolfSSL_CertManagerSetOCSPOverrideURL
 9450*/
 9451int wolfSSL_SetOCSP_OverrideURL(WOLFSSL* ssl, const char* url);
 9452
 9453/*!
 9454    \brief この関数は、WOLFSSL_CERT_MANAGER構造体にOCSPコールバックを設定します。
 9455
 9456    \return SSL_SUCCESS 関数がエラーなしで実行された場合に返されます。CMのocspIOCb、ocspRespFreeCb、ocspIOCtxメンバが設定されます。
 9457    \return BAD_FUNC_ARG WOLFSSLまたはWOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9458
 9459    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9460    \param ioCb CbOCSPIO型への関数ポインタ。
 9461    \param respFreeCb CbOCSPRespFree型への関数ポインタで、レスポンスメモリを解放する呼び出しです。
 9462    \param ioCbCtx CMのocspIOCtxメンバに保持されるvoidポインタ。
 9463
 9464    _Example_
 9465    \code
 9466    WOLFSSL* ssl = wolfSSL_new(ctx);
 9467    …
 9468    int OCSPIO_CB(void* , const char*, int , unsigned char* , int,
 9469    unsigned char**){  // このシグネチャが必要です
 9470        // 関数本体
 9471    }
 9472    …
 9473    void OCSPRespFree_CB(void* , unsigned char* ){ // このシグネチャが必要です
 9474    	// 関数本体
 9475    }
 9476    …
 9477    void* ioCbCtx;
 9478    CbOCSPRespFree CB_OCSPRespFree;
 9479
 9480    if(wolfSSL_SetOCSP_Cb(ssl, OCSPIO_CB( pass args ), CB_OCSPRespFree,
 9481				ioCbCtx) != SSL_SUCCESS){
 9482	    // コールバックが設定されませんでした
 9483    }
 9484    \endcode
 9485
 9486    \sa wolfSSL_CertManagerSetOCSP_Cb
 9487    \sa CbOCSPIO
 9488    \sa CbOCSPRespFree
 9489*/
 9490int wolfSSL_SetOCSP_Cb(WOLFSSL* ssl, CbOCSPIO ioCb, CbOCSPRespFree respFreeCb,
 9491                       void* ioCbCtx);
 9492
 9493/*!
 9494    \brief CTXを通じてCRL証明書検証を有効にします。
 9495
 9496    \return SSL_SUCCESS この関数とそのサブルーチンがエラーなしで実行された場合に返されます。
 9497    \return BAD_FUNC_ARG CTX構造体がNULLの場合、またはサブルーチンで無効な引数が渡された場合に返されます。
 9498    \return MEMORY_E 関数の実行中にメモリ割り当てエラーが発生した場合に返されます。
 9499    \return SSL_FAILURE WOLFSSL_CERT_MANAGERのcrlメンバが正しく初期化できなかった場合に返されます。
 9500    \return NOT_COMPILED_IN wolfSSLがHAVE_CRLオプション付きでコンパイルされていません。
 9501
 9502    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9503
 9504    _Example_
 9505    \code
 9506    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9507    WOLFSSL* ssl = wolfSSL_new(ctx);
 9508    ...
 9509    if(wolfSSL_CTX_EnableCRL(ssl->ctx, options) != SSL_SUCCESS){
 9510    	// 関数が失敗しました
 9511    }
 9512    \endcode
 9513
 9514    \sa wolfSSL_CertManagerEnableCRL
 9515    \sa InitCRL
 9516    \sa wolfSSL_CTX_DisableCRL
 9517*/
 9518int wolfSSL_CTX_EnableCRL(WOLFSSL_CTX* ctx, int options);
 9519
 9520/*!
 9521    \brief この関数は、CTX構造体でCRL検証を無効にします。
 9522
 9523    \return SSL_SUCCESS 関数がエラーなしで実行された場合に返されます。WOLFSSL_CERT_MANAGER構造体のcrlEnabledメンバが0に設定されます。
 9524    \return BAD_FUNC_ARG CTX構造体またはCM構造体のいずれかがNULL値の場合に返されます。
 9525
 9526    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 9527
 9528    _Example_
 9529    \code
 9530    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9531    WOLFSSL* ssl = wolfSSL_new(ctx);
 9532    ...
 9533    if(wolfSSL_CTX_DisableCRL(ssl->ctx) != SSL_SUCCESS){
 9534    	// 失敗ケース
 9535    }
 9536    \endcode
 9537
 9538    \sa wolfSSL_CertManagerDisableCRL
 9539*/
 9540int wolfSSL_CTX_DisableCRL(WOLFSSL_CTX* ctx);
 9541
 9542/*!
 9543    \brief この関数は、wolfSSL_CertManagerLoadCRL()を通じてCRLをWOLFSSL_CTX構造体にロードします。
 9544
 9545    \return SSL_SUCCESS - 関数とそのサブルーチンがエラーなしで実行された場合に返されます。
 9546    \return BAD_FUNC_ARG - この関数またはサブルーチンにNULL構造体が渡された場合に返されます。
 9547    \return BAD_PATH_ERROR - path変数がNULLとして開かれた場合に返されます。
 9548    \return MEMORY_E - メモリの割り当てが失敗した場合に返されます。
 9549
 9550    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 9551    \param path 証明書へのパス。
 9552    \param type 証明書のタイプを保持する整数変数。
 9553    \param monitor モニタパスが要求されているかを判定するために使用される整数変数。
 9554
 9555    _Example_
 9556    \code
 9557    WOLFSSL_CTX* ctx;
 9558    const char* path;
 9559    …
 9560    return wolfSSL_CTX_LoadCRL(ctx, path, SSL_FILETYPE_PEM, 0);
 9561    \endcode
 9562
 9563    \sa wolfSSL_CertManagerLoadCRL
 9564    \sa LoadCRL
 9565*/
 9566int wolfSSL_CTX_LoadCRL(WOLFSSL_CTX* ctx, const char* path, int type, int monitor);
 9567
 9568/*!
 9569    \brief この関数は、wolfSSL_CertManagerSetCRL_Cbを呼び出すことにより、コールバック引数をWOLFSSL_CERT_MANAGER構造体のcbMissingCRLメンバに設定します。
 9570
 9571    \return SSL_SUCCESS 実行が成功した場合に返されます。WOLFSSL_CERT_MANAGER構造体のメンバcbMssingCRLがcbに正常に設定されました。
 9572    \return BAD_FUNC_ARG WOLFSSL_CTXまたはWOLFSSL_CERT_MANAGERがNULLの場合に返されます。
 9573
 9574    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
 9575    \param cb CbMissingCRL型のコールバック関数へのポインタ。
 9576    シグネチャ要件:
 9577	void (*CbMissingCRL)(const char* url);
 9578
 9579    _Example_
 9580    \code
 9581    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 9582    …
 9583    void cb(const char* url) // 必要なシグネチャ
 9584    {
 9585    	// 関数本体
 9586    }
 9587    …
 9588    if (wolfSSL_CTX_SetCRL_Cb(ctx, cb) != SSL_SUCCESS){
 9589    	// 失敗ケース、cbが正しく設定されませんでした
 9590    }
 9591    \endcode
 9592
 9593    \sa wolfSSL_CertManagerSetCRL_Cb
 9594    \sa CbMissingCRL
 9595*/
 9596int wolfSSL_CTX_SetCRL_Cb(WOLFSSL_CTX* ctx, CbMissingCRL cb);
 9597
 9598/*!
 9599    \brief この関数は、wolfSSLのOCSP機能の動作を設定するオプションを設定します。optionsの値は、以下のオプションの1つ以上をOR演算することで形成されます。
 9600    WOLFSSL_OCSP_URL_OVERRIDE - 証明書内のURLの代わりにオーバーライドURLを使用します。オーバーライドURLはwolfSSL_CTX_SetOCSP_OverrideURL()関数を使用して指定されます。
 9601    WOLFSSL_OCSP_CHECKALL - すべてのOCSPチェックをオンに設定します。
 9602    WOLFSSL_OCSP_NO_NONCE - OCSP要求作成時のnonceオプションを設定します。
 9603
 9604    この関数は、wolfSSLがOCSPサポート付きでコンパイルされている場合(--enable-ocsp、#define HAVE_OCSP)にのみOCSPオプションを設定します。
 9605
 9606    \return SSL_SUCCESS 成功時に返されます。
 9607    \return SSL_FAILURE 失敗時に返されます。
 9608    \return NOT_COMPILED_IN この関数が呼び出されたが、wolfSSLのコンパイル時にOCSPサポートが有効になっていなかった場合に返されます。
 9609
 9610    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 9611    \param options OCSPオプションを設定するために使用される値。
 9612
 9613    _Example_
 9614    \code
 9615    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9616    int options; // オプション定数で初期化
 9617    …
 9618    int ret = wolfSSL_CTX_EnableOCSP(ctx, options);
 9619    if(ret != SSL_SUCCESS){
 9620        // OCSPが有効になっていません
 9621    }
 9622    \endcode
 9623
 9624    \sa wolfSSL_CertManagerEnableOCSP
 9625    \sa wolfSSL_EnableOCSP
 9626*/
 9627int wolfSSL_CTX_EnableOCSP(WOLFSSL_CTX* ctx, int options);
 9628
 9629/*!
 9630    \brief この関数は、WOLFSSL_CERT_MANAGER構造体のocspEnabledメンバに影響を与えることにより、OCSP証明書失効チェックを無効にします。
 9631
 9632    \return SSL_SUCCESS 関数がエラーなしで実行された場合に返されます。CMのocspEnabledメンバが無効にされました。
 9633    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合に返されます。
 9634
 9635    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 9636
 9637    _Example_
 9638    \code
 9639    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
 9640    WOLFSSL* ssl = wolfSSL_new(ctx);
 9641    ...
 9642    if(!wolfSSL_CTX_DisableOCSP(ssl->ctx)){
 9643    	// OCSPが無効になっていません
 9644    }
 9645    \endcode
 9646
 9647    \sa wolfSSL_DisableOCSP
 9648    \sa wolfSSL_CertManagerDisableOCSP
 9649*/
 9650int wolfSSL_CTX_DisableOCSP(WOLFSSL_CTX* ctx);
 9651
 9652/*!
 9653    \brief この関数は、OCSPが使用するURLを手動で設定します。デフォルトでは、wolfSSL_CTX_EnableOCSPを使用してWOLFSSL_OCSP_URL_OVERRIDEオプションが設定されていない限り、OCSPは個々の証明書で見つかったURLを使用します。
 9654
 9655    \return SSL_SUCCESS 成功時に返されます。
 9656    \return SSL_FAILURE 失敗時に返されます。
 9657    \return NOT_COMPILED_IN この関数が呼び出されたが、wolfSSLのコンパイル時にOCSPサポートが有効になっていなかった場合に返されます。
 9658
 9659    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 9660    \param url wolfSSLが使用するOCSP URLへのポインタ。
 9661
 9662    _Example_
 9663    \code
 9664    WOLFSSL_CTX* ctx = 0;
 9665    ...
 9666    wolfSSL_CTX_OCSP_set_override_url(ctx, "custom-url-here");
 9667    \endcode
 9668
 9669    \sa wolfSSL_CTX_OCSP_set_options
 9670*/
 9671int wolfSSL_CTX_SetOCSP_OverrideURL(WOLFSSL_CTX* ctx, const char* url);
 9672
 9673/*!
 9674    \brief WOLFSSL_CTX構造体にOCSPのコールバックを設定します。
 9675
 9676    \return SSL_SUCCESS 関数が正常に実行された場合に返されます。CM内のocspIOCb、ocspRespFreeCb、ocspIOCtxメンバが正常に設定されました。
 9677    \return BAD_FUNC_ARG WOLFSSL_CTXまたはWOLFSSL_CERT_MANAGER構造体がNULLの場合に返されます。
 9678
 9679    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9680    \param ioCb 関数ポインタであるCbOCSPIO型。
 9681    \param respFreeCb 関数ポインタであるCbOCSPRespFree型。
 9682    \param ioCbCtx WOLFSSL_CERT_MANAGERに保持されるvoidポインタ。
 9683
 9684    _Example_
 9685    \code
 9686    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 9687    …
 9688    CbOCSPIO ocspIOCb;
 9689    CbOCSPRespFree ocspRespFreeCb;
 9690    …
 9691    void* ioCbCtx;
 9692
 9693    int isSetOCSP = wolfSSL_CTX_SetOCSP_Cb(ctx, ocspIOCb,
 9694    ocspRespFreeCb, ioCbCtx);
 9695
 9696    if(isSetOCSP != SSL_SUCCESS){
 9697    	// 関数が正常に返されませんでした
 9698    }
 9699    \endcode
 9700
 9701    \sa wolfSSL_CertManagerSetOCSP_Cb
 9702    \sa CbOCSPIO
 9703    \sa CbOCSPRespFree
 9704*/
 9705int wolfSSL_CTX_SetOCSP_Cb(WOLFSSL_CTX* ctx,
 9706                           CbOCSPIO ioCb, CbOCSPRespFree respFreeCb,
 9707                           void* ioCbCtx);
 9708
 9709/*!
 9710    \brief この関数は、wolfSSL_CertManagerEnableOCSPStapling()を呼び出してOCSPステープリングを有効にします。
 9711    \return SSL_SUCCESS エラーがなく、関数が正常に実行された場合に返されます。
 9712    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULL、またはサブルーチンに許可されていない引数値が渡された場合に返されます。
 9713    \return MEMORY_E メモリの割り当てに問題があった場合に返されます。
 9714    \return SSL_FAILURE OCSP構造体の初期化が失敗した場合に返されます。
 9715    \return NOT_COMPILED_IN wolfSSLがHAVE_CERTIFICATE_STATUS_REQUESTオプション付きでコンパイルされていない場合に返されます。
 9716
 9717    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
 9718
 9719    _Example_
 9720    \code
 9721    WOLFSSL* ssl = WOLFSSL_new();
 9722    ssl->method.version; // 希望するプロトコルに設定
 9723    ...
 9724    if(!wolfSSL_CTX_EnableOCSPStapling(ssl->ctx)){
 9725    	// OCSPステープリングが有効になっていません
 9726    }
 9727    \endcode
 9728
 9729    \sa wolfSSL_CertManagerEnableOCSPStapling
 9730    \sa InitOCSP
 9731*/
 9732int wolfSSL_CTX_EnableOCSPStapling(WOLFSSL_CTX* ctx);
 9733
 9734/*!
 9735    \ingroup CertsKeys
 9736
 9737    \brief 通常、SSLハンドシェイクの終了時に、wolfSSLは一時配列を解放します。ハンドシェイクが始まる前にこの関数を呼び出すと、wolfSSLは一時配列を解放しなくなります。一時配列はwolfSSL_get_keys()やPSKヒントなどに必要になる場合があります。ユーザーが一時配列を使い終わったら、wolfSSL_FreeArrays()を呼び出してリソースを即座に解放するか、あるいは関連するSSLオブジェクトが解放されるときにリソースが解放されます。
 9738
 9739    \return none 戻り値なし。
 9740
 9741    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9742
 9743    _Example_
 9744    \code
 9745    WOLFSSL* ssl;
 9746    ...
 9747    wolfSSL_KeepArrays(ssl);
 9748    \endcode
 9749
 9750    \sa wolfSSL_FreeArrays
 9751*/
 9752void wolfSSL_KeepArrays(WOLFSSL* ssl);
 9753
 9754/*!
 9755    \ingroup CertsKeys
 9756
 9757    \brief 通常、SSLハンドシェイクの終了時に、wolfSSLは一時配列を解放します。ハンドシェイクの前にwolfSSL_KeepArrays()が呼び出されていた場合、wolfSSLは一時配列を解放しません。この関数は一時配列を明示的に解放し、ユーザーが一時配列を使い終わり、SSLオブジェクトが解放されるのを待たずにこれらのリソースを解放したい場合に呼び出す必要があります。
 9758
 9759    \return none 戻り値なし。
 9760
 9761    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9762
 9763    _Example_
 9764    \code
 9765    WOLFSSL* ssl;
 9766    ...
 9767    wolfSSL_FreeArrays(ssl);
 9768    \endcode
 9769
 9770    \sa wolfSSL_KeepArrays
 9771*/
 9772void wolfSSL_FreeArrays(WOLFSSL* ssl);
 9773
 9774/*!
 9775    \brief この関数は、'ssl'パラメータで渡されたSSLオブジェクトでServer Name Indicationの使用を有効にします。つまり、wolfSSLクライアントはClientHelloでSNI拡張を送信し、wolfSSLサーバーはSNI不一致の場合、ClientHello + SNIに対してServerHello + 空のSNIまたはfatalアラートで応答します。
 9776
 9777    \return WOLFSSL_SUCCESS 成功時。
 9778    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラーです。sslがNULL、dataがNULL、typeが未知の値(以下を参照)。
 9779    \return MEMORY_E メモリが不足している場合に返されるエラーです。
 9780
 9781    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 9782    \param type dataで渡されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9783    \param data サーバー名データへのポインタ。
 9784    \param size サーバー名データのサイズ。
 9785
 9786    _Example_
 9787    \code
 9788    int ret = 0;
 9789    WOLFSSL_CTX* ctx = 0;
 9790    WOLFSSL* ssl = 0;
 9791    ctx = wolfSSL_CTX_new(method);
 9792    if (ctx == NULL) {
 9793        // コンテキスト作成失敗
 9794    }
 9795    ssl = wolfSSL_new(ctx);
 9796    if (ssl == NULL) {
 9797        // ssl作成失敗
 9798    }
 9799    ret = wolfSSL_UseSNI(ssl, WOLFSSL_SNI_HOST_NAME, "www.yassl.com",
 9800        strlen("www.yassl.com"));
 9801    if (ret != WOLFSSL_SUCCESS) {
 9802        // sni使用失敗
 9803    }
 9804    \endcode
 9805
 9806    \sa wolfSSL_new
 9807    \sa wolfSSL_CTX_UseSNI
 9808*/
 9809int wolfSSL_UseSNI(WOLFSSL* ssl, unsigned char type,
 9810                                         const void* data, unsigned short size);
 9811
 9812/*!
 9813    \brief この関数は、'ctx'パラメータで渡されたSSLコンテキストから作成されたSSLオブジェクトに対してServer Name Indicationの使用を有効にします。つまり、wolfSSLクライアントはClientHelloでSNI拡張を送信し、wolfSSLサーバーはSNI不一致の場合、ClientHello + SNIに対してServerHello + 空のSNIまたはfatalアラートで応答します。
 9814
 9815    \return WOLFSSL_SUCCESS 成功時。
 9816    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラーです。ctxがNULL、dataがNULL、typeが未知の値(以下を参照)。
 9817    \return MEMORY_E メモリが不足している場合に返されるエラーです。
 9818
 9819    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 9820    \param type dataで渡されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9821    \param data サーバー名データへのポインタ。
 9822    \param size サーバー名データのサイズ。
 9823
 9824    _Example_
 9825    \code
 9826    int ret = 0;
 9827    WOLFSSL_CTX* ctx = 0;
 9828    ctx = wolfSSL_CTX_new(method);
 9829    if (ctx == NULL) {
 9830        // コンテキスト作成失敗
 9831    }
 9832    ret = wolfSSL_CTX_UseSNI(ctx, WOLFSSL_SNI_HOST_NAME, "www.yassl.com",
 9833        strlen("www.yassl.com"));
 9834    if (ret != WOLFSSL_SUCCESS) {
 9835        // sni使用失敗
 9836    }
 9837    \endcode
 9838
 9839    \sa wolfSSL_CTX_new
 9840    \sa wolfSSL_UseSNI
 9841*/
 9842int wolfSSL_CTX_UseSNI(WOLFSSL_CTX* ctx, unsigned char type,
 9843                                         const void* data, unsigned short size);
 9844
 9845/*!
 9846    \brief この関数は、'ssl'パラメータで渡されたSSLオブジェクトでServer Name Indicationを使用するSSLセッションの動作を設定するために、サーバー側で呼び出されます。オプションについては以下で説明します。
 9847
 9848    \return none 戻り値なし。
 9849
 9850    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 9851    \param type dataで渡されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9852    \param options 選択されたオプションを含むビット単位のセマフォ。利用可能なオプションは、enum { WOLFSSL_SNI_CONTINUE_ON_MISMATCH = 0x01, WOLFSSL_SNI_ANSWER_ON_MISMATCH = 0x02 }です。通常、クライアントから提供されたホスト名がサーバーと一致しない場合、サーバーはfatalレベルのunrecognized_name(112)アラートを送信してハンドシェイクを中止します。
 9853    \param WOLFSSL_SNI_CONTINUE_ON_MISMATCH このオプションが設定されている場合、サーバーはセッションを中止する代わりにSNI応答を送信しません。
 9854    \param WOLFSSL_SNI_ANSWER_ON_MISMATCH このオプションが設定されている場合、サーバーはセッションを中止する代わりに、ホスト名が一致しているかのようにSNI応答を送信します。
 9855
 9856    _Example_
 9857    \code
 9858    int ret = 0;
 9859    WOLFSSL_CTX* ctx = 0;
 9860    WOLFSSL* ssl = 0;
 9861    ctx = wolfSSL_CTX_new(method);
 9862    if (ctx == NULL) {
 9863        // コンテキスト作成失敗
 9864    }
 9865    ssl = wolfSSL_new(ctx);
 9866    if (ssl == NULL) {
 9867        // ssl作成失敗
 9868    }
 9869    ret = wolfSSL_UseSNI(ssl, 0, "www.yassl.com", strlen("www.yassl.com"));
 9870    if (ret != WOLFSSL_SUCCESS) {
 9871        // sni使用失敗
 9872    }
 9873    wolfSSL_SNI_SetOptions(ssl, WOLFSSL_SNI_HOST_NAME,
 9874        WOLFSSL_SNI_CONTINUE_ON_MISMATCH);
 9875    \endcode
 9876
 9877    \sa wolfSSL_new
 9878    \sa wolfSSL_UseSNI
 9879    \sa wolfSSL_CTX_SNI_SetOptions
 9880*/
 9881void wolfSSL_SNI_SetOptions(WOLFSSL* ssl, unsigned char type,
 9882                                                         unsigned char options);
 9883
 9884/*!
 9885    \brief この関数は、'ctx'パラメータで渡されたSSLコンテキストから作成されたSSLオブジェクトに対してServer Name Indicationを使用するSSLセッションの動作を設定するために、サーバー側で呼び出されます。オプションについては以下で説明します。
 9886
 9887    \return none 戻り値なし。
 9888
 9889    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
 9890    \param type dataで渡されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9891    \param options 選択されたオプションを含むビット単位のセマフォ。利用可能なオプションは、enum { WOLFSSL_SNI_CONTINUE_ON_MISMATCH = 0x01, WOLFSSL_SNI_ANSWER_ON_MISMATCH = 0x02 }です。通常、クライアントから提供されたホスト名がサーバーと一致しない場合、サーバーはfatalレベルのunrecognized_name(112)アラートを送信してハンドシェイクを中止します。
 9892    \param WOLFSSL_SNI_CONTINUE_ON_MISMATCH このオプションが設定されている場合、サーバーはセッションを中止する代わりにSNI応答を送信しません。
 9893    \param WOLFSSL_SNI_ANSWER_ON_MISMATCH このオプションが設定されている場合、サーバーはセッションを中止する代わりに、ホスト名が一致しているかのようにSNI応答を送信します。
 9894
 9895    _Example_
 9896    \code
 9897    int ret = 0;
 9898    WOLFSSL_CTX* ctx = 0;
 9899    ctx = wolfSSL_CTX_new(method);
 9900    if (ctx == NULL) {
 9901       // コンテキスト作成失敗
 9902    }
 9903    ret = wolfSSL_CTX_UseSNI(ctx, 0, "www.yassl.com", strlen("www.yassl.com"));
 9904    if (ret != WOLFSSL_SUCCESS) {
 9905        // sni使用失敗
 9906    }
 9907    wolfSSL_CTX_SNI_SetOptions(ctx, WOLFSSL_SNI_HOST_NAME,
 9908    WOLFSSL_SNI_CONTINUE_ON_MISMATCH);
 9909    \endcode
 9910
 9911    \sa wolfSSL_CTX_new
 9912    \sa wolfSSL_CTX_UseSNI
 9913    \sa wolfSSL_SNI_SetOptions
 9914*/
 9915void wolfSSL_CTX_SNI_SetOptions(WOLFSSL_CTX* ctx,
 9916                                     unsigned char type, unsigned char options);
 9917
 9918/*!
 9919    \brief この関数は、クライアントがセッションを開始するために送信したClient Helloメッセージからクライアントによって提供されたServer Name Indicationを取得するために、サーバー側で呼び出されます。SNIを取得するためにコンテキストやセッションのセットアップは必要ありません。
 9920
 9921    \return WOLFSSL_SUCCESS 成功時。
 9922    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラーです。bufferがNULL、bufferSz <= 0、sniがNULL、inOutSzがNULLまたは<= 0。
 9923    \return BUFFER_ERROR 不正な形式のClient Helloメッセージがある場合に返されるエラーです。
 9924    \return INCOMPLETE_DATA 抽出を完了するのに十分なデータがない場合に返されるエラーです。
 9925
 9926    \param buffer クライアントから提供されたデータ(Client Hello)へのポインタ。
 9927    \param bufferSz Client Helloメッセージのサイズ。
 9928    \param type bufferから取得されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9929    \param sni 出力が格納される場所へのポインタ。
 9930    \param inOutSz 出力サイズへのポインタ。この値はMIN("SNIの長さ", inOutSz)に更新されます。
 9931
 9932    _Example_
 9933    \code
 9934    unsigned char buffer[1024] = {0};
 9935    unsigned char result[32]   = {0};
 9936    int           length       = 32;
 9937    // Client Helloをbufferに読み込み...
 9938    ret = wolfSSL_SNI_GetFromBuffer(buffer, sizeof(buffer), 0, result, &length);
 9939    if (ret != WOLFSSL_SUCCESS) {
 9940        // sni取得失敗
 9941    }
 9942    \endcode
 9943
 9944    \sa wolfSSL_UseSNI
 9945    \sa wolfSSL_CTX_UseSNI
 9946    \sa wolfSSL_SNI_GetRequest
 9947*/
 9948int wolfSSL_SNI_GetFromBuffer(
 9949                 const unsigned char* clientHello, unsigned int helloSz,
 9950                 unsigned char type, unsigned char* sni, unsigned int* inOutSz);
 9951
 9952/*!
 9953    \ingroup IO
 9954
 9955    \brief この関数はSNIオブジェクトのステータスを取得します。
 9956
 9957    \return value SNIがNULLでない場合、この関数はSNI構造体のstatusメンバーのバイト値を返します。
 9958    \return 0 SNIオブジェクトがNULLの場合。
 9959
 9960    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
 9961    \param type SNIタイプ。
 9962
 9963    _Example_
 9964    \code
 9965    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
 9966    WOLFSSL* ssl = wolfSSL_new(ctx);
 9967    …
 9968    #define AssertIntEQ(x, y) AssertInt(x, y, ==, !=)
 9969    …
 9970    Byte type = WOLFSSL_SNI_HOST_NAME;
 9971    char* request = (char*)&type;
 9972    AssertIntEQ(WOLFSSL_SNI_NO_MATCH, wolfSSL_SNI_Status(ssl, type));
 9973    …
 9974    \endcode
 9975
 9976    \sa TLSX_SNI_Status
 9977    \sa TLSX_SNI_find
 9978    \sa TLSX_Find
 9979*/
 9980unsigned char wolfSSL_SNI_Status(WOLFSSL* ssl, unsigned char type);
 9981
 9982/*!
 9983    \brief この関数は、SSLセッションでクライアントによって提供されたServer Name Indicationを取得するために、サーバー側で呼び出されます。
 9984
 9985    \return size 提供されたSNIデータのサイズ。
 9986
 9987    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
 9988    \param type dataで取得されるサーバー名のタイプを示します。既知のタイプは、enum { WOLFSSL_SNI_HOST_NAME = 0 }です。
 9989    \param data クライアントから提供されたデータへのポインタ。
 9990
 9991    _Example_
 9992    \code
 9993    int ret = 0;
 9994    WOLFSSL_CTX* ctx = 0;
 9995    WOLFSSL* ssl = 0;
 9996    ctx = wolfSSL_CTX_new(method);
 9997    if (ctx == NULL) {
 9998        // コンテキスト作成失敗
 9999    }
10000    ssl = wolfSSL_new(ctx);
10001    if (ssl == NULL) {
10002        // ssl作成失敗
10003    }
10004    ret = wolfSSL_UseSNI(ssl, 0, "www.yassl.com", strlen("www.yassl.com"));
10005    if (ret != WOLFSSL_SUCCESS) {
10006        // sni使用失敗
10007    }
10008    if (wolfSSL_accept(ssl) == SSL_SUCCESS) {
10009        void *data = NULL;
10010        unsigned short size = wolfSSL_SNI_GetRequest(ssl, 0, &data);
10011    }
10012    \endcode
10013
10014    \sa wolfSSL_UseSNI
10015    \sa wolfSSL_CTX_UseSNI
10016*/
10017unsigned short wolfSSL_SNI_GetRequest(WOLFSSL *ssl,
10018                                               unsigned char type, void** data);
10019
10020/*!
10021    \ingroup Setup
10022
10023    \brief wolfSSLセッションでALPNの使用をセットアップします。
10024
10025    \return WOLFSSL_SUCCESS 成功時。
10026    \return BAD_FUNC_ARG sslまたはprotocol_name_listがnull、またはprotocol_name_listSzが大きすぎる、またはoptionsがサポートされていない何かを含む場合に返されます。
10027    \return MEMORY_ERROR プロトコルリストのメモリ割り当てエラー。
10028    \return SSL_FAILURE 失敗時。
10029
10030    \param ssl 使用するwolfSSLセッション。
10031    \param protocol_name_list 使用するプロトコル名のリスト。カンマ区切りの文字列が必要です。
10032    \param protocol_name_listSz プロトコル名リストのサイズ。
10033    \param options WOLFSSL_ALPN_CONTINUE_ON_MISMATCHまたはWOLFSSL_ALPN_FAILED_ON_MISMATCH。
10034
10035    _Example_
10036    \code
10037    wolfSSL_Init();
10038    WOLFSSL_CTX* ctx;
10039    WOLFSSL* ssl;
10040    WOLFSSL_METHOD method = // 任意のwolfSSLメソッド
10041    ctx = wolfSSL_CTX_new(method);
10042    ssl = wolfSSL_new(ctx);
10043
10044    char alpn_list[] = {};    if (wolfSSL_UseALPN(ssl, alpn_list, sizeof(alpn_list),
10045        WOLFSSL_APN_FAILED_ON_MISMATCH) != WOLFSSL_SUCCESS)
10046    {
10047       // セッションチケット設定エラー
10048    }
10049    \endcode
10050
10051    \sa TLSX_UseALPN
10052*/
10053int wolfSSL_UseALPN(WOLFSSL* ssl, char *protocol_name_list,
10054                                unsigned int protocol_name_listSz,
10055                                unsigned char options);
10056
10057/*!
10058    \ingroup TLS
10059
10060    \brief この関数は、サーバーによって設定されたプロトコル名を取得します。
10061
10062    \return SSL_SUCCESS エラーがスローされずに正常に実行された場合に返されます。
10063    \return SSL_FATAL_ERROR 拡張が見つからなかった場合、またはピアとのプロトコルマッチがなかった場合に返されます。また、受け入れられたプロトコル名が複数ある場合にもエラーがスローされます。
10064    \return SSL_ALPN_NOT_FOUND ピアとのプロトコルマッチが見つからなかったことを示して返されます。
10065    \return BAD_FUNC_ARG 関数にNULL引数が渡された場合に返されます。
10066
10067    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10068    \param protocol_name プロトコル名を表し、ALPN構造体に保持されるcharへのポインタ。
10069    \param size protocol_nameのサイズを表すword16型。
10070
10071    _Example_
10072    \code
10073    WOLFSSL_CTX* ctx = WOLFSSL_CTX_new( protocol method );
10074    WOLFSSL* ssl = WOLFSSL_new(ctx);
10075    ...
10076    int err;
10077    char* protocol_name = NULL;
10078    Word16 protocol_nameSz = 0;
10079    err = wolfSSL_ALPN_GetProtocol(ssl, &protocol_name, &protocol_nameSz);
10080
10081    if(err == SSL_SUCCESS){
10082	    // ALPNプロトコルを送信
10083    }
10084    \endcode
10085
10086    \sa TLSX_ALPN_GetRequest
10087    \sa TLSX_Find
10088*/
10089int wolfSSL_ALPN_GetProtocol(WOLFSSL* ssl, char **protocol_name,
10090                                         unsigned short *size);
10091
10092/*!
10093    \ingroup TLS
10094
10095    \brief この関数は、SSLオブジェクトからalpn_client_listデータをバッファにコピーします。
10096
10097    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。SSLオブジェクトのalpn_client_listメンバがlistパラメータにコピーされました。
10098    \return BAD_FUNC_ARG listまたはlistSzパラメータがNULLの場合に返されます。
10099    \return BUFFER_ERROR listバッファに問題がある場合に返されます(NULLであるか、サイズが0の場合)。
10100    \return MEMORY_ERROR メモリの動的割り当てに問題があった場合に返されます。
10101
10102    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10103    \param list バッファへのポインタ。SSLオブジェクトからのデータがここにコピーされます。
10104    \param listSz バッファサイズ。
10105
10106    _Example_
10107    \code
10108    #import <wolfssl/ssl.h>
10109
10110    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method);
10111    WOLFSSL* ssl = wolfSSL_new(ctx);
10112    …
10113    #ifdef HAVE_ALPN
10114    char* list = NULL;
10115    word16 listSz = 0;
10116    …
10117    err = wolfSSL_ALPN_GetPeerProtocol(ssl, &list, &listSz);
10118
10119    if(err == SSL_SUCCESS){
10120	    // クライアントが送信したプロトコル名のリスト
10121    }
10122    \endcode
10123
10124    \sa wolfSSL_UseALPN
10125*/
10126int wolfSSL_ALPN_GetPeerProtocol(WOLFSSL* ssl, char **list,
10127                                             unsigned short *listSz);
10128
10129/*!
10130    \brief この関数は、'ssl'パラメータで渡されたSSLオブジェクトでMaximum Fragment Lengthの使用を有効にするために、クライアント側で呼び出されます。これは、wolfSSLクライアントによってClientHelloでMaximum Fragment Length拡張が送信されることを意味します。
10131
10132    \return SSL_SUCCESS 成功時。
10133    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: sslがNULL、mflが範囲外。
10134    \return MEMORY_E メモリが不足している場合に返されるエラー。
10135
10136    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
10137    \param mfl セッションに要求されるMaximum Fragment Lengthを示します。利用可能なオプションは: enum { WOLFSSL_MFL_2_9  = 1, 512バイト WOLFSSL_MFL_2_10 = 2, 1024バイト WOLFSSL_MFL_2_11 = 3, 2048バイト WOLFSSL_MFL_2_12 = 4, 4096バイト WOLFSSL_MFL_2_13 = 5, 8192バイト wolfSSL専用!!! };
10138
10139    _Example_
10140    \code
10141    int ret = 0;
10142    WOLFSSL_CTX* ctx = 0;
10143    WOLFSSL* ssl = 0;
10144    ctx = wolfSSL_CTX_new(method);
10145    if (ctx == NULL) {
10146        // コンテキストの作成に失敗
10147    }
10148    ssl = wolfSSL_new(ctx);
10149    if (ssl == NULL) {
10150        // sslの作成に失敗
10151    }
10152    ret = wolfSSL_UseMaxFragment(ssl, WOLFSSL_MFL_2_11);
10153    if (ret != 0) {
10154        // max fragmentの使用に失敗
10155    }
10156    \endcode
10157
10158    \sa wolfSSL_new
10159    \sa wolfSSL_CTX_UseMaxFragment
10160*/
10161int wolfSSL_UseMaxFragment(WOLFSSL* ssl, unsigned char mfl);
10162
10163/*!
10164    \brief この関数は、'ctx'パラメータで渡されたSSLコンテキストから作成されたSSLオブジェクトに対してMaximum Fragment Lengthの使用を有効にするために、クライアント側で呼び出されます。これは、wolfSSLクライアントによってClientHelloでMaximum Fragment Length拡張が送信されることを意味します。
10165
10166    \return SSL_SUCCESS 成功時。
10167    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: ctxがNULL、mflが範囲外。
10168    \return MEMORY_E メモリが不足している場合に返されるエラー。
10169
10170    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
10171    \param mfl セッションに要求されるMaximum Fragment Lengthを示します。利用可能なオプションは: enum { WOLFSSL_MFL_2_9  = 1 512バイト、WOLFSSL_MFL_2_10 = 2 1024バイト、WOLFSSL_MFL_2_11 = 3 2048バイト WOLFSSL_MFL_2_12 = 4 4096バイト、WOLFSSL_MFL_2_13 = 5 8192バイト wolfSSL専用!!!、WOLFSSL_MFL_2_13 = 6 256バイト wolfSSL専用!!! };
10172
10173    _Example_
10174    \code
10175    int ret = 0;
10176    WOLFSSL_CTX* ctx = 0;
10177    ctx = wolfSSL_CTX_new(method);
10178    if (ctx == NULL) {
10179        // コンテキストの作成に失敗
10180    }
10181    ret = wolfSSL_CTX_UseMaxFragment(ctx, WOLFSSL_MFL_2_11);
10182    if (ret != 0) {
10183        // max fragmentの使用に失敗
10184    }
10185    \endcode
10186
10187    \sa wolfSSL_CTX_new
10188    \sa wolfSSL_UseMaxFragment
10189*/
10190int wolfSSL_CTX_UseMaxFragment(WOLFSSL_CTX* ctx, unsigned char mfl);
10191
10192/*!
10193    \brief この関数は、'ssl'パラメータで渡されたSSLオブジェクトでTruncated HMACの使用を有効にするために、クライアント側で呼び出されます。これは、wolfSSLクライアントによってClientHelloでTruncated HMAC拡張が送信されることを意味します。
10194
10195    \return SSL_SUCCESS 成功時。
10196    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: sslがNULL。
10197    \return MEMORY_E メモリが不足している場合に返されるエラー。
10198
10199    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
10200
10201    _Example_
10202    \code
10203    int ret = 0;
10204    WOLFSSL_CTX* ctx = 0;
10205    WOLFSSL* ssl = 0;
10206    ctx = wolfSSL_CTX_new(method);
10207    if (ctx == NULL) {
10208        // コンテキストの作成に失敗
10209    }
10210    ssl = wolfSSL_new(ctx);
10211    if (ssl == NULL) {
10212        // sslの作成に失敗
10213    }
10214    ret = wolfSSL_UseTruncatedHMAC(ssl);
10215    if (ret != 0) {
10216        // truncated HMACの使用に失敗
10217    }
10218    \endcode
10219
10220    \sa wolfSSL_new
10221    \sa wolfSSL_CTX_UseMaxFragment
10222*/
10223int wolfSSL_UseTruncatedHMAC(WOLFSSL* ssl);
10224
10225/*!
10226    \brief この関数は、'ctx'パラメータで渡されたSSLコンテキストから作成されたSSLオブジェクトに対してTruncated HMACの使用を有効にするために、クライアント側で呼び出されます。これは、wolfSSLクライアントによってClientHelloでTruncated HMAC拡張が送信されることを意味します。
10227
10228    \return SSL_SUCCESS 成功時。
10229    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: ctxがNULL。
10230    \return MEMORY_E メモリが不足している場合に返されるエラー。
10231
10232    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
10233
10234    _Example_
10235    \code
10236    int ret = 0;
10237    WOLFSSL_CTX* ctx = 0;
10238    ctx = wolfSSL_CTX_new(method);
10239    if (ctx == NULL) {
10240        // コンテキストの作成に失敗
10241    }
10242    ret = wolfSSL_CTX_UseTruncatedHMAC(ctx);
10243    if (ret != 0) {
10244        // truncated HMACの使用に失敗
10245    }
10246    \endcode
10247
10248    \sa wolfSSL_CTX_new
10249    \sa wolfSSL_UseMaxFragment
10250*/
10251int wolfSSL_CTX_UseTruncatedHMAC(WOLFSSL_CTX* ctx);
10252
10253/*!
10254    \brief ステープリングはCAに連絡する必要性を排除します。ステープリングは、OCSPで提示される証明書失効チェックのコストを削減します。
10255
10256    \return SSL_SUCCESS TLSX_UseCertificateStatusRequestがエラーなく実行された場合に返されます。
10257    \return MEMORY_E メモリの割り当てにエラーがある場合に返されます。
10258    \return BAD_FUNC_ARG 関数に渡された引数がNULLまたは許容できない値である場合に返されます。
10259
10260    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10261    \param status_type TLSX_UseCertificateStatusRequest()に渡され、CertificateStatusRequest構造体に格納されるバイト型。
10262    \param options TLSX_UseCertificateStatusRequest()に渡され、CertificateStatusRequest構造体に格納されるバイト型。
10263
10264    _Example_
10265    \code
10266    WOLFSSL* ssl = wolfSSL_new(ctx);
10267    …
10268    if (wolfSSL_UseOCSPStapling(ssl, WOLFSSL_CSR2_OCSP,
10269        WOLFSSL_CSR2_OCSP_USE_NONCE) != SSL_SUCCESS){
10270	    // 失敗ケース
10271    }
10272    \endcode
10273
10274    \sa TLSX_UseCertificateStatusRequest
10275    \sa wolfSSL_CTX_UseOCSPStapling
10276*/
10277int wolfSSL_UseOCSPStapling(WOLFSSL* ssl,
10278                              unsigned char status_type, unsigned char options);
10279
10280/*!
10281    \brief この関数は、ハンドシェイク中に証明書ステータスを要求します。
10282
10283    \return SSL_SUCCESS 関数とサブルーチンがエラーなく実行された場合に返されます。
10284    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULLの場合、またはサブルーチンに許可されていない値が渡された場合に返されます。
10285    \return MEMORY_E 関数またはサブルーチンがメモリの適切な割り当てに失敗した場合に返されます。
10286
10287    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
10288    \param status_type TLSX_UseCertificateStatusRequest()に渡され、CertificateStatusRequest構造体に格納されるバイト型。
10289    \param options TLSX_UseCertificateStatusRequest()に渡され、CertificateStatusRequest構造体に格納されるバイト型。
10290
10291    _Example_
10292    \code
10293    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
10294    WOLFSSL* ssl = wolfSSL_new(ctx);
10295    byte statusRequest = 0; // ステータスリクエストを初期化
10296    …
10297    switch(statusRequest){
10298    	case WOLFSSL_CSR_OCSP:
10299    		if(wolfSSL_CTX_UseOCSPStapling(ssl->ctx, WOLFSSL_CSR_OCSP,
10300                WOLF_CSR_OCSP_USE_NONCE) != SSL_SUCCESS){
10301                // UseCertificateStatusRequestが失敗
10302    }
10303    // switchケースを続ける
10304    \endcode
10305
10306    \sa wolfSSL_UseOCSPStapingV2
10307    \sa wolfSSL_UseOCSPStapling
10308    \sa TLSX_UseCertificateStatusRequest
10309*/
10310int wolfSSL_CTX_UseOCSPStapling(WOLFSSL_CTX* ctx,
10311                              unsigned char status_type, unsigned char options);
10312
10313/*!
10314    \brief この関数は、OCSPのステータスタイプとオプションを設定します。
10315
10316    \return SSL_SUCCESS 関数とサブルーチンがエラーなく実行された場合に返されます。
10317    \return MEMORY_E メモリ割り当てエラーがあった場合に返されます。
10318    \return BAD_FUNC_ARG 関数またはサブルーチンにNULLまたは許容されない引数が渡された場合に返されます。
10319
10320    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10321    \param status_type OCSPステータスタイプをロードするバイト型。
10322    \param options wolfSSL_SNI_SetOptions()とwolfSSL_CTX_SNI_SetOptions()で設定されるOCSPオプションを保持するバイト型。
10323
10324    _Example_
10325    \code
10326    WOLFSSL* ssl = wolfSSL_new(ctx);
10327    ...
10328    if (wolfSSL_UseOCSPStaplingV2(ssl, WOLFSSL_CSR2_OCSP_MULTI, 0) != SSL_SUCCESS){
10329    	// 正しく実行されませんでした。失敗ケースのコードブロック
10330    }
10331    \endcode
10332
10333    \sa TLSX_UseCertificatStatusRequestV2
10334    \sa wolfSSL_SNI_SetOptions
10335    \sa wolfSSL_CTX_SNI_SetOptions
10336*/
10337int wolfSSL_UseOCSPStaplingV2(WOLFSSL* ssl,
10338                              unsigned char status_type, unsigned char options);
10339
10340/*!
10341    \brief OCSPステープリング用の証明書ステータス要求を作成して初期化します。
10342
10343    \return SSL_SUCCESS 関数とサブルーチンがエラーなく実行された場合。
10344    \return BAD_FUNC_ARG WOLFSSL_CTX構造体がNULL、またはside変数がクライアント側でない場合に返されます。
10345    \return MEMORY_E メモリの割り当てに失敗した場合に返されます。
10346
10347    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
10348    \param status_type CertificatStatusRequest構造体にあるバイト型で、WOLFSSL_CSR2_OCSPまたはWOLFSSL_CSR2_OCSP_MULTIのいずれかである必要があります。
10349    \param options CertificateStatusRequestItemV2構造体に保持されるバイト型。
10350
10351    _Example_
10352    \code
10353    WOLFSSL_CTX* ctx  = wolfSSL_CTX_new( protocol method );
10354    byte status_type;
10355    byte options;
10356    ...
10357    if(wolfSSL_CTX_UseOCSPStaplingV2(ctx, status_type, options); != SSL_SUCCESS){
10358    	// 失敗ケース
10359    }
10360    \endcode
10361
10362    \sa TLSX_UseCertificateStatusRequestV2
10363    \sa wc_RNG_GenerateBlock
10364    \sa TLSX_Push
10365*/
10366int wolfSSL_CTX_UseOCSPStaplingV2(WOLFSSL_CTX* ctx,
10367                              unsigned char status_type, unsigned char options);
10368
10369/*!
10370    \brief この関数は、'ssl'パラメータで渡されたSSLオブジェクトでSupported Elliptic Curves拡張の使用を有効にするために、クライアント側で呼び出されます。これは、wolfSSLクライアントによってClientHelloで有効化されたサポートされる曲線が送信されることを意味します。この関数は、複数の曲線を有効にするために複数回呼び出すことができます。
10371
10372    \return SSL_SUCCESS 成功時。
10373    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: sslがNULL、nameが不明な値(下記参照)。
10374    \return MEMORY_E メモリが不足している場合に返されるエラー。    \param ssl wolfSSL_new()で作成されたSSLオブジェクトへのポインタ。
10375    \param name セッションでサポートされる曲線を示します。利用可能なオプションは以下の通りです: enum { WOLFSSL_ECC_SECP160R1 = 0x10,
10376    WOLFSSL_ECC_SECP192R1 = 0x13, WOLFSSL_ECC_SECP224R1 = 0x15,
10377    WOLFSSL_ECC_SECP256R1 = 0x17, WOLFSSL_ECC_SECP384R1 = 0x18,
10378    WOLFSSL_ECC_SECP521R1 = 0x19 };
10379
10380    _Example_
10381    \code
10382    int ret = 0;
10383    WOLFSSL_CTX* ctx = 0;
10384    WOLFSSL* ssl = 0;
10385    ctx = wolfSSL_CTX_new(method);
10386    if (ctx == NULL) {
10387        // コンテキストの作成に失敗しました。
10388    }
10389    ssl = wolfSSL_new(ctx);
10390    if (ssl == NULL) {
10391        // sslの作成に失敗しました。
10392    }
10393    ret = wolfSSL_UseSupportedCurve(ssl, WOLFSSL_ECC_SECP256R1);
10394    if (ret != 0) {
10395        // 楕円曲線拡張の使用に失敗しました。
10396    }
10397    \endcode
10398
10399    \sa wolfSSL_CTX_new
10400    \sa wolfSSL_CTX_UseSupportedCurve
10401*/
10402int wolfSSL_UseSupportedCurve(WOLFSSL* ssl, word16 name);
10403
10404/*!
10405    \brief この関数は、ctxパラメータで渡されたSSLコンテキストから作成されたSSLオブジェクトに対して、サポートされる楕円曲線拡張の使用を有効にするためにクライアント側で呼び出されます。これは、有効にされたサポートされる曲線がwolfSSLクライアントによってClientHelloで送信されることを意味します。この関数は、複数の曲線を有効にするために複数回呼び出すことができます。
10406
10407    \return SSL_SUCCESS 成功時。
10408    \return BAD_FUNC_ARG 次のいずれかの場合に返されるエラー: ctxがNULL、nameが不明な値(下記参照)。
10409    \return MEMORY_E メモリが不足している場合に返されるエラー。
10410
10411    \param ctx wolfSSL_CTX_new()で作成されたSSLコンテキストへのポインタ。
10412    \param name セッションでサポートされる曲線を示します。利用可能なオプションは以下の通りです: enum { WOLFSSL_ECC_SECP160R1 = 0x10,
10413    WOLFSSL_ECC_SECP192R1 = 0x13, WOLFSSL_ECC_SECP224R1 = 0x15,
10414    WOLFSSL_ECC_SECP256R1 = 0x17, WOLFSSL_ECC_SECP384R1 = 0x18,
10415    WOLFSSL_ECC_SECP521R1 = 0x19 };
10416
10417    _Example_
10418    \code
10419    int ret = 0;
10420    WOLFSSL_CTX* ctx = 0;
10421    ctx = wolfSSL_CTX_new(method);
10422    if (ctx == NULL) {
10423        // コンテキストの作成に失敗しました。
10424    }
10425    ret = wolfSSL_CTX_UseSupportedCurve(ctx, WOLFSSL_ECC_SECP256R1);
10426    if (ret != 0) {
10427        // 楕円曲線拡張の使用に失敗しました。
10428    }
10429    \endcode
10430
10431    \sa wolfSSL_CTX_new
10432    \sa wolfSSL_UseSupportedCurve
10433*/
10434int wolfSSL_CTX_UseSupportedCurve(WOLFSSL_CTX* ctx,
10435                                                           word16 name);
10436
10437/*!
10438    \ingroup IO
10439
10440    \brief この関数は、提供されたWOLFSSL構造体に対して安全な再ネゴシエーションを強制します。これは推奨されません。
10441
10442    \return SSL_SUCCESS 安全な再ネゴシエーションの設定に成功しました。
10443    \return BAD_FUNC_ARG sslがNULLの場合にエラーを返します。
10444    \return MEMORY_E 安全な再ネゴシエーション用のメモリを割り当てできない場合にエラーを返します。
10445
10446    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10447
10448    _Example_
10449    \code
10450    wolfSSL_Init();
10451    WOLFSSL_CTX* ctx;
10452    WOLFSSL* ssl;
10453    WOLFSSL_METHOD method = // 何らかのwolfSSLメソッド
10454    ctx = wolfSSL_CTX_new(method);
10455    ssl = wolfSSL_new(ctx);
10456
10457    if(wolfSSL_UseSecureRenegotiation(ssl) != SSL_SUCCESS)
10458    {
10459        // 安全な再ネゴシエーションの設定エラー
10460    }
10461    \endcode
10462
10463    \sa TLSX_Find
10464    \sa TLSX_UseSecureRenegotiation
10465*/
10466int wolfSSL_UseSecureRenegotiation(WOLFSSL* ssl);
10467
10468/*!
10469    \ingroup IO
10470
10471    \brief この関数は安全な再ネゴシエーションハンドシェイクを実行します。wolfSSLはこの機能を推奨していないため、これはユーザが強制するものです。
10472
10473    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
10474    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合、またはサブルーチンで受け入れられない引数が渡された場合に返されます。
10475    \return SECURE_RENEGOTIATION_E ハンドシェイクの再ネゴシエーションでエラーがあった場合に返されます。
10476    \return SSL_FATAL_ERROR サーバまたはクライアント設定にエラーがあり、再ネゴシエーションを完了できなかった場合に返されます。wolfSSL_negotiate()を参照してください。
10477
10478    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10479
10480    _Example_
10481    \code
10482    WOLFSSL* ssl = wolfSSL_new(ctx);
10483    ...
10484    if(wolfSSL_Rehandshake(ssl) != SSL_SUCCESS){
10485	    // エラーが発生し、再ハンドシェイクは成功しませんでした。
10486    }
10487    \endcode
10488
10489    \sa wolfSSL_negotiate
10490    \sa wc_InitSha512
10491    \sa wc_InitSha384
10492    \sa wc_InitSha256
10493    \sa wc_InitSha
10494    \sa wc_InitMd5
10495*/
10496int wolfSSL_Rehandshake(WOLFSSL* ssl);
10497
10498/*!
10499    \ingroup IO
10500
10501    \brief 提供されたWOLFSSL構造体にセッションチケットを使用するよう強制します。定数HAVE_SESSION_TICKETが定義されており、定数NO_WOLFSSL_CLIENTが定義されていない必要があります。
10502
10503    \return SSL_SUCCESS セッションチケットの使用設定に成功しました。
10504    \return BAD_FUNC_ARG sslがNULLの場合に返されます。
10505    \return MEMORY_E セッションチケット設定のためのメモリ割り当てエラー。
10506
10507    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10508
10509    _Example_
10510    \code
10511    wolfSSL_Init();
10512    WOLFSSL_CTX* ctx;
10513    WOLFSSL* ssl;
10514    WOLFSSL_METHOD method = // 何らかのwolfSSLメソッド
10515    ctx = wolfSSL_CTX_new(method);
10516    ssl = wolfSSL_new(ctx);
10517
10518    if(wolfSSL_UseSessionTicket(ssl) != SSL_SUCCESS)
10519    {
10520        // セッションチケットの設定エラー
10521    }
10522    \endcode
10523
10524    \sa TLSX_UseSessionTicket
10525*/
10526int wolfSSL_UseSessionTicket(WOLFSSL* ssl);
10527
10528/*!
10529    \ingroup Setup
10530
10531    \brief この関数は、wolfSSLコンテキストにセッションチケットを使用するよう設定します。
10532
10533    \return SSL_SUCCESS 関数が正常に実行されました。
10534    \return BAD_FUNC_ARG ctxがNULLの場合に返されます。
10535    \return MEMORY_E 内部関数でメモリ割り当てエラー。
10536
10537    \param ctx 使用するWOLFSSL_CTX構造体。
10538
10539    _Example_
10540    \code
10541    wolfSSL_Init();
10542    WOLFSSL_CTX* ctx;
10543    WOLFSSL_METHOD method = // 何らかのwolfSSLメソッド ;
10544    ctx = wolfSSL_CTX_new(method);
10545
10546    if(wolfSSL_CTX_UseSessionTicket(ctx) != SSL_SUCCESS)
10547    {
10548        // セッションチケットの設定エラー
10549    }
10550    \endcode
10551
10552    \sa TLSX_UseSessionTicket
10553*/
10554int wolfSSL_CTX_UseSessionTicket(WOLFSSL_CTX* ctx);
10555
10556/*!
10557    \ingroup IO
10558
10559    \brief この関数は、Session構造体のticketメンバをバッファにコピーします。bufがNULLでbufSzが非NULLの場合、bufSzはチケット長に設定されます。
10560
10561    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
10562    \return BAD_FUNC_ARG sslまたはbufSzがNULLの場合、またはbufSzが非NULLでbufがNULLの場合に返されます。
10563
10564
10565    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10566    \param buf メモリバッファを表すbyteポインタ。
10567    \param bufSz バッファサイズを表すword32ポインタ。
10568
10569    _Example_
10570    \code
10571    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
10572    WOLFSSL* ssl = wolfSSL_new(ctx);
10573    byte* buf;
10574    word32 bufSz;  // bufサイズで初期化
10575    …
10576    if(wolfSSL_get_SessionTicket(ssl, buf, bufSz) <= 0){
10577	    // バッファに何も書き込まれませんでした。
10578    } else {
10579	    // バッファはssl->session->ticketの内容を保持しています。
10580    }
10581    \endcode
10582
10583    \sa wolfSSL_UseSessionTicket
10584    \sa wolfSSL_set_SessionTicket
10585*/
10586int wolfSSL_get_SessionTicket(WOLFSSL* ssl, unsigned char* buf, word32* bufSz);
10587
10588/*!
10589    \ingroup IO
10590
10591    \brief この関数は、WOLFSSL構造体内のWOLFSSL_SESSION構造体のticketメンバを設定します。関数に渡されたバッファはメモリにコピーされます。
10592
10593    \return SSL_SUCCESS 関数の実行が成功した場合に返されます。関数はエラーなく返されました。
10594    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。bufSz引数がゼロでないのにbuf引数がNULLの場合にも返されます。
10595
10596    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10597    \param buf セッション構造体のticketメンバに読み込まれるbyteポインタ。
10598    \param bufSz バッファのサイズを表すword32型。
10599
10600    _Example_
10601    \code
10602    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
10603    WOLFSSL* ssl = wolfSSL_new(ctx);
10604    byte* buffer; // 読み込むファイル
10605    word32 bufSz;
10606    ...
10607    if(wolfSSL_KeepArrays(ssl, buffer, bufSz) != SSL_SUCCESS){
10608    	// バッファをメモリに読み込む際にエラーが発生しました。
10609    }
10610    \endcode
10611
10612    \sa wolfSSL_set_SessionTicket_cb
10613*/
10614int wolfSSL_set_SessionTicket(WOLFSSL* ssl, const unsigned char* buf,
10615                              word32 bufSz);
10616
10617/*!
10618    \brief この関数は、セッションチケットコールバックを設定します。CallbackSessionTicket型は、次のシグネチャを持つ関数ポインタです:
10619    int (*CallbackSessionTicket)(WOLFSSL*, const unsigned char*, int, void*)
10620
10621    \return SSL_SUCCESS 関数がエラーなく実行された場合に返されます。
10622    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
10623
10624    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10625    \param cb CallbackSessionTicket型への関数ポインタ。
10626    \param ctx WOLFSSL構造体のsession_ticket_ctxメンバへのvoidポインタ。
10627
10628    _Example_
10629    \code
10630    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
10631    WOLFSSL* ssl = wolfSSL_new(ctx);
10632    …
10633    int sessionTicketCB(WOLFSSL* ssl, const unsigned char* ticket, int ticketSz,
10634				void* ctx){ … }
10635    wolfSSL_set_SessionTicket_cb(ssl, sessionTicketCB, (void*)"initial session");
10636    \endcode
10637
10638    \sa wolfSSL_get_SessionTicket
10639    \sa CallbackSessionTicket
10640    \sa sessionTicketCB
10641*/
10642int wolfSSL_set_SessionTicket_cb(WOLFSSL* ssl,
10643                                 CallbackSessionTicket cb, void* ctx);
10644
10645/*!
10646    \brief この関数は、TLS v1.3ハンドシェイクが確立された後、クライアントにセッションチケットを送信します。
10647
10648    \return WOLFSSL_SUCCESS 新しいセッションチケットが送信された場合に返されます。
10649    \return BAD_FUNC_ARG WOLFSSL構造体がNULL、またはTLS v1.3を使用していない場合に返されます。
10650    \return SIDE_ERROR サーバでない場合に返されます。
10651    \return NOT_READY_ERROR ハンドシェイクが完了していない場合に返されます。
10652    \return WOLFSSL_FATAL_ERROR メッセージの作成または送信に失敗した場合に返されます。
10653
10654    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10655
10656    _Example_
10657    \code
10658    int ret;
10659    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
10660    WOLFSSL* ssl = wolfSSL_new(ctx);
10661    …
10662    ret = wolfSSL_send_SessionTicket(ssl);
10663    if (ret != WOLFSSL_SUCCESS) {
10664        // 新しいセッションチケットが送信されませんでした。
10665    }
10666    \endcode
10667
10668    \sa wolfSSL_get_SessionTicket
10669    \sa CallbackSessionTicket
10670    \sa sessionTicketCB
10671 */
10672int wolfSSL_send_SessionTicket(WOLFSSL* ssl);
10673
10674/*!
10675    \brief この関数は、RFC 5077で規定されているセッションチケットをサポートするサーバのセッションチケット鍵暗号化コールバック関数を設定します。
10676
10677    \return SSL_SUCCESS セッションの設定に成功した場合に返されます。
10678    \return BAD_FUNC_ARG 失敗時に返されます。これは、関数に無効な引数が渡された場合に発生します。
10679
10680    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTXオブジェクトへのポインタ。
10681    \param cb セッションチケットを暗号化/復号するユーザコールバック関数
10682    \param ssl(Callback) wolfSSL_new()で作成されたWOLFSSLオブジェクトへのポインタ
10683    \param key_name(Callback) このチケットコンテキスト用の一意の鍵名、ランダムに生成されるべきです
10684    \param iv(Callback) このチケット用の一意のIV、最大128ビット、ランダムに生成されるべきです
10685    \param mac(Callback) このチケット用の最大256ビットのmac
10686    \param enc(Callback) この暗号化パラメータがtrueの場合、ユーザはkey_name、iv、macを入力し、長さinLenのチケットをインプレースで暗号化し、結果の出力長を*outLenに設定する必要があります。WOLFSSL_TICKET_RET_OKを返すことで、wolfSSLに暗号化が成功したことを伝えます。この暗号化パラメータがfalseの場合、ユーザはkey_name、iv、macを使用して長さinLenのチケットのインプレース復号を実行する必要があります。結果の復号長は*outLenに設定する必要があります。WOLFSSL_TICKET_RET_OKを返すことで、wolfSSLに復号されたチケットを使用して続行するよう伝えます。WOLFSSL_TICKET_RET_CREATEを返すことで、wolfSSLに復号されたチケットを使用するが、クライアントに送信する新しいチケットも生成するよう伝えます。これは最近鍵をロールした場合に完全なハンドシェイクを強制したくない場合に役立ちます。WOLFSSL_TICKET_RET_REJECTを返すことで、wolfSSLにこのチケットを拒否し、完全なハンドシェイクを実行し、通常のセッション再開用の新しい標準セッションIDを作成するよう伝えます。WOLFSSL_TICKET_RET_FATALを返すことで、wolfSSLに致命的エラーで接続試行を終了するよう伝えます。
10687    \param ticket(Callback) 暗号化されたチケットの入出力バッファ。encパラメータを参照してください。
10688    \param inLen(Callback) ticketパラメータの入力長。
10689    \param outLen(Callback) ticketパラメータの結果出力長。コールバックに入るとき、outLenはticketバッファで利用可能な最大サイズを示します。
10690    \param userCtx(Callback) wolfSSL_CTX_set_TicketEncCtx()で設定されたユーザコンテキスト
10691
10692    _Example_
10693    \code
10694    wolfssl/test.hのmyTicketEncCb()を参照してください。
10695    サンプルサーバとサンプルechoserverで使用されています。
10696    \endcode
10697
10698    \sa wolfSSL_CTX_set_TicketHint
10699    \sa wolfSSL_CTX_set_TicketEncCtx
10700*/
10701int wolfSSL_CTX_set_TicketEncCb(WOLFSSL_CTX* ctx,
10702                                            SessionTicketEncCb cb);
10703
10704/*!
10705    \brief この関数は、クライアントに中継されるセッションチケットヒントを設定します。サーバ側での使用。
10706
10707    \return SSL_SUCCESS セッションの設定に成功した場合に返されます。
10708    \return BAD_FUNC_ARG 失敗時に返されます。これは、関数に無効な引数が渡された場合に発生します。
10709
10710    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTXオブジェクトへのポインタ。
10711    \param hint チケットが有効である可能性がある秒数。クライアントへのヒント。
10712
10713    _Example_
10714    \code
10715    none
10716    \endcode
10717
10718    \sa wolfSSL_CTX_set_TicketEncCb*/
10719int wolfSSL_CTX_set_TicketHint(WOLFSSL_CTX* ctx, int hint);
10720
10721/*!
10722    \brief この関数は、コールバック用のセッションチケット暗号化ユーザコンテキストを設定します。サーバ側で使用します。
10723
10724    \return SSL_SUCCESS セッションの設定に成功した場合に返されます。
10725    \return BAD_FUNC_ARG 失敗時に返されます。これは関数に無効な引数が渡されたことが原因です。
10726
10727    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTXオブジェクトへのポインタ。
10728    \param userCtx コールバック用のユーザコンテキスト。
10729
10730    _Example_
10731    \code
10732    none
10733    \endcode
10734
10735    \sa wolfSSL_CTX_set_TicketEncCb
10736*/
10737int wolfSSL_CTX_set_TicketEncCtx(WOLFSSL_CTX* ctx, void* userCtx);
10738
10739/*!
10740    \brief この関数は、コールバック用のセッションチケット暗号化ユーザコンテキストを取得します。サーバ側で使用します。
10741
10742    \return userCtx セッションの取得に成功した場合に返されます。
10743    \return NULL 失敗時に返されます。これは関数に無効な引数が渡された場合、またはユーザコンテキストが設定されていない場合に発生します。
10744
10745    \param ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTXオブジェクトへのポインタ。
10746
10747    _Example_
10748    \code
10749    none
10750    \endcode
10751
10752    \sa wolfSSL_CTX_set_TicketEncCtx
10753*/
10754void* wolfSSL_CTX_get_TicketEncCtx(WOLFSSL_CTX* ctx);
10755
10756/*!
10757    \brief この関数は、ハンドシェイク完了コールバックを設定します。WOLFSSL構造体のhsDoneCbとhsDoneCtxメンバがこの関数で設定されます。
10758
10759    \return SSL_SUCCESS 関数がエラーなしで実行された場合に返されます。WOLFSSL構造体のhsDoneCbとhsDoneCtxメンバが設定されます。
10760    \return BAD_FUNC_ARG WOLFSSL構造体がNULLの場合に返されます。
10761
10762    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
10763    \param cb HandShakeDoneCb型の関数ポインタで、次の形式のシグネチャを持ちます: int (*HandShakeDoneCb)(WOLFSSL*, void*);
10764    \param user_ctx ユーザ登録コンテキストへのvoidポインタ。
10765
10766    _Example_
10767    \code
10768    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
10769    WOLFSSL* ssl = wolfSSL_new(ctx);
10770    …
10771    int myHsDoneCb(WOLFSSL* ssl, void* user_ctx){
10772        // コールバック関数
10773    }
10774    …
10775    wolfSSL_SetHsDoneCb(ssl, myHsDoneCb, NULL);
10776    \endcode
10777
10778    \sa HandShakeDoneCb
10779*/
10780int wolfSSL_SetHsDoneCb(WOLFSSL* ssl, HandShakeDoneCb cb, void* user_ctx);
10781
10782/*!
10783    \ingroup IO
10784
10785    \brief この関数は、セッションの統計情報を出力します。
10786
10787    \return SSL_SUCCESS 関数とサブルーチンがエラーなしで返された場合に返されます。セッション統計が正常に取得され、出力されました。
10788    \return BAD_FUNC_ARG サブルーチンwolfSSL_get_session_stats()に許容できない引数が渡された場合に返されます。
10789    \return BAD_MUTEX_E サブルーチンでmutexエラーが発生した場合に返されます。
10790
10791    \param none パラメータなし。
10792
10793    _Example_
10794    \code
10795    // 統計を取得するためのセッションオブジェクトが必要です
10796    if(wolfSSL_PrintSessionStats(void) != SSL_SUCCESS){
10797        // セッション統計を出力しませんでした
10798    }
10799
10800    \endcode
10801
10802    \sa wolfSSL_get_session_stats
10803*/
10804int wolfSSL_PrintSessionStats(void);
10805
10806/*!
10807    \ingroup IO
10808
10809    \brief この関数は、セッションの統計情報を取得します。
10810
10811    \return SSL_SUCCESS 関数とサブルーチンがエラーなしで返された場合に返されます。セッション統計が正常に取得され、出力されました。
10812    \return BAD_FUNC_ARG サブルーチンwolfSSL_get_session_stats()に許容できない引数が渡された場合に返されます。
10813    \return BAD_MUTEX_E サブルーチンでmutexエラーが発生した場合に返されます。
10814
10815    \param active 総現在セッション数を表すword32ポインタ。
10816    \param total 総セッション数を表すword32ポインタ。
10817    \param peak ピークセッション数を表すword32ポインタ。
10818    \param maxSessions 最大セッション数を表すword32ポインタ。
10819
10820    _Example_
10821    \code
10822    int wolfSSL_PrintSessionStats(void){
10823    …
10824    ret = wolfSSL_get_session_stats(&totalSessionsNow,
10825        &totalSessionsSeen, &peak, &maxSessions);
10826    …
10827    return ret;
10828    \endcode
10829
10830    \sa wolfSSL_PrintSessionStats
10831*/
10832int wolfSSL_get_session_stats(unsigned int* active,
10833                                          unsigned int* total,
10834                                          unsigned int* peak,
10835                                          unsigned int* maxSessions);
10836
10837/*!
10838    \ingroup TLS
10839
10840    \brief この関数は、crとsrの値をコピーし、wc_PRF(疑似乱数関数)に渡し、その値を返します。
10841
10842    \return 0 成功時。
10843    \return BUFFER_E バッファのサイズでエラーが発生する場合に返されます。
10844    \return MEMORY_E サブルーチンが動的メモリの割り当てに失敗した場合に返されます。
10845
10846    \param ms Arrays構造体に保持されているマスターシークレット。
10847    \param msLen マスターシークレットの長さ。
10848    \param pms Arrays構造体に保持されているプリマスターシークレット。
10849    \param pmsLen プリマスターシークレットの長さ。
10850    \param cr クライアントランダム。
10851    \param sr サーバランダム。
10852    \param tls1_2 バージョンが少なくともTLSバージョン1.2であることを示します。
10853    \param hash_type ハッシュタイプを示します。
10854
10855    _Example_
10856    \code
10857    WOLFSSL* ssl;
10858
10859    MakeTlsMasterSecretで呼び出され、以下のように必要な情報を取得します:
10860
10861    int MakeTlsMasterSecret(WOLFSSL* ssl){
10862        int ret;
10863        ret = wolfSSL_makeTlsMasterSecret(ssl->arrays->masterSecret, SECRET_LEN,
10864            ssl->arrays->preMasterSecret, ssl->arrays->preMasterSz,
10865            ssl->arrays->clientRandom, ssl->arrays->serverRandom,
10866            IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
10867        …
10868        return ret;
10869    }
10870    \endcode
10871
10872    \sa wc_PRF
10873    \sa MakeTlsMasterSecret
10874*/
10875
10876int wolfSSL_MakeTlsMasterSecret(unsigned char* ms, word32 msLen,
10877                               const unsigned char* pms, word32 pmsLen,
10878                               const unsigned char* cr, const unsigned char* sr,
10879                               int tls1_2, int hash_type);
10880
10881/*!
10882    \ingroup CertsKeys
10883
10884    \brief TLS鍵を導出するための外部向けラッパー。
10885
10886    \return 0 成功時に返されます。
10887    \return BUFFER_E labLenとseedLenの合計(合計サイズを計算)が最大サイズを超えた場合に返されます。
10888    \return MEMORY_E メモリの割り当てに失敗した場合に返されます。
10889
10890    \param key_data DeriveTlsKeysで割り当てられ、最終ハッシュを保持するためにwc_PRFに渡されるバイトポインタ。
10891    \param keyLen DeriveTlsKeysでWOLFSSL構造体のspecsメンバから導出されるword32型。
10892    \param ms WOLFSSL構造体内のarrays構造体に保持されているマスターシークレットを保持する定数ポインタ型。
10893    \param msLen 列挙定義SECRET_LENでマスターシークレットの長さを保持するword32型。
10894    \param sr WOLFSSL構造体内のarrays構造体のserverRandomメンバへの定数バイトポインタ。
10895    \param cr WOLFSSL構造体内のarrays構造体のclientRandomメンバへの定数バイトポインタ。
10896    \param tls1_2 IsAtLeastTLSv1_2()から返される整数型。
10897    \param hash_type WOLFSSL構造体に保持されている整数型。
10898
10899    _Example_
10900    \code
10901    int DeriveTlsKeys(WOLFSSL* ssl){
10902        int ret;
10903        …
10904        ret = wolfSSL_DeriveTlsKeys(key_data, length, ssl->arrays->masterSecret,
10905            SECRET_LEN, ssl->arrays->clientRandom,
10906            IsAtLeastTLSv1_2(ssl), ssl->specs.mac_algorithm);
10907        …
10908    }
10909    \endcode
10910
10911    \sa wc_PRF
10912    \sa DeriveTlsKeys
10913    \sa IsAtLeastTLSv1_2
10914*/
10915
10916int wolfSSL_DeriveTlsKeys(unsigned char* key_data, word32 keyLen,
10917                               const unsigned char* ms, word32 msLen,
10918                               const unsigned char* sr, const unsigned char* cr,
10919                               int tls1_2, int hash_type);
10920
10921/*!
10922    \brief wolfSSL_connect_ex()は、HandShakeコールバックを設定できる拡張です。これは、デバッガが利用できず、スニッフィングが実用的でない場合に、組み込みシステムのデバッグサポートに役立ちます。HandShakeコールバックは、ハンドシェイクエラーが発生したかどうかに関わらず呼び出されます。SSLパケットの最大数が既知であるため、動的メモリは使用されません。パケット名はpacketNames[]を通じてアクセスできます。接続拡張はまた、タイムアウト値と共にTimeoutコールバックを設定できます。これは、ユーザがTCPスタックのタイムアウトを待ちたくない場合に便利です。この拡張は、いずれか、両方、またはどちらのコールバックもなしで呼び出すことができます。
10923
10924    \return SSL_SUCCESS 成功時。
10925    \return GETTIME_ERROR gettimeofday()がエラーに遭遇した場合に返されます。
10926    \return SETITIMER_ERROR setitimer()がエラーに遭遇した場合に返されます。
10927    \return SIGACT_ERROR sigaction()がエラーに遭遇した場合に返されます。
10928    \return SSL_FATAL_ERROR 基礎となるSSL_connect()呼び出しがエラーに遭遇した場合に返されます。
10929
10930    \param none パラメータなし。
10931
10932    _Example_
10933    \code
10934    none
10935    \endcode
10936
10937    \sa wolfSSL_accept_ex
10938*/
10939int wolfSSL_connect_ex(WOLFSSL* ssl, HandShakeCallBack hsCb,
10940                       TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout);
10941
10942/*!
10943    \brief wolfSSL_accept_ex()は、HandShakeコールバックを設定できる拡張です。これは、デバッガが利用できず、スニッフィングが実用的でない場合に、組み込みシステムのデバッグサポートに役立ちます。HandShakeコールバックは、ハンドシェイクエラーが発生したかどうかに関わらず呼び出されます。SSLパケットの最大数が既知であるため、動的メモリは使用されません。パケット名はpacketNames[]を通じてアクセスできます。接続拡張はまた、タイムアウト値と共にTimeoutコールバックを設定できます。これは、ユーザがTCPスタックのタイムアウトを待ちたくない場合に便利です。この拡張は、いずれか、両方、またはどちらのコールバックもなしで呼び出すことができます。
10944
10945    \return SSL_SUCCESS 成功時。
10946    \return GETTIME_ERROR gettimeofday()がエラーに遭遇した場合に返されます。
10947    \return SETITIMER_ERROR setitimer()がエラーに遭遇した場合に返されます。
10948    \return SIGACT_ERROR sigaction()がエラーに遭遇した場合に返されます。
10949    \return SSL_FATAL_ERROR 基礎となるSSL_accept()呼び出しがエラーに遭遇した場合に返されます。
10950
10951    \param none パラメータなし。
10952
10953    _Example_
10954    \code
10955    none
10956    \endcode
10957
10958    \sa wolfSSL_connect_ex
10959*/
10960int wolfSSL_accept_ex(WOLFSSL* ssl, HandShakeCallBack hsCb,
10961                      TimeoutCallBack toCb, WOLFSSL_TIMEVAL timeout);
10962
10963/*!
10964    \ingroup IO
10965
10966    \brief これは、BIOの内部ファイルポインタを設定するために使用されます。
10967
10968    \return SSL_SUCCESS ファイルポインタの設定に成功した場合。
10969    \return SSL_FAILURE エラーケースが発生した場合。
10970
10971    \param bio ペアを設定するWOLFSSL_BIO構造体。
10972    \param fp bioに設定するファイルポインタ。
10973    \param c ファイルクローズ動作フラグ。
10974
10975    _Example_
10976    \code
10977    WOLFSSL_BIO* bio;
10978    XFILE fp;
10979    int ret;
10980    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
10981    ret  = wolfSSL_BIO_set_fp(bio, fp, BIO_CLOSE);
10982    // ret値を確認
10983    \endcode
10984
10985    \sa wolfSSL_BIO_new
10986    \sa wolfSSL_BIO_s_mem
10987    \sa wolfSSL_BIO_get_fp
10988    \sa wolfSSL_BIO_free
10989*/
10990long wolfSSL_BIO_set_fp(WOLFSSL_BIO *bio, XFILE fp, int c);
10991
10992/*!
10993    \ingroup IO
10994
10995    \brief これは、BIOの内部ファイルポインタを取得するために使用されます。
10996
10997    \return SSL_SUCCESS ファイルポインタの取得に成功した場合。
10998    \return SSL_FAILURE エラーケースが発生した場合。
10999
11000    \param bio ペアを設定するWOLFSSL_BIO構造体。
11001    \param fp bioに設定するファイルポインタ。
11002
11003    _Example_
11004    \code
11005    WOLFSSL_BIO* bio;
11006    XFILE fp;
11007    int ret;
11008    bio  = wolfSSL_BIO_new(wolfSSL_BIO_s_file());
11009    ret  = wolfSSL_BIO_get_fp(bio, &fp);
11010    // ret値を確認
11011    \endcode
11012
11013    \sa wolfSSL_BIO_new
11014    \sa wolfSSL_BIO_s_mem
11015    \sa wolfSSL_BIO_set_fp
11016    \sa wolfSSL_BIO_free
11017*/
11018long wolfSSL_BIO_get_fp(WOLFSSL_BIO *bio, XFILE* fp);
11019
11020/*!
11021    \ingroup Setup
11022
11023    \brief この関数は、秘密鍵が使用されている証明書と一致していることを確認します。
11024
11025    \return SSL_SUCCESS 一致に成功した場合。
11026    \return SSL_FAILURE エラーケースが発生した場合。
11027    \return <0 SSL_FAILURE以外のすべてのエラーケースは負の値です。
11028
11029    \param ssl 確認するWOLFSSL構造体。
11030
11031    _Example_
11032    \code
11033    WOLFSSL* ssl;
11034    int ret;
11035    // sslを作成してセットアップ
11036    ret  = wolfSSL_check_private_key(ssl);
11037    // ret値を確認
11038    \endcode
11039
11040    \sa wolfSSL_new
11041    \sa wolfSSL_free
11042*/
11043int wolfSSL_check_private_key(const WOLFSSL* ssl);
11044
11045/*!
11046    \ingroup CertsKeys
11047
11048    \brief この関数は、渡されたNID値に一致する拡張インデックスを検索して返します。
11049
11050    \return ＞= 0 成功時、拡張インデックスが返されます。
11051    \return -1 拡張が見つからない場合、またはエラーが発生した場合。
11052
11053    \param x509 拡張を検索するために解析する証明書。
11054    \param nid 見つける拡張OID。
11055    \param lastpos lastPos以降の拡張から検索を開始します。
11056                   最初は-1に設定します。
11057
11058    _Example_
11059    \code
11060    const WOLFSSL_X509* x509;
11061    int lastPos = -1;
11062    int idx;
11063
11064    idx = wolfSSL_X509_get_ext_by_NID(x509, NID_basic_constraints, lastPos);
11065    \endcode*/
11066int wolfSSL_X509_get_ext_by_NID(const WOLFSSL_X509 *x, int nid, int lastpos);
11067
11068/*!
11069    \ingroup CertsKeys
11070
11071    \brief この関数は渡されたNID値に一致する拡張を検索して返します。
11072
11073    \return pointer 成功した場合、STACK_OF(WOLFSSL_ASN1_OBJECT)ポインタが返されます。
11074    \return NULL 拡張が見つからない、またはエラーが発生した場合。
11075
11076    \param x509 拡張を解析する証明書。
11077    \param nid 検索する拡張OID。
11078    \param c NULLでない場合、複数の拡張が見つかった場合は-2、見つからなかった場合は-1、見つかってクリティカルでない場合は0、見つかってクリティカルな場合は1に設定されます。
11079    \param idx NULLの場合は最初に一致した拡張を返します。それ以外の場合、x509に格納されていなければidxから開始します。
11080
11081    _Example_
11082    \code
11083    const WOLFSSL_X509* x509;
11084    int c;
11085    int idx = 0;
11086    STACK_OF(WOLFSSL_ASN1_OBJECT)* sk;
11087
11088    sk = wolfSSL_X509_get_ext_d2i(x509, NID_basic_constraints, &c, &idx);
11089    // skがNULLでないか確認してから使用。使用後はskを解放する必要があります
11090    \endcode
11091
11092    \sa wolfSSL_sk_ASN1_OBJECT_free
11093*/
11094void* wolfSSL_X509_get_ext_d2i(const WOLFSSL_X509* x509,
11095                                                     int nid, int* c, int* idx);
11096
11097/*!
11098    \ingroup CertsKeys
11099
11100    \brief この関数はDER証明書のハッシュを返します。
11101
11102    \return SSL_SUCCESS ハッシュの作成に成功した場合。
11103    \return SSL_FAILURE 不正な入力またはハッシュ失敗時に返されます。
11104
11105    \param x509 ハッシュを取得する証明書。
11106    \param digest 使用するハッシュアルゴリズム。
11107    \param buf ハッシュを保持するバッファ。
11108    \param len バッファの長さ。
11109
11110    _Example_
11111    \code
11112    WOLFSSL_X509* x509;
11113    unsigned char buffer[64];
11114    unsigned int bufferSz;
11115    int ret;
11116
11117    ret = wolfSSL_X509_digest(x509, wolfSSL_EVP_sha256(), buffer, &bufferSz);
11118    // ret値を確認
11119    \endcode
11120
11121    \sa none
11122*/
11123int wolfSSL_X509_digest(const WOLFSSL_X509* x509,
11124        const WOLFSSL_EVP_MD* digest, unsigned char* buf, unsigned int* len);
11125
11126/*!
11127    \ingroup Setup
11128
11129    \brief ハンドシェイク中に使用するWOLFSSL構造体の証明書を設定するために使用されます。
11130
11131    \return SSL_SUCCESS 引数の設定に成功した場合。
11132    \return SSL_FAILURE NULL引数が渡された場合。
11133
11134    \param ssl 証明書を設定するWOLFSSL構造体。
11135    \param x509 使用する証明書。
11136
11137    _Example_
11138    \code WOLFSSL* ssl;
11139    WOLFSSL_X509* x509
11140    int ret;
11141    // sslオブジェクトとx509を作成
11142    ret  = wolfSSL_use_certificate(ssl, x509);
11143    // ret値を確認
11144    \endcode
11145
11146    \sa wolfSSL_new
11147    \sa wolfSSL_free
11148*/
11149int wolfSSL_use_certificate(WOLFSSL* ssl, WOLFSSL_X509* x509);
11150
11151/*!
11152    \ingroup Setup
11153
11154    \brief ハンドシェイク中に使用するWOLFSSL構造体の証明書を設定するために使用されます。DER形式のバッファが必要です。
11155
11156    \return SSL_SUCCESS 引数の設定に成功した場合。
11157    \return SSL_FAILURE NULL引数が渡された場合。
11158
11159    \param ssl 証明書を設定するWOLFSSL構造体。
11160    \param der 使用するDER証明書。
11161    \param derSz 渡されたDERバッファのサイズ。
11162
11163    _Example_
11164    \code
11165    WOLFSSL* ssl;
11166    unsigned char* der;
11167    int derSz;
11168    int ret;
11169    // sslオブジェクトを作成してDER変数を設定
11170    ret  = wolfSSL_use_certificate_ASN1(ssl, der, derSz);
11171    // ret値を確認
11172    \endcode
11173
11174    \sa wolfSSL_new
11175    \sa wolfSSL_free
11176*/
11177int wolfSSL_use_certificate_ASN1(WOLFSSL* ssl, const unsigned char* der,
11178                                 int derSz);
11179
11180/*!
11181    \ingroup CertsKeys
11182
11183    \brief WOLFSSL構造体の秘密鍵を設定するために使用されます。
11184
11185    \return SSL_SUCCESS 引数の設定に成功した場合。
11186    \return SSL_FAILURE NULLのsslが渡された場合。すべてのエラーケースは負の値になります。
11187
11188    \param ssl 引数を設定するWOLFSSL構造体。
11189    \param pkey 使用する秘密鍵。
11190
11191    _Example_
11192    \code
11193    WOLFSSL* ssl;
11194    WOLFSSL_EVP_PKEY* pkey;
11195    int ret;
11196    // sslオブジェクトを作成して秘密鍵をセットアップ
11197    ret  = wolfSSL_use_PrivateKey(ssl, pkey);
11198    // ret値を確認
11199    \endcode
11200
11201    \sa wolfSSL_new
11202    \sa wolfSSL_free
11203*/
11204int wolfSSL_use_PrivateKey(WOLFSSL* ssl, WOLFSSL_EVP_PKEY* pkey);
11205
11206/*!
11207    \ingroup CertsKeys
11208
11209    \brief WOLFSSL構造体の秘密鍵を設定するために使用されます。DER形式の鍵バッファが必要です。
11210
11211    \return SSL_SUCCESS 秘密鍵の解析と設定に成功した場合。
11212    \return SSL_FAILURE NULLのsslが渡された場合。すべてのエラーケースは負の値になります。
11213
11214    \param pri 秘密鍵のタイプ。
11215    \param ssl 引数を設定するWOLFSSL構造体。
11216    \param der DER鍵を保持するバッファ。
11217    \param derSz derバッファのサイズ。
11218
11219    _Example_
11220    \code
11221    WOLFSSL* ssl;
11222    unsigned char* pkey;
11223    long pkeySz;
11224    int ret;
11225    // sslオブジェクトを作成して秘密鍵をセットアップ
11226    ret  = wolfSSL_use_PrivateKey_ASN1(1, ssl, pkey, pkeySz);
11227    // ret値を確認
11228    \endcode
11229
11230    \sa wolfSSL_new
11231    \sa wolfSSL_free
11232    \sa wolfSSL_use_PrivateKey
11233*/
11234int wolfSSL_use_PrivateKey_ASN1(int pri, WOLFSSL* ssl,
11235                        const unsigned char* der, long derSz);
11236
11237/*!
11238    \ingroup CertsKeys
11239
11240    \brief WOLFSSL構造体の秘密鍵を設定するために使用されます。DER形式のRSA鍵バッファが必要です。
11241
11242    \return SSL_SUCCESS 秘密鍵の解析と設定に成功した場合。
11243    \return SSL_FAILURE NULLのsslが渡された場合。すべてのエラーケースは負の値になります。
11244
11245    \param ssl 引数を設定するWOLFSSL構造体。
11246    \param der DER鍵を保持するバッファ。
11247    \param derSz derバッファのサイズ。
11248
11249    _Example_
11250    \code
11251    WOLFSSL* ssl;
11252    unsigned char* pkey;
11253    long pkeySz;
11254    int ret;
11255    // sslオブジェクトを作成してRSA秘密鍵をセットアップ
11256    ret  = wolfSSL_use_RSAPrivateKey_ASN1(ssl, pkey, pkeySz);
11257    // ret値を確認
11258    \endcode
11259
11260    \sa wolfSSL_new
11261    \sa wolfSSL_free
11262    \sa wolfSSL_use_PrivateKey
11263*/
11264int wolfSSL_use_RSAPrivateKey_ASN1(WOLFSSL* ssl, unsigned char* der,
11265                                                                long derSz);
11266
11267/*!
11268    \ingroup CertsKeys
11269
11270    \brief この関数はdsaのパラメータを新しく作成されたWOLFSSL_DH構造体に複製します。
11271
11272    \return WOLFSSL_DH 複製に成功した場合、WOLFSSL_DH構造体を返します。
11273    \return NULL 失敗時。
11274
11275    \param dsa 複製するWOLFSSL_DSA構造体。
11276
11277    _Example_
11278    \code
11279    WOLFSSL_DH* dh;
11280    WOLFSSL_DSA* dsa;
11281    // dsaをセットアップ
11282    dh = wolfSSL_DSA_dup_DH(dsa);
11283
11284    // dhがnullでないか確認
11285    \endcode
11286
11287    \sa none
11288*/
11289WOLFSSL_DH *wolfSSL_DSA_dup_DH(const WOLFSSL_DSA *r);
11290
11291/*!
11292    \ingroup Setup
11293
11294    \brief ハンドシェイク完了後にマスターキーを取得するために使用されます。
11295
11296    \return ＞0 データの取得に成功した場合、0より大きい値を返します。
11297    \return 0 ランダムデータバッファがない、またはエラー状態の場合は0を返します。
11298    \return max 渡されたoutSzが0の場合、必要な最大バッファサイズが返されます。
11299
11300    \param ses マスターシークレットバッファを取得するWOLFSSL_SESSION構造体。
11301    \param out データを保持するバッファ。
11302    \param outSz 渡されたoutバッファのサイズ(0の場合、関数は必要な最大バッファサイズを返します)。
11303
11304    _Example_
11305    \code
11306    WOLFSSL_SESSION ssl;
11307    unsigned char* buffer;
11308    size_t bufferSz;
11309    size_t ret;
11310    // ハンドシェイクを完了してセッション構造体を取得
11311    bufferSz  = wolfSSL_SESSION_get_master_secret(ses, NULL, 0);
11312    buffer = malloc(bufferSz);
11313    ret  = wolfSSL_SESSION_get_master_secret(ses, buffer, bufferSz);
11314    // ret値を確認
11315    \endcode
11316
11317    \sa wolfSSL_new
11318    \sa wolfSSL_free
11319*/
11320int wolfSSL_SESSION_get_master_key(const WOLFSSL_SESSION* ses,
11321        unsigned char* out, int outSz);
11322
11323/*!
11324    \ingroup Setup
11325
11326    \brief マスターシークレットキーの長さを取得するために使用されます。
11327
11328    \return size マスターシークレットキーのサイズを返します。
11329
11330    \param ses マスターシークレットバッファを取得するWOLFSSL_SESSION構造体。
11331
11332    _Example_
11333    \code
11334    WOLFSSL_SESSION ssl;
11335    unsigned char* buffer;
11336    size_t bufferSz;
11337    size_t ret;
11338    // ハンドシェイクを完了してセッション構造体を取得
11339    bufferSz  = wolfSSL_SESSION_get_master_secret_length(ses);
11340    buffer = malloc(bufferSz);
11341    // ret値を確認
11342    \endcode
11343
11344    \sa wolfSSL_new
11345    \sa wolfSSL_free
11346*/
11347int wolfSSL_SESSION_get_master_key_length(const WOLFSSL_SESSION* ses);
11348
11349/*!
11350    \ingroup Setup
11351
11352    \brief ctxのWOLFSSL_X509_STORE構造体のsetter関数です。
11353
11354    \return none 戻り値なし。
11355
11356    \param ctx 証明書ストアポインタを設定するWOLFSSL_CTX構造体へのポインタ。
11357    \param str ctxに設定するWOLFSSL_X509_STOREへのポインタ。
11358
11359    _Example_
11360    \code
11361    WOLFSSL_CTX ctx;
11362    WOLFSSL_X509_STORE* st;
11363    // ctxとstをセットアップ
11364    st = wolfSSL_CTX_set_cert_store(ctx, st);
11365    // stを使用
11366    \endcode
11367
11368    \sa wolfSSL_CTX_new
11369    \sa wolfSSL_CTX_free
11370*/
11371void wolfSSL_CTX_set_cert_store(WOLFSSL_CTX* ctx,
11372                                                       WOLFSSL_X509_STORE* str);
11373
11374/*!
11375    \ingroup CertsKeys
11376
11377    \brief この関数はbioからDERバッファを取得し、それをWOLFSSL_X509構造体に変換します。
11378
11379    \return pointer 成功時にWOLFSSL_X509構造体ポインタを返します。
11380    \return Null 失敗時にNULLを返します。
11381
11382    \param bio DER証明書バッファを持つWOLFSSL_BIO構造体へのポインタ。
11383    \param x509 作成された新しいWOLFSSL_X509構造体に設定されるポインタ。
11384
11385    _Example_
11386    \code
11387    WOLFSSL_BIO* bio;
11388    WOLFSSL_X509* x509;
11389    // DERをbioにロード
11390    x509 = wolfSSL_d2i_X509_bio(bio, NULL);
11391    // または
11392    wolfSSL_d2i_X509_bio(bio, &x509);
11393    // 返されたx509を使用(NULLをチェック)
11394    \endcode
11395
11396    \sa none
11397*/
11398WOLFSSL_X509* wolfSSL_d2i_X509_bio(WOLFSSL_BIO* bio, WOLFSSL_X509** x509);
11399
11400/*!
11401    \ingroup Setup
11402
11403    \brief ctxのWOLFSSL_X509_STORE構造体のgetter関数です。
11404
11405    \return WOLFSSL_X509_STORE* ポインタの取得に成功した場合。
11406    \return NULL NULL引数が渡された場合に返されます。
11407
11408    \param ctx 証明書ストアポインタを取得するWOLFSSL_CTX構造体へのポインタ。
11409
11410    _Example_
11411    \code
11412    WOLFSSL_CTX ctx;
11413    WOLFSSL_X509_STORE* st;
11414    // ctxをセットアップ
11415    st = wolfSSL_CTX_get_cert_store(ctx);
11416    // stを使用
11417    \endcode
11418
11419    \sa wolfSSL_CTX_new
11420    \sa wolfSSL_CTX_free
11421    \sa wolfSSL_CTX_set_cert_store
11422*/
11423WOLFSSL_X509_STORE* wolfSSL_CTX_get_cert_store(WOLFSSL_CTX* ctx);
11424
11425/*!
11426    \ingroup IO
11427
11428    \brief 読み取り保留中のバイト数を取得します。BIOタイプがBIO_BIOの場合、ペアから読み取るバイト数です。BIOがSSLオブジェクトを含む場合、SSLオブジェクトからの保留中のデータです(wolfSSL_pending(ssl))。BIO_MEMORYタイプの場合、メモリバッファのサイズを返します。
11429
11430    \return ＞=0 保留中のバイト数。
11431
11432    \param bio すでに作成されているWOLFSSL_BIO構造体へのポインタ。
11433
11434    _Example_
11435    \code
11436    WOLFSSL_BIO* bio;    int pending;
11437    bio = wolfSSL_BIO_new();
11438    …
11439    pending = wolfSSL_BIO_ctrl_pending(bio);
11440    \endcode
11441
11442    \sa wolfSSL_BIO_make_bio_pair
11443    \sa wolfSSL_BIO_new
11444*/
11445size_t wolfSSL_BIO_ctrl_pending(WOLFSSL_BIO *b);
11446
11447/*!
11448    \ingroup Setup
11449
11450    \brief ハンドシェイク中にサーバーから送信されたランダムデータを取得するために使用されます。
11451
11452    \return ＞0 データの取得に成功した場合、0より大きい値を返します。
11453    \return 0 ランダムデータバッファがない場合、またはエラー状態の場合、0を返します。
11454    \return max 渡されたoutSzが0の場合、必要な最大バッファサイズを返します。
11455
11456    \param ssl クライアントのランダムデータバッファを取得するWOLFSSL構造体。
11457    \param out ランダムデータを保持するバッファ。
11458    \param outSz 渡されたoutバッファのサイズ(0の場合、関数は必要な最大バッファサイズを返します)。
11459
11460    _Example_
11461    \code
11462    WOLFSSL ssl;
11463    unsigned char* buffer;
11464    size_t bufferSz;
11465    size_t ret;
11466    bufferSz  = wolfSSL_get_server_random(ssl, NULL, 0);
11467    buffer = malloc(bufferSz);
11468    ret  = wolfSSL_get_server_random(ssl, buffer, bufferSz);
11469    // ret値を確認
11470    \endcode
11471
11472    \sa wolfSSL_new
11473    \sa wolfSSL_free
11474*/
11475size_t wolfSSL_get_server_random(const WOLFSSL *ssl,
11476                                             unsigned char *out, size_t outlen);
11477
11478/*!
11479    \ingroup Setup
11480
11481    \brief ハンドシェイク中にクライアントから送信されたランダムデータを取得するために使用されます。
11482
11483    \return ＞0 データの取得に成功した場合、0より大きい値を返します。
11484    \return 0 ランダムデータバッファがない場合、またはエラー状態の場合、0を返します。
11485    \return max 渡されたoutSzが0の場合、必要な最大バッファサイズを返します。
11486
11487    \param ssl クライアントのランダムデータバッファを取得するWOLFSSL構造体。
11488    \param out ランダムデータを保持するバッファ。
11489    \param outSz 渡されたoutバッファのサイズ(0の場合、関数は必要な最大バッファサイズを返します)。
11490
11491    _Example_
11492    \code
11493    WOLFSSL ssl;
11494    unsigned char* buffer;
11495    size_t bufferSz;
11496    size_t ret;
11497    bufferSz  = wolfSSL_get_client_random(ssl, NULL, 0);
11498    buffer = malloc(bufferSz);
11499    ret  = wolfSSL_get_client_random(ssl, buffer, bufferSz);
11500    // ret値を確認
11501    \endcode
11502
11503    \sa wolfSSL_new
11504    \sa wolfSSL_free
11505*/
11506size_t wolfSSL_get_client_random(const WOLFSSL* ssl,
11507                                              unsigned char* out, size_t outSz);
11508
11509/*!
11510    \ingroup Setup
11511
11512    \brief ctx内に設定されたパスワードコールバックのgetter関数です。
11513
11514    \return func 成功時にはコールバック関数を返します。
11515    \return NULL ctxがNULLの場合、NULLを返します。
11516
11517    \param ctx コールバックを取得するWOLFSSL_CTX構造体。
11518
11519    _Example_
11520    \code
11521    WOLFSSL_CTX* ctx;
11522    wc_pem_password_cb cb;
11523    // ctxをセットアップ
11524    cb = wolfSSL_CTX_get_default_passwd_cb(ctx);
11525    //cbを使用
11526    \endcode
11527
11528    \sa wolfSSL_CTX_new
11529    \sa wolfSSL_CTX_free
11530*/
11531wc_pem_password_cb* wolfSSL_CTX_get_default_passwd_cb(WOLFSSL_CTX*
11532                                                                  ctx);
11533
11534/*!
11535    \ingroup Setup
11536
11537    \brief ctx内に設定されたパスワードコールバックユーザーデータのgetter関数です。
11538
11539    \return pointer 成功時にはユーザーデータポインタを返します。
11540    \return NULL ctxがNULLの場合、NULLを返します。
11541
11542    \param ctx ユーザーデータを取得するWOLFSSL_CTX構造体。
11543
11544    _Example_
11545    \code
11546    WOLFSSL_CTX* ctx;
11547    void* data;
11548    // ctxをセットアップ
11549    data = wolfSSL_CTX_get_default_passwd_cb(ctx);
11550    //dataを使用
11551    \endcode
11552
11553    \sa wolfSSL_CTX_new
11554    \sa wolfSSL_CTX_free
11555*/
11556void *wolfSSL_CTX_get_default_passwd_cb_userdata(WOLFSSL_CTX *ctx);
11557
11558/*!
11559    \ingroup CertsKeys
11560
11561    \brief この関数はwolfSSL_PEM_read_bio_X509と同じように動作します。AUXは、信頼された/拒否されたユースケースや人間が読みやすいフレンドリ名などの追加情報を含むことを意味します。
11562
11563    \return WOLFSSL_X509 PEMバッファの解析に成功した場合、WOLFSSL_X509構造体が返されます。
11564    \return Null PEMバッファの解析に失敗した場合。
11565
11566    \param bp PEMバッファを取得するWOLFSSL_BIO構造体。
11567    \param x 関数の副作用によってWOLFSSL_X509を設定する場合。
11568    \param cb パスワードコールバック。
11569    \param u NULL終端のユーザーパスワード。
11570
11571    _Example_
11572    \code
11573    WOLFSSL_BIO* bio;
11574    WOLFSSL_X509* x509;
11575    // bioをセットアップ
11576    X509 = wolfSSL_PEM_read_bio_X509_AUX(bio, NULL, NULL, NULL);
11577    //x509がnullでないことを確認してから使用
11578    \endcode
11579
11580    \sa wolfSSL_PEM_read_bio_X509
11581*/
11582WOLFSSL_X509 *wolfSSL_PEM_read_bio_X509_AUX
11583        (WOLFSSL_BIO *bp, WOLFSSL_X509 **x, wc_pem_password_cb *cb, void *u);
11584
11585/*!
11586    \ingroup CertsKeys
11587
11588    \brief WOLFSSL_CTX構造体のdhメンバをDiffie-Hellmanパラメータで初期化します。
11589
11590    \return SSL_SUCCESS 関数が正常に実行された場合に返されます。
11591    \return BAD_FUNC_ARG ctxまたはdh構造体がNULLの場合に返されます。
11592    \return SSL_FATAL_ERROR 構造体の値の設定にエラーがあった場合に返されます。
11593    \return MEMORY_E メモリの割り当てに失敗した場合に返されます。
11594
11595    \param ctx wolfSSL_CTX_new()を使用して作成されたWOLFSSL_CTX構造体へのポインタ。
11596    \param dh WOLFSSL_DH構造体へのポインタ。
11597
11598    _Example_
11599    \code
11600    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
11601    WOLFSSL_DH* dh;
11602    …
11603    return wolfSSL_CTX_set_tmp_dh(ctx, dh);
11604    \endcode
11605
11606    \sa wolfSSL_BN_bn2bin
11607*/
11608long wolfSSL_CTX_set_tmp_dh(WOLFSSL_CTX* ctx, WOLFSSL_DH* dh);
11609
11610/*!
11611    \ingroup CertsKeys
11612
11613    \brief この関数は、bio内のPEMバッファからDSAパラメータを取得します。
11614
11615    \return WOLFSSL_DSA PEMバッファの解析に成功した場合、WOLFSSL_DSA構造体が作成されて返されます。
11616    \return Null PEMバッファの解析に失敗した場合。
11617
11618    \param bio PEMメモリポインタを取得するためのWOLFSSL_BIO構造体へのポインタ。
11619    \param x 新しいWOLFSSL_DSA構造体に設定されるポインタ。
11620    \param cb パスワードコールバック関数。
11621    \param u null終端のパスワード文字列。
11622
11623    _Example_
11624    \code
11625    WOLFSSL_BIO* bio;
11626    WOLFSSL_DSA* dsa;
11627    // bioをセットアップ
11628    dsa = wolfSSL_PEM_read_bio_DSAparams(bio, NULL, NULL, NULL);
11629
11630    // dsaがNULLでないことを確認してからdsaを使用
11631    \endcode
11632
11633    \sa none
11634*/
11635WOLFSSL_DSA *wolfSSL_PEM_read_bio_DSAparams(WOLFSSL_BIO *bp,
11636    WOLFSSL_DSA **x, wc_pem_password_cb *cb, void *u);
11637
11638/*!
11639    \ingroup Debug
11640
11641    \brief この関数は、WOLFSSL_ERRORから発生した最後のエラーの絶対値を返します。
11642
11643    \return error 最後のエラーの絶対値を返します。
11644
11645    \param none パラメータはありません。
11646
11647    _Example_
11648    \code
11649    unsigned long err;
11650    ...
11651    err = wolfSSL_ERR_peek_last_error();
11652    // err値を検査
11653    \endcode
11654
11655    \sa wolfSSL_ERR_print_errors_fp
11656*/
11657unsigned long wolfSSL_ERR_peek_last_error(void);
11658
11659/*!
11660    \ingroup CertsKeys
11661
11662    \brief この関数は、ピアの証明書チェーンを取得します。
11663
11664    \return pointer ピアのCertificateスタックへのポインタを返します。
11665    \return NULL ピア証明書がない場合に返されます。
11666
11667    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11668
11669    _Example_
11670    \code
11671    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( method );
11672    WOLFSSL* ssl = wolfSSL_new(ctx);
11673    ...
11674    wolfSSL_connect(ssl);
11675    STACK_OF(WOLFSSL_X509)* chain = wolfSSL_get_peer_cert_chain(ssl);
11676    if(chain){
11677	    // ピア証明書チェーンへのポインタがあります
11678    }
11679    \endcode
11680
11681    \sa wolfSSL_X509_get_issuer_name
11682    \sa wolfSSL_X509_get_subject_name
11683    \sa wolfSSL_X509_get_isCA
11684*/
11685WOLF_STACK_OF(WOLFSSL_X509)* wolfSSL_get_peer_cert_chain(const WOLFSSL*);
11686
11687/*!
11688    \ingroup Setup
11689
11690    \brief この関数は、WOLFSSL_CTXオブジェクトのオプションビットをリセットします。
11691
11692    \return option 新しいオプションビット。
11693
11694    \param ctx SSLコンテキストへのポインタ。
11695
11696    _Example_
11697    \code
11698    WOLFSSL_CTX* ctx = 0;
11699    ...
11700    wolfSSL_CTX_clear_options(ctx, SSL_OP_NO_TLSv1);
11701    \endcode
11702
11703    \sa wolfSSL_CTX_new
11704    \sa wolfSSL_new
11705    \sa wolfSSL_free
11706*/
11707long wolfSSL_CTX_clear_options(WOLFSSL_CTX* ctx, long opt);
11708
11709/*!
11710    \ingroup IO
11711
11712    \brief この関数は、WOLFSSL構造体のjObjectRefメンバを設定します。
11713
11714    \return SSL_SUCCESS jObjectRefがobjPtrに適切に設定された場合に返されます。
11715    \return SSL_FAILURE 関数が適切に実行されず、jObjectRefが設定されていない場合に返されます。
11716
11717    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11718    \param objPtr jObjectRefに設定されるvoidポインタ。
11719
11720    _Example_
11721    \code
11722    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
11723    WOLFSSL* ssl = WOLFSSL_new();
11724    void* objPtr = &obj;
11725    ...
11726    if(wolfSSL_set_jobject(ssl, objPtr)){
11727    	// 成功ケース
11728    }
11729    \endcode
11730
11731    \sa wolfSSL_get_jobject
11732*/
11733int wolfSSL_set_jobject(WOLFSSL* ssl, void* objPtr);
11734
11735/*!
11736    \ingroup IO
11737
11738    \brief この関数は、WOLFSSL構造体のjObjectRefメンバを返します。
11739
11740    \return value WOLFSSL構造体がNULLでない場合、関数はjObjectRef値を返します。
11741    \return NULL WOLFSSL構造体がNULLの場合に返されます。
11742
11743    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11744
11745    _Example_
11746    \code
11747    WOLFSSL_CTX* ctx = wolfSSL_CTX_new( protocol method );
11748    WOLFSSL* ssl = wolfSSL(ctx);
11749    ...
11750    void* jobject = wolfSSL_get_jobject(ssl);
11751
11752    if(jobject != NULL){
11753    	// 成功ケース
11754    }
11755    \endcode
11756
11757    \sa wolfSSL_set_jobject
11758*/
11759void* wolfSSL_get_jobject(WOLFSSL* ssl);
11760
11761/*!
11762    \ingroup Setup
11763
11764    \brief この関数は、ssl内にコールバックを設定します。コールバックはハンドシェイクメッセージを監視するためのものです。cbのNULL値はコールバックをリセットします。
11765
11766    \return SSL_SUCCESS 成功時。
11767    \return SSL_FAILURE NULLのsslが渡された場合。
11768
11769    \param ssl コールバック引数を設定するWOLFSSL構造体。
11770
11771    _Example_
11772    \code
11773    static cb(int write_p, int version, int content_type,
11774    const void *buf, size_t len, WOLFSSL *ssl, void *arg)
11775    …
11776    WOLFSSL* ssl;
11777    ret  = wolfSSL_set_msg_callback(ssl, cb);
11778    // retを確認
11779    \endcode
11780
11781    \sa wolfSSL_set_msg_callback_arg
11782*/
11783int wolfSSL_set_msg_callback(WOLFSSL *ssl, SSL_Msg_Cb cb);
11784
11785/*!
11786    \ingroup Setup
11787
11788    \brief この関数は、ssl内に関連するコールバックコンテキスト値を設定します。値はコールバック引数に渡されます。
11789
11790    \return none 戻り値はありません。
11791
11792    \param ssl コールバック引数を設定するWOLFSSL構造体。
11793
11794    _Example_
11795    \code
11796    static cb(int write_p, int version, int content_type,
11797    const void *buf, size_t len, WOLFSSL *ssl, void *arg)
11798    …
11799    WOLFSSL* ssl;
11800    ret  = wolfSSL_set_msg_callback(ssl, cb);
11801    // retを確認
11802    wolfSSL_set_msg_callback(ssl, arg);
11803    \endcode
11804
11805    \sa wolfSSL_set_msg_callback
11806*/
11807int wolfSSL_set_msg_callback_arg(WOLFSSL *ssl, void* arg);
11808
11809/*!
11810    \ingroup CertsKeys
11811
11812    \brief この関数は、ピア証明書から次の代替名(もしあれば)を返します。
11813
11814    \return NULL 次の代替名がない場合。
11815    \return cert->altNamesNext->name WOLFSSL_X509構造体から返されます。    altNameリストからの文字列値が存在する場合に返されます。
11816
11817    \param cert wolfSSL_X509構造体へのポインタ。
11818
11819    _Example_
11820    \code
11821    WOLFSSL_X509 x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), NULL,
11822                                                        DYNAMIC_TYPE_X509);
11823    …
11824    int x509NextAltName = wolfSSL_X509_get_next_altname(x509);
11825    if(x509NextAltName == NULL){
11826        //別のalt nameはありません。
11827    }
11828    \endcode
11829
11830    \sa wolfSSL_X509_get_issuer_name
11831    \sa wolfSSL_X509_get_subject_name
11832*/
11833char* wolfSSL_X509_get_next_altname(WOLFSSL_X509*);
11834
11835/*!
11836    \ingroup CertsKeys
11837
11838    \brief この関数は、x509がNULLかどうかを確認し、NULLでない場合はx509構造体のnotBeforeメンバを返します。
11839
11840    \return pointer x509構造体のnotBeforeメンバへのASN1_TIMEを持つ構造体へのポインタ。
11841    \return NULL x509構造体がNULLの場合、関数はNULLを返します。
11842
11843    \param x509 WOLFSSL_X509構造体へのポインタ。
11844
11845    _Example_
11846    \code
11847    WOLFSSL_X509* x509 = (WOLFSSL_X509)XMALLOC(sizeof(WOLFSSL_X509), NULL,
11848    DYNAMIC_TYPE_X509) ;
11849    …
11850    const WOLFSSL_ASN1_TIME* notAfter = wolfSSL_X509_get_notBefore(x509);
11851    if(notAfter == NULL){
11852        //x509オブジェクトがNULLでした。
11853    }
11854    \endcode
11855
11856    \sa wolfSSL_X509_get_notAfter
11857*/
11858WOLFSSL_ASN1_TIME* wolfSSL_X509_get_notBefore(WOLFSSL_X509*);
11859
11860/*!
11861    \ingroup IO
11862
11863    \brief この関数はクライアント側で呼び出され、サーバとのSSL/TLSハンドシェイクを開始します。この関数が呼び出されるとき、基礎となる通信チャネルはすでに設定されています。wolfSSL_connect()は、ブロッキングI/Oと非ブロッキングI/Oの両方で動作します。基礎となるI/Oが非ブロッキングの場合、wolfSSL_connect()は、基礎となるI/OがwolfSSL_connect()がハンドシェイクを続行するために必要とするものを満たすことができないときに返されます。この場合、wolfSSL_get_error()の呼び出しはSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEを返します。呼び出しプロセスは、基礎となるI/Oの準備ができたときにwolfSSL_connect()の呼び出しを繰り返す必要があり、wolfSSLは中断したところから再開します。非ブロッキングソケットを使用する場合、何もする必要はありませんが、select()を使用して必要な条件を確認できます。基礎となるI/Oがブロッキングの場合、wolfSSL_connect()はハンドシェイクが完了するかエラーが発生するまで返されません。wolfSSLは、OpenSSLとは異なるアプローチで証明書検証を行います。クライアントのデフォルトポリシーはサーバを検証することです。つまり、サーバを検証するためのCAを読み込まない場合、接続エラー、検証不可(-155)が発生します。サーバの検証が失敗してもSSL_connectが成功し、セキュリティを低下させるOpenSSLの動作を模倣したい場合は、SSL_new()を呼び出す前にSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);を呼び出すことでこれを実現できます。ただし、推奨されません。
11864
11865    \return SSL_SUCCESS 成功した場合。
11866    \return SSL_FATAL_ERROR エラーが発生した場合に返されます。より詳細なエラーコードを取得するには、wolfSSL_get_error()を呼び出してください。
11867
11868    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11869
11870    _Example_
11871    \code
11872    int ret = 0;
11873    int err = 0;
11874    WOLFSSL* ssl;
11875    char buffer[80];
11876    ...
11877    ret = wolfSSL_connect(ssl);
11878    if (ret != SSL_SUCCESS) {
11879        err = wolfSSL_get_error(ssl, ret);
11880        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
11881    }
11882    \endcode
11883
11884    \sa wolfSSL_get_error
11885    \sa wolfSSL_accept
11886*/
11887int  wolfSSL_connect(WOLFSSL* ssl);
11888
11889/*!
11890    \ingroup Setup
11891
11892    \brief この関数は、HelloRetryRequestメッセージにCookieを含める必要があることを示すために、サーバ側で呼び出されます。また、プロトコルDTLS v1.3を使用する場合、ハンドシェイクには常にCookie交換が含まれることを示します。プロトコルDTLS v1.3を使用する場合、Cookie交換はデフォルトで有効になっていることに注意してください。Cookieは現在のトランスクリプトのハッシュを保持しており、別のサーバプロセスが応答のClientHelloを処理できるようにします。secretは、Cookieデータの完全性チェックを生成する際に使用されます。
11893
11894    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11895    \param [in] secret secretを保持するバッファへのポインタ。NULLを渡すと、新しいランダムなsecretを生成することを示します。
11896    \param [in] secretSz secretのサイズ(バイト単位)。0を渡すと、デフォルトサイズを使用することを示します:WC_SHA256_DIGEST_SIZE(SHA-256が利用できない場合はWC_SHA_DIGEST_SIZE)。
11897
11898    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
11899    \return SIDE_ERROR クライアントで呼び出された場合。
11900    \return WOLFSSL_SUCCESS 成功した場合。
11901    \return MEMORY_ERROR secretを保存するための動的メモリの割り当てに失敗した場合。
11902    \return Another 内部エラーの場合は他の負の値。
11903
11904    _Example_
11905    \code
11906    int ret;
11907    WOLFSSL* ssl;
11908    char secret[32];
11909    ...
11910    ret = wolfSSL__send_hrr_cookie(ssl, secret, sizeof(secret));
11911    if (ret != WOLFSSL_SUCCESS) {
11912        // Cookieとsecretの使用設定に失敗しました。
11913    }
11914    \endcode
11915
11916    \sa wolfSSL_new
11917    \sa wolfSSL_disable_hrr_cookie
11918*/
11919int  wolfSSL_send_hrr_cookie(WOLFSSL* ssl,
11920    const unsigned char* secret, unsigned int secretSz);
11921
11922/*!
11923
11924    \ingroup Setup
11925
11926    \brief この関数は、HelloRetryRequestメッセージにCookieを含めてはならないこと、およびプロトコルDTLS v1.3を使用している場合、ハンドシェイクにCookie交換を含めないことを示すために、サーバ側で呼び出されます。プロトコルDTLS v1.3を使用する際にCookie交換を行わないと、サーバがDoS/増幅攻撃に対して脆弱になる可能性があることに注意してください。
11927
11928    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11929
11930    \return WOLFSSL_SUCCESS 成功した場合。
11931    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
11932    \return SIDE_ERROR クライアントで呼び出された場合。
11933
11934    \sa wolfSSL_send_hrr_cookie
11935*/
11936int wolfSSL_disable_hrr_cookie(WOLFSSL* ssl);
11937
11938/*!
11939    \ingroup Setup
11940
11941    \brief この関数は、ハンドシェイクが完了した後、再開セッションチケットの送信を停止するために、サーバで呼び出されます。
11942
11943    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
11944
11945    \return BAD_FUNC_ARG ctxがNULLまたはTLS v1.3を使用していない場合。
11946    \return SIDE_ERROR クライアントで呼び出された場合。
11947    \return 0 成功した場合。
11948
11949    _Example_
11950    \code
11951    int ret;
11952    WOLFSSL_CTX* ctx;
11953    ...
11954    ret = wolfSSL_CTX_no_ticket_TLSv13(ctx);
11955    if (ret != 0) {
11956        // no ticketの設定に失敗しました。
11957    }
11958    \endcode
11959
11960    \sa wolfSSL_no_ticket_TLSv13
11961*/
11962int  wolfSSL_CTX_no_ticket_TLSv13(WOLFSSL_CTX* ctx);
11963
11964/*!
11965    \ingroup Setup
11966
11967    \brief この関数は、ハンドシェイクが完了した後、再開セッションチケットの送信を停止するために、サーバで呼び出されます。
11968
11969    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
11970
11971    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
11972    \return SIDE_ERROR クライアントで呼び出された場合。
11973    \return 0 成功した場合。
11974
11975    _Example_
11976    \code
11977    int ret;
11978    WOLFSSL* ssl;
11979    ...
11980    ret = wolfSSL_no_ticket_TLSv13(ssl);
11981    if (ret != 0) {
11982        // no ticketの設定に失敗しました。
11983    }
11984    \endcode
11985
11986    \sa wolfSSL_CTX_no_ticket_TLSv13
11987*/
11988int  wolfSSL_no_ticket_TLSv13(WOLFSSL* ssl);
11989
11990/*!
11991    \ingroup Setup
11992
11993    \brief この関数は、事前共有鍵を認証に使用するハンドシェイクの際に、Diffie-Hellman(DH)スタイルの鍵交換を禁止するために、TLS v1.3 wolfSSLコンテキストで呼び出されます。
11994
11995    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
11996
11997    \return BAD_FUNC_ARG ctxがNULLまたはTLS v1.3を使用していない場合。
11998    \return 0 成功した場合。
11999
12000    _Example_
12001    \code
12002    int ret;
12003    WOLFSSL_CTX* ctx;
12004    ...
12005    ret = wolfSSL_CTX_no_dhe_psk(ctx);
12006    if (ret != 0) {
12007        // PSKハンドシェイクのDHE無効化の設定に失敗しました。
12008    }
12009    \endcode
12010
12011    \sa wolfSSL_no_dhe_psk
12012*/
12013int  wolfSSL_CTX_no_dhe_psk(WOLFSSL_CTX* ctx);
12014
12015/*!
12016    \ingroup Setup
12017
12018    \brief この関数は、事前共有鍵を認証に使用するハンドシェイクの際に、Diffie-Hellman(DH)スタイルの鍵交換を禁止するために、TLS v1.3クライアントまたはサーバwolfSSLで呼び出されます。
12019
12020    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12021
12022    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
12023    \return 0 成功した場合。
12024
12025    _Example_
12026    \code
12027    int ret;
12028    WOLFSSL* ssl;
12029    ...
12030    ret = wolfSSL_no_dhe_psk(ssl);
12031    if (ret != 0) {
12032        // PSKハンドシェイクのDHE無効化の設定に失敗しました。
12033    }
12034    \endcode
12035
12036    \sa wolfSSL_CTX_no_dhe_psk
12037*/
12038int  wolfSSL_no_dhe_psk(WOLFSSL* ssl);
12039
12040/*!
12041    \ingroup IO
12042
12043    \brief この関数は、鍵のロールオーバーを強制するために、TLS v1.3クライアントまたはサーバwolfSSLで呼び出されます。KeyUpdateメッセージがピアに送信され、暗号化用の新しい鍵が計算されます。ピアはKeyUpdateメッセージを送り返し、その後新しい復号鍵が計算されます。この関数は、ハンドシェイクが完了した後にのみ呼び出すことができます。
12044
12045    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12046
12047    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
12048    \return WANT_WRITE 書き込みの準備ができていない場合。
12049    \return WOLFSSL_SUCCESS 成功した場合。
12050
12051    _Example_
12052    \code
12053    int ret;
12054    WOLFSSL* ssl;
12055    ...
12056    ret = wolfSSL_update_keys(ssl);
12057    if (ret == WANT_WRITE) {
12058        // I/Oの準備ができたら再度呼び出す必要があります。
12059    }
12060    else if (ret != WOLFSSL_SUCCESS) {
12061        // 鍵更新の送信に失敗しました。
12062    }
12063    \endcode
12064
12065    \sa wolfSSL_write
12066*/
12067int  wolfSSL_update_keys(WOLFSSL* ssl);
12068
12069/*!
12070    \ingroup IO
12071
12072    \brief この関数は、鍵のロールオーバーが進行中かどうかを判断するために、TLS v1.3クライアントまたはサーバwolfSSLで呼び出されます。wolfSSL_update_keys()が呼び出されると、KeyUpdateメッセージが送信され、暗号化鍵が更新されます。復号鍵は、応答を受信したときに更新されます。
12073
12074    \param [in] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12075    \param [out] required 鍵更新応答が不要な場合は0。鍵更新応答が必要な場合は1。
12076
12077    \return 0 成功した場合。
12078    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
12079
12080    _Example_
12081    \code
12082    int ret;
12083    WOLFSSL* ssl;
12084    int required;
12085    ...
12086    ret = wolfSSL_key_update_response(ssl, &required);
12087    if (ret != 0) {
12088        // 不正なパラメータ
12089    }
12090    if (required) {
12091        // 暗号化鍵が更新され、復号鍵を変更するための応答を待っています。
12092    }
12093    \endcode
12094
12095    \sa wolfSSL_update_keys
12096*/
12097int  wolfSSL_key_update_response(WOLFSSL* ssl, int* required);
12098
12099/*!
12100    \ingroup Setup
12101
12102    \brief この関数は、サーバからの要求に応じてクライアント証明書をハンドシェイク後に送信できるようにするために、TLS v1.3クライアントwolfSSLコンテキストで呼び出されます。これは、クライアント認証が必要なページとそうでないページを持つWebサーバに接続する際に便利です。
12103
12104    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12105
12106    \return BAD_FUNC_ARG ctxがNULLまたはTLS v1.3を使用していない場合。
12107    \return SIDE_ERROR サーバで呼び出された場合。
12108    \return 0 成功した場合。
12109
12110    _Example_
12111    \code
12112    int ret;
12113    WOLFSSL_CTX* ctx;
12114    ...
12115    ret = wolfSSL_allow_post_handshake_auth(ctx);
12116    if (ret != 0) {
12117        // ハンドシェイク後認証の許可に失敗しました。
12118    }
12119    \endcode
12120
12121    \sa wolfSSL_allow_post_handshake_auth
12122    \sa wolfSSL_request_certificate
12123*/
12124int  wolfSSL_CTX_allow_post_handshake_auth(WOLFSSL_CTX* ctx);
12125
12126/*!
12127    \ingroup Setup
12128
12129    \brief この関数は、サーバからの要求に応じてクライアント証明書をハンドシェイク後に送信できるようにするために、TLS v1.3クライアントwolfSSLで呼び出されます。Post-Handshake Client Authentication拡張がClientHelloで送信されます。これは、クライアント認証が必要なページとそうでないページを持つWebサーバに接続する際に便利です。
12130
12131    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12132
12133    \return BAD_FUNC_ARG sslがNULLまたはTLS v1.3を使用していない場合。
12134    \return SIDE_ERROR サーバで呼び出された場合。
12135    \return 0 成功した場合。
12136
12137    _Example_
12138    \code
12139    int ret;
12140    WOLFSSL* ssl;
12141    ...
12142    ret = wolfSSL_allow_post_handshake_auth(ssl);
12143    if (ret != 0) {
12144        // ハンドシェイク後認証の許可に失敗しました。
12145    }
12146    \endcode
12147
12148    \sa wolfSSL_CTX_allow_post_handshake_auth
12149    \sa wolfSSL_request_certificate
12150*/
12151int  wolfSSL_allow_post_handshake_auth(WOLFSSL* ssl);
12152
12153/*!    \ingroup IO
12154
12155    \brief この関数は、TLS v1.3クライアントからクライアント証明書を要求します。これは、Webサーバがクライアント認証を必要とするページと必要としないページの両方を提供している場合に便利です。接続上で最大256回の要求を送信できます。
12156
12157    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12158
12159    \return BAD_FUNC_ARG sslがNULLの場合、またはTLS v1.3を使用していない場合。
12160    \return WANT_WRITE 書き込みの準備ができていない場合。
12161    \return SIDE_ERROR クライアントで呼び出された場合。
12162    \return NOT_READY_ERROR ハンドシェイクが完了していないときに呼び出された場合。
12163    \return POST_HAND_AUTH_ERROR ポストハンドシェイク認証が許可されていない場合。
12164    \return MEMORY_E 動的メモリ割り当てが失敗した場合。
12165    \return WOLFSSL_SUCCESS 成功時。
12166
12167    _Example_
12168    \code
12169    int ret;
12170    WOLFSSL* ssl;
12171    ...
12172    ret = wolfSSL_request_certificate(ssl);
12173    if (ret == WANT_WRITE) {
12174        // I/Oの準備ができたら再度呼び出す必要があります
12175    }
12176    else if (ret != WOLFSSL_SUCCESS) {
12177        // クライアント証明書の要求に失敗しました
12178    }
12179    \endcode
12180
12181    \sa wolfSSL_allow_post_handshake_auth
12182    \sa wolfSSL_write
12183*/
12184int  wolfSSL_request_certificate(WOLFSSL* ssl);
12185
12186/*!
12187    \ingroup Setup
12188
12189    \brief この関数は、wolfSSLコンテキストで優先順位に従って許可する署名アルゴリズムのリストを設定します。リストはnull終端のテキスト文字列で、コロン区切りのリストです。各要素は "<公開鍵アルゴリズム>+<ハッシュ>" の形式（例: "RSA-PSS+SHA256:ECDSA+SHA384"）で指定します。Edwards曲線アルゴリズムである "ED25519" および "ED448" はハッシュがアルゴリズムに内包されるため、サフィックスを付けずに記述します。コンテキストに既に保持されているリストは置き換えられます。
12190
12191    認識される公開鍵トークンとハッシュトークン、および各トークンを利用するために必要なビルドオプションを以下の表に示します。
12192
12193    公開鍵トークン:
12194
12195    | トークン          | 必要なビルドオプション                              |
12196    | ----------------- | -------------------------------------------------- |
12197    | RSA               | !NO_RSA                                            |
12198    | RSA-PSS  /  PSS   | !NO_RSA かつ WC_RSA_PSS                            |
12199    | ECDSA             | HAVE_ECC                                           |
12200    | ED25519           | HAVE_ED25519（ハッシュ指定不要）                    |
12201    | ED448             | HAVE_ED448 （ハッシュ指定不要）                    |
12202    | DSA               | !NO_DSA                                            |
12203    | SM2               | WOLFSSL_SM2 かつ WOLFSSL_SM3（ハッシュは SM3 固定） |
12204
12205    ハッシュトークン:
12206
12207    | トークン | 必要なビルドオプション                                              |
12208    | -------- | ------------------------------------------------------------------ |
12209    | SHA256   | !NO_SHA256                                                         |
12210    | SHA384   | WOLFSSL_SHA384                                                     |
12211    | SHA512   | WOLFSSL_SHA512                                                     |
12212    | SHA224   | WOLFSSL_SHA224                                                     |
12213    | SM3      | WOLFSSL_SM3                                                        |
12214    | SHA1     | !NO_SHA かつ（!NO_OLD_TLS または WOLFSSL_ALLOW_TLS_SHA1）          |
12215
12216    TLS 1.3 における注意事項: RFC 8446 の規定により、RSA PKCS#1 v1.5、DSA、SHA-1、SHA-224 はハンドシェイク署名としては使用できず、リストに含まれていてもネゴシエーション時に除外されます。"RSA-PSS+SHAxxx" を指定した場合は rsa_pss_rsae_shaxxx と rsa_pss_pss_shaxxx の両方のスキームが追加されます。Brainpool ECDSA 署名スキーム（RFC 8734）は本文字列インタフェースでは選択できず、HAVE_ECC_BRAINPOOL が有効な場合に自動でネゴシエーションされます。
12217
12218    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12219    \param [in] list "<公開鍵アルゴリズム>+<ハッシュ>" 要素（または digest を伴わない "ED25519" / "ED448"）のコロン区切りリスト。
12220
12221    \return WOLFSSL_SUCCESS 成功時。
12222    \return WOLFSSL_FAILURE ポインタパラメータがNULLの場合、suites 構造体の確保に失敗した場合、またはリスト中のいずれかのトークンが認識されないか現在のビルドでサポートされていない場合。
12223
12224    _Example_
12225    \code
12226    int ret;
12227    WOLFSSL_CTX* ctx;
12228    const char* list = "RSA-PSS+SHA256:ECDSA+SHA384:ED25519";
12229    ...
12230    ret = wolfSSL_CTX_set1_sigalgs_list(ctx, list);
12231    if (ret != WOLFSSL_SUCCESS) {
12232        // 署名アルゴリズムリストの設定に失敗しました
12233    }
12234    \endcode
12235
12236    \sa wolfSSL_set1_sigalgs_list
12237    \sa wolfSSL_CTX_set1_groups_list
12238*/
12239int  wolfSSL_CTX_set1_sigalgs_list(WOLFSSL_CTX* ctx, const char* list);
12240
12241/*!
12242    \ingroup Setup
12243
12244    \brief この関数は、wolfSSLセッションで優先順位に従って許可する署名アルゴリズムのリストを設定します。リストの形式、認識される公開鍵トークンおよびハッシュトークンは wolfSSL_CTX_set1_sigalgs_list() と同一です。トークン一覧および TLS 1.3 における注意事項については wolfSSL_CTX_set1_sigalgs_list() の説明を参照してください。セッションに既に保持されているリストは置き換えられます。
12245
12246    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12247    \param [in] list "<公開鍵アルゴリズム>+<ハッシュ>" 要素（または digest を伴わない "ED25519" / "ED448"）のコロン区切りリスト。
12248
12249    \return WOLFSSL_SUCCESS 成功時。
12250    \return WOLFSSL_FAILURE ポインタパラメータがNULLの場合、suites 構造体の確保に失敗した場合、またはリスト中のいずれかのトークンが認識されないか現在のビルドでサポートされていない場合。
12251
12252    _Example_
12253    \code
12254    int ret;
12255    WOLFSSL* ssl;
12256    const char* list = "RSA-PSS+SHA256:ECDSA+SHA384:ED25519";
12257    ...
12258    ret = wolfSSL_set1_sigalgs_list(ssl, list);
12259    if (ret != WOLFSSL_SUCCESS) {
12260        // 署名アルゴリズムリストの設定に失敗しました
12261    }
12262    \endcode
12263
12264    \sa wolfSSL_CTX_set1_sigalgs_list
12265    \sa wolfSSL_set1_groups_list
12266*/
12267int  wolfSSL_set1_sigalgs_list(WOLFSSL* ssl, const char* list);
12268
12269/*!
12270    \ingroup Setup
12271
12272    \brief この関数は、wolfSSLコンテキストで優先順位に従って許可する鍵交換グループ（名前付き楕円曲線および KEM）のリストを設定します。リストはnull終端のテキスト文字列で、グループ名をコロンで区切って指定します（例: "P-384:P-256:X25519"）。TLS v1.3 接続で使用する鍵交換パラメータを設定するために本関数を呼び出します（本関数は HAVE_ECC、WOLFSSL_TLS13、HAVE_SUPPORTED_CURVES がすべて定義された場合にのみ提供されます）。
12273
12274    認識されるグループ名と必要なビルドオプションを以下に示します。名前は表とケースセンシティブに比較されます。
12275
12276    NIST / SEC 曲線（HAVE_ECC が必要）:
12277
12278    | 名前      | 曲線 / グループ                                                |
12279    | --------- | ------------------------------------------------------------ |
12280    | P-160     | secp160r1                                                    |
12281    | P-160-2   | secp160r2                                                    |
12282    | P-192     | secp192r1 (prime192v1)                                       |
12283    | P-224     | secp224r1                                                    |
12284    | P-256     | secp256r1 (prime256v1) — "prime256v1" / "secp256r1" でも指定可 |
12285    | P-384     | secp384r1 — "secp384r1" でも指定可                           |
12286    | P-521     | secp521r1 — "secp521r1" でも指定可                           |
12287    | K-160     | secp160k1                                                    |
12288    | K-192     | secp192k1                                                    |
12289    | K-224     | secp224k1                                                    |
12290    | K-256     | secp256k1                                                    |
12291
12292    Brainpool 曲線（HAVE_ECC に加えて WOLFSSL_CUSTOM_CURVES と HAVE_ECC_BRAINPOOL が必要。通常は --enable-ecccustcurves=all で有効化）:
12293
12294    | 名前  | 曲線               |
12295    | ----- | ------------------ |
12296    | B-256 | brainpoolP256r1    |
12297    | B-384 | brainpoolP384r1    |
12298    | B-512 | brainpoolP512r1    |
12299
12300    Edwards / Montgomery 曲線:
12301
12302    | 名前   | 必要なビルドオプション |
12303    | ------ | --------------------- |
12304    | X25519 | HAVE_CURVE25519       |
12305    | X448   | HAVE_CURVE448         |
12306
12307    SM2（WOLFSSL_SM2 が必要）:
12308
12309    | 名前      | グループ          |
12310    | --------- | ----------------- |
12311    | SM2       | sm2p256v1         |
12312    | sm2p256v1 | sm2p256v1（別名） |
12313
12314    ML-KEM（耐量子）グループ（WOLFSSL_HAVE_MLKEM かつ !WOLFSSL_NO_ML_KEM が必要）:
12315
12316    | 名前        |
12317    | ----------- |
12318    | ML_KEM_512  |
12319    | ML_KEM_768  |
12320    | ML_KEM_1024 |
12321
12322    ML-KEM ハイブリッドグループは、上記に加えて HAVE_ECC、および WOLFSSL_WC_MLKEM または HAVE_LIBOQS、さらに WOLFSSL_PQC_HYBRIDS（"extra" セットには WOLFSSL_EXTRA_PQC_HYBRIDS）が必要です:
12323
12324    | 名前                | 必要なハイブリッドフラグ   |
12325    | ------------------- | -------------------------- |
12326    | SecP256r1MLKEM768   | WOLFSSL_PQC_HYBRIDS        |
12327    | SecP384r1MLKEM1024  | WOLFSSL_PQC_HYBRIDS        |
12328    | X25519MLKEM768      | WOLFSSL_PQC_HYBRIDS        |
12329    | SecP256r1MLKEM512   | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12330    | SecP384r1MLKEM768   | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12331    | SecP521r1MLKEM1024  | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12332    | X25519MLKEM512      | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12333    | X448MLKEM768        | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12334
12335    レガシー Kyber グループ（WOLFSSL_MLKEM_KYBER が必要。ハイブリッドはさらに HAVE_ECC と、WOLFSSL_WC_MLKEM または HAVE_LIBOQS が必要）:
12336
12337    | 名前                  |
12338    | --------------------- |
12339    | KYBER_LEVEL1          |
12340    | KYBER_LEVEL3          |
12341    | KYBER_LEVEL5          |
12342    | P256_KYBER_LEVEL1     |
12343    | P256_KYBER_LEVEL3     |
12344    | P384_KYBER_LEVEL3     |
12345    | P521_KYBER_LEVEL5     |
12346    | X25519_KYBER_LEVEL1   |
12347    | X25519_KYBER_LEVEL3   |
12348    | X448_KYBER_LEVEL3     |
12349
12350    上記の名前に加え、HAVE_FIPS および HAVE_SELFTEST が定義されていないビルドでは、wolfCrypt に登録されている任意の曲線名（wc_ecc_get_curve_idx_from_name() で参照、例: "brainpoolP256r1"）も受理されます。
12351
12352    リストに指定した名前の順序はそのまま保持され、TLS 1.3 における KeyShare の優先順位として使用されます。
12353
12354    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12355    \param [in] list 鍵交換グループ名のコロン区切りリストである文字列。
12356
12357    \return WOLFSSL_FAILURE ポインタパラメータがNULLの場合、グループがWOLFSSL_MAX_GROUP_COUNTを超える場合、グループ名が認識されない場合、またはTLS v1.3を使用していない場合。
12358    \return WOLFSSL_SUCCESS 成功時。
12359
12360    _Example_
12361    \code
12362    int ret;
12363    WOLFSSL_CTX* ctx;
12364    const char* list = "P-384:P-256";
12365    ...
12366    ret = wolfSSL_CTX_set1_groups_list(ctx, list);
12367    if (ret != WOLFSSL_SUCCESS) {
12368        // グループリストの設定に失敗しました
12369    }
12370    \endcode
12371
12372    \sa wolfSSL_set1_groups_list
12373    \sa wolfSSL_CTX_set_groups
12374    \sa wolfSSL_set_groups
12375    \sa wolfSSL_UseKeyShare
12376    \sa wolfSSL_preferred_group
12377*/
12378int  wolfSSL_CTX_set1_groups_list(WOLFSSL_CTX *ctx, const char *list);
12379
12380/*!
12381    \ingroup Setup
12382
12383    \brief この関数は、wolfSSLセッションで優先順位に従って許可する鍵交換グループ（名前付き楕円曲線および KEM）のリストを設定します。リストの形式および認識されるグループ名は wolfSSL_CTX_set1_groups_list() と同一です。利用可能な名前一覧および必要なビルドオプションについては wolfSSL_CTX_set1_groups_list() の説明を参照してください。
12384
12385    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12386    \param [in] list 鍵交換グループのコロン区切りリストである文字列。
12387
12388    \return WOLFSSL_FAILURE ポインタパラメータがNULLの場合、グループがWOLFSSL_MAX_GROUP_COUNTを超える場合、グループ名が認識されない場合、またはTLS v1.3を使用していない場合。
12389    \return WOLFSSL_SUCCESS 成功時。
12390
12391    _Example_
12392    \code
12393    int ret;
12394    WOLFSSL* ssl;
12395    const char* list = "P-384:P-256";
12396    ...
12397    ret = wolfSSL_CTX_set1_groups_list(ssl, list);
12398    if (ret != WOLFSSL_SUCCESS) {
12399        // グループリストの設定に失敗しました
12400    }
12401    \endcode
12402
12403    \sa wolfSSL_CTX_set1_groups_list
12404    \sa wolfSSL_CTX_set_groups
12405    \sa wolfSSL_set_groups
12406    \sa wolfSSL_UseKeyShare
12407    \sa wolfSSL_preferred_group
12408*/
12409int  wolfSSL_set1_groups_list(WOLFSSL *ssl, const char *list);
12410
12411/*!
12412    \ingroup TLS
12413
12414    \brief この関数は、TLS v1.3ハンドシェイクでクライアントが優先的に使用したい鍵交換グループを返します。ハンドシェイク完了後にこの関数を呼び出して、サーバが優先するグループを判定し、この情報を将来の接続で使用して鍵交換用の鍵ペアを事前生成できます。
12415
12416    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12417
12418    \return BAD_FUNC_ARG sslがNULLの場合、またはTLS v1.3を使用していない場合。
12419    \return SIDE_ERROR サーバで呼び出された場合。
12420    \return NOT_READY_ERROR ハンドシェイク完了前に呼び出された場合。
12421    \return Group identifier 成功時、グループ識別子。
12422
12423    _Example_
12424    \code
12425    int ret;
12426    int group;
12427    WOLFSSL* ssl;
12428    ...
12429    ret = wolfSSL_CTX_set1_groups_list(ssl)
12430    if (ret < 0) {
12431        // グループの取得に失敗しました
12432    }
12433    group = ret;
12434    \endcode
12435
12436    \sa wolfSSL_UseKeyShare
12437    \sa wolfSSL_CTX_set_groups
12438    \sa wolfSSL_set_groups
12439    \sa wolfSSL_CTX_set1_groups_list
12440    \sa wolfSSL_set1_groups_list
12441*/
12442int  wolfSSL_preferred_group(WOLFSSL* ssl);
12443
12444/*!
12445    \ingroup Setup
12446
12447    \brief この関数は、wolfSSLコンテキストで優先順位に従って許可する鍵交換グループ（名前付き楕円曲線および KEM）のリストを設定します。リストは名前付きグループ識別子（下表参照）の配列で、\p count に配列内の識別子数を指定します。TLS v1.3 接続で使用する鍵交換パラメータを設定するために本関数を呼び出します。配列の順序がそのまま KeyShare の優先順位として用いられます。
12448
12449    認識される識別子と必要なビルドオプションを以下に示します。識別子は \<wolfssl/ssl.h\> 内の無名 enum で定義されています。
12450
12451    NIST / SEC 曲線（HAVE_ECC が必要）:
12452
12453    | 識別子                    | 曲線 / グループ                       |
12454    | ------------------------- | ------------------------------------ |
12455    | WOLFSSL_ECC_SECP160K1     | secp160k1                            |
12456    | WOLFSSL_ECC_SECP160R1     | secp160r1                            |
12457    | WOLFSSL_ECC_SECP160R2     | secp160r2                            |
12458    | WOLFSSL_ECC_SECP192K1     | secp192k1                            |
12459    | WOLFSSL_ECC_SECP192R1     | secp192r1 (prime192v1)               |
12460    | WOLFSSL_ECC_SECP224K1     | secp224k1                            |
12461    | WOLFSSL_ECC_SECP224R1     | secp224r1                            |
12462    | WOLFSSL_ECC_SECP256K1     | secp256k1                            |
12463    | WOLFSSL_ECC_SECP256R1     | secp256r1 (prime256v1)               |
12464    | WOLFSSL_ECC_SECP384R1     | secp384r1                            |
12465    | WOLFSSL_ECC_SECP521R1     | secp521r1                            |
12466
12467    Brainpool 曲線（HAVE_ECC に加えて WOLFSSL_CUSTOM_CURVES と HAVE_ECC_BRAINPOOL が必要。通常は --enable-ecccustcurves=all で有効化）:
12468
12469    | 識別子                              | 曲線             | 備考 |
12470    | ----------------------------------- | ---------------- | ---- |
12471    | WOLFSSL_ECC_BRAINPOOLP256R1         | brainpoolP256r1  | TLS 1.2 グループ ID 26 |
12472    | WOLFSSL_ECC_BRAINPOOLP384R1         | brainpoolP384r1  | TLS 1.2 グループ ID 27 |
12473    | WOLFSSL_ECC_BRAINPOOLP512R1         | brainpoolP512r1  | TLS 1.2 グループ ID 28 |
12474    | WOLFSSL_ECC_BRAINPOOLP256R1TLS13    | brainpoolP256r1  | RFC 8734 TLS 1.3 ID    |
12475    | WOLFSSL_ECC_BRAINPOOLP384R1TLS13    | brainpoolP384r1  | RFC 8734 TLS 1.3 ID    |
12476    | WOLFSSL_ECC_BRAINPOOLP512R1TLS13    | brainpoolP512r1  | RFC 8734 TLS 1.3 ID    |
12477
12478    Edwards / Montgomery 曲線:
12479
12480    | 識別子            | 必要なビルドオプション |
12481    | ----------------- | ---------------------- |
12482    | WOLFSSL_ECC_X25519| HAVE_CURVE25519        |
12483    | WOLFSSL_ECC_X448  | HAVE_CURVE448          |
12484
12485    SM2（WOLFSSL_SM2 が必要）:
12486
12487    | 識別子                 | グループ  |
12488    | ---------------------- | --------- |
12489    | WOLFSSL_ECC_SM2P256V1  | sm2p256v1 |
12490
12491    有限体 DH（RFC 7919）グループ（HAVE_FFDHE および各サイズに対応する HAVE_FFDHE_NNNN マクロが必要）:
12492
12493    | 識別子             | グループ    |
12494    | ------------------ | ----------- |
12495    | WOLFSSL_FFDHE_2048 | ffdhe2048   |
12496    | WOLFSSL_FFDHE_3072 | ffdhe3072   |
12497    | WOLFSSL_FFDHE_4096 | ffdhe4096   |
12498    | WOLFSSL_FFDHE_6144 | ffdhe6144   |
12499    | WOLFSSL_FFDHE_8192 | ffdhe8192   |
12500
12501    ML-KEM（耐量子）グループ（HAVE_PQC、WOLFSSL_HAVE_MLKEM、!WOLFSSL_NO_ML_KEM が必要）:
12502
12503    | 識別子             |
12504    | ------------------ |
12505    | WOLFSSL_ML_KEM_512 |
12506    | WOLFSSL_ML_KEM_768 |
12507    | WOLFSSL_ML_KEM_1024|
12508
12509    ML-KEM ハイブリッドグループは、上記に加えて HAVE_ECC、および WOLFSSL_WC_MLKEM または HAVE_LIBOQS、さらに WOLFSSL_PQC_HYBRIDS（"extra" セットには WOLFSSL_EXTRA_PQC_HYBRIDS）が必要です:
12510
12511    | 識別子                           | 必要なハイブリッドフラグ   |
12512    | -------------------------------- | -------------------------- |
12513    | WOLFSSL_SECP256R1MLKEM768        | WOLFSSL_PQC_HYBRIDS        |
12514    | WOLFSSL_X25519MLKEM768           | WOLFSSL_PQC_HYBRIDS        |
12515    | WOLFSSL_SECP384R1MLKEM1024       | WOLFSSL_PQC_HYBRIDS        |
12516    | WOLFSSL_SECP256R1MLKEM512        | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12517    | WOLFSSL_SECP384R1MLKEM768        | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12518    | WOLFSSL_SECP521R1MLKEM1024       | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12519    | WOLFSSL_X25519MLKEM512           | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12520    | WOLFSSL_X448MLKEM768             | WOLFSSL_EXTRA_PQC_HYBRIDS  |
12521
12522    レガシー Kyber グループ（HAVE_PQC と WOLFSSL_MLKEM_KYBER が必要。ハイブリッドはさらに HAVE_ECC と、WOLFSSL_WC_MLKEM または HAVE_LIBOQS が必要）:
12523
12524    | 識別子                      |
12525    | --------------------------- |
12526    | WOLFSSL_KYBER_LEVEL1        |
12527    | WOLFSSL_KYBER_LEVEL3        |
12528    | WOLFSSL_KYBER_LEVEL5        |
12529    | WOLFSSL_P256_KYBER_LEVEL1   |
12530    | WOLFSSL_P256_KYBER_LEVEL3   |
12531    | WOLFSSL_P384_KYBER_LEVEL3   |
12532    | WOLFSSL_P521_KYBER_LEVEL5   |
12533    | WOLFSSL_X25519_KYBER_LEVEL1 |
12534    | WOLFSSL_X25519_KYBER_LEVEL3 |
12535    | WOLFSSL_X448_KYBER_LEVEL3   |
12536
12537    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12538    \param [in] groups 識別子による鍵交換グループのリスト。
12539    \param [in] count \p groups 内の識別子数（WOLFSSL_MAX_GROUP_COUNT を超えてはならない）。
12540
12541    \return BAD_FUNC_ARG ポインタパラメータが NULL の場合、\p count が WOLFSSL_MAX_GROUP_COUNT を超える場合、または基底メソッドが TLS メソッドでない場合。
12542    \return WOLFSSL_SUCCESS 成功時。
12543
12544    _Example_
12545    \code
12546    int ret;
12547    WOLFSSL_CTX* ctx;
12548    int groups[] = { WOLFSSL_ECC_X25519, WOLFSSL_ECC_SECP256R1 };
12549    int count = sizeof(groups) / sizeof(groups[0]);
12550    ...
12551    ret = wolfSSL_CTX_set_groups(ctx, groups, count);
12552    if (ret != WOLFSSL_SUCCESS) {
12553        // グループリストの設定に失敗しました
12554    }
12555    \endcode
12556
12557    \sa wolfSSL_set_groups
12558    \sa wolfSSL_UseKeyShare
12559    \sa wolfSSL_CTX_set1_groups_list
12560    \sa wolfSSL_set1_groups_list
12561    \sa wolfSSL_preferred_group
12562*/
12563int  wolfSSL_CTX_set_groups(WOLFSSL_CTX* ctx, int* groups,
12564    int count);
12565
12566/*!
12567    \ingroup Setup
12568
12569    \brief この関数は、wolfSSLセッションで優先順位に従って許可する鍵交換グループ（名前付き楕円曲線および KEM）のリストを設定します。配列の形式および認識される識別子は wolfSSL_CTX_set_groups() と同一です。利用可能な識別子一覧および必要なビルドオプションについては wolfSSL_CTX_set_groups() の説明を参照してください。
12570
12571    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12572    \param [in] groups 識別子による鍵交換グループのリスト。
12573    \param [in] count \p groups 内の識別子数（WOLFSSL_MAX_GROUP_COUNT を超えてはならない）。
12574
12575    \return BAD_FUNC_ARG ポインタパラメータが NULL の場合、\p count が WOLFSSL_MAX_GROUP_COUNT を超える場合、識別子のいずれかが認識されない場合、または基底メソッドが TLS メソッドでない場合。
12576    \return WOLFSSL_SUCCESS 成功時。
12577
12578    _Example_
12579    \code
12580    int ret;
12581    WOLFSSL* ssl;
12582    int groups[] = { WOLFSSL_ECC_X25519, WOLFSSL_ECC_SECP256R1 };
12583    int count = sizeof(groups) / sizeof(groups[0]);
12584    ...
12585    ret = wolfSSL_set_groups(ssl, groups, count);
12586    if (ret != WOLFSSL_SUCCESS) {
12587        // グループリストの設定に失敗しました
12588    }
12589    \endcode
12590
12591    \sa wolfSSL_CTX_set_groups
12592    \sa wolfSSL_UseKeyShare
12593    \sa wolfSSL_CTX_set1_groups_list
12594    \sa wolfSSL_set1_groups_list
12595    \sa wolfSSL_preferred_group
12596*/
12597int  wolfSSL_set_groups(WOLFSSL* ssl, int* groups, int count);
12598
12599/*!
12600    \ingroup IO
12601
12602    \brief この関数はクライアント側で呼び出され、サーバとのTLS v1.3ハンドシェイクを開始します。この関数が呼び出されるとき、基礎となる通信チャネルはすでに設定されています。wolfSSL_connect()はブロッキングI/Oと非ブロッキングI/Oの両方で動作します。基礎となるI/Oが非ブロッキングの場合、基礎となるI/OがwolfSSL_connect()がハンドシェイクを続行するために必要なものを満たせない場合、wolfSSL_connect()は返されます。この場合、wolfSSL_get_error()を呼び出すとSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、基礎となるI/Oの準備ができたときにwolfSSL_connect()の呼び出しを繰り返す必要があり、wolfSSLは中断したところから再開します。非ブロッキングソケットを使用する場合、何もする必要はありませんが、select()を使用して必要な条件を確認できます。基礎となるI/OがブロッキングI/Oの場合、wolfSSL_connect()はハンドシェイクが完了するかエラーが発生するまで返されません。wolfSSLは証明書検証にOpenSSLとは異なるアプローチを取ります。クライアントのデフォルトポリシーはサーバを検証することです。つまり、サーバを検証するためのCAをロードしない場合、接続エラー「検証できません(-155)」が発生します。サーバの検証が失敗してもSSL_connectが成功するというOpenSSLの動作を模倣し、セキュリティを低下させたい場合は、SSL_new()を呼び出す前にSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0)を呼び出すことでこれを行うことができます。ただし、これは推奨されません。
12603
12604    \return SSL_SUCCESS 成功時。
12605    \return SSL_FATAL_ERROR エラーが発生した場合に返されます。より詳細なエラーコードを取得するには、wolfSSL_get_error()を呼び出してください。
12606
12607    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12608
12609    _Example_
12610    \code
12611    int ret = 0;
12612    int err = 0;
12613    WOLFSSL* ssl;
12614    char buffer[80];
12615    ...
12616
12617    ret = wolfSSL_connect_TLSv13(ssl);
12618    if (ret != SSL_SUCCESS) {
12619        err = wolfSSL_get_error(ssl, ret);
12620        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
12621    }
12622    \endcode
12623
12624    \sa wolfSSL_get_error
12625    \sa wolfSSL_connect
12626    \sa wolfSSL_accept_TLSv13
12627    \sa wolfSSL_accept
12628*/
12629int  wolfSSL_connect_TLSv13(WOLFSSL* ssl);
12630
12631/*!
12632    \ingroup IO
12633
12634    \brief この関数はサーバ側で呼び出され、SSL/TLSクライアントがSSL/TLSハンドシェイクを開始するのを待ちます。この関数が呼び出されるとき、基礎となる通信チャネルはすでに設定されています。wolfSSL_accept()はブロッキングI/Oと非ブロッキングI/Oの両方で動作します。基礎となるI/Oが非ブロッキングの場合、基礎となるI/OがwolfSSL_accept()がハンドシェイクを続行するために必要なものを満たせない場合、wolfSSL_accept()は返されます。この場合、wolfSSL_get_error()を呼び出すとSSL_ERROR_WANT_READまたはSSL_ERROR_WANT_WRITEのいずれかが返されます。呼び出し側プロセスは、データが読み取り可能になったときにwolfSSL_acceptの呼び出しを繰り返す必要があり、wolfSSLは中断したところから再開します。非ブロッキングソケットを使用する場合、何もする必要はありませんが、select()を使用して必要な条件を確認できます。基礎となるI/OがブロッキングI/Oの場合、wolfSSL_accept()はハンドシェイクが完了するかエラーが発生するまで返されません。TLS v1.3接続を期待する場合にこの関数を呼び出してください。ただし、古いバージョンのClientHelloメッセージもサポートされています。
12635
12636    \return SSL_SUCCESS 成功時。
12637    \return SSL_FATAL_ERROR エラーが発生した場合に返されます。より詳細なエラーコードを取得するには、wolfSSL_get_error()を呼び出してください。
12638
12639    \param ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12640
12641    _Example_
12642    \code
12643    int ret = 0;
12644    int err = 0;
12645    WOLFSSL* ssl;
12646    char buffer[80];
12647    ...
12648
12649    ret = wolfSSL_accept_TLSv13(ssl);
12650    if (ret != SSL_SUCCESS) {
12651        err = wolfSSL_get_error(ssl, ret);
12652        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
12653    }
12654    \endcode
12655
12656    \sa wolfSSL_get_error
12657    \sa wolfSSL_connect_TLSv13
12658    \sa wolfSSL_connect
12659    \sa wolfSSL_accept_TLSv13
12660    \sa wolfSSL_accept
12661*/
12662wolfSSL_accept_TLSv13(WOLFSSL* ssl);
12663
12664/*!
12665    \ingroup Setup
12666
12667    \brief この関数は、TLS v1.3クライアントまたはサーバがwolfSSLコンテキストを使用して交換する意思のある早期データの最大量を設定します。リプレイ攻撃を軽減するために処理する早期データの量を制限するには、この関数を呼び出してください。早期データは、セッションチケットが送信された接続の鍵から派生した鍵によって保護されるため、セッションチケットが再開に使用されるたびに同じになります。この値は再開用のセッションチケットに含まれます。サーバの値がゼロの場合、セッションチケットを使用してクライアントが早期データを送信しないことを示します。クライアントの値がゼロの場合、クライアントが早期データを送信しないことを示します。早期データのバイト数は、アプリケーションで実用的に可能な限り低く保つことをお勧めします。
12668
12669    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12670    \param [in] sz 受け入れる早期データの量(バイト単位)。
12671
12672    \return BAD_FUNC_ARG ctxがNULLの場合、またはTLS v1.3を使用していない場合。
12673    \return 0 成功時。
12674
12675    _Example_
12676    \code
12677    int ret;
12678    WOLFSSL_CTX* ctx;
12679    ...
12680    ret = wolfSSL_CTX_set_max_early_data(ctx, 128);
12681    if (ret != WOLFSSL_SUCCESS) {
12682        // グループリストの設定に失敗しました
12683    }
12684    \endcode
12685
12686    \sa wolfSSL_set_max_early_data
12687    \sa wolfSSL_write_early_data
12688    \sa wolfSSL_read_early_data
12689*/
12690int  wolfSSL_CTX_set_max_early_data(WOLFSSL_CTX* ctx,
12691    unsigned int sz);
12692
12693/*!
12694    \ingroup Setup
12695
12696    \brief この関数は、TLS v1.3クライアントまたはサーバが交換する意思のある早期データの最大量を設定します。リプレイ攻撃を軽減するために処理する早期データの量を制限するには、この関数を呼び出してください。早期データは、セッションチケットが送信された接続の鍵から派生した鍵によって保護されるため、セッションチケットが再開に使用されるたびに同じになります。この値は再開用のセッションチケットに含まれます。サーバの値がゼロの場合、セッションチケットを使用してクライアントが早期データを送信しないことを示します。クライアントの値がゼロの場合、クライアントが早期データを送信しないことを示します。早期データのバイト数は、アプリケーションで実用的に可能な限り低く保つことをお勧めします。
12697
12698    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12699    \param [in] sz クライアントから受け入れる早期データの量(バイト単位)。
12700
12701    \return BAD_FUNC_ARG sslがNULLの場合、またはTLS v1.3を使用していない場合。
12702    \return 0 成功時。    _Example_
12703    \code
12704    int ret;
12705    WOLFSSL* ssl;
12706    ...
12707    ret = wolfSSL_set_max_early_data(ssl, 128);
12708    if (ret != WOLFSSL_SUCCESS) {
12709        // グループリストの設定に失敗しました
12710    }
12711    \endcode
12712
12713    \sa wolfSSL_CTX_set_max_early_data
12714    \sa wolfSSL_write_early_data
12715    \sa wolfSSL_read_early_data
12716*/
12717int  wolfSSL_set_max_early_data(WOLFSSL* ssl, unsigned int sz);
12718
12719/*!
12720    \ingroup IO
12721
12722    \brief この関数は再開時にサーバーにアーリーデータを書き込みます。wolfSSL_connect()またはwolfSSL_connect_TLSv13()の前にこの関数を呼び出してください。この関数はクライアントでのみ使用されます。
12723
12724    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12725    \param [in] data サーバーに書き込むアーリーデータを保持するバッファ。
12726    \param [in] sz 書き込むアーリーデータの量(バイト単位)。
12727    \param [out] outSz 書き込まれたアーリーデータの量(バイト単位)。
12728
12729    \return BAD_FUNC_ARG ポインタパラメータがNULL、szが0未満、またはTLSv1.3を使用していない場合。
12730    \return SIDE_ERROR サーバーで呼び出された場合。
12731    \return WOLFSSL_FATAL_ERROR 接続が確立されなかった場合。
12732    \return 成功した場合、書き込まれたアーリーデータのバイト数。
12733
12734    _Example_
12735    \code
12736    int ret = 0;
12737    int err = 0;
12738    WOLFSSL* ssl;
12739    byte earlyData[] = { early data };
12740    int outSz;
12741    char buffer[80];
12742    ...
12743
12744    ret = wolfSSL_write_early_data(ssl, earlyData, sizeof(earlyData), &outSz);
12745    if (ret < 0) {
12746        err = wolfSSL_get_error(ssl, ret);
12747        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
12748        goto err_label;
12749    }
12750    if (outSz < sizeof(earlyData)) {
12751        // すべてのアーリーデータが送信されませんでした
12752    }
12753    ret = wolfSSL_connect_TLSv13(ssl);
12754    if (ret != SSL_SUCCESS) {
12755        err = wolfSSL_get_error(ssl, ret);
12756        printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
12757    }
12758    \endcode
12759
12760    \sa wolfSSL_read_early_data
12761    \sa wolfSSL_connect
12762    \sa wolfSSL_connect_TLSv13
12763*/
12764int  wolfSSL_write_early_data(WOLFSSL* ssl, const void* data,
12765    int sz, int* outSz);
12766
12767/*!
12768    \ingroup IO
12769
12770    \brief この関数は再開時にクライアントからのアーリーデータを読み取ります。クライアントを受け入れ、ハンドシェイクでアーリーデータを読み取るには、wolfSSL_accept()またはwolfSSL_accept_TLSv13()の代わりにこの関数を呼び出します。wolfSSL_is_init_finished()がtrueを返すまで関数を呼び出す必要があります。アーリーデータは複数のメッセージでクライアントから送信される場合があります。アーリーデータがない場合、ハンドシェイクは通常通り処理されます。この関数はサーバーでのみ使用されます。
12771
12772    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12773    \param [out] data クライアントから読み取ったアーリーデータを保持するバッファ。
12774    \param [in] sz バッファのサイズ(バイト単位)。
12775    \param [out] outSz 読み取ったアーリーデータのバイト数。
12776
12777    \return BAD_FUNC_ARG ポインタパラメータがNULL、szが0未満、またはTLSv1.3を使用していない場合。
12778    \return SIDE_ERROR クライアントで呼び出された場合。
12779    \return WOLFSSL_FATAL_ERROR 接続の受け入れが失敗した場合。
12780    \return 読み取ったアーリーデータのバイト数(ゼロの場合もあります)。
12781
12782    _Example_
12783    \code
12784    int ret = 0;
12785    int err = 0;
12786    WOLFSSL* ssl;
12787    byte earlyData[128];
12788    int outSz;
12789    char buffer[80];
12790    ...
12791
12792    do {
12793        ret = wolfSSL_read_early_data(ssl, earlyData, sizeof(earlyData), &outSz);
12794        if (ret < 0) {
12795            err = wolfSSL_get_error(ssl, ret);
12796            printf("error = %d, %s\n", err, wolfSSL_ERR_error_string(err, buffer));
12797        }
12798        if (outSz > 0) {
12799            // アーリーデータが利用可能
12800        }
12801    } while (!wolfSSL_is_init_finished(ssl));
12802    \endcode
12803
12804    \sa wolfSSL_write_early_data
12805    \sa wolfSSL_accept
12806    \sa wolfSSL_accept_TLSv13
12807*/
12808int  wolfSSL_read_early_data(WOLFSSL* ssl, void* data, int sz,
12809    int* outSz);
12810
12811/*!
12812    \ingroup IO
12813
12814    \brief この関数はWOLFSSLオブジェクトにデータを注入するために呼び出されます。これは、データを単一の場所から読み取り、複数の接続に分割する必要がある場合に便利です。呼び出し元はwolfSSL_read()を呼び出してWOLFSSLオブジェクトから平文データを抽出する必要があります。
12815
12816    \param [in] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12817    \param [in] data sslオブジェクトに注入するデータ。
12818    \param [in] sz 注入するデータのバイト数。
12819
12820    \return BAD_FUNC_ARG いずれかのポインタパラメータがNULLまたはsz <= 0の場合。
12821    \return APP_DATA_READY 読み取るべきアプリケーションデータが残っている場合。
12822    \return MEMORY_E 割り当てが失敗した場合。
12823    \return WOLFSSL_SUCCESS 成功時。
12824
12825    _Example_
12826    \code
12827    byte buf[2000]
12828    sz = recv(fd, buf, sizeof(buf), 0);
12829    if (sz <= 0)
12830        // エラー
12831    if (wolfSSL_inject(ssl, buf, sz) != WOLFSSL_SUCCESS)
12832        // エラー
12833    sz = wolfSSL_read(ssl, buf, sizeof(buf);
12834    \endcode
12835
12836    \sa wolfSSL_read
12837*/
12838int wolfSSL_inject(WOLFSSL* ssl, const void* data, int sz);
12839
12840/*!
12841    \ingroup Setup
12842
12843    \brief この関数はTLS v1.3接続のための事前共有鍵(PSK)クライアント側コールバックを設定します。コールバックはPSKアイデンティティを検索し、その鍵とハンドシェイクで使用する暗号の名前を返すために使用されます。この関数はWOLFSSL_CTX構造体のclient_psk_tls13_cbメンバーを設定します。
12844
12845    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12846    \param [in] cb TLS 1.3クライアント用の事前共有鍵(PSK)コールバック。
12847
12848    _Example_
12849    \code
12850    WOLFSSL_CTX* ctx;
12851    ...
12852    wolfSSL_CTX_set_psk_client_tls13_callback(ctx, my_psk_client_tls13_cb);
12853    \endcode
12854
12855    \sa wolfSSL_set_psk_client_tls13_callback
12856    \sa wolfSSL_CTX_set_psk_server_tls13_callback
12857    \sa wolfSSL_set_psk_server_tls13_callback
12858*/
12859void wolfSSL_CTX_set_psk_client_tls13_callback(WOLFSSL_CTX* ctx,
12860    wc_psk_client_tls13_callback cb);
12861
12862/*!
12863    \ingroup Setup
12864
12865    \brief この関数はTLS v1.3接続のための事前共有鍵(PSK)クライアント側コールバックを設定します。コールバックはPSKアイデンティティを検索し、その鍵とハンドシェイクで使用する暗号の名前を返すために使用されます。この関数はWOLFSSL構造体のoptionsフィールドのclient_psk_tls13_cbメンバーを設定します。
12866
12867    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12868    \param [in] cb TLS 1.3クライアント用の事前共有鍵(PSK)コールバック。
12869
12870    _Example_
12871    \code
12872    WOLFSSL* ssl;
12873    ...
12874    wolfSSL_set_psk_client_tls13_callback(ssl, my_psk_client_tls13_cb);
12875    \endcode
12876
12877    \sa wolfSSL_CTX_set_psk_client_tls13_callback
12878    \sa wolfSSL_CTX_set_psk_server_tls13_callback
12879    \sa wolfSSL_set_psk_server_tls13_callback
12880*/
12881void wolfSSL_set_psk_client_tls13_callback(WOLFSSL* ssl,
12882    wc_psk_client_tls13_callback cb);
12883
12884/*!
12885    \ingroup Setup
12886
12887    \brief この関数はTLS v1.3接続のための事前共有鍵(PSK)サーバー側コールバックを設定します。コールバックはPSKアイデンティティを検索し、その鍵とハンドシェイクで使用する暗号の名前を返すために使用されます。この関数はWOLFSSL_CTX構造体のserver_psk_tls13_cbメンバーを設定します。
12888
12889    \param [in,out] ctx wolfSSL_CTX_new()で作成されたWOLFSSL_CTX構造体へのポインタ。
12890    \param [in] cb TLS 1.3サーバー用の事前共有鍵(PSK)コールバック。
12891
12892    _Example_
12893    \code
12894    WOLFSSL_CTX* ctx;
12895    ...
12896    wolfSSL_CTX_set_psk_server_tls13_callback(ctx, my_psk_client_tls13_cb);
12897    \endcode
12898
12899    \sa wolfSSL_CTX_set_psk_client_tls13_callback
12900    \sa wolfSSL_set_psk_client_tls13_callback
12901    \sa wolfSSL_set_psk_server_tls13_callback
12902*/
12903void wolfSSL_CTX_set_psk_server_tls13_callback(WOLFSSL_CTX* ctx,
12904    wc_psk_server_tls13_callback cb);
12905
12906/*!
12907    \ingroup Setup
12908
12909    \brief この関数はTLS v1.3接続のための事前共有鍵(PSK)サーバー側コールバックを設定します。コールバックはPSKアイデンティティを検索し、その鍵とハンドシェイクで使用する暗号の名前を返すために使用されます。この関数はWOLFSSL構造体のoptionsフィールドのserver_psk_tls13_cbメンバーを設定します。
12910
12911    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12912    \param [in] cb TLS 1.3サーバー用の事前共有鍵(PSK)コールバック。
12913
12914    _Example_
12915    \code
12916    WOLFSSL* ssl;
12917    ...
12918    wolfSSL_set_psk_server_tls13_callback(ssl, my_psk_server_tls13_cb);
12919    \endcode
12920
12921    \sa wolfSSL_CTX_set_psk_client_tls13_callback
12922    \sa wolfSSL_set_psk_client_tls13_callback
12923    \sa wolfSSL_CTX_set_psk_server_tls13_callback
12924*/
12925void wolfSSL_set_psk_server_tls13_callback(WOLFSSL* ssl,
12926    wc_psk_server_tls13_callback cb);
12927
12928/*!
12929    \ingroup Setup
12930
12931    \brief この関数は鍵ペアの生成を含む、グループから鍵共有エントリを作成します。KeyShare拡張には鍵交換用に生成されたすべての公開鍵が含まれます。この関数が呼び出されると、指定されたグループのみが含まれます。サーバーに対して優先グループが以前に確立されている場合に、この関数を呼び出します。
12932
12933    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12934    \param [in] group 鍵交換グループ識別子。
12935
12936    \return BAD_FUNC_ARG sslがNULLの場合。
12937    \return MEMORY_E 動的メモリ割り当てが失敗した場合。
12938    \return WOLFSSL_SUCCESS 成功した場合。
12939
12940    _Example_
12941    \code
12942    int ret;
12943    WOLFSSL* ssl;
12944    ...
12945    ret = wolfSSL_UseKeyShare(ssl, WOLFSSL_ECC_X25519);
12946    if (ret != WOLFSSL_SUCCESS) {
12947        // 鍵共有の設定に失敗しました
12948    }
12949    \endcode
12950
12951    \sa wolfSSL_preferred_group
12952    \sa wolfSSL_CTX_set1_groups_list
12953    \sa wolfSSL_set1_groups_list
12954    \sa wolfSSL_CTX_set_groups
12955    \sa wolfSSL_set_groups
12956    \sa wolfSSL_NoKeyShares
12957*/
12958int wolfSSL_UseKeyShare(WOLFSSL* ssl, word16 group);
12959
12960/*!
12961    \ingroup Setup
12962
12963    \brief この関数はClientHelloで鍵共有が送信されないようにするために呼び出されます。これにより、ハンドシェイクで鍵交換が必要な場合、サーバーはHelloRetryRequestで応答することになります。期待される鍵交換グループが不明で、不要な鍵の生成を避けたい場合にこの関数を呼び出します。鍵交換が必要な場合、ハンドシェイクを完了するために追加のラウンドトリップが必要になることに注意してください。
12964
12965    \param [in,out] ssl wolfSSL_new()を使用して作成されたWOLFSSL構造体へのポインタ。
12966
12967    \return BAD_FUNC_ARG sslがNULLの場合。
12968    \return SIDE_ERROR サーバーで呼び出された場合。
12969    \return WOLFSSL_SUCCESS 成功した場合。
12970
12971    _Example_
12972    \code
12973    int ret;
12974    WOLFSSL* ssl;
12975    ...
12976    ret = wolfSSL_NoKeyShares(ssl);
12977    if (ret != WOLFSSL_SUCCESS) {
12978        // 鍵共有なしの設定に失敗しました
12979    }
12980    \endcode
12981
12982    \sa wolfSSL_UseKeyShare
12983*/
12984int wolfSSL_NoKeyShares(WOLFSSL* ssl);
12985
12986/*!
12987    \ingroup Setup
12988
12989    \brief この関数はアプリケーションがサーバーであり、TLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。
12990
12991    \param [in] heap 静的メモリアロケータが動的メモリ割り当て時に使用するバッファへのポインタ。
12992
12993    \return 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
12994    \return FAIL XMALLOCの呼び出し時にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
12995
12996    _Example_
12997    \code
12998    #include <wolfssl/ssl.h>
12999
13000    WOLFSSL_METHOD* method;
13001    WOLFSSL_CTX* ctx;
13002
13003    method = wolfTLSv1_3_server_method_ex(NULL);
13004    if (method == NULL) {
13005        // メソッドの取得ができません
13006    }
13007
13008    ctx = wolfSSL_CTX_new(method);
13009    ...
13010    \endcode
13011
13012    \sa wolfSSLv3_server_method
13013    \sa wolfTLSv1_server_method
13014    \sa wolfTLSv1_1_server_method
13015    \sa wolfTLSv1_2_server_method
13016    \sa wolfTLSv1_3_server_method
13017    \sa wolfDTLSv1_server_method
13018    \sa wolfSSLv23_server_method
13019    \sa wolfSSL_CTX_new
13020*/
13021WOLFSSL_METHOD *wolfTLSv1_3_server_method_ex(void* heap);
13022
13023/*!
13024    \ingroup Setup
13025
13026    \brief この関数はアプリケーションがクライアントであり、TLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体のメモリを割り当て、初期化します。
13027
13028    \param [in] heap 静的メモリアロケータが動的メモリ割り当て時に使用するバッファへのポインタ。
13029
13030    \return 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
13031    \return FAIL XMALLOCの呼び出し時にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常はNULLで、errnoがENOMEMに設定されます)。
13032
13033    _Example_
13034    \code
13035    #include <wolfssl/ssl.h>
13036
13037    WOLFSSL_METHOD* method;
13038    WOLFSSL_CTX* ctx;    method = wolfTLSv1_3_client_method_ex(NULL);
13039    if (method == NULL) {
13040        // メソッドを取得できません
13041    }
13042
13043    ctx = wolfSSL_CTX_new(method);
13044    ...
13045    \endcode
13046
13047    \sa wolfSSLv3_client_method
13048    \sa wolfTLSv1_client_method
13049    \sa wolfTLSv1_1_client_method
13050    \sa wolfTLSv1_2_client_method
13051    \sa wolfTLSv1_3_client_method
13052    \sa wolfDTLSv1_client_method
13053    \sa wolfSSLv23_client_method
13054    \sa wolfSSL_CTX_new
13055*/
13056WOLFSSL_METHOD *wolfTLSv1_3_client_method_ex(void* heap);
13057
13058/*!
13059    \ingroup Setup
13060
13061    \brief この関数は、アプリケーションがサーバーであり、TLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体用のメモリを割り当て、初期化します。
13062
13063    \return 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
13064    \return FAIL XMALLOC呼び出し時にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常、errnoがENOMEMに設定されたNULL)。
13065
13066    _Example_
13067    \code
13068    #include <wolfssl/ssl.h>
13069
13070    WOLFSSL_METHOD* method;
13071    WOLFSSL_CTX* ctx;
13072
13073    method = wolfTLSv1_3_server_method();
13074    if (method == NULL) {
13075        // メソッドを取得できません
13076    }
13077
13078    ctx = wolfSSL_CTX_new(method);
13079    ...
13080    \endcode
13081
13082    \sa wolfSSLv3_server_method
13083    \sa wolfTLSv1_server_method
13084    \sa wolfTLSv1_1_server_method
13085    \sa wolfTLSv1_2_server_method
13086    \sa wolfTLSv1_3_server_method_ex
13087    \sa wolfDTLSv1_server_method
13088    \sa wolfSSLv23_server_method
13089    \sa wolfSSL_CTX_new
13090*/
13091WOLFSSL_METHOD *wolfTLSv1_3_server_method(void);
13092
13093/*!
13094    \ingroup Setup
13095
13096    \brief この関数は、アプリケーションがクライアントであり、TLS 1.3プロトコルのみをサポートすることを示すために使用されます。この関数は、wolfSSL_CTX_new()でSSL/TLSコンテキストを作成する際に使用される新しいwolfSSL_METHOD構造体用のメモリを割り当て、初期化します。
13097
13098    \return 成功した場合、呼び出しは新しく作成されたWOLFSSL_METHOD構造体へのポインタを返します。
13099    \return FAIL XMALLOC呼び出し時にメモリ割り当てが失敗した場合、基礎となるmalloc()実装の失敗値が返されます(通常、errnoがENOMEMに設定されたNULL)。
13100
13101    _Example_
13102    \code
13103    #include <wolfssl/ssl.h>
13104
13105    WOLFSSL_METHOD* method;
13106    WOLFSSL_CTX* ctx;
13107
13108    method = wolfTLSv1_3_client_method();
13109    if (method == NULL) {
13110        // メソッドを取得できません
13111    }
13112
13113    ctx = wolfSSL_CTX_new(method);
13114    ...
13115    \endcode
13116
13117    \sa wolfSSLv3_client_method
13118    \sa wolfTLSv1_client_method
13119    \sa wolfTLSv1_1_client_method
13120    \sa wolfTLSv1_2_client_method
13121    \sa wolfTLSv1_3_client_method_ex
13122    \sa wolfDTLSv1_client_method
13123    \sa wolfSSLv23_client_method
13124    \sa wolfSSL_CTX_new
13125*/
13126WOLFSSL_METHOD *wolfTLSv1_3_client_method(void);
13127
13128/*!
13129    \ingroup Setup
13130
13131    \brief この関数は、どちら側(サーバー/クライアント)であるかがまだ決定されていないことを除いて、wolfTLSv1_3_client_methodと同様のWOLFSSL_METHODを返します。
13132
13133    \param [in] heap 静的メモリアロケータが動的メモリ割り当て中に使用するバッファへのポインタ。
13134
13135    \return WOLFSSL_METHOD 正常に作成された場合、WOLFSSL_METHODポインタを返します。
13136    \return NULL メモリ割り当てエラーまたはメソッドの作成に失敗した場合はNull。
13137
13138    _Example_
13139    \code
13140    WOLFSSL* ctx;
13141    ctx  = wolfSSL_CTX_new(wolfTLSv1_3_method_ex(NULL));
13142    // ret値を確認
13143    \endcode
13144
13145    \sa wolfSSL_new
13146    \sa wolfSSL_free
13147*/
13148WOLFSSL_METHOD *wolfTLSv1_3_method_ex(void* heap);
13149
13150/*!
13151    \ingroup Setup
13152
13153    \brief この関数は、どちら側(サーバー/クライアント)であるかがまだ決定されていないことを除いて、wolfTLSv1_3_client_methodと同様のWOLFSSL_METHODを返します。
13154
13155    \return WOLFSSL_METHOD 正常に作成された場合、WOLFSSL_METHODポインタを返します。
13156    \return NULL メモリ割り当てエラーまたはメソッドの作成に失敗した場合はNull。
13157
13158    _Example_
13159    \code
13160    WOLFSSL* ctx;
13161    ctx  = wolfSSL_CTX_new(wolfTLSv1_3_method());
13162    // ret値を確認
13163    \endcode
13164
13165    \sa wolfSSL_new
13166    \sa wolfSSL_free
13167*/
13168WOLFSSL_METHOD *wolfTLSv1_3_method(void);
13169
13170/*!
13171 \ingroup SSL
13172 \brief この関数は、テスト専用の固定/静的エフェメラル鍵を設定します。
13173 \return 0 鍵が正常にロードされました。
13174 \param ctx WOLFSSL_CTXコンテキストポインタ。
13175 \param keyAlgo WC_PK_TYPE_DHやWC_PK_TYPE_ECDHなどのenum wc_PkType。
13176 \param key 鍵ファイルパス(keySz == 0の場合)または実際の鍵バッファ(PEMまたはASN.1)。
13177 \param keySz 鍵サイズ("key"引数がファイルパスの場合は0である必要があります)。
13178 \param format WOLFSSL_FILETYPE_ASN1またはWOLFSSL_FILETYPE_PEM。
13179 \sa wolfSSL_CTX_get_ephemeral_key
13180 */
13181int wolfSSL_CTX_set_ephemeral_key(WOLFSSL_CTX* ctx, int keyAlgo, const char* key, unsigned int keySz, int format);
13182
13183/*!
13184 \ingroup SSL
13185 \brief この関数は、テスト専用の固定/静的エフェメラル鍵を設定します。
13186 \return 0 鍵が正常にロードされました。
13187 \param ssl WOLFSSLオブジェクトポインタ。
13188 \param keyAlgo WC_PK_TYPE_DHやWC_PK_TYPE_ECDHなどのenum wc_PkType。
13189 \param key 鍵ファイルパス(keySz == 0の場合)または実際の鍵バッファ(PEMまたはASN.1)。
13190 \param keySz 鍵サイズ("key"引数がファイルパスの場合は0である必要があります)。
13191 \param format WOLFSSL_FILETYPE_ASN1またはWOLFSSL_FILETYPE_PEM。
13192 \sa wolfSSL_get_ephemeral_key
13193 */
13194int wolfSSL_set_ephemeral_key(WOLFSSL* ssl, int keyAlgo, const char* key, unsigned int keySz, int format);
13195
13196/*!
13197 \ingroup SSL
13198 \brief この関数は、ASN.1/DERとしてロードされた鍵へのポインタを返します。
13199 \return 0 鍵が正常に返されました。
13200 \param ctx WOLFSSL_CTXコンテキストポインタ。
13201 \param keyAlgo WC_PK_TYPE_DHやWC_PK_TYPE_ECDHなどのenum wc_PkType。
13202 \param key 鍵バッファポインタ。
13203 \param keySz 鍵サイズポインタ。
13204 \sa wolfSSL_CTX_set_ephemeral_key
13205 */
13206int wolfSSL_CTX_get_ephemeral_key(WOLFSSL_CTX* ctx, int keyAlgo,
13207    const unsigned char** key, unsigned int* keySz);
13208
13209/*!
13210 \ingroup SSL
13211 \brief この関数は、ASN.1/DERとしてロードされた鍵へのポインタを返します。
13212 \return 0 鍵が正常に返されました。
13213 \param ssl WOLFSSLオブジェクトポインタ。
13214 \param keyAlgo WC_PK_TYPE_DHやWC_PK_TYPE_ECDHなどのenum wc_PkType。
13215 \param key 鍵バッファポインタ。
13216 \param keySz 鍵サイズポインタ。
13217 \sa wolfSSL_set_ephemeral_key
13218 */
13219int wolfSSL_get_ephemeral_key(WOLFSSL* ssl, int keyAlgo,
13220    const unsigned char** key, unsigned int* keySz);
13221
13222/*!
13223 \ingroup SSL
13224 \brief 選択したメッセージダイジェスト、パディング、およびRSA鍵でメッセージに署名します。
13225 \return WOLFSSL_SUCCESS 成功時、エラー時はc。
13226 \param hashAlg ハッシュNID。
13227 \param hash 署名するメッセージ。おそらくこれは署名するメッセージのダイジェストになります。
13228 \param hLen 署名するメッセージの長さ。
13229 \param sigRet 出力バッファ。
13230 \param sigLen 入力時: sigRetバッファの長さ、出力時: sigRetに書き込まれたデータの長さ。
13231 \param rsa 入力の署名に使用されるRSA鍵。
13232 \param flag 1: 署名を出力、0: パディングされていない署名と比較すべき値を出力。注意: RSA_PKCS1_PSS_PADDINGの場合、*Verify*関数の出力をチェックするためにwc_RsaPSS_CheckPadding_ex関数を使用する必要があります。
13233 \param padding 使用するパディング。現在、署名にはRSA_PKCS1_PSS_PADDINGとRSA_PKCS1_PADDINGのみがサポートされています。
13234 */
13235int wolfSSL_RSA_sign_generic_padding(int hashAlg, const unsigned char* hash,
13236                               unsigned int hLen, unsigned char* sigRet,
13237                               unsigned int* sigLen, WOLFSSL_RSA* rsa,
13238                               int flag, int padding);
13239/*!
13240
13241\brief DTLSv1.3スタックが送信したが、まだ他のピアから確認応答されていないメッセージがあるかどうかをチェックします。
13242
13243 \return 1 保留中のメッセージがある場合、それ以外は0。
13244 \param ssl WOLFSSLオブジェクトポインタ。
13245*/
13246int wolfSSL_dtls13_has_pending_msg(WOLFSSL *ssl);
13247
13248/*!
13249    \ingroup SSL
13250    \brief セッションからEarly Dataの最大サイズを取得します。
13251
13252    \param [in] s WOLFSSL_SESSIONインスタンス。
13253
13254    \return セッションが派生したWOLFSSL*で設定されたmax_early_dataの値。
13255
13256    \sa wolfSSL_set_max_early_data
13257    \sa wolfSSL_write_early_data
13258    \sa wolfSSL_read_early_data
13259 */
13260unsigned int wolfSSL_SESSION_get_max_early_data(const WOLFSSL_SESSION *s);
13261
13262/*!
13263    \ingroup SSL
13264    \brief 外部データ用の新しいインデックスを取得します。このエントリは以下のAPIにも適用されます:
13265           - wolfSSL_CTX_get_ex_new_index
13266           - wolfSSL_get_ex_new_index
13267           - wolfSSL_SESSION_get_ex_new_index
13268           - wolfSSL_X509_get_ex_new_index
13269
13270    \param [in] class_index 外部データインデックスが適用されるオブジェクトクラスの識別子。wolfSSLでは無視されます。
13271    \param [in] argl 互換性のために渡されるオプションのlong型引数。wolfSSLでは無視されます。
13272    \param [in] argp 互換性のために渡されるオプションのポインタ型引数。wolfSSLでは無視されます。
13273    \param [in] new_func 外部データコンストラクタコールバックへのポインタ。wolfSSLでは無視されます。
13274    \param [in] dup_func 外部データ複製コールバックへのポインタ。wolfSSLでは無視されます。
13275    \param [in] free_func 外部データデストラクタコールバックへのポインタ。wolfSSLでは無視されます。
13276
13277    \return このオブジェクトクラスの外部データAPIで使用される新しいインデックス値。
13278 */
13279int wolfSSL_CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
13280                                    WOLFSSL_CRYPTO_EX_new* new_func,
13281                                    WOLFSSL_CRYPTO_EX_dup* dup_func,
13282                                    WOLFSSL_CRYPTO_EX_free* free_func);
13283
13284/*!
13285 \ingroup Setup
13286 \brief この関数がクライアント側で呼び出された場合、ピアに送信できる証明書タイプを設定します。サーバー側で呼び出された場合、ピアから受け入れ可能な証明書タイプを設定します。優先順位の高い順にバッファに証明書タイプを格納します。設定をデフォルトにリセットするには、bufにNULLを渡すか、lenに0を渡します。デフォルトでは、証明書タイプはX509のみです。両側が"Raw public key"証明書を送信または受け入れることを意図している場合、WOLFSSL_CERT_TYPE_RPKをバッファに含めて設定する必要があります。
13287
13288 \return WOLFSSL_SUCCESS 証明書タイプが正常に設定された場合。
13289 \return BAD_FUNC_ARG ctxにNULLが渡された場合、証明書タイプとして不正な値が指定された場合、bufサイズがMAX_CLIENT_CERT_TYPE_CNTを超えた場合、またはbuf内に重複する値が見つかった場合。
13290
13291 \param ctx WOLFSSL_CTXオブジェクトポインタ。
13292 \param buf 証明書タイプが格納されるバッファ。
13293 \param len bufサイズ(バイト単位)(含まれる証明書タイプの数と同じ)。
13294    _Example_
13295 \code
13296  int ret;
13297  WOLFSSL_CTX* ctx;
13298  char buf[] = {WOLFSSL_CERT_TYPE_RPK, WOLFSSL_CERT_TYPE_X509};
13299  int len = sizeof(buf)/sizeof(char);
13300  ...
13301
13302  ret = wolfSSL_CTX_set_client_cert_type(ctx, buf, len);
13303 \endcode
13304 \sa wolfSSL_set_client_cert_type
13305 \sa wolfSSL_CTX_set_server_cert_type
13306 \sa wolfSSL_set_server_cert_type
13307 \sa wolfSSL_get_negotiated_client_cert_type
13308 \sa wolfSSL_get_negotiated_server_cert_type
13309 */
13310int wolfSSL_CTX_set_client_cert_type(WOLFSSL_CTX* ctx, const char* buf, int len);
13311
13312/*!
13313 \ingroup Setup
13314 \brief この関数がサーバー側で呼び出された場合、ピアに送信できる証明書タイプを設定します。クライアント側で呼び出された場合、ピアから受け入れ可能な証明書タイプを設定します。優先順位の高い順にバッファに証明書タイプを格納します。設定をデフォルトにリセットするには、bufにNULLを渡すか、lenに0を渡します。デフォルトでは、証明書タイプはX509のみです。両側が"Raw public key"証明書を送信または受け入れることを意図している場合、WOLFSSL_CERT_TYPE_RPKをバッファに含めて設定する必要があります。
13315
13316 \return WOLFSSL_SUCCESS 証明書タイプが正常に設定された場合。
13317 \return BAD_FUNC_ARG ctxにNULLが渡された場合、証明書タイプとして不正な値が指定された場合、bufサイズがMAX_SERVER_CERT_TYPE_CNTを超えた場合、またはbuf内に重複する値が見つかった場合。
13318
13319 \param ctx WOLFSSL_CTXオブジェクトポインタ。
13320 \param buf 証明書タイプが格納されるバッファ。
13321 \param len bufサイズ(バイト単位)(含まれる証明書タイプの数と同じ)。
13322    _Example_
13323 \code
13324  int ret;
13325  WOLFSSL_CTX* ctx;
13326  char buf[] = {WOLFSSL_CERT_TYPE_RPK, WOLFSSL_CERT_TYPE_X509};
13327  int len = sizeof(buf)/sizeof(char);
13328  ...
13329
13330  ret = wolfSSL_CTX_set_server_cert_type(ctx, buf, len);
13331 \endcode
13332 \sa wolfSSL_set_client_cert_type
13333 \sa wolfSSL_CTX_set_client_cert_type
13334 \sa wolfSSL_set_server_cert_type
13335 \sa wolfSSL_get_negotiated_client_cert_type
13336 \sa wolfSSL_get_negotiated_server_cert_type
13337 */
13338int wolfSSL_CTX_set_server_cert_type(WOLFSSL_CTX* ctx, const char* buf, int len);
13339
13340/*!
13341 \ingroup Setup
13342 \brief この関数がクライアント側で呼び出された場合、ピアに送信できる証明書タイプを設定します。サーバー側で呼び出された場合、ピアから受け入れ可能な証明書タイプを設定します。優先順位の高い順にバッファに証明書タイプを格納します。設定をデフォルトにリセットするには、bufにNULLを渡すか、lenに0を渡します。デフォルトでは、証明書タイプはX509のみです。両側が"Raw public key"証明書を送信または受け入れることを意図している場合、WOLFSSL_CERT_TYPE_RPKをバッファに含めて設定する必要があります。
13343
13344 \return WOLFSSL_SUCCESS 証明書タイプが正常に設定された場合。
13345 \return BAD_FUNC_ARG ctxにNULLが渡された場合、証明書タイプとして不正な値が指定された場合、bufサイズがMAX_CLIENT_CERT_TYPE_CNTを超えた場合、またはbuf内に重複する値が見つかった場合。
13346
13347 \param ssl WOLFSSLオブジェクトポインタ。
13348 \param buf 証明書タイプが格納されるバッファ。
13349 \param len bufサイズ(バイト単位)(含まれる証明書タイプの数と同じ)。
13350    _Example_
13351 \code
13352  int ret;
13353  WOLFSSL* ssl;
13354  char buf[] = {WOLFSSL_CERT_TYPE_RPK, WOLFSSL_CERT_TYPE_X509};
13355  int len = sizeof(buf)/sizeof(char);
13356  ...
13357
13358  ret = wolfSSL_set_client_cert_type(ssl, buf, len);
13359 \endcode
13360 \sa wolfSSL_CTX_set_client_cert_type
13361 \sa wolfSSL_CTX_set_server_cert_type
13362 \sa wolfSSL_set_server_cert_type
13363 \sa wolfSSL_get_negotiated_client_cert_type
13364 \sa wolfSSL_get_negotiated_server_cert_type
13365 */
13366int wolfSSL_set_client_cert_type(WOLFSSL* ssl, const char* buf, int len);
13367
13368/*!
13369 \ingroup Setup
13370 \brief この関数がサーバー側で呼び出された場合、ピアに送信できる証明書タイプを設定します。クライアント側で呼び出された場合、ピアから受け入れ可能な証明書タイプを設定します。優先順位の高い順にバッファに証明書タイプを格納します。設定をデフォルトにリセットするには、bufにNULLを渡すか、lenに0を渡します。デフォルトでは、証明書タイプはX509のみです。両側が"Raw public key"証明書を送信または受け入れることを意図している場合、WOLFSSL_CERT_TYPE_RPKをバッファに含めて設定する必要があります。
13371
13372 \return WOLFSSL_SUCCESS 証明書タイプが正常に設定された場合。
13373 \return BAD_FUNC_ARG ctxにNULLが渡された場合、証明書タイプとして不正な値が指定された場合、bufサイズがMAX_SERVER_CERT_TYPE_CNTを超えた場合、またはbuf内に重複する値が見つかった場合。
13374
13375 \param ctx WOLFSSL_CTXオブジェクトポインタ。
13376 \param buf 証明書タイプが格納されるバッファ。
13377 \param len bufサイズ(バイト単位)(含まれる証明書タイプの数と同じ)。
13378    _Example_
13379 \code
13380  int ret;  WOLFSSL* ssl;
13381  char buf[] = {WOLFSSL_CERT_TYPE_RPK, WOLFSSL_CERT_TYPE_X509};
13382  int len = sizeof(buf)/sizeof(char);
13383  ...
13384
13385  ret = wolfSSL_set_server_cert_type(ssl, buf, len);
13386 \endcode
13387 \sa wolfSSL_set_client_cert_type
13388 \sa wolfSSL_CTX_set_server_cert_type
13389 \sa wolfSSL_set_server_cert_type
13390 \sa wolfSSL_get_negotiated_client_cert_type
13391 \sa wolfSSL_get_negotiated_server_cert_type
13392 */
13393int wolfSSL_set_server_cert_type(WOLFSSL* ssl, const char* buf, int len);
13394
13395/*!
13396    \ingroup Setup
13397
13398    \brief 指定されたWOLFSSL_CTXコンテキストに対してハンドシェイクメッセージグループ化を有効にします。
13399
13400    この関数は、指定されたコンテキストから作成されたすべてのSSLオブジェクトに対してハンドシェイクメッセージグループ化をオンにします。
13401
13402    \return WOLFSSL_SUCCESS 成功時。
13403    \return BAD_FUNC_ARG ctxがNULLの場合。
13404
13405    \param ctx WOLFSSL_CTX構造体へのポインタ。
13406
13407    _Example_
13408    \code
13409    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method());
13410    wolfSSL_CTX_set_group_messages(ctx);
13411    \endcode
13412
13413    \sa wolfSSL_CTX_clear_group_messages
13414    \sa wolfSSL_set_group_messages
13415    \sa wolfSSL_clear_group_messages
13416*/
13417int wolfSSL_CTX_set_group_messages(WOLFSSL_CTX* ctx);
13418
13419/*!
13420    \ingroup Setup
13421
13422    \brief 指定されたWOLFSSL_CTXコンテキストに対してハンドシェイクメッセージグループ化を無効にします。
13423
13424    この関数は、指定されたコンテキストから作成されたすべてのSSLオブジェクトに対してハンドシェイクメッセージグループ化をオフにします。
13425
13426    \return WOLFSSL_SUCCESS 成功時。
13427    \return BAD_FUNC_ARG ctxがNULLの場合。
13428
13429    \param ctx WOLFSSL_CTX構造体へのポインタ。
13430
13431    _Example_
13432    \code
13433    WOLFSSL_CTX* ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method());
13434    wolfSSL_CTX_clear_group_messages(ctx);
13435    \endcode
13436
13437    \sa wolfSSL_CTX_set_group_messages
13438    \sa wolfSSL_set_group_messages
13439    \sa wolfSSL_clear_group_messages
13440*/
13441int wolfSSL_CTX_clear_group_messages(WOLFSSL_CTX* ctx);
13442
13443/*!
13444    \ingroup Setup
13445
13446    \brief 指定されたWOLFSSLオブジェクトに対してハンドシェイクメッセージグループ化を有効にします。
13447
13448    この関数は、指定されたSSLオブジェクトに対してハンドシェイクメッセージグループ化をオンにします。
13449
13450    \return WOLFSSL_SUCCESS 成功時。
13451    \return BAD_FUNC_ARG sslがNULLの場合。
13452
13453    \param ssl WOLFSSL構造体へのポインタ。
13454
13455    _Example_
13456    \code
13457    WOLFSSL* ssl = wolfSSL_new(ctx);
13458    wolfSSL_set_group_messages(ssl);
13459    \endcode
13460
13461    \sa wolfSSL_clear_group_messages
13462    \sa wolfSSL_CTX_set_group_messages
13463    \sa wolfSSL_CTX_clear_group_messages
13464*/
13465int wolfSSL_set_group_messages(WOLFSSL* ssl);
13466
13467/*!
13468    \ingroup Setup
13469
13470    \brief 指定されたWOLFSSLオブジェクトに対してハンドシェイクメッセージグループ化を無効にします。
13471
13472    この関数は、指定されたSSLオブジェクトに対してハンドシェイクメッセージグループ化をオフにします。
13473
13474    \return WOLFSSL_SUCCESS 成功時。
13475    \return BAD_FUNC_ARG sslがNULLの場合。
13476
13477    \param ssl WOLFSSL構造体へのポインタ。
13478
13479    _Example_
13480    \code
13481    WOLFSSL* ssl = wolfSSL_new(ctx);
13482    wolfSSL_clear_group_messages(ssl);
13483    \endcode
13484
13485    \sa wolfSSL_set_group_messages
13486    \sa wolfSSL_CTX_set_group_messages
13487    \sa wolfSSL_CTX_clear_group_messages
13488*/
13489int wolfSSL_clear_group_messages(WOLFSSL* ssl);
13490
13491/*!
13492 \ingroup SSL
13493 \brief この関数は、ClientHelloとServerHelloで行われたクライアント証明書タイプネゴシエーションの結果を返します。ネゴシエーションが発生しなかった場合、戻り値としてWOLFSSL_SUCCESSが返され、証明書タイプとしてWOLFSSL_CERT_TYPE_UNKNOWNが返されます。
13494
13495 \return WOLFSSL_SUCCESS ネゴシエートされた証明書タイプを取得できた場合。
13496 \return BAD_FUNC_ARG ctxまたはtpにNULLが渡された場合。
13497 \param ssl WOLFSSLオブジェクトポインタ。
13498 \param tp 証明書タイプが返されるバッファ。次の3つの証明書タイプのいずれかが返されます:WOLFSSL_CERT_TYPE_RPK、WOLFSSL_CERT_TYPE_X509、またはWOLFSSL_CERT_TYPE_UNKNOWN。
13499
13500    _Example_
13501 \code
13502  int ret;
13503  WOLFSSL* ssl;
13504  int tp;
13505  ...
13506
13507  ret = wolfSSL_get_negotiated_client_cert_type(ssl, &tp);
13508 \endcode
13509 \sa wolfSSL_set_client_cert_type
13510 \sa wolfSSL_CTX_set_client_cert_type
13511 \sa wolfSSL_set_server_cert_type
13512 \sa wolfSSL_CTX_set_server_cert_type
13513 \sa wolfSSL_get_negotiated_server_cert_type
13514 */
13515int wolfSSL_get_negotiated_client_cert_type(WOLFSSL* ssl, int* tp);
13516
13517/*!
13518 \ingroup SSL
13519 \brief この関数は、ClientHelloとServerHelloで行われたサーバ証明書タイプネゴシエーションの結果を返します。ネゴシエーションが発生しなかった場合、戻り値としてWOLFSSL_SUCCESSが返され、証明書タイプとしてWOLFSSL_CERT_TYPE_UNKNOWNが返されます。
13520
13521 \return WOLFSSL_SUCCESS ネゴシエートされた証明書タイプを取得できた場合。
13522 \return BAD_FUNC_ARG ctxまたはtpにNULLが渡された場合。
13523 \param ssl WOLFSSLオブジェクトポインタ。
13524 \param tp 証明書タイプが返されるバッファ。次の3つの証明書タイプのいずれかが返されます:WOLFSSL_CERT_TYPE_RPK、WOLFSSL_CERT_TYPE_X509、またはWOLFSSL_CERT_TYPE_UNKNOWN。
13525    _Example_
13526 \code
13527  int ret;
13528  WOLFSSL* ssl;
13529  int tp;
13530　...
13531
13532  ret = wolfSSL_get_negotiated_server_cert_type(ssl, &tp);
13533 \endcode
13534 \sa wolfSSL_set_client_cert_type
13535 \sa wolfSSL_CTX_set_client_cert_type
13536 \sa wolfSSL_set_server_cert_type
13537 \sa wolfSSL_CTX_set_server_cert_type
13538 \sa wolfSSL_get_negotiated_client_cert_type
13539 */
13540int wolfSSL_get_negotiated_server_cert_type(WOLFSSL* ssl, int* tp);
13541
13542/*!
13543
13544\brief SSLオブジェクトに対してConnectionID拡張の使用を有効にします。RFC 9146およびRFC 9147を参照してください。
13545
13546 \return WOLFSSL_SUCCESS 成功時、それ以外の場合はエラーコード。
13547
13548 \param ssl WOLFSSLオブジェクトポインタ。
13549
13550 \sa wolfSSL_dtls_cid_is_enabled
13551 \sa wolfSSL_dtls_cid_set
13552 \sa wolfSSL_dtls_cid_get_rx_size
13553 \sa wolfSSL_dtls_cid_get_rx
13554 \sa wolfSSL_dtls_cid_get_tx_size
13555 \sa wolfSSL_dtls_cid_get_tx
13556*/
13557int wolfSSL_dtls_cid_use(WOLFSSL* ssl);
13558
13559/*!
13560
13561\brief ハンドシェイク完了後に呼び出された場合、SSLオブジェクトに対してConnectionIDが正常にネゴシエートされたかどうかを確認します。RFC 9146およびRFC 9147を参照してください。
13562
13563 \return 1 ConnectionIDが正しくネゴシエートされた場合、それ以外は0。
13564
13565 \param ssl WOLFSSLオブジェクトポインタ。
13566
13567 \sa wolfSSL_dtls_cid_use
13568 \sa wolfSSL_dtls_cid_set
13569 \sa wolfSSL_dtls_cid_get_rx_size
13570 \sa wolfSSL_dtls_cid_get_rx
13571 \sa wolfSSL_dtls_cid_get_tx_size
13572 \sa wolfSSL_dtls_cid_get_tx
13573*/
13574int wolfSSL_dtls_cid_is_enabled(WOLFSSL* ssl);
13575
13576/*!
13577
13578\brief この接続でレコードを送信する際に相手ピアが使用するConnectionIDを設定します。RFC 9146およびRFC 9147を参照してください。ConnectionIDは最大DTLS_CID_MAX_SIZE(調整可能なコンパイル時定義)である必要があり、255バイトを超えることはできません。
13579
13580 \return WOLFSSL_SUCCESS ConnectionIDが正しく設定された場合、それ以外の場合はエラーコード。
13581
13582 \param ssl WOLFSSLオブジェクトポインタ。
13583 \param cid 使用するConnectionID。
13584 \param size 提供されたConnectionIDのサイズ。
13585
13586 \sa wolfSSL_dtls_cid_use
13587 \sa wolfSSL_dtls_cid_is_enabled
13588 \sa wolfSSL_dtls_cid_get_rx_size
13589 \sa wolfSSL_dtls_cid_get_rx
13590 \sa wolfSSL_dtls_cid_get_tx_size
13591 \sa wolfSSL_dtls_cid_get_tx
13592*/
13593int wolfSSL_dtls_cid_set(WOLFSSL* ssl, unsigned char* cid,
13594    unsigned int size);
13595
13596/*!
13597
13598\brief この接続でレコードを送信する際に相手ピアが使用するConnectionIDのサイズを取得します。RFC 9146およびRFC 9147を参照してください。サイズはパラメータsizeに格納されます。
13599
13600 \return WOLFSSL_SUCCESS ConnectionIDが正しくネゴシエートされた場合、それ以外の場合はエラーコード。
13601
13602 \param ssl WOLFSSLオブジェクトポインタ。
13603 \param size サイズが格納される符号なしint型へのポインタ。
13604
13605 \sa wolfSSL_dtls_cid_use
13606 \sa wolfSSL_dtls_cid_is_enabled
13607 \sa wolfSSL_dtls_cid_set
13608 \sa wolfSSL_dtls_cid_get_rx
13609 \sa wolfSSL_dtls_cid_get_tx_size
13610 \sa wolfSSL_dtls_cid_get_tx
13611*/
13612int wolfSSL_dtls_cid_get_rx_size(WOLFSSL* ssl,
13613    unsigned int* size);
13614
13615/*!
13616
13617\brief この接続でレコードを送信する際に相手ピアが使用するConnectionIDを、パラメータbufferが指すバッファにコピーします。RFC 9146およびRFC 9147を参照してください。bufferSzでバッファ内の利用可能なスペースを提供する必要があります。
13618
13619 \return WOLFSSL_SUCCESS ConnectionIDが正しくコピーされた場合、それ以外の場合はエラーコード。
13620
13621 \param ssl WOLFSSLオブジェクトポインタ。
13622 \param buffer ConnectionIDがコピーされるバッファ。
13623 \param bufferSz buffer内の利用可能なスペース。
13624
13625 \sa wolfSSL_dtls_cid_get0_rx
13626 \sa wolfSSL_dtls_cid_use
13627 \sa wolfSSL_dtls_cid_is_enabled
13628 \sa wolfSSL_dtls_cid_set
13629 \sa wolfSSL_dtls_cid_get_rx_size
13630 \sa wolfSSL_dtls_cid_get_tx_size
13631 \sa wolfSSL_dtls_cid_get_tx
13632*/
13633int wolfSSL_dtls_cid_get_rx(WOLFSSL* ssl, unsigned char* buffer,
13634    unsigned int bufferSz);
13635
13636/*!
13637
13638\brief 相手ピアが使用するConnectionIDを取得します。RFC 9146およびRFC 9147を参照してください。
13639
13640 \return WOLFSSL_SUCCESS ConnectionIDがcidに正しく設定された場合。
13641
13642 \param ssl WOLFSSLオブジェクトポインタ。
13643 \param cid CIDを保持する内部メモリに設定されるポインタ。
13644
13645 \sa wolfSSL_dtls_cid_get_rx
13646 \sa wolfSSL_dtls_cid_use
13647 \sa wolfSSL_dtls_cid_is_enabled
13648 \sa wolfSSL_dtls_cid_set
13649 \sa wolfSSL_dtls_cid_get_rx_size
13650 \sa wolfSSL_dtls_cid_get_tx_size
13651 \sa wolfSSL_dtls_cid_get_tx
13652*/
13653int wolfSSL_dtls_cid_get0_rx(WOLFSSL* ssl, unsigned char** cid);
13654
13655/*!
13656
13657\brief この接続でレコードを送信する際に使用するConnectionIDのサイズを取得します。RFC 9146およびRFC 9147を参照してください。サイズはパラメータsizeに格納されます。
13658
13659 \return WOLFSSL_SUCCESS ConnectionIDサイズが正しく格納された場合、それ以外の場合はエラーコード。
13660
13661 \param ssl WOLFSSLオブジェクトポインタ。
13662 \param size サイズが格納される符号なしint型へのポインタ。
13663
13664 \sa wolfSSL_dtls_cid_use
13665 \sa wolfSSL_dtls_cid_is_enabled
13666 \sa wolfSSL_dtls_cid_set
13667 \sa wolfSSL_dtls_cid_get_rx_size
13668 \sa wolfSSL_dtls_cid_get_rx
13669 \sa wolfSSL_dtls_cid_get_tx
13670*/
13671int wolfSSL_dtls_cid_get_tx_size(WOLFSSL* ssl, unsigned int* size);
13672
13673/*!
13674
13675\brief この接続でレコードを送信する際に使用するConnectionIDを、パラメータbufferが指すバッファにコピーします。RFC 9146およびRFC 9147を参照してください。bufferSzで利用可能なサイズを提供する必要があります。
13676
13677 \return WOLFSSL_SUCCESS ConnectionIDが正しくコピーされた場合、それ以外の場合はエラーコード。
13678
13679 \param ssl WOLFSSLオブジェクトポインタ。
13680 \param buffer ConnectionIDがコピーされるバッファ。
13681 \param bufferSz buffer内の利用可能なスペース。
13682
13683 \sa wolfSSL_dtls_cid_get0_tx
13684 \sa wolfSSL_dtls_cid_use
13685 \sa wolfSSL_dtls_cid_is_enabled
13686 \sa wolfSSL_dtls_cid_set
13687 \sa wolfSSL_dtls_cid_get_rx_size
13688 \sa wolfSSL_dtls_cid_get_rx
13689 \sa wolfSSL_dtls_cid_get_tx_size
13690*/
13691int wolfSSL_dtls_cid_get_tx(WOLFSSL* ssl, unsigned char* buffer,
13692    unsigned int bufferSz);
13693
13694/*!
13695
13696\brief この接続でレコードを送信する際に使用するConnectionIDを取得します。RFC 9146およびRFC 9147を参照してください。
13697
13698 \return WOLFSSL_SUCCESS ConnectionIDが正しく取得された場合、それ以外の場合はエラーコード。
13699
13700 \param ssl WOLFSSLオブジェクトポインタ。
13701 \param cid CIDを保持する内部メモリに設定されるポインタ。
13702
13703 \sa wolfSSL_dtls_cid_get_tx
13704 \sa wolfSSL_dtls_cid_use
13705 \sa wolfSSL_dtls_cid_is_enabled
13706 \sa wolfSSL_dtls_cid_set
13707 \sa wolfSSL_dtls_cid_get_rx_size
13708 \sa wolfSSL_dtls_cid_get_rx
13709 \sa wolfSSL_dtls_cid_get_tx_size
13710*/
13711int wolfSSL_dtls_cid_get0_tx(WOLFSSL* ssl, unsigned char** cid);
13712
13713/*!
13714
13715\brief レコードデータグラム/メッセージからConnectionIDを抽出します。RFC 9146およびRFC 9147を参照してください。
13716
13717 \param msg ネットワークから読み取られたデータグラムを保持するバッファ。
13718 \param msgSz msgのサイズ(バイト単位)。
13719 \param cid msgバッファ内のCIDの開始位置へのポインタ。
13720 \param cidSz 期待されるCIDのサイズ。レコード層にはCIDサイズフィールドがないため、CIDのサイズを事前に知っている必要があります。すべての接続に定数CIDを使用することを推奨します。
13721
13722 \sa wolfSSL_dtls_cid_get_tx
13723 \sa wolfSSL_dtls_cid_use
13724 \sa wolfSSL_dtls_cid_is_enabled
13725 \sa wolfSSL_dtls_cid_set
13726 \sa wolfSSL_dtls_cid_get_rx_size
13727 \sa wolfSSL_dtls_cid_get_rx
13728 \sa wolfSSL_dtls_cid_get_tx_size
13729*/
13730const unsigned char* wolfSSL_dtls_cid_parse(const unsigned char* msg,
13731        unsigned int msgSz, unsigned int cidSz);
13732
13733/*!
13734    \ingroup TLS
13735    \brief サーバ側では、この関数は証明書要求でクライアントに送信されるCA名のリストを設定します。これは、サーバがサポートするCAのヒントとして機能します。
13736
13737    クライアント側では、この関数は効果がありません。
13738
13739    \param [in] ctx wolfSSLコンテキストへのポインタ。
13740    \param [in] names 設定される名前のリスト。
13741
13742    \sa wolfSSL_set_client_CA_list
13743    \sa wolfSSL_CTX_get_client_CA_list
13744    \sa wolfSSL_get_client_CA_list
13745    \sa wolfSSL_CTX_set0_CA_list
13746    \sa wolfSSL_set0_CA_list    \sa wolfSSL_CTX_get0_CA_list
13747    \sa wolfSSL_get0_CA_list
13748    \sa wolfSSL_get0_peer_CA_list
13749*/
13750void wolfSSL_CTX_set_client_CA_list(WOLFSSL_CTX* ctx,
13751                                    WOLF_STACK_OF(WOLFSSL_X509_NAME)* names);
13752
13753/*!
13754    \ingroup TLS
13755    \brief これは、wolfSSL_CTX_set_client_CA_listを介して以前に設定されたリストを取得します。リストが設定されていない場合はNULLを返します。
13756
13757    \param [in] ctx wolfSSLコンテキストへのポインタ。
13758    \return CA名を含むWOLFSSL_X509_NAMEのスタック。
13759
13760    \sa wolfSSL_set_client_CA_list
13761    \sa wolfSSL_CTX_set_client_CA_list
13762    \sa wolfSSL_get_client_CA_list
13763    \sa wolfSSL_CTX_set0_CA_list
13764    \sa wolfSSL_set0_CA_list
13765    \sa wolfSSL_CTX_get0_CA_list
13766    \sa wolfSSL_get0_CA_list
13767    \sa wolfSSL_get0_peer_CA_list
13768*/
13769WOLFSSL_STACK *wolfSSL_CTX_get_client_CA_list(
13770        const WOLFSSL_CTX *ctx);
13771
13772/*!
13773    \ingroup TLS
13774    \brief wolfSSL_CTX_set_client_CA_listと同じですが、セッション固有です。CAリストがコンテキストとセッションの両方に設定されている場合、セッション上のリストが使用されます。
13775
13776    \param [in] ssl WOLFSSLオブジェクトへのポインタ。
13777    \param [in] names 設定する名前のリスト。
13778
13779    \sa wolfSSL_CTX_set_client_CA_list
13780    \sa wolfSSL_CTX_get_client_CA_list
13781    \sa wolfSSL_get_client_CA_list
13782    \sa wolfSSL_CTX_set0_CA_list
13783    \sa wolfSSL_set0_CA_list
13784    \sa wolfSSL_CTX_get0_CA_list
13785    \sa wolfSSL_get0_CA_list
13786    \sa wolfSSL_get0_peer_CA_list
13787*/
13788void wolfSSL_set_client_CA_list(WOLFSSL* ssl,
13789                                    WOLF_STACK_OF(WOLFSSL_X509_NAME)* names);
13790
13791/*!
13792    \ingroup TLS
13793    \brief サーバ側では、wolfSSL_set_client_CA_listを介して以前に設定されたリストを取得します。何も設定されていない場合は、wolfSSL_CTX_set_client_CA_listを介して以前に設定されたリストを返します。リストが全く設定されていない場合は、NULLを返します。
13794
13795    クライアント側では、サーバから受信したリストを取得します。何も受信していない場合はNULLを返します。wolfSSL_CTX_set_cert_cbを使用して、サーバから証明書要求を受信したときに証明書を動的にロードするコールバックを登録できます。
13796
13797    \param [in] ssl WOLFSSLオブジェクトへのポインタ。
13798    \return CA名を含むWOLFSSL_X509_NAMEのスタック。
13799
13800    \sa wolfSSL_CTX_set_cert_cb
13801    \sa wolfSSL_CTX_set_client_CA_list
13802    \sa wolfSSL_CTX_get_client_CA_list
13803    \sa wolfSSL_get_client_CA_list
13804    \sa wolfSSL_CTX_set0_CA_list
13805    \sa wolfSSL_set0_CA_list
13806    \sa wolfSSL_CTX_get0_CA_list
13807    \sa wolfSSL_get0_CA_list
13808    \sa wolfSSL_get0_peer_CA_list
13809*/
13810WOLFSSL_STACK* wolfSSL_get_client_CA_list(
13811            const WOLFSSL* ssl);
13812
13813/*!
13814    \ingroup TLS
13815    \brief この関数は、ピアの認証でサポートされているCAのヒントとしてピアに送信されるCA名のリストを設定します。
13816
13817    TLS >= 1.3では、これはクライアントとサーバ間の両方向でサポートされています。サーバ側では、CA名はCertificateRequestの一部として送信されるため、この関数は*_set_client_CA_listと同等です。クライアント側では、これらはClientHelloの一部として送信されます。
13818
13819    TLS < 1.3では、クライアントからサーバへのCA名の送信はサポートされていないため、この関数はwolfSSL_CTX_set_client_CA_listと同等です。
13820
13821    *_set_client_CA_listと*_set0_CA_listを介して設定されたリストは内部的に別々であることに注意してください。つまり、*_get_client_CA_listを呼び出しても*_set0_CA_listを介して設定されたリストは取得されず、その逆も同様です。両方が設定されている場合、サーバはクライアントにCA名を送信する際に*_set0_CA_listを無視します。
13822
13823    \param [in] ctx wolfSSLコンテキストへのポインタ。
13824    \param [in] names 設定する名前のリスト。
13825
13826    \sa wolfSSL_CTX_set_client_CA_list
13827    \sa wolfSSL_set_client_CA_list
13828    \sa wolfSSL_CTX_get_client_CA_list
13829    \sa wolfSSL_get_client_CA_list
13830    \sa wolfSSL_set0_CA_list
13831    \sa wolfSSL_CTX_get0_CA_list
13832    \sa wolfSSL_get0_CA_list
13833    \sa wolfSSL_get0_peer_CA_list
13834*/
13835void wolfSSL_CTX_set0_CA_list(WOLFSSL_CTX *ctx,
13836        WOLF_STACK_OF(WOLFSSL_X509_NAME)* names);
13837
13838/*!
13839    \ingroup TLS
13840    \brief これは、wolfSSL_CTX_set0_CA_listを介して以前に設定されたリストを取得します。リストが設定されていない場合はNULLを返します。
13841
13842    \param [in] ctx wolfSSLコンテキストへのポインタ。
13843    \return CA名を含むWOLFSSL_X509_NAMEのスタック。
13844
13845    \sa wolfSSL_CTX_set_client_CA_list
13846    \sa wolfSSL_set_client_CA_list
13847    \sa wolfSSL_CTX_get_client_CA_list
13848    \sa wolfSSL_get_client_CA_list
13849    \sa wolfSSL_CTX_set0_CA_list
13850    \sa wolfSSL_set0_CA_list
13851    \sa wolfSSL_get0_CA_list
13852    \sa wolfSSL_get0_peer_CA_list
13853*/
13854WOLFSSL_STACK *wolfSSL_CTX_get0_CA_list(
13855        const WOLFSSL_CTX *ctx);
13856
13857/*!
13858    \ingroup TLS
13859    \brief wolfSSL_CTX_set0_CA_listと同じですが、セッション固有です。CAリストがコンテキストとセッションの両方に設定されている場合、セッション上のリストが使用されます。
13860
13861    \param [in] ssl WOLFSSLオブジェクトへのポインタ。
13862    \param [in] names 設定する名前のリスト。
13863
13864    \sa wolfSSL_CTX_set_client_CA_list
13865    \sa wolfSSL_set_client_CA_list
13866    \sa wolfSSL_CTX_get_client_CA_list
13867    \sa wolfSSL_get_client_CA_list
13868    \sa wolfSSL_CTX_set0_CA_list
13869    \sa wolfSSL_CTX_get0_CA_list
13870    \sa wolfSSL_get0_CA_list
13871    \sa wolfSSL_get0_peer_CA_list
13872*/
13873void wolfSSL_set0_CA_list(WOLFSSL *ssl,
13874        WOLF_STACK_OF(WOLFSSL_X509_NAME) *names);
13875
13876/*!
13877    \ingroup TLS
13878    \brief これは、wolfSSL_set0_CA_listを介して以前に設定されたリストを取得します。何も設定されていない場合は、wolfSSL_CTX_set0_CA_listを介して以前に設定されたリストを返します。リストが全く設定されていない場合は、NULLを返します。
13879
13880    \param [in] ssl WOLFSSLオブジェクトへのポインタ。
13881    \return CA名を含むWOLFSSL_X509_NAMEのスタック。
13882
13883    \sa wolfSSL_CTX_set_client_CA_list
13884    \sa wolfSSL_set_client_CA_list
13885    \sa wolfSSL_CTX_get_client_CA_list
13886    \sa wolfSSL_get_client_CA_list
13887    \sa wolfSSL_CTX_set0_CA_list
13888    \sa wolfSSL_set0_CA_list
13889    \sa wolfSSL_CTX_get0_CA_list
13890    \sa wolfSSL_get0_peer_CA_list
13891*/
13892WOLFSSL_STACK *wolfSSL_get0_CA_list(
13893        const WOLFSSL *ssl);
13894
13895/*!
13896    \ingroup TLS
13897    \brief これは、ピアから受信したCAリストを返します。
13898
13899    クライアント側では、これはサーバがCertificateRequestで送信したリストであり、この関数はwolfSSL_get_client_CA_listと同等です。
13900
13901    サーバ側では、これはTLS >= 1.3でクライアントがClientHelloメッセージで送信したリストです。TLS < 1.3では、この関数はサーバ側で常にNULLを返します。
13902
13903    wolfSSL_CTX_set_cert_cbを使用して、ピアからCAリストを受信したときに証明書を動的にロードするコールバックを登録できます。
13904
13905    \param [in] ssl WOLFSSLオブジェクトへのポインタ。
13906    \return CA名を含むWOLFSSL_X509_NAMEのスタック。
13907
13908    \sa wolfSSL_CTX_set_cert_cb
13909    \sa wolfSSL_CTX_set_client_CA_list
13910    \sa wolfSSL_set_client_CA_list
13911    \sa wolfSSL_CTX_get_client_CA_list
13912    \sa wolfSSL_get_client_CA_list
13913    \sa wolfSSL_CTX_set0_CA_list
13914    \sa wolfSSL_set0_CA_list
13915    \sa wolfSSL_CTX_get0_CA_list
13916    \sa wolfSSL_get0_CA_list
13917*/
13918WOLFSSL_STACK *wolfSSL_get0_peer_CA_list(const WOLFSSL *ssl);
13919
13920/*!
13921    \ingroup TLS
13922    \brief この関数は、証明書が使用される直前に呼び出されるコールバックを設定し、アプリケーションが証明書を検査、設定、またはクリアできるようにします。例えば、ピアから送信されたCAリストに反応することができます。
13923
13924    \param [in] ctx wolfSSLコンテキストへのポインタ。
13925    \param [in] cb コールバックへの関数ポインタ。
13926    \param [in] arg コールバックに渡されるポインタ。
13927
13928    \sa wolfSSL_get0_peer_CA_list
13929    \sa wolfSSL_get_client_CA_list
13930*/
13931void wolfSSL_CTX_set_cert_cb(WOLFSSL_CTX* ctx,
13932    int (*cb)(WOLFSSL *, void *), void *arg);
13933
13934/*!
13935    \ingroup TLS
13936
13937    \brief この関数は、クライアントが提供する暗号スイートと署名アルゴリズムの生のリストを返します。リストは、wolfSSL_CTX_set_cert_cb()で設定されたコールバック内でのみ保存され、返されます。これは、利用可能な暗号スイートと署名アルゴリズムに基づいて証明書と鍵を動的にロードできるようにするのに便利です。
13938
13939    \param [in] ssl リストを抽出するWOLFSSLオブジェクト。
13940    \param [out] suites クライアント暗号スイートの生のフィルタリングされていないリスト。利用可能なスイートがない場合はNULLになることがあります。
13941    \param [out] suiteSz suitesのサイズ(バイト単位)。
13942    \param [out] hashSigAlgo クライアント署名アルゴリズムの生のフィルタリングされていないリスト。提供されない場合はNULLになることがあります。
13943    \param [out] hashSigAlgoSz hashSigAlgoのサイズ(バイト単位)。
13944    \return WOLFSSL_SUCCESS スイートが利用可能な場合。
13945    \return WOLFSSL_FAILURE スイートが利用できない場合。
13946
13947    _Example_
13948    \code
13949    int certCB(WOLFSSL* ssl, void* arg)
13950    {
13951        const byte* suites = NULL;
13952        word16 suiteSz = 0;
13953        const byte* hashSigAlgo = NULL;
13954        word16 hashSigAlgoSz = 0;
13955
13956        wolfSSL_get_client_suites_sigalgs(ssl, &suites, &suiteSz, &hashSigAlgo,
13957                &hashSigAlgoSz);
13958
13959        // 暗号スイートとsigalgsに基づいてロードする証明書を選択
13960    }
13961
13962    WOLFSSL* ctx;
13963    ctx  = wolfSSL_CTX_new(wolfTLSv1_3_method_ex(NULL));
13964    wolfSSL_CTX_set_cert_cb(ctx, certCB, NULL);
13965    \endcode
13966
13967    \sa wolfSSL_get_ciphersuite_info
13968    \sa wolfSSL_get_sigalg_info
13969*/
13970int wolfSSL_get_client_suites_sigalgs(const WOLFSSL* ssl,
13971        const byte** suites, word16* suiteSz,
13972        const byte** hashSigAlgo, word16* hashSigAlgoSz);
13973
13974/*!
13975    \ingroup TLS
13976
13977    \brief これは、生の暗号スイートバイトから直接暗号スイートに関する情報を返します。
13978
13979    \param [in] first 暗号スイートの最初のバイト。
13980    \param [in] second 暗号スイートの2番目のバイト。
13981
13982    \return WOLFSSL_CIPHERSUITE_INFO 暗号スイートで使用される認証のタイプに関する情報を含む構造体。
13983
13984    _Example_
13985    \code
13986    WOLFSSL_CIPHERSUITE_INFO info =
13987            wolfSSL_get_ciphersuite_info(suites[0], suites[1]);
13988    if (info.rsaAuth)
13989        haveRSA = 1;
13990    else if (info.eccAuth)
13991        haveECC = 1;
13992    \endcode
13993
13994    \sa wolfSSL_get_client_suites_sigalgs
13995    \sa wolfSSL_get_sigalg_info
13996*/
13997WOLFSSL_CIPHERSUITE_INFO wolfSSL_get_ciphersuite_info(byte first,
13998        byte second);
13999
14000/*!
14001    \ingroup TLS
14002
14003    \brief これは、生の暗号スイートバイトから直接ハッシュおよび署名アルゴリズムに関する情報を返します。
14004
14005    \param [in] first ハッシュおよび署名アルゴリズムの最初のバイト。
14006    \param [in] second ハッシュおよび署名アルゴリズムの2番目のバイト。
14007    \param [out] hashAlgo MACアルゴリズムのenum wc_HashType。
14008    \param [out] sigAlgo 認証アルゴリズムのenum Key_Sum。
14009
14010    \return 0            情報が正しく設定された場合。
14011    \return BAD_FUNC_ARG 入力パラメータのいずれかがNULLの場合、またはバイトが認識されるsigalgスイートでない場合。
14012
14013    _Example_
14014    \code
14015    enum wc_HashType hashAlgo;
14016    enum Key_Sum sigAlgo;
14017
14018    wolfSSL_get_sigalg_info(hashSigAlgo[idx+0], hashSigAlgo[idx+1],
14019            &hashAlgo, &sigAlgo);
14020
14021    if (sigAlgo == RSAk || sigAlgo == RSAPSSk)
14022        haveRSA = 1;
14023    else if (sigAlgo == ECDSAk)
14024        haveECC = 1;
14025    \endcode
14026
14027    \sa wolfSSL_get_client_suites_sigalgs
14028    \sa wolfSSL_get_ciphersuite_info
14029*/
14030int wolfSSL_get_sigalg_info(byte first, byte second,
14031        int* hashAlgo, int* sigAlgo);