| Top | |
|
|
|
GEnum ├── PseudoTcpDebugLevel ├── PseudoTcpShutdown ├── PseudoTcpState ╰── PseudoTcpWriteResult GObject ╰── PseudoTcpSocket
The PseudoTcpSocket is an object implementing a Pseudo Tcp Socket for use over UDP. The socket will implement a subset of the TCP stack to allow for a reliable transport over non-reliable sockets (such as UDP).
See the file tests/test-pseudotcp.c in the source package for an example of how to use the object.
PseudoTcpSocket * pseudo_tcp_socket_new (guint32 conversation,PseudoTcpCallbacks *callbacks);
Creates a new PseudoTcpSocket for the specified conversation
The callbacks must be non-NULL, in order to get notified of packets the
socket needs to send.
If the callbacks structure was dynamicly allocated, it can be freed
after the call pseudo_tcp_socket_new
conversation |
The conversation id for the socket. |
|
callbacks |
A pointer to the PseudoTcpCallbacks structure for getting notified of the PseudoTcpSocket events. |
Since: 0.0.11
gboolean
pseudo_tcp_socket_connect (PseudoTcpSocket *self);
Connects the PseudoTcpSocket to the peer with the same conversation id.
The connection will only be successful after the
PseudoTcpCallbacks:PseudoTcpOpened callback is called
TRUE on success, FALSE on failure (not in TCP_LISTEN state)
See also: pseudo_tcp_socket_get_error()
Since: 0.0.11
gint pseudo_tcp_socket_recv (PseudoTcpSocket *self,char *buffer,size_t len);
Receive data from the socket.
Only call this on the PseudoTcpCallbacks:PseudoTcpReadable callback.
This function should be called in a loop. If this function does not
return -1 with EWOULDBLOCK as the error, the
PseudoTcpCallbacks:PseudoTcpReadable callback will not be called again.
self |
The PseudoTcpSocket object. |
|
buffer |
The buffer to fill with received data |
|
len |
The length of |
Since: 0.0.11
gint pseudo_tcp_socket_send (PseudoTcpSocket *self,const char *buffer,guint32 len);
Send data on the socket.
If this function return -1 with EWOULDBLOCK as the error, or if the return
value is lower than len, then the PseudoTcpCallbacks:PseudoTcpWritable
callback will be called when the socket will become writable.
self |
The PseudoTcpSocket object. |
|
buffer |
The buffer with data to send |
|
len |
The length of |
Since: 0.0.11
void pseudo_tcp_socket_close (PseudoTcpSocket *self,gboolean force);
Close the socket for sending. If force
is set to FALSE, the socket will
finish sending pending data before closing. If it is set to TRUE, the socket
will discard pending data and close the connection immediately (sending a TCP
RST segment).
The socket will be closed in both directions – sending and receiving – and
any pending received data must be read before calling this function, by
calling pseudo_tcp_socket_recv() until it blocks. If any pending data is in
the receive buffer when pseudo_tcp_socket_close() is called, a TCP RST
segment will be sent to the peer to notify it of the data loss.
The PseudoTcpCallbacks:PseudoTcpClosed callback will not be called once
the socket gets closed. It is only used for aborted connection.
Instead, the socket gets closed when the pseudo_tcp_socket_get_next_clock()
function returns FALSE.
See also: pseudo_tcp_socket_get_next_clock()
self |
The PseudoTcpSocket object. |
|
force |
|
Since: 0.0.11
void pseudo_tcp_socket_shutdown (PseudoTcpSocket *self,PseudoTcpShutdown how);
Shut down sending, receiving, or both on the socket, depending on the value
of how
. The behaviour of pseudo_tcp_socket_send() and
pseudo_tcp_socket_recv() will immediately change after this function returns
(depending on the value of how
), though the socket may continue to process
network traffic in the background even if sending or receiving data is
forbidden.
This is equivalent to the POSIX shutdown() function. Setting how
to
PSEUDO_TCP_SHUTDOWN_RDWR is equivalent to calling pseudo_tcp_socket_close().
Since: 0.1.8
gboolean
pseudo_tcp_socket_is_closed (PseudoTcpSocket *self);
Gets whether the socket is closed, with the shutdown handshake completed, and both peers no longer able to read or write data to the connection.
Since: 0.1.8
gboolean
pseudo_tcp_socket_is_closed_remotely (PseudoTcpSocket *self);
Gets whether the socket has been closed on the remote peer’s side of the
connection (i.e. whether pseudo_tcp_socket_close() has been called there).
This is guaranteed to return TRUE if pseudo_tcp_socket_is_closed() returns
TRUE. It will not return TRUE after pseudo_tcp_socket_close() is called
until a FIN segment is received from the remote peer.
Since: 0.1.8
int
pseudo_tcp_socket_get_error (PseudoTcpSocket *self);
Return the last encountered error.
The return value can be :
EINVAL (for pseudo_tcp_socket_connect()).
EWOULDBLOCK or ENOTCONN (for pseudo_tcp_socket_recv() and
pseudo_tcp_socket_send()).
The error code
See also: pseudo_tcp_socket_connect()
See also: pseudo_tcp_socket_recv()
See also: pseudo_tcp_socket_send()
Since: 0.0.11
gboolean pseudo_tcp_socket_get_next_clock (PseudoTcpSocket *self,guint64 *timeout);
Call this to determine the timeout needed before the next time call
to pseudo_tcp_socket_notify_clock() should be made.
TRUE if timeout
was filled, FALSE if the socket is closed and
ready to be destroyed.
See also: pseudo_tcp_socket_notify_clock()
Since: 0.0.11
void
pseudo_tcp_socket_notify_clock (PseudoTcpSocket *self);
Start the processing of receiving data, pending data or syn/acks.
Call this based on timeout value returned by
pseudo_tcp_socket_get_next_clock().
It's ok to call this too frequently.
See also: pseudo_tcp_socket_get_next_clock()
Since: 0.0.11
void pseudo_tcp_socket_notify_mtu (PseudoTcpSocket *self,guint16 mtu);
Set the MTU of the socket
Since: 0.0.11
gboolean pseudo_tcp_socket_notify_packet (PseudoTcpSocket *self,const gchar *buffer,guint32 len);
Notify the PseudoTcpSocket when a new packet arrives
self |
The PseudoTcpSocket object. |
|
buffer |
The buffer containing the received data |
|
len |
The length of |
Since: 0.0.11
void
pseudo_tcp_set_debug_level (PseudoTcpDebugLevel level);
Sets the debug level to enable/disable normal/verbose debug messages.
Since: 0.0.11
gint
pseudo_tcp_socket_get_available_bytes (PseudoTcpSocket *self);
Gets the number of bytes of data in the buffer that can be read without receiving more packets from the network.
Since: 0.1.5
gboolean
pseudo_tcp_socket_can_send (PseudoTcpSocket *self);
Returns if there is space in the send buffer to send any data.
Since: 0.1.5
gsize
pseudo_tcp_socket_get_available_send_space
(PseudoTcpSocket *self);
Gets the number of bytes of space available in the transmission buffer.
Since: 0.1.5
gboolean pseudo_tcp_socket_notify_message (PseudoTcpSocket *self,NiceInputMessage *message);
Notify the PseudoTcpSocket that a new message has arrived, and enqueue the data in its buffers to the PseudoTcpSocket’s receive buffer.
self |
The PseudoTcpSocket object. |
|
message |
A NiceInputMessage containing the received data. |
Since: 0.1.5
void pseudo_tcp_socket_set_time (PseudoTcpSocket *self,guint32 current_time);
Sets the current monotonic time to be used by the TCP socket when calculating
timeouts and expiry times. If this function is not called, or is called with
current_time
as zero, g_get_monotonic_time() will be used. Otherwise, the
specified current_time
will be used until it is updated by calling this
function again.
This function is intended for testing only, and should not be used in production code.
self |
The PseudoTcpSocket object. |
|
current_time |
Current monotonic time, in milliseconds; or zero to use the system monotonic clock. |
Since: 0.1.8
typedef struct _PseudoTcpSocket PseudoTcpSocket;
The PseudoTcpSocket is the GObject implementing the Pseudo TCP Socket
Since: 0.0.11
An enum representing the state of the PseudoTcpSocket. These states correspond to the TCP states in RFC 793.
See also: “state”
|
The socket's initial state. The socket isn't connected and is listening for an incoming connection |
||
|
The socket has sent a connection request (SYN) packet and is waiting for an answer |
||
|
The socket has received a connection request (SYN) packet. |
||
|
The socket is connected |
||
|
The socket has been closed |
||
|
The socket has been closed locally but not remotely (Since: 0.1.8) |
||
|
The socket has been closed locally but not remotely (Since: 0.1.8) |
||
|
The socket has been closed locally and remotely (Since: 0.1.8) |
||
|
The socket has been closed locally and remotely (Since: 0.1.8) |
||
|
The socket has been closed remotely but not locally (Since: 0.1.8) |
||
|
The socket has been closed locally and remotely (Since: 0.1.8) |
Since: 0.0.11
An enum representing the result value of the write operation requested by the PseudoTcpSocket.
See also: PseudoTcpCallbacks:WritePacket
Since: 0.0.11
typedef struct {
gpointer user_data;
void (*PseudoTcpOpened) (PseudoTcpSocket *tcp, gpointer data);
void (*PseudoTcpReadable) (PseudoTcpSocket *tcp, gpointer data);
void (*PseudoTcpWritable) (PseudoTcpSocket *tcp, gpointer data);
void (*PseudoTcpClosed) (PseudoTcpSocket *tcp, guint32 error, gpointer data);
PseudoTcpWriteResult (*WritePacket) (PseudoTcpSocket *tcp,
const gchar * buffer, guint32 len, gpointer data);
} PseudoTcpCallbacks;
A structure containing callbacks functions that will be called by the PseudoTcpSocket when some events happen.
See also: PseudoTcpWriteResult
gpointer |
A user defined pointer to be passed to the callbacks |
|
The PseudoTcpSocket is now connected |
||
The socket is readable |
||
The socket is writable |
||
The socket was closed (both sides) |
||
This callback is called when the socket needs to send data. |
Since: 0.0.11
Options for which parts of a connection to shut down when calling
pseudo_tcp_socket_shutdown(). These correspond to the values passed to POSIX
shutdown().
Since: 0.1.8
“ack-delay” property“ack-delay” guint
Delayed ACK timeout (in milliseconds).
Owner: PseudoTcpSocket
Flags: Read / Write
Default value: 100
“callbacks” property“callbacks” gpointer
Structure with the callbacks to call when PseudoTcp events happen.
Owner: PseudoTcpSocket
Flags: Read / Write
“conversation” property“conversation” guint
The TCP Conversation ID.
Owner: PseudoTcpSocket
Flags: Read / Write / Construct Only
Default value: 0
“no-delay” property“no-delay” gboolean
Disable the Nagle algorithm (like the TCP_NODELAY option).
Owner: PseudoTcpSocket
Flags: Read / Write
Default value: TRUE
“rcv-buf” property“rcv-buf” guint
Receive Buffer size.
Owner: PseudoTcpSocket
Flags: Read / Write
Allowed values: >= 1
Default value: 61440
“snd-buf” property“snd-buf” guint
Send Buffer size.
Owner: PseudoTcpSocket
Flags: Read / Write
Allowed values: >= 1
Default value: 92160
“state” property“state” guint
The current state (enum PseudoTcpState) of the PseudoTcp socket.
Owner: PseudoTcpSocket
Flags: Read
Allowed values: <= 4
Default value: 0
“support-fin-ack” property“support-fin-ack” gboolean
Whether to support the FIN–ACK extension to the pseudo-TCP protocol for this socket. The extension is only compatible with other libnice pseudo-TCP stacks, and not with Jingle pseudo-TCP stacks. If enabled, support is negotiatied on connection setup, so it is safe for a PseudoTcpSocket with support enabled to be used with one with it disabled, or with a Jingle pseudo-TCP socket which doesn’t support it at all.
Support is enabled by default.
Owner: PseudoTcpSocket
Flags: Read / Write / Construct Only
Default value: TRUE
Since: 0.1.8