Refactor types

account.go

@@ -10,15 +10,15 @@ import "github.com/PretendoNetwork/nex-go/v2/types"
 // guest account, an account which represents the authentication server, and one which represents
 // the secure server. See https://nintendo-wiki.pretendo.network/docs/nex/kerberos for more information.
 type Account struct {
-	PID      *types.PID // * The PID of the account. PIDs are unique IDs per account. NEX PIDs start at 1800000000 and decrement with each new account.
-	Username string     // * The username for the account. For NEX user accounts this is the same as the accounts PID.
-	Password string     // * The password for the account. For NEX accounts this is always 16 characters long using seemingly any ASCII character
+	PID      types.PID // * The PID of the account. PIDs are unique IDs per account. NEX PIDs start at 1800000000 and decrement with each new account.
+	Username string    // * The username for the account. For NEX user accounts this is the same as the accounts PID.
+	Password string    // * The password for the account. For NEX accounts this is always 16 characters long using seemingly any ASCII character
 }
 
 // NewAccount returns a new instance of Account.
 // This does not register an account, only creates a new
 // struct instance.
-func NewAccount(pid *types.PID, username, password string) *Account {
+func NewAccount(pid types.PID, username, password string) *Account {
 	return &Account{
 		PID:      pid,
 		Username: username,

byte_stream_in.go

@@ -68,98 +68,98 @@ func (bsi *ByteStreamIn) Read(length uint64) ([]byte, error) {
 	return bsi.ReadBytesNext(int64(length)), nil
 }
 
-// ReadPrimitiveUInt8 reads a uint8
-func (bsi *ByteStreamIn) ReadPrimitiveUInt8() (uint8, error) {
+// ReadUInt8 reads a uint8
+func (bsi *ByteStreamIn) ReadUInt8() (uint8, error) {
 	if bsi.Remaining() < 1 {
 		return 0, errors.New("Not enough data to read uint8")
 	}
 
 	return uint8(bsi.ReadByteNext()), nil
 }
 
-// ReadPrimitiveUInt16LE reads a Little-Endian encoded uint16
-func (bsi *ByteStreamIn) ReadPrimitiveUInt16LE() (uint16, error) {
+// ReadUInt16LE reads a Little-Endian encoded uint16
+func (bsi *ByteStreamIn) ReadUInt16LE() (uint16, error) {
 	if bsi.Remaining() < 2 {
 		return 0, errors.New("Not enough data to read uint16")
 	}
 
 	return bsi.ReadU16LENext(1)[0], nil
 }
 
-// ReadPrimitiveUInt32LE reads a Little-Endian encoded uint32
-func (bsi *ByteStreamIn) ReadPrimitiveUInt32LE() (uint32, error) {
+// ReadUInt32LE reads a Little-Endian encoded uint32
+func (bsi *ByteStreamIn) ReadUInt32LE() (uint32, error) {
 	if bsi.Remaining() < 4 {
 		return 0, errors.New("Not enough data to read uint32")
 	}
 
 	return bsi.ReadU32LENext(1)[0], nil
 }
 
-// ReadPrimitiveUInt64LE reads a Little-Endian encoded uint64
-func (bsi *ByteStreamIn) ReadPrimitiveUInt64LE() (uint64, error) {
+// ReadUInt64LE reads a Little-Endian encoded uint64
+func (bsi *ByteStreamIn) ReadUInt64LE() (uint64, error) {
 	if bsi.Remaining() < 8 {
 		return 0, errors.New("Not enough data to read uint64")
 	}
 
 	return bsi.ReadU64LENext(1)[0], nil
 }
 
-// ReadPrimitiveInt8 reads a uint8
-func (bsi *ByteStreamIn) ReadPrimitiveInt8() (int8, error) {
+// ReadInt8 reads a uint8
+func (bsi *ByteStreamIn) ReadInt8() (int8, error) {
 	if bsi.Remaining() < 1 {
 		return 0, errors.New("Not enough data to read int8")
 	}
 
 	return int8(bsi.ReadByteNext()), nil
 }
 
-// ReadPrimitiveInt16LE reads a Little-Endian encoded int16
-func (bsi *ByteStreamIn) ReadPrimitiveInt16LE() (int16, error) {
+// ReadInt16LE reads a Little-Endian encoded int16
+func (bsi *ByteStreamIn) ReadInt16LE() (int16, error) {
 	if bsi.Remaining() < 2 {
 		return 0, errors.New("Not enough data to read int16")
 	}
 
 	return int16(bsi.ReadU16LENext(1)[0]), nil
 }
 
-// ReadPrimitiveInt32LE reads a Little-Endian encoded int32
-func (bsi *ByteStreamIn) ReadPrimitiveInt32LE() (int32, error) {
+// ReadInt32LE reads a Little-Endian encoded int32
+func (bsi *ByteStreamIn) ReadInt32LE() (int32, error) {
 	if bsi.Remaining() < 4 {
 		return 0, errors.New("Not enough data to read int32")
 	}
 
 	return int32(bsi.ReadU32LENext(1)[0]), nil
 }
 
-// ReadPrimitiveInt64LE reads a Little-Endian encoded int64
-func (bsi *ByteStreamIn) ReadPrimitiveInt64LE() (int64, error) {
+// ReadInt64LE reads a Little-Endian encoded int64
+func (bsi *ByteStreamIn) ReadInt64LE() (int64, error) {
 	if bsi.Remaining() < 8 {
 		return 0, errors.New("Not enough data to read int64")
 	}
 
 	return int64(bsi.ReadU64LENext(1)[0]), nil
 }
 
-// ReadPrimitiveFloat32LE reads a Little-Endian encoded float32
-func (bsi *ByteStreamIn) ReadPrimitiveFloat32LE() (float32, error) {
+// ReadFloat32LE reads a Little-Endian encoded float32
+func (bsi *ByteStreamIn) ReadFloat32LE() (float32, error) {
 	if bsi.Remaining() < 4 {
 		return 0, errors.New("Not enough data to read float32")
 	}
 
 	return bsi.ReadF32LENext(1)[0], nil
 }
 
-// ReadPrimitiveFloat64LE reads a Little-Endian encoded float64
-func (bsi *ByteStreamIn) ReadPrimitiveFloat64LE() (float64, error) {
+// ReadFloat64LE reads a Little-Endian encoded float64
+func (bsi *ByteStreamIn) ReadFloat64LE() (float64, error) {
 	if bsi.Remaining() < 8 {
 		return 0, errors.New("Not enough data to read float64")
 	}
 
 	return bsi.ReadF64LENext(1)[0], nil
 }
 
-// ReadPrimitiveBool reads a bool
-func (bsi *ByteStreamIn) ReadPrimitiveBool() (bool, error) {
+// ReadBool reads a bool
+func (bsi *ByteStreamIn) ReadBool() (bool, error) {
 	if bsi.Remaining() < 1 {
 		return false, errors.New("Not enough data to read bool")
 	}

byte_stream_out.go

@@ -56,68 +56,68 @@ func (bso *ByteStreamOut) Write(data []byte) {
 	bso.WriteBytesNext(data)
 }
 
-// WritePrimitiveUInt8 writes a uint8
-func (bso *ByteStreamOut) WritePrimitiveUInt8(u8 uint8) {
+// WriteUInt8 writes a uint8
+func (bso *ByteStreamOut) WriteUInt8(u8 uint8) {
 	bso.Grow(1)
 	bso.WriteByteNext(byte(u8))
 }
 
-// WritePrimitiveUInt16LE writes a uint16 as LE
-func (bso *ByteStreamOut) WritePrimitiveUInt16LE(u16 uint16) {
+// WriteUInt16LE writes a uint16 as LE
+func (bso *ByteStreamOut) WriteUInt16LE(u16 uint16) {
 	bso.Grow(2)
 	bso.WriteU16LENext([]uint16{u16})
 }
 
-// WritePrimitiveUInt32LE writes a uint32 as LE
-func (bso *ByteStreamOut) WritePrimitiveUInt32LE(u32 uint32) {
+// WriteUInt32LE writes a uint32 as LE
+func (bso *ByteStreamOut) WriteUInt32LE(u32 uint32) {
 	bso.Grow(4)
 	bso.WriteU32LENext([]uint32{u32})
 }
 
-// WritePrimitiveUInt64LE writes a uint64 as LE
-func (bso *ByteStreamOut) WritePrimitiveUInt64LE(u64 uint64) {
+// WriteUInt64LE writes a uint64 as LE
+func (bso *ByteStreamOut) WriteUInt64LE(u64 uint64) {
 	bso.Grow(8)
 	bso.WriteU64LENext([]uint64{u64})
 }
 
-// WritePrimitiveInt8 writes a int8
-func (bso *ByteStreamOut) WritePrimitiveInt8(s8 int8) {
+// WriteInt8 writes a int8
+func (bso *ByteStreamOut) WriteInt8(s8 int8) {
 	bso.Grow(1)
 	bso.WriteByteNext(byte(s8))
 }
 
-// WritePrimitiveInt16LE writes a uint16 as LE
-func (bso *ByteStreamOut) WritePrimitiveInt16LE(s16 int16) {
+// WriteInt16LE writes a uint16 as LE
+func (bso *ByteStreamOut) WriteInt16LE(s16 int16) {
 	bso.Grow(2)
 	bso.WriteU16LENext([]uint16{uint16(s16)})
 }
 
-// WritePrimitiveInt32LE writes a int32 as LE
-func (bso *ByteStreamOut) WritePrimitiveInt32LE(s32 int32) {
+// WriteInt32LE writes a int32 as LE
+func (bso *ByteStreamOut) WriteInt32LE(s32 int32) {
 	bso.Grow(4)
 	bso.WriteU32LENext([]uint32{uint32(s32)})
 }
 
-// WritePrimitiveInt64LE writes a int64 as LE
-func (bso *ByteStreamOut) WritePrimitiveInt64LE(s64 int64) {
+// WriteInt64LE writes a int64 as LE
+func (bso *ByteStreamOut) WriteInt64LE(s64 int64) {
 	bso.Grow(8)
 	bso.WriteU64LENext([]uint64{uint64(s64)})
 }
 
-// WritePrimitiveFloat32LE writes a float32 as LE
-func (bso *ByteStreamOut) WritePrimitiveFloat32LE(f32 float32) {
+// WriteFloat32LE writes a float32 as LE
+func (bso *ByteStreamOut) WriteFloat32LE(f32 float32) {
 	bso.Grow(4)
 	bso.WriteF32LENext([]float32{f32})
 }
 
-// WritePrimitiveFloat64LE writes a float64 as LE
-func (bso *ByteStreamOut) WritePrimitiveFloat64LE(f64 float64) {
+// WriteFloat64LE writes a float64 as LE
+func (bso *ByteStreamOut) WriteFloat64LE(f64 float64) {
 	bso.Grow(8)
 	bso.WriteF64LENext([]float64{f64})
 }
 
-// WritePrimitiveBool writes a bool
-func (bso *ByteStreamOut) WritePrimitiveBool(b bool) {
+// WriteBool writes a bool
+func (bso *ByteStreamOut) WriteBool(b bool) {
 	var bVar uint8
 	if b {
 		bVar = 1

connection_interface.go

@@ -11,6 +11,6 @@ import (
 type ConnectionInterface interface {
 	Endpoint() EndpointInterface
 	Address() net.Addr
-	PID() *types.PID
-	SetPID(pid *types.PID)
+	PID() types.PID
+	SetPID(pid types.PID)
 }

hpp_client.go

@@ -10,7 +10,7 @@ import (
 type HPPClient struct {
 	address  *net.TCPAddr
 	endpoint *HPPServer
-	pid      *types.PID
+	pid      types.PID
 }
 
 // Endpoint returns the server the client is connecting to
@@ -24,12 +24,12 @@ func (c *HPPClient) Address() net.Addr {
 }
 
 // PID returns the clients NEX PID
-func (c *HPPClient) PID() *types.PID {
+func (c *HPPClient) PID() types.PID {
 	return c.pid
 }
 
 // SetPID sets the clients NEX PID
-func (c *HPPClient) SetPID(pid *types.PID) {
+func (c *HPPClient) SetPID(pid types.PID) {
 	c.pid = pid
 }
 

hpp_server.go

@@ -18,7 +18,7 @@ type HPPServer struct {
 	dataHandlers             []func(packet PacketInterface)
 	errorEventHandlers       []func(err *Error)
 	byteStreamSettings       *ByteStreamSettings
-	AccountDetailsByPID      func(pid *types.PID) (*Account, *Error)
+	AccountDetailsByPID      func(pid types.PID) (*Account, *Error)
 	AccountDetailsByUsername func(username string) (*Account, *Error)
 	useVerboseRMC            bool
 }

init.go

@@ -10,10 +10,10 @@ var logger = plogger.NewLogger()
 func init() {
 	initResultCodes()
 
-	types.RegisterVariantType(1, types.NewPrimitiveS64(0))
-	types.RegisterVariantType(2, types.NewPrimitiveF64(0))
-	types.RegisterVariantType(3, types.NewPrimitiveBool(false))
+	types.RegisterVariantType(1, types.NewInt64(0))
+	types.RegisterVariantType(2, types.NewDouble(0))
+	types.RegisterVariantType(3, types.NewBool(false))
 	types.RegisterVariantType(4, types.NewString(""))
 	types.RegisterVariantType(5, types.NewDateTime(0))
-	types.RegisterVariantType(6, types.NewPrimitiveU64(0))
+	types.RegisterVariantType(6, types.NewUInt64(0))
 }

kerberos.go

@@ -69,8 +69,8 @@ func NewKerberosEncryption(key []byte) *KerberosEncryption {
 // KerberosTicket represents a ticket granting a user access to a secure server
 type KerberosTicket struct {
 	SessionKey   []byte
-	TargetPID    *types.PID
-	InternalData *types.Buffer
+	TargetPID    types.PID
+	InternalData types.Buffer
 }
 
 // Encrypt writes the ticket data to the provided stream and returns the encrypted byte slice
@@ -94,8 +94,8 @@ func NewKerberosTicket() *KerberosTicket {
 // KerberosTicketInternalData holds the internal data for a kerberos ticket to be processed by the server
 type KerberosTicketInternalData struct {
 	Server     *PRUDPServer // TODO - Remove this dependency and make a settings struct
-	Issued     *types.DateTime
-	SourcePID  *types.PID
+	Issued     types.DateTime
+	SourcePID  types.PID
 	SessionKey []byte
 }
 
@@ -152,10 +152,10 @@ func (ti *KerberosTicketInternalData) Decrypt(stream *ByteStreamIn, key []byte)
 			return fmt.Errorf("Failed to read Kerberos ticket internal data. %s", err.Error())
 		}
 
-		hash := md5.Sum(append(key, ticketKey.Value...))
+		hash := md5.Sum(append(key, ticketKey...))
 		key = hash[:]
 
-		stream = NewByteStreamIn(data.Value, stream.LibraryVersions, stream.Settings)
+		stream = NewByteStreamIn(data, stream.LibraryVersions, stream.Settings)
 	}
 
 	encryption := NewKerberosEncryption(key)
@@ -190,17 +190,15 @@ func NewKerberosTicketInternalData(server *PRUDPServer) *KerberosTicketInternalD
 }
 
 // DeriveKerberosKey derives a users kerberos encryption key based on their PID and password
-func DeriveKerberosKey(pid *types.PID, password []byte) []byte {
-	iterationCount := int(65000 + pid.Value()%1024)
-	key := make([]byte, md5.Size)
-	copy(key, password)
-
-	hash := md5.Sum(password)
-	copy(key, hash[:])
-
-	for i := 1; i < iterationCount; i++ {
-		hash = md5.Sum(key)
-		copy(key, hash[:])
+func DeriveKerberosKey(pid types.PID, password []byte) []byte {
+	iterationCount := int(65000 + pid%1024)
+	key := password
+	hash := make([]byte, md5.Size)
+
+	for i := 0; i < iterationCount; i++ {
+		sum := md5.Sum(key)
+		copy(hash, sum[:])
+		key = hash
 	}
 
 	return key

prudp_connection.go

@@ -21,7 +21,7 @@ type PRUDPConnection struct {
 	SessionID                           uint8                                  // * Random value generated at the start of the session. Client and server IDs do not need to match
 	ServerSessionID                     uint8                                  // * Random value generated at the start of the session. Client and server IDs do not need to match
 	SessionKey                          []byte                                 // * Secret key generated at the start of the session. Used for encrypting packets to the secure server
-	pid                                 *types.PID                             // * PID of the user
+	pid                                 types.PID                              // * PID of the user
 	DefaultPRUDPVersion                 int                                    // * The PRUDP version the connection was established with. Used for sending PING packets
 	StreamType                          constants.StreamType                   // * rdv::Stream::Type used in this connection
 	StreamID                            uint8                                  // * rdv::Stream ID, also called the "port number", used in this connection. 0-15 on PRUDPv0/v1, and 0-31 on PRUDPLite
@@ -38,7 +38,7 @@ type PRUDPConnection struct {
 	lastSentPingTime                    time.Time
 	heartbeatTimer                      *time.Timer
 	pingKickTimer                       *time.Timer
-	StationURLs                         *types.List[*types.StationURL]
+	StationURLs                         types.List[types.StationURL]
 	mutex                               *sync.Mutex
 }
 
@@ -53,12 +53,12 @@ func (pc *PRUDPConnection) Address() net.Addr {
 }
 
 // PID returns the clients unique PID
-func (pc *PRUDPConnection) PID() *types.PID {
+func (pc *PRUDPConnection) PID() types.PID {
 	return pc.pid
 }
 
 // SetPID sets the clients unique PID
-func (pc *PRUDPConnection) SetPID(pid *types.PID) {
+func (pc *PRUDPConnection) SetPID(pid types.PID) {
 	pc.pid = pid
 }
 
@@ -299,11 +299,9 @@ func NewPRUDPConnection(socket *SocketConnection) *PRUDPConnection {
 		outgoingUnreliableSequenceIDCounter: NewCounter[uint16](1),
 		outgoingPingSequenceIDCounter:       NewCounter[uint16](0),
 		incomingFragmentBuffers:             NewMutexMap[uint8, []byte](),
-		StationURLs:                         types.NewList[*types.StationURL](),
+		StationURLs:                         types.NewList[types.StationURL](),
 		mutex:                               &sync.Mutex{},
 	}
 
-	pc.StationURLs.Type = types.NewStationURL("")
-
 	return pc
 }