path: root/network.go

package salticidae

// #include <stdlib.h>
// #include "salticidae/network.h"
import "C"
import "runtime"

// The C pointer type for a MsgNetwork handle.
type CMsgNetwork = *C.msgnetwork_t
type msgNetwork struct{ inner CMsgNetwork }

// The handle for a message network.
type MsgNetwork = *msgNetwork

// Convert an existing C pointer into a go object. Notice that when the go
// object does *not* own the resource of the C pointer, so it is only valid to
// the extent in which the given C pointer is valid. The C memory will not be
// deallocated when the go object is finalized by GC. This applies to all other
// "FromC" functions.
func MsgNetworkFromC(ptr CMsgNetwork) MsgNetwork {
	return &msgNetwork{inner: ptr}
}

// The C pointer type for a MsgNetworkConn handle.
type CMsgNetworkConn = *C.msgnetwork_conn_t
type msgNetworkConn struct {
	inner    CMsgNetworkConn
	autoFree bool
}

// The handle for a message network connection.
type MsgNetworkConn = *msgNetworkConn

func MsgNetworkConnFromC(ptr CMsgNetworkConn) MsgNetworkConn {
	return &msgNetworkConn{inner: ptr}
}

var (
	CONN_MODE_ACTIVE  = MsgNetworkConnMode(C.CONN_MODE_ACTIVE)
	CONN_MODE_PASSIVE = MsgNetworkConnMode(C.CONN_MODE_PASSIVE)
)

// The connection mode. CONN_MODE_ACTIVE: a connection established from the
// local side. CONN_MODE_PASSIVE: a connection established from the remote
// side. CONN_MODE_DEAD: a connection that is already closed.
type MsgNetworkConnMode = C.msgnetwork_conn_mode_t

func msgNetworkConnSetFinalizer(res MsgNetworkConn, autoFree bool) {
	res.autoFree = autoFree
	if res != nil && autoFree {
		runtime.SetFinalizer(res, func(self MsgNetworkConn) { self.Free() })
	}
}

func (self MsgNetworkConn) Free() {
	C.msgnetwork_conn_free(self.inner)
	if self.autoFree {
		runtime.SetFinalizer(self, nil)
	}
}

// Get the corresponding MsgNetwork handle that manages this connection. The
// returned handle is only valid during the lifetime of this connection.
func (self MsgNetworkConn) GetNet() MsgNetwork {
	return MsgNetworkFromC(C.msgnetwork_conn_get_net(self.inner))
}

func (self MsgNetworkConn) GetMode() MsgNetworkConnMode {
	return C.msgnetwork_conn_get_mode(self.inner)
}

// Get the address of the remote end of this connection. Use Copy() to make a
// copy of the address if you want to use the address object beyond the
// lifetime of the connection.
func (self MsgNetworkConn) GetAddr() NetAddr {
	return NetAddrFromC(C.msgnetwork_conn_get_addr(self.inner))
}

// Check if the connection has been terminated.
func (self MsgNetworkConn) IsTerminated() bool {
	return bool(C.msgnetwork_conn_is_terminated(self.inner))
}

// Get the certificate of the remote end of this connection. Use Copy() to make a
// copy of the certificate if you want to use the certificate object beyond the
// lifetime of the connection.
func (self MsgNetworkConn) GetPeerCert() X509 {
	return &x509{inner: C.msgnetwork_conn_get_peer_cert(self.inner)}
}

// Make a copy of the object. This is required if you want to keep the
// connection passed as a callback parameter by other salticidae methods (such
// like MsgNetwork/PeerNetwork).
func (self MsgNetworkConn) Copy(autoFree bool) MsgNetworkConn {
	res := MsgNetworkConnFromC(C.msgnetwork_conn_copy(self.inner))
	msgNetworkConnSetFinalizer(res, autoFree)
	return res
}

// The C pointer type for a MsgNetworkConfig object.
type CMsgNetworkConfig = *C.msgnetwork_config_t
type msgNetworkConfig struct{ inner CMsgNetworkConfig }

// Configuration for MsgNetwork.
type MsgNetworkConfig = *msgNetworkConfig

func MsgNetworkConfigFromC(ptr CMsgNetworkConfig) MsgNetworkConfig {
	return &msgNetworkConfig{inner: ptr}
}

// Create the configuration object with default settings.
func NewMsgNetworkConfig() MsgNetworkConfig {
	res := MsgNetworkConfigFromC(C.msgnetwork_config_new())
	runtime.SetFinalizer(res, func(self MsgNetworkConfig) { self.free() })
	return res
}

func (self MsgNetworkConfig) free() { C.msgnetwork_config_free(self.inner) }

// Set the number of consecutive read attempts in the message delivery queue.
// Usually the default value is good enough. This is used to make the tradeoff
// between the event loop fairness and the amortization of syscall cost.
func (self MsgNetworkConfig) BurstSize(size int) {
	C.msgnetwork_config_burst_size(self.inner, C.size_t(size))
}

// Set the maximum backlogs (see POSIX TCP backlog).
func (self MsgNetworkConfig) MaxListenBacklog(backlog int) {
	C.msgnetwork_config_max_listen_backlog(self.inner, C.int(backlog))
}

// Set the timeout for connecting to the remote (in seconds).
func (self MsgNetworkConfig) ConnServerTimeout(timeout float64) {
	C.msgnetwork_config_conn_server_timeout(self.inner, C.double(timeout))
}

// Set the size for an inbound data chunk (per read() syscall).
func (self MsgNetworkConfig) SegBuffSize(size int) {
	C.msgnetwork_config_seg_buff_size(self.inner, C.size_t(size))
}

// Set the number of worker threads.
func (self MsgNetworkConfig) NWorker(nworker int) {
	C.msgnetwork_config_nworker(self.inner, C.size_t(nworker))
}

// Set the capacity of the send buffer.
func (self MsgNetworkConfig) QueueCapacity(capacity int) {
	C.msgnetwork_config_queue_capacity(self.inner, C.size_t(capacity))
}

// Specify whether to use SSL/TLS. When this flag is enabled, MsgNetwork uses
// TLSKey (or TLSKeyFile) or TLSCert (or TLSCertFile) to setup the underlying
// OpenSSL.
func (self MsgNetworkConfig) EnableTLS(enabled bool) {
	C.msgnetwork_config_enable_tls(self.inner, C.bool(enabled))
}

// Load the TLS key from a file. The file should be an unencrypted PEM file.
// Use TLSKey() instead for more complex usage.
func (self MsgNetworkConfig) TLSKeyFile(fname string) {
	c_str := C.CString(fname)
	C.msgnetwork_config_tls_key_file(self.inner, c_str)
	C.free(rawptr_t(c_str))
}

// Load the TLS certificate from a file. The file should be an unencrypted
// (X509) PEM file.  Use TLSCert() instead for more complex usage.
func (self MsgNetworkConfig) TLSCertFile(fname string) {
	c_str := C.CString(fname)
	C.msgnetwork_config_tls_cert_file(self.inner, c_str)
	C.free(rawptr_t(c_str))
}

// Use the given TLS key. This overrides TLSKeyFile(). pkey will be moved and
// kept by the library. Thus, no methods of msg involving the payload should be
// called afterwards.
func (self MsgNetworkConfig) TLSKeyByMove(pkey PKey) {
	C.msgnetwork_config_tls_key_by_move(self.inner, pkey.inner)
}

//// Load the TLS certificate from a file. The file should be an unencrypted
//// (X509) PEM file.  Use TLSCert() instead for more complex usage.
//func (self MsgNetworkConfig) TLSCert(fname string) {
//    c_str := C.CString(fname)
//    C.msgnetwork_config_tls_cert(self.inner, c_str)
//    C.free(rawptr_t(c_str))
//}

// Create a message network handle which is attached to given event loop.
func NewMsgNetwork(ec EventContext, config MsgNetworkConfig, err *Error) MsgNetwork {
	res := MsgNetworkFromC(C.msgnetwork_new(ec.inner, config.inner, err))
	if res != nil {
		ec.attach(rawptr_t(res.inner), res)
		runtime.SetFinalizer(res, func(self MsgNetwork) { self.free() })
	}
	return res
}

func (self MsgNetwork) free() { C.msgnetwork_free(self.inner) }

// Start the message network (by spawning worker threads). This should be
// called before using any other methods.
func (self MsgNetwork) Start() { C.msgnetwork_start(self.inner) }

// Listen to the specified network address.
func (self MsgNetwork) Listen(addr NetAddr, err *Error) {
	C.msgnetwork_listen(self.inner, addr.inner, err)
}

// Stop the message network. No other methods should be called after this.
func (self MsgNetwork) Stop() { C.msgnetwork_stop(self.inner) }

// Send a message through the given connection.
func (self MsgNetwork) SendMsg(msg Msg, conn MsgNetworkConn) bool {
	return bool(C.msgnetwork_send_msg(self.inner, msg.inner, conn.inner))
}

// Send a message through the given connection, using a worker thread to
// seralize and put data to the send buffer. The payload contained in the given
// msg will be moved and sent. Thus, no methods of msg involving the payload
// should be called afterwards.
func (self MsgNetwork) SendMsgDeferredByMove(msg Msg, conn MsgNetworkConn) int32 {
	return int32(C.msgnetwork_send_msg_deferred_by_move(self.inner, msg.inner, conn.inner))
}

// Try to connect to a remote address. The connection handle is returned. The
// returned connection handle could be kept in your program.
func (self MsgNetwork) ConnectSync(addr NetAddr, autoFree bool, err *Error) MsgNetworkConn {
	res := MsgNetworkConnFromC(C.msgnetwork_connect_sync(self.inner, addr.inner, err))
	msgNetworkConnSetFinalizer(res, autoFree)
	return res
}

// Try to connect to a remote address (async). It returns an id which could be
// used to identify the corresponding error in the error callback.
func (self MsgNetwork) Connect(addr