Section courante

A propos

Section administrative du site

 Langage  Elément  Programmation  Bibliothèque  Projet  Compilateur  Débogueur  IDE  Annexe  Aide 
ABAP/4
Ada
Assembleur
Assembly & bytecode
ASP (Active Server Pages)
Basic
C
C++
C# (C Sharp)
Cobol
ColdFusion
Fortran
HTML
Java
JavaScript
LISP
Logo
LotusScript
Oberon
Pascal
Perl
PHP
PL/1
Prolog
Python
Rebol
REXX
Ruby
SAS
NoSQL
SQL
Swift
X++ (Axapta)
GNAT
SMALLAda
VHDL
Assembleur 370
Assembleur 1802
Assembleur 4004
Assembleur 6502
Assembleur 6800
Assembleur 68000
Assembleur 8080 et 8085
Assembleur 8089
Assembleur 80x86
Assembleur AGC4
Assembleur ARM
Assembleur DPS 8000
Assembleur i860
Assembleur Itanium
Assembleur MIPS
Assembleur PDP-11
Assembleur PowerPC
Assembleur RISC-V
Assembleur SPARC
Assembleur SuperH
Assembleur UNIVAC I
Assembleur VAX
Assembleur Z80
Assembleur Z8000
Assembleur z/Architecture
ASSEMBLER/MONITOR 64
Micol Assembler
GFA Assembler
A86
MASM (Macro Assembler)
TASM (Turbo Assembler)
CIL
Jasmin
LLVM
MSIL
Parrot
P-Code (PCode)
SWEET16
G-Pascal
ASP 1.0
ASP 2.0
ASP 3.0
ASP.NET
ASP.NET Core
ABasiC (Amiga)
Adam SmartBASIC
Altair BASIC
AmigaBASIC (Amiga)
AMOS Basic (Amiga)
Atari Basic (Atari 400, 600 XL, 800, 800XL)
Basic Apple II (Integer BASIC/APPLESOFT)
Basic Commodore 64 (CBM-BASIC)
Basic Commodore 128 (BASIC 7.0)
Basic Commodore VIC-20 (CBM-BASIC 2.0)
Basic Coco 1 (Color Basic)
Basic Coco 2 (Extended Color Basic)
Basic Coco 3 (Extended Color Basic 2.0)
BASICA (PC DOS)
Basic Pro
BBC BASIC
Blitz BASIC (Amiga)
DarkBASIC
Dartmouth BASIC
GFA-Basic (Atari ST/Amiga)
GWBASIC (MS-DOS)
Liberty BASIC
Locomotive BASIC (Amstrad CPC)
MSX-Basic
Omikron Basic (Atari ST)
Oric Extended Basic
Power Basic
Quick Basic/QBasic (MS-DOS)
Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
ST BASIC (Atari ST)
Turbo Basic
Vintage BASIC
VBScript
Visual Basic (VB)
Visual Basic .NET (VB .NET)
Visual Basic pour DOS
Yabasic
BeckerBASIC
SIMONS' BASIC
Basic09 d'OS-9
Disk Extended Color Basic
Basic09 d'OS-9
Disk Extended Color Basic
Access
Excel
Visual Basic pour Windows
Visual Basic .NET pour Windows
C Shell Unix (csh)
C pour Amiga
C pour Atari ST
C pour DOS
C pour Falcon030
C pour GEMDOS (Atari ST)
C pour Linux
C pour PowerTV OS
C pour OS/2
C pour Unix
C pour Windows
Aztec C
CoCo-C
GNU C
HiSoft C
IBM C/2
Introl-C
Lattice C
Microsoft C
MinGW C
MSX-C
Open Watcom C
OS-9 C Compiler
Pure C
Quick C
Turbo C
HiSoft C for Atari ST
HiSoft C for CP/M (Amstrad CPC)
C++ pour OS/2
C++ pour Windows
Borland C++
C++Builder
IBM VisualAge C++
Intel C++
MinGW C++
Open Watcom C++
Symantec C++
Turbo C++
Visual C++
Visual C++ .NET
Watcom C++
Zortech C++
C# (C Sharp) pour Windows
Apple III Cobol
Microsoft Cobol
BlueDragon
Lucee
OpenBD
Railo
Smith Project
Microsoft Fortran
WATFOR-77
CSS
FBML
Open Graph
SVG
XML
XSL/XSLT
LESS
SASS
GCJ (GNU)
JSP
Jython
Visual J++
Node.js
TypeScript
AutoLISP
ACSLogo
LotusScript pour Windows
Amiga Oberon
Oberon .NET
Apple Pascal
Delphi/Kylix/Lazarus
Free Pascal
GNU Pascal
HighSpeed Pascal
IBM Personal Computer Pascal
Lisa Pascal
Maxon Pascal
MPW Pascal
OS-9 Pascal
OSS Personal Pascal
Pascal-86
Pascal du Cray Research
Pascal/VS
Pascal-XT
PURE Pascal
QuickPascal
RemObjets Chrome
Sun Pascal
THINK Pascal
Tiny Pascal (TRS-80)
Turbo Pascal
UCSD Pascal
VAX Pascal
Virtual Pascal
Turbo Pascal for CP/M-80
Turbo Pascal for DOS
Turbo Pascal for Macintosh
Turbo Pascal for Windows
CodeIgniter (Cadre d'application)
Drupal (Projet)
Joomla! (Projet)
Phalanger (PHP .NET)
phpBB (Projet)
Smarty (balise)
Twig (balise)
Symfony (Cadre d'application)
WordPress (Projet)
Zend (Cadre d'application)
PL360
PL/M-80
PL/M-86
Turbo Prolog
CPython
IronPython
Jython
PyPy
AREXX
Regina REXX
JMP
Btrieve
Cassandra
Clipper
CouchDB
dBASE
Hbase
Hypertable
MongoDB
Redis
Access
BigQuery
DB2
H2
Interbase
MySQL
Oracle
PostgreSQL
SAP HANA
SQL Server
Sybase
U-SQL
Type de données élémentaires
Structure de données Linux
Fichier d'entête
Référence des fonctions
aalib.h
adime.h
allegro.h
assert.h
ctype.h
math.h
SDL/SDL.h
setjmp.h
signal.h
stdarg.h
stdio.h
stdlib.h
string.h
time.h
unistd.h
X11/Xutil.h
zip.h
Bonjour
glibc
OpenGL
Eigen
Noyau Linux (Kernel)
KDE
GNU C
Clang
IBM VisualAge C++
Intel C++
GNU Debugger (GDB)
CodeBlocks
Eclipse
KDevelop
NetBeans
gcc
Bibliographie
Préface
Notes légal
Dictionnaire
Recherche

openssl/bio.h

BIO
C pour Linux

Description

Cette bibliothèque renferme les routines du BIO.

Liste des fonctions

Nom Prototype Description
BIO_APPEND_FILENAME int BIO_append_filename(BIO *b, char *name); Cette fonction permet de fixer en mode ajouter un nom de fichier spécifié dans un mécanisme BIO.
BIO_CALLBACK_CTRL long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long)); Cette fonction permet d'effectuer des opérations utilisateur pour des types variés dans un mécanisme BIO.
BIO_CTRL long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg); Cette fonction permet d'effectuer des opérations de contrôle pour des types variés dans un mécanisme BIO.
BIO_CTRL_GET_READ_REQUEST size_t BIO_ctrl_get_read_request(BIO *b); Cette fonction permet de demander la quantité de données requises pour un contrôle dans un mécanisme BIO.
BIO_CTRL_GET_WRITE_GUARANTEE size_t BIO_ctrl_get_write_guarantee(BIO *b); Cette fonction permet de demander la longueur maximal de données pouvant être écrite pour un contrôle dans un mécanisme BIO.
BIO_CTRL_PENDING size_t BIO_ctrl_pending(BIO *b); Cette fonction permet de demander le nombre de caractères en attente dans le tampon de lecture et d'écriture pour le contrôle en utilisant un mécanisme BIO.
BIO_CTRL_RESET_READ_REQUEST int BIO_ctrl_reset_read_request(BIO *b); Cette fonction permet de réinitialiser à 0 la valeur retourné par la fonction BIO_get_read_request() avec un mécanisme BIO.
BIO_CTRL_WPENDING size_t BIO_ctrl_wpending(BIO *b); Cette fonction permet de demander le nombre de caractères en attente dans le tampon d'écriture pour le contrôle en utilisant un mécanisme BIO.
BIO_DEBUG_CALLBACK long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi, long argl,long ret); Cette fonction permet d'indiquer une fonction utilisateur pour le déboguage en utilisant un mécanisme BIO.
BIO_DO_ACCEPT int BIO_do_accept(BIO *b); Cette fonction permet d'accepter la création d'un socket et la liaison d'une adresse en utilisant un mécanisme BIO.
BIO_DO_CONNECT int BIO_do_connect(BIO *b); Cette fonction permet d'effectuer une connexion en utilisant un mécanisme BIO.
BIO_EOF int BIO_eof(BIO *b); Cette fonction permet d'indiquer si la fin est atteinte dans un mécanisme BIO.
BIO_F_BASE64 BIO_METHOD * BIO_f_base64(void); Cette fonction permet de demander une méthode de filtre de base 64 dans un mécanisme BIO.
BIO_F_BUFFER BIO_METHOD * BIO_f_buffer(void); Cette fonction permet de demander une méthode de filtre de tamporisation dans un mécanisme BIO.
BIO_F_CIPHER BIO_METHOD * BIO_f_cipher(void); Cette fonction permet de demander une méthode de filtre de chiffrement dans un mécanisme BIO.
BIO_F_MD BIO_METHOD * BIO_f_md(void); Cette fonction permet de demander une méthode de filtre de message sommaire dans un mécanisme BIO.
BIO_F_NULL BIO_METHOD * BIO_f_null(void); Cette fonction permet de demander une méthode de filtre nulle dans un mécanisme BIO.
BIO_F_SSL BIO_METHOD *BIO_f_ssl(void); Cette fonction permet de demander une méthode SSL dans un mécanisme BIO.
BIO_FIND_TYPE BIO * BIO_find_type(BIO *b,int bio_type); Cette fonction permet d'effectuer une recherche d'un type spécifié dans un mécanisme BIO.
BIO_FLUSH int BIO_flush(BIO *b); Cette fonction permet de vider les tampons du mécanisme BIO.
BIO_FREE int BIO_free(BIO *a); Cette fonction permet de libérer les ressources du mécanisme BIO.
BIO_FREE_ALL void BIO_free_all(BIO *a); Cette fonction permet de libérer tous les ressources du mécanisme BIO.
BIO_GET_ACCEPT_PORT char *BIO_get_accept_port(BIO *b); Cette fonction permet de demander un port acceptant dans un mécanisme BIO.
BIO_GET_BIND_MODE long BIO_get_bind_mode(BIO *b, long dummy); Cette fonction permet de demander le mode de liaison dans un mécanisme BIO.
BIO_GET_CIPHER_CTX int BIO_get_cipher_ctx(BIO *b, EVP_CIPHER_CTX **pctx); Cette fonction permet de demander le contexte de décryptage dans un mécanisme BIO.
BIO_GET_CIPHER_STATUS int BIO_get_cipher_status(BIO *b); Cette fonction permet de demander si le décryptage et la vérification d'une fin de fichier a été détecté dans un mécanisme BIO.
BIO_GET_CLOSE int BIO_get_close(BIO *b); Cette fonction permet de demander l'état de fermeture dans un mécanisme BIO.
BIO_GET_CONN_HOSTNAME char *BIO_get_conn_hostname(BIO *b); Cette fonction permet de demander le nom de l'hôte de la communication TCP/IP dans un mécanisme BIO.
BIO_GET_CONN_INT_PORT long BIO_get_conn_int_port(BIO *b, int port); Cette fonction permet de demander l'entier du port de communication TCP/IP dans un mécanisme BIO.
BIO_GET_CONN_IP char *BIO_get_conn_ip(BIO *b, dummy); Cette fonction permet de demander l'IP pour une communication TCP/IP dans un mécanisme BIO.
BIO_GET_CONN_PORT char *BIO_get_conn_port(BIO *b); Cette fonction permet de demander le port de communication TCP/IP dans un mécanisme BIO.
BIO_GET_FP BIO_get_fp(BIO *b,FILE **fpp); Cette fonction permet de demander le pointeur de fichier dans un mécanisme BIO.
BIO_GET_INFO_CALLBACK int BIO_get_info_callback(BIO *b,bio_info_cb **cbp); Cette fonction permet de demander les informations sur une fonction utilisateur d'un mécanisme BIO.
BIO_GET_MD int BIO_get_md(BIO *b,EVP_MD **mdp); Cette fonction permet de demander une méthode d'un mécanisme BIO.
BIO_GET_MD_CTX int BIO_get_md_ctx(BIO *b,EVP_MD_CTX **mdcp); Cette fonction permet de demander le contexte dans un mécanisme BIO.
BIO_GET_MEM_DATA long BIO_get_mem_data(BIO *b, char **pp) Cette fonction permet de fixer le début des données mémoires d'un mécanisme BIO et de retourner la quantité total de données disponible.
BIO_GET_MEM_PTR BIO_get_mem_ptr(BIO *b,BUF_MEM **pp) Cette fonction permet de demander une structure de tampon sous-jacente dans un mécanisme BIO.
BIO_GET_READ_REQUEST #define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL) Cette fonction permet de demander la quantité de données requises dans un mécanisme BIO.
BIO_GET_RETRY_BIO BIO * BIO_get_retry_BIO(BIO *bio, int *reason); Cette fonction permet de demander la raison précise d'une condition spécial s'étant passé avec un mécanisme BIO.
BIO_GET_RETRY_REASON int BIO_get_retry_reason(BIO *bio); Cette fonction permet de demander la raison d'une condition spécial s'étant passé avec un mécanisme BIO.
BIO_GETS int BIO_gets(BIO *b,char *buf, int size); Cette fonction permet de demander une chaine de caractères avec un mécanisme BIO.
BIO_INT_CTRL long BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg); Cette fonction permet d'effectuer un contrôle avec un mécanisme BIO.
BIO_NEW BIO * BIO_new(BIO_METHOD *type); Cette fonction permet de créer un nouveau type de méthode d'accès des ressource du mécanisme BIO.
BIO_NEW_BIO_PAIR int BIO_new_bio_pair(BIO **bio1, size_t writebuf1, BIO **bio2, size_t writebuf2); Cette fonction permet de créer une connexion en paire par un mécanisme BIO.
BIO_NEW_BUFFER_SSL_CONNECT BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx); Cette fonction permet de créer une nouvelle chaine BIO constitué de tampon BIO et de connexion BIO.
BIO_NEW_FD BIO *BIO_new_fd(int fd, int close_flag); Cette fonction permet de demander un descripteur de fichier BIO.
BIO_NEW_FILE BIO *BIO_new_file(const char *filename, const char *mode); Cette fonction permet de créer un fichier spécifié avec le mode spécifié dans un mécanisme BIO.
BIO_NEW_FP BIO *BIO_new_fp(FILE *stream, int flags); Cette fonction permet de créer une nouveau flux de données dans un mécanisme BIO.
BIO_NEW_MEM_BUF BIO *BIO_new_mem_buf(void *buf, int len); Cette fonction permet de créer une nouveau tampon mémoire spécifié dans un mécanisme BIO.
BIO_NEW_SOCKET BIO *BIO_new_socket(int sock, int close_flag); Cette fonction permet de créer une nouveau Socket dans un mécanisme BIO.
BIO_NEW_SSL BIO *BIO_new_ssl(SSL_CTX *ctx,int client); Cette fonction permet de créer une nouvelle allocation SSL dans un mécanisme BIO.
BIO_NEW_SSL_CONNECT BIO *BIO_new_ssl_connect(SSL_CTX *ctx); Cette fonction permet de créer une nouvelle chaine BIO SSL dans un mécanisme BIO.
BIO_NEXT BIO * BIO_next(BIO *b); Cette fonction permet de demander le prochain BIO dans la chaine d'un mécanisme BIO.
BIO_PENDING int BIO_pending(BIO *b); Cette fonction permet de demander le nombre de caractères en attente dans le tampon de lecture et d'écriture dans un mécanisme BIO.
BIO_POP BIO * BIO_pop(BIO *b); Cette fonction permet d'enlever un BIO à un mécanisme BIO et retourne le prochain BIO de la chaine.
BIO_PTR_CTRL char * BIO_ptr_ctrl(BIO *bp,int cmd,long larg); Cette fonction permet de fixer la position du pointeur de contrôle avec un mécanisme BIO.
BIO_PUSH BIO * BIO_push(BIO *b,BIO *append); Cette fonction permet d'ajouter un BIO à un mécanisme BIO.
BIO_PUTS int BIO_puts(BIO *b,const char *buf); Cette fonction permet d'écrire une chaine de caractères avec une terminaison NULL avec un mécanisme BIO.
BIO_READ int BIO_read(BIO *b, void *buf, int len); Cette fonction permet d'effectuer une lecture de données dans un mécanisme BIO.
BIO_READ_FILENAME int BIO_read_filename(BIO *b, char *name); Cette fonction permet de fixer en mode lecture un nom de fichier spécifié dans un mécanisme BIO.
BIO_RESET int BIO_reset(BIO *b); Cette fonction permet de réintialiser le mécanisme BIO dans son état initiale.
BIO_RW_FILENAME int BIO_rw_filename(BIO *b, char *name); Cette fonction permet de fixer en mode lecture ou écriture un nom de fichier spécifié dans un mécanisme BIO.
BIO_S_ACCEPT BIO_METHOD *BIO_s_accept(void); Cette fonction permet de demander la méthode d'acceptation d'un mécanisme BIO.
BIO_S_BIO BIO_METHOD *BIO_s_bio(void); Cette fonction permet de demander la méthode pour une paire de mécanisme BIO.
BIO_S_CONNECT BIO_METHOD * BIO_s_connect(void); Cette fonction permet de demander la méthode de connexion pour un mécanisme BIO.
BIO_S_FD BIO_METHOD * BIO_s_fd(void); Cette fonction permet de demander la méthode de descripteur de fichier pour un mécanisme BIO.
BIO_S_FILE BIO_METHOD * BIO_s_file(void); Cette fonction permet de demander la méthode fichier pour un mécanisme BIO.
BIO_S_MEM BIO_METHOD * BIO_s_mem(void); Cette fonction permet de demander la méthode mémoire pour un mécanisme BIO.
BIO_S_NULL BIO_METHOD * BIO_s_null(void); Cette fonction permet de demander la méthode nulle pour un mécanisme BIO.
BIO_S_SOCKET BIO_METHOD *BIO_s_socket(void); Cette fonction permet de demander la méthode d'un mécanisme BIO pour un Socket.
BIO_SEEK int BIO_seek(BIO *b, int ofs); Cette fonction permet de fixer la position du pointeur de fichier dans le mécanisme BIO.
BIO_SET int BIO_set(BIO *a,BIO_METHOD *type); Cette fonction permet de fixer le type de méthode d'accès des ressource du mécanisme BIO.
BIO_SET_ACCEPT_BIOS long BIO_set_accept_bios(BIO *b, char *bio); Cette fonction permet de fixer la chaine BIOS à utiliser dans un mécanisme BIO.
BIO_SET_ACCEPT_PORT long BIO_set_accept_port(BIO *b, char *name); Cette fonction permet de fixer un port à accepter dans un mécanisme BIO.
BIO_SET_BIND_MODE long BIO_set_bind_mode(BIO *b, long mode); Cette fonction permet de fixer le mode de liaison dans un mécanisme BIO.
BIO_SET_CIPHER void BIO_set_cipher(BIO *b,const EVP_CIPHER *cipher, unsigned char *key, unsigned char *iv, int enc); Cette fonction permet de fixer le chiffrement avec une clef dans un mécanisme BIO.
BIO_SET_CLOSE int BIO_set_close(BIO *b,long flag); Cette fonction permet de fixer l'état de fermeture dans un mécanisme BIO.
BIO_SET_CONN_HOSTNAME long BIO_set_conn_hostname(BIO *b, char *name); Cette fonction permet de fixer le nom de l'hôte de la communication TCP/IP dans un mécanisme BIO.
BIO_SET_CONN_INT_PORT long BIO_set_conn_int_port(BIO *b, char *port); Cette fonction permet de fixer l'entier de port de communication TCP/IP dans un mécanisme BIO.
BIO_SET_CONN_IP long BIO_set_conn_ip(BIO *b, char *ip); Cette fonction permet de fixer IP pour une communication TCP/IP dans un mécanisme BIO.
BIO_SET_CONN_PORT long BIO_set_conn_port(BIO *b, char *port); Cette fonction permet de fixer le port de communication TCP/IP dans un mécanisme BIO.
BIO_SET_FP void BIO_set_fp(BIO *b,FILE *fp, int flags); Cette fonction permet de fixer la position d'un pointeur de fichier dans un mécanisme BIO.
BIO_SET_INFO_CALLBACK int BIO_set_info_callback(BIO *b,bio_info_cb *cb); Cette fonction permet de fixer l'information à l'aide d'une fonction utilisateur d'un mécanisme BIO.
BIO_SET_MD int BIO_set_md(BIO *b,EVP_MD *md); Cette fonction permet de fixer le message utilisateur d'un mécanisme BIO.
BIO_SET_MEM_BUF void BIO_set_mem_buf(BIO *b,BUF_MEM *bm,int c); Cette fonction permet de fixer la structure interne de la mémoire d'un mécanisme BIO.
BIO_SET_MEM_EOF_RETURN void BIO_set_mem_eof_return(BIO *b,int v); Cette fonction permet de fixer le comportement de la mémoire d'un mécanisme BIO quand il est vide.
BIO_SET_NBIO long BIO_set_nbio(BIO *b, long n); Cette fonction permet de fixer le mode de non-blocage d'entrée/sortie d'un mécanisme BIO.
BIO_SET_NBIO_ACCEPT long BIO_set_nbio_accept(BIO *b, int n); Cette fonction permet de fixer le socket d'acceptation d'un mode de blocage d'un mécanisme BIO.
BIO_SSL_COPY_SESSION_ID int BIO_ssl_copy_session_id(BIO *to,BIO *from); Cette fonction permet de copier un identificateur de session SSL entre une chaine source et destination d'un mécanisme BIO.
BIO_SSL_SHUTDOWN void BIO_ssl_shutdown(BIO *bio); Cette fonction permet de fermer une connexion SSL dans une chaine de mécanisme BIO.
BIO_TELL int BIO_tell(BIO *b); Cette fonction permet de demander la position du pointeur de fichier dans le mécanisme BIO.
BIO_VFREE void BIO_vfree(BIO *a); Cette fonction permet de libérer un mécanisme BIO sans retourner de valeur.
BIO_WPENDING int BIO_wpending(BIO *b); Cette fonction permet de demander le nombre de caractères en attente dans le tampon d'écriture dans un mécanisme BIO.
BIO_WRITE int BIO_write(BIO *b, const void *buf, int len); Cette fonction permet d'écrire la quantité de données spécifiés du tampon spécifié dans un mécanisme BIO.
BIO_WRITE_FILENAME int BIO_write_filename(BIO *b, char *name) Cette fonction permet de fixer en mode écriture un nom de fichier spécifié dans un mécanisme BIO.


PARTAGER CETTE PAGE SUR
Dernière mise à jour : Samedi, le 20 février 2016