func receiveUDP(udpConn *net.UDPConn, rAddr *net.UDPAddr) {
b := make([]byte, 1024)
udpConn.SetReadDeadline(time.Now().Add(5 * time.Second))
n, Addr, err := udpConn.ReadFromUDP(b)
// n,err:=udpConn.Read(b)
if err != nil {
fmt.Println(err.Error())
return
}
if n > 1024 {
fmt.Println("Buff out!")
return
}
fmt.Println(udpConn.RemoteAddr().Network())
if !Addr.IP.Equal(rAddr.IP) {
fmt.Println("IP diff:%s-%s", Addr.IP.String(), rAddr.IP.String())
return
} else if Addr.Port != rAddr.Port {
fmt.Println("Port diff:%d-%d", Addr.Port, rAddr.Port)
return
}
fmt.Printf("Receive from %s:%s", udpConn.RemoteAddr().String(), b[:n])
}
// HandleFind - Receives a Find message with a list of peers in this environment
func (dht *DHTClient) HandleFind(data DHTMessage, conn *net.UDPConn) {
// This means we've received a list of nodes we can connect to
if data.Arguments != "" {
ids := strings.Split(data.Arguments, ",")
if len(ids) == 0 {
Log(Error, "Malformed list of peers received")
} else {
// Go over list of received peer IDs and look if we know
// anything about them. Add every new peer into list of peers
for _, id := range ids {
var found = false
for _, peer := range dht.Peers {
if peer.ID == id {
found = true
}
}
if !found {
var p PeerIP
p.ID = id
dht.Peers = append(dht.Peers, p)
}
}
k := 0
for _, peer := range dht.Peers {
var found = false
for _, id := range ids {
if peer.ID == id {
found = true
}
}
if found {
dht.Peers[k] = peer
k++
}
}
dht.Peers = dht.Peers[:k]
if dht.PeerChannel == nil {
dht.PeerChannel = make(chan []PeerIP)
}
dht.PeerChannel <- dht.Peers
Log(Debug, "Received peers from %s: %s", conn.RemoteAddr().String(), data.Arguments)
dht.UpdateLastCatch(data.Arguments)
}
} else {
dht.Peers = dht.Peers[:0]
}
}
func (p *Proxy) proxyUDPStream(ctx context.Context, src *net.UDPConn) {
srcRemoteAddr := src.RemoteAddr().(*net.UDPAddr)
srcLocalAddr := src.LocalAddr().(*net.UDPAddr)
route := p.routes.GetTable().Lookup(protocols.UDP,
srcRemoteAddr.IP, srcLocalAddr.IP,
uint16(srcRemoteAddr.Port), uint16(srcLocalAddr.Port))
if route == nil {
src.Close()
return
}
go func() {
dstAddr := net.UDPAddr{
IP: route.Outbound.DstIP,
Port: int(route.Outbound.DstPort),
}
dst, err := net.DialUDP("udp", nil, &dstAddr)
if err != nil {
src.Close()
return
}
dst.SetKeepAlivePeriod(10 * time.Second)
src.SetKeepAlivePeriod(10 * time.Second)
go func() {
<-ctx.Done()
src.Close()
dst.Close()
}()
go func() {
defer dst.CloseWrite()
defer src.CloseRead()
io.Copy(dst, src)
}()
go func() {
defer src.CloseWrite()
defer dst.CloseRead()
io.Copy(src, dst)
}()
}()
}
func readAndWriteUDP(r io.Reader, w io.Writer, con *net.UDPConn, ra net.Addr, verbose bool) <-chan net.Addr {
buf := make([]byte, BUFFER_LIMIT)
cAddr := make(chan net.Addr)
go func() {
defer func() {
con.Close()
cAddr <- ra
}()
for {
var bytesread int
var errRead, errWrite error
if con, ok := r.(*net.UDPConn); ok {
var addr net.Addr
bytesread, addr, errRead = con.ReadFrom(buf)
if con.RemoteAddr() == nil && ra == nil {
ra = addr
cAddr <- ra
}
} else {
bytesread, errRead = r.Read(buf)
}
if errRead != nil {
if errRead != io.EOF {
if verbose {
log.Println("READ ERROR: ", errRead)
}
}
break
}
if con, ok := w.(*net.UDPConn); ok && con.RemoteAddr() == nil {
_, errWrite = con.WriteTo(buf[0:bytesread], ra)
} else {
_, errWrite = w.Write(buf[0:bytesread])
}
if errWrite != nil {
if verbose {
log.Println("WRITE ERROR: ", errWrite)
}
return
}
}
}()
return cAddr
}
// HandleConn analyzes received connecting message and assigns received
// cliend ID if any
func (dht *DHTClient) HandleConn(data DHTMessage, conn *net.UDPConn) {
if dht.State != DHTStateConnecting && dht.State != DHTStateReconnecting {
return
}
if data.ID == "" {
Log(Error, "Empty ID was received")
return
}
if data.ID == "0" {
Log(Error, "Empty ID were received. Stopping")
return
}
dht.State = DHTStateOperating
dht.ID = data.ID
Log(Info, "Received connection confirmation from router %s",
conn.RemoteAddr().String())
Log(Info, "Received personal ID for this session: %s", data.ID)
}
func HandleUDPConnection(con *net.UDPConn, verbose bool) {
chan_remote := readAndWriteUDP(con, os.Stdout, con, nil, verbose)
ra := con.RemoteAddr()
if ra == nil {
ra = <-chan_remote
}
chan_local := readAndWriteUDP(os.Stdin, con, con, ra, verbose)
select {
case <-chan_local:
if verbose {
log.Println("Connection closed from local process")
}
case <-chan_remote:
if verbose {
log.Println("Connection closed from remote process")
}
}
}
// ListenDHT - listens for packets received from DHT bootstrap node
// Every packet is unmarshaled and turned into Request structure
// which we should analyze and respond
func (dht *DHTClient) ListenDHT(conn *net.UDPConn) {
defer conn.Close()
Log(Info, "Bootstraping via %s", conn.RemoteAddr().String())
dht.Listeners++
var failCounter = 0
for {
if dht.Shutdown {
Log(Info, "Closing DHT Connection to %s", conn.RemoteAddr().String())
conn.Close()
for i, c := range dht.Connection {
if c.RemoteAddr().String() == conn.RemoteAddr().String() {
dht.Connection = append(dht.Connection[:i], dht.Connection[i+1:]...)
}
}
break
}
var buf [512]byte
_, _, err := conn.ReadFromUDP(buf[0:])
if err != nil {
Log(Debug, "Failed to read from Discovery Service: %v", err)
failCounter++
} else {
failCounter = 0
data, err := dht.Extract(buf[:512])
if err != nil {
Log(Error, "Failed to extract a message received from discovery service: %v", err)
} else {
callback, exists := dht.ResponseHandlers[data.Command]
if exists {
Log(Trace, "DHT Received %v", data)
callback(data, conn)
} else {
Log(Debug, "Unsupported packet type received from DHT: %s", data.Command)
}
}
}
if failCounter > 1000 {
Log(Error, "Multiple errors reading from DHT")
break
}
}
dht.Listeners--
}
func dnsReqResp(name string, conn *net.UDPConn) (net.IP, error) {
//question
var ret net.IP
remote := conn.RemoteAddr().String()
header, err := dnsQdGen(name, remote)
if err != nil {
return ret, qdGenError
}
_, err = conn.Write(header)
if err != nil {
return ret, reqNetworkError
}
respBuf := make([]byte, dnsBufSize)
nread, _, err := conn.ReadFromUDP(respBuf[:dnsRespMax])
if err != nil {
return ret, respNetworkError
}
//respose
respRd := bytes.NewReader(respBuf)
dns := dnsHeader{}
err = binary.Read(respRd, binary.BigEndian, &dns)
if (dns.Flags&_QR) == 0 || err != nil {
return ret, respFormatError
}
numQd := dns.QdCount
numAn := dns.AnCount
buflen := len(respBuf)
pos := int(unsafe.Sizeof(dns))
for i := 0; i < int(numQd); i++ {
for {
n := int(respBuf[pos])
if n == 0 {
pos += 1
break
}
if n > nameLenMax {
return ret, respFormatError
}
pos += (n + 1)
if pos >= buflen {
return ret, respFormatError
}
}
pos += 4 //skip type and class
}
if pos >= nread {
return ret, respFormatError
}
for i := 0; i < int(numAn); i++ {
size := parseNameSize(respBuf, pos)
if size <= 0 {
return ret, respFormatError
}
pos += size
tp := (respBuf[pos] << 16) + respBuf[pos+1]
pos += 8 //skip type, class ttl
if pos >= nread {
return ret, respFormatError
}
dataLen := (respBuf[pos] << 16) + respBuf[pos+1]
pos += 2 //skip data len
if tp == qdTypeA && dataLen == net.IPv4len {
ret = respBuf[pos : pos+4]
return ret, nil
}
pos += int(dataLen) //skip data
if pos >= nread {
return ret, respFormatError
}
}
return ret, respNotFoundError
}
// Sends the data in sendbuf to peer_addr (with possible resends) and waits for
// an ACK with the correct block id, if sendbuf contains a DATA message.
// Returns true if the sending was successful and the ACK was received.
func sendAndWaitForAck(udp_conn *net.UDPConn, peer_addr *net.UDPAddr, sendbuf []byte, retransmissions, dups, strays *int) bool {
// absolute deadline when this function will return false
deadline := time.Now().Add(total_timeout)
readbuf := make([]byte, 4096)
*retransmissions-- // to counter the ++ being done at the start of the loop
outer:
for {
// re/send
*retransmissions++
n, err := udp_conn.Write(sendbuf)
if err != nil {
util.Log(0, "ERROR! TFTP error in Write(): %v", err)
break
}
if n != len(sendbuf) {
util.Log(0, "ERROR! TFTP: Incomplete write")
break
}
//util.Log(2, "DEBUG! TFTP: Sent %v bytes to %v. Waiting for ACK...", len(sendbuf), peer_addr)
for {
// check absolute deadline
if time.Now().After(deadline) {
break outer
}
// set deadline for next read
timo := time.Duration(rand.Int63n(int64(max_wait_retry-min_wait_retry))) + min_wait_retry
endtime2 := time.Now().Add(timo)
if endtime2.After(deadline) {
endtime2 = deadline
}
udp_conn.SetReadDeadline(endtime2)
n, from, err := udp_conn.ReadFromUDP(readbuf)
if err != nil {
e, ok := err.(*net.OpError)
if !ok || !e.Timeout() {
util.Log(0, "ERROR! TFTP ReadFromUDP() failed while waiting for ACK from %v (local address: %v): %v", udp_conn.RemoteAddr(), udp_conn.LocalAddr(), err)
break outer // retries make no sense => bail out
} else {
//util.Log(2, "DEBUG! TFTP timeout => resend %#v", sendbuf)
continue outer // resend
}
}
if from.Port != peer_addr.Port {
*strays++
emsg := fmt.Sprintf("WARNING! TFTP server got UDP packet from incorrect source: %v instead of %v", from.Port, peer_addr.Port)
sendError(udp_conn, from, 5, emsg) // 5 => Unknown transfer ID
continue // This error is not fatal since it doesn't affect our peer
}
if n == 4 && readbuf[0] == 0 && readbuf[1] == 4 && // 4 => ACK
(sendbuf[1] != 3 || // we did not send DATA
// or the ACK's block id is the same as the one we sent
(readbuf[2] == sendbuf[2] && readbuf[3] == sendbuf[3])) {
//util.Log(2, "DEBUG! TFTP: Received ACK from %v: %#v", peer_addr, readbuf[0:n])
return true
} else {
if readbuf[0] == 0 && readbuf[1] == 5 { // error
util.Log(0, "ERROR! TFTP ERROR received while waiting for ACK from %v: %v", peer_addr, string(readbuf[4:n]))
break outer // retries make no sense => bail out
} else {
// if we sent DATA but the ACK is not for the block we sent,
// increase dup counter. If we wanted to be anal we would need to check
// if the block id is one less for it to be an actual dup, but
// since the dup counter is only for reporting, we don't care.
if sendbuf[1] == 3 && (readbuf[2] != sendbuf[2] || readbuf[3] != sendbuf[3]) {
*dups++
//util.Log(2, "DEBUG! TFTP duplicate ACK received: %#v => Ignored", string(readbuf[0:n]))
// ONLY "continue", NOT "continue outer", i.e. DUPs DO NOT CAUSE A RESEND.
// THIS PREVENTS http://en.wikipedia.org/wiki/Sorcerer's_Apprentice_Syndrome
// When timeout happens, it will cause a resend.
continue
} else {
emsg := fmt.Sprintf("ERROR! TFTP server waiting for ACK from %v but got: %#v", peer_addr, string(readbuf[0:n]))
sendError(udp_conn, from, 0, emsg) // 0 => Unspecified error
break outer // retries make no sense => bail out
}
}
}
}
}
util.Log(0, "ERROR! TFTP send not acknowledged by %v (retransmissions: %v, dups: %v, strays: %v)", peer_addr, *retransmissions, *dups, *strays)
return false
}
func close(c *net.UDPConn) {
log.Printf("closing: %s -> %s", c.LocalAddr().String(), c.RemoteAddr().String())
c.Close()
}