package async_ssl

The type of pointer values. A value of type ('a, [`C]) pointer contains a C-compatible pointer, and a value of type ('a, [`OCaml]) pointer contains a pointer to a value that can be moved by OCaml runtime.

The type of C-compatible pointer values. A value of type t ptr can be used to read and write values of type t at particular addresses.

The type of pointer values pointing directly into OCaml values. Pointers of this type should never be captured by external code. In particular, functions accepting 'a ocaml pointers must not invoke any OCaml code.

The type of C array values. A value of type t carray can be used to read and write array objects in C-managed storage.

The type of Bigarray classes. There are four instances, one for each of the Bigarray submodules.

The class of Bigarray.Genarray.t values

The class of Bigarray.Array1.t values

The class of Bigarray.Array2.t values

The class of Bigarray.Array3.t values

The base type of values representing C struct and union types. The 'kind parameter is a polymorphic variant type indicating whether the type represents a struct (`Struct) or a union (`Union).

The type of values representing C struct types.

The type of values representing C union types.

The type of values representing C struct or union members (called "fields" here). A value of type (a, s) field represents a field of type a in a struct or union of type s.

The type of abstract values. The purpose of the abstract type is to represent values whose type varies from platform to platform.

For example, the type pthread_t is a pointer on some platforms, an integer on other platforms, and a struct on a third set of platforms. One way to deal with this kind of situation is to have possibly-platform-specific code which interrogates the C type in some way to help determine an appropriate representation. Another way is to use abstract, leaving the representation opaque.

(Note, however, that although pthread_t is a convenient example, since the type used to implement it varies significantly across platforms, it's not actually a good match for abstract, since values of type pthread_t are passed and returned by value.)

sizeof t computes the size in bytes of the type t. The exception IncompleteType is raised if t is incomplete.

alignment t computes the alignment requirements of the type t. The exception IncompleteType is raised if t is incomplete.

Pretty-print a C representation of the type to the specified formatter.

Pretty-print a C representation of the function type to the specified formatter.

Return a C representation of the type.

Return a C representation of the function type.

Pretty-print a representation of the C value to the specified formatter.

Return a string representation of the C value.

A null pointer.

!@ p dereferences the pointer p. If the reference type is a scalar type then dereferencing constructs a new value. If the reference type is an aggregate type then dereferencing returns a value that references the memory pointed to by p.

p <-@ v writes the value v to the address p.

If p is a pointer to an array element then p +@ n computes the address of the nth next element.

If p is a pointer to an array element then p -@ n computes the address of the nth previous element.

ptr_diff p q computes q - p. As in C, both p and q must point into the same array, and the result value is the difference of the subscripts of the two array elements.

Conversion from void *.

Conversion to void *.

allocate t v allocates a fresh value of type t, initialises it with v and returns its address. The argument ?finalise, if present, will be called just before the memory is freed. The value will be automatically freed after no references to the pointer remain within the calling OCaml program.

allocate_n t ~count:n allocates a fresh array with element type t and length n, and returns its address. The argument ?finalise, if present, will be called just before the memory is freed. The array will be automatically freed after no references to the pointer remain within the calling OCaml program. The memory is allocated with libc's calloc and is guaranteed to be zero-filled.

If p and q are pointers to elements i and j of the same array then ptr_compare p q compares the indexes of the elements. The result is negative if i is less than j, positive if i is greater than j, and zero if i and j are equal.

is_null p is true when p is a null pointer.

Retrieve the reference type of a pointer.

Convert the numeric representation of an address to a pointer

Convert the numeric representation of an address to a function pointer

raw_address_of_ptr p returns the numeric representation of p.

Note that the return value remains valid only as long as the pointed-to object is alive. If p is a managed object (e.g. a value returned by make) then unless the caller retains a reference to p, the object may be collected, invalidating the returned address.

string_from_ptr p ~length creates a string initialized with the length characters at address p.

Raise Invalid_argument "Ctypes.string_from_ptr" if length is negative.

ocaml_string_start s allows to pass a pointer to the contents of an OCaml string directly to a C function.

ocaml_bytes_start s allows to pass a pointer to the contents of an OCaml byte array directly to a C function.

Operations on C arrays.

Return the address of the first element of the given Bigarray value.

bigarray_of_ptr c dims k p converts the C pointer p to a C-layout bigarray value. No copy is made; the bigarray references the memory pointed to by p.

fortran_bigarray_of_ptr c dims k p converts the C pointer p to a Fortran-layout bigarray value. No copy is made; the bigarray references the memory pointed to by p.

array_of_bigarray c b converts the bigarray value b to a value of type CArray.t. No copy is made; the result occupies the same memory as b.

bigarray_of_array c k a converts the CArray.t value a to a C-layout bigarray value. No copy is made; the result occupies the same memory as a.

Allocate a fresh, uninitialised structure or union value. The argument ?finalise, if present, will be called just before the underlying memory is freed.

setf s f v overwrites the value of the field f in the structure or union s with v.

getf s f retrieves the value of the field f in the structure or union s. The semantics for non-scalar types are non-copying, as for (!@).

s @. f computes the address of the field f in the structure or union value s.

p |-> f computes the address of the field f in the structure or union value pointed to by p.

offsetof f returns the offset, in bytes, of the field f from the beginning of the associated struct type.

field_type f returns the type of the field f.

field_name f returns the name of the field f.

addr s returns the address of the structure or union s.

coerce t1 t2 returns a coercion function between the types represented by t1 and t2. If t1 cannot be coerced to t2, coerce raises Uncoercible.

The following coercions are currently supported:

• All function and object pointer types are intercoercible.
• Any type may be coerced to void
• There is a coercion between a view and another type t (in either direction) if there is a coercion between the representation type underlying the view and t.
• Coercion is transitive: if t1 is coercible to t2 and t2 is coercible to t3, then t1 is directly coercible to t3.

The set of supported coercions is subject to change. Future versions of ctypes may both add new types of coercion and restrict the existing coercions.

coerce_fn f1 f2 returns a coercion function between the function types represented by f1 and f2. If f1 cannot be coerced to f2, coerce_fn raises Uncoercible.

A function type f1 may be coerced to another function type f2 if all of the following hold:

• the C types described by f1 and f2 have the same arity

• each argument of f2 may be coerced to the corresponding argument of f1

• the return type of f1 may be coerced to the return type of f2

The set of supported coercions is subject to change. Future versions of ctypes may both add new types of coercion and restrict the existing coercions.

Foreign function binding interface.

Foreign types binding interface.

An attempt was made to use a feature not currently supported by ctypes. In practice this refers to attempts to use an union, array or abstract type as an argument or return type of a function.

An attempt was made to modify a sealed struct or union type description.

An attempt was made to compute the size or alignment of an incomplete type.

The incomplete types are struct and union types that have not been sealed, and the void type.

It is not permitted to compute the size or alignment requirements of an incomplete type, to use it as a struct or union member, to read or write a value of the type through a pointer or to use it as the referenced type in pointer arithmetic. Additionally, incomplete struct and union types cannot be used as argument or return types.

An attempt was made to coerce between uncoercible types.

foreign name typ exposes the C function of type typ named by name as an OCaml value.

The argument ?from, if supplied, is a library handle returned by Dl.dlopen.

The argument ?stub, if true (defaults to false), indicates that the function should not raise an exception if name is not found but return an OCaml value that raises an exception when called.

The value ?check_errno, which defaults to false, indicates whether Unix.Unix_error should be raised if the C function modifies errno. Please note that a function that succeeds is allowed to change errno. So use this option with caution.

The value ?release_runtime_lock, which defaults to false, indicates whether the OCaml runtime lock should be released during the call to the C function, allowing other threads to run. If the runtime lock is released then the C function must not access OCaml heap objects, such as arguments passed using Ctypes.ocaml_string and Ctypes.ocaml_bytes, and must not call back into OCaml.

• raises Dl.DL_error

  if name is not found in ?from and ?stub is false.

foreign_value name typ exposes the C value of type typ named by name as an OCaml value. The argument ?from, if supplied, is a library handle returned by Dl.dlopen.

Construct a function pointer type from a function type.

The ctypes library, like C itself, distinguishes functions and function pointers. Functions are not first class: it is not possible to use them as arguments or return values of calls, or store them in addressable memory. Function pointers are first class, and so have none of these restrictions.

The value ?check_errno, which defaults to false, indicates whether Unix.Unix_error should be raised if the C function modifies errno.

The value ?runtime_lock, which defaults to false, indicates whether the OCaml runtime lock should be released during the call to the C function, allowing other threads to run. If the runtime lock is released then the C function must not access OCaml heap objects, such as arguments passed using Ctypes.ocaml_string and Ctypes.ocaml_bytes, and must not call back into OCaml. If the function pointer is used to call into OCaml from C then the ?runtime_lock argument indicates whether the lock should be acquired and held during the call.

• raises Dl.DL_error

  if name is not found in ?from and ?stub is false.

  A note on lifetime: this function ties the lifetime of the C function to the associated OCaml closure, so that the C function may be used only while the closure is still live.

  The dynamic_funptr function is an alternative to funptr with explicit lifetime management.

Construct a function pointer type from a function type.

This behaves like funptr, except that null pointers appear in OCaml as None.

A closure passed to C was collected by the OCaml garbage collector before it was called.

Define a type representation for passing OCaml functions to C with explicit lifetime management.

(val (dynamic_funptr (foo @-> returning bar))) corresponds to the C type bar( * )(foo).

Example:

module Progress_callback =
  (val (dynamic_funptr (int @-> int @-> ptr void @-> returning void)))
let keygen = foreign "RSA_generate_key"
  (int @-> int @-> Progress_callback.t @-> ptr void @-> returning rsa_key)
let secret_key =
  Progress_callback.with_fun
    (fun a b _ -> printf "progress: a:%d, b:%d\n" a b)
    (fun progress ->
       keygen 2048 65537 progress null)

Hook called on collection of closures associated with dynamic_funptr values that have not been deallocated with free.

By default the ctypes library retains closures associated with function pointers that have not been freed and prints a warning to stderr.

You can use this hook to change how these error messages are reported.