public ExternalServersController(IMemoryCache cache)
{
this.cache = cache;
serverManager = new ServersManager(this.cache);
}
private static void Login(AuthClient client, bool autoconnect)
{
ServersManager.DisconnectAlreadyConnectedClient(client, client.Account.Id);
AuthServer.Instance.AuthClients.Add(client);
bool hasRights = false;
if (client.Account.Role > ServerRoleEnum.PLAYER)
{
hasRights = true;
}
client.Send(new IdentificationSuccessMessage(hasRights, false, client.Account.Username, client.Account.Nickname, client.Account.Id, 0, "Supprimer ce personnage?", 2, 1, 0));
var characters = CharacterRecord.GetAccountCharacters(client.Account.Id);
if (!autoconnect)
{
SendServerListMessage(client, characters.Count);
return;
}
else
{
if (WorldServer.Instance.ServerState == ServerStatusEnum.ONLINE)
{
SelectedServer(null, client);
}
else
{
SendServerListMessage(client, characters.Count);
}
}
}
/// <summary>
/// 本地服务器-保存集群当前配置
/// </summary>
private void button_Cluster_SaveIni_Click(object sender, RoutedEventArgs e)
{
int indexLocal = listBox_LocalServer_ClusterFile.SelectedIndex;
string nameLocal = ComboBox_LocalServer_SavesFolder.SelectedItem?.ToString();
if (tabItem_LocalServer.IsSelected)
{
if (indexLocal == -1)
{
return;
}
ExtendHelper.CopyAllProperties(UI, m_ClusterInfo_Local[indexLocal].ClusterSetting);
SavesManager.SetClusterInfo(nameLocal, m_ClusterInfo_Local[indexLocal]);
}
SftpClient client = ServersManager.GetExistSftp(m_ServerConnect, UI.Location, UI.Username, UI.Password);
int indexCloud = listBox_CloudServer_ClusterFile.SelectedIndex;
string nameCloud = ComboBox_CloudServer_SavesFolder.SelectedItem?.ToString();
if (tabItem_CloudServer.IsSelected)
{
if (indexCloud == -1)
{
return;
}
if (client == null)
{
return;
}
ExtendHelper.CopyAllProperties(UI, m_ClusterInfo_Cloud[indexCloud].ClusterSetting);
SavesManager.SetClusterInfo(nameCloud, m_ClusterInfo_Cloud[indexCloud], client);
}
}
public override void RunImplement()
{
try
{
Account p = client.SessionPlayer;
if (p != null && p.match != null && p.matchSlot == p.match.leader && p.match.state == MatchStateEnum.Ready)
{
int channelId = serverInfo - (serverInfo / 10 * 10);
Match mt = ServersManager.GetChannel(channelId).GetMatch(id);
if (mt != null)
{
Account lider = mt.GetLeader();
if (lider != null && lider.client != null && lider.isOnline)
{
lider.SendPacket(new CLAN_WAR_MATCH_REQUEST_BATTLE_PAK(p.match, p));
client.SendCompletePacket(PackageDataManager.CLAN_WAR_LEAVE_TEAM_SUCCESS_PAK);
return;
}
}
}
client.SendCompletePacket(PackageDataManager.CLAN_WAR_MATCH_PROPOSE_ERROR_PAK);
}
catch (Exception ex)
{
PacketLog(ex);
}
}
public override void RunImplement()
{
Account player = client.SessionPlayer;
if (player == null || player.match == null)
{
return;
}
try
{
int channelId = serverInfo - ((serverInfo / 10) * 10);
Channel ch = ServersManager.GetChannel(channelId);
if (ch != null)
{
Match match = ch.GetMatch(id);
if (match != null)
{
client.SendPacket(new CLAN_WAR_MATCH_TEAM_INFO_PAK(0, match.clan));
}
else
{
client.SendPacket(new CLAN_WAR_MATCH_TEAM_INFO_PAK(0x80000000));
}
}
else
{
client.SendPacket(new CLAN_WAR_MATCH_TEAM_INFO_PAK(0x80000000));
}
}
catch (Exception ex)
{
PacketLog(ex);
}
}
public override void RunImplement()
{
Channel channel = ServersManager.GetChannel(channelId);
if (channel != null)
{
channel.RemoveEmptyRooms();
List <Room> rooms = channel.rooms;
List <Account> waiting = channel.GetWaitPlayers();
int Rpages = (int)Math.Ceiling(rooms.Count / 15d);
int Apages = (int)Math.Ceiling(waiting.Count / 10d);
if (client.lastRoomPage >= Rpages)
{
client.lastRoomPage = 0;
}
if (client.lastPlayerPage >= Apages)
{
client.lastPlayerPage = 0;
}
int roomsCount = 0, playersCount = 0;
byte[] roomsArray = GetRoomListData(ref roomsCount, rooms);
byte[] waitingArray = GetPlayerListData(client.lastPlayerPage, ref playersCount, waiting);
client.SendPacket(new API_ROOM_LIST_ACK(rooms.Count, waiting.Count, client.lastRoomPage++, client.lastPlayerPage++, roomsCount, playersCount, roomsArray, waitingArray));
}
}
static void ServersManager_Sent(ServersManager <HttpConnection> s, ref ServerAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Console.WriteLine("Sent error: {0}", e.SocketError.ToString());
}
}
private void ServersManager_BeforeSend(ServersManager <Connection> s, Connection c, ServerAsyncEventArgs e)
{
if (c != null && c.Mode == Connection.Modes.WebSocket)
{
//c.BeforeSend(e);
var header = new WebSocketHeader()
{
Fin = true,
Opcode = websocketOpcode.HasValue ? websocketOpcode.Value : c.WebSocketHeader.Opcode,
PayloadLength = e.Count,
};
int headerLength = header.GetHeaderLength();
if (e.OffsetOffset < headerLength)
{
throw new InvalidProgramException(@"TransportLayer.ServersManager_BeforeSend no reserved space for WebSocket header");
}
e.OffsetOffset -= headerLength;
e.Count += headerLength;
header.GenerateHeader(e.OutgoingData);
}
}
public void LoadData()
{
Out.Info("Loading ServerList...");
Servers = ServersManager.GetServers();
Out.Info("Loading BlockedIp");
BlockedIp = AccountManager.GetBlockedIps(); Out.Debug($"{BlockedIp.Count} ips blocked");
}
/// <summary>
/// 本地服务器-开启当前服务器集群
/// </summary>
private void button_LocalServer_StartCluster_Click(object sender, RoutedEventArgs e)
{
int indexLocalFile = listBox_LocalServer_ClusterFile.SelectedIndex;
int indexLocalPath = dataGrid_LocalServer_ServersPath.SelectedIndex;
if (indexLocalFile == -1 || indexLocalPath == -1)
{
return;
}
//保存当前选中的集群配置
ExtendHelper.CopyAllProperties(UI, m_ClusterInfo_Local[indexLocalFile].ClusterSetting);
SavesManager.SetClusterInfo(ComboBox_LocalServer_SavesFolder.SelectedItem?.ToString(), m_ClusterInfo_Local[indexLocalFile]);
string confdir = ComboBox_LocalServer_SavesFolder.SelectedItem.ToString();
string cluster = listBox_LocalServer_ClusterFile.SelectedItem.ToString();
string exefile = (dataGrid_LocalServer_ServersPath.SelectedItem as DataRowView)[2].ToString();
bool isShell = (bool)radioButton_LocalServer_OpenType_1.IsChecked;
//依次开启集群服务器
foreach (var server in m_ClusterInfo_Local[indexLocalFile].ClusterServers)
{
string shard = server.Setting.Shard_Master ? "Master" : "Caves";
string parameter = ServersManager.CreatParameter(confdir, cluster, shard);
CreatNewProcess(exefile, parameter, isShell, server.Session);
}
}
static void CreateSomeGarbage(ServersManager<BaseConnection2> serversManager)
{
EventArgsManager.Get();
EventArgsManager.Get();
EventArgsManager.Get();
EventArgsManager.Get();
EventArgsManager.Get();
}
public static void SelectedServer(ServerSelectionMessage message, AuthClient client)
{
string host = ConfigurationManager.Instance.IsCustomHost == true ? ConfigurationManager.Instance.RealHost : ConfigurationManager.Instance.Host;
var encrypted = AccountsProvider.EncryptTicket(ServersManager.TransfertToGame(client.Account), client.AesKey);
client.Send(new SelectedServerDataMessage((ushort)ConfigurationManager.Instance.ServerId, host, (ushort)ConfigurationManager.Instance.WorldPort, true, encrypted));
client.Disconnect();
}
internal static void Infos()
{
Logger.Init2("Version: " + ConstantsRepertory.VERSION);
Logger.NewLine();
Logger.Init2("Dofus Version ) " + ConstantsRepertory.DOFUS_REQUIRED_VERSION);
Logger.Init2("Clients connecteds on AuthServer: " + ServersManager.GetAuthConnectedCount());
Logger.Init2("Clients connecteds on WorldServer: " + ServersManager.GetWorldConnectedCount());
Logger.Init2("Total: " + ServersManager.GetConnectedCounts());
}
public void Initialize(string ip, int port)
{
DateTime startTime = DateTime.Now;
Out.Info("Initializing server...");
try
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(IPAddress.Parse(ip), port));
socket.Listen(100);
Ip = ip;
Port = port;
}
catch (SocketException e)
{
Out.Error(e.Message);
Dispose();
return;
}
Clients = new Dictionary <Socket, IBaseClient>();
Servers = new Dictionary <int, WorldServer>();
Out.Info("Loading Config...");
if (!File.Exists("config.txt"))
{
Out.Error("Can't load 'config.txt' !");
Dispose();
return;
}
Config = ConfigManager.GetConfig();
if (Config.ContainsKey("Debug") && Config["Debug"] == "true")
{
Out.DebugMode = true;
}
if (Config.ContainsKey("Maintenance") && Config["Maintenance"] == "true")
{
onMaintenance = true;
}
ProtocolVersion = int.Parse(Config["ProtocolVersion"]);
if (!ConfigManager.CheckConfig(Config))
{
Dispose();
return;
}
Out.Info("Initializing database...");
DatabaseManager.Initialize(Config["Database_Host"], Config["Database_User"], Config["Database_Password"], Config["Database_Auth"]);
if (Config.ContainsKey("AuthServer_Name"))
{
Console.Title = Config["AuthServer_Name"];
}
AccountManager.Initialize(DatabaseManager.connection);
ServersManager.Initialize(DatabaseManager.connection);
LoadData();
Out.Info($"Server started successfuly (Elapsed time : {DateTime.Now.Subtract(startTime).TotalMilliseconds.ToString("### ###")} ms)");
socket.BeginAccept(AcceptCallBack, null);
Out.Debug("Waiting for clients...");
}
public override void Write()
{
WriteH(2049);
WriteD(SessionId);
WriteIP(Ip);
WriteH(Port); //29890
WriteH(SessionSeed);
WriteB(ServersManager.GameServerListBytes);
WriteD(ServersManager.GetPlayers());
}
private static void Main()
{
Program.AlreadyExit = false;
Control.CheckForIllegalCrossThreadCalls = false;
Program.StartTime = Environment.TickCount;
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
ProtocolTypeManager.Initialize();
MessageReceiver.Initialize();
ServersManager.StartAllServers();
Application.Run((Form) new MainForm());
}
public static void Exit()
{
if (Program.AlreadyExit)
{
return;
}
Program.AlreadyExit = true;
ServersManager.StopAllServers();
WindowManager.Exit();
Application.Exit();
Environment.Exit(1);
}
public static void Initialize(GameController gameReference)
{
GameInstance = gameReference;
GraphicsManager = GameInstance.Graphics;
GraphicsDevice = GameInstance.GraphicsDevice;
Content = GameInstance.Content;
SpriteBatch = new CoreSpriteBatch(GraphicsDevice);
Window = GameInstance.Window;
if (CommandLineArgHandler.ForceGraphics)
{
Window.Title = GameController.GAMENAME + " " + GameController.GAMEDEVELOPMENTSTAGE + " (FORCED GRAPHICS)";
}
else
{
Window.Title = GameController.GAMENAME + " " + GameController.GAMEDEVELOPMENTSTAGE;
}
GameOptions = Options.LoadOptions();
KeyBindings = Keyboard.LoadKeyboard();
GraphicsManager.PreferredBackBufferWidth = Convert.ToInt32(GameOptions.WindowSize.X);
GraphicsManager.PreferredBackBufferHeight = Convert.ToInt32(GameOptions.WindowSize.Y);
GraphicsDevice.PresentationParameters.BackBufferFormat = SurfaceFormat.Rgba1010102;
GraphicsDevice.PresentationParameters.DepthStencilFormat = DepthFormat.Depth24Stencil8;
WindowSize = new Rectangle(0, 0, Convert.ToInt32(GameOptions.WindowSize.X), Convert.ToInt32(GameOptions.WindowSize.Y));
GraphicsManager.PreferMultiSampling = true;
GraphicsManager.ApplyChanges();
Canvas.SetupCanvas();
//Player = new Player();
GameJoltSave = new GamejoltSave();
GameMessage = new GameMessage(null, new System.Drawing.Size(0, 0), new Vector2(0, 0));
ServersManager = new ServersManager();
Sampler = new SamplerState
{
Filter = TextureFilter.Point,
AddressU = TextureAddressMode.Clamp,
AddressV = TextureAddressMode.Clamp
};
GraphicsDevice.SamplerStates[0] = Sampler;
//SetScreen(new SplashScreen(GameInstance));
SetScreen(Screen.CreateSplashScreen((GameInstance)));
}
public override void RunImplement()
{
Channel channel = ServersManager.GetChannel(channelId);
if (channel != null)
{
Room room = channel.GetRoom(roomId);
if (room != null)
{
client.SendPacket(new API_ROOM_INFO_ACK(room));
}
}
}
public ConnectionTest()
{
serversManager = new ServersManager <Connection>(new ServersManagerConfig());
// create offset in tests
//
args = new ServerAsyncEventArgs[10];
for (int i = 0; i < args.Length; i++)
{
args[i] = EventArgsManager.Get();
//= serversManager.BuffersPool.Get();
args[i].AllocateBuffer();
}
}
public static void Main()
{
Settings = new Settings();
Settings.TryLoad();
Settings.Save();
ServersManager = new ServersManager();
ServersManager.TryLoadServers();
ServersManager.SaveServers();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
private bool ServersManager_Received(ServersManager <Connection> s, Connection connection1, ref ServerAsyncEventArgs e1)
{
connection = connection1;
e = e1;
bool closeConnection = OnReceived();
e1 = e;
connection = null;
e = null;
return(closeConnection);
}
public ConnectionTest()
{
serversManager = new ServersManager<Connection>(new ServersManagerConfig());
// create offset in tests
//
args = new ServerAsyncEventArgs[10];
for (int i = 0; i < args.Length; i++)
{
args[i] = EventArgsManager.Get();
//= serversManager.BuffersPool.Get();
args[i].AllocateBuffer();
}
}
public static void HandleAuthentificationTicket(AuthenticationTicketMessage message, WorldClient client)
{
var msg = (AuthenticationTicketMessage)message;
var reader = new BigEndianReader(Encoding.ASCII.GetBytes(msg.ticket));
var count = reader.ReadByte();
var ticket = reader.ReadUTFBytes(count);
client.Account = ServersManager.GetAccount(ticket);
client.Characters = CharacterRecord.GetAccountCharacters(client.Account.Id);
client.Send(new AuthenticationTicketAcceptedMessage());
client.Send(new AccountCapabilitiesMessage(true, true, client.Account.Id, BreedRecord.AvailableBreedsFlags, BreedRecord.AvailableBreedsFlags, 1));
client.Send(new TrustStatusMessage(true, true));
client.Send(new ServerOptionalFeaturesMessage(new sbyte[] { 1, 2, 3, 4, 5, 6 }));
}
public override void RunImplement()
{
try
{
Account player = client.SessionPlayer;
if (player == null || player.channelId >= 0)
{
return;
}
Channel channel = ServersManager.GetChannel(channelId);
if (channel != null)
{
if (ChannelRequirementCheck(player, channel))
{
client.SendCompletePacket(PackageDataManager.BASE_CHANNEL_ENTER_0x80000202_PAK);
}
else if (channel.players.Count >= Settings.MaxPlayersChannel)
{
client.SendCompletePacket(PackageDataManager.BASE_CHANNEL_ENTER_0x80000201_PAK);
}
else
{
player.channelId = channelId;
client.SendPacket(new BASE_CHANNEL_ENTER_PAK(player.channelId, channel.announce));
player.status.UpdateChannel((byte)player.channelId);
player.UpdateCacheInfo();
}
}
else
{
client.SendCompletePacket(PackageDataManager.BASE_CHANNEL_ENTER_0x80000000_PAK);
client.Close(3000);
}
}
catch (Exception ex)
{
PacketLog(ex);
}
/*
* 0x80000201 STBL_IDX_EP_SERVER_USER_FULL_C
* 0x80000202 - De acordo com o ChannelType
* 0x80000203 STBL_IDX_EP_SERVER_NOT_SATISFY_MTS
* 0x80000204 STR_UI_GOTO_GWARNET_CHANNEL_ERROR
* 0x80000205 STR_UI_GOTO_AZERBAIJAN_CHANNEL_ERROR
* 0x80000206 STR_POPUP_MOBILE_CERTIFICATION_ERROR
* 0x80000207 STR_UI_GOTO_TURKISH_CHANNEL_ERROR
* 0x80000208 STR_UI_GOTO_MENA_CHANNEL_ERROR
*/
}
private void UserDataWorker_DoWork(object sender, DoWorkEventArgs e)
{
CreateDefaultTable();
GetDatabaseData();
if (SavesManager.GetSavesFolder().Count == 0)
{
SavesManager.CreatSavesFolder();
}
UI.SaveFolders_Local = SavesManager.GetSavesFolder();
foreach (var item in ServersManager.GetExistProcess())
{
textBox_Servers_Tab_Log.Text += item + "\r\n";
}
}
static void HandleCommand(string[] cmd)
{
switch (cmd[0])
{
case "rl":
ServersManager.Initialize(DatabaseManager.connection);
auth.Servers = ServersManager.GetServers();
foreach (AuthClient client in auth.Clients.Values)
{
foreach (Common.Database.Modeles.Auth.WorldServer s in auth.Servers.Values)
{
client.Send(new ServerStatusUpdateMessage(new Protocol.Types.GameServerInformations(s.ServerId, s.Status, s.Completion, true, 14)));
}
}
break;
case "test":
Out.WriteLine("TEST !!!", ConsoleColor.Yellow);
break;
case "exit":
auth.Dispose();
Out.WriteLine("Auth server stopped successfully", ConsoleColor.Cyan);
break;
case "start":
if (auth.Clients != null)
{
Out.Error("Server already started");
break;
}
auth.Initialize(ip, port);
break;
case "world":
if (cmd.Length > 1 && cmd[1] == "start")
{
world = new WorldServer();
}
break;
default:
Out.WriteLine($"Unknown command {cmd[0]}", ConsoleColor.Red);
break;
}
}
static bool ServersManager_Received(ServersManager <HttpConnection> s, HttpConnection connection, ref ServerAsyncEventArgs e)
{
bool closeConnection = false, repeat = true;
while (repeat)
{
repeat = connection.Proccess(ref e, out closeConnection);
if (connection.IsMessageReady)
{
httpServer.ProcessIncomingRequest(connection);
connection.ResetState();
}
}
return(!closeConnection);
}
public TransportLayer(ServersManager<Connection> serversManager1, Opcodes? websocketResponseFrame)
{
ChangeSettings(websocketResponseFrame);
serversManager = serversManager1;
serversManager.ServerAdded += ServersManager_ServerAdded;
serversManager.ServerRemoved += ServersManager_ServerRemoved;
serversManager.ServerInfo += ServersManager_ServerInfo;
serversManager.NewConnection += ServersManager_NewConnection;
serversManager.EndConnection += ServersManager_EndConnection;
serversManager.Received += ServersManager_Received;
serversManager.Sent += ServersManager_Sent;
serversManager.BeforeSend += ServersManager_BeforeSend;
ajax = new AjaxWebsocket();
ajax.SendAsync = SendAsyncAjax;
}
static bool ServersManager_Received(ServersManager<HttpConnection> s, HttpConnection connection, ref ServerAsyncEventArgs e)
{
bool closeConnection = false, repeat = true;
while (repeat)
{
repeat = connection.Proccess(ref e, out closeConnection);
if (connection.IsMessageReady)
{
httpServer.ProcessIncomingRequest(connection);
connection.ResetState();
}
}
return !closeConnection;
}
public TransportLayer(ServersManager <Connection> serversManager1, Opcodes?websocketResponseFrame)
{
ChangeSettings(websocketResponseFrame);
serversManager = serversManager1;
serversManager.ServerAdded += ServersManager_ServerAdded;
serversManager.ServerRemoved += ServersManager_ServerRemoved;
serversManager.ServerInfo += ServersManager_ServerInfo;
serversManager.NewConnection += ServersManager_NewConnection;
serversManager.EndConnection += ServersManager_EndConnection;
serversManager.Received += ServersManager_Received;
serversManager.Sent += ServersManager_Sent;
serversManager.BeforeSend += ServersManager_BeforeSend;
ajax = new AjaxWebsocket();
ajax.SendAsync = SendAsyncAjax;
}
private void button_CloudServer_AddCluster_Click(object sender, RoutedEventArgs e)
{
SftpClient client = ServersManager.GetExistSftp(m_ServerConnect, UI.Location, UI.Username, UI.Password);
if (client == null)
{
return;
}
string userPath = (UI.Username == "root") ? "/root" : $"/home/{UI.Username}";
try { client.CreateDirectory($"{userPath}/.klei/{textBox_CloudServer_ClusterSaveList_AddPath.Text}"); }
catch (SshException) { }
catch (Exception) { throw; };
UI.SaveFolders_Cloud.Add(textBox_CloudServer_ClusterSaveList_AddPath.Text);
}
public void Start()
{
//lock (syncRoot)
{
if (PublicIp == null)
{
throw new Exception("Invalid Public IP");
}
allocations = new AllocationsPool();
allocations.Removed += Allocation_Removed;
ServerAsyncEventArgs.DefaultOffsetOffset = TcpFramingHeader.TcpFramingHeaderLength;
turnServer = new ServersManager <TurnConnection>(new ServersManagerConfig());
turnServer.Bind(new ProtocolPort()
{
Protocol = ServerProtocol.Udp, Port = TurnUdpPort,
});
turnServer.Bind(new ProtocolPort()
{
Protocol = ServerProtocol.Tcp, Port = TurnTcpPort,
});
turnServer.Bind(new ProtocolPort()
{
Protocol = ServerProtocol.Tcp, Port = TurnPseudoTlsPort,
});
turnServer.NewConnection += TurnServer_NewConnection;
turnServer.Received += TurnServer_Received;
turnServer.ServerAdded += TurnServer_ServerAdded;
turnServer.ServerRemoved += TurnServer_ServerRemoved;
turnServer.Start(true);
peerServer = new ServersManager <PeerConnection>(
new ServersManagerConfig()
{
MinPort = MinPort,
MaxPort = MaxPort,
});
peerServer.AddressPredicate = (i, ip, ai) => { return(ai.Address.Equals(RealIp)); };
peerServer.Received += PeerServer_Received;
peerServer.Start(true);
peerServer.ServerAdded += PeerServer_ServerAdded;
peerServer.ServerRemoved += PeerServer_ServerRemoved;
}
}
private void button_CloudServer_StartCluster_Click(object sender, RoutedEventArgs e)
{
SftpClient client = ServersManager.GetExistSftp(m_ServerConnect, UI.Location, UI.Username, UI.Password);
string nameCloud = ComboBox_CloudServer_SavesFolder.SelectedItem?.ToString();
int indexCloud = listBox_CloudServer_ClusterFile.SelectedIndex;
int indexCloudFile = listBox_CloudServer_ClusterFile.SelectedIndex;
if (client == null)
{
return;
}
ExtendHelper.CopyAllProperties(UI, m_ClusterInfo_Cloud[indexCloud].ClusterSetting);
SavesManager.SetClusterInfo(nameCloud, m_ClusterInfo_Cloud[indexCloud], client);
string confdir = ComboBox_CloudServer_SavesFolder.SelectedItem.ToString();
string cluster = listBox_CloudServer_ClusterFile.SelectedItem.ToString();
string exefile = (dataGrid_CloudServer_ServersPath.SelectedItem as DataRowView)[2].ToString();
string exepath = exefile.Replace("/dontstarve_dedicated_server_nullrenderer", "");
List <string> screenList = ServersManager.GetExistScreens(UI.Location, UI.Username, UI.Password);
foreach (var server in m_ClusterInfo_Cloud[indexCloudFile].ClusterServers)
{
string shard = server.Setting.Shard_Master ? "Master" : "Caves";
string parameter = ServersManager.CreatParameter(confdir, cluster, shard);
string command = string.Empty;
string screenName = cluster + "_" + server.Folder;
if (screenList.Contains(screenName))
{
command = $"screen -xr {screenName}";
}
else
{
command += $"cd {exepath}\r";
command += $"screen -S {screenName} {"./dontstarve_dedicated_server_nullrenderer"} {parameter}";
}
CreatNewScreens(UI.Location, UI.Username, UI.Password, command);
}
}
static void Main(string[] args)
{
var exePath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
/////////////////////////////////////////////////////////////////////////
serversManager = new ServersManager<HttpConnection>(new ServersManagerConfig());
serversManager.Bind(new ProtocolPort() { Protocol = ServerProtocol.Tcp, Port = 8080, });
serversManager.ServerAdded += ServersManager_ServerAdded;
serversManager.ServerRemoved += ServersManager_ServerRemoved;
serversManager.ServerInfo += ServersManager_ServerInfo;
serversManager.NewConnection += ServersManager_NewConnection;
serversManager.EndConnection += ServersManager_EndConnection;
serversManager.Received += ServersManager_Received;
serversManager.Sent += ServersManager_Sent;
serversManager.Logger.Enable(exePath + @"\Log.pcap");
/////////////////////////////////////////////////////////////////////////
HttpMessage.BufferManager = new BufferManagerProxy();
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Loading DFA table...");
HttpMessageReader.LoadTables(exePath + @"\Http.Message.dfa");
XcapUriParser.LoadTables(exePath);
/////////////////////////////////////////////////////////////////////////
xcapServer = new XcapServer();
xcapServer.AddHandler(new ResourceListsHandlerExample());
//xcapServer.AddHandler(new RlsServicesHandler());
/////////////////////////////////////////////////////////////////////////
httpServer = new HttpServer();
httpServer.SendAsync = serversManager.SendAsync;
(httpServer as IHttpServerAgentRegistrar).Register(xcapServer, 0, true);
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Starting...");
try
{
serversManager.Start();
Console.WriteLine(@"Started!");
}
catch (Exception ex)
{
Console.WriteLine(@"Failed to start");
Console.WriteLine(@"Error: {0}", ex.Message);
}
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Press any key to stop server...");
Console.ReadKey(true);
Console.WriteLine();
}
static void ServersManager_EndConnection(ServersManager<HttpConnection> s, BaseConnection e)
{
Console.WriteLine(@" Connection Closed: {0}", e.RemoteEndPoint.ToString(), e.ToString());
}
private void ServersManager_BeforeSend(ServersManager<Connection> s, Connection c, ServerAsyncEventArgs e)
{
if (c != null && c.Mode == Connection.Modes.WebSocket)
{
//c.BeforeSend(e);
var header = new WebSocketHeader()
{
Fin = true,
Opcode = websocketOpcode.HasValue ? websocketOpcode.Value : c.WebSocketHeader.Opcode,
PayloadLength = e.Count,
};
int headerLength = header.GetHeaderLength();
if (e.OffsetOffset < headerLength)
throw new InvalidProgramException(@"TransportLayer.ServersManager_BeforeSend no reserved space for WebSocket header");
e.OffsetOffset -= headerLength;
e.Count += headerLength;
header.GenerateHeader(e.OutgoingData);
}
}
private bool ServersManager_Received(ServersManager<Connection> s, Connection connection1, ref ServerAsyncEventArgs e1)
{
connection = connection1;
e = e1;
bool closeConnection = OnReceived();
e1 = e;
connection = null;
e = null;
return closeConnection;
}
private bool TurnServer_Received(ServersManager<TurnConnection> s, TurnConnection c, ref ServerAsyncEventArgs e)
{
if (e.LocalEndPoint.Protocol == ServerProtocol.Udp)
{
if (TurnMessage.IsTurnMessage(e.Buffer, e.Offset, e.BytesTransferred))
TurnServer_TurnDataReceived(ref e);
else
TurnServer_PeerDataReceived(ref e);
}
else if (e.LocalEndPoint.Protocol == ServerProtocol.Tcp)
{
if (c.Buffer.IsValid)
{
c.Buffer.Resize(Math.Max(4096, c.BytesExpected));
if (c.Buffer.CopyTransferredFrom(e, 0) == false)
return false;
if (c.Buffer.Count < c.BytesExpected)
return true;
}
else
{
if (e.BytesTransferred < c.BytesExpected)
return c.Buffer.CopyTransferredFrom(e, 0);
}
int proccessed = 0;
for (; ; )
{
if (c.Buffer.IsValid)
{
if (e == null)
{
e = EventArgsManager.Get();
e.CopyAddressesFrom(c);
}
e.AttachBuffer(c.Buffer);
proccessed = 0;
}
if (e.BytesTransferred - proccessed < c.BytesExpected)
return c.Buffer.CopyTransferredFrom(e, proccessed);
switch (c.Phase)
{
case TcpPhase.WaitingFirstXpacket:
if (pseudoTlsMessage.IsBeginOfClientHello(e.Buffer, e.Offset, FirstXpacketLength))
{
c.Phase = TcpPhase.WaitingClientHello;
c.BytesExpected = PseudoTlsMessage.ClientHelloLength;
}
else
{
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
if (FirstXpacketLength <= TcpFramingHeader.TcpFramingHeaderLength)
goto case TcpPhase.WaitingTcpFrame;
}
break;
case TcpPhase.WaitingClientHello:
if (pseudoTlsMessage.IsClientHello(e.Buffer, e.Offset) == false)
return false;
var x = EventArgsManager.Get();
x.CopyAddressesFrom(e);
x.Count = PseudoTlsMessage.ServerHelloHelloDoneLength;
pseudoTlsMessage.GetServerHelloHelloDoneBytes(x.Buffer, x.Offset);
s.SendAsync(x);
proccessed += c.BytesExpected;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
case TcpPhase.WaitingTcpFrame:
TcpFramingHeader tcpHeader;
if (TcpFramingHeader.TryParse(e.Buffer, e.Offset, out tcpHeader) == false)
return false;
proccessed += c.BytesExpected;
c.Phase = (tcpHeader.Type == TcpFrameType.ControlMessage) ?
TcpPhase.WaitingTurnControlMessage : TcpPhase.WaitingTurnEndToEndData;
c.BytesExpected = tcpHeader.Length;
break;
case TcpPhase.WaitingTurnEndToEndData:
case TcpPhase.WaitingTurnControlMessage:
if (e.BytesTransferred - proccessed < c.BytesExpected)
if (c.Buffer.CopyTransferredFrom(e, proccessed + c.BytesExpected) == false)
return false;
e.Count -= proccessed;
e.Offset += proccessed;
e.BytesTransferred = c.BytesExpected;
if (c.Phase == TcpPhase.WaitingTurnEndToEndData)
TurnServer_PeerDataReceived(ref e);
else
TurnServer_TurnDataReceived(ref e);
proccessed = e.BytesTransferred;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
default:
throw new NotImplementedException();
}
}
}
else
throw new NotImplementedException();
return true;
}
private void ServersManager_Sent(ServersManager<Connection> s, ref ServerAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Tracer.WriteInformation("Send error");
switch (e.UserTokenForSending2 & 0x000000ff)
{
case SipModule:
SendErrorSip(e.UserTokenForSending);
break;
case HttpModule:
// e.UserTokenForSending2 >> 8 == httpModuleId
break;
case AjaxModule:
ajax.SendError(e.UserTokenForSending);
break;
}
}
}
private bool PeerServer_Received(ServersManager<PeerConnection> s, BaseConnection с, ref ServerAsyncEventArgs e)
{
//lock (syncRoot)
{
try
{
Allocation allocation = allocations.Get(e.LocalEndPoint);
if (allocation != null)
{
if (allocation.Permissions.IsPermited(e.RemoteEndPoint))
{
allocation.TouchLifetime();
if (allocation.ActiveDestination.IsEqual(e.RemoteEndPoint))
{
if (e.LocalEndPoint.Protocol == ServerProtocol.Tcp)
{
TcpFramingHeader.GetBytes(e.Buffer, e.Offset, TcpFrameType.EndToEndData, e.BytesTransferred);
e.Count = e.OffsetOffset + e.BytesTransferred;
e.OffsetOffset = 0;
}
else
{
e.Count = e.BytesTransferred;
}
e.LocalEndPoint = allocation.Local;
e.RemoteEndPoint = allocation.Reflexive;
e.ConnectionId = ServerAsyncEventArgs.AnyConnectionId;
turnServer.SendAsync(e);
e = null;
}
else
{
TurnMessage message = new TurnMessage()
{
IsAttributePaddingDisabled = true,
MessageType = MessageType.DataIndication,
TransactionId = TransactionServer.GenerateTransactionId(),
MagicCookie = new MagicCookie(),
RemoteAddress = new RemoteAddress()
{
IpAddress = e.RemoteEndPoint.Address,
Port = (UInt16)e.RemoteEndPoint.Port,
},
Data = new Data()
{
ValueRef = e.Buffer,
ValueRefOffset = e.Offset,
ValueRefLength = e.BytesTransferred,
},
};
SendTurn(message, allocation.Local, allocation.Reflexive);
}
}
}
}
catch (Exception ex)
{
logger.WriteWarning(ex.ToString());
}
}
return true;
}
static void ServersManager_EndConnection(ServersManager<BaseConnection2> s, BaseConnection e)
{
Interlocked.Increment(ref closedConnections);
}
public void Start()
{
//lock (syncRoot)
{
if (PublicIp == null)
throw new Exception("Invalid Public IP");
allocations = new AllocationsPool();
allocations.Removed += Allocation_Removed;
ServerAsyncEventArgs.DefaultOffsetOffset = TcpFramingHeader.TcpFramingHeaderLength;
turnServer = new ServersManager<TurnConnection>(new ServersManagerConfig());
turnServer.Bind(new ProtocolPort() { Protocol = ServerProtocol.Udp, Port = TurnUdpPort, });
turnServer.Bind(new ProtocolPort() { Protocol = ServerProtocol.Tcp, Port = TurnTcpPort, });
turnServer.Bind(new ProtocolPort() { Protocol = ServerProtocol.Tcp, Port = TurnPseudoTlsPort, });
turnServer.NewConnection += TurnServer_NewConnection;
turnServer.Received += TurnServer_Received;
turnServer.ServerAdded += TurnServer_ServerAdded;
turnServer.ServerRemoved += TurnServer_ServerRemoved;
turnServer.Start(true);
peerServer = new ServersManager<PeerConnection>(
new ServersManagerConfig()
{
MinPort = MinPort,
MaxPort = MaxPort,
});
peerServer.AddressPredicate = (i, ip, ai) => { return ai.Address.Equals(RealIp); };
peerServer.Received += PeerServer_Received;
peerServer.Start(true);
peerServer.ServerAdded += PeerServer_ServerAdded;
peerServer.ServerRemoved += PeerServer_ServerRemoved;
}
}
static void Main(string[] args)
{
int serverPort = 5070;
if (args.Length >= 1)
int.TryParse(args[0], out serverPort);
Console.WriteLine("Server Port: {0}", serverPort);
IPEndPoint real = null, fake = null;
if (args.Length >= 4)
{
int fakePort;
IPAddress realIp, fakeIp;
if (IPAddress.TryParse(args[1], out realIp) && IPAddress.TryParse(args[2], out fakeIp) &&
int.TryParse(args[3], out fakePort))
{
real = new IPEndPoint(realIp, serverPort);
fake = new IPEndPoint(fakeIp, fakePort);
Console.WriteLine("Fake and real IP parsed.");
Console.WriteLine("Real - Fake: {0} <=> {1}", real, fake);
}
}
Console.Write(@"Load certificate...");
var certificate = new X509Certificate2("SocketServers.pfx");
Console.WriteLine(@"Ok");
Console.Write(@"Initialize...");
int port = 6000;
IPAddress address = IPAddress.Parse(@"200.200.200.200");
var serversManager = new ServersManager<BaseConnection2>(new ServersManagerConfig() { /*TcpOffsetOffset = 256, */TlsCertificate = certificate, });
serversManager.FakeAddressAction =
(ServerEndPoint real1) =>
{
if (real != null && real.Equals(real1))
return fake;
return new IPEndPoint(address, port++);
};
serversManager.Bind(new ProtocolPort() { Protocol = ServerProtocol.Tcp, Port = serverPort, });
serversManager.Bind(new ProtocolPort() { Protocol = ServerProtocol.Udp, Port = serverPort, });
serversManager.Bind(new ProtocolPort() { Protocol = ServerProtocol.Tls, Port = serverPort + 1, });
serversManager.ServerAdded += ServersManager_ServerAdded;
serversManager.ServerRemoved += ServersManager_ServerRemoved;
serversManager.ServerInfo += ServersManager_ServerInfo;
serversManager.Received += ServersManager_Received;
serversManager.Sent += ServersManager_Sent;
serversManager.NewConnection += ServersManager_NewConnection;
serversManager.EndConnection += ServersManager_EndConnection;
//serversManager.Logger.Enable("test-log.pcap");
//for (int i = 0; i < 10; i++)
// serversManager.BuffersPool.Get();
Console.WriteLine(@"Ok");
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Starting...");
try
{
serversManager.Start(true);
Console.WriteLine(@"Started!");
}
catch (Exception ex)
{
Console.WriteLine(@"Failed to start");
Console.WriteLine(@"Error: {0}", ex.Message);
}
/////////////////////////////////////////////////////////////////////////
//CreateSomeGarbage(serversManager);
Console.WriteLine(@"Press any key to stop server...");
while (Console.KeyAvailable == false)
{
Console.Write("Connections: {0} - {1} = {2}\t\r", openedConnections, closedConnections, openedConnections - closedConnections);
Thread.Sleep(500);
}
Console.ReadKey(true);
Console.WriteLine();
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Stats:");
Console.WriteLine(@" Buffers Created : {0}", EventArgsManager.Created);
Console.WriteLine(@" Buffers Queued : {0}", EventArgsManager.Queued);
/////////////////////////////////////////////////////////////////////////
Console.WriteLine(@"Stoping...");
try
{
serversManager.Dispose();
Console.WriteLine(@"Stopped");
}
catch (Exception ex)
{
Console.WriteLine(@"Failed to stop");
Console.WriteLine(@"Error: {0}", ex.Message);
}
serversManager.ServerAdded -= ServersManager_ServerAdded;
serversManager.ServerInfo -= ServersManager_ServerInfo;
serversManager.ServerRemoved -= ServersManager_ServerRemoved;
serversManager.Received -= ServersManager_Received;
serversManager.Sent -= ServersManager_Sent;
serversManager.NewConnection -= ServersManager_NewConnection;
serversManager.EndConnection -= ServersManager_EndConnection;
/////////////////////////////////////////////////////////////////////////
//CreateSomeGarbage(serversManager);
for (int i = 0; i < 20; i++)
{
if (EventArgsManager.Created == EventArgsManager.Queued)
break;
Console.Write("\rWaiting for buffers: {0} seconds", i / 2);
Thread.Sleep(500);
}
Console.WriteLine();
if (EventArgsManager.Created != EventArgsManager.Queued)
{
Console.WriteLine(@"Lost buffers:");
Console.WriteLine(@" Buffers Created : {0}", EventArgsManager.Created);
Console.WriteLine(@" Buffers Queued : {0}", EventArgsManager.Queued);
Console.WriteLine(" GC for gen #0 {0}, #1 {1}, #2 {2}", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2));
Console.Write(@" Trying to garbage lost buffers...");
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
if (EventArgsManager.Created != EventArgsManager.Queued)
{
Console.WriteLine("Failed {0}", EventArgsManager.Created - EventArgsManager.Queued);
Console.WriteLine(" GC for gen #0 {0}, #1 {1}, #2 {2}", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2));
}
else
Console.WriteLine("Ok");
Console.ReadKey(true);
}
}
static void ServersManager_Sent(ServersManager<BaseConnection2> server, ref ServerAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
Console.WriteLine("Sent error: {0}", e.SocketError.ToString());
}
static bool ServersManager_Received(ServersManager<BaseConnection2> server, BaseConnection c, ref ServerAsyncEventArgs e)
{
e.Count = e.BytesTransferred;
server.SendAsync(e);
e = null;
return true;
}
static void ServersManager_NewConnection(ServersManager<BaseConnection2> s, BaseConnection e)
{
Interlocked.Increment(ref openedConnections);
}
private void ServersManager_EndConnection(ServersManager<Connection> s, Connection c)
{
Tracer.WriteInformation(string.Format(@"End Connection from {0}", c.RemoteEndPoint.ToString()));
}
public void Stop()
{
//lock (syncRoot)
{
if (allocations != null)
{
allocations.Clear();
allocations.Removed -= Allocation_Removed;
allocations = null;
}
if (turnServer != null)
{
turnServer.Dispose();
turnServer = null;
}
Authentificater = null;
}
}
private void TurnServer_NewConnection(ServersManager<TurnConnection> s, TurnConnection c)
{
c.Phase = TcpPhase.WaitingFirstXpacket;
c.BytesExpected = FirstXpacketLength;
}
public Initializer(EventHandler<EventArgs> configChangedHandler)
{
var configuration = SipServerConfigurationSection.GetSection();
var adUsers = (configuration.IsActiveDirectoryEnabled == false) ? null : new AdUsers(configuration.ActiveDirectoryGroup);
Func<Userz> CreateUserz = () =>
{
var result = new Userz(configuration.CustomUsersPath);
result.Add(new CsvUsers(configuration.UsersCsvFilePathName));
if (adUsers != null)
result.Add(adUsers);
result.LoadCustomUsers();
return result;
};
var serversManager = new ServersManager<Connection>(new ServersManagerConfig());
var transportLayer = new TransportLayer(serversManager, configuration.WebSocketResponseFrame);
var authorization = new SipAuthorizationManager();
var transactionLayer = new TransactionLayer(authorization);
var userz = CreateUserz();
var locationService = new LocationService();
var mras = new Mras.Mras1();
var trunkManager = new TrunkManager();
var accounts = new Accountx(configuration.AccountConfigFilePathName);
var msPresTu = new MsPresTU(accounts, userz, locationService);
var wcfService = new WCFService(configuration, msPresTu.EnhancedPresence, trunkManager, accounts, userz);
var httpAuthorization = new HttpAuthorizationManager();
var httpServer = new HttpServer(httpAuthorization, configuration.AdminUri);
//var httpServerAgentRegistrar = new Func<IHttpServerAgent, IHttpServer>((agent) => { return httpServer.Register(agent); });
var restapi = new RestapiService(accounts, userz) { AdministratorPassword = configuration.AdministratorPassword, };
var httpFileServer = new HttpFileServer(configuration.WwwPath, string.Empty);
var xcapServer = new XcapServer();
var configurationMonitor = new ConfigurationMonitor();
var simpleModule = new SimpleModule(EqualityComparer<string>.Default);
var proxyServerTU = new ProxyServerTU(locationService, trunkManager, accounts);
GetResults = (
out TransportLayer transportLayer1,
out TransactionLayer transactionLayer1,
out LocationService locationService1,
out WCFService wcfService1,
out ConfigurationMonitor configurationMonitor1,
out TrunkManager trunkManager1,
out SipAuthorizationManager authorization1,
out Userz userz1,
out AdUsers adUsers1,
out Mras.Mras1 mras1,
out HttpFileServer httpFileServer1,
out Accountx accounts1,
out RestapiService restapi1,
out ProxyServerTU proxyServerTU1
) =>
{
transportLayer1 = transportLayer;
transactionLayer1 = transactionLayer;
locationService1 = locationService;
wcfService1 = wcfService;
configurationMonitor1 = configurationMonitor;
trunkManager1 = trunkManager;
authorization1 = authorization;
userz1 = userz;
adUsers1 = adUsers;
mras1 = mras;
httpFileServer1 = httpFileServer;
accounts1 = accounts;
restapi1 = restapi;
proxyServerTU1 = proxyServerTU;
};
Action InitializeTracer = () =>
{
Tracer.Initialize(serversManager.Logger);
Tracer.Configure(configuration.TracingPath, configuration.IsTracingEnabled);
};
Action InitializeConfigurationMonitor = () =>
{
configurationMonitor.Changed += configChangedHandler;
configurationMonitor.StartMonitoring(configuration);
};
Action InitializeHttpModules = () =>
{
httpServer.SendAsync = transportLayer.SendAsyncHttp;
transportLayer.IncomingHttpRequest = httpServer.ProcessIncomingRequest;
httpServer.Register(restapi, 0, true);
httpServer.Register(xcapServer, 0, true);
httpServer.Register(new HttpFileServer(configuration.WwwAdminPath, configuration.AdminUri), 254, true);
httpServer.Register(httpFileServer, 255, true);
xcapServer.AddHandler(new ResourceListsHandler(accounts, userz));
xcapServer.AddHandler(new PidfManipulationHandler(simpleModule));
};
Action InitializeWcfService = () =>
{
wcfService.Start();
};
Action InitializeProxyServerTU = () =>
{
proxyServerTU.IsOfficeSIPFiletransferEnabled = configuration.IsOfficeSIPFiletransferEnabled;
};
Action InitializeTransactionLayer = () =>
{
InitializeProxyServerTU();
transportLayer.IncomingMessage += transactionLayer.IncomingMessage;
transportLayer.SendErrorSip += transactionLayer.TransportError;
transactionLayer.SendAsync = transportLayer.SendAsyncSip;
transactionLayer.IsLocalAddress = transportLayer.IsLocalAddress;
serversManager.EndConnection += (s, c) => { locationService.RemoveBindingsWhenConnectionEnd(c.Id); };
transactionLayer.RegisterTransactionUser(new RegistrarTU(locationService, accounts));
transactionLayer.RegisterTransactionUser(msPresTu);
transactionLayer.RegisterTransactionUser(new SimpleTU(simpleModule));
transactionLayer.RegisterTransactionUser(new OptionsTU());
transactionLayer.RegisterTransactionUser(new MessageSummaryTU());
transactionLayer.RegisterTransactionUser(new MrasTU(mras));
transactionLayer.RegisterTransactionUser(new DirectorySearchTU(accounts, new ServiceSoap.ServiceSoap1(), userz));
transactionLayer.RegisterTransactionUser(proxyServerTU);
transactionLayer.RegisterTransactionUser(new TrunkTU(trunkManager));
transactionLayer.RegisterTransactionUser(new ErrorTU());
};
Action InitializeAuthorization = () =>
{
authorization.IsEnabled = configuration.IsAuthorizationEnabled;
if (configuration.IsActiveDirectoryEnabled)
{
var kerberosAuth = new SipMicrosoftAuthentication(SipAuthSchemes.Kerberos, accounts, userz);
var ntlmAuth = new SipMicrosoftAuthentication(SipAuthSchemes.Ntlm, accounts, userz);
authorization.RegisterAgent(kerberosAuth, SipAuthSchemes.Kerberos);
authorization.RegisterAgent(ntlmAuth, SipAuthSchemes.Ntlm);
}
var digestAuth = new SipDigestAuthentication(accounts, userz, configuration.IsAuthIntEnabled);
authorization.RegisterAgent(digestAuth, SipAuthSchemes.Digest);
httpAuthorization.IsEnabled = configuration.IsAuthorizationEnabled;
httpAuthorization.RegisterAgent(new HttpDigestAuthentication(accounts, userz, false), HttpAuthSchemes.Digest);
};
Action InitializeServersManager = () =>
{
serversManager.FakeAddressAction = (ServerEndPoint localEndpoint) =>
{
foreach (var portForwarding in configuration.PortForwardings)
{
if (localEndpoint.Equals(portForwarding.Protocol, portForwarding.LocalEndpoint))
return portForwarding.ExternalEndpoint;
}
return null;
};
Action<ServerProtocol, int> bind = (protocol, port) =>
{
if (port > 0)
{
var error = serversManager.Bind(new ProtocolPort()
{
Protocol = protocol,
Port = port,
});
if (error != SocketError.Success)
Tracer.WriteError("Can't open " + protocol + " port " + port + ".\r\n" + error.ToString());
}
};
if (configuration.UdpPort > 0)
bind(ServerProtocol.Udp, configuration.UdpPort);
if (configuration.TcpPort > 0)
bind(ServerProtocol.Tcp, configuration.TcpPort);
if (configuration.TcpPort2 > 0)
bind(ServerProtocol.Tcp, configuration.TcpPort2);
};
ConfigureMras(mras, configuration);
InitializeConfigurationMonitor();
InitializeTracer();
InitializeTransactionLayer();
InitializeAuthorization();
InitializeWcfService();
InitializeHttpModules();
InitializeServersManager();
}
