func (this *MattressProtocol) ReadPacket(c *gotcp.Conn) (gotcp.Packet, error) { smconn := c.GetExtraData().(*Conn) buffer := smconn.GetBuffer() conn := c.GetRawConn() for { data := make([]byte, 2048) readLengh, err := conn.Read(data) log.Printf("%X\n", data[0:readLengh]) if err != nil { return nil, err } if readLengh == 0 { return nil, gotcp.ErrConnClosing } else { buffer.Write(data[0:readLengh]) cmdid, pkglen := CheckProtocol(buffer) // log.Printf("recv box cmd %d \n", cmdid) pkgbyte := make([]byte, pkglen) buffer.Read(pkgbyte) switch cmdid { case ReportStatus: return ParseReportStatus(pkgbyte), nil case HalfPack: case Illegal: } } } }
func on_posup(c *gotcp.Conn, p *ShaPacket) { log.Println("posupin") posup_pkg := p.Packet.(*protocol.PosUpPacket) if posup_pkg.WifiCount > 2 { posup_pkg.LocationTime = time.Now().Format("060102150405") sql := fmt.Sprintf("INSERT INTO t_posup_log(id, imme,location_time,datainfo,accesstype) VALUES ('%s',to_timestamp('%s','YYMMDDhh24miss'),'%s','%s')", posup_pkg.IMEI, posup_pkg.LocationTime, posup_pkg.Wifi, 1) log.Println("heihei", sql) GetServer().Dbsrv.Insert(sql) c.AsyncWritePacket(p, time.Second) } else if posup_pkg.GPSFlag != "" { c.AsyncWritePacket(p, time.Second) log.Println("long", posup_pkg.Longitude) if posup_pkg.Longitude != "" { log.Println("-----tag 2") posup_pkg.LocationTime = time.Now().Format("060102150405") sql := fmt.Sprintf("INSERT INTO t_posup_log(imme,location_time,glat,glong) VALUES ('%s',to_timestamp('%s','YYMMDDhh24miss'),'%s','%s')", posup_pkg.IMEI, posup_pkg.LocationTime, posup_pkg.Latitude, posup_pkg.Longitude) log.Println(sql) GetServer().Dbsrv.Insert(sql) } else if posup_pkg.WifiCount > 2 { log.Println("-----tag 3") posup_pkg.LocationTime = time.Now().Format("060102150405") sql := fmt.Sprintf("INSERT INTO t_posup_log(imme,location_time,datainfo,accesstype) VALUES ('%s',to_timestamp('%s','YYMMDDhh24miss'),'%s','%s')", posup_pkg.IMEI, posup_pkg.LocationTime, posup_pkg.Wifi, 1) log.Println("heihei", sql) GetServer().Dbsrv.Insert(sql) } } }
func (this *Callback) OnConnect(c *gotcp.Conn) bool { conn := NewConn(c) c.PutExtraData(conn) return true }
func (this *DasCallback) OnConnect(c *gotcp.Conn) bool { addr := c.GetRawConn().RemoteAddr() c.PutExtraData(addr) fmt.Println("OnConnect:", addr) return true }
func (this *ShaProtocol) ReadPacket(c *gotcp.Conn) (gotcp.Packet, error) { smconn := c.GetExtraData().(*Conn) smconn.UpdateReadflag() buffer := smconn.GetBuffer() conn := c.GetRawConn() for { data := make([]byte, 2048) readLengh, err := conn.Read(data) if err != nil { return nil, err } if readLengh == 0 { return nil, gotcp.ErrConnClosing } else { buffer.Write(data[0:readLengh]) cmdid, pkglen := CheckProtocol(buffer) pkgbyte := make([]byte, pkglen) buffer.Read(pkgbyte) switch cmdid { case Login: pkg := ParseLogin(pkgbyte, smconn) return NewShaPacket(Login, pkg), nil case HeartBeat: pkg := ParseHeart(pkgbyte) return NewShaPacket(HeartBeat, pkg), nil case SendDeviceList: pkg := ParseDeviceList(pkgbyte, smconn) return NewShaPacket(SendDeviceList, pkg), nil case OperateFeedback: pkg := ParseFeedback(pkgbyte) return NewShaPacket(OperateFeedback, pkg), nil case Warn: pkg := ParseWarn(pkgbyte) return NewShaPacket(Warn, pkg), nil case AddDelDevice: pkg := ParseAddDelDevice(pkgbyte) return NewShaPacket(AddDelDevice, pkg), nil case SetDevicenameFeedback: pkg := ParseFeedbackSetDevicename(pkgbyte) return NewShaPacket(SetDevicenameFeedback, pkg), nil case DelDeviceFeedback: pkg := ParseFeedbackDelDevice(pkgbyte) return NewShaPacket(DelDeviceFeedback, pkg), nil case Illegal: case HalfPack: } } } }
func on_warnup(c *gotcp.Conn, p *ShaPacket) { c.AsyncWritePacket(p, time.Second) warnup_pkg := p.Packet.(*protocol.WarnUpPacket) sql := fmt.Sprintf("INSERT INTO t_warnup_log(imme,warnstyle,warn_time) VALUES ('%s','%s',to_timestamp('%s','YYMMDDhh24miss'))", warnup_pkg.IMEI, warnup_pkg.WarnStyle, time.Now().Format("060102150405")) log.Println(sql) GetServer().Dbsrv.Insert(sql) time.AfterFunc(1*time.Second, func() { locate_pkg := protocol.Parse_Locate(warnup_pkg.Encryption, warnup_pkg.IMEI, warnup_pkg.SerialNumber) c.AsyncWritePacket(locate_pkg, time.Second) }) }
func (this *Callback) OnConnect(c *gotcp.Conn) bool { heartbeat := GetConfiguration().GetServerConnCheckInterval() readlimit := GetConfiguration().GetServerReadLimit() writelimit := GetConfiguration().GetServerWriteLimit() config := &ConnConfig{ HeartBeat: uint8(heartbeat), ReadLimit: int64(readlimit), WriteLimit: int64(writelimit), } conn := NewConn(c, config) c.PutExtraData(conn) //NewConns().Add(conn) conn.Do() return true }
func (this *Callback) OnConnect(c *gotcp.Conn) bool { checkinterval := GetConfiguration().GetServerConnCheckInterval() readlimit := GetConfiguration().GetServerReadLimit() writelimit := GetConfiguration().GetServerWriteLimit() config := &ConnConfig{ ConnCheckInterval: uint16(checkinterval), ReadLimit: uint16(readlimit), WriteLimit: uint16(writelimit), } conn := NewConn(c, config) c.PutExtraData(conn) conn.Do() NewConns().Add(conn) return true }
func (this *Callback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool { shaPacket := p.(*ShaPacket) log.Println("onmessage packettype", shaPacket.Type) switch shaPacket.Type { case protocol.Login: on_login(c, shaPacket) case protocol.HeartBeat: c.AsyncWritePacket(shaPacket, time.Second) case protocol.PosUp: on_posup(c, shaPacket) case protocol.Echo: c.AsyncWritePacket(shaPacket, time.Second) case protocol.WarnUp: on_warnup(c, shaPacket) } return true }
func (this *TelnetCallback) OnConnect(c *gotcp.Conn) bool { addr := c.GetRawConn().RemoteAddr() c.PutExtraData(addr) fmt.Println("OnConnect:", addr) c.AsyncWritePacket(NewTelnetPacket("unknow", []byte("Welcome to this Telnet Server")), 0) return true }
func (this *Callback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool { bedPacket := p.(*BedPacket) switch bedPacket.Type { case Login: c.AsyncWritePacket(bedPacket, time.Second) case HeartBeat: c.AsyncWritePacket(bedPacket, time.Second) case AppControlFeedback: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) case HandleControlFeedback: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) case AppPottyFeedback: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) case HandlePottyFeedback: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) case AfterPotty: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) case AppBedReset: GetServer().GetProducer().Send(GetServer().GetTopic(), p.Serialize()) } return true }
func (this *NsqProtocol) ReadPacket(goconn *gotcp.Conn) (gotcp.Packet, error) { conn := goconn.GetRawConn() fullBuf := bytes.NewBuffer([]byte{}) fmt.Println("Read packet") for { data := make([]byte, 1024) readLengh, err := conn.Read(data) if err != nil { // EOF, or worse return nil, err } if readLengh == 0 { // Connection maybe cloased by the client return nil, gotcp.ErrConnClosing } else { fullBuf.Write(data[:readLengh]) cmdtype, err := fullBuf.ReadByte() if err != nil { return nil, err } if cmdtype == 0xBA { result := fullBuf.Next(7) // end := fullBuf.Next(1) return NewDasPacket(0xBA, result), nil } else if cmdtype == 0xBB { mac := fullBuf.Next(6) // end := fullBuf.Next(1) return NewDasPacket(0xBB, mac), nil } else if cmdtype == 0xBC { mac := fullBuf.Next(6) // end := fullBuf.Next(1) return NewDasPacket(0xBC, mac), nil } } } }
func on_login(c *gotcp.Conn, p *ShaPacket) { conn := c.GetExtraData().(*Conn) conn.Status = ConnSuccess loginPkg := p.Packet.(*protocol.LoginPacket) conn.IMEI = loginPkg.IMEI conn.ID, _ = strconv.ParseUint(loginPkg.IMEI, 10, 64) NewConns().SetID(conn.ID, conn.index) c.AsyncWritePacket(p, time.Second) time.AfterFunc(1*time.Second, func() { set_interval_pkg := protocol.Parse_Set_Interval(loginPkg.Encryption, loginPkg.IMEI, loginPkg.SerialNumber) c.AsyncWritePacket(set_interval_pkg, time.Second) }) }
func (this *TelnetCallback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool { packet := p.(*TelnetPacket) command := packet.GetData() commandType := packet.GetType() switch commandType { case "echo": c.AsyncWritePacket(NewTelnetPacket("echo", command), 0) case "login": c.AsyncWritePacket(NewTelnetPacket("login", []byte(string(command)+" has login")), 0) case "quit": return false default: c.AsyncWritePacket(NewTelnetPacket("unknow", []byte("unknow command")), 0) } return true }
func (this *TelnetCallback) OnClose(c *gotcp.Conn) { fmt.Println("OnClose:", c.GetExtraData()) }
func (this *Callback) OnClose(c *gotcp.Conn) { conn := c.GetExtraData().(*Conn) conn.Close() }
func (this *DasProtocol) ReadPacket(goconn *gotcp.Conn) (gotcp.Packet, error) { conn := goconn.GetRawConn() for { data := make([]byte, 1024) readLengh, err := conn.Read(data) if err != nil { // EOF, or worse return nil, err } if readLengh == 0 { // Connection maybe cloased by the client return nil, gotcp.ErrConnClosing } else { goconn.GetRecvBytes().Write(data[:readLengh]) fmt.Println(goconn.GetRecvBytes().Bytes()) if goconn.GetRecvBytes().Bytes()[0] == 0xBA || goconn.GetRecvBytes().Bytes()[0] == 0xBB || goconn.GetRecvBytes().Bytes()[0] == 0xBC { if goconn.GetRecvBytes().Len() >= 8 { cmdtype, _ := goconn.GetRecvBytes().ReadByte() if cmdtype == 0xBA { result := goconn.GetRecvBytes().Next(6) // cmdtype + result + serialid goconn.GetRecvBytes().Next(1) return NewDasPacket(0xBA, result), nil } else if cmdtype == 0xBB { mac := goconn.GetRecvBytes().Next(6) goconn.GetRecvBytes().Next(1) return NewDasPacket(0xBB, mac), nil } else if cmdtype == 0xBC { mac := goconn.GetRecvBytes().Next(6) goconn.GetRecvBytes().Next(1) return NewDasPacket(0xBC, mac), nil } } else { return nil, gotcp.ErrReadHalf } } else { goconn.GetRecvBytes().Reset() return nil, gotcp.ErrReadHalf } } } }
func (this *Callback) OnClose(c *gotcp.Conn) { conn := c.GetExtraData().(*Conn) conn.Close() NewConns().Remove(conn.GetBedID()) NewBedHub().Remove(conn.GetBedID()) }
func (this *ShaProtocol) ReadPacket(c *gotcp.Conn) (gotcp.Packet, error) { smconn := c.GetExtraData().(*Conn) var once sync.Once once.Do(smconn.UpdateReadflag) buffer := smconn.GetBuffer() conn := c.GetRawConn() for { if smconn.ReadMore { data := make([]byte, 2048) readLengh, err := conn.Read(data) log.Printf("<IN> %x\n", data[0:readLengh]) if err != nil { return nil, err } if readLengh == 0 { return nil, gotcp.ErrConnClosing } buffer.Write(data[0:readLengh]) } cmdid, pkglen := protocol.CheckProtocol(buffer) pkgbyte := make([]byte, pkglen) buffer.Read(pkgbyte) switch cmdid { case protocol.Login: pkg := protocol.ParseLogin(pkgbyte) smconn.ReadMore = false return NewShaPacket(protocol.Login, pkg), nil case protocol.HeartBeat: pkg := protocol.ParseHeart(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.HeartBeat, pkg), nil case protocol.Add_Del_Device: pkg := protocol.Parse_Add_Del_Device(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Add_Del_Device, pkg), nil case protocol.Notification: pkg := protocol.Parse_Notification(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Notification, pkg), nil case protocol.Feedback_SetName: pkg := protocol.Parse_Feedback_SetName(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_SetName, pkg), nil case protocol.Feedback_Del_Device: pkg := protocol.Parse_Feedback_Del_Device(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_Del_Device, pkg), nil case protocol.Feedback_Query_Attr: pkg := protocol.Parse_Feedback_Query_Attr(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_Query_Attr, pkg), nil case protocol.Feedback_Depolyment: pkg := protocol.Parse_Feedback_Deployment(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_Depolyment, pkg), nil case protocol.Feedback_OnOff: pkg := protocol.Parse_Feedback_Onoff(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_OnOff, pkg), nil case protocol.Feedback_Level_Control: pkg := protocol.Parse_Feedback_Level_Control(pkgbyte, smconn.ID) smconn.ReadMore = false return NewShaPacket(protocol.Feedback_Level_Control, pkg), nil case protocol.Illegal: smconn.ReadMore = true case protocol.HalfPack: smconn.ReadMore = true } } }
func (this *DasCallback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool { // 0xBA command feedback 0xBB heartbeat 0xBC login // 0xBA cmdtype(1-8) status(0/1) serialid daspacket := p.(*DasPacket) command := daspacket.GetData() commandtype := daspacket.GetType() fmt.Println("----onmessage ", command) switch commandtype { case 0xBA: var result []byte var cmdop byte cmdop = command[0]*10 + command[1] result = append(result, cmdop) result = append(result, c.GetMac()...) result = append(result, command[3:7]...) result = append(result, command[2]) c.Send(c.GetTopic(), result) fmt.Printf("-----recv should up the result%x \n", result) case 0xBB: c.SetTimeFlag(time.Now().Unix()) c.AsyncWritePacket(NewDasPacket(0xAB, command), time.Second) case 0xBC: c.SetID(getMac(command), c.GetIndex()) c.AsyncWritePacket(NewDasPacket(0xAC, command), time.Second) default: gktoolkit.Trace() } return true }
func (this *BedProtocol) ReadPacket(c *gotcp.Conn) (gotcp.Packet, error) { smconn := c.GetExtraData().(*Conn) buffer := smconn.GetBuffer() conn := c.GetRawConn() for { data := make([]byte, 2048) readLengh, err := conn.Read(data) log.Printf("recv %x", data[0:readLengh]) if err != nil { return nil, err } if readLengh == 0 { return nil, gotcp.ErrConnClosing } else { buffer.Write(data[0:readLengh]) cmdid, pkglen := CheckProtocol(buffer) log.Println(cmdid) log.Println(NewConns().Check(0)) if cmdid != Login && !NewConns().Check(smconn.GetBedID()) { return nil, ErrNotLogin } smconn.UpdateReadflag() pkgbyte := make([]byte, pkglen) buffer.Read(pkgbyte) switch cmdid { case Login: pkg := ParseLogin(pkgbyte, smconn) return NewBedPacket(Login, pkg), nil case HeartBeat: pkg := ParseHeart(pkgbyte) return NewBedPacket(HeartBeat, pkg), nil case AppControlFeedback: pkg := ParseAppControlFeedback(pkgbyte, smconn, AppControlFeedback) return NewBedPacket(AppControlFeedback, pkg), nil case HandleControlFeedback: bedpkg := ParseHandleControlFeedback(pkgbyte) smconn.SendToBed(bedpkg) pkg := ParseAppControlFeedback(pkgbyte, smconn, HandleControlFeedback) return NewBedPacket(HandleControlFeedback, pkg), nil case AppPottyFeedback: pkg := ParsePottyFeedback(pkgbyte, smconn, AppPottyFeedback) return NewBedPacket(AppPottyFeedback, pkg), nil case HandlePottyFeedback: bedpkg := ParseHandlePottyFeedback(pkgbyte) smconn.SendToBed(bedpkg) pkg := ParsePottyFeedback(pkgbyte, smconn, HandlePottyFeedback) return NewBedPacket(HandlePottyFeedback, pkg), nil case AfterPotty: bedpkg := ParseAfterPottyTobedFeedback(pkgbyte) smconn.SendToBed(bedpkg) pkg := ParseAfterPottyFeedback(pkgbyte, smconn) return NewBedPacket(AfterPotty, pkg), nil case AppBedReset: pkg := ParseAppControlFeedback(pkgbyte, smconn, AppBedReset) return NewBedPacket(AppBedReset, pkg), nil case Illegal: case HalfPack: } } } }
func (this *Callback) OnMessage(c *gotcp.Conn, p gotcp.Packet) bool { echoPacket := p.(*echo.EchoPacket) fmt.Printf("OnMessage:[%v] [%v]\n", echoPacket.GetLength(), string(echoPacket.GetBody())) c.AsyncWritePacket(echo.NewEchoPacket(echoPacket.Serialize(), true), time.Second) return true }