Пример #1
0
// listen to incoming UDP data using the given hostport, used on server side
func (h *networkUtility) listen(hostport string) error {
	serverAddr, err := lspnet.ResolveUDPAddr("udp", hostport)
	if err != nil {
		return nil
	}
	conn, err := lspnet.ListenUDP("udp", serverAddr)
	if err != nil {
		return err
	}
	h.conn = conn
	return nil
}
Пример #2
0
func (now *Connect) listen(hostport string) error {
	serverAddr, err := lspnet.ResolveUDPAddr("udp", hostport)
	if err != nil {
		return nil
	}
	conn, err := lspnet.ListenUDP("udp", serverAddr)
	if err != nil {
		return err
	}
	now.conn = conn
	now.addr = serverAddr
	return nil
}
func (s *server) StartListen(port string) error {
	uAddr, err := lspnet.ResolveUDPAddr("udp", ":"+port)
	if err != nil {
		fmt.Println("Unable to resolve UDP addr ", port)
		return err
	}
	s.sConn, err = lspnet.ListenUDP("udp", uAddr)
	if err != nil {
		fmt.Println("Unable to listen on port ", port)
		return err
	}

	go s.handleMessages()
	go s.ticking()

	for {
		select {
		case <-s.quitAllChan:
			fmt.Println("server quit listener")
			return nil
		default:
			// read a msg from UDP and check its type
			buf := make([]byte, 2000)
			n, addr, err := s.sConn.ReadFromUDP(buf)
			if err != nil {
				return err
			}
			msg := Message{}
			json.Unmarshal(buf[0:n], &msg)
			switch msg.Type {
			case MsgConnect:
				// receive a conn msg from client
				s.addChan <- addr
			case MsgData:
				// add to data channel if hash match, drop otherwise
				if hex.EncodeToString(calMD5Hash(msg)) == hex.EncodeToString(msg.Hash) {
					s.dataChan <- &msg
				} else {
					fmt.Println("Hash does not match")
				}
			case MsgAck:
				s.ackChan <- &msg
			}
		}
	}
	return err
}
Пример #4
0
func NewFixedSizeUDPServer(maxMsgSize int, port int) (UDPServer, error) {
	addr, err := net.ResolveUDPAddr("udp4", fmt.Sprintf(":%v", port))
	if err != nil {
		return nil, err
	}

	conn, err := net.ListenUDP("udp", addr) // non-blocking. no need to wait for any client to establish a connection like TCP does
	if err != nil {
		return nil, err
	}

	return &FixedSizeUDPServer{
		maxMsgSize: maxMsgSize,
		addr:       addr,
		conn:       conn,
		closed:     false,
	}, nil
}
Пример #5
0
// NewServer creates, initiates, and returns a new server. This function should
// NOT block. Instead, it should spawn one or more goroutines (to handle things
// like accepting incoming client connections, triggering epoch events at
// fixed intervals, synchronizing events using a for-select loop like you saw in
// project 0, etc.) and immediately return. It should return a non-nil error if
// there was an error resolving or listening on the specified port number.
func NewServer(port int, params *Params) (Server, error) {
	s := &server{
		nextConnectId:      1,
		clients:            make(map[int]*abstractClient),
		readFromClientChan: make(chan *msgPackage),
		writeToClientChan:  make(chan *Message),
		readRequest: &requestRead{
			ask:      make(chan int),
			response: make(chan *Message),
		},
		writeRequest: &requestWrite{
			ask:      make(chan []byte),
			connId:   make(chan int),
			response: make(chan error),
		},
		readList:  list.New(),
		writeList: list.New(),

		flag: false,

		// variables for window size
		windowSize:  params.WindowSize,
		mapNeedSend: list.New(),

		// variables for epoch
		epochChan:   make(chan int),
		epochMillis: params.EpochMillis,
		epochLimit:  params.EpochLimit,

		// close
		deleteClient: make(chan int),
		closeConnRequest: &requestCloseConn{
			ask:      make(chan int),
			getError: make(chan error),
		},
		waitToWriteFinish: false,
		writeFinished:     make(chan int),
		waitToAckFinish:   false,
		ackFinished:       make(chan int),
		closeRead:         make(chan int, 1),
		closeEpoch:        make(chan int, 1),
		closeEvent:        make(chan int, 1),

		// close conn
		closeConn: make(chan int, 1),
	}

	// start server
	addr, err := lspnet.ResolveUDPAddr("udp", "localhost:"+strconv.Itoa(port))
	if err != nil {
		return nil, err
	}

	conn, err := lspnet.ListenUDP("udp", addr)
	if err != nil {
		return nil, err
	}

	s.conn = conn
	go s.readMessage()
	go s.handleMessage()
	go s.epochFire()

	fmt.Println("new server")
	return s, nil
}