public void RegisterSession(ISessionContext SessionContext)
{
var sc = (SessionContext)(SessionContext);
if (sc == null)
{
throw new InvalidOperationException();
}
SessionSet.DoAction(ss => ss.Add(sc));
}
protected void SendAsync(Byte[] Bytes, int Offset, int Count, Action Completed, Action <SocketError> Faulted)
{
Socket.DoAction
(
ss =>
{
if (ss == null)
{
return;
}
ss.SendAsync(Bytes, 0, Bytes.Length, Completed, Faulted);
}
);
}
public void AddToActionQueue(Action Action)
{
ActionQueue.DoAction
(
q =>
{
q.Queue.AddLast(Action);
if (!q.IsRunning)
{
q.IsRunning = true;
QueueUserWorkItem(ExecuteActionQueue);
}
}
);
}
private void OnShutdownRead()
{
Action OnFailure = null;
RawReadingContext.DoAction(c =>
{
if ((c.OnSuccess != null) && (c.OnFailure != null))
{
OnFailure = c.OnFailure;
c.OnSuccess = null;
c.OnFailure = null;
}
});
if (OnFailure != null)
{
OnFailure();
}
}
private void OnWrite(Unit w, Action OnSuccess, Action OnFailure)
{
var ByteArrays = vts.TakeWriteBuffer();
var TotalLength = ByteArrays.Sum(b => b.Length);
var WriteBuffer = new Byte[GetMinNotLessPowerOfTwo(TotalLength)];
var Offset = 0;
foreach (var b in ByteArrays)
{
Array.Copy(b, 0, WriteBuffer, Offset, b.Length);
Offset += b.Length;
}
var RemoteEndPoint = this.RemoteEndPoint;
var SessionId = this.SessionId;
var SecureContext = this.SecureContext;
var Indices = new List <int>();
RawReadingContext.DoAction(c =>
{
if (c.NotAcknowledgedIndices.Count == 0)
{
return;
}
var MaxHandled = c.Parts.MaxHandled;
var Acknowledged = new List <int>();
foreach (var i in c.NotAcknowledgedIndices)
{
if (c.Parts.IsEqualOrAfter(MaxHandled, i))
{
Acknowledged.Add(i);
}
else if (PartContext.IsSuccessor(i, MaxHandled))
{
Acknowledged.Add(i);
MaxHandled = i;
}
}
foreach (var i in Acknowledged)
{
c.NotAcknowledgedIndices.Remove(i);
}
Indices.Add(MaxHandled);
Indices.AddRange(c.NotAcknowledgedIndices);
c.NotAcknowledgedIndices.Clear();
});
if ((ByteArrays.Length == 0) && (Indices.Count == 0))
{
OnSuccess();
return;
}
var Success = true;
var Parts = new List <Byte[]>();
CookedWritingContext.DoAction(c =>
{
var Time = DateTime.UtcNow;
var WritingOffset = 0;
while ((Indices.Count > 0) || (WritingOffset < TotalLength))
{
var Index = PartContext.GetSuccessor(c.WritenIndex);
var NumIndex = Indices.Count;
if (NumIndex > 0xFFFF)
{
Success = false;
return;
}
var IsACK = NumIndex > 0;
var Length = Math.Min(12 + (IsACK ? 2 + NumIndex * 2 : 0) + TotalLength - WritingOffset, MaxPacketLength);
var DataLength = Length - (12 + (IsACK ? 2 + NumIndex * 2 : 0));
if (DataLength < 0)
{
Success = false;
return;
}
var Buffer = new Byte[Length];
Buffer[0] = (Byte)(SessionId & 0xFF);
Buffer[1] = (Byte)((SessionId >> 8) & 0xFF);
Buffer[2] = (Byte)((SessionId >> 16) & 0xFF);
Buffer[3] = (Byte)((SessionId >> 24) & 0xFF);
var Flag = 0;
if (IsACK)
{
Flag |= 1; //ACK
Buffer[12] = (Byte)(NumIndex & 0xFF);
Buffer[13] = (Byte)((NumIndex >> 8) & 0xFF);
var j = 0;
foreach (var i in Indices)
{
Buffer[14 + j * 2] = (Byte)(i & 0xFF);
Buffer[14 + j * 2 + 1] = (Byte)((i >> 8) & 0xFF);
j += 1;
}
Indices.Clear();
}
Array.Copy(WriteBuffer, WritingOffset, Buffer, 12 + (IsACK ? 2 + NumIndex * 2 : 0), DataLength);
WritingOffset += DataLength;
var IsEncrypted = (SecureContext != null);
if (IsEncrypted)
{
Flag |= 2; //ENC
}
Buffer[4] = (Byte)(Flag & 0xFF);
Buffer[5] = (Byte)((Flag >> 8) & 0xFF);
Buffer[6] = (Byte)(Index & 0xFF);
Buffer[7] = (Byte)((Index >> 8) & 0xFF);
var Verification = 0;
if (SecureContext != null)
{
var Key = SecureContext.ServerToken.Concat(Cryptography.SHA256(Buffer.Skip(4).Take(4)));
var HMACBytes = Cryptography.HMACSHA256Simple(Key, Buffer).Take(4).ToArray();
Verification = HMACBytes[0] | ((Int32)(HMACBytes[1]) << 8) | ((Int32)(HMACBytes[2]) << 16) | ((Int32)(HMACBytes[3]) << 24);
}
else
{
Verification = Cryptography.CRC32(Buffer);
}
Buffer[8] = (Byte)(Verification & 0xFF);
Buffer[9] = (Byte)((Verification >> 8) & 0xFF);
Buffer[10] = (Byte)((Verification >> 16) & 0xFF);
Buffer[11] = (Byte)((Verification >> 24) & 0xFF);
var Part = new Part {
Index = Index, ResendTime = Time.AddIntMilliseconds(GetTimeoutMilliseconds(0)), Data = Buffer, ResentCount = 0
};
if (!c.Parts.TryPushPart(Index, Buffer))
{
Success = false;
return;
}
Parts.Add(Part.Data);
if (Server.ServerContext.EnableLogTransport)
{
Server.ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = SessionId.ToString("X8"), RemoteEndPoint = RemoteEndPoint, Time = DateTime.UtcNow, Type = "UdpTransport", Name = "Send", Message = "Index: " + Index.ToInvariantString() + " Length: " + Part.Data.Length.ToInvariantString()
});
}
c.WritenIndex = Index;
}
});
foreach (var p in Parts)
{
try
{
SendPacket(RemoteEndPoint, p);
}
catch
{
Success = false;
break;
}
}
if (!Success)
{
OnFailure();
}
else
{
OnSuccess();
}
}
private void OnWrite(IStreamedVirtualTransportClient vtc, Action OnSuccess, Action <SocketError> OnFailure)
{
var ByteArrays = vtc.TakeWriteBuffer();
var TotalLength = ByteArrays.Sum(b => b.Length);
var WriteBuffer = new Byte[GetMinNotLessPowerOfTwo(TotalLength)];
var Offset = 0;
foreach (var b in ByteArrays)
{
Array.Copy(b, 0, WriteBuffer, Offset, b.Length);
Offset += b.Length;
}
var RemoteEndPoint = this.RemoteEndPoint;
int SessionId = 0;
var State = ConnectionState.Initial;
this.ConnectionStateValue.Update(v =>
{
SessionId = this.SessionId;
State = v;
if (v == ConnectionState.Initial)
{
return(ConnectionState.Connecting);
}
return(v);
});
if (State == ConnectionState.Connecting)
{
throw new InvalidOperationException();
}
var SecureContext = this.SecureContext;
var Indices = new List <int>();
RawReadingContext.DoAction(c =>
{
if (c.NotAcknowledgedIndices.Count == 0)
{
return;
}
var MaxHandled = c.Parts.MaxHandled;
var Acknowledged = new List <int>();
foreach (var i in c.NotAcknowledgedIndices)
{
if (c.Parts.IsEqualOrAfter(MaxHandled, i))
{
Acknowledged.Add(i);
}
else if (PartContext.IsSuccessor(i, MaxHandled))
{
Acknowledged.Add(i);
MaxHandled = i;
}
}
foreach (var i in Acknowledged)
{
c.NotAcknowledgedIndices.Remove(i);
}
Indices.Add(MaxHandled);
Indices.AddRange(c.NotAcknowledgedIndices);
c.NotAcknowledgedIndices.Clear();
});
if ((ByteArrays.Length == 0) && (Indices.Count == 0))
{
OnSuccess();
return;
}
var se = SocketError.Success;
var Parts = new List <Byte[]>();
CookedWritingContext.DoAction(c =>
{
var Time = DateTime.UtcNow;
var WritingOffset = 0;
while (WritingOffset < TotalLength)
{
var Index = PartContext.GetSuccessor(c.WritenIndex);
var NumIndex = Indices.Count;
if (NumIndex > 0xFFFF)
{
se = SocketError.NoBufferSpaceAvailable;
return;
}
var IsACK = NumIndex > 0;
var Flag = 0;
if (State == ConnectionState.Initial)
{
Flag |= 4; //INI
IsACK = false;
}
var Length = Math.Min(12 + (IsACK ? 2 + NumIndex * 2 : 0) + TotalLength - WritingOffset, MaxPacketLength);
var DataLength = Length - (12 + (IsACK ? 2 + NumIndex * 2 : 0));
if (DataLength < 0)
{
se = SocketError.NoBufferSpaceAvailable;
return;
}
var Buffer = new Byte[Length];
Buffer[0] = (Byte)(SessionId & 0xFF);
Buffer[1] = (Byte)((SessionId >> 8) & 0xFF);
Buffer[2] = (Byte)((SessionId >> 16) & 0xFF);
Buffer[3] = (Byte)((SessionId >> 24) & 0xFF);
if (IsACK)
{
Flag |= 1; //ACK
Buffer[12] = (Byte)(NumIndex & 0xFF);
Buffer[13] = (Byte)((NumIndex >> 8) & 0xFF);
var j = 0;
foreach (var i in Indices)
{
Buffer[14 + j * 2] = (Byte)(i & 0xFF);
Buffer[14 + j * 2 + 1] = (Byte)((i >> 8) & 0xFF);
j += 1;
}
Indices.Clear();
}
Array.Copy(WriteBuffer, WritingOffset, Buffer, 12 + (IsACK ? 2 + NumIndex * 2 : 0), DataLength);
WritingOffset += DataLength;
if (SecureContext != null)
{
Flag |= 2; //ENC
}
Buffer[4] = (Byte)(Flag & 0xFF);
Buffer[5] = (Byte)((Flag >> 8) & 0xFF);
Buffer[6] = (Byte)(Index & 0xFF);
Buffer[7] = (Byte)((Index >> 8) & 0xFF);
var Verification = 0;
if (SecureContext != null)
{
var Key = SecureContext.ClientToken.Concat(Cryptography.SHA256(Buffer.Skip(4).Take(4)));
var HMACBytes = Cryptography.HMACSHA256Simple(Key, Buffer).Take(4).ToArray();
Verification = HMACBytes[0] | ((Int32)(HMACBytes[1]) << 8) | ((Int32)(HMACBytes[2]) << 16) | ((Int32)(HMACBytes[3]) << 24);
}
else
{
Verification = Cryptography.CRC32(Buffer);
}
Buffer[8] = (Byte)(Verification & 0xFF);
Buffer[9] = (Byte)((Verification >> 8) & 0xFF);
Buffer[10] = (Byte)((Verification >> 16) & 0xFF);
Buffer[11] = (Byte)((Verification >> 24) & 0xFF);
var Part = new Part {
Index = Index, ResendTime = Time.AddIntMilliseconds(GetTimeoutMilliseconds(0)), Data = Buffer, ResentCount = 0
};
if (!c.Parts.TryPushPart(Index, Buffer))
{
se = SocketError.NoBufferSpaceAvailable;
return;
}
Parts.Add(Part.Data);
//Debug.WriteLine(Times.DateTimeUtcWithMillisecondsToString(DateTime.UtcNow) + " Send SessionId: " + SessionId.ToString("X8") + " Index: " + Index.ToString());
c.WritenIndex = Index;
}
if (c.Timer == null)
{
c.Timer = new Timer(o => Check(), null, CheckTimeout, Timeout.Infinite);
}
});
foreach (var p in Parts)
{
try
{
SendPacket(RemoteEndPoint, p);
}
catch
{
se = SocketError.Interrupted;
break;
}
}
if (se != SocketError.Success)
{
OnFailure(se);
}
else
{
OnSuccess();
}
}
/// <summary>接收消息</summary>
/// <param name="DoResultHandle">运行处理消息函数，应保证不多线程同时访问BinarySocketClient</param>
/// <param name="UnknownFaulted">未知错误处理函数</param>
public void ReceiveAsync(Action <Action> DoResultHandle, Action <Exception> UnknownFaulted)
{
Action <Exception> Faulted = ex =>
{
if (!IsRunningValue.Check(b => b) && IsSocketErrorKnown(ex))
{
return;
}
UnknownFaulted(ex);
};
Action <int> Completed = null;
Completed = Count =>
{
Action a = () =>
{
if (Count == 0)
{
return;
}
while (true)
{
var r = VirtualTransportClient.Handle(Count);
if (r.OnContinue)
{
break;
}
else if (r.OnCommand)
{
DoResultHandle(r.Command.HandleResult);
var RemainCount = VirtualTransportClient.GetReadBuffer().Count;
if (RemainCount <= 0)
{
break;
}
Count = 0;
}
else
{
throw new InvalidOperationException();
}
}
var Buffer = VirtualTransportClient.GetReadBuffer();
var BufferLength = Buffer.Offset + Buffer.Count;
IsRunningValue.DoAction(b =>
{
if (b)
{
Socket.ReceiveAsync(Buffer.Array, BufferLength, Buffer.Array.Length - BufferLength, Completed, Faulted);
}
});
};
if (System.Diagnostics.Debugger.IsAttached)
{
a();
}
else
{
try
{
a();
}
catch (Exception ex)
{
Faulted(ex);
}
}
};
{
var Buffer = VirtualTransportClient.GetReadBuffer();
var BufferLength = Buffer.Offset + Buffer.Count;
Socket.ReceiveAsync(Buffer.Array, BufferLength, Buffer.Array.Length - BufferLength, Completed, Faulted);
}
}
public void Start()
{
var Success = false;
try
{
IsRunningValue.Update
(
b =>
{
if (b)
{
throw new InvalidOperationException();
}
if (BindingsValue.Length == 0)
{
throw new Exception("NoValidBinding");
}
ListeningTaskTokenSource = new CancellationTokenSource();
AcceptingTaskTokenSource = new CancellationTokenSource();
AcceptingTaskNotifier = new AutoResetEvent(false);
PurifieringTaskTokenSource = new CancellationTokenSource();
PurifieringTaskNotifier = new AutoResetEvent(false);
var ListeningTaskToken = ListeningTaskTokenSource.Token;
var AcceptingTaskToken = AcceptingTaskTokenSource.Token;
var PurifieringTaskToken = PurifieringTaskTokenSource.Token;
var Exceptions = new List <Exception>();
foreach (var Binding in BindingsValue)
{
var Socket = new Socket(Binding.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
Socket.Bind(Binding);
}
catch (SocketException ex)
{
Exceptions.Add(ex);
continue;
}
Socket.Listen(MaxConnectionsValue.HasValue ? (MaxConnectionsValue.Value + 1) : 128);
var BindingInfo = new BindingInfo
{
Socket = new LockedVariable <Socket>(Socket),
Task = null
};
var Task = new Task
(
() =>
{
try
{
while (true)
{
if (ListeningTaskToken.IsCancellationRequested)
{
return;
}
try
{
var a = BindingInfo.Socket.Check(s => s).Accept();
AcceptedSockets.Add(a);
AcceptingTaskNotifier.Set();
}
catch (SocketException)
{
if (ListeningTaskToken.IsCancellationRequested)
{
return;
}
BindingInfo.Socket.Update
(
OriginalSocket =>
{
try
{
OriginalSocket.Close();
}
catch (Exception)
{
}
try
{
OriginalSocket.Dispose();
}
catch (Exception)
{
}
var NewSocket = new Socket(Binding.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
NewSocket.Bind(Binding);
NewSocket.Listen(MaxConnectionsValue.HasValue ? (MaxConnectionsValue.Value + 1) : 128);
Socket = NewSocket;
return(NewSocket);
}
);
}
}
}
catch (ObjectDisposedException)
{
}
},
TaskCreationOptions.LongRunning
);
BindingInfo.Task = Task;
BindingInfos.Add(Binding, BindingInfo);
}
if (BindingInfos.Count == 0)
{
throw new AggregateException(Exceptions);
}
AcceptingTask = new Task
(
() =>
{
while (true)
{
if (AcceptingTaskToken.IsCancellationRequested)
{
return;
}
AcceptingTaskNotifier.WaitOne();
while (true)
{
Socket a;
if (!AcceptedSockets.TryTake(out a))
{
break;
}
var s = new TSession()
{
Server = (TServer)this,
RemoteEndPoint = (IPEndPoint)(a.RemoteEndPoint)
};
if (SessionIdleTimeoutValue.HasValue)
{
a.ReceiveTimeout = SessionIdleTimeoutValue.Value * 1000;
}
s.SetSocket(a);
if (MaxConnectionsValue.HasValue && (Sessions.Check(ss => ss.Count) >= MaxConnectionsValue.Value))
{
try
{
s.Start();
if (MaxConnectionsExceeded != null)
{
MaxConnectionsExceeded(s);
}
}
finally
{
s.Stop();
s.Dispose();
}
continue;
}
IPEndPoint e = (IPEndPoint)(a.RemoteEndPoint);
if (MaxConnectionsPerIPValue.HasValue && (IpSessions.Check(iss => iss.ContainsKey(e.Address) ? iss[e.Address] : 0) >= MaxConnectionsPerIPValue.Value))
{
try
{
s.Start();
if (MaxConnectionsPerIPExceeded != null)
{
MaxConnectionsPerIPExceeded(s);
}
}
finally
{
s.Stop();
s.Dispose();
}
continue;
}
Sessions.DoAction
(
ss =>
{
ss.Add(s);
}
);
IpSessions.DoAction
(
iss =>
{
if (iss.ContainsKey(e.Address))
{
iss[e.Address] += 1;
}
else
{
iss.Add(e.Address, 1);
}
}
);
s.Start();
}
}
},
AcceptingTaskToken,
TaskCreationOptions.LongRunning
);
PurifieringTask = new Task
(
() =>
{
while (true)
{
if (PurifieringTaskToken.IsCancellationRequested)
{
return;
}
PurifieringTaskNotifier.WaitOne();
TSession StoppingSession;
while (StoppingSessions.TryTake(out StoppingSession))
{
var Removed = false;
Sessions.DoAction
(
ss =>
{
if (ss.Contains(StoppingSession))
{
ss.Remove(StoppingSession);
Removed = true;
}
}
);
if (Removed)
{
var IpAddress = StoppingSession.RemoteEndPoint.Address;
IpSessions.DoAction
(
iss =>
{
if (iss.ContainsKey(IpAddress))
{
iss[IpAddress] -= 1;
if (iss[IpAddress] == 0)
{
iss.Remove(IpAddress);
}
}
}
);
}
StoppingSession.Stop();
StoppingSession.Dispose();
}
}
},
PurifieringTaskToken,
TaskCreationOptions.LongRunning
);
AcceptingTask.Start();
PurifieringTask.Start();
foreach (var BindingInfo in BindingInfos.Values)
{
BindingInfo.Task.Start();
}
Success = true;
return(true);
}
);
}
finally
{
if (!Success)
{
Stop();
}
}
}
public void Start()
{
var Success = false;
try
{
IsRunningValue.Update
(
b =>
{
if (b)
{
throw new InvalidOperationException();
}
if (BindingsValue.Length == 0)
{
throw new Exception("NoValidBinding");
}
ListeningTaskTokenSource = new CancellationTokenSource();
var ListeningTaskToken = ListeningTaskTokenSource.Token;
Action <UdpSession> Purify = StoppingSession =>
{
SessionSets.DoAction
(
ss =>
{
if (ss.Sessions.Contains(StoppingSession))
{
ss.Sessions.Remove(StoppingSession);
var IpAddress = StoppingSession.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (isi.Authenticated.Contains(StoppingSession))
{
isi.Authenticated.Remove(StoppingSession);
}
isi.Count -= 1;
if (isi.Count == 0)
{
ss.IpSessions.Remove(IpAddress);
}
var SessionId = StoppingSession.SessionId;
ss.SessionIdToSession.Remove(SessionId);
}
}
);
StoppingSession.Dispose();
};
Action <AcceptingInfo> Accept = a =>
{
var ep = a.RemoteEndPoint;
UdpSession s = null;
try
{
var Buffer = a.ReadBuffer;
if (Buffer.Length < 12)
{
return;
}
var SessionId = Buffer[0] | ((Int32)(Buffer[1]) << 8) | ((Int32)(Buffer[2]) << 16) | ((Int32)(Buffer[3]) << 24);
var Flag = Buffer[4] | ((Int32)(Buffer[5]) << 8);
var Index = Buffer[6] | ((Int32)(Buffer[7]) << 8);
var Verification = Buffer[8] | ((Int32)(Buffer[9]) << 8) | ((Int32)(Buffer[10]) << 16) | ((Int32)(Buffer[11]) << 24);
Buffer[8] = 0;
Buffer[9] = 0;
Buffer[10] = 0;
Buffer[11] = 0;
if (ServerContext.EnableLogTransport)
{
//按Flag中是否包含AUX分别生成日志
if ((Flag & 8) != 0)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = SessionId.ToString("X8"), RemoteEndPoint = ep, Time = DateTime.UtcNow, Type = "UdpTransport", Name = "ReceiveAux", Message = "AckIndex: " + Index.ToInvariantString() + " Length: " + Buffer.Length.ToInvariantString()
});
}
else
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = SessionId.ToString("X8"), RemoteEndPoint = ep, Time = DateTime.UtcNow, Type = "UdpTransport", Name = "Receive", Message = "Index: " + Index.ToInvariantString() + " Length: " + Buffer.Length.ToInvariantString()
});
}
}
//如果Flag中不包含ENC，则验证CRC32
if ((Flag & 2) == 0)
{
if (Cryptography.CRC32(Buffer) != Verification)
{
if (ServerContext.EnableLogTransport)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = SessionId.ToString("X8"), RemoteEndPoint = ep, Time = DateTime.UtcNow, Type = "UdpTransport", Name = "Receive", Message = "Index: " + Index.ToInvariantString() + " CRC32Failed"
});
}
return;
}
}
//如果Flag中包含INI，则初始化
if ((Flag & 4) != 0)
{
if ((Flag & 1) != 0)
{
return;
}
if ((Flag & 2) != 0)
{
return;
}
if ((Flag & 8) != 0)
{
return;
}
var Offset = 12;
s = new UdpSession(this, a.Socket, ep, VirtualTransportServerFactory, QueueUserWorkItem);
SessionId = s.SessionId;
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
PurifyConsumer.DoOne();
}
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
try
{
s.Start();
OnMaxConnectionsExceeded(s);
}
finally
{
s.Dispose();
}
return;
}
if (MaxConnectionsPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(ep.Address) ? ss.IpSessions[ep.Address].Count : 0) >= MaxConnectionsPerIPValue.Value))
{
try
{
s.Start();
OnMaxConnectionsPerIPExceeded(s);
}
finally
{
PurifyConsumer.Push(s);
}
return;
}
if (MaxUnauthenticatedPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(ep.Address) ? (ss.IpSessions[ep.Address].Count - ss.IpSessions[ep.Address].Authenticated.Count) : 0) >= MaxUnauthenticatedPerIPValue.Value))
{
try
{
s.Start();
OnMaxConnectionsPerIPExceeded(s);
}
finally
{
PurifyConsumer.Push(s);
}
return;
}
SessionSets.DoAction
(
ss =>
{
ss.Sessions.Add(s);
if (ss.IpSessions.ContainsKey(ep.Address))
{
ss.IpSessions[ep.Address].Count += 1;
}
else
{
var isi = new IpSessionInfo();
isi.Count += 1;
ss.IpSessions.Add(ep.Address, isi);
}
while ((SessionId == 0) || ss.SessionIdToSession.ContainsKey(SessionId))
{
s = new UdpSession(this, a.Socket, ep, VirtualTransportServerFactory, QueueUserWorkItem);
SessionId = s.SessionId;
}
ss.SessionIdToSession.Add(SessionId, s);
}
);
s.Start();
s.PrePush(() =>
{
if (!s.Push(ep, Index, null, Buffer, Offset, Buffer.Length - Offset))
{
PurifyConsumer.Push(s);
}
});
}
else
{
var Close = false;
SessionSets.DoAction
(
ss =>
{
if (!ss.SessionIdToSession.ContainsKey(SessionId))
{
Close = true;
return;
}
s = ss.SessionIdToSession[SessionId];
}
);
if (Close)
{
return;
}
s.PrePush(() =>
{
var IsEncrypted = (Flag & 2) != 0;
var NextSecureContext = s.NextSecureContext;
var SecureContext = s.SecureContext;
if ((SecureContext == null) && (NextSecureContext != null))
{
s.SecureContext = NextSecureContext;
s.NextSecureContext = null;
SecureContext = NextSecureContext;
NextSecureContext = null;
}
if ((SecureContext != null) != IsEncrypted)
{
return;
}
if (IsEncrypted)
{
var Key = SecureContext.ClientToken.Concat(Cryptography.SHA256(Buffer.Skip(4).Take(4)));
var HMACBytes = Cryptography.HMACSHA256Simple(Key, Buffer).Take(4).ToArray();
var HMAC = HMACBytes[0] | ((Int32)(HMACBytes[1]) << 8) | ((Int32)(HMACBytes[2]) << 16) | ((Int32)(HMACBytes[3]) << 24);
if (HMAC != Verification)
{
if (ServerContext.EnableLogTransport)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = SessionId.ToString("X8"), RemoteEndPoint = ep, Time = DateTime.UtcNow, Type = "UdpTransport", Name = "Receive", Message = "Index: " + Index.ToInvariantString() + " HMACFailed"
});
}
return;
}
}
var Offset = 12;
int[] Indices = null;
if ((Flag & 1) != 0)
{
if (Buffer.Length < 14)
{
return;
}
var NumIndex = Buffer[Offset] | ((Int32)(Buffer[Offset + 1]) << 8);
if (Buffer.Length < 14 + NumIndex * 2)
{
return;
}
if (NumIndex > UdpSession.WritingWindowSize) //若Index数量较大，则丢弃包
{
return;
}
Offset += 2;
Indices = new int[NumIndex];
for (int k = 0; k < NumIndex; k += 1)
{
Indices[k] = Buffer[Offset + k * 2] | ((Int32)(Buffer[Offset + k * 2 + 1]) << 8);
}
Offset += NumIndex * 2;
}
//如果Flag中包含AUX，则判断
if ((Flag & 8) != 0)
{
if (Indices == null)
{
return;
}
if (Indices.Length < 1)
{
return;
}
if (Index != Indices[0])
{
return;
}
if (Offset != Buffer.Length)
{
return;
}
}
var PreviousRemoteEndPoint = s.RemoteEndPoint;
if (!PreviousRemoteEndPoint.Equals(ep))
{
SessionSets.DoAction
(
ss =>
{
var Authenticated = false;
{
var PreviousIpAddress = PreviousRemoteEndPoint.Address;
var isi = ss.IpSessions[PreviousIpAddress];
if (isi.Authenticated.Contains(s))
{
isi.Authenticated.Remove(s);
Authenticated = true;
}
isi.Count -= 1;
if (isi.Count == 0)
{
ss.IpSessions.Remove(PreviousIpAddress);
}
}
{
IpSessionInfo isi;
if (ss.IpSessions.ContainsKey(ep.Address))
{
isi = ss.IpSessions[ep.Address];
isi.Count += 1;
}
else
{
isi = new IpSessionInfo();
isi.Count += 1;
ss.IpSessions.Add(ep.Address, isi);
}
if (Authenticated)
{
isi.Authenticated.Add(s);
}
}
s.RemoteEndPoint = ep;
}
);
}
if ((Flag & 8) != 0)
{
if (!s.PushAux(ep, Indices))
{
PurifyConsumer.Push(s);
}
}
else
{
if (!s.Push(ep, Index, Indices, Buffer, Offset, Buffer.Length - Offset))
{
PurifyConsumer.Push(s);
}
}
});
}
}
catch (Exception ex)
{
if (ServerContext.EnableLogSystem)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = "", RemoteEndPoint = ep, Time = DateTime.UtcNow, Type = "Sys", Name = "Exception", Message = ExceptionInfo.GetExceptionInfo(ex)
});
}
if (s != null)
{
PurifyConsumer.Push(s);
}
}
};
AcceptConsumer = new AsyncConsumer <AcceptingInfo>(QueueUserWorkItem, a => { Accept(a); return(true); }, int.MaxValue);
var Exceptions = new List <Exception>();
var Bindings = new List <IPEndPoint>();
//将所有默认地址换为实际的所有接口地址
foreach (var Binding in BindingsValue)
{
if (IPAddress.Equals(Binding.Address, IPAddress.Any) || IPAddress.Equals(Binding.Address, IPAddress.IPv6Any))
{
foreach (var ni in NetworkInterface.GetAllNetworkInterfaces())
{
foreach (var a in ni.GetIPProperties().UnicastAddresses)
{
if (a.Address.AddressFamily == Binding.Address.AddressFamily)
{
Bindings.Add(new IPEndPoint(a.Address, Binding.Port));
}
}
}
}
else
{
Bindings.Add(Binding);
}
}
foreach (var Binding in Bindings)
{
Func <Socket> CreateSocket = () =>
{
var s = new Socket(Binding.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
//在Windows下关闭SIO_UDP_CONNRESET报告，防止接受数据出错
//http://support.microsoft.com/kb/263823/en-us
if (System.Environment.OSVersion.Platform == PlatformID.Win32NT)
{
uint IOC_IN = 0x80000000;
uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
s.IOControl(unchecked ((int)(SIO_UDP_CONNRESET)), new byte[] { Convert.ToByte(false) }, null);
}
return(s);
};
var Socket = CreateSocket();
try
{
Socket.Bind(Binding);
}
catch (SocketException ex)
{
Exceptions.Add(ex);
continue;
}
var BindingInfo = new BindingInfo();
BindingInfo.EndPoint = Binding;
BindingInfo.Socket = new LockedVariable <Socket>(Socket);
Func <SocketAsyncEventArgs, Boolean> Completed = args =>
{
try
{
if (ListeningTaskToken.IsCancellationRequested)
{
return(false);
}
if (args.SocketError == SocketError.Success)
{
var Count = args.BytesTransferred;
var ReadBuffer = new Byte[Count];
Array.Copy(BindingInfo.ReadBuffer, ReadBuffer, Count);
var a = new AcceptingInfo {
Socket = BindingInfo.Socket.Check(s => s), ReadBuffer = ReadBuffer, RemoteEndPoint = (IPEndPoint)(args.RemoteEndPoint)
};
AcceptConsumer.Push(a);
}
else
{
BindingInfo.Socket.Update
(
OriginalSocket =>
{
try
{
OriginalSocket.Dispose();
}
catch (Exception)
{
}
var NewSocket = CreateSocket();
NewSocket.Bind(Binding);
return(NewSocket);
}
);
}
}
finally
{
args.Dispose();
}
BindingInfo.Start();
return(true);
};
BindingInfo.ListenConsumer = new AsyncConsumer <SocketAsyncEventArgs>(QueueUserWorkItem, Completed, 1);
BindingInfo.Start = () =>
{
var EventArgs = new SocketAsyncEventArgs();
EventArgs.RemoteEndPoint = new IPEndPoint(Binding.Address.AddressFamily == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any, 0);
EventArgs.SetBuffer(BindingInfo.ReadBuffer, 0, BindingInfo.ReadBuffer.Length);
var bs = BindingInfo.Socket.Check(s => s);
EventArgs.Completed += (o, args) => BindingInfo.ListenConsumer.Push(args);
try
{
if (!bs.ReceiveFromAsync(EventArgs))
{
BindingInfo.ListenConsumer.Push(EventArgs);
}
}
catch (ObjectDisposedException)
{
}
};
BindingInfos.Add(BindingInfo);
}
if (BindingInfos.Count == 0)
{
throw new AggregateException(Exceptions);
}
PurifyConsumer = new AsyncConsumer <UdpSession>(PurifierQueueUserWorkItem, s => { Purify(s); return(true); }, int.MaxValue);
if (UnauthenticatedSessionIdleTimeoutValue.HasValue || SessionIdleTimeoutValue.HasValue)
{
var TimePeriod = TimeSpan.FromSeconds(Math.Max(TimeoutCheckPeriodValue, 1));
LastActiveTimeCheckTimer = new Timer(state =>
{
if (UnauthenticatedSessionIdleTimeoutValue.HasValue)
{
var CheckTime = DateTime.UtcNow.AddIntSeconds(-UnauthenticatedSessionIdleTimeoutValue.Value);
SessionSets.DoAction
(
ss =>
{
foreach (var s in ss.Sessions)
{
var IpAddress = s.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (!isi.Authenticated.Contains(s))
{
if (s.LastActiveTime < CheckTime)
{
PurifyConsumer.Push(s);
}
}
}
}
);
}
if (SessionIdleTimeoutValue.HasValue)
{
var CheckTime = DateTime.UtcNow.AddIntSeconds(-SessionIdleTimeoutValue.Value);
SessionSets.DoAction
(
ss =>
{
foreach (var s in ss.Sessions)
{
var IpAddress = s.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (isi.Authenticated.Contains(s))
{
if (s.LastActiveTime < CheckTime)
{
PurifyConsumer.Push(s);
}
}
}
}
);
}
}, null, TimePeriod, TimePeriod);
}
foreach (var BindingInfo in BindingInfos)
{
BindingInfo.Start();
}
Success = true;
return(true);
}
);
}
finally
{
if (!Success)
{
Stop();
}
}
}
public void Start()
{
var Success = false;
try
{
IsRunningValue.Update
(
b =>
{
if (b)
{
throw new InvalidOperationException();
}
if (BindingsValue.Length == 0)
{
throw new Exception("NoValidBinding");
}
ListeningTaskTokenSource = new CancellationTokenSource();
var ListeningTaskToken = ListeningTaskTokenSource.Token;
Action <TcpSession> Purify = StoppingSession =>
{
SessionSets.DoAction
(
ss =>
{
if (ss.Sessions.Contains(StoppingSession))
{
ss.Sessions.Remove(StoppingSession);
var IpAddress = StoppingSession.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (isi.Authenticated.Contains(StoppingSession))
{
isi.Authenticated.Remove(StoppingSession);
}
isi.Count -= 1;
if (isi.Count == 0)
{
ss.IpSessions.Remove(IpAddress);
}
}
}
);
StoppingSession.Dispose();
};
Action <Socket> Accept = a =>
{
IPEndPoint ep;
try
{
ep = (IPEndPoint)(a.RemoteEndPoint);
}
catch
{
a.Dispose();
return;
}
var s = new TcpSession(this, new StreamedAsyncSocket(a, UnauthenticatedSessionIdleTimeoutValue, QueueUserWorkItem), ep, VirtualTransportServerFactory, QueueUserWorkItem);
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
PurifyConsumer.DoOne();
}
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
try
{
s.Start();
OnMaxConnectionsExceeded(s);
}
finally
{
s.Dispose();
}
return;
}
if (MaxConnectionsPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(ep.Address) ? ss.IpSessions[ep.Address].Count : 0) >= MaxConnectionsPerIPValue.Value))
{
try
{
s.Start();
OnMaxConnectionsPerIPExceeded(s);
}
finally
{
PurifyConsumer.Push(s);
}
return;
}
if (MaxUnauthenticatedPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(ep.Address) ? ss.IpSessions[ep.Address].Count : 0) >= MaxUnauthenticatedPerIPValue.Value))
{
try
{
s.Start();
OnMaxConnectionsPerIPExceeded(s);
}
finally
{
PurifyConsumer.Push(s);
}
return;
}
SessionSets.DoAction
(
ss =>
{
ss.Sessions.Add(s);
if (ss.IpSessions.ContainsKey(ep.Address))
{
ss.IpSessions[ep.Address].Count += 1;
}
else
{
var isi = new IpSessionInfo();
isi.Count += 1;
ss.IpSessions.Add(ep.Address, isi);
}
}
);
s.Start();
};
AcceptConsumer = new AsyncConsumer <Socket>(QueueUserWorkItem, a => { Accept(a); return(true); }, int.MaxValue);
var Exceptions = new List <Exception>();
foreach (var Binding in BindingsValue)
{
Func <Socket> CreateSocket = () =>
{
var s = new Socket(Binding.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
return(s);
};
var Socket = CreateSocket();
try
{
Socket.Bind(Binding);
}
catch (SocketException ex)
{
Exceptions.Add(ex);
continue;
}
Socket.Listen(MaxConnectionsValue.HasValue ? (MaxConnectionsValue.Value + 1) : 128);
var BindingInfo = new BindingInfo();
BindingInfo.EndPoint = Binding;
BindingInfo.Socket = new LockedVariable <Socket>(Socket);
Func <SocketAsyncEventArgs, Boolean> Completed = args =>
{
try
{
if (ListeningTaskToken.IsCancellationRequested)
{
return(false);
}
if (args.SocketError == SocketError.Success)
{
var a = args.AcceptSocket;
AcceptConsumer.Push(a);
}
else
{
BindingInfo.Socket.Update
(
OriginalSocket =>
{
try
{
OriginalSocket.Dispose();
}
catch (Exception)
{
}
var NewSocket = CreateSocket();
NewSocket.Bind(Binding);
NewSocket.Listen(MaxConnectionsValue.HasValue ? (MaxConnectionsValue.Value + 1) : 128);
return(NewSocket);
}
);
}
}
finally
{
args.Dispose();
}
BindingInfo.Start();
return(true);
};
BindingInfo.ListenConsumer = new AsyncConsumer <SocketAsyncEventArgs>(QueueUserWorkItem, Completed, 1);
BindingInfo.Start = () =>
{
var EventArgs = new SocketAsyncEventArgs();
var bs = BindingInfo.Socket.Check(s => s);
EventArgs.Completed += (o, args) =>
{
if (ListeningTaskToken.IsCancellationRequested)
{
return;
}
BindingInfo.ListenConsumer.Push(args);
};
try
{
if (!bs.AcceptAsync(EventArgs))
{
BindingInfo.ListenConsumer.Push(EventArgs);
}
}
catch (ObjectDisposedException)
{
}
};
BindingInfos.Add(BindingInfo);
}
if (BindingInfos.Count == 0)
{
throw new AggregateException(Exceptions);
}
PurifyConsumer = new AsyncConsumer <TcpSession>(PurifierQueueUserWorkItem, s => { Purify(s); return(true); }, int.MaxValue);
foreach (var BindingInfo in BindingInfos)
{
BindingInfo.Start();
}
Success = true;
return(true);
}
);
}
finally
{
if (!Success)
{
Stop();
}
}
}
public void Start()
{
var Success = false;
try
{
IsRunningValue.Update
(
b =>
{
if (b)
{
throw new InvalidOperationException();
}
if (BindingsValue.Length == 0)
{
throw new Exception("NoValidBinding");
}
ListeningTaskTokenSource = new CancellationTokenSource();
var ListeningTaskToken = ListeningTaskTokenSource.Token;
foreach (var Binding in BindingsValue)
{
Listener.Prefixes.Add(Binding);
}
if (UnauthenticatedSessionIdleTimeoutValue.HasValue)
{
SetTimer(Listener, UnauthenticatedSessionIdleTimeoutValue.Value);
}
Action <HttpListenerContext> PurifyContext = ListenerContext =>
{
try
{
ListenerContext.Response.Close();
}
catch
{
}
};
Action <HttpSession> Purify = StoppingSession =>
{
SessionSets.DoAction
(
ss =>
{
if (ss.Sessions.Contains(StoppingSession))
{
ss.Sessions.Remove(StoppingSession);
var IpAddress = StoppingSession.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (isi.Authenticated.Contains(StoppingSession))
{
isi.Authenticated.Remove(StoppingSession);
}
isi.Count -= 1;
if (isi.Count == 0)
{
ss.IpSessions.Remove(IpAddress);
}
var SessionId = ss.SessionToId[StoppingSession];
ss.SessionIdToSession.Remove(SessionId);
ss.SessionToId.Remove(StoppingSession);
}
}
);
StoppingSession.Dispose();
};
Action <HttpListenerContext> Accept = a =>
{
IPEndPoint e = null;
try
{
e = (IPEndPoint)a.Request.RemoteEndPoint;
var XForwardedFor = a.Request.Headers["X-Forwarded-For"];
var Address = e.Address;
if ((XForwardedFor != null) && (XForwardedFor != ""))
{
try
{
IPAddress addr;
if (IPAddress.TryParse(XForwardedFor.Split(',')[0].Trim(' '), out addr))
{
Address = addr;
}
}
catch
{
}
}
var XForwardedPort = a.Request.Headers["X-Forwarded-Port"];
var Port = e.Port;
if ((XForwardedPort != null) && (XForwardedPort != ""))
{
try
{
int p;
if (int.TryParse(XForwardedPort.Split(',')[0].Trim(' '), out p))
{
Port = p;
}
}
catch
{
}
}
e = new IPEndPoint(Address, Port);
if (ServerContext.EnableLogSystem)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = "", RemoteEndPoint = e, Time = DateTime.UtcNow, Type = "Sys", Name = "RequestIn", Message = ""
});
}
if (a.Request.ContentLength64 < 0)
{
a.Response.StatusCode = 411;
NotifyListenerContextQuit(a);
return;
}
if (a.Request.ContentLength64 > ReadBufferSize)
{
a.Response.StatusCode = 413;
NotifyListenerContextQuit(a);
return;
}
if (!IsMatchBindingName(a.Request.Url))
{
a.Response.StatusCode = 404;
NotifyListenerContextQuit(a);
return;
}
var Headers = a.Request.Headers.AllKeys.ToDictionary(k => k, k => a.Request.Headers[k]);
if (Headers.ContainsKey("Range"))
{
a.Response.StatusCode = 400;
NotifyListenerContextQuit(a);
return;
}
if (Headers.ContainsKey("Accept-Charset"))
{
var AcceptCharsetParts = Headers["Accept-Charset"].Split(';');
if (AcceptCharsetParts.Length == 0)
{
a.Response.StatusCode = 400;
NotifyListenerContextQuit(a);
return;
}
var EncodingNames = AcceptCharsetParts[0].Split(',').Select(n => n.Trim(' ')).ToArray();
if (!(EncodingNames.Contains("utf-8", StringComparer.OrdinalIgnoreCase) || EncodingNames.Contains("*", StringComparer.OrdinalIgnoreCase)))
{
a.Response.StatusCode = 400;
NotifyListenerContextQuit(a);
return;
}
}
{
var Query = HttpListenerRequestExtension.GetQuery(a.Request);
if (Query.ContainsKey("sessionid"))
{
HttpSession s = null;
var SessionId = Query["sessionid"];
var Close = false;
SessionSets.DoAction
(
ss =>
{
if (!ss.SessionIdToSession.ContainsKey(SessionId))
{
a.Response.StatusCode = 403;
Close = true;
return;
}
var CurrentSession = ss.SessionIdToSession[SessionId];
if (!CurrentSession.RemoteEndPoint.Address.Equals(e.Address))
{
a.Response.StatusCode = 403;
Close = true;
return;
}
s = ss.SessionIdToSession[SessionId];
}
);
if (Close)
{
NotifyListenerContextQuit(a);
return;
}
var NewSessionId = Convert.ToBase64String(Cryptography.CreateRandom(64));
SessionSets.DoAction
(
ss =>
{
ss.SessionIdToSession.Remove(SessionId);
ss.SessionIdToSession.Add(NewSessionId, s);
ss.SessionToId[s] = NewSessionId;
}
);
if (!s.Push(a, NewSessionId))
{
NotifyListenerContextQuit(a);
return;
}
return;
}
}
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
ContextPurifyConsumer.DoOne();
PurifyConsumer.DoOne();
}
if (MaxConnectionsValue.HasValue && (SessionSets.Check(ss => ss.Sessions.Count) >= MaxConnectionsValue.Value))
{
a.Response.StatusCode = 503;
NotifyListenerContextQuit(a);
return;
}
if (MaxConnectionsPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(e.Address) ? ss.IpSessions[e.Address].Count : 0) >= MaxConnectionsPerIPValue.Value))
{
a.Response.StatusCode = 503;
NotifyListenerContextQuit(a);
return;
}
if (MaxUnauthenticatedPerIPValue.HasValue && (SessionSets.Check(ss => ss.IpSessions.ContainsKey(e.Address) ? (ss.IpSessions[e.Address].Count - ss.IpSessions[e.Address].Authenticated.Count) : 0) >= MaxUnauthenticatedPerIPValue.Value))
{
a.Response.StatusCode = 503;
NotifyListenerContextQuit(a);
return;
}
{
var s = new HttpSession(this, e, VirtualTransportServerFactory, QueueUserWorkItem);
var SessionId = Convert.ToBase64String(Cryptography.CreateRandom(64));
SessionSets.DoAction
(
ss =>
{
ss.Sessions.Add(s);
if (ss.IpSessions.ContainsKey(e.Address))
{
ss.IpSessions[e.Address].Count += 1;
}
else
{
var isi = new IpSessionInfo();
isi.Count += 1;
ss.IpSessions.Add(e.Address, isi);
}
ss.SessionIdToSession.Add(SessionId, s);
ss.SessionToId.Add(s, SessionId);
}
);
s.Start();
if (!s.Push(a, SessionId))
{
NotifyListenerContextQuit(a);
return;
}
}
}
catch (Exception ex)
{
if (ServerContext.EnableLogSystem)
{
ServerContext.RaiseSessionLog(new SessionLogEntry {
Token = "", RemoteEndPoint = e ?? new IPEndPoint(IPAddress.Any, 0), Time = DateTime.UtcNow, Type = "Sys", Name = "Exception", Message = ExceptionInfo.GetExceptionInfo(ex)
});
}
try
{
a.Response.StatusCode = 500;
}
catch
{
}
NotifyListenerContextQuit(a);
}
};
AcceptConsumer = new AsyncConsumer <HttpListenerContext>(QueueUserWorkItem, a => { Accept(a); return(true); }, int.MaxValue);
ContextPurifyConsumer = new AsyncConsumer <HttpListenerContext>(QueueUserWorkItem, l => { PurifyContext(l); return(true); }, int.MaxValue);
PurifyConsumer = new AsyncConsumer <HttpSession>(PurifierQueueUserWorkItem, s => { Purify(s); return(true); }, int.MaxValue);
if (UnauthenticatedSessionIdleTimeoutValue.HasValue || SessionIdleTimeoutValue.HasValue)
{
var TimePeriod = TimeSpan.FromSeconds(Math.Max(TimeoutCheckPeriodValue, 1));
LastActiveTimeCheckTimer = new Timer(state =>
{
if (UnauthenticatedSessionIdleTimeoutValue.HasValue)
{
var CheckTime = DateTime.UtcNow.AddIntSeconds(-UnauthenticatedSessionIdleTimeoutValue.Value);
SessionSets.DoAction
(
ss =>
{
foreach (var s in ss.Sessions)
{
var IpAddress = s.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (!isi.Authenticated.Contains(s))
{
if (s.LastActiveTime < CheckTime)
{
PurifyConsumer.Push(s);
}
}
}
}
);
}
if (SessionIdleTimeoutValue.HasValue)
{
var CheckTime = DateTime.UtcNow.AddIntSeconds(-SessionIdleTimeoutValue.Value);
SessionSets.DoAction
(
ss =>
{
foreach (var s in ss.Sessions)
{
var IpAddress = s.RemoteEndPoint.Address;
var isi = ss.IpSessions[IpAddress];
if (isi.Authenticated.Contains(s))
{
if (s.LastActiveTime < CheckTime)
{
PurifyConsumer.Push(s);
}
}
}
}
);
}
}, null, TimePeriod, TimePeriod);
}
try
{
Listener.Start();
}
catch (HttpListenerException ex)
{
String Message;
if (ex.ErrorCode == 5)
{
var l = new List <String>();
l.Add("Under Windows, try run the following as administrator:");
var UserDomainName = Environment.UserDomainName;
var UserName = Environment.UserName;
foreach (var p in BindingsValue)
{
l.Add(@"netsh http add urlacl url={0} user={1}\{2}".Formats(p, UserDomainName, UserName));
}
l.Add("and delete it when you don't need it:");
foreach (var p in BindingsValue)
{
l.Add(@"netsh http delete urlacl url={0}".Formats(p));
}
Message = String.Join("\r\n", l.ToArray());
}
else
{
Message = ExceptionInfo.GetExceptionInfo(ex);
}
throw new AggregateException(Message, ex);
}
Action Listen = () =>
{
if (ListeningTaskToken.IsCancellationRequested)
{
return;
}
var l = Listener;
var lc = ListenConsumer;
l.BeginGetContext(ar =>
{
if (!l.IsListening)
{
return;
}
try
{
var a = l.EndGetContext(ar);
AcceptConsumer.Push(a);
}
catch (HttpListenerException)
{
}
catch (ObjectDisposedException)
{
}
lc.Push(0);
}, null);
};
ListenConsumer = new AsyncConsumer <int>(QueueUserWorkItem, i => { Listen(); return(true); }, 1);
Listen();
Success = true;
return(true);
}
);
}
finally
{
if (!Success)
{
Stop();
}
}
}
private void Check()
{
Action AfterAction = null;
c.DoAction(cc =>
{
if (cc.State == 0)
{
cc.State = 1;
AfterAction = () => AddToActionQueue(Check);
return;
}
if (cc.State == 1)
{
if (cc.IsWriteEnabled)
{
if (cc.Writes.Count > 0)
{
cc.State = 2;
var w = cc.Writes.Dequeue();
AfterAction = () => AddToActionQueue(() => Write(w));
return;
}
}
if (cc.IsReadEnabled)
{
if (cc.Reads.Count > 0)
{
cc.State = 3;
var r = cc.Reads.Dequeue();
AfterAction = () => AddToActionQueue(() => Execute(r));
return;
}
if (!cc.IsInRawRead)
{
cc.IsInRawRead = true;
AfterAction = () => OnStartRawRead(NotifyStartRawReadSuccess, NotifyStartRawReadFailure);
return;
}
}
else
{
if (!cc.IsReadShutDown)
{
cc.IsReadShutDown = true;
AfterAction = () =>
{
OnShutdownRead();
AddToActionQueue(Check);
};
return;
}
if (cc.IsWriteEnabled)
{
if (!cc.IsWriteShutDown)
{
cc.IsWriteEnabled = false;
cc.IsWriteShutDown = true;
AfterAction = () =>
{
OnShutdownWrite();
AddToActionQueue(Check);
};
return;
}
}
else
{
if (cc.IsReadShutDown && cc.IsWriteShutDown && !cc.IsInRawRead)
{
cc.State = 4;
AfterAction = OnExit;
return;
}
}
}
}
});
if (AfterAction != null)
{
AfterAction();
}
}