public HostsItem(NetAddress ip, HostName host, string comment = "")
{
Enabled = true;
IP = ip;
Aliases = new HostAliases(host);
Comment = comment ?? "";
Valid = true;
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
HostName host = new HostName("www.mail.ru");
var eps = await DatagramSocket.GetEndpointPairsAsync(host, "80");
if (eps.Count >= 1)
{
messageb.Text = eps.Count.ToString() + "\n";
}
else
{
messageb.Text = "error\n";
}
//Ping ping = new Ping();
// Send a ping.
//PingReply reply = await ping.SendPingAsync("dotnetperls.com");
// Display the result.
//Text.Text = "ADDRESS:" + reply.Address.ToString();
//Text.Text = Text.Text + "TIME:" + reply.RoundtripTime;
}
/// <summary>
/// Ask for Host name/IP if not already in memory.
/// </summary>
/// <returns></returns>
internal static bool CheckHost()
{
bool retVal = true;
Log.Verbose("-= [ HostInfo ]=- : ", ConsoleColor.Green, false);
General.SaveCursor();
while (string.IsNullOrWhiteSpace(HostName))
{
General.ClearLine(50, Defs.CurrentCursor[(int)CURSOR_LOC.LEFT], Defs.CurrentCursor[(int)CURSOR_LOC.TOP]);
HostName = Console.ReadLine();
NewHost = true;
if (string.IsNullOrWhiteSpace(HostName))
{
retVal = false;
break;
}
else
{
string[] hostInfo = HostName.Split(':');
if (hostInfo.Length > 1)
{
if (int.TryParse(hostInfo[1], out int port))
{
Port = port;
}
HostName = hostInfo[0];
}
if (!Processor.PingHost(HostName, Port))
{
//padding is to clear out previous port that might be longer in string. Fixes screen overwrite issue.
Log.Error($"Failed to connect to host. Port is currently set to {General.PadString(Port.ToString() + ".", 10)}\n If this port is incorrect try <HOST_NAME>:<PORT>");
HostName = null;
}
}
}
return(retVal);
}
private async void btnConnect_Click(object sender, RoutedEventArgs e)
{
HostName host = new HostName(textBoxIP.Text);
string port = textBoxPort.Text;
if (connected)
{
StatusText.Text = "уже подключен";
return;
}
try
{
StatusText.Text = "попытка подключения ...";
// Try to connect to the
await clientSocket.ConnectAsync(host, port);
connected = true;
StatusText.Text = "подключение установлено" + Environment.NewLine;
}
catch (Exception exception)
{
// If this is an unknown status,
// it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
StatusText.Text = "не удалось установить подключение: "; //+ exception.Message;
// Could retry the connection, but for this simple example
// just close the socket.
closing = true;
// the Close method is mapped to the C# Dispose
clientSocket.Dispose();
clientSocket = null;
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (Uuid != null)
{
hashCode = hashCode * 59 + Uuid.GetHashCode();
}
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
if (HostName != null)
{
hashCode = hashCode * 59 + HostName.GetHashCode();
}
hashCode = hashCode * 59 + Port.GetHashCode();
hashCode = hashCode * 59 + IsLdaps.GetHashCode();
if (Account != null)
{
hashCode = hashCode * 59 + Account.GetHashCode();
}
if (Password != null)
{
hashCode = hashCode * 59 + Password.GetHashCode();
}
if (BaseDn != null)
{
hashCode = hashCode * 59 + BaseDn.GetHashCode();
}
if (LdapAttributes != null)
{
hashCode = hashCode * 59 + LdapAttributes.GetHashCode();
}
return(hashCode);
}
}
public MainPage()
{
this.InitializeComponent();
var displayRequest = new Windows.System.Display.DisplayRequest();
displayRequest = new Windows.System.Display.DisplayRequest();
displayRequest.RequestActive();
int period = 200;
ThreadPoolTimer PeriodicTimer =
ThreadPoolTimer.CreatePeriodicTimer(TimerElapsedHandler,
TimeSpan.FromMilliseconds(period));
PopUpCanvas.Margin = new Windows.UI.Xaml.Thickness(-85, -50, -97, -56);
hostName = new HostName("192.168.0.100");
hostPort = "7777";
Windows.UI.ViewManagement.StatusBar.GetForCurrentView().HideAsync();
SoftJoy.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
SoftJoyBoundary.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
HorizontalLine.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
VerticalLine.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
PopUpCanvas.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
SoftJoy.Opacity = 0.2;
faceCollection.Add(face1);
faceCollection.Add(face2);
faceCollection.Add(face3);
faceCollection.Add(face4);
faceCollection.Add(face5);
//ValidIpAddressRegex = new Regex(@"^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");
//ValidIpAddressRegex = new Regex(@"([0-9]{1,3}\.){3}[0-9]{1,3}");
//ValidHostnameRegex = new Regex(@"^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$");
ValidHostnameRegex = new Regex(@"^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$");
RefreshHorizont();
//faceCollection = new { face1, face2, face3, face4, face5 };
this.NavigationCacheMode = NavigationCacheMode.Required;
}
/// <summary>
/// Connect to the device given host name
/// </summary>
/// <param name="deviceHostName">Raw host name of the device</param>
/// <returns>True if connected successfully. Else False</returns>
public async Task <bool> ConnectAsync(string deviceHostName)
{
// dispose of any existing socket
if (_socket != null)
{
_socket.Dispose();
_socket = null;
}
if (_writer != null)
{
_writer.Dispose();
_writer = null;
}
try
{
// create hostname
HostName host = new HostName(deviceHostName);
// create new socket and attempt to connect
_socket = new StreamSocket();
// if connect fails, go to Bluetooth manager settings
// connect it manually and disconnect
// then try again
await _socket.ConnectAsync(host, "1");
// create a writer based on the socket
_writer = new DataWriter(_socket.OutputStream);
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
throw;
}
}
private async Task <bool> SendMulticast(string buffer)
{
try
{
HostName mcast = new HostName(cMulticastAddress);
DataWriter writer = new DataWriter(await mtransmitter.GetOutputStreamAsync(mcast, cPort));
if (writer != null)
{
writer.WriteString(buffer);
uint result = await writer.StoreAsync();
bool bresult = await writer.FlushAsync();
writer.DetachStream();
writer.Dispose();
return(true);
}
/*
* // Connect to the server (in our case the listener we created in previous step).
* IOutputStream os = await mtransmitter.GetOutputStreamAsync(mcast, cPort);
* if (os != null)
* {
* mwriter.WriteString(buffer);
* uint result = await mwriter.StoreAsync();
* if (_reportResult != null) _reportResult("Sent Discovery Message: " + buffer);
* return true;
* }*/
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown)
{
return(false);
}
return(false);
}
return(false);
}
private async Task StartSocket()
{
Debug.WriteLine("Starting TCP listner ...");
socket = new StreamSocket();
// var test_ip = GetLocalIp();
HostName serverHost = new HostName(ServerIP);
try
{
await socket.ConnectAsync(serverHost, ConnectionPort.ToString());
using (DataReader reader = new DataReader(socket.InputStream))
{
reader.InputStreamOptions = InputStreamOptions.Partial;
while (true)
{
var bytesRead = await reader.LoadAsync(1024);
var tmp = reader.ReadString(bytesRead);
if (string.IsNullOrEmpty(tmp))
{
continue;
}
_data = tmp.Replace("\0", "");
_waitHandle.Set();
}
}
}
catch (System.Runtime.InteropServices.COMException e)
{
//Debug.WriteLine(e.Message);
}
catch (Exception e)
{
//Debug.WriteLine(e.Message);
}
Debug.WriteLine("TCP listner closed.");
}
public static ResponseConfiguration WriteEventsCompleted(HttpEntity entity, Message message)
{
Debug.Assert(message.GetType() == typeof(ClientMessage.WriteEventsCompleted));
var completed = message as ClientMessage.WriteEventsCompleted;
if (completed == null)
{
return(InternalServerEror(entity, message));
}
switch (completed.ErrorCode)
{
case OperationErrorCode.Success:
return(new ResponseConfiguration(HttpStatusCode.Created,
"Created",
null,
new KeyValuePair <string, string>("Location",
HostName.Combine(entity.UserHostName,
"/streams/{0}/{1}",
completed.EventStreamId,
completed.EventNumber == 0 ? 1 : completed.EventNumber))));
case OperationErrorCode.PrepareTimeout:
case OperationErrorCode.CommitTimeout:
case OperationErrorCode.ForwardTimeout:
return(new ResponseConfiguration(HttpStatusCode.InternalServerError, "Write timeout", null));
case OperationErrorCode.WrongExpectedVersion:
return(new ResponseConfiguration(HttpStatusCode.BadRequest, "Wrong expected version", null));
case OperationErrorCode.StreamDeleted:
return(new ResponseConfiguration(HttpStatusCode.Gone, "Stream deleted", null));
case OperationErrorCode.InvalidTransaction:
return(new ResponseConfiguration(HttpStatusCode.InternalServerError, "Invalid transaction", null));
default:
throw new ArgumentOutOfRangeException();
}
}
private async void CheckHost()
{
regexResult = ValidHostnameRegex.Split(IPBox.Text);
if (regexResult[0] == "")
{
Debug.WriteLine("HOST");
HostName serverHost = new HostName(IPBox.Text);
var clientSocket = new StreamSocket();
await clientSocket.ConnectAsync(serverHost, "http");
var ipAddress = clientSocket.Information.RemoteAddress.DisplayName;
hostName = new HostName(ipAddress);
}
else
{
Debug.WriteLine("IP");
hostName = new HostName(IPBox.Text);
}
hostPort = PortBox.Text;
}
private async Task Connect()
{
try {
serverSocket = new StreamSocket();
var hostName = new HostName(hostname);
await serverSocket.ConnectAsync(hostName, port.ToString());
Debug.WriteLine("Client Connected");
connected = true;
} catch (Exception ex) {
Debug.WriteLine(ex.Message);
}
if (serverSocket != null)
{
//inputStream = new StreamReader(serverSocket.InputStream.AsStreamForRead());
outputStream = serverSocket.OutputStream.AsStreamForWrite();
//inputStream = serverSocket.InputStream.AsStreamForRead();
Debug.WriteLine("Streams initialized.");
}
}
/// <summary>
/// Connects to the server and requests data.
/// </summary>
private void ConnectListener()
{
if (frameReceiverStatus == FrameReceiverStatus.WaitingForConnection ||
frameReceiverStatus == FrameReceiverStatus.ToDefer ||
frameReceiverStatus == FrameReceiverStatus.Looping)
{
Debug.Log(TAG + ": ConnectListener() not supported at current status");
return;
}
frameReceiverStatus = FrameReceiverStatus.WaitingForConnection;
Debug.Log(TAG + ": Connecting to " + serverIP);
HostName networkHost = new HostName(serverIP);
networkConnection = new StreamSocket();
IAsyncAction outstandingAction = networkConnection.ConnectAsync(networkHost, connectionPort.ToString());
AsyncActionCompletedHandler aach = new AsyncActionCompletedHandler(RcvNetworkConnectedHandler);
outstandingAction.Completed = aach;
}
public async void sendData(string recipientIP, string message)
{
i++;
try
{
sendSocket = new StreamSocket();
HostName recipient = new HostName(recipientIP);//reciver's IP
await sendSocket.ConnectAsync(recipient, port);
Stream streamOut = sendSocket.OutputStream.AsStreamForWrite();
StreamWriter writer = new StreamWriter(streamOut);
await writer.WriteLineAsync(message);
await writer.FlushAsync();
sendSocket.Dispose();
}
catch (Exception)
{
}
}
private async Task startListener(HostName hostname)
{
try
{
_streamSocketListener = new StreamSocketListener();
// thêm sự kiện received.
// sự kiện sẽ được kích hoạt khi nhận được yêu cầu kết nối từ client. hoặc khi client gửi thông điệp đến server
_streamSocketListener.ConnectionReceived += ConnectionReceived;
// Server bắt đầu lắng nghe kết nối
await this._streamSocketListener.BindEndpointAsync(hostname, _port.ToString());
// xuất ra màn hình bằng text box
this.textDebug.Text += "Server started listen in IP:" + hostname.RawName + " and prefix: " + hostname.IPInformation.PrefixLength.ToString() + "\n";
}
catch (Exception ex)
{
this.textDebug.Text += ex.Message + "\n";
}
}
public async Task <bool> Connect(HostName host, string serviceName)
{
try
{
var socket = new StreamSocket();
await socket.ConnectAsync(host, serviceName);
reader = socket.InputStream.AsStreamForRead();
writer = socket.OutputStream.AsStreamForWrite();
Connected?.Invoke(this, EventArgs.Empty);
var ignore = Run(cts.Token);
}
catch
{
return(false);
}
return(true);
}
private async void btnContectToServer_Click(object sender, RoutedEventArgs e)
{
try
{
serverHost = new HostName(txtHostName.Text);
protocol = txtProtocol.Text;
await client.ConnectAsync(serverHost, protocol);
txtStatus.Text = "Connect success";
}
catch (Exception ex)
{
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
txtStatus.Text = "Error while connecting " + ex.Message;
client.Dispose();
client = null;
}
}
private void ExecuteBuild()
{
_buildRunning.Value++;
string hostName = HostName.Value;
string seedHostName = SeedHostName.Value;
UICall(TerminalLines.Clear);
var builder = new SetupBuilder(hostName, AddSeed.Value ? seedHostName : null, _config, s => UICall(() => TerminalLines.Add(s)), Context.System, _deploymentApi, _repositoryApi, ActionInvoker);
var id = Guid.NewGuid().ToString().Substring(0, 5);
_server.AddPendingInstallations(id, builder, AddShortcut);
AddShortcut.Set(false);
AddSeed.Set(false);
HostName.Set(string.Empty);
SeedHostName.Set(string.Empty);
_buildRunning.Value--;
}
public async Task <ChannelBase> Connect(string remoteServer, string remotePort, DataFormat dataFormat)
{
try
{
ConnectionStatus = ConnectionStatus.Connecting;
hostName = new HostName(remoteServer);
streamSocket = new StreamSocket();
streamSocket.Control.NoDelay = true;
await streamSocket.ConnectAsync(hostName, remotePort).AsTask().ConfigureAwait(false);
ConnectionStatus = ConnectionStatus.Connected;
channel = await ChannelFactory.BindChannelAsync(dataFormat, this, streamSocket).ConfigureAwait(false);
}
catch (Exception exception)
{
ConnectionStatus = ConnectionStatus.Failed;
Debug.WriteLine(string.Format("Error receiving data: {0}", exception.Message));
}
return(channel);
}
private async void OnSend(object sender, RoutedEventArgs e)
{
try
{
var host = new HostName(uiAddress.Text);
var service = uiService.Text;
var data = uiData.Text;
var ptype = uiProtocolType.IsOn ? CharGenClient_Rfc_864.ProtocolType.Udp : CharGenClient_Rfc_864.ProtocolType.Tcp; // double-checked; off is TCP.
if (client == null)
{
client = new CharGenClient_Rfc_864();
client.LogEvent += Client_LogEvent;
}
await client.WriteAsync(host, service, ptype, data);
}
catch (Exception ex)
{
Client_LogEvent(this, $"ERROR: Client: Write exception {ex.Message} for host {uiAddress.Text}");
}
}
/// <summary>
/// multi cast byte
/// </summary>
/// <param name="info"></param>
private async void send_byte(byte[] info)
{
try
{
System.Net.Sockets.Socket soc;
IOutputStream outputStream;
HostName remoteHostname = new HostName("224.3.0.5");
outputStream = await listenerSocket.GetOutputStreamAsync(remoteHostname, "22113");
byte[] stringToSend = info;
DataWriter writer = new DataWriter(outputStream);
writer.WriteBytes(stringToSend);
await writer.StoreAsync();
}
catch (Exception ex)
{
netlog.Text = ex.ToString();
}
}
public async Task JoinMulticastGroupAsync(
string multicastAddress,
int port,
ICommunicationInterface communicationInterface = null,
bool allowMultipleBindToSamePort = false)
{
//Throws and exception if the communication interface is not ready og valid.
CheckCommunicationInterface(communicationInterface);
var hostName = new HostName(multicastAddress);
var serviceName = port.ToString();
await BindeUdpServiceNameAsync(communicationInterface, serviceName, allowMultipleBindToSamePort)
.ConfigureAwait(false);
DatagramSocket.Control.OutboundUnicastHopLimit = (byte)TTL;
DatagramSocket.JoinMulticastGroup(hostName);
_multicastAddress = multicastAddress;
_multicastPort = port;
}
/// <summary>
/// Connects to the server and requests data.
/// </summary>
private bool ConnectListener()
{
if (waitingForConnection)
{
Debug.Log("Not a good time to connect listener");
return(false);
}
Debug.Log("Connecting to " + serverIP);
waitingForConnection = true;
HostName networkHost = new HostName(serverIP);
networkConnection = new StreamSocket();
IAsyncAction outstandingAction = networkConnection.ConnectAsync(networkHost, SendConnectionPort.ToString());
AsyncActionCompletedHandler aach = new AsyncActionCompletedHandler(RcvNetworkConnectedHandler);
outstandingAction.Completed = aach;
return(true);
}
private string GetIPAddress()
{
string ipAddress = "Unknown IP";
#if !UNITY_EDITOR && WINDOWS_UWP
var icp = NetworkInformation.GetInternetConnectionProfile();
if (icp != null && icp.NetworkAdapter != null)
{
HostName localName = NetworkInformation.GetHostNames().FirstOrDefault(n =>
n.Type == HostNameType.Ipv4 &&
n.IPInformation != null &&
n.IPInformation.NetworkAdapter != null &&
n.IPInformation.NetworkAdapter.NetworkAdapterId == icp.NetworkAdapter.NetworkAdapterId);
if (localName != null)
{
ipAddress = localName.ToString();
}
}
#endif
return(ipAddress);
}
private async void AutoRemoteHttpServerOnRequestReceived(Request request, HostName hostName)
{
if (request.communication_base_params.type != "Message")
{
return;
}
var m = request as Message;
var device = new Device {
key = request.sender, localip = hostName.RawName
};
if (m == null || m.password != autoRemotePassword)
{
if (Device.KnownDeviceList.Contains(request.sender))
{
this.SendStatus(device);
}
return;
}
await DispatcherHelper.RunAsync(() => this.ProcessMessage(m, device));
}
/// <summary>
/// Connect to the given host device.
/// </summary>
/// <param name="deviceHostName">The host device name.</param>
public async Task <bool> Connect(HostName deviceHostName)
{
if (socket != null)
{
try
{
await socket.ConnectAsync(deviceHostName, "1");
dataReader = new DataReader(socket.InputStream);
Task.Run(() => { ReceiveMessages(); });
dataWriter = new DataWriter(socket.OutputStream);
return(true);
}
catch (Exception)
{
//ignore
}
}
return(false);
}
public static async void Connect(string serverIP, string serverPort)
{
try
{
Status = ConnectionStatus.Connecting;
_hostName = new HostName(serverIP);
_streamSocket2 = new StreamSocket();
await _streamSocket2.ConnectAsync(_hostName, serverPort);
Status = ConnectionStatus.Connected;
_writer2 = new DataWriter(_streamSocket2.OutputStream);
_reader2 = new DataReader(_streamSocket2.InputStream);
GetData();
}
catch (Exception e)
{
Status = ConnectionStatus.Failed;
//todo:report errors via event to be consumed by UI thread
}
}
public override async Task <bool> Connect(Connection newConnection)
{
HostName hostName = null;
string remoteServiceName = null;
var peer = newConnection.Source as PeerInformation;
if (peer != null)
{
hostName = peer.HostName;
remoteServiceName = "1";
}
else
{
var deviceInfo = newConnection.Source as DeviceInformation;
if (deviceInfo != null)
{
var service = await RfcommDeviceService.FromIdAsync(deviceInfo.Id);
if (service == null)
{
return(false);
}
hostName = service.ConnectionHostName;
remoteServiceName = service.ConnectionServiceName;
}
}
var result = false;
if (hostName != null)
{
result = await this.Connect(hostName, remoteServiceName);
await base.Connect(newConnection);
}
return(result);
}
public static FeedElement ToStreamEventForwardFeed(ClientMessage.ReadStreamEventsForwardCompleted msg, Uri requestedUrl, EmbedLevel embedContent)
{
Ensure.NotNull(msg, "msg");
string escapedStreamId = Uri.EscapeDataString(msg.EventStreamId);
var self = HostName.Combine(requestedUrl, "/streams/{0}", escapedStreamId);
var feed = new FeedElement();
feed.SetTitle(string.Format("Event stream '{0}'", msg.EventStreamId));
feed.StreamId = msg.EventStreamId;
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null ? msg.Events[0].Event.TimeStamp : DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.SetHeadOfStream(msg.IsEndOfStream);
var prevEventNumber = Math.Min(msg.FromEventNumber + msg.MaxCount - 1, msg.LastEventNumber) + 1;
var nextEventNumber = msg.FromEventNumber - 1;
feed.AddLink("self", self);
feed.AddLink("first", HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", escapedStreamId, msg.MaxCount));
if (nextEventNumber >= 0)
{
feed.AddLink("last", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, 0, msg.MaxCount));
feed.AddLink("next", HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", escapedStreamId, nextEventNumber, msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous", HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", escapedStreamId, prevEventNumber, msg.MaxCount));
}
if (!escapedStreamId.StartsWith("$$"))
{
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", escapedStreamId));
}
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i], requestedUrl, embedContent));
}
return(feed);
}
private async Task <string> GetUrlViaSocketStream(Uri url)
{
try
{
using (var socket = new StreamSocket())
{
var host = new HostName(url.Host);
await socket.ConnectAsync(host, "80").AsTask().ConfigureAwait(false);
const string request = "GET {0} HTTP/1.1\r\n" +
"Host: {1}\r\n" +
"\r\n";
var outStream = socket.OutputStream.AsStreamForWrite();
using (var sw = new StreamWriter(outStream))
{
var requestToSend = String.Format(request, url.AbsoluteUri, url.Host);
await sw.WriteAsync(requestToSend).ConfigureAwait(false);
await sw.FlushAsync().ConfigureAwait(false);
}
var inStream = socket.InputStream.AsStreamForRead();
using (var reader = new StreamReader(inStream))
{
var response = await reader.ReadToEndAsync().ConfigureAwait(false);
return(response);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
return(null);
}
public static FeedElement ToAllEventsForwardFeed(ClientMessage.ReadAllEventsForwardCompleted msg,
Uri requestedUrl, EmbedLevel embedContent)
{
var self = HostName.Combine(requestedUrl, "/streams/{0}", AllEscaped);
var feed = new FeedElement();
feed.SetTitle("All events");
feed.SetId(self);
feed.SetUpdated(msg.Events.Length > 0 && msg.Events[0].Event != null
? msg.Events[msg.Events.Length - 1].Event.TimeStamp
: DateTime.MinValue.ToUniversalTime());
feed.SetAuthor(AtomSpecs.Author);
feed.AddLink("self", self);
feed.AddLink("first",
HostName.Combine(requestedUrl, "/streams/{0}/head/backward/{1}", AllEscaped, msg.MaxCount));
if (msg.CurrentPos.CommitPosition != 0)
{
feed.AddLink("last",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped,
new TFPos(0, 0).AsString(), msg.MaxCount));
feed.AddLink("next",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/backward/{2}", AllEscaped, msg.PrevPos.AsString(),
msg.MaxCount));
}
if (!msg.IsEndOfStream || msg.Events.Length > 0)
{
feed.AddLink("previous",
HostName.Combine(requestedUrl, "/streams/{0}/{1}/forward/{2}", AllEscaped, msg.NextPos.AsString(),
msg.MaxCount));
}
feed.AddLink("metadata", HostName.Combine(requestedUrl, "/streams/{0}/metadata", AllEscaped));
for (int i = msg.Events.Length - 1; i >= 0; --i)
{
feed.AddEntry(ToEntry(msg.Events[i].WithoutPosition(), requestedUrl, embedContent));
}
return(feed);
}
internal NetEndPoint(HostName hostName, string port)
{
HostName = hostName;
Port = int.Parse(port);
PortStr = port;
}
public NetEndPoint(HostName hostname, int port)
{
HostName = hostname; Port = port;
}
public NetEndPoint(HostName hostname, string port)
{
HostName = hostname; Port = int.Parse(port);
}
public D3API(HostName host)
{
Host = host;
}
async Task ConnectAsync(HttpWebRequest request)
{
var isLocked = false;
try
{
Monitor.TryEnter(_socketLock, ref isLocked);
if (_socket != null && _status == WebExceptionStatus.Success)
{
// Take the chunked stream to the expected state (State.None)
if (CanReuse() && await CompleteChunkedReadAsync(CancellationToken.None).ConfigureAwait(false))
{
_reused = true;
return;
}
}
_reused = false;
if (_socket != null)
{
_socket.Dispose();
_socket = null;
}
_chunkStream = null;
}
finally
{
if (isLocked)
Monitor.Exit(_socketLock);
}
var hostEntry = await _sPoint.GetHostEntryAsync().ConfigureAwait(false);
if (hostEntry == null)
{
#if MONOTOUCH
monotouch_start_wwan (sPoint.Address.ToString ());
hostEntry = sPoint.HostEntry;
if (hostEntry == null) {
#endif
_status = _sPoint.UsesProxy ? WebExceptionStatus.ProxyNameResolutionFailure :
WebExceptionStatus.NameResolutionFailure;
return;
#if MONOTOUCH
}
#endif
}
foreach (var address in hostEntry.AddressList)
{
lock (_socketLock)
{
if (null != _socket)
{
_socket.Dispose();
_socket = null;
}
try
{
_socket = new StreamSocket();
}
catch (Exception se)
{
// The Socket ctor can throw if we run out of FD's
if (!request.Aborted)
_status = WebExceptionStatus.ConnectFailure;
_connectException = se;
return;
}
_socket.Control.NoDelay = !_sPoint.UseNagleAlgorithm;
try
{
_sPoint.KeepAliveSetup(_socket);
}
catch
{
// Ignore. Not supported in all platforms.
}
}
var port = _sPoint.Address.Port;
var remote = new IPEndPoint(address, port);
IPEndPoint local;
if (!_sPoint.GetLocalEndPointFromDelegate(remote, out local))
{
StreamSocket s;
lock (_socketLock)
{
s = _socket;
_socket = null;
_status = WebExceptionStatus.ConnectFailure;
}
if (s != null)
s.Dispose();
return;
}
try
{
if (request.Aborted)
return;
var remoteHostName = new HostName(request.RequestUri.Host);
var remoteServiceName = port.ToString(CultureInfo.InvariantCulture);
await _socket.ConnectAsync(remoteHostName, remoteServiceName, _ssl ? SocketProtectionLevel.Ssl : SocketProtectionLevel.PlainSocket).AsTask().ConfigureAwait(false);
_status = WebExceptionStatus.Success;
break;
}
catch (ThreadAbortException)
{
// program exiting...
StreamSocket s;
lock (_socketLock)
{
s = _socket;
_socket = null;
}
if (s != null)
s.Dispose();
return;
}
catch (ObjectDisposedException)
{
// socket closed from another thread
return;
}
catch (Exception exc)
{
StreamSocket s;
lock (_socketLock)
{
s = _socket;
_socket = null;
if (!request.Aborted)
_status = WebExceptionStatus.ConnectFailure;
}
if (s != null)
s.Dispose();
_connectException = exc;
}
}
}
public NetEndPoint(string hostname, int port)
{
HostName = (hostname == null) ? null : new HostName(hostname); Port = port;
}
/// <summary>
/// Creates an instance of RoutePolicy using the defined connection
/// profile and host name values.
/// </summary>
/// <param name="pConnectionProfile">The connection profile</param>
/// <param name="pHostName">
/// The host name for the route policy to the special PDP context.
/// </param>
public RoutePolicy(ConnectionProfile pConnectionProfile, HostName pHostName)
{
ConnectionProfile = pConnectionProfile;
HostName = pHostName;
}
internal NetEndPoint(int port)
{
HostName = null;
PortStr = port.ToString();
Port = port;
}
public NetEndPoint(string hostName, int port)
{
var task = DatagramSocket.GetEndpointPairsAsync(new HostName(hostName), port.ToString()).AsTask();
task.Wait();
HostName = task.Result[0].RemoteHostName;
Port = port;
PortStr = port.ToString();
}
public StreamSocketConnectOperation ConnectAsync (HostName hostName, string remoteServiceName, SocketProtectionLevel protectionLevel)
{
throw new NotImplementedException();
}
public UpgradeToSslOperation UpgradeToSslAsync (SocketProtectionLevel protectionlevel, HostName validationHostName)
{
throw new NotImplementedException();
}