Leahnaya/friends
1
0
Fork 0
mirror of https://github.com/PretendoNetwork/friends.git synced 2026-08-02 08:04:39 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

use new PID, DateTime and method returns

Browse Source
This commit is contained in:
Jonathan Barrow 2023-11-14 22:47:52 -05:00
parent cb82df0e20
commit de11455a1b
No known key found for this signature in database
GPG Key ID: E86E9FE9049C741F
54 changed files with 302 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
database/3ds/get_friend_miis.go
View File

@ -32,7 +32,7 @@ func GetFriendMiis(pids []uint32) ([]*friends_3ds_types.FriendMii, error) {
rows.Scan(&pid, &mii.Name, &mii.MiiData)
friendMii := friends_3ds_types.NewFriendMii()
friendMii.PID = pid
friendMii.PID = nex.NewPID(pid)
friendMii.Mii = mii
friendMii.ModifiedAt = changedTime

14
database/3ds/save_friendship.go
View File

@ -11,25 +11,25 @@ import (
// SaveFriendship saves a friend relationship for a user
func SaveFriendship(senderPID uint32, recipientPID uint32) (*friends_3ds_types.FriendRelationship, error) {
friendRelationship := friends_3ds_types.NewFriendRelationship()
friendRelationship.PID = recipientPID
friendRelationship.PID = nex.NewPID(recipientPID)
friendRelationship.LFC = 0
friendRelationship.RelationshipType = 0 // Incomplete
friendRelationship.RelationshipType = 0 // * Incomplete
nowTime := nex.NewDateTime(0)
nowTime.FromTimestamp(time.Now())
// Ensure that we inputted a valid user.
// * Ensure that we inputted a valid user.
var found bool
err := database.Postgres.QueryRow(`SELECT COUNT(*) FROM "3ds".user_data WHERE pid=$1 LIMIT 1`, recipientPID).Scan(&found)
if err != nil {
return nil, err
}
if !found {
friendRelationship.RelationshipType = 2 // Non-existent
friendRelationship.RelationshipType = 2 // * Non-existent
return friendRelationship, nil
}
// Get the other side's relationship, we need to know if we've already got one sent to us.
// * Get the other side's relationship, we need to know if we've already got one sent to us.
err = database.Postgres.QueryRow(`
SELECT COUNT(*) FROM "3ds".friendships WHERE user1_pid=$1 AND user2_pid=$2 AND type=0 LIMIT 1`, recipientPID, senderPID).Scan(&found)
if err != nil {
@ -49,7 +49,7 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) (*friends_3ds_types.F
acceptedTime := nex.NewDateTime(0).Now()
// We need to have two relationships for both sides as friend relationships are not one single object.
// * We need to have two relationships for both sides as friend relationships are not one single object.
_, err = database.Postgres.Exec(`
INSERT INTO "3ds".friendships (user1_pid, user2_pid, date, type)
VALUES ($1, $2, $3, 1)
@ -72,6 +72,6 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) (*friends_3ds_types.F
return nil, err
}
friendRelationship.RelationshipType = 1 // Complete
friendRelationship.RelationshipType = 1 // * Complete
return friendRelationship, nil
}

16
database/wiiu/accept_friend_request_and_return_friend_info.go
View File

@ -28,10 +28,10 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wi
acceptedTime := nex.NewDateTime(0)
acceptedTime.FromTimestamp(time.Now())
// Friendships are two-way relationships, not just one link between 2 entities
// "A" has friend "B" and "B" has friend "A", so store both relationships
// * Friendships are two-way relationships, not just one link between 2 entities
// * "A" has friend "B" and "B" has friend "A", so store both relationships
// If were friends before, just activate the status again
// * If were friends before, just activate the status again
_, err = database.Postgres.Exec(`
INSERT INTO wiiu.friendships (user1_pid, user2_pid, date, active)
@ -65,14 +65,14 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wi
var lastOnline *nex.DateTime
if connectedUser != nil {
// Online
// * Online
friendInfo.NNAInfo = connectedUser.NNAInfo
friendInfo.Presence = connectedUser.PresenceV2
lastOnline = nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
} else {
// Offline
// * Offline
userInfo, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
return nil, err
@ -96,7 +96,7 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wi
friendInfo.Presence.Unknown3 = 0
friendInfo.Presence.GameServerID = 0
friendInfo.Presence.Unknown4 = 0
friendInfo.Presence.PID = senderPID
friendInfo.Presence.PID = nex.NewPID(senderPID)
friendInfo.Presence.GatheringID = 0
friendInfo.Presence.ApplicationData = make([]byte, 0)
friendInfo.Presence.Unknown5 = 0
@ -113,7 +113,7 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wi
}
}
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO: Change this
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO - Change this
}
status, err := GetUserComment(senderPID)
@ -123,7 +123,7 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wi
friendInfo.Status = status
friendInfo.BecameFriend = acceptedTime
friendInfo.LastOnline = lastOnline // TODO: Change this
friendInfo.LastOnline = lastOnline // TODO - Change this
friendInfo.Unknown = 0
return friendInfo, nil

8
database/wiiu/get_user_friend_list.go
View File

@ -35,7 +35,7 @@ func GetUserFriendList(pid uint32) ([]*friends_wiiu_types.FriendInfo, error) {
var lastOnline *nex.DateTime
if connectedUser != nil {
// Online
// * Online
friendInfo.NNAInfo = connectedUser.NNAInfo
friendInfo.Presence = connectedUser.PresenceV2
@ -54,7 +54,7 @@ func GetUserFriendList(pid uint32) ([]*friends_wiiu_types.FriendInfo, error) {
lastOnline = nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
} else {
// Offline
// * Offline
userInfo, err := utility.GetUserInfoByPID(friendPID)
if err != nil {
@ -79,7 +79,7 @@ func GetUserFriendList(pid uint32) ([]*friends_wiiu_types.FriendInfo, error) {
friendInfo.Presence.Unknown3 = 0
friendInfo.Presence.GameServerID = 0
friendInfo.Presence.Unknown4 = 0
friendInfo.Presence.PID = 0
friendInfo.Presence.PID = nex.NewPID[uint32](0)
friendInfo.Presence.GatheringID = 0
friendInfo.Presence.ApplicationData = []byte{0x00}
friendInfo.Presence.Unknown5 = 0
@ -92,7 +92,7 @@ func GetUserFriendList(pid uint32) ([]*friends_wiiu_types.FriendInfo, error) {
return nil, err
}
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO: Change this
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO - Change this
}
status, err := GetUserComment(friendPID)

2
database/wiiu/update_user_comment.go
View File

@ -7,7 +7,7 @@ import (
// UpdateUserComment updates a user's comment
func UpdateUserComment(pid uint32, message string) (uint64, error) {
changed := nex.NewDateTime(0).Now()
changed := nex.NewDateTime(0).Now().Value()
_, err := database.Postgres.Exec(`
INSERT INTO wiiu.user_data (pid, comment, comment_changed)

4
globals/password_from_pid.go
View File

@ -8,10 +8,10 @@ import (
"google.golang.org/grpc/metadata"
)
func PasswordFromPID(pid uint32) (string, uint32) {
func PasswordFromPID(pid *nex.PID) (string, uint32) {
ctx := metadata.NewOutgoingContext(context.Background(), GRPCAccountCommonMetadata)
response, err := GRPCAccountClient.GetNEXPassword(ctx, &pb.GetNEXPasswordRequest{Pid: pid})
response, err := GRPCAccountClient.GetNEXPassword(ctx, &pb.GetNEXPasswordRequest{Pid: pid.LegacyValue()})
if err != nil {
Logger.Error(err.Error())
return "", nex.Errors.RendezVous.InvalidUsername

2
grpc/get_user_friend_pids.go
View File

@ -40,7 +40,7 @@ func (s *gRPCFriendsServer) GetUserFriendPIDs(ctx context.Context, in *pb.GetUse
for _, relationship := range relationships {
// * Only add complete relationships to the list
if relationship.RelationshipType == 1 {
pids = append(pids, relationship.PID)
pids = append(pids, relationship.PID.LegacyValue())
}
}

2
grpc/get_user_friend_requests_incoming.go
View File

@ -25,7 +25,7 @@ func (s *gRPCFriendsServer) GetUserFriendRequestsIncoming(ctx context.Context, i
for i := 0; i < len(friendRequestsIn); i++ {
friendRequest := &pb.FriendRequest{
Id: friendRequestsIn[i].Message.FriendRequestID,
Sender: friendRequestsIn[i].PrincipalInfo.PID,
Sender: friendRequestsIn[i].PrincipalInfo.PID.LegacyValue(),
Recipient: in.GetPid(),
Sent: uint64(friendRequestsIn[i].SentOn.Standard().Unix()),
Expires: uint64(friendRequestsIn[i].Message.ExpiresOn.Standard().Unix()),

35
nex/account-management/nintendo_create_account.go
View File

@ -15,24 +15,22 @@ import (
account_management_types "github.com/PretendoNetwork/nex-protocols-go/account-management/types"
)
func NintendoCreateAccount(err error, packet nex.PacketInterface, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder) uint32 {
func NintendoCreateAccount(err error, packet nex.PacketInterface, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Core.InvalidArgument
return nil, nex.Errors.Core.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
var tokenBase64 string
oAuthDataType := oAuthData.TypeName()
switch oAuthDataType {
case "NintendoCreateAccountData": // Wii U
case "NintendoCreateAccountData": // * Wii U
nintendoCreateAccountData := oAuthData.ObjectData().(*account_management_types.NintendoCreateAccountData)
tokenBase64 = nintendoCreateAccountData.Token
case "AccountExtraInfo": // 3DS
case "AccountExtraInfo": // * 3DS
accountExtraInfo := oAuthData.ObjectData().(*account_management_types.AccountExtraInfo)
tokenBase64 = accountExtraInfo.NEXToken
@ -41,19 +39,19 @@ func NintendoCreateAccount(err error, packet nex.PacketInterface, callID uint32,
tokenBase64 = strings.Replace(tokenBase64, "*", "=", -1)
default:
globals.Logger.Errorf("Invalid oAuthData data type %s!", oAuthDataType)
return nex.Errors.Authentication.TokenParseError
return nil, nex.Errors.Authentication.TokenParseError
}
encryptedToken, err := base64.StdEncoding.DecodeString(tokenBase64)
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Authentication.TokenParseError
return nil, nex.Errors.Authentication.TokenParseError
}
decryptedToken, err := utility.DecryptToken(encryptedToken)
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Authentication.TokenParseError
return nil, nex.Errors.Authentication.TokenParseError
}
pid := decryptedToken.UserPID
@ -65,7 +63,7 @@ func NintendoCreateAccount(err error, packet nex.PacketInterface, callID uint32,
_, err = mac.Write(pidByteArray)
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Authentication.Unknown
return nil, nex.Errors.Authentication.Unknown
}
pidHmac := hex.EncodeToString(mac.Sum(nil))
@ -82,20 +80,5 @@ func NintendoCreateAccount(err error, packet nex.PacketInterface, callID uint32,
rmcResponse.MethodID = account_management.MethodNintendoCreateAccount
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

29
nex/friends-3ds/add_friendship_by_pid.go
View File

@ -8,23 +8,23 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func AddFriendshipByPrincipalID(err error, packet nex.PacketInterface, callID uint32, lfc uint64, pid uint32) uint32 {
func AddFriendshipByPrincipalID(err error, packet nex.PacketInterface, callID uint32, lfc uint64, pid *nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
friendRelationship, err := database_3ds.SaveFriendship(client.PID().LegacyValue(), pid)
friendRelationship, err := database_3ds.SaveFriendship(client.PID().LegacyValue(), pid.LegacyValue())
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
connectedUser := globals.ConnectedUsers[pid]
connectedUser := globals.ConnectedUsers[pid.LegacyValue()]
if connectedUser != nil {
go notifications_3ds.SendFriendshipCompleted(connectedUser.Client, pid, client.PID().LegacyValue())
go notifications_3ds.SendFriendshipCompleted(connectedUser.Client, pid.LegacyValue(), client.PID())
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -38,20 +38,5 @@ func AddFriendshipByPrincipalID(err error, packet nex.PacketInterface, callID ui
rmcResponse.MethodID = friends_3ds.MethodAddFriendByPrincipalID
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-3ds/get_all_friends.go
View File

@ -9,10 +9,10 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetAllFriends(err error, packet nex.PacketInterface, callID uint32) uint32 {
func GetAllFriends(err error, packet nex.PacketInterface, callID uint32) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
client := packet.Sender().(*nex.PRUDPClient)
@ -20,7 +20,7 @@ func GetAllFriends(err error, packet nex.PacketInterface, callID uint32) uint32
friendRelationships, err := database_3ds.GetUserFriends(client.PID().LegacyValue())
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -34,20 +34,5 @@ func GetAllFriends(err error, packet nex.PacketInterface, callID uint32) uint32
rmcResponse.MethodID = friends_3ds.MethodGetAllFriends
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

25
nex/friends-3ds/get_friend_mii.go
View File

@ -9,18 +9,16 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetFriendMii(err error, packet nex.PacketInterface, callID uint32, pids []uint32) uint32 {
func GetFriendMii(err error, packet nex.PacketInterface, callID uint32, pids []uint32) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
miiList, err := database_3ds.GetFriendMiis(pids)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -34,20 +32,5 @@ func GetFriendMii(err error, packet nex.PacketInterface, callID uint32, pids []u
rmcResponse.MethodID = friends_3ds.MethodGetFriendMii
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

31
nex/friends-3ds/get_friend_persistent_info.go
View File

@ -9,18 +9,24 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetFriendPersistentInfo(err error, packet nex.PacketInterface, callID uint32, pids []uint32) uint32 {
func GetFriendPersistentInfo(err error, packet nex.PacketInterface, callID uint32, pids []*nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
client := packet.Sender().(*nex.PRUDPClient)
infoList, err := database_3ds.GetFriendPersistentInfos(client.PID().LegacyValue(), pids)
friendPIDs := make([]uint32, len(pids))
for _, pid := range pids {
friendPIDs = append(friendPIDs, pid.LegacyValue())
}
infoList, err := database_3ds.GetFriendPersistentInfos(client.PID().LegacyValue(), friendPIDs)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -34,20 +40,5 @@ func GetFriendPersistentInfo(err error, packet nex.PacketInterface, callID uint3
rmcResponse.MethodID = friends_3ds.MethodGetFriendPersistentInfo
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

27
nex/friends-3ds/get_friend_presence.go
View File

@ -7,23 +7,21 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func GetFriendPresence(err error, packet nex.PacketInterface, callID uint32, pids []uint32) uint32 {
func GetFriendPresence(err error, packet nex.PacketInterface, callID uint32, pids []*nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
client := packet.Sender().(*nex.PRUDPClient)
presenceList := make([]*friends_3ds_types.FriendPresence, 0)
for i := 0; i < len(pids); i++ {
connectedUser := globals.ConnectedUsers[pids[i]]
connectedUser := globals.ConnectedUsers[pids[i].LegacyValue()]
if connectedUser != nil && connectedUser.Presence != nil {
friendPresence := friends_3ds_types.NewFriendPresence()
friendPresence.PID = pids[i]
friendPresence.Presence = globals.ConnectedUsers[pids[i]].Presence
friendPresence.Presence = globals.ConnectedUsers[pids[i].LegacyValue()].Presence
presenceList = append(presenceList, friendPresence)
}
@ -40,20 +38,5 @@ func GetFriendPresence(err error, packet nex.PacketInterface, callID uint32, pid
rmcResponse.MethodID = friends_3ds.MethodGetFriendPresence
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

4
nex/friends-3ds/get_pid_by_lfc.go
View File

@ -6,7 +6,7 @@ import (
// friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetPrincipalIDByLocalFriendCode(err error, packet nex.PacketInterface, callID uint32, lfc uint64, lfcList []uint64) uint32 {
func GetPrincipalIDByLocalFriendCode(err error, packet nex.PacketInterface, callID uint32, lfc uint64, lfcList []uint64) (*nex.RMCMessage, uint32) {
// Respond with unimplemented, waiting for gRPC to retrieve PID from account server
// rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
@ -27,5 +27,5 @@ func GetPrincipalIDByLocalFriendCode(err error, packet nex.PacketInterface, call
// globals.SecureServer.Send(responsePacket)
return nex.Errors.Core.NotImplemented
return nil, nex.Errors.Core.NotImplemented
}

4
nex/friends-3ds/remove_friend_by_lfc.go
View File

@ -6,7 +6,7 @@ import (
// friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func RemoveFriendByLocalFriendCode(err error, packet nex.PacketInterface, callID uint32, friendLFC uint64) uint32 {
func RemoveFriendByLocalFriendCode(err error, packet nex.PacketInterface, callID uint32, friendLFC uint64) (*nex.RMCMessage, uint32) {
// Respond with unimplemented, waiting for gRPC to retrieve PID from account server
// rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
@ -27,5 +27,5 @@ func RemoveFriendByLocalFriendCode(err error, packet nex.PacketInterface, callID
// globals.SecureServer.Send(responsePacket)
return nex.Errors.Core.NotImplemented
return nil, nex.Errors.Core.NotImplemented
}

27
nex/friends-3ds/remove_friend_by_pid.go
View File

@ -9,23 +9,23 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func RemoveFriendByPrincipalID(err error, packet nex.PacketInterface, callID uint32, pid uint32) uint32 {
func RemoveFriendByPrincipalID(err error, packet nex.PacketInterface, callID uint32, pid *nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
err = database_3ds.RemoveFriendship(client.PID().LegacyValue(), pid)
err = database_3ds.RemoveFriendship(client.PID().LegacyValue(), pid.LegacyValue())
if err != nil {
if err == database.ErrFriendshipNotFound {
// * Official servers don't actually check this, but
// * we'll do it ourselves
return nex.Errors.FPD.NotFriend
return nil, nex.Errors.FPD.NotFriend
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
@ -36,20 +36,5 @@ func RemoveFriendByPrincipalID(err error, packet nex.PacketInterface, callID uin
rmcResponse.MethodID = friends_3ds.MethodRemoveFriendByPrincipalID
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

40
nex/friends-3ds/sync_friend.go
View File

@ -13,10 +13,10 @@ import (
"golang.org/x/exp/slices"
)
func SyncFriend(err error, packet nex.PacketInterface, callID uint32, lfc uint64, pids []uint32, lfcList []uint64) uint32 {
func SyncFriend(err error, packet nex.PacketInterface, callID uint32, lfc uint64, pids []*nex.PID, lfcList []uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -24,33 +24,33 @@ func SyncFriend(err error, packet nex.PacketInterface, callID uint32, lfc uint64
friendRelationships, err := database_3ds.GetUserFriends(client.PID().LegacyValue())
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
for i := 0; i < len(friendRelationships); i++ {
if !slices.Contains(pids, friendRelationships[i].PID) {
err := database_3ds.RemoveFriendship(client.PID().LegacyValue(), friendRelationships[i].PID)
err := database_3ds.RemoveFriendship(client.PID().LegacyValue(), friendRelationships[i].PID.LegacyValue())
if err != nil && err != database.ErrFriendshipNotFound {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
}
for i := 0; i < len(pids); i++ {
if !isPIDInRelationships(friendRelationships, pids[i]) {
friendRelationship, err := database_3ds.SaveFriendship(client.PID().LegacyValue(), pids[i])
if !isPIDInRelationships(friendRelationships, pids[i].LegacyValue()) {
friendRelationship, err := database_3ds.SaveFriendship(client.PID().LegacyValue(), pids[i].LegacyValue())
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
friendRelationships = append(friendRelationships, friendRelationship)
// Alert the other side, in case they weren't able to get our presence data
connectedUser := globals.ConnectedUsers[pids[i]]
connectedUser := globals.ConnectedUsers[pids[i].LegacyValue()]
if connectedUser != nil {
go notifications_3ds.SendFriendshipCompleted(connectedUser.Client, pids[i], client.PID().LegacyValue())
go notifications_3ds.SendFriendshipCompleted(connectedUser.Client, pids[i].LegacyValue(), client.PID())
}
}
}
@ -66,29 +66,15 @@ func SyncFriend(err error, packet nex.PacketInterface, callID uint32, lfc uint64
rmcResponse.MethodID = friends_3ds.MethodSyncFriend
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}
func isPIDInRelationships(relationships []*friends_3ds_types.FriendRelationship, pid uint32) bool {
for i := range relationships {
if relationships[i].PID == pid {
if relationships[i].PID.LegacyValue() == pid {
return true
}
}
return false
}

23
nex/friends-3ds/update_comment.go
View File

@ -8,10 +8,10 @@ import (
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment string) uint32 {
func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment string) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -19,7 +19,7 @@ func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment
err = database_3ds.UpdateUserComment(client.PID().LegacyValue(), comment)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
go notifications_3ds.SendCommentUpdate(client, comment)
@ -29,20 +29,5 @@ func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment
rmcResponse.MethodID = friends_3ds.MethodUpdateComment
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-3ds/update_favorite_game_key.go
View File

@ -9,10 +9,10 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateFavoriteGameKey(err error, packet nex.PacketInterface, callID uint32, gameKey *friends_3ds_types.GameKey) uint32 {
func UpdateFavoriteGameKey(err error, packet nex.PacketInterface, callID uint32, gameKey *friends_3ds_types.GameKey) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -20,7 +20,7 @@ func UpdateFavoriteGameKey(err error, packet nex.PacketInterface, callID uint32,
err = database_3ds.UpdateUserFavoriteGame(client.PID().LegacyValue(), gameKey)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
go notifications_3ds.SendFavoriteUpdate(client, gameKey)
@ -30,20 +30,5 @@ func UpdateFavoriteGameKey(err error, packet nex.PacketInterface, callID uint32,
rmcResponse.MethodID = friends_3ds.MethodUpdateFavoriteGameKey
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-3ds/update_mii.go
View File

@ -9,10 +9,10 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateMii(err error, packet nex.PacketInterface, callID uint32, mii *friends_3ds_types.Mii) uint32 {
func UpdateMii(err error, packet nex.PacketInterface, callID uint32, mii *friends_3ds_types.Mii) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -20,7 +20,7 @@ func UpdateMii(err error, packet nex.PacketInterface, callID uint32, mii *friend
err = database_3ds.UpdateUserMii(client.PID().LegacyValue(), mii)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
go notifications_3ds.SendMiiUpdateNotification(client)
@ -30,20 +30,5 @@ func UpdateMii(err error, packet nex.PacketInterface, callID uint32, mii *friend
rmcResponse.MethodID = friends_3ds.MethodUpdateMii
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-3ds/update_preference.go
View File

@ -9,10 +9,10 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, showOnline bool, showCurrentGame bool, showPlayedGame bool) uint32 {
func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, showOnline bool, showCurrentGame bool, showPlayedGame bool) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -20,7 +20,7 @@ func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, show
err = database_3ds.UpdateUserPreferences(client.PID().LegacyValue(), showOnline, showCurrentGame)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
if !showCurrentGame {
@ -38,20 +38,5 @@ func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, show
rmcResponse.MethodID = friends_3ds.MethodUpdatePreference
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

21
nex/friends-3ds/update_presence.go
View File

@ -9,10 +9,10 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presence *friends_3ds_types.NintendoPresence, showGame bool) uint32 {
func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presence *friends_3ds_types.NintendoPresence, showGame bool) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -47,20 +47,5 @@ func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presen
rmcResponse.MethodID = friends_3ds.MethodUpdatePresence
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-3ds/update_profile.go
View File

@ -8,10 +8,10 @@ import (
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateProfile(err error, packet nex.PacketInterface, callID uint32, profileData *friends_3ds_types.MyProfile) uint32 {
func UpdateProfile(err error, packet nex.PacketInterface, callID uint32, profileData *friends_3ds_types.MyProfile) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -19,7 +19,7 @@ func UpdateProfile(err error, packet nex.PacketInterface, callID uint32, profile
err = database_3ds.UpdateUserProfile(client.PID().LegacyValue(), profileData)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponse := nex.NewRMCSuccess(nil)
@ -27,20 +27,5 @@ func UpdateProfile(err error, packet nex.PacketInterface, callID uint32, profile
rmcResponse.MethodID = friends_3ds.MethodUpdateProfile
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

29
nex/friends-wiiu/accept_friend_request.go
View File

@ -10,10 +10,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AcceptFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) uint32 {
func AcceptFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -21,14 +21,14 @@ func AcceptFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
friendInfo, err := database_wiiu.AcceptFriendRequestAndReturnFriendInfo(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
return nil, nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
friendPID := friendInfo.NNAInfo.PrincipalBasicInfo.PID
friendPID := friendInfo.NNAInfo.PrincipalBasicInfo.PID.LegacyValue()
connectedUser := globals.ConnectedUsers[friendPID]
if connectedUser != nil {
@ -49,7 +49,7 @@ func AcceptFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
}
senderFriendInfo.BecameFriend = friendInfo.BecameFriend
senderFriendInfo.LastOnline = friendInfo.LastOnline // TODO: Change this
senderFriendInfo.LastOnline = friendInfo.LastOnline // TODO - Change this
senderFriendInfo.Unknown = 0
go notifications_wiiu.SendFriendRequestAccepted(connectedUser.Client, senderFriendInfo)
@ -66,20 +66,5 @@ func AcceptFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
rmcResponse.MethodID = friends_wiiu.MethodAcceptFriendRequest
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

38
nex/friends-wiiu/add_blacklist.go
View File

@ -1,8 +1,6 @@
package nex_friends_wiiu
import (
"time"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
@ -12,10 +10,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AddBlacklist(err error, packet nex.PacketInterface, callID uint32, blacklistPrincipal *friends_wiiu_types.BlacklistedPrincipal) uint32 {
func AddBlacklist(err error, packet nex.PacketInterface, callID uint32, blacklistPrincipal *friends_wiiu_types.BlacklistedPrincipal) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -26,26 +24,23 @@ func AddBlacklist(err error, packet nex.PacketInterface, callID uint32, blacklis
titleID := currentBlacklistPrincipal.GameKey.TitleID
titleVersion := currentBlacklistPrincipal.GameKey.TitleVersion
date := nex.NewDateTime(0)
date.FromTimestamp(time.Now())
userInfo, err := utility.GetUserInfoByPID(currentBlacklistPrincipal.PrincipalBasicInfo.PID)
userInfo, err := utility.GetUserInfoByPID(currentBlacklistPrincipal.PrincipalBasicInfo.PID.LegacyValue())
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID // TODO: Not sure if this is the correct error.
return nil, nex.Errors.FPD.InvalidPrincipalID // TODO - Not sure if this is the correct error.
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
currentBlacklistPrincipal.PrincipalBasicInfo = userInfo
currentBlacklistPrincipal.BlackListedSince = date
currentBlacklistPrincipal.BlackListedSince = nex.NewDateTime(0).Now()
err = database_wiiu.SetUserBlocked(client.PID().LegacyValue(), senderPID, titleID, titleVersion)
err = database_wiiu.SetUserBlocked(client.PID().LegacyValue(), senderPID.LegacyValue(), titleID, titleVersion)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -59,20 +54,5 @@ func AddBlacklist(err error, packet nex.PacketInterface, callID uint32, blacklis
rmcResponse.MethodID = friends_wiiu.MethodAddBlackList
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

65
nex/friends-wiiu/add_friend_request.go
View File

@ -13,31 +13,31 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid uint32, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *friends_wiiu_types.GameKey, unknown6 *nex.DateTime) uint32 {
func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid *nex.PID, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *friends_wiiu_types.GameKey, unknown6 *nex.DateTime) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
senderPID := client.PID().LegacyValue()
recipientPID := pid
recipientPID := pid.LegacyValue()
senderPrincipalInfo, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
recipientPrincipalInfo, err := utility.GetUserInfoByPID(recipientPID)
if err != nil {
if err == database.ErrPIDNotFound {
globals.Logger.Errorf("User %d has sent friend request to invalid PID %d", senderPID, pid)
return nex.Errors.FPD.InvalidPrincipalID // TODO: Not sure if this is the correct error.
return nil, nex.Errors.FPD.InvalidPrincipalID // TODO - Not sure if this is the correct error.
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
@ -53,7 +53,7 @@ func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid
friendRequestID, err := database_wiiu.SaveFriendRequest(senderPID, recipientPID, sentTime.Value(), expireTime.Value(), message)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
friendRequest := friends_wiiu_types.NewFriendRequest()
@ -63,21 +63,21 @@ func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid
friendRequest.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequest.Message.FriendRequestID = friendRequestID
friendRequest.Message.Received = false
friendRequest.Message.Unknown2 = 1 // replaying from real
friendRequest.Message.Unknown2 = 1 // * Replaying from official server
friendRequest.Message.Message = message
friendRequest.Message.Unknown3 = 0 // replaying from real server
friendRequest.Message.Unknown4 = "" // replaying from real server
friendRequest.Message.GameKey = gameKey // maybe this is reused?
friendRequest.Message.Unknown5 = unknown6 // maybe this is reused?
friendRequest.Message.ExpiresOn = expireTime // no idea why this is set as the sent time
friendRequest.Message.Unknown3 = 0 // * Replaying from official server
friendRequest.Message.Unknown4 = "" // * Replaying from official server
friendRequest.Message.GameKey = gameKey // * Maybe this is reused?
friendRequest.Message.Unknown5 = unknown6 // * Maybe this is reused?
friendRequest.Message.ExpiresOn = expireTime // * No idea why this is set as the sent time
friendRequest.SentOn = sentTime
// Why does this exist?? Always empty??
// * Why does this exist?? Always empty??
friendInfo := friends_wiiu_types.NewFriendInfo()
friendInfo.NNAInfo = friends_wiiu_types.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = friends_wiiu_types.NewPrincipalBasicInfo()
friendInfo.NNAInfo.PrincipalBasicInfo.PID = 0
friendInfo.NNAInfo.PrincipalBasicInfo.PID = nex.NewPID[uint32](0)
friendInfo.NNAInfo.PrincipalBasicInfo.NNID = ""
friendInfo.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu_types.NewMiiV2()
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Name = ""
@ -92,14 +92,14 @@ func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid
friendInfo.Presence = friends_wiiu_types.NewNintendoPresenceV2()
friendInfo.Presence.ChangedFlags = 0
friendInfo.Presence.Online = false
friendInfo.Presence.GameKey = gameKey // maybe this is reused?
friendInfo.Presence.GameKey = gameKey // * Maybe this is reused?
friendInfo.Presence.Unknown1 = 0
friendInfo.Presence.Message = ""
friendInfo.Presence.Unknown2 = 0
friendInfo.Presence.Unknown3 = 0
friendInfo.Presence.GameServerID = 0
friendInfo.Presence.Unknown4 = 0
friendInfo.Presence.PID = 0
friendInfo.Presence.PID = nex.NewPID[uint32](0)
friendInfo.Presence.GatheringID = 0
friendInfo.Presence.ApplicationData = []byte{0x00}
friendInfo.Presence.Unknown5 = 0
@ -118,21 +118,19 @@ func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid
recipientClient := globals.ConnectedUsers[recipientPID]
if recipientClient != nil {
friendRequestNotificationData := friends_wiiu_types.NewFriendRequest()
friendRequestNotificationData.PrincipalInfo = senderPrincipalInfo
friendRequestNotificationData.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequestNotificationData.Message.FriendRequestID = friendRequestID
friendRequestNotificationData.Message.Received = false
friendRequestNotificationData.Message.Unknown2 = 1 // replaying from real
friendRequestNotificationData.Message.Unknown2 = 1 // * Replaying from official server
friendRequestNotificationData.Message.Message = message
friendRequestNotificationData.Message.Unknown3 = 0 // replaying from real server
friendRequestNotificationData.Message.Unknown4 = "" // replaying from real server
friendRequestNotificationData.Message.GameKey = gameKey // maybe this is reused?
friendRequestNotificationData.Message.Unknown5 = unknown6 // maybe this is reused?
friendRequestNotificationData.Message.ExpiresOn = expireTime // no idea why this is set as the sent time
friendRequestNotificationData.Message.Unknown3 = 0 // * Replaying from server server
friendRequestNotificationData.Message.Unknown4 = "" // * Replaying from server server
friendRequestNotificationData.Message.GameKey = gameKey // * Maybe this is reused?
friendRequestNotificationData.Message.Unknown5 = unknown6 // * Maybe this is reused?
friendRequestNotificationData.Message.ExpiresOn = expireTime // * No idea why this is set as the sent time
friendRequestNotificationData.SentOn = sentTime
go notifications_wiiu.SendFriendRequest(recipientClient.Client, friendRequestNotificationData)
@ -150,20 +148,5 @@ func AddFriendRequest(err error, packet nex.PacketInterface, callID uint32, pid
rmcResponse.MethodID = friends_wiiu.MethodAddFriendRequest
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

29
nex/friends-wiiu/cancel_friend_request.go
View File

@ -9,10 +9,10 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func CancelFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) uint32 {
func CancelFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -20,17 +20,17 @@ func CancelFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
pid, err := database_wiiu.DeleteFriendRequestAndReturnFriendPID(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
return nil, nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
connectedUser := globals.ConnectedUsers[pid]
if connectedUser != nil {
// This may send the friend removed notification, but they are the same.
go notifications_wiiu.SendFriendshipRemoved(connectedUser.Client, client.PID().LegacyValue())
// * This may send the friend removed notification, but they are the same.
go notifications_wiiu.SendFriendshipRemoved(connectedUser.Client, client.PID())
}
rmcResponse := nex.NewRMCSuccess(nil)
@ -38,20 +38,5 @@ func CancelFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
rmcResponse.MethodID = friends_wiiu.MethodCancelFriendRequest
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-wiiu/check_setting_status.go
View File

@ -6,14 +6,12 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func CheckSettingStatus(err error, packet nex.PacketInterface, callID uint32) uint32 {
func CheckSettingStatus(err error, packet nex.PacketInterface, callID uint32) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
client := packet.Sender().(*nex.PRUDPClient)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteUInt8(0xFF)
@ -25,20 +23,5 @@ func CheckSettingStatus(err error, packet nex.PacketInterface, callID uint32) ui
rmcResponse.MethodID = friends_wiiu.MethodCheckSettingStatus
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

27
nex/friends-wiiu/delete_friend_request.go
View File

@ -8,21 +8,19 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func DeleteFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) uint32 {
func DeleteFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
err = database_wiiu.SetFriendRequestDenied(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
return nil, nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
@ -31,20 +29,5 @@ func DeleteFriendRequest(err error, packet nex.PacketInterface, callID uint32, i
rmcResponse.MethodID = friends_wiiu.MethodDeleteFriendRequest
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

25
nex/friends-wiiu/delete_persistent_notification.go
View File

@ -7,35 +7,18 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func DeletePersistentNotification(err error, packet nex.PacketInterface, callID uint32, notifications []*friends_wiiu_types.PersistentNotification) uint32 {
func DeletePersistentNotification(err error, packet nex.PacketInterface, callID uint32, notifications []*friends_wiiu_types.PersistentNotification) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
// TODO: Do something here
// TODO - Do something here
rmcResponse := nex.NewRMCSuccess(nil)
rmcResponse.ProtocolID = friends_wiiu.ProtocolID
rmcResponse.MethodID = friends_wiiu.MethodDeletePersistentNotification
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

31
nex/friends-wiiu/deny_friend_request.go
View File

@ -12,10 +12,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func DenyFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) uint32 {
func DenyFriendRequest(err error, packet nex.PacketInterface, callID uint32, id uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -23,29 +23,29 @@ func DenyFriendRequest(err error, packet nex.PacketInterface, callID uint32, id
err = database_wiiu.SetFriendRequestDenied(id)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
senderPID, _, err := database_wiiu.GetPIDsByFriendRequestID(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
return nil, nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
err = database_wiiu.SetUserBlocked(client.PID().LegacyValue(), senderPID, 0, 0)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
info, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
date := nex.NewDateTime(0)
@ -69,20 +69,5 @@ func DenyFriendRequest(err error, packet nex.PacketInterface, callID uint32, id
rmcResponse.MethodID = friends_wiiu.MethodDenyFriendRequest
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

29
nex/friends-wiiu/get_basic_info.go
View File

@ -8,26 +8,24 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func GetBasicInfo(err error, packet nex.PacketInterface, callID uint32, pids []uint32) uint32 {
func GetBasicInfo(err error, packet nex.PacketInterface, callID uint32, pids []*nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
infos := make([]*friends_wiiu_types.PrincipalBasicInfo, 0)
for i := 0; i < len(pids); i++ {
pid := pids[i]
info, err := utility.GetUserInfoByPID(pid)
info, err := utility.GetUserInfoByPID(pid.LegacyValue())
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
if info.PID != 0 {
if info.PID.LegacyValue() != 0 {
infos = append(infos, info)
}
}
@ -43,20 +41,5 @@ func GetBasicInfo(err error, packet nex.PacketInterface, callID uint32, pids []u
rmcResponse.MethodID = friends_wiiu.MethodGetBasicInfo
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-wiiu/get_request_block_settings.go
View File

@ -8,10 +8,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func GetRequestBlockSettings(err error, packet nex.PacketInterface, callID uint32, pids []uint32) uint32 {
func GetRequestBlockSettings(err error, packet nex.PacketInterface, callID uint32, pids []uint32) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -28,7 +28,7 @@ func GetRequestBlockSettings(err error, packet nex.PacketInterface, callID uint3
isBlocked, err := database_wiiu.IsFriendRequestBlocked(client.PID().LegacyValue(), requestedPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.Core.Unknown
return nil, nex.Errors.Core.Unknown
}
setting.IsBlocked = isBlocked
@ -47,20 +47,5 @@ func GetRequestBlockSettings(err error, packet nex.PacketInterface, callID uint3
rmcResponse.MethodID = friends_wiiu.MethodGetRequestBlockSettings
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

25
nex/friends-wiiu/mark_friend_requests_as_received.go
View File

@ -7,20 +7,18 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func MarkFriendRequestsAsReceived(err error, packet nex.PacketInterface, callID uint32, ids []uint64) uint32 {
func MarkFriendRequestsAsReceived(err error, packet nex.PacketInterface, callID uint32, ids []uint64) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
for i := 0; i < len(ids); i++ {
id := ids[i]
err = database_wiiu.SetFriendRequestReceived(id)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
@ -29,20 +27,5 @@ func MarkFriendRequestsAsReceived(err error, packet nex.PacketInterface, callID
rmcResponse.MethodID = friends_wiiu.MethodMarkFriendRequestsAsReceived
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

27
nex/friends-wiiu/remove_blacklist.go
View File

@ -8,21 +8,21 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func RemoveBlacklist(err error, packet nex.PacketInterface, callID uint32, blockedPID uint32) uint32 {
func RemoveBlacklist(err error, packet nex.PacketInterface, callID uint32, blockedPID *nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
err = database_wiiu.UnsetUserBlocked(client.PID().LegacyValue(), blockedPID)
err = database_wiiu.UnsetUserBlocked(client.PID().LegacyValue(), blockedPID.LegacyValue())
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.NotInMyBlacklist
return nil, nex.Errors.FPD.NotInMyBlacklist
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
@ -31,20 +31,5 @@ func RemoveBlacklist(err error, packet nex.PacketInterface, callID uint32, block
rmcResponse.MethodID = friends_wiiu.MethodRemoveBlackList
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

29
nex/friends-wiiu/remove_friend.go
View File

@ -9,25 +9,25 @@ import (
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func RemoveFriend(err error, packet nex.PacketInterface, callID uint32, pid uint32) uint32 {
func RemoveFriend(err error, packet nex.PacketInterface, callID uint32, pid *nex.PID) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
err = database_wiiu.RemoveFriendship(client.PID().LegacyValue(), pid)
err = database_wiiu.RemoveFriendship(client.PID().LegacyValue(), pid.LegacyValue())
if err != nil {
if err == database.ErrFriendshipNotFound {
return nex.Errors.FPD.NotInMyFriendList
return nil, nex.Errors.FPD.NotInMyFriendList
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
connectedUser := globals.ConnectedUsers[pid]
connectedUser := globals.ConnectedUsers[pid.LegacyValue()]
if connectedUser != nil {
go notifications_wiiu.SendFriendshipRemoved(connectedUser.Client, pid)
}
@ -37,20 +37,5 @@ func RemoveFriend(err error, packet nex.PacketInterface, callID uint32, pid uint
rmcResponse.MethodID = friends_wiiu.MethodRemoveFriend
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

55
nex/friends-wiiu/update_and_get_all_information.go
View File

@ -14,15 +14,15 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID uint32, nnaInfo *friends_wiiu_types.NNAInfo, presence *friends_wiiu_types.NintendoPresenceV2, birthday *nex.DateTime) uint32 {
func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID uint32, nnaInfo *friends_wiiu_types.NNAInfo, presence *friends_wiiu_types.NintendoPresenceV2, birthday *nex.DateTime) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
// Get user information
// * Get user information
pid := client.PID().LegacyValue()
if globals.ConnectedUsers[pid] == nil {
@ -41,53 +41,53 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
principalPreference, err := database_wiiu.GetUserPrincipalPreference(pid)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID
return nil, nex.Errors.FPD.InvalidPrincipalID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
comment, err := database_wiiu.GetUserComment(pid)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID
return nil, nex.Errors.FPD.InvalidPrincipalID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
}
friendList, err := database_wiiu.GetUserFriendList(pid)
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
friendRequestsOut, err := database_wiiu.GetUserFriendRequestsOut(pid)
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
friendRequestsIn, err := database_wiiu.GetUserFriendRequestsIn(pid)
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
blockList, err := database_wiiu.GetUserBlockList(pid)
if err != nil && err != database.ErrBlacklistNotFound {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
notifications := database_wiiu.GetUserNotifications(pid)
// Update user information
// * Update user information
presence.Online = true // Force online status. I have no idea why this is always false
presence.PID = pid // WHY IS THIS SET TO 0 BY DEFAULT??
presence.Online = true // * Force online status. I have no idea why this is always false
presence.PID = client.PID() // * WHY IS THIS SET TO 0 BY DEFAULT??
notifications_wiiu.SendPresenceUpdate(presence)
@ -105,7 +105,7 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
bella.NNAInfo.Unknown1 = 0
bella.NNAInfo.Unknown2 = 0
bella.NNAInfo.PrincipalBasicInfo.PID = 1743126339
bella.NNAInfo.PrincipalBasicInfo.PID = nex.NewPID[uint32](1743126339)
bella.NNAInfo.PrincipalBasicInfo.NNID = "bells1998"
bella.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu_types.NewMiiV2()
bella.NNAInfo.PrincipalBasicInfo.Unknown = 0
@ -142,7 +142,7 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
bella.Presence.GameServerID = 0
//bella.Presence.Unknown4 = 3
bella.Presence.Unknown4 = 0
bella.Presence.PID = 1743126339
bella.Presence.PID = nex.NewPID[uint32](1743126339)
//bella.Presence.GatheringID = 1743126339 // test fake ID
bella.Presence.GatheringID = 0
//bella.Presence.ApplicationData, _ = hex.DecodeString("0000200300000000000000001843ffe567000000")
@ -183,7 +183,7 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
friend.NNAInfo.Unknown1 = 0
friend.NNAInfo.Unknown2 = 0
friend.NNAInfo.PrincipalBasicInfo.PID = pid
friend.NNAInfo.PrincipalBasicInfo.PID = nex.NewPID[uint32](pid)
friend.NNAInfo.PrincipalBasicInfo.NNID = fmt.Sprint(pid)
friend.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu_types.NewMiiV2()
friend.NNAInfo.PrincipalBasicInfo.Unknown = 0
@ -220,7 +220,7 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
friend.Presence.GameServerID = 0
//bella.Presence.Unknown4 = 3
friend.Presence.Unknown4 = 0
friend.Presence.PID = pid
friend.Presence.PID = nex.NewPID[uint32](pid)
//bella.Presence.GatheringID = 1743126339 // test fake ID
friend.Presence.GatheringID = 0
//bella.Presence.ApplicationData, _ = hex.DecodeString("0000200300000000000000001843ffe567000000")
@ -260,22 +260,5 @@ func UpdateAndGetAllInformation(err error, packet nex.PacketInterface, callID ui
rmcResponse.MethodID = friends_wiiu.MethodUpdateAndGetAllInformation
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
responsePacket.SetRMCMessage(rmcResponse)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-wiiu/update_comment.go
View File

@ -8,10 +8,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment *friends_wiiu_types.Comment) uint32 {
func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment *friends_wiiu_types.Comment) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -19,7 +19,7 @@ func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment
changed, err := database_wiiu.UpdateUserComment(client.PID().LegacyValue(), comment.Contents)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
@ -33,20 +33,5 @@ func UpdateComment(err error, packet nex.PacketInterface, callID uint32, comment
rmcResponse.MethodID = friends_wiiu.MethodUpdateComment
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

23
nex/friends-wiiu/update_preference.go
View File

@ -8,10 +8,10 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, principalPreference *friends_wiiu_types.PrincipalPreference) uint32 {
func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, principalPreference *friends_wiiu_types.PrincipalPreference) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -19,7 +19,7 @@ func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, prin
err = database_wiiu.UpdateUserPrincipalPreference(client.PID().LegacyValue(), principalPreference)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
return nil, nex.Errors.FPD.Unknown
}
rmcResponse := nex.NewRMCSuccess(nil)
@ -27,20 +27,5 @@ func UpdatePreference(err error, packet nex.PacketInterface, callID uint32, prin
rmcResponse.MethodID = friends_wiiu.MethodUpdatePreference
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

25
nex/friends-wiiu/update_presence.go
View File

@ -9,18 +9,18 @@ import (
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presence *friends_wiiu_types.NintendoPresenceV2) uint32 {
func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presence *friends_wiiu_types.NintendoPresenceV2) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
return nil, nex.Errors.FPD.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
pid := client.PID().LegacyValue()
presence.Online = true // Force online status. I have no idea why this is always false
presence.PID = pid // WHY IS THIS SET TO 0 BY DEFAULT??
presence.Online = true // * Force online status. I have no idea why this is always false
presence.PID = client.PID() // * WHY IS THIS SET TO 0 BY DEFAULT??
if globals.ConnectedUsers[pid] == nil {
// TODO - Figure out why this is getting removed
@ -42,20 +42,5 @@ func UpdatePresence(err error, packet nex.PacketInterface, callID uint32, presen
rmcResponse.MethodID = friends_wiiu.MethodUpdatePresence
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

2
nex/register_common_secure_server_protocols.go
View File

@ -8,5 +8,5 @@ import (
func registerCommonSecureServerProtocols() {
secureConnectionProtocol := secureconnection.NewCommonSecureConnectionProtocol(globals.SecureServer)
secureConnectionProtocol.RegisterEx(nex_secure_connection.RegisterEx)
secureConnectionProtocol.RegisterEx = nex_secure_connection.RegisterEx
}

72
nex/register_secure_server_protocols.go
View File

@ -15,42 +15,42 @@ func registerSecureServerProtocols() {
friendsWiiUProtocol := friends_wiiu.NewProtocol(globals.SecureServer)
friends3DSProtocol := friends_3ds.NewProtocol(globals.SecureServer)
// Account Management protocol handles
accountManagementProtocol.NintendoCreateAccount(nex_account_management.NintendoCreateAccount)
// * Account Management protocol handles
accountManagementProtocol.NintendoCreateAccount = nex_account_management.NintendoCreateAccount
// Friends (WiiU) protocol handles
friendsWiiUProtocol.UpdateAndGetAllInformation(nex_friends_wiiu.UpdateAndGetAllInformation)
friendsWiiUProtocol.AddFriendRequest(nex_friends_wiiu.AddFriendRequest)
friendsWiiUProtocol.RemoveFriend(nex_friends_wiiu.RemoveFriend)
friendsWiiUProtocol.CancelFriendRequest(nex_friends_wiiu.CancelFriendRequest)
friendsWiiUProtocol.AcceptFriendRequest(nex_friends_wiiu.AcceptFriendRequest)
friendsWiiUProtocol.DeleteFriendRequest(nex_friends_wiiu.DeleteFriendRequest)
friendsWiiUProtocol.DenyFriendRequest(nex_friends_wiiu.DenyFriendRequest)
friendsWiiUProtocol.MarkFriendRequestsAsReceived(nex_friends_wiiu.MarkFriendRequestsAsReceived)
friendsWiiUProtocol.AddBlackList(nex_friends_wiiu.AddBlacklist)
friendsWiiUProtocol.RemoveBlackList(nex_friends_wiiu.RemoveBlacklist)
friendsWiiUProtocol.UpdatePresence(nex_friends_wiiu.UpdatePresence)
friendsWiiUProtocol.UpdateComment(nex_friends_wiiu.UpdateComment)
friendsWiiUProtocol.UpdatePreference(nex_friends_wiiu.UpdatePreference)
friendsWiiUProtocol.GetBasicInfo(nex_friends_wiiu.GetBasicInfo)
friendsWiiUProtocol.DeletePersistentNotification(nex_friends_wiiu.DeletePersistentNotification)
friendsWiiUProtocol.CheckSettingStatus(nex_friends_wiiu.CheckSettingStatus)
friendsWiiUProtocol.GetRequestBlockSettings(nex_friends_wiiu.GetRequestBlockSettings)
// * Friends (WiiU) protocol handles
friendsWiiUProtocol.UpdateAndGetAllInformation = nex_friends_wiiu.UpdateAndGetAllInformation
friendsWiiUProtocol.AddFriendRequest = nex_friends_wiiu.AddFriendRequest
friendsWiiUProtocol.RemoveFriend = nex_friends_wiiu.RemoveFriend
friendsWiiUProtocol.CancelFriendRequest = nex_friends_wiiu.CancelFriendRequest
friendsWiiUProtocol.AcceptFriendRequest = nex_friends_wiiu.AcceptFriendRequest
friendsWiiUProtocol.DeleteFriendRequest = nex_friends_wiiu.DeleteFriendRequest
friendsWiiUProtocol.DenyFriendRequest = nex_friends_wiiu.DenyFriendRequest
friendsWiiUProtocol.MarkFriendRequestsAsReceived = nex_friends_wiiu.MarkFriendRequestsAsReceived
friendsWiiUProtocol.AddBlackList = nex_friends_wiiu.AddBlacklist
friendsWiiUProtocol.RemoveBlackList = nex_friends_wiiu.RemoveBlacklist
friendsWiiUProtocol.UpdatePresence = nex_friends_wiiu.UpdatePresence
friendsWiiUProtocol.UpdateComment = nex_friends_wiiu.UpdateComment
friendsWiiUProtocol.UpdatePreference = nex_friends_wiiu.UpdatePreference
friendsWiiUProtocol.GetBasicInfo = nex_friends_wiiu.GetBasicInfo
friendsWiiUProtocol.DeletePersistentNotification = nex_friends_wiiu.DeletePersistentNotification
friendsWiiUProtocol.CheckSettingStatus = nex_friends_wiiu.CheckSettingStatus
friendsWiiUProtocol.GetRequestBlockSettings = nex_friends_wiiu.GetRequestBlockSettings
// Friends (3DS) protocol handles
friends3DSProtocol.UpdateProfile(nex_friends_3ds.UpdateProfile)
friends3DSProtocol.UpdateMii(nex_friends_3ds.UpdateMii)
friends3DSProtocol.UpdatePreference(nex_friends_3ds.UpdatePreference)
friends3DSProtocol.SyncFriend(nex_friends_3ds.SyncFriend)
friends3DSProtocol.UpdatePresence(nex_friends_3ds.UpdatePresence)
friends3DSProtocol.UpdateFavoriteGameKey(nex_friends_3ds.UpdateFavoriteGameKey)
friends3DSProtocol.UpdateComment(nex_friends_3ds.UpdateComment)
friends3DSProtocol.AddFriendByPrincipalID(nex_friends_3ds.AddFriendshipByPrincipalID)
friends3DSProtocol.GetFriendPersistentInfo(nex_friends_3ds.GetFriendPersistentInfo)
friends3DSProtocol.GetFriendMii(nex_friends_3ds.GetFriendMii)
friends3DSProtocol.GetFriendPresence(nex_friends_3ds.GetFriendPresence)
friends3DSProtocol.RemoveFriendByPrincipalID(nex_friends_3ds.RemoveFriendByPrincipalID)
friends3DSProtocol.RemoveFriendByLocalFriendCode(nex_friends_3ds.RemoveFriendByLocalFriendCode)
friends3DSProtocol.GetPrincipalIDByLocalFriendCode(nex_friends_3ds.GetPrincipalIDByLocalFriendCode)
friends3DSProtocol.GetAllFriends(nex_friends_3ds.GetAllFriends)
// * Friends (3DS) protocol handles
friends3DSProtocol.UpdateProfile = nex_friends_3ds.UpdateProfile
friends3DSProtocol.UpdateMii = nex_friends_3ds.UpdateMii
friends3DSProtocol.UpdatePreference = nex_friends_3ds.UpdatePreference
friends3DSProtocol.SyncFriend = nex_friends_3ds.SyncFriend
friends3DSProtocol.UpdatePresence = nex_friends_3ds.UpdatePresence
friends3DSProtocol.UpdateFavoriteGameKey = nex_friends_3ds.UpdateFavoriteGameKey
friends3DSProtocol.UpdateComment = nex_friends_3ds.UpdateComment
friends3DSProtocol.AddFriendByPrincipalID = nex_friends_3ds.AddFriendshipByPrincipalID
friends3DSProtocol.GetFriendPersistentInfo = nex_friends_3ds.GetFriendPersistentInfo
friends3DSProtocol.GetFriendMii = nex_friends_3ds.GetFriendMii
friends3DSProtocol.GetFriendPresence = nex_friends_3ds.GetFriendPresence
friends3DSProtocol.RemoveFriendByPrincipalID = nex_friends_3ds.RemoveFriendByPrincipalID
friends3DSProtocol.RemoveFriendByLocalFriendCode = nex_friends_3ds.RemoveFriendByLocalFriendCode
friends3DSProtocol.GetPrincipalIDByLocalFriendCode = nex_friends_3ds.GetPrincipalIDByLocalFriendCode
friends3DSProtocol.GetAllFriends = nex_friends_3ds.GetAllFriends
}

26
nex/secure-connection/register_ex.go
View File

@ -12,10 +12,10 @@ import (
secure_connection "github.com/PretendoNetwork/nex-protocols-go/secure-connection"
)
func RegisterEx(err error, packet nex.PacketInterface, callID uint32, stationUrls []*nex.StationURL, loginData *nex.DataHolder) uint32 {
func RegisterEx(err error, packet nex.PacketInterface, callID uint32, stationUrls []*nex.StationURL, loginData *nex.DataHolder) (*nex.RMCMessage, uint32) {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Core.InvalidArgument
return nil, nex.Errors.Core.InvalidArgument
}
client := packet.Sender().(*nex.PRUDPClient)
@ -36,7 +36,7 @@ func RegisterEx(err error, packet nex.PacketInterface, callID uint32, stationUrl
loginDataType := loginData.TypeName()
switch loginDataType {
case "NintendoLoginData":
user.Platform = types.WUP // Platform is Wii U
user.Platform = types.WUP // * Platform is Wii U
err = database_wiiu.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
@ -44,7 +44,7 @@ func RegisterEx(err error, packet nex.PacketInterface, callID uint32, stationUrl
retval = nex.NewResultError(nex.Errors.Authentication.Unknown)
}
case "AccountExtraInfo":
user.Platform = types.CTR // Platform is 3DS
user.Platform = types.CTR // * Platform is 3DS
err = database_3ds.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
@ -79,26 +79,10 @@ func RegisterEx(err error, packet nex.PacketInterface, callID uint32, stationUrl
rmcResponseBody := rmcResponseStream.Bytes()
// Build response packet
rmcResponse := nex.NewRMCSuccess(rmcResponseBody)
rmcResponse.ProtocolID = secure_connection.ProtocolID
rmcResponse.MethodID = secure_connection.MethodRegisterEx
rmcResponse.CallID = callID
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPRUDPPacketV0(client, nil)
responsePacket.SetType(nex.DataPacket)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
responsePacket.SetSourceStreamType(packet.(nex.PRUDPPacketInterface).DestinationStreamType())
responsePacket.SetSourcePort(packet.(nex.PRUDPPacketInterface).DestinationPort())
responsePacket.SetDestinationStreamType(packet.(nex.PRUDPPacketInterface).SourceStreamType())
responsePacket.SetDestinationPort(packet.(nex.PRUDPPacketInterface).SourcePort())
responsePacket.SetPayload(rmcResponseBytes)
globals.SecureServer.Send(responsePacket)
return 0
return rmcResponse, 0
}

4
notifications/3ds/send_comment_update.go
View File

@ -16,7 +16,7 @@ func SendCommentUpdate(client *nex.PRUDPClient, comment string) {
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 3
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("NintendoNotificationEventGeneral")
eventObject.DataHolder.SetObjectData(notificationEvent)
@ -39,7 +39,7 @@ func SendCommentUpdate(client *nex.PRUDPClient, comment string) {
for i := 0; i < len(friendsList); i++ {
connectedUser := globals.ConnectedUsers[friendsList[i].PID]
connectedUser := globals.ConnectedUsers[friendsList[i].PID.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

4
notifications/3ds/send_favorite_update.go
View File

@ -14,7 +14,7 @@ import (
func SendFavoriteUpdate(client *nex.PRUDPClient, gameKey *friends_3ds_types.GameKey) {
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 2
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("GameKey")
eventObject.DataHolder.SetObjectData(gameKey)
@ -37,7 +37,7 @@ func SendFavoriteUpdate(client *nex.PRUDPClient, gameKey *friends_3ds_types.Game
for i := 0; i < len(friendsList); i++ {
connectedUser := globals.ConnectedUsers[friendsList[i].PID]
connectedUser := globals.ConnectedUsers[friendsList[i].PID.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

2
notifications/3ds/send_friendship_completed.go
View File

@ -7,7 +7,7 @@ import (
nintendo_notifications_types "github.com/PretendoNetwork/nex-protocols-go/nintendo-notifications/types"
)
func SendFriendshipCompleted(client *nex.PRUDPClient, friendPID uint32, senderPID uint32) {
func SendFriendshipCompleted(client *nex.PRUDPClient, friendPID uint32, senderPID *nex.PID) {
notificationEvent := nintendo_notifications_types.NewNintendoNotificationEventGeneral()
notificationEvent.U32Param = 0
notificationEvent.U64Param1 = 0

4
notifications/3ds/send_mii_notification.go
View File

@ -15,7 +15,7 @@ func SendMiiUpdateNotification(client *nex.PRUDPClient) {
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 5
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("NintendoNotificationEventGeneral")
eventObject.DataHolder.SetObjectData(notificationEvent)
@ -38,7 +38,7 @@ func SendMiiUpdateNotification(client *nex.PRUDPClient) {
for i := 0; i < len(friendsList); i++ {
connectedUser := globals.ConnectedUsers[friendsList[i].PID]
connectedUser := globals.ConnectedUsers[friendsList[i].PID.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

4
notifications/3ds/send_presence_update.go
View File

@ -14,7 +14,7 @@ import (
func SendPresenceUpdate(client *nex.PRUDPClient, presence *friends_3ds_types.NintendoPresence) {
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 1
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("NintendoPresence")
eventObject.DataHolder.SetObjectData(presence)
@ -37,7 +37,7 @@ func SendPresenceUpdate(client *nex.PRUDPClient, presence *friends_3ds_types.Nin
for i := 0; i < len(friendsList); i++ {
connectedUser := globals.ConnectedUsers[friendsList[i].PID]
connectedUser := globals.ConnectedUsers[friendsList[i].PID.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

6
notifications/3ds/send_user_went_offline.go
View File

@ -21,12 +21,12 @@ func SendUserWentOfflineGlobally(client *nex.PRUDPClient) {
}
}
func SendUserWentOffline(client *nex.PRUDPClient, pid uint32) {
func SendUserWentOffline(client *nex.PRUDPClient, pid *nex.PID) {
notificationEvent := nintendo_notifications_types.NewNintendoNotificationEventGeneral()
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 10
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("NintendoNotificationEventGeneral")
eventObject.DataHolder.SetObjectData(notificationEvent)
@ -42,7 +42,7 @@ func SendUserWentOffline(client *nex.PRUDPClient, pid uint32) {
rmcRequestBytes := rmcRequest.Bytes()
connectedUser := globals.ConnectedUsers[pid]
connectedUser := globals.ConnectedUsers[pid.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

2
notifications/wiiu/send_friendship_removed.go
View File

@ -7,7 +7,7 @@ import (
nintendo_notifications_types "github.com/PretendoNetwork/nex-protocols-go/nintendo-notifications/types"
)
func SendFriendshipRemoved(client *nex.PRUDPClient, senderPID uint32) {
func SendFriendshipRemoved(client *nex.PRUDPClient, senderPID *nex.PID) {
nintendoNotificationEventGeneral := nintendo_notifications_types.NewNintendoNotificationEventGeneral()
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()

6
notifications/wiiu/send_presence_update.go
View File

@ -31,7 +31,7 @@ func SendPresenceUpdate(presence *friends_wiiu_types.NintendoPresenceV2) {
rmcRequestBytes := rmcRequest.Bytes()
friendList, err := database_wiiu.GetUserFriendList(presence.PID)
friendList, err := database_wiiu.GetUserFriendList(presence.PID.LegacyValue())
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
}
@ -44,7 +44,7 @@ func SendPresenceUpdate(presence *friends_wiiu_types.NintendoPresenceV2) {
if friendList[i] != nil && friendList[i].Presence != nil {
// TODO: Better track the bad users PID
friendPID = friendList[i].Presence.PID
friendPID = friendList[i].Presence.PID.LegacyValue()
}
globals.Logger.Error(fmt.Sprintf("User %d has friend %d with bad presence data", pid, friendPID))
@ -61,7 +61,7 @@ func SendPresenceUpdate(presence *friends_wiiu_types.NintendoPresenceV2) {
}
friendPID := friendList[i].NNAInfo.PrincipalBasicInfo.PID
connectedUser := globals.ConnectedUsers[friendPID]
connectedUser := globals.ConnectedUsers[friendPID.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

11
notifications/wiiu/send_user_went_offline.go
View File

@ -1,8 +1,6 @@
package notifications_wiiu
import (
"time"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
@ -22,9 +20,8 @@ func SendUserWentOfflineGlobally(client *nex.PRUDPClient) {
}
}
func SendUserWentOffline(client *nex.PRUDPClient, pid uint32) {
lastOnline := nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
func SendUserWentOffline(client *nex.PRUDPClient, pid *nex.PID) {
lastOnline := nex.NewDateTime(0).Now()
nintendoNotificationEventGeneral := nintendo_notifications_types.NewNintendoNotificationEventGeneral()
@ -35,7 +32,7 @@ func SendUserWentOffline(client *nex.PRUDPClient, pid uint32) {
eventObject := nintendo_notifications_types.NewNintendoNotificationEvent()
eventObject.Type = 10
eventObject.SenderPID = client.PID().LegacyValue()
eventObject.SenderPID = client.PID()
eventObject.DataHolder = nex.NewDataHolder()
eventObject.DataHolder.SetTypeName("NintendoNotificationEventGeneral")
eventObject.DataHolder.SetObjectData(nintendoNotificationEventGeneral)
@ -51,7 +48,7 @@ func SendUserWentOffline(client *nex.PRUDPClient, pid uint32) {
rmcRequestBytes := rmcRequest.Bytes()
connectedUser := globals.ConnectedUsers[pid]
connectedUser := globals.ConnectedUsers[pid.LegacyValue()]
if connectedUser != nil {
requestPacket, _ := nex.NewPRUDPPacketV0(connectedUser.Client, nil)

6
utility/get_user_info_by_pid.go
View File

@ -3,10 +3,10 @@ package utility
import (
"encoding/base64"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/nex-go"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/globals"
@ -25,7 +25,7 @@ func GetUserInfoByPID(pid uint32) (*friends_wiiu_types.PrincipalBasicInfo, error
info := friends_wiiu_types.NewPrincipalBasicInfo()
info.PID = userData.Pid
info.PID = nex.NewPID(userData.Pid)
info.NNID = userData.Username
info.Mii = friends_wiiu_types.NewMiiV2()
info.Unknown = 2