/// <summary>
/// TODO: Documentation StunClient_OnReceivedIndication
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
private void StunClient_OnReceivedIndication(object sender, StunMessage receivedMsg)
{
switch (receivedMsg.MethodType)
{
case StunMethodType.ConnectionAttempt:
if (this.OnConnectionAttemptReceived != null)
this.OnConnectionAttemptReceived(this, receivedMsg);
break;
case StunMethodType.Data:
if (this.OnDataReceived != null)
this.OnDataReceived(this, receivedMsg);
break;
}
}
/// <summary>
/// TODO: Documentation StunClient_OnReceivedError
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
/// <param name="sentMsg"></param>
/// <param name="transactionObject"></param>
private void StunClient_OnReceivedError(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject)
{
switch (receivedMsg.MethodType)
{
case StunMethodType.Allocate:
if (receivedMsg.Stun.ErrorCode.ErrorType == ErrorCodeType.Unauthorized)
{
String[] credentials = transactionObject as String[];
if (credentials != null)
this.AllocateRetry(receivedMsg, credentials[0], credentials[1]);
else
if (this.OnAllocateFailed != null)
this.OnAllocateFailed(this, receivedMsg, sentMsg, transactionObject);
}
break;
}
}
/// <summary>
/// TODO: Documentation turnManager_OnConnectionBindSucceed
/// </summary>
/// <param name="sender"></param>
/// <param name="connectedSocket"></param>
/// <param name="receivedMsg"></param>
private void turnManager_OnConnectionBindSucceed(object sender, Socket connectedSocket, StunMessage receivedMsg)
{
if (this.OnTurnConnectionBindSucceed != null)
this.OnTurnConnectionBindSucceed(this, connectedSocket, this.StartingSessionSid, this.StartingSessionRecipient);
if (this.OnConnectionTryEnded != null)
this.OnConnectionTryEnded(this, this.StartingSessionSid);
this.CancelStartingSession();
}
/// <summary>
/// TODO: Documentation StunClient_OnReceivedSuccessResponse
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
/// <param name="sentMsg"></param>
/// <param name="transactionObject"></param>
private void StunClient_OnReceivedSuccessResponse(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject)
{
switch (receivedMsg.MethodType)
{
case StunMethodType.Allocate:
TurnAllocation allocation = new TurnAllocation()
{
Username = sentMsg.Stun.Username.ValueString,
Password = transactionObject as String,
Realm = sentMsg.Stun.Realm.ValueString,
Nonce = sentMsg.Stun.Nonce.ValueString,
RelayedMappedAddress = receivedMsg.Turn.XorRelayedAddress,
MappedAddress = receivedMsg.Stun.XorMappedAddress,
StartTime = DateTime.Now,
LifeTime = StunUtilities.ReverseBytes(BitConverter.ToUInt32(receivedMsg.Turn.LifeTime.Value, 0))
};
if (this.Allocations.ContainsKey(receivedMsg.Turn.XorRelayedAddress))
this.Allocations[receivedMsg.Turn.XorRelayedAddress] = allocation;
else
{
this.Allocations.Add(receivedMsg.Turn.XorRelayedAddress, allocation);
if (this.OnAllocateSucceed != null)
this.OnAllocateSucceed(this, allocation, sentMsg, receivedMsg);
}
break;
case StunMethodType.CreatePermission:
TurnPermission permission = new TurnPermission()
{
PeerAddress = sentMsg.Turn.XorPeerAddress,
StartTime = DateTime.Now,
LifeTime = 300
};
TurnAllocation permAllocation = transactionObject as TurnAllocation;
if (permAllocation.Permissions.ContainsKey(sentMsg.Turn.XorPeerAddress))
permAllocation.Permissions[sentMsg.Turn.XorPeerAddress] = permission;
else
{
permAllocation.Permissions.Add(sentMsg.Turn.XorPeerAddress, permission);
if (this.OnCreatePermissionSucceed != null)
this.OnCreatePermissionSucceed(this, permAllocation, permission, sentMsg, receivedMsg);
}
break;
case StunMethodType.ChannelBind:
TurnChannel channel = new TurnChannel()
{
Channel = sentMsg.Turn.ChannelNumber,
PeerAddress = sentMsg.Turn.XorPeerAddress,
StartTime = DateTime.Now,
LifeTime = 600
};
TurnAllocation channelAllocation = transactionObject as TurnAllocation;
if (channelAllocation.Channels.ContainsKey(sentMsg.Turn.ChannelNumber))
channelAllocation.Channels[sentMsg.Turn.ChannelNumber] = channel;
else
{
channelAllocation.Channels.Add(sentMsg.Turn.ChannelNumber, channel);
if (this.OnChannelBindSucceed != null)
this.OnChannelBindSucceed(this, transactionObject as TurnAllocation, channel, sentMsg, receivedMsg);
}
break;
case StunMethodType.ConnectionBind:
if (this.OnConnectionBindSucceed != null)
this.OnConnectionBindSucceed(this, transactionObject as Socket, receivedMsg);
break;
}
}
/// <summary>
/// TODO: Documentation SendIndication
/// </summary>
/// <param name="xorPeerAddress"></param>
/// <param name="data"></param>
/// <param name="allocation"></param>
public void SendIndication(XorMappedAddress xorPeerAddress, byte[] data, TurnAllocation allocation)
{
StunMessage msg = new StunMessage(StunMethodType.Send, StunMethodClass.Indication, StunUtilities.NewTransactionId);
msg.Turn.XorPeerAddress = xorPeerAddress;
msg.Turn.Data = new StunAttribute(StunAttributeType.Data, data);
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, allocation.Username);
msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, allocation.Realm);
msg.Stun.Nonce = new UTF8Attribute(StunAttributeType.Nonce, allocation.Nonce);
msg.AddMessageIntegrity(allocation.Password, true);
this.StunClient.BeginSendMessage(msg, null);
}
/// <summary>
/// Sample usage of this StunClient
/// </summary>
/// <param name="args">Unused</param>
private static void Main(string[] args)
{
KeyValuePair<IPEndPoint, IPEndPoint> stunKeyValue = StunUtilities.GetMappedAddressFrom(null,
new IPEndPoint(IPAddress.Parse("66.228.45.110"), StunClient.DEFAULT_STUN_PORT),
ProtocolType.Udp);
StunMessage msg = new StunMessage(StunMethodType.Binding, StunMethodClass.Request, StunUtilities.NewTransactionId);
msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, "Hello World !");
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, "Bob");
byte[] octets = msg;
StunMessage msgCopy = octets;
// Reuse of an existing local IPEndPoint makes the three requests returning
// the same MappedAddress IPEndPoint if this client is behind a Cone NAT
StunClient cli1 = new StunClient(stunKeyValue.Key,
new IPEndPoint(IPAddress.Parse("66.228.45.110"), StunClient.DEFAULT_STUNS_PORT),
ProtocolType.Tcp, null,
(sender, certificate, chain, sslPolicyErrors) => true);
// Sample TLS over TCP working with ejabberd but may not work with the sample server IP given here
cli1.Connect();
StunMessage resp1 = cli1.SendMessage(msgCopy);
cli1.Disconnect();
msgCopy.ClearAttributes();
StunClient cli2 = new StunClient(stunKeyValue.Key,
new IPEndPoint(IPAddress.Parse("132.177.123.13"), StunClient.DEFAULT_STUN_PORT),
ProtocolType.Udp, null, null);
cli2.Connect();
StunMessage resp2 = cli2.SendMessage(msgCopy);
cli2.Disconnect();
}
/// <summary>
/// Computes a HMAC SHA1 based on this StunMessage attributes
/// </summary>
/// <param name="hmacSha1Key">The key of HMAC SHA1 computation algorithm</param>
/// <returns>The HMAC computed value of this StunMessage</returns>
private byte[] ComputeHMAC(byte[] hmacSha1Key)
{
byte[] hashed;
using (HMACSHA1 hmacSha1 = new HMACSHA1(hmacSha1Key))
{
StunMessage thisCopy = new StunMessage(this.MethodType, this.MethodClass, this.TransactionID);
foreach (var item in this.attributesList)
{
if (item.Key == StunAttributeType.MessageIntegrity)
break;
thisCopy.SetAttribute(item.Value);
}
if (this.Stun.FingerPrint != null)
thisCopy.SetAttribute(this.Stun.FingerPrint);
byte[] thisCopyBytes = thisCopy;
// Insert a fake message length for HMAC computation as described in [RFC5489#15.4]
UInt16 dummyLength = StunUtilities.ReverseBytes((UInt16)(thisCopy.MessageLength + 24)); // 20 hmac + 4 header
BitConverter.GetBytes(dummyLength).CopyTo(thisCopyBytes, 2);
hashed = hmacSha1.ComputeHash(thisCopyBytes);
}
return hashed;
}
/// <summary>
/// TODO: Documentation RefreshAllocation
/// </summary>
/// <param name="allocation"></param>
/// <param name="lifeTime"></param>
public void RefreshAllocation(TurnAllocation allocation, UInt32 lifeTime)
{
StunMessage msg = new StunMessage(StunMethodType.Refresh, StunMethodClass.Request, StunUtilities.NewTransactionId);
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, allocation.Username);
msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, allocation.Realm);
msg.Stun.Nonce = new UTF8Attribute(StunAttributeType.Nonce, allocation.Nonce);
msg.Turn.LifeTime = new StunAttribute(StunAttributeType.LifeTime, BitConverter.GetBytes(StunUtilities.ReverseBytes(lifeTime)));
msg.AddMessageIntegrity(allocation.Password, true);
this.StunClient.BeginSendMessage(msg, null);
}
/// <summary>
/// TODO: Documentation StunClient_OnReceivedError
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
/// <param name="sentMsg"></param>
/// <param name="transactionObject"></param>
private void StunClient_OnReceivedError(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject)
{
switch (receivedMsg.MethodType)
{
case StunMethodType.Allocate:
if (receivedMsg.Stun.ErrorCode.ErrorType == ErrorCodeType.Unauthorized)
{
String[] credentials = transactionObject as String[];
if (credentials != null)
{
this.AllocateRetry(receivedMsg, credentials[0], credentials[1]);
}
else
if (this.OnAllocateFailed != null)
{
this.OnAllocateFailed(this, receivedMsg, sentMsg, transactionObject);
}
}
break;
}
}
/// <summary>
/// TODO: Documentation Allocate
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
public void Allocate(String username, String password)
{
StunMessage msg = new StunMessage(StunMethodType.Allocate, StunMethodClass.Request, StunUtilities.NewTransactionId);
this.StunClient.BeginSendMessage(msg, new String[] { username, password });
}
/// <summary>
/// TODO: Documentation StunClient_OnReceivedSuccessResponse
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
/// <param name="sentMsg"></param>
/// <param name="transactionObject"></param>
private void StunClient_OnReceivedSuccessResponse(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject)
{
switch (receivedMsg.MethodType)
{
case StunMethodType.Allocate:
TurnAllocation allocation = new TurnAllocation()
{
Username = sentMsg.Stun.Username.ValueString,
Password = transactionObject as String,
Realm = sentMsg.Stun.Realm.ValueString,
Nonce = sentMsg.Stun.Nonce.ValueString,
RelayedMappedAddress = receivedMsg.Turn.XorRelayedAddress,
MappedAddress = receivedMsg.Stun.XorMappedAddress,
StartTime = DateTime.Now,
LifeTime = StunUtilities.ReverseBytes(BitConverter.ToUInt32(receivedMsg.Turn.LifeTime.Value, 0))
};
if (this.Allocations.ContainsKey(receivedMsg.Turn.XorRelayedAddress))
{
this.Allocations[receivedMsg.Turn.XorRelayedAddress] = allocation;
}
else
{
this.Allocations.Add(receivedMsg.Turn.XorRelayedAddress, allocation);
if (this.OnAllocateSucceed != null)
{
this.OnAllocateSucceed(this, allocation, sentMsg, receivedMsg);
}
}
break;
case StunMethodType.CreatePermission:
TurnPermission permission = new TurnPermission()
{
PeerAddress = sentMsg.Turn.XorPeerAddress,
StartTime = DateTime.Now,
LifeTime = 300
};
TurnAllocation permAllocation = transactionObject as TurnAllocation;
if (permAllocation.Permissions.ContainsKey(sentMsg.Turn.XorPeerAddress))
{
permAllocation.Permissions[sentMsg.Turn.XorPeerAddress] = permission;
}
else
{
permAllocation.Permissions.Add(sentMsg.Turn.XorPeerAddress, permission);
if (this.OnCreatePermissionSucceed != null)
{
this.OnCreatePermissionSucceed(this, permAllocation, permission, sentMsg, receivedMsg);
}
}
break;
case StunMethodType.ChannelBind:
TurnChannel channel = new TurnChannel()
{
Channel = sentMsg.Turn.ChannelNumber,
PeerAddress = sentMsg.Turn.XorPeerAddress,
StartTime = DateTime.Now,
LifeTime = 600
};
TurnAllocation channelAllocation = transactionObject as TurnAllocation;
if (channelAllocation.Channels.ContainsKey(sentMsg.Turn.ChannelNumber))
{
channelAllocation.Channels[sentMsg.Turn.ChannelNumber] = channel;
}
else
{
channelAllocation.Channels.Add(sentMsg.Turn.ChannelNumber, channel);
if (this.OnChannelBindSucceed != null)
{
this.OnChannelBindSucceed(this, transactionObject as TurnAllocation, channel, sentMsg, receivedMsg);
}
}
break;
case StunMethodType.ConnectionBind:
if (this.OnConnectionBindSucceed != null)
{
this.OnConnectionBindSucceed(this, transactionObject as Socket, receivedMsg);
}
break;
}
}
/// <summary>
/// Sends a StunMessage to the connected STUN Server.
/// </summary>
/// <param name="msgToSend">The StunMessage to send to the connected STUN Server</param>
/// <param name="transactionObject"></param>
public void BeginSendMessage(StunMessage msgToSend, Object transactionObject)
{
if(msgToSend.MethodClass == StunMethodClass.Request)
this.PendingTransactions.Add(msgToSend.TransactionID, new KeyValuePair<StunMessage, Object>(msgToSend, transactionObject));
if (this.UseSsl)
this.SslStream.BeginWrite(msgToSend, 0, msgToSend.Bytes.Length, new AsyncCallback(this.SendCallback), null);
else
this.Socket.BeginSend(msgToSend, 0, msgToSend.Bytes.Length, SocketFlags.None, new AsyncCallback(this.SendCallback), null);
}
/// <summary>
/// Sends a StunMessage to the connected STUN Server.
/// </summary>
/// <param name="msgToSend">The StunMessage to send to the connected STUN Server</param>
/// <returns>The STUN Server response or null if msgToSend parameter is not a Request</returns>
public StunMessage SendMessage(StunMessage msgToSend)
{
Boolean waitForResponse = msgToSend.MethodClass == StunMethodClass.Request;
byte[] msgReceived = new byte[StunClient.BUFFER_SIZE];
if (this.UseSsl)
{
this.SslStream.Write(msgToSend, 0, msgToSend.Bytes.Length);
if (waitForResponse)
this.SslStream.Read(msgReceived, 0, StunClient.BUFFER_SIZE);
}
else
{
this.Socket.Send(msgToSend, 0, msgToSend.Bytes.Length, SocketFlags.None);
if (waitForResponse)
this.Socket.Receive(msgReceived, 0, StunClient.BUFFER_SIZE, SocketFlags.None);
}
if (waitForResponse &&
new ByteArrayComparer().Equals(((StunMessage)msgReceived).TransactionID, msgToSend.TransactionID))
{
return msgReceived;
}
return null;
}
/// <summary>
/// TODO: Documentation Allocate
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
public void Allocate(String username, String password)
{
StunMessage msg = new StunMessage(StunMethodType.Allocate, StunMethodClass.Request, StunUtilities.NewTransactionId);
this.StunClient.BeginSendMessage(msg, new String[] { username, password });
}
/// <summary>
/// TODO: Documentation turnManager_OnAllocateSucceed
/// </summary>
/// <param name="sender"></param>
/// <param name="allocation"></param>
/// <param name="sentMsg"></param>
/// <param name="receivedMsg"></param>
private void turnManager_OnAllocateSucceed(object sender, TurnAllocation allocation, StunMessage sentMsg, StunMessage receivedMsg)
{
if (this.StartingSessionRecipient != null)
{
this.turnSessions[this.StartingSessionSid].TurnAllocation = allocation;
XmlDocument doc = new XmlDocument();
// Jingle Transport
JingleIce jingleIce = new JingleIce(doc)
{
Pwd = JingleUtilities.GenerateIcePwd,
Ufrag = JingleUtilities.GenerateIceUfrag
};
if (this.OnIceCandidatesGathering != null)
this.OnIceCandidatesGathering(this, jingleIce, (sender as TurnManager).HostEP, this.turnSessions[this.StartingSessionSid].UseTurnOnly, allocation);
this.localCandidates.Add(this.StartingSessionSid, jingleIce.GetCandidates());
JingleIQ jingleIq = null;
// Jingle Description
Element jingleDescription = null;
String contentName = null;
if (this.OnDescriptionGathering != null)
this.OnDescriptionGathering(this, doc, this.StartingSessionSid, ref jingleDescription, ref contentName);
jingleIq = this.JingleManager.SessionRequest(this.StartingSessionRecipient,
this.StartingSessionAction,
this.StartingSessionSid, contentName,
jingleDescription, jingleIce);
//this.jingleManager.FindSession(this.StartingSessionSid).Local = jingleIq.Instruction;
this.Stream.Write(jingleIq);
}
}
/// <summary>
/// TODO: Documentation AllocateRetry
/// </summary>
/// <param name="receivedMsg"></param>
/// <param name="username"></param>
/// <param name="password"></param>
private void AllocateRetry(StunMessage receivedMsg, String username, String password)
{
StunMessage msg = new StunMessage(StunMethodType.Allocate, StunMethodClass.Request, StunUtilities.NewTransactionId);
msg.Turn.RequestedTransport = new StunAttribute(StunAttributeType.RequestedTransport, BitConverter.GetBytes(StunMessage.CODE_POINT_TCP));
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, username);
msg.Stun.Realm = receivedMsg.Stun.Realm;
msg.Stun.Nonce = receivedMsg.Stun.Nonce;
msg.AddMessageIntegrity(password, true);
this.StunClient.BeginSendMessage(msg, password);
}
/// <summary>
/// TODO: Documentation turnManager_OnAllocateFailed
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
/// <param name="sentMsg"></param>
/// <param name="transactionObject"></param>
private void turnManager_OnAllocateFailed(object sender, StunMessage receivedMsg, StunMessage sentMsg, object transactionObject)
{
if (this.StartingSessionRecipient != null)
{
if (this.OnConnectionTryEnded != null)
this.OnConnectionTryEnded(this, this.StartingSessionSid);
this.DestroyTurnSession(this.StartingSessionSid);
this.CancelStartingSession();
}
}
/// <summary>
/// TODO: Documentation BindChannel
/// </summary>
/// <param name="channelNumber"></param>
/// <param name="xorPeerAddress"></param>
/// <param name="allocation"></param>
public void BindChannel(byte[] channelNumber, XorMappedAddress xorPeerAddress, TurnAllocation allocation)
{
StunMessage msg = new StunMessage(StunMethodType.ChannelBind, StunMethodClass.Request, StunUtilities.NewTransactionId);
msg.Turn.ChannelNumber = new StunAttribute(StunAttributeType.ChannelNumber, channelNumber);
msg.Turn.XorPeerAddress = xorPeerAddress;
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, allocation.Username);
msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, allocation.Realm);
msg.Stun.Nonce = new UTF8Attribute(StunAttributeType.Nonce, allocation.Nonce);
msg.AddMessageIntegrity(allocation.Password, true);
this.StunClient.BeginSendMessage(msg, allocation);
}
/// <summary>
/// TODO: Documentation turnManager_OnConnectionAttemptReceived
/// </summary>
/// <param name="sender"></param>
/// <param name="receivedMsg"></param>
private void turnManager_OnConnectionAttemptReceived(object sender, StunMessage receivedMsg)
{
(sender as TurnManager).ConnectionBind(receivedMsg.Turn.ConnectionId, this.TurnUsername, this.TurnPassword);
}
/// <summary>
/// TODO: Documentation ConnectionBind
/// </summary>
/// <param name="connectionId"></param>
/// <param name="username"></param>
/// <param name="password"></param>
public void ConnectionBind(StunAttribute connectionId, String username, String password)
{
this.TurnTcpManager = new TurnManager(this.StunClient.ServerEP,
this.StunClient.ProtocolType,
this.StunClient.ClientCertificate,
this.StunClient.RemoteCertificateValidation);
this.TurnTcpManager.OnAllocateSucceed += (object sender, TurnAllocation allocation, StunMessage sentMsg, StunMessage receivedMsg) =>
{
StunMessage msg = new StunMessage(StunMethodType.ConnectionBind, StunMethodClass.Request, StunUtilities.NewTransactionId);
msg.Turn.ConnectionId = connectionId;
msg.Stun.Username = new UTF8Attribute(StunAttributeType.Username, allocation.Username);
msg.Stun.Realm = new UTF8Attribute(StunAttributeType.Realm, allocation.Realm);
msg.Stun.Nonce = new UTF8Attribute(StunAttributeType.Nonce, allocation.Nonce);
msg.AddMessageIntegrity(allocation.Password, true);
this.TurnTcpManager.StunClient.BeginSendMessage(msg, this.TurnTcpManager.StunClient.Socket);
};
this.TurnTcpManager.OnConnectionBindSucceed += (object sender, Socket connectedSocket, StunMessage receivedMsg) =>
{
this.TurnTcpManager.Allocations.Clear();
this.TurnTcpManager.StunClient.Cancel = true;
if (this.OnConnectionBindSucceed != null)
this.OnConnectionBindSucceed(sender, connectedSocket, receivedMsg);
};
this.TurnTcpManager.Connect();
this.TurnTcpManager.Allocate(username, password);
}
/// <summary>
/// TODO: Documentation ReceiveCallback
/// </summary>
/// <param name="ar"></param>
private void ReceiveCallback(IAsyncResult ar)
{
byte[] state = (byte[])ar.AsyncState;
try
{
Int32 bytesReceived;
if (this.UseSsl)
{
bytesReceived = this.SslStream.EndRead(ar);
}
else
{
bytesReceived = this.Socket.EndReceive(ar);
}
if (bytesReceived > 0)
{
StunMessage receivedMsg = state;
KeyValuePair <StunMessage, Object> transactionObject = new KeyValuePair <StunMessage, Object>();
switch (receivedMsg.MethodClass)
{
case StunMethodClass.SuccessResponse:
if (!this.IsPendingTransaction(receivedMsg.TransactionID, out transactionObject))
{
return;
}
if (this.OnReceivedSuccessResponse != null)
{
this.OnReceivedSuccessResponse(this, receivedMsg, transactionObject.Key, transactionObject.Value);
}
break;
case StunMethodClass.Indication:
if (this.OnReceivedIndication != null)
{
this.OnReceivedIndication(this, receivedMsg);
}
break;
case StunMethodClass.Error:
if (!this.IsPendingTransaction(receivedMsg.TransactionID, out transactionObject))
{
return;
}
if (this.OnReceivedError != null)
{
this.OnReceivedError(this, receivedMsg, transactionObject.Key, transactionObject.Value);
}
break;
}
byte[] result = new byte[StunClient.BUFFER_SIZE];
if (this.Socket != null && !this.Cancel)
{
if (this.UseSsl)
{
this.SslStream.BeginRead(result, 0, result.Length, new AsyncCallback(this.ReceiveCallback), result);
}
else
{
this.Socket.BeginReceive(result, 0, result.Length, SocketFlags.None, new AsyncCallback(this.ReceiveCallback), result);
}
}
}
else
{
if (!this.isDisconnecting)
{
this.Disconnect();
}
}
}
catch (Exception ex)
{
if (!this.isDisconnecting)
{
this.Disconnect();
}
}
}