async void loginButton_Clicked(object sender, EventArgs e)
{
StringBuilder sb = new StringBuilder("https://accounts.google.com/o/oauth2/auth");
// append query strings
sb.Append("?");
sb.Append("scope=email%20profile&");
sb.Append("redirect_uri=http://localhost:" + LISTEN_PORT + "&");
sb.Append("response_type=code&");
sb.Append("client_id=" + APP_ID);
Debug.WriteLine("url: " + sb.ToString());
webView.Source = sb.ToString();
webView.IsVisible = true;
TcpSocketListener listener = new TcpSocketListener();
listener.ConnectionReceived += DidConnect;
await listener.StartListeningAsync(LISTEN_PORT);
//HttpClient mClient = new HttpClient
//{
// BaseAddress = new Uri("https://accounts.google.com/o/oauth2/auth")
//};
//http://stackoverflow.com/questions/17096201/build-query-string-for-system-net-httpclient-get
}
// Listening TCP
public async void StartListeningTcp()
{
var listenPort = 25000;
var listener = new TcpSocketListener();
// when we get connections, read byte-by-byte from the socket's read stream
listener.ConnectionReceived += async(sender, args) =>
{
var client = args.SocketClient;
var bytesRead = -1;
var buf = new byte[1200];
while (bytesRead != 0)
{
bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, buf.Length);
if (bytesRead > 0)
{
}
}
Debug.WriteLine($"Buffer: {buf.Length}");
data = System.Text.Encoding.UTF8.GetString(buf, 0, buf.Length);
await Task.Delay(TimeSpan.FromMilliseconds(500));
Debug.WriteLine($"Result: {data}");
// FIXME
Device.BeginInvokeOnMainThread(() =>
{
dataFromServer.Text = data;
DisplayAlert("Data From Server", data, "OK");
});
bytesRead = 0;
};
// bind to the listen port across all interfaces
await listener.StartListeningAsync(listenPort);
}
[InlineData(1000)] // yes buffered stream
public async Task TcpSocketClient_ShouldBeAbleToDisconnectThenReconnect(int bufferSize)
{
TcpSocketClient sut = null;
var port = PortGranter.GrantPort();
var listener = new TcpSocketListener();
await listener.StartListeningAsync(port);
if (bufferSize != -1)
{
sut = new TcpSocketClient(bufferSize);
}
else
{
sut = new TcpSocketClient();
}
await sut.ConnectAsync("127.0.0.1", port);
await sut.DisconnectAsync();
await sut.ConnectAsync("127.0.0.1", port);
await sut.DisconnectAsync();
await listener.StopListeningAsync();
}
private Task ExecuteServerListener(AutoResetEvent e)
{
return(Task.Run(() =>
{
_log = LogManager?.CreateLog(typeof(FtpServer));
using (var listener = new TcpSocketListener(0))
{
listener.ConnectionReceived = ConnectionReceived;
try
{
e.Reset();
listener.StartListeningAsync(Port).Wait();
_log?.Debug("Server listening on port {0}", Port);
try
{
e.WaitOne();
}
finally
{
listener.StopListeningAsync().Wait();
foreach (var connection in _connections.ToArray())
{
connection.Close();
}
}
}
catch (Exception ex)
{
_log?.Fatal(ex, "{0}", ex.Message);
}
}
}
));
}
public FileServerService(FileServerServiceSettings settings)
{
this.settings = settings;
this.InitializeTcpPacketProcessor();
this.tcpSocketListener = new TcpSocketListener(this.settings.ListenIP, this.settings.Port);
this.fileServers = new Dictionary <int, FileServer>();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
this.deferral = taskInstance.GetDeferral();
var listenPort = 11000;
var listener = new TcpSocketListener();
// when we get connections, read byte-by-byte from the socket's read stream
listener.ConnectionReceived += async(sender, args) =>
{
var client = args.SocketClient;
var bytesRead = -1;
var buf = new byte[1];
while (bytesRead != 0)
{
bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1);
if (bytesRead > 0)
{
Debug.Write(buf[0]);
}
}
};
// bind to the listen port across all interfaces
listener.StartListeningAsync(listenPort);
}
private void InitListener()
{
string hostName = Dns.GetHostName();
IPAddress[] ipasAddresses = Dns.GetHostAddresses(hostName);
List <IPAddress> list = new List <IPAddress>(ipasAddresses)
{
IPAddress.Parse("127.0.0.1")
};
_Listeners = new List <ISocketListener>(list.Count);
foreach (IPAddress ipa in list)
{
ListenerInfo info = new ListenerInfo()
{
BackLog = Config.BackLog,
EndPoint = new IPEndPoint(ipa, Config.ListenPort)
};
ISocketListener socketListener = new TcpSocketListener(info);
socketListener.NewClientAccepted += tcpSocketListener_NewClientAccepted;
socketListener.Error += tcpSocketListener_Error;
socketListener.Stopped += tcpSocketListener_Stopped;
socketListener.Start();
_Listeners.Add(socketListener);
}
}
public async Task Listen(int port)
{
var myIP = GetLocalIPAddress();
_inChannel = new TcpSocketListener();
// when we get connections, read byte-by-byte from the socket's read stream
_inChannel.ConnectionReceived += async(sender, args) =>
{
RaiseInfoEvent("Client Connected!");
var client = args.SocketClient;
var bytesRead = -1;
var buf = new byte[1];
while (bytesRead != 0)
{
bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1);
if (bytesRead > 0)
{
Debug.Write(buf[0]);
}
RaiseInfoEvent(string.Format("Client sent: {0}", buf[0]));
}
};
// bind to the listen port across all interfaces
await _inChannel.StartListeningAsync(inPort);
IsListening = true;
RaiseInfoEvent(string.Format("Listening at {0}", myIP));
RaiseInChannelStarted(true);
}
public ConnectionServer()
{
Client = new JBVClient(SoftwareID.ConnectionServer);
router = new Router();
leaseHandler = new LeaseHandler();
logHandler = new LogHandler();
DummyConnection cRouter1 = new DummyConnection();
DummyConnection cRouter2 = new DummyConnection();
DummyConnection cRouter3 = new DummyConnection();
router.AddConnection(cRouter1);
router.AddConnection(cRouter2);
router.AddConnection(cRouter3);
DummyConnection.CoupleConnections(cRouter1, Client.Connection);
DummyConnection.CoupleConnections(cRouter2, leaseHandler.Connection);
DummyConnection.CoupleConnections(cRouter3, logHandler.Connection);
listener = new TcpSocketListener();
listener.OnClientAccept += (sender, client) => router.AddConnection(new TCPConnection(client));
listener.BeginListening(Settings.Items.ListenerPort);
}
public TcpSocketListenerPage()
{
_listener = new TcpSocketListener();
_messagesSub = new Subject <Message>();
_messagesObs = _messagesSub.AsObservable();
_listener.ConnectionReceived += (sender, args) =>
{
var client = args.SocketClient;
Device.BeginInvokeOnMainThread(() => _clients.Add(client));
Task.Factory.StartNew(() =>
{
foreach (var msg in client.ReadStrings(_canceller.Token))
{
_messagesSub.OnNext(msg);
}
Device.BeginInvokeOnMainThread(() => _clients.Remove(client));
}, TaskCreationOptions.LongRunning);
};
InitView();
}
private async Task ExecuteServerListener(CancellationToken cancellationToken)
{
_log = LogManager?.CreateLog(typeof(FtpServer));
using (var listener = new TcpSocketListener(0))
{
listener.ConnectionReceived = ConnectionReceived;
try
{
await listener.StartListeningAsync(Port);
try
{
for (; ;)
{
cancellationToken.ThrowIfCancellationRequested();
await Task.Delay(100, cancellationToken);
}
}
finally
{
await listener.StopListeningAsync();
foreach (var connection in _connections.ToArray())
{
connection.Close();
}
}
}
catch (Exception ex)
{
_log?.Fatal(ex, "{0}", ex.Message);
}
}
}
public CitpTcpListenService(ICitpLogService log, IpAddress nicAddress)
{
_log = log;
_nicAddress = nicAddress;
_listener = new TcpSocketListener();
_listener.ConnectionReceived += connectionReceived;
_cancellationTokenSource = new CancellationTokenSource();
}
//constructor
public Listener(int mPortNum)
{
isListening = false;
this.listenerUDP = new UdpSocketReceiver();
this.listenerTCP = new TcpSocketListener();
this.portNum = mPortNum;
}
private async Task <IObservable <IHttpRequestReponse> > GetTcpRequestResponseObservable(
int port,
ICommunicationInterface communicationInterface = null,
bool allowMultipleBindToSamePort = false)
{
var tcpListener = new TcpSocketListener();
var observeTcpRequest = await tcpListener.CreateObservableListener(
port,
communicationInterface,
allowMultipleBindToSamePort);
var observable = Observable.Create <IHttpRequestReponse>(
obs =>
{
var disp = observeTcpRequest.Subscribe(
tcpSocket =>
{
var stream = tcpSocket.ReadStream;
var requestHandler = new HttpParserDelegate
{
HttpRequestReponse =
{
RemoteAddress = tcpSocket.RemoteAddress,
RemotePort = tcpSocket.RemotePort,
TcpSocketClient = tcpSocket,
RequestType = RequestType.TCP
}
};
var result = _httpStreamParser.Parse(requestHandler, stream, Timeout);
obs.OnNext(result);
},
ex =>
{
Cleanup();
obs.OnError(ex);
},
() =>
{
Cleanup();
obs.OnCompleted();
});
return(disp);
void Cleanup()
{
_tcpListenerPortToObservable.Remove(port);
tcpListener.Dispose();
}
});
return(observable);
}
public DatabaseServerChannelIncoming(TcpSocketListener tcpListener, ILogger logger)
{
this._tcpListener = tcpListener ?? throw new ArgumentNullException(nameof(tcpListener));
this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
this._tcpListener.Clients.OnClientAdded += Clients_OnClientAdded;
this._tcpListener.Clients.OnClientRemoved += Clients_OnClientRemoved;
this._isRunning = false;
}
public async Task StartServer(int port, bool singleConnection, int retryCount = 1)
{
// Create TCP listener
var listener = new TcpSocketListener(2048);
listener.ConnectionReceived = async(sender, args) =>
{
var clientSocketContext = new SimpleSocket();
try
{
// Stop listening if we accept only a single connection
if (singleConnection)
{
await listener.StopListeningAsync();
}
clientSocketContext.SetSocket((TcpSocketClient)args.SocketClient);
// Do an ack with magic packet (necessary so that we know it's not a dead connection,
// it sometimes happen when doing port forwarding because service don't refuse connection right away but only fails when sending data)
await SendAndReceiveAck(clientSocketContext.socket, MagicAck, MagicAck);
if (Connected != null)
{
Connected(clientSocketContext);
}
clientSocketContext.isConnected = true;
}
catch (Exception)
{
clientSocketContext.DisposeSocket();
}
};
for (int i = 0; i < retryCount; ++i)
{
try
{
// Start listening
await listener.StartListeningAsync(port);
break; // Break if no exception, otherwise retry
}
catch (Exception)
{
// If there was an exception last try, propragate exception
if (i == retryCount - 1)
{
throw;
}
}
}
}
//constructor
public Listener(int mPortNum, bool mTcpOnly = false)
{
isListening = false;
if (!mTcpOnly)
{
this.listenerUDP = new UdpSocketReceiver();
}
this.listenerTCP = new TcpSocketListener();
this.portNum = mPortNum;
}
public async Task TcpSocketClient_ShouldBeAbleToConnect()
{
var port = PortGranter.GrantPort();
var listener = new TcpSocketListener();
await listener.StartListeningAsync(port);
var sut = new TcpSocketClient();
await sut.ConnectAsync("127.0.0.1", port);
await listener.StopListeningAsync();
// getting here means nothing went boom
Assert.True(true);
}
private async Task CreateJsonTcpListener()
{
var speechListenPort = 12000;
jsonTcpListener = new TcpSocketListener();
jsonTcpListener.ConnectionReceived += async(sender, args) =>
{
var client = args.SocketClient;
var bytesRead = -1;
var buf = new byte[1024];
while (bytesRead != 0)
{
bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1024);
if (bytesRead > 0)
{
var text = Encoding.UTF8.GetString(buf, 0, bytesRead);
// Ugly hack to avoid crash
try
{
myModel = JsonConvert.DeserializeObject <DataModel>(text);
Device.BeginInvokeOnMainThread(() =>
{
UpdateUI();
UpdateView();
});
}
catch
{
myModel.textToSpeech = "";
}
}
}
};
// bind to the listen port across all interfaces
await jsonTcpListener.StartListeningAsync(speechListenPort);
}
private async Task <bool> StartListener()
{
try
{
//TODO: Handle port already open error
_listener = new TcpSocketListener();
_listener.ConnectionReceived += Listener_ConnectionReceived;
await _listener.StartListeningAsync(_listenPort);
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
return(false);
}
}
public async Task Listen(int listenPort)
{
StringBuilder sbResult = new StringBuilder();
var listener = new TcpSocketListener();
// when we get connections, read byte-by-byte from the socket's read stream
listener.ConnectionReceived += async(sender, args) =>
{
var client = args.SocketClient;
Console.WriteLine("Connection Received");
Console.WriteLine("Connection Received Details: " + client.RemoteAddress + ":" + client.RemotePort);
byte[] buffer = new byte[2048]; // read in chunks of 2KB
int bytesRead = args.SocketClient.ReadStream.Read(buffer, 0, buffer.Length);
while (bytesRead > 0)
{
string result = Encoding.Default.GetString(buffer).Trim().Replace("\0", "");
sbResult.Append(result);
Console.WriteLine("Received (Byte): " + result + " - bytesRead " + bytesRead);
buffer = new byte[2048];
InvokeMessageReceived(client.RemoteAddress, client.RemotePort, sbResult.ToString());
bytesRead = args.SocketClient.ReadStream.Read(buffer, 0, buffer.Length);
sbResult = new StringBuilder();
await SendMessage(sbResult.ToString());
}
};
// bind to the listen port across all interfaces
await listener.StartListeningAsync(listenPort);
Console.WriteLine("Listening on " + listenPort);
}
public void Start()
{
DeviceCache.Current.Init();
BlackTableHelper.Load();
ServerInstrumentation.Current.Init();
if (File.Exists("data.txt"))
{
File.Delete("data.txt");
}
var port = CurrencyStoreSection.Instance.Server.Port;
var queue = CurrencyStoreSection.Instance.Server.Backlog;
socketListener = new TcpSocketListener(IPAddress.Any, port, queue);
socketListener.SocketConnected += new EventHandler <SocketEventArgs>(SocketConnected);
socketListener.Start();
//processor.Start();
}
public string revc_text(int length)
{
string result = "";
var listener = new TcpSocketListener();
listener.ConnectionReceived += async(sender, args) =>
{
var _client = args.SocketClient;
List <byte> all_byte = new List <byte>();
for (int i = 0; i < length; i++)
{
var nextByte = await Task.Run(() => client.ReadStream.ReadByte());
all_byte.Add((byte)nextByte);
}
result = (new System.Text.UTF8Encoding()).GetString(all_byte.ToArray(), 0, all_byte.Count);
};
listener.StartListeningAsync(port[0]);
return(result);
}
static void server()
{
Console.Title = "Server";
Console.WriteLine("Waiting for client...");
TcpSocketListener l = new TcpSocketListener(1000);
TcpSocket client = null;
l.Accepted += (s, e) =>
{
Console.WriteLine("Client accepted!");
client = e.AcceptedSocket;
beginChat(true, client);
l.Stop();
};
l.Start();
while (true)
{
string msg = Console.ReadLine();
if (client.Connected)
{
if (msg.ToLower() != "disconnect")
{
byte[] msgPayload = Encoding.ASCII.GetBytes(msg);
client.SendAsync(msgPayload);
}
else
{
client.Disconnect();
break;
}
}
else
{
break;
}
}
server();
}
public async Task Server(string listeningAddress, int listeningPort, string sendingAddress, int sendingPort)
{
var listener = new TcpSocketListener();
Console.WriteLine("Listening on " + listeningAddress + " at " + listeningPort);
// when we get connections, read byte-by-byte from the socket's read stream
listener.ConnectionReceived += async(sender, args) =>
{
var client = args.SocketClient;
var bytesRead = -1;
var buf = new byte[1024];
List <byte> data = new List <byte>();
while (bytesRead != 0)
{
bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1024);
if (bytesRead > 0)
{
data.AddRange(buf.ToList());
}
}
string result = Encoding.ASCII.GetString(data.Where(x => x != 0).ToArray()).Trim();
Console.WriteLine("Received " + result + " from " + args.SocketClient.RemoteAddress + " at " + args.SocketClient.RemotePort);
Console.WriteLine("Sending " + result + " to " + args.SocketClient.RemoteAddress + " at " + sendingPort);
await SendData(args.SocketClient.RemoteAddress, sendingPort, result);
//Console.WriteLine("Sending " + result + " to " + args.SocketClient.RemoteAddress + " at " + args.SocketClient.RemotePort);
//await SendData(args.SocketClient.RemoteAddress, args.SocketClient.RemotePort, result);
};
// bind to the listen port across all interfaces
await listener.StartListeningAsync(listeningPort);
}
public async Task TcpSocketClient_ShouldSendReceiveData()
{
var bytesToSend = new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5 };
var len = bytesToSend.Length;
var port = PortGranter.GrantPort();
var listener = new TcpSocketListener();
await listener.StartListeningAsync(port);
var tcs = new TaskCompletionSource <bool>();
listener.ConnectionReceived += async(sender, args) =>
{
var bytesReceived = new byte[len];
await args.SocketClient.ReadStream.ReadAsync(bytesReceived, 0, len);
var allSame =
Enumerable
.Zip(bytesToSend,
bytesReceived,
(s, r) => s == r)
.All(b => b);
tcs.SetResult(allSame);
};
var client = new TcpSocketClient();
await client.ConnectAsync("127.0.0.1", port);
await client.WriteStream.WriteAsync(bytesToSend, 0, len);
var ok = await tcs.Task;
await listener.StopListeningAsync();
Assert.True(ok);
}
private static void Main()
{
Console.Write("input server ip address:");
var readLine = Console.ReadLine();
while (readLine == null || !IPAddress.TryParse(readLine, out _address))
{
Console.WriteLine("wrong ip address");
Console.Write("input server ip address:");
readLine = Console.ReadLine();
}
Console.Write("input server port:");
while (!ushort.TryParse(Console.ReadLine(), out _port))
{
Console.WriteLine("wrong port number");
Console.Write("input server port:");
}
var server = new TcpSocketListener();
CommandDispatcher.ServerListener = server;
server.SocketAcceptd += args =>
{
args.AcceptClient.TcpDataReceived += eventArgs =>
{
};
};
Console.WriteLine(server.Start(new IPEndPoint(_address, _port)) ? "server started" : "server start failed");
var channel = new IpcServerChannel("PrizeClawControlChannel");
ChannelServices.RegisterChannel(channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(CommandDispatcher), nameof(CommandDispatcher), WellKnownObjectMode.SingleCall);
while (!_isInProcess)
{
Thread.Sleep(10000);
}
}
public async Task WaitForCompanion()
{
Serializer = new ProtobufNetworkSerializer();
var tcs = new TaskCompletionSource <bool>();
listener = new TcpSocketListener();
listener.ConnectionReceived += (s, e) =>
{
Serializer.ObjectDeserialized += SimpleNetworkSerializerObjectDeserialized;
tcs.TrySetResult(true);
client = e.SocketClient;
try
{
Serializer.ReadFromStream(client.ReadStream);
}
catch (Exception exc)
{
//show error?
}
};
await listener.StartListeningAsync(Port);
await tcs.Task;
}
public void Start()
{
DeviceCache.Current.Init();
BlackTableHelper.Load();
ServerInstrumentation.Current.Init();
if (File.Exists("data.txt"))
{
File.Delete("data.txt");
}
var port = CurrencyStoreSection.Instance.Server.Port;
var queue = CurrencyStoreSection.Instance.Server.Backlog;
socketListener = new TcpSocketListener(IPAddress.Any, port, queue);
socketListener.SocketConnected += new EventHandler<SocketEventArgs>(SocketConnected);
socketListener.Start();
//processor.Start();
}
public Listener()
{
_listener = new TcpSocketListener(10);
_listener.ConnectionReceived += _listener_ConnectionReceived;
}
public PacketsPage()
{
InitializeComponent();
tcpPort = SettingsPage.TCPPort;
udpPort = SettingsPage.UDPPort;
tcpServer = new TcpSocketListener();
udpServer = new UdpSocketReceiver();
tcpServer.ConnectionReceived += TcpConnection;
udpServer.MessageReceived += UdpConnection;
Task.Run(async() =>
{
await tcpServer.StartListeningAsync(tcpPort);
await udpServer.StartListeningAsync(udpPort);
SettingsPage.TCPPort = tcpServer.LocalPort;
MessagingCenter.Send(this, Events.BOUND_PORTS_CHANGED, 0);
});
//udpServer.StartListeningAsync(udpPort);
/*
+= async (sender, args) =>
* {
* var client = args.SocketClient;
*
* var bytesRead = -1;
* var buf = new byte[1];
*
* while (bytesRead != 0)
* {
* bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1);
* //if (bytesRead > 0)
* // Debug.Write(buf[0]);
* }
* };
*/
_connection = DependencyService.Get <ISQLiteDb>().GetConnection();
/*
* var demopackets = Packet.GetDemoPackets();
* for (int i = 0; i < demopackets.Count(); i++) {
* _thepackets.Add(demopackets[i]);
* }
* packetListView.ItemsSource = _thepackets;
*/
tcp = new TcpSocketClient();
udp = new UdpSocketClient();
thepacket = new Packet();
MessagingCenter.Subscribe <LoginPage, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsync);
MessagingCenter.Subscribe <ImportCloud, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsyncIC);
MessagingCenter.Subscribe <PacketEditPage, Packet>(this, Events.PACKET_MODIFIED, OnPacketModified);
}
