Basic design of the tsocket abstraction
=======================================

The tsocket abstraction is splitted into two
different kinds of communitation interfaces.

There's the "tstream_context" interface with abstracts
the communication through a bidirectional
byte stream between two endpoints.

And there's the "tdgram_context" interface
with abstracts datagram based communication between any
number of endpoints.

Both interfaces share the "tsocket_address" abstraction
for endpoint addresses.

The whole library is based on the talloc(3) and 'tevent' libraries
and provides "tevent_req" based "foo_send()"/"foo_recv()" functions pairs
for all abstracted methods that need to be async.

The tsocket_address abstraction
===============================

A tsocket_address represents a generic socket endpoint.
It behaves like an abstract class, therefore it has no direct constructor.
Constructors are described in later sections of this document.

A function get the string representation of an endpoint for debugging is
available but callers SHOULD NOT try to parse this string. To get more
details callers should use getter methods of the specific tsocket_address
implemention.

  char *tsocket_address_string(const struct tsocket_address *addr,
      TALLOC_CTX *mem_ctx);

A function to create a copy of the tsocket_address is also avilable.
This is useful before doing modifications to a socket
via additional methods of the specific tsocket_address implementation.

  struct tsocket_address *tsocket_address_copy(const struct tsocket_address *addr,
      TALLOC_CTX *mem_ctx);

The tdgram_context abstraction
==============================

The tdgram_context is like an abstract class for datagram
based sockets. The interface provides async 'tevent_req' based
functions similar to recvfrom(2)/sendto(2)/close(2) syscalls.

The tdgram_recvfrom_send() method can be called to ask for the
next available datagram from the abstracted tdgram_context.
It returns a 'tevent_req' handle, where the caller can register
a callback with tevent_req_set_callback(). The callback is triggered
when a datagram is available or an error occurs.

The callback is then supposed to get the result by calling
tdgram_recvfrom_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
Otherwise it returns the length of the datagram
(0 is never returned!). '*buf' will contain the buffer of the
datagram and '*src' the abstracted tsocket_address of the sender
of the received datagram.

The caller can only have one outstanding tdgram_recvfrom_send()
at a time otherwise the caller will get '*perrno = EBUSY'.

  struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tdgram_context *dgram);

  ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
      int *perrno,
      TALLOC_CTX *mem_ctx,
      uint8_t **buf,
      struct tsocket_address **src);

The tdgram_sendto_send() method can be called to send a
datagram (specified by a buf/len) to a destination endpoint
(specified by dst). It's not allowed for len to be 0.
It returns a 'tevent_req' handle, where the caller can register a
callback with tevent_req_set_callback(). The callback is triggered
when the specific implementation (thinks it)
has delivered the datagram to the "wire".

The callback is then supposed to get the result by calling
tdgram_sendto_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
Otherwise it returns the length of the datagram
(0 is never returned!).

The caller can only have one outstanding tdgram_sendto_send()
at a time otherwise the caller will get '*perrno = EBUSY'.

  struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tdgram_context *dgram,
      const uint8_t *buf, size_t len,
      const struct tsocket_address *dst);

  ssize_t tdgram_sendto_recv(struct tevent_req *req,
      int *perrno);

The tdgram_disconnect_send() method should be used to normally
shutdown/close the abstracted socket.

The caller should make sure there're no outstanding tdgram_recvfrom_send()
and tdgram_sendto_send() calls otherwise the caller will get '*perrno = EBUSY'.

Note: you can always use talloc_free(tdgram) to cleanup the resources
of the tdgram_context on a fatal error.

  struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tdgram_context *dgram);

  int tdgram_disconnect_recv(struct tevent_req *req,
      int *perrno);

The tstream_context abstraction
===============================

A tstream_context is like an abstract class for stream
based sockets. The interface provides async 'tevent_req' based
functions similar to the readv(2)/writev(2)/close(2) syscalls.

The tstream_pending_bytes() function is able to report how many bytes of
the incoming stream have been received but have not been consumed yet.
It returns -1 and sets 'errno' on failure.
Otherwise it returns the number of uncomsumed bytes (it can return 0!).

  ssize_t tstream_pending_bytes(struct tstream_context *stream);

The tstream_readv_send() method can be called to read a
specific amount of bytes from the stream into the buffers
of the given iovec vector. The caller has to preallocate the buffers
in the iovec vector. The caller might need to use
tstream_pending_bytes() if the protocol doesn't have a fixed pdu header
containing the pdu size. tstream_readv_send() returns a 'tevent_req' handle,
where the caller can register a callback with tevent_req_set_callback().
The callback is triggered when all iovec buffers are completely
filled with bytes from the socket or an error occurs.

The callback is then supposed to get the result by calling
tstream_readv_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
Otherwise it returns the length of the datagram (0 is never returned!).

The caller can only have one outstanding tstream_readv_send()
at a time otherwise the caller will get *perrno = EBUSY.

  struct tevent_req *tstream_readv_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream,
      struct iovec *vector,
      size_t count);

  int tstream_readv_recv(struct tevent_req *req,
      int *perrno);

The tstream_writev_send() method can be called to write
buffers in the given iovec vector into the stream socket.
It is invalid to pass an empty vector.
tstream_writev_send() returns a 'tevent_req' handle,
where the caller can register a callback with tevent_req_set_callback().
The callback is triggered when the specific implementation (thinks it)
has delivered the all buffers to the "wire".

The callback is then supposed to get the result by calling
tstream_writev_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
Otherwise it returns the total amount of bytes sent.
(0 is never returned!).

The caller can only have one outstanding tstream_writev_send()
at a time otherwise the caller will get '*perrno = EBUSY'.

  struct tevent_req *tstream_writev_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream,
      const struct iovec *vector,
      size_t count);

  int tstream_writev_recv(struct tevent_req *req,
      int *perrno);

The tstream_disconnect_send() method should normally be used to
shutdown/close the abstracted socket.

The caller should make sure there're no outstanding tstream_readv_send()
and tstream_writev_send() calls otherwise the caller will get '*perrno = EBUSY'.

Note: you can always use talloc_free(tstream) to cleanup the resources
of the tstream_context on a fatal error.

  struct tevent_req *tstream_disconnect_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream);

  int tstream_disconnect_recv(struct tevent_req *req,
      int *perrno);

PDU receive helper functions
============================

In order to simplify the job, for callers that want to implement
a function to receive a full PDU with a single async function pair,
some helper functions are provided.

The caller can use the tstream_readv_pdu_send() function
to ask for the next available PDU on the abstracted tstream_context.
The caller needs to provide a "next_vector" function and a private
state for this function. The tstream_readv_pdu engine will ask
the next_vector function for the next iovec vector to be used.
There's a tstream_readv_send/recv pair for each vector returned
by the next_vector function. If the next_vector function detects
it received a full pdu, it returns an empty vector. The the callback
of the tevent_req (returned by tstream_readv_pdu_send()) is triggered.
Note: the buffer allocation is completely up to the next_vector function
and its private state.

See the 'dcerpc_read_ncacn_packet_send/recv' functions in Samba as an
example.

  typedef int (*tstream_readv_pdu_next_vector_t)(struct tstream_context *stream,
      void *private_data,
      TALLOC_CTX *mem_ctx,
      struct iovec **vector,
      size_t *count);

  struct tevent_req *tstream_readv_pdu_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream,
      tstream_readv_pdu_next_vector_t next_vector_fn,
      void *next_vector_private);

  int tstream_readv_pdu_recv(struct tevent_req *req, int *perrno);

Async 'tevent_queue' based helper functions
===========================================

In some cases the caller doesn't care about the IO ordering on the
abstracted socket.
(Remember at the low level there's always only one IO in a specific
 direction allowed, only one tdgram_sendto_send() at a time).

Some helpers that use 'tevent_queue' are avilable to simplify handling
multiple IO requests. The functions just get a 'queue' argument and
internally serialize all operations.

  struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tdgram_context *dgram,
      struct tevent_queue *queue,
      const uint8_t *buf,
      size_t len,
      struct tsocket_address *dst);

  ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno);

  struct tevent_req *tstream_readv_pdu_queue_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream,
      struct tevent_queue *queue,
      tstream_readv_pdu_next_vector_t next_vector_fn,
      void *next_vector_private);

  int tstream_readv_pdu_queue_recv(struct tevent_req *req, int *perrno);

  struct tevent_req *tstream_writev_queue_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      struct tstream_context *stream,
      struct tevent_queue *queue,
      const struct iovec *vector,
      size_t count);

  int tstream_writev_queue_recv(struct tevent_req *req, int *perrno);

BSD sockets: ipv4, ipv6 and unix
================================

The main tsocket library comes with implentations
for BSD style ipv4, ipv6 and unix sockets.

You can use the tsocket_address_inet_from_strings()
function to create a tsocket_address for ipv4 and ipv6
endpoint addresses. "family" can be "ipv4", "ipv6" or "ip".
With "ip" is autodetects "ipv4" or "ipv6" based on the
"addr_string" string. "addr_string" must be a valid
ip address string based on the selected family
(dns names are not allowed!). But it's valid to pass NULL,
which gets mapped to "0.0.0.0" or "::".
It returns -1 and sets errno on error. Otherwise it returns 0.

  int tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
      const char *family,
      const char *addr_string,
      uint16_t port,
      struct tsocket_address **addr);

To get the ip address string of an existing 'inet' tsocket_address
you can use the tsocket_address_inet_addr_string() function.
It will return NULL and set errno to EINVAL if the tsocket_address
doesn't represent an ipv4 or ipv6 endpoint address.

  char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
      TALLOC_CTX *mem_ctx);

To get the port number of an existing 'inet' tsocket_address
you can use the tsocket_address_inet_port() function.
It will return 0 and set errno to EINVAL if the tsocket_address
doesn't represent an ipv4 or ipv6 endpoint address.

  uint16_t tsocket_address_inet_port(const struct tsocket_address *addr);

To set the port number of an existing 'inet' tsocket_address
you can use the tsocket_address_inet_set_port() function.
It will return -1 and set errno to EINVAL if the tsocket_address
doesn't represent an ipv4 or ipv6 endpoint address.
It returns 0 on success.

  int tsocket_address_inet_set_port(struct tsocket_address *addr,
      uint16_t port);

You can use the tsocket_address_unix_from_path()
function to create a tsocket_address for unix domain
endpoint addresses. "path" is the filesystem path
(NULL will map ""). If the path is longer than
the low level kernel supports the function will
return -1 and set errno to ENAMETOOLONG.
On success it returns 0.

  int tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
      const char *path,
      struct tsocket_address **addr);

To get the path of an 'unix' tsocket_address
you can use the tsocket_address_unix_path() function.
It will return NULL and set errno to EINVAL if the tsocket_address
doesn't represent a unix domain endpoint path.

  char *tsocket_address_unix_path(const struct tsocket_address *addr,
      TALLOC_CTX *mem_ctx);

You can use tdgram_inet_udp_socket() to create a tdgram_context
for ipv4 or ipv6 UDP communication. "local_address" has to be
an 'inet' tsocket_address and it has to represent the local
endpoint. "remote_address" can be NULL or an 'inet' tsocket_address
presenting a remote endpoint. It returns -1 ans sets errno on error
and it returns 0 on success.

  int tdgram_inet_udp_socket(const struct tsocket_address *local_address,
      const struct tsocket_address *remote_address,
      TALLOC_CTX *mem_ctx,
      struct tdgram_context **dgram);

You can use tdgram_unix_socket() to create a tdgram_context
for unix domain datagram communication. "local_address" has to be
an 'unix' tsocket_address and it has to represent the local
endpoint. "remote_address" can be NULL or an 'unix' tsocket_address
presenting a remote endpoint. It returns -1 ans sets errno on error
and it returns 0 on success.

  int tdgram_unix_socket(const struct tsocket_address *local,
      const struct tsocket_address *remote,
      TALLOC_CTX *mem_ctx,
      struct tdgram_context **dgram);

You can use tstream_inet_tcp_connect_send to asynchronously
connect to a remote ipv4 or ipv6 TCP endpoint and create a
tstream_context for the stream based communication. "local_address" has to be
an 'inet' tsocket_address and it has to represent the local
endpoint. "remote_address" has to be an 'inet' tsocket_address
presenting a remote endpoint. It returns a 'tevent_req' handle,
where the caller can register a callback with tevent_req_set_callback().
The callback is triggered when a socket is connected and ready for IO
or an error happened.

The callback is then supposed to get the result by calling
tstream_inet_tcp_connect_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
It returns 0 on success and returns the new tstream_context
in '*stream'.

  struct tevent_req *tstream_inet_tcp_connect_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      const struct tsocket_address *local_address,
      const struct tsocket_address *remote_address);

  int tstream_inet_tcp_connect_recv(struct tevent_req *req,
      int *perrno,
      TALLOC_CTX *mem_ctx,
      struct tstream_context **stream);

You can use tstream_unix_connect_send to asynchronously
connect to a unix domain endpoint and create a
tstream_context for the stream based communication.
"local_address" has to be an 'unix' tsocket_address and
it has to represent the local endpoint. "remote_address"
has to be an 'inet' tsocket_address presenting a remote endpoint.
It returns a 'tevent_req' handle, where the caller can register
a callback with tevent_req_set_callback(). The callback is
triggered when a socket is connected and ready for IO
or an error happened.

The callback is then supposed to get the result by calling
tstream_unix_connect_recv() on the 'tevent_req'. It returns -1
and sets '*perrno' to the actual 'errno' on failure.
It returns 0 on success and returns the new tstream_context
in '*stream'.

  struct tevent_req *tstream_unix_connect_send(TALLOC_CTX *mem_ctx,
      struct tevent_context *ev,
      const struct tsocket_address *local,
      const struct tsocket_address *remote);

  int _tstream_unix_connect_recv(struct tevent_req *req,
      int *perrno,
      TALLOC_CTX *mem_ctx,
      struct tstream_context **stream);

You can use tstream_unix_socketpair to create two connected
'unix' tsocket_contexts for the stream based communication.
It returns -1 and sets errno on error and it returns 0 on
success.

  int tstream_unix_socketpair(TALLOC_CTX *mem_ctx1,
      struct tstream_context **stream1,
      TALLOC_CTX *mem_ctx2,
      struct tstream_context **stream2);

In some situations it's needed to create a tsocket_address from
a given 'struct sockaddr'. You can use tsocket_address_bsd_from_sockaddr()
for that. This should only be used if really needed, because of
already existing fixed APIs. Only AF_INET, AF_INET6 and AF_UNIX
sockets are allowed. The function returns -1 and sets errno on error.
Otherwise it returns 0.

  int tsocket_address_bsd_from_sockaddr(TALLOC_CTX *mem_ctx,
      struct sockaddr *sa,
      socklen_t sasocklen,
      struct tsocket_address **addr);

In some situations it's needed to get a 'struct sockaddr' from a
given tsocket_address . You can use tsocket_address_bsd_sockaddr()
for that. This should only be used if really needed. Only AF_INET,
AF_INET6 and AF_UNIX are supported. It returns the size of '*sa' on
success, otherwise it returns -1 and sets 'errno'.

  ssize_t tsocket_address_bsd_sockaddr(const struct tsocket_address *addr,
      struct sockaddr *sa,
      socklen_t sasocklen);

In some situations it's needed to wrap existing file descriptors
into the tstream abstraction. You can use tstream_bsd_existing_socket()
for that. But you should read the tsocket_bsd.c code and unterstand it
in order use this function. E.g. the fd has to be non blocking already.
It will return -1 and set errno on error. Otherwise it returns 0
and sets '*stream' to point to the new tstream_context.

  int tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,
      int fd,
      struct tstream_context **stream);

Virtual Sockets
===============

The abstracted layout of tdgram_context and tstream_context
allow implementations arround virtual sockets for encrypted tunnels
(like TLS, SASL or GSSAPI) or named pipes over smb.

Named Pipe Auth (NPA) Sockets
=============================

Samba has an implementation to abstract named pipes over smb
(within the server side). See libcli/named_pipe_auth/npa_tstream.[ch]
for the core code. The current callers are located in source4/ntvfs/ipc/vfs_ipc.c
and source4/rpc_server/service_rpc.c for the users.