package async_ssl

You can search for identifiers within the package.

in-package search v0.2.0

package async_ssl

async_ssl
- Async_ssl
  - Ffi
    
    ASN1_object
    
    ASN1_string
    
    Bio
    
    Dh
    
    Ec_key
    
    Curve
    
    Rsa
    
    Ssl
    
    Ssl_ctx
    
    Ssl_error
    
    Ssl_session
    
    X509
    
    X509_name
    
    X509_name_entry
  - Ffi_generated
  - Ffi_generated_types
    
    FOREIGN
    
    TYPE
  - Import
  - Opt
  - Rfc3526
  - Ssl
    
    Certificate
    
    Connection
    
    Opt
    
    Session
    
    Verify_mode
    
    Version
  - Std
  - Verify_mode
  - Version
async_ssl.bindings
- Async_ssl_bindings
  - Ffi_bindings
    
    Bindings
    
    ASN1_object
    
    ASN1_string
    
    Bignum
    
    Bio
    
    Ctypes
    
    FOREIGN
    
    TYPE
    
    Dh
    
    Ec_key
    
    Engine
    
    Foreign
    
    FOREIGN
    
    Funptr
    
    TYPE
    
    Rsa
    
    Ssl
    
    Ssl_ctx
    
    Ssl_method
    
    Ssl_session
    
    X509
    
    X509_name
    
    X509_name_entry
    
    Types
    
    Ssl_error
    
    Ssl_op
    
    Verify_mode
    
    Verify_result

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Ctypes end

type (!'a, !'b) pointer = ('a, 'b) Ctypes_static.pointer

type !'a ptr = ('a, [ `C ]) pointer

type !'a ocaml = 'a Ctypes_static.ocaml

type !'a carray = 'a Ctypes_static.carray

type !'a bigarray_class = 'a Ctypes_static.bigarray_class

val genarray : 
  < ba_repr : 'b
    ; bigarray : ('a, 'b, 'l) Bigarray.Genarray.t
    ; carray : 'a carray
    ; dims : int array
    ; element : 'a
    ; layout : 'l >
    bigarray_class

val array1 : 
  < ba_repr : 'b
    ; bigarray : ('a, 'b, 'l) Bigarray.Array1.t
    ; carray : 'a carray
    ; dims : int
    ; element : 'a
    ; layout : 'l >
    bigarray_class

val array2 : 
  < ba_repr : 'b
    ; bigarray : ('a, 'b, 'l) Bigarray.Array2.t
    ; carray : 'a carray carray
    ; dims : int * int
    ; element : 'a
    ; layout : 'l >
    bigarray_class

val array3 : 
  < ba_repr : 'b
    ; bigarray : ('a, 'b, 'l) Bigarray.Array3.t
    ; carray : 'a carray carray carray
    ; dims : int * int * int
    ; element : 'a
    ; layout : 'l >
    bigarray_class

type (!'a, !'kind) structured = ('a, 'kind) Ctypes_static.structured

type !'a structure = ('a, [ `Struct ]) structured

type !'a union = ('a, [ `Union ]) structured

type (!'a, !'t) field = ('a, 't) Ctypes_static.field

type !'a abstract = 'a Ctypes_static.abstract

type !'a typ = 'a Ctypes_static.typ

val void : unit typ

val char : char typ

val schar : int typ

val short : int typ

val int : int typ

val long : Signed.long typ

val llong : Signed.llong typ

val nativeint : nativeint typ

val int8_t : int typ

val int16_t : int typ

val int32_t : int32 typ

val int64_t : int64 typ

module Intptr = Ctypes.Intptr

val intptr_t : Intptr.t typ

module Ptrdiff = Ctypes.Ptrdiff

val ptrdiff_t : Ptrdiff.t typ

val camlint : int typ

val uchar : Unsigned.uchar typ

val bool : bool typ

val uint8_t : Unsigned.uint8 typ

val uint16_t : Unsigned.uint16 typ

val uint32_t : Unsigned.uint32 typ

val uint64_t : Unsigned.uint64 typ

val size_t : Unsigned.size_t typ

val ushort : Unsigned.ushort typ

val sint : Signed.sint typ

val uint : Unsigned.uint typ

val ulong : Unsigned.ulong typ

val ullong : Unsigned.ullong typ

module Uintptr = Ctypes.Uintptr

val uintptr_t : Uintptr.t typ

val float : float typ

val double : float typ

val ldouble : LDouble.t typ

val complex32 : Stdlib.Complex.t typ

val complex64 : Stdlib.Complex.t typ

val complexld : ComplexL.t typ

val ptr : 'a typ -> 'a Ctypes_static.ptr typ

val ptr_opt : 'a typ -> 'a Ctypes_static.ptr option typ

val string : string typ

val string_opt : string option typ

val ocaml_string : string Ctypes_static.ocaml typ

val ocaml_bytes : bytes Ctypes_static.ocaml typ

val array : int -> 'a typ -> 'a Ctypes_static.carray typ

val bigarray : 
  < ba_repr : 'b
    ; bigarray : 'bigarray
    ; carray : 'c
    ; dims : 'dims
    ; element : 'a
    ; layout : Bigarray.c_layout >
    Ctypes_static.bigarray_class ->
  'dims ->
  ('a, 'b) Bigarray.kind ->
  'bigarray typ

val fortran_bigarray : 
  < ba_repr : 'b
    ; bigarray : 'bigarray
    ; carray : 'c
    ; dims : 'dims
    ; element : 'a
    ; layout : Bigarray.fortran_layout >
    Ctypes_static.bigarray_class ->
  'dims ->
  ('a, 'b) Bigarray.kind ->
  'bigarray typ

val typ_of_bigarray_kind : ('a, 'b) Bigarray.kind -> 'a typ

val structure : string -> 's Ctypes_static.structure typ

val union : string -> 's Ctypes_static.union typ

val field : 
  ('s, [< `Struct | `Union ] as 'b) Ctypes_static.structured typ ->
  string ->
  'a typ ->
  ('a, ('s, 'b) Ctypes_static.structured) field

val seal : ('a, [< `Struct | `Union ]) Ctypes_static.structured typ -> unit

val view : 
  ?format_typ:
    ((Stdlib.Format.formatter -> unit) -> Stdlib.Format.formatter -> unit) ->
  ?format:(Stdlib.Format.formatter -> 'b -> unit) ->
  read:('a -> 'b) ->
  write:('b -> 'a) ->
  'a typ ->
  'b typ

val typedef : 'a typ -> string -> 'a typ

val abstract : 
  name:string ->
  size:int ->
  alignment:int ->
  'a Ctypes_static.abstract typ

val lift_typ : 'a Ctypes_static.typ -> 'a typ

type !'a fn = 'a Ctypes_static.fn

val (@->) : 'a typ -> 'b fn -> ('a -> 'b) fn

val returning : 'a typ -> 'a fn

type !'a static_funptr = 'a Ctypes_static.static_funptr

val static_funptr : 'a fn -> 'a Ctypes_static.static_funptr typ

val sizeof : 'a typ -> int

val alignment : 'a typ -> int

val format_typ : ?name:string -> Stdlib.Format.formatter -> 'a typ -> unit

val format_fn : ?name:string -> Stdlib.Format.formatter -> 'a fn -> unit

val string_of_typ : ?name:string -> 'a typ -> string

val string_of_fn : ?name:string -> 'a fn -> string

val format : 'a typ -> Stdlib.Format.formatter -> 'a -> unit

val string_of : 'a typ -> 'a -> string

val null : unit ptr

val (!@) : 'a ptr -> 'a

val (<-@) : 'a ptr -> 'a -> unit

val (+@) : ('a, 'b) pointer -> int -> ('a, 'b) pointer

val (-@) : ('a, 'b) pointer -> int -> ('a, 'b) pointer

val ptr_diff : ('a, 'b) pointer -> ('a, 'b) pointer -> int

val from_voidp : 'a typ -> unit ptr -> 'a ptr

val to_voidp : 'a ptr -> unit ptr

val allocate : ?finalise:('a ptr -> unit) -> 'a typ -> 'a -> 'a ptr

val allocate_n : ?finalise:('a ptr -> unit) -> 'a typ -> count:int -> 'a ptr

val ptr_compare : 'a ptr -> 'a ptr -> int

val is_null : 'a ptr -> bool

val reference_type : 'a ptr -> 'a typ

val ptr_of_raw_address : nativeint -> unit ptr

val funptr_of_raw_address : 
  nativeint ->
  (unit -> unit) Ctypes_static.static_funptr

val raw_address_of_ptr : unit ptr -> nativeint

val string_from_ptr : char ptr -> length:int -> string

val ocaml_string_start : string -> string ocaml

val ocaml_bytes_start : bytes -> bytes ocaml

module CArray = Ctypes.CArray

val bigarray_start : 
  < ba_repr : 'c
    ; bigarray : 'b
    ; carray : 'd
    ; dims : 'e
    ; element : 'a
    ; layout : 'l >
    bigarray_class ->
  'b ->
  'a ptr

val bigarray_of_ptr : 
  < ba_repr : 'f
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'i
    ; element : 'a
    ; layout : Bigarray.c_layout >
    bigarray_class ->
  'i ->
  ('a, 'f) Bigarray.kind ->
  'a ptr ->
  'b

val fortran_bigarray_of_ptr : 
  < ba_repr : 'f
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'i
    ; element : 'a
    ; layout : Bigarray.fortran_layout >
    bigarray_class ->
  'i ->
  ('a, 'f) Bigarray.kind ->
  'a ptr ->
  'b

val array_of_bigarray : 
  < ba_repr : 'a
    ; bigarray : 'b
    ; carray : 'c
    ; dims : 'd
    ; element : 'e
    ; layout : Bigarray.c_layout >
    bigarray_class ->
  'b ->
  'c

val bigarray_of_array : 
  < ba_repr : 'f
    ; bigarray : 'b
    ; carray : 'c carray
    ; dims : 'i
    ; element : 'a
    ; layout : Bigarray.c_layout >
    bigarray_class ->
  ('a, 'f) Bigarray.kind ->
  'c carray ->
  'b

val make : 
  ?finalise:(('a, 'b) structured -> unit) ->
  ('a, 'b) structured typ ->
  ('a, 'b) structured

val setf : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a -> unit

val getf : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a

val (@.) : ('b, 'c) structured -> ('a, ('b, 'c) structured) field -> 'a ptr

val (|->) : 
  ('b, 'c) structured ptr ->
  ('a, ('b, 'c) structured) field ->
  'a ptr

val offsetof : ('a, 'b structure) field -> int

val field_type : ('a, 'b) field -> 'a typ

val field_name : ('a, 'b) field -> string

val addr : ('a, 'b) structured -> ('a, 'b) structured ptr

val coerce : 'a typ -> 'b typ -> 'a -> 'b

val coerce_fn : 'a fn -> 'b fn -> 'a -> 'b

module type FOREIGN = sig ... end

module type TYPE = sig ... end

module Root = Ctypes.Root

exception Unsupported of string

exception ModifyingSealedType of string

exception IncompleteType

type uncoercible_info = Ctypes.uncoercible_info

exception Uncoercible of uncoercible_info

include module type of struct include Foreign end

val foreign : 
  ?abi:Libffi_abi.abi ->
  ?from:Dl.library ->
  ?stub:bool ->
  ?check_errno:bool ->
  ?release_runtime_lock:bool ->
  string ->
  ('a -> 'b) Ctypes.fn ->
  'a ->
  'b

val foreign_value : 
  ?from:Dl.library ->
  string ->
  'a Ctypes.typ ->
  'a Ctypes.ptr

val funptr : 
  ?abi:Libffi_abi.abi ->
  ?name:string ->
  ?check_errno:bool ->
  ?runtime_lock:bool ->
  ?thread_registration:bool ->
  ('a -> 'b) Ctypes.fn ->
  ('a -> 'b) Ctypes.typ

val funptr_opt : 
  ?abi:Libffi_abi.abi ->
  ?name:string ->
  ?check_errno:bool ->
  ?runtime_lock:bool ->
  ?thread_registration:bool ->
  ('a -> 'b) Ctypes.fn ->
  ('a -> 'b) option Ctypes.typ

exception CallToExpiredClosure

module type Funptr = sig ... end

val dynamic_funptr : 
  ?abi:Libffi_abi.abi ->
  ?runtime_lock:bool ->
  ?thread_registration:bool ->
  ('a -> 'b) Ctypes.fn ->
  (module Funptr
  with type fn = 'a -> 'b)

val report_leaked_funptr : (string -> unit) Stdlib.ref