Exemplo n.º 1
0
// handleMessages takes all messages from the Send channel
// and actually sends them over the network. It then waits
// for the response and puts it in the Recv channel.
func (c *Client) handleMessages(tnl io.ReadWriter) {
	// We don't need compression for a local socket:
	protocol := protocol.NewProtocol(tnl, false)

	for {
		select {
		case <-c.quit:
			return
		case msg := <-c.Send:
			if err := protocol.Send(msg); err != nil {
				log.Warning("client-send: ", err)
				c.Recv <- nil
				continue
			}

			resp := &wire.Response{}
			if err := protocol.Recv(resp); err != nil {
				log.Warning("client-recv: ", err)
				c.Recv <- nil
				continue
			}

			c.Recv <- resp
		}
	}
}
Exemplo n.º 2
0
// Handles incoming requests:
func (d *Server) handleConnection(ctx context.Context, conn net.Conn) {
	// Make sure this connection count gets released:
	defer func() {
		if err := conn.Close(); err != nil {
			log.Debugf("daemon-loop: connection drop failed: %v", err)
		}

		d.maxConnections <- allowOneConn{}
	}()

	tnl, err := security.NewEllipticTunnel(conn)
	if err != nil {
		log.Error("Tunnel failed", err)
		return
	}

	p := protocol.NewProtocol(tnl, false)

	// Loop until client disconnect or dies otherwise:
	for {
		msg := &wire.Command{}
		if err := p.Recv(msg); err != nil {
			if err != io.EOF {
				log.Warning("daemon-recv: ", err)
			}
			return
		}

		log.Infof("recv: %s: %v", conn.RemoteAddr().String(), msg)
		d.handleCommand(ctx, msg, p)
	}
}
Exemplo n.º 3
0
// wrapConnAsProto establishes the moose protocol on the raw ipfs connection
func wrapConnAsProto(conn net.Conn, node *ipfsutil.Node, peerHash string) (*protocol.Protocol, error) {
	pub, err := node.PublicKeyFor(peerHash)
	if err != nil {
		return nil, err
	}

	priv, err := node.PrivateKey()
	if err != nil {
		return nil, err
	}

	authrw := security.NewAuthReadWriter(conn, priv, pub)
	if err := authrw.Trigger(); err != nil {
		return nil, err
	}

	return protocol.NewProtocol(authrw, true), nil
}