PacketCoding

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def CreateControlPacket(packet: PlanetSideControlPacket): ControlPacket

Access to the ControlPacket constructor.
Access to the ControlPacket constructor.
packet
a PlanetSideControlPacket
returns
a ControlPacket
def CreateCryptoPacket(sequence: Int, packet: PlanetSideCryptoPacket): CryptoPacket

Access to the CryptoPacket constructor.
Access to the CryptoPacket constructor.
sequence
na
packet
a PlanetSideCryptoPacket
returns
a CryptoPacket
def CreateGamePacket(sequence: Int, packet: PlanetSideGamePacket): GamePacket

Access to the GamePacket constructor.
Access to the GamePacket constructor.
sequence
na
packet
a PlanetSideGamePacket
returns
a GamePacket
def DecodeControlPacket(msg: ByteVector): Attempt[PlanetSideControlPacket]

Transform a ByteVector into a ControlPacket.
Transform a ByteVector into a ControlPacket.
msg
the the raw data to decode
returns
a PlanetSideControlPacket
def DecodeGamePacket(msg: ByteVector): Attempt[PlanetSideGamePacket]

Transform a ByteVector into a GamePacket.
Transform a ByteVector into a GamePacket.
msg
the the raw data to decode
returns
a PlanetSideGamePacket
def DecodePacket(msg: ByteVector): Attempt[PlanetSidePacket]

Transforms ByteVector data into a PlanetSide packet.
Transforms ByteVector data into a PlanetSide packet. Similar to the UnmarshalPacket but it does not process packet headers. It supports GamePacket in exchange for not supporting CryptoPacket (like UnMarshalPacket). Mostly used in tests.
msg
raw, unencrypted packet
returns
PlanetSidePacket

See also
UnMarshalPacket
def EncodePacket(packet: PlanetSideGamePacket): Attempt[BitVector]

Overloaded method for transforming a GamePacket into its BitVector representation.
Overloaded method for transforming a GamePacket into its BitVector representation.
packet
the game packet to encode
returns
a BitVector translated from the packet's data
def EncodePacket(packet: PlanetSideCryptoPacket): Attempt[BitVector]

Overloaded method for transforming a CryptoPacket into its BitVector representation.
Overloaded method for transforming a CryptoPacket into its BitVector representation.
packet
the crypto packet to encode
returns
a BitVector translated from the packet's data
def EncodePacket(packet: PlanetSideControlPacket): Attempt[BitVector]

Overloaded method for transforming a ControlPacket into its BitVector representation.
Overloaded method for transforming a ControlPacket into its BitVector representation.
packet
the control packet to encode
returns
a BitVector translated from the packet's data
def MarshalPacket(packet: PlanetSidePacketContainer): Attempt[BitVector]

Transform a kind of packet into the sequence of data that represents it.
Transform a kind of packet into the sequence of data that represents it. Wraps around the encoding process for all valid packet container types.
packet
the packet to encode
returns
a BitVector translated from the packet's data
final val PLANETSIDE_MIN_PACKET_SIZE: Int(1)

A lower bound on the packet size
def UnmarshalPacket(msg: ByteVector): Attempt[PlanetSidePacketContainer]

Helper function to decode a packet without specifying a crypto state.
Helper function to decode a packet without specifying a crypto state. Used when there is no crypto state available such as in tests.
msg
packet data bytes
returns
PlanetSidePacketContainer
def UnmarshalPacket(msg: ByteVector, cryptoState: Type): Attempt[PlanetSidePacketContainer]

Transforms ByteVector data into a PlanetSide packet.
Transforms ByteVector data into a PlanetSide packet. Attempt to decode with an optional header and required payload. Does not decode into a GamePacket.
msg
the raw packet
cryptoState
the current state of the connection's crypto. This is only used when decoding crypto packets as they do not have opcodes
returns
PlanetSidePacketContainer
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def decryptPacket(crypto: CryptoStateWithMAC, packet: EncryptedPacket): Attempt[PlanetSidePacketContainer]

Perform decryption on an EncryptedPacket.
Perform decryption on an EncryptedPacket.
crypto
the current state of the connection's crypto
packet
an encrypted packet
returns
a general packet container type
def decryptPacketData(crypto: CryptoStateWithMAC, packet: EncryptedPacket): Attempt[ByteVector]

Compose the decrypted payload data from a formerly encrypted packet.
Compose the decrypted payload data from a formerly encrypted packet.
crypto
the current state of the connection's crypto
packet
an encrypted packet
returns
a sequence of decrypted data
def encryptPacket(crypto: CryptoStateWithMAC, sequenceNumber: Int, rawPacket: ByteVector): Attempt[EncryptedPacket]

Perform encryption on the packet's raw data.
Perform encryption on the packet's raw data.
crypto
the current cryptographic state
sequenceNumber
na
rawPacket
a ByteVector that represents the packet data
returns
an EncryptedPacket
def encryptPacket(crypto: CryptoStateWithMAC, packet: PlanetSidePacketContainer): Attempt[EncryptedPacket]

Encrypt the provided packet using the provided cryptographic state.
Encrypt the provided packet using the provided cryptographic state. Translate the packet into data to send on to the actual encryption process.
crypto
the current cryptographic state
packet
the unencrypted packet
returns
an EncryptedPacket
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getPacketDataForEncryption(packet: PlanetSidePacketContainer): Attempt[(Int, ByteVector)]

Transform the privileged packet into a RawPacket representation to get: the sequence number, and the raw ByteVector data.
Transform the privileged packet into a RawPacket representation to get: the sequence number, and the raw ByteVector data.
packet
the unencrypted packet
returns
paired data based on the packet
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def makeRawPacket(packet: PlanetSidePacketContainer): Attempt[BitVector]

Transform either a GamePacket or a ControlPacket into a BitVector.
Transform either a GamePacket or a ControlPacket into a BitVector. This is not as thorough as the process of unmarshalling though the results are very similar.
packet
a packet
returns
a BitVector that represents the packet
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unmarshalPayload(sequenceNumber: Int, payload: ByteVector): Attempt[PlanetSidePacketContainer]

Transform decrypted packet data into the type of packet that it represents.
Transform decrypted packet data into the type of packet that it represents. Will not compose data into an EncryptedPacket or into a CryptoPacket.
sequenceNumber
na
payload
the decrypted packet data
returns
a general packet container type
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package packet

object PacketCoding

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def CreateControlPacket(packet: PlanetSideControlPacket): ControlPacket

def CreateCryptoPacket(sequence: Int, packet: PlanetSideCryptoPacket): CryptoPacket

def CreateGamePacket(sequence: Int, packet: PlanetSideGamePacket): GamePacket

def DecodeControlPacket(msg: ByteVector): Attempt[PlanetSideControlPacket]

def DecodeGamePacket(msg: ByteVector): Attempt[PlanetSideGamePacket]

def DecodePacket(msg: ByteVector): Attempt[PlanetSidePacket]

def EncodePacket(packet: PlanetSideGamePacket): Attempt[BitVector]

def EncodePacket(packet: PlanetSideCryptoPacket): Attempt[BitVector]

def EncodePacket(packet: PlanetSideControlPacket): Attempt[BitVector]

def MarshalPacket(packet: PlanetSidePacketContainer): Attempt[BitVector]

final val PLANETSIDE_MIN_PACKET_SIZE: Int(1)

def UnmarshalPacket(msg: ByteVector): Attempt[PlanetSidePacketContainer]

def UnmarshalPacket(msg: ByteVector, cryptoState: Type): Attempt[PlanetSidePacketContainer]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def decryptPacket(crypto: CryptoStateWithMAC, packet: EncryptedPacket): Attempt[PlanetSidePacketContainer]

def decryptPacketData(crypto: CryptoStateWithMAC, packet: EncryptedPacket): Attempt[ByteVector]

def encryptPacket(crypto: CryptoStateWithMAC, sequenceNumber: Int, rawPacket: ByteVector): Attempt[EncryptedPacket]

def encryptPacket(crypto: CryptoStateWithMAC, packet: PlanetSidePacketContainer): Attempt[EncryptedPacket]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getPacketDataForEncryption(packet: PlanetSidePacketContainer): Attempt[(Int, ByteVector)]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def makeRawPacket(packet: PlanetSidePacketContainer): Attempt[BitVector]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def unmarshalPayload(sequenceNumber: Int, payload: ByteVector): Attempt[PlanetSidePacketContainer]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped