Index of modules

This module implements AES in Ciphertext Stealing mode (see RFC 3962)

Returns a new crypto module where missing modes are added for all ECB ciphers.

Interface to Apache API.

Operations on arguments and lists of thereof.

Authentication

Encoders/decoders for big endian - network byte order

Bundle a list of ciphers as crypto module

The CRAM-MD5 SASL mechanism (RFC 2195), which is obsolete and only provided for completeness.

Functions to manipulate cookies.

Credentials

Cryptography

This is the cryptosystem as defined in RFC 3961, so far needed here.

The DIGEST-MD5 SASL mechanism (RFC 2831).

For a given attribute lookup module L this module provides parser and printer for distinguished names in string format (RFC 4514).

module MyPool = DbiPool (Dbi_postgres)

The default profile for Netmech_spnego_http: Use spnego_trans_id for the https transport, and reject any unencrypted transport (empty list).

This is the standard HTTP digest authentication mechanism (see RFCs 2069, 2617, 7616).

This is the standard HTTP digest authentication mechanism (see RFCs 2069, 2617, 7616).

Cryptographic digests

Equeue implements generic event queues.

The Equeue, Unixqueue, and Engines HOWTO

Introduction into programming with equeue (formerly known as "Equeue User's Guide").

Access to exceptions

Foreword

The implementation of TLS backed by GnuTLS, here using Netsys_types as TLS_EXCEPTIONS module

This is an adapter turning any GSSAPI mechanism into a SASL mechanism.

How to get OCamlnet

The GSSAPI

Encoders/decoders for host byte order - which is either little endian or big endian, depending on the CPU (or CPU mode)

Registering Apache handlers.

OCamlnet is an enhanced system platform library for Ocaml.

IPv6 Support

Key purpose IDs as returned by parse_ext_key_usage

This is an adapter turning the Kerberos 5 GSSAPI mechanism into a SASL mechanism.

This is the other adapter turning the Kerberos 5 GSSAPI mechanism into a SASL mechanism.

This is the profile used for Netmech_krb5_sasl.Krb5_gs2

Encoders/decoders for little endian

Instantiate this module.

Create a custom version of the digest mechanism

Create an encapsulation module

Creates a LEVER module from a function type as specified in FUN_TYPE

Create a new mailbox access module for message type T.t

Creates a module with get and set functions to access variables of type T.t.

Creates get and set like make_var_type.

Accelerators for bytecode

Enables accelerator module Netaccel

Parsing of mail addresses

Messages with ASCII armor

ASN.1 support functions

ASN.1 encoder

Some primitives for authentication

Internal auxiliary functions

A Netbuffer.t is a buffer that can grow and shrink dynamically.

Camlboxes are a fast IPC mechanism to send Ocaml values from one process to another.

Common data-structures for CGI-like connectors.

Apache JServ Protocol (AJP) 1.3 connector.

Netcgi Apache "mod" connector.

Classical CGI connector.

Functions to develop new connectors.

Pools of connections for the ocamldbi generic database interface.

FastCGI connector.

Netplex support for FastCGI, SCGI and AJP connectors

Porting netcgi1 programs to netcgi2

SCGI connector.

Connector for testing your code.

Object-oriented I/O: Basic types and classes

Crypto extensions for Netchannels

Netchannels Tutorial

Netclient tutorial

Registry for compression algorithms

Conversion between character encodings

Support for common date/time parsing and formatting.

X.500 distinguished names

Base64, Quoted Printable, URL encoding, HTML escaping

Exception registry

Class type stream_fs for filesystems with stream access to files

FTP client

Senders and receivers for the FTP data connection

FTP filesystem

Globbing

This is the system-wide version of GSSAPI

Bindings of a C library

Authentication helpers for GSSAPI

Support functions for GSS-API

Gzip object channels

Parsing of HTML

Basic definitions for the HTTP protocol

HTTP 1.1 client

Connection cache

HTTP filesystem

The event-based encapsulation of the HTTP daemon

Overview over the HTTP daemon

The protocol kernel of the HTTP daemon

Netplex support

The reactive encapsulation of the HTTP daemon

Service Providers for HTTP daemon

Type definitions for the HTTP daemon

Utility functions

LDAP client

Basic logging facility

Internal access to the character conversion database

Multi-processing for compute jobs

Shared arrays

Netmulticore Basics

Shared buffer

Camlboxes for use in netmulticore programs

Condition variables

Shared hashtables

Shared heaps of structured values

Shared 2-dimensional arrays (matrices)

Memory pools

Mutexes

Statically typed processes

Shared queues

Shared mutable variables

Semaphores

Netmulticore Tutorial

Digest authentication for HTTP

The GS2 bridge for using GSSAPI mechanisms as SASL mechanisms

Kerberos 5 as SASL mechanism

SCRAM mechanism for authentication (RFC 5802)

The SCRAM security mechanism for GSS-API

SCRAM for HTTP (prerelease)

SCRAM as SASL mechanism

SPNEGO (GSSAPI) authentication for HTTP

Netmime contains high-level classes and functions to process mail and MIME messages.

MIME: parsing and printing for channels

MIME: Access methods for frequent standard fields.

Low-level functions to parse and print mail and MIME messages

Netmime Tutorial

Binary encodings of numbers

X.500 Object Identifiers

Buffer for page-aligned I/O

Netplex Administration Guide

Advanced features of Netplex

Container environment

Read the configuration file

Containers

Controller

Type-safe marshalling between processes of the same executable

Internal services

Introduction into Netplex

Netplex toolkit

Loggers

Main program for Netplex servers

Netplex message boxes

Multi-processing provider

Multi-threading provider

Netplex-wide mutexes

Netplex-wide semaphores

Netplex-wide variables

Socket service creation

Types for Netplex

Workload management

This is an interface for the Post Office Protocol - Version 3 (POP3) as specifed by RFC 1939.

The SASLprep algorithm (RFC 4013)

Functions to compose and send electronic mails

Netsendmail Tutorial

Shared memory for O'Caml programs using multi-processing

Arrays in shared memory

Data representation for shared memory

Hash tables in shared memory

Shared Memory for IPC

This is an interface for the Simple Mail Tranfer Protocol (SMTP) as specified by RFC 2821.

Parsing of socket addresses

A netstream is an input channel that is read block by block.

Wrapper for regexps with PCRE syntax

Wrapper for regexps with Str syntax

Support module for tagged strings

System calls missing in the Unix module

Symmetric cryptographic ciphers

Cryptographic providers

Helpers for crypto modes

Types for crypto providers

Cryptographic digests (hashes)

Global variables

GSS-API Definition

Bigarrays as memory buffers

Object-oriented thread API

Manage persistent objects

Sets of file descriptors for polling

Pollsets for POSIX operating systems

Pollsets for Win32

Polymorphic message pipes

Polymorphic message sockets

POSIX-specific system calls missing in the Unix module, and further API's from POSIX-style operating systems.

Random-number generator

User interface for SASL mechanisms

Generic anonymous semaphores

Signal handler framework

User-level TLS API

Temporary files

Types for all Netsys modules

Primitives for Win32

Some helpers for en/decoding XDR faster

Telnet client

GnuTLS

Bindings of a C library

Bindings of a C library

Support types and functions for TLS

Support module for Alain Frisch's ulex lexer generator

Netulex Tutorial

Unicode character information

Configure how to load Unicode tables

Uniform Resource Locators (URLs)

LDAP-specific URLs

Neturl Tutorial

X.509 certificates

X.509 public key cryptography - keys and naming

X.509 public key cryptography - wrappers

External Data Representation

Managed Strings

What's new in OCamlnet 4

Handy operators: ++, >>, and eps_e

The PLAIN SASL mechanism (RFC 4616).

Platform Support

Regular Expression Backends

Common types and exceptions

GSS-API for RPC authentication

Authentication module AUTH_SYS

RPC clients

Contents Rpc_intro.intro Rpc_intro.intro_clnt, Rpc_intro.intro_srv , Rpc_intro.rpcgen, Rpc_intro.mapping Rpc_intro.syn_xdr, Rpc_intro.syn_prog, Rpc_intro.map_names, Rpc_intro.map_ints, Rpc_intro.map_fps, Rpc_intro.map_strings, Rpc_intro.map_arrays, Rpc_intro.map_records, Rpc_intro.map_enums, Rpc_intro.map_eunions, Rpc_intro.map_iunions, Rpc_intro.map_opts, Rpc_intro.map_recs , Rpc_intro.lib, Rpc_intro.rpc_netplex, Rpc_intro.restrictions

Securing RPC with the GSSAPI

RPC Language Mapping Reference

Netplex support for RPC servers (TCP only)

Packing and Unpacking of messages; can be used by both client and server programs.

Portmapper/RPCBIND interface

RPC programs

RPC proxies

RPC servers

Synchronous API for RPC clients

Low-level RPC transporters

Utility functions

Minimal support for TI-RPC over the XTI API

Create a new SCRAM SASL mechanism for this profile.

SCRAM with SHA1 profile

SCRAM with SHA1_PLUS profile

SCRAM with SHA256 profile

SCRAM with SHA256_PLUS profile

Uses SHA-1 as hash function.

Same as Netmech_scram_sasl.SHA1, only that the mechanism name is "SCRAM-SHA-1-PLUS"

Uses SHA-256 as hash function.

Same as Netmech_scram_sasl.SHA256, only that the mechanism name is "SCRAM-SHA-256-PLUS"

SCRAM-SHA-256 where only the server authenticates the client

SCRAM-SHA-256 where additionally also the client checks that the server knows the credentials.

The SPNEGO mechanism for HTTP, see Netmech_spnego_http

Calls external programs, creates pipelines, etc.

Shell filesystem

The shell library: Pipelines and redirections

Calls external programs, creates pipelines, etc.

Run shell commands within Unixqueues

Symmetric cryptography as provided by GnuTLS and its helper library Nettle

This is the system-wide version of GSSAPI

Same as GNUTLS, but without the extra gnutls_* functions

TLS support

Unixqueue implementation on top of Netsys_pollset

Datagrams

An engine performs a certain task in an autonomous way.

Compatibility with OCamlnet-3

Unified engines for stream I/O

Use Libevent as event loop

Compatibility with Lwt

Using engines in multi-threaded programs

Multiplex Controllers

Support for pluggable resolvers

Parser/printer for distnguished names as they may occur in X.509 certificates