private void ReplaceDstHostWithThisHost()
{
string hostRequestHeaderValue = protocolMachine.RequestMessage.HeaderList.Host;
if (hostRequestHeaderValue != null)
{
var thisListener = new ConnectionTarget();
thisListener.Parse(hostRequestHeaderValue, sourceConnectionType);
var x = Destination.ToString();
var y = thisListener.ToString();
var bx = protocolMachine.ResponseMessage.Encoding.GetBytes(x);
var by = protocolMachine.ResponseMessage.Encoding.GetBytes(y);
if (protocolMachine.ResponseMessage.MessageBody.Contains(bx))
{
View.PutLine("{0}: Rewrite: {1} ===> {2}", Name, x, y);
protocolMachine.ResponseMessage.MessageBody.Replace(bx, by);
}
bx = protocolMachine.ResponseMessage.Encoding.GetBytes(Destination.Hostname);
by = protocolMachine.ResponseMessage.Encoding.GetBytes(thisListener.Hostname);
if (protocolMachine.ResponseMessage.MessageBody.Contains(bx))
{
View.PutLine("{0}: Rewrite: {1} ===> {2}", Name, Destination.Hostname, thisListener.Hostname);
protocolMachine.ResponseMessage.MessageBody.Replace(bx, by);
}
}
}
public static void Connect(ConnectionTarget endpoint, string password, Action onConnect, Action onAbort)
{
Game.JoinServer(endpoint, password);
Action <string> onRetry = newPassword => Connect(endpoint, newPassword, onConnect, onAbort);
Ui.OpenWindow("CONNECTING_PANEL", new WidgetArgs()
{
{ "endpoint", endpoint },
{ "onConnect", onConnect },
{ "onAbort", onAbort },
{ "onRetry", onRetry }
});
}
public static OrderManager JoinServer(ConnectionTarget endpoint, string password, bool recordReplay = true)
{
var connection = new NetworkConnection(endpoint);
if (recordReplay)
{
connection.StartRecording(() => { return(TimestampedFilename()); });
}
var om = new OrderManager(endpoint, password, connection);
JoinInner(om);
return(om);
}
public ConnectionLogic(Widget widget, ConnectionTarget endpoint, Action onConnect, Action onAbort, Action <string> onRetry)
{
this.onConnect = onConnect;
this.onAbort = onAbort;
this.onRetry = onRetry;
Game.ConnectionStateChanged += ConnectionStateChanged;
var panel = widget;
panel.Get <ButtonWidget>("ABORT_BUTTON").OnClick = () => { CloseWindow(); onAbort(); };
widget.Get <LabelWidget>("CONNECTING_DESC").GetText = () => $"Connecting to {endpoint}...";
}
void Update()
{
// Sends virtual keyboards strokes to the TextMeshes for the IP address and the port.
AbsorbInput();
if (Input.GetKeyDown(KeyCode.Tab))
{
if (ConnectionTarget == ConnectionTarget.Controller)
{
ConnectionTarget = ConnectionTarget.Kinect;
}
else
{
ConnectionTarget = ConnectionTarget.Controller;
}
}
}
public DirectConnectLogic(Widget widget, Action onExit, Action openLobby, ConnectionTarget directConnectEndPoint)
{
var panel = widget;
var ipField = panel.Get <TextFieldWidget>("IP");
var portField = panel.Get <TextFieldWidget>("PORT");
var text = Game.Settings.Player.LastServer;
var last = text.LastIndexOf(':');
if (last < 0)
{
ipField.Text = "localhost";
portField.Text = "1234";
}
else
{
ipField.Text = text.Substring(0, last);
portField.Text = text.Substring(last + 1);
}
panel.Get <ButtonWidget>("JOIN_BUTTON").OnClick = () =>
{
var port = Exts.WithDefault(1234, () => Exts.ParseIntegerInvariant(portField.Text));
Game.Settings.Player.LastServer = "{0}:{1}".F(ipField.Text, port);
Game.Settings.Save();
ConnectionLogic.Connect(new ConnectionTarget(ipField.Text, port), "", () => { Ui.CloseWindow(); openLobby(); }, DoNothing);
};
panel.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => { Ui.CloseWindow(); onExit(); };
if (directConnectEndPoint != null)
{
// The connection window must be opened at the end of the tick for the widget hierarchy to
// work out, but we also want to prevent the server browser from flashing visible for one tick.
widget.Visible = false;
Game.RunAfterTick(() =>
{
ConnectionLogic.Connect(directConnectEndPoint, "", () => { Ui.CloseWindow(); openLobby(); }, DoNothing);
widget.Visible = true;
});
}
}
public static OrderManager JoinServer(ConnectionTarget endpoint, string password, bool recordReplay = true)
{
var newConnection = new NetworkConnection(endpoint);
if (recordReplay)
{
newConnection.StartRecording(() => { return(TimestampedFilename()); });
}
var om = new OrderManager(newConnection);
JoinInner(om);
CurrentServerSettings.Password = password;
CurrentServerSettings.Target = endpoint;
lastConnectionState = ConnectionState.PreConnecting;
ConnectionStateChanged(OrderManager, password, newConnection);
return(om);
}
public static string ConnectionString(ConnectionTarget target)
{
string connectionString;
switch (target)
{
case ConnectionTarget.Services:
connectionString = WebConfigurationManager.ConnectionStrings["csServices"].ConnectionString;
break;
case ConnectionTarget.App:
connectionString = WebConfigurationManager.ConnectionStrings["csApp"].ConnectionString;
break;
default:
connectionString = null;
break;
}
return(connectionString);
}
public static DataTable ExecuteSelectQuery(string query, Dictionary <string, object> parameters, ConnectionTarget target)
{
DataTable result = new DataTable();
QueryValidation(query);
var parametersList = CreateParametersList(parameters);
ParametersValidation(parametersList);
try
{
using (SqlConnection connection = new SqlConnection(ConnectionString(target)))
using (SqlCommand command = new SqlCommand(query, connection))
using (SqlDataAdapter adapter = new SqlDataAdapter(command))
{
if (parametersList != null)
{
command.Parameters.AddRange(parametersList.ToArray());
}
connection.Open();
adapter.Fill(result);
command.Parameters.Clear();
connection.Close();
}
}
catch (Exception ex)
{
throw;
}
return(result);
}
public MultiplayerLogic(Widget widget, ModData modData, Action onStart, Action onExit, ConnectionTarget directConnectEndPoint)
{
// MultiplayerLogic is a superset of the ServerListLogic
// but cannot be a direct subclass because it needs to pass object-level state to the constructor
serverListLogic = new ServerListLogic(widget, modData, Join);
this.onStart = onStart;
this.onExit = onExit;
var directConnectButton = widget.Get <ButtonWidget>("DIRECTCONNECT_BUTTON");
directConnectButton.OnClick = () =>
{
Ui.OpenWindow("DIRECTCONNECT_PANEL", new WidgetArgs
{
{ "openLobby", OpenLobby },
{ "onExit", DoNothing },
{ "directConnectEndPoint", null },
});
};
var createServerButton = widget.Get <ButtonWidget>("CREATE_BUTTON");
createServerButton.OnClick = () =>
{
Ui.OpenWindow("MULTIPLAYER_CREATESERVER_PANEL", new WidgetArgs
{
{ "openLobby", OpenLobby },
{ "onExit", DoNothing }
});
};
var hasMaps = modData.MapCache.Any(p => !p.Visibility.HasFlag(MapVisibility.Shellmap));
createServerButton.Disabled = !hasMaps;
widget.Get <ButtonWidget>("BACK_BUTTON").OnClick = () => { Ui.CloseWindow(); onExit(); };
if (directConnectEndPoint != null)
{
// The connection window must be opened at the end of the tick for the widget hierarchy to
// work out, but we also want to prevent the server browser from flashing visible for one tick.
widget.Visible = false;
Game.RunAfterTick(() =>
{
Ui.OpenWindow("DIRECTCONNECT_PANEL", new WidgetArgs
{
{ "openLobby", OpenLobby },
{ "onExit", DoNothing },
{ "directConnectEndPoint", directConnectEndPoint },
});
widget.Visible = true;
});
}
}
void Awake()
{
ConnectionTarget = ConnectionTarget.Controller;
}
public OuterClientBase(string name, ConnectionTarget target)
{
Name = name;
Target = target;
}
public void Run(string[] args)
{
if (args.Length == 0)
{
Help();
return;
}
var e = args.GetEnumerator();
while (e.MoveNext())
{
var a = ((string)e.Current).ToLowerInvariant();
if (a == "-help" || a == "-h" || a == "-?")
{
Help();
return;
}
else if (a == "-output" || a == "-out")
{
if (e.MoveNext())
{
ViewFactory.Builder.SetPath((string)e.Current);
View = ViewFactory.CreateView();
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-target")
{
if (e.MoveNext())
{
target = new ConnectionTarget();
if (!target.Parse((string)e.Current))
{
throw new Exception(BAD_TARGET);
}
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-address" || a == "-addr")
{
if (e.MoveNext())
{
if (target == null)
{
throw new Exception(NO_TARGET);
}
target.Address = (string)e.Current;
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-port")
{
if (e.MoveNext())
{
nonSecurePort = int.Parse((string)e.Current);
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
if (nonSecurePort <= 0 || 65536 <= nonSecurePort)
{
throw new Exception(BAD_NPORT);
}
}
else if (a == "-secureport" || a == "-secport")
{
if (e.MoveNext())
{
securePort = int.Parse((string)e.Current);
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
if (securePort <= 0 || 65536 <= securePort)
{
throw new Exception(BAD_SPORT);
}
}
else if (a == "-certpath")
{
if (e.MoveNext())
{
certificatePath = (string)e.Current;
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-certpassword" || a == "-certpasswd" || a == "-certpass")
{
if (e.MoveNext())
{
certificatePassword = (string)e.Current;
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-shutdown")
{
commandRequest = "shutdown";
}
else if (a == "-commandtarget" || a == "-cmdtarget")
{
if (e.MoveNext())
{
commandTarget = (string)e.Current;
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
var ss = commandTarget.Split(new char[] { ':' });
if (ss.Length == 2)
{
commandTarget = ss[0];
commandPort = int.Parse(ss[1]);
}
else if (ss.Length != 1)
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
else if (a == "-commandport" || a == "-cmdport")
{
if (e.MoveNext())
{
commandPort = int.Parse((string)e.Current);
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
#if DEBUG
else if (a == "-debug")
{
System.Diagnostics.Debugger.Launch();
}
#endif
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
if (target != null)
{
if (nonSecurePort == 0 && target.Type == ConnectionType.Raw)
{
nonSecurePort = HttpConstants.HTTP_PORT;
}
if (nonSecurePort > 0)
{
var nonSecureListener = new NonSecureListener()
{
Destination = target,
Port = nonSecurePort
};
ListenerList.Add(nonSecureListener);
}
if ((certificatePath != null && certificatePassword == null) || (certificatePath == null && certificatePassword != null))
{
throw new Exception(CERTIFICATE_PATH_AND_PASSWORD);
}
if (securePort == 0 && (target.Type == ConnectionType.Encrypted || certificatePath != null))
{
securePort = HttpConstants.HTTPS_PORT;
}
if (securePort > 0)
{
if (certificatePath == null || certificatePassword == null)
{
throw new Exception(CERTIFICATE_PATH_AND_PASSWORD);
}
var secureListener = new SecureListener()
{
Destination = target,
Port = securePort,
ServerCertificatePath = certificatePath,
ServerCertificatePassword = certificatePassword
};
ListenerList.Add(secureListener);
}
}
if (ListenerList.Count > 0)
{
if (commandRequest != null)
{
throw new Exception(EXCLUSIVE_REQUESTS);
}
var commandListener = new CommandListener()
{
Port = commandPort,
OnShutdown = ShutDown
};
ListenerList.Add(commandListener);
foreach (var listener in ListenerList)
{
listener.Start();
}
TerminateEvent.WaitOne();
foreach (var listener in ListenerList)
{
listener.Stop();
}
foreach (var listener in ListenerList)
{
listener.Wait();
}
}
else if (commandRequest != null)
{
var commandClient = new CommandClient()
{
Hostname = commandTarget,
Port = commandPort
};
commandClient.Send(commandRequest);
}
else
{
throw new Exception(BAD_COMMAND_LINE_SYNTAX);
}
}
public static int ExecuteNonQuery(string query, Dictionary <string, object> parameters, ConnectionTarget target)
{
int rowsAffected;
QueryValidation(query);
var parametersList = CreateParametersList(parameters);
ParametersValidation(parametersList);
try
{
using (SqlConnection connection = new SqlConnection(ConnectionString(target)))
using (SqlCommand command = new SqlCommand(query, connection))
{
if (parametersList != null)
{
command.Parameters.AddRange(parametersList.ToArray());
}
connection.Open();
rowsAffected = command.ExecuteNonQuery();
command.Parameters.Clear();
connection.Close();
}
}
catch (Exception ex)
{
throw;
}
return(rowsAffected);
}
public static int ExecuteNonQuery(string query, ConnectionTarget target) => ExecuteNonQuery(query, null, target);
public static int?ExecuteIdentityQuery(string query, Dictionary <string, object> parameters, ConnectionTarget target)
{
int?scopeIdentity = null;
QueryValidation(query);
var parametersList = CreateParametersList(parameters);
ParametersValidation(parametersList);
query = query + Environment.NewLine + "SELECT SCOPE_IDENTITY();";
try
{
using (SqlConnection connection = new SqlConnection(ConnectionString(target)))
using (SqlCommand command = new SqlCommand(query, connection))
{
if (parametersList != null)
{
command.Parameters.AddRange(parametersList.ToArray());
}
connection.Open();
scopeIdentity = Utils.ConvertToNullableInt(command.ExecuteScalar());
command.Parameters.Clear();
connection.Close();
}
}
catch (Exception ex)
{
throw;
}
return(scopeIdentity);
}
public static int?ExecuteIdentityQuery(string query, ConnectionTarget target) => ExecuteIdentityQuery(query, null, target);
public static void RemoteDirectConnect(ConnectionTarget endpoint)
{
OnRemoteDirectConnect(endpoint);
}
public static DataTable ExecuteSelectQuery(string query, ConnectionTarget target) => ExecuteSelectQuery(query, null, target);
public static object ExecuteScalarSelectQuery(string query, ConnectionTarget target) => ExecuteScalarSelectQuery(query, null, target);
void Awake()
{
ConnectionTarget = ConnectionTarget.Kinect;
}
public NonSecureOuterClient(int serialNumber, ConnectionTarget target)
: base(string.Format("{0}/NonSecureOuterClient", serialNumber), target)
{
}
