2019-04-18 16:38:24 +01:00
|
|
|
package yggdrasil
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
2019-04-21 12:28:46 +01:00
|
|
|
"fmt"
|
2019-04-18 16:38:24 +01:00
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/yggdrasil-network/yggdrasil-go/src/crypto"
|
2019-04-18 23:38:23 +01:00
|
|
|
"github.com/yggdrasil-network/yggdrasil-go/src/util"
|
2019-08-23 23:36:00 -05:00
|
|
|
|
|
|
|
"github.com/Arceliar/phony"
|
2019-04-18 16:38:24 +01:00
|
|
|
)
|
|
|
|
|
2019-05-29 20:16:17 +01:00
|
|
|
// ConnError implements the net.Error interface
|
2019-04-26 19:31:47 -05:00
|
|
|
type ConnError struct {
|
|
|
|
error
|
|
|
|
timeout bool
|
|
|
|
temporary bool
|
2019-07-17 11:13:53 +01:00
|
|
|
closed bool
|
2019-05-29 20:16:17 +01:00
|
|
|
maxsize int
|
2019-04-26 19:31:47 -05:00
|
|
|
}
|
|
|
|
|
2019-05-29 20:16:17 +01:00
|
|
|
// Timeout returns true if the error relates to a timeout condition on the
|
|
|
|
// connection.
|
2019-04-26 19:31:47 -05:00
|
|
|
func (e *ConnError) Timeout() bool {
|
|
|
|
return e.timeout
|
|
|
|
}
|
|
|
|
|
2019-05-29 20:16:17 +01:00
|
|
|
// Temporary return true if the error is temporary or false if it is a permanent
|
|
|
|
// error condition.
|
2019-04-26 19:31:47 -05:00
|
|
|
func (e *ConnError) Temporary() bool {
|
|
|
|
return e.temporary
|
|
|
|
}
|
|
|
|
|
2019-05-29 20:16:17 +01:00
|
|
|
// PacketTooBig returns in response to sending a packet that is too large, and
|
|
|
|
// if so, the maximum supported packet size that should be used for the
|
|
|
|
// connection.
|
2019-07-27 15:00:09 +01:00
|
|
|
func (e *ConnError) PacketTooBig() bool {
|
|
|
|
return e.maxsize > 0
|
|
|
|
}
|
|
|
|
|
|
|
|
// PacketMaximumSize returns the maximum supported packet size. This will only
|
|
|
|
// return a non-zero value if ConnError.PacketTooBig() returns true.
|
|
|
|
func (e *ConnError) PacketMaximumSize() int {
|
|
|
|
if !e.PacketTooBig() {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
return e.maxsize
|
2019-05-29 20:16:17 +01:00
|
|
|
}
|
|
|
|
|
2019-07-17 11:13:53 +01:00
|
|
|
// Closed returns if the session is already closed and is now unusable.
|
|
|
|
func (e *ConnError) Closed() bool {
|
|
|
|
return e.closed
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// The Conn struct is a reference to an active connection session between the
|
|
|
|
// local node and a remote node. Conn implements the io.ReadWriteCloser
|
|
|
|
// interface and is used to send and receive traffic with a remote node.
|
2019-04-18 23:38:23 +01:00
|
|
|
type Conn struct {
|
2019-08-25 10:36:09 -05:00
|
|
|
phony.Inbox
|
2019-04-18 23:38:23 +01:00
|
|
|
core *Core
|
2019-08-23 23:36:00 -05:00
|
|
|
readDeadline *time.Time
|
|
|
|
writeDeadline *time.Time
|
2019-04-18 23:38:23 +01:00
|
|
|
nodeID *crypto.NodeID
|
|
|
|
nodeMask *crypto.NodeID
|
2019-04-21 20:38:14 -05:00
|
|
|
session *sessionInfo
|
2019-08-24 00:17:37 -05:00
|
|
|
mtu uint16
|
2019-08-24 01:52:21 -05:00
|
|
|
readCallback func([]byte)
|
|
|
|
readBuffer chan []byte
|
2019-04-26 18:07:57 -05:00
|
|
|
}
|
|
|
|
|
2019-04-26 19:31:47 -05:00
|
|
|
// TODO func NewConn() that initializes additional fields as needed
|
2019-04-26 18:07:57 -05:00
|
|
|
func newConn(core *Core, nodeID *crypto.NodeID, nodeMask *crypto.NodeID, session *sessionInfo) *Conn {
|
|
|
|
conn := Conn{
|
2019-08-24 01:52:21 -05:00
|
|
|
core: core,
|
|
|
|
nodeID: nodeID,
|
|
|
|
nodeMask: nodeMask,
|
|
|
|
session: session,
|
|
|
|
readBuffer: make(chan []byte, 1024),
|
2019-04-26 18:07:57 -05:00
|
|
|
}
|
|
|
|
return &conn
|
2019-04-18 23:38:23 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// String returns a string that uniquely identifies a connection. Currently this
|
|
|
|
// takes a form similar to "conn=0x0000000", which contains a memory reference
|
|
|
|
// to the Conn object. While this value should always be unique for each Conn
|
|
|
|
// object, the format of this is not strictly defined and may change in the
|
|
|
|
// future.
|
2019-04-21 12:28:46 +01:00
|
|
|
func (c *Conn) String() string {
|
2019-08-23 23:36:00 -05:00
|
|
|
var s string
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() { s = fmt.Sprintf("conn=%p", c) })
|
2019-08-23 23:36:00 -05:00
|
|
|
return s
|
2019-04-21 12:28:46 +01:00
|
|
|
}
|
|
|
|
|
2019-08-25 10:36:09 -05:00
|
|
|
func (c *Conn) setMTU(from phony.Actor, mtu uint16) {
|
2019-08-27 19:43:54 -05:00
|
|
|
c.Act(from, func() { c.mtu = mtu })
|
2019-08-24 00:17:37 -05:00
|
|
|
}
|
|
|
|
|
2019-10-03 18:44:47 -05:00
|
|
|
// This should never be called from an actor, used in the dial functions
|
2019-06-28 18:42:31 -05:00
|
|
|
func (c *Conn) search() error {
|
2019-09-03 19:03:12 -05:00
|
|
|
var err error
|
|
|
|
done := make(chan struct{})
|
2019-08-28 12:26:44 +01:00
|
|
|
phony.Block(&c.core.router, func() {
|
2019-09-03 19:03:12 -05:00
|
|
|
_, isIn := c.core.router.searches.searches[*c.nodeID]
|
|
|
|
if !isIn {
|
|
|
|
searchCompleted := func(sinfo *sessionInfo, e error) {
|
|
|
|
select {
|
|
|
|
case <-done:
|
|
|
|
// Somehow this was called multiple times, TODO don't let that happen
|
|
|
|
if sinfo != nil {
|
|
|
|
// Need to clean up to avoid a session leak
|
|
|
|
sinfo.cancel.Cancel(nil)
|
2019-09-18 18:33:51 -05:00
|
|
|
sinfo.sessions.removeSession(sinfo)
|
2019-09-03 19:03:12 -05:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
if sinfo != nil {
|
|
|
|
// Finish initializing the session
|
2019-09-18 18:33:51 -05:00
|
|
|
sinfo.setConn(nil, c)
|
2019-09-03 19:03:12 -05:00
|
|
|
}
|
|
|
|
c.session = sinfo
|
2019-10-03 18:44:47 -05:00
|
|
|
c.nodeID = crypto.GetNodeID(&c.session.theirPermPub)
|
|
|
|
for i := range c.nodeMask {
|
|
|
|
c.nodeMask[i] = 0xFF
|
|
|
|
}
|
2019-09-03 19:03:12 -05:00
|
|
|
err = e
|
|
|
|
close(done)
|
|
|
|
}
|
2019-04-22 20:06:39 +01:00
|
|
|
}
|
2019-09-03 19:03:12 -05:00
|
|
|
sinfo := c.core.router.searches.newIterSearch(c.nodeID, c.nodeMask, searchCompleted)
|
2019-06-29 12:14:44 -05:00
|
|
|
sinfo.continueSearch()
|
2019-09-03 19:03:12 -05:00
|
|
|
} else {
|
|
|
|
err = errors.New("search already exists")
|
|
|
|
close(done)
|
2019-04-26 19:31:47 -05:00
|
|
|
}
|
2019-09-03 19:03:12 -05:00
|
|
|
})
|
|
|
|
<-done
|
|
|
|
if c.session == nil && err == nil {
|
|
|
|
panic("search failed but returned no error")
|
|
|
|
}
|
|
|
|
return err
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-08-24 00:17:37 -05:00
|
|
|
// Used in session keep-alive traffic
|
2019-08-03 22:07:38 -05:00
|
|
|
func (c *Conn) doSearch() {
|
|
|
|
routerWork := func() {
|
|
|
|
// Check to see if there is a search already matching the destination
|
2019-08-23 20:26:15 -05:00
|
|
|
sinfo, isIn := c.core.router.searches.searches[*c.nodeID]
|
2019-08-03 22:07:38 -05:00
|
|
|
if !isIn {
|
|
|
|
// Nothing was found, so create a new search
|
|
|
|
searchCompleted := func(sinfo *sessionInfo, e error) {}
|
2019-08-23 20:26:15 -05:00
|
|
|
sinfo = c.core.router.searches.newIterSearch(c.nodeID, c.nodeMask, searchCompleted)
|
2019-08-03 22:07:38 -05:00
|
|
|
c.core.log.Debugf("%s DHT search started: %p", c.String(), sinfo)
|
2019-08-11 13:00:19 -05:00
|
|
|
// Start the search
|
|
|
|
sinfo.continueSearch()
|
2019-08-03 22:07:38 -05:00
|
|
|
}
|
|
|
|
}
|
2019-08-27 19:43:54 -05:00
|
|
|
c.core.router.Act(c.session, routerWork)
|
2019-08-03 22:07:38 -05:00
|
|
|
}
|
|
|
|
|
2019-08-23 23:36:00 -05:00
|
|
|
func (c *Conn) _getDeadlineCancellation(t *time.Time) (util.Cancellation, bool) {
|
|
|
|
if t != nil {
|
2019-07-17 21:37:45 -05:00
|
|
|
// A deadline is set, so return a Cancellation that uses it
|
2019-08-23 23:36:00 -05:00
|
|
|
c := util.CancellationWithDeadline(c.session.cancel, *t)
|
2019-08-19 18:06:05 -05:00
|
|
|
return c, true
|
2019-07-17 21:37:45 -05:00
|
|
|
} else {
|
2019-08-19 18:06:05 -05:00
|
|
|
// No deadline was set, so just return the existinc cancellation and a dummy value
|
|
|
|
return c.session.cancel, false
|
2019-04-26 19:31:47 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// SetReadCallback allows you to specify a function that will be called whenever
|
|
|
|
// a packet is received. This should be used if you wish to implement
|
|
|
|
// asynchronous patterns for receiving data from the remote node.
|
|
|
|
//
|
|
|
|
// Note that if a read callback has been supplied, you should no longer attempt
|
|
|
|
// to use the synchronous Read function.
|
2019-08-24 01:52:21 -05:00
|
|
|
func (c *Conn) SetReadCallback(callback func([]byte)) {
|
2019-08-27 19:43:54 -05:00
|
|
|
c.Act(nil, func() {
|
2019-08-24 01:57:08 -05:00
|
|
|
c.readCallback = callback
|
|
|
|
c._drainReadBuffer()
|
2019-08-24 01:52:21 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Conn) _drainReadBuffer() {
|
|
|
|
if c.readCallback == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
select {
|
|
|
|
case bs := <-c.readBuffer:
|
|
|
|
c.readCallback(bs)
|
2019-08-27 19:43:54 -05:00
|
|
|
c.Act(nil, c._drainReadBuffer) // In case there's more
|
2019-08-24 01:52:21 -05:00
|
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Called by the session to pass a new message to the Conn
|
2019-08-25 10:36:09 -05:00
|
|
|
func (c *Conn) recvMsg(from phony.Actor, msg []byte) {
|
2019-08-27 19:43:54 -05:00
|
|
|
c.Act(from, func() {
|
2019-08-24 01:52:21 -05:00
|
|
|
if c.readCallback != nil {
|
|
|
|
c.readCallback(msg)
|
|
|
|
} else {
|
|
|
|
select {
|
|
|
|
case c.readBuffer <- msg:
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-08-04 15:53:34 -05:00
|
|
|
// Used internally by Read, the caller is responsible for util.PutBytes when they're done.
|
2019-09-01 13:04:10 -05:00
|
|
|
func (c *Conn) readNoCopy() ([]byte, error) {
|
2019-08-23 23:36:00 -05:00
|
|
|
var cancel util.Cancellation
|
|
|
|
var doCancel bool
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() { cancel, doCancel = c._getDeadlineCancellation(c.readDeadline) })
|
2019-08-19 18:06:05 -05:00
|
|
|
if doCancel {
|
|
|
|
defer cancel.Cancel(nil)
|
|
|
|
}
|
2019-08-04 02:08:47 -05:00
|
|
|
// Wait for some traffic to come through from the session
|
|
|
|
select {
|
|
|
|
case <-cancel.Finished():
|
|
|
|
if cancel.Error() == util.CancellationTimeoutError {
|
2019-08-04 15:53:34 -05:00
|
|
|
return nil, ConnError{errors.New("read timeout"), true, false, false, 0}
|
2019-08-04 02:08:47 -05:00
|
|
|
} else {
|
2019-08-04 15:53:34 -05:00
|
|
|
return nil, ConnError{errors.New("session closed"), false, false, true, 0}
|
2019-04-19 10:55:15 +01:00
|
|
|
}
|
2019-08-24 01:52:21 -05:00
|
|
|
case bs := <-c.readBuffer:
|
2019-08-04 15:53:34 -05:00
|
|
|
return bs, nil
|
2019-04-18 23:38:23 +01:00
|
|
|
}
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// Read allows you to read from the connection in a synchronous fashion. The
|
|
|
|
// function will block up until the point that either new data is available, the
|
|
|
|
// connection has been closed or the read deadline has been reached. If the
|
|
|
|
// function succeeds, the number of bytes read from the connection will be
|
|
|
|
// returned. Otherwise, an error condition will be returned.
|
|
|
|
//
|
|
|
|
// Note that you can also implement asynchronous reads by using SetReadCallback.
|
|
|
|
// If you do that, you should no longer attempt to use the Read function.
|
2019-08-04 15:53:34 -05:00
|
|
|
func (c *Conn) Read(b []byte) (int, error) {
|
2019-09-01 13:04:10 -05:00
|
|
|
bs, err := c.readNoCopy()
|
2019-08-04 15:53:34 -05:00
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
n := len(bs)
|
|
|
|
if len(bs) > len(b) {
|
|
|
|
n = len(b)
|
|
|
|
err = ConnError{errors.New("read buffer too small for entire packet"), false, true, false, 0}
|
|
|
|
}
|
|
|
|
// Copy results to the output slice and clean up
|
|
|
|
copy(b, bs)
|
|
|
|
util.PutBytes(bs)
|
|
|
|
// Return the number of bytes copied to the slice, along with any error
|
|
|
|
return n, err
|
|
|
|
}
|
|
|
|
|
2019-08-24 00:17:37 -05:00
|
|
|
func (c *Conn) _write(msg FlowKeyMessage) error {
|
|
|
|
if len(msg.Message) > int(c.mtu) {
|
|
|
|
return ConnError{errors.New("packet too big"), true, false, false, int(c.mtu)}
|
|
|
|
}
|
2019-08-27 19:43:54 -05:00
|
|
|
c.session.Act(c, func() {
|
2019-08-24 00:17:37 -05:00
|
|
|
// Send the packet
|
|
|
|
c.session._send(msg)
|
2019-10-03 18:50:33 -05:00
|
|
|
// Session keep-alive, while we wait for the crypto workers from send
|
2019-06-28 18:42:31 -05:00
|
|
|
switch {
|
2019-08-04 15:53:34 -05:00
|
|
|
case time.Since(c.session.time) > 6*time.Second:
|
|
|
|
if c.session.time.Before(c.session.pingTime) && time.Since(c.session.pingTime) > 6*time.Second {
|
2019-06-28 18:42:31 -05:00
|
|
|
// TODO double check that the above condition is correct
|
2019-08-03 22:07:38 -05:00
|
|
|
c.doSearch()
|
2019-06-28 18:42:31 -05:00
|
|
|
} else {
|
2019-08-23 20:05:18 -05:00
|
|
|
c.session.ping(c.session) // TODO send from self if this becomes an actor
|
2019-06-28 18:42:31 -05:00
|
|
|
}
|
2019-08-04 15:53:34 -05:00
|
|
|
case c.session.reset && c.session.pingTime.Before(c.session.time):
|
2019-08-23 20:05:18 -05:00
|
|
|
c.session.ping(c.session) // TODO send from self if this becomes an actor
|
2019-06-28 18:42:31 -05:00
|
|
|
default: // Don't do anything, to keep traffic throttled
|
|
|
|
}
|
2019-08-24 00:17:37 -05:00
|
|
|
})
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// WriteFrom should be called by a phony.Actor, and tells the Conn to send a
|
|
|
|
// message. This is used internaly by Write. If the callback is called with a
|
|
|
|
// non-nil value, then it is safe to reuse the argument FlowKeyMessage.
|
2019-08-25 10:36:09 -05:00
|
|
|
func (c *Conn) WriteFrom(from phony.Actor, msg FlowKeyMessage, callback func(error)) {
|
2019-08-27 19:43:54 -05:00
|
|
|
c.Act(from, func() {
|
2019-08-24 00:44:02 -05:00
|
|
|
callback(c._write(msg))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-09-01 13:04:10 -05:00
|
|
|
// writeNoCopy is used internally by Write and makes use of WriteFrom under the hood.
|
2019-08-24 00:44:02 -05:00
|
|
|
// The caller must not reuse the argument FlowKeyMessage when a nil error is returned.
|
2019-09-01 13:04:10 -05:00
|
|
|
func (c *Conn) writeNoCopy(msg FlowKeyMessage) error {
|
2019-08-24 00:17:37 -05:00
|
|
|
var cancel util.Cancellation
|
|
|
|
var doCancel bool
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() { cancel, doCancel = c._getDeadlineCancellation(c.writeDeadline) })
|
2019-10-05 12:23:21 -05:00
|
|
|
if doCancel {
|
|
|
|
defer cancel.Cancel(nil)
|
|
|
|
}
|
2019-08-24 00:17:37 -05:00
|
|
|
var err error
|
|
|
|
select {
|
|
|
|
case <-cancel.Finished():
|
|
|
|
if cancel.Error() == util.CancellationTimeoutError {
|
|
|
|
err = ConnError{errors.New("write timeout"), true, false, false, 0}
|
|
|
|
} else {
|
|
|
|
err = ConnError{errors.New("session closed"), false, false, true, 0}
|
2019-08-04 02:08:47 -05:00
|
|
|
}
|
2019-08-24 00:17:37 -05:00
|
|
|
default:
|
2019-08-24 00:44:02 -05:00
|
|
|
done := make(chan struct{})
|
|
|
|
callback := func(e error) { err = e; close(done) }
|
|
|
|
c.WriteFrom(nil, msg, callback)
|
|
|
|
<-done
|
2019-05-29 20:16:17 +01:00
|
|
|
}
|
2019-08-04 15:53:34 -05:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// Write allows you to write to the connection in a synchronous fashion. This
|
|
|
|
// function may block until either the write has completed, the connection has
|
|
|
|
// been closed or the write deadline has been reached. If the function succeeds,
|
|
|
|
// the number of written bytes is returned. Otherwise, an error condition is
|
|
|
|
// returned.
|
2019-08-04 15:53:34 -05:00
|
|
|
func (c *Conn) Write(b []byte) (int, error) {
|
|
|
|
written := len(b)
|
2019-08-06 19:25:55 -05:00
|
|
|
msg := FlowKeyMessage{Message: append(util.GetBytes(), b...)}
|
2019-09-01 13:04:10 -05:00
|
|
|
err := c.writeNoCopy(msg)
|
2019-08-04 15:53:34 -05:00
|
|
|
if err != nil {
|
2019-08-06 19:25:55 -05:00
|
|
|
util.PutBytes(msg.Message)
|
2019-08-04 15:53:34 -05:00
|
|
|
written = 0
|
|
|
|
}
|
2019-05-29 20:16:17 +01:00
|
|
|
return written, err
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// Close will close an open connection and any blocking operations on the
|
|
|
|
// connection will unblock and return. From this point forward, the connection
|
|
|
|
// can no longer be used and you should no longer attempt to Read or Write to
|
|
|
|
// the connection.
|
2019-07-17 21:42:17 +01:00
|
|
|
func (c *Conn) Close() (err error) {
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() {
|
2019-08-23 23:36:00 -05:00
|
|
|
if c.session != nil {
|
|
|
|
// Close the session, if it hasn't been closed already
|
|
|
|
if e := c.session.cancel.Cancel(errors.New("connection closed")); e != nil {
|
|
|
|
err = ConnError{errors.New("close failed, session already closed"), false, false, true, 0}
|
2019-08-25 19:13:47 -05:00
|
|
|
} else {
|
|
|
|
c.session.doRemove()
|
2019-08-23 23:36:00 -05:00
|
|
|
}
|
2019-08-05 19:11:28 -05:00
|
|
|
}
|
2019-08-23 23:36:00 -05:00
|
|
|
})
|
2019-07-17 21:42:17 +01:00
|
|
|
return
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// LocalAddr returns the complete node ID of the local side of the connection.
|
|
|
|
// This is always going to return your own node's node ID.
|
2019-04-18 16:38:24 +01:00
|
|
|
func (c *Conn) LocalAddr() crypto.NodeID {
|
2019-08-23 20:53:00 -05:00
|
|
|
return *crypto.GetNodeID(&c.core.boxPub)
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// RemoteAddr returns the complete node ID of the remote side of the connection.
|
2019-04-18 16:38:24 +01:00
|
|
|
func (c *Conn) RemoteAddr() crypto.NodeID {
|
2019-10-03 18:44:47 -05:00
|
|
|
// RemoteAddr is set during the dial or accept, and isn't changed, so it's safe to access directly
|
|
|
|
return *c.nodeID
|
2019-04-18 16:38:24 +01:00
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// SetDeadline is equivalent to calling both SetReadDeadline and
|
|
|
|
// SetWriteDeadline with the same value, configuring the maximum amount of time
|
|
|
|
// that synchronous Read and Write operations can block for. If no deadline is
|
|
|
|
// configured, Read and Write operations can potentially block indefinitely.
|
2019-04-18 16:38:24 +01:00
|
|
|
func (c *Conn) SetDeadline(t time.Time) error {
|
|
|
|
c.SetReadDeadline(t)
|
|
|
|
c.SetWriteDeadline(t)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// SetReadDeadline configures the maximum amount of time that a synchronous Read
|
|
|
|
// operation can block for. A Read operation will unblock at the point that the
|
|
|
|
// read deadline is reached if no other condition (such as data arrival or
|
|
|
|
// connection closure) happens first. If no deadline is configured, Read
|
|
|
|
// operations can potentially block indefinitely.
|
2019-04-18 16:38:24 +01:00
|
|
|
func (c *Conn) SetReadDeadline(t time.Time) error {
|
2019-08-24 01:52:21 -05:00
|
|
|
// TODO warn that this can block while waiting for the Conn actor to run, so don't call it from other actors...
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() { c.readDeadline = &t })
|
2019-04-18 16:38:24 +01:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-09-01 23:33:51 +01:00
|
|
|
// SetWriteDeadline configures the maximum amount of time that a synchronous
|
|
|
|
// Write operation can block for. A Write operation will unblock at the point
|
|
|
|
// that the read deadline is reached if no other condition (such as data sending
|
|
|
|
// or connection closure) happens first. If no deadline is configured, Write
|
|
|
|
// operations can potentially block indefinitely.
|
2019-04-18 16:38:24 +01:00
|
|
|
func (c *Conn) SetWriteDeadline(t time.Time) error {
|
2019-08-24 01:52:21 -05:00
|
|
|
// TODO warn that this can block while waiting for the Conn actor to run, so don't call it from other actors...
|
2019-08-27 19:43:54 -05:00
|
|
|
phony.Block(c, func() { c.writeDeadline = &t })
|
2019-04-18 16:38:24 +01:00
|
|
|
return nil
|
|
|
|
}
|