// 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 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) } }
// 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 }
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 (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] } } }
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 }
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 }
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 (fw *firewall) Dial(addr net.Addr) (net.Conn, error) { if fw.rule != nil && !fw.rule.Match(addr) { return nil, &net.OpError{Op: "dial", Net: addr.Network(), Addr: addr, Err: errors.New("unreachable host")} } return fw.t.Dial(addr) }
// 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 (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 }
// 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 }
// 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 }
// 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()) }
// 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 }
// 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() } } }
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} }
// 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 (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) }
// 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 }
// 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 }
// 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 }
// 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() }
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) }
// 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 } } }