Esempio n. 1
0
func (s *KFServer) startServer() bool {
	ret := s.handle.Start(&s.proc)
	if !ret {
		jklog.Lfile().Errorln("failed start server.")
		return false
	}

	for {
		jklog.L().Infoln("wait accept. ")
		jklog.Lfile().Infoln("wait accept. ")
		c := s.handle.Accept(&s.proc)
		if c == nil {
			jklog.Lfile().Errorln("accept failed.")
			return false
		}

		item := &sv.JKServerProcessItem{}
		item.Conn = c
		item.ReadDone = make(chan bool)
		go s.dealResponse(s.proc, item)
		go func() bool {
			for {
				_, err := s.handle.Read(&s.proc, item)
				if err != nil {
					item.ReadDone <- false
					return false
				}
			}
			return true
		}()
	}
	jklog.Lfile().Errorln("Program return for failed start.")

	return true
}
Esempio n. 2
0
func (s *KFServer) dealResponse(proc sv.JKServerProcess, item *sv.JKServerProcessItem) {
	for {
		jklog.Lfile().Infoln("wait response of read result.")
		ret := <-item.ReadDone

		/*
			now := time.Now().Unix()
			if item.TimeLast == 0 {
				item.TimeLast = now
			}
			if now-item.TimeLast > 5 {
				// 5 seconds
				continue
			}
			item.TimeLast = now
		*/
		if ret {
			jklog.Lfile().Debugln("response of deal ", item.RemoteAddr)
			// jklog.L().Debugln("data is : ", string(item.Data))
			s.dealResponseCmd(string(item.Data), item)
		} else {
			jklog.Lfile().Errorln("read response failed ", item.RemoteAddr)
			break
		}
	}
}
Esempio n. 3
0
func (newser *JKNewServer) Accept(proc *JKServerProcess) net.Conn {
	acp, err := proc.Listen.Accept()
	if err != nil {
		jklog.Lfile().Errorln("accept failed. ", err)
		return nil
	}
	jklog.Lfile().Debugln("got accept from: ", acp.RemoteAddr().String())
	return acp
}
Esempio n. 4
0
func (newser *JKNewServer) Read(proc *JKServerProcess, procItem *JKServerProcessItem) (int, error) {
	servItem := procItem

	remAddr := procItem.Conn.RemoteAddr().String()
	servItem.RemoteAddr = remAddr

	proc.addItem(servItem)

	jklog.L().Debugln("first read first bytes.")
	// first read 4 bytes for length.
	buflen := make([]byte, 4)
	_, err := procItem.Conn.Read(buflen)
	if err != nil {
		jklog.Lfile().Errorln("read failed of first read. ", err)
		return 0, err
	}
	datalen := int(BytesToInt(buflen))
	jklog.L().Debugln("length of after data: ", datalen)

	readbuf := make([]byte, datalen)
	lenbuf := 0

	jklog.L().Debugln("goto read data from : ", remAddr)
	for {
		if lenbuf >= datalen {
			procItem.ReadDone <- true
			break
		}
		buf := make([]byte, 1024)
		n, err := procItem.Conn.Read(buf)
		if err == io.EOF {
			jklog.Lfile().Infoln("EOF of read.")
			break
		}
		if err != nil {
			jklog.Lfile().Errorln("read data failed: ", err)
			return 0, err
		}

		copy(readbuf[lenbuf:lenbuf+n], buf[0:n])
		lenbuf += n

		servItem.Data = readbuf
	}
	// procItem.ReadDone <- true
	jklog.L().Infoln("data from ", procItem.RemoteAddr, " with len ", lenbuf)
	return lenbuf, nil
}
Esempio n. 5
0
func (ser *JKServerProcess) listenLocalTCP(port int) bool {
	str := JK_NET_ADDRESS_LOCAL + ":" + fmt.Sprintf("%d", port)
	jklog.L().Debugln("start to listen : ", str)
	nt, err := net.ResolveTCPAddr("tcp", str)
	if err != nil {
		jklog.Lfile().Errorln("error resolve: ", err)
		return false
	}

	lis, err := net.ListenTCP("tcp", nt)
	if err != nil {
		jklog.Lfile().Errorln("error listen: ", err)
		return false
	}
	ser.Listen = lis

	return true
}
Esempio n. 6
0
func (s *KFServer) dealResponseCmd(data string, item *sv.JKServerProcessItem) {
	p := ParseJKProtocol(data)

	if p != nil {
		if p.Command() == JK_PROTOCOL_CMD_REGISTER {
			retstr := p.GenerateResponseOK()
			item.Conn.Write([]byte(retstr))
		} else if p.Command() == JK_PROTOCOL_CMD_CONTROL && p.SubCommand() == JK_PROTOCOL_CMD_SAVEFILE {
			jklog.Lfile().Infoln("command with savefile.")
			filename, fdata := p.ParseFilenameData()
			ret := JKSaveFileData(p.ID(), filename, fdata)
			if ret {
				retstr := p.GenerateResponseOK()
				item.Conn.Write([]byte(retstr))
			} else {
				retstr := p.GenerateResponseFail()
				item.Conn.Write([]byte(retstr))
			}
		}
	}
}