Exemple #1
0
func loop() {
	body := make([]byte, 1024)
	// TODO using http client request the device
	var request, response common.Message
	for i := 0; i < 3600*1000; i++ {
		request.Header.PayloadLen = uint16(rand.Intn(30) + 1)
		request.Header.Version = 123
		request.Header.MsgCode = common.ZC_CODE_ZDESCRIBE
		request.Header.MsgId = uint8(i + 101)
		var j uint16
		for j = 0; j < request.Header.PayloadLen; j++ {
			body[j] = byte(j + 1)
		}
		old := time.Now().UTC()
		request.Payload = body[:request.Header.PayloadLen]
		fmt.Println("Write Request:", request.Header, body[:request.Header.PayloadLen])
		// check the message
		if response.Header.MsgCode != common.ZC_CODE_ERR {
			fmt.Println("Read Response:", response.Header, body[:response.Header.PayloadLen])
			for j = 0; j < response.Header.PayloadLen; j++ {
				common.Assert(response.Payload[j] == body[j], "check the response failed")
			}
			fmt.Println("request timeused:", request.Header.MsgId, old, time.Now().UTC())
		} else {
			fmt.Println("Send Request to Device Failed")
		}
		time.Sleep(time.Millisecond * 50)
	}
}
func (this *GatewayServiceHandler) handleForwardRequest(req *zc.ZMsg, resp *zc.ZMsg) {
	domain := req.GetString("domain")
	subDomain := req.GetString("submain")
	deviceId := req.GetString("deviceid")
	Conn, find := this.device.Find(*server.NewDeviceGID(domain, subDomain, deviceId))
	if !find || Conn == nil {
		resp.SetErr(common.ErrDeviceForward.Error())
		log.Warningf("the device gateway not find:gid[%s:%s:%s]", domain, subDomain, deviceId)
		return
	}
	// convert the request to message by loading by so
	var request common.Message
	request.Header.Version = 1
	request.Header.MsgId = 1
	request.Header.MsgCode = 123
	payload, _ := req.GetPayload()
	request.Header.PayloadLen = uint16(len(payload))
	request.Payload = payload

	// receive the device response result
	result := make(chan common.Message, 32)
	defer close(result)
	err := Conn.(*server.Connection).SendRequest(&request, &result)
	if err != nil {
		resp.SetErr(err.Error())
		log.Warningf("forward message to dev failed:gid[%s:%s:%s], err[%v]", domain, subDomain, deviceId, err)
		return
	}
	log.Infof("forward message to device succ:code[%d], gid[%s:%s:%s]", request.Header.MsgCode, domain, subDomain, deviceId)

	// wait reponse from the device then response to the appclient
	response, err := this.waitResponse(request.Header.MsgId, result, common.APP_TIMEOUT)
	if err != nil {
		resp.SetErr(err.Error())
		log.Warningf("wait the current response failed:gid[%s:%s:%s], err[%v]", domain, subDomain, deviceId, err)
		return
	}
	log.Infof("forward device request succ:gid[%s:%s:%s]", domain, subDomain, deviceId)
	resp.PutObject("response", zc.ZObject{"body": response.Payload})
	resp.SetAck()
}
Exemple #3
0
func loop() {
	//conn, err := net.Dial("tcp", "101.251.106.4:8384")
	//conn, err := net.Dial("tcp", "127.0.0.1:8384")
	conn, err := net.Dial("tcp", "192.168.1.114:8384")
	if err != nil {
		fmt.Println("Connect Error:", err)
		return
	}
	defer conn.Close()
	body := make([]byte, 1024)
	var report, request, response, empty common.Message
	// handshake step 1
	randKey := common.GenerateRandomKey(common.ZC_HS_MSG_LEN)
	request.Header.MsgCode = common.ZC_CODE_HANDSHAKE_1
	request.Header.PayloadLen = common.ZC_HS_MSG_LEN + common.ZC_HS_DEVICE_ID_LEN
	deviceId := "zzzzzzzzzzzz"
	fmt.Println("Generate random and id:", randKey, []byte(deviceId))
	request.Payload = make([]byte, request.Header.PayloadLen)
	copy(request.Payload[0:common.ZC_HS_MSG_LEN], randKey)
	copy(request.Payload[common.ZC_HS_MSG_LEN:request.Header.PayloadLen], []byte(deviceId))
	var contex common.EncryptContex
	contex.PublicKey = []byte("80138512665003396643737838315916663972728479914654754587175091902061894104953")
	contex.EncryptType = common.ZC_SEC_TYPE_RSA
	err = common.Send(conn, contex, &request, common.DEV_WRITE_TIMEOUT)
	if err != nil {
		fmt.Println("HANDSHAKE_1 failed:", err)
		return
	}
	fmt.Println("Write Handshake_1 succ")
	// handshake step 2
	contex.PrivateKey = common.PrivateKey
	err = common.Receive(conn, contex, &response, common.DEV_READ_TIMEOUT)
	if err != nil {
		fmt.Println("HANDSHAKE_2 failed:", err)
		return
	}
	sessionKey := make([]byte, common.ZC_HS_SESSION_KEY_LEN)
	copy(sessionKey, response.Payload[common.ZC_HS_MSG_LEN:])
	fmt.Println("Receive Handshake_2 Session Key:", response.Payload[:common.ZC_HS_MSG_LEN], sessionKey)

	// handshake step 3
	contex.EncryptType = common.ZC_SEC_TYPE_AES
	contex.SessionKey = sessionKey
	copy(request.Payload, randKey)
	request.Payload = request.Payload[0:common.ZC_HS_MSG_LEN]
	request.Header.PayloadLen = common.ZC_HS_MSG_LEN
	if len(request.Payload) != int(request.Header.PayloadLen) {
		fmt.Println("check payload len failed", len(request.Payload), request.Header.PayloadLen)
		return
	}
	request.Header.MsgCode = common.ZC_CODE_HANDSHAKE_3
	err = common.Send(conn, contex, &request, common.DEV_WRITE_TIMEOUT)
	if err != nil {
		fmt.Println("HANDSHAKE_3 failed:", err)
		return
	}
	fmt.Println("Write Handshake_3 succ")

	// handshake step 4
	err = common.Receive(conn, contex, &response, common.DEV_READ_TIMEOUT)
	if err != nil {
		fmt.Println("HANDSHAKE_4 failed:", err)
		return
	} else if !bytes.Equal(response.Payload, randKey) {
		fmt.Println("check random key failed")
		return
	} else {
		fmt.Println("CLOUD SAY HELLO WORLD TO DEV")
	}

	for i := 0; i < 3600; i++ {
		// step 1. send report message
		report.Header.PayloadLen = 0
		report.Header.Version = 123
		report.Header.MsgCode = common.ZC_CODE_HEARTBEAT
		report.Header.MsgId = uint8(i + 101)
		report.Payload = body[:report.Header.PayloadLen]
		err = common.Send(conn, contex, &report, common.DEV_WRITE_TIMEOUT)
		if err != nil {
			fmt.Println("Write Report Error:", err)
			return
		}
		// step 2. read the request
		err = common.Receive(conn, contex, &request, common.DEV_READ_TIMEOUT)
		if err != nil {
			fmt.Println("Receive Response Error:", err)
			return
		}
		fmt.Println("Read Request succ:", request.Header.MsgId, request.Payload)
		// step 3. echo empty message
		empty.Header.MsgId = request.Header.MsgId
		empty.Header.Version = request.Header.Version
		empty.Header.MsgCode = common.ZC_CODE_EMPTY
		empty.Header.PayloadLen = 0
		err = common.Send(conn, contex, &empty, common.DEV_WRITE_TIMEOUT)
		if err != nil {
			fmt.Println("Write Empty Response failed:", err)
			return
		}
		// fmt.Println("Write Empty Response", request.Header.MsgId)
		// step 4. write echo ack
		request.Header.MsgCode = common.ZC_CODE_ACK
		err = common.Send(conn, contex, &request, common.DEV_WRITE_TIMEOUT)
		if err != nil {
			fmt.Println("Write Response failed:", err)
			return
		}
		fmt.Println("Write Response:", request.Header.MsgId, request.Payload)
	}
}
func (this *Connection) DeviceHandShake() (*DeviceGID, error) {
	var handShake common.Message
	// HANDSHAKE_1 using cloud private key
	this.contex.EncryptType = common.ZC_SEC_TYPE_RSA
	this.contex.PrivateKey = common.PrivateKey
	err := common.Receive(this.socket, this.contex, &handShake, common.DEV_READ_TIMEOUT)
	if err != nil {
		log.Warningf("read handShake_1 failed:err[%v]", err)
		return nil, err
	} else if handShake.Header.MsgCode != common.ZC_CODE_HANDSHAKE_1 {
		log.Warningf("check message code failed:code[%d]", handShake.Header.MsgCode)
		return nil, common.ErrInvalidMsg
	} else if handShake.Header.PayloadLen != (common.ZC_HS_MSG_LEN + common.ZC_HS_DEVICE_ID_LEN) {
		log.Warningf("check handshake step 1 failed:len[%d]", handShake.Header.PayloadLen)
		return nil, common.ErrInvalidMsg
	}
	fmt.Println("[DEV] HANDSHAKE_1 SUCC")

	// get device public key for rsa
	devRandom := handShake.Payload[0:common.ZC_HS_MSG_LEN]
	deviceId := handShake.Payload[common.ZC_HS_MSG_LEN : common.ZC_HS_MSG_LEN+common.ZC_HS_DEVICE_ID_LEN]
	log.Infof("Receive Dev Random and ID:", devRandom, deviceId)
	this.gid = DeviceGID{domain: "app", subDomain: "test", deviceId: string(deviceId)}
	device, err := this.deviceManager.Get(this.gid)
	if err != nil {
		log.Errorf("the device not valid:addr[%v], gid[%s]", this.socket.RemoteAddr(), this.gid.String())
		return nil, err
	}

	// HANDSHAKE_2 using device public key
	this.contex.EncryptType = common.ZC_SEC_TYPE_RSA
	this.contex.PublicKey = []byte(device.PublicKey())
	this.sessionKey = common.GenerateRandomKey(common.ZC_HS_SESSION_KEY_LEN)
	log.Infof("New session key:key[%v], dest[%v], gid[%s]", this.sessionKey, this.socket.RemoteAddr(), this.gid.String())
	handShake.Header.MsgId = this.getNewRequestId()
	var response common.Message
	response.Header.MsgCode = common.ZC_CODE_HANDSHAKE_2
	response.Header.PayloadLen = common.ZC_HS_MSG_LEN + common.ZC_HS_SESSION_KEY_LEN
	response.Payload = make([]byte, response.Header.PayloadLen)
	copy(response.Payload[0:common.ZC_HS_MSG_LEN], devRandom)
	copy(response.Payload[common.ZC_HS_MSG_LEN:response.Header.PayloadLen], this.sessionKey)
	err = common.Send(this.socket, this.contex, &response, common.DEV_WRITE_TIMEOUT)
	if err != nil {
		log.Warningf("Write ZC_CODE_HANDSHAKE_2 failed:err[%v]", err)
		return &this.gid, err
	}
	fmt.Println("[DEV] HANDSHAKE_2 SUCC")

	// HANDSHAKE_3 using session key
	this.contex.EncryptType = common.ZC_SEC_TYPE_AES
	this.contex.SessionKey = this.sessionKey
	err = common.Receive(this.socket, this.contex, &handShake, common.DEV_READ_TIMEOUT)
	if err != nil {
		log.Warningf("read handShake_3 failed:err[%v]", err)
		return &this.gid, err
	} else if handShake.Header.MsgCode != common.ZC_CODE_HANDSHAKE_3 {
		log.Warningf("check message code failed:code[%d]", handShake.Header.MsgCode)
		return &this.gid, common.ErrInvalidMsg
	} else if handShake.Header.PayloadLen != common.ZC_HS_MSG_LEN {
		log.Warningf("check handshake step 3 failed:len[%d]", handShake.Header.PayloadLen)
		return &this.gid, common.ErrInvalidMsg
	} else if !bytes.Equal(handShake.Payload, devRandom) {
		log.Warningf("check handshake content failed:payload[%v], random[%v]", handShake.Payload, devRandom)
		return &this.gid, common.ErrInvalidMsg
	}
	fmt.Println("[DEV] HANDSHAKE_3 SUCC")

	// HANDSHAKE_4 using session key
	this.contex.EncryptType = common.ZC_SEC_TYPE_AES
	this.contex.SessionKey = this.sessionKey
	handShake.Header.MsgId = this.getNewRequestId()
	handShake.Header.MsgCode = common.ZC_CODE_HANDSHAKE_4
	handShake.Header.PayloadLen = common.ZC_HS_MSG_LEN
	handShake.Payload = devRandom
	err = common.Send(this.socket, this.contex, &handShake, common.DEV_WRITE_TIMEOUT)
	if err != nil {
		log.Warningf("Write ZC_CODE_HANDSHAKE_4 failed:err[%v]", err)
		return &this.gid, err
	}
	fmt.Println("[DEV] HANDSHAKE_4 PASS, WELCOME:", this.socket.RemoteAddr())
	return &this.gid, err
}