private void SaveLog(SeverityLevel level, string text)
{
_connection = ConnectionInstance.Instance.GetConnection(_loggerConnectionString);
text = text.Replace("'", "''");
text = text.Replace("\"", "\\\"");
var command = new OdbcCommand($"INSERT INTO `Log` (`Level`, `Message`, `Timestamp`) VALUES('{LevelNames[level]}', '{text}', '{DateTime.Now}')")
{
Connection = _connection
};
try
{
if (_connection.State == ConnectionState.Closed)
{
_connection.Open();
if (_connection.State == ConnectionState.Open)
{
command.ExecuteNonQuery();
}
}
}
finally
{
ConnectionInstance.CloseConnection(_loggerConnectionString);
}
}
/// <summary>
/// 执行命令
/// </summary>
public override void ExecuteCommand()
{
try
{
CommandInstance.CommandText = SqlCommandText;
CommandInstance.Connection = ConnectionInstance;
ConnectionInstance.Open();
if (SqlParametersInstance != null && SqlParametersInstance.Count > 0)
{
foreach (SqlParameter parameter in SqlParametersInstance)
{
SqlParameter copyParameter = (SqlParameter)((ICloneable)parameter).Clone();
CommandInstance.Parameters.Add(copyParameter);
}
}
SqlDataOperationRecord = CommandInstance.ExecuteNonQuery();
ConnectionInstance.Close();
}
catch (Exception exception)
{
base.SettingOperattionMessage(exception.Message);
}
SettingCommandText(string.Empty);
CommandInstance.Parameters.Clear();
SqlParametersInstance.Clear();
}
public static void PurgeLog()
{
var _connection = ConnectionInstance.Instance.GetConnection($"DSN={DsnName}");
var command = new OdbcCommand($"DELETE * FROM `{LogTable}` WHERE `Timestamp` < {DeadDate.ToOADate()}")
{
Connection = _connection
};
_connection.Open();
try
{
int affectedRows = command.ExecuteNonQuery();
if (affectedRows > 0)
{
Logger.Instance.Debug($"Purged {affectedRows} log entries that had timestamps before {DeadDate}.");
}
}
catch (OdbcException e)
{
Logger.Instance.Error($"An error occured while purging log entries with timestamps before {DeadDate}: {e.Message}");
}
finally
{
ConnectionInstance.CloseConnection($"DSN={DsnName}");
}
}
/// <summary>
/// 数据读取器
/// </summary>
/// <returns></returns>
public override DbDataReader ExecuteReader()
{
try
{
CommandInstance.CommandText = SqlCommandText;
CommandInstance.Connection = ConnectionInstance;
ConnectionInstance.Open();
if (SqlParametersInstance != null)
{
if (SqlParametersInstance.Count > 0)
{
CommandInstance.Parameters.AddRange(SqlParametersInstance.ToArray());
}
}
this.reader = CommandInstance.ExecuteReader();
ConnectionInstance.Close();
}
catch (Exception ex)
{
base.SettingOperattionMessage(ex.Message);
}
SettingCommandText(string.Empty);
CommandInstance.Parameters.Clear();
SqlParametersInstance.Clear();
return(this.reader);
}
public void StopConnect()
{
if (ConnectionInstance != null)
{
ConnectionInstance.Disconnect();
ConnectionInstance = null;
}
StopHeartbeat();
Thread.Sleep(200);
}
private void SendHeartBeatThread(object sender)
{
if (Connected)
{
//IsMaster = ConnectionInstance.IsMaster();
if (!ConnectionInstance.SendHeartBeat())
{
LOG.Error(string.Format("心跳检测错误"));
//连接错误
ServerEventArg arg = new ServerEventArg("Unknown", ServerEventType.Disconnected);
OnConnectFaultHander?.BeginInvoke(arg, null, null);
}
}
}
/// <summary>
/// Creates a new instance of UdpProxy
/// </summary>
/// <param name="localPort">The local port number to open for the proxy
/// (remote port is set later as it is unknown until just before connection)</param>
/// <param name="remoteHost">The remote host to route the incoming data to</param>
/// <param name="displayHost">The remote host dns for user display</param>
public UdpProxy(int localPort, string remoteHost, string displayHost)
{
LocalPort = localPort;
RemoteHost = remoteHost;
// Reserve the port so we don't need to pick new ports later
m_listener = new UdpClient(new IPEndPoint(IPAddress.Loopback, localPort));
var udpGrouping = ComponentEngine.Instance.GetComponent <TcpComponent>().udpGroup;
m_connectionInstance = new ConnectionInstance
{
HostName = displayHost,
Id = Guid.NewGuid(),
Parent = udpGrouping,
};
}
public DataTable LoadLog()
{
var _connection = ConnectionInstance.Instance.GetConnection($"DSN={DsnName}");
string query = $"SELECT `Timestamp`, `Level`, `Message` FROM `{LogTable}` WHERE `Level` NOT LIKE 'DEBUG' ORDER BY `Timestamp` DESC";
if (Settings.DebugMode)
{
query = $"SELECT `Timestamp`, `Level`, `Message` FROM `{LogTable}` ORDER BY `Timestamp` DESC";
}
_connection.Open();
OdbcDataAdapter adapter = new OdbcDataAdapter(query, _connection);
DataTable table = new DataTable();
try
{
adapter.Fill(table);
table.DefaultView.AllowDelete = false;
table.DefaultView.AllowEdit = false;
table.DefaultView.AllowNew = false;
return(table);
}
catch (Exception e)
{
Logger.Instance.Error($"An error occured while retrieving the log: {e.Message}");
}
finally
{
ConnectionInstance.CloseConnection($"DSN={DsnName}");
}
var mapping = new Mapping();
List <string> logColumns = mapping.GetColumns(LogTable, DsnName);
DataTable logTable = new DataTable();
foreach (string logColumn in logColumns)
{
logTable.Columns.Add(logColumn);
}
logTable.DefaultView.AllowDelete = false;
logTable.DefaultView.AllowEdit = false;
logTable.DefaultView.AllowNew = false;
return(logTable);
}
public SslMitmInstance(Stream client, Stream server, ConnectionInstance connectionInstance, int chunkSize = 4096)
{
ProxyManagerWindow.Instance.Dispatcher.BeginInvoke(new Action(() =>
{
((ManagerWindowViewModel)ProxyManagerWindow.Instance.DataContext).RefreshConversations();
}));
m_connectionInstance = connectionInstance;
connectionInstance.SslMitmInstance = this;
m_client = client;
m_server = server;
OnFrameIn += WsEventHander.Instance.OnFrameIn;
ForwardStreamNew(client, server, new byte[chunkSize], CommPacketDirection.ClientToServer);
ForwardStreamNew(server, client, new byte[chunkSize], CommPacketDirection.ServerToClient);
Dispatcher(CommPacketDirection.ServerToClient);
Dispatcher(CommPacketDirection.ClientToServer);
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisCacheManager"/> class.
/// </summary>
public RedisCacheManager()
{
_cache = ConnectionInstance.GetDatabase();
_protector = new MachineKeyDataProtector(new[] { typeof(RedisCacheManager).FullName });
}
private void OnBeginAcceptTcpClient(IAsyncResult ar)
{
TcpClient clientConnection;
try
{
clientConnection = m_listener.EndAcceptTcpClient(ar);
}
catch
{
Kill();
return;
}
m_listener.BeginAcceptTcpClient(OnBeginAcceptTcpClient, ar.AsyncState);
string remoteHost = null;
try
{
// SSL the client
var clientStream = clientConnection.GetStream();
var inputSplitStream = new SplitStream.SplitStream(clientStream);
var splitStream1 = inputSplitStream.GetReader();
splitStream1.IsMaster = true;
var splitStream2 = inputSplitStream.GetReader();
inputSplitStream.StartReadAhead();
StringBuilder sb = new StringBuilder();
int byt;
byte[] buffer = new byte[1024];
remoteHost = null;
while (true)
{
if ((byt = splitStream2.ReadByte()) == -1)
{
break;
}
sb.Append((char)byt);
int av = 0;
while ((av = splitStream2.GetBufferAvailable()) > 0)
{
splitStream2.Read(buffer, 0, Math.Min(buffer.Length, av));
sb.Append(Encoding.UTF8.GetString(buffer, 0, av));
}
var sbstring = sb.ToString();
Match q = s_hostreg.Match(sbstring);
if (q.Success)
{
remoteHost = q.Groups[0].Value;
break;
}
}
inputSplitStream.TerminateReader(splitStream2);
splitStream2.Dispose();
var clientSecureStream = new SslStream(splitStream1, false);
clientSecureStream.AuthenticateAsServer(m_certificates.Where(cur => remoteHost.EndsWith(cur.Key)).First().Value);
// Connect to server
var serverConnection = new TcpClient(m_hostLookup[remoteHost], m_port);
// SSL the server
var serverStream = serverConnection.GetStream();
var serverSecureStream = new SslStream(serverStream, false, (a, b, c, d) => true);
serverSecureStream.AuthenticateAsClient(remoteHost);
ProxyManagerWindow.Instance.Dispatcher.BeginInvoke(new Action(() =>
{
var connectionGrouping = ComponentEngine.Instance.GetComponent <TcpComponent>().GetGrouping(remoteHost, m_port);
ConnectionInstance instanceModel = new ConnectionInstance()
{
HostName = remoteHost,
Id = Guid.NewGuid(),
Parent = connectionGrouping,
};
SslMitmInstance instance = new SslMitmInstance(clientSecureStream, serverSecureStream, instanceModel)
{
ReplaceIpaddr = m_replaceIpaddr,
};
connectionGrouping.Instances.Add(instanceModel);
}));
}
catch (Exception)
{
//MainWindow.Instance.Dispatcher.Invoke(new Action(() =>
//{
// MessageBox.Show($"5 Fatal error (did you prep?) ({remoteHost ?? "nohost"}): {ex.Message}");
//}));
}
}
public void StartConnect()
{
if (Connected)
{
return;
}
// 创建
switch (HostType)
{
case HostConnectionType.Machine:
ConnectionInstance = MachineProxy.Create(RemoteHostAddress);
break;
case HostConnectionType.Process:
ConnectionInstance = ProcessProxy.Create(RemoteHostAddress);
break;
case HostConnectionType.Resource:
ConnectionInstance = ResourceProxy.Create(RemoteHostAddress);
break;
case HostConnectionType.Partner:
ConnectionInstance = PartnerProxy.Create(RemoteHostAddress);
break;
case HostConnectionType.Admin:
ConnectionInstance = AdminProxy.Create(RemoteHostAddress);
break;
default:
throw new NotSupportedException();
}
// 连接
ConnectionInstance?.Connect();
if (Connected)
{
//连接事件
ServerEventArg arg = new ServerEventArg("Unknown", ServerEventType.Connected);
LOG.Info($"启动{HostType.ToString()}对方端口{RemoteHostAddress}成功");
OnConnectedHander?.BeginInvoke(arg, null, null);
//启动心跳
//StartHeartbeat();
}
else
{
//连接失败
ServerEventArg arg = new ServerEventArg("Unknown", ServerEventType.Fault);
LOG.Debug($"启动{HostType.ToString()}对方端口{RemoteHostAddress}失败");
OnConnectFaultHander?.BeginInvoke(arg, null, null);
ConnectionInstance = null;
}
}
