func (i *InmemTransport) makeRPC(target net.Addr, args interface{}, r io.Reader, timeout time.Duration) (rpcResp RPCResponse, err error) {
i.RLock()
peer, ok := i.peers[target.String()]
i.RUnlock()
if !ok {
err = fmt.Errorf("failed to connect to peer: %v", target)
return
}
// Send the RPC over
respCh := make(chan RPCResponse)
peer.consumerCh <- RPC{
Command: args,
Reader: r,
RespChan: respCh,
}
// Wait for a response
select {
case rpcResp = <-respCh:
if rpcResp.Error != nil {
err = rpcResp.Error
}
case <-time.After(timeout):
err = fmt.Errorf("command timed out")
}
return
}
func packetDump(addr net.Addr, data []byte, cache TemplateCache) {
p, err := nf9packet.Decode(data)
if err != nil {
fmt.Fprintln(os.Stderr, err)
return
}
templateList := p.TemplateRecords()
flowSets := p.DataFlowSets()
for _, t := range templateList {
templateKey := fmt.Sprintf("%s|%b|%v", addr.String(), p.SourceId, t.TemplateId)
cache[templateKey] = t
}
for _, set := range flowSets {
templateKey := fmt.Sprintf("%s|%b|%v", addr.String(), p.SourceId, set.Id)
template, ok := cache[templateKey]
if !ok {
// We do not have template for this Data FlowSet yet
continue
}
records := template.DecodeFlowSet(&set)
if records == nil {
// Error in decoding Data FlowSet
continue
}
printTable(template, records)
}
}
// Determine ssl server names from a net.Addr
func GetTargetServernames(addr net.Addr) (hosts []string, err error) {
c, err := tls.Dial("tcp4", addr.String(), &tls.Config{RootCAs: trust_db})
if err != nil {
if err, ok := err.(x509.HostnameError); ok {
// This is a tls error condition our side because we asked for an
// IP connection (we don't know the hostname of the target, only
// the IP).
// It's okay because we're just interested in finding out what hosts
// we should tell the client we are. If it is invalid, the client
// will bail out.
hosts := err.Certificate.DNSNames
if len(hosts) == 0 {
hosts = []string{err.Certificate.Subject.CommonName} //err.Host}
}
return hosts, nil
}
return
}
err = c.Handshake()
if err != nil {
return
}
hosts = c.ConnectionState().PeerCertificates[0].DNSNames
return
}
// newAuthAddr returns a string from a net.Addr used to index the address the key in our lookup.
func newAuthAddr(addr net.Addr) string {
if addr == nil {
return ""
}
host, _, _ := net.SplitHostPort(addr.String())
return host
}
// getConn is used to get a connection from the pool
func (n *NetworkTransport) getConn(target net.Addr) (*netConn, error) {
// Check for a pooled conn
if conn := n.getPooledConn(target); conn != nil {
return conn, nil
}
// Dial a new connection
conn, err := n.stream.Dial(target.String(), n.timeout)
if err != nil {
return nil, err
}
// Wrap the conn
netConn := &netConn{
target: target,
conn: conn,
r: bufio.NewReader(conn),
w: bufio.NewWriter(conn),
}
// Setup encoder/decoders
netConn.dec = codec.NewDecoder(netConn.r, &codec.MsgpackHandle{})
netConn.enc = codec.NewEncoder(netConn.w, &codec.MsgpackHandle{})
// Done
return netConn, nil
}
func (udp *udpProxySocket) getBackendConn(activeClients *clientCache, cliAddr net.Addr, proxier *Proxier, service proxy.ServicePortName, timeout time.Duration) (net.Conn, error) {
activeClients.mu.Lock()
defer activeClients.mu.Unlock()
svrConn, found := activeClients.clients[cliAddr.String()]
if !found {
// TODO: This could spin up a new goroutine to make the outbound connection,
// and keep accepting inbound traffic.
glog.V(3).Infof("New UDP connection from %s", cliAddr)
var err error
svrConn, err = tryConnect(service, cliAddr, "udp", proxier)
if err != nil {
return nil, err
}
if err = svrConn.SetDeadline(time.Now().Add(timeout)); err != nil {
glog.Errorf("SetDeadline failed: %v", err)
return nil, err
}
activeClients.clients[cliAddr.String()] = svrConn
go func(cliAddr net.Addr, svrConn net.Conn, activeClients *clientCache, timeout time.Duration) {
defer util.HandleCrash()
udp.proxyClient(cliAddr, svrConn, activeClients, timeout)
}(cliAddr, svrConn, activeClients, timeout)
}
return svrConn, nil
}
func runListener(listenPacket listenPacketFunc, port *port, dataChan chan<- []byte, stopChan <-chan struct{}) (err error) {
conn, err := listenPacket(fmt.Sprintf(":%d", port.Get()))
if err != nil {
return
}
port.Set(conn.Port())
go func() {
<-stopChan
conn.Close()
}()
for {
buffer := make([]byte, 4096)
var n int
var addr net.Addr
n, addr, err = conn.ReadFrom(buffer) // errors returned from here are used for control
if err != nil {
return
}
if n == 0 {
log.Printf("Warning: zero bytes read from client: %v\n", addr.String())
} else {
dataChan <- buffer[0:n]
}
}
}
// newNetAddress attempts to extract the IP address and port from the passed
// net.Addr interface and create a bitcoin NetAddress structure using that
// information.
func newNetAddress(addr net.Addr, services btcwire.ServiceFlag) (*btcwire.NetAddress, error) {
// addr will be a net.TCPAddr when not using a proxy.
if tcpAddr, ok := addr.(*net.TCPAddr); ok {
ip := tcpAddr.IP
port := uint16(tcpAddr.Port)
na := btcwire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// addr will be a socks.ProxiedAddr when using a proxy.
if proxiedAddr, ok := addr.(*socks.ProxiedAddr); ok {
ip := net.ParseIP(proxiedAddr.Host)
if ip == nil {
ip = net.ParseIP("0.0.0.0")
}
port := uint16(proxiedAddr.Port)
na := btcwire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// For the most part, addr should be one of the two above cases, but
// to be safe, fall back to trying to parse the information from the
// address string as a last resort.
host, portStr, err := net.SplitHostPort(addr.String())
if err != nil {
return nil, err
}
ip := net.ParseIP(host)
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return nil, err
}
na := btcwire.NewNetAddressIPPort(ip, uint16(port), services)
return na, nil
}
// sendTCPUserMsg is used to send a TCP userMsg to another host
func (m *Memberlist) sendTCPUserMsg(to net.Addr, sendBuf []byte) error {
dialer := net.Dialer{Timeout: m.config.TCPTimeout}
conn, err := dialer.Dial("tcp", to.String())
if err != nil {
return err
}
defer conn.Close()
bufConn := bytes.NewBuffer(nil)
if err := bufConn.WriteByte(byte(userMsg)); err != nil {
return err
}
// Send our node state
header := userMsgHeader{UserMsgLen: len(sendBuf)}
hd := codec.MsgpackHandle{}
enc := codec.NewEncoder(bufConn, &hd)
if err := enc.Encode(&header); err != nil {
return err
}
if _, err := bufConn.Write(sendBuf); err != nil {
return err
}
return m.rawSendMsgTCP(conn, bufConn.Bytes())
}
func (ct *codecTransport) Dial(addr net.Addr) (codec.CarrierConn, error) {
c, err := net.Dial("tcp", addr.String())
if err != nil {
return nil, err
}
return newCodecConn(trace.NewFrame("hmac", "dial"), c.(*net.TCPConn), ct.key)
}
func NewSession(transportDesc string, remoteAddr net.Addr) (s *Session) {
s = &Session{}
// deserialize input data
parts := strings.Split(transportDesc, ";")
s.SessionType = parts[0]
s.SessionMode = parts[1]
paramsMap := map[string]string{}
for _, v := range parts[2:] {
pair := strings.Split(v, "=")
paramsMap[pair[0]] = pair[1]
}
s.ClientPort = strings.Split(paramsMap["client_port"], "-")[0]
// pick a random udp port
ip := strings.Split(remoteAddr.String(), ":")[0]
conn, err := net.Dial("udp", fmt.Sprintf("%s:%s", ip, s.ClientPort))
if err != nil {
fmt.Println(err)
return
}
s.ServerPort = strings.Split(conn.LocalAddr().String(), ":")[1]
s.conn = conn
s.Id = strconv.Itoa(rand.Int())
s.start = time.Now()
sessions[s.Id] = s
return
}
// start initializes the infostore with the rpc server address and
// then begins processing connecting clients in an infinite select
// loop via goroutine. Periodically, clients connected and awaiting
// the next round of gossip are awoken via the conditional variable.
func (s *server) start(grpcServer *grpc.Server, addr net.Addr) {
s.mu.Lock()
s.is.NodeAddr = util.MakeUnresolvedAddr(addr.Network(), addr.String())
s.mu.Unlock()
RegisterGossipServer(grpcServer, s)
broadcast := func() {
ready := make(chan struct{})
s.mu.Lock()
close(s.ready)
s.ready = ready
s.mu.Unlock()
}
unregister := s.is.registerCallback(".*", func(_ string, _ roachpb.Value) {
broadcast()
})
s.stopper.RunWorker(func() {
<-s.stopper.ShouldDrain()
s.mu.Lock()
unregister()
s.mu.Unlock()
broadcast()
})
}
func startGossipAtAddr(
nodeID roachpb.NodeID,
addr net.Addr,
stopper *stop.Stopper,
t *testing.T,
registry *metric.Registry,
) *Gossip {
rpcContext := rpc.NewContext(log.AmbientContext{}, &base.Config{Insecure: true}, nil, stopper)
server := rpc.NewServer(rpcContext)
g := NewTest(nodeID, rpcContext, server, nil, stopper, registry)
ln, err := netutil.ListenAndServeGRPC(stopper, server, addr)
if err != nil {
t.Fatal(err)
}
addr = ln.Addr()
if err := g.SetNodeDescriptor(&roachpb.NodeDescriptor{
NodeID: nodeID,
Address: util.MakeUnresolvedAddr(addr.Network(), addr.String()),
}); err != nil {
t.Fatal(err)
}
g.start(addr)
time.Sleep(time.Millisecond)
return g
}
func (c *cluster) EnsureLeader(t *testing.T, expect net.Addr) {
limit := time.Now().Add(400 * time.Millisecond)
CHECK:
for _, r := range c.rafts {
leader := r.Leader()
if expect == nil {
if leader != nil {
if time.Now().After(limit) {
t.Fatalf("leader %v expected nil", leader)
} else {
goto WAIT
}
}
} else {
if leader == nil || leader.String() != expect.String() {
if time.Now().After(limit) {
t.Fatalf("leader %v expected %v", leader, expect)
} else {
goto WAIT
}
}
}
}
return
WAIT:
time.Sleep(10 * time.Millisecond)
goto CHECK
}
func officialAddr(unresolvedAddr string, resolvedAddr net.Addr) (*util.UnresolvedAddr, error) {
unresolvedHost, unresolvedPort, err := net.SplitHostPort(unresolvedAddr)
if err != nil {
return nil, err
}
resolvedHost, resolvedPort, err := net.SplitHostPort(resolvedAddr.String())
if err != nil {
return nil, err
}
var host string
if unresolvedHost != "" {
// A host was provided, use it.
host = unresolvedHost
} else {
// A host was not provided. Ask the system, and fall back to the listener.
if hostname, err := os.Hostname(); err == nil {
host = hostname
} else {
host = resolvedHost
}
}
var port string
if unresolvedPort != "0" {
// A port was provided, use it.
port = unresolvedPort
} else {
// A port was not provided, but the system assigned one.
port = resolvedPort
}
return util.NewUnresolvedAddr(resolvedAddr.Network(), net.JoinHostPort(host, port)), nil
}
// remoteJoin is used to handle join events on the wan serf cluster
func (s *Server) remoteJoin(me serf.MemberEvent) {
for _, m := range me.Members {
ok, parts := isConsulServer(m)
if !ok {
s.logger.Printf("[WARN] consul: non-server in WAN pool: %s %s", m.Name)
continue
}
var addr net.Addr = &net.TCPAddr{IP: m.Addr, Port: parts.Port}
s.logger.Printf("[INFO] consul: adding server for datacenter: %s, addr: %s", parts.Datacenter, addr)
// Check if this server is known
found := false
s.remoteLock.Lock()
existing := s.remoteConsuls[parts.Datacenter]
for _, e := range existing {
if e.String() == addr.String() {
found = true
break
}
}
// Add ot the list if not known
if !found {
s.remoteConsuls[parts.Datacenter] = append(existing, addr)
}
s.remoteLock.Unlock()
// Trigger the callback
if s.config.ServerUp != nil {
s.config.ServerUp()
}
}
}
// joinConsulServer is used to try to join another consul server
func (s *Server) joinConsulServer(m serf.Member, parts *serverParts) error {
// Do not join ourself
if m.Name == s.config.NodeName {
return nil
}
// Check for possibility of multiple bootstrap nodes
if parts.Bootstrap {
members := s.serfLAN.Members()
for _, member := range members {
valid, p := isConsulServer(member)
if valid && member.Name != m.Name && p.Bootstrap {
s.logger.Printf("[ERR] consul: '%v' and '%v' are both in bootstrap mode. Only one node should be in bootstrap mode, not adding Raft peer.", m.Name, member.Name)
return nil
}
}
}
// Attempt to add as a peer
var addr net.Addr = &net.TCPAddr{IP: m.Addr, Port: parts.Port}
future := s.raft.AddPeer(addr.String())
if err := future.Error(); err != nil && err != raft.ErrKnownPeer {
s.logger.Printf("[ERR] consul: failed to add raft peer: %v", err)
return err
}
return nil
}
// remoteFailed is used to handle fail events on the wan serf cluster
func (s *Server) remoteFailed(me serf.MemberEvent) {
for _, m := range me.Members {
ok, parts := isConsulServer(m)
if !ok {
continue
}
var addr net.Addr = &net.TCPAddr{IP: m.Addr, Port: parts.Port}
s.logger.Printf("[INFO] consul: removing server for datacenter: %s, addr: %s", parts.Datacenter, addr)
// Remove the server if known
s.remoteLock.Lock()
existing := s.remoteConsuls[parts.Datacenter]
n := len(existing)
for i := 0; i < n; i++ {
if existing[i].String() == addr.String() {
existing[i], existing[n-1] = existing[n-1], nil
existing = existing[:n-1]
n--
break
}
}
// Trim the list if all known consuls are dead
if n == 0 {
delete(s.remoteConsuls, parts.Datacenter)
} else {
s.remoteConsuls[parts.Datacenter] = existing
}
s.remoteLock.Unlock()
}
}
func (c *Client) dial(addr net.Addr) (net.Conn, error) {
type connError struct {
cn net.Conn
err error
}
ch := make(chan connError)
go func() {
nc, err := net.Dial(addr.Network(), addr.String())
ch <- connError{nc, err}
}()
select {
case ce := <-ch:
return ce.cn, ce.err
case <-time.After(c.netTimeout()):
// Too slow. Fall through.
}
// Close the conn if it does end up finally coming in
go func() {
ce := <-ch
if ce.err == nil {
ce.cn.Close()
}
}()
return nil, &ConnectTimeoutError{addr}
}
func (m *connManager) New(addr net.Addr) chan []byte {
reqChan := make(chan []byte, 64) // TODO (better value)
m.Lock()
m.reqMap[addr.String()] = reqChan
m.Unlock()
return reqChan
}
func (a *Agent) Propagate(dest net.Addr, id string, addr net.Addr) {
a.wlock.Lock()
defer a.wlock.Unlock()
fmt.Fprintf(&a.wbur, wpropagate, id, addr.String())
a.Socket.WriteTo(a.wbur.Bytes(), dest)
a.wbur.Truncate(0)
}
// initDescriptor initializes the node descriptor with the server
// address and the node attributes.
func (n *Node) initDescriptor(addr net.Addr, attrs proto.Attributes) {
n.Descriptor.Address = proto.Addr{
Network: addr.Network(),
Address: addr.String(),
}
n.Descriptor.Attrs = attrs
}
// listen and run
func ListenAndServe(addr string) error {
var netaddr net.Addr
var err error
if strings.Contains(addr, "/") {
netaddr, err = net.ResolveUnixAddr("unix", addr)
if err != nil {
return err
}
} else {
netaddr, err = net.ResolveTCPAddr("tcp", addr)
if err != nil {
return err
}
}
// listen
l, err := net.Listen(netaddr.Network(), netaddr.String())
if err != nil {
return err
}
// same with ServeRpc
http.Handle(GetRpcPath(codecName), &rpcHandler{NewServerCodec})
err = http.Serve(l, nil)
return err
}
// closeClient closes an existing client specified by client's
// remote address.
func (g *Gossip) closeClient(addr net.Addr) {
g.clientsMu.Lock()
c := g.clients[addr.String()]
c.close()
delete(g.clients, addr.String())
g.clientsMu.Unlock()
}
// Dial connects to the address addr and returns a Message-oriented connection.
func Dial(addr net.Addr) (*Conn, error) {
conn, err := net.Dial(addr.Network(), addr.String())
if err != nil {
return nil, err
}
return WrapConn(conn), nil
}
func sshPermissionsFromProcess(
processGuid string,
index int,
receptorClient receptor.Client,
remoteAddr net.Addr,
) (*ssh.Permissions, error) {
actual, err := receptorClient.ActualLRPByProcessGuidAndIndex(processGuid, index)
if err != nil {
return nil, err
}
desired, err := receptorClient.GetDesiredLRP(processGuid)
if err != nil {
return nil, err
}
sshRoute, err := getRoutingInfo(&desired)
if err != nil {
return nil, err
}
logMessage := fmt.Sprintf("Successful remote access by %s", remoteAddr.String())
return createPermissions(sshRoute, &actual, desired.LogGuid, logMessage, index)
}
// verifyAddr starts a server listener at the specified addr and
// then dials a client to verify a connection is established.
func verifyAddr(addr net.Addr, t *testing.T) {
ln, err := net.Listen(addr.Network(), addr.String())
if err != nil {
t.Error(err)
return
}
acceptChan := make(chan struct{})
go func() {
_, err := ln.Accept()
if err != nil {
t.Error(err)
}
close(acceptChan)
}()
addr = ln.Addr()
conn, err := net.Dial(addr.Network(), addr.String())
if err != nil {
t.Errorf("could not connect to %s", addr)
return
}
select {
case <-acceptChan:
// success.
case <-time.After(500 * time.Millisecond):
t.Error("timeout waiting for client connection after 500ms")
}
conn.Close()
}
// This function is expected to be called as a goroutine.
// TODO: Track and log bytes copied, like TCP
func (udp *udpProxySocket) proxyClient(cliAddr net.Addr, svrConn net.Conn, activeClients *clientCache, timeout time.Duration) {
defer svrConn.Close()
var buffer [4096]byte
for {
n, err := svrConn.Read(buffer[0:])
if err != nil {
if !logTimeout(err) {
glog.Errorf("Read failed: %v", err)
}
break
}
svrConn.SetDeadline(time.Now().Add(timeout))
if err != nil {
glog.Errorf("SetDeadline failed: %v", err)
break
}
n, err = udp.WriteTo(buffer[0:n], cliAddr)
if err != nil {
if !logTimeout(err) {
glog.Errorf("WriteTo failed: %v", err)
}
break
}
}
activeClients.mu.Lock()
delete(activeClients.clients, cliAddr.String())
activeClients.mu.Unlock()
}
func (udp *udpProxySocket) getBackendConn(activeClients *clientCache, cliAddr net.Addr, proxier *Proxier, service string, timeout time.Duration) (net.Conn, error) {
activeClients.mu.Lock()
defer activeClients.mu.Unlock()
svrConn, found := activeClients.clients[cliAddr.String()]
if !found {
// TODO: This could spin up a new goroutine to make the outbound connection,
// and keep accepting inbound traffic.
glog.V(2).Infof("New UDP connection from %s", cliAddr)
endpoint, err := proxier.loadBalancer.NextEndpoint(service, cliAddr)
if err != nil {
glog.Errorf("Couldn't find an endpoint for %s %v", service, err)
return nil, err
}
glog.V(3).Infof("Mapped service %q to endpoint %s", service, endpoint)
svrConn, err = net.DialTimeout("udp", endpoint, endpointDialTimeout)
if err != nil {
// TODO: Try another endpoint?
glog.Errorf("Dial failed: %v", err)
return nil, err
}
activeClients.clients[cliAddr.String()] = svrConn
go func(cliAddr net.Addr, svrConn net.Conn, activeClients *clientCache, timeout time.Duration) {
defer util.HandleCrash()
udp.proxyClient(cliAddr, svrConn, activeClients, timeout)
}(cliAddr, svrConn, activeClients, timeout)
}
return svrConn, nil
}
func udpListener(conn *net.UDPConn, sendingFrom net.Addr, start *sync.WaitGroup, end *sync.WaitGroup) {
fmt.Fprintln(os.Stderr, "Started listener...")
start.Done()
buff := make([]byte, 1600) // standard MTU size -- no packet should be bigger
for i := 0; true; i++ {
fmt.Fprintln(os.Stderr, "Waiting for packet #"+strconv.Itoa(i))
len, from, err := conn.ReadFromUDP(buff)
if err != nil {
fmt.Fprintln(os.Stderr, "Error receiving UDP packet: "+err.Error())
}
if from.String() == sendingFrom.String() {
i--
continue
}
str := string(buff[:len])
fmt.Println("Received message from " + from.String() + "\n\t" + str)
if strings.Contains(str, "<<terminate>>") {
conn.Close()
fmt.Fprintln(os.Stderr, "Terminated UDP listener")
end.Done()
return
}
}
}