openssl - en to fr translation catalogue (98 entries)

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

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

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

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

note: type: textblock
en: TBA
fr: À préciser

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

note: type: textblock
en: BIO_f_buffer - buffering BIO
fr: BIO_f_buffer - BIO de mise en tampon

note: type: textblock
en: BIO_f_buffer() returns the buffering BIO method.
fr: B<BIO_f_buffer>() renvoie la méthode BIO de mise en tampon.

note: type: textblock
en: Data written to a buffering BIO is buffered and periodically written to the next BIO in the chain. Data read from a buffering BIO comes from an internal buffer which is filled from the next BIO in the chain.  Both BIO_gets() and BIO_puts() are supported.
fr: Les données écrites vers un BIO de mise en tampon sont mises en tampon et écrites périodiquement dans le BIO suivant de la chaîne. Les données lues d'un BIO de mise en tampon viennent d'un tampon interne qui est rempli à partir du BIO suivant de la chaîne. B<BIO_gets>() et B<BIO_puts>() sont toutes deux prises en charge.

note: type: textblock
en: Calling BIO_reset() on a buffering BIO clears any buffered data.
fr: Appeler B<BIO_reset>() sur un BIO de mise en tampon efface toutes les données en tampon.

note: type: textblock
en: BIO_get_buffer_num_lines() returns the number of lines currently buffered.
fr: B<BIO_get_buffer_num_lines>() renvoie le nombre de lignes actuellement dans le tampon.

note: type: textblock
en: BIO_set_read_buffer_size(), BIO_set_write_buffer_size() and BIO_set_buffer_size()  set the read, write or both read and write buffer sizes to B<size>. The initial buffer size is DEFAULT_BUFFER_SIZE, currently 4096. Any attempt to reduce the buffer size below DEFAULT_BUFFER_SIZE is ignored. Any buffered data is cleared when the buffer is resized.
fr: B<BIO_set_read_buffer_size>(), B<BIO_set_write_buffer_size>() et B<BIO_set_buffer_size>() définissent la lecture, l'écriture ou la lecture et l'écriture des tailles de tampon sur I<size>. La taille de tampon initiale est B<DEFAULT_BUFFER_SIZE>, actuellement 4096. Toute tentative de diminution de la taille de tampon en dessous de B<DEFAULT_BUFFER_SIZE> est ignorée. Toutes les données en tampon sont effacées quand le tampon est redimensionné.

note: type: textblock
en: BIO_set_buffer_read_data() clears the read buffer and fills it with B<num> bytes of B<buf>. If B<num> is larger than the current buffer size the buffer is expanded.
fr: B<BIO_set_buffer_read_data>() efface le tampon de lecture et le remplit avec I<num> octets de I<buf>. Si I<num> est plus grand que la taille actuelle du tampon, le tampon est agrandi.

note: type: textblock
en: Buffering BIOs implement BIO_gets() by using BIO_read() operations on the next BIO in the chain. By prepending a buffering BIO to a chain it is therefore possible to provide BIO_gets() functionality if the following BIOs do not support it (for example SSL BIOs).
fr: Les BIO de mise en tampon implémentent B<BIO_gets>() en utilisant des opérations B<BIO_read>() sur le BIO suivant de la chaîne. En faisant précéder une chaîne par un BIO de mise en tampon, il est donc possible de fournir la fonctionnalité B<BIO_gets>() si les BIO suivants ne le permettent pas (par exemple les BIO SSL).

note: type: textblock
en: Data is only written to the next BIO in the chain when the write buffer fills or when BIO_flush() is called. It is therefore important to call BIO_flush()  whenever any pending data should be written such as when removing a buffering BIO using BIO_pop(). BIO_flush() may need to be retried if the ultimate source/sink BIO is non blocking.
fr: Les données ne sont écrites sur le BIO suivant de la chaîne que lorsque le tampon d'écriture est plein ou que B<BIO_flush>() est appelée. Il est donc important d'appeler B<BIO_flush>() à chaque fois que des données en attente devraient être écrites comme lors de la suppression d'un BIO de mise en tampon en utilisant B<BIO_pop>(). B<BIO_flush>() pourrait devoir être réessayée si le dernier BIO source ou destination est non bloquant.

note: type: textblock
en: BIO_get_buffer_num_lines() returns the number of lines buffered (may be 0).
fr: B<BIO_get_buffer_num_lines>() renvoie le nombre de lignes en tampon (peut être B<0>).

note: type: textblock
en: BIO_set_read_buffer_size(), BIO_set_write_buffer_size() and BIO_set_buffer_size()  return 1 if the buffer was successfully resized or 0 for failure.
fr: B<BIO_set_read_buffer_size>(), B<BIO_set_write_buffer_size>() et B<BIO_set_buffer_size>() renvoient B<1> si la taille du tampon a pu être modifiée ou B<0> en cas d'échec.

note: type: textblock
en: BIO_set_buffer_read_data() returns 1 if the data was set correctly or 0 if there was an error.
fr: B<BIO_set_buffer_read_data>() renvoie B<1> si les données ont pu être positionnées correctement ou B<0> s'il y a eu une erreur.

note: type: textblock
en: BIO_f_null - null filter
fr: BIO_f_null - Filtre nul

note: type: textblock
en: BIO_f_null() returns the null filter BIO method. This is a filter BIO that does nothing.
fr: BIO_f_null() renvoie la méthode BIO correspondant à un filtre nul. Il s'agit d'un filtre BIO qui ne fait rien.

note: type: textblock
en: All requests to a null filter BIO are passed through to the next BIO in the chain: this means that a BIO chain containing a null filter BIO behaves just as though the BIO was not there.
fr: Toutes les requêtes envoyées à un filtre BIO nul sont passées au BIO suivant dans la chaîne : ceci signifie qu'une chaîne BIO contenant un filtre BIO nul se comporte comme s'il n'était pas présent.

note: type: textblock
en: As may be apparent a null filter BIO is not particularly useful.
fr: Comme vous vous en êtes peut-être aperçu, un filtre BIO nul n'est pas particulièrement utile.

note: type: textblock
en: BIO_f_null() returns the null filter BIO method.
fr: BIO_f_null() renvoie la méthode du filtre BIO nul.

note: type: =head1
en: EXAMPLE
fr: EXEMPLE

note: type: textblock
en: BIO_new, BIO_set, BIO_free, BIO_vfree, BIO_free_all - BIO allocation and freeing functions
fr: BIO_new, BIO_set, BIO_free, BIO_vfree, BIO_free_all - Fonctions d'allocation et libération de BIO

note: type: textblock
en: The BIO_new() function returns a new BIO using method B<type>.
fr: La fonction B<BIO_new>() renvoie un nouveau BIO utilisant la méthode B<type>.

note: type: textblock
en: BIO_set() sets the method of an already existing BIO.
fr: B<BIO_set>() définit la méthode d'un BIO déjà existant.

note: type: textblock
en: BIO_free() frees up a single BIO, BIO_vfree() also frees up a single BIO but it does not return a value. Calling BIO_free() may also have some effect on the underlying I/O structure, for example it may close the file being referred to under certain circumstances. For more details see the individual BIO_METHOD descriptions.
fr: B<BIO_free>() libère un seul BIO, B<BIO_vfree>() libère aussi un seul BIO mais ne renvoie pas de valeur. Appeler B<BIO_free>() pourrait aussi avoir un certain effet sur la structure d'entrées et sorties sous-jacente, par exemple elle pourrait fermer le fichier référencé dans certaines circonstances. Consultez les descriptions de chaque BIO_METHOD pour plus de précisions.

note: type: textblock
en: BIO_free_all() frees up an entire BIO chain, it does not halt if an error occurs freeing up an individual BIO in the chain.
fr: B<BIO_free_all>() libère toute une chaîne de BIO, elle ne s'arrête pas en cas d'erreur de libération d'un BIO de la chaîne.

note: type: textblock
en: BIO_new() returns a newly created BIO or NULL if the call fails.
fr: B<BIO_new>() renvoie un BIO nouvellement créé ou NULL si l'appel échoue.

note: type: textblock
en: BIO_set(), BIO_free() return 1 for success and 0 for failure.
fr: B<BIO_set>() et B<BIO_free>() renvoient 1 si elles réussissent et 0 si elles échouent.

note: type: textblock
en: BIO_free_all() and BIO_vfree() do not return values.
fr: B<BIO_free_all>() et B<BIO_vfree>() ne renvoient pas de valeur.

note: type: textblock
en: Some BIOs (such as memory BIOs) can be used immediately after calling BIO_new(). Others (such as file BIOs) need some additional initialization, and frequently a utility function exists to create and initialize such BIOs.
fr: Certains BIO (comme les BIO mémoire) peuvent être utilisés immédiatement après avoir appelé B<BIO_new>(). D'autres (comme les BIO fichier) ont besoin d'initialisation supplémentaire et une fonction utilitaire existe souvent pour créer et initialiser ce genre de BIO.

note: type: textblock
en: If BIO_free() is called on a BIO chain it will only free one BIO resulting in a memory leak.
fr: Si B<BIO_free>() est appelée sur une chaîne de BIO, elle ne libérera qu'un seul BIO avec pour conséquence une fuite de mémoire.

note: type: textblock
en: Calling BIO_free_all() a single BIO has the same effect as calling BIO_free()  on it other than the discarded return value.
fr: Appeler B<BIO_free_all>() sur un seul BIO a le même effet que d'appeler B<BIO_free>() dessus à part l'absence de valeur de retour.

note: type: textblock
en: Normally the B<type> argument is supplied by a function which returns a pointer to a BIO_METHOD. There is a naming convention for such functions: a source/sink BIO is normally called BIO_s_*() and a filter BIO BIO_f_*();
fr: L'argument I<type> est normalement fourni par une fonction qui renvoie un pointeur vers une BIO_METHOD. Une convention de nommage existe pour ce genre de fonction : un BIO source ou destination s'appelle B<BIO_s_>I<*>() et un BIO filtre B<BIO_f_>I<*>().

note: type: textblock
en: Create a memory BIO:
fr: Créer un BIO mémoire :

note: type: verbatim
en:  BIO_new_CMS - CMS streaming filter BIO
fr:  BIO_new_CMS - BIO filtre de flux CMS

note: type: textblock
en: BIO_new_CMS() returns a streaming filter BIO chain based on B<cms>. The output of the filter is written to B<out>. Any data written to the chain is automatically translated to a BER format CMS structure of the appropriate type.
fr: B<BIO_new_CMS>() renvoie une chaîne de BIO filtre de flux basée sur I<cms>. La sortie du filtre est écrite vers I<out>. Toutes les données écrites vers la chaîne sont automatiquement traduites en une structure CMS au format BER du type approprié.

note: type: textblock
en: The chain returned by this function behaves like a standard filter BIO. It supports non blocking I/O. Content is processed and streamed on the fly and not all held in memory at once: so it is possible to encode very large structures.  After all content has been written through the chain BIO_flush() must be called to finalise the structure.
fr: La chaîne renvoyée par cette fonction se comporte comme un BIO filtre standard. Elle permet les entrées et sorties non bloquantes. Le contenu est traité et envoyé en flux à la volée sans passer du tout en mémoire : il est donc possible d'encoder de très grandes structures. Après que tout le contenu a été écrit dans la chaîne, B<BIO_flush>() doit être appelée pour finaliser la structure.

note: type: textblock
en: The B<CMS_STREAM> flag must be included in the corresponding B<flags> parameter of the B<cms> creation function.
fr: L'attribut B<CMS_STREAM> doit être inclus dans le paramètre I<flags> correspondant de la fonction de création de I<cms>.

note: type: textblock
en: If an application wishes to write additional data to B<out> BIOs should be removed from the chain using BIO_pop() and freed with BIO_free() until B<out> is reached. If no additional data needs to be written BIO_free_all() can be called to free up the whole chain.
fr: Si une application désire écrire des données supplémentaires vers I<out>, les BIO devraient être supprimés de la chaîne en utilisant B<BIO_pop>() et libérés avec B<BIO_free>() jusqu'à ce que I<out> soit atteint. Si aucune donnée ne doit être écrite, B<BIO_free_all>() peut être appelée pour libérer toute la chaîne.

note: type: textblock
en: Any content written through the filter is used verbatim: no canonical translation is performed.
fr: Tout le contenu écrit par l'intermédiaire du filtre est utilisé verbatim : aucune traduction canonique n'est réalisée.

note: type: textblock
en: It is possible to chain multiple BIOs to, for example, create a triple wrapped signed, enveloped, signed structure. In this case it is the applications responsibility to set the inner content type of any outer CMS_ContentInfo structures.
fr: Plusieurs BIO peuvent être chaînés pour, par exemple, créer une structure triple — signée enveloppée, enveloppée et signée. Dans ce cas, définir le type de contenu interne de toutes les structures CMS_ContentInfo externes est de la responsabilité des applications.

note: type: textblock
en: Large numbers of small writes through the chain should be avoided as this will produce an output consisting of lots of OCTET STRING structures. Prepending a BIO_f_buffer() buffering BIO will prevent this.
fr: De nombreuses petites écritures à travers la chaîne sont à éviter car cela produira une sortie constituée de nombreuses structures OCTET STRING. Faire précéder par un BIO tampon B<BIO_f_buffer>() évitera cela.

note: type: textblock
en: There is currently no corresponding inverse BIO: i.e. one which can decode a CMS structure on the fly.
fr: Aucune fonction BIO inverse correspondante n'existe aujourd'hui, c'est-à-dire une capable de décoder une structure CMS à la volée.

note: type: textblock
en: BIO_new_CMS() returns a BIO chain when successful or NULL if an error occurred. The error can be obtained from ERR_get_error(3).
fr: B<BIO_new_CMS>() renvoie une chaîne de BIO ou NULL en cas d'erreur. L'erreur peut être obtenue à l'aide de L<ERR_get_error(3)|ERR_get_error(3)>.

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

note: type: textblock
en: BIO_new_CMS() was added to OpenSSL 1.0.0
fr: B<BIO_new_CMS>() a été ajoutée dans OpenSSL 1.0.0

note: type: textblock
en: BIO_push, BIO_pop - add and remove BIOs from a chain.
fr: BIO_push, BIO_pop - Ajouter et supprimer des BIO d'une chaîne

note: type: textblock
en: The BIO_push() function appends the BIO B<append> to B<b>, it returns B<b>.
fr: La fonction B<BIO_push>() ajoute le BIO I<append> à I<b>, elle renvoie I<b>.

note: type: textblock
en: BIO_pop() removes the BIO B<b> from a chain and returns the next BIO in the chain, or NULL if there is no next BIO. The removed BIO then becomes a single BIO with no association with the original chain, it can thus be freed or attached to a different chain.
fr: B<BIO_pop>() supprime le BIO I<b> d'une chaîne et renvoie le BIO suivant de la chaîne ou NULL s'il n'y a pas de BIO suivant. Le BIO supprimé devient alors un simple BIO sans association avec la chaîne d'origine, il peut donc être libéré ou attaché à une autre chaîne.

note: type: textblock
en: The names of these functions are perhaps a little misleading. BIO_push()  joins two BIO chains whereas BIO_pop() deletes a single BIO from a chain, the deleted BIO does not need to be at the end of a chain.
fr: Les noms de ces fonctions peuvent peut-être prêter un peu à confusion. B<BIO_push>() joint deux chaînes de BIO alors que B<BIO_pop>() supprime un seul BIO d'une chaîne, le BIO supprimé ne doit pas forcément être à la fin d'une chaîne.

note: type: textblock
en: The process of calling BIO_push() and BIO_pop() on a BIO may have additional consequences (a control call is made to the affected BIOs) any effects will be noted in the descriptions of individual BIOs.
fr: Le processus d'appeler B<BIO_push>() et B<BIO_pop>() sur un BIO pourrait avoir des conséquences supplémentaires (un appel de contrôle est fait sur les BIO affectés), tous les effets seront notés dans les descriptions de chaque BIO.

note: type: textblock
en: For these examples suppose B<md1> and B<md2> are digest BIOs, B<b64> is a base64 BIO and B<f> is a file BIO.
fr: Pour ces exemples, I<md1> et I<md2> sont supposés être des BIO de signature, I<b64> est un BIO en base64 et I<f> est un BIO fichier.

note: type: textblock
en: If the call:
fr: Si l'appel :

note: type: textblock
en: is made then the new chain will be B<b64-f>. After making the calls
fr: est fait, alors la nouvelle chaîne sera I<b64-f>. Après avoir fait les appels

note: type: textblock
en: the new chain is B<md1-md2-b64-f>. Data written to B<md1> will be digested by B<md1> and B<md2>, B<base64> encoded and written to B<f>.
fr: la nouvelle chaîne est I<md1-md2-b64-f>. Les données écrites vers I<md1> seront signées par I<md1> et I<md2>, encodées en B<base64> et écrites vers I<f>.

note: type: textblock
en: It should be noted that reading causes data to pass in the reverse direction, that is data is read from B<f>, base64 B<decoded> and digested by B<md1> and B<md2>. If the call:
fr: Remarquez que la lecture force les données à passer en sens inverse, c'est-à-dire que les données sont lues de I<f>, B<décodées> de base64 et signées par I<md1> et I<md2>. Si l'appel :

note: type: textblock
en: The call will return B<b64> and the new chain will be B<md1-b64-f> data can be written to B<md1> as before.
fr: L'appel renverra I<b64> et la nouvelle chaîne sera I<md1-b64-f>, les données peuvent être écrites vers I<md1> comme avant.

note: type: textblock
en: BIO_push() returns the end of the chain, B<b>.
fr: B<BIO_push>() renvoie la fin de la chaîne, I<b>.

note: type: textblock
en: BIO_pop() returns the next BIO in the chain, or NULL if there is no next BIO.
fr: B<BIO_pop>() renvoie le BIO suivant de la chaîne ou NULL s'il n'y a pas de BIO suivant.

note: type: textblock
en: BIO_read, BIO_write, BIO_gets, BIO_puts - BIO I/O functions
fr: BIO_read, BIO_write, BIO_gets, BIO_puts - Fonctions d'entrées et sorties de BIO

note: type: textblock
en: BIO_read() attempts to read B<len> bytes from BIO B<b> and places the data in B<buf>.
fr: B<BIO_read>() essaye de lire I<len> octets du BIO I<b> et place les données dans I<buf>.

note: type: textblock
en: BIO_gets() performs the BIOs "gets" operation and places the data in B<buf>. Usually this operation will attempt to read a line of data from the BIO of maximum length B<len>. There are exceptions to this however, for example BIO_gets() on a digest BIO will calculate and return the digest and other BIOs may not support BIO_gets() at all.
fr: B<BIO_gets>() réalise l'opération « gets » des BIO et place les données dans I<buf>. Normalement, cette opération essayera de lire une ligne de données de taille maximale I<len> du BIO. Il y a cependant des exceptions à cela, par exemple B<BIO_gets>() sur un BIO de signature calculera et renverra la signature mais d'autres BIO pourraient ne pas prendre B<BIO_gets>() en charge du tout.

note: type: textblock
en: BIO_write() attempts to write B<len> bytes from B<buf> to BIO B<b>.
fr: B<BIO_write>() essaye d'écrire I<len> octets de I<buf> sur le BIO I<b>.

note: type: textblock
en: BIO_puts() attempts to write a null terminated string B<buf> to BIO B<b>
fr: B<BIO_puts>() essaye d'écrire une chaîne I<buf> terminée par null sur le BIO I<b>.

note: type: textblock
en: All these functions return either the amount of data successfully read or written (if the return value is positive) or that no data was successfully read or written if the result is 0 or -1. If the return value is -2 then the operation is not implemented in the specific BIO type.
fr: Toutes ces fonctions renvoient soit la quantité de données lues ou écrites correctement (si la valeur de retour est positive), soit 0 ou -1 si aucune donnée n'a été lue ou écrite, soit -2 si l'opération n'est pas implémentée dans ce type de BIO en particulier.

note: type: textblock
en: A 0 or -1 return is not necessarily an indication of an error. In particular when the source/sink is non-blocking or of a certain type it may merely be an indication that no data is currently available and that the application should retry the operation later.
fr: Une valeur de retour de 0 ou -1 n'est pas forcément une indication d'erreur. En particulier quand la source ou la destination sont non bloquantes ou d'un certain type, cela pourrait juste être une indication qu'aucune donnée n'est actuellement disponible et que l'application devrait réessayer l'opération plus tard.

note: type: textblock
en: One technique sometimes used with blocking sockets is to use a system call (such as select(), poll() or equivalent) to determine when data is available and then call read() to read the data. The equivalent with BIOs (that is call select() on the underlying I/O structure and then call BIO_read() to read the data) should B<not> be used because a single call to BIO_read()  can cause several reads (and writes in the case of SSL BIOs) on the underlying I/O structure and may block as a result. Instead select() (or equivalent)  should be combined with non blocking I/O so successive reads will request a retry instead of blocking.
fr: Une technique parfois utilisée avec les sockets bloquantes est d'utiliser un appel système (comme B<select>(), B<poll>() ou équivalent) pour déterminer quand les données sont disponibles et ensuite d'appeler B<read>() pour lire les données. L'équivalent avec les BIO (c'est-à-dire appeler B<select>() sur la structure d'entrées et sorties sous-jacente et ensuite d'appeler B<BIO_read>() pour lire les données) ne devrait B<pas> être utilisé parce qu'un simple appel de B<BIO_read>() peut provoquer plusieurs lectures (et écritures dans le cas des BIO SSL) sur la structure d'entrées et sorties sous-jacente et pourrait par conséquent bloquer. À la place, B<select>() (ou équivalent) devrait être combiné avec des entrées et sorties non bloquantes pour que les lectures successives demandent à réessayer au lieu de bloquer.

note: type: textblock
en: See L<BIO_should_retry(3)|BIO_should_retry(3)> for details of how to determine the cause of a retry and other I/O issues.
fr: Consultez L<BIO_should_retry(3)|BIO_should_retry(3)> pour des précisions sur la façon de déterminer la cause d'un réessai ou tout autre problème d'entrées et sorties.

note: type: textblock
en: If the BIO_gets() function is not supported by a BIO then it possible to work around this by adding a buffering BIO L<BIO_f_buffer(3)|BIO_f_buffer(3)> to the chain.
fr: Si la fonction B<BIO_gets>() n'est pas prise en charge par un BIO, alors contourner cela est possible en ajoutant un BIO tampon L<BIO_f_buffer(3)|BIO_f_buffer(3)> à la chaîne.

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

note: type: textblock
en: BIO_s_connect, BIO_new_connect, BIO_set_conn_hostname, BIO_set_conn_port, BIO_set_conn_ip, BIO_set_conn_int_port, BIO_get_conn_hostname, BIO_get_conn_port, BIO_get_conn_ip, BIO_get_conn_int_port, BIO_set_nbio, BIO_do_connect - connect BIO
fr: BIO_s_connect, BIO_new_connect, BIO_set_conn_hostname, BIO_set_conn_port, BIO_set_conn_ip, BIO_set_conn_int_port, BIO_get_conn_hostname, BIO_get_conn_port, BIO_get_conn_ip, BIO_get_conn_int_port, BIO_set_nbio, BIO_do_connect - Connecter un BIO

note: type: textblock
en: BIO_set_conn_hostname(), BIO_set_conn_port(), BIO_set_conn_ip(), BIO_set_conn_int_port(), BIO_get_conn_hostname(), BIO_get_conn_port(), BIO_get_conn_ip(), BIO_get_conn_int_port(), BIO_set_nbio() and BIO_do_connect() are macros.
fr: BIO_set_conn_hostname(), BIO_set_conn_port(), BIO_set_conn_ip(), BIO_set_conn_int_port(), BIO_get_conn_hostname(), BIO_get_conn_port(), BIO_get_conn_ip(), BIO_get_conn_int_port(), BIO_set_nbio() et BIO_do_connect() sont des macros.

note: type: textblock
en: BIO_get_fd() returns the socket or -1 if the BIO has not been initialized.
fr: BIO_get_fd() renvoie la socket ou -1 si le BIO n'a pas été initialisé.

note: type: textblock
en: BIO_set_conn_hostname(), BIO_set_conn_port(), BIO_set_conn_ip() and BIO_set_conn_int_port() always return 1.
fr: BIO_set_conn_hostname(), BIO_set_conn_port(), BIO_set_conn_ip() et BIO_set_conn_int_port() renvoient toujours 1.

note: type: textblock
en: BIO_get_conn_hostname() returns the connected hostname or NULL is none was set.
fr: BIO_get_conn_hostname() renvoie le nom de l'hôte connecté ou NULL s'il n'y en a pas.

note: type: textblock
en: BIO_get_conn_port() returns a string representing the connected port or NULL if not set.
fr: BIO_get_conn_port() renvoie une chaîne représentant le port connecté ou NULL s'il n'y en a pas.

note: type: textblock
en: BIO_get_conn_ip() returns a pointer to the connected IP address in binary form or all zeros if not set.
fr: BIO_get_conn_ip() renvoie un pointeur vers l'adresse IP connectée sous forme binaire ou que des zéro s'il n'y en a pas.

note: type: textblock
en: BIO_get_conn_int_port() returns the connected port or 0 if none was set.
fr: BIO_get_conn_int_port() renvoie le port connecté ou 0 s'il n'y en a pas.

note: type: textblock
en: BIO_set_nbio() always returns 1.
fr: BIO_set_nbio() renvoie toujours 1.

note: type: textblock
en: BIO_do_connect() returns 1 if the connection was successfully established and 0 or -1 if the connection failed.
fr: BIO_do_connect() renvoie 1 si la connexion a été établie avec succès et 0 ou -1 si la connexion a échoué.

note: type: textblock
en: This is example connects to a webserver on the local host and attempts to retrieve a page and copy the result to standard output.
fr: Voici un exemple qui se connecte à un serveur web sur l'hôte local, tente de récupérer une page, puis copie le résultat sur la sortie standard.

note: type: textblock
en: BIO_set_fd() always returns 1.
fr: BIO_set_fd() renvoie toujours 1.

note: type: textblock
en: Alternative technique:
fr: Technique alternative :

note: type: textblock
en: BIO_s_null - null data sink
fr: BIO_s_null - Destination de données NULL

note: type: textblock
en: BIO_s_null() returns the null sink BIO method. Data written to the null sink is discarded, reads return EOF.
fr: B<BIO_s_null>() renvoie la méthode de BIO destination NULL. Les données écrites vers la destination NULL sont ignorées, les lectures renvoient EOF.

note: type: textblock
en: A null sink BIO behaves in a similar manner to the Unix /dev/null device.
fr: Un BIO destination NULL se comporte de façon similaire au périphérique UNIX /dev/null.

note: type: textblock
en: A null bio can be placed on the end of a chain to discard any data passed through it.
fr: Un BIO NULL peut être placé à la fin d'une chaîne pour ignorer toutes les données qui lui sont passées.

note: type: textblock
en: A null sink is useful if, for example, an application wishes to digest some data by writing through a digest bio but not send the digested data anywhere.  Since a BIO chain must normally include a source/sink BIO this can be achieved by adding a null sink BIO to the end of the chain
fr: Une destination NULL est utile si, par exemple, une application désire calculer quelques données en écrivant par un BIO d'algorithme mais sans envoyer les données calculées nulle part. Puisqu'une chaîne BIO doit normalement inclure un BIO source ou destination, cela peut être réalisé en ajoutant un BIO destination NULL à la fin de la chaîne.

note: type: textblock
en: BIO_s_null() returns the null sink BIO method.
fr: B<BIO_s_null>() renvoie la méthode de BIO destination NULL.

note: type: textblock
en: bio - I/O abstraction
fr: bio - Abstraction d'entrées-sorties

note: type: textblock
en: A BIO is an I/O abstraction, it hides many of the underlying I/O details from an application. If an application uses a BIO for its I/O it can transparently handle SSL connections, unencrypted network connections and file I/O.
fr: Un BIO est une abstraction d'entrées-sorties. Il cache beaucoup des détails des entrées-sorties sous-jacentes à l'application. Si une application utilise un BIO pour ses entrées-sorties, elle peut prendre en charge de façon transparente des connexions SSL, des connections réseau non chiffrées et des entrées-sorties utilisant des fichiers.

note: type: textblock
en: There are two type of BIO, a source/sink BIO and a filter BIO.
fr: Il y a deux types de BIO, un BIO de type source/destination et un BIO de type filtre.

note: type: textblock
en: As its name implies a source/sink BIO is a source and/or sink of data, examples include a socket BIO and a file BIO.
fr: Comme son nom l'indique le BIO source/destination est une source et/ou une destination pour des données, comme par exemple un BIO socket et un BIO fichier.

note: type: textblock
en: A filter BIO takes data from one BIO and passes it through to another, or the application. The data may be left unmodified (for example a message digest BIO) or translated (for example an encryption BIO). The effect of a filter BIO may change according to the I/O operation it is performing: for example an encryption BIO will encrypt data if it is being written to and decrypt data if it is being read from.
fr: Un BIO filtre prend des données dans un BIO et les passe à un autre ou à l'application. Les données peuvent rester inchangées (par exemple un BIO de signature de message) ou traduites (par exemple un BIO de chiffrement). Les effets d'un BIO filtre peuvent varier en fonction de l'opération d'entrées-sorties effectuée : par exemple un BIO de chiffrement chiffrera les données si on écrit dedans et déchiffrera les données si on y lit.

note: type: textblock
en: BIOs can be joined together to form a chain (a single BIO is a chain with one component). A chain normally consist of one source/sink BIO and one or more filter BIOs. Data read from or written to the first BIO then traverses the chain to the end (normally a source/sink BIO).
fr: Des BIO peuvent être attaché les uns aux autres pour former une chaîne (une BIO unique est une chaîne avec un seul composant). Une chaîne consiste normalement en un BIO source/destination et un filtre ou plus. Les données lues ou écrites dans le premier BIO traversent la chaîne jusqu'au bout (normalement un BIO source/destination).
