private static async Task <bool> IsServerTheAwake()
{
ResourceLoader config = ResourceLoader.GetForViewIndependentUse("Config");
bool isAwake = false;
StreamSocket socket = new StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(config.GetString("NetworkHelper_HostName"));
string serverPort = config.GetString("NetworkHelper_Port");
try
{
await socket.ConnectAsync(serverHost, serverPort);
isAwake = true;
await socket.CancelIOAsync();
}
catch (System.Runtime.InteropServices.COMException ex)
{
await _log.InfoAsync("Der Server ist nicht eingeschaltet", ex);
}
catch (Exception ex)
{
await _log.ErrorAsync("Die Überprüfung, ob der Server eingeschaltet ist, ist fehlgeschlagen.", ex);
}
finally
{
socket.Dispose();
}
return(isAwake);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
try
{
////Create the StreamSocket and establish a connection to the echo server.
//Windows.Networking.Sockets.StreamSocket socket = new Windows.Networking.Sockets.StreamSocket();
//The server hostname that we will be establishing a connection to. We will be running the server and client locally,
//so we will use localhost as the hostname.
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("133.37.56.223");
//Every protocol typically has a standard port number. For example HTTP is typically 80, FTP is 20 and 21, etc.
//For the echo server/client application we will use a random port 1337.
string serverPort = "50005";
await socket.ConnectAsync(serverHost, serverPort);
while (true)
{
//Read data from the echo server.
Stream streamIn = socket.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
System.Diagnostics.Debug.WriteLine("ok");
string response = await reader.ReadLineAsync(); //サーバからの入力待ち
textblock.Text = response;
}
}
catch (Exception)
{
//Handle exception here.
}
}
private async void btnConnect_Click(object sender, RoutedEventArgs e)
{
Windows.Networking.Sockets.DatagramSocket socket = new Windows.Networking.Sockets.DatagramSocket();
socket.MessageReceived += Socket_MessageReceived;
//You can use any port that is not currently in use already on the machine. We will be using two separate and random
//ports for the client and server because both the will be running on the same machine.
string serverPort = "8001";
string clientPort = "8002";
//Because we will be running the client and server on the same machine, we will use localhost as the hostname.
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("127.0.0.1");
//Bind the socket to the clientPort so that we can start listening for UDP messages from the UDP echo server.
await socket.BindServiceNameAsync(clientPort);
await socket.ConnectAsync(serverHost, serverPort);
//Write a message to the UDP echo server.
Stream streamOut = (await socket.GetOutputStreamAsync(serverHost, serverPort)).AsStreamForWrite();
StreamWriter writer = new StreamWriter(streamOut);
string message = "I'm the message from client!";
await writer.WriteLineAsync(message);
await writer.FlushAsync();
}
private async void ListenSock(string dest, string port)
{
try {
//Create the StreamSocket and establish a connection to the echo server.
clientSocket = new StreamSocket();
//The server hostname that we will be establishing a connection to. We will be running the server and client locally,
//so we will use localhost as the hostname.
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(dest);
//Every protocol typically has a standard port number. For example HTTP is typically 80, FTP is 20 and 21, etc.
//For the echo server/client application we will use a random port 1337.
await clientSocket.ConnectAsync(serverHost, port);
status.Text = "Socket succesfully connected!";
dataReaderObject = new DataReader(clientSocket.InputStream);
// ReadCancellationTokenSource.CancelAfter(2000);
pMan.TIMEOUT = 1000;
while (true)
{
await ReadAsync(ReadCancellationTokenSource.Token);
}
} catch (Exception ex1) {
status.Text = ex1.Message;
CloseDevice();
}
}
/// <summary>
/// Opens an kerberos encrypted connection to a server.
/// </summary>
/// <param name="IP">Hostname or IP-Address.</param>
/// <param name="RemotePort">Target port of the remote server.</param>
/// <param name="PColl">The Portal Collection.</param>
/// <param name="Kerberos">The Kerberos connectionsettings.</param>
/// <returns>Returns the link of the connection.</returns>
/// <exception cref="System.Net.Sockets.SocketException">Thrown if vaser is unable to create a socket or a connection.</exception>
/*public static Link ConnectClient(string IP, int RemotePort, PortalCollection PColl, VaserKerberosClient Kerberos)
* {
* //if (Mode == VaserOptions.ModeSSL) throw new Exception("Missing X509Certificate2");
* if (PColl == null) throw new Exception("PortalCollection is needed!");
*
* try
* {
* //TcpClient client = new TcpClient();
* Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
* StreamSocket s = new StreamSocket();
* client.Connect(IP, Port);
* if (client.Connected)
* {
* StreamSocket client = new StreamSocket();
* Windows.Networking.HostName serverHost = new Windows.Networking.HostName(IP);
* await client.ConnectAsync(serverHost, RemotePort.ToString(), SocketProtectionLevel.);
*
* PColl._Active = true;
* Connection con = new Connection(client, false, VaserOptions.ModeKerberos, PColl, null, null, Kerberos, null);
*
* lock (Link._Static_ThreadLock)
* {
* Link.LinkList.Add(con.link);
* }
*
* return con.link;
* }
* else
* {
* return null;
* }
* }
* catch (Exception e)
* {
* throw e;
* }
* }*/
/// <summary>
/// Connect to a Vaser server via SSL.
/// </summary>
/// <param name="IP">Hostname or IP-Address.</param>
/// <param name="RemotePort">Target port of the remote server.</param>
/// <param name="PColl">The Portal Collection.</param>
/// <param name="SSL">The SSL connectionsettings.</param>
/// <returns>Returns the link of the connection.</returns>
/// <exception cref="System.Net.Sockets.SocketException">Thrown if vaser is unable to create a socket or a connection.</exception>
public static async System.Threading.Tasks.Task <Link> ConnectClient(string IP, int RemotePort, PortalCollection PColl, VaserSSLClient SSL)
{
if (SSL == null)
{
throw new Exception("Missing SSL options in ConnectClient(...)");
}
if (PColl == null)
{
throw new Exception("PortalCollection is needed!");
}
try
{
StreamSocket client = new StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(IP);
await client.ConnectAsync(serverHost, RemotePort.ToString(), SocketProtectionLevel.Tls12);
PColl._Active = true;
Connection con = new Connection(client, false, VaserOptions.ModeSSL, PColl, null, null, null, SSL);
return(con.link);
}
catch (Exception e)
{
throw e;
}
}
public async void SendTCPAsync(string message)
{
try
{
tcpClientSocket = new StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(HupIPAddress);
await tcpClientSocket.ConnectAsync(serverHost, TCPSenderPort.ToString());
using (Stream outputStream = tcpClientSocket.OutputStream.AsStreamForWrite())
{
using (StreamWriter streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(message);
await streamWriter.FlushAsync();
}
}
}
catch
{
// Console.WriteLine("error sending TCP message");
}
}
public static async void Send(string str, string ip = "192.168.1.40", bool isBroadcast = false)
{
try
{
using (var socket = new DatagramSocket())
{
if (isBroadcast)
{
socket.Control.MulticastOnly = false;
}
var hn = new Windows.Networking.HostName(ip);
using (Stream outStream = (await socket.GetOutputStreamAsync(hn, Utils.devicesUDPPort.ToString())).AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outStream))
{
await streamWriter.WriteAsync(str);
await streamWriter.FlushAsync();
}
}
}
gameBrain.Debug("message sent via UDP: " + str + " @" + ip + ":" + Utils.devicesUDPPort + "Broadcast: " + isBroadcast);
}
catch (Exception e)
{
gameBrain.Debug(e.Message);
}
}
/// <summary>
/// Creates a TCP client object for use,
/// </summary>
/// <param name="hostName">
///
/// </param>
/// <param name="portNumber">
///
/// </param>
/// <param name="messageService">
///
/// </param>
/// <param name="responder">
///
/// </param>
public TCPClient(string hostName = NetworkingLibaryCore.LocalHostName, string portNumber = NetworkingLibaryCore.DefaultServiceName, IDisplayMessage messageService = null, ITCPResponder responder = null)
{
this.portNumber = portNumber;
this.hostName = new Windows.Networking.HostName(hostName);
this.messageService = messageService;
this.responder = responder;
}
private async Task <bool> Reconnect()
{
try
{
_serverHost = new Windows.Networking.HostName(_IPAddress);
// Try to connect to the
_clientSocket.Dispose();
_clientSocket = new StreamSocket();
await _clientSocket.ConnectAsync(_serverHost, _port);
return(true);
}
catch (Exception ex)
{
// If this is an unknown status,
// it means that the error is fatal and retry will likely fail.
if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown)
{
throw;
}
// 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;
return(false);
}
}
private async void bnConnect_Click(object sender, RoutedEventArgs e)
{
ushort port = 0;
if (UInt16.TryParse(this.txPort.Text, out port))
{
if (string.IsNullOrEmpty(this.txAddress.Text))
{
this.txAddress.Text = this.txAddress.PlaceholderText;
}
Windows.Networking.HostName host = new Windows.Networking.HostName(this.txAddress.Text);
this.connector = new Connector(true);
if (this.connector != null)
{
this.connection = await this.connector.ConnectAsync(host, port);
if (this.connection != null)
{
this.bnConnect.IsEnabled = false;
this.bnClose.IsEnabled = true;
this.bnStart.IsEnabled = true;
this.bnStop.IsEnabled = false;
this.connection.Disconnected += Connection_Disconnected;
var propertySet = new PropertySet();
var propertySetDictionary = propertySet as IDictionary <string, object>;
propertySet["Connection"] = this.connection;
RegisterSchemeHandler(propertySet);
}
}
}
}
/// <summary>This method Creates a socket, then sends the inital SOCKS request info. It stops before reading so that other methods may differently interpret the results.It returns the open socket.
///<para>targetHostname The hostname of the destination host.</para>
///<para>targetPort The port to connect to</para>
///<para>req SOCKS/TOR request code</para>
///</summary>
public static async Task <StreamSocket> TorSocketPreAsync(String targetHostname, int targetPort, byte req)
{
StreamSocket s = new StreamSocket();
Windows.Networking.HostName proxyAddrHostName = new Windows.Networking.HostName(proxyAddr);
await s.ConnectAsync(proxyAddrHostName, proxyPort.ToString());
BinaryWriter _os = new BinaryWriter(s.OutputStream.AsStreamForWrite());
_os.Write(SOCKS_VERSION);
_os.Write(req);
// 2 bytes
_os.Write((short)targetPort);
// 4 bytes, high byte first
_os.Write(SOCKS4A_FAKEIP);
_os.Write(SOCKS_DELIM);
_os.Write(targetHostname);
_os.Write(SOCKS_DELIM);
_os.Flush();
_os.Dispose();
return(s);
}
private async void CharacteristicStreamButton_Click(object sender, RoutedEventArgs e)
{
try
{
// Create a client socket and connect to the server.
//Windows.Networking.Sockets.
if (socket == null)
{
socket = new Windows.Networking.Sockets.StreamSocket();
}
// Define the server name and port
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("localhost");
string serverPort = "1337";
// Connect to server
await socket.ConnectAsync(serverHost, serverPort);
// launch the HR data stream routine.
socket.InputStream.AsStreamForRead();
//
// Start listening for incoming TCP connections on the specified port.
}
catch (Exception ex)
{
// This happens when the network socket failed to create
rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage);
}
}
private async void StartClient()
{
try
{
// Create the DatagramSocket and establish a connection to the echo server.
var clientDatagramSocket = new Windows.Networking.Sockets.DatagramSocket();
clientDatagramSocket.MessageReceived += ClientDatagramSocket_MessageReceived;
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
await clientDatagramSocket.BindServiceNameAsync("servername");
// Send a request to the echo server.
string request = "Hello, World!";
using (var serverDatagramSocket = new Windows.Networking.Sockets.DatagramSocket())
{
using (Stream outputStream = (await serverDatagramSocket.GetOutputStreamAsync(hostName, "3655")).AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
//await streamWriter.WriteAsync();
await streamWriter.FlushAsync();
}
}
}
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
}
}
private async void connectbutton_ClickAsync(object sender, RoutedEventArgs e)
{
mTimer2.Start();
TextBox TBox = IP;
Ip = TBox.Text;
var settings = ApplicationData.Current.LocalSettings;
settings.Values["IP"] = Ip;
serverDisposed.Visibility = Visibility.Collapsed;
try
{
socket = new Windows.Networking.Sockets.StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(Ip);
string serverPort = "1337";
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
Writer = new StreamWriter(streamOut);
VerticalPage verticalpage = frame.Content as VerticalPage;
verticalpage.AppearImg();
//create timer
mTimer.Tick += MTimer_Tick;
mTimer.Interval = TimeSpan.FromSeconds(5);
mTimer.Start();
connectbutton.Visibility = Visibility.Collapsed;
stackPanel.Visibility = Visibility.Collapsed;
serverIP.Visibility = Visibility.Collapsed;
}
catch (Exception ex)
{
}
}
public async override Task <bool> ConnectAsync()
{
try
{
_readBuffer = new char[MAX_BUFFER_SIZE];
_socket = new Windows.Networking.Sockets.StreamSocket();
var host = new Windows.Networking.HostName(_remoteDevice.IPAddress);
await _socket.ConnectAsync(host, Constants.TCPListenPort.ToString());
_inputStream = _socket.InputStream.AsStreamForRead();
_reader = new StreamReader(_inputStream);
_outputStream = _socket.OutputStream.AsStreamForWrite();
_writer = new StreamWriter(_outputStream);
ReceiveData();
_pingTimer = new Timer(Ping, null, 0, 2500);
InvokeConnected();
return(true);
}
catch (Exception ex)
{
_logger.NotifyUserError("TCPIPChannel_Listen", ex.Message);
return(false);
}
}
/// <summary>
/// Opens an unencrypted connection to a server.
/// </summary>
/// <param name="IP">Hostname or IP-Address.</param>
/// <param name="RemotePort">Target port of the remote server.</param>
/// <param name="PColl">The Portal Collection.</param>
/// <returns>Returns the link of the connection.</returns>
/// <exception cref="System.Net.Sockets.SocketException">Thrown if vaser is unable to create a socket or a connection.</exception>
public static async System.Threading.Tasks.Task <Link> ConnectClient(string IP, int RemotePort, PortalCollection PColl)
{
//if (Mode == VaserOptions.ModeSSL) throw new Exception("Missing X509Certificate2");
if (PColl == null)
{
throw new Exception("PortalCollection is needed!");
}
try
{
//Debug.WriteLine("Connecting");
StreamSocket client = new StreamSocket();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(IP);
await client.ConnectAsync(serverHost, RemotePort.ToString(), SocketProtectionLevel.PlainSocket);
//Debug.WriteLine("Connected");
PColl._Active = true;
//Debug.WriteLine("Create Connection class");
Connection con = new Connection(client, false, VaserOptions.ModeNotEncrypted, PColl, null, null, null, null);
//Debug.WriteLine("Create Connection class DONE" );
return(con.link);
}
catch (Exception e)
{
throw e;
}
}
async void discoverer_TvFound(Windows.Networking.HostName TvHost, UInt16 TvPort, string TvResponse)
{
ToggleProgressBar(false);
SetProgressText("Found TV.");
await AddTvUnique(TvHost, TvPort);
await GetTvNameFrom(TvHost, TvPort, TvResponse);
}
public async void Connect(Game1 g)
{
Socket = new StreamSocket();
Windows.Networking.HostName hn = new Windows.Networking.HostName(ip);
await Socket.ConnectAsync(hn, port.ToString());
g.c = true;
this.Listen();
}
// </SnippetMakeFilterList>
// <SnippetFindByHostName>
private async Task <RemoteSystem> getDeviceByAddressAsync(string IPaddress)
{
// construct a HostName object
Windows.Networking.HostName deviceHost = new Windows.Networking.HostName(IPaddress);
// create a RemoteSystem object with the HostName
RemoteSystem remotesys = await RemoteSystem.FindByHostNameAsync(deviceHost);
return(remotesys);
}
public async void Send_Message(byte[] message, Windows.Networking.HostName ip, string port)
{
Debug.Log("Sending");
IOutputStream streamOut = await this.socket.GetOutputStreamAsync(ip, port);
DataWriter dataWriter = new DataWriter(streamOut);
dataWriter.WriteBytes(message);
await dataWriter.StoreAsync();
}
public static async Task <XDocument> SockeRequest(
string ip,
string port,
string strReq
)
{
XDocument doc = null;
try
{
var socket = new Windows.Networking.Sockets.StreamSocket();
var serverHost = new Windows.Networking.HostName(ip);
await socket.ConnectAsync(serverHost, port);
//Send request
DataWriter writer = new DataWriter(socket.OutputStream);
writer.WriteUInt32(writer.MeasureString(strReq));
writer.WriteString(strReq);
await writer.StoreAsync();
await writer.FlushAsync();
writer.DetachStream();
writer.Dispose();
//Read response
Stream streamIn = socket.InputStream.AsStreamForRead();
int bsize = 4096;
byte[] buffer = new byte[bsize];
int readByte = await streamIn.ReadAsync(
buffer,
0,
bsize
);
if (readByte <= 0)
{
//return null if there is no response
return(doc);
}
byte[] rdata = new byte[readByte];
Array.Copy(buffer, rdata, readByte);
streamIn.Dispose();
socket.Dispose();
doc = XDocument.Parse(Encoding.ASCII.GetString(rdata));
}
catch (Exception ex)
{
}
return(doc);
}
private async Task OnSend()
{
if (string.IsNullOrEmpty(IPAddress))
{
await NotifyAsync("Destination IP is Empty");
return;
}
IsBusy = true;
var contentType = Enum.Parse <ContentType>(_selectedContentType.ToString());
if (CoreApplication.Properties.ContainsKey("listener"))
{
Windows.Networking.Sockets.StreamSocket socket = null;
try
{
var host = new Windows.Networking.HostName(IPAddress);
socket = new Windows.Networking.Sockets.StreamSocket();
socket.Control.KeepAlive = false;
await socket.ConnectAsync(host, App.ServiceName);
switch (contentType)
{
case ContentType.File:
await SendFileAsync(socket.InputStream, socket.OutputStream);
break;
case ContentType.Code:
var language = Enum.Parse <HighlightedLanguage>(_language.ToString());
await SendContentAsync(socket.InputStream, socket.OutputStream, contentType, language);
break;
case ContentType.Text:
await SendContentAsync(socket.InputStream, socket.OutputStream, contentType);
break;
}
}
catch (Exception ex)
{
await NotifyAsync(ex.Message);
}
finally
{
socket?.Dispose();
IsBusy = false;
}
}
else
{
await NotifyAsync("Somthing wrong.. Please Restart the app and try again");
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
if (this.btnConnect.Label == "Connect")
{
try
{
Windows.Networking.HostName serverHost = new Windows.Networking.HostName(txtIP.Text);
string serverPort = txtPort.Text;
await socket.ConnectAsync(serverHost, serverPort);
Stream streamOut = socket.OutputStream.AsStreamForWrite();
BinaryWriter writer = new BinaryWriter(streamOut);
Stream streamIn = socket.InputStream.AsStreamForRead();
BinaryReader reader = new BinaryReader(streamIn);
Boolean connOn = true;
int countLimit = handshake.Length + zonelabels.Length;
handshake[0] = App.createLoginString(this.txtPassword.Password);
int[] fixedLenght = new int[] { 53 };
this.txtEvent.Text = "Connecting...";
this.txtStatus.Text = "Status: Connecting...";
await comms(reader, writer, handshake, answerLenghtArray, 0);
this.txtEvent.Text = "Retrieving Zone Labels...";
this.txtStatus.Text = "Status: Connected";
this.btnConnect.Label = "Disconnect";
await comms(reader, writer, zonelabels, fixedLenght, 2);
int i = 1;
foreach (CheckBox item in this.gridView.Items)
{
item.Content = Mappings.zoneLabel[i];
i++;
}
while (connOn)
{
await comms(reader, writer, retrieveInfo, fixedLenght, 1000);
}
}
catch (Exception er)
{
Debug.WriteLine("ops...");
Debug.WriteLine(er.Message);
}
}
else
{
socket.Dispose();
}
}
public async Task SsdpQueryAsync(string filter = "ssdp:all", int seconds = 5, int port = 1900)
{
_ssdpPort = port;
_foundDevices = new List <string>();
var remoteIP = new Windows.Networking.HostName(_ssdp_ip);
var ssdpQuery = GetSSDPQuery(seconds, port, filter);
var reqBuff = Encoding.UTF8.GetBytes(ssdpQuery);
try
{
if (_readerSocket != null)
{
_readerSocket.Dispose();
}
}
catch (Exception ex)
{
LogException("SSDPFinder.QueryAsync - Close Existing Socket", ex);
}
_readerSocket = new DatagramSocket();
_readerSocket.MessageReceived += (sender, args) =>
{
Task.Run(async() =>
{
var addr = args.RemoteAddress.DisplayName;
var result = args.GetDataStream();
var resultStream = result.AsStreamForRead(1024);
using (var reader = new StreamReader(resultStream))
{
var resultText = await reader.ReadToEndAsync();
if (resultText.StartsWith("HTTP/1.1 200 OK"))
{
HandleSSDPResponse(resultText);
}
};
});
};
var ipAddress = PlatformSupport.Services.Network.GetIPV4Address();
var hostName = new Windows.Networking.HostName(ipAddress);
await _readerSocket.BindEndpointAsync(hostName, "");
Core.PlatformSupport.Services.Logger.AddCustomEvent(LogLevel.Message, "SSDPFinder.QueryAsync", _readerSocket.Information.LocalAddress + " " + _readerSocket.Information.LocalPort);
_readerSocket.JoinMulticastGroup(remoteIP);
using (var stream = await _readerSocket.GetOutputStreamAsync(remoteIP, _ssdpPort.ToString()))
{
await stream.WriteAsync(reqBuff.AsBuffer());
}
}
private void Socket_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
this.senderIP = args.RemoteAddress;
this.senderPort = args.RemotePort;
DataReader dataReader = args.GetDataReader();
Byte[] buffer = new Byte[dataReader.UnconsumedBufferLength];
dataReader.ReadBytes(buffer);
this.messageQueue.Enqueue(buffer);
}
// Purpose: Connect to node.js application (lamechat.js)
// End Result: node.js app now has a socket open that can send
// messages back to this tcp client application
private async void cmdConnect_Click(object sender, RoutedEventArgs e)
{
AddPrompt();
Windows.Networking.HostName serverHost = new Windows.Networking.HostName("127.0.0.1");
await tcpClient.ConnectAsync(serverHost, "8000");
serverStream = tcpClient.OutputStream.AsStreamForWrite();
StreamWriter writer = new StreamWriter(serverStream);
string request = txtChatName.Text.Trim() + " is joining";
await writer.WriteLineAsync(request);
await writer.FlushAsync();
Stream streamIn = tcpClient.InputStream.AsStreamForRead();
StreamReader reader = new StreamReader(streamIn);
string response = await reader.ReadLineAsync();
//byte[] outStream = Encoding.ASCII.GetBytes(txtChatName.Text.Trim()
// + " is joining");
//serverStream.Write(outStream, 0, outStream.Length);
//serverStream.Flush();
// upload as javascript blob
//Task taskOpenEndpoint = Task.Factory.StartNew(() =>
//{
// while (true)
// {
// // Read bytes
// serverStream = tcpClient.InputStream.AsStreamForRead();
// byte[] message = new byte[4096];
// int bytesRead;
// bytesRead = 0;
// try
// {
// // Read up to 4096 bytes
// bytesRead = serverStream.Read(message, 0, 4096);
// }
// catch
// {
// /*a socket error has occured*/
// }
// //We have rad the message.
// ASCIIEncoding encoder = new ASCIIEncoding();
// // Update main window
// AddMessage(encoder.GetString(message, 0, bytesRead));
// //Thread.Sleep(500);
// }
//});
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="localIP">A string containing the IP address of the local network adapter to bind sockets to. Null or empty string will use IPAddress.Any.</param>
public SocketFactory(string localIP)
{
_DeviceNetworkType = DeviceNetworkType.IPv4;
_LocalIP = localIP;
if (!String.IsNullOrEmpty(localIP))
{
var hostName = new Windows.Networking.HostName(localIP);
if (hostName.Type == Windows.Networking.HostNameType.Ipv6)
{
_DeviceNetworkType = DeviceNetworkType.IPv6;
}
}
}
/// <summary>
/// This is the click handler for the 'ConnectSocket' button.
/// </summary>
/// <param name="sender">Object for which the event was generated.</param>
/// <param name="e">Event's parameters.</param>
private async void ConnectSocket_Click(object sender, RoutedEventArgs e)
{
// By default 'HostNameForConnect' is disabled and host name validation is not required. When enabling the
// text box validating the host name is required since it was received from an untrusted source
// (user input). The host name is validated by catching ArgumentExceptions thrown by the HostName
// constructor for invalid input.
Windows.Networking.HostName hostName;
try
{
hostName = new Windows.Networking.HostName(HostNameForConnect.Text);
}
catch (ArgumentException)
{
return;
}
string[] serviceNames =
{
_vlcLeftLeftServiceName.Text,
_vlcLeftFrontServiceName.Text,
_vlcRightFrontServiceName.Text,
_vlcRightRightServiceName.Text,
};
// Save the socket, so subsequent steps can use it.
try
{
foreach (var serviceName in serviceNames)
{
Task.Run(async() =>
{
var socket = new Windows.Networking.Sockets.StreamSocket();
socket.Control.KeepAlive = true;
await socket.ConnectAsync(hostName, serviceName);
OnServerConnectionEstablished(socket);
});
}
}
catch (Exception exception)
{
// If this is an unknown status it means that the error is fatal and retry will likely fail.
if (Windows.Networking.Sockets.SocketError.GetStatus(exception.HResult) ==
Windows.Networking.Sockets.SocketErrorStatus.Unknown)
{
throw;
}
}
}
private async void StartClient()
{
try
{
// Create the StreamSocket and establish a connection to the echo server.
using (var streamSocket = new Windows.Networking.Sockets.StreamSocket())
{
// The server hostname that we will be establishing a connection to. In this example, the server and client are in the same process.
var hostName = new Windows.Networking.HostName("localhost");
this.clientListBox.Items.Add("client is trying to connect...");
await streamSocket.ConnectAsync(hostName, StreamSocketAndListenerPage.PortNumber);
this.clientListBox.Items.Add("client connected");
// Send a request to the echo server.
string request = "Hello, World!";
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(request);
await streamWriter.FlushAsync();
}
}
this.clientListBox.Items.Add(string.Format("client sent the request: \"{0}\"", request));
// Read data from the echo server.
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
response = await streamReader.ReadLineAsync();
}
}
this.clientListBox.Items.Add(string.Format("client received the response: \"{0}\" ", response));
}
this.clientListBox.Items.Add("client closed its socket");
}
catch (Exception ex)
{
Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult);
this.clientListBox.Items.Add(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message);
}
}
public async Task SendCommand(string command)
{
if ((_Host != null) && (_PortNumber != null))
{
ShowMessage("Connecting to " + _Host + ":" + _PortNumber);
streamSocket = new Windows.Networking.Sockets.StreamSocket();
try
{
var hostName = new Windows.Networking.HostName(_Host);
await streamSocket.ConnectAsync(hostName, _PortNumber);
ShowMessage("Connected!");
using (Stream outputStream = streamSocket.OutputStream.AsStreamForWrite())
{
using (var streamWriter = new StreamWriter(outputStream))
{
await streamWriter.WriteLineAsync(command);
await streamWriter.FlushAsync();
ShowMessage("Sent!");
}
}
// Read data from the echo server.
string response;
using (Stream inputStream = streamSocket.InputStream.AsStreamForRead())
{
using (StreamReader streamReader = new StreamReader(inputStream))
{
if (!streamReader.EndOfStream)
{
response = await streamReader.ReadLineAsync();
ShowMessage(response);
}
}
}
streamSocket.Dispose();
}
catch (Exception E)
{
ShowMessage(E.Message);
}
}
}
/// <summary>
/// @see http://www.johnthom.com/implementing-ssdp-search-in-windows-phone-8-using-winrt/
/// </summary>
public async Task DiscoverDevices()
{
int timeout = 3000;
var remoteIp = "239.255.255.250";
var remoteIpHostName = new Windows.Networking.HostName(remoteIp);
var port = "1900";
string query = "M-SEARCH * HTTP/1.1\r\n" +
"HOST: 239.255.255.250:1900\r\n" +
"ST: upnp:rootdevice\r\n" +
"MAN: \"ssdp:discover\"\r\n" +
"MX: " + timeout.ToString() + "\r\n\r\n";
var buffer = Encoding.UTF8.GetBytes(query);
using (var socket = new DatagramSocket())
{
socket.MessageReceived += (sender, args) => {
Task.Run(() => {
using (var reader = args.GetDataReader())
{
byte[] respBuff = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(respBuff);
string response = Encoding.UTF8.GetString(respBuff, 0, respBuff.Length).ToLower();
response.Trim('\0');
ProcessSSDPResponse(response);
}
});
};
await socket.BindEndpointAsync(null, "");
socket.JoinMulticastGroup(remoteIpHostName);
using (var stream = await socket.GetOutputStreamAsync(remoteIpHostName, port))
{
await stream.WriteAsync(buffer.AsBuffer());
}
// Execute within timeout
await Task.Delay(timeout);
}
}
internal async Task<IList<Camera>> probeTask()
{
var cameras = new List<Camera>();
var cameraAddressMap = new Dictionary<string, Camera>();
listener.MessageReceived += (DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) =>
{
try
{
var reader = args.GetDataReader();
var bytesRemaining = reader.UnconsumedBufferLength;
var receivedString = reader.ReadString(bytesRemaining);
var soapEnvelope = new XmlDocument();
soapEnvelope.LoadXml(receivedString);
//var probeMatches = soapEnvelope.GetElementsByTagName("wsdd:ProbeMatch");
var probeMatches = soapEnvelope.SelectNodesNS("//wsdd:ProbeMatch", "xmlns:wsdd='http://schemas.xmlsoap.org/ws/2005/04/discovery'");
foreach (var probeMatch in probeMatches)
{
Debug.WriteLine(probeMatch.GetXml());
var endpointAddressNode = probeMatch.SelectSingleNodeNS("wsa:EndpointReference/wsa:Address", "xmlns:wsdd='http://schemas.xmlsoap.org/ws/2005/04/discovery' xmlns:wsa='http://schemas.xmlsoap.org/ws/2004/08/addressing'");
var xAddressNode = probeMatch.SelectSingleNodeNS("wsdd:XAddrs", "xmlns:wsdd='http://schemas.xmlsoap.org/ws/2005/04/discovery' xmlns:wsa='http://schemas.xmlsoap.org/ws/2004/08/addressing'");
var cameraAddress = endpointAddressNode.InnerText;
var cameraUri = xAddressNode.InnerText;
if (!cameraAddressMap.ContainsKey(cameraAddress))
{
var uri = new Uri(cameraUri);
var cameraInstance = new Camera(cameraAddress, uri);
cameras.Add(cameraInstance);
cameraAddressMap.Add(cameraAddress, cameraInstance);
}
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message + "\n" + e.StackTrace);
}
};
await listener.BindEndpointAsync(null, string.Empty);
var ssdp = new Windows.Networking.HostName("239.255.255.250");
listener.JoinMulticastGroup(ssdp);
using (var stream = await listener.GetOutputStreamAsync(ssdp, "3702"))
{
using (var writer = new DataWriter(stream))
{
string req = GetRequestString();
writer.WriteString(req);
await writer.StoreAsync();
await Task.Delay(5000);
}
}
return cameras;
}
