All Classes and Interfaces
Class
Description
Message sent when the map or char server want to update the users data, seemingly to update data
that can be recalled by OTHER map servers.
This provides a read-and-write view of the users that are active on the game server.
Implementation of PacketReader that wraps a Netty
ByteBuf.The record for a character server we want to tell the login clients about.
This contains the state and netty behavior of the ping pong client.
Context wraps the calling context when performing packet logic.
Source determines where the context was constructed and called into.
The FrameCodec converts to and from
ByteBuf streams into individual Packet objects.The main entrypoint for the LoginServer.
The HA session represents the connection between the Login server and the Char server.
The containing object of all the various packet handler objects.
Utility object for pairing the ip address and port together.
Implementation of
ActiveUserCollection that stores the list of active users in memory.An in-memory implementation of
PendingAuthCollection, responsible for generating auth
tokens and keeping them around/expunging them when they are no longer needed.In-memory implementation of
ServerCollection, responsible for keeping track of known
servers.Implementation of the context object which provides
PacketHandlers for the codecs.The response object indicating a login failed.
The login request object, coming from the client.
Initializes the login server channel.
The main entrypoint for the LoginServer.
Service object which contains the logic for running a login service.
Represents the ongoing transaction between the client and the login server that represents a user
trying to authenticate.
The response for a login request from a client.
Base class for abstracting common login success logic, as it's a packet with multiple packet
prefixes but that share similar layouts.
This main runs both client and server as separate threads.
Main entrypoint.
This wraps the client into a runnable that can be run as a main entrypoint OR passed into a
Thread.
This wraps the server into a runnable that can be run as a main entrypoint OR passed into a
Thread.
A
UserLoader implementation which reads from the mysql db using the rathena schema via
the mybatis xml fileImplementation of
Context which wraps an upper-level context and sets the Context.Source to the given value and sets the underlying object to an instance
of ChannelHandlerContext.The packet object pairs the byte stream with the matched rule.
Codec responsible for converting to and from
Packet objects and the
business-logic specific POJOs.Interface responsible for converting to and from Packet objects to a POJO type
Interface for decoding packets into data.
Represents a specification for which packet ID (labeled 'prefix' here) is of what type (STATIC or
DYNAMIC), what name and Java class POJO, and what kRO packet version the POJO maps to.
The type of packet, currently only 2.
The pending auth collection contains pending authentications (with expirations) that the login
server stores and recalls.
An auth token is a login1/login2 item pair that we send to the client.
The super simple Ping request POJO
This is the packet handler for the Ping message.
Netty clients logic for the ping pong example.
Netty server logic for the ping pong example.
The super simple Pong response POJO
This is the packet handler for the Pong message.
Thread factory which prefixes the thread with the given name and an incremental integer.
This is a simplification of the code found in nettys LoggingHandler that juts dumps read and
writes and is used to dump the POJOs AFTER the frame and packet codecs are done.
The root context is the context implementation for the Ping/Pong server and defines the packet
version and provides the
PacketHandlers.The collection containing the servers.
Acts as the stateful object for tracking the server side of a connection.
This most-simple user authenticator just does a standard password comparison.
The interface for authenticating a user.
Interface for loading users.