public ConnectedClientForm(LSClient client, ServerInfoMessage serverInfo)
{
InitializeComponent();
this.client = client;
categorySelector.Categories = serverInfo.FileCategories;
requestManager = new RequestManager(client);
}
private void SetServerInfo(ServerInfoMessage message)
{
this.ServerIP = message.ServerIP;
this.ServerPort = message.ServerPort;
if (this.ServerInfoChange != null)
{
this.ServerInfoChange(this, null);
}
}
/// <summary>
/// Sends the <see cref="ServerInfoMessage"/> structure to the connected client.
/// </summary>
/// <param name="info">The info message to send.</param>
/// <returns>True on success.</returns>
public bool SendServerInfo(ServerInfoMessage info)
{
_packet.Reset((ushort)RoutingID.ServerInfo, 0);
if (info.Write(_packet))
{
_packet.FinalisePacket();
return(Add(_packet) > 0);
}
return(false);
}
private void ShowServerInfo(ServerInfoMessage info)
{
Console.WriteLine("Server info");
Console.WriteLine(string.Format(" Coordinate frame: {0} ({1})", info.CoordinateFrame.ToString(),
info.IsLeftHanded ? "left" : "right"));
Console.WriteLine(string.Format(" Time unit: {0}", TimeString(info.TimeUnit)));
Console.WriteLine(string.Format(" Default time: {0} {1} Hz",
TimeString(info.DefaultFrameTime * info.TimeUnit),
1e6 / (info.DefaultFrameTime * info.TimeUnit)));
}
public static void TestShape(Shape reference, CreateShapeFunction createShape, ShapeValidationFunction validate)
{
ServerInfoMessage info = ServerInfoMessage.Default;
info.CoordinateFrame = CoordinateFrame.XYZ;
ServerSettings serverSettings = ServerSettings.Default;
serverSettings.Flags &= ~(ServerFlag.Collate | ServerFlag.Compress);
serverSettings.PortRange = 1000;
IServer server = new TcpServer(serverSettings);
// std::cout << "Start on port " << serverSettings.listenPort << std::endl;
Assert.True(server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous));
// std::cout << "Server listening on port " << server.connectionMonitor()->port() << std::endl;;
// Create client and connect.
TcpClient client = new TcpClient("127.0.0.1", server.ConnectionMonitor.Port);
// Wait for connection.
if (server.ConnectionMonitor.WaitForConnections(5000u) > 0)
{
server.ConnectionMonitor.CommitConnections(null);
}
Assert.True(server.ConnectionCount > 0);
Assert.True(client.Connected);
// Send server messages from another thread. Otherwise large packets may block.
Thread sendThread = new Thread(() =>
{
Assert.True(server.Create(reference) > 0);
Assert.True(server.UpdateTransfers(0) >= 0);
Assert.True(server.UpdateFrame(0.0f) > 0);
// Send end message.
ControlMessage ctrlMsg = new ControlMessage();
Assert.True(ServerUtil.SendMessage(server, (ushort)RoutingID.Control, (ushort)ControlMessageID.End, ctrlMsg) > 0);
Assert.True(server.UpdateFrame(0.0f) > 0);
});
sendThread.Start();
// Process client messages.
ValidateClient(client, reference, info, createShape, validate);
client.Close();
sendThread.Join();
server.Close();
server.ConnectionMonitor.Stop();
server.ConnectionMonitor.Join();
}
public ExistingArchivesForm(ServerInfoMessage serverInfo)
{
InitializeComponent();
double availableGb = Math.Round(
serverInfo.AvailableCapacityInBytes / Math.Pow(1024, 3), 1);
double totalGb = Math.Round(
serverInfo.TotalCapacityInBytes / Math.Pow(1024, 3), 1);
availableMemLabel.Text = availableGb.ToString();
totalMemLabel.Text = totalGb.ToString();
}
/// <summary>
/// Decode the <see cref="Tes.Net.ServerInfoMessage" /> packet.
/// </summary>
/// <param name="packet">The packet containing a <c>ServerInfoMessage</c></param>
private void HandleServerInfo(PacketBuffer packet)
{
NetworkReader packetReader = new NetworkReader(packet.CreateReadStream(true));
ServerInfoMessage serverInfo = new ServerInfoMessage();
if (serverInfo.Read(packetReader))
{
_defaultFrameTime = serverInfo.DefaultFrameTime;
_timeUnit = serverInfo.TimeUnit;
}
}
IServer InitialiseServer()
{
ServerSettings serverSettings = ServerSettings.Default;
ServerInfoMessage info = ServerInfoMessage.Default;
serverSettings.ListenPort = TestPort;
info.CoordinateFrame = ServerCoordinateFrame;
//serverSettings.Flags |= ServerFlag.Compress;
return(new TcpServer(serverSettings));
}
public void HandleServerInfoRequest(ServerInfoRequestMessage request,
IFileCategorizationStrategy categorizationStrategy)
{
string drive = FileOperations.GetDriveFromPath(logsDestPath);
ServerInfoMessage serverInfo = new ServerInfoMessage(
FileOperations.GetLogCategories(logsSourcePath, categorizationStrategy),
FileOperations.GetFileNamesInDirectory(logsDestPath, ".zip"),
FileOperations.GetDriveAvailableBytes(drive),
FileOperations.GetDriveTotalBytes(drive));
client.Writer.Write(serverInfo);
logger.Log("Sent server info:");
logger.Log(serverInfo.ToString(true));
}
private async void connectButton_Click(object sender, EventArgs e)
{
connectButton.Enabled = false;
LSClient client = new LSClient();
if (await client.TryConnectAsync(IPAddress.Parse(selectedConnection.ConnectionIP), 1337))
{
Console.WriteLine("Waiting for server info...");
ServerInfoMessage serverInfo = await new RequestManager(client).RetrieveServerInfo();
//Console.WriteLine("Received server info: " +
// JsonConvert.SerializeObject(serverInfo, Formatting.Indented));
new ConnectedClientForm(client, serverInfo).ShowDialog(this);
client.Close();
}
connectButton.Enabled = true;
}
/// <summary>
/// Sends the given <see cref="ServerInfoMessage"/> to the client.
/// </summary>
/// <param name="info">Details of the server to send to the client.</param>
/// <remarks>
/// Should always be send as the first message to the client.
/// </remarks>
public bool SendServerInfo(ServerInfoMessage info)
{
_serverInfo = info;
const float secondsToMicroseconds = 1e6f;
_secondsToTimeUnit = secondsToMicroseconds / (_serverInfo.TimeUnit != 0 ? _serverInfo.TimeUnit : 1.0f);
if (Connected)
{
_packetLock.Lock();
try
{
_packet.Reset((ushort)RoutingID.ServerInfo, 0);
if (info.Write(_packet))
{
_packet.FinalisePacket();
_sendLock.Lock();
try
{
// Do not use collation buffer or compression for this message.
if (_client != null && _client.Connected)
{
_client.GetStream().Write(_packet.Data, _packet.Cursor, _packet.Count);
}
return(true);
}
catch (System.IO.IOException)
{
_client.Close();
_client = null;
}
finally
{
_sendLock.Unlock();
}
}
}
finally
{
_packetLock.Unlock();
}
}
return(false);
}
public void ServerInfo()
{
var msg = new ServerInfoMessage(new ServerInfo(new ServerSettings
{
ServerLogo = "logo",
Name = "name",
Description = "description"
}, new GuestUserProvider()));
msg.WritePayload(serverContext, writer);
long length = stream.Position;
stream.Position = 0;
msg = new ServerInfoMessage();
msg.ReadPayload(clientContext, reader);
Assert.AreEqual(length, stream.Position);
}
/// <summary>
/// Functionality:This method do following things
/// 1-SenderID=-1 represent its send by server
/// 2-Send all participant list of running conference by assinging infoMsg.AttendeeProfileList=ClientList
/// infoMsg.AttendeeProfileList is HashTable
/// 3-Receive message to a particular id
/// Status : This function is not using anywhere in the code.
///
/// </summary>
/// <param name="receiver"></param>
private void SendUserListUpdateMessage(IMessageReceiver receiver)
{
ServerInfoMessage infoMsg = new ServerInfoMessage();
infoMsg.SenderID=-1;
infoMsg.AttendeeProfileList = ClientList;
// ((IMessageReceiver) this._dispatcher.TransparentProxy).ReceiveMessage(infoMsg);
receiver.ReceiveMessage(infoMsg);
infoMsg = null; // GC
}
static void Main(string[] args)
{
//if (HaveOption("help", args))
//{
// ShowUsage();
// return;
//}
Console.CancelKeyPress += new ConsoleCancelEventHandler(ControlCHandler);
ServerSettings serverSettings = ServerSettings.Default;
ServerInfoMessage info = ServerInfoMessage.Default;
info.CoordinateFrame = CoordinateFrame.XYZ;
serverSettings.Flags |= ServerFlag.Collate;
serverSettings.Flags |= ServerFlag.Compress;
IServer server = new TcpServer(serverSettings);
const int targetFrameTimeMs = 1000 / 5;
int updateElapsedMs = 0;
Vector3 offset = Vector3.Zero;
float dt = 0;
float time = 0;
Stopwatch frameTimer = new Stopwatch();
Stopwatch sleepTimer = new Stopwatch();
server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous);
frameTimer.Start();
while (!Quit)
{
frameTimer.Stop();
dt = frameTimer.ElapsedMilliseconds * 1e-3f;
time += dt;
frameTimer.Reset();
frameTimer.Start();
sleepTimer.Reset();
sleepTimer.Start();
if (server.ConnectionMonitor.Mode == ConnectionMonitorMode.Synchronous)
{
server.ConnectionMonitor.MonitorConnections();
}
server.ConnectionMonitor.CommitConnections(OnNewConnection);
server.UpdateTransfers(0);
server.UpdateFrame(dt);
offset.X += 0.05f;
if (offset.X >= 1.0f)
{
offset.X = 0.0f;
}
ManyBoxes(server, 50, 50, 50, offset, new Vector3(0.1f, 0.1f, 0.1f));
Console.Write(string.Format("\rFrame {0}: {1} connection(s) ", dt, server.ConnectionCount));
// Work out how long to sleep for.
sleepTimer.Stop();
updateElapsedMs = (int)sleepTimer.ElapsedMilliseconds;
if (updateElapsedMs + 1 < targetFrameTimeMs)
{
// Sleep until the next frame. Sleep for a millisecond less than we need to allow
// a bit of overhead.
System.Threading.Thread.Sleep(targetFrameTimeMs - (updateElapsedMs + 1));
}
}
server.UpdateFrame(0);
server.ConnectionMonitor.Stop();
server.ConnectionMonitor.Join();
}
/// <summary>
/// Handles an unconnected message, usually from the auth server.
/// </summary>
private void HandleUnconnectedMessage(NetIncomingMessage im)
{
if (im == null)
{
throw new ArgumentNullException(nameof(im));
}
// Make sure the unconnected message is coming from the real auth server.
if (Equals(im.SenderEndPoint, networkManager.AuthEndpoint) &&
im.SenderEndPoint.Port == Globals.Values.DefaultAuthPort)
{
var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent
switch (messageType)
{
case MessageTypes.AuthInit:
{
var msg = new AuthInitMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.InitReceived.Invoke(
new EventManager.NetEvents.AuthServerEvents.InitEventArgs(msg.Username, msg.UUID,
msg.PrivateKey,
msg.PublicKey));
break;
}
case MessageTypes.FailedLogin:
{
var msg = new FailedLoginMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.FailedLogin.Invoke(
new EventManager.NetEvents.AuthServerEvents.FailedLoginEventArgs(msg.ErrorMessage));
break;
}
case MessageTypes.Verified:
{
var msg = new VerifiedMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.Verified.Invoke(
new EventManager.NetEvents.AuthServerEvents.VerifiedEventArgs(msg.Verified));
break;
}
case MessageTypes.PluginDownload:
{
var msg = new PluginDownloadMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Auth.PluginDownloadRequested.Invoke(
new EventManager.NetEvents.AuthServerEvents.PluginDownloadEventArgs(msg));
break;
}
}
}
else // Message not from auth server, instead from a game server
{
var messageType = (MessageTypes)im.ReadByte(); // Find the type of data message sent
switch (messageType)
{
case MessageTypes.ServerInfo:
{
var msg = new ServerInfoMessage(im, MessageContext.Client);
networkManager.Client.Events.Network.Game.ServerInfoReceived.Invoke(
new EventManager.NetEvents.GameServerEvents.ServerInfoEventArgs(msg.Description, msg.Players,
msg.MaxPlayers, im.SenderEndPoint));
break;
}
}
}
}
static void Main(string[] args)
{
if (HaveOption("help", args))
{
ShowUsage();
return;
}
Console.CancelKeyPress += new ConsoleCancelEventHandler(ControlCHandler);
ServerSettings serverSettings = ServerSettings.Default;
serverSettings.PortRange = 10;
ServerInfoMessage info = ServerInfoMessage.Default;
info.CoordinateFrame = CoordinateFrame.XYZ;
if (HaveOption("compress", args))
{
serverSettings.Flags |= ServerFlag.Compress;
}
IServer server = new TcpServer(serverSettings, info);
List <Shapes.Shape> shapes = new List <Shapes.Shape>();
List <ShapeMover> movers = new List <ShapeMover>();
List <Resource> resources = new List <Resource>();
Ids ids = new Ids();
ids.NextShapeId = 1;
CreateAxes(ids, shapes, movers, resources, args);
CreateShapes(ids, shapes, movers, resources, args);
const int targetFrameTimeMs = 1000 / 30;
int updateElapsedMs = 0;
float dt = 0;
float time = 0;
Stopwatch frameTimer = new Stopwatch();
Stopwatch sleepTimer = new Stopwatch();
// Register shapes with server.
foreach (Shapes.Shape shape in shapes)
{
server.Create(shape);
}
if (!server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous))
{
Console.WriteLine("Failed to start listen socket.");
return;
}
Console.WriteLine(string.Format("Listening on port {0}", server.ConnectionMonitor.Port));
frameTimer.Start();
while (!Quit)
{
frameTimer.Stop();
dt = frameTimer.ElapsedMilliseconds * 1e-3f;
time += dt;
frameTimer.Reset();
frameTimer.Start();
sleepTimer.Reset();
sleepTimer.Start();
foreach (ShapeMover mover in movers)
{
mover.Update(time, dt);
server.Update(mover.Shape);
}
server.UpdateFrame(dt);
if (server.ConnectionMonitor.Mode == ConnectionMonitorMode.Synchronous)
{
server.ConnectionMonitor.MonitorConnections();
}
server.ConnectionMonitor.CommitConnections((IServer s, IConnection connection) =>
{
foreach (Shapes.Shape shape in shapes)
{
connection.Create(shape);
}
});
server.UpdateTransfers(64 * 1024);
Console.Write(string.Format("\rFrame {0}: {1} connection(s) ", dt, server.ConnectionCount));
// Console Flush?
// Work out how long to sleep for.
sleepTimer.Stop();
updateElapsedMs = (int)sleepTimer.ElapsedMilliseconds;
if (updateElapsedMs + 1 < targetFrameTimeMs)
{
// Sleep until the next frame. Sleep for a millisecond less than we need to allow
// a bit of overhead.
System.Threading.Thread.Sleep(targetFrameTimeMs - (updateElapsedMs + 1));
}
}
foreach (Shapes.Shape shape in shapes)
{
server.Destroy(shape);
}
server.UpdateFrame(0);
server.ConnectionMonitor.Stop();
server.ConnectionMonitor.Join();
}
static void ValidateClient(TcpClient socket, Shape reference, ServerInfoMessage serverInfo, CreateShapeFunction createShape, ShapeValidationFunction validate, uint timeoutSec = 10u)
{
Stopwatch timer = new Stopwatch();
ServerInfoMessage readServerInfo = new ServerInfoMessage();
Dictionary <ulong, Resource> resources = new Dictionary <ulong, Resource>();
PacketBuffer packetBuffer = new PacketBuffer(64 * 1024);
Shape shape = createShape();
bool endMsgReceived = false;
bool serverInfoRead = false;
bool shapeMsgRead = false;
timer.Start();
// Keep looping until we get a CIdEnd ControlMessage or timeoutSec elapses.
// Timeout ignored when debugger is attached.
while (!endMsgReceived && (Debugger.IsAttached || timer.ElapsedMilliseconds / 1000u < timeoutSec))
{
if (socket.Available <= 0)
{
Thread.Yield();
continue;
}
// Data available. Read from the network stream into a buffer and attempt to
// read a valid message.
packetBuffer.Append(socket.GetStream(), socket.Available);
PacketBuffer completedPacket;
bool crcOk = true;
while ((completedPacket = packetBuffer.PopPacket(out crcOk)) != null || !crcOk)
{
Assert.True(crcOk);
if (crcOk)
{
if (packetBuffer.DroppedByteCount != 0)
{
Console.Error.WriteLine("Dropped {0} bad bytes", packetBuffer.DroppedByteCount);
packetBuffer.DroppedByteCount = 0;
}
Assert.Equal(PacketHeader.PacketMarker, completedPacket.Header.Marker);
Assert.Equal(PacketHeader.PacketVersionMajor, completedPacket.Header.VersionMajor);
Assert.Equal(PacketHeader.PacketVersionMinor, completedPacket.Header.VersionMinor);
NetworkReader packetReader = new NetworkReader(completedPacket.CreateReadStream(true));
switch (completedPacket.Header.RoutingID)
{
case (int)RoutingID.ServerInfo:
serverInfoRead = true;
Assert.True(readServerInfo.Read(packetReader));
// Validate server info.
Assert.Equal(serverInfo.TimeUnit, readServerInfo.TimeUnit);
Assert.Equal(serverInfo.DefaultFrameTime, readServerInfo.DefaultFrameTime);
Assert.Equal(serverInfo.CoordinateFrame, readServerInfo.CoordinateFrame);
unsafe
{
for (int i = 0; i < ServerInfoMessage.ReservedBytes; ++i)
{
Assert.Equal(serverInfo.Reserved[i], readServerInfo.Reserved[i]);
}
}
break;
case (int)RoutingID.Control:
{
// Only interested in the CIdEnd message to mark the end of the stream.
ControlMessage msg = new ControlMessage();
Assert.True(msg.Read(packetReader));
if (completedPacket.Header.MessageID == (int)ControlMessageID.End)
{
endMsgReceived = true;
}
break;
}
case (int)RoutingID.Mesh:
HandleMeshMessage(completedPacket, packetReader, resources);
break;
default:
if (completedPacket.Header.RoutingID == reference.RoutingID)
{
shapeMsgRead = true;
HandleShapeMessage(completedPacket, packetReader, shape, reference);
}
break;
}
}
}
// else fail?
}
Assert.True(serverInfoRead);
Assert.True(shapeMsgRead);
Assert.True(endMsgReceived);
// Validate the shape state.
if (shapeMsgRead)
{
validate(shape, reference, resources);
}
}
/// <summary>
/// The process network messages such as users joining, moving, etc
/// </summary>
public void ProcessNetworkMessages()
{
while (NetManager.NetServer.Status == NetPeerStatus.Running)
{
// If an issue occurs with this (again), see the discussion at:
// https://groups.google.com/forum/#!topic/lidgren-network-gen3/EN3vaykwBWM
NetManager.NetServer.MessageReceivedEvent.WaitOne();
try
{
NetIncomingMessage inc; // Used to store messages
while ((inc = NetManager.ReadMessage()) != null)
{
switch (inc.MessageType)
{
case NetIncomingMessageType.Error:
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.VerboseDebugMessage:
case NetIncomingMessageType.WarningMessage:
Logger.WriteLine(LogType.Error, "MessageHandler Loop: " + inc.ReadString());
break;
// ConnectionApproval messages are sent when a client would like to connect to the server
case NetIncomingMessageType.ConnectionApproval:
{
// If client does not send username information (Purposely trying to use a modded client?)
if (inc.LengthBytes == 0)
{
inc.SenderConnection?.Deny("Invalid Hail Message");
break;
}
var type =
(MessageTypes)Enum.Parse(typeof(MessageTypes), inc.ReadByte().ToString());
// Find message type
switch (type)
{
// The connection should come with a public key to verify the client's session
case MessageTypes.PublicKey:
{
var msg = new PublicKeyMessage(inc, MessageContext.Client);
Server.Events.Network.UserLoginRequested.Invoke(
new EventManager.NetEvents.LoginRequestEventArgs(msg.Username, msg.UUID,
msg.PublicKey, inc.SenderConnection));
break;
}
}
break;
}
// Data messages are all messages manually sent from client
// These are the bulk of the messages, used for Sender movement, block placing, etc
case NetIncomingMessageType.Data:
{
ProcessDataMessage(inc);
break;
}
// StatusChanged messages occur when a client connects, disconnects, is approved, etc
// NOTE: Disconnecting and Disconnected are not instant unless client is shutdown with Disconnect()
case NetIncomingMessageType.StatusChanged:
{
var sender = Server.PlayerFromRUI(inc.SenderConnection.RemoteUniqueIdentifier, true);
// When a player's connection is finalized
if (inc.SenderConnection != null &&
inc.SenderConnection.Status == NetConnectionStatus.Connected)
{
if (sender != null)
{
Server.Events.Network.UserConnected.Invoke(
new EventManager.NetEvents.ConnectionEventArgs(sender));
}
}
// When a client disconnects
else if (inc.SenderConnection != null &&
(inc.SenderConnection.Status == NetConnectionStatus.Disconnected ||
inc.SenderConnection.Status == NetConnectionStatus.Disconnecting))
{
if (sender != null)
{
Server.Events.Network.UserDisconnected.Invoke(
new EventManager.NetEvents.DisconnectionEventArgs(sender,
inc.ReadString()));
}
}
break;
}
// Listen to unconnected data
case NetIncomingMessageType.UnconnectedData:
{
var type = (MessageTypes)Enum.Parse(typeof(MessageTypes), inc.ReadByte().ToString());
// Handle messages from the auth server differently then ones from players (ping requests)
if (Equals(inc.SenderEndPoint, NetManager.AuthEndpoint))
{
switch (type)
{
// When the auth server confirms if a session is valid or not.
case MessageTypes.ValidSession:
{
var msg = new ValidSessionMessage(inc, MessageContext.Server);
Server.Events.Network.SessionValidated.Invoke(
new EventManager.NetEvents.SessionEventArgs(
msg.Username, msg.UUID, msg.Valid));
break;
}
}
}
else
{
switch (type)
{
// When the auth server confirms if a session is valid or not.
case MessageTypes.ServerInfo:
{
// ReSharper disable once UnusedVariable
var msg = new ServerInfoMessage(inc, MessageContext.Server);
Server.Events.Network.InfoRequested.Invoke(
new EventManager.NetEvents.RequestInfoEventArgs(
inc.SenderEndPoint));
break;
}
}
}
break;
}
}
NetManager.Recycle(inc);
}
}
catch (Exception e)
{
Logger.WriteLine(LogType.Error, e.ToString());
}
}
}
/// <summary>
///This function do the following things
///-increment the NextClientId
///-Assign Profile.ClientId=i
/// Attaches the client.
///
///
/// Fetches the URI of the remote host that sent a request.
/// </summary>
/// <param name="nickname">Nickname.</param>
public int AttachClient(string nickname, ClientProfile profile, MessageObject msg)
{
try
{
int id=NextClientId++;
profile.ClientId=id;
/*
* this.restartTimer = true;
*is commented because its not using anywhere in the code.
*/
//this.restartTimer = true;
showFailReciverList("public int AttachClient(string nickname, ClientProfile profile, MessageObject msg)");
// change relevant to close meeting.
// if(conferenceCloseThread.ThreadState == System.Threading.ThreadState.Running)
// this.conferenceCloseThread.Suspend();
bHostJoined =(profile.clientType == ClientType.ClientHost);
strMeetingId=profile.ConferenceID.ToString();
string receiverUri = GenuineUtility.FetchCurrentRemoteUri() + "/MessageReceiver.rem";
IMessageReceiver iMessageReceiver = (IMessageReceiver) Activator.GetObject(typeof(IMessageReceiver), receiverUri);
profile.clientURI=receiverUri;
GenuineUtility.CurrentSession["ConnectionID"] = id;
// Console.WriteLine("Client with nickname \"{0}\" has been registered{1}.", nickname,NextClientId);
while(m_bLocked==true)
{
Console.WriteLine("Meeting jammed in while loop in attachclient()line 1710 & meetingID->" + strMeetingId + " Participant Name ->"+profile.Name );
System.Threading.Thread.Sleep(1000);
}
m_bLocked=true;
this._dispatcher.Add((MarshalByRefObject) iMessageReceiver);
this.ClientList.Add(profile.ClientId,profile);
m_bLocked=false;
iMessageReceiver.ReceiveMessage(msg);// sending the authentication message
/*
* When host is joined, its color should be Red.
* colorsArray[0] is red color
*/
if(profile.clientType==ClientType.ClientHost)
{
profile.m_AssignedColor = colorsArray[0];
}
else
{
if(mcount==0)//checking index for assigning attendee
{ //if 0 index then increment it
profile.m_AssignedColor = colorsArray[mcount+1];
}
else //Simple Assign index because assinging will not
{ //be red color
profile.m_AssignedColor = colorsArray[mcount];
}
}
SendUserJoinMessage(profile);
mcount++;
if(mcount >= 15)
mcount = 0;
//Send all profile Lists to joing participant.
ServerInfoMessage infoMsg = new ServerInfoMessage();
infoMsg.SenderID=-1;
infoMsg.AttendeeProfileList = ClientList;
iMessageReceiver.ReceiveMessage(infoMsg); // senfing the info message
// It should be removed
SendConferenceParameters(iMessageReceiver);
return id;
}
catch(Exception ex)
{
m_bLocked=false;
Console.WriteLine("Exception Message Occured at AttachClient-> "+ex.Message.ToString()+" Exception source :::"+ex.StackTrace+" Exception StackTrace ::: "+ex.StackTrace+" Exception Tostring ::: "+ex.ToString());
m_bLocked=false;
return 0;
}
}
/// <summary>
/// Create a new <see cref="TcpServer"/> with the given <paramref name="settings"/>
/// and <paramref name="serverInfo"/>.
/// </summary>
/// <param name="settings">The settings to instantiate with.</param>
/// <param name="serverInfo">The <see cref="ServerInfoMessage"/> sent to new clients.</param>
public TcpServer(ServerSettings settings, ServerInfoMessage serverInfo)
{
Settings = settings;
ServerInfo = serverInfo;
ConnectionMonitor = new ConnectionMonitor(this);
}
