Esempio n. 1
0
func generator(t time.Duration) {
	for {
		var s conn.Setting
		s.GetSetting()
		if s.Isconnected {
			var k ftprotocol.KeepAlive
			k.SessionKey = []byte(s.Sessionkey)
			k.Sequence = byte(s.Sequence[0])

			//			log.Printf("session key : %X, sequence : %X\n", k.SessionKey, k.Sequence)

			//		log.Printf("send keepalive : %X", k.Message())

			var m conn.Message
			m.Messagetype = conn.REQUEST
			m.Info = hex.EncodeToString(k.Message())
			m.Status = conn.NONE

			m.InsertMessage()

			//			sequence = IncreaseSeq(sequence)

		}

		time.Sleep(time.Millisecond * time.Duration(t))
		//		time.Sleep(time.Millisecond * time.Duration(s.Writeinterval))

	}

}
Esempio n. 2
0
func IncreaseOneSequence() {
	var s conn.Setting
	s.GetSetting()
	//	log.Printf(" seq  :%x", byte(s.Sequence[0]))
	s.Sequence = string(IncreaseSeq(byte(s.Sequence[0])))
	//	log.Printf("Sequence : %s", s.Sequence)
	s.UpdateSequence()
}
Esempio n. 3
0
func (c *MesssageController) SendPwdKey() {

	messageid := ftprotocol.SCREENPRESS
	var setting conn.Setting
	setting.GetSetting()

	switch messageid {
	case ftprotocol.SCREENPRESS:
		var g ftprotocol.ScreenPress

		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		screenid, _ := c.GetInt32("screenid")
		g.ScreenID = uint32(screenid)

		coorx, _ := c.GetInt32("coorx")
		g.X = uint32(coorx)

		coory, _ := c.GetInt32("coory")
		g.Y = uint32(coory)

		//		log.Println(g)

		out := g.Message()

		//		log.Println(out)

		var m conn.Message
		m.Messagetype = conn.REQUEST
		m.Info = hex.EncodeToString(out)
		m.Status = conn.NONE
		log.Println(m.Info)

		m.InsertMessage()

		c.Ctx.WriteString("ok")

	default:
		c.Ctx.WriteString("Invalid Message")

	}

}
Esempio n. 4
0
func (c *MesssageController) UpdateSetting() {

	var s conn.Setting
	s.GetSetting()
	result := make(map[string]string)

	result["sessionkey"] = string(s.Sessionkey)
	result["sequence"] = string(s.Sequence)

	result["deviceid"] = strconv.Itoa(int(s.Deviceid))
	result["protocolver"] = s.Protocolver
	result["sessionstatus"] = strconv.Itoa(int(s.Sessionstatus))
	result["sessiontimeout"] = strconv.Itoa(int(s.Sessiontimeout))
	result["messagetimeout"] = strconv.Itoa(int(s.Messagetimeout))
	result["maxretrycount"] = strconv.Itoa(int(s.Maxretrycount))
	result["devicename"] = s.Devicename
	result["sensorbroadcastperiod"] = strconv.Itoa(int(s.Sensorbroadcastperiod))

	js, _ := json.Marshal(result)

	c.Ctx.WriteString(string(js))

}
Esempio n. 5
0
func writer(t time.Duration) {
	// get one request
	for {
		var s conn.Setting
		s.GetSetting()
		//		time.Sleep(time.Millisecond * time.Duration(s.Writeinterval))
		time.Sleep(time.Millisecond * time.Duration(t))
		if s.Isconnected {
			var m conn.Message
			err := m.GetOneRequest()
			if err != nil {
				//				log.Println("writer:", err.Error())
				continue
			}

			//			log.Printf("get one request :%v", m)

			b, _ := hex.DecodeString(m.Info)
			err = comm.Writer(b)
			if err != nil {
				log.Println(err.Error())
				continue
			}
			log.Printf("Send:%X", b)
			IncreaseOneSequence()

			if bSoftDelete {
				m.Status = conn.DELETED
				m.UpdateStatus()
			} else {
				m.DeleteMessage()
				//		log.Println("the request is deleted.")
			}
		}

	}
}
Esempio n. 6
0
func (c *MesssageController) Generate() {
	messageid, _ := strconv.ParseInt(c.GetString("messageid"), 16, 64)
	var setting conn.Setting
	setting.GetSetting()

	switch messageid {
	case ftprotocol.REQUESTSESSION:
		var rs ftprotocol.RequestSession
		//	rs.SessionKey, _ = hex.DecodeString(c.GetString("sessionkey"))

		//	rs.SessionKey = []byte(strings.ToUpper(c.GetString("sessionkey")))
		rs.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))

		//	beego.Debug("SessionKey", rs.SessionKey)
		//	rs.MessageID, _ = hex.DecodeString(c.GetString("messageid"))
		rs.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		//		beego.Debug("MessageID", rs.MessageID)
		//		rs.Sequence = byte(c.GetString("sequence")[0])
		rs.Sequence = byte(setting.Sequence[0])

		//		beego.Debug("Sequence", c.GetString("sequence"), []byte(c.GetString("sequence")))

		deviceid, _ := strconv.ParseUint(c.GetString("deviceid"), 16, 32)

		rs.DeviceID = uint32(deviceid)

		protocalver, _ := c.GetInt32("protocolver")
		rs.ProtocolVersion = uint32(protocalver)

		rs.NoAck = true

		out := rs.Message()
		//		beego.Debug(out)
		c.Ctx.WriteString(hex.EncodeToString(out))

	case ftprotocol.GETSENSOR:
		var g ftprotocol.GetSensor

		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		g.IsBroadcast, _ = c.GetBool("bbroadcastperiod")

		bpvalue, _ := c.GetInt32("broadcastperiodvalue")
		g.Broadcastperiod = uint32(bpvalue)
		g.IsAllSensorData, _ = c.GetBool("isallsensordata")

		//		log.Printf("%v, %d, %v", g.IsBroadcast, g.Broadcastperiod, g.IsAllSensorData)

		out := g.Message()
		c.Ctx.WriteString(hex.EncodeToString(out))

	case ftprotocol.KEEPALIVE:
		var ka ftprotocol.KeepAlive
		/*
			ka.SessionKey = []byte(strings.ToUpper(c.GetString("sessionkey")))
			ka.Sequence = byte(c.GetString("sequence")[0])
			ka.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		*/
		ka.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		ka.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		ka.Sequence = byte(setting.Sequence[0])

		out := ka.Message()
		//      beego.Debug(out)
		c.Ctx.WriteString(hex.EncodeToString(out))

	case ftprotocol.GETRUNTIME:
		var g ftprotocol.GetRunTime
		/*
			g.SessionKey = []byte(strings.ToUpper(c.GetString("sessionkey")))
			g.Sequence = byte(c.GetString("sequence")[0])
			g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		*/
		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		out := g.Message()
		//      beego.Debug(out)
		c.Ctx.WriteString(hex.EncodeToString(out))
	case ftprotocol.DEVICENAMEREQUEST:
		var g ftprotocol.DeviceNameRequest
		/*
			g.SessionKey = []byte(strings.ToUpper(c.GetString("sessionkey")))
			g.Sequence = byte(c.GetString("sequence")[0])
			g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		*/
		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		out := g.Message()
		//      beego.Debug(out)
		c.Ctx.WriteString(hex.EncodeToString(out))
	case ftprotocol.GETVERSIONSREQUEST:
		var g ftprotocol.GetVersionsRequest
		/*
			g.SessionKey = []byte(strings.ToUpper(c.GetString("sessionkey")))
			g.Sequence = byte(c.GetString("sequence")[0])
			g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		*/
		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		out := g.Message()
		//      beego.Debug(out)
		c.Ctx.WriteString(hex.EncodeToString(out))
	case ftprotocol.SCREENPRESS:
		var g ftprotocol.ScreenPress

		g.SessionKey = []byte(strings.ToUpper(setting.Sessionkey))
		g.MessageID = []byte(strings.ToUpper(c.GetString("messageid")))
		g.Sequence = byte(setting.Sequence[0])

		screenid, _ := c.GetInt32("screenid")
		g.ScreenID = uint32(screenid)

		coorx, _ := c.GetInt32("coorx")
		g.X = uint32(coorx)

		coory, _ := c.GetInt32("coory")
		g.Y = uint32(coory)

		log.Println(g)

		out := g.Message()

		log.Println(out)

		c.Ctx.WriteString(hex.EncodeToString(out))

	default:
		c.Ctx.WriteString("Invalid Message")

	}

	/*

		switch messageid {
		case ftprotocol.REQUESTSESSION:
			var rs ftprotocol.RequestSession
			rs.SessionKey, _ = hex.DecodeString(c.GetString("sessionkey"))
			rs.MessageID, _ = hex.DecodeString(c.GetString("messageid"))

			out := rs.Message()
			c.Ctx.WriteString(hex.EncodeToString(out))
		default:

		}
	*/
}