Golang UDPConn.SetDeadline方法代码示例

func newConn(sock *net.UDPConn, local, remote net.Addr, id int) *Conn {
	sock.SetDeadline(time.Time{})
	conn := &Conn{conn: sock, local: local, remote: remote, closed: false, quit: make(chan bool), tmp: make([]byte, CacheBuffSize*2), tmp2: make([]byte, CacheBuffSize), sendChan: make(chan string, 10), checkCanWrite: make(chan chan bool), readChan: make(chan cache), overTime: time.Now().Unix() + 30, fecWriteId: 0, fecSendC: 0}
	debug("create", id)
	conn.kcp = ikcp.Ikcp_create(uint32(id), conn)
	conn.kcp.Output = udp_output
	conn.SetKcp(DefaultKcpSetting())
	if *bCompress {
		conn.compressCache = make([]byte, CacheBuffSize*2)
		conn.compressSendChan = make(chan []byte, 100)
		go func() {
			for {
				select {
				case b := <-conn.compressSendChan:
					enc, er := zappy.Encode(conn.compressCache, b)
					if er != nil {
						log.Println("compress error", er.Error())
						go conn.Close()
						break
					}
					//log.Println("compress", len(b), len(enc))
					conn.conn.WriteTo(enc, conn.remote)
				case <-conn.quit:
					return
				}
			}
		}()
	}
	return conn
}

func newConn(sock *net.UDPConn, local, remote net.Addr, id int) *Conn {
	sock.SetDeadline(time.Time{})
	conn := &Conn{conn: sock, local: local, remote: remote, closed: false, quit: make(chan bool), tmp: make([]byte, 2000), tmp2: make([]byte, 2000), sendChan: make(chan string, 10), checkCanWrite: make(chan chan bool), readChan: make(chan cache)}
	debug("create", id)
	conn.kcp = ikcp.Ikcp_create(uint32(id), conn)
	conn.kcp.Output = udp_output
	ikcp.Ikcp_wndsize(conn.kcp, 128, 128)
	ikcp.Ikcp_nodelay(conn.kcp, 1, 10, 2, 1)
	return conn
}

// readInputUdp parses the buffer for UDP sockets.
func readInputUdp(conn net.UDPConn, parseChannel chan []byte, logger Logger, config *ConfigValues) {
	// config.Connection.Udp.Maxpacket is our max read

	// Large buffer to handle high UDP traffic, and manage GC pressure
	bufSize := 1 << 20
	buf := make([]byte, bufSize)
	offset := 0

	flush := func() []byte {
		parseChannel <- buf[0:offset]
		offset = 0
		return make([]byte, bufSize)
	}

	// Set initial deadline: 500ms
	sockErr := conn.SetDeadline(time.Now().Add(time.Millisecond * 500))
	if sockErr != nil {
		logger.Error.Printf("Error seting socket deadline: %s", sockErr)
		panic(sockErr)
	}

	for {
		length, err := conn.Read(buf[offset : offset+config.Connection.Udp.Maxpacket])
		if err == nil {
			// Always delimit our metrics
			buf[offset+length] = '\n'
			offset = offset + length + 1
		} else if terr, ok := err.(net.Error); ok && terr.Timeout() {
			if offset > 0 {
				buf = flush()
			}
			sockErr = conn.SetDeadline(time.Now().Add(time.Millisecond * 500))
			if sockErr != nil {
				panic(sockErr)
			}
		} else if strings.HasSuffix(err.Error(), "use of closed network connection") {
			// Go, it would be great if there was a better way to detect
			// this error...an enum?
			// Connection closed, lets wrap up and finish
			logger.Info.Printf("Stopping UDP read goroutine.")
			return
		} else {
			logger.Error.Println("UDP read error:", err)
		}

		// Full Buffer?
		if bufSize-offset <= config.Connection.Udp.Maxpacket {
			buf = flush()
		}

		// Track the number of UDP packets we read
		UdpPackets++
	}
}

func TestHandlePing_WrongNode(t *testing.T) {
	m := GetMemberlist(t)
	m.config.EnableCompression = false
	defer m.Shutdown()

	var udp *net.UDPConn
	for port := 60000; port < 61000; port++ {
		udpAddr := fmt.Sprintf("127.0.0.1:%d", port)
		udpLn, err := net.ListenPacket("udp", udpAddr)
		if err == nil {
			udp = udpLn.(*net.UDPConn)
			break
		}
	}

	if udp == nil {
		t.Fatalf("no udp listener")
	}

	// Encode a ping, wrong node!
	ping := ping{SeqNo: 42, Node: m.config.Name + "-bad"}
	buf, err := encode(pingMsg, ping)
	if err != nil {
		t.Fatalf("unexpected err %s", err)
	}

	// Send
	addr := &net.UDPAddr{IP: net.ParseIP(m.config.BindAddr), Port: m.config.BindPort}
	udp.WriteTo(buf.Bytes(), addr)

	// Wait for response
	udp.SetDeadline(time.Now().Add(50 * time.Millisecond))
	in := make([]byte, 1500)
	_, _, err = udp.ReadFrom(in)

	// Should get an i/o timeout
	if err == nil {
		t.Fatalf("expected err %s", err)
	}
}

func (sfa *SFlowAgent) feedFlowTable(conn *net.UDPConn) {
	var buf [maxDgramSize]byte
	_, _, err := conn.ReadFromUDP(buf[:])
	if err != nil {
		conn.SetDeadline(time.Now().Add(1 * time.Second))
		return
	}

	p := gopacket.NewPacket(buf[:], layers.LayerTypeSFlow, gopacket.Default)
	sflowLayer := p.Layer(layers.LayerTypeSFlow)
	sflowPacket, ok := sflowLayer.(*layers.SFlowDatagram)
	if !ok {
		return
	}

	if sflowPacket.SampleCount > 0 {
		for _, sample := range sflowPacket.FlowSamples {
			flows := flow.FlowsFromSFlowSample(sfa.flowTable, &sample, sfa.FlowProbePathSetter)
			logging.GetLogger().Debugf("%d flows captured", len(flows))
		}
	}
}

func (this *Service) P2pService(sock *net.UDPConn) {
	this.WaitGroup.AddOne()
	defer this.WaitGroup.Done()
	exitNotify := this.WaitGroup.ExitNotify()
	var buf [2048]byte
	for {
		select {
		case <-exitNotify:
			return
		default:
		}
		sock.SetDeadline(time.Now().Add(NET_READ_MAX_DATELINE))
		n, addr, err := sock.ReadFromUDP(buf[:])
		if err != nil {
			syslog.Info(err)
			continue
		}
		if n < 4 {
			syslog.Info("udp data package too small")
			continue
		}
		sid := binary.BigEndian.Uint32(buf[:4])
		this.RWMutex.RLock()
		client, ok := this.ClientMap[sid]
		this.RWMutex.RUnlock()
		if ok == false {
			syslog.Debug("client not exist!!! sid:", sid)
			continue
		}
		client.IP = util.IPToInt(addr.String())
		client.Port = uint32(addr.Port)
		if _, err := sock.WriteToUDP([]byte(addr.String()), addr); err != nil {
			syslog.Info("udp send data failed!!!", err)
			continue
		}
	}
}

// ListenUDPConn is similar to Listen, but takes an already existing
// net.UDPConn and listens for CurveCP on top of that. The CurveCP
// address is the UDPConn's LocalAddr().
//
// The main use of ListenUDPConn is to first execute a NAT-busting
// protocol on the UDPConn, and then use CurveCP to communicate with
// the peer.
func ListenUDPConn(sock *net.UDPConn, key []byte) (net.Listener, error) {
	sock.SetDeadline(time.Time{})
	return newServer(sock, key), nil
}

func newConn(sock *net.UDPConn, local, remote net.Addr) *Conn {
	sock.SetDeadline(time.Time{})
	return &Conn{sock, local, remote}
}