Golang ListenUDP示例

说明

golang listenudp示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: net

示例#1
文件: server.go 项目: sichuanyl/babylon

func ListenAndServe(addr string, port int) {
	//addr_tcp, err := net.ResolveTCPAddr("tcp", l)
	//if err != nil {
	//	panic(err)
	//}
	//listen_tcp, err := net.ListenTCP("tcp", addr_tcp)
	//if err != nil {
	//	panic(err)
	//}
	//go tcp_listen(listen_tcp)
	rtp_l := fmt.Sprintf("%v:%v", addr, port)
	rtcp_l := fmt.Sprintf("%v:%v", addr, port+1)
	addr1, err := net.ResolveUDPAddr("udp", rtp_l)
	if err != nil {
		panic(err)
	}
	listen_rtp, err := net.ListenUDP("udp", addr1)
	if err != nil {
		panic(err)
	}
	go udp_rtp_listen(listen_rtp)

	addr2, err := net.ResolveUDPAddr("udp", rtcp_l)
	if err != nil {
		panic(err)
	}
	listen_rtcp, err := net.ListenUDP("udp", addr2)
	if err != nil {
		panic(err)
	}
	go udp_rtcp_listen(listen_rtcp)
}

示例#2
文件: udp_server.go 项目: hfeeki/webrtcServer

func main() {
	//测试手动注册两个通道
	sip.GetChannel("10.2.42.197", "10.2.42.133")
	sip.GetChannel("10.2.42.133", "10.2.42.197")
	//链接WebRTC 服务
	go webrtcSocket.Init()
	//开启出测地址
	go sip.InitListener()

	//监听视频端口
	service := ":8088"
	udpAddr, err := net.ResolveUDPAddr("udp", service)
	checkError(err)
	conn, err := net.ListenUDP("udp", udpAddr)
	checkError(err)
	fmt.Println("监听端口")
	for {
		handleVideo(conn)
	}

	//监听语音端口
	go func() {
		serviceAudio := ":11113"
		udpAddrAudio, err := net.ResolveUDPAddr("udp", serviceAudio)
		checkError(err)
		connAudio, err := net.ListenUDP("udp", udpAddrAudio)
		checkError(err)

		for {
			handleAudio(connAudio)
		}
	}()

}

示例#3
文件: context_test.go 项目: rrawrriw/ite

func Test_ContextCloseFuncWithConn(t *testing.T) {

	time.Sleep(1 * time.Second)

	testResult := make(chan error)

	conns := make([]*net.UDPConn, 3)
	for x := 0; x < 3; x++ {
		a := net.UDPAddr{
			IP:   net.ParseIP("127.0.0.1"),
			Port: 12345 + x,
		}
		c, err := net.ListenUDP("udp", &a)
		if err != nil {
			t.Fatal(err.Error())
		}
		conns[x] = c
	}

	ctx := NewContextWithConn(conns)

	// Test done channel
	testTimeout := time.After(200 * time.Millisecond)
	go func() {
		select {
		case <-testTimeout:
			errMsg := "Expect to close done channel"
			testResult <- errors.New(errMsg)
		case <-ctx.DoneChan:
			testResult <- nil
		}
	}()

	ctx.Done()

	// Test if a connection not closed
	for x := 0; x < 3; x++ {
		a := net.UDPAddr{
			IP:   net.ParseIP("127.0.0.1"),
			Port: 12345 + x,
		}
		c, err := net.ListenUDP("udp", &a)
		if err != nil {
			t.Fatal(err.Error())
		}

		err = c.Close()
		if err != nil {
			t.Fatal(err.Error())
		}

	}

	err := <-testResult
	if err != nil {
		t.Fatal(err.Error())
	}

	time.Sleep(1 * time.Second)
}

示例#4
文件: udp.go 项目: helgeanl/vigilant-pancake

func Udp_init(localListenPort, broadcastListenPort, message_size int, send_ch, receive_ch chan Udp_message) (err error) {
	//Generating broadcast address
	baddr, err = net.ResolveUDPAddr("udp4", "255.255.255.255:"+strconv.Itoa(broadcastListenPort))
	if err != nil {
		return err
	}

	//Generating localaddress
	tempConn, err := net.DialUDP("udp4", nil, baddr)
	defer tempConn.Close()
	tempAddr := tempConn.LocalAddr()
	laddr, err = net.ResolveUDPAddr("udp4", tempAddr.String())
	laddr.Port = localListenPort

	//Creating local listening connections
	localListenConn, err := net.ListenUDP("udp4", laddr)
	if err != nil {
		return err
	}

	//Creating listener on broadcast connection
	broadcastListenConn, err := net.ListenUDP("udp", baddr)
	if err != nil {
		localListenConn.Close()
		return err
	}

	go udp_receive_server(localListenConn, broadcastListenConn, message_size, receive_ch)
	go udp_transmit_server(localListenConn, broadcastListenConn, send_ch)

	//	fmt.Printf("Generating local address: \t Network(): %s \t String(): %s \n", laddr.Network(), laddr.String())
	//	fmt.Printf("Generating broadcast address: \t Network(): %s \t String(): %s \n", baddr.Network(), baddr.String())
	return err
}

示例#5
文件: udp.go 项目: helgeanl/vigilant-pancake

func udpInit(localListenPort, broadcastListenPort, messageSize int, sendCh, receiveCh chan udpMessage) (err error) {
	//Generating broadcast address
	baddr, err = net.ResolveUDPAddr("udp4", "255.255.255.255:"+strconv.Itoa(broadcastListenPort))
	if err != nil {
		return err
	}

	//Generating localaddress
	tempConn, err := net.DialUDP("udp4", nil, baddr)
	defer tempConn.Close()
	tempAddr := tempConn.LocalAddr()
	laddr, err := net.ResolveUDPAddr("udp4", tempAddr.String())
	laddr.Port = localListenPort
	def.LocalIP = laddr.String()

	//Creating local listening connections
	localListenConn, err := net.ListenUDP("udp4", laddr)
	if err != nil {
		return err
	}

	//Creating listener on broadcast connection
	broadcastListenConn, err := net.ListenUDP("udp", baddr)
	if err != nil {
		localListenConn.Close()
		return err
	}
	udpConnection = true
	go udpReceiveServer(localListenConn, broadcastListenConn, messageSize, receiveCh)
	go udpTransmitServer(localListenConn, broadcastListenConn, sendCh)

	return err
}

示例#6
文件: network_handler.go 项目: powermundsen/heis

func initSockets(BROADCAST_IP string, PORTNUM_COST string, PORTNUM_ORDER string) bool {

	//Create broadcast socket for orders
	broadcast_udp_addr, err := net.ResolveUDPAddr("udp", BROADCAST_IP+PORTNUM_ORDER)
	if err != nil {
		log.Println(" ResolveUDPAddr failed", err)
	}

	broadcast_order_conn, err := net.DialUDP("udp", nil, broadcast_udp_addr)
	if err != nil {
		log.Println("Could not establish UDP connection. Enter single eleveator mode. \n", err)
		return false
	}
	broadcast_order_conn = broadcast_order_conn

	//Create broadcast socket for cost updates
	broadcast_udp_addr, err = net.ResolveUDPAddr("udp", BROADCAST_IP+PORTNUM_COST)
	if err != nil {
		log.Println("ResolveUDPAddr failed", err)
	}

	broadcast_cost_conn, err = net.DialUDP("udp", nil, broadcast_udp_addr)
	if err != nil {
		log.Println("Could not establish UDP connection. Enter single eleveator mode. \n", err)
		return false
	}
	broadcast_cost_conn = broadcast_cost_conn

	//Create receiver socket for external orders
	listen_addr, err := net.ResolveUDPAddr("udp", PORTNUM_ORDER)
	if err != nil {
		log.Println("ResolveUDPAddr failed ", err)
	}

	receive_order_conn, err := net.ListenUDP("udp", listen_addr)
	if err != nil {
		log.Println("Could not establish UDP connection. Enter single eleveator mode. \n", err)
		return false
	}
	receive_order_conn = receive_order_conn

	//Create receiver socket for cost updates
	listen_addr, err = net.ResolveUDPAddr("udp", PORTNUM_COST)
	if err != nil {
		log.Println("ResolveUDPAddr failed ", err)
	}

	receive_cost_conn, err := net.ListenUDP("udp", listen_addr)
	if err != nil {
		log.Println("Could not establish UDP connection. Enter single eleveator mode.\n", err)
		return false
	}
	receive_cost_conn = receive_cost_conn

	return true
}

示例#7
文件: skcp.go 项目: dearplain/fast-shadowsocks

func Dial(remote string) (*UDPSession, error) {
	// defer SavePanic()
	//log.Println("Dial")
	remoteAddr, err := net.ResolveUDPAddr("udp", remote)
	if err != nil {
		return nil, err
	}

	tmpSock, _err := net.ListenUDP("udp", nil)
	if _err != nil {
		return nil, _err
	}

	// 必须新建一个 否则服务端新socket发送过来的数据 会直接被丢弃 接收不到
	localSock, _err := net.ListenUDP("udp", nil)
	if _err != nil {
		return nil, _err
	}
	localAddr := localSock.LocalAddr().(*net.UDPAddr)

	//buf := make([]byte, 1500) //udp包大小不超过1400
	wbuf := make([]byte, 5)
	buf := make([]byte, 5)
	wbuf[0] = CmdCreateSession
	binary.LittleEndian.PutUint32(wbuf[1:], uint32(localAddr.Port))
	for j := 0; j < 20; j = j + 1 {
		tmpSock.WriteTo(wbuf, remoteAddr)
		tmpSock.SetReadDeadline(time.Now().Add(300 * time.Millisecond))
		n, from, err := tmpSock.ReadFromUDP(buf)
		if n >= len(buf) && from.String() == remoteAddr.String() {
			if buf[0] == CmdCreateSessionRsp {
				//log.Println("CmdCreateSessionRsp")
				tmpSock.Close()
				newAddr := net.UDPAddr{
					IP:   from.IP,
					Port: int(binary.LittleEndian.Uint32(buf[1:])),
				}
				session := newUDPSession(nil, &newAddr, localSock, localAddr)
				go session.readLoop()
				go session.updateLoop()
				return session, nil
			}
		}
		if n < 0 {
			//log.Println("dial: n < 0 ")
			tmpSock.Close()
			localSock.Close()
			return nil, err
		}
	}

	tmpSock.Close()
	localSock.Close()
	return nil, errors.New("dial: no response")
}

示例#8
文件: udp.go 项目: larskfjntnu/TTK4145ElevatorProject

/*
	This function initializes the UDP module. It sets the port for listening, broadcasting, the approved message size and the channels
	for communicating with the calling module. It returns the local IP-address of this system/module, and an error if if it fails(then ip is "").
*/
func Init(localListenPort, broadcastListenPort, messageSize int, sendChannel <-chan UDPMessage, receiveChannel chan<- UDPMessage) (localIP string, err error) {

	// Generate broadcast address
	broadcastAdress, err = net.ResolveUDPAddr(udp4, broadcastIp+strconv.Itoa(broadcastListenPort))
	if err != nil {
		log.Println("UDP:\t Could not resolve UDPAddress.")
		return "", err
	} else if debug {
		// We are in debug mode.
		log.Printf("UDP:\t Generating broadcast address:\t %s \n", broadcastAdress.String())
	}

	// Generate local address, uses the tempConnection to fetch address via the UDP dial.
	tempConnection, err := net.DialUDP(udp4, nil, broadcastAdress)
	if err != nil {
		log.Println("UDP:\t No network connection")
		return "", err
	}
	defer tempConnection.Close() // Makes sure the connection is closed when Init completes.
	tempAddress := tempConnection.LocalAddr()
	localAddress, err = net.ResolveUDPAddr(udp4, tempAddress.String())
	if err != nil {
		log.Println("UDP:\t Could not resolve local address.")
		return "", err
	} else if debug {
		log.Printf("UDP:\t Generating local address: \t%s \n", localAddress.String())
	}
	localAddress.Port = localListenPort // Set the port property of the *net.UDPAddr struct

	// Create local listening connections
	localListenConnection, err := net.ListenUDP(udp4, localAddress) // Listens for incoming UDP packets addressed to localAddress.
	if err != nil {
		log.Println("UDP:\t Couldn't create a UDP listener socket.")
		return "", err
	}
	if debug {
		log.Println("UDP:\t Created a UDP listener socket.")
	}

	// Create a listener on broadcast connection.
	broadcastListenConnection, err := net.ListenUDP(udp4, &net.UDPAddr{IP: net.IPv4(0, 0, 0, 0), Port: broadcastListenPort})
	if err != nil {
		log.Println("UDP:\t Could not create a UDP broadcast listen socket.")
		localListenConnection.Close()
		return "", err
	}
	if debug {
		log.Println("UDP:\t Created a UDP broadcast listen socket.")
	}
	// Start goroutines to handle incoming messages and sending outgoing messages.
	go udpReceiveServer(localListenConnection, broadcastListenConnection, messageSize, receiveChannel)
	go udpTransmitServer(localListenConnection, broadcastListenConnection, localListenPort, broadcastListenPort, sendChannel)
	return localAddress.IP.String(), err
}

示例#9
文件: udp_test.go 项目: lixin9311/simplevpn

func TestSecureUdp(t *testing.T) {
	data := []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
	port := ":0"
	udpAddr, err := net.ResolveUDPAddr("udp", port)
	if err != nil {
		t.Fatal(err)
	}
	ln, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		t.Fatal(err)
	}
	Addr := ln.LocalAddr()
	defer ln.Close()
	cipher, err := NewCipher("aes-256-cfb", "password")
	if err != nil {
		t.Fatal(err)
	}
	go func() {
		secureConn := NewPacketConn(ln, cipher.Copy())
		buf := make([]byte, 1500)
		n, src, err := secureConn.ReadFrom(buf)
		if err != nil {
			t.Fatal(err)
		}
		if !bytes.Equal(buf[:n], data) {
			t.Error("UDP server recieved data does not match.")
		}
		_, err = secureConn.WriteTo(buf[:n], src)
		if err != nil {
			t.Fatal(err)
		}
		return
	}()
	time.Sleep(100 * time.Millisecond)
	ln2, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		t.Fatal(err)
	}
	secureconn := NewPacketConn(ln2, cipher.Copy())
	_, err = secureconn.WriteTo(data, Addr)
	if err != nil {
		t.Fatal(err)
	}
	buf := make([]byte, 1500)
	n, _, err := secureconn.ReadFrom(buf)
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(buf[:n], data) {
		t.Error("UDP client read does not match.")
	}

}

示例#10
文件: server.go 项目: edc1591/gohome

// Constructs server structure
func newServer(iface *net.Interface) (*Server, error) {
	// Create wildcard connections (because :5353 can be already taken by other apps)
	ipv4conn, err := net.ListenUDP("udp4", mdnsWildcardAddrIPv4)
	if err != nil {
		log.Printf("[ERR] bonjour: Failed to bind to udp4 port: %v", err)
	}
	ipv6conn, err := net.ListenUDP("udp6", mdnsWildcardAddrIPv6)
	if err != nil {
		log.Printf("[ERR] bonjour: Failed to bind to udp6 port: %v", err)
	}
	if ipv4conn == nil && ipv6conn == nil {
		return nil, fmt.Errorf("[ERR] bonjour: Failed to bind to any udp port!")
	}

	// Join multicast groups to receive announcements
	p1 := ipv4.NewPacketConn(ipv4conn)
	p2 := ipv6.NewPacketConn(ipv6conn)
	if iface != nil {
		if err := p1.JoinGroup(iface, &net.UDPAddr{IP: mdnsGroupIPv4}); err != nil {
			return nil, err
		}
		if err := p2.JoinGroup(iface, &net.UDPAddr{IP: mdnsGroupIPv6}); err != nil {
			return nil, err
		}
	} else {
		ifaces, err := net.Interfaces()
		if err != nil {
			return nil, err
		}
		errCount1, errCount2 := 0, 0
		for _, iface := range ifaces {
			if err := p1.JoinGroup(&iface, &net.UDPAddr{IP: mdnsGroupIPv4}); err != nil {
				errCount1++
			}
			if err := p2.JoinGroup(&iface, &net.UDPAddr{IP: mdnsGroupIPv6}); err != nil {
				errCount2++
			}
		}
		if len(ifaces) == errCount1 && len(ifaces) == errCount2 {
			return nil, fmt.Errorf("Failed to join multicast group on all interfaces!")
		}
	}

	s := &Server{
		ipv4conn: ipv4conn,
		ipv6conn: ipv6conn,
		ttl:      3200,
	}

	return s, nil
}

示例#11
文件: client.go 项目: anlaneg/socketplane

// Client structure constructor
func newClient(iface *net.Interface, serviceChan chan<- *ServiceEntry) (*client, error) {
	// Create wildcard connections (because :5353 can be already taken by other apps)
	ipv4conn, err := net.ListenUDP("udp4", mdnsWildcardAddrIPv4)
	if err != nil {
		log.Printf("[ERR] bonjour: Failed to bind to udp4 port: %v", err)
	}
	ipv6conn, err := net.ListenUDP("udp6", mdnsWildcardAddrIPv6)
	if ipv4conn == nil && ipv6conn == nil {
		return nil, fmt.Errorf("[ERR] bonjour: Failed to bind to any udp port!")
	}

	// Join multicast groups to receive announcements from server
	p1 := ipv4.NewPacketConn(ipv4conn)
	p2 := ipv6.NewPacketConn(ipv6conn)
	if iface != nil {
		if err := p1.JoinGroup(iface, &net.UDPAddr{IP: mdnsGroupIPv4}); err != nil {
			return nil, err
		}
		if err := p2.JoinGroup(iface, &net.UDPAddr{IP: mdnsGroupIPv6}); err != nil {
			return nil, err
		}
	} else {
		ifaces, err := net.Interfaces()
		if err != nil {
			return nil, err
		}
		errCount1, errCount2 := 0, 0
		for _, iface := range ifaces {
			if err := p1.JoinGroup(&iface, &net.UDPAddr{IP: mdnsGroupIPv4}); err != nil {
				errCount1++
			}
			if err := p2.JoinGroup(&iface, &net.UDPAddr{IP: mdnsGroupIPv6}); err != nil {
				errCount2++
			}
		}
		if len(ifaces) == errCount1 && len(ifaces) == errCount2 {
			return nil, fmt.Errorf("Failed to join multicast group on all interfaces!")
		}
	}

	c := &client{
		lookupParams: make(map[string]*LookupParams),
		serviceChan:  serviceChan,
		ipv4conn:     ipv4conn,
		ipv6conn:     ipv6conn,
		closedCh:     make(chan bool),
	}

	return c, nil
}

示例#12
文件: transportUDP.go 项目: thomasberger/gortp

// ListenOnTransports listens for incoming RTP and RTCP packets addressed
// to this transport.
//
func (tp *TransportUDP) ListenOnTransports() (err error) {
	tp.dataConn, err = net.ListenUDP(tp.localAddrRtp.Network(), tp.localAddrRtp)
	if err != nil {
		return
	}
	tp.ctrlConn, err = net.ListenUDP(tp.localAddrRtcp.Network(), tp.localAddrRtcp)
	if err != nil {
		tp.dataConn.Close()
		tp.dataConn = nil
		return
	}
	go tp.readDataPacket()
	go tp.readCtrlPacket()
	return nil
}

示例#13
文件: sender.go 项目: valm0unt/udpsender

func InitSendService(speed int64, from string, to string) (service *SendService, err error) {
	service = new(SendService)
	service.speed = speed

	addr, err := net.ResolveUDPAddr("udp4", from)
	if err != nil {
		return nil, err
	}
	service.addr, err = net.ResolveUDPAddr("udp4", to)
	if err != nil {
		return nil, err
	}
	service.conn, err = net.ListenUDP("udp4", addr)
	if err != nil {
		return nil, err
	}

	// conn, err := net.Dial("udp", "127.0.0.1:12345")

	// if err != nil {
	// 	panic(err)
	// }

	// service.conn = conn

	return service, nil
}

示例#14
文件: discover.go 项目: JoeX2/syncthing

func NewDiscoverer(id string, port int, extPort int, extServer string) (*Discoverer, error) {
	local4 := &net.UDPAddr{IP: net.IP{0, 0, 0, 0}, Port: AnnouncementPort}
	conn, err := net.ListenUDP("udp4", local4)
	if err != nil {
		return nil, err
	}

	disc := &Discoverer{
		MyID:             id,
		ListenPort:       port,
		BroadcastIntv:    30 * time.Second,
		ExtListenPort:    extPort,
		ExtBroadcastIntv: 1800 * time.Second,

		conn:      conn,
		registry:  make(map[string]string),
		extServer: extServer,
	}

	go disc.recvAnnouncements()

	if disc.ListenPort > 0 {
		disc.sendAnnouncements()
	}
	if len(disc.extServer) > 0 && disc.ExtListenPort > 0 {
		disc.sendExtAnnouncements()
	}

	return disc, nil
}

示例#15
文件: server.go 项目: paulhammond/statsp

// Listen creates a UDP server that parses statsd data into metrics and
// sends them over a channel.
func Listen(addr string, c chan Packet, clean bool) {
	cleaner := NewCleaner()
	laddr, err := net.ResolveUDPAddr("udp", addr)
	if err != nil {
		log.Fatalln("fatal: failed to resolve address", err)
	}
	conn, err := net.ListenUDP("udp", laddr)
	if err != nil {
		log.Fatalln("fatal: failed to listen", err)
	}
	for {
		buf := make([]byte, 1452)
		n, raddr, err := conn.ReadFrom(buf[:])
		t := time.Now().UTC()
		if err != nil {
			log.Println("error: Failed to recieve packet", err)
		} else {
			metrics, err := Parse(buf[0:n])
			if err != nil {
				log.Println("error: Failed to recieve packet", err)
			}
			if metrics != nil {
				var p Packet
				if clean {
					cleaned := cleaner.CleanMetrics(*metrics)
					p = Packet{&cleaned, raddr, t}
				} else {
					p = Packet{metrics, raddr, t}
				}

				c <- p
			}
		}
	}
}

示例#16
文件: radius.go 项目: hoffoo/go-radius

// Open a udp connection on addr, and loop input in a goroutine
func (s *Server) listen(addr string) error {
	udpAddr, err := net.ResolveUDPAddr("udp", addr)

	if err != nil {
		return err
	}

	s.conn, err = net.ListenUDP("udp", udpAddr)

	if err != nil {
		return err
	}

	// loop reading
	go func() {
		for {
			buff := make([]byte, 1024)
			n, addr, err := s.conn.ReadFromUDP(buff)
			if s.open {
				*s.in <- Packet{buff, n, addr, err}
			} else {
				close(*s.in)
				return
			}
		}
	}()

	return nil
}

示例#17
文件: main.go 项目: uovobw/usss

func main() {
	flag.Parse()

	go gResolver(*dnsname, *ttl)

	laddr, err := net.ResolveUDPAddr("udp4", fmt.Sprintf("%s:%d", *bindaddr, *inport))
	if err != nil {
		log.Printf("Cannot resolve %s:%d: %s", *bindaddr, *inport, err)
		return
	}
	conn, err := net.ListenUDP("udp4", laddr)
	if err != nil {
		log.Printf("Cannot listen on %s: %s", laddr, err)
		return
	}
	for {
		b := make([]byte, 1500)
		_, _, _, raddr, err := conn.ReadMsgUDP(b, nil)
		if err != nil {
			log.Printf("error reading udp message: %s", err)
			return
		}
		log.Printf("got packet from: %s", raddr)
		go gHandleUdpPacket(b)
	}
}

示例#18
文件: statsd.go 项目: skwong2/telegraf

// udpListen starts listening for udp packets on the configured port.
func (s *Statsd) udpListen() error {
	address, _ := net.ResolveUDPAddr("udp", s.ServiceAddress)
	listener, err := net.ListenUDP("udp", address)
	if err != nil {
		log.Fatalf("ERROR: ListenUDP - %s", err)
	}
	defer listener.Close()
	log.Println("Statsd listener listening on: ", listener.LocalAddr().String())

	for {
		select {
		case <-s.done:
			return nil
		default:
			buf := make([]byte, 1024)
			n, _, err := listener.ReadFromUDP(buf)
			if err != nil {
				log.Printf("ERROR: %s\n", err.Error())
			}

			lines := strings.Split(string(buf[:n]), "\n")
			for _, line := range lines {
				line = strings.TrimSpace(line)
				if line != "" {
					select {
					case s.in <- line:
					default:
						log.Printf(dropwarn, line)
					}
				}
			}
		}
	}
}

示例#19
文件: resolver.go 项目: jwhonce/docker

func (r *resolver) SetupFunc(port int) func() {
	return (func() {
		var err error

		// DNS operates primarily on UDP
		addr := &net.UDPAddr{
			IP:   net.ParseIP(r.listenAddress),
			Port: port,
		}

		r.conn, err = net.ListenUDP("udp", addr)
		if err != nil {
			r.err = fmt.Errorf("error in opening name server socket %v", err)
			return
		}

		// Listen on a TCP as well
		tcpaddr := &net.TCPAddr{
			IP:   net.ParseIP(r.listenAddress),
			Port: port,
		}

		r.tcpListen, err = net.ListenTCP("tcp", tcpaddr)
		if err != nil {
			r.err = fmt.Errorf("error in opening name TCP server socket %v", err)
			return
		}
		r.err = nil
	})
}

示例#20
文件: udp.go 项目: rugby110/statsdaemon

// Listener receives packets from the udp buffer, parses them and feeds both the Metrics channel
// as well as the metricAmounts channel
func Listener(listen_addr, prefix_internal string, output *common.Output, parse parseLineFunc) {
	address, err := net.ResolveUDPAddr("udp", listen_addr)
	if err != nil {
		log.Fatalf("ERROR: Cannot resolve '%s' - %s", listen_addr, err)
	}

	listener, err := net.ListenUDP("udp", address)
	if err != nil {
		log.Fatalf("ERROR: ListenUDP - %s", err)
	}
	defer listener.Close()
	log.Printf("listening on %s", address)

	message := make([]byte, MaxUdpPacketSize)
	for {
		n, remaddr, err := listener.ReadFromUDP(message)
		if err != nil {
			log.Printf("ERROR: reading UDP packet from %+v - %s", remaddr, err)
			continue
		}

		for _, p := range ParseMessage(message[:n], prefix_internal, output, parse) {
			output.Metrics <- p
			output.MetricAmounts <- common.MetricAmount{p.Bucket, p.Sampling}
		}
	}
}

示例#21
文件: backup.go 项目: quentingmb/RealTimeProg

func main() {

	udpAddr, err := net.ResolveUDPAddr("udp", ":20014")
	if err != nil {
		log.Fatal(err)
	}

	udpListen, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		log.Fatal(err)
	}

	backupvalue := backup(udpListen)
	fmt.Println(backupvalue)

	udpListen.Close()

	udpAddr, err = net.ResolveUDPAddr("udp", "129.241.187.255:20014")
	if err != nil {
		log.Fatal(err)
	}

	udpBroadcast, err := net.DialUDP("udp", nil, udpAddr)
	if err != nil {
		log.Fatal(err)
	}

	primary(backupvalue, udpBroadcast)

	udpBroadcast.Close()

}

示例#22
文件: main.go 项目: hycxa/gonet

//----------------------------------------------- Stats Server start
func main() {
	defer func() {
		if x := recover(); x != nil {
			log.Println("caught panic in main()", x)
		}
	}()

	config := cfg.Get()
	// start logger
	if config["stats_log"] != "" {
		cfg.StartLogger(config["stats_log"])
	}

	log.Println("Starting Stats Server")
	go SignalProc()
	go SysRoutine()

	// Listen
	service := DEFAULT_SERVICE
	if config["stats_service"] != "" {
		service = config["stats_service"]
	}

	log.Println("Stats Service:", service)
	udpAddr, err := net.ResolveUDPAddr("udp", service)
	checkError(err)

	udpconn, err := net.ListenUDP("udp", udpAddr)
	checkError(err)

	log.Println("Stats Server OK.")
	handleClient(udpconn)
}

示例#23
文件: UDP.go 项目: redbullnerd/elevator2

func listenImAlive() {
	service := broadcast + ":" + UDPport
	addr, err := net.ResolveUDPAddr("udp4", service)
	if err != nil {
		fmt.Println("net.ResolveUDPAddr error in listenImAlive: ", err)
		internal.setupFail <- true
	}

	isalivesocket, err := net.ListenUDP("udp4", addr)
	if err != nil {
		fmt.Println("net.ListenUDP error in listenImAlive: ", err)
		internal.setupFail <- true
	}
	var data [512]byte

	for {
		select {
		case <-internal.quitlistenImAlive:
			return
		default:
			_, senderAddr, err := isalivesocket.ReadFromUDP(data[0:])
			if err != nil {
				fmt.Println("ReadFromUDP error in listenImAlive: ", err)
			}
			if localIP != senderAddr.IP.String() {
				if err != nil {
					fmt.Println("read error in listenImAlive")
				} else {
					remoteElev := senderAddr.IP.String()
					internal.isAlivechan <- remoteElev
				}
			}
		}
	}
}

示例#24
文件: dogstatsd_test.go 项目: CNDonny/scope

func TestMetricSink(t *testing.T) {
	udpAddr, err := net.ResolveUDPAddr("udp", DogStatsdAddr)
	if err != nil {
		t.Fatal(err)
	}
	server, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		t.Fatal(err)
	}
	defer server.Close()

	buf := make([]byte, 1024)

	for _, tt := range MetricSinkTests {
		dog := MockNewDogStatsdSink(DogStatsdAddr, tt.Tags, tt.PropagateHostname)
		method := reflect.ValueOf(dog).MethodByName(tt.Method)
		method.Call([]reflect.Value{
			reflect.ValueOf(tt.Metric),
			reflect.ValueOf(tt.Value)})

		n, _ := server.Read(buf)
		msg := buf[:n]
		if string(msg) != tt.Expected {
			t.Fatalf("Line %s does not match expected: %s", string(msg), tt.Expected)
		}
	}
}

示例#25
文件: decoder_v9_test.go 项目: gitter-badger/go-netflow

func ExampleV9Decoder() {
	// Boiler plate UDP server
	addr, _ := net.ResolveUDPAddr("udp", ":2055")
	server, _ := net.ListenUDP("udp", addr)

	// This is our decoder
	decoder := NewDecoder()

	// Shared cache for all decoders and sources
	cache := make(V9TemplateCache)

	// Forever receive messages from the network
	for {
		var msg = make([]byte, 8192)
		if _, _, err := server.ReadFromUDP(msg); err == nil {
			if d, err := decoder.Decode(msg); err != nil {
				if v9, ok := d.(*V9Decoder); ok {
					v9.Cache = cache
				}

				// Now use d.Next() or feed trough d.Flows()
			}
		}
	}
}

示例#26
文件: services.go 项目: karlitxo/tgres

func (g *statsdUdpTextServiceManager) Start(file *os.File) error {
	var (
		err     error
		udpAddr *net.UDPAddr
	)

	if config.StatsdUdpListenSpec != "" {
		if file != nil {
			g.conn, err = net.FileConn(file)
		} else {
			udpAddr, err = net.ResolveUDPAddr("udp", config.StatsdUdpListenSpec)
			if err == nil {
				g.conn, err = net.ListenUDP("udp", udpAddr)
			}
		}
	} else {
		log.Printf("Not starting Statsd UDP protocol because statsd-udp-listen-spec is blank.")
		return nil
	}
	if err != nil {
		return fmt.Errorf("Error starting Statsd UDP Text Protocol serviceManager: %v", err)
	}

	fmt.Printf("Statsd UDP protocol Listening on %s\n", config.StatsdTextListenSpec)

	// for UDP timeout must be 0
	go handleStatsdTextProtocol(g.t, g.conn, 0)

	return nil
}

示例#27
文件: watchdog.go 项目: hagna/watchdog

func (s *Server) ListenAndServe() error {
	uaddr, err := net.ResolveUDPAddr("udp", s.Addr)
	if err != nil {
		return err
	}
	conn, err := net.ListenUDP("udp", uaddr)
	if err != nil {
		return err
	}
	defer conn.Close()
	log.Println("listening on", uaddr)
	newmsg := make(chan Message)
	go messageReceiver(s, newmsg)
	for {
		b := make([]byte, 1024)
		n, addr, err := conn.ReadFrom(b)
		if err != nil {
			log.Println("error %v", err)
			continue
		}
		heartbeat := Message{From: addr.String()}
		b = bytes.TrimLeft(b[:n], "\n")
		heartbeat.extract(b) // remove newline
		newmsg <- heartbeat
	}

}

示例#28
文件: syslog_producer.go 项目: pkoro/go-kafka

func (this *SyslogProducer) startUDPServer() {
	Trace(this, "Starting UDP server")
	udpAddr, err := net.ResolveUDPAddr("udp", this.config.UDPAddr)
	if err != nil {
		panic(err)
	}

	connection, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		panic(err)
	}
	closeChannel := make(chan bool, 1)
	this.closeChannels = append(this.closeChannels, closeChannel)

	go func() {
		for {
			select {
			case <-closeChannel:
				return
			default:
			}

			this.scan(connection)
		}
	}()
	Infof(this, "Listening for messages at UDP %s", this.config.UDPAddr)
}

示例#29
文件: main.go 项目: cyfdecyf/iidr

func main() {
	theCache = cache.New(time.Hour, time.Minute)

	var err error
	server, err = net.ResolveUDPAddr("udp", "208.67.220.220:53")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Can't resolve server address: %v\n", err)
		os.Exit(1)
	}

	addr, err := net.ResolveUDPAddr("udp", "0.0.0.0:53")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Can't resolve service address: %v\n", err)
		os.Exit(1)
	}
	conn, err := net.ListenUDP("udp", addr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Can't listen on udp port: %v\n", err)
		os.Exit(1)
	}

	replyCh = make(chan *reply)
	go sendReply(conn)

	for {
		reqData := make([]byte, 2048)
		nr, client, err := conn.ReadFromUDP(reqData)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Failed to read from client: %v\n", err)
			//checkTempErr(err)
			continue
		}
		go proxyClientDNS(reqData[:nr], client)
	}
}

示例#30
文件: inputs.go 项目: hellcoderz/heka

func (self *UdpInput) Init(config interface{}) error {
	self.config = config.(*UdpInputConfig)
	if len(self.config.Address) > 3 && self.config.Address[:3] == "fd:" {
		// File descriptor
		fdStr := self.config.Address[3:]
		fdInt, err := strconv.ParseUint(fdStr, 0, 0)
		if err != nil {
			log.Println(err)
			return fmt.Errorf("Invalid file descriptor: %s", self.config.Address)
		}
		fd := uintptr(fdInt)
		udpFile := os.NewFile(fd, "udpFile")
		self.listener, err = net.FileConn(udpFile)
		if err != nil {
			return fmt.Errorf("Error accessing UDP fd: %s\n", err.Error())
		}
	} else {
		// IP address
		udpAddr, err := net.ResolveUDPAddr("udp", self.config.Address)
		if err != nil {
			return fmt.Errorf("ResolveUDPAddr failed: %s\n", err.Error())
		}
		self.listener, err = net.ListenUDP("udp", udpAddr)
		if err != nil {
			return fmt.Errorf("ListenUDP failed: %s\n", err.Error())
		}
	}
	return nil
}

展开阅读全文