public UserConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
RegisterPacketHandler((int)PacketType.LoginRequest, OnPlayerLoginRequest);
RegisterPacketHandler((int)PacketType.PacketGenericMessage, (int)GenericMessageType.GetLatestVersion, OnGetLatestVersion);
RegisterStandardPacketReplyHandler((int)PacketType.PacketGenericMessage, 878787, OnClientMachineInfo);
}
/// <summary>
/// Override from ServerBase, to make sure we create the proper connection object for inbound connections.
/// If we don't override this method, a generic InboundConnection class will be instantiated.
/// </summary>
protected override InboundConnection CreateInboundConnection(Socket s, ServerBase server, int serviceID, bool isBlocking)
{
InboundConnection con = null;
// ServiceIDs represents the type connection that is being requested.
// these IDs are set in the App.Config of the initiating server and are any arbitrarily agreed upon integers
switch (serviceID)
{
case 7:
con = new ZeusInboundConnection(s, server, isBlocking);
con.ServiceID = serviceID;
break;
case 1: // central server
con = new GSTurnedLobbyInboundCentralConnection(s, server, isBlocking);
con.ServiceID = serviceID;
GameManager.Instance.CentralServer = con as GSInboundServerConnection;
break;
default: // assume player client
con = new GSTurnedLobbyInboundPlayerConnection(s, server, isBlocking);
con.ServiceID = serviceID;
break;
}
#if DEBUG
if (con == null)
{
throw new ArgumentOutOfRangeException("ServiceID " + serviceID.ToString() + " is unknown to CreateInboundConnection. Cannot process connection.");
}
#endif
return con;
}
/// <summary>
/// Override this method to create the correct connection object for connecting to another server in the Hive
/// given the service request ID listed in the App.Config.
/// Once the appropriate connection is created, it takes over the handshaking and communication.
/// </summary>
public override OutboundServerConnection CreateOutboundServerConnection(string name, ServerBase server, string reportedIP, int serviceID, bool isBlocking)
{
switch (serviceID)
{
default:
return new BeholderOutboundServerConnection(name, server, reportedIP, isBlocking);
}
}
/// <summary>
/// Override from ServerBase, to make sure we create the proper connection object for inbound connections.
/// If we don't override this method, a generic CSInboundServerConnection class will be instantiated.
/// </summary>
protected override InboundConnection CreateInboundConnection(Socket s, ServerBase server, int serviceId, bool isBlocking)
{
if (serviceId == 7)
{
return new ZeusInboundConnection(s, server, isBlocking);
}
return new CSInboundServerConnection(s, server, isBlocking);
}
public OutboundServerConnection(string name, ServerBase server, string reportedIP, bool isBlocking)
: base(isBlocking)
{
Name = name;
LoggedIn = false;
Disonnected = false;
Server = server;
ReportedIP = reportedIP;
RegisterPacketHandler((int)ServerPacketType.ServerStatusUpdate, OnServerPong);
}
protected override InboundConnection CreateInboundConnection(System.Net.Sockets.Socket s, ServerBase server, int serviceID, bool isBlocking)
{
if (serviceID == 7)
{
return new ZeusInboundConnection(s, server, isBlocking);
}
if (serviceID == 99)
{
return new InboundChatLoginConnection(s, server, isBlocking);
}
return new InboundWorldLoginConnection(s, server, isBlocking);
}
public InboundConnection(Socket s, ServerBase server, bool isBlocking)
: base(isBlocking)
{
MyServer = server;
NUM_CONNECTIONS_IN_MEMORY++;
try
{
MyTCPSocket = s;
MyTCPSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, DisableTCPDelay);
m_TimeoutTimer = new Timer();
int timeout = ConfigHelper.GetIntConfig("PlayerConnectionTimeout");
if (timeout < 1)
{
timeout = 10;
}
m_TimeoutTimer.Interval = timeout * 1000;
m_TimeoutTimer.Elapsed += new ElapsedEventHandler(TimeoutTimer_Elapsed);
m_TimeoutTimer.Start();
ServerUser = new Shared.ServerUser();
ServerUser.MyConnection = this;
// Track the network socket associated with this connection object.
string msg = "";
if (!ConnectionManager.TrackUserSocket(this, ref msg))
{
KillConnection(msg);
return;
}
if (!Transit.ListenForDataOnSocket())
{
KillConnection("Remote end closed socket.");
return;
}
Log1.Logger("Server").Info("Now have [" + ConnectionManager.ConnectionCount.ToString() + " connections] attached.");
}
catch (Exception e)
{
KillConnection("Error instantiating Inbound connection object " + GetType().ToString() + " : " + e.Message);
Log1.Logger("Server.Network").Error("Error instantiating Inbound connection object " + GetType().ToString() + " : " + e.Message, e);
return;
}
SendRijndaelExchangeRequest();
}
/// <summary>
/// Returns the authorized user object, or null if the user isn't currently authorized
/// </summary>
/// <param name="account"></param>
/// <returns></returns>
public static ServerUser GetAuthorizedUser(string account, ServerBase server, PacketLoginRequest.ConnectionType conType)
{
ServerUser u = null;
if (conType == PacketLoginRequest.ConnectionType.AssistedTransfer)
{
lock (m_AuthorizedAccountsSyncRoot)
{
AuthorizedAccounts.TryGetValue(account.ToLower(), out u);
}
}
else if (conType == PacketLoginRequest.ConnectionType.UnassistedTransfer)
{
Guid ticket = Guid.Empty;
string authServer = "";
DateTime whenAuthd = DateTime.MinValue;
int character = -1;
string targetServerID = "";
Guid accountID = Guid.Empty;
if (!DB.Instance.User_GetAuthorizationTicket(account, out authServer, out ticket, out whenAuthd, out character, out targetServerID, out accountID) || ticket == Guid.Empty)
{
return null;
}
if (targetServerID != server.ServerUserID)
{
// we weren't authorized to be on this server.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer to [" + server.ServerUserID + "], but that user was only authorized to transfer to target server ID [" + targetServerID+ "]. Connection denied.");
return null;
}
if (whenAuthd + AuthTicketLifetime < DateTime.UtcNow)
{
// ticket expired.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer to [" + server.ServerUserID + "], but that user's auth ticket is expired. Connection denied.");
return null;
}
// Got a ticket. Load up the user from the DB.
u = new ServerUser();
u.OwningServer = server.ServerUserID;
u.AuthTicket = ticket;
u.ID = accountID;
u.AccountName = account;
// load the profile
AccountProfile ap = new AccountProfile(account);
u.Profile = ap;
ap.Load(server.RequireAuthentication);
// load the character
if (character > -1)
{
string msg = "";
u.CurrentCharacter = CharacterUtil.Instance.LoadCharacter(u, character, ref msg);
if (u.CurrentCharacter == null)
{
// Couldn't load character.
Log1.Logger(server.ServerUserID).Error("[" + account + "] attempted unassisted transfer with characer [" + character + "], but that character could not be loaded from the DB: [" + msg + "]. Connection denied.");
return null;
}
u.CurrentCharacter.OwningAccount = u;
CharacterCache.CacheCharacter(u.CurrentCharacter, server.ServerUserID);
}
}
AuthorizeUser(u); // gotta call this to activate/renew the auth ticket on this server.
return u;
}
public CentralLobbyInboundBeholderConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
}
public CSInboundPlayerConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
}
/// <summary>
/// Override from ServerBase, to make sure we create the proper connection object for inbound connections.
/// If we don't override this method, a generic CSOutboundConnection class will be instantiated.
/// </summary>
public override OutboundServerConnection CreateOutboundServerConnection(string name, ServerBase server, string reportedIP, int serviceId, bool isBlocking)
{
return new CSOutboundConnection(name, server, reportedIP, isBlocking);
}
public LobbyBeholderOutboundServerConnection(string name, ServerBase server, string reportedIP, bool isBlocking)
: base(name, server, reportedIP, isBlocking)
{
}
public LSInboundConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
RegisterPacketHandler((int)PacketType.LoginRequest, OnPlayerLoginRequest);
}
public CentralLobbyOutboundContentConnection(string name, ServerBase server, string reportedIP, bool isBlocking)
: base(name, server, reportedIP, isBlocking)
{
}
public InboundLobbyLoginConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
}
/// <summary>
/// Override from ServerBase, to make sure we create the proper connection object for outbound connections.
/// If we don't override this method, a generic OutboundServerConnection class will be instantiated.
/// </summary>
public override OutboundServerConnection CreateOutboundServerConnection(string name, ServerBase server, string reportedIP, int serviceID, bool isBlocking)
{
// we need to define a new class and instantiate it here for any outbound connections. currently, the game lobby server
// should have no outbound connections. If it tries to create some (i.e. this exception has been thrown), there is likely
// an outbound connection defined in your App.Config file that probably shouldn't be there.
throw new NotImplementedException("No outbound connections object have been defined for GameServer_Lobby");
}
protected override InboundConnection CreateInboundConnection(Socket s, ServerBase server, int serviceID, bool isBlocking)
{
if (serviceID == 7) // 7eus
{
ZeusPatchInboundZeusConnection zcon = new ZeusPatchInboundZeusConnection(s, server, isBlocking);
return zcon;
}
UserConnection con = new UserConnection(s, server, isBlocking);
return con;
}
public LSOutboundConnection(string name, ServerBase server, string reportedIP, bool isBlocking)
: base(name, server, reportedIP, isBlocking)
{
}
public GSTurnedLobbyInboundPlayerConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
}
/// <summary>
/// Override from ServerBase, to make sure we create the proper connection object for inbound connections.
/// If we don't override this method, a generic InboundConnection class will be instantiated.
/// </summary>
protected override InboundConnection CreateInboundConnection(Socket s, ServerBase server, int serviceID, bool isBlocking)
{
return new AcctServiceInboundZeusConnection(s, server, isBlocking);
}
public GSLobbyInboundCentralConnection(Socket s, ServerBase server, bool isBlocking)
: base(s, server, isBlocking)
{
}
