private void TurnServer_PeerDataReceived(ref ServerAsyncEventArgs e)
{
//lock (syncRoot)
{
try
{
Allocation allocation = allocations.GetByPeer(e.LocalEndPoint, e.RemoteEndPoint);
if (allocation != null)
{
allocation.TouchLifetime();
if (allocation.IsActiveDestinationEnabled)
{
e.LocalEndPoint = allocation.Alocated;
e.RemoteEndPoint = allocation.ActiveDestination;
e.Count = e.BytesTransferred;
e.ConnectionId = ServerAsyncEventArgs.AnyNewConnectionId;
peerServer.SendAsync(e);
e = null;
}
}
}
catch (Exception ex)
{
logger.WriteWarning(ex.ToString());
}
}
}
public void ProcessOutgoing(ServerAsyncEventArgs e)
{
int sessionId = e.ConnectionId;
Session session;
if (sessions.TryGetValue(sessionId, out session) == false)
{
// send error
}
else
{
lock (session)
{
if (session.IsConnected)
{
SendSipEventArgs(e, session);
}
else
{
session.AddOutgoingMessage(e);
}
}
}
}
public int ProccessTransactionUser(bool isAck, ServerAsyncEventArgs e)
{
int action = 0;
switch (State)
{
case Transaction.States.Created:
action |= Transaction.Action.SendOutgoingMessage;
if (e.LocalEndPoint.IsTransportUnreliable())
{
eventArgs = e.CreateDeepCopy();
}
action |= SetState(Transaction.States.Trying);
break;
case Transaction.States.Trying:
case Transaction.States.Proceeding:
case Transaction.States.Completed:
case Transaction.States.Terminated:
break;
}
return(action);
}
public int ProccessTransactionUser(int statusCode, ServerAsyncEventArgs e)
{
int action = 0;
switch (State)
{
case Transaction.States.Proceeding:
action |= Transaction.Action.SendOutgoingMessage;
if (statusCode >= 101 && statusCode <= 199)
{
CacheMessage(e);
}
else if (statusCode >= 200 && statusCode <= 299)
{
action |= SetState(Transaction.States.Terminated);
}
else if (statusCode >= 300 && statusCode <= 699)
{
CacheMessage(e);
action |= SetState(Transaction.States.Completed);
}
break;
case Transaction.States.Completed:
case Transaction.States.Confirmed:
case Transaction.States.Terminated:
break;
}
return(action);
}
//private bool IsInitialRequest(HttpMessageReader httpReader)
//{
// return httpReader.RequestUri.ToString().Contains("connect=1");
//}
//private int GetSessionId(HttpMessageReader httpReader)
//{
// uint cookie;
// if (httpReader.TryGetCookieUInt(cookieName, out cookie))
// return Session.GetSessionId(GetConnectionId(httpReader), (int)cookie);
// return -1;
//}
private void SendSipEventArgs(ServerAsyncEventArgs e, Session session)
{
session.RestoreAddresses(e);
WriteHttpHeader(e);
SendAsync(e, true);
}
static void ServersManager_Sent(ServersManager <HttpConnection> s, ref ServerAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Console.WriteLine("Sent error: {0}", e.SocketError.ToString());
}
}
private void CacheMessage(ServerAsyncEventArgs e)
{
if (eventArgs != null)
{
eventArgs.Dispose();
}
eventArgs = e.CreateDeepCopy();
}
private void SendWriter(ServerAsyncEventArgs r, HttpMessageWriter writer)
{
r.Count = writer.Count;
r.OffsetOffset = writer.OffsetOffset;
r.AttachBuffer(writer.Detach());
SendAsync(r, false);
}
public BufferHandle Dettach(ref ServerAsyncEventArgs e)
{
ArraySegment <byte> segment1, segment2;
base.Dettach(ref e, out segment1, out segment2);
return(new BufferHandle(segment1, segment2));
}
public void RestoreAddresses(ServerAsyncEventArgs e)
{
e.ConnectionId = connectionId;
e.LocalEndPoint = localEndPoint;
e.RemoteEndPoint = remoteEndPoint;
localEndPoint = null;
remoteEndPoint = null;
}
public int ProccessTransactionUser(int statusCode, ServerAsyncEventArgs e)
{
int action = 0;
switch (State)
{
case Transaction.States.Trying:
action |= Transaction.Action.SendOutgoingMessage;
if (statusCode >= 100 && statusCode <= 199)
{
eventArgs = e.CreateDeepCopy();
SetState(Transaction.States.Proceeding, ref action);
}
else if (statusCode >= 200 && statusCode <= 699)
{
if (e.LocalEndPoint.IsTransportUnreliable())
{
SetState(Transaction.States.Completed, ref action);
}
else
{
SetState(Transaction.States.Terminated, ref action);
}
}
break;
case Transaction.States.Proceeding:
action |= Transaction.Action.SendOutgoingMessage;
if (statusCode >= 200 && statusCode <= 699)
{
if (e.LocalEndPoint.IsTransportUnreliable())
{
eventArgs = e.CreateDeepCopy();
SetState(Transaction.States.Completed, ref action);
}
else
{
SetState(Transaction.States.Terminated, ref action);
}
}
break;
case Transaction.States.Completed:
case Transaction.States.Terminated:
break;
}
return(action);
}
public void SendAsyncSip(ServerAsyncEventArgs e)
{
if (AjaxWebsocket.IsAjax(e))
{
ajax.ProcessOutgoing(e);
}
else
{
e.UserTokenForSending2 = SipModule;
serversManager.SendAsync(e);
}
}
public ServerAsyncEventArgs GetOutgoingMessage()
{
ServerAsyncEventArgs e = null;
if (outgoingMessages.Count > 0)
{
e = outgoingMessages[0];
outgoingMessages.RemoveAt(0);
}
return(e);
}
private void DoWork(ServerAsyncEventArgs e, int transactionKId, int action)
{
if ((action & Transaction.Action.SendOutgoingMessage) > 0)
{
SendAsync(e);
}
else
{
e.Dispose();
}
DoWork(transactionKId, action);
}
public IncomingMessage(ServerAsyncEventArgs e, SipMessageReader reader, ArraySegment <byte> content)
{
if (e.LocalEndPoint.Protocol != ServerProtocol.Udp)
{
throw new ArgumentException();
}
ConnectionAddresses = new ConnectionAddresses(Transports.Udp, e.LocalEndPoint,
new IPEndPoint(e.RemoteEndPoint.Address, e.RemoteEndPoint.Port), ServerAsyncEventArgs.AnyNewConnectionId);
Reader = reader;
Content = content;
Header = new ArraySegment <byte>(e.Buffer, e.Offset, e.BytesTransferred - content.Count);
}
private bool ServersManager_Received(ServersManager <Connection> s, Connection connection1, ref ServerAsyncEventArgs e1)
{
connection = connection1;
e = e1;
bool closeConnection = OnReceived();
e1 = e;
connection = null;
e = null;
return(closeConnection);
}
private static void WriteHttpHeader(ServerAsyncEventArgs e)
{
using (var writer = new HttpMessageWriter())
{
writer.WriteStatusLine(StatusCodes.OK);
writer.WriteContentLength(e.Count);
writer.WriteAccessControlHeaders();
writer.WriteCRLF();
e.OffsetOffset -= writer.Count;
e.Count += writer.Count;
Buffer.BlockCopy(writer.Buffer, writer.Offset, e.Buffer, e.Offset, writer.Count);
}
}
public int ProccessTransactionUser(int transactionId, ServerAsyncEventArgs e, int statusCode)
{
int action = 0;
lock (sync)
{
T transaction;
if (TryGet(transactionId, out transaction))
{
action = transaction.ProccessTransactionUser(statusCode, e);
UpdateOrRemove(transaction);
}
}
return(action);
}
private void GetBuffer(ServerEndPoint local, IPEndPoint remote, int length, out ServerAsyncEventArgs e, out int offset)
{
int headerLength = (local.Protocol == ServerProtocol.Tcp) ? TcpFramingHeader.TcpFramingHeaderLength : 0;
e = EventArgsManager.Get();
e.ConnectionId = ServerAsyncEventArgs.AnyConnectionId;
e.LocalEndPoint = local;
e.RemoteEndPoint = remote;
e.Count = headerLength + length;
e.AllocateBuffer();
if (headerLength > 0)
{
TcpFramingHeader.GetBytes(e.Buffer, e.Offset, TcpFrameType.ControlMessage, length);
}
offset = e.Offset + headerLength;
}
public bool Proccess(ref ServerAsyncEventArgs e, out bool closeConnection)
{
this.e = e;
if (index < maxThread)
{
release[index].Set();
ThreadPool.QueueUserWorkItem(Proccess, index);
done.WaitOne();
}
else
{
Proccess();
}
index = (index + 1) % (maxThread * 2);
e = this.e;
closeConnection = this.closeConnection;
return(repeat);
}
private void ServersManager_Sent(ServersManager <Connection> s, ref ServerAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
Tracer.WriteInformation("Send error");
switch (e.UserTokenForSending2 & 0x000000ff)
{
case SipModule:
SendErrorSip(e.UserTokenForSending);
break;
case HttpModule:
// e.UserTokenForSending2 >> 8 == httpModuleId
break;
case AjaxModule:
ajax.SendError(e.UserTokenForSending);
break;
}
}
}
public int ProccessTransactionUser(bool isAck, ServerAsyncEventArgs e)
{
int action = 0;
switch (State)
{
case Transaction.States.Created:
action |= Transaction.Action.SendOutgoingMessage;
eventArgs = e.CreateDeepCopy();
action |= SetState(Transaction.States.Calling);
break;
case Transaction.States.Calling:
case Transaction.States.Proceeding:
break;
case Transaction.States.Completed:
if (isAck && IsTransportUnreliable)
{
if (eventArgs != null)
{
eventArgs.Dispose();
}
eventArgs = e.CreateDeepCopy();
isAckCached = true;
}
break;
case Transaction.States.Terminated:
break;
}
return(action);
}
private void TurnServer_TurnDataReceived(ref ServerAsyncEventArgs e)
{
//lock (syncRoot)
{
TurnMessage response = null;
try
{
if (true)//(TransactionServer.GetCachedResponse(e, out response) == false)
{
TurnMessage request = TurnMessage.Parse(e.Buffer, e.Offset, e.BytesTransferred, TurnMessageRfc.MsTurn);
if (Authentificater.Process(request, out response))
{
Allocation allocation = null;
if (request.MsSequenceNumber != null)
{
allocation = allocations.Get(request.MsSequenceNumber.ConnectionId);
}
if (allocation != null)
{
if (request.MsSequenceNumber != null)
{
response = allocation.GetResponse(request.MsSequenceNumber.SequenceNumber);
}
}
if (response == null)
{
if (allocation != null)
{
allocation.TouchLifetime();
}
switch (request.MessageType)
{
case MessageType.AllocateRequest:
response = ProcessAllocateRequest(ref allocation, request, e.LocalEndPoint, e.RemoteEndPoint);
break;
case MessageType.SendRequest:
response = ProcessSendRequest(allocation, request, ref e);
break;
case MessageType.SetActiveDestinationRequest:
response = ProcessSetActiveDestinationRequest(allocation, request, e.RemoteEndPoint);
break;
}
if (allocation != null && response != null)
{
allocation.SetResponse(response);
}
}
}
//TransactionServer.CacheResponse(e, response);
}
}
catch (TurnMessageException ex)
{
response = GetErrorResponse(ex.ErrorCode, e);
}
catch (TurnServerException ex)
{
response = GetErrorResponse(ex.ErrorCode, e);
}
catch (Exception ex)
{
response = GetErrorResponse(ErrorCode.ServerError, e);
logger.WriteError(ex.ToString());
}
if (response != null)
{
SendTurn(response, e.LocalEndPoint, e.RemoteEndPoint);
}
}
}
private void SendAsyncAjax(ServerAsyncEventArgs e, bool sipAjax)
{
e.UserTokenForSending2 = sipAjax ? SipModule : AjaxModule;
serversManager.SendAsync(e);
}
private TurnMessage ProcessSendRequest(Allocation allocation, TurnMessage request, ref ServerAsyncEventArgs e)
{
try
{
if (allocation == null)
{
throw new TurnServerException(ErrorCode.NoBinding);
}
if (request.Data == null || request.DestinationAddress == null)
{
throw new TurnServerException(ErrorCode.BadRequest);
}
allocation.Permissions.Permit(request.DestinationAddress.IpEndPoint);
e.LocalEndPoint = allocation.Alocated;
e.RemoteEndPoint = request.DestinationAddress.IpEndPoint;
e.Offset = request.Data.ValueRefOffset;
e.Count = request.Data.ValueRefLength;
e.ConnectionId = ServerAsyncEventArgs.AnyNewConnectionId;
peerServer.SendAsync(e);
e = null;
}
catch (Exception ex)
{
logger.WriteWarning(ex.ToString());
}
// [MS-TURN] The server MUST NOT respond to a client with either
// a Send response or a Send error response.
return(null);
}
public void SendAsyncHttp(ServerAsyncEventArgs e, int httpModuleId)
{
e.UserTokenForSending2 = HttpModule | (httpModuleId << 8);
serversManager.SendAsync(e);
}
private bool TurnServer_Received(ServersManager <TurnConnection> s, TurnConnection c, ref ServerAsyncEventArgs e)
{
if (e.LocalEndPoint.Protocol == ServerProtocol.Udp)
{
if (TurnMessage.IsTurnMessage(e.Buffer, e.Offset, e.BytesTransferred))
{
TurnServer_TurnDataReceived(ref e);
}
else
{
TurnServer_PeerDataReceived(ref e);
}
}
else if (e.LocalEndPoint.Protocol == ServerProtocol.Tcp)
{
if (c.Buffer.IsValid)
{
c.Buffer.Resize(Math.Max(4096, c.BytesExpected));
if (c.Buffer.CopyTransferredFrom(e, 0) == false)
{
return(false);
}
if (c.Buffer.Count < c.BytesExpected)
{
return(true);
}
}
else
{
if (e.BytesTransferred < c.BytesExpected)
{
return(c.Buffer.CopyTransferredFrom(e, 0));
}
}
int proccessed = 0;
for (; ;)
{
if (c.Buffer.IsValid)
{
if (e == null)
{
e = EventArgsManager.Get();
e.CopyAddressesFrom(c);
}
e.AttachBuffer(c.Buffer);
proccessed = 0;
}
if (e.BytesTransferred - proccessed < c.BytesExpected)
{
return(c.Buffer.CopyTransferredFrom(e, proccessed));
}
switch (c.Phase)
{
case TcpPhase.WaitingFirstXpacket:
if (pseudoTlsMessage.IsBeginOfClientHello(e.Buffer, e.Offset, FirstXpacketLength))
{
c.Phase = TcpPhase.WaitingClientHello;
c.BytesExpected = PseudoTlsMessage.ClientHelloLength;
}
else
{
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
if (FirstXpacketLength <= TcpFramingHeader.TcpFramingHeaderLength)
{
goto case TcpPhase.WaitingTcpFrame;
}
}
break;
case TcpPhase.WaitingClientHello:
if (pseudoTlsMessage.IsClientHello(e.Buffer, e.Offset) == false)
{
return(false);
}
var x = EventArgsManager.Get();
x.CopyAddressesFrom(e);
x.Count = PseudoTlsMessage.ServerHelloHelloDoneLength;
pseudoTlsMessage.GetServerHelloHelloDoneBytes(x.Buffer, x.Offset);
s.SendAsync(x);
proccessed += c.BytesExpected;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
case TcpPhase.WaitingTcpFrame:
TcpFramingHeader tcpHeader;
if (TcpFramingHeader.TryParse(e.Buffer, e.Offset, out tcpHeader) == false)
{
return(false);
}
proccessed += c.BytesExpected;
c.Phase = (tcpHeader.Type == TcpFrameType.ControlMessage) ?
TcpPhase.WaitingTurnControlMessage : TcpPhase.WaitingTurnEndToEndData;
c.BytesExpected = tcpHeader.Length;
break;
case TcpPhase.WaitingTurnEndToEndData:
case TcpPhase.WaitingTurnControlMessage:
if (e.BytesTransferred - proccessed < c.BytesExpected)
{
if (c.Buffer.CopyTransferredFrom(e, proccessed + c.BytesExpected) == false)
{
return(false);
}
}
e.Count -= proccessed;
e.Offset += proccessed;
e.BytesTransferred = c.BytesExpected;
if (c.Phase == TcpPhase.WaitingTurnEndToEndData)
{
TurnServer_PeerDataReceived(ref e);
}
else
{
TurnServer_TurnDataReceived(ref e);
}
proccessed = e.BytesTransferred;
c.Phase = TcpPhase.WaitingTcpFrame;
c.BytesExpected = TcpFramingHeader.TcpFramingHeaderLength;
break;
default:
throw new NotImplementedException();
}
}
}
else
{
throw new NotImplementedException();
}
return(true);
}
public int ProccessTransactionUser(int transactionId, int router, int userData, bool isAck, ServerAsyncEventArgs e)
{
lock (sync)
{
var transaction = Add(transactionId, router, userData);
int action = transaction.ProccessTransactionUser(isAck, e);
UpdateOrRemove(transaction);
return(action);
}
}
private void ServersManager_BeforeSend(ServersManager <Connection> s, Connection c, ServerAsyncEventArgs e)
{
if (c != null && c.Mode == Connection.Modes.WebSocket)
{
//c.BeforeSend(e);
var header = new WebSocketHeader()
{
Fin = true,
Opcode = websocketOpcode.HasValue ? websocketOpcode.Value : c.WebSocketHeader.Opcode,
PayloadLength = e.Count,
};
int headerLength = header.GetHeaderLength();
if (e.OffsetOffset < headerLength)
{
throw new InvalidProgramException(@"TransportLayer.ServersManager_BeforeSend no reserved space for WebSocket header");
}
e.OffsetOffset -= headerLength;
e.Count += headerLength;
header.GenerateHeader(e.OutgoingData);
}
}
static bool ServersManager_Received(ServersManager <HttpConnection> s, HttpConnection connection, ref ServerAsyncEventArgs e)
{
bool closeConnection = false, repeat = true;
while (repeat)
{
repeat = connection.Proccess(ref e, out closeConnection);
if (connection.IsMessageReady)
{
httpServer.ProcessIncomingRequest(connection);
connection.ResetState();
}
}
return(!closeConnection);
}
