Beispiel #1
1
func retrieveFortune(clientConn net.UDPConn, fortuneInfoMsg clientServerUtils.FortuneInfoMessage) clientServerUtils.FortuneMessage {
	//Send FortuneReqMessage to fserver
	fortuneReqMsg := clientServerUtils.FortuneReqMessage{fortuneInfoMsg.FortuneNonce}
	fortuneReq, err := json.Marshal(fortuneReqMsg)
	if err != nil {
		fmt.Println("Error marshalling fortuneReqMsg: ", err)
		os.Exit(-1)
	}

	fmt.Println("Retrieving fortune from fserver")
	fserverUDPAddr := resolveUDPAddr(fortuneInfoMsg.FortuneServer)
	_, err = clientConn.WriteToUDP(fortuneReq, &fserverUDPAddr)
	if err != nil {
		fmt.Println("Error writing to fserver: ", err)
		os.Exit(-1)
	}

	//Receive FortuneMessage reply from fserver
	var buf [1024]byte
	msgLen, err := clientConn.Read(buf[:])
	if err != nil {
		fmt.Println("Error on read: ", err)
		os.Exit(-1)
	}
	fortuneReplyStr := string(buf[0:msgLen])
	fortuneBytes := []byte(fortuneReplyStr)

	var fortune clientServerUtils.FortuneMessage
	json.Unmarshal(fortuneBytes, &fortune)
	return fortune
}
Beispiel #2
0
func (s *UdpForwardServer) handleUdpForwardLocal(conn *net.UDPConn, laddr, raddr *net.UDPAddr, data []byte) {
	lconn, err := net.ListenUDP("udp", nil)
	if err != nil {
		glog.V(LWARNING).Infof("[udp] %s -> %s : %s", laddr, raddr, err)
		return
	}
	defer lconn.Close()

	if _, err := lconn.WriteToUDP(data, raddr); err != nil {
		glog.V(LWARNING).Infof("[udp] %s -> %s : %s", laddr, raddr, err)
		return
	}
	glog.V(LDEBUG).Infof("[udp] %s >>> %s length %d", laddr, raddr, len(data))

	b := make([]byte, MediumBufferSize)
	lconn.SetReadDeadline(time.Now().Add(ReadTimeout))
	n, addr, err := lconn.ReadFromUDP(b)
	if err != nil {
		glog.V(LWARNING).Infof("[udp] %s <- %s : %s", laddr, raddr, err)
		return
	}
	glog.V(LDEBUG).Infof("[udp] %s <<< %s length %d", laddr, addr, n)

	if _, err := conn.WriteToUDP(b[:n], laddr); err != nil {
		glog.V(LWARNING).Infof("[udp] %s <- %s : %s", laddr, raddr, err)
	}
	return
}
Beispiel #3
0
func (s *UDPServer) handleCall(conn *net.UDPConn) {
	// Read and buffer UDP datagram
	b := make([]byte, MaxUdpSize)

	packetSize, callerAddr, err := conn.ReadFromUDP(b)
	if err != nil {
		s.server.log.WithField("err", err).Error("Cannot read UDP datagram")

		return
	}

	reply, err := s.server.handleRecord(b[0:packetSize])
	if err != nil {
		s.server.log.WithField("err", err).Error("handling record")
	}

	if _, err := conn.WriteToUDP(reply.Bytes(), callerAddr); err != nil {
		s.server.log.WithFields(logrus.Fields{
			"callerAddr": callerAddr.String(),
			"err":        err,
		}).Error("Cannot send reply over UDP")

		return
	}
}
Beispiel #4
0
//发出缓存
func fushCache(conn *net.UDPConn, sendAddr *net.UDPAddr) {
	cacheArray := TempChanMap[sendAddr.IP.String()]

	/*    for item := cacheArray.Front();item != nil ; item = item.Next() {
	                fmt.Print("-");
			conn.WriteToUDP(item.Value.([]byte), sendAddr)
	    }
	*/
	length := TempChanMapIndex[sendAddr.IP.String()]
	fmt.Println(length, sendAddr.IP.String())
	for i := 0; i < length; i++ {
		if len(cacheArray[i]) > 0 {
			fmt.Print("-")
			position, err := conn.WriteToUDP(cacheArray[i], sendAddr)

			checkError(err)
			if err != nil {
				fmt.Println(position)
			}
		}
	}
	/*
	   for item := cacheArray.Front();item != nil ; item = item.Next() {
	      cacheArray.Remove(item)
	      fmt.Println("remove");
	   }
	*/
	TempChanMap[sendAddr.IP.String()] = make([][]byte, 1000, 1000000)
	TempChanMapIndex[sendAddr.IP.String()] = 0
	//fmt.Println(TempChanMap,sendAddr.IP.String());

}
Beispiel #5
0
func (s ServerUdp) udpHandler(conn *net.UDPConn) {
	var buf [512]byte
	_, addr, err := conn.ReadFromUDP(buf[0:])
	if err != nil {
		log.Printf("Error: %s \n", err)
	}
	var hash int = 0
	for _, d := range buf[11:] {
		hash += int(d)
	}
	gethash, _ := strconv.Atoi(string(buf[5:10]))

	if string(buf[0:5]) == "MAGIC" && hash == gethash {
		_, err = conn.WriteToUDP([]byte("200"), addr)
		if err != nil {
			log.Printf("Error: %s \n", err)
		}
	} else {
		_, err = conn.WriteToUDP([]byte("400"), addr)
		if err != nil {
			log.Printf("Error: %s \n", err)
		}
		log.Printf("Inv UDP %s From %v:%v,Ignored\n", string(buf[0:]), addr.IP, addr.Port)
		return
	}
	log.Printf("Recv GPRMC From %v:%v\n%s\n", addr.IP, addr.Port, string(buf[0:]))
	s.Info <- buf[11:len(buf)]
}
func handleClient(conn *net.UDPConn, sb []byte) {
	var buf [256]byte
	size, addr, err := conn.ReadFromUDP(buf[0:])
	//println(size, addr)
	if err != nil {
		return
	}
	if size < 48 {
		return
	}
	sec, microsec := gettimeofday()
	vn := byteArrayToUint64(buf[0:][0:3]) & 0x38000000
	copy(sb[0:3], uint64ToByteArray(0x040106F0|vn)) // flag
	copy(sb[4:7], []byte{0, 0, 0, 0})               //delay
	copy(sb[8:11], uint64ToByteArray(0x00000010))   // dispersion
	copy(sb[12:15], []byte("LOCL"))                 // Ref ID
	copy(sb[16:19], uint64ToByteArray(sec+0x83AA7E80))
	copy(sb[20:23], []byte{0, 0, 0, 0})
	copy(sb[24:31], buf[0:][40:47])
	copy(sb[32:35], uint64ToByteArray(sec+0x83AA7E80))
	copy(sb[36:39], uint64ToByteArray((microsec/500000)*0x80000000))
	sec, microsec = gettimeofday()
	copy(sb[40:43], uint64ToByteArray(sec+0x83AA7E80))
	copy(sb[44:47], uint64ToByteArray((microsec/500000)*0x80000000))

	conn.WriteToUDP([]byte(sb), addr)
}
Beispiel #7
0
/* Constructs and sends an ACK packet over conn. */
func sendAck(conn *net.UDPConn, addr *net.UDPAddr) {
	ack := make([]byte, 4)
	copy(ack, ACK)
	//TODO copy block number
	_, err := conn.WriteToUDP(ack, addr)
	checkError(err)
}
Beispiel #8
0
func (handler *VMessInboundHandler) handlePacket(conn *net.UDPConn, request *protocol.VMessRequest, packet v2net.Packet, clientAddr *net.UDPAddr) {
	ray := handler.vPoint.DispatchToOutbound(packet)
	close(ray.InboundInput())

	responseKey := md5.Sum(request.RequestKey)
	responseIV := md5.Sum(request.RequestIV)

	buffer := alloc.NewBuffer().Clear()
	defer buffer.Release()

	responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], buffer)
	if err != nil {
		log.Error("VMessIn: Failed to create encrypt writer: %v", err)
		return
	}
	responseWriter.Write(request.ResponseHeader)

	hasData := false

	if data, ok := <-ray.InboundOutput(); ok {
		hasData = true
		responseWriter.Write(data.Value)
		data.Release()
	}

	if hasData {
		conn.WriteToUDP(buffer.Value, clientAddr)
		log.Info("VMessIn sending %d bytes to %s", buffer.Len(), clientAddr.String())
	}
}
Beispiel #9
0
func (handler *VMessInboundHandler) handlePacket(conn *net.UDPConn, request *protocol.VMessRequest, packet v2net.Packet, clientAddr *net.UDPAddr) {
	ray := handler.vPoint.DispatchToOutbound(packet)
	close(ray.InboundInput())

	responseKey := md5.Sum(request.RequestKey[:])
	responseIV := md5.Sum(request.RequestIV[:])

	buffer := bytes.NewBuffer(make([]byte, 0, bufferSize))

	response := protocol.NewVMessResponse(request)
	responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], buffer)
	if err != nil {
		log.Error("VMessIn: Failed to create encrypt writer: %v", err)
		return
	}
	responseWriter.Write(response[:])

	hasData := false

	if data, ok := <-ray.InboundOutput(); ok {
		hasData = true
		responseWriter.Write(data)
	}

	if hasData {
		conn.WriteToUDP(buffer.Bytes(), clientAddr)
		log.Info("VMessIn sending %d bytes to %s", len(buffer.Bytes()), clientAddr.String())
	}
}
Beispiel #10
0
/* Sends file data in DATA packets over conn. */
func sendData(conn *net.UDPConn, addr *net.UDPAddr, filename string) {
	input, err := os.Open(filename)
	checkError(err)

	buf := make([]byte, 512)
	for {
		n, err := input.Read(buf)
		checkError(err)

		data := make([]byte, n+4)
		copy(data, DATA)
		copy(data[4:], buf[:n])
		_, err = conn.WriteToUDP(data, addr)
		checkError(err)

		if n < len(buf) {
			finalAck := make([]byte, 4)
			for !bytes.Equal(finalAck[0:2], ACK) {
				_, _, err := conn.ReadFromUDP(finalAck)
				checkError(err)
			}

			break
		}
	}

}
Beispiel #11
0
// parseAndAck parses the UDP payload and sends anwACK to the client receiver.
// TODO(jvesuna): Keep parseAndAck routine live with a connection. Have the ackServer channel data
// to this routine for faster processing.
func parseAndAck(buf []byte, ServerConn *net.UDPConn, clientUDPAddr *net.UDPAddr) {
	messageAck := &ptpb.PingtestMessage{}
	if err := proto.Unmarshal(buf, messageAck); err != nil {
		//TODO(jvesuna): Fix this error handling.
		log.Println("error: failed to unmarshal packet in parseAndAck:", err)
	}

	if *tinyAck {
		// Don't include padding.
		// Here, messageAck should always be about the same size.
		messageAck = &ptpb.PingtestMessage{
			PingtestParams: messageAck.PingtestParams,
			Type:           messageAck.Type,
		}
	}

	wireBytesAck, err := proto.Marshal(messageAck)
	if err != nil {
		fmt.Println("error marshalling ACK:", err)
	}

	// Send ACK.
	ServerConn.SetWriteBuffer(proto.Size(messageAck))
	_, err = ServerConn.WriteToUDP(wireBytesAck, clientUDPAddr)
	if err != nil {
		log.Println("Failed to send ACK:", err)
	}
	log.Println("Sent Ack")
}
Beispiel #12
0
func SendAChunk(conn *net.UDPConn, addr *net.UDPAddr, isServer bool) {
	var n2 int
	var err error
	var datablock []byte
	//Send the chink that we have in the Block (it is either the previous one being retransmitted or a the next one
	var opcode = "\x00\x03" //Data packet
	var blocknumBytes = make([]byte, 2)
	binary.BigEndian.PutUint16(blocknumBytes, uint16(chunk.blocknum))

	datablock = append(datablock, []byte(opcode)...)
	datablock = append(datablock, blocknumBytes...)
	fmt.Println("Stage 2: Datablock ", datablock)
	if chunk.nbytes < 512 {
		// make a slice of size chunk.nbytes and copy the data into it
		tempbuf := make([]byte, chunk.nbytes)
		n1 := copy(tempbuf, chunk.buf[0:chunk.nbytes])
		fmt.Println("Copied %d bytes to the last chunk being sent", n1)
		datablock = append(datablock, tempbuf...)
	} else {
		datablock = append(datablock, chunk.buf...)
	}
	fmt.Println("sending datablock", datablock)
	if isServer {
		n2, err = conn.WriteToUDP(datablock, addr)
	} else {
		n2, err = conn.Write(datablock)
	}
	fmt.Println("Number of Bytes sent is ", n2)
	if err != nil {
		fmt.Printf("Couldn't send datablock %v", err)
	}
}
Beispiel #13
0
/**
  Handles a single UDP connection as a goroutine
*/
func udpHandler(buf []byte, b int, n int, conn *net.UDPConn, addr *net.UDPAddr) {
	defer fmt.Printf("Datagram %d sent!\n", n)

	// Slice buffer depending on read bytes, trim spaces
	clean := bytes.TrimSpace(buf[:b])

	// Decrypt incoming request []byte
	clean = decrypt(clean)

	// Parse the received JSON
	r := Request{}
	err := json.Unmarshal(clean, &r)
	if err != nil {
		fmt.Println(err)
		return
	}

	resp := findRoad(&r)

	// Convert to JSON, send over the wire
	s, err := json.Marshal(&resp)
	if err != nil {
		panic(err)
	}

	// Encrypt response []byte
	s = encrypt(s)

	conn.WriteToUDP(s, addr)
}
Beispiel #14
0
func udp_transmit_server(lconn, bconn *net.UDPConn, send_ch chan Udp_message) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("ERROR in udp_transmit_server: %s \n Closing connection.", r)
			lconn.Close()
			bconn.Close()
		}
	}()

	var err error
	var n int

	for {
		//		fmt.Printf("udp_transmit_server: waiting on new value on Global_Send_ch \n")
		msg := <-send_ch
		//		fmt.Printf("Writing %s \n", msg.Data)
		if msg.Raddr == "broadcast" {
			n, err = lconn.WriteToUDP([]byte(msg.Data), baddr)
		} else {
			raddr, err := net.ResolveUDPAddr("udp", msg.Raddr)
			if err != nil {
				fmt.Printf("Error: udp_transmit_server: could not resolve raddr\n")
				panic(err)
			}
			n, err = lconn.WriteToUDP([]byte(msg.Data), raddr)
		}
		if err != nil || n < 0 {
			fmt.Printf("Error: udp_transmit_server: writing\n")
			panic(err)
		}
		//		fmt.Printf("udp_transmit_server: Sent %s to %s \n", msg.Data, msg.Raddr)
	}
}
Beispiel #15
0
func listenUdp(c *net.UDPConn) {
	//m := make(map[string]int, 100)
	for {
		var message string

		buf := make([]byte, MAIN_BUFFER_SIZE)
		n, addr, err := c.ReadFromUDP(buf)

		if err != nil {
			log.Fatalln("error reading UDP: ", err)
			//break
		}
		message = string(buf[0:n])
		log.Println("received message from ", addr, message)

		writeSize, writeErr := c.WriteToUDP(buf, addr)
		if writeErr != nil {
			log.Fatalln("error writing UDP: ", writeErr, writeSize)
			//break
		}

		// IF this is a chat message, broadcast it:
		//h.broadcast <- message
		// TODO: IF this is a movement command, hand it to nav system
		// TODO: IF we don't recognize it, throw an error
	}
	c.Close()
}
Beispiel #16
0
func (r *Router) routePacket(pkt []byte, conn *net.UDPConn) {
	if len(pkt) < minIP4HdrSize {
		log.V(1).Infof("Packet too small (%d bytes), unable to route", len(pkt))
		return
	}

	r.mux.Lock()
	defer r.mux.Unlock()

	dstIP := ip.FromBytes(pkt[16:20])

	for i, re := range r.routes {
		if re.sn.Contains(dstIP) {
			nbytes, err := conn.WriteToUDP(pkt, re.addr)
			switch {
			case err != nil:
				log.V(1).Info("UDP send failed with: ", err)
			case nbytes != len(pkt):
				log.V(1).Infof("Was only able to UDP send %d out of %d bytes to %s: ", nbytes, len(pkt), re.addr.IP)
			}

			// packets for same dest tend to come in burst. swap to front make it faster for subsequent ones
			if i != 0 {
				r.routes[0], r.routes[i] = r.routes[i], r.routes[0]
			}
			return
		}
	}

	log.V(1).Info("No route found for ", dstIP)
}
Beispiel #17
0
func encode(udp *net.UDPConn, ack bool, topic string, payload []byte) {
	// decode the topic to determine where we're sending this
	tt := txTopicRE.FindStringSubmatch(topic)
	if len(tt) != 4 {
		log.Printf("Cannot parse MQTT message topic for transmission: %s", topic)
		return
	}
	groupId, _ := strconv.Atoi(tt[1])
	nodeId, _ := strconv.Atoi(tt[2])
	boot := tt[3] == "tb"
	unicast := nodeId > 0 && nodeId < 31
	if !unicast && nodeId != 0 {
		log.Printf("Invalid nodeId=%d in MQTT message", nodeId)
		return
	}

	// map the group_id to the appropriate UDP destination
	addr := mapGroupToAddr(byte(groupId))
	if addr == nil {
		log.Printf("No GW known for RF group %d", groupId)
		return
	}

	// Parse message payload as JSON
	var msg RFMessage
	err := json.Unmarshal(payload, &msg)
	if err != nil {
		log.Printf("Cannot parse JSON payload of MQTT message: %s", err)
		return
	}
	data, _ := base64.StdEncoding.DecodeString(msg.Base64)

	// Figure out the message type code
	var code byte
	switch {
	//case boot && msg.Kind == "pairing":     code = RF_Pairing // not sent out to nodes!
	case boot && msg.Kind == "boot" && unicast:
		code = RF_BootReply
	case !boot && ack && unicast:
		code = RF_DataReq
	case !boot && ack && !unicast:
		code = RF_BcastReq
	case !boot && !ack && unicast:
		code = RF_DataPush
	case !boot && !ack && !unicast:
		code = RF_BcastPush
	default:
		log.Printf("Invalid MQTT message combo: boot=%t kind=%s ack=%t",
			boot, msg.Kind, ack)
	}

	// actually send the packet
	buf := make([]byte, len(data)+3)
	buf[0] = code
	buf[1] = byte(groupId)
	buf[2] = byte(nodeId)
	copy(buf[3:], data)
	udp.WriteToUDP(buf, addr)
}
func forward_tap_to_phys(phys_conn *net.UDPConn, tap_conn *TapConn, peer_addr *net.UDPAddr, key []byte, chan_disc_peer chan net.UDPAddr) {
	/* Raw tap frame received */
	frame := make([]byte, TAP_MTU+14)
	/* Encapsulated frame and error */
	var enc_frame []byte
	var invalid error = nil
	/* Discovered peer */
	var disc_peer_addr net.UDPAddr

	/* Initialize our HMAC-SHA256 hash context */
	hmac_h := hmac.New(sha256.New, key)

	/* If a peer was specified, fill in our discovered peer information */
	if peer_addr != nil {
		disc_peer_addr.IP = peer_addr.IP
		disc_peer_addr.Port = peer_addr.Port
	} else {
		/* Otherwise, wait for the forward_phys_to_tap() goroutine to discover a peer */
		disc_peer_addr = <-chan_disc_peer
	}

	log.Printf("Starting tap->phys forwarding with peer %s:%d...\n", disc_peer_addr.IP, disc_peer_addr.Port)

	for {
		/* Read a raw frame from our tap device */
		n, err := tap_conn.Read(frame)
		if err != nil {
			log.Fatalf("Error reading from tap device!: %s\n", err)
		}

		if DEBUG == 2 {
			log.Println("<- tap  | Plaintext frame to peer:")
			log.Println("\n" + hex.Dump(frame[0:n]))
		}

		/* Encapsulate the frame */
		enc_frame, invalid = encap_frame(frame[0:n], hmac_h)

		/* Skip it if it's invalid */
		if invalid != nil {
			if DEBUG >= 1 {
				log.Printf("-> phys | Frame discarded! Size: %d, Reason: %s\n", n, invalid.Error())
				log.Println("\n" + hex.Dump(frame[0:n]))
			}
			continue
		}

		if DEBUG == 2 {
			log.Println("-> phys | Encapsulated frame to peer:")
			log.Println("\n" + hex.Dump(enc_frame))
		}

		/* Send the encapsulated frame to our peer through UDP */
		_, err = phys_conn.WriteToUDP(enc_frame, &disc_peer_addr)
		if err != nil {
			log.Fatalf("Error writing to UDP socket!: %s\n", err)
		}
	}
}
Beispiel #19
0
func (server *SocksServer) handlePacket(conn *net.UDPConn, packet v2net.Packet, clientAddr *net.UDPAddr) {
	ray := server.vPoint.DispatchToOutbound(packet)
	close(ray.InboundInput())

	if data, ok := <-ray.InboundOutput(); ok {
		conn.WriteToUDP(data, clientAddr)
	}
}
Beispiel #20
0
func doJob(conn *net.UDPConn, address *net.UDPAddr, buf []byte) {
	_, err := conn.WriteToUDP(buf, address)
	if err != nil {
		cntOutErr++
		fmt.Fprintf(os.Stderr, "write fail %s \n", err)
	}
	cntOut++
}
Beispiel #21
0
func myNetwork_serverSend(c *net.UDPConn, packet []byte, cAddr *net.UDPAddr) {
	if rand.Intn(4) != 10 { //25% failure rate
		c.WriteToUDP(packet, cAddr)
	} else {
		log.Println("Dropped Packet: ", packet)
	}

}
Beispiel #22
0
func WriteMessage(c *net.UDPConn, msg *Message, dst net.IP) (err os.Error) {
	out, err := msg.Marshal()
	if err != nil {
		return
	}
	_, err = c.WriteToUDP(out, &net.UDPAddr{IP: dst, Port: 67})
	return
}
Beispiel #23
0
func handleClient(conn *net.UDPConn) {
	var buf [512]byte
	_, addr, err := conn.ReadFromUDP(buf[0:])
	if err != nil {
		return
	}
	daytime := time.Now().String()
	conn.WriteToUDP([]byte(daytime), addr)
}
Beispiel #24
0
func sendReply(conn *net.UDPConn) {
	for {
		aReply := <-replyCh
		_, err := conn.WriteToUDP(aReply.data, aReply.addr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Failed to write to client: %v\n", err)
			//checkTempErr(err)
		}
	}
}
Beispiel #25
0
func send(connection *net.UDPConn, outbound chan Packet, wg *sync.WaitGroup) {
	defer wg.Done()
	for packet := range outbound {
		_, err := connection.WriteToUDP(packet.data, packet.addr)
		if err != nil {
			log.Println("Error on write: ", err)
			continue
		}
	}
}
Beispiel #26
0
// sendMsg bencodes the data in 'query' and sends it to the remote node.
func sendMsg(conn *net.UDPConn, raddr *net.UDPAddr, query interface{}) {
	totalSent.Add(1)
	var b bytes.Buffer
	if err := bencode.Marshal(&b, query); err != nil {
		return
	}
	if _, err := conn.WriteToUDP(b.Bytes(), raddr); err != nil {
		// debug.Println("DHT: node write failed:", err)
	}
	return
}
Beispiel #27
0
func (gatewayimpl *GatewayImpl) SendPullACK(conn *net.UDPConn, addr *net.UDPAddr, protocolversion byte, randomtoken uint16) error {
	out := make([]byte, 4)
	out[0] = protocolversion
	binary.LittleEndian.PutUint16(out[1:3], randomtoken)
	out[3] = byte(semtech.PullACK)
	_, err := conn.WriteToUDP(out, addr)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #28
0
func sendErrMessage(conn net.UDPConn, sendto *net.UDPAddr, errMsg clientServerUtils.ErrMessage) {
	req, err := json.Marshal(errMsg)
	if err != nil {
		fmt.Println("Error marshalling ErrMessage: ", err)
		os.Exit(-1)
	}
	_, err = conn.WriteToUDP(req, sendto)
	if err != nil {
		fmt.Println("Error writing ErrMessage to client: ", err)
	}
}
Beispiel #29
0
func SendMsg(conn *net.UDPConn, returnAddress *net.UDPAddr, msg Message) {
	b, err := msgpack.Marshal(msg)
	if err != nil {
		// do something!
	}
	bytesWritten, networkErr := conn.WriteToUDP(b, returnAddress)

	if networkErr != nil {
		log.Fatalf("FAILED TO WRITE %d BYTES. Reason: %v", bytesWritten, networkErr)
	}
}
Beispiel #30
0
func udp_transmit_server(lconn, bconn *net.UDPConn, send_ch <-chan udpMessage) {
	for {
		msg := <-send_ch
		if msg.raddr == "broadcast" {
			lconn.WriteToUDP(msg.data, baddr)
		} else {
			raddr, _ := net.ResolveUDPAddr("udp", msg.raddr)
			lconn.WriteToUDP(msg.data, raddr)
		}
	}
}