openssl - en to fr translation catalogue (363 entries)

note: type: =head1
en: NAME
fr: NOM

note: type: =head1
en: EXAMPLES
fr: EXEMPLES

note: type: =head1
en: BUGS
fr: BOGUES

note: type: =head1
en: RETURN VALUES
fr: VALEURS DE RETOUR

note: type: textblock
en: See DESCRIPTION
fr: Consultez la section B<DESCRIPTION>

note: type: =head1
en: SEE ALSO
fr: VOIR AUSSI

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_get_current_cipher(3)|SSL_get_current_cipher(3)>, L<SSL_get_ciphers(3)|SSL_get_ciphers(3)>, L<ciphers(1)|ciphers(1)>, L<SSL_CTX_set_cipher_list(3)|SSL_CTX_set_cipher_list(3)>
fr: L<B<ssl>(3)|ssl(3)>, L<B<SSL_get_current_cipher>(3)|SSL_get_current_cipher(3)>, L<B<SSL_get_ciphers>(3)|SSL_get_ciphers(3)>, L<B<ciphers>(1)|ciphers(1)>, L<B<SSL_CTX_set_cipher_list>(3)|SSL_CTX_set_cipher_list(3)>

note: type: textblock
en: SSL_COMP_add_compression_method() adds the compression method B<cm> with the identifier B<id> to the list of available compression methods. This list is globally maintained for all SSL operations within this application.  It cannot be set for specific SSL_CTX or SSL objects.
fr: B<SSL_COMP_add_compression_method>() ajoute la méthode de compression I<cm> avec l'identifiant I<id> à la liste des méthodes de compression disponibles. Cette liste est maintenue globalement pour toutes les opérations SSL dans cette application. Elle ne peut pas être définie pour des objets SSL_CTX ou SSL spécifiques.

note: type: textblock
en: The TLS standard (or SSLv3) allows the integration of compression methods into the communication. The TLS RFC does however not specify compression methods or their corresponding identifiers, so there is currently no compatible way to integrate compression with unknown peers. It is therefore currently not recommended to integrate compression into applications. Applications for non-public use may agree on certain compression methods. Using different compression methods with the same identifier will lead to connection failure.
fr: La norme TLS (ou SSLv3) permet l'intégration des méthodes de compression dans la communication. La RFC TLS ne spécifie cependant pas de méthode de compression ni d'identifiant correspondant, il n'y a donc actuellement pas de moyen compatible d'intégrer la compression avec des pairs inconnus. Il n'est par conséquent pas recommandé d'intégrer actuellement la compression dans les applications. Les applications pour utilisation non publique pourraient se mettre d'accord sur certaines méthodes de compression. L'utilisation de différentes méthodes de compression avec le même identifiant aura pour conséquence un échec de connexion.

note: type: textblock
en: An OpenSSL client speaking a protocol that allows compression (SSLv3, TLSv1)  will unconditionally send the list of all compression methods enabled with SSL_COMP_add_compression_method() to the server during the handshake.  Unlike the mechanisms to set a cipher list, there is no method available to restrict the list of compression method on a per connection basis.
fr: Un client OpenSSL utilisant un protocole qui permet la compression (SSLv3, TLSv1) enverra sans condition la liste de toutes les méthodes de compression activées avec B<SSL_COMP_add_compression_method>() au serveur pendant l'initialisation de connexion. Contrairement aux mécanismes de définition de liste d'algorithmes de chiffrement, aucune méthode n'est disponible pour restreindre la liste des méthodes de compression en fonction de la connexion.

note: type: textblock
en: An OpenSSL server will match the identifiers listed by a client against its own compression methods and will unconditionally activate compression when a matching identifier is found. There is no way to restrict the list of compression methods supported on a per connection basis.
fr: Un serveur OpenSSL comparera les identifiants envoyés par un client avec ses propres méthodes de compression et activera sans condition la compression si un identifiant correspondant est trouvé. Restreindre la liste des méthodes de compression prises en charge en fonction de la connexion est impossible.

note: type: =head1
en: WARNINGS
fr: AVERTISSEMENTS

note: type: textblock
en: Once the identities of the compression methods for the TLS protocol have been standardized, the compression API will most likely be changed. Using it in the current state is not recommended.
fr: Une fois que les identités des méthodes de compression pour le protocole TLS auront été normalisées, l'interface de programmation sera sans doute modifiée. L'utiliser maintenant n'est pas recommandé.

note: type: textblock
en: SSL_COMP_add_compression_method() may return the following values:
fr: B<SSL_COMP_add_compression_method>() pourrait renvoyer les valeurs suivantes.

note: type: textblock
en: The operation succeeded.
fr: L'opération a réussi.

note: type: textblock
en: The operation failed. Check the error queue to find out the reason.
fr: L'opération a échoué. Vérifiez la file d'erreur pour découvrir la raison.

note: type: textblock
en: SSL_accept - wait for a TLS/SSL client to initiate a TLS/SSL handshake
fr: SSL_accept - Attendre qu'un client TLS/SSL initie une connexion TLS/SSL

note: type: textblock
en: SSL_accept() waits for a TLS/SSL client to initiate the TLS/SSL handshake.  The communication channel must already have been set and assigned to the B<ssl> by setting an underlying B<BIO>.
fr: B<SSL_accept>() attend qu'un client TLS/SSL initie une connexion TLS/SSL. Le canal de communication doit avoir déjà été défini et assigné à B<ssl> en définissant un B<BIO> sous-jacent.

note: type: textblock
en: The behaviour of SSL_accept() depends on the underlying BIO.
fr: Le comportement de B<SSL_accept>() dépend du BIO sous-jacent.

note: type: textblock
en: If the underlying BIO is B<blocking>, SSL_accept() will only return once the handshake has been finished or an error occurred.
fr: Si le BIO sous-jacent est B<bloquant>, B<SSL_accept>() ne s'arrêtera qu'une fois l'initiation de connexion terminée ou si une erreur survient.

note: type: textblock
en: If the underlying BIO is B<non-blocking>, SSL_accept() will also return when the underlying BIO could not satisfy the needs of SSL_accept()  to continue the handshake, indicating the problem by the return value -1.  In this case a call to SSL_get_error() with the return value of SSL_accept() will yield B<SSL_ERROR_WANT_READ> or B<SSL_ERROR_WANT_WRITE>. The calling process then must repeat the call after taking appropriate action to satisfy the needs of SSL_accept().  The action depends on the underlying BIO. When using a non-blocking socket, nothing is to be done, but select() can be used to check for the required condition. When using a buffering BIO, like a BIO pair, data must be written into or retrieved out of the BIO before being able to continue.
fr: Si le BIO sous-jacent est B<non bloquant>, B<SSL_accept>() s'arrêtera aussi si le BIO sous-jacent ne peut pas satisfaire les besoins de B<SSL_accept>() pour continuer l'initiation de connexion, indiquant le problème avec la valeur de retour -1. Dans ce cas, un appel de B<SSL_get_error>() avec la valeur de retour de B<SSL_accept>() renverra B<SSL_ERROR_WANT_READ> ou B<SSL_ERROR_WANT_WRITE>. Le processus appelant doit alors répéter l'appel après avoir pris les mesures nécessaires pour satisfaire les besoins de B<SSL_accept>(). L'action dépend du BIO sous-jacent. Lors de l'utilisation d'une socket non bloquante, il n'y a rien à faire, à part utiliser B<select>() pour vérifier la condition nécessaire. Lors de l'utilisation d'un BIO de type tampon, comme une paire de BIO, les données doivent être écrites ou récupérées du BIO avant de pouvoir continuer.

note: type: textblock
en: The following return values can occur:
fr: Les valeurs suivantes peuvent être renvoyées.

note: type: textblock
en: The TLS/SSL handshake was not successful but was shut down controlled and by the specifications of the TLS/SSL protocol. Call SSL_get_error() with the return value B<ret> to find out the reason.
fr: L'initiation de connexion TLS ou SSL n'a pas réussi mais a été arrêtée de façon contrôlée conformément aux spécifications des protocoles TLS ou SSL. Appelez B<SSL_get_error>() avec la valeur de retour B<ret> pour en connaître la raison.

note: type: textblock
en: The TLS/SSL handshake was successfully completed, a TLS/SSL connection has been established.
fr: L'initiation de connexion TLS ou SSL a réussi, une connexion TLS ou SSL a été établie.

note: type: textblock
en: The TLS/SSL handshake was not successful because a fatal error occurred either at the protocol level or a connection failure occurred. The shutdown was not clean. It can also occur of action is need to continue the operation for non-blocking BIOs. Call SSL_get_error() with the return value B<ret> to find out the reason.
fr: L'initiation de connexion TLS ou SSL n'a pas réussi soit à cause d'une erreur fatale survenue au niveau du protocole, soit à cause d'un échec de connexion. L'arrêt n'était pas propre. Cela peut aussi arriver si une action est nécessaire pour continuer l'opération pour les BIO non bloquants. Appelez B<SSL_get_error>() avec la valeur de retour B<ret> pour en connaître la raison.

note: type: textblock
en: SSL_clear - reset SSL object to allow another connection
fr: SSL_clear - Réinitialiser un objet SSL pour permettre une autre connexion

note: type: textblock
en: Reset B<ssl> to allow another connection. All settings (method, ciphers, BIOs) are kept.
fr: Réinitialiser B<ssl> pour permettre une autre connexion. Tous les réglages (méthode, algorithmes, BIO) sont gardés.

note: type: textblock
en: SSL_clear is used to prepare an SSL object for a new connection. While all settings are kept, a side effect is the handling of the current SSL session.  If a session is still B<open>, it is considered bad and will be removed from the session cache, as required by RFC2246. A session is considered open, if L<SSL_shutdown(3)|SSL_shutdown(3)> was not called for the connection or at least L<SSL_set_shutdown(3)|SSL_set_shutdown(3)> was used to set the SSL_SENT_SHUTDOWN state.
fr: SSL_clear est utilisée pour préparer un objet SSL pour une nouvelle connexion. Alors que tous les réglages sont gardés, un effet de bord est le traitement de la session SSL actuelle. Si une session est encore B<ouverte>, elle est considérée mauvaise et sera supprimée du cache de session, comme exigé par la RFC 2246. Une session est considérée ouverte si L<SSL_shutdown(3)|SSL_shutdown(3)> n'a pas été appelée pour la connexion ou en tout cas si L<SSL_set_shutdown(3)|SSL_set_shutdown(3)> a été utilisée pour envoyer l'état SSL_SENT_SHUTDOWN.

note: type: textblock
en: If a session was closed cleanly, the session object will be kept and all settings corresponding. This explicitly means, that e.g. the special method used during the session will be kept for the next handshake. So if the session was a TLSv1 session, a SSL client object will use a TLSv1 client method for the next handshake and a SSL server object will use a TLSv1 server method, even if SSLv23_*_methods were chosen on startup. This will might lead to connection failures (see L<SSL_new(3)|SSL_new(3)>)  for a description of the method's properties.
fr: Si une session a été fermée proprement, l'objet de session sera gardé avec tous les réglages correspondants. Cela signifie explicitement que, par exemple, la méthode spécifiquement utilisée pendant la session sera gardée pour la nouvelle initialisation. Donc s'il s'agissait d'une session TLSv1, un objet client SSL utilisera une méthode client TLSv1 pour l'initialisation suivante et un objet serveur SSL utilisera une méthode serveur TLSv1, même si SSLv23_*_methods avaient été choisies au démarrage. Cela pourrait conduire à des échecs de connexion (consultez L<SSL_new(3)|SSL_new(3)>) pour une description des propriétés de la méthode.

note: type: textblock
en: SSL_clear() resets the SSL object to allow for another connection. The reset operation however keeps several settings of the last sessions (some of these settings were made automatically during the last handshake). It only makes sense for a new connection with the exact same peer that shares these settings, and may fail if that peer changes its settings between connections. Use the sequence L<SSL_get_session(3)|SSL_get_session(3)>; L<SSL_new(3)|SSL_new(3)>; L<SSL_set_session(3)|SSL_set_session(3)>; L<SSL_free(3)|SSL_free(3)> instead to avoid such failures (or simply L<SSL_free(3)|SSL_free(3)>; L<SSL_new(3)|SSL_new(3)> if session reuse is not desired).
fr: B<SSL_clear>() réinitialise l'objet SSL pour permettre une autre connexion. L'opération de réinitialisation garde cependant plusieurs réglages de la session précédente (certains de ces réglages ont été faits automatiquement pendant l'initialisation précédente). Cela n'a de sens que pour une nouvelle connexion avec un pair aux réglages parfaitement identiques, et pourrait échouer si ce pair modifie ses réglages entre les connexions. Utilisez la séquence L<SSL_get_session(3)|SSL_get_session(3)> ; L<SSL_new(3)|SSL_new(3)> ; L<SSL_set_session(3)|SSL_set_session(3)> ; L<SSL_free(3)|SSL_free(3)> à la place pour éviter ces types d'échecs (ou simplement L<SSL_free(3)|SSL_free(3)> ; L<SSL_new(3)|SSL_new(3)> si la réutilisation de session n'est pas voulue).

note: type: textblock
en: The SSL_clear() operation could not be performed. Check the error stack to find out the reason.
fr: L'opération B<SSL_clear>() n'a pas pu être réalisée. Vérifiez la pile d'erreur pour découvrir la raison.

note: type: textblock
en: The SSL_clear() operation was successful.
fr: L'opération B<SSL_clear>() a réussi.

note: type: textblock
en: SSL_connect - initiate the TLS/SSL handshake with an TLS/SSL server
fr: SSL_connect - Démarrer l'initiation de connexion TLS ou SSL avec un serveur TLS ou SSL

note: type: textblock
en: SSL_connect() initiates the TLS/SSL handshake with a server. The communication channel must already have been set and assigned to the B<ssl> by setting an underlying B<BIO>.
fr: B<SSL_connect>() commence l'initiation de connexion TLS ou SSL avec un serveur. Le canal de communication doit avoir déjà été configuré et assigné à B<ssl> en configurant le B<BIO> sous-jacent.

note: type: textblock
en: The behaviour of SSL_connect() depends on the underlying BIO.
fr: Le comportement de B<SSL_connect>() dépend du BIO sous-jacent.

note: type: textblock
en: If the underlying BIO is B<blocking>, SSL_connect() will only return once the handshake has been finished or an error occurred.
fr: Si le BIO sous-jacent est B<bloquant>, B<SSL_connect>() ne s'arrêtera qu'une fois l'initiation de connexion terminée ou si une erreur survient.

note: type: textblock
en: If the underlying BIO is B<non-blocking>, SSL_connect() will also return when the underlying BIO could not satisfy the needs of SSL_connect()  to continue the handshake, indicating the problem by the return value -1.  In this case a call to SSL_get_error() with the return value of SSL_connect() will yield B<SSL_ERROR_WANT_READ> or B<SSL_ERROR_WANT_WRITE>. The calling process then must repeat the call after taking appropriate action to satisfy the needs of SSL_connect().  The action depends on the underlying BIO. When using a non-blocking socket, nothing is to be done, but select() can be used to check for the required condition. When using a buffering BIO, like a BIO pair, data must be written into or retrieved out of the BIO before being able to continue.
fr: Si le BIO sous-jacent est B<non bloquant>, B<SSL_connect>() s'arrêtera aussi si le BIO sous-jacent ne peut pas satisfaire les besoins de B<SSL_connect>() pour continuer l'initiation de connexion, indiquant le problème avec la valeur de retour -1. Dans ce cas, un appel de B<SSL_get_error>() avec la valeur de retour de B<SSL_connect>() renverra B<SSL_ERROR_WANT_READ> ou B<SSL_ERROR_WANT_WRITE>. Le processus appelant doit alors répéter l'appel après avoir pris les mesures nécessaires pour satisfaire les besoins de B<SSL_connect>(). L'action dépend du BIO sous-jacent. Lors de l'utilisation d'une socket non bloquante, il n'y a rien à faire, à part utiliser B<select>() pour vérifier la condition nécessaire. Lors de l'utilisation d'un BIO de type tampon, comme une paire de BIO, les données doivent être écrites ou récupérées du BIO avant de pouvoir continuer.

note: type: textblock
en: The TLS/SSL handshake was not successful, because a fatal error occurred either at the protocol level or a connection failure occurred. The shutdown was not clean. It can also occur of action is need to continue the operation for non-blocking BIOs. Call SSL_get_error() with the return value B<ret> to find out the reason.
fr: L'initiation de connexion TLS ou SSL n'a pas réussi, soit à cause d'une erreur fatale survenue au niveau du protocole, soit à cause d'un échec de connexion. L'arrêt n'était pas propre. Cela peut aussi arriver si une action est nécessaire pour continuer l'opération pour les BIO non bloquants. Appelez B<SSL_get_error>() avec la valeur de retour B<ret> pour en connaître la raison.

note: type: textblock
en: SSL_do_handshake - perform a TLS/SSL handshake
fr: SSL_do_handshake - Réaliser une initiation de connexion TLS ou SSL

note: type: textblock
en: SSL_do_handshake() will wait for a SSL/TLS handshake to take place. If the connection is in client mode, the handshake will be started. The handshake routines may have to be explicitly set in advance using either L<SSL_set_connect_state(3)|SSL_set_connect_state(3)> or L<SSL_set_accept_state(3)|SSL_set_accept_state(3)>.
fr: B<SSL_do_handshake>() attendra une initiation de connexion TLS ou SSL. Si la connexion est en mode client, l'initiation de connexion sera démarrée. Les routines d'initiation de connexion pourraient avoir besoin d'être définies explicitement au préalable en utilisant soit L<SSL_set_connect_state(3)|SSL_set_connect_state(3)>, soit L<SSL_set_accept_state(3)|SSL_set_accept_state(3)>.

note: type: textblock
en: The behaviour of SSL_do_handshake() depends on the underlying BIO.
fr: Le comportement de B<SSL_do_handshake>() dépend du BIO sous-jacent.

note: type: textblock
en: If the underlying BIO is B<blocking>, SSL_do_handshake() will only return once the handshake has been finished or an error occurred.
fr: Si le BIO sous-jacent est B<bloquant>, B<SSL_do_handshake>() ne s'arrêtera qu'une fois l'initiation de connexion terminée ou si une erreur survient.

note: type: textblock
en: If the underlying BIO is B<non-blocking>, SSL_do_handshake() will also return when the underlying BIO could not satisfy the needs of SSL_do_handshake()  to continue the handshake. In this case a call to SSL_get_error() with the return value of SSL_do_handshake() will yield B<SSL_ERROR_WANT_READ> or B<SSL_ERROR_WANT_WRITE>. The calling process then must repeat the call after taking appropriate action to satisfy the needs of SSL_do_handshake().  The action depends on the underlying BIO. When using a non-blocking socket, nothing is to be done, but select() can be used to check for the required condition. When using a buffering BIO, like a BIO pair, data must be written into or retrieved out of the BIO before being able to continue.
fr: Si le BIO sous-jacent est B<non bloquant>, B<SSL_do_handshake>() s'arrêtera aussi si le BIO sous-jacent ne peut pas satisfaire les besoins de B<SSL_do_handshake>() pour continuer l'initiation de connexion. Dans ce cas, un appel de B<SSL_get_error>() avec la valeur de retour de B<SSL_do_handshake>() renverra B<SSL_ERROR_WANT_READ> ou B<SSL_ERROR_WANT_WRITE>. Le processus appelant doit alors répéter l'appel après avoir pris les mesures nécessaires pour satisfaire les besoins de B<SSL_do_handshake>(). L'action dépend du BIO sous-jacent. Lors de l'utilisation d'une socket non bloquante, il n'y a rien à faire, à part utiliser B<select>() pour vérifier la condition nécessaire. Lors de l'utilisation d'un BIO de type tampon, comme une paire de BIO, les données doivent être écrites ou récupérées du BIO avant de pouvoir continuer.

note: type: textblock
en: SSL_free - free an allocated SSL structure
fr: SSL_free - Libérer une structure SSL allouée

note: type: textblock
en: SSL_free() decrements the reference count of B<ssl>, and removes the SSL structure pointed to by B<ssl> and frees up the allocated memory if the reference count has reached 0.
fr: SSL_free() décrémente le décompte de références de B<ssl> et retire la structure SSL pointée par B<ssl> et libère la mémoire allouée, si le décompte de références atteint 0.

note: type: textblock
en: SSL_free() also calls the free()ing procedures for indirectly affected items, if applicable: the buffering BIO, the read and write BIOs, cipher lists specially created for this B<ssl>, the B<SSL_SESSION>.  Do not explicitly free these indirectly freed up items before or after calling SSL_free(), as trying to free things twice may lead to program failure.
fr: SSL_free() appelle également les procédures free() pour les éléments alloués indirectement, qui peuvent être : les BIO tampons, les BIO de lecture ou écriture, les listes d'algorithmes de chiffrement spécialement créées pour la structure B<ssl>, la session B<SSL_SESSION>. Ne libérer pas ces éléments directement avant ou après l'appel à SSL_free() (essayer de libérer un objet deux fois peut conduire à des échecs du programme).

note: type: textblock
en: The ssl session has reference counts from two users: the SSL object, for which the reference count is removed by SSL_free() and the internal session cache. If the session is considered bad, because L<SSL_shutdown(3)|SSL_shutdown(3)> was not called for the connection and L<SSL_set_shutdown(3)|SSL_set_shutdown(3)> was not used to set the SSL_SENT_SHUTDOWN state, the session will also be removed from the session cache as required by RFC2246.
fr: La session ssl a des compteurs de références pour deux utilisation : pour l'objet SSL (son compteur de références est supprimé par SSL_free()) et le cache de sessions internes. Si la session est considérée comme une mauvaise session, parce que L<SSL_shutdown(3)|SSL_shutdown(3)> n'a pas été appelée pour la connexion et L<SSL_set_shutdown(3)|SSL_set_shutdown(3)> n'a pas été utilisée pour positionner l'état SSL_SENT_SHUTDOWN, la session sera également supprimée du cache de sessions comme décrit dans la RFC 2246.

note: type: textblock
en: SSL_free() does not provide diagnostic information.
fr: SSL_free() ne fournit pas de renseignements de diagnostic.

note: type: textblock
en: SSL_library_init, OpenSSL_add_ssl_algorithms, SSLeay_add_ssl_algorithms - initialize SSL library by registering algorithms
fr: SSL_library_init, OpenSSL_add_ssl_algorithms, SSLeay_add_ssl_algorithms - Initialiser la bibliothèque SSL par des algorithmes d'enregistrement

note: type: textblock
en: SSL_library_init() registers the available SSL/TLS ciphers and digests.
fr: B<SSL_library_init>() enregistre les algorithmes de chiffrement et de signature SSL ou TLS disponibles.

note: type: textblock
en: OpenSSL_add_ssl_algorithms() and SSLeay_add_ssl_algorithms() are synonyms for SSL_library_init().
fr: B<OpenSSL_add_ssl_algorithms>() et B<SSLeay_add_ssl_algorithms>() sont synonymes de B<SSL_library_init>().

note: type: textblock
en: SSL_library_init() must be called before any other action takes place.  SSL_library_init() is not reentrant.
fr: B<SSL_library_init>() doit être appelée avant toute autre action. B<SSL_library_init>() n'est pas rentrante.

note: type: =head1
en: WARNING
fr: AVERTISSEMENT

note: type: textblock
en: SSL_library_init() adds ciphers and digests used directly and indirectly by SSL/TLS.
fr: B<_library_init>() ajoute les algorithmes de chiffrement et de signature utilisés directement ou indirectement par SSL ou TLS.

note: type: textblock
en: A typical TLS/SSL application will start with the library initialization, and provide readable error messages.
fr: Une application TLS/SSL typique démarrera avec la bibliothèque d'initialisation et fournit des messages d'erreur lisibles.

note: type: verbatim
en:  SSL_load_error_strings();                /* readable error messages */
     SSL_library_init();                      /* initialize library */
fr:  SSL_load_error_strings();       /* messages d'erreur compréhensibles */
     SSL_library_init();             /* initialiser la bibliothèque */

note: type: textblock
en: SSL_library_init() always returns "1", so it is safe to discard the return value.
fr: B<SSL_library_init>() renvoie toujours « 1 », ignorer la valeur de retour est donc possible.

note: type: textblock
en: OpenSSL 0.9.8o and 1.0.0a and later added SHA2 algorithms to SSL_library_init().  Applications which need to use SHA2 in earlier versions of OpenSSL should call OpenSSL_add_all_algorithms() as well.
fr: OpenSSL 0.9.8o et 1.0.0a ainsi que les versions suivantes ont ajouté les algorithmes SHA2 à B<SSL_library_init>(). Les applications qui ont besoin d'utiliser SHA2 dans les versions précédentes d'OpenSSL devraient appeler aussi B<OpenSSL_add_all_algorithms>().

note: type: textblock
en: L<ssl(3)|ssl(3)>, L<SSL_load_error_strings(3)|SSL_load_error_strings(3)>, L<RAND_add(3)|RAND_add(3)>
fr: L<RAND_add(3)|RAND_add(3)>, L<ssl(3)|ssl(3)>, L<SSL_load_error_strings(3)|SSL_load_error_strings(3)>

note: type: textblock
en: SSL_new - create a new SSL structure for a connection
fr: SSL_new - Créer une nouvelle structure SSL pour une connexion

note: type: textblock
en: SSL_new() creates a new B<SSL> structure which is needed to hold the data for a TLS/SSL connection. The new structure inherits the settings of the underlying context B<ctx>: connection method (SSLv2/v3/TLSv1), options, verification settings, timeout settings.
fr: SSL_new() crée une nouvelle structure B<SSL> nécessaire pour conserver les données d'une connexion TLS/SSL. La nouvelle structure hérite des paramètres du contexte B<ctx> sous-jacent : la méthode de connexion (SSLv2/v3/TLSv1), options, paramètres de vérification, paramètres des temporisations.

note: type: textblock
en: The creation of a new SSL structure failed. Check the error stack to find out the reason.
fr: La création d'une structure SSL a échoué. Consultez la pile des erreurs pour trouver la raison.

note: type: =item
en: Pointer to an SSL structure
fr: Pointeur vers une structure SSL.

note: type: textblock
en: The return value points to an allocated SSL structure.
fr: La valeur de retour pointe vers une structure SSL allouée.

note: type: textblock
en: SSL_pending - obtain number of readable bytes buffered in an SSL object
fr: SSL_pending - Obtenir un nombre d'octets lisibles en tampon dans un objet SSL

note: type: textblock
en: SSL_pending() returns the number of bytes which are available inside B<ssl> for immediate read.
fr: B<SSL_pending>() renvoie le nombre d'octets disponibles dans B<ssl> pour lecture immédiate.

note: type: textblock
en: Data are received in blocks from the peer. Therefore data can be buffered inside B<ssl> and are ready for immediate retrieval with L<SSL_read(3)|SSL_read(3)>.
fr: Les données sont reçues en bloc du pair. Par conséquent les données peuvent être mise en tampon dans B<ssl> et être prêtes à être immédiatement récupérées avec L<SSL_read(3)|SSL_read(3)>.

note: type: textblock
en: The number of bytes pending is returned.
fr: Le nombre d'octets en attente est renvoyé.

note: type: textblock
en: SSL_pending() takes into account only bytes from the TLS/SSL record that is currently being processed (if any).  If the B<SSL> object's I<read_ahead> flag is set (see L<SSL_CTX_set_read_ahead(3)|SSL_CTX_set_read_ahead(3)>), additional protocol bytes may have been read containing more TLS/SSL records; these are ignored by SSL_pending().
fr: B<SSL_pending>() ne prend en compte que les octets de l'enregistrement TLS ou SSL en cours de traitement (s'il y en a un). Si l'attribut I<read_ahead> de l'objet B<SSL> est défini (consultez L<B<SSL_CTX_set_read_ahead>(3)SSL_CTX_set_read_ahead(3)>, des octets de protocole supplémentaires contenant plus d'enregistrements TLS ou SSL pourraient avoir été lus, ils sont ignorés par B<SSL_pending>().

note: type: textblock
en: Up to OpenSSL 0.9.6, SSL_pending() does not check if the record type of pending data is application data.
fr: Jusqu'à OpenSSL 0.9.6, B<SSL_pending>() ne vérifie pas si les données en attente ont un type d'enregistrement de données d'application.

note: type: textblock
en: L<SSL_read(3)|SSL_read(3)>, L<SSL_CTX_set_read_ahead(3)|SSL_CTX_set_read_ahead(3)>, L<ssl(3)|ssl(3)>
fr: L<B<SSL_read>(3)|SSL_read(3)>, L<B<SSL_CTX_set_read_ahead>(3)|SSL_CTX_set_read_ahead(3)>, L<B<ssl>(3)|ssl(3)>

note: type: textblock
en: SSL_state_string, SSL_state_string_long - get textual description of state of an SSL object
fr: SSL_state_string, SSL_state_string_long - Obtenir la description textuelle de l'état d'un objet SSL

note: type: textblock
en: SSL_state_string() returns a 6 letter string indicating the current state of the SSL object B<ssl>.
fr: B<SSL_state_string>() renvoie une chaîne de 6 lettres indiquant l'état actuel de l'objet SSL B<ssl>.

note: type: textblock
en: SSL_state_string_long() returns a string indicating the current state of the SSL object B<ssl>.
fr: B<SSL_state_string_long>() renvoie une chaîne indiquant l'état actuel de l'objet SSL B<ssl>.

note: type: textblock
en: During its use, an SSL objects passes several states. The state is internally maintained. Querying the state information is not very informative before or when a connection has been established. It however can be of significant interest during the handshake.
fr: Pendant son utilisation, un objet SSL passe par plusieurs états. L'état est maintenu en interne. La demande de renseignements d'état n'est pas très informative avant ou quand une connexion a été établie. Elle peut cependant être significativement intéressante pendant l'initialisation.

note: type: textblock
en: When using non-blocking sockets, the function call performing the handshake may return with SSL_ERROR_WANT_READ or SSL_ERROR_WANT_WRITE condition, so that SSL_state_string[_long]() may be called.
fr: Lors de l'utilisation de sockets non bloquantes, l'appel de fonction réalisant l'initialisation pourrait s'arrêter avec les conditions SSL_ERROR_WANT_READ ou SSL_ERROR_WANT_WRITE, de telle sorte que B<SSL_state_string>[B<_long>]() puisse être appelée.

note: type: textblock
en: For both blocking or non-blocking sockets, the details state information can be used within the info_callback function set with the SSL_set_info_callback() call.
fr: Pour les sockets bloquantes ou non bloquantes, les renseignements d'état détaillés peuvent être utilisés à l'intérieur de la fonction info_callback définie avec l'appel B<SSL_set_info_callback>().

note: type: textblock
en: Detailed description of possible states to be included later.
fr: Un description détaillée des états possibles sera ajoutée plus tard.

note: type: textblock
en: SSL_want, SSL_want_nothing, SSL_want_read, SSL_want_write, SSL_want_x509_lookup - obtain state information TLS/SSL I/O operation
fr: SSL_want, SSL_want_nothing, SSL_want_read, SSL_want_write, SSL_want_x509_lookup - Obtenir des informations d'état sur les opérations d'entrées et sorties TLS ou SSL

note: type: textblock
en: SSL_want() returns state information for the SSL object B<ssl>.
fr: B<SSL_want>() renvoie les informations d'état pour l'objet SSL B<ssl>.

note: type: textblock
en: The other SSL_want_*() calls are shortcuts for the possible states returned by SSL_want().
fr: Les autres appels B<SSL_want_>I<*>() sont des raccourcis pour les états possibles renvoyés par B<SSL_want>().

note: type: textblock
en: SSL_want() examines the internal state information of the SSL object. Its return values are similar to that of L<SSL_get_error(3)|SSL_get_error(3)>.  Unlike L<SSL_get_error(3)|SSL_get_error(3)>, which also evaluates the error queue, the results are obtained by examining an internal state flag only. The information must therefore only be used for normal operation under non-blocking I/O. Error conditions are not handled and must be treated using L<SSL_get_error(3)|SSL_get_error(3)>.
fr: B<SSL_want>() examine les renseignements d'état interne de l'objet SSL. Ses valeurs de retours sont similaires à celles de L<SSL_get_error(3)|SSL_get_error(3)>. Contrairement à L<SSL_get_error(3)|SSL_get_error(3)>, qui évalue aussi la file d'erreurs, les résultats sont obtenus en n'examinant que l'attribut d'état interne. Les renseignements ne doivent donc être qu'utilisés pour une opération normale sous entrées et sorties non bloquantes. Les conditions d'erreur ne sont pas gérées et doivent être traitées avec L<SSL_get_error(3)|SSL_get_error(3)>.

note: type: textblock
en: The result returned by SSL_want() should always be consistent with the result of L<SSL_get_error(3)|SSL_get_error(3)>.
fr: Le résultat renvoyé par B<SSL_want>() devrait toujours être cohérent avec celui de L<SSL_get_error(3)|SSL_get_error(3)>.

note: type: textblock
en: The following return values can currently occur for SSL_want():
fr: Les valeurs suivantes peuvent être actuellement renvoyées par B<SSL_want>().

note: type: textblock
en: There is no data to be written or to be read.
fr: Aucune donnée n'est en attente de lecture ou d'écriture.

note: type: textblock
en: There are data in the SSL buffer that must be written to the underlying B<BIO> layer in order to complete the actual SSL_*() operation.  A call to L<SSL_get_error(3)|SSL_get_error(3)> should return SSL_ERROR_WANT_WRITE.
fr: Des données dans le tampon SSL doivent être écrites dans la couche B<BIO> sous-jacente afin de terminer l'opération B<SSL_>I<*>() en cours. Un appel à L<SSL_get_error(3)|SSL_get_error(3)> devrait renvoyer SSL_ERROR_WANT_WRITE.

note: type: textblock
en: More data must be read from the underlying B<BIO> layer in order to complete the actual SSL_*() operation.  A call to L<SSL_get_error(3)|SSL_get_error(3)> should return SSL_ERROR_WANT_READ.
fr: Des données supplémentaires doivent être lues dans la couche B<BIO> sous-jacente afin de terminer l'opération B<SSL_>I<*>() en cours. Un appel à L<SSL_get_error(3)|SSL_get_error(3)> devrait renvoyer SSL_ERROR_WANT_READ.

note: type: textblock
en: The operation did not complete because an application callback set by SSL_CTX_set_client_cert_cb() has asked to be called again.  A call to L<SSL_get_error(3)|SSL_get_error(3)> should return SSL_ERROR_WANT_X509_LOOKUP.
fr: L'opération ne s'est pas terminée car un rappel d'application défini par B<SSL_CTX_set_client_cert_cb>() a demandé à être appelé de nouveau. Un appel à L<SSL_get_error(3)|SSL_get_error(3)> devrait renvoyer SSL_ERROR_WANT_X509_LOOKUP.

note: type: textblock
en: SSL_want_nothing(), SSL_want_read(), SSL_want_write(), SSL_want_x509_lookup()  return 1, when the corresponding condition is true or 0 otherwise.
fr: B<SSL_want_nothing>(), B<SSL_want_read>(), B<SSL_want_write>(), B<SSL_want_x509_lookup>() renvoient 1 quand la condition correspondante est vraie, 0 sinon.

note: type: textblock
en: SSL - OpenSSL SSL/TLS library
fr: SSL - Bibliothèque SSL/TLS OpenSSL

note: type: textblock
en: The OpenSSL B<ssl> library implements the Secure Sockets Layer (SSL v2/v3) and Transport Layer Security (TLS v1) protocols. It provides a rich API which is documented here.
fr: La bibliothèque B<ssl> OpenSSL implémente les protocoles « Secure Sockets Layer » (SSL v2/v3) et « Transport Layer Security » (TLS v1). Elle fournit une interface de programmation applicative (API) riche qui est documentée ici.

note: type: textblock
en: At first the library must be initialized; see L<SSL_library_init(3)|SSL_library_init(3)>.
fr: Tout d'abord, la bibliothèque doit être initialisée ; consultez L<SSL_library_init(3)|SSL_library_init(3)>.

note: type: textblock
en: Then an B<SSL_CTX> object is created as a framework to establish TLS/SSL enabled connections (see L<SSL_CTX_new(3)|SSL_CTX_new(3)>).  Various options regarding certificates, algorithms etc. can be set in this object.
fr: Ensuite un objet B<SSL_CTX> est créé en tant que cadre pour établir des connexions utilisant TLS/SSL (consultez L<SSL_CTX_new(3)|SSL_CTX_new(3)>). Différentes options concernant les certificats, I<algorithmes>, etc. peuvent être définies pour cet objet.

note: type: textblock
en: When a network connection has been created, it can be assigned to an B<SSL> object. After the B<SSL> object has been created using L<SSL_new(3)|SSL_new(3)>, L<SSL_set_fd(3)|SSL_set_fd(3)> or L<SSL_set_bio(3)|SSL_set_bio(3)> can be used to associate the network connection with the object.
fr: Une fois une connexion réseau créée, elle peut être attribuée à un objet B<SSL>. Après la création de l'objet SSL avec L<SSL_new(3)|SSL_new(3)>, L<SSL_set_fd(3)|SSL_set_fd(3)> ou L<SSL_set_bio(3)|SSL_set_bio(3)> peuvent être utilisés pour associer la connexion réseau avec l'objet.

note: type: textblock
en: Then the TLS/SSL handshake is performed using L<SSL_accept(3)|SSL_accept(3)> or L<SSL_connect(3)|SSL_connect(3)> respectively.  L<SSL_read(3)|SSL_read(3)> and L<SSL_write(3)|SSL_write(3)> are used to read and write data on the TLS/SSL connection.  L<SSL_shutdown(3)|SSL_shutdown(3)> can be used to shut down the TLS/SSL connection.
fr: Ensuite la poignée de main TLS/SSL est effectuée en utilisant respectivement L<SSL_accept(3)|SSL_accept(3)> ou L<SSL_connect(3)|SSL_connect(3)>. L<SSL_read(3)|SSL_read(3)> et L<SSL_write(3)|SSL_write(3)> sont utilisés pour lire et écrire les données dans la connexion TLS/SSL. L<SSL_shutdown(3)|SSL_shutdown(3)> peut être utilisé pour éteindre la connexion TLS/SSL.

note: type: =head1
en: DATA STRUCTURES
fr: STRUCTURES DE DONNÉES

note: type: textblock
en: Currently the OpenSSL B<ssl> library functions deals with the following data structures:
fr: Actuellement, les fonctions de la bibliothèque B<ssl> OpenSSL traitent des structures de données suivantes.

note: type: =item
en: B<SSL_METHOD> (SSL Method)
fr: B<SSL_METHOD> (Méthode SSL)

note: type: textblock
en: That's a dispatch structure describing the internal B<ssl> library methods/functions which implement the various protocol versions (SSLv1, SSLv2 and TLSv1). It's needed to create an B<SSL_CTX>.
fr: C'est une structure de distribution décrivant les méthodes et fonctions internes de la bibliothèque B<ssl> qui implémentent les différentes versions des protocoles (SSLv1, SSLv2 et TLSv1). C'est un acquis préalable à la création d'un B<SSL_CTX>.

note: type: =item
en: B<SSL_CIPHER> (SSL Cipher)
fr: B<SSL_CIPHER> (Chiffrement SSL)

note: type: textblock
en: This structure holds the algorithm information for a particular cipher which are a core part of the SSL/TLS protocol. The available ciphers are configured on a B<SSL_CTX> basis and the actually used ones are then part of the B<SSL_SESSION>.
fr: Cette structure contient les informations de l'algorithme pour un chiffrement particulier qui sont au centre du protocole SSL/TLS. Les chiffrements disponibles sont configurés dans un cadre B<SSL_CTX> et ceux effectivement utilisés font alors partie de B<SSL_SESSION>.

note: type: =item
en: B<SSL_CTX> (SSL Context)
fr: B<SSL_CTX> (Contexte SSL)

note: type: textblock
en: That's the global context structure which is created by a server or client once per program life-time and which holds mainly default values for the B<SSL> structures which are later created for the connections.
fr: C'est la structure globale de contexte qui est créée par un serveur ou un client une fois par durée de vie du programme et qui contient principalement les valeurs par défaut pour les structures B<SSL> qui sont ensuite créées pour les connexions.

note: type: =item
en: B<SSL_SESSION> (SSL Session)
fr: B<SSL_SESSION> (Session SSL)

note: type: textblock
en: This is a structure containing the current TLS/SSL session details for a connection: B<SSL_CIPHER>s, client and server certificates, keys, etc.
fr: C'est la structure contenant les détails de la session TLS/SSL courante  pour une connexion : les B<SSL_CIPHER>, les certificats client et serveur, les I<clés>, etc.

note: type: =item
en: B<SSL> (SSL Connection)
fr: B<SSL> (Connexion SSL)

note: type: textblock
en: That's the main SSL/TLS structure which is created by a server or client per established connection. This actually is the core structure in the SSL API.  Under run-time the application usually deals with this structure which has links to mostly all other structures.
fr: C'est la structure SSL/TLS principale qui est créée par un serveur ou client pour chaque connexion établie. Il s'agit en fait de la structure centrale de l'API SSL. Lors de l'exécution l'application traite majoritairement avec cette structure qui a des liens vers quasiment toutes les autres structures.

note: type: =head1
en: HEADER FILES
fr: FICHIERS D'EN-TÊTE

note: type: textblock
en: Currently the OpenSSL B<ssl> library provides the following C header files containing the prototypes for the data structures and and functions:
fr: Actuellement, la bibliothèque B<ssl> OpenSSL fournit les fichiers d'en-tête C suivants contenant les prototypes pour les structures de données et les fonctions suivantes.

note: type: textblock
en: That's the common header file for the SSL/TLS API.  Include it into your program to make the API of the B<ssl> library available. It internally includes both more private SSL headers and headers from the B<crypto> library.  Whenever you need hard-core details on the internals of the SSL API, look inside this header file.
fr: C'est le fichier d'en-tête commun pour l'API SSL/TLS. Incluez-le dans votre programme pour rendre l'API de la bibliothèque B<ssl> disponible. Il inclut en interne à la fois des fichiers d'en-tête privés SSL et d'en-tête de la bibliothèque B<crypto>. À chaque fois que vous avez besoin de détails précis sur les entrailles de l'API SSL, regardez à l'intérieur de ce fichier d'en-tête.

note: type: textblock
en: That's the sub header file dealing with the SSLv2 protocol only.  I<Usually you don't have to include it explicitly because it's already included by ssl.h>.
fr: C'est le sous-fichier d'en-tête qui traite seulement du protocole SSLv2. I<En principe vous n'avez pas besoin de l'inclure explicitement parce qu'il est déjà inclus par ssl.h>

note: type: textblock
en: That's the sub header file dealing with the SSLv3 protocol only.  I<Usually you don't have to include it explicitly because it's already included by ssl.h>.
fr: C'est le sous-fichier d'en-tête qui traite seulement du protocole SSLv3. I<En principe vous n'avez pas besoin de l'inclure explicitement parce qu'il est déjà inclus par ssl.h>

note: type: textblock
en: That's the sub header file dealing with the combined use of the SSLv2 and SSLv3 protocols.  I<Usually you don't have to include it explicitly because it's already included by ssl.h>.
fr: C'est le sous-fichier d'en-tête qui traite de la combinaison des protocoles SSLv2 et SSLv3. I<En principe vous n'avez pas besoin de l'inclure explicitement parce qu'il est déjà inclus par ssl.h>

note: type: textblock
en: That's the sub header file dealing with the TLSv1 protocol only.  I<Usually you don't have to include it explicitly because it's already included by ssl.h>.
fr: C'est le sous-fichier d'en-tête qui traite seulement du protocole TLSv1. I<En principe vous n'avez pas besoin de l'inclure explicitement parce qu'il est déjà inclus par ssl.h>

note: type: =head1
en: API FUNCTIONS
fr: FONCTIONS DE L'API

note: type: textblock
en: Currently the OpenSSL B<ssl> library exports 214 API functions.  They are documented in the following:
fr: Actuellement, la bibliothèque B<ssl> OpenSSL exporte 214 fonctions d'API. Elles sont documentées ci-dessous.

note: type: =head2
en: DEALING WITH PROTOCOL METHODS
fr: TRAITEMENT DES MÉTHODES DE PROTOCOLE

note: type: textblock
en: Here we document the various API functions which deal with the SSL/TLS protocol methods defined in B<SSL_METHOD> structures.
fr: Voici une documentation des fonctions d'API qui traitent des méthodes des protocoles SSL/TLS définies dans des structures B<SSL_METHOD>.

note: type: textblock
en: Constructor for the SSLv2 SSL_METHOD structure for a dedicated client.
fr: Constructeur pour la structure SSL_METHOD de SSLv2 pour un client uniquement.

note: type: textblock
en: Constructor for the SSLv2 SSL_METHOD structure for a dedicated server.
fr: Constructeur pour la structure SSL_METHOD de SSLv2 pour un serveur uniquement.

note: type: textblock
en: Constructor for the SSLv2 SSL_METHOD structure for combined client and server.
fr: Constructeur pour la structure SSL_METHOD de SSLv2 pour client et serveur combinés.

note: type: textblock
en: Constructor for the SSLv3 SSL_METHOD structure for a dedicated client.
fr: Constructeur pour la structure SSL_METHOD de SSLv3 pour un client uniquement.

note: type: textblock
en: Constructor for the SSLv3 SSL_METHOD structure for a dedicated server.
fr: Constructeur pour la structure SSL_METHOD de SSLv3 pour un serveur uniquement.

note: type: textblock
en: Constructor for the SSLv3 SSL_METHOD structure for combined client and server.
fr: Constructeur pour la structure SSL_METHOD de SSLv3 pour client et serveur combinés.

note: type: textblock
en: Constructor for the TLSv1 SSL_METHOD structure for a dedicated client.
fr: Constructeur pour la structure SSL_METHOD de TLSv1 pour un client uniquement.

note: type: textblock
en: Constructor for the TLSv1 SSL_METHOD structure for a dedicated server.
fr: Constructeur pour la structure SSL_METHOD de TLSv1 pour un serveur uniquement.

note: type: textblock
en: Constructor for the TLSv1 SSL_METHOD structure for combined client and server.
fr: Constructeur pour la structure SSL_METHOD de TLSv1 pour client et serveur combinés.

note: type: =head2
en: DEALING WITH CIPHERS
fr: TRAITEMENTS DES CHIFFREMENTS

note: type: textblock
en: Here we document the various API functions which deal with the SSL/TLS ciphers defined in B<SSL_CIPHER> structures.
fr: Voici une documentation des fonctions d'API qui traitent des chiffrements SSL/TLS définis dans des structures B<SSL_CIPHER>.

note: type: =item
en: char *B<SSL_CIPHER_description>(SSL_CIPHER *cipher, char *buf, int len);
fr: char *B<SSL_CIPHER_description>(SSL_CIPHER *I<chiffrement>, char *I<tampon>, int I<taille>);

note: type: textblock
en: Write a string to I<buf> (with a maximum size of I<len>) containing a human readable description of I<cipher>. Returns I<buf>.
fr: Écrit une chaîne dans I<tampon> (avec une taille maximum de I<taille>) contenant une description lisible par les humains de I<chiffrement>. Renvoie I<tampon>.

note: type: =item
en: int B<SSL_CIPHER_get_bits>(SSL_CIPHER *cipher, int *alg_bits);
fr: int B<SSL_CIPHER_get_bits>(SSL_CIPHER *I<chiffrement>, int *I<alg_bits>);

note: type: textblock
en: Determine the number of bits in I<cipher>. Because of export crippled ciphers there are two bits: The bits the algorithm supports in general (stored to I<alg_bits>) and the bits which are actually used (the return value).
fr: Détermine le nombre de bits pour le chiffrement. À cause de l'export de chiffrements endommagés il y a deux bits : les bits que l'algorithme gère en général (conservés dans I<alg_bits>) et les bits qui sont effectivement utilisés (la valeur I<renvoyée>).

note: type: =item
en: const char *B<SSL_CIPHER_get_name>(SSL_CIPHER *cipher);
fr: const char *B<SSL_CIPHER_get_name>(SSL_CIPHER *I<chiffrement>);

note: type: textblock
en: Return the internal name of I<cipher> as a string. These are the various strings defined by the I<SSL2_TXT_xxx>, I<SSL3_TXT_xxx> and I<TLS1_TXT_xxx> definitions in the header files.
fr: Renvoie le nom interne du I<chiffrement> en tant que chaîne de caractères. Ce sont les différentes chaînes définies par les définitions I<SSL2_TXT_xxx>, I<SSL3_TXT_xxx> et I<TLS1_TXT_xxx> dans les fichiers d'en-tête.

note: type: =item
en: char *B<SSL_CIPHER_get_version>(SSL_CIPHER *cipher);
fr: char *B<SSL_CIPHER_get_version>(SSL_CIPHER *I<chiffrement>);

note: type: textblock
en: Returns a string like "C<TLSv1/SSLv3>" or "C<SSLv2>" which indicates the SSL/TLS protocol version to which I<cipher> belongs (i.e. where it was defined in the specification the first time).
fr: Renvoie une chaîne du style "C<TLSv1/SSLv3>" ou "C<SSLv2>" qui indique la version du protocole SSL/TLS auquel le I<chiffrement> appartient (c'est-à-dire où elle a été définie dans les spécifications pour la première fois).

note: type: =head2
en: DEALING WITH PROTOCOL CONTEXTS
fr: TRAITEMENT DES CONTEXTES DE PROTOCOLE

note: type: textblock
en: Here we document the various API functions which deal with the SSL/TLS protocol context defined in the B<SSL_CTX> structure.
fr: Voici une documentation des fonctions d'API qui traitent du contexte des protocoles SSL/TLS défini dans la structure B<SSL_CTX>.

note: type: =item
en: int B<SSL_CTX_add_client_CA>(SSL_CTX *ctx, X509 *x);
fr: int B<SSL_CTX_add_client_CA>(SSL_CTX *I<ctx>, X509 *I<x>);

note: type: =item
en: long B<SSL_CTX_add_extra_chain_cert>(SSL_CTX *ctx, X509 *x509);
fr: long B<SSL_CTX_add_extra_chain_cert>(SSL_CTX *I<ctx>, X509 *I<x509>);

note: type: =item
en: int B<SSL_CTX_add_session>(SSL_CTX *ctx, SSL_SESSION *c);
fr: int B<SSL_CTX_add_session>(SSL_CTX *I<ctx>, SSL_SESSION *I<c>);

note: type: =item
en: int B<SSL_CTX_check_private_key>(const SSL_CTX *ctx);
fr: int B<SSL_CTX_check_private_key>(const SSL_CTX *I<ctx>);

note: type: =item
en: long B<SSL_CTX_ctrl>(SSL_CTX *ctx, int cmd, long larg, char *parg);
fr: long B<SSL_CTX_ctrl>(SSL_CTX *I<ctx>, int I<cmd>, long I<larg>, char *I<parg>);

note: type: =item
en: void B<SSL_CTX_flush_sessions>(SSL_CTX *s, long t);
fr: void B<SSL_CTX_flush_sessions>(SSL_CTX *I<s>, long I<t>);

note: type: =item
en: void B<SSL_CTX_free>(SSL_CTX *a);
fr: void B<SSL_CTX_free>(SSL_CTX *I<a>);

note: type: =item
en: char *B<SSL_CTX_get_app_data>(SSL_CTX *ctx);
fr: char *B<SSL_CTX_get_app_data>(SSL_CTX *I<ctx>);

note: type: =item
en: X509_STORE *B<SSL_CTX_get_cert_store>(SSL_CTX *ctx);
fr: X509_STORE *B<SSL_CTX_get_cert_store>(SSL_CTX *I<ctx>);

note: type: =item
en: STACK *B<SSL_CTX_get_client_CA_list>(const SSL_CTX *ctx);
fr: STACK *B<SSL_CTX_get_client_CA_list>(const SSL_CTX *I<ctx>);

note: type: =item
en: int (*B<SSL_CTX_get_client_cert_cb>(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
fr: int (*B<SSL_CTX_get_client_cert_cb>(SSL_CTX *I<ctx>))(SSL *I<ssl>, X509 **I<x>509, EVP_PKEY **I<clé_privée>);

note: type: =item
en: void B<SSL_CTX_get_default_read_ahead>(SSL_CTX *ctx);
fr: void B<SSL_CTX_get_default_read_ahead>(SSL_CTX *I<ctx>);

note: type: =item
en: char *B<SSL_CTX_get_ex_data>(const SSL_CTX *s, int idx);
fr: char *B<SSL_CTX_get_ex_data>(const SSL_CTX *I<s>, int I<idx>);

note: type: =item
en: int B<SSL_CTX_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
fr: int B<SSL_CTX_get_ex_new_index>(long I<argl>, char *I<argp>, int (*I<new_func>);(void), int (*I<dup_func>)(void), void (*I<free_func>)(void))

note: type: =item
en: void (*B<SSL_CTX_get_info_callback>(SSL_CTX *ctx))(SSL *ssl, int cb, int ret);
fr: void (*B<SSL_CTX_get_info_callback>(SSL_CTX *I<ctx>))(SSL *I<ssl>, int I<cb>, int I<ret>);

note: type: =item
en: int B<SSL_CTX_get_quiet_shutdown>(const SSL_CTX *ctx);
fr: int B<SSL_CTX_get_quiet_shutdown>(const SSL_CTX *I<ctx>);

note: type: =item
en: void B<SSL_CTX_get_read_ahead>(SSL_CTX *ctx);
fr: void B<SSL_CTX_get_read_ahead>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_get_session_cache_mode>(SSL_CTX *ctx);
fr: int B<SSL_CTX_get_session_cache_mode>(SSL_CTX *I<ctx>);

note: type: =item
en: long B<SSL_CTX_get_timeout>(const SSL_CTX *ctx);
fr: long B<SSL_CTX_get_timeout>(const SSL_CTX *I<ctx>);

note: type: =item
en: int (*B<SSL_CTX_get_verify_callback>(const SSL_CTX *ctx))(int ok, X509_STORE_CTX *ctx);
fr: int (*B<SSL_CTX_get_verify_callback>(const SSL_CTX *I<ctx>))(int I<ok>, X509_STORE_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_get_verify_mode>(SSL_CTX *ctx);
fr: int B<SSL_CTX_get_verify_mode>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_load_verify_locations>(SSL_CTX *ctx, char *CAfile, char *CApath);
fr: int B<SSL_CTX_load_verify_locations>(SSL_CTX *I<ctx>, char *I<fichierCA>, char *I<cheminCA>);

note: type: =item
en: long B<SSL_CTX_need_tmp_RSA>(SSL_CTX *ctx);
fr: long B<SSL_CTX_need_tmp_RSA>(SSL_CTX *I<ctx>);

note: type: =item
en: SSL_CTX *B<SSL_CTX_new>(const SSL_METHOD *meth);
fr: SSL_CTX *B<SSL_CTX_new>(const SSL_METHOD *I<meth>);

note: type: =item
en: int B<SSL_CTX_remove_session>(SSL_CTX *ctx, SSL_SESSION *c);
fr: int B<SSL_CTX_remove_session>(SSL_CTX *I<ctx>, SSL_SESSION *I<c>);

note: type: =item
en: int B<SSL_CTX_sess_accept>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_accept>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_accept_good>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_accept_good>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_accept_renegotiate>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_accept_renegotiate>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_cache_full>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_cache_full>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_cb_hits>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_cb_hits>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_connect>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_connect>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_connect_good>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_connect_good>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_connect_renegotiate>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_connect_renegotiate>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_get_cache_size>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_get_cache_size>(SSL_CTX *I<ctx>);

note: type: =item
en: SSL_SESSION *(*B<SSL_CTX_sess_get_get_cb>(SSL_CTX *ctx))(SSL *ssl, unsigned char *data, int len, int *copy);
fr: SSL_SESSION *(*B<SSL_CTX_sess_get_get_cb>(SSL_CTX *I<ctx>))(SSL *I<ssl>, unsigned char *I<données>, int I<taille>, int *I<copie>);

note: type: =item
en: int (*B<SSL_CTX_sess_get_new_cb>(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION *sess);
fr: int (*B<SSL_CTX_sess_get_new_cb>(SSL_CTX *I<ctx>)(SSL *I<ssl>, SSL_SESSION *I<sess>);

note: type: =item
en: void (*B<SSL_CTX_sess_get_remove_cb>(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SESSION *sess);
fr: void (*B<SSL_CTX_sess_get_remove_cb>(SSL_CTX *I<ctx>)(SSL_CTX *I<ctx>, SSL_SESSION *I<sess>);

note: type: =item
en: int B<SSL_CTX_sess_hits>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_hits>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_misses>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_misses>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_sess_number>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_number>(SSL_CTX *I<ctx>);

note: type: =item
en: void B<SSL_CTX_sess_set_cache_size>(SSL_CTX *ctx,t);
fr: void B<SSL_CTX_sess_set_cache_size>(SSL_CTX *I<ctx>,t);

note: type: =item
en: void B<SSL_CTX_sess_set_get_cb>(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl, unsigned char *data, int len, int *copy));
fr: void B<SSL_CTX_sess_set_get_cb>(SSL_CTX *I<ctx>, SSL_SESSION *(*I<cb>)(SSL *I<ssl>, unsigned char *I<données>, int I<taille>, int *I<copie>));

note: type: =item
en: void B<SSL_CTX_sess_set_new_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SESSION *sess));
fr: void B<SSL_CTX_sess_set_new_cb>(SSL_CTX *I<ctx>, int (*I<cb>)(SSL *I<ssl>, SSL_SESSION *I<sess>));

note: type: =item
en: void B<SSL_CTX_sess_set_remove_cb>(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess));
fr: void B<SSL_CTX_sess_set_remove_cb>(SSL_CTX *I<ctx>, void (*I<cb>)(SSL_CTX *I<ctx>, SSL_SESSION *I<sess>));

note: type: =item
en: int B<SSL_CTX_sess_timeouts>(SSL_CTX *ctx);
fr: int B<SSL_CTX_sess_timeouts>(SSL_CTX *I<ctx>);

note: type: =item
en: LHASH *B<SSL_CTX_sessions>(SSL_CTX *ctx);
fr: LHASH *B<SSL_CTX_sessions>(SSL_CTX *I<ctx>);

note: type: =item
en: void B<SSL_CTX_set_app_data>(SSL_CTX *ctx, void *arg);
fr: void B<SSL_CTX_set_app_data>(SSL_CTX *I<ctx>, void *I<arg>);

note: type: =item
en: void B<SSL_CTX_set_cert_store>(SSL_CTX *ctx, X509_STORE *cs);
fr: void B<SSL_CTX_set_cert_store>(SSL_CTX *I<ctx>, X509_STORE *I<cs>);

note: type: =item
en: void B<SSL_CTX_set_cert_verify_cb>(SSL_CTX *ctx, int (*cb)(), char *arg)
fr: void B<SSL_CTX_set_cert_verify_cb>(SSL_CTX *I<ctx>, int (*I<cb>)(), char *I<arg>)

note: type: =item
en: int B<SSL_CTX_set_cipher_list>(SSL_CTX *ctx, char *str);
fr: int B<SSL_CTX_set_cipher_list>(SSL_CTX *I<ctx>, char *I<str>);

note: type: =item
en: void B<SSL_CTX_set_client_CA_list>(SSL_CTX *ctx, STACK *list);
fr: void B<SSL_CTX_set_client_CA_list>(SSL_CTX *I<ctx>, STACK *I<list>);

note: type: =item
en: void B<SSL_CTX_set_client_cert_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));
fr: void B<SSL_CTX_set_client_cert_cb>(SSL_CTX *I<ctx>, int (*I<cb>)(SSL *I<ssl>, X509 **I<x509>, EVP_PKEY **I<clé_privée>));

note: type: =item
en: void B<SSL_CTX_set_default_passwd_cb>(SSL_CTX *ctx, int (*cb);(void))
fr: void B<SSL_CTX_set_default_passwd_cb>(SSL_CTX *I<ctx>, int (*I<cb>);(void))

note: type: =item
en: void B<SSL_CTX_set_default_read_ahead>(SSL_CTX *ctx, int m);
fr: void B<SSL_CTX_set_default_read_ahead>(SSL_CTX *I<ctx>, int I<m>);

note: type: =item
en: int B<SSL_CTX_set_default_verify_paths>(SSL_CTX *ctx);
fr: int B<SSL_CTX_set_default_verify_paths>(SSL_CTX *I<ctx>);

note: type: =item
en: int B<SSL_CTX_set_ex_data>(SSL_CTX *s, int idx, char *arg);
fr: int B<SSL_CTX_set_ex_data>(SSL_CTX *I<s>, int I<idx>, char *I<arg>);

note: type: =item
en: void B<SSL_CTX_set_info_callback>(SSL_CTX *ctx, void (*cb)(SSL *ssl, int cb, int ret));
fr: void B<SSL_CTX_set_info_callback>(SSL_CTX *I<ctx>, void (*I<cb>)(SSL *I<ssl>, int I<cb>, int I<ret>));

note: type: =item
en: void B<SSL_CTX_set_msg_callback>(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
fr: void B<SSL_CTX_set_msg_callback>(SSL_CTX *I<ctx>, void (*I<cb>)(int I<write_p>, int I<version>, int I<content_type>, const void *I<tampon>, size_t I<taille>, SSL *I<ssl>, void *I<arg>));

note: type: =item
en: void B<SSL_CTX_set_msg_callback_arg>(SSL_CTX *ctx, void *arg);
fr: void B<SSL_CTX_set_msg_callback_arg>(SSL_CTX *I<ctx>, void *I<arg>);

note: type: =item
en: void B<SSL_CTX_set_options>(SSL_CTX *ctx, unsigned long op);
fr: void B<SSL_CTX_set_options>(SSL_CTX *I<ctx>, unsigned long I<op>);

note: type: =item
en: void B<SSL_CTX_set_quiet_shutdown>(SSL_CTX *ctx, int mode);
fr: void B<SSL_CTX_set_quiet_shutdown>(SSL_CTX *I<ctx>, int I<mode>);

note: type: =item
en: void B<SSL_CTX_set_read_ahead>(SSL_CTX *ctx, int m);
fr: void B<SSL_CTX_set_read_ahead>(SSL_CTX *I<ctx>, int I<m>);

note: type: =item
en: void B<SSL_CTX_set_session_cache_mode>(SSL_CTX *ctx, int mode);
fr: void B<SSL_CTX_set_session_cache_mode>(SSL_CTX *I<ctx>, int I<mode>);

note: type: =item
en: int B<SSL_CTX_set_ssl_version>(SSL_CTX *ctx, const SSL_METHOD *meth);
fr: int B<SSL_CTX_set_ssl_version>(SSL_CTX *I<ctx>, const SSL_METHOD *I<meth>);

note: type: =item
en: void B<SSL_CTX_set_timeout>(SSL_CTX *ctx, long t);
fr: void B<SSL_CTX_set_timeout>(SSL_CTX *I<ctx>, long I<t>);

note: type: =item
en: long B<SSL_CTX_set_tmp_dh>(SSL_CTX* ctx, DH *dh);
fr: long B<SSL_CTX_set_tmp_dh>(SSL_CTX* ctx, DH *I<dh>);

note: type: =item
en: long B<SSL_CTX_set_tmp_dh_callback>(SSL_CTX *ctx, DH *(*cb)(void));
fr: long B<SSL_CTX_set_tmp_dh_callback>(SSL_CTX *I<ctx>, DH *(*I<cb>)(void));

note: type: =item
en: long B<SSL_CTX_set_tmp_rsa>(SSL_CTX *ctx, RSA *rsa);
fr: long B<SSL_CTX_set_tmp_rsa>(SSL_CTX *I<ctx>, RSA *I<rsa>);

note: type: textblock
en: C<long B<SSL_CTX_set_tmp_rsa_callback>(SSL_CTX *B<ctx>, RSA *(*B<cb>)(SSL *B<ssl>, int B<export>, int B<keylength>));>
fr: long B<SSL_CTX_set_tmp_rsa_callback>(SSL_CTX *I<ctx>, RSA *(*I<cb>)(SSL *I<ssl>, int I<export>, int I<taille_clé>));

note: type: textblock
en: Sets the callback which will be called when a temporary private key is required. The B<C<export>> flag will be set if the reason for needing a temp key is that an export ciphersuite is in use, in which case, B<C<keylength>> will contain the required keylength in bits. Generate a key of appropriate size (using ???) and return it.
fr: Définit la fonction de rappel qui sera appelée quand une clé privée temporaire est requise. Le paramètre I<export> sera défini si la raison de l'obtention d'une clé temporaire est l'utilisation d'un export d'une suite de chiffrement. Dans ce cas, I<taille_clé> contiendra la longueur requise de la clé en bits. Générez une clé de la taille appropriée et renvoyez-là.

note: type: textblock
en: long B<SSL_set_tmp_rsa_callback>(SSL *ssl, RSA *(*cb)(SSL *ssl, int export, int keylength));
fr: long B<SSL_set_tmp_rsa_callback>(SSL *I<ssl>, RSA *(*I<cb>)(SSL *I<ssl>, int I<export>, int I<taille_clé>));

note: type: textblock
en: The same as B<SSL_CTX_set_tmp_rsa_callback>, except it operates on an SSL session instead of a context.
fr: Identique à B<SSL_CTX_set_tmp_rsa_callback>, à la différence qu'il opère sur une session SSL au lieu d'un contexte.

note: type: =item
en: void B<SSL_CTX_set_verify>(SSL_CTX *ctx, int mode, int (*cb);(void))
fr: void B<SSL_CTX_set_verify>(SSL_CTX *I<ctx>, int I<mode>, int (*I<cb>);(void))

note: type: =item
en: int B<SSL_CTX_use_PrivateKey>(SSL_CTX *ctx, EVP_PKEY *pkey);
fr: int B<SSL_CTX_use_PrivateKey>(SSL_CTX *I<ctx>, EVP_PKEY *I<clé_privée>);

note: type: =item
en: int B<SSL_CTX_use_PrivateKey_ASN1>(int type, SSL_CTX *ctx, unsigned char *d, long len);
fr: int B<SSL_CTX_use_PrivateKey_ASN1>(int I<type>, SSL_CTX *I<ctx>, unsigned char *I<d>, long I<taille>);

note: type: =item
en: int B<SSL_CTX_use_PrivateKey_file>(SSL_CTX *ctx, char *file, int type);
fr: int B<SSL_CTX_use_PrivateKey_file>(SSL_CTX *I<ctx>, char *I<fichier>, int I<type>);

note: type: =item
en: int B<SSL_CTX_use_RSAPrivateKey>(SSL_CTX *ctx, RSA *rsa);
fr: int B<SSL_CTX_use_RSAPrivateKey>(SSL_CTX *I<ctx>, RSA *I<rsa>);

note: type: =item
en: int B<SSL_CTX_use_RSAPrivateKey_ASN1>(SSL_CTX *ctx, unsigned char *d, long len);
fr: int B<SSL_CTX_use_RSAPrivateKey_ASN1>(SSL_CTX *I<ctx>, unsigned char *I<d>, long I<taille>);

note: type: =item
en: int B<SSL_CTX_use_RSAPrivateKey_file>(SSL_CTX *ctx, char *file, int type);
fr: int B<SSL_CTX_use_RSAPrivateKey_file>(SSL_CTX *I<ctx>, char *I<fichier>, int I<type>);

note: type: =item
en: int B<SSL_CTX_use_certificate>(SSL_CTX *ctx, X509 *x);
fr: int B<SSL_CTX_use_certificate>(SSL_CTX *I<ctx>, X509 *I<x>);

note: type: =item
en: int B<SSL_CTX_use_certificate_ASN1>(SSL_CTX *ctx, int len, unsigned char *d);
fr: int B<SSL_CTX_use_certificate_ASN1>(SSL_CTX *I<ctx>, int I<taille>, unsigned char *I<d>);

note: type: =item
en: int B<SSL_CTX_use_certificate_file>(SSL_CTX *ctx, char *file, int type);
fr: int B<SSL_CTX_use_certificate_file>(SSL_CTX *I<ctx>, char *I<fichier>, int I<type>);

note: type: =item
en: X509 *B<SSL_CTX_get0_certificate>(const SSL_CTX *ctx);
fr: X509 *B<SSL_CTX_get0_certificate>(const SSL_CTX *I<ctx>);

note: type: =item
en: EVP_PKEY *B<SSL_CTX_get0_privatekey>(const SSL_CTX *ctx);
fr: EVP_PKEY *B<SSL_CTX_get0_privatekey>(const SSL_CTX *I<ctx>);

note: type: =item
en: void B<SSL_CTX_set_psk_client_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
fr: void B<SSL_CTX_set_psk_client_callback>(SSL_CTX *I<ctx>, unsigned int (*I<callback>)(SSL *I<ssl>, const char *I<hint>, char *I<identity>, unsigned int I<max_identity_len>, unsigned char *I<psk>, unsigned int I<max_psk_len>));

note: type: =item
en: int B<SSL_CTX_use_psk_identity_hint>(SSL_CTX *ctx, const char *hint);
fr: int B<SSL_CTX_use_psk_identity_hint>(SSL_CTX *I<ctx>, const char *I<hint>);

note: type: =item
en: void B<SSL_CTX_set_psk_server_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
fr: void B<SSL_CTX_set_psk_server_callback>(SSL_CTX *I<ctx>, unsigned int (*I<callback>)(SSL *I<ssl>, const char *I<identity>, unsigned char *I<psk>, int I<max_psk_len>));

note: type: =head2
en: DEALING WITH SESSIONS
fr: TRAITEMENTS DES SESSIONS

note: type: textblock
en: Here we document the various API functions which deal with the SSL/TLS sessions defined in the B<SSL_SESSION> structures.
fr: Voici une documentation des fonctions d'API qui traitent des sessions SSL/TLS définies dans des structures B<SSL_SESSION>.

note: type: =item
en: int B<SSL_SESSION_cmp>(const SSL_SESSION *a, const SSL_SESSION *b);
fr: int B<SSL_SESSION_cmp>(const SSL_SESSION *I<a>, const SSL_SESSION *I<b>);

note: type: =item
en: void B<SSL_SESSION_free>(SSL_SESSION *ss);
fr: void B<SSL_SESSION_free>(SSL_SESSION *I<ss>);

note: type: =item
en: char *B<SSL_SESSION_get_app_data>(SSL_SESSION *s);
fr: char *B<SSL_SESSION_get_app_data>(SSL_SESSION *I<s>);

note: type: =item
en: char *B<SSL_SESSION_get_ex_data>(const SSL_SESSION *s, int idx);
fr: char *B<SSL_SESSION_get_ex_data>(const SSL_SESSION *I<s>, int I<idx>);

note: type: =item
en: int B<SSL_SESSION_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
fr: int B<SSL_SESSION_get_ex_new_index>(long I<argl>, char *I<argp>, int (*I<new_func>);(void), int (*I<dup_func>)(void), void (*I<free_func>)(void))

note: type: =item
en: long B<SSL_SESSION_get_time>(const SSL_SESSION *s);
fr: long B<SSL_SESSION_get_time>(const SSL_SESSION *I<s>);

note: type: =item
en: long B<SSL_SESSION_get_timeout>(const SSL_SESSION *s);
fr: long B<SSL_SESSION_get_timeout>(const SSL_SESSION *I<s>);

note: type: =item
en: unsigned long B<SSL_SESSION_hash>(const SSL_SESSION *a);
fr: unsigned long B<SSL_SESSION_hash>(const SSL_SESSION *I<a>);

note: type: =item
en: int B<SSL_SESSION_print>(BIO *bp, const SSL_SESSION *x);
fr: int B<SSL_SESSION_print>(BIO *I<bp>, const SSL_SESSION *I<x>);

note: type: =item
en: int B<SSL_SESSION_print_fp>(FILE *fp, const SSL_SESSION *x);
fr: int B<SSL_SESSION_print_fp>(FILE *I<fp>, const SSL_SESSION *I<x>);

note: type: =item
en: void B<SSL_SESSION_set_app_data>(SSL_SESSION *s, char *a);
fr: void B<SSL_SESSION_set_app_data>(SSL_SESSION *I<s>, char *I<a>);

note: type: =item
en: int B<SSL_SESSION_set_ex_data>(SSL_SESSION *s, int idx, char *arg);
fr: int B<SSL_SESSION_set_ex_data>(SSL_SESSION *I<s>, int I<idx>, char *I<arg>);

note: type: =item
en: long B<SSL_SESSION_set_time>(SSL_SESSION *s, long t);
fr: long B<SSL_SESSION_set_time>(SSL_SESSION *I<s>, long I<t>);

note: type: =item
en: long B<SSL_SESSION_set_timeout>(SSL_SESSION *s, long t);
fr: long B<SSL_SESSION_set_timeout>(SSL_SESSION *I<s>, long I<t>);

note: type: =head2
en: DEALING WITH CONNECTIONS
fr: TRAITEMENTS DES CONNEXIONS

note: type: textblock
en: Here we document the various API functions which deal with the SSL/TLS connection defined in the B<SSL> structure.
fr: Voici une documentation des fonctions d'API qui traitent de la connexion SSL/TLS définie dans la structure B<SSL>.

note: type: =item
en: int B<SSL_accept>(SSL *ssl);
fr: int B<SSL_accept>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_add_dir_cert_subjects_to_stack>(STACK *stack, const char *dir);
fr: int B<SSL_add_dir_cert_subjects_to_stack>(STACK *I<stack>, const char *I<dossier>);

note: type: =item
en: int B<SSL_add_file_cert_subjects_to_stack>(STACK *stack, const char *file);
fr: int B<SSL_add_file_cert_subjects_to_stack>(STACK *I<stack>, const char *I<fichier>);

note: type: =item
en: int B<SSL_add_client_CA>(SSL *ssl, X509 *x);
fr: int B<SSL_add_client_CA>(SSL *I<ssl>, X509 *I<x>);

note: type: =item
en: char *B<SSL_alert_desc_string>(int value);
fr: char *B<SSL_alert_desc_string>(int I<valeur>);

note: type: =item
en: char *B<SSL_alert_desc_string_long>(int value);
fr: char *B<SSL_alert_desc_string_long>(int I<valeur>);

note: type: =item
en: char *B<SSL_alert_type_string>(int value);
fr: char *B<SSL_alert_type_string>(int I<valeur>);

note: type: =item
en: char *B<SSL_alert_type_string_long>(int value);
fr: char *B<SSL_alert_type_string_long>(int I<valeur>);

note: type: =item
en: int B<SSL_check_private_key>(const SSL *ssl);
fr: int B<SSL_check_private_key>(const SSL *I<ssl>);

note: type: =item
en: void B<SSL_clear>(SSL *ssl);
fr: void B<SSL_clear>(SSL *I<ssl>);

note: type: =item
en: long B<SSL_clear_num_renegotiations>(SSL *ssl);
fr: long B<SSL_clear_num_renegotiations>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_connect>(SSL *ssl);
fr: int B<SSL_connect>(SSL *I<ssl>);

note: type: =item
en: void B<SSL_copy_session_id>(SSL *t, const SSL *f);
fr: void B<SSL_copy_session_id>(SSL *I<t>, const SSL *I<f>);

note: type: =item
en: long B<SSL_ctrl>(SSL *ssl, int cmd, long larg, char *parg);
fr: long B<SSL_ctrl>(SSL *I<ssl>, int I<cmd>, long I<larg>, char *I<parg>);

note: type: =item
en: int B<SSL_do_handshake>(SSL *ssl);
fr: int B<SSL_do_handshake>(SSL *I<ssl>);

note: type: =item
en: SSL *B<SSL_dup>(SSL *ssl);
fr: SSL *B<SSL_dup>(SSL *I<ssl>);

note: type: =item
en: STACK *B<SSL_dup_CA_list>(STACK *sk);
fr: STACK *B<SSL_dup_CA_list>(STACK *I<sk>);

note: type: =item
en: void B<SSL_free>(SSL *ssl);
fr: void B<SSL_free>(SSL *I<ssl>);

note: type: =item
en: SSL_CTX *B<SSL_get_SSL_CTX>(const SSL *ssl);
fr: SSL_CTX *B<SSL_get_SSL_CTX>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_get_app_data>(SSL *ssl);
fr: char *B<SSL_get_app_data>(SSL *I<ssl>);

note: type: =item
en: X509 *B<SSL_get_certificate>(const SSL *ssl);
fr: X509 *B<SSL_get_certificate>(const SSL *I<ssl>);

note: type: =item
en: const char *B<SSL_get_cipher>(const SSL *ssl);
fr: const char *B<SSL_get_cipher>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_get_cipher_bits>(const SSL *ssl, int *alg_bits);
fr: int B<SSL_get_cipher_bits>(const SSL *I<ssl>, int *I<alg_bits>);

note: type: =item
en: char *B<SSL_get_cipher_list>(const SSL *ssl, int n);
fr: char *B<SSL_get_cipher_list>(const SSL *I<ssl>, int I<n>);

note: type: =item
en: char *B<SSL_get_cipher_name>(const SSL *ssl);
fr: char *B<SSL_get_cipher_name>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_get_cipher_version>(const SSL *ssl);
fr: char *B<SSL_get_cipher_version>(const SSL *I<ssl>);

note: type: =item
en: STACK *B<SSL_get_ciphers>(const SSL *ssl);
fr: STACK *B<SSL_get_ciphers>(const SSL *I<ssl>);

note: type: =item
en: STACK *B<SSL_get_client_CA_list>(const SSL *ssl);
fr: STACK *B<SSL_get_client_CA_list>(const SSL *I<ssl>);

note: type: =item
en: SSL_CIPHER *B<SSL_get_current_cipher>(SSL *ssl);
fr: SSL_CIPHER *B<SSL_get_current_cipher>(SSL *I<ssl>);

note: type: =item
en: long B<SSL_get_default_timeout>(const SSL *ssl);
fr: long B<SSL_get_default_timeout>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_get_error>(const SSL *ssl, int i);
fr: int B<SSL_get_error>(const SSL *I<ssl>, int I<i>);

note: type: =item
en: char *B<SSL_get_ex_data>(const SSL *ssl, int idx);
fr: char *B<SSL_get_ex_data>(const SSL *I<ssl>, int I<idx>);

note: type: =item
en: int B<SSL_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
fr: int B<SSL_get_ex_new_index>(long I<argl>, char *I<argp>, int (*I<new_func>);(void), int (*I<dup_func>)(void), void (*I<free_func>)(void))

note: type: =item
en: int B<SSL_get_fd>(const SSL *ssl);
fr: int B<SSL_get_fd>(const SSL *I<ssl>);

note: type: =item
en: void (*B<SSL_get_info_callback>(const SSL *ssl);)()
fr: void (*B<SSL_get_info_callback>(const SSL *I<ssl>);)()

note: type: =item
en: STACK *B<SSL_get_peer_cert_chain>(const SSL *ssl);
fr: STACK *B<SSL_get_peer_cert_chain>(const SSL *I<ssl>);

note: type: =item
en: X509 *B<SSL_get_peer_certificate>(const SSL *ssl);
fr: X509 *B<SSL_get_peer_certificate>(const SSL *I<ssl>);

note: type: =item
en: EVP_PKEY *B<SSL_get_privatekey>(const SSL *ssl);
fr: EVP_PKEY *B<SSL_get_privatekey>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_get_quiet_shutdown>(const SSL *ssl);
fr: int B<SSL_get_quiet_shutdown>(const SSL *I<ssl>);

note: type: =item
en: BIO *B<SSL_get_rbio>(const SSL *ssl);
fr: BIO *B<SSL_get_rbio>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_get_read_ahead>(const SSL *ssl);
fr: int B<SSL_get_read_ahead>(const SSL *I<ssl>);

note: type: =item
en: SSL_SESSION *B<SSL_get_session>(const SSL *ssl);
fr: SSL_SESSION *B<SSL_get_session>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_get_shared_ciphers>(const SSL *ssl, char *buf, int len);
fr: char *B<SSL_get_shared_ciphers>(const SSL *I<ssl>, char *I<tampon>, int I<taille>);

note: type: =item
en: int B<SSL_get_shutdown>(const SSL *ssl);
fr: int B<SSL_get_shutdown>(const SSL *I<ssl>);

note: type: =item
en: const SSL_METHOD *B<SSL_get_ssl_method>(SSL *ssl);
fr: const SSL_METHOD *B<SSL_get_ssl_method>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_get_state>(const SSL *ssl);
fr: int B<SSL_get_state>(const SSL *I<ssl>);

note: type: =item
en: long B<SSL_get_time>(const SSL *ssl);
fr: long B<SSL_get_time>(const SSL *I<ssl>);

note: type: =item
en: long B<SSL_get_timeout>(const SSL *ssl);
fr: long B<SSL_get_timeout>(const SSL *I<ssl>);

note: type: =item
en: int (*B<SSL_get_verify_callback>(const SSL *ssl))(int,X509_STORE_CTX *)
fr: int (*B<SSL_get_verify_callback>(const SSL *I<ssl>))(int,X509_STORE_CTX *)

note: type: =item
en: int B<SSL_get_verify_mode>(const SSL *ssl);
fr: int B<SSL_get_verify_mode>(const SSL *I<ssl>);

note: type: =item
en: long B<SSL_get_verify_result>(const SSL *ssl);
fr: long B<SSL_get_verify_result>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_get_version>(const SSL *ssl);
fr: char *B<SSL_get_version>(const SSL *I<ssl>);

note: type: =item
en: BIO *B<SSL_get_wbio>(const SSL *ssl);
fr: BIO *B<SSL_get_wbio>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_in_accept_init>(SSL *ssl);
fr: int B<SSL_in_accept_init>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_in_before>(SSL *ssl);
fr: int B<SSL_in_before>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_in_connect_init>(SSL *ssl);
fr: int B<SSL_in_connect_init>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_in_init>(SSL *ssl);
fr: int B<SSL_in_init>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_is_init_finished>(SSL *ssl);
fr: int B<SSL_is_init_finished>(SSL *I<ssl>);

note: type: =item
en: STACK *B<SSL_load_client_CA_file>(char *file);
fr: STACK *B<SSL_load_client_CA_file>(char *I<fichier>);

note: type: =item
en: SSL *B<SSL_new>(SSL_CTX *ctx);
fr: SSL *B<SSL_new>(SSL_CTX *I<ctx>);

note: type: =item
en: long B<SSL_num_renegotiations>(SSL *ssl);
fr: long B<SSL_num_renegotiations>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_peek>(SSL *ssl, void *buf, int num);
fr: int B<SSL_peek>(SSL *I<ssl>, void *I<tampon>, int I<num>);

note: type: =item
en: int B<SSL_pending>(const SSL *ssl);
fr: int B<SSL_pending>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_read>(SSL *ssl, void *buf, int num);
fr: int B<SSL_read>(SSL *I<ssl>, void *I<tampon>, int I<num>);

note: type: =item
en: int B<SSL_renegotiate>(SSL *ssl);
fr: int B<SSL_renegotiate>(SSL *I<ssl>);

note: type: =item
en: char *B<SSL_rstate_string>(SSL *ssl);
fr: char *B<SSL_rstate_string>(SSL *I<ssl>);

note: type: =item
en: char *B<SSL_rstate_string_long>(SSL *ssl);
fr: char *B<SSL_rstate_string_long>(SSL *I<ssl>);

note: type: =item
en: long B<SSL_session_reused>(SSL *ssl);
fr: long B<SSL_session_reused>(SSL *I<ssl>);

note: type: =item
en: void B<SSL_set_accept_state>(SSL *ssl);
fr: void B<SSL_set_accept_state>(SSL *I<ssl>);

note: type: =item
en: void B<SSL_set_app_data>(SSL *ssl, char *arg);
fr: void B<SSL_set_app_data>(SSL *I<ssl>, char *I<arg>);

note: type: =item
en: void B<SSL_set_bio>(SSL *ssl, BIO *rbio, BIO *wbio);
fr: void B<SSL_set_bio>(SSL *I<ssl>, BIO *I<rbio>, BIO *I<wbio>);

note: type: =item
en: int B<SSL_set_cipher_list>(SSL *ssl, char *str);
fr: int B<SSL_set_cipher_list>(SSL *I<ssl>, char *I<str>);

note: type: =item
en: void B<SSL_set_client_CA_list>(SSL *ssl, STACK *list);
fr: void B<SSL_set_client_CA_list>(SSL *I<ssl>, STACK *I<list>);

note: type: =item
en: void B<SSL_set_connect_state>(SSL *ssl);
fr: void B<SSL_set_connect_state>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_set_ex_data>(SSL *ssl, int idx, char *arg);
fr: int B<SSL_set_ex_data>(SSL *I<ssl>, int I<idx>, char *I<arg>);

note: type: =item
en: int B<SSL_set_fd>(SSL *ssl, int fd);
fr: int B<SSL_set_fd>(SSL *I<ssl>, int I<fd>);

note: type: =item
en: void B<SSL_set_info_callback>(SSL *ssl, void (*cb);(void))
fr: void B<SSL_set_info_callback>(SSL *I<ssl>, void (*I<cb>);(void))

note: type: =item
en: void B<SSL_set_msg_callback>(SSL *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
fr: void B<SSL_set_msg_callback>(SSL *I<ctx>, void (*I<cb>)(int I<write_p>, int I<version>, int I<content_type>, const void *I<tampon>, size_t I<taille>, SSL *I<ssl>, void *I<arg>));

note: type: =item
en: void B<SSL_set_msg_callback_arg>(SSL *ctx, void *arg);
fr: void B<SSL_set_msg_callback_arg>(SSL *I<ctx>, void *I<arg>);

note: type: =item
en: void B<SSL_set_options>(SSL *ssl, unsigned long op);
fr: void B<SSL_set_options>(SSL *I<ssl>, unsigned long I<op>);

note: type: =item
en: void B<SSL_set_quiet_shutdown>(SSL *ssl, int mode);
fr: void B<SSL_set_quiet_shutdown>(SSL *I<ssl>, int I<mode>);

note: type: =item
en: void B<SSL_set_read_ahead>(SSL *ssl, int yes);
fr: void B<SSL_set_read_ahead>(SSL *I<ssl>, int I<yes>);

note: type: =item
en: int B<SSL_set_rfd>(SSL *ssl, int fd);
fr: int B<SSL_set_rfd>(SSL *I<ssl>, int I<fd>);

note: type: =item
en: int B<SSL_set_session>(SSL *ssl, SSL_SESSION *session);
fr: int B<SSL_set_session>(SSL *I<ssl>, SSL_SESSION *I<session>);

note: type: =item
en: void B<SSL_set_shutdown>(SSL *ssl, int mode);
fr: void B<SSL_set_shutdown>(SSL *I<ssl>, int I<mode>);

note: type: =item
en: int B<SSL_set_ssl_method>(SSL *ssl, const SSL_METHOD *meth);
fr: int B<SSL_set_ssl_method>(SSL *I<ssl>, const SSL_METHOD *I<meth>);

note: type: =item
en: void B<SSL_set_time>(SSL *ssl, long t);
fr: void B<SSL_set_time>(SSL *I<ssl>, long I<t>);

note: type: =item
en: void B<SSL_set_timeout>(SSL *ssl, long t);
fr: void B<SSL_set_timeout>(SSL *I<ssl>, long I<t>);

note: type: =item
en: void B<SSL_set_verify>(SSL *ssl, int mode, int (*callback);(void))
fr: void B<SSL_set_verify>(SSL *I<ssl>, int I<mode>, int (*I<callback>);(void))

note: type: =item
en: void B<SSL_set_verify_result>(SSL *ssl, long arg);
fr: void B<SSL_set_verify_result>(SSL *I<ssl>, long I<arg>);

note: type: =item
en: int B<SSL_set_wfd>(SSL *ssl, int fd);
fr: int B<SSL_set_wfd>(SSL *I<ssl>, int I<fd>);

note: type: =item
en: int B<SSL_shutdown>(SSL *ssl);
fr: int B<SSL_shutdown>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_state>(const SSL *ssl);
fr: int B<SSL_state>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_state_string>(const SSL *ssl);
fr: char *B<SSL_state_string>(const SSL *I<ssl>);

note: type: =item
en: char *B<SSL_state_string_long>(const SSL *ssl);
fr: char *B<SSL_state_string_long>(const SSL *I<ssl>);

note: type: =item
en: long B<SSL_total_renegotiations>(SSL *ssl);
fr: long B<SSL_total_renegotiations>(SSL *I<ssl>);

note: type: =item
en: int B<SSL_use_PrivateKey>(SSL *ssl, EVP_PKEY *pkey);
fr: int B<SSL_use_PrivateKey>(SSL *I<ssl>, EVP_PKEY *I<clé_privée>);

note: type: =item
en: int B<SSL_use_PrivateKey_ASN1>(int type, SSL *ssl, unsigned char *d, long len);
fr: int B<SSL_use_PrivateKey_ASN1>(int I<type>, SSL *I<ssl>, unsigned char *I<d>, long I<taille>);

note: type: =item
en: int B<SSL_use_PrivateKey_file>(SSL *ssl, char *file, int type);
fr: int B<SSL_use_PrivateKey_file>(SSL *I<ssl>, char *I<fichier>, int I<type>);

note: type: =item
en: int B<SSL_use_RSAPrivateKey>(SSL *ssl, RSA *rsa);
fr: int B<SSL_use_RSAPrivateKey>(SSL *I<ssl>, RSA *I<rsa>);

note: type: =item
en: int B<SSL_use_RSAPrivateKey_ASN1>(SSL *ssl, unsigned char *d, long len);
fr: int B<SSL_use_RSAPrivateKey_ASN1>(SSL *I<ssl>, unsigned char *I<d>, long I<taille>);

note: type: =item
en: int B<SSL_use_RSAPrivateKey_file>(SSL *ssl, char *file, int type);
fr: int B<SSL_use_RSAPrivateKey_file>(SSL *I<ssl>, char *I<fichier>, int I<type>);

note: type: =item
en: int B<SSL_use_certificate>(SSL *ssl, X509 *x);
fr: int B<SSL_use_certificate>(SSL *I<ssl>, X509 *I<x>);

note: type: =item
en: int B<SSL_use_certificate_ASN1>(SSL *ssl, int len, unsigned char *d);
fr: int B<SSL_use_certificate_ASN1>(SSL *I<ssl>, int I<taille>, unsigned char *I<d>);

note: type: =item
en: int B<SSL_use_certificate_file>(SSL *ssl, char *file, int type);
fr: int B<SSL_use_certificate_file>(SSL *I<ssl>, char *I<fichier>, int I<type>);

note: type: =item
en: int B<SSL_version>(const SSL *ssl);
fr: int B<SSL_version>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_want>(const SSL *ssl);
fr: int B<SSL_want>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_want_nothing>(const SSL *ssl);
fr: int B<SSL_want_nothing>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_want_read>(const SSL *ssl);
fr: int B<SSL_want_read>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_want_write>(const SSL *ssl);
fr: int B<SSL_want_write>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_want_x509_lookup>(const SSL *ssl);
fr: int B<SSL_want_x509_lookup>(const SSL *I<ssl>);

note: type: =item
en: int B<SSL_write>(SSL *ssl, const void *buf, int num);
fr: int B<SSL_write>(SSL *I<ssl>, const void *I<tampon>, int I<num>);

note: type: =item
en: void B<SSL_set_psk_client_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
fr: void B<SSL_set_psk_client_callback>(SSL *I<ssl>, unsigned int (*I<callback>)(SSL *I<ssl>, const char *I<hint>, char *I<identity>, unsigned int I<max_identity_len>, unsigned char *I<psk>, unsigned int I<max_psk_len>));

note: type: =item
en: int B<SSL_use_psk_identity_hint>(SSL *ssl, const char *hint);
fr: int B<SSL_use_psk_identity_hint>(SSL *I<ssl>, const char *I<hint>);

note: type: =item
en: void B<SSL_set_psk_server_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
fr: void B<SSL_set_psk_server_callback>(SSL *I<ssl>, unsigned int (*I<callback>)(SSL *I<ssl>, const char *I<identity>, unsigned char *I<psk>, int I<max_psk_len>));

note: type: =item
en: const char *B<SSL_get_psk_identity_hint>(SSL *ssl);
fr: const char *B<SSL_get_psk_identity_hint>(SSL *I<ssl>);

note: type: =item
en: const char *B<SSL_get_psk_identity>(SSL *ssl);
fr: const char *B<SSL_get_psk_identity>(SSL *I<ssl>);

note: type: =head1
en: HISTORY
fr: HISTORIQUE

note: type: textblock
en: The L<ssl(3)|ssl(3)> document appeared in OpenSSL 0.9.2
fr: Le document L<ssl(3)|ssl(3)> est apparu dans OpenSSL 0.9.2
