public override void InitializeTransport()
{
telepathy = new TelepathyWebsocketsMultiplexTransport();
steam = new SteamworksNetworkTransport();
Transport.layer = steam;
}
public void ChangeTo(StatisticsInfo info)
{
Bps.SuspendUpdate();
Pps.SuspendUpdate();
Bps.Add(Tuple.Create(startTime, info.Bps));
Pps.Add(Tuple.Create(startTime, info.Pps));
startTime++;
if (Bps.Count > MaxPoints)
{
Bps.RemoveAt(0);
Pps.RemoveAt(0);
}
Bps.ResumeUpdate();
Pps.ResumeUpdate();
foreach (var key in info.TransportLayer.Keys)
{
TransportLayer.UpdateOrAdd(key, info.TransportLayer[key]);
}
foreach (var key in info.ApplicationLayer.Keys)
{
ApplicationLayer.UpdateOrAdd(key, info.ApplicationLayer[key]);
}
foreach (var key in info.NetworkLayer.Keys)
{
NetworkLayer.UpdateOrAdd(key, info.NetworkLayer[key]);
}
}
public MainWindow()
{
InitializeComponent();
globalData = new GlobalData();
transporLayer = new TransportLayer();
serial = new Serial(globalData, transporLayer);
serial.deviceInfoEvent += device_info_event;
canInterface = new CANInterface(transporLayer, serial);
commandHandler = new CommandHandler(canInterface, transporLayer, serial);
mainGrid.Background = new ImageBrush(new BitmapImage(new Uri(BaseUriHelper.GetBaseUri(this), "assets/3.jpg")));
}
static void DNP3Response(LinkLayer ll, TransportLayer tl, ApplicationLayer al, ref byte[] buffer)
{
var appData = ApplicationLayer.ApplicationResponse(al);
al.ApplicationData = appData;
var transData = TransportLayer.TransportResponse(tl, al);
tl.TransportData = transData;
var linkData = LinkLayer.LinkResponse(ll, tl);
buffer = linkData;
}
public SipStack()
{
var hf = new HeaderFactory();
hf.AddDefaultParsers();
_messageFactory = new MessageFactory(hf);
_transportLayer = new TransportLayer(MessageFactory);
_transportLayer.RequestReceived += OnRequest;
_transportLayer.ResponseReceived += OnResponse;
_transactionManager = new TransactionManager(_transportLayer);
_dialogManager = new DialogManager(this);
_authenticator = new Authenticator();
}
// initialization
public TelepathyWebsocketsMultiplexTransport()
{
// set client to llapi in webgl, telepathy otherwise
if (Application.platform == RuntimePlatform.WebGLPlayer)
{
client = new LLAPITransport();
}
else
{
client = new TelepathyTransport();
}
// server never runs as WebGLPlayer, need to wait for Start call to
// decide which transport to use
}
public void ServerStartWebsockets(string address, int port, int maxConnections)
{
// WebGL host mode should work without errors, even though we can't
// start a server in WebGL
// (can't call LLAPI's AddWebsocketHost in webgl anyway)
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
server = new LLAPITransport();
server.ServerStartWebsockets(address, port, maxConnections);
}
else
{
Debug.LogWarning("ServerStartWebsockets can't be called in WebGL.");
}
}
public void ServerStart(string address, int port, int maxConnections)
{
// WebGL host mode should work without errors, even though we can't
// start a server in WebGL
// (can't use Telepathy threads in webgl anyway)
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
server = new TelepathyTransport();
server.ServerStart(address, port, maxConnections);
}
else
{
Debug.LogWarning("ServerStart can't be called in WebGL.");
}
}
public void ProcessRpc(BitReaderWriter reader)
{
reader.ReadData(m_sender, false);
MyPacket packet;
packet.Data = m_sender.ReceiveStream.Data;
packet.Sender = MyEventContext.Current.Sender;
if (packet.Sender.IsNull)
{
packet.Sender = new EndpointId(Sync.MyId);
}
packet.Timestamp = TimeSpan.Zero;
packet.PayloadOffset = 0;
packet.PayloadLength = (int)m_sender.ReceiveStream.Position;
TransportLayer.HandleOldGameEvent(packet);
}
// initialization
public TelepathyWebsocketsMultiplexTransport()
{
// set client to llapi in webgl, telepathy otherwise
if (Application.platform == RuntimePlatform.WebGLPlayer)
{
#pragma warning disable CS0618 // Type or member is obsolete
client = new LLAPITransport();
#pragma warning restore CS0618 // Type or member is obsolete
}
else
{
client = new TelepathyTransport();
}
// server never runs as WebGLPlayer, need to wait for Start call to
// decide which transport to use
}
public MyVirtualClient(Endpoint endPoint, MyClientStateBase clientState, Sandbox.Game.World.MyPlayer.PlayerId playerId)
{
this.m_clientState = clientState;
this.m_clientState.EndpointId = endPoint;
this.m_clientState.PlayerSerialId = playerId.SerialId;
this.PlayerId = playerId;
TransportLayer.Register(MyMessageId.SERVER_DATA, endPoint.Index, new Action <MyPacket>(this.OnServerData));
TransportLayer.Register(MyMessageId.REPLICATION_CREATE, endPoint.Index, new Action <MyPacket>(this.OnReplicationCreate));
TransportLayer.Register(MyMessageId.REPLICATION_DESTROY, endPoint.Index, new Action <MyPacket>(this.OnReplicationDestroy));
TransportLayer.Register(MyMessageId.SERVER_STATE_SYNC, endPoint.Index, new Action <MyPacket>(this.OnServerStateSync));
TransportLayer.Register(MyMessageId.RPC, endPoint.Index, new Action <MyPacket>(this.OnEvent));
TransportLayer.Register(MyMessageId.REPLICATION_STREAM_BEGIN, endPoint.Index, new Action <MyPacket>(this.OnReplicationStreamBegin));
TransportLayer.Register(MyMessageId.JOIN_RESULT, endPoint.Index, new Action <MyPacket>(this.OnJoinResult));
TransportLayer.Register(MyMessageId.WORLD_DATA, endPoint.Index, new Action <MyPacket>(this.OnWorldData));
TransportLayer.Register(MyMessageId.CLIENT_CONNNECTED, endPoint.Index, new Action <MyPacket>(this.OnClientConnected));
TransportLayer.Register(MyMessageId.REPLICATION_ISLAND_DONE, endPoint.Index, new Action <MyPacket>(this.OnReplicationIslandDone));
}
public void ServerStartWebsockets(string address, ushort port)
{
// WebGL host mode should work without errors, even though we can't
// start a server in WebGL
// (can't call LLAPI's AddWebsocketHost in webgl anyway)
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
#pragma warning disable CS0618 // Type or member is obsolete
server = new LLAPITransport();
#pragma warning restore CS0618 // Type or member is obsolete
server.ServerStartWebsockets(address, port);
}
else
{
Debug.LogWarning("ServerStartWebsockets can't be called in WebGL.");
}
}
/// <summary>
/// Find replicable and write data into m_sender
/// </summary>
private MyExternalReplicable PrepareSend <TMsg>(ref TMsg msg, MyTransportMessageEnum messageType)
where TMsg : struct, IEntityMessage
{
long entityId = msg.GetEntityId();
var entity = MyEntities.GetEntityById(entityId);
Debug.Assert(entity is IMyEventProxy, "To use SendAsRpc, entity must be IMyEventProxy and must have replicable in replication layer");
var id = TransportLayer.GetId <TMsg>(messageType);
var callback = TransportLayer.GetCallback <TMsg>(messageType);
m_sender.SendStream.Position = 0;
m_sender.SendStream.WriteUShort(id.Item1);
callback.Write(m_sender.SendStream, ref msg);
var replicable = MyMultiplayer.Static.ReplicationLayer.GetProxyTarget((IMyEventProxy)entity) as MyExternalReplicable;
Debug.Assert(replicable != null, "No replicable found for entity");
Debug.Assert(replicable is IMyProxyTarget, "Replicable must be proxy target");
return(replicable);
}
private void SendConnectRequest(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
private void SendClientUpdate(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_UPDATE, data, false, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
private void SendClientAcks(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.CLIENT_ACKS, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
/// <summary>
/// True iff the SequenceNumber, AcknowledgmentNumber, ControlBits, Window, UrgentPointer and Options fields are equal.
/// </summary>
protected override bool EqualFields(TransportLayer other)
{
return EqualFields(other as TcpLayer);
}
public void RunFileWithSpeed(RunSpeeds run_speed)
{
if (string.IsNullOrEmpty(FileName))
{
return;
}
if (run_speed == RunSpeeds.Original)
{
return;
}
if (PacketCount == 0 || SelectedNetworkAdapter == null)
{
return;
}
// Retrieve the length of the capture file
long capLength = new FileInfo(FileName).Length;
int time_interval = 100;
switch (run_speed)
{
case RunSpeeds.Original:
case RunSpeeds.s100:
time_interval = 100;
break;
case RunSpeeds.Zero:
time_interval = 1;
break;
case RunSpeeds.s250:
time_interval = 250;
break;
case RunSpeeds.s500:
time_interval = 500;
break;
case RunSpeeds.s1000:
time_interval = 1000;
break;
default:
time_interval = 100;
break;
}
DateTime time_stamp = DateTime.Now;
// Open the capture file
OfflinePacketDevice selectedInputDevice = new OfflinePacketDevice(FileName);
using (PacketCommunicator inputCommunicator =
selectedInputDevice.Open(65536, // portion of the packet to capture
// 65536 guarantees that the whole packet will be captured on all the link layers
PacketDeviceOpenAttributes.Promiscuous, // promiscuous mode
1000)) // read timeout
{
// Open the output device
using (PacketCommunicator outputCommunicator =
SelectedNetworkAdapter.Open(100, PacketDeviceOpenAttributes.Promiscuous, 1000))
{
// Fill the buffer with the packets from the file
AlteredPackets = new List <Packet>();
Packet packet;
int packet_count = 0;
while (inputCommunicator.ReceivePacket(out packet) == PacketCommunicatorReceiveResult.Ok)
{
// Create the builder that will build our packets
EthernetLayer ethernet_layer = packet.Ethernet == null ? null : (EthernetLayer)packet.Ethernet.ExtractLayer();
IpV4Layer ipv4_layer = packet.Ethernet.IpV4 == null ? null : (IpV4Layer)packet.Ethernet.IpV4.ExtractLayer();
IcmpLayer icmp_layer = packet.Ethernet.IpV4.Icmp == null ? null : (IcmpLayer)packet.Ethernet.IpV4.Icmp.ExtractLayer();
TransportLayer transport_layer = packet.Ethernet.IpV4.Transport == null ? null : (TransportLayer)packet.Ethernet.IpV4.Transport.ExtractLayer();
PayloadLayer datagram_layer = packet.Ethernet.IpV4.Payload == null ? null : (PayloadLayer)packet.Ethernet.IpV4.Payload.ExtractLayer();
try
{
if (ipv4_layer.Length < 1) // Catch null Length
{
// Do Nothing
}
}
catch
{
ipv4_layer = null;
}
List <ILayer> layers = new List <ILayer>();
if (IsRTP(packet))
{
if (ethernet_layer != null)
{
layers.Add(ethernet_layer);
}
if (ipv4_layer != null)
{
layers.Add(ipv4_layer);
}
if (datagram_layer != null)
{
layers.Add(datagram_layer);
}
}
else
{
if (ethernet_layer != null)
{
layers.Add(ethernet_layer);
}
if (ipv4_layer != null)
{
layers.Add(ipv4_layer);
}
if (icmp_layer != null)
{
layers.Add(icmp_layer);
}
if (transport_layer != null)
{
layers.Add(transport_layer);
}
if (datagram_layer != null && IsRTP(packet))
{
layers.Add(datagram_layer);
}
}
PacketBuilder builder = new PacketBuilder(layers);
Packet altered_packet = builder.Build(time_stamp.AddMilliseconds((packet_count * time_interval) / 1000));
ProcessAlteredPacket(altered_packet);
packet_count++;
}
// Allocate a send buffer
using (PacketSendBuffer sendBuffer = new PacketSendBuffer(4294967295))
{
foreach (Packet p in AlteredPackets)
{
sendBuffer.Enqueue(p);
}
// Transmit the queue
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
long startTimeMs = stopwatch.ElapsedMilliseconds;
Common.ConsoleWriteLine(ConsoleText);
Common.ConsoleWriteLine(ConsoleText, "File:\n " + FileName.Substring(FileName.LastIndexOf("\\") + 1));
Common.ConsoleWriteLine(ConsoleText, " Start Time: " + startTimeMs);
outputCommunicator.Transmit(sendBuffer, true);
long endTimeMs = stopwatch.ElapsedMilliseconds;
Common.ConsoleWriteLine(ConsoleText, " End Time: " + endTimeMs);
long elapsedTimeMs = endTimeMs - startTimeMs;
Common.ConsoleWriteLine(ConsoleText, " Elapsed Time: " + elapsedTimeMs);
double averagePacketsPerSecond = elapsedTimeMs == 0 ? double.MaxValue : (double)AlteredPackets.Count / elapsedTimeMs * 1000;
Common.ConsoleWriteLine(ConsoleText, " Elapsed time: " + elapsedTimeMs + " ms");
Common.ConsoleWriteLine(ConsoleText, " Total packets generated = " + AlteredPackets.Count);
Common.ConsoleWriteLine(ConsoleText, " Average packets per second = " + averagePacketsPerSecond);
Common.ConsoleWriteLine(ConsoleText, "");
}
}
}
}
/// <summary>
/// This is the main function for the simple client. It parses the command line and creates
/// a socket of the requested type. For TCP, it will resolve the name and attempt to connect
/// to each resolved address until a successful connection is made. Once connected a request
/// message is sent followed by shutting down the send connection. The client then receives
/// data until the server closes its side at which point the client socket is closed. For
/// UDP, the socket is created and if indicated connected to the server's address. A single
/// request datagram message. The client then waits to receive a response and continues to
/// do so until a zero byte datagram is receive which indicates the end of the response.
/// </summary>
/// <param name="args">Command line arguments</param>
static void Main(string[] args)
{
SocketType sockType = SocketType.Stream;
ProtocolType sockProtocol = ProtocolType.Tcp;
string remoteName = "localhost";
bool udpConnect = false;
int remotePort = 5150, bufferSize = 4096;
Console.WriteLine();
usage();
Console.WriteLine();
// Parse the command line
for (int i = 0; i < args.Length; i++)
{
try
{
if ((args[i][0] == '-') || (args[i][0] == '/'))
{
switch (Char.ToLower(args[i][1]))
{
case 'c': // "Connect" the UDP socket to the destination
udpConnect = true;
break;
case 'n': // Destination address to connect to or send to
remoteName = args[++i];
break;
case 'p': // Port number for the destination
remotePort = System.Convert.ToInt32(args[++i]);
break;
case 't': // Specified TCP or UDP
i++;
if (String.Compare(args[i], "tcp", true) == 0)
{
sockType = SocketType.Stream;
sockProtocol = ProtocolType.Tcp;
}
else if (String.Compare(args[i], "udp", true) == 0)
{
sockType = SocketType.Dgram;
sockProtocol = ProtocolType.Udp;
}
else
{
usage();
return;
}
break;
case 'x': // Size of the send and receive buffers
bufferSize = System.Convert.ToInt32(args[++i]);
break;
default:
usage();
return;
}
}
}
catch
{
usage();
return;
}
}
Socket clientSocket = null;
IPHostEntry resolvedHost = null;
IPEndPoint destination = null;
byte[] sendBuffer = new byte[bufferSize], recvBuffer = new Byte[bufferSize];
int rc;
// Format the string message into the send buffer
// we will send the DNP3 request
ApplicationLayer al = new ApplicationLayer();
al.ApplicationData = new byte[] { 0x02, 0x00, 0x06 };
al.FunctionCode = (byte)FunctionCode.READ; // Read
al.ApplicationControl = 0xc2;
al.serialize(ref al.ApplicationData);
TransportLayer tl = new TransportLayer();
tl.TransportData = al.ApplicationData;
tl.seq = 1;
tl.FIN = 1;
tl.FIR = 1;
tl.serialize(ref tl.TransportData);
LinkLayer ll = new LinkLayer();
ll.LinkData = tl.TransportData;
ll.source = 3;
ll.destination = 4;
ll.dir = (byte)DIR.MASTER;
ll.prm = (byte)PRM.INITIATED;
ll.fcb = (byte)FCB.set;
ll.fcv = (byte)FCV.set;
ll.functionCode = (byte)PrimaryFunctionCode.PRI_CONFIRMED_USER_DATA;
ll.controlByte = ll.GetControlByte(true);
ll.serialize(ref ll.LinkData);
var sb = new StringBuilder("new byte[] { ");
for (var i = 0; i < ll.LinkData.Length; i++)
{
var b = ll.LinkData[i];
sb.Append(b);
if (i < ll.LinkData.Length - 1)
{
sb.Append(", ");
}
}
sb.Append(" }");
Console.WriteLine("DNP3 data using String Builder " + sb.ToString());
//FormatBuffer(sendBuffer, textMessage);
BufferFormatting(ref sendBuffer, ll.LinkData);
try
{
// Try to resolve the remote host name or address
resolvedHost = Dns.GetHostEntry(remoteName);
Console.WriteLine("Client: GetHostEntry() is OK...");
// Try each address returned
foreach (IPAddress addr in resolvedHost.AddressList)
{
// Create a socket corresponding to the address family of the resolved address
clientSocket = new Socket(
addr.AddressFamily,
sockType,
sockProtocol
);
Console.WriteLine("Client: Socket() is OK...");
try
{
// Create the endpoint that describes the destination
destination = new IPEndPoint(addr, remotePort);
Console.WriteLine("Client: IPEndPoint() is OK. IP Address: {0}, server port: {1}", addr, remotePort);
if ((sockProtocol == ProtocolType.Udp) && (udpConnect == false))
{
Console.WriteLine("Client: Destination address is: {0}", destination.ToString());
break;
}
else
{
Console.WriteLine("Client: Attempting connection to: {0}", destination.ToString());
}
clientSocket.Connect(destination);
Console.WriteLine("Client: Connect() is OK...");
break;
}
catch (SocketException)
{
// Connect failed, so close the socket and try the next address
clientSocket.Close();
Console.WriteLine("Client: Close() is OK...");
clientSocket = null;
continue;
}
}
// Make sure we have a valid socket before trying to use it
if ((clientSocket != null) && (destination != null))
{
try
{
new Thread(() =>
{
int sendCount = 0;
while (true && sendCount < 1)
{
// Send the request to the server
if ((sockProtocol == ProtocolType.Udp) && (udpConnect == false))
{
clientSocket.SendTo(sendBuffer, destination);
sendCount++;
Console.WriteLine("Client: SendTo() is OK...UDP...");
}
else
{
rc = clientSocket.Send(sendBuffer);
sendCount++;
Console.WriteLine("Client: send() is OK...TCP...");
Console.WriteLine("Client: Sent request of {0} bytes", rc);
// For TCP, shutdown sending on our side since the client won't send any more data
if (sockProtocol == ProtocolType.Tcp)
{
//clientSocket.Shutdown(SocketShutdown.Send);
//Console.WriteLine("Client: Shutdown() is OK...");
}
}
}
}).Start();
// Receive data in a loop until the server closes the connection. For
// TCP this occurs when the server performs a shutdown or closes
// the socket. For UDP, we'll know to exit when the remote host
// sends a zero byte datagram.
new Thread(() =>
{
while (true)
{
if ((sockProtocol == ProtocolType.Tcp) || (udpConnect == true))
{
rc = clientSocket.Receive(recvBuffer);
Console.WriteLine("Client: Receive() is OK...");
Console.WriteLine("Client: Read {0} bytes", rc);
recvBuffer = recvBuffer.Where((v, i) => i < rc).ToArray();
var sbs = new StringBuilder("new byte[] { ");
for (var i = 0; i < recvBuffer.Length; i++)
{
var b = recvBuffer[i];
sbs.Append(b);
if (i < recvBuffer.Length - 1)
{
sbs.Append(", ");
}
}
sbs.Append(" }");
Console.WriteLine("DNP3 Application response " + sbs.ToString());
}
else
{
IPEndPoint fromEndPoint = new IPEndPoint(destination.Address, 0);
Console.WriteLine("Client: IPEndPoint() is OK...");
EndPoint castFromEndPoint = (EndPoint)fromEndPoint;
rc = clientSocket.ReceiveFrom(recvBuffer, ref castFromEndPoint);
Console.WriteLine("Client: ReceiveFrom() is OK...");
fromEndPoint = (IPEndPoint)castFromEndPoint;
Console.WriteLine("Client: Read {0} bytes from {1}", rc, fromEndPoint.ToString());
}
// Exit loop if server indicates shutdown
if (rc == 0)
{
clientSocket.Close();
Console.WriteLine("Client: Close() is OK...");
break;
}
}
}).Start();
}
catch (SocketException err)
{
Console.WriteLine("Client: Error occurred while sending or receiving data.");
Console.WriteLine(" Error: {0}", err.Message);
}
}
else
{
Console.WriteLine("Client: Unable to establish connection to server!");
}
}
catch (SocketException err)
{
Console.WriteLine("Client: Socket error occurred: {0}", err.Message);
}
}
public ZFingerDevice CreateZFingerDevice()
{
var sessionId = NextSessionId();
ZFingerDevice ret = new ZFingerDevice(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
private void SendEvent(IPacketData data, bool reliable)
{
TransportLayer.SendMessage(MyMessageId.RPC, data, reliable, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
public InstallerController CreateInstallerController()
{
var sessionId = NextSessionId();
InstallerController ret = new InstallerController(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
public BridgeController CreateBridgeController()
{
var sessionId = NextSessionId();
BridgeController ret = new BridgeController(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
public Slave CreateSlave()
{
var sessionId = NextSessionId();
Slave ret = new Slave(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
public XModemDevice CreateXModem()
{
return(new XModemDevice(SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(0)));
}
private void Start()
{
canMove = true;
m_RigidBody = GetComponent<Rigidbody>();
m_Capsule = GetComponent<CapsuleCollider>();
if (isLocalPlayer)
{
transportLayer = GameObject.FindObjectOfType<TransportLayer>();
flashlightStatus = 1;
cam = GetComponentInChildren<Camera>();
mouseLook.Init(transform, cam.transform);
if (isServer)
GameObject.Instantiate(Resources.Load("Prefabs/ObjectSpawner") as GameObject, new Vector3(0, 0, 0), new Quaternion());
}
if (!isLocalPlayer)
{
GetComponentInChildren<Camera>().gameObject.SetActive(false);
}
}
private void SendReplicableReady(IPacketData data)
{
TransportLayer.SendMessage(MyMessageId.REPLICATION_READY, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index);
}
public void ServerStartWebsockets(string address, int port, int maxConnections)
{
server = new LLAPITransport();
server.ServerStartWebsockets(address, port, maxConnections);
}
public TextDevice CreateTextDevice()
{
var sessionId = NextSessionId();
TextDevice ret = new TextDevice(sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
// Use this for initialization
void Start () {
transportLayer = GameObject.FindObjectOfType<TransportLayer>();
}
public ApplicationClient CreateClient()
{
var sessionId = NextSessionId();
ApplicationClient ret = new ApplicationClient(ApiType, sessionId, SessionLayer.CreateClient(), FrameLayer.CreateClient(), TransportLayer.CreateClient(sessionId));
return(ret);
}
public void ServerStart(string address, int port, int maxConnections)
{
server = new TelepathyTransport();
server.ServerStart(address, port, maxConnections);
}
