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 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));
}
}
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 OnConnectCompletion(PPError result)
{
if (result != PPError.Ok)
{
var status = $"Connection failed: {result}";
PostMessage(status);
return;
}
if (IsUDP)
{
var addr = PPBUDPSocket.GetBoundAddress(udp_socket_);
PostMessage($"Bound to: {((Var)PPBNetAddress.DescribeAsString(addr, PPBool.True)).AsString()}");
}
else
{
PostMessage("Connected");
}
Receive();
}
