Provided by: manpages-fr-extra_20151231_all bug

NOM

       CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback, CRYPTO_THREADID_current,
       CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy, CRYPTO_THREADID_hash,
       CRYPTO_set_locking_callback, CRYPTO_num_locks, CRYPTO_set_dynlock_create_callback,
       CRYPTO_set_dynlock_lock_callback, CRYPTO_set_dynlock_destroy_callback,
       CRYPTO_get_new_dynlockid, CRYPTO_destroy_dynlockid, CRYPTO_lock - support de thread
       d'OpenSSL

SYNOPSIS

        #include <openssl/crypto.h>

        /* N'utilisez pas cette structure directement. */
        typedef struct crypto_threadid_st
                {
                void *ptr;
                unsigned long val;
                } CRYPTO_THREADID;
        /* Utilisez seulement CRYPTO_THREADID_set_[numeric|pointer]() à l'intérieur des rétroactions */
        void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val);
        void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr);
        int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *));
        void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *);
        void CRYPTO_THREADID_current(CRYPTO_THREADID *id);
        int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a,
                                const CRYPTO_THREADID *b);
        void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest,
                                 const CRYPTO_THREADID *src);
        unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id);

        int CRYPTO_num_locks(void);

        /* struct CRYPTO_dynlock_value doit être défini par l'utilisateur */
        struct CRYPTO_dynlock_value;

        void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value *
               (*dyn_create_function)(char *file, int line));
        void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function)
               (int mode, struct CRYPTO_dynlock_value *l,
               const char *file, int line));
        void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function)
               (struct CRYPTO_dynlock_value *l, const char *file, int line));

        int CRYPTO_get_new_dynlockid(void);

        void CRYPTO_destroy_dynlockid(int i);

        void CRYPTO_lock(int mode, int n, const char *file, int line);

        #define CRYPTO_w_lock(type)    \
               CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
        #define CRYPTO_w_unlock(type)  \
               CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,__FILE__,__LINE__)
        #define CRYPTO_r_lock(type)    \
               CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,__FILE__,__LINE__)
        #define CRYPTO_r_unlock(type)  \
               CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,__FILE__,__LINE__)
        #define CRYPTO_add(addr,amount,type)   \
               CRYPTO_add_lock(addr,amount,type,__FILE__,__LINE__)

DESCRIPTION

       OpenSSL peut être utilisé de façon sûre dans des applications multithreadées si deux
       fonctions rétroactives locking_function et threadid_func sont initialisées.

       locking_function(int mode, int n, const char *file, int line) est nécessaire pour
       verrouiller des structures de données partagées. (Notez qu'OpenSSL utilise un certain
       nombre de structures de données globales qui seront partagées de façon implicite à chaque
       fois que plusieurs threads utiliseront OpenSSL). Les applications multithreadées peuvent
       planter de façon aléatoire si elle n'est pas initialisée.

       locking_function() doit être capable de gérer jusqu'à CRYPTO_num_locks() mutex de verrous
       différents. Elle règle le nème verrou si mode & CRYPTO_LOCK, et le libère dans le cas
       contraire.

       file et line sont le numéro du fichier de la fonction qui pose le verrou. Ils peuvent être
       utilisés pour déboguer.

       threadid_func(CRYPTO_THREADID *id) est nécessaire pour enregistrer les identifiants des
       threads en cours d'exécution dans id. L'implémentation de cette rétroaction ne doit pas
       remplir id directement, mais doit utiliser CRYPTO_THREADID_set_numeric() si les ID des
       threads sont numériques, ou CRYPTO_THREADID_set_pointer() si ce sont des pointeurs. Si
       l'application n'enregistre pas ce genre de rétroactions en utilisant
       CRYPTO_THREADID_set_callback(), alors une implémentation par défaut est utilisée — sur
       Windows et BeOS cela utilise les API d'identification de threads par défaut, sur toutes
       les autres plateformes, cela utilise l'adresse de errno. Cette dernière est satisfaisante
       pour la sécurité des threads si et seulement si la plateforme dispose d'un identifiant
       numérique d'erreur pour les threads locaux.

       Une fois que threadid_func() est enregistrée, ou si l'implémentation par défaut doit être
       utilisée ;

       ·   CRYPTO_THREADID_current() enregistre les ID des threads en cours d'exécution dans
           l'objet id donné.

       ·   CRYPTO_THREADID_cmp() compare deux ID de threads (renvoyant 0 pour égalité,
           c'est-à-dire avec la même sémantique que memcmp()).

       ·   CRYPTO_THREADID_cpy() duplique la valeur d'ID d'un thread.

       ·   CRYPTO_THREADID_hash() renvoie une valeur numérique utilisable comme une clé de table
           de hachage. Celle-ci est en général la valeur numérique exacte ou un pointeur vers
           l'ID du thread utilisé en interne, mais cela gère aussi les cas peu courants où les
           pointeurs sont plus longs que les variables « long » et les ID des pointeurs dans la
           plateforme sont basés sur des pointeurs — dans ce cas, un mélange est fait pour
           essayer de produire une valeur unique même si elle n'est pas aussi grande que l'ID
           réel du thread dans la plateforme.

       De plus, OpenSSL supporte les verrous dynamiques, et parfois, certaines parties d'OpenSSL
       en ont besoin pour de meilleures performances. Pour activer cela, les choses suivantes
       sont nécessaires :

       ·   Trois fonctions rétroactives en plus, dyn_create_function, dyn_lock_function et
           dyn_destroy_function.

       ·   Une structure définie à partir des données que chaque verrou doit manipuler.

       struct CRYPTO_dynlock_value doit être défini de façon à pouvoir contenir n'importe quelle
       structure nécessaire à la gestion des verrous.

       dyn_create_function(const char *file, int line) est nécessaire pour créer un verrou. Les
       applications multithreadées peuvent planter de façon aléatoire si elle n'est pas
       initialisée.

       dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line) est nécessaire
       pour verrouiller le verrou dynamique numéro n. Les applications multithreadées peuvent
       planter de façon aléatoire si elle n'est pas initialisée.

       dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) est nécessaire pour
       détruire le verrou I. Les applications multithreadées peuvent planter de façon aléatoire
       si elle n'est pas initialisée.

       CRYPTO_get_new_dynlockid() est utilisée pour créer les verrous. Elle appellera
       dyn_create_function pour la création.

       CRYPTO_destroy_dynlockid() est utilisée pour détruire les verrous. Elle appellera
       dyn_destroy_function pour la destruction.

       CRYPTO_lock() est utilisée pour verrouiller et déverrouiller les verrous. Mode est un
       champ de bits décrivant ce qui doit être fait avec le verrou. n est le nombre de verrous
       comme renvoyé par CRYPTO_get_new_dynlockid(). mode peut être combiné à partir des valeurs
       suivantes. Ces valeurs sont mutuellement exclusives, avec un comportement indéfini si
       elles sont mal utilisées (par exemple, CRYPTO_READ et CRYPTO_WRITE ne doivent pas être
       utilisées ensemble).

               CRYPTO_LOCK     0x01
               CRYPTO_UNLOCK   0x02
               CRYPTO_READ     0x04
               CRYPTO_WRITE    0x08

VALEURS DE RETOUR

       CRYPTO_num_locks() renvoie le nombre nécessaire de verrous.

       CRYPTO_get_new_dynlockid() renvoie l'index vers le verrou nouvellement créé.

       Les autres fonctions ne renvoient pas de valeur.

NOTES

       Vous pouvez savoir si la gestion des threads d'OpenSSL a été activée avec :

        #define OPENSSL_THREAD_DEFINES
        #include <openssl/opensslconf.h>
        #if defined(OPENSSL_THREADS)
          // support de thread activé
        #else
          // pas de support de thread
        #endif

       Aussi, les verrous dynamiques ne sont actuellement pas utilisés en interne par OpenSSL,
       mais cela peut changer dans le futur.

EXEMPLES

       crypto/threads/mttest.c montre des exemples d'utilisation des fonctions rétroactives sur
       Solaris, Irix et Win32.

HISTORIQUE

       CRYPTO_set_locking_callback() est disponible dans toutes les versions de SSLeay et
       d'OpenSSL. CRYPTO_num_locks() a été ajoutée dans OpenSSL 0.9.4. Toutes les fonctions
       traitant des verrous dynamiques ont été ajoutées dans OpenSSL 0.9.5b-dev. CRYPTO_THREADID
       et les fonctions qui lui sont associées ont été introduites dans OpenSSL 1.0.0 pour
       remplacer (en fait, pour rendre obsolète) les anciennes fonctions
       CRYPTO_set_id_callback(), CRYPTO_get_id_callback() et CRYPTO_thread_id() qui supposaient
       que les ID des threads étaient toujours représentés par un « unsigned long ».

VOIR AUSSI

       crypto(3)

TRADUCTION

       La traduction de cette page de manuel est maintenue par les membres de la liste
       <debian-l10n-french AT lists DOT debian DOT org>. Veuillez signaler toute erreur de
       traduction par un rapport de bogue sur le paquet manpages-fr-extra.