// GetOriginalDst returns original destination of Conn func GetOriginalDst(c net.Conn) (string, error) { tcp, ok := c.(*net.TCPConn) if !ok { return "", errors.New("socket is not tcp") } file, err := tcp.File() if err != nil { return "", err } defer file.Close() sa, err := syscall.Getsockname(int(file.Fd())) if err != nil { return "", err } var addr net.TCPAddr if v, ok := sa.(*syscall.SockaddrInet4); ok { addr = net.TCPAddr{IP: v.Addr[0:], Port: v.Port} } else if v, ok := sa.(*syscall.SockaddrInet6); ok { addr = net.TCPAddr{IP: v.Addr[0:], Port: v.Port, Zone: zoneToString(int(v.ZoneId))} } else { return "", errors.New("socket is not ipv4") } return addr.String(), nil }
func (thisNode *node) removeDeadFinger(deadAddress *net.TCPAddr) { // If a connected node disappears, remove it from the finger table. var closestFinger *net.TCPAddr for _, entry := range thisNode.fingerTable { if entry.fingerAddress != nil && entry.fingerAddress.String() == deadAddress.String() { entry.fingerAddress = nil } else if entry.fingerAddress != nil && closestFinger == nil { closestFinger = entry.fingerAddress } } // If it's the predecessor, remove it. if thisNode.predecessorAddress.String() == deadAddress.String() { thisNode.predecessorAddress = nil } // If there was some other finger, replace it. if closestFinger != nil { thisNode.SetSuccessor(closestFinger) } else if thisNode.predecessorAddress != nil { // There was no other finger in the table, but maybe as a predecessor? thisNode.SetSuccessor(thisNode.predecessorAddress) } else { // If not, become a singular node ring. thisNode.MakeIntoRing() } }
// Generate all publishable URLs for a given HTTP port. func interfaceURLs(port int) (types.URLs, error) { allAddrs, err := net.InterfaceAddrs() if err != nil { return []url.URL{}, err } var allURLs types.URLs for _, a := range allAddrs { ip, ok := a.(*net.IPNet) if !ok || !ip.IP.IsGlobalUnicast() { continue } tcp := net.TCPAddr{ IP: ip.IP, Port: port, } u := url.URL{ Scheme: "http", Host: tcp.String(), } allURLs = append(allURLs, u) } if len(allAddrs) == 0 { return []url.URL{}, fmt.Errorf("no publishable addresses") } return allURLs, nil }
// sendState is used to initiate a push/pull over TCP with a remote node func (m *Memberlist) sendAndReceiveState(addr []byte, port uint16, join bool) ([]pushNodeState, []byte, error) { // Attempt to connect dialer := net.Dialer{Timeout: m.config.TCPTimeout} dest := net.TCPAddr{IP: addr, Port: int(port)} conn, err := dialer.Dial("tcp", dest.String()) if err != nil { return nil, nil, err } defer conn.Close() m.logger.Printf("[DEBUG] memberlist: Initiating push/pull sync with: %s", conn.RemoteAddr()) metrics.IncrCounter([]string{"memberlist", "tcp", "connect"}, 1) // Send our state if err := m.sendLocalState(conn, join); err != nil { return nil, nil, err } // Read remote state _, remote, userState, err := m.readRemoteState(conn) if err != nil { err := fmt.Errorf("Reading remote state failed: %v", err) return nil, nil, err } // Return the remote state return remote, userState, nil }
// sendState is used to initiate a push/pull over TCP with a remote node func (m *Memberlist) sendAndReceiveState(addr []byte) ([]pushNodeState, []byte, error) { // Attempt to connect dialer := net.Dialer{Timeout: m.config.TCPTimeout} dest := net.TCPAddr{IP: addr, Port: m.config.TCPPort} conn, err := dialer.Dial("tcp", dest.String()) if err != nil { return nil, nil, err } defer conn.Close() m.logger.Printf("[INFO] Initiating push/pull sync with: %s", conn.RemoteAddr()) // Send our state if err := m.sendLocalState(conn); err != nil { return nil, nil, err } // Read remote state remote, userState, err := m.readRemoteState(conn) if err != nil { err := fmt.Errorf("Reading remote state failed: %v", err) return nil, nil, err } // Return the remote state return remote, userState, nil }
func main() { if len(os.Args) != 2 { fmt.Fprintf(os.Stderr, "Usage: %s message", os.Args[0]) os.Exit(1) } message := os.Args[1] serverIP := "127.0.0.1" //サーバ側のIP serverPort := "55555" //サーバ側のポート番号 myIP := "127.0.0.1" //クライアント側のIP myPort := 55556 //クライアント側のポート番号 tcpAddr, err := net.ResolveTCPAddr("tcp", serverIP+":"+serverPort) checkError(err) myAddr := new(net.TCPAddr) myAddr.IP = net.ParseIP(myIP) myAddr.Port = myPort conn, err := net.DialTCP("tcp", myAddr, tcpAddr) checkError(err) defer conn.Close() conn.SetWriteDeadline(time.Now().Add(10 * time.Second)) conn.Write([]byte(message)) readBuf := make([]byte, 1024) conn.SetReadDeadline(time.Now().Add(10 * time.Second)) readlen, err := conn.Read(readBuf) checkError(err) fmt.Println("server: " + string(readBuf[:readlen])) }
func ts6_main(msg chan string, exit chan int) { // No configuration, so this is fixed. var addr net.TCPAddr addr.IP = net.IPv4(127, 0, 0, 1) addr.Port = 3725 // Start our listener. l, err := net.ListenTCP("tcp4", &addr) if err != nil { fmt.Printf("No bind: %s\n", err) exit <- 0 } else { go listen(l) // Again, no configuration. addr.Port = 13725 c, err := net.DialTCP("tcp4", nil, &addr) if err != nil { fmt.Printf("No connection: %s\n", err) } else { go link(c, true) } } // Handle messages. for message := range msg { if message == "exit" { exit <- 0 } } }
// detailedOutput is used to dump all known information about nodes in // their raw format func (c *MembersCommand) detailedOutput(members []agent.Member) []string { result := make([]string, 0, len(members)) header := "Node|Address|Status|Tags" result = append(result, header) for _, member := range members { // Get the tags sorted by key tagKeys := make([]string, 0, len(member.Tags)) for key := range member.Tags { tagKeys = append(tagKeys, key) } sort.Strings(tagKeys) // Format the tags as tag1=v1,tag2=v2,... var tagPairs []string for _, key := range tagKeys { tagPairs = append(tagPairs, fmt.Sprintf("%s=%s", key, member.Tags[key])) } tags := strings.Join(tagPairs, ",") addr := net.TCPAddr{IP: member.Addr, Port: int(member.Port)} line := fmt.Sprintf("%s|%s|%s|%s", member.Name, addr.String(), member.Status, tags) result = append(result, line) } return result }
func (p *httpProxyClient) DialTCP(network string, laddr, raddr *net.TCPAddr) (net.Conn, error) { if laddr != nil || laddr.Port != 0 { return nil, errors.New("代理协议不支持指定本地地址。") } return p.DialTCPSAddr(network, raddr.String()) }
// sendAndReceiveState is used to initiate a push/pull over TCP with a remote node func (m *Memberlist) sendAndReceiveState(addr []byte, port uint16, join bool) ([]pushNodeState, []byte, error) { // Attempt to connect dialer := net.Dialer{Timeout: m.config.TCPTimeout} dest := net.TCPAddr{IP: addr, Port: int(port)} conn, err := dialer.Dial("tcp", dest.String()) if err != nil { return nil, nil, err } defer conn.Close() m.logger.Printf("[DEBUG] memberlist: Initiating push/pull sync with: %s", conn.RemoteAddr()) metrics.IncrCounter([]string{"memberlist", "tcp", "connect"}, 1) // Send our state if err := m.sendLocalState(conn, join); err != nil { return nil, nil, err } conn.SetDeadline(time.Now().Add(m.config.TCPTimeout)) msgType, bufConn, dec, err := m.readTCP(conn) if err != nil { return nil, nil, err } // Quit if not push/pull if msgType != pushPullMsg { err := fmt.Errorf("received invalid msgType (%d), expected pushPullMsg (%d) %s", msgType, pushPullMsg, LogConn(conn)) return nil, nil, err } // Read remote state _, remoteNodes, userState, err := m.readRemoteState(bufConn, dec) return remoteNodes, userState, err }
func (d *DHT) replyAnnouncePeer(addr net.UDPAddr, node *remoteNode, r responseType) { ih := InfoHash(r.A.InfoHash) if log.V(3) { log.Infof("DHT: announce_peer. Host %v, nodeID: %x, infoHash: %x, peerPort %d, distance to me %x", addr, r.A.Id, ih, r.A.Port, hashDistance(ih, InfoHash(d.nodeId)), ) } // node can be nil if, for example, the server just restarted and received an announce_peer // from a node it doesn't yet know about. if node != nil && d.checkToken(addr, r.A.Token) { peerAddr := net.TCPAddr{IP: addr.IP, Port: r.A.Port} d.peerStore.addContact(ih, nettools.DottedPortToBinary(peerAddr.String())) // Allow searching this node immediately, since it's telling us // it has an infohash. Enables faster upgrade of other nodes to // "peer" of an infohash, if the announcement is valid. node.lastResponseTime = time.Now().Add(-searchRetryPeriod) if d.peerStore.hasLocalDownload(ih) { d.PeersRequestResults <- map[InfoHash][]string{ih: []string{nettools.DottedPortToBinary(peerAddr.String())}} } } // Always reply positively. jech says this is to avoid "back-tracking", not sure what that means. reply := replyMessage{ T: r.T, Y: "r", R: map[string]interface{}{"id": d.nodeId}, } sendMsg(d.conn, addr, reply) }
func MakeConn(ip string) (*net.TCPConn, error) { var addr net.TCPAddr addr.IP = net.ParseIP(ip) addr.Port = Port c, err := net.DialTCP("tcp4", nil, &addr) return c, err }
func CreateTCPSocket(proto, addr string) (net.Listener, error) { var err error var laddr *net.TCPAddr laddr, err = net.ResolveTCPAddr(proto, addr) if err != nil { return nil, err } family, ipv6only := favoriteTCPAddrFamily(proto, laddr, "listen") var socketAddr syscall.Sockaddr if socketAddr, err = ipToSockaddr(family, laddr.IP, laddr.Port, laddr.Zone); err != nil { panic(err) return nil, err } var s int if s, err = sysSocket(family, syscall.SOCK_STREAM, 0); err != nil { return nil, err } if err = setDefaultSockopts(s, family, syscall.SOCK_STREAM, ipv6only); err != nil { closesocket(s) return nil, err } if err = setDefaultListenerSockopts(s); err != nil { closesocket(s) return nil, err } if err = syscall.SetsockoptInt(s, syscall.SOL_SOCKET, SO_REUSEPORT, 1); err != nil { closesocket(s) panic(err) return nil, err } if err = syscall.Bind(s, socketAddr); err != nil { closesocket(s) return nil, err } if err = syscall.Listen(s, maxListenerBacklog()); err != nil { closesocket(s) return nil, err } file := os.NewFile(uintptr(s), "listener-"+laddr.String()) defer file.Close() var socketListener net.Listener if socketListener, err = net.FileListener(file); err != nil { return nil, err } return socketListener, nil }
func mustConnectLookupd(t *testing.T, tcpAddr *net.TCPAddr) net.Conn { conn, err := net.DialTimeout("tcp", tcpAddr.String(), time.Second) if err != nil { t.Fatal("failed to connect to lookupd") } conn.Write(nsq.MagicV1) return conn }
func mustConnectNSQD(tcpAddr *net.TCPAddr) (net.Conn, error) { conn, err := net.DialTimeout("tcp", tcpAddr.String(), time.Second) if err != nil { return nil, err } conn.Write(nsq.MagicV2) return conn, nil }
func ServeHTTPBooter(listenAddr net.TCPAddr, ds datasource.DataSource, webPort int) error { logging.Log("HTTPBOOTER", "Listening on %s", listenAddr.String()) mux, err := HTTPBooterMux(listenAddr, ds, webPort) if err != nil { return err } return http.ListenAndServe(listenAddr.String(), mux) }
func mustConnectGFW(tcpAddr *net.TCPAddr) (net.Conn, error) { conn, err := net.DialTimeout("tcp", tcpAddr.String(), time.Second) if err != nil { return nil, err } conn.Write([]byte(" V1")) return conn, nil }
func ServeHTTPBooter(listenAddr net.TCPAddr, runtimeConfig *datasource.RuntimeConfiguration, bootParamsRepo *cloudconfig.Repo) error { logging.Log("HTTPBOOTER", "Listening on %s", listenAddr.String()) mux, err := HTTPBooterMux(listenAddr, runtimeConfig, bootParamsRepo) if err != nil { return err } return http.ListenAndServe(listenAddr.String(), mux) }
// No routine in package net to test if an address is v4 or v6? func isTCPIPv6(address *net.TCPAddr) bool { if strings.HasPrefix(address.String(), "<nil>") { return false } else { return (address.String()[0] == '[') } return false // Should never arrive here }
func (c *MembersCommand) Run(args []string) int { var detailed bool var roleFilter, statusFilter string cmdFlags := flag.NewFlagSet("members", flag.ContinueOnError) cmdFlags.Usage = func() { c.Ui.Output(c.Help()) } cmdFlags.BoolVar(&detailed, "detailed", false, "detailed output") cmdFlags.StringVar(&roleFilter, "role", ".*", "role filter") cmdFlags.StringVar(&statusFilter, "status", ".*", "status filter") rpcAddr := RPCAddrFlag(cmdFlags) if err := cmdFlags.Parse(args); err != nil { return 1 } // Compile the regexp roleRe, err := regexp.Compile(roleFilter) if err != nil { c.Ui.Error(fmt.Sprintf("Failed to compile role regexp: %v", err)) return 1 } statusRe, err := regexp.Compile(statusFilter) if err != nil { c.Ui.Error(fmt.Sprintf("Failed to compile status regexp: %v", err)) return 1 } client, err := RPCClient(*rpcAddr) if err != nil { c.Ui.Error(fmt.Sprintf("Error connecting to Serf agent: %s", err)) return 1 } defer client.Close() members, err := client.Members() if err != nil { c.Ui.Error(fmt.Sprintf("Error retrieving members: %s", err)) return 1 } for _, member := range members { // Skip the non-matching members if !roleRe.MatchString(member.Role) || !statusRe.MatchString(member.Status) { continue } addr := net.TCPAddr{IP: member.Addr, Port: int(member.Port)} c.Ui.Output(fmt.Sprintf("%s %s %s %s", member.Name, addr.String(), member.Status, member.Role)) if detailed { c.Ui.Output(fmt.Sprintf(" Protocol Version: %d", member.DelegateCur)) c.Ui.Output(fmt.Sprintf(" Available Protocol Range: [%d, %d]", member.DelegateMin, member.DelegateMax)) } } return 0 }
// Send DataItems to Zabbix server and wait for response. // Returns encountered fatal error like I/O and marshalling/unmarshalling. // Caller should inspect response (and in some situations also Zabbix server log) // to check if all items are accepted. func Send(addr *net.TCPAddr, di DataItems) (res *Response, err error) { b, err := di.Marshal() if err != nil { return } // Zabbix doesn't support persistent connections, so open/close it every time. conn, err := net.DialTCP(addr.Network(), nil, addr) if err != nil { return } defer conn.Close() _, err = conn.Write(b) if err != nil { return } buf := make([]byte, 8) _, err = io.ReadFull(conn, buf[:5]) if err != nil { return } if !bytes.Equal(buf[:5], header) { err = ErrBadHeader return } _, err = io.ReadFull(conn, buf) if err != nil { return } var datalen uint64 err = binary.Read(bytes.NewBuffer(buf), binary.LittleEndian, &datalen) if err != nil { err = ErrBadHeader return } buf = make([]byte, datalen) _, err = io.ReadFull(conn, buf) if err != nil { return } res = new(Response) err = json.Unmarshal(buf, res) if err == nil { m := infoRE.FindStringSubmatch(res.Info) if len(m) == 3 { p, _ := strconv.Atoi(m[1]) f, _ := strconv.Atoi(m[2]) res.Processed = p res.Failed = f } } return }
func CheckStatusOld(addr *net.TCPAddr, host string, port uint16) (*MinecraftStatus, time.Duration, error) { conn, err := net.DialTCP(addr.Network(), nil, addr) if err != nil { return nil, 0, fmt.Errorf("CheckStatusOld error dialing: %s", err) } defer conn.Close() status, ping, err := CheckStatusOldConn(conn, host, port) return status, ping, err }
func Serve(listenAddr net.TCPAddr, datasource *datasource.DataSource) error { logging.Log(debugTag, "Serving Rest API on %s", listenAddr) restApi := newRestServerAPI(datasource) handler, err := restApi.MakeHandler() if err != nil { return err } return http.ListenAndServe(listenAddr.String(), handler) }
func (cluster *mongoCluster) server(addr string, tcpaddr *net.TCPAddr) *mongoServer { cluster.RLock() server := cluster.servers.Search(tcpaddr.String()) cluster.RUnlock() if server != nil { return server } return newServer(addr, tcpaddr, cluster.sync, cluster.dial) }
func sendAliasBackupToPredecessor(sourceAddress, receiver *net.TCPAddr, alias string) error { var ( fail = fmt.Errorf("failed: sendAliasBackupToPredecessor(%s, %s)", receiver.String(), alias) err error ) if _, err = sendArgument(sourceAddress, receiver, "AliasBackupToPredecessor", alias); err != nil { return fmt.Errorf("%s:\n%s", fail.Error(), err.Error()) } return nil }
// Helper function to decode a *net.TCPAddr into a tuple of network and // address. Must use this since kavu/so_reuseport does not currently // support passing "tcp" to support for IPv4 and IPv6. We must pass "tcp4" // or "tcp6" explicitly. func decodeAddress(tuple *net.TCPAddr) (network, address string) { if tuple.IP.To4() != nil { network = "tcp4" } else { network = "tcp6" } address = tuple.String() return }
func deleteAliasAtPredecessor(sourceAddress, receiver *net.TCPAddr, hashOfName string) error { var ( fail = fmt.Errorf("failed: deleteAliasAtPredecessor(%s, %s)", receiver.String(), hashOfName) err error ) if _, err = sendArgument(sourceAddress, receiver, "DeleteAliasAtPredecessor", hashOfName); err != nil { return fmt.Errorf("%s:\n%s", fail.Error(), err.Error()) } return nil }
func TCPAddr(buf []byte) (net.TCPAddr, int) { var value net.TCPAddr value.IP = make([]byte, 16) copy(value.IP, buf[:16]) value.Port = int(binary.BigEndian.Uint16(buf[16:18])) return value, Size }
func ProxyRelay(port string, relays map[string]Relay) error { tcpAddr := net.TCPAddr{} tcpAddr.IP = net.ParseIP("127.0.0.1") tcpAddr.Port, _ = strconv.Atoi(port) ln, err := net.ListenTCP("tcp", &tcpAddr) if err != nil { msg := fmt.Sprintf("Proxy listener error on port %s: %s", port, err) LogWriter.Err(msg) return fmt.Errorf(msg) } msg := fmt.Sprintf("Started proxy listener on port: %s", port) LogWriter.Info(msg) defer ln.Close() for { conn, err := ln.AcceptTCP() if err != nil { msg := fmt.Sprintf("Error accepting TCP connection on port %s: %s", port, err) LogWriter.Err(msg) continue } conn.SetKeepAlive(true) if err != nil { msg := fmt.Sprintf("Error setting keep-alive on connection: %s", err) LogWriter.Err(msg) } go acceptClient(conn, relays) } return nil }
func makeNewNode(host string, port int) (*node, error) { var ( resolvedAddress *net.TCPAddr err error ) if resolvedAddress, err = net.ResolveTCPAddr("tcp", net.JoinHostPort(host, strconv.Itoa(port))); err != nil { return nil, err } newNode := new(node) newNode.SetAddress(resolvedAddress) if host == "" { return nil, ErrNotYetImplemented } else { newNode.baseKey = hashString(resolvedAddress.String()) } entries := M() newNode.fingerTable = make([]*tableEntry, entries, entries) for row := 0; row < entries; row++ { newNode.SetTableEntry(row, nil) } newNode.dataStorage = make(map[string][]byte) newNode.backupStorageOfPredecessorsData = make(map[string][]byte) newNode.backupStorageOfSuccessorsData = make(map[string][]byte) newNode.aliasStorage = make(map[string]string) newNode.backupStorageOfPredecessorsAliases = make(map[string]string) newNode.backupStorageOfSuccessorsAliases = make(map[string]string) newNode.wgs = new(waitGroups) return newNode, nil }