From 66914cd88bd822d3399e754f43a42906c043f1fd Mon Sep 17 00:00:00 2001 From: Determinant Date: Sat, 22 Jun 2019 01:45:37 -0400 Subject: support TLS; change some API --- Makefile | 5 +- crypto.go | 94 +++++++++++++++++++++++++ network.go | 88 +++++++++++++++++++----- salticidae | 2 +- stream.go | 53 ++++++++++++-- test_msgnet/main.go | 12 ++-- test_msgnet_tls/alice.pem | 83 ++++++++++++++++++++++ test_msgnet_tls/bob.pem | 83 ++++++++++++++++++++++ test_msgnet_tls/main.go | 171 ++++++++++++++++++++++++++++++++++++++++++++++ test_p2p_stress/main.go | 18 ++--- 10 files changed, 569 insertions(+), 40 deletions(-) create mode 100644 crypto.go create mode 100644 test_msgnet_tls/alice.pem create mode 100644 test_msgnet_tls/bob.pem create mode 100644 test_msgnet_tls/main.go diff --git a/Makefile b/Makefile index 4e2b0cb..7ac8971 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,6 @@ .PHONY: all clean -all: build/test_msgnet build/test_p2p_stress +all: build/test_msgnet build/test_p2p_stress build/test_msgnet_tls salticidae/libsalticidae.so: @@ -13,6 +13,9 @@ build: build/test_msgnet: salticidae/libsalticidae.so test_msgnet/main.go make -C salticidae/ go build -o $@ github.com/Determinant/salticidae-go/test_msgnet +build/test_msgnet_tls: salticidae/libsalticidae.so test_msgnet_tls/main.go + make -C salticidae/ + go build -o $@ github.com/Determinant/salticidae-go/test_msgnet_tls build/test_p2p_stress: salticidae/libsalticidae.so test_p2p_stress/main.go make -C salticidae/ go build -o $@ github.com/Determinant/salticidae-go/test_p2p_stress diff --git a/crypto.go b/crypto.go new file mode 100644 index 0000000..528be5c --- /dev/null +++ b/crypto.go @@ -0,0 +1,94 @@ +package salticidae + +// #include +// #include "salticidae/crypto.h" +import "C" +import "runtime" + +// The C pointer type for a X509 handle. +type CX509 = *C.x509_t +type x509 struct { inner CX509 } +// The handle for a X509 certificate. +type X509 = *x509 + +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 := &x509{ inner: 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 := &x509{ inner: 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 +} + +func (self X509) GetDer() ByteArray { + res := &byteArray{ inner: C.x509_get_der(self.inner) } + runtime.SetFinalizer(res, func(self ByteArray) { self.free() }) + return res +} + +// The C pointer type for a PKey handle. +type CPKey = *C.pkey_t +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 +} + +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 +} + +func (self PKey) free() { C.pkey_free(self.inner) } +func (self PKey) GetPubKeyDer() ByteArray { + res := &byteArray{ inner: C.pkey_get_pubkey_der(self.inner) } + runtime.SetFinalizer(res, func(self ByteArray) { self.free() }) + return res +} + +func (self PKey) GetPrivKeyDer() ByteArray { + res := &byteArray{ inner: C.pkey_get_privkey_der(self.inner) } + runtime.SetFinalizer(res, func(self ByteArray) { self.free() }) + return res +} diff --git a/network.go b/network.go index 0440326..5880cc9 100644 --- a/network.go +++ b/network.go @@ -1,5 +1,6 @@ package salticidae +// #include // #include "salticidae/network.h" import "C" import "runtime" @@ -59,6 +60,13 @@ func (self MsgNetworkConn) GetAddr() NetAddr { return NetAddrFromC(C.msgnetwork_conn_get_addr(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). @@ -95,36 +103,76 @@ func (self MsgNetworkConfig) BurstSize(size int) { C.msgnetwork_config_burst_size(self.inner, C.size_t(size)) } -// Maximum backlogs (see POSIX TCP backlog). +// 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)) } -// The timeout for connecting to the remote (in seconds). +// 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)) } -// The size for an inbound data chunk (per read() syscall). +// 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)) } -// The number of worker threads. +// Set the number of worker threads. func (self MsgNetworkConfig) NWorker(nworker int) { C.msgnetwork_config_nworker(self.inner, C.size_t(nworker)) } -// The capacity of the send buffer. +// 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) MsgNetwork { - res := MsgNetworkFromC(C.msgnetwork_new(ec.inner, config.inner)) - ec.attach(rawptr_t(res.inner), res) - runtime.SetFinalizer(res, func(self MsgNetwork) { self.free() }) +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 } @@ -155,9 +203,11 @@ func (self MsgNetwork) SendMsgDeferredByMove(msg Msg, conn MsgNetworkConn) { // 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) Connect(addr NetAddr, err *Error) MsgNetworkConn { - res := MsgNetworkConnFromC(C.msgnetwork_connect(self.inner, addr.inner, err)) - runtime.SetFinalizer(res, func(self MsgNetworkConn) { self.free() }) +func (self MsgNetwork) Connect(addr NetAddr, blocking bool, err *Error) MsgNetworkConn { + res := MsgNetworkConnFromC(C.msgnetwork_connect(self.inner, addr.inner, C.bool(blocking), err)) + if res != nil { + runtime.SetFinalizer(res, func(self MsgNetworkConn) { self.free() }) + } return res } @@ -269,10 +319,12 @@ func (self PeerNetworkConfig) AsMsgNetworkConfig() MsgNetworkConfig { } // Create a peer-to-peer message network handle. -func NewPeerNetwork(ec EventContext, config PeerNetworkConfig) PeerNetwork { - res := PeerNetworkFromC(C.peernetwork_new(ec.inner, config.inner)) - ec.attach(rawptr_t(res.inner), res) - runtime.SetFinalizer(res, func(self PeerNetwork) { self.free() }) +func NewPeerNetwork(ec EventContext, config PeerNetworkConfig, err *Error) PeerNetwork { + res := PeerNetworkFromC(C.peernetwork_new(ec.inner, config.inner, err)) + if res != nil { + ec.attach(rawptr_t(res.inner), res) + runtime.SetFinalizer(res, func(self PeerNetwork) { self.free() }) + } return res } @@ -290,7 +342,9 @@ func (self PeerNetwork) HasPeer(paddr NetAddr) bool { return bool(C.peernetwork_ // returned connection handle could be kept in your program. func (self PeerNetwork) GetPeerConn(paddr NetAddr, err *Error) PeerNetworkConn { res := PeerNetworkConnFromC(C.peernetwork_get_peer_conn(self.inner, paddr.inner, err)) - runtime.SetFinalizer(res, func(self PeerNetworkConn) { self.free() }) + if res != nil { + runtime.SetFinalizer(res, func(self PeerNetworkConn) { self.free() }) + } return res } diff --git a/salticidae b/salticidae index ff904b2..da9410b 160000 --- a/salticidae +++ b/salticidae @@ -1 +1 @@ -Subproject commit ff904b23147e72db4f7f77f8269242d9a5a0859e +Subproject commit da9410b41cf56340fd4a3e5148df704c9c0e139c diff --git a/stream.go b/stream.go index c35933e..bbc7680 100644 --- a/stream.go +++ b/stream.go @@ -30,6 +30,14 @@ func NewByteArrayMovedFromDataStream(src DataStream) ByteArray { return res } +func NewByteArrayFromHex(hex string) ByteArray { + c_str := C.CString(hex) + res := &byteArray{ inner: C.bytearray_new_from_hex(c_str) } + C.free(rawptr_t(c_str)) + runtime.SetFinalizer(res, func(self ByteArray) { self.free() }) + return res +} + // The C pointer to a DataStream object. type CDataStream = *C.datastream_t type dataStream struct { @@ -47,11 +55,17 @@ func DataStreamFromC(ptr CDataStream) DataStream { } } +func dataStreamSetFinalizer(res DataStream) DataStream { + if res != nil { + runtime.SetFinalizer(res, func(self DataStream) { self.free() }) + } + return res +} + // Create an empty DataStream. func NewDataStream() DataStream { res := DataStreamFromC(C.datastream_new()) - runtime.SetFinalizer(res, func(self DataStream) { self.free() }) - return res + return dataStreamSetFinalizer(res) } // Create a DataStream with data copied from bytes. @@ -63,7 +77,20 @@ func NewDataStreamFromBytes(bytes []byte) (res DataStream) { } else { res = DataStreamFromC(C.datastream_new()) } - runtime.SetFinalizer(res, func(self DataStream) { self.free() }) + return dataStreamSetFinalizer(res) +} + +// Create a DataStream with content moved from a ByteArray. +func NewDataStreamMovedFromByteArray(bytes ByteArray) (res DataStream) { + res = DataStreamFromC(C.datastream_new_moved_from_bytearray(bytes.inner)) + dataStreamSetFinalizer(res) + return +} + +// Create a DataStream with content copied from a ByteArray. +func NewDataStreamFromByteArray(bytes ByteArray) (res DataStream) { + res = DataStreamFromC(C.datastream_new_from_bytearray(bytes.inner)) + dataStreamSetFinalizer(res) return } @@ -75,8 +102,7 @@ func (self DataStream) detach(ptr rawptr_t) { delete(self.attached, uintptr(ptr) // Make a copy of the object. func (self DataStream) Copy() DataStream { res := DataStreamFromC(C.datastream_copy(self.inner)) - runtime.SetFinalizer(res, func(self DataStream) { self.free() }) - return res + return dataStreamSetFinalizer(res) } // TODO: datastream_data @@ -166,7 +192,17 @@ type UInt256 = *uint256 // Create a 256-bit integer. func NewUInt256() UInt256 { res := &uint256{ inner: C.uint256_new() } - runtime.SetFinalizer(res, func(self UInt256) { self.free() }) + if res != nil { + runtime.SetFinalizer(res, func(self UInt256) { self.free() }) + } + return res +} + +func NewUInt256FromByteArray(bytes ByteArray) UInt256 { + res := &uint256{ inner: C.uint256_new_from_bytearray(bytes.inner) } + if res != nil { + runtime.SetFinalizer(res, func(self UInt256) { self.free() }) + } return res } @@ -191,6 +227,11 @@ func (self DataStream) GetHash() UInt256 { return res } +// Get the Sha256 hash of the given ByteArray content. +func (self ByteArray) GetHash() UInt256 { + return NewDataStreamFromByteArray(self).GetHash() +} + // Get hexadicemal string representation of the given DataStream content // (without consuming the stream). func (self DataStream) GetHex() string { diff --git a/test_msgnet/main.go b/test_msgnet/main.go index 66d7287..065b773 100644 --- a/test_msgnet/main.go +++ b/test_msgnet/main.go @@ -113,7 +113,7 @@ func connHandler(_conn *C.struct_msgnetwork_conn_t, connected C.bool, _ unsafe.P } else { fmt.Printf("[%s] Disconnected, retrying.\n", name) err := salticidae.NewError() - net.Connect(conn.GetAddr(), &err) + net.Connect(conn.GetAddr(), false, &err) } } @@ -127,20 +127,18 @@ func errorHandler(_err *C.struct_SalticidaeCError, fatal C.bool, _ unsafe.Pointe func genMyNet(ec salticidae.EventContext, name string, myAddr salticidae.NetAddr, otherAddr salticidae.NetAddr) MyNet { + err := salticidae.NewError() netconfig := salticidae.NewMsgNetworkConfig() - n := MyNet { - net: salticidae.NewMsgNetwork(ec, netconfig), - name: name, - } + net := salticidae.NewMsgNetwork(ec, netconfig, &err); checkError(&err) + n := MyNet { net: net, name: name } n.net.RegHandler(MSG_OPCODE_HELLO, salticidae.MsgNetworkMsgCallback(C.onReceiveHello), nil) n.net.RegHandler(MSG_OPCODE_ACK, salticidae.MsgNetworkMsgCallback(C.onReceiveAck), nil) n.net.RegConnHandler(salticidae.MsgNetworkConnCallback(C.connHandler), nil) n.net.RegErrorHandler(salticidae.MsgNetworkErrorCallback(C.errorHandler), nil) n.net.Start() - err := salticidae.NewError() n.net.Listen(myAddr, &err); checkError(&err) - n.net.Connect(otherAddr, &err); checkError(&err) + n.net.Connect(otherAddr, false, &err); checkError(&err) return n } diff --git a/test_msgnet_tls/alice.pem b/test_msgnet_tls/alice.pem new file mode 100644 index 0000000..6efe00f --- /dev/null +++ b/test_msgnet_tls/alice.pem @@ -0,0 +1,83 @@ +-----BEGIN PRIVATE KEY----- +MIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQDZFKh7iaGPvfvh +6qYrQN0Twq9nnpukjHYG+Zjuq/6T/JgMVezRXDA6e6nPH1va6tRzi+MsJ4Ues7al +m6ddnxNgUOI2ROl9G6Gmx68Y75BGR1vKMUw7ujz8flaXYFO5mASSbE87pI5F/Hm/ +7k0Ke47rEE6Ke1iARcv0pW9loFT8y00NBXg/IQSUSb1riDXOHVK3fY8xHN5w5/pX +waLNpqTByKOPcBCQhJBWh83n09vYysDEFzJC3QUvNWNCUttbgexqY8hJO4jP5SD+ +DmSiPw+6gNiyJdPdvmY+VgDXtd1d1ApihkiLlSa3EhQAMbS6ajM3NuwS5ikpnZ5c +NDvGuBS4XQx8R+X93Q1xyeclNVkd2bFj0rdjfIxyurl8Nziq2/NM/AVCtBXCdGDO +8aFnivPlA/FtfKbfuhhNVWts0ODLHR8dd5AZpGjtgZBJiXW97XQOeG0hDp8WwBNn +s0UFEewkMOMX1ByA7ZWeOSiJHe+lcmVEs7RaUcEhs5OK/sgAo3Ig+4mO0z6VH8gp +/WxP8ce+5xA6cTao2wJn3N1ux4Oq4fqZXR3rPh7IcEkHCyBKL1jxiUmPlIXvmED2 +PzyWSxyoDTm9w1TBLamD0Usdd1P99Rclgri3erhr6kT4YnWV0WMqrsP3ZserGTkm +3Gsi6s6X9sTdu3Yi/P4N2nvRPZOB0wIDAQABAoICADwSk21ccPEuSf4CyWk+0e8d ++RxbsAahOChF+iRSRGj/hbQkMxzcvhvxDNTcgLbcNV6kX4Fgjl4orWq24GHwG5ST +zYXnHBYbB2j36WSlJu/L34LckZQVvbrB24SYi5LYlqtOfb6rkxObArYyY+96sdoq +8RExgRQ+PGq/PUyKSfqK6A+qa9RMds/yeBDB6OHZC4LrpCybKJNmHskaNMtkSkO2 +Gk0fXfYgOTE486or3rLnqOCa6rXGJCEkTQuVkk6IbbwjUNGzP/EIH1Eu+npLqTab +YVwrS64ZeoHVmvYWxeOpQhZxwrGd3NDcl9xV5QWRTgsBj+LK/qkdjS1G5yPe3RyF +WLs9MxjfHrJMn7TdJzLumcBY4wtTA9+wzafBFfN3UJWfAN0OesO+KaAqixcbVYr8 +BDE6+rryKKxwghgOvxdlDWHLlYYQPUktn0Gn4gxQpQD+viXGhNNr95gn8QkO1RV8 +A3T//PXTGA2+hVG8pi9sL/vXm/Q/5439KjsiD2OadU0rFubzioC+OYkB1tgdo5hL +CWpfPcD0xBBbyv8X6iqIAqETVY6R9uvwWowEBuJ+F4O16l/USpq8sTH8zPJltd9I +CVV3KKUvxtyA62oE6GkVbJWlSd02mBsMVJ+EWO5OOkfDCGNdXOhAWmycoZ8W6j1l +p3m6rgI+O09GoeU0GspBAoIBAQDzfJ1eRNZVkcGN3mHwpJ+qgC/iKaWbDKsUwv4s +jLKmx2TvZFE0ZaOusb1H7W92GF0yXcIbIe4ThHDrTruQW0QnOK6XzgdYUwEKkq39 +74uhwm6D/98/+Gzv0fpSZ1pQg/UL1ORYG/UmkwVvQEn78wRf9YZhZ4XSU4+u76CT +EcrGH++0M2LXpcS5Fe0YrSnLoSujflW5ZD54TcZekhQboe/VtdvhLnnYrp61M5nE +7e+h9tmyeX07Vl+1iWQqZuSUU1If2b7AEDXhq1Rbvl2MShV7ScvgcITXqJT1F2g7 +2o3NkMvtyVKFuIJ0bW/l74TodDmBZmkDyU90wlxahrOV7kBFAoIBAQDkPKMXgBhA +zGjRvm/5cJ/BBk5wj/DWVLeo77WBY0t4wZMiyIXHK/eTBJOUikbP6G18N6y/aqls +QeXFQ036vwgzYGhseMKaokTX/Jn56YLF3A+yfa4mIX90oZSuxFuY5K3Uo8/WFpjg +OObW9pWa7h4LyEagj0nFnQdHtuIA9mJxlAhk+nLAhFByhWrrTGPbAOM73e2hPDkd +aXayawuVR3DwTaVY1cg98y9jIwdvtkVAkO5unEVovCq3EptBrkt60djzAzUYwAWz +fNOKqvjT2tjPUaeGgm57AvFusIBT4cwtQb38tsyMItdgcEnkGeKL/UIdq7R9S/r+ +85Hagaccv5c3AoIBAQCjcQrRtLOLTQP4D0b/GgJzmQiLcBlSMvbEQQANN4TUnxQJ +/fTkjzWIlpbQKXmgdEpa/MTHIceGImkKCxeslxbwnQPVst8LUuxoBH32701zj+hP +gvqBHmlBslmt5uKhGXLsNkPxQRMWiaokO6tuDHrrTwydZbhWrvDMJN5M2qyaweVN +uRCoYQXkl+tHnTVpEw8P+EXi5H9qkgqOgNAunE05z5GBXok8AjtWtwSJRI6O0fzf +6N0/b4NfgJJURC07w5Jk/u0kT71bdn5x9x8khLZWw/qu9di2SttyifvV8acuTfwV +6gYS7P/k13E9j8JPp3TSf8QOXpuPbMhBnBoAkqVhAoIBADbzjoTi93PqgzY0trsE +7cHIpeweC+tevFV1WWsMoCgz2xwd0W/R2yrPiETUQhZerLWipfn0UVRaTVsASG8d +vXi5NosfTCN0/ERQcjYkjbLbt//OmLZfjFNlb+ngJvmZ3Wx8AFdYW3ho2tNYzU5f +FGbb0n1n4mgs1Yrjsmhu6ebUsGy3jBdkBAZ+ru52FvisrwlD9qnCWTIGqWhts30+ +lSeWWkAYQL0BpyAkV+8CoIvaGT4Sa/e6jkJDvZPDxjKNAcIIvKj32qeLX1dcsMo5 +P8gyrbYKA1WksMJoxozrqYAf+wE0de0rmlWC05eSz+PKlzeTlsIwH/9wX2aPns+i +JWMCggEAMnngikXoidKfFMd18ruosj8hUr0cY6ZfQndhJZ2uu9kGvwM4b4kWRuxq +UzLzg81hsUj43b+BkVR3V/bnpxyc7uSklvIghcQGMHqskAHcEmBLp0x4qIs8s7f6 +mKIcmeFidMqdTynujPBa4i08ewBxNQYmopllhI7/mAS1/epHXrv9vCfBDUj3fZ4D ++FePXLzYoUOiwukrxFscAdjXeHunuIlesSSUMPyx0WJ4R3LCNATAibcUYY+20pGn +hV+fwE1S22JqalW2NEkFyGl4dck0w50vekzt3vZBLjWvsBz1DS2xPbGJyEYAzxL8 +THSAjGzVtLewAwo0qkl141+539oWDw== +-----END PRIVATE KEY----- +-----BEGIN CERTIFICATE----- +MIIFazCCA1OgAwIBAgIUFitZjQ11n2jQiX7GPH5RtQorw1gwDQYJKoZIhvcNAQEL +BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0xOTA2MjEwMjU5MThaFw0xOTA3 +MjEwMjU5MThaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw +HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQDZFKh7iaGPvfvh6qYrQN0Twq9nnpukjHYG+Zjuq/6T +/JgMVezRXDA6e6nPH1va6tRzi+MsJ4Ues7alm6ddnxNgUOI2ROl9G6Gmx68Y75BG +R1vKMUw7ujz8flaXYFO5mASSbE87pI5F/Hm/7k0Ke47rEE6Ke1iARcv0pW9loFT8 +y00NBXg/IQSUSb1riDXOHVK3fY8xHN5w5/pXwaLNpqTByKOPcBCQhJBWh83n09vY +ysDEFzJC3QUvNWNCUttbgexqY8hJO4jP5SD+DmSiPw+6gNiyJdPdvmY+VgDXtd1d +1ApihkiLlSa3EhQAMbS6ajM3NuwS5ikpnZ5cNDvGuBS4XQx8R+X93Q1xyeclNVkd +2bFj0rdjfIxyurl8Nziq2/NM/AVCtBXCdGDO8aFnivPlA/FtfKbfuhhNVWts0ODL +HR8dd5AZpGjtgZBJiXW97XQOeG0hDp8WwBNns0UFEewkMOMX1ByA7ZWeOSiJHe+l +cmVEs7RaUcEhs5OK/sgAo3Ig+4mO0z6VH8gp/WxP8ce+5xA6cTao2wJn3N1ux4Oq +4fqZXR3rPh7IcEkHCyBKL1jxiUmPlIXvmED2PzyWSxyoDTm9w1TBLamD0Usdd1P9 +9Rclgri3erhr6kT4YnWV0WMqrsP3ZserGTkm3Gsi6s6X9sTdu3Yi/P4N2nvRPZOB +0wIDAQABo1MwUTAdBgNVHQ4EFgQU/dKIin9ueRiA5tqyKmD9w0g4TVAwHwYDVR0j +BBgwFoAU/dKIin9ueRiA5tqyKmD9w0g4TVAwDwYDVR0TAQH/BAUwAwEB/zANBgkq +hkiG9w0BAQsFAAOCAgEANGM+fUoMyYkbdSRhocIJ/WZo3fb96289SsDmVrwQyazn +4O0MPlgz2y6RXQf0rDr0xQ9jj0hv6UEpVcaUdVrgRYJzW7YviN6x/urqsJNtVUJb +t6xF+IS+ibT4OulJlQyJlYX0opQQzVQGgKW8jwetPdBNVtoH5j7AZaCYhlOnOz6r +JpA07sI3fSuVb0NjDuHPgzR139r1IlpBLP/OmkG4LH19tP9Ad78Dehl7K/TA2Rwr +i3wZk77Wvbz7u5ZMqHxxdS4opUWYnpyApeudFNiXRS1ls7R7lJZE3+9OKT9EcVd+ +GwJzWJVvtqXotOqfjYVWj4EFebH9MAdb34l7F1OgyKQ3Nmw7BzuQ7XdoKn5/DL5Q +b9PeRSnWpzgaSEj341GlZL1fs2IY+KYxHB3XeptDgAIPRP7+Q39/FRKGyuxTX2l/ +7a1jIN7xRF15mqpEzbICch+RXv9hMMHqMr7H8psQXKbQTFZkZatwPneho1T6E58o +JLjQME1bOMR++forya9rZZCl11io3OitFbzewBmMdPCcA5fJS13MW7jJ6x41L/lw +d6qBH3eG2paTc+aVRIaJhhwR/ommpILiU8X/kXq6StLGB1YD5Jm0KvREyME/o0U7 +sT/91lpmMtRtwqaIOTZbUn1vEmS3aHZKS5q+Vs/eYZm3exF/L+Bzy40vn9wxU0I= +-----END CERTIFICATE----- diff --git a/test_msgnet_tls/bob.pem b/test_msgnet_tls/bob.pem new file mode 100644 index 0000000..8f8afcc --- /dev/null +++ b/test_msgnet_tls/bob.pem @@ -0,0 +1,83 @@ +-----BEGIN PRIVATE KEY----- +MIIJQwIBADANBgkqhkiG9w0BAQEFAASCCS0wggkpAgEAAoICAQDfnQZzGUUL/pQN +4g3U7fI6DHsvy6AztawB89m5nbXOFA9YGiFpzTGByZ6xAJRRnoz5HtbwjbkAYiUc +G+sbGF7RSDAchAOC0EYKK8YQd/kGYzD/mIFzyzRSk1Kpc/SSIDKmuO9iFWfNSOqI +zfkE8M0hV2vwbZ/tZfi/ToP8nH7Zllpa6E2SQhQRDsojMPSyMkP2uYvBL9CjRbZz +gsVPaHItfQkP5c3+oNTgTNbv6HwI98h2xXYIAL8MKg7B/xj8BXczf9KGhWNCcRn/ +ci+wME08e9+FZUH1JYIQgRAu1Q7eGp5JhGl4Tls9/YTH7FFVTbpZZaoRj95mMKVT +zrXOlSdiQcAuAnfKvSm733tK9VL/JFFWfrscWaWONKUEogW988hQ7xg+0VQ5BBd3 +/S6yT/0fUjVLwM2hoJguQFtNkuBdeT7Bp+cVO0uI+g1sPFV3+0XC0Z5MytwedS+0 +BSq3KBheQ/FBTDZ8wHk9H1fPbNX4va1dj4bw2D5vuQL1gYTSIV5yUARakt78qH9s +9+gkUfJGjtiI8FBbF5p4AhbBpKD0dhy7Pbkzw3zaWGCxOATUXTxiB9qgLwjancax +x1XegMB8ZhjoNjUzX1iBh11Sejmqv0Sv1PLdAgzxlIVfaIkf/wyQwX/GGbqN7ne/ +J+lk2DIe3ynxn6FmIdvtfrFbbCGpxQIDAQABAoICAQCvAlp14qUjig+d/foNWF1o +CTSwZ5HuZpVEwfD5UPFlZFXOAkV8ZNgGWCIXLfjnGEwE/ZoDkyfjoOyiX0dWYXB0 +Iydkaf3Fd/QZKcFOSldgJGnI4TcPxU4iAqODc/lKFGEQE1VnUpF3HUZR48Ktlzk0 +ixMzjNjKGDDiqTSrlF/DM+VrmLx9Z7IE16pkeIBKpwSCKR20CRQldP4i0YpTZ89U +wrNA+f6K9p0lH35pLW9GJYeDTW/fO5ZKkvAR7PFE7ZIpgDToi6Tv700Fm/yuzF7m +o5yA7or8rmppOFnODXohYnvX1gYl3k2S6sPtJItTVA4wwVyleg/5ssDyIqowEJRM +39nSRsf89kXK9nPD+WRbmPOM4uGtqOWtb+UK0Ymzf+Sism7pi71HfPULE1d5lMiJ +T2pXSwxUGK9pDgqyKqyBn7G5qmwqG1aZuSUs/jRq44DFKFfaeWg8jZAWEisZhJjS +pX98Boa0FBQNudeHHkYo3d9+pi+Armc2W2v3Emzg92RnNJ9O1hSjc/erqZw1C7oL +toXyf785E8k60Nx+99GslRNU4ZWtjiNS71pLTnkpCjJTFCQ3bigV9lt9P5KNgSOo +Kbsae5+H7Ogl8hWKbQ4ESl7RDR4d8mGOFfDmeH6pWhDl0cr/CErzeL3VyWIQ/FZg +B2KBObf5yGzHZFxDSEMLAQKCAQEA8UaHYEbYruS//WUwp01raVV1IUtORhd+/38r +ql9VoavDzjnVzqKNOfXflhF5zuviHp6+i0KQSGaI8vMJ+FrlLU5i1pyrJMf42IOw +/L8R4MlC4iZ95Z9XJEMts09h63kHIEX6oluwmVL7AvVW7mfmdSbK1HSm2LJnidRM +bhtBw/r79kfSpdRwC88E6jiK3Nw6vl0CNoD+sambsbxsgJMtHr8gwaJcln6tzVZJ +zdYACubxQAEM5fPCisWajwE4iAFB0Zku2655OLtQl2JNlxejmZwT6ae+Lcqrniyi +zJiYkQb0Q7vDAsamRMXJh7hXGK8XhONXtenuWz3UYeMGr37NdQKCAQEA7UKPLDY8 +wA5lVRskPbq6A9tzDRF94zmelQXuanso93QpMU+qswDK8UId4YqZfRV7IWcLHbAg +HOcmn2vREARSC1u18LSASmCPg214tgcSJ5q9+naTiStXEZ1PEVjKAiz9WVymUlF9 +vWs0kNRC686aLc/WwpZRRo9Xm8FsnM5EGbknxECi4/ro4hvV1G3xsvq87utmb3R6 +6Ijf22gMfWPcq1CyZa08Di8Pj9Nt8HB5TvFp9ekhKJ+GUuwSCLea6b+FlBA5K5m8 +OZRfbDhJVM5zjOXIMysfYrmyRSuJMc37W5qQcIFjPY2wlVheKWz+gOM2zHAfoa4b +cJRRC9uwVGRREQKCAQA0FRh2BPUTU9fJ2EUXaFPuaf8dz8a2xK2qc4Y2gdvXSV+8 +LanksBwyTcwU9fLIYwzttTDGmPjSWCfp4eLeFKjyDcCyOSGMkAo8mrji5k/yqR9h ++BMnNS03a7T6xwEJNpf+NHz0/Tvy7QG4UsOQNSd/VH9mO0Qk9OX6z7Qr9IBO0OgA +8uIa3+/L7MVP1iLLqFKZ8zPeFhxkt4sfY+A8JQkRYQquIeFAr1nPQHgwEajysYWU +XmWtYeA12pARnJ7aZQMTPrDpxRDv2Sd9dj/vhK/RIer+fjJEakJ/o30FE0+jxs+F +q4teFwmfQN7PCFDsyCcYjYbKgxPr6D3nX3169rFdAoIBAQCzYwK7S9rM31WQbnAN +WDQynGa1t8b12WfkhtKHoc0Mo8BNb03B/9RxaysKj2+Tmn05eR53eOYe1EpoeO1d +7dZWjiXW87KYCcAYf9mnz1rTpPUE/Uh5itJPGCBjHj3GPVvkh9+dF845PGhHJKXg +gpoiDyXyhBK5hcGYmztSp8XnqQ2/HZvLQbd41dDrx6DaUSgugL83f9s6G9sdmeLv +n2SGBwKLS9q/YqeieBqEk5W0sWULMBQJEexOn/zWqHOxTkRh+Y4wQBGHe35WZYxU +WbAWFNo0jeMyEvMNx2f4xyPIU+nnlnyBWrLriB/RtH4M1z5kflX8OZa3nPxWOelt +NVfxAoIBAAdMdcqLzpekcZbaQ9IQ3ItqmQ0jFNa5dEC9eDSMFHlghutJKNlAwkC8 +gTZlnobSXlKAKmVWmP5Zgo3WMQCXJaTIfNg7TF9ykobGzXSH43fwWZKw8cD1ZqvR ++Frf1HIxkbotG93kef1uUeUAvBj7lZM78rSWObCQ+p6ovX2j+d15mj1/pDupQ9nE +GoGdktzAhy95VEuTpX+OllaAtbOwZco5X/9htHJCEWgMhFUDNptjZhGYaNiH7Pa3 +xqvy3ipHOi3AcD9mNWkroFaInCjnQN415VE18zgYnsVGRpMGSEB7Oj09QTtU+kzO +HHHAbLi3XqeKbfEWQL0METvL2SBhlAA= +-----END PRIVATE KEY----- +-----BEGIN CERTIFICATE----- +MIIFazCCA1OgAwIBAgIUTfDNmCzLkU+iC/fDlcG2P7Z2iXMwDQYJKoZIhvcNAQEL +BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM +GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0xOTA2MjEwMzI4MjVaFw0xOTA3 +MjEwMzI4MjVaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw +HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQDfnQZzGUUL/pQN4g3U7fI6DHsvy6AztawB89m5nbXO +FA9YGiFpzTGByZ6xAJRRnoz5HtbwjbkAYiUcG+sbGF7RSDAchAOC0EYKK8YQd/kG +YzD/mIFzyzRSk1Kpc/SSIDKmuO9iFWfNSOqIzfkE8M0hV2vwbZ/tZfi/ToP8nH7Z +llpa6E2SQhQRDsojMPSyMkP2uYvBL9CjRbZzgsVPaHItfQkP5c3+oNTgTNbv6HwI +98h2xXYIAL8MKg7B/xj8BXczf9KGhWNCcRn/ci+wME08e9+FZUH1JYIQgRAu1Q7e +Gp5JhGl4Tls9/YTH7FFVTbpZZaoRj95mMKVTzrXOlSdiQcAuAnfKvSm733tK9VL/ +JFFWfrscWaWONKUEogW988hQ7xg+0VQ5BBd3/S6yT/0fUjVLwM2hoJguQFtNkuBd +eT7Bp+cVO0uI+g1sPFV3+0XC0Z5MytwedS+0BSq3KBheQ/FBTDZ8wHk9H1fPbNX4 +va1dj4bw2D5vuQL1gYTSIV5yUARakt78qH9s9+gkUfJGjtiI8FBbF5p4AhbBpKD0 +dhy7Pbkzw3zaWGCxOATUXTxiB9qgLwjancaxx1XegMB8ZhjoNjUzX1iBh11Sejmq +v0Sv1PLdAgzxlIVfaIkf/wyQwX/GGbqN7ne/J+lk2DIe3ynxn6FmIdvtfrFbbCGp +xQIDAQABo1MwUTAdBgNVHQ4EFgQUX/c1vXnm9tkgHTZndvy5PzgoupIwHwYDVR0j +BBgwFoAUX/c1vXnm9tkgHTZndvy5PzgoupIwDwYDVR0TAQH/BAUwAwEB/zANBgkq +hkiG9w0BAQsFAAOCAgEAhUik2ITFpR8s571Ds1jNr/kvM3j1dwG1qCIN7GuE4XuV +0vS6W2FCeBfB/WPvf9HCQFNR9l9npPI27BJA1J853ywlzj6WyfiA9Fv517aOMCs+ +PaySYcM23Hyyi3sSAdNYWlnQg0JUI1kdIMb3dileleDz2Eh6IxIugpvZ3s+7bOiN +H2FkOrzMq/w8aJ+kUk8IyGToxtBVvmjbINRK0bgANHJOifzp5ASYqvEZAcggot1n +pvVToqGDxtuuVd4qX8/DXPCVooOJ0RAcGZ44+hXfN1T5icPmnqMLuoPx9qiUZO+T +PIHg2DknmZSEunyy4LO5SiEsQVBzL3v8voYIqoobBuB5A2wyG9BXT5c3OM2rxDkX +UfXjxMdiGu3+iOaGE0KePXVY6oy3vgbmaowh5n8ZN6sN8aJPty3ZdpYpRPXKJsft +DtTH5sITHiisU2+rV2kJMKyASrxPWJAxkelahbUacOzid83TG+uqBCUJY0YPLRsF +TCvZ/jqJ8PNXFiZWnfyVkH3qFNjzQ595xMLe5fE5p/pCEV7aqHI0Ds9VYy82IJAT +070s/gtoLj5DussTetb9rh7Nt9ndJ5T7vvL9aeSmulRs2Z1j6u7rTvo4TjAbLbxx +bCR8r/T+5G0F9qLC6o4C2kFfZSiogxtM8n6tCJzzpWnpMwVad0a+GuH4tdNFsQA= +-----END CERTIFICATE----- diff --git a/test_msgnet_tls/main.go b/test_msgnet_tls/main.go new file mode 100644 index 0000000..c45cfdf --- /dev/null +++ b/test_msgnet_tls/main.go @@ -0,0 +1,171 @@ +package main + +// #cgo CFLAGS: -I${SRCDIR}/../salticidae/include/ +// #include +// #include "salticidae/network.h" +// void onTerm(int sig, void *); +// void onReceiveHello(msg_t *, msgnetwork_conn_t *, void *); +// void onReceiveAck(msg_t *, msgnetwork_conn_t *, void *); +// bool connHandler(msgnetwork_conn_t *, bool, void *); +// void errorHandler(SalticidaeCError *, bool, void *); +import "C" + +import ( + "encoding/binary" + "os" + "fmt" + "unsafe" + "github.com/Determinant/salticidae-go" +) + +const ( + MSG_OPCODE_HELLO salticidae.Opcode = iota + MSG_OPCODE_ACK +) + +func msgHelloSerialize(name string, text string) salticidae.Msg { + serialized := salticidae.NewDataStream() + t := make([]byte, 4) + binary.LittleEndian.PutUint32(t, uint32(len(name))) + serialized.PutData(t) + serialized.PutData([]byte(name)) + serialized.PutData([]byte(text)) + return salticidae.NewMsgMovedFromByteArray( + MSG_OPCODE_HELLO, salticidae.NewByteArrayMovedFromDataStream(serialized)) +} + +func msgHelloUnserialize(msg salticidae.Msg) (name string, text string) { + p := msg.GetPayloadByMove() + t := p.GetDataInPlace(4); length := binary.LittleEndian.Uint32(t.Get()); t.Release() + t = p.GetDataInPlace(int(length)); name = string(t.Get()); t.Release() + t = p.GetDataInPlace(p.Size()); text = string(t.Get()); t.Release() + return +} + +func msgAckSerialize() salticidae.Msg { + return salticidae.NewMsgMovedFromByteArray(MSG_OPCODE_ACK, salticidae.NewByteArray()) +} + +func checkError(err *salticidae.Error) { + if err.GetCode() != 0 { + fmt.Printf("error during a sync call: %s\n", salticidae.StrError(err.GetCode())) + os.Exit(1) + } +} + +type MyNet struct { + net salticidae.MsgNetwork + name string + peerCert salticidae.UInt256 + cname *C.char +} + +var ( + alice, bob MyNet + ec salticidae.EventContext +) + +//export onTerm +func onTerm(_ C.int, _ unsafe.Pointer) { + ec.Stop() +} + +//export onReceiveHello +func onReceiveHello(_msg *C.struct_msg_t, _conn *C.struct_msgnetwork_conn_t, userdata unsafe.Pointer) { + msg := salticidae.MsgFromC(salticidae.CMsg(_msg)) + conn := salticidae.MsgNetworkConnFromC(salticidae.CMsgNetworkConn(_conn)) + net := conn.GetNet() + name, text := msgHelloUnserialize(msg) + myName := C.GoString((*C.char)(userdata)) + fmt.Printf("[%s] %s says %s\n", myName, name, text) + ack := msgAckSerialize() + net.SendMsg(ack, conn) +} + +//export onReceiveAck +func onReceiveAck(_ *C.struct_msg_t, _conn *C.struct_msgnetwork_conn_t, userdata unsafe.Pointer) { + myName := C.GoString((*C.char)(userdata)) + fmt.Printf("[%s] the peer knows\n", myName) +} + +//export connHandler +func connHandler(_conn *C.struct_msgnetwork_conn_t, connected C.bool, userdata unsafe.Pointer) C.bool { + conn := salticidae.MsgNetworkConnFromC(salticidae.CMsgNetworkConn(_conn)) + net := conn.GetNet() + myName := C.GoString((*C.char)(userdata)) + n := alice + if myName == "bob" { n = bob } + res := true + if connected { + certHash := conn.GetPeerCert().GetDer().GetHash() + res = certHash.IsEq(n.peerCert) + if conn.GetMode() == salticidae.CONN_MODE_ACTIVE { + fmt.Printf("[%s] Connected, sending hello.\n", myName) + hello := msgHelloSerialize(myName, "Hello there!") + n.net.SendMsg(hello, conn) + } else { + status := "fail" + if res { status = "ok" } + fmt.Printf("[%s] Accepted, waiting for greetings.\n" + + "The peer certificate footprint is %s (%s)\n", + myName, certHash.GetHex(), status) + } + } else { + fmt.Printf("[%s] Disconnected, retrying.\n", myName) + err := salticidae.NewError() + net.Connect(conn.GetAddr(), false, &err) + } + return C.bool(res) +} + +//export errorHandler +func errorHandler(_err *C.struct_SalticidaeCError, fatal C.bool, _ unsafe.Pointer) { + err := (*salticidae.Error)(unsafe.Pointer(_err)) + s := "recoverable" + if fatal { s = "fatal" } + fmt.Printf("Captured %s error during an async call: %s\n", s, salticidae.StrError(err.GetCode())) +} + +func genMyNet(ec salticidae.EventContext, + name string, peerCert string, + myAddr salticidae.NetAddr, otherAddr salticidae.NetAddr) MyNet { + err := salticidae.NewError() + netconfig := salticidae.NewMsgNetworkConfig() + netconfig.EnableTLS(true) + netconfig.TLSKeyFile(name + ".pem") + netconfig.TLSCertFile(name + ".pem") + net := salticidae.NewMsgNetwork(ec, netconfig, &err); checkError(&err) + _peerCert := salticidae.NewUInt256FromByteArray(salticidae.NewByteArrayFromHex(peerCert)) + cname := C.CString(name) + n := MyNet { net: net, name: name, peerCert: _peerCert, cname: cname } + n.net.RegHandler(MSG_OPCODE_HELLO, salticidae.MsgNetworkMsgCallback(C.onReceiveHello), unsafe.Pointer(cname)) + n.net.RegHandler(MSG_OPCODE_ACK, salticidae.MsgNetworkMsgCallback(C.onReceiveAck), unsafe.Pointer(cname)) + n.net.RegConnHandler(salticidae.MsgNetworkConnCallback(C.connHandler), unsafe.Pointer(cname)) + n.net.RegErrorHandler(salticidae.MsgNetworkErrorCallback(C.errorHandler), unsafe.Pointer(cname)) + + n.net.Start() + n.net.Listen(myAddr, &err); checkError(&err) + n.net.Connect(otherAddr, false, &err); checkError(&err) + return n +} + +func main() { + ec = salticidae.NewEventContext() + + aliceAddr := salticidae.NewAddrFromIPPortString("127.0.0.1:12345") + bobAddr := salticidae.NewAddrFromIPPortString("127.0.0.1:12346") + + alice = genMyNet(ec, "alice", "ed5a9a8c7429dcb235a88244bc69d43d16b35008ce49736b27aaa3042a674043", aliceAddr, bobAddr) + bob = genMyNet(ec, "bob", "ef3bea4e72f4d0e85da7643545312e2ff6dded5e176560bdffb1e53b1cef4896", bobAddr, aliceAddr) + + ev_int := salticidae.NewSigEvent(ec, salticidae.SigEventCallback(C.onTerm), nil) + ev_int.Add(salticidae.SIGINT) + ev_term := salticidae.NewSigEvent(ec, salticidae.SigEventCallback(C.onTerm), nil) + ev_term.Add(salticidae.SIGTERM) + + ec.Dispatch() + alice.net.Stop() + bob.net.Stop() + C.free(unsafe.Pointer(alice.cname)) + C.free(unsafe.Pointer(bob.cname)) +} diff --git a/test_p2p_stress/main.go b/test_p2p_stress/main.go index 9e0757f..69f9d6c 100644 --- a/test_p2p_stress/main.go +++ b/test_p2p_stress/main.go @@ -240,6 +240,7 @@ func onTerm(_ C.int, _ unsafe.Pointer) { func main() { ec = salticidae.NewEventContext() + err := salticidae.NewError() var addrs []salticidae.NetAddr for i := 0; i < 5; i++ { @@ -256,22 +257,23 @@ func main() { ids = make([](*C.int), len(addrs)) for i, addr := range addrs { ec := salticidae.NewEventContext() + net := salticidae.NewPeerNetwork(ec, netconfig, &err); checkError(&err) apps[i] = AppContext { addr: addr, ec: ec, - net: salticidae.NewPeerNetwork(ec, netconfig), + net: net, tcall: salticidae.NewThreadCall(ec), tc: make(map[uint64] *TestContext), } ids[i] = (*C.int)(C.malloc(C.sizeof_int)) *ids[i] = C.int(i) _i := unsafe.Pointer(ids[i]) - net := apps[i].net.AsMsgNetwork() - net.RegHandler(MSG_OPCODE_RAND, salticidae.MsgNetworkMsgCallback(C.onReceiveRand), _i) - net.RegHandler(MSG_OPCODE_ACK, salticidae.MsgNetworkMsgCallback(C.onReceiveAck), _i) - net.RegConnHandler(salticidae.MsgNetworkConnCallback(C.connHandler), _i) - net.RegErrorHandler(salticidae.MsgNetworkErrorCallback(C.errorHandler), _i) - net.Start() + mnet := net.AsMsgNetwork() + mnet.RegHandler(MSG_OPCODE_RAND, salticidae.MsgNetworkMsgCallback(C.onReceiveRand), _i) + mnet.RegHandler(MSG_OPCODE_ACK, salticidae.MsgNetworkMsgCallback(C.onReceiveAck), _i) + mnet.RegConnHandler(salticidae.MsgNetworkConnCallback(C.connHandler), _i) + mnet.RegErrorHandler(salticidae.MsgNetworkErrorCallback(C.errorHandler), _i) + mnet.Start() } threads.Add(len(apps)) @@ -280,7 +282,7 @@ func main() { go func() { err := salticidae.NewError() a := &apps[app_id] - a.net.Listen(a.addr, &err) + a.net.Listen(a.addr, &err); checkError(&err) for _, addr := range addrs { if !addr.IsEq(a.addr) { a.net.AddPeer(addr) -- cgit v1.2.3