Struct lu_packets::general::client::Handshake

pub struct Handshake {
    pub network_version: u32,
    pub service_id: ServiceId,
}

Completes a version handshake initiated by the client.

Trigger

Receipt of a client-sent Handshake packet that was acceptable to the server.

Handling

Optionally check if the server’s network_version matches your own. You can usually assume that the server will check this itself and disconnect if it doesn’t match, but you can check again to be sure.

Response

If the server’s service_id is ServiceId::Auth, respond with a LoginRequest with your username and password. If it is ServiceId::World, send a ClientValidation with your username and the session key provided by auth.

Notes

As the version confirm process was designed with more than just client-server in mind, it sends the server’s network version and service id as well, even though this isn’t really needed by the client (even the service id isn’t needed, since you usually only connect to auth once, and it’s the very first connection). This could be simplified if the protocol is ever revised.

Fields

network_version: u32

The network protocol version of the server. For servers compatible with live, this is 171022. This was relevant mainly back when LU was actively updated. Server projects making modifications to the network protocol should set this to a different value.

service_id: ServiceId

Service ID of the server, ServiceId::Auth for auth servers, ServiceId::World for world servers.

Trait Implementations

impl Debug for Handshake

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__ENDIO_ENDIANNESS: Endianness, __ENDIO_READER: Read + ERead<__ENDIO_ENDIANNESS>> Deserialize<__ENDIO_ENDIANNESS, __ENDIO_READER> for Handshakewhere
    u32: Deserialize<__ENDIO_ENDIANNESS, __ENDIO_READER>,
    ServiceId: Deserialize<__ENDIO_ENDIANNESS, __ENDIO_READER>,

fn deserialize(reader: &mut __ENDIO_READER) -> Result<Self>

Deserializes the type by reading from the reader.

impl From<Handshake> for Message

fn from(msg: Handshake) -> Self

Converts to this type from the input type.

impl From<Handshake> for Message

fn from(msg: Handshake) -> Self

Converts to this type from the input type.

impl PartialEq<Handshake> for Handshake

fn eq(&self, other: &Handshake) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'__ENDIO_LIFETIME, __ENDIO_ENDIANNESS: Endianness, __ENDIO_WRITER: Write + EWrite<__ENDIO_ENDIANNESS>> Serialize<__ENDIO_ENDIANNESS, __ENDIO_WRITER> for &'__ENDIO_LIFETIME Handshakewhere
    &'__ENDIO_LIFETIME u32: Serialize<__ENDIO_ENDIANNESS, __ENDIO_WRITER>,
    &'__ENDIO_LIFETIME ServiceId: Serialize<__ENDIO_ENDIANNESS, __ENDIO_WRITER>,

fn serialize(self, writer: &mut __ENDIO_WRITER) -> Result<()>

Serializes the type by writing to the writer.

impl StructuralPartialEq for Handshake