void OnResolveCompletion(PPError result)
{
if (result != PPError.Ok)
{
PostMessage("Resolve failed.");
return;
}
var addr = PPBHostResolver.GetNetAddress(resolver_, 0);
PostMessage($"Resolved: {(Var)PPBNetAddress.DescribeAsString(addr, PPBool.True)}");
var callback = new CompletionCallback(OnConnectCompletion);
if (IsUDP)
{
PostMessage("Binding ...");
remote_host_ = new PPResource(addr);
var ipv4_addr = new PPNetAddressIPv4(0);
PPBUDPSocket.Bind(udp_socket_, addr, callback);
}
else
{
PostMessage("Connecting ...");
PPBTCPSocket.Connect(tcp_socket_, addr, callback);
}
}
void TryRead()
{
PPBTCPSocket.Read(incomingSocket,
receiveBuffer,
BUFFER_SIZE,
new CompletionCallback(OnReadCompletion));
}
void TryAccept()
{
var onAcceptCompletionCallback = new CompletionCallbackWithOutput <PPResource>(OnAcceptCompletion);
PPBTCPSocket.Accept(listeningSocket,
out onAcceptCompletionCallback.OutputAdapter.output,
onAcceptCompletionCallback);
}
void Connect(string host, bool tcp)
{
if (IsConnected)
{
PostMessage("Already connected.");
return;
}
if (tcp)
{
tcp_socket_ = PPBTCPSocket.Create(this);
if (PPBTCPSocket.IsTCPSocket(tcp_socket_) == PPBool.False)
{
PostMessage("Error creating TCPSocket.");
return;
}
}
else
{
udp_socket_ = PPBUDPSocket.Create(this);
if (PPBUDPSocket.IsUDPSocket(udp_socket_) == PPBool.False)
{
PostMessage("Error creating UDPSocket.");
return;
}
}
resolver_ = PPBHostResolver.Create(this);
if (PPBHostResolver.IsHostResolver(resolver_) == PPBool.False)
{
PostMessage("Error creating HostResolver.");
return;
}
ushort port = 80;
var hostname = host;
int pos = host.IndexOf(':');
if (pos > 0)
{
hostname = host.Substring(0, pos);
port = ushort.Parse(host.Substring(pos + 1));
}
var hint = new PPHostResolverHint()
{
family = PPNetAddressFamily.Unspecified, flags = 0
};
PPBHostResolver.Resolve(resolver_,
hostname,
port,
hint,
new CompletionCallback(OnResolveCompletion));
PostMessage("Resolving ...");
}
void Send(string message)
{
if (!IsConnected)
{
PostMessage("Not connected.");
return;
}
if (send_outstanding_)
{
PostMessage("Already sending.");
return;
}
var data = Encoding.UTF8.GetBytes(message);
var size = data.Length;
var callback = new CompletionCallback(OnSendCompletion);
int result = 0;
if (IsUDP)
{
result = PPBUDPSocket.SendTo(udp_socket_, data, size, remote_host_, callback);
}
else
{
result = PPBTCPSocket.Write(tcp_socket_, data, size, callback);
}
string status = string.Empty;
if (result < 0)
{
if ((PPError)result == PPError.OkCompletionpending)
{
status = $"Sending bytes: {size}";
PostMessage(status);
send_outstanding_ = true;
}
else
{
status = $"Send returned error: {result}";
PostMessage(status);
}
}
else
{
status = $"Sent bytes synchronously: {result}";
PostMessage(status);
}
}
void Receive()
{
if (IsUDP)
{
Array.Clear(receive_buffer_, 0, receive_buffer_.Length);
var OnReceiveFromCompletionCallback = new CompletionCallbackWithOutput <PPResource>(OnReceiveFromCompletion);
PPBUDPSocket.RecvFrom(udp_socket_, receive_buffer_, kBufferSize, out OnReceiveFromCompletionCallback.OutputAdapter.output, OnReceiveFromCompletionCallback);
}
else
{
Array.Clear(receive_buffer_, 0, receive_buffer_.Length);
PPBTCPSocket.Read(tcp_socket_, receive_buffer_, kBufferSize, new CompletionCallback(OnReceiveCompletion));
}
}
private void OnAcceptCompletion(PPError result, PPResource socket)
{
if (result != PPError.Ok)
{
instance.PostMessage($"server: Accept failed: {result}");
return;
}
var addr = PPBTCPSocket.GetLocalAddress(socket);
instance.PostMessage($"server: New connection from: {((Var)PPBNetAddress.DescribeAsString(addr, PPBool.True)).ToString()}");
incomingSocket = new PPResource(socket);
TryRead();
}
private void OnListenCompletion(PPError result)
{
var status = string.Empty;
if (result != PPError.Ok)
{
instance.PostMessage($"server: Listen failed with: {result}");
return;
}
var addr = PPBTCPSocket.GetLocalAddress(listeningSocket);
instance.PostMessage($"server: Listening on: {((Var)PPBNetAddress.DescribeAsString(addr, PPBool.True)).AsString()}");
TryAccept();
}
private void OnBindCompletion(PPError result)
{
if (result != PPError.Ok)
{
instance.PostMessage($"server: Bind failed with: {result}");
return;
}
var rtn = (PPError)PPBTCPSocket.Listen(listeningSocket,
BACK_LOG,
new CompletionCallback(OnListenCompletion));
if (rtn != PPError.OkCompletionpending)
{
instance.PostMessage("server: Error listening on server socket.");
return;
}
}
void Close()
{
if (!IsConnected)
{
PostMessage("Not connected.");
return;
}
if (tcp_socket_.IsEmpty)
{
PPBUDPSocket.Close(udp_socket_);
udp_socket_.Dispose();
}
else
{
PPBTCPSocket.Close(tcp_socket_);
tcp_socket_.Dispose();
}
PostMessage("Closed connection.");
}
private void OnReadCompletion(PPError result)
{
var status = string.Empty;
if ((int)result <= 0)
{
if ((int)result == 0)
{
status = "server: client disconnected";
}
else
{
status = $"server: Read failed: {result}";
}
instance.PostMessage(status);
// Remove the current incoming socket and try
// to accept the next one.
PPBTCPSocket.Close(incomingSocket);
incomingSocket.Dispose();
TryAccept();
return;
}
status = $"server: Read {(int)result} bytes";
instance.PostMessage(status);
// Echo the bytes back to the client
result = (PPError)PPBTCPSocket.Write(incomingSocket,
receiveBuffer,
(int)result,
new CompletionCallback(OnWriteCompletion));
if (result != PPError.OkCompletionpending)
{
instance.PostMessage($"server: Write failed: {result}");
}
}
void Start(short port)
{
listeningSocket = PPBTCPSocket.Create(instance);
if (PPBTCPSocket.IsTCPSocket(listeningSocket) == PPBool.False)
{
instance.PostMessage("Error creating TCPSocket.");
return;
}
instance.PostMessage($"Starting server on port: {port}");
// Attempt to listen on all interfaces (0.0.0.0)
// on the given port number.
//var ipv4_addr = new PPNetAddressIPv4((ushort)IPAddress.HostToNetworkOrder(port));
var addr = new NetAddress(instance, (ushort)IPAddress.HostToNetworkOrder(port));
var rtn = (PPError)PPBTCPSocket.Bind(listeningSocket, addr, new CompletionCallback(OnBindCompletion));
if (rtn != PPError.OkCompletionpending)
{
instance.PostMessage("Error binding listening socket.");
return;
}
}