use the stupid gofmt

7 files changed, 537 insertions, 476 deletions

diff --git a/crypto.go b/crypto.go
index aba5602..5e77d6d 100644
--- a/crypto.go
+++ b/crypto.go
@@ -7,92 +7,94 @@ import "runtime"
 
 // The C pointer type for a X509 handle.
 type CX509 = *C.x509_t
-type x509 struct { inner CX509 }
+type x509 struct{ inner CX509 }
+
 // The handle for a X509 certificate.
 type X509 = *x509
 
 func X509FromC(ptr CX509) X509 {
-    return &x509{ inner: ptr }
+	return &x509{inner: ptr}
 }
 
 func NewX509FromPemFile(fname string, passwd *string, err *Error) X509 {
-    fname_c_str := C.CString(fname)
-    passwd_c_str := (*C.char)(nil)
-    if passwd != nil {
-        passwd_c_str = C.CString(*passwd)
-    }
-    res := X509FromC(C.x509_new_from_pem_file(fname_c_str, passwd_c_str, err))
-    if res != nil {
-        runtime.SetFinalizer(res, func(self X509) { self.free() })
-    }
-    C.free(rawptr_t(fname_c_str))
-    if passwd_c_str != nil {
-        C.free(rawptr_t(passwd_c_str))
-    }
-    return res
+	fname_c_str := C.CString(fname)
+	passwd_c_str := (*C.char)(nil)
+	if passwd != nil {
+		passwd_c_str = C.CString(*passwd)
+	}
+	res := X509FromC(C.x509_new_from_pem_file(fname_c_str, passwd_c_str, err))
+	if res != nil {
+		runtime.SetFinalizer(res, func(self X509) { self.free() })
+	}
+	C.free(rawptr_t(fname_c_str))
+	if passwd_c_str != nil {
+		C.free(rawptr_t(passwd_c_str))
+	}
+	return res
 }
 
 func NewX509FromDer(der ByteArray, err *Error) X509 {
-    res := X509FromC(C.x509_new_from_der(der.inner, err))
-    if res != nil {
-        runtime.SetFinalizer(res, func(self X509) { self.free() })
-    }
-    return res
+	res := X509FromC(C.x509_new_from_der(der.inner, err))
+	if res != nil {
+		runtime.SetFinalizer(res, func(self X509) { self.free() })
+	}
+	return res
 }
 
 func (self X509) free() { C.x509_free(self.inner) }
 func (self X509) GetPubKey() PKey {
-    res := &pKey{ inner: C.x509_get_pubkey(self.inner) }
-    runtime.SetFinalizer(res, func(self PKey) { self.free() })
-    return res
+	res := &pKey{inner: C.x509_get_pubkey(self.inner)}
+	runtime.SetFinalizer(res, func(self PKey) { self.free() })
+	return res
 }
 
 func (self X509) GetDer(autoFree bool) ByteArray {
-    res := ByteArrayFromC(C.x509_get_der(self.inner))
-    byteArraySetFinalizer(res, autoFree)
-    return res
+	res := ByteArrayFromC(C.x509_get_der(self.inner))
+	byteArraySetFinalizer(res, autoFree)
+	return res
 }
 
 // The C pointer type for a PKey handle.
 type CPKey = *C.pkey_t
-type pKey struct { inner CPKey }
+type pKey struct{ inner CPKey }
+
 // The handle for an OpenSSL EVP_PKEY.
 type PKey = *pKey
 
 func NewPrivKeyFromPemFile(fname string, passwd *string, err *Error) PKey {
-    fname_c_str := C.CString(fname)
-    passwd_c_str := (*C.char)(nil)
-    if passwd != nil {
-        passwd_c_str = C.CString(*passwd)
-    }
-    res := &pKey{ inner: C.pkey_new_privkey_from_pem_file(fname_c_str, passwd_c_str, err) }
-    if res != nil {
-        runtime.SetFinalizer(res, func(self PKey) { self.free() })
-    }
-    C.free(rawptr_t(fname_c_str))
-    if passwd_c_str != nil {
-        C.free(rawptr_t(passwd_c_str))
-    }
-    return res
+	fname_c_str := C.CString(fname)
+	passwd_c_str := (*C.char)(nil)
+	if passwd != nil {
+		passwd_c_str = C.CString(*passwd)
+	}
+	res := &pKey{inner: C.pkey_new_privkey_from_pem_file(fname_c_str, passwd_c_str, err)}
+	if res != nil {
+		runtime.SetFinalizer(res, func(self PKey) { self.free() })
+	}
+	C.free(rawptr_t(fname_c_str))
+	if passwd_c_str != nil {
+		C.free(rawptr_t(passwd_c_str))
+	}
+	return res
 }
 
 func NewPrivKeyFromDer(der ByteArray, err *Error) PKey {
-    res := &pKey{ inner: C.pkey_new_privkey_from_der(der.inner, err) }
-    if res != nil {
-        runtime.SetFinalizer(res, func(self PKey) { self.free() })
-    }
-    return res
+	res := &pKey{inner: C.pkey_new_privkey_from_der(der.inner, err)}
+	if res != nil {
+		runtime.SetFinalizer(res, func(self PKey) { self.free() })
+	}
+	return res
 }
 
 func (self PKey) free() { C.pkey_free(self.inner) }
 func (self PKey) GetPubKeyDer(autoFree bool) ByteArray {
-    res := ByteArrayFromC(C.pkey_get_pubkey_der(self.inner))
-    byteArraySetFinalizer(res, autoFree)
-    return res
+	res := ByteArrayFromC(C.pkey_get_pubkey_der(self.inner))
+	byteArraySetFinalizer(res, autoFree)
+	return res
 }
 
 func (self PKey) GetPrivKeyDer(autoFree bool) ByteArray {
-    res := ByteArrayFromC(C.pkey_get_privkey_der(self.inner))
-    byteArraySetFinalizer(res, autoFree)
-    return res
+	res := ByteArrayFromC(C.pkey_get_privkey_der(self.inner))
+	byteArraySetFinalizer(res, autoFree)
+	return res
 }
diff --git a/event.go b/event.go
index 3923dc8..6323907 100644
--- a/event.go
+++ b/event.go
@@ -8,24 +8,25 @@ import "runtime"
 // The C pointer type for an EventContext handle.
 type CEventContext = *C.eventcontext_t
 type eventContext struct {
-    inner CEventContext
-    attached map[uintptr]interface{}
+	inner    CEventContext
+	attached map[uintptr]interface{}
 }
+
 // The handle for an event loop.
 type EventContext = *eventContext
 
 func NewEventContext() EventContext {
-    res := &eventContext{
-        inner: C.eventcontext_new(),
-        attached: make(map[uintptr]interface{}),
-    }
-    runtime.SetFinalizer(res, func(self EventContext) { self.free() })
-    return res
+	res := &eventContext{
+		inner:    C.eventcontext_new(),
+		attached: make(map[uintptr]interface{}),
+	}
+	runtime.SetFinalizer(res, func(self EventContext) { self.free() })
+	return res
 }
 
 func (self EventContext) attach(ptr rawptr_t, x interface{}) { self.attached[uintptr(ptr)] = x }
-func (self EventContext) detach(ptr rawptr_t) { delete(self.attached, uintptr(ptr)) }
-func (self EventContext) free() { C.eventcontext_free(self.inner) }
+func (self EventContext) detach(ptr rawptr_t)                { delete(self.attached, uintptr(ptr)) }
+func (self EventContext) free()                              { C.eventcontext_free(self.inner) }
 
 // Start the event loop. This is a blocking call that will hand over the
 // control flow to the infinite loop which triggers callbacks upon new events.
@@ -40,7 +41,8 @@ func (self EventContext) Stop() { C.eventcontext_stop(self.inner) }
 
 // The C pointer type for a ThreadCall handle.
 type CThreadCall = *C.threadcall_t
-type threadCall struct { inner CThreadCall }
+type threadCall struct{ inner CThreadCall }
+
 // The handle for scheduling a function call executed by a particular
 // EventContext event loop.
 type ThreadCall = *threadCall
@@ -53,23 +55,23 @@ type ThreadCallCallback = C.threadcall_callback_t
 // invokcation of AsyncCall() will schedule a function call executed in the
 // given EventContext event loop.
 func NewThreadCall(ec EventContext) ThreadCall {
-    res := &threadCall{ inner: C.threadcall_new(ec.inner) }
-    runtime.SetFinalizer(res, func(self ThreadCall) { self.free() })
-    return res
+	res := &threadCall{inner: C.threadcall_new(ec.inner)}
+	runtime.SetFinalizer(res, func(self ThreadCall) { self.free() })
+	return res
 }
 
 func (self ThreadCall) free() { C.threadcall_free(self.inner) }
 
 // Schedule a function to be executed in the target event loop.
 func (self ThreadCall) AsyncCall(callback ThreadCallCallback, userdata rawptr_t) {
-    C.threadcall_async_call(self.inner, callback, userdata)
+	C.threadcall_async_call(self.inner, callback, userdata)
 }
 
 // The C pointer type for TimerEvent handle.
 type CTimerEvent = *C.timerev_t
 type timerEvent struct {
-    inner CTimerEvent
-    ec EventContext
+	inner CTimerEvent
+	ec    EventContext
 }
 
 // The handle for a timed event.
@@ -82,45 +84,44 @@ type TimerEventCallback = C.timerev_callback_t
 // Create a TimerEvent handle attached to the given EventContext, with a
 // registered callback.
 func NewTimerEvent(_ec EventContext, cb TimerEventCallback, userdata rawptr_t) TimerEvent {
-    res := &timerEvent{
-        inner: C.timerev_new(_ec.inner, cb, userdata),
-        ec: _ec,
-    }
-    _ec.attach(rawptr_t(res.inner), res)
-    runtime.SetFinalizer(res, func(self TimerEvent) { self.free() })
-    return res
+	res := &timerEvent{
+		inner: C.timerev_new(_ec.inner, cb, userdata),
+		ec:    _ec,
+	}
+	_ec.attach(rawptr_t(res.inner), res)
+	runtime.SetFinalizer(res, func(self TimerEvent) { self.free() })
+	return res
 }
 
 func (self TimerEvent) free() { C.timerev_free(self.inner) }
 
 // Change the callback.
 func (self TimerEvent) SetCallback(callback TimerEventCallback, userdata rawptr_t) {
-    C.timerev_set_callback(self.inner, callback, userdata)
+	C.timerev_set_callback(self.inner, callback, userdata)
 }
 
 // Schedule the timer to go off after t_sec seconds.
 func (self TimerEvent) Add(t_sec float64) { C.timerev_add(self.inner, C.double(t_sec)) }
 
-
 // Unschedule the timer if it was scheduled. The timer could still be rescheduled
 // by calling Add() afterwards.
 func (self TimerEvent) Del() {
-    self.ec.detach(rawptr_t(self.inner))
-    C.timerev_del(self.inner)
+	self.ec.detach(rawptr_t(self.inner))
+	C.timerev_del(self.inner)
 }
 
 // Empty the timer. It will be unscheduled and deallocated and its methods
 // should never be called again.
 func (self TimerEvent) Clear() {
-    self.ec.detach(rawptr_t(self.inner))
-    C.timerev_clear(self.inner)
+	self.ec.detach(rawptr_t(self.inner))
+	C.timerev_clear(self.inner)
 }
 
 // The C pointer type for a SigEvent.
 type CSigEvent = *C.sigev_t
 type sigEvent struct {
-    inner CSigEvent
-    ec EventContext
+	inner CSigEvent
+	ec    EventContext
 }
 
 // The handle for a UNIX signal event.
@@ -129,20 +130,20 @@ type SigEvent = *sigEvent
 type SigEventCallback = C.sigev_callback_t
 
 var (
-    SIGTERM = C.SIGTERM
-    SIGINT = C.SIGINT
+	SIGTERM = C.SIGTERM
+	SIGINT  = C.SIGINT
 )
 
 // Create a SigEvent handle attached to the given EventContext, with a
 // registered callback.
 func NewSigEvent(_ec EventContext, cb SigEventCallback, userdata rawptr_t) SigEvent {
-    res := &sigEvent{
-        inner: C.sigev_new(_ec.inner, cb, userdata),
-        ec: _ec,
-    }
-    _ec.attach(rawptr_t(res.inner), res)
-    runtime.SetFinalizer(res, func(self SigEvent) { self.free() })
-    return res
+	res := &sigEvent{
+		inner: C.sigev_new(_ec.inner, cb, userdata),
+		ec:    _ec,
+	}
+	_ec.attach(rawptr_t(res.inner), res)
+	runtime.SetFinalizer(res, func(self SigEvent) { self.free() })
+	return res
 }
 
 func (self SigEvent) free() { C.sigev_free(self.inner) }
@@ -150,25 +151,24 @@ func (self SigEvent) free() { C.sigev_free(self.inner) }
 // Register the handle to listen for UNIX signal sig.
 func (self SigEvent) Add(sig int) { C.sigev_add(self.inner, C.int(sig)) }
 
-
 // Unregister the handle. The handle may be re-registered in the future.
 func (self SigEvent) Del() {
-    self.ec.detach(rawptr_t(self.inner))
-    C.sigev_del(self.inner)
+	self.ec.detach(rawptr_t(self.inner))
+	C.sigev_del(self.inner)
 }
 
 // Unregister the handle. Any methods of the handle should no longer be used
 // and the handle will be deallocated.
 func (self SigEvent) Clear() {
-    self.ec.detach(rawptr_t(self.inner))
-    C.sigev_clear(self.inner)
+	self.ec.detach(rawptr_t(self.inner))
+	C.sigev_clear(self.inner)
 }
 
 // The C pointer type for a MPSCQueue object.
 type CMPSCQueue = *C.mpscqueue_t
 type mpscQueue struct {
-    inner CMPSCQueue
-    ec EventContext
+	inner CMPSCQueue
+	ec    EventContext
 }
 
 // The object for a Multi-Producer, Single-Consumer queue.
@@ -182,41 +182,41 @@ type MPSCQueueCallback = C.mpscqueue_callback_t
 
 // Create a MPSCQueue object.
 func NewMPSCQueue() MPSCQueue {
-    res := &mpscQueue{ inner: C.mpscqueue_new(), ec: nil }
-    runtime.SetFinalizer(res, func(self MPSCQueue) { self.free() })
-    return res
+	res := &mpscQueue{inner: C.mpscqueue_new(), ec: nil}
+	runtime.SetFinalizer(res, func(self MPSCQueue) { self.free() })
+	return res
 }
 
 func (self MPSCQueue) free() { C.mpscqueue_free(self.inner) }
 
 // Register the callback invoked when there are new elements in the MPSC queue.
 func (self MPSCQueue) RegHandler(_ec EventContext, callback MPSCQueueCallback, userdata rawptr_t) {
-    C.mpscqueue_reg_handler(self.inner, _ec.inner, callback, userdata)
-    self.ec = _ec
-    _ec.attach(rawptr_t(self.inner), self)
+	C.mpscqueue_reg_handler(self.inner, _ec.inner, callback, userdata)
+	self.ec = _ec
+	_ec.attach(rawptr_t(self.inner), self)
 }
 
 // Unregister the callback.
 func (self MPSCQueue) UnregHandler() {
-    self.ec.detach(rawptr_t(self.inner))
-    C.mpscqueue_unreg_handler(self.inner)
+	self.ec.detach(rawptr_t(self.inner))
+	C.mpscqueue_unreg_handler(self.inner)
 }
 
 // Enqueue an element (thread-safe). It returns true if successful. If
 // unbounded is true the queue is expanded when full (and this function will
 // return true).
 func (self MPSCQueue) Enqueue(elem rawptr_t, unbounded bool) bool {
-    return bool(C.mpscqueue_enqueue(self.inner, elem, C.bool(unbounded)))
+	return bool(C.mpscqueue_enqueue(self.inner, elem, C.bool(unbounded)))
 }
 
 // Try to dequeue an element from the queue (should only be called from one
 // thread). It returns true if successful.
 func (self MPSCQueue) TryDequeue(elem *rawptr_t) bool {
-    return bool(C.mpscqueue_try_dequeue(self.inner, elem))
+	return bool(C.mpscqueue_try_dequeue(self.inner, elem))
 }
 
 // Set the initial capacity of the queue. This should only be called before the
 // first dequeue/enqueue operation.
 func (self MPSCQueue) SetCapacity(capacity int) {
-    C.mpscqueue_set_capacity(self.inner, C.size_t(capacity))
+	C.mpscqueue_set_capacity(self.inner, C.size_t(capacity))
 }
diff --git a/msg.go b/msg.go
index f7e6b1c..e7fd774 100644
--- a/msg.go
+++ b/msg.go
@@ -8,9 +8,10 @@ import "runtime"
 // The C pointer type for a Msg object.
 type CMsg = *C.msg_t
 type msg struct {
-    inner CMsg
-    autoFree bool
+	inner    CMsg
+	autoFree bool
 }
+
 // Message sent by MsgNetwork.
 type Msg = *msg
 
@@ -19,29 +20,29 @@ type Msg = *msg
 // 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 MsgFromC(ptr CMsg) Msg { return &msg{ inner: ptr } }
+func MsgFromC(ptr CMsg) Msg { return &msg{inner: ptr} }
 
 func msgSetFinalizer(res Msg, autoFree bool) {
-    res.autoFree = autoFree
-    if res != nil && autoFree {
-        runtime.SetFinalizer(res, func(self Msg) { self.Free() })
-    }
+	res.autoFree = autoFree
+	if res != nil && autoFree {
+		runtime.SetFinalizer(res, func(self Msg) { self.Free() })
+	}
 }
 
 // Create a message by taking out all data from src. Notice this is a zero-copy
 // operation that consumes and invalidates the data in src ("move" semantics)
 // so that no more operation should be done to src after this function call.
 func NewMsgMovedFromByteArray(opcode Opcode, src ByteArray, autoFree bool) Msg {
-    res := MsgFromC(C.msg_new_moved_from_bytearray(C._opcode_t(opcode), src.inner))
-    msgSetFinalizer(res, autoFree)
-    return res
+	res := MsgFromC(C.msg_new_moved_from_bytearray(C._opcode_t(opcode), src.inner))
+	msgSetFinalizer(res, autoFree)
+	return res
 }
 
 func (self Msg) Free() {
-    C.msg_free(self.inner)
-    if self.autoFree {
-        runtime.SetFinalizer(self, nil)
-    }
+	C.msg_free(self.inner)
+	if self.autoFree {
+		runtime.SetFinalizer(self, nil)
+	}
 }
 
 // Get the message payload by taking out all data. Notice this is a zero-copy
@@ -49,22 +50,22 @@ func (self Msg) Free() {
 // semantics) so that no more operation should be done to the payload after
 // this function call.
 func (self Msg) GetPayloadByMove() DataStream {
-    res := DataStreamFromC(C.msg_consume_payload(self.inner))
-    runtime.SetFinalizer(res, func(self DataStream) { self.Free() })
-    return res
+	res := DataStreamFromC(C.msg_consume_payload(self.inner))
+	runtime.SetFinalizer(res, func(self DataStream) { self.Free() })
+	return res
 }
 
 // Get the opcode.
 func (self Msg) GetOpcode() Opcode {
-    return Opcode(C.msg_get_opcode(self.inner))
+	return Opcode(C.msg_get_opcode(self.inner))
 }
 
 // Get the magic number.
 func (self Msg) GetMagic() uint32 {
-    return uint32(C.msg_get_magic(self.inner))
+	return uint32(C.msg_get_magic(self.inner))
 }
 
 // Set the magic number (the default value is 0x0).
 func (self Msg) SetMagic(magic uint32) {
-    C.msg_set_magic(self.inner, C.uint32_t(magic))
+	C.msg_set_magic(self.inner, C.uint32_t(magic))
 }
diff --git a/netaddr.go b/netaddr.go
index cc69313..096be06 100644
--- a/netaddr.go
+++ b/netaddr.go
@@ -8,9 +8,10 @@ import "runtime"
 // The C pointer type for a NetAddr object
 type CNetAddr = *C.netaddr_t
 type netAddr struct {
-    inner CNetAddr
-    autoFree bool
+	inner    CNetAddr
+	autoFree bool
 }
+
 // Network address object.
 type NetAddr = *netAddr
 
@@ -20,30 +21,30 @@ type NetAddr = *netAddr
 // deallocated when the go object is finalized by GC. This applies to all other
 // "FromC" functions.
 func NetAddrFromC(ptr CNetAddr) NetAddr {
-    return &netAddr{ inner: ptr }
+	return &netAddr{inner: ptr}
 }
 
 func netAddrSetFinalizer(res NetAddr, autoFree bool) {
-    res.autoFree = autoFree
-    if res != nil && autoFree {
-        runtime.SetFinalizer(res, func(self NetAddr) { self.Free() })
-    }
+	res.autoFree = autoFree
+	if res != nil && autoFree {
+		runtime.SetFinalizer(res, func(self NetAddr) { self.Free() })
+	}
 }
 
 // Create NetAddr from a TCP socket format string (e.g. 127.0.0.1:8888).
 func NewNetAddrFromIPPortString(addr string, autoFree bool, err *Error) (res NetAddr) {
-    c_str := C.CString(addr)
-    res = &netAddr{ inner: C.netaddr_new_from_sipport(c_str, err) }
-    C.free(rawptr_t(c_str))
-    netAddrSetFinalizer(res, autoFree)
-    return
+	c_str := C.CString(addr)
+	res = &netAddr{inner: C.netaddr_new_from_sipport(c_str, err)}
+	C.free(rawptr_t(c_str))
+	netAddrSetFinalizer(res, autoFree)
+	return
 }
 
 func (self NetAddr) Free() {
-    C.netaddr_free(self.inner)
-    if self.autoFree {
-        runtime.SetFinalizer(self, nil)
-    }
+	C.netaddr_free(self.inner)
+	if self.autoFree {
+		runtime.SetFinalizer(self, nil)
+	}
 }
 
 // Check if two addresses are the same.
@@ -62,54 +63,55 @@ func (self NetAddr) GetPort() uint16 { return uint16(C.netaddr_get_port(self.inn
 // returned (or passed as a callback parameter) by other salticidae methods
 // (such like MsgNetwork/PeerNetwork), unless those method return a moved object.
 func (self NetAddr) Copy(autoFree bool) NetAddr {
-    res := &netAddr{ inner: C.netaddr_copy(self.inner) }
-    netAddrSetFinalizer(res, autoFree)
-    return res
+	res := &netAddr{inner: C.netaddr_copy(self.inner)}
+	netAddrSetFinalizer(res, autoFree)
+	return res
 }
 
 // The C pointer type for a NetAddrArray object.
 type CNetAddrArray = *C.netaddr_array_t
 type netAddrArray struct {
-    inner CNetAddrArray
-    autoFree bool
+	inner    CNetAddrArray
+	autoFree bool
 }
+
 // An array of network address.
 type NetAddrArray = *netAddrArray
 
 func NetAddrArrayFromC(ptr CNetAddrArray) NetAddrArray {
-    return &netAddrArray{ inner: ptr }
+	return &netAddrArray{inner: ptr}
 }
 
 func netAddrArraySetFinalizer(res NetAddrArray, autoFree bool) {
-    res.autoFree = autoFree
-    if res != nil && autoFree {
-        runtime.SetFinalizer(res, func(self NetAddrArray) { self.Free() })
-    }
+	res.autoFree = autoFree
+	if res != nil && autoFree {
+		runtime.SetFinalizer(res, func(self NetAddrArray) { self.Free() })
+	}
 }
 
 // Convert a Go slice of net addresses to NetAddrArray.
 func NewNetAddrArrayFromAddrs(arr []NetAddr, autoFree bool) (res NetAddrArray) {
-    size := len(arr)
-    _arr := make([]CNetAddr, size)
-    for i, v := range arr {
-        _arr[i] = v.inner
-    }
-    if size > 0 {
-        // FIXME: here we assume struct of a single pointer has the same memory
-        // footprint the pointer
-        base := (**C.netaddr_t)(rawptr_t(&_arr[0]))
-        res = NetAddrArrayFromC(C.netaddr_array_new_from_addrs(base, C.size_t(size)))
-    } else {
-        res = NetAddrArrayFromC(C.netaddr_array_new())
-    }
-    runtime.KeepAlive(_arr)
-    netAddrArraySetFinalizer(res, autoFree)
-    return
+	size := len(arr)
+	_arr := make([]CNetAddr, size)
+	for i, v := range arr {
+		_arr[i] = v.inner
+	}
+	if size > 0 {
+		// FIXME: here we assume struct of a single pointer has the same memory
+		// footprint the pointer
+		base := (**C.netaddr_t)(rawptr_t(&_arr[0]))
+		res = NetAddrArrayFromC(C.netaddr_array_new_from_addrs(base, C.size_t(size)))
+	} else {
+		res = NetAddrArrayFromC(C.netaddr_array_new())
+	}
+	runtime.KeepAlive(_arr)
+	netAddrArraySetFinalizer(res, autoFree)
+	return
 }
 
 func (self NetAddrArray) Free() {
-    C.netaddr_array_free(self.inner)
-    if self.autoFree {
-        runtime.SetFinalizer(self, nil)
-    }
+	C.netaddr_array_free(self.inner)
+	if self.autoFree {
+		runtime.SetFinalizer(self, nil)
+	}
 }
diff --git a/network.go b/network.go
index b123eca..574a962 100644
--- a/network.go
+++ b/network.go
@@ -7,7 +7,8 @@ import "runtime"
 
 // The C pointer type for a MsgNetwork handle.
 type CMsgNetwork = *C.msgnetwork_t
-type msgNetwork struct { inner CMsgNetwork }
+type msgNetwork struct{ inner CMsgNetwork }
+
 // The handle for a message network.
 type MsgNetwork = *msgNetwork
 
@@ -17,25 +18,26 @@ type MsgNetwork = *msgNetwork
 // 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 }
+	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
+	inner    CMsgNetworkConn
+	autoFree bool
 }
+
 // The handle for a message network connection.
 type MsgNetworkConn = *msgNetworkConn
 
 func MsgNetworkConnFromC(ptr CMsgNetworkConn) MsgNetworkConn {
-    return &msgNetworkConn{ inner: ptr }
+	return &msgNetworkConn{inner: ptr}
 }
 
 var (
-    CONN_MODE_ACTIVE = MsgNetworkConnMode(C.CONN_MODE_ACTIVE)
-    CONN_MODE_PASSIVE = MsgNetworkConnMode(C.CONN_MODE_PASSIVE)
+	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
@@ -44,73 +46,73 @@ var (
 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() })
-    }
+	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)
-    }
+	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))
+	return MsgNetworkFromC(C.msgnetwork_conn_get_net(self.inner))
 }
 
 func (self MsgNetworkConn) GetMode() MsgNetworkConnMode {
-    return C.msgnetwork_conn_get_mode(self.inner)
+	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))
+	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))
+	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) }
+	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
+	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 }
+type msgNetworkConfig struct{ inner CMsgNetworkConfig }
+
 // Configuration for MsgNetwork.
 type MsgNetworkConfig = *msgNetworkConfig
 
 func MsgNetworkConfigFromC(ptr CMsgNetworkConfig) MsgNetworkConfig {
-    return &msgNetworkConfig{ inner: ptr }
+	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
+	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) }
@@ -119,62 +121,62 @@ func (self MsgNetworkConfig) free() { C.msgnetwork_config_free(self.inner) }
 // 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))
+	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))
+	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))
+	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))
+	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))
+	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))
+	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))
+	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))
+	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))
+	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)
+	C.msgnetwork_config_tls_key_by_move(self.inner, pkey.inner)
 }
 
 //// Load the TLS certificate from a file. The file should be an unencrypted
@@ -187,12 +189,12 @@ func (self MsgNetworkConfig) TLSKeyByMove(pkey PKey) {
 
 // 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
+	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) }
@@ -202,14 +204,16 @@ func (self MsgNetwork) free() { C.msgnetwork_free(self.inner) }
 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) }
+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))
+	return bool(C.msgnetwork_send_msg(self.inner, msg.inner, conn.inner))
 }
 
 // Send a message through the given connection, using a worker thread to
@@ -217,21 +221,21 @@ func (self MsgNetwork) SendMsg(msg Msg, conn MsgNetworkConn) bool {
 // 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))
+	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
+	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 NetAddr) int32 {
-    return int32(C.msgnetwork_connect(self.inner, addr.inner))
+	return int32(C.msgnetwork_connect(self.inner, addr.inner))
 }
 
 // Terminate the given connection.
@@ -240,10 +244,12 @@ func (self MsgNetwork) Terminate(conn MsgNetworkConn) { C.msgnetwork_terminate(s
 // The C function pointer type which takes msg_t*, msgnetwork_conn_t* and void*
 // (passing in the custom user data allocated by C.malloc) as parameters.
 type MsgNetworkMsgCallback = C.msgnetwork_msg_callback_t
+
 // The C function pointer type which takes msgnetwork_conn_t*, bool (true for
 // the connection is established, false for the connection is terminated) and
 // void* as parameters.
 type MsgNetworkConnCallback = C.msgnetwork_conn_callback_t
+
 // The C function Pointer type which takes SalticidaeCError* and void* as parameters.
 type MsgNetworkErrorCallback = C.msgnetwork_error_callback_t
 
@@ -251,53 +257,55 @@ type MsgNetworkErrorCallback = C.msgnetwork_error_callback_t
 // callback function will be invoked upon the delivery of each message with the
 // given opcode, by the thread of the event loop the MsgNetwork is attached to.
 func (self MsgNetwork) RegHandler(opcode Opcode, callback MsgNetworkMsgCallback, userdata rawptr_t) {
-    C.msgnetwork_reg_handler(self.inner, C._opcode_t(opcode), callback, userdata)
+	C.msgnetwork_reg_handler(self.inner, C._opcode_t(opcode), callback, userdata)
 }
 
 // Register a connection handler invoked when the connection state is changed.
 func (self MsgNetwork) RegConnHandler(callback MsgNetworkConnCallback, userdata rawptr_t) {
-    C.msgnetwork_reg_conn_handler(self.i