Emulation/friends
1
0
Fork 0
mirror of https://github.com/PretendoNetwork/friends.git synced 2024-05-17 20:30:47 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9 from PretendoNetwork/dev

Browse source 
Merge dev to master
This commit is contained in:
Jonathan Barrow 2023-10-13 16:21:14 -04:00 committed by GitHub
parent 348f43de1c cc9b839d45
commit 1654f0b458
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
115 changed files with 2203 additions and 1232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
.dockerignore Normal file
View file

@ -0,0 +1,7 @@
.env
.git
build
log
go.work
*.test
go.work.sum

19
Dockerfile Normal file
View file

@ -0,0 +1,19 @@
# --- builder ---
FROM golang:1.20.6-alpine3.17 as builder
LABEL stage=builder
RUN apk add git
WORKDIR /build
COPY go.* ./
RUN go mod download
COPY . ./
ARG BUILD_STRING=pretendo.friends.docker
RUN go build -ldflags "-X 'main.serverBuildString=${BUILD_STRING}'" -v -o server
# --- runner ---
FROM alpine:3.17 as runner
WORKDIR /build
COPY --from=builder /build/server /build/
CMD ["/build/server"]

64
Makefile Normal file
View file

@ -0,0 +1,64 @@
# TODO - Assumes a UNIX-like OS
RED := $(shell tput setaf 1)
BLUE := $(shell tput setaf 4)
CYAN := $(shell tput setaf 14)
ORANGE := $(shell tput setaf 202)
YELLOW := $(shell tput setaf 214)
RESET := $(shell tput sgr0)
ifeq ($(shell which go),)
# TODO - Read contents from .git folder instead?
$(error "$(RED)go command not found. Install go to continue $(BLUE)https://go.dev/doc/install$(RESET)")
endif
ifneq ($(wildcard .git),)
# * .git folder exists, build server build string from repo info
ifeq ($(shell which git),)
# TODO - Read contents from .git folder instead?
$(error "$(RED)git command not found. Install git to continue $(ORANGE)https://git-scm.com/downloads$(RESET)")
endif
$(info "$(CYAN)Building server build string from repository info$(RESET)")
# * Build server build string from repo info
BRANCH := $(shell git rev-parse --abbrev-ref HEAD)
REMOTE_ORIGIN := $(shell git config --get remote.origin.url)
# * Handle multiple origin URL formats
HTTPS_PREFIX_CHECK := $(shell echo $(REMOTE_ORIGIN) | head -c 8)
HTTP_PREFIX_CHECK := $(shell echo $(REMOTE_ORIGIN) | head -c 7)
GIT@_PREFIX_CHECK := $(shell echo $(REMOTE_ORIGIN) | head -c 4)
ifeq ($(HTTPS_PREFIX_CHECK), https://)
REMOTE_PATH := $(shell echo $(REMOTE_ORIGIN) | cut -d/ -f4-)
else ifeq ($(HTTP_PREFIX_CHECK), http://)
REMOTE_PATH := $(shell echo $(REMOTE_ORIGIN) | cut -d/ -f4-)
else ifeq ($(GIT@_PREFIX_CHECK), git@)
REMOTE_PATH := $(shell echo $(REMOTE_ORIGIN) | cut -d: -f2-)
else
REMOTE_PATH := $(shell echo $(REMOTE_ORIGIN) | cut -d/ -f2-)
endif
HASH := $(shell git rev-parse --short HEAD)
SERVER_BUILD := $(BRANCH):$(REMOTE_PATH)@$(HASH)
else
# * .git folder not present, assume downloaded from zip file and just use folder name
$(info "$(CYAN)git repository not found. Building server build string from folder name$(RESET)")
SERVER_BUILD := friends
endif
# * Final build string
DATE_TIME := $(shell date --iso=seconds)
BUILD_STRING := $(SERVER_BUILD), $(DATE_TIME)
default:
ifeq ($(wildcard .env),)
$(warning "$(YELLOW).env file not found, environment variables may not be populated correctly$(RESET)")
endif
go get -u
go mod tidy
go build -ldflags "-X 'main.serverBuildString=$(BUILD_STRING)'" -o ./build/friends
docker:
docker build -t friends --build-arg BUILD_STRING="$(BUILD_STRING)" .
docker image prune --filter label=stage=builder -f

102
README.md
View file

@ -1,5 +1,99 @@
# Friends - Secure
### Pretendo Friends secure server
# Friends replacement server
Includes both the authentication and secure servers
## About
Handles basic functionality for Wii U and 3DS friends. Many things are not implemented.
## Compiling
### Setup
Install [Go](https://go.dev/doc/install) and [git](https://git-scm.com/downloads), then clone and enter the repository
```bash
$ git clone https://github.com/PretendoNetwork/friends
$ cd friends
```
### Compiling and running using `docker` (Preferred)
Install Docker either through your systems package manager or the [official installer](https://docs.docker.com/get-docker/)
To build the container:
```bash
$ docker build -t friends .
$ docker image prune --filter label=stage=builder -f
```
Optionally you may provide `BUILD_STRING` to `--build-arg` to set the authentication server build string
```bash
$ docker build -t friends --build-arg BUILD_STRING=auth-build-string .
$ docker image prune --filter label=stage=builder -f
```
If `BUILD_STRING` is not set, the default build string `pretendo.friends.docker` is used. You may also use the `docker` rule when building with `make` to set the build string automatically. See [compiling using `make`](#compiling-using-make) below for more info
To run the image first create a `.env` file with your [Configuration](#configuration) set before using `docker run`
Example:
```
PN_FRIENDS_POSTGRES_URI=postgres://username:password@localhost/friends?sslmode=disable
PN_FRIENDS_AUTHENTICATION_SERVER_PORT=60000
...
```
```bash
$ docker run --name friends --env-file .env -it friends
```
The image is compatible popular container managers such as Docker Compose and Portainer
### Compiling using `go`
To compile using Go, `go get` the required modules and then `go build` to your desired location. You may also want to tidy the go modules, though this is optional
```bash
$ go get -u
$ go mod tidy
$ go build -o build/friends
```
The server is now built to `build/friends`
When compiling with only Go, the authentication servers build string is not automatically set. This should not cause any issues with gameplay, but it means that the server build will not be visible in any packet dumps or logs a title may produce
To compile the servers with the authentication server build string, add `-ldflags "-X 'main.serverBuildString=BUILD_STRING_HERE'"` to the build command, or use `make` to compile the server
### Compiling using `make`
Compiling using `make` will read the local `.git` directory to create a dynamic authentication server build string, based on your repositories remote origin and current commit
Install `make` either through your systems package manager or the [official download](https://www.gnu.org/software/make/). We provide two different rules; A `default` rule which compiles [using `go`](#compiling-using-go), and a `docker` rule which compiles [using `docker`](#compiling-and-running-using-docker-preferred). Please refer to each sections setup instructions before continuing with your preferred rule
To build using `go`
```bash
$ make
```
The server is now built to `build/friends`
To build using `docker`
```bash
$ make docker
```
The image is now ready to run
## Configuration
All configuration options are handled via environment variables
`.env` files are supported
| Name | Description | Required |
|-----------------------------------------|------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------|
| `PN_FRIENDS_CONFIG_DATABASE_URI` | Fully qualified URI to your Postgres server (Example `postgres://username:password@localhost/friends?sslmode=disable`) | Yes |
| `PN_FRIENDS_CONFIG_KERBEROS_PASSWORD` | Password used as part of the internal server data in Kerberos tickets | No (Default password `password` will be used) |
| `PN_FRIENDS_CONFIG_AES_KEY` | AES key used in tokens provided by the account server | Yes |
| `PN_FRIENDS_CONFIG_GRPC_API_KEY` | API key for your GRPC server | No (Assumed to be an open gRPC API) |
| `PN_FRIENDS_GRPC_SERVER_PORT` | Port for the GRPC server | Yes |
| `PN_FRIENDS_AUTHENTICATION_SERVER_PORT` | Port for the authentication server | Yes |
| `PN_FRIENDS_SECURE_SERVER_HOST` | Host name for the secure server (should point to the same address as the authentication server) | Yes |
| `PN_FRIENDS_SECURE_SERVER_PORT` | Port for the secure server | Yes |
| `PN_FRIENDS_ACCOUNT_GRPC_HOST` | Host name for your account server gRPC service | Yes |
| `PN_FRIENDS_ACCOUNT_GRPC_PORT` | Port for your account server gRPC service | Yes |
| `PN_FRIENDS_ACCOUNT_GRPC_API_KEY` | API key for your account server gRPC service | No (Assumed to be an open gRPC API) |

27
database/3ds/get_friend_miis.go
View file

@ -1,27 +1,22 @@
package database_3ds
import (
"database/sql"
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
"github.com/lib/pq"
)
// Get a friend's mii
func GetFriendMiis(pids []uint32) []*friends_3ds.FriendMii {
friendMiis := make([]*friends_3ds.FriendMii, 0)
// GetFriendMiis returns the Mii of all friends
func GetFriendMiis(pids []uint32) ([]*friends_3ds_types.FriendMii, error) {
friendMiis := make([]*friends_3ds_types.FriendMii, 0)
rows, err := database.Postgres.Query(`
SELECT pid, mii_name, mii_data FROM "3ds".user_data WHERE pid IN ($1)`, database.PIDArrayToString(pids))
SELECT pid, mii_name, mii_data FROM "3ds".user_data WHERE pid=ANY($1::int[])`, pq.Array(pids))
if err != nil {
if err == sql.ErrNoRows {
globals.Logger.Warning(err.Error())
} else {
globals.Logger.Critical(err.Error())
}
return friendMiis, err
}
changedTime := nex.NewDateTime(0)
@ -30,13 +25,13 @@ func GetFriendMiis(pids []uint32) []*friends_3ds.FriendMii {
for rows.Next() {
var pid uint32
mii := friends_3ds.NewMii()
mii := friends_3ds_types.NewMii()
mii.Unknown2 = false
mii.Unknown3 = 0
rows.Scan(&pid, &mii.Name, &mii.MiiData)
friendMii := friends_3ds.NewFriendMii()
friendMii := friends_3ds_types.NewFriendMii()
friendMii.PID = pid
friendMii.Mii = mii
friendMii.ModifiedAt = changedTime
@ -44,5 +39,5 @@ func GetFriendMiis(pids []uint32) []*friends_3ds.FriendMii {
friendMiis = append(friendMiis, friendMii)
}
return friendMiis
return friendMiis, nil
}

45
database/3ds/get_friend_persistent_infos.go
View file

@ -1,54 +1,37 @@
package database_3ds
import (
"database/sql"
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
"github.com/lib/pq"
)
// Get a friend's persistent information
func GetFriendPersistentInfos(user1_pid uint32, pids []uint32) []*friends_3ds.FriendPersistentInfo {
persistentInfos := make([]*friends_3ds.FriendPersistentInfo, 0)
// GetFriendPersistentInfos returns the persistent information of all friends
func GetFriendPersistentInfos(user1_pid uint32, pids []uint32) ([]*friends_3ds_types.FriendPersistentInfo, error) {
persistentInfos := make([]*friends_3ds_types.FriendPersistentInfo, 0)
rows, err := database.Postgres.Query(`
SELECT pid, region, area, language, favorite_title, favorite_title_version, comment, comment_changed, last_online FROM "3ds".user_data WHERE pid IN ($1)`, database.PIDArrayToString(pids))
SELECT pid, region, area, language, favorite_title, favorite_title_version, comment, comment_changed, last_online, mii_changed FROM "3ds".user_data WHERE pid=ANY($1::int[])`, pq.Array(pids))
if err != nil {
if err == sql.ErrNoRows {
globals.Logger.Warning(err.Error())
} else {
globals.Logger.Critical(err.Error())
}
return persistentInfos, err
}
for rows.Next() {
persistentInfo := friends_3ds.NewFriendPersistentInfo()
persistentInfo := friends_3ds_types.NewFriendPersistentInfo()
gameKey := friends_3ds.NewGameKey()
gameKey := friends_3ds_types.NewGameKey()
var lastOnlineTime uint64
var msgUpdateTime uint64
var friendedAtTime uint64
var miiModifiedAtTime uint64
rows.Scan(
&persistentInfo.PID, &persistentInfo.Region, &persistentInfo.Area, &persistentInfo.Language,
&gameKey.TitleID, &gameKey.TitleVersion, &persistentInfo.Message, &msgUpdateTime, &lastOnlineTime)
err = database.Postgres.QueryRow(`
SELECT date FROM "3ds".friendships WHERE user1_pid=$1 AND user2_pid=$2 AND type=0 LIMIT 1`, user1_pid, persistentInfo.PID).Scan(&friendedAtTime)
if err != nil {
if err == sql.ErrNoRows {
friendedAtTime = uint64(time.Now().Unix())
} else {
globals.Logger.Critical(err.Error())
}
}
&gameKey.TitleID, &gameKey.TitleVersion, &persistentInfo.Message, &msgUpdateTime, &lastOnlineTime, &miiModifiedAtTime)
persistentInfo.MessageUpdatedAt = nex.NewDateTime(msgUpdateTime)
persistentInfo.FriendedAt = nex.NewDateTime(friendedAtTime)
persistentInfo.MiiModifiedAt = nex.NewDateTime(miiModifiedAtTime)
persistentInfo.LastOnline = nex.NewDateTime(lastOnlineTime)
persistentInfo.GameKey = gameKey
persistentInfo.Platform = 2 // Always 3DS
@ -56,5 +39,5 @@ func GetFriendPersistentInfos(user1_pid uint32, pids []uint32) []*friends_3ds.Fr
persistentInfos = append(persistentInfos, persistentInfo)
}
return persistentInfos
return persistentInfos, nil
}

23
database/3ds/get_user_friends.go
View file

@ -3,28 +3,31 @@ package database_3ds
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
"github.com/PretendoNetwork/friends/database"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
// Get all of a user's friend relationships
func GetUserFriends(pid uint32) []*friends_3ds.FriendRelationship {
friendRelationships := make([]*friends_3ds.FriendRelationship, 0)
// GetUserFriends returns all friend relationships of a user
func GetUserFriends(pid uint32) ([]*friends_3ds_types.FriendRelationship, error) {
friendRelationships := make([]*friends_3ds_types.FriendRelationship, 0)
rows, err := database.Postgres.Query(`
SELECT user2_pid, type FROM "3ds".friendships WHERE user1_pid=$1 AND type=1 LIMIT 100`, pid)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
if err != nil {
if err == sql.ErrNoRows {
return friendRelationships, database.ErrEmptyList
} else {
return friendRelationships, err
}
}
for rows.Next() {
relationship := friends_3ds.NewFriendRelationship()
relationship := friends_3ds_types.NewFriendRelationship()
relationship.LFC = 0
rows.Scan(&relationship.PID, &relationship.RelationshipType)
friendRelationships = append(friendRelationships, relationship)
}
return friendRelationships
return friendRelationships, nil
}

20
database/3ds/remove_friendship.go
View file

@ -1,21 +1,27 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
// Remove a user's friend relationship
func RemoveFriendship(user1_pid uint32, user2_pid uint32) {
_, err := database.Postgres.Exec(`
// RemoveFriendship removes a user's friend relationship
func RemoveFriendship(user1_pid uint32, user2_pid uint32) error {
result, err := database.Postgres.Exec(`
DELETE FROM "3ds".friendships WHERE user1_pid=$1 AND user2_pid=$2`, user1_pid, user2_pid)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendshipNotFound
}
_, err = database.Postgres.Exec(`
UPDATE "3ds".friendships SET type=0 WHERE user1_pid=$1 AND user2_pid=$2`, user2_pid, user1_pid)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

29
database/3ds/save_friendship.go
View file

@ -3,15 +3,14 @@ package database_3ds
import (
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
// Save a friend relationship for a user
func SaveFriendship(senderPID uint32, recipientPID uint32) *friends_3ds.FriendRelationship {
friendRelationship := friends_3ds.NewFriendRelationship()
// 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.LFC = 0
friendRelationship.RelationshipType = 0 // Incomplete
@ -23,18 +22,18 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) *friends_3ds.FriendRe
var found bool
err := database.Postgres.QueryRow(`SELECT COUNT(*) FROM "3ds".user_data WHERE pid=$1 LIMIT 1`, recipientPID).Scan(&found)
if err != nil {
globals.Logger.Critical(err.Error())
return nil, err
}
if !found {
friendRelationship.RelationshipType = 2 // Non-existent
return friendRelationship
return friendRelationship, nil
}
// 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 {
globals.Logger.Critical(err.Error())
return nil, err
}
if !found {
_, err = database.Postgres.Exec(`
@ -43,9 +42,9 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) *friends_3ds.FriendRe
ON CONFLICT (user1_pid, user2_pid)
DO NOTHING`, senderPID, recipientPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nil, err
}
return friendRelationship
return friendRelationship, nil
}
acceptedTime := nex.NewDateTime(0).Now()
@ -59,8 +58,7 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) *friends_3ds.FriendRe
date = $3,
type = 1`, senderPID, recipientPID, acceptedTime)
if err != nil {
globals.Logger.Critical(err.Error())
return nil
return nil, err
}
_, err = database.Postgres.Exec(`
@ -71,10 +69,9 @@ func SaveFriendship(senderPID uint32, recipientPID uint32) *friends_3ds.FriendRe
date = $3,
type = 1`, recipientPID, senderPID, acceptedTime)
if err != nil {
globals.Logger.Critical(err.Error())
return nil
return nil, err
}
friendRelationship.RelationshipType = 1 // Complete
return friendRelationship
return friendRelationship, nil
}

11
database/3ds/update_user_comment.go
View file

@ -1,13 +1,12 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
)
// Update a user's comment
func UpdateUserComment(pid uint32, message string) {
// UpdateUserComment updates a user's comment
func UpdateUserComment(pid uint32, message string) error {
changed := nex.NewDateTime(0).Now()
_, err := database.Postgres.Exec(`
@ -19,6 +18,8 @@ func UpdateUserComment(pid uint32, message string) {
comment_changed = $3`, pid, message, changed)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

13
database/3ds/update_user_favorite_game.go
View file

@ -1,13 +1,12 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
"github.com/PretendoNetwork/friends/database"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
// Update a user's favorite game
func UpdateUserFavoriteGame(pid uint32, gameKey *friends_3ds.GameKey) {
// UpdateUserFavoriteGame updates a user's favorite game
func UpdateUserFavoriteGame(pid uint32, gameKey *friends_3ds_types.GameKey) error {
_, err := database.Postgres.Exec(`
INSERT INTO "3ds".user_data (pid, favorite_title, favorite_title_version)
VALUES ($1, $2, $3)
@ -17,6 +16,8 @@ func UpdateUserFavoriteGame(pid uint32, gameKey *friends_3ds.GameKey) {
favorite_title_version = $3`, pid, gameKey.TitleID, gameKey.TitleVersion)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

15
database/3ds/update_user_last_online_time.go
View file

@ -3,21 +3,20 @@ package database_3ds
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
)
// Update a user's last online time
func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) {
// UpdateUserLastOnlineTime updates a user's last online time
func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) error {
var showOnline bool
err := database.Postgres.QueryRow(`SELECT show_online FROM "3ds".user_data WHERE pid=$1`, pid).Scan(&showOnline)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return err
}
if !showOnline {
return
return nil
}
_, err = database.Postgres.Exec(`
@ -27,6 +26,8 @@ func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) {
DO UPDATE SET
last_online = $2`, pid, lastOnline.Value())
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

13
database/3ds/update_user_mii.go
View file

@ -1,14 +1,13 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
// Update a user's mii
func UpdateUserMii(pid uint32, mii *friends_3ds.Mii) {
// UpdateUserMii updates a user's mii
func UpdateUserMii(pid uint32, mii *friends_3ds_types.Mii) error {
_, err := database.Postgres.Exec(`
INSERT INTO "3ds".user_data (pid, mii_name, mii_data, mii_changed)
VALUES ($1, $2, $3, $4)
@ -19,6 +18,8 @@ func UpdateUserMii(pid uint32, mii *friends_3ds.Mii) {
mii_changed = $4`, pid, mii.Name, mii.MiiData, nex.NewDateTime(0).Now())
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

11
database/3ds/update_user_preferences.go
View file

@ -1,12 +1,11 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
// Update a user's preferences
func UpdateUserPreferences(pid uint32, show_online bool, show_current_game bool) {
// UpdateUserPreferences updates a user's preferences
func UpdateUserPreferences(pid uint32, show_online bool, show_current_game bool) error {
_, err := database.Postgres.Exec(`
INSERT INTO "3ds".user_data (pid, show_online, show_current_game)
VALUES ($1, $2, $3)
@ -16,6 +15,8 @@ func UpdateUserPreferences(pid uint32, show_online bool, show_current_game bool)
show_current_game = $3`, pid, show_online, show_current_game)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

13
database/3ds/update_user_profile.go
View file

@ -1,13 +1,12 @@
package database_3ds
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
"github.com/PretendoNetwork/friends/database"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
// Update a user's profile
func UpdateUserProfile(pid uint32, profileData *friends_3ds.MyProfile) {
// UpdateUserProfile updates a user's profile
func UpdateUserProfile(pid uint32, profileData *friends_3ds_types.MyProfile) error {
_, err := database.Postgres.Exec(`
INSERT INTO "3ds".user_data (pid, region, area, language)
VALUES ($1, $2, $3, $4)
@ -18,6 +17,8 @@ func UpdateUserProfile(pid uint32, profileData *friends_3ds.MyProfile) {
language = $4`, pid, profileData.Region, profileData.Area, profileData.Language)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

27
database/connect_mongo.go
View file

@ -1,27 +0,0 @@
package database
import (
"context"
"os"
"time"
"github.com/PretendoNetwork/friends-secure/globals"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
var mongoClient *mongo.Client
var mongoContext context.Context
var mongoDatabase *mongo.Database
var MongoCollection *mongo.Collection
func connectMongo() {
mongoClient, _ = mongo.NewClient(options.Client().ApplyURI(os.Getenv("PN_FRIENDS_CONFIG_MONGO_URI")))
mongoContext, _ = context.WithTimeout(context.Background(), 10*time.Second)
_ = mongoClient.Connect(mongoContext)
mongoDatabase = mongoClient.Database("pretendo")
MongoCollection = mongoDatabase.Collection("pnids")
globals.Logger.Success("Connected to Mongo!")
}

4
database/connect_postgres.go
View file

@ -6,12 +6,12 @@ import (
_ "github.com/lib/pq"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
)
var Postgres *sql.DB
func connectPostgres() {
func ConnectPostgres() {
var err error
Postgres, err = sql.Open("postgres", os.Getenv("PN_FRIENDS_CONFIG_DATABASE_URI"))

25
database/database.go
View file

@ -1,15 +1,22 @@
package database
import (
"fmt"
"strings"
"errors"
)
func Connect() {
connectMongo()
connectPostgres()
}
var (
// ErrPIDNotFound is returned if a given PID is not found in the database
ErrPIDNotFound = errors.New("PID not found")
func PIDArrayToString(array []uint32) string {
return strings.Trim(strings.Replace(fmt.Sprint(array), " ", ",", -1), "[]")
}
// ErrFriendRequestNotFound is returned if a given friend request is not found in the database
ErrFriendRequestNotFound = errors.New("Friend request not found")
// ErrFriendshipNotFound is returned if a given friendship is not found in the database
ErrFriendshipNotFound = errors.New("Friendship not found")
// ErrBlockListNotFound is returned if a given PID does not have a blacklist
ErrBlacklistNotFound = errors.New("Blacklist not found")
// ErrEmptyList is returned if a given PID returned an empty list on an operation
ErrEmptyList = errors.New("List is empty")
)

2
database/init_postgres_3ds.go
View file

@ -1,6 +1,6 @@
package database
import "github.com/PretendoNetwork/friends-secure/globals"
import "github.com/PretendoNetwork/friends/globals"
func initPostgres3DS() {
var err error

2
database/init_postgres_wiiu.go
View file

@ -1,6 +1,6 @@
package database
import "github.com/PretendoNetwork/friends-secure/globals"
import "github.com/PretendoNetwork/friends/globals"
func initPostgresWiiU() {
var err error

66
database/wiiu/accept_friend_request_and_return_friend_info.go
View file

@ -1,23 +1,28 @@
package database_wiiu
import (
"database/sql"
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
"github.com/gocql/gocql"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) *friends_wiiu.FriendInfo {
// AcceptFriendRequestAndReturnFriendInfo accepts the given friend reuqest and returns the friend's information
func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) (*friends_wiiu_types.FriendInfo, error) {
var senderPID uint32
var recipientPID uint32
err := database.Postgres.QueryRow(`SELECT sender_pid, recipient_pid FROM wiiu.friend_requests WHERE id=$1`, friendRequestID).Scan(&senderPID, &recipientPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nil
if err == sql.ErrNoRows {
return nil, database.ErrFriendRequestNotFound
} else {
return nil, err
}
}
acceptedTime := nex.NewDateTime(0)
@ -36,8 +41,7 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) *friends_wii
date = $3,
active = true`, senderPID, recipientPID, acceptedTime.Value())
if err != nil {
globals.Logger.Critical(err.Error())
return nil
return nil, err
}
_, err = database.Postgres.Exec(`
@ -48,13 +52,15 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) *friends_wii
date = $3,
active = true`, recipientPID, senderPID, acceptedTime.Value())
if err != nil {
globals.Logger.Critical(err.Error())
return nil
return nil, err
}
SetFriendRequestAccepted(friendRequestID)
err = SetFriendRequestAccepted(friendRequestID)
if err != nil {
return nil, err
}
friendInfo := friends_wiiu.NewFriendInfo()
friendInfo := friends_wiiu_types.NewFriendInfo()
connectedUser := globals.ConnectedUsers[senderPID]
var lastOnline *nex.DateTime
@ -67,16 +73,21 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) *friends_wii
lastOnline.FromTimestamp(time.Now())
} else {
// Offline
userInfo, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
return nil, err
}
friendInfo.NNAInfo = friends_wiiu.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = GetUserInfoByPID(senderPID)
friendInfo.NNAInfo = friends_wiiu_types.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = userInfo
friendInfo.NNAInfo.Unknown1 = 0
friendInfo.NNAInfo.Unknown2 = 0
friendInfo.Presence = friends_wiiu.NewNintendoPresenceV2()
friendInfo.Presence = friends_wiiu_types.NewNintendoPresenceV2()
friendInfo.Presence.ChangedFlags = 0
friendInfo.Presence.Online = false
friendInfo.Presence.GameKey = friends_wiiu.NewGameKey()
friendInfo.Presence.GameKey = friends_wiiu_types.NewGameKey()
friendInfo.Presence.GameKey.TitleID = 0
friendInfo.Presence.GameKey.TitleVersion = 0
friendInfo.Presence.Unknown1 = 0
@ -87,30 +98,33 @@ func AcceptFriendRequestAndReturnFriendInfo(friendRequestID uint64) *friends_wii
friendInfo.Presence.Unknown4 = 0
friendInfo.Presence.PID = senderPID
friendInfo.Presence.GatheringID = 0
friendInfo.Presence.ApplicationData = []byte{0x00}
friendInfo.Presence.ApplicationData = make([]byte, 0)
friendInfo.Presence.Unknown5 = 0
friendInfo.Presence.Unknown6 = 0
friendInfo.Presence.Unknown7 = 0
var lastOnlineTime uint64
err := database.Postgres.QueryRow(`SELECT last_online FROM wiiu.user_data WHERE pid=$1`, senderPID).Scan(&lastOnlineTime)
err = database.Postgres.QueryRow(`SELECT last_online FROM wiiu.user_data WHERE pid=$1`, senderPID).Scan(&lastOnlineTime)
if err != nil {
lastOnlineTime = nex.NewDateTime(0).Now()
if err == gocql.ErrNotFound {
globals.Logger.Error(err.Error())
if err == sql.ErrNoRows {
return nil, database.ErrPIDNotFound
} else {
globals.Logger.Critical(err.Error())
return nil, err
}
}
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO: Change this
}
friendInfo.Status = GetUserComment(senderPID)
status, err := GetUserComment(senderPID)
if err != nil {
return nil, err
}
friendInfo.Status = status
friendInfo.BecameFriend = acceptedTime
friendInfo.LastOnline = lastOnline // TODO: Change this
friendInfo.Unknown = 0
return friendInfo
return friendInfo, nil
}

25
database/wiiu/delete_friend_request_and_return_friend_pid.go
View file

@ -1,23 +1,34 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
"github.com/PretendoNetwork/friends/database"
)
func DeleteFriendRequestAndReturnFriendPID(friendRequestID uint64) uint32 {
// DeleteFriendRequestAndReturnFriendPID deletes a given friend request and returns the friend's PID
func DeleteFriendRequestAndReturnFriendPID(friendRequestID uint64) (uint32, error) {
var recipientPID uint32
err := database.Postgres.QueryRow(`SELECT recipient_pid FROM wiiu.friend_requests WHERE id=$1`, friendRequestID).Scan(&recipientPID)
if err != nil {
globals.Logger.Critical(err.Error())
if err == sql.ErrNoRows {
return 0, database.ErrFriendRequestNotFound
} else {
return 0, err
}
}
_, err = database.Postgres.Exec(`
result, err := database.Postgres.Exec(`
DELETE FROM wiiu.friend_requests WHERE id=$1`, friendRequestID)
if err != nil {
globals.Logger.Critical(err.Error())
return 0, err
}
return recipientPID
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return 0, database.ErrFriendRequestNotFound
}
return recipientPID, nil
}

13
database/wiiu/get_pids_by_friend_request_id.go
View file

@ -3,12 +3,11 @@ package database_wiiu
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
// Get a users outgoing friend request
func GetPIDsByFriendRequestID(friendRequestID uint64) (uint32, uint32) {
// GetPIDsByFriendRequestID returns the users outgoing friend request
func GetPIDsByFriendRequestID(friendRequestID uint64) (uint32, uint32, error) {
var senderPID uint32
var recipientPID uint32
@ -17,11 +16,11 @@ func GetPIDsByFriendRequestID(friendRequestID uint64) (uint32, uint32) {
`, friendRequestID).Scan(&senderPID, &recipientPID)
if err != nil {
if err == sql.ErrNoRows {
globals.Logger.Warning(err.Error())
return 0, 0, database.ErrFriendRequestNotFound
} else {
globals.Logger.Critical(err.Error())
return 0, 0, err
}
}
return senderPID, recipientPID
return senderPID, recipientPID, nil
}

34
database/wiiu/get_user_block_list.go
View file

@ -1,20 +1,25 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/utility"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
// Get a users blacklist
func GetUserBlockList(pid uint32) []*friends_wiiu.BlacklistedPrincipal {
blockList := make([]*friends_wiiu.BlacklistedPrincipal, 0)
// GetUserBlockList returns a user's blacklist
func GetUserBlockList(pid uint32) ([]*friends_wiiu_types.BlacklistedPrincipal, error) {
blockList := make([]*friends_wiiu_types.BlacklistedPrincipal, 0)
rows, err := database.Postgres.Query(`SELECT blocked_pid, title_id, title_version, date FROM wiiu.blocks WHERE blocker_pid=$1`, pid)
if err != nil {
globals.Logger.Critical(err.Error())
return blockList
if err == sql.ErrNoRows {
return blockList, database.ErrBlacklistNotFound
} else {
return blockList, err
}
}
for rows.Next() {
@ -24,11 +29,16 @@ func GetUserBlockList(pid uint32) []*friends_wiiu.BlacklistedPrincipal {
var date *nex.DateTime
rows.Scan(&pid, &titleId, &titleVersion, &date)
blacklistPrincipal := friends_wiiu.NewBlacklistedPrincipal()
userInfo, err := utility.GetUserInfoByPID(pid)
if err != nil {
return nil, err
}
blacklistPrincipal.PrincipalBasicInfo = GetUserInfoByPID(pid)
blacklistPrincipal := friends_wiiu_types.NewBlacklistedPrincipal()
blacklistPrincipal.GameKey = friends_wiiu.NewGameKey()
blacklistPrincipal.PrincipalBasicInfo = userInfo
blacklistPrincipal.GameKey = friends_wiiu_types.NewGameKey()
blacklistPrincipal.GameKey.TitleID = titleId
blacklistPrincipal.GameKey.TitleVersion = titleVersion
blacklistPrincipal.BlackListedSince = date
@ -36,5 +46,5 @@ func GetUserBlockList(pid uint32) []*friends_wiiu.BlacklistedPrincipal {
blockList = append(blockList, blacklistPrincipal)
}
return blockList
return blockList, nil
}

17
database/wiiu/get_user_comment.go
View file

@ -3,15 +3,14 @@ package database_wiiu
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
// Get a users comment
func GetUserComment(pid uint32) *friends_wiiu.Comment {
comment := friends_wiiu.NewComment()
// GetUserComment returns a user's comment
func GetUserComment(pid uint32) (*friends_wiiu_types.Comment, error) {
comment := friends_wiiu_types.NewComment()
comment.Unknown = 0
var changed uint64 = 0
@ -19,13 +18,13 @@ func GetUserComment(pid uint32) *friends_wiiu.Comment {
err := database.Postgres.QueryRow(`SELECT comment, comment_changed FROM wiiu.user_data WHERE pid=$1`, pid).Scan(&comment.Contents, &changed)
if err != nil {
if err == sql.ErrNoRows {
globals.Logger.Warning(err.Error())
return nil, database.ErrPIDNotFound
} else {
globals.Logger.Critical(err.Error())
return nil, err
}
}
comment.LastChanged = nex.NewDateTime(changed)
return comment
return comment, nil
}

58
database/wiiu/get_user_friend_list.go
View file

@ -1,24 +1,28 @@
package database_wiiu
import (
"database/sql"
"fmt"
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
"github.com/gocql/gocql"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
// Get a users friend list
func GetUserFriendList(pid uint32) []*friends_wiiu.FriendInfo {
friendList := make([]*friends_wiiu.FriendInfo, 0)
// GetUserFriendList returns a user's friend list
func GetUserFriendList(pid uint32) ([]*friends_wiiu_types.FriendInfo, error) {
friendList := make([]*friends_wiiu_types.FriendInfo, 0)
rows, err := database.Postgres.Query(`SELECT user2_pid, date FROM wiiu.friendships WHERE user1_pid=$1 AND active=true LIMIT 100`, pid)
if err != nil {
globals.Logger.Critical(err.Error())
return friendList
if err == sql.ErrNoRows {
return friendList, database.ErrEmptyList
} else {
return friendList, err
}
}
for rows.Next() {
@ -26,7 +30,7 @@ func GetUserFriendList(pid uint32) []*friends_wiiu.FriendInfo {
var date uint64
rows.Scan(&friendPID, &date)
friendInfo := friends_wiiu.NewFriendInfo()
friendInfo := friends_wiiu_types.NewFriendInfo()
connectedUser := globals.ConnectedUsers[friendPID]
var lastOnline *nex.DateTime
@ -52,15 +56,21 @@ func GetUserFriendList(pid uint32) []*friends_wiiu.FriendInfo {
} else {
// Offline
friendInfo.NNAInfo = friends_wiiu.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = GetUserInfoByPID(friendPID)
userInfo, err := utility.GetUserInfoByPID(friendPID)
if err != nil {
return nil, err
}
friendInfo.NNAInfo = friends_wiiu_types.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = userInfo
friendInfo.NNAInfo.Unknown1 = 0
friendInfo.NNAInfo.Unknown2 = 0
friendInfo.Presence = friends_wiiu.NewNintendoPresenceV2()
friendInfo.Presence = friends_wiiu_types.NewNintendoPresenceV2()
friendInfo.Presence.ChangedFlags = 0
friendInfo.Presence.Online = false
friendInfo.Presence.GameKey = friends_wiiu.NewGameKey()
friendInfo.Presence.GameKey = friends_wiiu_types.NewGameKey()
friendInfo.Presence.GameKey.TitleID = 0
friendInfo.Presence.GameKey.TitleVersion = 0
friendInfo.Presence.Unknown1 = 0
@ -77,21 +87,21 @@ func GetUserFriendList(pid uint32) []*friends_wiiu.FriendInfo {
friendInfo.Presence.Unknown7 = 0
var lastOnlineTime uint64
err := database.Postgres.QueryRow(`SELECT last_online FROM wiiu.user_data WHERE pid=$1`, friendPID).Scan(&lastOnlineTime)
err = database.Postgres.QueryRow(`SELECT last_online FROM wiiu.user_data WHERE pid=$1`, friendPID).Scan(&lastOnlineTime)
if err != nil {
lastOnlineTime = nex.NewDateTime(0).Now()
if err == gocql.ErrNotFound {
globals.Logger.Error(err.Error())
} else {
globals.Logger.Critical(err.Error())
}
return nil, err
}
lastOnline = nex.NewDateTime(lastOnlineTime) // TODO: Change this
}
friendInfo.Status = GetUserComment(friendPID)
status, err := GetUserComment(friendPID)
if err != nil {
return nil, err
}
friendInfo.Status = status
friendInfo.BecameFriend = nex.NewDateTime(date)
friendInfo.LastOnline = lastOnline
friendInfo.Unknown = 0
@ -99,5 +109,5 @@ func GetUserFriendList(pid uint32) []*friends_wiiu.FriendInfo {
friendList = append(friendList, friendInfo)
}
return friendList
return friendList, nil
}

18
database/wiiu/get_user_friend_pids.go
View file

@ -1,18 +1,22 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
"github.com/PretendoNetwork/friends/database"
)
// Get a users friend PIDs list
func GetUserFriendPIDs(pid uint32) []uint32 {
// GetUserFriendPIDs returns a user's friend PIDs list
func GetUserFriendPIDs(pid uint32) ([]uint32, error) {
pids := make([]uint32, 0)
rows, err := database.Postgres.Query(`SELECT user2_pid FROM wiiu.friendships WHERE user1_pid=$1 AND active=true LIMIT 100`, pid)
if err != nil {
globals.Logger.Critical(err.Error())
return pids
if err == sql.ErrNoRows {
return pids, database.ErrEmptyList
} else {
return pids, err
}
}
defer rows.Close()
@ -23,5 +27,5 @@ func GetUserFriendPIDs(pid uint32) []uint32 {
pids = append(pids, pid)
}
return pids
return pids, nil
}

34
database/wiiu/get_user_friend_requests_in.go
View file

@ -1,22 +1,26 @@
package database_wiiu
import (
"database/sql"
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/utility"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
// Get a users received friend requests
func GetUserFriendRequestsIn(pid uint32) []*friends_wiiu.FriendRequest {
friendRequestsIn := make([]*friends_wiiu.FriendRequest, 0)
// GetUserFriendRequestsIn returns the friend requests received by a user
func GetUserFriendRequestsIn(pid uint32) ([]*friends_wiiu_types.FriendRequest, error) {
friendRequestsIn := make([]*friends_wiiu_types.FriendRequest, 0)
rows, err := database.Postgres.Query(`SELECT id, sender_pid, sent_on, expires_on, message, received FROM wiiu.friend_requests WHERE recipient_pid=$1 AND accepted=false AND denied=false`, pid)
if err != nil {
globals.Logger.Critical(err.Error())
return friendRequestsIn
if err == sql.ErrNoRows {
return friendRequestsIn, database.ErrEmptyList
} else {
return friendRequestsIn, err
}
}
for rows.Next() {
@ -28,18 +32,22 @@ func GetUserFriendRequestsIn(pid uint32) []*friends_wiiu.FriendRequest {
var received bool
rows.Scan(&id, &senderPID, &sentOn, &expiresOn, &message, &received)
friendRequest := friends_wiiu.NewFriendRequest()
userInfo, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
return nil, err
}
friendRequest.PrincipalInfo = GetUserInfoByPID(senderPID)
friendRequest := friends_wiiu_types.NewFriendRequest()
friendRequest.Message = friends_wiiu.NewFriendRequestMessage()
friendRequest.PrincipalInfo = userInfo
friendRequest.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequest.Message.FriendRequestID = id
friendRequest.Message.Received = received
friendRequest.Message.Unknown2 = 1
friendRequest.Message.Message = message
friendRequest.Message.Unknown3 = 0
friendRequest.Message.Unknown4 = ""
friendRequest.Message.GameKey = friends_wiiu.NewGameKey()
friendRequest.Message.GameKey = friends_wiiu_types.NewGameKey()
friendRequest.Message.GameKey.TitleID = 0
friendRequest.Message.GameKey.TitleVersion = 0
friendRequest.Message.Unknown5 = nex.NewDateTime(134222053376) // idk what this value means but its always this
@ -52,5 +60,5 @@ func GetUserFriendRequestsIn(pid uint32) []*friends_wiiu.FriendRequest {
}
}
return friendRequestsIn
return friendRequestsIn, nil
}

35
database/wiiu/get_user_friend_requests_out.go
View file

@ -1,20 +1,25 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/utility"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
// Get a users sent friend requests
func GetUserFriendRequestsOut(pid uint32) []*friends_wiiu.FriendRequest {
friendRequestsOut := make([]*friends_wiiu.FriendRequest, 0)
// GetUserFriendRequestsOut returns the friend requests sent by a user
func GetUserFriendRequestsOut(pid uint32) ([]*friends_wiiu_types.FriendRequest, error) {
friendRequestsOut := make([]*friends_wiiu_types.FriendRequest, 0)
rows, err := database.Postgres.Query(`SELECT id, recipient_pid, sent_on, expires_on, message, received FROM wiiu.friend_requests WHERE sender_pid=$1 AND accepted=false`, pid)
if err != nil {
globals.Logger.Critical(err.Error())
return friendRequestsOut
if err == sql.ErrNoRows {
return friendRequestsOut, database.ErrEmptyList
} else {
return friendRequestsOut, err
}
}
for rows.Next() {
@ -26,18 +31,22 @@ func GetUserFriendRequestsOut(pid uint32) []*friends_wiiu.FriendRequest {
var received bool
rows.Scan(&id, &recipientPID, &sentOn, &expiresOn, &message, &received)
friendRequest := friends_wiiu.NewFriendRequest()
userInfo, err := utility.GetUserInfoByPID(recipientPID)
if err != nil {
return nil, err
}
friendRequest.PrincipalInfo = GetUserInfoByPID(recipientPID)
friendRequest := friends_wiiu_types.NewFriendRequest()
friendRequest.Message = friends_wiiu.NewFriendRequestMessage()
friendRequest.PrincipalInfo = userInfo
friendRequest.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequest.Message.FriendRequestID = id
friendRequest.Message.Received = received
friendRequest.Message.Unknown2 = 1
friendRequest.Message.Message = message
friendRequest.Message.Unknown3 = 0
friendRequest.Message.Unknown4 = ""
friendRequest.Message.GameKey = friends_wiiu.NewGameKey()
friendRequest.Message.GameKey = friends_wiiu_types.NewGameKey()
friendRequest.Message.GameKey.TitleID = 0
friendRequest.Message.GameKey.TitleVersion = 0
friendRequest.Message.Unknown5 = nex.NewDateTime(134222053376) // idk what this value means but its always this
@ -47,5 +56,5 @@ func GetUserFriendRequestsOut(pid uint32) []*friends_wiiu.FriendRequest {
friendRequestsOut = append(friendRequestsOut, friendRequest)
}
return friendRequestsOut
return friendRequestsOut, nil
}

45
database/wiiu/get_user_info_by_pid.go
View file

@ -1,45 +0,0 @@
package database_wiiu
import (
"context"
"encoding/base64"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func GetUserInfoByPID(pid uint32) *friends_wiiu.PrincipalBasicInfo {
var result bson.M
err := database.MongoCollection.FindOne(context.TODO(), bson.D{{Key: "pid", Value: pid}}, options.FindOne()).Decode(&result)
if err != nil {
if err == mongo.ErrNoDocuments {
return nil
}
globals.Logger.Critical(err.Error())
}
info := friends_wiiu.NewPrincipalBasicInfo()
info.PID = pid
info.NNID = result["username"].(string)
info.Mii = friends_wiiu.NewMiiV2()
info.Unknown = 2
encodedMiiData := result["mii"].(bson.M)["data"].(string)
decodedMiiData, _ := base64.StdEncoding.DecodeString(encodedMiiData)
info.Mii.Name = result["mii"].(bson.M)["name"].(string)
info.Mii.Unknown1 = 0
info.Mii.Unknown2 = 0
info.Mii.Data = decodedMiiData
info.Mii.Datetime = nex.NewDateTime(0)
return info
}

8
database/wiiu/get_user_notifications.go
View file

@ -1,8 +1,8 @@
package database_wiiu
import friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
import friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
// Get notifications for a user
func GetUserNotifications(pid uint32) []*friends_wiiu.PersistentNotification {
return make([]*friends_wiiu.PersistentNotification, 0)
// GetUserNotifications returns notifications for a user
func GetUserNotifications(pid uint32) []*friends_wiiu_types.PersistentNotification {
return make([]*friends_wiiu_types.PersistentNotification, 0)
}

16
database/wiiu/get_user_principal_preference.go
View file

@ -3,22 +3,22 @@ package database_wiiu
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
"github.com/PretendoNetwork/friends/database"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func GetUserPrincipalPreference(pid uint32) *friends_wiiu.PrincipalPreference {
preference := friends_wiiu.NewPrincipalPreference()
// GetUserPrincipalPreference returns the user preferences
func GetUserPrincipalPreference(pid uint32) (*friends_wiiu_types.PrincipalPreference, error) {
preference := friends_wiiu_types.NewPrincipalPreference()
err := database.Postgres.QueryRow(`SELECT show_online, show_current_game, block_friend_requests FROM wiiu.user_data WHERE pid=$1`, pid).Scan(&preference.ShowOnlinePresence, &preference.ShowCurrentTitle, &preference.BlockFriendRequests)
if err != nil {
if err == sql.ErrNoRows {
globals.Logger.Warning(err.Error())
return nil, database.ErrPIDNotFound
} else {
globals.Logger.Critical(err.Error())
return nil, err
}
}
return preference
return preference, nil
}

10
database/wiiu/is_friend_request_blocked.go
View file

@ -1,16 +1,16 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func IsFriendRequestBlocked(requesterPID uint32, requestedPID uint32) bool {
// IsFriendRequestBlocked determines if a requester PID has blocked a requested PID
func IsFriendRequestBlocked(requesterPID uint32, requestedPID uint32) (bool, error) {
var found bool
err := database.Postgres.QueryRow(`SELECT COUNT(*) FROM wiiu.blocks WHERE blocker_pid=$1 AND blocked_pid=$2 LIMIT 1`, requesterPID, requestedPID).Scan(&found)
if err != nil {
globals.Logger.Critical(err.Error())
return false, err
}
return found
return found, nil
}

20
database/wiiu/remove_friendship.go
View file

@ -1,21 +1,27 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
// Remove a user's friend relationship
func RemoveFriendship(user1_pid uint32, user2_pid uint32) {
_, err := database.Postgres.Exec(`
// RemoveFriendship removes a user's friend relationship
func RemoveFriendship(user1_pid uint32, user2_pid uint32) error {
result, err := database.Postgres.Exec(`
DELETE FROM wiiu.friendships WHERE user1_pid=$1 AND user2_pid=$2`, user1_pid, user2_pid)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendshipNotFound
}
_, err = database.Postgres.Exec(`
UPDATE wiiu.friendships SET active=false WHERE user1_pid=$1 AND user2_pid=$2`, user2_pid, user1_pid)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

31
database/wiiu/save_friend_request.go
View file

@ -3,27 +3,33 @@ package database_wiiu
import (
"database/sql"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func SaveFriendRequest(senderPID uint32, recipientPID uint32, sentTime uint64, expireTime uint64, message string) uint64 {
// SaveFriendRequest registers a new friend request
func SaveFriendRequest(senderPID uint32, recipientPID uint32, sentTime uint64, expireTime uint64, message string) (uint64, error) {
var id uint64
friendRequestBlocked := IsFriendRequestBlocked(recipientPID, senderPID)
friendRequestBlocked, err := IsFriendRequestBlocked(recipientPID, senderPID)
if err != nil {
return 0, err
}
// Make sure we don't already have that friend request! If we do, give them the one we already have.
err := database.Postgres.QueryRow(`SELECT id FROM wiiu.friend_requests WHERE sender_pid=$1 AND recipient_pid=$2`, senderPID, recipientPID).Scan(&id)
err = database.Postgres.QueryRow(`SELECT id FROM wiiu.friend_requests WHERE sender_pid=$1 AND recipient_pid=$2`, senderPID, recipientPID).Scan(&id)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return 0
return 0, err
} else if id != 0 {
// If they aren't blocked, we want to unset the denied status on the previous request we have so that it appears again.
if friendRequestBlocked {
return id
return id, nil
} else {
UnsetFriendRequestDenied(id)
return id
err = UnsetFriendRequestDenied(id)
if err != nil {
return 0, err
}
return id, nil
}
}
@ -31,9 +37,8 @@ func SaveFriendRequest(senderPID uint32, recipientPID uint32, sentTime uint64, e
INSERT INTO wiiu.friend_requests (sender_pid, recipient_pid, sent_on, expires_on, message, received, accepted, denied)
VALUES ($1, $2, $3, $4, $5, false, false, $6) RETURNING id`, senderPID, recipientPID, sentTime, expireTime, message, friendRequestBlocked).Scan(&id)
if err != nil {
globals.Logger.Critical(err.Error())
return 0
return 0, err
}
return id
return id, nil
}

18
database/wiiu/set_friend_request_accepted.go
View file

@ -1,14 +1,20 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func SetFriendRequestAccepted(friendRequestID uint64) {
_, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET accepted=true WHERE id=$1`, friendRequestID)
// SetFriendRequestAccepted marks a friend request as accepted
func SetFriendRequestAccepted(friendRequestID uint64) error {
result, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET accepted=true WHERE id=$1`, friendRequestID)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendRequestNotFound
}
return nil
}

18
database/wiiu/set_friend_request_denied.go
View file

@ -1,14 +1,20 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func SetFriendRequestDenied(friendRequestID uint64) {
_, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET denied=true WHERE id=$1`, friendRequestID)
// SetFriendRequestDenied marks a friend request as denied
func SetFriendRequestDenied(friendRequestID uint64) error {
result, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET denied=true WHERE id=$1`, friendRequestID)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendRequestNotFound
}
return nil
}

18
database/wiiu/set_friend_request_received.go
View file

@ -1,14 +1,20 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func SetFriendRequestReceived(friendRequestID uint64) {
_, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET received=true WHERE id=$1`, friendRequestID)
// SetFriendRequestReceived marks a friend request as received
func SetFriendRequestReceived(friendRequestID uint64) error {
result, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET received=true WHERE id=$1`, friendRequestID)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendRequestNotFound
}
return nil
}

10
database/wiiu/set_user_blocked.go
View file

@ -3,12 +3,12 @@ package database_wiiu
import (
"time"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
)
func SetUserBlocked(blockerPID uint32, blockedPID uint32, titleId uint64, titleVersion uint16) {
// SetUserBlocked marks a blocked PID as blocked on a bloker PID block list
func SetUserBlocked(blockerPID uint32, blockedPID uint32, titleId uint64, titleVersion uint16) error {
date := nex.NewDateTime(0)
date.FromTimestamp(time.Now())
@ -19,6 +19,8 @@ func SetUserBlocked(blockerPID uint32, blockedPID uint32, titleId uint64, titleV
DO UPDATE SET
date = $5`, blockerPID, blockedPID, titleId, titleVersion, date.Value())
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

18
database/wiiu/unset_friend_request_denied.go
View file

@ -1,14 +1,20 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
func UnsetFriendRequestDenied(friendRequestID uint64) {
_, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET denied=false WHERE id=$1`, friendRequestID)
// UnsetFriendRequestDenied unmarks a friend request as denied
func UnsetFriendRequestDenied(friendRequestID uint64) error {
result, err := database.Postgres.Exec(`UPDATE wiiu.friend_requests SET denied=false WHERE id=$1`, friendRequestID)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrFriendRequestNotFound
}
return nil
}

18
database/wiiu/unset_user_blocked.go
View file

@ -1,15 +1,21 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
)
// Remove a block from a user
func UnsetUserBlocked(user1_pid uint32, user2_pid uint32) {
_, err := database.Postgres.Exec(`
// UnsetUserBlocked removes a block from a user
func UnsetUserBlocked(user1_pid uint32, user2_pid uint32) error {
result, err := database.Postgres.Exec(`
DELETE FROM wiiu.blocks WHERE blocker_pid=$1 AND blocked_pid=$2`, user1_pid, user2_pid)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
rowsAffected, _ := result.RowsAffected()
if rowsAffected == 0 {
return database.ErrPIDNotFound
}
return nil
}

11
database/wiiu/update_user_comment.go
View file

@ -1,13 +1,12 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
)
// Update a users comment
func UpdateUserComment(pid uint32, message string) uint64 {
// UpdateUserComment updates a user's comment
func UpdateUserComment(pid uint32, message string) (uint64, error) {
changed := nex.NewDateTime(0).Now()
_, err := database.Postgres.Exec(`
@ -19,8 +18,8 @@ func UpdateUserComment(pid uint32, message string) uint64 {
comment_changed = $3`, pid, message, changed)
if err != nil {
globals.Logger.Critical(err.Error())
return 0, err
}
return changed
return changed, nil
}

10
database/wiiu/update_user_last_online_time.go
View file

@ -1,12 +1,12 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/nex-go"
)
func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) {
// UpdateUserLastOnlineTime updates a user's last online time
func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) error {
_, err := database.Postgres.Exec(`
INSERT INTO wiiu.user_data (pid, last_online)
VALUES ($1, $2)
@ -15,6 +15,8 @@ func UpdateUserLastOnlineTime(pid uint32, lastOnline *nex.DateTime) {
last_online = $2`, pid, lastOnline.Value())
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

12
database/wiiu/update_user_principal_preference.go
View file

@ -1,12 +1,12 @@
package database_wiiu
import (
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
"github.com/PretendoNetwork/friends/database"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdateUserPrincipalPreference(pid uint32, principalPreference *friends_wiiu.PrincipalPreference) {
// UpdateUserPrincipalPreference updates the user preferences
func UpdateUserPrincipalPreference(pid uint32, principalPreference *friends_wiiu_types.PrincipalPreference) error {
_, err := database.Postgres.Exec(`
INSERT INTO wiiu.user_data (pid, show_online, show_current_game, block_friend_requests)
VALUES ($1, $2, $3, $4)
@ -17,6 +17,8 @@ func UpdateUserPrincipalPreference(pid uint32, principalPreference *friends_wiiu
block_friend_requests = $4`, pid, principalPreference.ShowOnlinePresence, principalPreference.ShowCurrentTitle, principalPreference.BlockFriendRequests)
if err != nil {
globals.Logger.Critical(err.Error())
return err
}
return nil
}

19
globals/get_user_data.go Normal file
View file

@ -0,0 +1,19 @@
package globals
import (
"context"
pb "github.com/PretendoNetwork/grpc-go/account"
"google.golang.org/grpc/metadata"
)
func GetUserData(pid uint32) (*pb.GetUserDataResponse, error) {
ctx := metadata.NewOutgoingContext(context.Background(), GRPCAccountCommonMetadata)
response, err := GRPCAccountClient.GetUserData(ctx, &pb.GetUserDataRequest{Pid: pid})
if err != nil {
return nil, err
}
return response, nil
}

14
globals/globals.go
View file

@ -1,12 +1,20 @@
package globals
import (
"github.com/PretendoNetwork/friends-secure/types"
"github.com/PretendoNetwork/friends/types"
pb "github.com/PretendoNetwork/grpc-go/account"
"github.com/PretendoNetwork/nex-go"
"github.com/PretendoNetwork/plogger-go"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
)
var Logger = plogger.NewLogger()
var NEXServer *nex.Server
var Logger *plogger.Logger
var KerberosPassword = "password" // * Default password
var AuthenticationServer *nex.Server
var SecureServer *nex.Server
var ConnectedUsers map[uint32]*types.ConnectedUser
var AESKey []byte
var GRPCAccountClientConnection *grpc.ClientConn
var GRPCAccountClient pb.AccountClient
var GRPCAccountCommonMetadata metadata.MD

21
globals/password_from_pid.go Normal file
View file

@ -0,0 +1,21 @@
package globals
import (
"context"
pb "github.com/PretendoNetwork/grpc-go/account"
"github.com/PretendoNetwork/nex-go"
"google.golang.org/grpc/metadata"
)
func PasswordFromPID(pid uint32) (string, uint32) {
ctx := metadata.NewOutgoingContext(context.Background(), GRPCAccountCommonMetadata)
response, err := GRPCAccountClient.GetNEXPassword(ctx, &pb.GetNEXPasswordRequest{Pid: pid})
if err != nil {
Logger.Error(err.Error())
return "", nex.Errors.RendezVous.InvalidUsername
}
return response.Password, 0
}

45
go.mod
View file

@ -1,44 +1,31 @@
module github.com/PretendoNetwork/friends-secure
module github.com/PretendoNetwork/friends
go 1.18
require (
github.com/PretendoNetwork/grpc-go v0.0.0-20230418154649-25a94d02f01f
github.com/PretendoNetwork/nex-go v1.0.26
github.com/PretendoNetwork/nex-protocols-go v1.0.31
github.com/PretendoNetwork/plogger-go v1.0.2
github.com/gocql/gocql v1.5.2
github.com/PretendoNetwork/grpc-go v1.0.2
github.com/PretendoNetwork/nex-go v1.0.41
github.com/PretendoNetwork/nex-protocols-common-go v1.0.28
github.com/PretendoNetwork/nex-protocols-go v1.0.54
github.com/PretendoNetwork/plogger-go v1.0.4
github.com/golang/protobuf v1.5.3
github.com/joho/godotenv v1.5.1
github.com/lib/pq v1.10.9
go.mongodb.org/mongo-driver v1.11.7
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1
google.golang.org/grpc v1.55.0
golang.org/x/exp v0.0.0-20231006140011-7918f672742d
google.golang.org/grpc v1.58.2
)
require (
github.com/fatih/color v1.15.0 // indirect
github.com/golang/snappy v0.0.4 // indirect
github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect
github.com/jwalton/go-supportscolor v1.1.0 // indirect
github.com/klauspost/compress v1.16.5 // indirect
github.com/jwalton/go-supportscolor v1.2.0 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect
github.com/mattn/go-isatty v0.0.19 // indirect
github.com/montanaflynn/stats v0.7.1 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/stretchr/testify v1.7.0 // indirect
github.com/superwhiskers/crunch/v3 v3.5.7 // indirect
github.com/xdg-go/pbkdf2 v1.0.0 // indirect
github.com/xdg-go/scram v1.1.2 // indirect
github.com/xdg-go/stringprep v1.0.4 // indirect
github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
golang.org/x/crypto v0.9.0 // indirect
golang.org/x/net v0.10.0 // indirect
golang.org/x/sync v0.2.0 // indirect
golang.org/x/sys v0.9.0 // indirect
golang.org/x/term v0.9.0 // indirect
golang.org/x/text v0.10.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc // indirect
google.golang.org/protobuf v1.30.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect
golang.org/x/mod v0.13.0 // indirect
golang.org/x/net v0.16.0 // indirect
golang.org/x/sys v0.13.0 // indirect
golang.org/x/term v0.13.0 // indirect
golang.org/x/text v0.13.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 // indirect
google.golang.org/protobuf v1.31.0 // indirect
)

149
go.sum
View file

@ -1,46 +1,24 @@
github.com/PretendoNetwork/grpc-go v0.0.0-20230418154649-25a94d02f01f h1:RfnZOFUIiw9rpxPo4RDkPXx7DdM8rxix3xfpbV/A2e8=
github.com/PretendoNetwork/grpc-go v0.0.0-20230418154649-25a94d02f01f/go.mod h1:XZjEsij9lL7HJBNkH6JPbBIkUSq/1rjflvjGdv+DAj0=
github.com/PretendoNetwork/nex-go v1.0.26 h1:lJqDS5F8s836xcQzCEI5hNvUesmTsh2NGDC4tZvG250=
github.com/PretendoNetwork/nex-go v1.0.26/go.mod h1:qzc5s4iNrt1ubS9Axb38b2jPuEsiETN2mDijn+MthmI=
github.com/PretendoNetwork/nex-protocols-go v1.0.31 h1:HnnfyXKO8HJRplL29VSmlGftBmITV91tnF1jVqjFw5Y=
github.com/PretendoNetwork/nex-protocols-go v1.0.31/go.mod h1:Pw1u2rsZGXuv45iM9y/7nZ5TBr1L5hctv9ylNXlW1ws=
github.com/PretendoNetwork/plogger-go v1.0.2 h1:vWKEnEmJJzYwqLxLyiSsAvCrZV6qnnu/a0GQOjIfzY0=
github.com/PretendoNetwork/plogger-go v1.0.2/go.mod h1:7kD6M4vPq1JL4LTuPg6kuB1OvUBOwQOtAvTaUwMbwvU=
github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY=
github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k=
github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/PretendoNetwork/grpc-go v1.0.2 h1:9TvKmX7dCOANyoHEra1MMYqS1N/RGav66TRG4SHInvo=
github.com/PretendoNetwork/grpc-go v1.0.2/go.mod h1:XZjEsij9lL7HJBNkH6JPbBIkUSq/1rjflvjGdv+DAj0=
github.com/PretendoNetwork/nex-go v1.0.41 h1:TcBb1Bpe2KAB+AXaGX1K9NVQBRtZJIoy4yCvRde2xbI=
github.com/PretendoNetwork/nex-go v1.0.41/go.mod h1:QwHEa165DeVd0xIuthrgc3j6NWXT8lyPSG6t5kC/Shk=
github.com/PretendoNetwork/nex-protocols-common-go v1.0.28 h1:ErkWga7Uzn4WoDU8Q/Sy+geHy0fF0G/5wFnL5i6hngI=
github.com/PretendoNetwork/nex-protocols-common-go v1.0.28/go.mod h1:4jYhLg+Cb2qhJHyyA+f2OwCrmc98zuTO3JPWK22mIKw=
github.com/PretendoNetwork/nex-protocols-go v1.0.54 h1:nDbGnNpe7F/cwBZBvFFFPS1afZQ4OLpVHfF8t5xug/Y=
github.com/PretendoNetwork/nex-protocols-go v1.0.54/go.mod h1:136762CMIcAsTZDrt4W7gDE4ppiBuc9zN2QFOHESjS8=
github.com/PretendoNetwork/plogger-go v1.0.4 h1:PF7xHw9eDRHH+RsAP9tmAE7fG0N0p6H4iPwHKnsoXwc=
github.com/PretendoNetwork/plogger-go v1.0.4/go.mod h1:7kD6M4vPq1JL4LTuPg6kuB1OvUBOwQOtAvTaUwMbwvU=
github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
github.com/gocql/gocql v1.5.2 h1:WnKf8xRQImcT/KLaEWG2pjEeryDB7K0qQN9mPs1C58Q=
github.com/gocql/gocql v1.5.2/go.mod h1:3gM2c4D3AnkISwBxGnMMsS8Oy4y2lhbPRsH4xnJrHG8=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/jwalton/go-supportscolor v1.1.0 h1:HsXFJdMPjRUAx8cIW6g30hVSFYaxh9yRQwEWgkAR7lQ=
github.com/jwalton/go-supportscolor v1.1.0/go.mod h1:hFVUAZV2cWg+WFFC4v8pT2X/S2qUUBYMioBD9AINXGs=
github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI=
github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/jwalton/go-supportscolor v1.2.0 h1:g6Ha4u7Vm3LIsQ5wmeBpS4gazu0UP1DRDE8y6bre4H8=
github.com/jwalton/go-supportscolor v1.2.0/go.mod h1:hFVUAZV2cWg+WFFC4v8pT2X/S2qUUBYMioBD9AINXGs=
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
@ -48,98 +26,31 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/superwhiskers/crunch/v3 v3.5.7 h1:N9RLxaR65C36i26BUIpzPXGy2f6pQ7wisu2bawbKNqg=
github.com/superwhiskers/crunch/v3 v3.5.7/go.mod h1:4ub2EKgF1MAhTjoOCTU4b9uLMsAweHEa89aRrfAypXA=
github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4=
github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk=
github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
github.com/xdg-go/scram v1.1.1/go.mod h1:RaEWvsqvNKKvBPvcKeFjrG2cJqOkHTiyTpzz23ni57g=
github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgklLGvcBnW8=
github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a h1:fZHgsYlfvtyqToslyjUt3VOPF4J7aK/3MPcK7xp3PDk=
github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a/go.mod h1:ul22v+Nro/R083muKhosV54bj5niojjWZvU8xrevuH4=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
go.mongodb.org/mongo-driver v1.11.7 h1:LIwYxASDLGUg/8wOhgOOZhX8tQa/9tgZPgzZoVqJvcs=
go.mongodb.org/mongo-driver v1.11.7/go.mod h1:G9TgswdsWjX4tmDA5zfs2+6AEPpYJwqblyjsfuh8oXY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.2.0 h1:PUR+T4wwASmuSTYdKjYHI5TD22Wy5ogLU5qZCOLxBrI=
golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY=
golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/net v0.16.0 h1:7eBu7KsSvFDtSXUIDbh3aqlK4DPsZ1rByC8PFfBThos=
golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.9.0 h1:GRRCnKYhdQrD8kfRAdQ6Zcw1P0OcELxGLKJvtjVMZ28=
golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/term v0.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc h1:XSJ8Vk1SWuNr8S18z1NZSziL0CPIXLCCMDOEFtHBOFc=
google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
google.golang.org/grpc v1.55.0 h1:3Oj82/tFSCeUrRTg/5E/7d/W5A1tj6Ky1ABAuZuv5ag=
google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8=
google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 h1:6GQBEOdGkX6MMTLT9V+TjtIRZCw9VPD5Z+yHY9wMgS0=
google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY=
google.golang.org/grpc v1.58.2 h1:SXUpjxeVF3FKrTYQI4f4KvbGD5u2xccdYdurwowix5I=
google.golang.org/grpc v1.58.2/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=

27
grpc/accept_friend_request.go
View file

@ -3,13 +3,36 @@ package grpc
import (
"context"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
)
func (s *gRPCFriendsServer) AcceptFriendRequest(ctx context.Context, in *pb.AcceptFriendRequestRequest) (*pb.AcceptFriendRequestResponse, error) {
friendInfo := database_wiiu.AcceptFriendRequestAndReturnFriendInfo(in.GetFriendRequestId())
friendInfo, err := database_wiiu.AcceptFriendRequestAndReturnFriendInfo(in.GetFriendRequestId())
if err != nil {
if err == database.ErrFriendRequestNotFound {
return &pb.AcceptFriendRequestResponse{
Success: false,
}, status.Errorf(codes.NotFound, "friend request not found")
}
if err == database.ErrPIDNotFound {
return &pb.AcceptFriendRequestResponse{
Success: false,
}, status.Errorf(codes.FailedPrecondition, "friend request has invalid PID")
}
globals.Logger.Critical(err.Error())
return &pb.AcceptFriendRequestResponse{
Success: false,
}, status.Errorf(codes.Internal, "internal server error")
}
return &pb.AcceptFriendRequestResponse{
Success: friendInfo != nil,

22
grpc/deny_friend_request.go
View file

@ -3,13 +3,29 @@ package grpc
import (
"context"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
)
func (s *gRPCFriendsServer) DenyFriendRequest(ctx context.Context, in *pb.DenyFriendRequestRequest) (*pb.DenyFriendRequestResponse, error) {
// TODO - Make this return an error
database_wiiu.SetFriendRequestDenied(in.GetFriendRequestId())
err := database_wiiu.SetFriendRequestDenied(in.GetFriendRequestId())
if err != nil {
if err == database.ErrFriendRequestNotFound {
return &pb.DenyFriendRequestResponse{
Success: false,
}, status.Errorf(codes.NotFound, "friend request not found")
}
globals.Logger.Critical(err.Error())
return &pb.DenyFriendRequestResponse{
Success: false,
}, status.Errorf(codes.Internal, "internal server error")
}
return &pb.DenyFriendRequestResponse{
Success: true,

22
grpc/get_user_friend_pids.go
View file

@ -3,16 +3,26 @@ package grpc
import (
"context"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/friends/database"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
)
func (s *gRPCFriendsServer) GetUserFriendPIDs(ctx context.Context, in *pb.GetUserFriendPIDsRequest) (*pb.GetUserFriendPIDsResponse, error) {
var pids []uint32
var err error
// * Try Wii U database first
pids = database_wiiu.GetUserFriendPIDs(in.GetPid())
pids, err = database_wiiu.GetUserFriendPIDs(in.GetPid())
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nil, status.Errorf(codes.Internal, "internal server error")
}
if len(pids) > 0 {
return &pb.GetUserFriendPIDsResponse{
@ -21,7 +31,11 @@ func (s *gRPCFriendsServer) GetUserFriendPIDs(ctx context.Context, in *pb.GetUse
}
// * If no PIDs are given, try with 3DS database instead
relationships := database_3ds.GetUserFriends(in.GetPid())
relationships, err := database_3ds.GetUserFriends(in.GetPid())
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nil, status.Errorf(codes.Internal, "internal server error")
}
for _, relationship := range relationships {
// * Only add complete relationships to the list

13
grpc/get_user_friend_requests_incoming.go
View file

@ -3,13 +3,22 @@ package grpc
import (
"context"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
)
func (s *gRPCFriendsServer) GetUserFriendRequestsIncoming(ctx context.Context, in *pb.GetUserFriendRequestsIncomingRequest) (*pb.GetUserFriendRequestsIncomingResponse, error) {
friendRequestsIn := database_wiiu.GetUserFriendRequestsIn(in.GetPid())
friendRequestsIn, err := database_wiiu.GetUserFriendRequestsIn(in.GetPid())
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return nil, status.Errorf(codes.Internal, "internal server error")
}
friendRequests := make([]*pb.FriendRequest, 0, len(friendRequestsIn))

4
grpc/grpc_server.go
View file

@ -1,8 +1,10 @@
package grpc
import (
"fmt"
"log"
"net"
"os"
pb "github.com/PretendoNetwork/grpc-go/friends"
"google.golang.org/grpc"
@ -13,7 +15,7 @@ type gRPCFriendsServer struct {
}
func StartGRPCServer() {
listener, err := net.Listen("tcp", ":50051")
listener, err := net.Listen("tcp", fmt.Sprintf(":%s", os.Getenv("PN_FRIENDS_GRPC_SERVER_PORT")))
if err != nil {
log.Fatalf("failed to listen: %v", err)
}

16
grpc/send_user_friend_request.go
View file

@ -4,7 +4,11 @@ import (
"context"
"time"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
nex "github.com/PretendoNetwork/nex-go"
)
@ -24,9 +28,15 @@ func (s *gRPCFriendsServer) SendUserFriendRequest(ctx context.Context, in *pb.Se
message := in.GetMessage()
id := database_wiiu.SaveFriendRequest(sender, recipient, sentTime.Value(), expireTime.Value(), message)
id, err := database_wiiu.SaveFriendRequest(sender, recipient, sentTime.Value(), expireTime.Value(), message)
if err != nil {
globals.Logger.Critical(err.Error())
return &pb.SendUserFriendRequestResponse{
Success: false,
}, status.Errorf(codes.Internal, "internal server error")
}
return &pb.SendUserFriendRequestResponse{
Success: id == 0,
Success: id != 0,
}, nil
}

4
grpc/send_user_notification_wiiu.go
View file

@ -3,7 +3,7 @@ package grpc
import (
"context"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
pb "github.com/PretendoNetwork/grpc-go/friends"
nex "github.com/PretendoNetwork/nex-go"
nintendo_notifications "github.com/PretendoNetwork/nex-protocols-go/nintendo-notifications"
@ -34,7 +34,7 @@ func (s *gRPCFriendsServer) SendUserNotificationWiiU(ctx context.Context, in *pb
requestPacket.AddFlag(nex.FlagNeedsAck)
requestPacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(requestPacket)
globals.SecureServer.Send(requestPacket)
}
return &empty.Empty{}, nil

134
init.go
View file

@ -2,30 +2,148 @@ package main
import (
"encoding/hex"
"log"
"fmt"
"os"
"strconv"
"strings"
"github.com/PretendoNetwork/friends-secure/database"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends-secure/types"
"github.com/PretendoNetwork/friends/database"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/types"
"github.com/PretendoNetwork/plogger-go"
pb "github.com/PretendoNetwork/grpc-go/account"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/metadata"
"github.com/joho/godotenv"
)
func init() {
globals.Logger = plogger.NewLogger()
globals.ConnectedUsers = make(map[uint32]*types.ConnectedUser)
// Setup RSA private key for token parsing
var err error
err = godotenv.Load()
if err != nil {
log.Fatal("Error loading .env file")
globals.Logger.Warningf("Error loading .env file: %s", err.Error())
}
globals.AESKey, err = hex.DecodeString(os.Getenv("PN_FRIENDS_CONFIG_AES_KEY"))
postgresURI := os.Getenv("PN_FRIENDS_CONFIG_DATABASE_URI")
kerberosPassword := os.Getenv("PN_FRIENDS_CONFIG_KERBEROS_PASSWORD")
aesKey := os.Getenv("PN_FRIENDS_CONFIG_AES_KEY")
grpcAPIKey := os.Getenv("PN_FRIENDS_CONFIG_GRPC_API_KEY")
grpcServerPort := os.Getenv("PN_FRIENDS_GRPC_SERVER_PORT")
authenticationServerPort := os.Getenv("PN_FRIENDS_AUTHENTICATION_SERVER_PORT")
secureServerHost := os.Getenv("PN_FRIENDS_SECURE_SERVER_HOST")
secureServerPort := os.Getenv("PN_FRIENDS_SECURE_SERVER_PORT")
accountGRPCHost := os.Getenv("PN_FRIENDS_ACCOUNT_GRPC_HOST")
accountGRPCPort := os.Getenv("PN_FRIENDS_ACCOUNT_GRPC_PORT")
accountGRPCAPIKey := os.Getenv("PN_FRIENDS_ACCOUNT_GRPC_API_KEY")
if strings.TrimSpace(postgresURI) == "" {
globals.Logger.Error("PN_FRIENDS_CONFIG_DATABASE_URI environment variable not set")
os.Exit(0)
}
if strings.TrimSpace(kerberosPassword) == "" {
globals.Logger.Warningf("PN_FRIENDS_CONFIG_KERBEROS_PASSWORD environment variable not set. Using default password: %q", globals.KerberosPassword)
} else {
globals.KerberosPassword = kerberosPassword
}
if strings.TrimSpace(aesKey) == "" {
globals.Logger.Error("PN_FRIENDS_CONFIG_AES_KEY environment variable not set")
os.Exit(0)
} else {
globals.AESKey, err = hex.DecodeString(os.Getenv("PN_FRIENDS_CONFIG_AES_KEY"))
if err != nil {
globals.Logger.Criticalf("Failed to decode AES key: %v", err)
os.Exit(0)
}
}
if strings.TrimSpace(grpcAPIKey) == "" {
globals.Logger.Warning("Insecure gRPC server detected. PN_FRIENDS_CONFIG_GRPC_API_KEY environment variable not set")
}
if strings.TrimSpace(grpcServerPort) == "" {
globals.Logger.Error("PN_FRIENDS_GRPC_SERVER_PORT environment variable not set")
os.Exit(0)
}
if port, err := strconv.Atoi(grpcServerPort); err != nil {
globals.Logger.Errorf("PN_FRIENDS_GRPC_SERVER_PORT is not a valid port. Expected 0-65535, got %s", grpcServerPort)
os.Exit(0)
} else if port < 0 || port > 65535 {
globals.Logger.Errorf("PN_FRIENDS_GRPC_SERVER_PORT is not a valid port. Expected 0-65535, got %s", grpcServerPort)
os.Exit(0)
}
if strings.TrimSpace(authenticationServerPort) == "" {
globals.Logger.Error("PN_FRIENDS_AUTHENTICATION_SERVER_PORT environment variable not set")
os.Exit(0)
}
if port, err := strconv.Atoi(authenticationServerPort); err != nil {
globals.Logger.Errorf("PN_FRIENDS_AUTHENTICATION_SERVER_PORT is not a valid port. Expected 0-65535, got %s", authenticationServerPort)
os.Exit(0)
} else if port < 0 || port > 65535 {
globals.Logger.Errorf("PN_FRIENDS_AUTHENTICATION_SERVER_PORT is not a valid port. Expected 0-65535, got %s", authenticationServerPort)
os.Exit(0)
}
if strings.TrimSpace(secureServerHost) == "" {
globals.Logger.Error("PN_FRIENDS_SECURE_SERVER_HOST environment variable not set")
os.Exit(0)
}
if strings.TrimSpace(secureServerPort) == "" {
globals.Logger.Error("PN_FRIENDS_SECURE_SERVER_PORT environment variable not set")
os.Exit(0)
}
if port, err := strconv.Atoi(secureServerPort); err != nil {
globals.Logger.Errorf("PN_FRIENDS_SECURE_SERVER_PORT is not a valid port. Expected 0-65535, got %s", secureServerPort)
os.Exit(0)
} else if port < 0 || port > 65535 {
globals.Logger.Errorf("PN_FRIENDS_SECURE_SERVER_PORT is not a valid port. Expected 0-65535, got %s", secureServerPort)
os.Exit(0)
}
if strings.TrimSpace(accountGRPCHost) == "" {
globals.Logger.Error("PN_FRIENDS_ACCOUNT_GRPC_HOST environment variable not set")
os.Exit(0)
}
if strings.TrimSpace(accountGRPCPort) == "" {
globals.Logger.Error("PN_FRIENDS_ACCOUNT_GRPC_PORT environment variable not set")
os.Exit(0)
}
if port, err := strconv.Atoi(accountGRPCPort); err != nil {
globals.Logger.Errorf("PN_FRIENDS_ACCOUNT_GRPC_PORT is not a valid port. Expected 0-65535, got %s", accountGRPCPort)
os.Exit(0)
} else if port < 0 || port > 65535 {
globals.Logger.Errorf("PN_FRIENDS_ACCOUNT_GRPC_PORT is not a valid port. Expected 0-65535, got %s", accountGRPCPort)
os.Exit(0)
}
if strings.TrimSpace(accountGRPCAPIKey) == "" {
globals.Logger.Warning("Insecure gRPC server detected. PN_FRIENDS_ACCOUNT_GRPC_API_KEY environment variable not set")
}
globals.GRPCAccountClientConnection, err = grpc.Dial(fmt.Sprintf("%s:%s", accountGRPCHost, accountGRPCPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatal(err)
globals.Logger.Criticalf("Failed to connect to account gRPC server: %v", err)
os.Exit(0)
}
database.Connect()
globals.GRPCAccountClient = pb.NewAccountClient(globals.GRPCAccountClientConnection)
globals.GRPCAccountCommonMetadata = metadata.Pairs(
"X-API-Key", accountGRPCAPIKey,
)
database.ConnectPostgres()
}

9
main.go
View file

@ -3,17 +3,18 @@ package main
import (
"sync"
"github.com/PretendoNetwork/friends-secure/grpc"
"github.com/PretendoNetwork/friends-secure/nex"
"github.com/PretendoNetwork/friends/grpc"
"github.com/PretendoNetwork/friends/nex"
)
var wg sync.WaitGroup
func main() {
wg.Add(2)
wg.Add(3)
go grpc.StartGRPCServer()
go nex.StartNEXServer()
go nex.StartAuthenticationServer()
go nex.StartSecureServer()
wg.Wait()
}

81
nex/account-management/nintendo_create_account.go
View file

@ -8,64 +8,77 @@ import (
"encoding/hex"
"strings"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends-secure/utility"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
nex "github.com/PretendoNetwork/nex-go"
account_management "github.com/PretendoNetwork/nex-protocols-go/account-management"
account_management_types "github.com/PretendoNetwork/nex-protocols-go/account-management/types"
)
func NintendoCreateAccount(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder) {
func NintendoCreateAccount(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder) uint32 {
if err != nil {
// TODO: Handle error
globals.Logger.Critical(err.Error())
globals.Logger.Error(err.Error())
return nex.Errors.Core.InvalidArgument
}
rmcResponse := nex.NewRMCResponse(account_management.ProtocolID, callID)
var tokenBase64 string
oAuthDataType := oAuthData.TypeName()
if oAuthDataType == "NintendoCreateAccountData" { // Wii U
nintendoCreateAccountData := oAuthData.ObjectData().(*account_management.NintendoCreateAccountData)
switch oAuthDataType {
case "NintendoCreateAccountData": // Wii U
nintendoCreateAccountData := oAuthData.ObjectData().(*account_management_types.NintendoCreateAccountData)
tokenBase64 = nintendoCreateAccountData.Token
} else if oAuthDataType == "AccountExtraInfo" { // 3DS
accountExtraInfo := oAuthData.ObjectData().(*account_management.AccountExtraInfo)
case "AccountExtraInfo": // 3DS
accountExtraInfo := oAuthData.ObjectData().(*account_management_types.AccountExtraInfo)
tokenBase64 = accountExtraInfo.NEXToken
tokenBase64 = strings.Replace(tokenBase64, ".", "+", -1)
tokenBase64 = strings.Replace(tokenBase64, "-", "/", -1)
tokenBase64 = strings.Replace(tokenBase64, "*", "=", -1)
default:
globals.Logger.Errorf("Invalid oAuthData data type %s!", oAuthDataType)
return nex.Errors.Authentication.TokenParseError
}
encryptedToken, _ := base64.StdEncoding.DecodeString(tokenBase64)
encryptedToken, err := base64.StdEncoding.DecodeString(tokenBase64)
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Authentication.TokenParseError
}
decryptedToken, err := utility.DecryptToken(encryptedToken)
if err != nil {
globals.Logger.Error(err.Error())
rmcResponse.SetError(nex.Errors.Authentication.TokenParseError)
} else {
pid := decryptedToken.UserPID
pidByteArray := make([]byte, 4)
binary.LittleEndian.PutUint32(pidByteArray, pid)
mac := hmac.New(md5.New, []byte(strKey))
mac.Write(pidByteArray)
pidHmac := hex.EncodeToString(mac.Sum(nil))
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream.WriteUInt32LE(pid)
rmcResponseStream.WriteString(pidHmac)
rmcResponseBody := rmcResponseStream.Bytes()
rmcResponse.SetSuccess(account_management.MethodNintendoCreateAccount, rmcResponseBody)
return nex.Errors.Authentication.TokenParseError
}
pid := decryptedToken.UserPID
pidByteArray := make([]byte, 4)
binary.LittleEndian.PutUint32(pidByteArray, pid)
mac := hmac.New(md5.New, []byte(strKey))
_, err = mac.Write(pidByteArray)
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Authentication.Unknown
}
pidHmac := hex.EncodeToString(mac.Sum(nil))
rmcResponse := nex.NewRMCResponse(account_management.ProtocolID, callID)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteUInt32LE(pid)
rmcResponseStream.WriteString(pidHmac)
rmcResponseBody := rmcResponseStream.Bytes()
rmcResponse.SetSuccess(account_management.MethodNintendoCreateAccount, rmcResponseBody)
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
@ -79,5 +92,7 @@ func NintendoCreateAccount(err error, client *nex.Client, callID uint32, strPrin
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

38
nex/authentication.go Normal file
View file

@ -0,0 +1,38 @@
package nex
import (
"fmt"
"os"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/nex-go"
)
var serverBuildString string
func StartAuthenticationServer() {
globals.AuthenticationServer = nex.NewServer()
globals.AuthenticationServer.SetPRUDPVersion(0)
globals.AuthenticationServer.SetPRUDPProtocolMinorVersion(0) // TODO: Figure out what to put here
globals.AuthenticationServer.SetDefaultNEXVersion(&nex.NEXVersion{
Major: 1,
Minor: 1,
Patch: 0,
})
globals.AuthenticationServer.SetKerberosKeySize(16)
globals.AuthenticationServer.SetKerberosPassword(globals.KerberosPassword)
globals.AuthenticationServer.SetAccessKey("ridfebb9")
globals.AuthenticationServer.On("Data", func(packet *nex.PacketV0) {
request := packet.RMCRequest()
fmt.Println("==Friends - Auth==")
fmt.Printf("Protocol ID: %#v\n", request.ProtocolID())
fmt.Printf("Method ID: %#v\n", request.MethodID())
fmt.Println("===============")
})
registerCommonAuthenticationServerProtocols()
globals.AuthenticationServer.Listen(fmt.Sprintf(":%s", os.Getenv("PN_FRIENDS_AUTHENTICATION_SERVER_PORT")))
}

79
nex/connect.go
View file

@ -1,54 +1,73 @@
package nex
import (
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends-secure/types"
"time"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
)
func connect(packet *nex.PacketV0) {
packet.Sender().SetClientConnectionSignature(packet.ConnectionSignature())
// * We aren't making any replies here because the common Secure Protocol already does that
// *
// * We only want to check that the data given is right so that we don't register a client
// * with an invalid request
payload := packet.Payload()
stream := nex.NewStreamIn(payload, globals.NEXServer)
stream := nex.NewStreamIn(payload, globals.SecureServer)
ticketData, _ := stream.ReadBuffer()
requestData, _ := stream.ReadBuffer()
ticketData, err := stream.ReadBuffer()
if err != nil {
return
}
serverKey := nex.DeriveKerberosKey(2, []byte(globals.NEXServer.KerberosPassword()))
requestData, err := stream.ReadBuffer()
if err != nil {
return
}
// TODO: use random key from auth server
ticketDataEncryption, _ := nex.NewKerberosEncryption(serverKey)
decryptedTicketData := ticketDataEncryption.Decrypt(ticketData)
ticketDataStream := nex.NewStreamIn(decryptedTicketData, globals.NEXServer)
serverKey := nex.DeriveKerberosKey(2, []byte(globals.SecureServer.KerberosPassword()))
_, _ = ticketDataStream.ReadUInt64LE() // expiration time
_, _ = ticketDataStream.ReadUInt32LE() // User PID
sessionKey := ticketDataStream.ReadBytesNext(16)
ticket := nex.NewKerberosTicketInternalData()
err = ticket.Decrypt(nex.NewStreamIn(ticketData, globals.SecureServer), serverKey)
if err != nil {
return
}
requestDataEncryption, _ := nex.NewKerberosEncryption(sessionKey)
decryptedRequestData := requestDataEncryption.Decrypt(requestData)
requestDataStream := nex.NewStreamIn(decryptedRequestData, globals.NEXServer)
ticketTime := ticket.Timestamp().Standard()
serverTime := time.Now().UTC()
userPID, _ := requestDataStream.ReadUInt32LE() // User PID
timeLimit := ticketTime.Add(time.Minute * 2)
if serverTime.After(timeLimit) {
return
}
_, _ = requestDataStream.ReadUInt32LE() //CID of secure server station url
responseCheck, _ := requestDataStream.ReadUInt32LE()
sessionKey := ticket.SessionKey()
kerberos, err := nex.NewKerberosEncryption(sessionKey)
if err != nil {
return
}
responseValueStream := nex.NewStreamOut(globals.NEXServer)
responseValueStream.WriteUInt32LE(responseCheck + 1)
decryptedRequestData := kerberos.Decrypt(requestData)
checkDataStream := nex.NewStreamIn(decryptedRequestData, globals.SecureServer)
responseValueBufferStream := nex.NewStreamOut(globals.NEXServer)
responseValueBufferStream.WriteBuffer(responseValueStream.Bytes())
userPID, err := checkDataStream.ReadUInt32LE()
if err != nil {
return
}
packet.Sender().UpdateRC4Key(sessionKey)
_, err = checkDataStream.ReadUInt32LE() // CID of secure server station url
if err != nil {
return
}
globals.NEXServer.AcknowledgePacket(packet, responseValueBufferStream.Bytes())
packet.Sender().SetPID(userPID)
_, err = checkDataStream.ReadUInt32LE() // Response check
if err != nil {
return
}
connectedUser := types.NewConnectedUser()
connectedUser.PID = packet.Sender().PID()
connectedUser.PID = userPID
connectedUser.Client = packet.Sender()
globals.ConnectedUsers[userPID] = connectedUser
}

27
nex/friends-3ds/add_friendship_by_pid.go
View file

@ -1,22 +1,31 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func AddFriendshipByPrincipalID(err error, client *nex.Client, callID uint32, lfc uint64, pid uint32) {
friendRelationship := database_3ds.SaveFriendship(client.PID(), pid)
func AddFriendshipByPrincipalID(err error, client *nex.Client, callID uint32, lfc uint64, pid uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
friendRelationship, err := database_3ds.SaveFriendship(client.PID(), pid)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
connectedUser := globals.ConnectedUsers[pid]
if connectedUser != nil {
go notifications_3ds.SendFriendshipCompleted(connectedUser.Client, pid, client.PID())
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(friendRelationship)
@ -38,5 +47,7 @@ func AddFriendshipByPrincipalID(err error, client *nex.Client, callID uint32, lf
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

27
nex/friends-3ds/get_all_friends.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetAllFriends(err error, client *nex.Client, callID uint32) {
friendRelationships := database_3ds.GetUserFriends(client.PID())
func GetAllFriends(err error, client *nex.Client, callID uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
friendRelationships, err := database_3ds.GetUserFriends(client.PID())
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(friendRelationships)
@ -32,5 +43,7 @@ func GetAllFriends(err error, client *nex.Client, callID uint32) {
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

27
nex/friends-3ds/get_friend_mii.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetFriendMii(err error, client *nex.Client, callID uint32, pids []uint32) {
miiList := database_3ds.GetFriendMiis(pids)
func GetFriendMii(err error, client *nex.Client, callID uint32, pids []uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
miiList, err := database_3ds.GetFriendMiis(pids)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(miiList)
@ -32,5 +43,7 @@ func GetFriendMii(err error, client *nex.Client, callID uint32, pids []uint32) {
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

27
nex/friends-3ds/get_friend_persistent_info.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
"database/sql"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetFriendPersistentInfo(err error, client *nex.Client, callID uint32, pids []uint32) {
infoList := database_3ds.GetFriendPersistentInfos(client.PID(), pids)
func GetFriendPersistentInfo(err error, client *nex.Client, callID uint32, pids []uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
infoList, err := database_3ds.GetFriendPersistentInfos(client.PID(), pids)
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(infoList)
@ -32,5 +43,7 @@ func GetFriendPersistentInfo(err error, client *nex.Client, callID uint32, pids
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

22
nex/friends-3ds/get_friend_presence.go
View file

@ -1,19 +1,25 @@
package nex_friends_3ds
import (
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func GetFriendPresence(err error, client *nex.Client, callID uint32, pids []uint32) {
presenceList := make([]*friends_3ds.FriendPresence, 0)
func GetFriendPresence(err error, client *nex.Client, callID uint32, pids []uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
}
presenceList := make([]*friends_3ds_types.FriendPresence, 0)
for i := 0; i < len(pids); i++ {
connectedUser := globals.ConnectedUsers[pids[i]]
if connectedUser != nil && connectedUser.Presence != nil {
friendPresence := friends_3ds.NewFriendPresence()
friendPresence := friends_3ds_types.NewFriendPresence()
friendPresence.PID = pids[i]
friendPresence.Presence = globals.ConnectedUsers[pids[i]].Presence
@ -21,7 +27,7 @@ func GetFriendPresence(err error, client *nex.Client, callID uint32, pids []uint
}
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(presenceList)
@ -43,5 +49,7 @@ func GetFriendPresence(err error, client *nex.Client, callID uint32, pids []uint
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

32
nex/friends-3ds/get_pid_by_lfc.go
View file

@ -1,29 +1,31 @@
package nex_friends_3ds
import (
"github.com/PretendoNetwork/friends-secure/globals"
// "github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
// friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func GetPrincipalIDByLocalFriendCode(err error, client *nex.Client, callID uint32, lfc uint64, lfcList []uint64) {
func GetPrincipalIDByLocalFriendCode(err error, client *nex.Client, callID uint32, lfc uint64, lfcList []uint64) uint32 {
// Respond with unimplemented, waiting for gRPC to retrieve PID from account server
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetError(nex.Errors.Core.NotImplemented)
// rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
// rmcResponse.SetError(nex.Errors.Core.NotImplemented)
rmcResponseBytes := rmcResponse.Bytes()
// rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
// responsePacket, _ := nex.NewPacketV0(client, nil)
responsePacket.SetVersion(0)
responsePacket.SetSource(0xA1)
responsePacket.SetDestination(0xAF)
responsePacket.SetType(nex.DataPacket)
responsePacket.SetPayload(rmcResponseBytes)
// responsePacket.SetVersion(0)
// responsePacket.SetSource(0xA1)
// responsePacket.SetDestination(0xAF)
// responsePacket.SetType(nex.DataPacket)
// responsePacket.SetPayload(rmcResponseBytes)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
// responsePacket.AddFlag(nex.FlagNeedsAck)
// responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
// globals.SecureServer.Send(responsePacket)
return nex.Errors.Core.NotImplemented
}

32
nex/friends-3ds/remove_friend_by_lfc.go
View file

@ -1,29 +1,31 @@
package nex_friends_3ds
import (
"github.com/PretendoNetwork/friends-secure/globals"
// "github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
// friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func RemoveFriendByLocalFriendCode(err error, client *nex.Client, callID uint32, friendLFC uint64) {
func RemoveFriendByLocalFriendCode(err error, client *nex.Client, callID uint32, friendLFC uint64) uint32 {
// Respond with unimplemented, waiting for gRPC to retrieve PID from account server
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetError(nex.Errors.Core.NotImplemented)
// rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
// rmcResponse.SetError(nex.Errors.Core.NotImplemented)
rmcResponseBytes := rmcResponse.Bytes()
// rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
// responsePacket, _ := nex.NewPacketV0(client, nil)
responsePacket.SetVersion(0)
responsePacket.SetSource(0xA1)
responsePacket.SetDestination(0xAF)
responsePacket.SetType(nex.DataPacket)
responsePacket.SetPayload(rmcResponseBytes)
// responsePacket.SetVersion(0)
// responsePacket.SetSource(0xA1)
// responsePacket.SetDestination(0xAF)
// responsePacket.SetType(nex.DataPacket)
// responsePacket.SetPayload(rmcResponseBytes)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
// responsePacket.AddFlag(nex.FlagNeedsAck)
// responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
// globals.SecureServer.Send(responsePacket)
return nex.Errors.Core.NotImplemented
}

33
nex/friends-3ds/remove_friend_by_pid.go
View file

@ -1,16 +1,33 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
"github.com/PretendoNetwork/friends/database"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func RemoveFriendByPrincipalID(err error, client *nex.Client, callID uint32, pid uint32) {
func RemoveFriendByPrincipalID(err error, client *nex.Client, callID uint32, pid uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.RemoveFriendship(client.PID(), pid)
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
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
go notifications_3ds.SendUserWentOffline(client, pid)
database_3ds.RemoveFriendship(client.PID(), pid)
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodRemoveFriendByPrincipalID, nil)
@ -28,5 +45,7 @@ func RemoveFriendByPrincipalID(err error, client *nex.Client, callID uint32, pid
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

45
nex/friends-3ds/sync_friend.go
View file

@ -1,26 +1,47 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
"database/sql"
"github.com/PretendoNetwork/friends/database"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
"golang.org/x/exp/slices"
)
func SyncFriend(err error, client *nex.Client, callID uint32, lfc uint64, pids []uint32, lfcList []uint64) {
friendRelationships := database_3ds.GetUserFriends(client.PID())
func SyncFriend(err error, client *nex.Client, callID uint32, lfc uint64, pids []uint32, lfcList []uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
friendRelationships, err := database_3ds.GetUserFriends(client.PID())
if err != nil && err != sql.ErrNoRows {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
for i := 0; i < len(friendRelationships); i++ {
if !slices.Contains(pids, friendRelationships[i].PID) {
database_3ds.RemoveFriendship(client.PID(), friendRelationships[i].PID)
err := database_3ds.RemoveFriendship(client.PID(), friendRelationships[i].PID)
if err != nil && err != database.ErrFriendshipNotFound {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
}
for i := 0; i < len(pids); i++ {
if !isPIDInRelationships(friendRelationships, pids[i]) {
friendRelationship := database_3ds.SaveFriendship(client.PID(), pids[i])
friendRelationship, err := database_3ds.SaveFriendship(client.PID(), pids[i])
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
friendRelationships = append(friendRelationships, friendRelationship)
@ -32,7 +53,7 @@ func SyncFriend(err error, client *nex.Client, callID uint32, lfc uint64, pids [
}
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(friendRelationships)
@ -54,10 +75,12 @@ func SyncFriend(err error, client *nex.Client, callID uint32, lfc uint64, pids [
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}
func isPIDInRelationships(relationships []*friends_3ds.FriendRelationship, pid uint32) bool {
func isPIDInRelationships(relationships []*friends_3ds_types.FriendRelationship, pid uint32) bool {
for i := range relationships {
if relationships[i].PID == pid {
return true

27
nex/friends-3ds/update_comment.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
)
func UpdateComment(err error, client *nex.Client, callID uint32, comment string) {
func UpdateComment(err error, client *nex.Client, callID uint32, comment string) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.UpdateUserComment(client.PID(), comment)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
go notifications_3ds.SendCommentUpdate(client, comment)
database_3ds.UpdateUserComment(client.PID(), comment)
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodUpdateComment, nil)
@ -28,5 +39,7 @@ func UpdateComment(err error, client *nex.Client, callID uint32, comment string)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

27
nex/friends-3ds/update_favorite_game_key.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateFavoriteGameKey(err error, client *nex.Client, callID uint32, gameKey *friends_3ds.GameKey) {
func UpdateFavoriteGameKey(err error, client *nex.Client, callID uint32, gameKey *friends_3ds_types.GameKey) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.UpdateUserFavoriteGame(client.PID(), gameKey)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
go notifications_3ds.SendFavoriteUpdate(client, gameKey)
database_3ds.UpdateUserFavoriteGame(client.PID(), gameKey)
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodUpdateFavoriteGameKey, nil)
@ -28,5 +39,7 @@ func UpdateFavoriteGameKey(err error, client *nex.Client, callID uint32, gameKey
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

27
nex/friends-3ds/update_mii.go
View file

@ -1,16 +1,27 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateMii(err error, client *nex.Client, callID uint32, mii *friends_3ds.Mii) {
func UpdateMii(err error, client *nex.Client, callID uint32, mii *friends_3ds_types.Mii) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.UpdateUserMii(client.PID(), mii)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
go notifications_3ds.SendMiiUpdateNotification(client)
database_3ds.UpdateUserMii(client.PID(), mii)
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodUpdateMii, nil)
@ -28,5 +39,7 @@ func UpdateMii(err error, client *nex.Client, callID uint32, mii *friends_3ds.Mi
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

32
nex/friends-3ds/update_preference.go
View file

@ -1,17 +1,29 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdatePreference(err error, client *nex.Client, callID uint32, showOnline bool, showCurrentGame bool, showPlayedGame bool) {
func UpdatePreference(err error, client *nex.Client, callID uint32, showOnline bool, showCurrentGame bool, showPlayedGame bool) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.UpdateUserPreferences(client.PID(), showOnline, showCurrentGame)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
if !showCurrentGame {
emptyPresence := friends_3ds.NewNintendoPresence()
emptyPresence.GameKey = friends_3ds.NewGameKey()
emptyPresence := friends_3ds_types.NewNintendoPresence()
emptyPresence.GameKey = friends_3ds_types.NewGameKey()
emptyPresence.ChangedFlags = 0xFFFFFFFF // All flags
notifications_3ds.SendPresenceUpdate(client, emptyPresence)
}
@ -19,8 +31,6 @@ func UpdatePreference(err error, client *nex.Client, callID uint32, showOnline b
notifications_3ds.SendUserWentOfflineGlobally(client)
}
database_3ds.UpdateUserPreferences(client.PID(), showOnline, showCurrentGame)
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodUpdatePreference, nil)
@ -37,5 +47,7 @@ func UpdatePreference(err error, client *nex.Client, callID uint32, showOnline b
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

24
nex/friends-3ds/update_presence.go
View file

@ -1,20 +1,26 @@
package nex_friends_3ds
import (
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
"github.com/PretendoNetwork/friends-secure/types"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdatePresence(err error, client *nex.Client, callID uint32, presence *friends_3ds.NintendoPresence, showGame bool) {
func UpdatePresence(err error, client *nex.Client, callID uint32, presence *friends_3ds_types.NintendoPresence, showGame bool) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
currentPresence := presence
// Send an entirely empty status, with every flag set to update
if !showGame {
currentPresence = friends_3ds.NewNintendoPresence()
currentPresence.GameKey = friends_3ds.NewGameKey()
currentPresence = friends_3ds_types.NewNintendoPresence()
currentPresence.GameKey = friends_3ds_types.NewGameKey()
currentPresence.ChangedFlags = 0xFFFFFFFF // All flags
}
@ -50,5 +56,7 @@ func UpdatePresence(err error, client *nex.Client, callID uint32, presence *frie
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

24
nex/friends-3ds/update_profile.go
View file

@ -1,14 +1,24 @@
package nex_friends_3ds
import (
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
"github.com/PretendoNetwork/friends-secure/globals"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_3ds_types "github.com/PretendoNetwork/nex-protocols-go/friends-3ds/types"
)
func UpdateProfile(err error, client *nex.Client, callID uint32, profileData *friends_3ds.MyProfile) {
database_3ds.UpdateUserProfile(client.PID(), profileData)
func UpdateProfile(err error, client *nex.Client, callID uint32, profileData *friends_3ds_types.MyProfile) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_3ds.UpdateUserProfile(client.PID(), profileData)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponse := nex.NewRMCResponse(friends_3ds.ProtocolID, callID)
rmcResponse.SetSuccess(friends_3ds.MethodUpdateProfile, nil)
@ -26,5 +36,7 @@ func UpdateProfile(err error, client *nex.Client, callID uint32, profileData *fr
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

45
nex/friends-wiiu/accept_friend_request.go
View file

@ -1,15 +1,30 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AcceptFriendRequest(err error, client *nex.Client, callID uint32, id uint64) {
friendInfo := database_wiiu.AcceptFriendRequestAndReturnFriendInfo(id)
func AcceptFriendRequest(err error, client *nex.Client, callID uint32, id uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
friendInfo, err := database_wiiu.AcceptFriendRequestAndReturnFriendInfo(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
friendPID := friendInfo.NNAInfo.PrincipalBasicInfo.PID
connectedUser := globals.ConnectedUsers[friendPID]
@ -18,11 +33,19 @@ func AcceptFriendRequest(err error, client *nex.Client, callID uint32, id uint64
senderPID := client.PID()
senderConnectedUser := globals.ConnectedUsers[senderPID]
senderFriendInfo := friends_wiiu.NewFriendInfo()
senderFriendInfo := friends_wiiu_types.NewFriendInfo()
senderFriendInfo.NNAInfo = senderConnectedUser.NNAInfo
senderFriendInfo.Presence = senderConnectedUser.PresenceV2
senderFriendInfo.Status = database_wiiu.GetUserComment(senderPID)
status, err := database_wiiu.GetUserComment(senderPID)
if err != nil {
globals.Logger.Critical(err.Error())
senderFriendInfo.Status = friends_wiiu_types.NewComment()
senderFriendInfo.Status.LastChanged = nex.NewDateTime(0)
} else {
senderFriendInfo.Status = status
}
senderFriendInfo.BecameFriend = friendInfo.BecameFriend
senderFriendInfo.LastOnline = friendInfo.LastOnline // TODO: Change this
senderFriendInfo.Unknown = 0
@ -30,7 +53,7 @@ func AcceptFriendRequest(err error, client *nex.Client, callID uint32, id uint64
go notifications_wiiu.SendFriendRequestAccepted(connectedUser.Client, senderFriendInfo)
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(friendInfo)
@ -53,5 +76,7 @@ func AcceptFriendRequest(err error, client *nex.Client, callID uint32, id uint64
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

58
nex/friends-wiiu/add_blacklist.go
View file

@ -3,13 +3,21 @@ package nex_friends_wiiu
import (
"time"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AddBlacklist(err error, client *nex.Client, callID uint32, blacklistPrincipal *friends_wiiu.BlacklistedPrincipal) {
func AddBlacklist(err error, client *nex.Client, callID uint32, blacklistPrincipal *friends_wiiu_types.BlacklistedPrincipal) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
currentBlacklistPrincipal := blacklistPrincipal
senderPID := currentBlacklistPrincipal.PrincipalBasicInfo.PID
@ -19,36 +27,26 @@ func AddBlacklist(err error, client *nex.Client, callID uint32, blacklistPrincip
date := nex.NewDateTime(0)
date.FromTimestamp(time.Now())
userInfo := database_wiiu.GetUserInfoByPID(currentBlacklistPrincipal.PrincipalBasicInfo.PID)
if userInfo == nil {
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetError(nex.Errors.FPD.FriendNotExists) // TODO: Not sure if this is the correct error.
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
responsePacket.SetVersion(0)
responsePacket.SetSource(0xA1)
responsePacket.SetDestination(0xAF)
responsePacket.SetType(nex.DataPacket)
responsePacket.SetPayload(rmcResponseBytes)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
return
userInfo, err := utility.GetUserInfoByPID(currentBlacklistPrincipal.PrincipalBasicInfo.PID)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID // TODO: Not sure if this is the correct error.
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
currentBlacklistPrincipal.PrincipalBasicInfo = userInfo
currentBlacklistPrincipal.BlackListedSince = date
database_wiiu.SetUserBlocked(client.PID(), senderPID, titleID, titleVersion)
err = database_wiiu.SetUserBlocked(client.PID(), senderPID, titleID, titleVersion)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(blacklistPrincipal)
@ -71,5 +69,7 @@ func AddBlacklist(err error, client *nex.Client, callID uint32, blacklistPrincip
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

93
nex/friends-wiiu/add_friend_request.go
View file

@ -1,43 +1,42 @@
package nex_friends_wiiu
import (
"fmt"
"time"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
"github.com/PretendoNetwork/friends/utility"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *friends_wiiu.GameKey, unknown6 *nex.DateTime) {
func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *friends_wiiu_types.GameKey, unknown6 *nex.DateTime) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
senderPID := client.PID()
recipientPID := pid
recipient := database_wiiu.GetUserInfoByPID(recipientPID)
if recipient == nil {
globals.Logger.Error(fmt.Sprintf("User %d has sent friend request to invalid PID %d", senderPID, pid))
senderPrincipalInfo, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetError(nex.Errors.FPD.InvalidPrincipalID) // TODO - Is this the right error?
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
responsePacket.SetVersion(0)
responsePacket.SetSource(0xA1)
responsePacket.SetDestination(0xAF)
responsePacket.SetType(nex.DataPacket)
responsePacket.SetPayload(rmcResponseBytes)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
return
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.
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
currentTimestamp := time.Now()
@ -49,13 +48,17 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
sentTime.FromTimestamp(currentTimestamp)
expireTime.FromTimestamp(expireTimestamp)
friendRequestID := database_wiiu.SaveFriendRequest(senderPID, recipientPID, sentTime.Value(), expireTime.Value(), message)
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
}
friendRequest := friends_wiiu.NewFriendRequest()
friendRequest := friends_wiiu_types.NewFriendRequest()
friendRequest.PrincipalInfo = database_wiiu.GetUserInfoByPID(recipientPID)
friendRequest.PrincipalInfo = recipientPrincipalInfo
friendRequest.Message = friends_wiiu.NewFriendRequestMessage()
friendRequest.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequest.Message.FriendRequestID = friendRequestID
friendRequest.Message.Received = false
friendRequest.Message.Unknown2 = 1 // replaying from real
@ -68,23 +71,23 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
friendRequest.SentOn = sentTime
// Why does this exist?? Always empty??
friendInfo := friends_wiiu.NewFriendInfo()
friendInfo := friends_wiiu_types.NewFriendInfo()
friendInfo.NNAInfo = friends_wiiu.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = friends_wiiu.NewPrincipalBasicInfo()
friendInfo.NNAInfo = friends_wiiu_types.NewNNAInfo()
friendInfo.NNAInfo.PrincipalBasicInfo = friends_wiiu_types.NewPrincipalBasicInfo()
friendInfo.NNAInfo.PrincipalBasicInfo.PID = 0
friendInfo.NNAInfo.PrincipalBasicInfo.NNID = ""
friendInfo.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu.NewMiiV2()
friendInfo.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu_types.NewMiiV2()
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Name = ""
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Unknown1 = 0
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Unknown2 = 0
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Data = []byte{}
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.MiiData = []byte{}
friendInfo.NNAInfo.PrincipalBasicInfo.Mii.Datetime = nex.NewDateTime(0)
friendInfo.NNAInfo.PrincipalBasicInfo.Unknown = 0
friendInfo.NNAInfo.Unknown1 = 0
friendInfo.NNAInfo.Unknown2 = 0
friendInfo.Presence = friends_wiiu.NewNintendoPresenceV2()
friendInfo.Presence = friends_wiiu_types.NewNintendoPresenceV2()
friendInfo.Presence.ChangedFlags = 0
friendInfo.Presence.Online = false
friendInfo.Presence.GameKey = gameKey // maybe this is reused?
@ -101,7 +104,7 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
friendInfo.Presence.Unknown6 = 0
friendInfo.Presence.Unknown7 = 0
friendInfo.Status = friends_wiiu.NewComment()
friendInfo.Status = friends_wiiu_types.NewComment()
friendInfo.Status.Unknown = 0
friendInfo.Status.Contents = ""
friendInfo.Status.LastChanged = nex.NewDateTime(0)
@ -114,11 +117,11 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
if recipientClient != nil {
friendRequestNotificationData := friends_wiiu.NewFriendRequest()
friendRequestNotificationData := friends_wiiu_types.NewFriendRequest()
friendRequestNotificationData.PrincipalInfo = database_wiiu.GetUserInfoByPID(senderPID)
friendRequestNotificationData.PrincipalInfo = senderPrincipalInfo
friendRequestNotificationData.Message = friends_wiiu.NewFriendRequestMessage()
friendRequestNotificationData.Message = friends_wiiu_types.NewFriendRequestMessage()
friendRequestNotificationData.Message.FriendRequestID = friendRequestID
friendRequestNotificationData.Message.Received = false
friendRequestNotificationData.Message.Unknown2 = 1 // replaying from real
@ -133,7 +136,7 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
go notifications_wiiu.SendFriendRequest(recipientClient, friendRequestNotificationData)
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(friendRequest)
rmcResponseStream.WriteStructure(friendInfo)
@ -157,5 +160,7 @@ func AddFriendRequest(err error, client *nex.Client, callID uint32, pid uint32,
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

30
nex/friends-wiiu/cancel_friend_request.go
View file

@ -1,15 +1,29 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func CancelFriendRequest(err error, client *nex.Client, callID uint32, id uint64) {
pid := database_wiiu.DeleteFriendRequestAndReturnFriendPID(id)
func CancelFriendRequest(err error, client *nex.Client, callID uint32, id uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
pid, err := database_wiiu.DeleteFriendRequestAndReturnFriendPID(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
connectedUser := globals.ConnectedUsers[pid]
if connectedUser != nil {
@ -33,5 +47,7 @@ func CancelFriendRequest(err error, client *nex.Client, callID uint32, id uint64
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

17
nex/friends-wiiu/check_setting_status.go
View file

@ -1,13 +1,18 @@
package nex_friends_wiiu
import (
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func CheckSettingStatus(err error, client *nex.Client, callID uint32) {
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
func CheckSettingStatus(err error, client *nex.Client, callID uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteUInt8(0xFF)
@ -30,5 +35,7 @@ func CheckSettingStatus(err error, client *nex.Client, callID uint32) {
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

28
nex/friends-wiiu/delete_friend_request.go
View file

@ -1,14 +1,28 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func DeleteFriendRequest(err error, client *nex.Client, callID uint32, id uint64) {
database_wiiu.SetFriendRequestDenied(id)
func DeleteFriendRequest(err error, client *nex.Client, callID uint32, id uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_wiiu.SetFriendRequestDenied(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetSuccess(friends_wiiu.MethodDeleteFriendRequest, nil)
@ -26,5 +40,7 @@ func DeleteFriendRequest(err error, client *nex.Client, callID uint32, id uint64
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

16
nex/friends-wiiu/delete_persistent_notification.go
View file

@ -1,12 +1,18 @@
package nex_friends_wiiu
import (
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func DeletePersistentNotification(err error, client *nex.Client, callID uint32, notifications []*friends_wiiu.PersistentNotification) {
func DeletePersistentNotification(err error, client *nex.Client, callID uint32, notifications []*friends_wiiu_types.PersistentNotification) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
// TODO: Do something here
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
@ -25,5 +31,7 @@ func DeletePersistentNotification(err error, client *nex.Client, callID uint32,
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

55
nex/friends-wiiu/deny_friend_request.go
View file

@ -3,31 +3,60 @@ package nex_friends_wiiu
import (
"time"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func DenyFriendRequest(err error, client *nex.Client, callID uint32, id uint64) {
database_wiiu.SetFriendRequestDenied(id)
func DenyFriendRequest(err error, client *nex.Client, callID uint32, id uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
senderPID, _ := database_wiiu.GetPIDsByFriendRequestID(id)
database_wiiu.SetUserBlocked(client.PID(), senderPID, 0, 0)
err = database_wiiu.SetFriendRequestDenied(id)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
info := database_wiiu.GetUserInfoByPID(senderPID)
senderPID, _, err := database_wiiu.GetPIDsByFriendRequestID(id)
if err != nil {
if err == database.ErrFriendRequestNotFound {
return nex.Errors.FPD.InvalidMessageID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
err = database_wiiu.SetUserBlocked(client.PID(), senderPID, 0, 0)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
info, err := utility.GetUserInfoByPID(senderPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
date := nex.NewDateTime(0)
date.FromTimestamp(time.Now())
// Create a new blacklist principal for the client, as unlike AddBlacklist they don't send one to us.
blacklistPrincipal := friends_wiiu.NewBlacklistedPrincipal()
blacklistPrincipal := friends_wiiu_types.NewBlacklistedPrincipal()
blacklistPrincipal.PrincipalBasicInfo = info
blacklistPrincipal.GameKey = friends_wiiu.NewGameKey()
blacklistPrincipal.GameKey = friends_wiiu_types.NewGameKey()
blacklistPrincipal.BlackListedSince = date
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(blacklistPrincipal)
@ -50,5 +79,7 @@ func DenyFriendRequest(err error, client *nex.Client, callID uint32, id uint64)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

31
nex/friends-wiiu/get_basic_info.go
View file

@ -1,25 +1,36 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/utility"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func GetBasicInfo(err error, client *nex.Client, callID uint32, pids []uint32) {
infos := make([]*friends_wiiu.PrincipalBasicInfo, 0)
func GetBasicInfo(err error, client *nex.Client, callID uint32, pids []uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
infos := make([]*friends_wiiu_types.PrincipalBasicInfo, 0)
for i := 0; i < len(pids); i++ {
pid := pids[i]
info := database_wiiu.GetUserInfoByPID(pid)
if info != nil {
info, err := utility.GetUserInfoByPID(pid)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
if info.PID != 0 {
infos = append(infos, info)
}
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(infos)
@ -42,5 +53,7 @@ func GetBasicInfo(err error, client *nex.Client, callID uint32, pids []uint32) {
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

32
nex/friends-wiiu/get_request_block_settings.go
View file

@ -1,28 +1,40 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func GetRequestBlockSettings(err error, client *nex.Client, callID uint32, pids []uint32) {
settings := make([]*friends_wiiu.PrincipalRequestBlockSetting, 0)
func GetRequestBlockSettings(err error, client *nex.Client, callID uint32, pids []uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
settings := make([]*friends_wiiu_types.PrincipalRequestBlockSetting, 0)
// TODO:
// Improve this. Use less database_wiiu.reads
for i := 0; i < len(pids); i++ {
requestedPID := pids[i]
setting := friends_wiiu.NewPrincipalRequestBlockSetting()
setting := friends_wiiu_types.NewPrincipalRequestBlockSetting()
setting.PID = requestedPID
setting.IsBlocked = database_wiiu.IsFriendRequestBlocked(client.PID(), requestedPID)
isBlocked, err := database_wiiu.IsFriendRequestBlocked(client.PID(), requestedPID)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.Core.Unknown
}
setting.IsBlocked = isBlocked
settings = append(settings, setting)
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteListStructure(settings)
@ -45,5 +57,7 @@ func GetRequestBlockSettings(err error, client *nex.Client, callID uint32, pids
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

23
nex/friends-wiiu/mark_friend_requests_as_received.go
View file

@ -1,16 +1,25 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func MarkFriendRequestsAsReceived(err error, client *nex.Client, callID uint32, ids []uint64) {
func MarkFriendRequestsAsReceived(err error, client *nex.Client, callID uint32, ids []uint64) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
for i := 0; i < len(ids); i++ {
id := ids[i]
database_wiiu.SetFriendRequestReceived(id)
err = database_wiiu.SetFriendRequestReceived(id)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
@ -29,5 +38,7 @@ func MarkFriendRequestsAsReceived(err error, client *nex.Client, callID uint32,
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

28
nex/friends-wiiu/remove_blacklist.go
View file

@ -1,14 +1,28 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func RemoveBlacklist(err error, client *nex.Client, callID uint32, blockedPID uint32) {
database_wiiu.UnsetUserBlocked(client.PID(), blockedPID)
func RemoveBlacklist(err error, client *nex.Client, callID uint32, blockedPID uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_wiiu.UnsetUserBlocked(client.PID(), blockedPID)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.NotInMyBlacklist
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetSuccess(friends_wiiu.MethodRemoveBlackList, nil)
@ -26,5 +40,7 @@ func RemoveBlacklist(err error, client *nex.Client, callID uint32, blockedPID ui
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

32
nex/friends-wiiu/remove_friend.go
View file

@ -1,21 +1,35 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func RemoveFriend(err error, client *nex.Client, callID uint32, pid uint32) {
func RemoveFriend(err error, client *nex.Client, callID uint32, pid uint32) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_wiiu.RemoveFriendship(client.PID(), pid)
if err != nil {
if err == database.ErrFriendshipNotFound {
return nex.Errors.FPD.NotInMyFriendList
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
connectedUser := globals.ConnectedUsers[pid]
if connectedUser != nil {
go notifications_wiiu.SendFriendshipRemoved(connectedUser.Client, pid)
}
database_wiiu.RemoveFriendship(client.PID(), pid)
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetSuccess(friends_wiiu.MethodRemoveFriend, nil)
@ -32,5 +46,7 @@ func RemoveFriend(err error, client *nex.Client, callID uint32, pid uint32) {
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

107
nex/friends-wiiu/update_and_get_all_information.go
View file

@ -3,28 +3,22 @@ package nex_friends_wiiu
import (
"os"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends-secure/types"
"github.com/PretendoNetwork/friends/database"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nnaInfo *friends_wiiu.NNAInfo, presence *friends_wiiu.NintendoPresenceV2, birthday *nex.DateTime) {
func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nnaInfo *friends_wiiu_types.NNAInfo, presence *friends_wiiu_types.NintendoPresenceV2, birthday *nex.DateTime) uint32 {
if err != nil {
// TODO: Handle error
globals.Logger.Critical(err.Error())
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
// Update user information
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)
// Get user information
pid := client.PID()
@ -41,37 +35,82 @@ func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nn
globals.ConnectedUsers[pid].NNAInfo = nnaInfo
globals.ConnectedUsers[pid].PresenceV2 = presence
principalPreference := database_wiiu.GetUserPrincipalPreference(pid)
comment := database_wiiu.GetUserComment(pid)
friendList := database_wiiu.GetUserFriendList(pid)
friendRequestsOut := database_wiiu.GetUserFriendRequestsOut(pid)
friendRequestsIn := database_wiiu.GetUserFriendRequestsIn(pid)
blockList := database_wiiu.GetUserBlockList(pid)
principalPreference, err := database_wiiu.GetUserPrincipalPreference(pid)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID
} else {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
}
comment, err := database_wiiu.GetUserComment(pid)
if err != nil {
if err == database.ErrPIDNotFound {
return nex.Errors.FPD.InvalidPrincipalID
} else {
globals.Logger.Critical(err.Error())
return 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
}
friendRequestsOut, err := database_wiiu.GetUserFriendRequestsOut(pid)
if err != nil && err != database.ErrEmptyList {
globals.Logger.Critical(err.Error())
return 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
}
blockList, err := database_wiiu.GetUserBlockList(pid)
if err != nil && err != database.ErrBlacklistNotFound {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
notifications := database_wiiu.GetUserNotifications(pid)
if os.Getenv("PN_FRIENDS_CONFIG_ENABLE_BELLA") == "true" {
bella := friends_wiiu.NewFriendInfo()
// Update user information
bella.NNAInfo = friends_wiiu.NewNNAInfo()
bella.Presence = friends_wiiu.NewNintendoPresenceV2()
bella.Status = friends_wiiu.NewComment()
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??
notifications_wiiu.SendPresenceUpdate(presence)
if os.Getenv("PN_FRIENDS_CONFIG_ENABLE_BELLA") == "true" {
bella := friends_wiiu_types.NewFriendInfo()
bella.NNAInfo = friends_wiiu_types.NewNNAInfo()
bella.Presence = friends_wiiu_types.NewNintendoPresenceV2()
bella.Status = friends_wiiu_types.NewComment()
bella.BecameFriend = nex.NewDateTime(0)
bella.LastOnline = nex.NewDateTime(0)
bella.Unknown = 0
bella.NNAInfo.PrincipalBasicInfo = friends_wiiu.NewPrincipalBasicInfo()
bella.NNAInfo.PrincipalBasicInfo = friends_wiiu_types.NewPrincipalBasicInfo()
bella.NNAInfo.Unknown1 = 0
bella.NNAInfo.Unknown2 = 0
bella.NNAInfo.PrincipalBasicInfo.PID = 1743126339
bella.NNAInfo.PrincipalBasicInfo.NNID = "bells1998"
bella.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu.NewMiiV2()
bella.NNAInfo.PrincipalBasicInfo.Mii = friends_wiiu_types.NewMiiV2()
bella.NNAInfo.PrincipalBasicInfo.Unknown = 0
bella.NNAInfo.PrincipalBasicInfo.Mii.Name = "bella"
bella.NNAInfo.PrincipalBasicInfo.Mii.Unknown1 = 0
bella.NNAInfo.PrincipalBasicInfo.Mii.Unknown2 = 0
bella.NNAInfo.PrincipalBasicInfo.Mii.Data = []byte{
bella.NNAInfo.PrincipalBasicInfo.Mii.MiiData = []byte{
0x03, 0x00, 0x00, 0x40, 0xE9, 0x55, 0xA2, 0x09,
0xE7, 0xC7, 0x41, 0x82, 0xD9, 0x7D, 0x0B, 0x2D,
0x03, 0xB3, 0xB8, 0x8D, 0x27, 0xD9, 0x00, 0x00,
@ -89,7 +128,7 @@ func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nn
bella.Presence.ChangedFlags = 0x1EE
bella.Presence.Online = true
bella.Presence.GameKey = friends_wiiu.NewGameKey()
bella.Presence.GameKey = friends_wiiu_types.NewGameKey()
bella.Presence.Unknown1 = 0
bella.Presence.Message = "Testing"
//bella.Presence.Unknown2 = 2
@ -121,7 +160,7 @@ func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nn
friendList = append(friendList, bella)
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteStructure(principalPreference)
rmcResponseStream.WriteStructure(comment)
@ -154,5 +193,7 @@ func UpdateAndGetAllInformation(err error, client *nex.Client, callID uint32, nn
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

26
nex/friends-wiiu/update_comment.go
View file

@ -1,18 +1,26 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdateComment(err error, client *nex.Client, callID uint32, comment *friends_wiiu.Comment) {
// TODO: Do something with this
func UpdateComment(err error, client *nex.Client, callID uint32, comment *friends_wiiu_types.Comment) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
changed := database_wiiu.UpdateUserComment(client.PID(), comment.Contents)
changed, err := database_wiiu.UpdateUserComment(client.PID(), comment.Contents)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
rmcResponseStream.WriteUInt64LE(changed)
@ -34,5 +42,7 @@ func UpdateComment(err error, client *nex.Client, callID uint32, comment *friend
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

24
nex/friends-wiiu/update_preference.go
View file

@ -1,14 +1,24 @@
package nex_friends_wiiu
import (
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdatePreference(err error, client *nex.Client, callID uint32, principalPreference *friends_wiiu.PrincipalPreference) {
database_wiiu.UpdateUserPrincipalPreference(client.PID(), principalPreference)
func UpdatePreference(err error, client *nex.Client, callID uint32, principalPreference *friends_wiiu_types.PrincipalPreference) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
err = database_wiiu.UpdateUserPrincipalPreference(client.PID(), principalPreference)
if err != nil {
globals.Logger.Critical(err.Error())
return nex.Errors.FPD.Unknown
}
rmcResponse := nex.NewRMCResponse(friends_wiiu.ProtocolID, callID)
rmcResponse.SetSuccess(friends_wiiu.MethodUpdatePreference, nil)
@ -26,5 +36,7 @@ func UpdatePreference(err error, client *nex.Client, callID uint32, principalPre
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

20
nex/friends-wiiu/update_presence.go
View file

@ -1,14 +1,20 @@
package nex_friends_wiiu
import (
"github.com/PretendoNetwork/friends-secure/globals"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends-secure/types"
"github.com/PretendoNetwork/friends/globals"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
friends_wiiu_types "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu/types"
)
func UpdatePresence(err error, client *nex.Client, callID uint32, presence *friends_wiiu.NintendoPresenceV2) {
func UpdatePresence(err error, client *nex.Client, callID uint32, presence *friends_wiiu_types.NintendoPresenceV2) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.FPD.InvalidArgument
}
pid := client.PID()
presence.Online = true // Force online status. I have no idea why this is always false
@ -45,5 +51,7 @@ func UpdatePresence(err error, client *nex.Client, callID uint32, presence *frie
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

32
nex/register_common_authentication_server_protocols.go Normal file
View file

@ -0,0 +1,32 @@
package nex
import (
"os"
"strconv"
"github.com/PretendoNetwork/friends/globals"
nex "github.com/PretendoNetwork/nex-go"
ticket_granting "github.com/PretendoNetwork/nex-protocols-common-go/ticket-granting"
)
func registerCommonAuthenticationServerProtocols() {
ticketGrantingProtocol := ticket_granting.NewCommonTicketGrantingProtocol(globals.AuthenticationServer)
port, _ := strconv.Atoi(os.Getenv("PN_FRIENDS_SECURE_SERVER_PORT"))
secureStationURL := nex.NewStationURL("")
secureStationURL.SetScheme("prudps")
secureStationURL.SetAddress(os.Getenv("PN_FRIENDS_SECURE_SERVER_HOST"))
secureStationURL.SetPort(uint32(port))
secureStationURL.SetCID(1)
secureStationURL.SetPID(2)
secureStationURL.SetSID(1)
secureStationURL.SetStream(10)
secureStationURL.SetType(2)
ticketGrantingProtocol.SetSecureStationURL(secureStationURL)
ticketGrantingProtocol.SetBuildName(serverBuildString)
ticketGrantingProtocol.EnableInsecureLogin()
globals.AuthenticationServer.SetPasswordFromPIDFunction(globals.PasswordFromPID)
}

12
nex/register_common_secure_server_protocols.go Normal file
View file

@ -0,0 +1,12 @@
package nex
import (
"github.com/PretendoNetwork/friends/globals"
nex_secure_connection "github.com/PretendoNetwork/friends/nex/secure-connection"
secureconnection "github.com/PretendoNetwork/nex-protocols-common-go/secure-connection"
)
func registerCommonSecureServerProtocols() {
secureConnectionProtocol := secureconnection.NewCommonSecureConnectionProtocol(globals.SecureServer)
secureConnectionProtocol.RegisterEx(nex_secure_connection.RegisterEx)
}

27
nex/register_nex_protocols.go → nex/register_secure_server_protocols.go
View file

@ -1,30 +1,23 @@
package nex
import (
"github.com/PretendoNetwork/friends-secure/globals"
nex_account_management "github.com/PretendoNetwork/friends-secure/nex/account-management"
nex_friends_3ds "github.com/PretendoNetwork/friends-secure/nex/friends-3ds"
nex_friends_wiiu "github.com/PretendoNetwork/friends-secure/nex/friends-wiiu"
nex_secure_connection "github.com/PretendoNetwork/friends-secure/nex/secure-connection"
"github.com/PretendoNetwork/friends/globals"
nex_account_management "github.com/PretendoNetwork/friends/nex/account-management"
nex_friends_3ds "github.com/PretendoNetwork/friends/nex/friends-3ds"
nex_friends_wiiu "github.com/PretendoNetwork/friends/nex/friends-wiiu"
account_management "github.com/PretendoNetwork/nex-protocols-go/account-management"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends/3ds"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends/wiiu"
secure_connection "github.com/PretendoNetwork/nex-protocols-go/secure-connection"
friends_3ds "github.com/PretendoNetwork/nex-protocols-go/friends-3ds"
friends_wiiu "github.com/PretendoNetwork/nex-protocols-go/friends-wiiu"
)
func registerNEXProtocols() {
secureConnectionProtocol := secure_connection.NewSecureConnectionProtocol(globals.NEXServer)
accountManagementProtocol := account_management.NewAccountManagementProtocol(globals.NEXServer)
friendsWiiUProtocol := friends_wiiu.NewFriendsWiiUProtocol(globals.NEXServer)
friends3DSProtocol := friends_3ds.NewFriends3DSProtocol(globals.NEXServer)
func registerSecureServerProtocols() {
accountManagementProtocol := account_management.NewProtocol(globals.SecureServer)
friendsWiiUProtocol := friends_wiiu.NewProtocol(globals.SecureServer)
friends3DSProtocol := friends_3ds.NewProtocol(globals.SecureServer)
// Account Management protocol handles
accountManagementProtocol.NintendoCreateAccount(nex_account_management.NintendoCreateAccount)
// Secure protocol handles
secureConnectionProtocol.Register(nex_secure_connection.Register)
secureConnectionProtocol.RegisterEx(nex_secure_connection.RegisterEx)
// Friends (WiiU) protocol handles
friendsWiiUProtocol.UpdateAndGetAllInformation(nex_friends_wiiu.UpdateAndGetAllInformation)
friendsWiiUProtocol.AddFriendRequest(nex_friends_wiiu.AddFriendRequest)

48
nex/secure-connection/register.go
View file

@ -1,48 +0,0 @@
package nex_secure_connection
import (
"strconv"
"github.com/PretendoNetwork/friends-secure/globals"
nex "github.com/PretendoNetwork/nex-go"
secure_connection "github.com/PretendoNetwork/nex-protocols-go/secure-connection"
)
func Register(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL) {
localStation := stationUrls[0]
address := client.Address().IP.String()
port := strconv.Itoa(client.Address().Port)
localStation.SetAddress(address)
localStation.SetPort(port)
localStationURL := localStation.EncodeToString()
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream.WriteUInt32LE(0x10001) // Success
rmcResponseStream.WriteUInt32LE(globals.NEXServer.ConnectionIDCounter().Increment())
rmcResponseStream.WriteString(localStationURL)
rmcResponseBody := rmcResponseStream.Bytes()
// Build response packet
rmcResponse := nex.NewRMCResponse(secure_connection.ProtocolID, callID)
rmcResponse.SetSuccess(secure_connection.MethodRegister, rmcResponseBody)
rmcResponseBytes := rmcResponse.Bytes()
responsePacket, _ := nex.NewPacketV0(client, nil)
responsePacket.SetVersion(0)
responsePacket.SetSource(0xA1)
responsePacket.SetDestination(0xAF)
responsePacket.SetType(nex.DataPacket)
responsePacket.SetPayload(rmcResponseBytes)
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
}

70
nex/secure-connection/register_ex.go
View file

@ -1,50 +1,72 @@
package nex_secure_connection
import (
"strconv"
"time"
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
"github.com/PretendoNetwork/friends-secure/types"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
secure_connection "github.com/PretendoNetwork/nex-protocols-go/secure-connection"
)
func RegisterEx(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL, loginData *nex.DataHolder) {
// TODO: Validate loginData
func RegisterEx(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL, loginData *nex.DataHolder) uint32 {
if err != nil {
globals.Logger.Error(err.Error())
return nex.Errors.Core.InvalidArgument
}
retval := nex.NewResultSuccess(nex.Errors.Core.Unknown)
rmcResponseStream := nex.NewStreamOut(globals.SecureServer)
// TODO: Validate loginData
pid := client.PID()
user := globals.ConnectedUsers[pid]
lastOnline := nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
if loginData.TypeName() == "NintendoLoginData" {
loginDataType := loginData.TypeName()
switch loginDataType {
case "NintendoLoginData":
user.Platform = types.WUP // Platform is Wii U
database_wiiu.UpdateUserLastOnlineTime(pid, lastOnline)
} else if loginData.TypeName() == "AccountExtraInfo" {
err = database_wiiu.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
globals.Logger.Critical(err.Error())
retval = nex.NewResultError(nex.Errors.Authentication.Unknown)
}
case "AccountExtraInfo":
user.Platform = types.CTR // Platform is 3DS
database_3ds.UpdateUserLastOnlineTime(pid, lastOnline)
err = database_3ds.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
globals.Logger.Critical(err.Error())
retval = nex.NewResultError(nex.Errors.Authentication.Unknown)
}
default:
globals.Logger.Errorf("Unknown loginData data type %s!", loginDataType)
retval = nex.NewResultError(nex.Errors.Authentication.ValidationFailed)
}
localStation := stationUrls[0]
if retval.IsSuccess() {
localStation := stationUrls[0]
address := client.Address().IP.String()
port := strconv.Itoa(client.Address().Port)
address := client.Address().IP.String()
localStation.SetAddress(address)
localStation.SetPort(port)
localStation.SetAddress(address)
localStation.SetPort(uint32(client.Address().Port))
localStationURL := localStation.EncodeToString()
localStationURL := localStation.EncodeToString()
rmcResponseStream := nex.NewStreamOut(globals.NEXServer)
rmcResponseStream.WriteUInt32LE(0x10001) // Success
rmcResponseStream.WriteUInt32LE(globals.NEXServer.ConnectionIDCounter().Increment())
rmcResponseStream.WriteString(localStationURL)
rmcResponseStream.WriteResult(retval)
rmcResponseStream.WriteUInt32LE(globals.SecureServer.ConnectionIDCounter().Increment())
rmcResponseStream.WriteString(localStationURL)
} else {
rmcResponseStream.WriteResult(retval)
rmcResponseStream.WriteUInt32LE(0)
rmcResponseStream.WriteString("prudp:/")
}
rmcResponseBody := rmcResponseStream.Bytes()
@ -65,5 +87,7 @@ func RegisterEx(err error, client *nex.Client, callID uint32, stationUrls []*nex
responsePacket.AddFlag(nex.FlagNeedsAck)
responsePacket.AddFlag(nex.FlagReliable)
globals.NEXServer.Send(responsePacket)
globals.SecureServer.Send(responsePacket)
return 0
}

82
nex/secure.go Normal file
View file

@ -0,0 +1,82 @@
package nex
import (
"fmt"
"os"
"time"
database_3ds "github.com/PretendoNetwork/friends/database/3ds"
database_wiiu "github.com/PretendoNetwork/friends/database/wiiu"
"github.com/PretendoNetwork/friends/globals"
notifications_3ds "github.com/PretendoNetwork/friends/notifications/3ds"
notifications_wiiu "github.com/PretendoNetwork/friends/notifications/wiiu"
"github.com/PretendoNetwork/friends/types"
nex "github.com/PretendoNetwork/nex-go"
_ "github.com/PretendoNetwork/nex-protocols-go"
)
func StartSecureServer() {
globals.SecureServer = nex.NewServer()
globals.SecureServer.SetFragmentSize(900)
globals.SecureServer.SetPRUDPVersion(0)
globals.SecureServer.SetKerberosKeySize(16)
globals.SecureServer.SetKerberosPassword(globals.KerberosPassword)
globals.SecureServer.SetPingTimeout(20) // Maybe too long?
globals.SecureServer.SetAccessKey("ridfebb9")
globals.SecureServer.SetDefaultNEXVersion(&nex.NEXVersion{
Major: 1,
Minor: 1,
Patch: 0,
})
globals.SecureServer.On("Data", func(packet *nex.PacketV0) {
request := packet.RMCRequest()
fmt.Println("==Friends - Secure==")
fmt.Printf("Protocol ID: %#v\n", request.ProtocolID())
fmt.Printf("Method ID: %#v\n", request.MethodID())
fmt.Println("====================")
})
globals.SecureServer.On("Kick", func(packet *nex.PacketV0) {
pid := packet.Sender().PID()
if globals.ConnectedUsers[pid] == nil {
return
}
platform := globals.ConnectedUsers[pid].Platform
lastOnline := nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
if platform == types.WUP {
err := database_wiiu.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
globals.Logger.Critical(err.Error())
}
notifications_wiiu.SendUserWentOfflineGlobally(packet.Sender())
} else if platform == types.CTR {
err := database_3ds.UpdateUserLastOnlineTime(pid, lastOnline)
if err != nil {
globals.Logger.Critical(err.Error())
}
notifications_3ds.SendUserWentOfflineGlobally(packet.Sender())
}
delete(globals.ConnectedUsers, pid)
fmt.Println("Leaving (Kick)")
})
globals.SecureServer.On("Disconnect", func(packet *nex.PacketV0) {
fmt.Println("Leaving (Disconnect)")
})
globals.SecureServer.On("Connect", connect)
registerCommonSecureServerProtocols()
registerSecureServerProtocols()
globals.SecureServer.Listen(fmt.Sprintf(":%s", os.Getenv("PN_FRIENDS_SECURE_SERVER_PORT")))
}

68
nex/server.go
View file

@ -1,68 +0,0 @@
package nex
import (
"fmt"
"os"
"time"
database_3ds "github.com/PretendoNetwork/friends-secure/database/3ds"
database_wiiu "github.com/PretendoNetwork/friends-secure/database/wiiu"
"github.com/PretendoNetwork/friends-secure/globals"
notifications_3ds "github.com/PretendoNetwork/friends-secure/notifications/3ds"
notifications_wiiu "github.com/PretendoNetwork/friends-secure/notifications/wiiu"
"github.com/PretendoNetwork/friends-secure/types"
nex "github.com/PretendoNetwork/nex-go"
_ "github.com/PretendoNetwork/nex-protocols-go"
)
func StartNEXServer() {
globals.NEXServer = nex.NewServer()
globals.NEXServer.SetFragmentSize(900)
globals.NEXServer.SetPRUDPVersion(0)
globals.NEXServer.SetKerberosKeySize(16)
globals.NEXServer.SetKerberosPassword(os.Getenv("PN_FRIENDS_CONFIG_KERBEROS_PASSWORD"))
globals.NEXServer.SetPingTimeout(20) // Maybe too long?
globals.NEXServer.SetAccessKey("ridfebb9")
globals.NEXServer.On("Data", func(packet *nex.PacketV0) {
request := packet.RMCRequest()
fmt.Println("==Friends - Secure==")
fmt.Printf("Protocol ID: %#v\n", request.ProtocolID())
fmt.Printf("Method ID: %#v\n", request.MethodID())
fmt.Println("====================")
})
globals.NEXServer.On("Kick", func(packet *nex.PacketV0) {
pid := packet.Sender().PID()
if globals.ConnectedUsers[pid] == nil {
return
}
platform := globals.ConnectedUsers[pid].Platform
lastOnline := nex.NewDateTime(0)
lastOnline.FromTimestamp(time.Now())
if platform == types.WUP {
database_wiiu.UpdateUserLastOnlineTime(pid, lastOnline)
notifications_wiiu.SendUserWentOfflineGlobally(packet.Sender())
} else if platform == types.CTR {
database_3ds.UpdateUserLastOnlineTime(pid, lastOnline)
notifications_3ds.SendUserWentOfflineGlobally(packet.Sender())
}
delete(globals.ConnectedUsers, pid)
fmt.Println("Leaving (Kick)")
})
globals.NEXServer.On("Disconnect", func(packet *nex.PacketV0) {
fmt.Println("Leaving (Disconnect)")
})
globals.NEXServer.On("Connect", connect)
registerNEXProtocols()
globals.NEXServer.Listen(":60001")
}

Some files were not shown because too many files have changed in this diff Show more