gateway/gateway.go

@@ -1,8 +1,6 @@
 package gateway
 
 import (
-	"sync"
-
 	"github.com/Philipp15b/go-steam"
 )
 
@@ -25,35 +23,20 @@ type GatewayInfo struct {
 	SteamLoginInfo  *steam.LogOnDetails
 	SteamClient     *steam.Client
 	SentryFile      string
-	friendSteamId   *FriendSteam
+	FriendSteamId   map[string]*StatusSteamFriend
 	SteamConnecting bool
 	Deleting        bool
 
 	// XMPP
 	XMPP_JID_Client              string
 	XMPP_Out                     chan interface{}
-	xmpp_Connected_Client        *XmppConnectedClient
+	XMPP_Connected_Client        map[string]bool
 	DebugMessage                 bool
-	xmpp_IQ_RemoteRoster_Request *XmppRemoteRosterRequest
+	XMPP_IQ_RemoteRoster_Request map[string]string
 	AllowEditRoster              bool
 	ChatstateNotificationData    chan string
 }
 
-type FriendSteam struct {
-	steamId map[string]*StatusSteamFriend
-	sync.RWMutex
-}
-
-type XmppConnectedClient struct {
-	client map[string]bool
-	sync.RWMutex
-}
-
-type XmppRemoteRosterRequest struct {
-	request map[string]string
-	sync.RWMutex
-}
-
 type StatusSteamFriend struct {
 	XMPP_Status   string
 	XMPP_Type     string
@@ -85,82 +68,3 @@ func (g *GatewayInfo) Delete() {
 
 	g.Disconnect()
 }
-
-func (s *GatewayInfo) CreateSteamIds() {
-	s.friendSteamId = &FriendSteam{steamId: make(map[string]*StatusSteamFriend)}
-}
-
-func (s *GatewayInfo) GetFriendSteamId(steamId string) *StatusSteamFriend {
-	s.friendSteamId.RLock()
-	defer s.friendSteamId.RUnlock()
-	return s.friendSteamId.steamId[steamId]
-}
-
-func (s *GatewayInfo) GetAllFriendSteamId() []string {
-	s.friendSteamId.RLock()
-	defer s.friendSteamId.RUnlock()
-	allSteamIds := make([]string, len(s.friendSteamId.steamId))
-
-	i := 0
-	for steamId := range s.friendSteamId.steamId {
-		allSteamIds[i] = steamId
-		i++
-	}
-	return allSteamIds
-}
-
-func (s *GatewayInfo) SetFriendSteamId(steamId string, status *StatusSteamFriend) {
-	s.friendSteamId.Lock()
-	s.friendSteamId.steamId[steamId] = status
-	s.friendSteamId.Unlock()
-}
-
-func (s *GatewayInfo) RemoveFriendSteamId(steamId string) {
-	s.friendSteamId.Lock()
-	delete(s.friendSteamId.steamId, steamId)
-	s.friendSteamId.Unlock()
-}
-
-func (s *GatewayInfo) CreateXmppConnectedClient() {
-	s.xmpp_Connected_Client = &XmppConnectedClient{client: make(map[string]bool)}
-}
-
-func (s *GatewayInfo) SetXmppConnectedClient(jid string) {
-	s.xmpp_Connected_Client.Lock()
-	s.xmpp_Connected_Client.client[jid] = true
-	s.xmpp_Connected_Client.Unlock()
-}
-
-func (s *GatewayInfo) RemoveXmppConnectedClient(jid string) {
-	s.xmpp_Connected_Client.Lock()
-	delete(s.xmpp_Connected_Client.client, jid)
-	s.xmpp_Connected_Client.Unlock()
-}
-
-func (s *GatewayInfo) GetLenXmppConnectedClient() int {
-	s.xmpp_Connected_Client.RLock()
-	defer s.xmpp_Connected_Client.RUnlock()
-	return len(s.xmpp_Connected_Client.client)
-}
-
-func (s *GatewayInfo) CreateXmppRemoteRosterRequest() {
-	s.xmpp_IQ_RemoteRoster_Request = &XmppRemoteRosterRequest{request: make(map[string]string)}
-}
-
-func (s *GatewayInfo) SetXmppRemoteRosterRequest(iqId, value string) {
-	s.xmpp_IQ_RemoteRoster_Request.Lock()
-	s.xmpp_IQ_RemoteRoster_Request.request[iqId] = value
-	s.xmpp_IQ_RemoteRoster_Request.Unlock()
-}
-
-func (s *GatewayInfo) RemoveXmppRemoteRosterRequest(iqId string) {
-	s.xmpp_IQ_RemoteRoster_Request.Lock()
-	delete(s.xmpp_IQ_RemoteRoster_Request.request, iqId)
-	s.xmpp_IQ_RemoteRoster_Request.Unlock()
-}
-
-func (s *GatewayInfo) GetXmppRemoteRosterRequest(iqId string) string {
-	s.xmpp_IQ_RemoteRoster_Request.RLock()
-	defer s.xmpp_IQ_RemoteRoster_Request.RUnlock()
-	return s.xmpp_IQ_RemoteRoster_Request.request[iqId]
-}

gateway/steam.go

@@ -127,16 +127,15 @@ func (g *GatewayInfo) mainSteam() {
 				status = Status_extended_away
 				tpye = Type_available
 			}
-			steamFriendId := g.GetFriendSteamId(steamId)
+			if _, ok := g.FriendSteamId[steamId]; !ok {
-			if steamFriendId == nil {
 				// Send subscribsion
 				g.SendXmppPresence(status, Type_subscribe, "", steamId+"@"+XmppJidComponent, gameName, name)
-				g.SetFriendSteamId(steamId, &StatusSteamFriend{XMPP_Status: status, XMPP_Type: tpye})
+				g.FriendSteamId[steamId] = &StatusSteamFriend{XMPP_Status: status, XMPP_Type: tpye}
 			} else {
-				steamFriendId.XMPP_Status = status
+				g.FriendSteamId[steamId].XMPP_Status = status
-				steamFriendId.XMPP_Type = tpye
+				g.FriendSteamId[steamId].XMPP_Type = tpye
-				steamFriendId.SteamGameName = gameName
+				g.FriendSteamId[steamId].SteamGameName = gameName
-				steamFriendId.SteamName = name
+				g.FriendSteamId[steamId].SteamName = name
 			}
 			g.SendXmppPresence(status, tpye, "", steamId+"@"+XmppJidComponent, gameName, name)
 
@@ -227,9 +226,9 @@ func (g *GatewayInfo) SteamDisconnect() {
 
 func (g *GatewayInfo) DisconnectAllSteamFriend() {
 	logger.Debug.Printf("[%s] Disconnect all Steam friend", g.XMPP_JID_Client)
-	for _, sid := range g.GetAllFriendSteamId() {
+	for sid := range g.FriendSteamId {
 		g.SendXmppPresence(Status_offline, Type_unavailable, "", sid+"@"+XmppJidComponent, "", "")
-		g.RemoveFriendSteamId(sid)
+		delete(g.FriendSteamId, sid)
 	}
 }
 

gateway/xmpp.go

@@ -56,14 +56,14 @@ func (g *GatewayInfo) ReceivedXMPP_Presence(presence *xmpp.Presence) {
 	if len(jid) == 2 {
 		// Resource exist —> client speaking
 		if presence.Type == Type_available {
-			g.SetXmppConnectedClient(presence.From)
+			g.XMPP_Connected_Client[presence.From] = true
 		} else if presence.Type == Type_unavailable {
-			g.RemoveXmppConnectedClient(presence.From)
+			delete(g.XMPP_Connected_Client, presence.From)
 		}
 	}
 
 	if presence.Type == Type_probe {
-		steamFriendStatus := g.GetFriendSteamId(steamJid[0])
+		steamFriendStatus := g.FriendSteamId[steamJid[0]]
 		if steamFriendStatus != nil {
 			g.SendXmppPresence(steamFriendStatus.XMPP_Status, steamFriendStatus.XMPP_Type, "", steamJid[0]+"@"+XmppJidComponent, steamFriendStatus.SteamGameName, steamFriendStatus.SteamName)
 		}
@@ -79,7 +79,7 @@ func (g *GatewayInfo) ReceivedXMPP_Presence(presence *xmpp.Presence) {
 		// Destination is gateway itself
 		if presence.Type == Type_unavailable {
 			// Disconnect
-			if g.GetLenXmppConnectedClient() <= 0 {
+			if len(g.XMPP_Connected_Client) <= 0 {
 				g.Disconnect()
 			}
 		} else {
@@ -138,9 +138,8 @@ func (g *GatewayInfo) ReceivedXMPP_Message(message *xmpp.Message) {
 
 func (g *GatewayInfo) ReceivedXMPP_IQ(iq *xmpp.IQ) bool {
 	ret := false
-	remoteRosterRequestValue := g.GetXmppRemoteRosterRequest(iq.ID)
+	if g.XMPP_IQ_RemoteRoster_Request[iq.ID] == RemoteRosterRequestPermission {
-	if remoteRosterRequestValue == RemoteRosterRequestPermission {
+		delete(g.XMPP_IQ_RemoteRoster_Request, iq.ID)
-		g.RemoveXmppRemoteRosterRequest(iq.ID)
 
 		if iq.Type == xmpp.IQTypeError && iq.Error.Condition() == xmpp.ErrorForbidden {
 			g.AllowEditRoster = false
@@ -161,15 +160,15 @@ func (g *GatewayInfo) ReceivedXMPP_IQ(iq *xmpp.IQ) bool {
 			logger.Info.Printf("Check roster edition authorisation by querying roster's user")
 			// Remote roster namespace may not be supported (like prosody), so we send a roster query
 			iqId := NextIqId()
-			g.SetXmppRemoteRosterRequest(iqId, RemoteRosterRequestRoster)
+			g.XMPP_IQ_RemoteRoster_Request[iqId] = RemoteRosterRequestRoster
 			iqSend := &xmpp.IQ{ID: iqId, Type: xmpp.IQTypeGet, From: iq.To, To: iq.From}
 			iqSend.PayloadEncode(&xmpp.RosterQuery{})
 			g.XMPP_Out <- iqSend
 		}
 		ret = true
 
-	} else if remoteRosterRequestValue == RemoteRosterRequestRoster {
+	} else if g.XMPP_IQ_RemoteRoster_Request[iq.ID] == RemoteRosterRequestRoster {
-		g.RemoveXmppRemoteRosterRequest(iq.ID)
+		delete(g.XMPP_IQ_RemoteRoster_Request, iq.ID)
 		if iq.Type == xmpp.IQTypeResult && iq.PayloadName().Space == xmpp.NSRoster {
 			g.AllowEditRoster = true
 		} else {

xmpp/xmpp.go

@@ -277,13 +277,13 @@ func AddNewUser(jidUser, steamLogin, steamPwd string, debugMessage bool) {
 	g.SteamPassword = steamPwd
 	g.XMPP_JID_Client = jidUser
 	g.SentryFile = gateway.SentryDirectory + jidUser
-	g.CreateSteamIds()
+	g.FriendSteamId = make(map[string]*gateway.StatusSteamFriend)
 	g.Deleting = false
 
 	g.XMPP_Out = comp.Out
-	g.CreateXmppConnectedClient()
+	g.XMPP_Connected_Client = make(map[string]bool)
 	g.DebugMessage = debugMessage
-	g.CreateXmppRemoteRosterRequest()
+	g.XMPP_IQ_RemoteRoster_Request = make(map[string]string)
 	g.AllowEditRoster = false
 
 	MapGatewayInfo[jidUser] = g
@@ -292,7 +292,7 @@ func AddNewUser(jidUser, steamLogin, steamPwd string, debugMessage bool) {
 	logger.Info.Printf("Check roster edition by asking with remote roster manager namespace")
 	// Ask if remote roster is allow
 	iqId := gateway.NextIqId()
-	g.SetXmppRemoteRosterRequest(iqId, gateway.RemoteRosterRequestPermission)
+	g.XMPP_IQ_RemoteRoster_Request[iqId] = gateway.RemoteRosterRequestPermission
 	iq := xmpp.IQ{To: jidUser, From: jid.Domain, Type: xmpp.IQTypeGet, ID: iqId}
 	// iq.PayloadEncode(&xmpp.RosterQuery{})
 	iq.PayloadEncode(&xmpp.RemoteRosterManagerQuery{Reason: "Manage contacts in the Steam contact list", Type: xmpp.RemoteRosterManagerTypeRequest})