func (af *AuthenticationFilter) OnPacketReceived(s *netlib.Session, packetid int, packet interface{}) bool {
if s.GetAttribute(SessionAttributeAuth) == nil {
if auth, ok := packet.(*protocol.SSPacketAuth); ok {
h := md5.New()
rawText := fmt.Sprintf("%v;%v", auth.GetTimestamp(), s.GetSessionConfig().AuthKey)
logger.Tracef("AuthenticationFilter rawtext=%v IsInnerLink(%v)", rawText, s.GetSessionConfig().IsInnerLink)
h.Write([]byte(rawText))
expectKey := hex.EncodeToString(h.Sum(nil))
if expectKey != auth.GetAuthKey() {
if af.SessionAuthHandler != nil {
af.SessionAuthHandler(s, false)
}
s.Close()
logger.Tracef("AuthenticationFilter AuthKey error[expect:%v get:%v]", expectKey, auth.GetAuthKey())
return false
}
s.SetAttribute(SessionAttributeAuth, true)
if af.SessionAuthHandler != nil {
af.SessionAuthHandler(s, true)
}
return false
} else {
s.Close()
logger.Warn("AuthenticationFilter packet not expect")
return false
}
}
return true
}
func (this *SessionHandlerServiceRegiste) OnSessionOpened(s *netlib.Session) {
sc := s.GetSessionConfig()
if sc.IsClient {
/*报告自己的监听信息*/
srvlib.ServiceMgr.ReportService(s)
} else {
s.SetAttribute(srvlib.SessionAttributeServiceFlag, 1)
}
}
func (csm *ClientSessionMgr) RegisteSession(s *netlib.Session) bool {
attr := s.GetAttribute(SessionAttributeClientSession)
if attr == nil {
sid := NewSessionId(s)
s.SetAttribute(SessionAttributeClientSession, sid)
csm.sessions[sid.Get()] = s
logger.Tracef("client session %v registe", sid.Get())
}
return true
}
func (this *PacketSlicesHandler) Process(s *netlib.Session, data interface{}) error {
if packetslices, ok := data.(*protocol.SSPacketSlices); ok {
seqNo := int(packetslices.GetSeqNo())
if seqNo < 1 {
return errors.New("PacketSlicesHandler unexpect packet seq:" + strconv.Itoa(seqNo))
}
totalSize := int(packetslices.GetTotalSize())
if totalSize > s.GetSessionConfig().MaxPacket {
return errors.New("PacketSlicesHandler exceed MaxPacket size:" + strconv.Itoa(s.GetSessionConfig().MaxPacket) + " size=" + strconv.Itoa(totalSize))
}
attr := s.GetAttribute(SessionAttributeBigBuf)
if seqNo == 1 {
if attr == nil {
attr = bytes.NewBuffer(make([]byte, 0, packetslices.GetTotalSize()))
s.SetAttribute(SessionAttributeBigBuf, attr)
}
}
if seqNo > 1 {
if attr == nil {
return errors.New("PacketSlicesHandler Incorrect packet seq, expect seq=1")
}
} else if attr == nil {
return errors.New("PacketSlicesHandler get bytesbuf failed")
}
buf := attr.(*bytes.Buffer)
if seqNo == 1 {
buf.Reset()
}
if buf.Len() != int(packetslices.GetOffset()) {
return errors.New("PacketSlicesHandler get next packet offset error")
}
buf.Write(packetslices.GetPacketData())
if buf.Len() == totalSize {
packetid, pck, err := netlib.UnmarshalPacket(buf.Bytes())
if err != nil {
return err
}
h := netlib.GetHandler(packetid)
if h != nil {
h.Process(s, pck)
}
}
}
return nil
}
func (this *serviceMgr) RegisteService(s *netlib.Session, services []*protocol.ServiceInfo) {
if this == nil || services == nil || len(services) == 0 {
return
}
s.SetAttribute(SessionAttributeServiceInfo, services)
for _, service := range services {
srvid := service.GetSrvId()
srvtype := service.GetSrvType()
if _, has := this.servicesPool[srvtype]; !has {
this.servicesPool[srvtype] = make(map[int32]*protocol.ServiceInfo)
}
this.servicesPool[srvtype][srvid] = service
pack := &protocol.SSServiceInfo{}
pack.Service = service
proto.SetDefaults(pack)
sessiontypes := GetCareSessionsByService(service.GetSrvType())
areaId := service.GetAreaId()
for _, v1 := range sessiontypes {
ServerSessionMgrSington.Broadcast(pack, int(areaId), int(v1))
}
}
}