/// <summary>
/// Handler for forwarded connections.
/// </summary>
/// <param name="connection">
/// The connection being forwarded.
/// </param>
/// <returns>
/// True if forwarding was established, false otherwise.
/// </returns>
private bool Forwarding(ServiceConnection connection)
{
Socket localService = StaticUtilities.CreateConnectedSocket(
"localhost",
HomeOS.Hub.Common.Constants.InfoServicePort);
NetworkStream netstream = new NetworkStream(localService, true /*ownSocket*/);
if (localService != null)
{
Forwarder forwarder = new Forwarder(
netstream,
connection.GetStream(),
this.StopForwarding, null);
return(true);
}
return(false);
}
private void Register()
{
// -
// Register ourselves with the cloud service.
// Then wait for it to send us client forwarding requests.
// -
Socket socket = StaticUtilities.CreateConnectedSocket(
Settings.ServiceHost,
Settings.ServicePort);
if (socket == null)
{
this.ExitCode = 1066; // 1066 = "The service has returned a service-specific error code." Or 10054? 10064? 10065?
OnStop();
return;
}
this.registrationConnection = new ServiceConnection(
Settings.ServiceHost,
socket,
0,
this.Forwarding, logger);
}
/// <summary>
/// Handler for all message types.
/// </summary>
/// <remarks>
/// Note we must not operate on the passed-in 'data' parameter after
/// this routine returns, as it just references the receive buffer.
/// </remarks>
/// <param name="type">The message type.</param>
/// <param name="data">The message data.</param>
/// <returns>
/// True if we entered send mode as a result of receiving this message,
/// false if we're staying in receive mode and should re-start receive.
/// </returns>
private bool HandleMessage(MessageType type, ArraySegment <byte> data)
{
#if DEBUG
logger.Log(
"HomeService Received '{0}' message with {1} bytes of data.",
type.ToString(),
data.Count.ToString());
#endif
switch (type)
{
case MessageType.PadN:
break;
case MessageType.EchoRequest:
this.bufferOffset = 0;
this.AppendMessage(MessageType.EchoReply, data);
this.SendMessage();
return(true);
case MessageType.EchoReply:
break;
case MessageType.Version:
if (data.Count != sizeof(byte))
{
this.ShutdownAndClose();
return(true);
}
this.peerProtocolVersion = data.Array[data.Offset];
#if DEBUG
logger.Log(
" HomeService Server is using protocol version #{0}",
this.peerProtocolVersion.ToString());
#endif
break;
case MessageType.PleaseIdentify:
#if DEBUG
logger.Log(" HomeService Sending Identification message");
#endif
this.bufferOffset = 0;
this.AppendMessage(
MessageType.Identification,
System.Text.Encoding.ASCII.GetBytes(this.identifier));
this.SendMessage();
return(true);
case MessageType.PleaseAuthenticate:
if (data.Count != sizeof(byte))
{
this.ShutdownAndClose();
return(true);
}
AuthenticationType authType =
(AuthenticationType)data.Array[data.Offset];
#if DEBUG
logger.Log(
" HomeService Authentication request is for type {0}",
authType.ToString());
logger.Log(" HomeService Sending SimpleAuthentication message");
#endif
this.bufferOffset = 0;
this.AppendMessage(
MessageType.SimpleAuthentication,
BitConverter.GetBytes(this.simpleAuthentication));
this.SendMessage();
return(true);
case MessageType.Authenticated:
this.bufferOffset = 0;
if (this.clientToken == 0)
{
#if DEBUG
logger.Log(" Sending RegisterService message");
#endif
this.AppendMessage(MessageType.RegisterService);
}
else
{
#if DEBUG
logger.Log(" Sending ForwardToClient message");
#endif
this.AppendMessage(
MessageType.ForwardToClient,
BitConverter.GetBytes(this.clientToken));
this.forwarding = true;
}
this.SendMessage();
return(true);
case MessageType.ClientAwaits:
if (data.Count != sizeof(uint))
{
this.ShutdownAndClose();
return(true);
}
uint clientToken = BitConverter.ToUInt32(
data.Array,
data.Offset);
#if DEBUG
logger.Log(" Client with instance token {0} awaits matchup.", clientToken.ToString());
logger.Log(" Launching client connection to connect back in and match up with gatekeeper client instance.");
#endif
// -
// Note about garbage collection (GC).
// The ServiceConnection constructor will have initiated
// one or more async receive calls by the time it returns.
// ReceiveAsync holds a reference to the
// SocketAsyncEventArgs object in use, and that object
// holds a reference to the ServiceConnection. Everything
// is driven off receive handlers, so some reference to the
// new ServiceConnection should remain around until the
// forwarding handler is invoked (or connection closed).
// -
Socket socket = StaticUtilities.CreateConnectedSocket(
this.socket.RemoteEndPoint);
if (null != socket)
{
ServiceConnection client = new ServiceConnection(
this.sslServerHost,
socket,
clientToken,
this.handler, this.logger);
}
break;
default:
#if DEBUG
logger.Log(" ** Unexpected message! Closing! **");
#endif
this.ShutdownAndClose();
return(true);
}
return(false);
}