public void Register(string appId, string portName)
{
_remotePort = new RemotePort(appId, portName, false);
_localPort.MessageReceived += OnMessageReceived;
_localPort.Listen();
Log.Debug("Register...");
}
/// <summary>
/// Sends a message over message port.
/// </summary>
/// <param name="message">The message to send. The recommended message size is under 4KB.</param>
/// <param name="remotePort">The remote port to which a message is sent</param>
/// <remarks>
/// Before calling this function, you must call Open().
/// In addition, you can check if a remote port is running by RemotePort.IsRunning() and RemotePort.RemotePortStateChanged event.
/// For more details, see https://docs.tizen.org/application/dotnet/guides/app-management/message-port/#managing-a-remote-port.
/// </remarks>
/// <exception cref="ArgumentNullException">The passed arguments is null but should never be null.</exception>
public void Send(Bundle message, RemotePort remotePort)
{
if (remotePort == null)
{
throw new ArgumentNullException(nameof(remotePort));
}
Send(message, remotePort.AppId, remotePort.PortName);
}
private void ParameterSaveCommandExecute()
{
Inifile.INIWriteValue(iniParameterPath, "System", "RemotePath", RemotePath);
Inifile.INIWriteValue(iniParameterPath, "System", "MachineID", MachineID);
Inifile.INIWriteValue(iniParameterPath, "Remote", "IP", RemoteIP);
Inifile.INIWriteValue(iniParameterPath, "Remote", "PORT", RemotePort.ToString());
Inifile.INIWriteValue(iniParameterPath, "Local", "IP", LocalIP);
Inifile.INIWriteValue(iniParameterPath, "Local", "PORT", LocalPort.ToString());
AddMessage("保存参数");
}
public ICommunicationMessage SendCommand(ICommunicationMessage command, int timeout)
{
// TODO: 添加 Communicator.sendCommand 实现
command.SeqID = CommandProcessor.AllocateID();
try
{
ICommunicationMessage response = null;
ManualResetEvent mutex = new ManualResetEvent(false);
lock (this)
{
if (Interlocked.Read(ref m_Started) == 0)
{
throw new Exception("与服务器的连接未建立.");
}
lock (this.m_MessagesWaitForResponse)
{
m_MessagesWaitForResponse[command.SeqID] = new CommonPair <ICommunicationMessage, ManualResetEvent>(null, mutex);
}
m_Comm.enqueueMessage(command);
}
// 等待响应包的回填
if (!mutex.WaitOne(timeout * 1000, false))
{
throw new Exception(RemoteIP + ":" + RemotePort.ToString() + "服务器通讯超时");
}
if (Interlocked.Read(ref m_Started) == 0)
{
throw new Exception(RemoteIP + ":" + RemotePort.ToString() + "服务器通讯中断");
}
lock (m_MessagesWaitForResponse)
{
response = m_MessagesWaitForResponse[command.SeqID].First;
m_MessagesWaitForResponse.Remove(command.SeqID);
}
return(response);
}
catch (Exception ex)
{
throw ex;
}
finally
{
lock (m_MessagesWaitForResponse)
{
m_MessagesWaitForResponse.Remove(command.SeqID);
}
}
}
public Boolean OptionalEquals(HTTPSNotification other)
=> Method.Equals(other.Method) &&
URL.Equals(other.URL) &&
RemotePort.Equals(other.RemotePort) &&
String.Equals(BasicAuth_Login, other.BasicAuth_Login) &&
String.Equals(BasicAuth_Password, other.BasicAuth_Password) &&
String.Equals(APIKey, other.APIKey) &&
String.Equals(Description, other.Description) &&
_NotificationMessageTypes.SetEquals(other._NotificationMessageTypes);
public Int32 CompareTo(HTTPSNotification other)
{
var c = URL.CompareTo(other.URL);
if (c != 0)
{
return(c);
}
c = RemotePort.CompareTo(other.RemotePort);
if (c != 0)
{
return(c);
}
return(Method.CompareTo(other.Method));
}
private void FormRemoteVnc_Load(object sender, EventArgs e)
{
this.textBoxDisplayName.Text = DisplayName;
this.textBoxRemoteIp.Text = RemoteIp;
this.textBoxRemotePort.Text = RemotePort.ToString();
this.textBoxDisplayName.TextChanged += textBoxDisplayName_TextChanged;
this.textBoxRemoteIp.TextChanged += textBoxRemoteIp_TextChanged;
this.textBoxRemotePort.TextChanged += textBoxRemotePort_TextChanged;
buttonOK.DialogResult = System.Windows.Forms.DialogResult.OK;
buttonCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
this.AcceptButton = buttonOK;
this.CancelButton = buttonCancel;
IsDirty = false;
}
private Dictionary <string, string> GetValues()
{
Dictionary <string, string> valuesDictionary = new Dictionary <string, string>();
foreach (PropertyName prop in PropertiesLookup.Keys)
{
switch (prop)
{
case PropertyName.LocalConnectionString:
valuesDictionary.Add(PropertiesLookup[prop], LocalConnectionString);
break;
case PropertyName.RemoteHost:
valuesDictionary.Add(PropertiesLookup[prop], RemoteHost);
break;
case PropertyName.RemotePassword:
valuesDictionary.Add(PropertiesLookup[prop], RemotePassword);
break;
case PropertyName.RemotePort:
valuesDictionary.Add(PropertiesLookup[prop], RemotePort.ToString());
break;
case PropertyName.RemoteRetryWrites:
valuesDictionary.Add(PropertiesLookup[prop], RemoteRetryWrites.ToString());
break;
case PropertyName.RemoteUserName:
valuesDictionary.Add(PropertiesLookup[prop], RemoteUserName);
break;
case PropertyName.RemoteUseSsl:
valuesDictionary.Add(PropertiesLookup[prop], RemoteUseSsl.ToString());
break;
}
}
return(valuesDictionary);
}
public override JObject ToJSON(Boolean Embedded = false)
=> JSONObject.Create(
!Embedded
? new JProperty("@context", JSONLDContext.ToString())
: null,
new JProperty("method", Method.ToString()),
new JProperty("URL", URL),
new JProperty("TCPPort", RemotePort.ToUInt16()),
BasicAuth_Login.IsNotNullOrEmpty() &&
BasicAuth_Password.IsNotNullOrEmpty()
? new JProperty("basicAuth",
new JObject(
new JProperty("login", BasicAuth_Login),
new JProperty("password", BasicAuth_Password)
)
)
: null,
APIKey.IsNotNullOrEmpty()
? new JProperty("APIKey", APIKey)
: null,
RequestTimeout.HasValue
? new JProperty("RequestTimeout", RequestTimeout.Value.TotalSeconds)
: null,
NotificationMessageTypes.SafeAny()
? new JProperty("messageTypes", new JArray(NotificationMessageTypes.Select(msgType => msgType.ToString())))
: null,
Description.IsNotNullOrEmpty()
? new JProperty("description", Description)
: null
);
public Boolean Equals(HTTPSNotification other)
=> URL.Equals(other.URL) &&
RemotePort.Equals(other.RemotePort) &&
Method.Equals(other.Method);
/// <summary>
/// Tries to determine the true IP address of the client and the address of the proxy, if any. If the
/// values have already been calculated and aren't going to change then this does nothing.
/// </summary>
private void DetermineClientAndProxyAddresses()
{
var translationBasis = String.Format("{0}-{1}", RemoteIpAddress, Headers["X-Forwarded-For"]);
if (!String.Equals(translationBasis, Get <string>(EnvironmentKey.ClientIpAddressBasis)))
{
Set <string>(EnvironmentKey.ClientIpAddressBasis, translationBasis);
var localOrLanRequest = IPEndPointHelper.IsLocalOrLanAddress(new IPEndPoint(ParseIpAddress(RemoteIpAddress), RemotePort.GetValueOrDefault()));
var xff = localOrLanRequest ? Headers["X-Forwarded-For"] : null;
if (!String.IsNullOrEmpty(xff))
{
xff = xff.Split(',').Last().Trim();
IPAddress ipAddress;
if (!IPAddress.TryParse(xff, out ipAddress))
{
xff = null;
}
}
if (String.IsNullOrEmpty(xff))
{
Set <string>(EnvironmentKey.ClientIpAddress, RemoteIpAddress);
Set <string>(EnvironmentKey.ProxyIpAddress, null);
}
else
{
Set <string>(EnvironmentKey.ClientIpAddress, xff);
Set <string>(EnvironmentKey.ProxyIpAddress, RemoteIpAddress);
}
}
}
/// <summary>
/// Execute the given HTTP request and return its result.
/// </summary>
/// <param name="Request">A HTTP request.</param>
/// <param name="RequestLogDelegate">A delegate for logging the HTTP request.</param>
/// <param name="ResponseLogDelegate">A delegate for logging the HTTP request/response.</param>
/// <param name="Timeout">An optional timeout.</param>
/// <param name="CancellationToken">A cancellation token.</param>
public async Task <HTTPResponse> Execute(HTTPRequest Request,
ClientRequestLogHandler RequestLogDelegate = null,
ClientResponseLogHandler ResponseLogDelegate = null,
TimeSpan?Timeout = null,
CancellationToken?CancellationToken = null)
{
#region Call the optional HTTP request log delegate
try
{
RequestLogDelegate?.Invoke(DateTime.Now, this, Request);
}
catch (Exception e)
{
e.Log(nameof(HTTPClient) + "." + nameof(RequestLogDelegate));
}
#endregion
var task = Task <HTTPResponse> .Factory.StartNew(() => {
HTTPResponse Response = null;
try
{
if (Environment.MachineName.Contains("QUAD2QUANTOR") && Request.URI.Contains("eRoaming"))
{
throw new Exception("Catch me if you can!");
}
Thread.CurrentThread.Priority = ThreadPriority.BelowNormal;
#region Data
var HTTPHeaderBytes = new Byte[0];
var sw = new Stopwatch();
if (!Timeout.HasValue)
{
Timeout = TimeSpan.FromSeconds(60);
}
#endregion
#region Create TCP connection (possibly also do DNS lookups)
if (TCPClient == null)
{
System.Net.IPEndPoint _FinalIPEndPoint = null;
IIPAddress _ResolvedRemoteIPAddress = null;
if (RemoteIPAddress == null)
{
if (Hostname.Trim() == "127.0.0.1")
{
_ResolvedRemoteIPAddress = IPv4Address.Localhost;
}
else
{
var RegExpr = new Regex(@"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b");
if (RegExpr.IsMatch(Hostname))
{
_ResolvedRemoteIPAddress = IPv4Address.Parse(Hostname);
}
}
#region DNS lookup...
if (_ResolvedRemoteIPAddress == null)
{
try
{
var IPv4AddressTask = DNSClient.
Query <A>(Hostname).
ContinueWith(QueryTask => QueryTask.Result.
Select(ARecord => ARecord.IPv4Address).
FirstOrDefault());
IPv4AddressTask.Wait();
_ResolvedRemoteIPAddress = IPv4AddressTask.Result;
}
catch (Exception e)
{
Debug.WriteLine("[" + DateTime.Now + "] " + e.Message);
}
}
#endregion
}
else
{
_ResolvedRemoteIPAddress = RemoteIPAddress;
}
_FinalIPEndPoint = new System.Net.IPEndPoint(new System.Net.IPAddress(_ResolvedRemoteIPAddress.GetBytes()), RemotePort.ToInt32());
sw.Start();
TCPClient = new TcpClient();
TCPClient.Connect(_FinalIPEndPoint);
TCPClient.ReceiveTimeout = (Int32)Timeout.Value.TotalMilliseconds;
}
#endregion
#region Create (Crypto-)Stream
TCPStream = TCPClient.GetStream();
TCPStream.ReadTimeout = (Int32)Timeout.Value.TotalMilliseconds;
TLSStream = RemoteCertificateValidator != null
? new SslStream(TCPStream,
false,
RemoteCertificateValidator)
// ClientCertificateSelector,
//EncryptionPolicy.RequireEncryption)
: null;
if (TLSStream != null)
{
TLSStream.ReadTimeout = (Int32)Timeout.Value.TotalMilliseconds;
}
HTTPStream = null;
if (RemoteCertificateValidator != null)
{
HTTPStream = TLSStream;
TLSStream.AuthenticateAsClient(Hostname);//, new X509CertificateCollection(new X509Certificate[] { ClientCert }), SslProtocols.Default, false);
}
else
{
HTTPStream = TCPStream;
}
HTTPStream.ReadTimeout = (Int32)Timeout.Value.TotalMilliseconds;
#endregion
#region Send Request
HTTPStream.Write(String.Concat(Request.EntireRequestHeader,
Environment.NewLine,
Environment.NewLine).
ToUTF8Bytes());
var RequestBodyLength = Request.HTTPBody == null
? Request.ContentLength.HasValue ? (Int32)Request.ContentLength.Value : 0
: Request.ContentLength.HasValue ? Math.Min((Int32)Request.ContentLength.Value, Request.HTTPBody.Length) : Request.HTTPBody.Length;
if (RequestBodyLength > 0)
{
HTTPStream.Write(Request.HTTPBody, 0, RequestBodyLength);
}
var _MemoryStream = new MemoryStream();
var _Buffer = new Byte[10485760]; // 10 MBytes, a smaller value leads to read errors!
#endregion
#region Wait timeout for the server to react!
//Debug.WriteLine("[" + DateTime.Now + "] HTTPClient timeout: " + Timeout.Value.ToString());
while (!TCPStream.DataAvailable)
{
if (sw.ElapsedMilliseconds >= Timeout.Value.TotalMilliseconds)
{
TCPClient.Close();
throw new Exception("[" + DateTime.Now + "] Could not read from the TCP stream for " + sw.ElapsedMilliseconds + "ms!");
}
Thread.Sleep(1);
}
//Debug.WriteLine("[" + DateTime.Now + "] HTTPClient (" + TCPClient.Client.LocalEndPoint.ToString() + " -> " + RemoteSocket.ToString() + ") got first response after " + sw.ElapsedMilliseconds + "ms!");
#endregion
#region Read the entire HTTP header, and maybe some of the HTTP body
var CurrentDataLength = 0;
do
{
#region When data available, write it to the buffer...
while (TCPStream.DataAvailable)
{
CurrentDataLength = HTTPStream.Read(_Buffer, 0, _Buffer.Length);
if (CurrentDataLength > -1)
{
_MemoryStream.Write(_Buffer, 0, CurrentDataLength);
// Debug.WriteLine("[" + DateTime.Now + "] Read " + CurrentDataLength + " bytes from HTTP connection (" + TCPClient.Client.LocalEndPoint.ToString() + " -> " + RemoteSocket.ToString() + ") (" + sw.ElapsedMilliseconds + "ms)!");
}
}
#endregion
#region Check if the entire HTTP header was already read into the buffer
if (_MemoryStream.Length > 4)
{
var MemoryCopy = _MemoryStream.ToArray();
for (var pos = 3; pos < MemoryCopy.Length; pos++)
{
if (MemoryCopy[pos] == 0x0a &&
MemoryCopy[pos - 1] == 0x0d &&
MemoryCopy[pos - 2] == 0x0a &&
MemoryCopy[pos - 3] == 0x0d)
{
Array.Resize(ref HTTPHeaderBytes, pos - 3);
Array.Copy(MemoryCopy, 0, HTTPHeaderBytes, 0, pos - 3);
break;
}
}
//if (HTTPHeaderBytes.Length > 0)
// Debug.WriteLine("[" + DateTime.Now + "] End of (" + TCPClient.Client.LocalEndPoint.ToString() + " -> " + RemoteSocket.ToString() + ") HTTP header at " + HTTPHeaderBytes.Length + " bytes (" + sw.ElapsedMilliseconds + "ms)!");
}
#endregion
Thread.Sleep(1);
}
// Note: Delayed parts of the HTTP body may not be read into the buffer
// => Must be read later!
while (TCPStream.DataAvailable ||
((sw.ElapsedMilliseconds < HTTPStream.ReadTimeout) && HTTPHeaderBytes.Length == 0));
//Debug.WriteLine("[" + DateTime.Now + "] Finally read " + _MemoryStream.Length + " bytes of HTTP client (" + TCPClient.Client.LocalEndPoint.ToString() + " -> " + RemoteSocket.ToString() + ") data (" + sw.ElapsedMilliseconds + "ms)!");
#endregion
#region Copy HTTP header data and create HTTP response
if (HTTPHeaderBytes.Length == 0)
{
throw new ApplicationException(DateTime.Now + " Could not find the end of the HTTP protocol header!");
}
Response = HTTPResponse.Parse(HTTPHeaderBytes.ToUTF8String(),
Request);
#endregion
#region Read 'Content-Length' bytes...
// Copy only the number of bytes given within
// the HTTP header element 'Content-Length'!
if (Response.ContentLength.HasValue && Response.ContentLength.Value > 0)
{
_MemoryStream.Seek(HTTPHeaderBytes.Length + 4, SeekOrigin.Begin);
var _Read = _MemoryStream.Read(_Buffer, 0, _Buffer.Length);
var _StillToRead = (Int32)Response.ContentLength.Value - _Read;
Response.HTTPBodyStream.Write(_Buffer, 0, _Read);
var _CurrentBufferSize = 0;
do
{
while (TCPStream.DataAvailable && _StillToRead > 0)
{
_CurrentBufferSize = Math.Min(_Buffer.Length, (Int32)_StillToRead);
_Read = HTTPStream.Read(_Buffer, 0, _CurrentBufferSize);
Response.HTTPBodyStream.Write(_Buffer, 0, _Read);
_StillToRead -= _Read;
}
if (_StillToRead <= 0)
{
break;
}
Thread.Sleep(1);
}while (sw.ElapsedMilliseconds < HTTPStream.ReadTimeout);
Response.ContentStreamToArray();
}
#endregion
#region ...or read till timeout (e.g. for chunked transport)!
else
{
try
{
_MemoryStream.Seek(HTTPHeaderBytes.Length + 4, SeekOrigin.Begin);
Response.NewContentStream();
Response.HTTPBodyStream.Write(_Buffer, 0, _MemoryStream.Read(_Buffer, 0, _Buffer.Length));
var Retries = 0;
while (Retries < 10)
{
while (TCPStream.DataAvailable)
{
Response.HTTPBodyStream.Write(_Buffer, 0, HTTPStream.Read(_Buffer, 0, _Buffer.Length));
Retries = 0;
}
Thread.Sleep(10);
Retries++;
}
if (Response.TransferEncoding == "chunked")
{
//Debug.WriteLine(DateTime.Now + " Chunked encoding detected");
var TEContent = ((MemoryStream)Response.HTTPBodyStream).ToArray();
var TEString = TEContent.ToUTF8String();
var ReadBlockLength = true;
var TEMemStram = new MemoryStream();
var LastPos = 0;
var i = 0;
do
{
if (i > 2 &&
ReadBlockLength &&
TEContent[i - 1] == '\n' &&
TEContent[i - 2] == '\r')
{
var len = TEContent.ReadTEBlockLength(LastPos, i - LastPos - 2);
//Debug.WriteLine(DateTime.Now + " Chunked encoded block of length " + len + " bytes detected");
if (len == 0)
{
break;
}
if (i + len <= TEContent.Length)
{
TEMemStram.Write(TEContent, i, len);
i = i + len;
if (TEContent[i] == 0x0d)
{
i++;
}
if (i < TEContent.Length - 1)
{
if (TEContent[i] == 0x0a)
{
i++;
}
}
else
{
}
LastPos = i;
ReadBlockLength = false;
}
else
{
// Reaching this point seems to be an endless loop!
break;
}
}
else
{
ReadBlockLength = true;
i++;
}
} while (i < TEContent.Length);
Response.ContentStreamToArray(TEMemStram);
}
else
{
Response.ContentStreamToArray();
}
}
catch (Exception e)
{
Debug.WriteLine(DateTime.Now + " " + e.Message);
}
}
#endregion
#region Close connection if requested!
if (Response.Connection == null ||
Response.Connection == "close")
{
TCPClient.Close();
HTTPStream = null;
TCPClient = null;
}
#endregion
}
catch (Exception e)
{
#region Create a HTTP response for the exception...
while (e.InnerException != null)
{
e = e.InnerException;
}
Response = new HTTPResponseBuilder(Request,
HTTPStatusCode.BadRequest)
{
ContentType = HTTPContentType.JSON_UTF8,
Content = JSONObject.Create(new JProperty("Message", e.Message),
new JProperty("StackTrace", e.StackTrace)).
ToUTF8Bytes()
};
#endregion
}
#region Call the optional HTTP response log delegate
try
{
ResponseLogDelegate?.Invoke(DateTime.Now, this, Request, Response);
}
catch (Exception e2)
{
e2.Log(nameof(HTTPClient) + "." + nameof(ResponseLogDelegate));
}
#endregion
return(Response);
}, TaskCreationOptions.AttachedToParent);
return(await task);
}
public override string ToString()
{
return((new System.Net.IPAddress(LocalIP)).ToString() + ":" + LocalPort.ToString() + "=>" +
(new System.Net.IPAddress(RemoteIP)).ToString() + ":" + RemotePort.ToString());
}
private void cmdConnect_Click(object sender, EventArgs e)
{
int LocalPort;
int RemotePort;
switch (lstRemotePort.Text)
{
case "HTTP": lstRemotePort.Text = "80"; break;
case "HTTPS": lstRemotePort.Text = "443"; break;
case "RDP": lstRemotePort.Text = "3389"; break;
case "POP3": lstRemotePort.Text = "110"; break;
case "SMTP": lstRemotePort.Text = "25"; break;
case "IMAP": lstRemotePort.Text = "143"; break;
case "SSH": lstRemotePort.Text = "22"; break;
case "TELNET": lstRemotePort.Text = "23"; break;
}
if (int.TryParse(txtLocalPort.Text, out LocalPort) == false)
{
MessageBox.Show(this, "Invalid Local Port.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (LocalPort < 1 || LocalPort > 65535)
{
MessageBox.Show(this, "Invalid Local Port.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (txtRemoteServer.Text.Trim() == "")
{
MessageBox.Show(this, "Invalid Remote Server.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (txtRemoteServer.Text.Contains("\"") == true || txtRemoteServer.Text.Contains("^") == true ||
txtRemoteServer.Text.Contains("\\") == true || txtRemoteServer.Text.Contains("%") == true)
{
MessageBox.Show(this, "Invalid Remote Server.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (int.TryParse(lstRemotePort.Text, out RemotePort) == false)
{
MessageBox.Show(this, "Invalid Remote Port.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (RemotePort < 1 || RemotePort > 65535)
{
MessageBox.Show(this, "Invalid Remote Port.", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
string Exec = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "FoxSDC_RemoteConnect.exe");
string SessionID = Program.net.CloneSession();
if (string.IsNullOrWhiteSpace(SessionID) == true)
{
MessageBox.Show(this, "Cannot get a new SessionID from the Server", Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
try
{
Process p = new Process();
p.StartInfo.FileName = Exec;
p.StartInfo.Arguments = "-direct \"" + Program.net.ConnectedURL + "\" \"" + MID + "\" \"" + SessionID + "\" " + LocalPort.ToString() + " \"" + txtRemoteServer.Text + "\" " + RemotePort.ToString();
p.StartInfo.UseShellExecute = false;
p.Start();
}
catch (Exception ee)
{
MessageBox.Show(this, "Cannot start the process " + Exec + " - " + ee.Message, Program.Title, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
Debug.WriteLine(ee.ToString());
return;
}
}
