| public SetBuffer ( byte buffer, int offset, int count ) : void | ||
| buffer | byte | |
| offset | int | |
| count | int | |
| return | void | |
public void SetBuffer(SocketAsyncEventArgs args)
{
if (_availableBuffers.Count > 0)
{
int index = _availableBuffers.Pop();
byte[] buffer;
lock (_bufferLocker)
{
buffer = _buffers[index];
}
args.SetBuffer(buffer, 0, buffer.Length);
}
else
{
byte[] buffer = new byte[_bufferSize];
lock (_bufferLocker)
{
_buffers.Add(buffer);
}
args.SetBuffer(buffer, 0, buffer.Length);
}
}
/// <summary>
/// Sets the buffer for a <see cref="SocketAsyncEventArgs"/> object.
/// </summary>
/// <param name="eventArgs">The SAEA whose buffer will be set</param>
/// <returns>True if the bucket was set.</returns>
public virtual bool SetBuffer(SocketAsyncEventArgs eventArgs)
{
lock (_freeIndexPool)
{
EnsureBufferAllocated();
var isBufferSet = true;
if (_freeIndexPool.Count > 0)
{
eventArgs.SetBuffer(_buffer, _freeIndexPool.Pop(), _bufferSize);
}
else
{
if ((_numberOfBytes - _bufferSize) < _currentIndex)
{
isBufferSet = false;
}
else
{
eventArgs.SetBuffer(_buffer, _currentIndex, _bufferSize);
_currentIndex += _bufferSize;
}
}
return isBufferSet;
}
}
public void SetBuffer_ByteArray ()
{
SocketAsyncEventArgs saea = new SocketAsyncEventArgs ();
byte [] buffer = new byte [0];
saea.SetBuffer (buffer, 0, 0);
Assert.AreEqual (0, saea.Buffer.Length, "0");
Assert.AreSame (saea.Buffer, buffer, "same");
saea.SetBuffer (null, 0, 0);
Assert.IsNull (saea.Buffer, "null");
}
///<summary>Partitions a section of the pool for the provided SocketAsyncEventArgs object.</summary>
/// <returns>True if the buffer was successfully partitioned and allocated. False otherwise.</returns>
public bool PartitionBuffer(SocketAsyncEventArgs args)
{
if (free_index_pool.Count > 0) {
args.SetBuffer(buffer, free_index_pool.Pop(), chunk_size);
} else {
if ((total_managed_size - chunk_size) < current_index)
return false;
args.SetBuffer(buffer, current_index, chunk_size);
current_index += chunk_size;
}
return true;
}
public void SetBuffer(SocketAsyncEventArgs args)
{
if (m_FreeIndex.Count > 0)
{
args.SetBuffer(m_BufferBlock, m_FreeIndex.Pop(), m_BufferSize);
}
else
{
args.SetBuffer(m_BufferBlock, m_CurrentIndex, m_BufferSize);
m_CurrentIndex += m_BufferSize;
}
}
partial void SendTimeRequest()
{
try
{
byte[] buffer = new byte[48];
buffer[0] = 0x1B;
DnsEndPoint _endPoint = new DnsEndPoint(_ServerAddress, 123, AddressFamily.InterNetwork);
Socket socket = null;
var socketArgs = new SocketAsyncEventArgs() { RemoteEndPoint = _endPoint };
try
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
try
{
socketArgs.Completed += Socket_Completed_SendAgain;
//TFW - For some reason 'ConnectAsync' reports an error
//desktop .Net 4, but 'Connect' works fine. On WP
//only ConnectAsync is available, and it appears to work.
#if USE_CONNECTASYNC
socketArgs.SetBuffer(buffer, 0, buffer.Length);
if (!socket.ConnectAsync(socketArgs))
Socket_Completed_SendAgain(socket, socketArgs);
#else
socket.Connect(socketArgs.RemoteEndPoint);
socketArgs.SetBuffer(buffer, 0, buffer.Length);
if (!socket.SendAsync(socketArgs))
Socket_Completed_SendAgain(socket, socketArgs);
#endif
}
catch
{
socketArgs.Completed -= this.Socket_Completed_SendAgain;
throw;
}
}
catch
{
socket?.Dispose();
throw;
}
}
catch (SocketException se)
{
OnErrorOccurred(new NtpNetworkException(se.Message, (int)se.SocketErrorCode, se));
}
catch (Exception ex)
{
OnErrorOccurred(new NtpNetworkException(ex.Message, -1, ex));
}
}
static void Accept_Completed(object sender, SocketAsyncEventArgs e)
{
Socket client = e.AcceptSocket;
Socket server = sender as Socket;
if (sender == null) return;
SocketAsyncEventArgs sendArg = new SocketAsyncEventArgs();
SocketAsyncEventArgs receciveArg = new SocketAsyncEventArgs();
ConnectInfo info = new ConnectInfo();
info.tmpList = new ArrayList();
info.SendArg = sendArg;
info.ReceiveArg = receciveArg;
info.ServerSocket=server;
byte[] sendbuffers=Encoding.ASCII.GetBytes("welcome\n");
sendArg.SetBuffer(sendbuffers, 0, sendbuffers.Length);
sendbuffers=new byte[1024];
receciveArg.SetBuffer(sendbuffers, 0, 1024);
receciveArg.UserToken = info;
receciveArg.Completed += new EventHandler<SocketAsyncEventArgs>(Rececive_Completed);
client.SendAsync(sendArg);
client.ReceiveAsync(receciveArg);
e.Dispose();
}
public void Send(byte[] buffer)
{
SocketAsyncEventArgs conn = new SocketAsyncEventArgs();
conn.SetBuffer(buffer, 0, buffer.Length);
_socket.SendAsync(conn);
}
private void BeginReceive()
{
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[5], 0, 5);
args.Completed += new EventHandler<SocketAsyncEventArgs>(HeaderReceived);
if (!App.ConnectedSocket.ReceiveAsync(args)) HeaderReceived(null, args);
}
/// <summary>
/// 添加异步回调参数
/// </summary>
/// <param name="value">异步回调参数</param>
internal static void Push(ref SocketAsyncEventArgs value)
{
value.SetBuffer(null, 0, 0);
value.UserToken = null;
value.SocketError = SocketError.Success;
TmphTypePool<SocketAsyncEventArgs>.Push(value);
}
public async Task Write(byte[] data)
{
var socketAsyncEventArgs = new SocketAsyncEventArgs();
socketAsyncEventArgs.SetBuffer(data, 0, data.Length);
await this.socket.SendTaskAsync(socketAsyncEventArgs);
}
internal SocketAsyncEventArgs Take(int size)
{
if (size > chunkSize)
throw new ArgumentOutOfRangeException(String.Format("Required buffer {0} size is larger than the chunk size {1}", size, chunkSize));
BufferFactory bufferFactory;
ArraySegment<byte> segment;
bool success;
// allocate new pools until we can acquire a buffer with the required size
// The way SAEAs and buffers are used we're fine with continously allocating
// new BufferFactories when we run out of space (and not being able to reuse them)
while (!factories.TryPeek(out bufferFactory) || !bufferFactory.TryAlloc(size, out segment))
{
lock (UpdateLock)
{
if (!factories.TryPeek(out bufferFactory) || !bufferFactory.TryAlloc(size, out segment))
{
// create & store a new factory, allocation will be handled by the while loop
factories.Push(new BufferFactory(chunkSize));
}
}
}
var retval = new SocketAsyncEventArgs();
retval.SetBuffer(segment.Array, segment.Offset, segment.Count);
success = knownEventArgs.TryAdd(retval, Tuple.Create(bufferFactory, segment));
Debug.Assert(success);
return retval;
}
/// <summary>
/// Starts to listen
/// </summary>
/// <param name="config">The server config.</param>
/// <returns></returns>
public override bool Start(IServerConfig config)
{
try
{
m_ListenSocket = new Socket(this.EndPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
m_ListenSocket.Bind(this.EndPoint);
uint IOC_IN = 0x80000000;
uint IOC_VENDOR = 0x18000000;
uint SIO_UDP_CONNRESET = IOC_IN | IOC_VENDOR | 12;
byte[] optionInValue = { Convert.ToByte(false) };
byte[] optionOutValue = new byte[4];
m_ListenSocket.IOControl((int)SIO_UDP_CONNRESET, optionInValue, optionOutValue);
var eventArgs = new SocketAsyncEventArgs();
eventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(eventArgs_Completed);
eventArgs.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
int receiveBufferSize = config.ReceiveBufferSize <= 0 ? 2048 : config.ReceiveBufferSize;
var buffer = new byte[receiveBufferSize];
eventArgs.SetBuffer(buffer, 0, buffer.Length);
m_ListenSocket.ReceiveFromAsync(eventArgs);
return true;
}
catch (Exception e)
{
OnError(e);
return false;
}
}
private void Client_SizeReceived(object sender, SocketAsyncEventArgs e)
{
e.Completed -= Client_SizeReceived;
EnsureSocketSuccess(e, () =>
{
SocketAsyncEventArgsUserToken userToken = (SocketAsyncEventArgsUserToken)e.UserToken;
int sizeToReceive = BitConverter.ToInt32(e.Buffer.Take(4).ToArray(), 0);
uint?messageID = (e.Buffer.Length == 8) ? (uint?)BitConverter.ToUInt32(e.Buffer.Skip(4).Take(4).ToArray(), 0) : null;
const int sizeLimitForLogging = 10 * 1024 * 1024; // 10 MB
if (sizeToReceive >= sizeLimitForLogging)
{
CoreLogger.UniqueInstance.Warn(string.Format("SizeToReceive is larger than 10 MB. Size is {0} bytes", sizeToReceive));
OnSocketError(System.Net.Sockets.SocketError.SocketError);
return;
}
userToken.MessageID = messageID;
userToken.SizeToReceive = sizeToReceive;
userToken.CurrentRawMessageLength = 0;
userToken.CurrentRawMessage = string.Empty;
byte[] messageBuffer = new byte[userToken.SizeToReceive];
e.SetBuffer(messageBuffer, 0, messageBuffer.Length);
e.Completed += Client_MessageReceived;
userToken.Socket.InvokeAsyncMethod(userToken.Socket.ReceiveAsync, Client_MessageReceived, e);
});
}
public IObservable<Unit> SendMessage(Socket connectedSocket, SocketAsyncEventArgs socketEventArgs, IScheduler scheduler, string message)
{
if (connectedSocket == null)
throw new ArgumentNullException("connectedSocket");
if (socketEventArgs == null)
throw new ArgumentNullException("socketEventArgs");
return Observable.Create<Unit>(observer =>
{
var disposable = new CompositeDisposable();
var buffer = Encoding.UTF8.GetBytes(message);
var disposableCompletedSubscription = socketEventArgs.CompletedObservable().ObserveOn(scheduler).Subscribe(_ =>
{
SendNotificationToObserver(observer, socketEventArgs);
});
var disposableActions = scheduler.Schedule(() =>
{
socketEventArgs.SetBuffer(buffer, 0, buffer.Length);
if (!connectedSocket.SendAsync(socketEventArgs))
{
SendNotificationToObserver(observer, socketEventArgs);
}
});
disposable.Add(disposableCompletedSubscription);
disposable.Add(disposableActions);
return disposable;
});
}
private void ProcessRequest(ClientObject co)
{
Client.Request Req = new Client.Request()
{
Header = co.Header,
Body = co.Buffer.Count > 0?co.Buffer.ToArray():null,
Client = co.EventArgs.AcceptSocket
};
Response Res = HandleRequest(Req);
Res.Header.ContentLength = Res.Body != null ? Res.Body.Length : 0;
Res.Header["Connection"] = KeepAlive ? "KeepAlive" : "Close";
List <byte> buf = new List <byte>();
buf.AddRange(Encoding.UTF8.GetBytes(Res.Header.ToHttpHeader()));
buf.AddRange(Base.NewLineBytes);
if (Res.Body != null && Res.Body.Length > 0)
{
buf.AddRange(Res.Body);
}
byte[] bts = buf.ToArray();
System.Net.Sockets.SocketAsyncEventArgs saea = new System.Net.Sockets.SocketAsyncEventArgs();
saea.Completed += SocketAsyncEventArgs_SendCompleted;
saea.SetBuffer(bts, 0, bts.Length);
saea.AcceptSocket = co.EventArgs.AcceptSocket;
saea.UserToken = co.EventArgs.UserToken;
co.EventArgs.AcceptSocket.SendAsync(saea);
Debug.WriteLine(Req.Header.Method + " " + Req.Header.Path + " " + Res.Header.Code + " " + Res.Header.Status);
}
public System.Threading.Tasks.Task<ReceivedUdpData> ReceiveAsync()
{
ThrowIfDisposed();
var tcs = new TaskCompletionSource<ReceivedUdpData>();
var socketEventArg = new SocketAsyncEventArgs();
try
{
socketEventArg.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
socketEventArg.UserToken = tcs;
socketEventArg.SetBuffer(new Byte[SsdpConstants.DefaultUdpSocketBufferSize], 0, SsdpConstants.DefaultUdpSocketBufferSize);
socketEventArg.Completed += socketEventArg_ReceiveCompleted;
_Socket.ReceiveAsync(socketEventArg);
}
catch
{
socketEventArg.Dispose();
throw;
}
return tcs.Task;
}
protected override bool ListenAsync(SocketAsyncEventArgs saea)
{
var bufferSize = ("Hi Peer2Net node here:" + Guid.Empty + ":127.0.0.1:0000").Length;
saea.SetBuffer(new byte[bufferSize], 0, bufferSize);
saea.RemoteEndPoint = new IPEndPoint(IPAddress.Any, Port);
return Listener.ReceiveFromAsync(saea);
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpChannel" /> class.
/// </summary>
/// <param name="readBuffer">Buffer used for our reading.</param>
/// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param>
/// <param name="decoder">
/// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be
/// overridden by this class.
/// </param>
public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) {
if (readBuffer == null) throw new ArgumentNullException("readBuffer");
if (encoder == null) throw new ArgumentNullException("encoder");
if (decoder == null) throw new ArgumentNullException("decoder");
_readArgs = new SocketAsyncEventArgs();
_readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity);
_readArgs.Completed += OnReadCompleted;
_readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs);
_encoder = encoder;
_decoder = decoder;
_decoder.MessageReceived = OnMessageReceived;
_writeArgs = new SocketAsyncEventArgs();
_writeArgs.Completed += OnSendCompleted;
_writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs);
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
RemoteEndpoint = EmptyEndpoint.Instance;
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
public bool Send(object message)
{
lock (this)
{
if (Connect())
{
try
{
IMessage msg = mPackage.SendCast(message);
byte[] data = mPackage.GetMessageData(msg);
mSendSAEA.SetBuffer(data, 0, data.Length);
if (!mSocket.SendAsync(mSendSAEA))
{
SendCompleted(this, mSendSAEA);
}
return(true);
}
catch (SocketException se)
{
ReleaseSocket();
OnError(se);
}
catch (ObjectDisposedException ode)
{
ReleaseSocket();
OnError(ode);
}
catch (Exception e_)
{
OnError(e_);
}
}
return(false);
}
}
public void SendPacket(byte[] buffer, int offset, int size, Action<StreamBuffer> onSent = null)
{
try
{
lock (_session)
{
if (_session.Socket == null)
return;
SocketAsyncEventArgs saea = new SocketAsyncEventArgs();
saea.Completed += SendComplete;
saea.SetBuffer(buffer, offset, size);
if (onSent != null)
saea.UserToken = new NetworkSendToken(new StreamBuffer(buffer, offset, size), onSent);
if (_session.Socket.SendAsync(saea) == false)
ReceiveComplete(null, saea);
}
}
catch (SocketException)
{
}
catch (Exception e)
{
Logger.Err(LogMask.Aegis, e.ToString());
}
}
public OSClient(IEFMagLinkRepository repository)
{
// First we set up our mutex and semaphore
mutex = new Mutex();
connected = false;
_repository = repository;
item = new SocketAsyncEventArgs();
_timerClient.Elapsed += new System.Timers.ElapsedEventHandler(_timerClient_Elapsed);
_timerClient.Interval = 10000;
_timerClient.Start();
_timerClientConnecTimer.Elapsed += new System.Timers.ElapsedEventHandler(_timerClientConnecTimer_Elapsed);
_timerClientConnecTimer.Interval = 15000;
_timerClientConnecTimer.Start();
numconnections = 0;
item.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);
item.SetBuffer(new Byte[Convert.ToInt32(Settings._instance.BufferSize)], 0, Convert.ToInt32(Settings._instance.BufferSize));
socketpool = new OSAsyncEventStack(Convert.ToInt32(Settings._instance.NumConnect));
for (Int32 i = 0; i < Convert.ToInt32(Settings._instance.NumConnect); i++)
{
SocketAsyncEventArgs item1 = new SocketAsyncEventArgs();
item1.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);
item1.SetBuffer(new Byte[Convert.ToInt32(Settings._instance.BufferSize)], 0, Convert.ToInt32(Settings._instance.BufferSize));
socketpool.Push(item1);
}
}
private async Task StartReceiving(StateObject state)
{
if (_isDisposed) return;
if (!_socket.Connected) return;
_logger.Info("Receiving message...");
var args = new SocketAsyncEventArgs();
args.SetBuffer(new byte[0x1000], 0, 0x1000);
var awaitable = new SocketAwaitable(args);
while (true)
{
await _socket.ReceiveAsync(awaitable);
var bytesRead = args.BytesTransferred;
if (bytesRead <= 0) break;
_logger.Info(string.Format("Bytes read: {0}", bytesRead));
if (awaitable.EventArgs.Buffer[0] == _framingProtocol.StartFrame || state.StartedReceiving)
{
state.Append(Encoding.ASCII.GetString(awaitable.EventArgs.Buffer, 0, bytesRead));
}
if (awaitable.EventArgs.Buffer[bytesRead - 1] == _framingProtocol.EndFrame) // We're done
{
InvokeMessageReceived(state.ToString());
}
}
}
/// <summary>
/// Format data for sending to client and assign an event handler for the Completed event
/// </summary>
/// <param name="ResponseCode"></param>
/// <param name="Data"></param>
internal void SendData(ServerResponseCode ResponseCode, string Data)
{
// Get a new SocketAsyncEventArgs object:
SocketAsyncEventArgs e = new SocketAsyncEventArgs();
// Create response and buffer it:
byte[] buffer = ServerResponse(ResponseCode, Data);
e.SetBuffer(buffer, 0, buffer.Length);
// Send a reference to this object for use in next callback:
e.UserToken = this;
// Store our last response:
LastServerResponse = ResponseCode;
// Assign delegate to handle the Completed event
switch (ResponseCode)
{
case ServerResponseCode.None:
throw new ArgumentException();
case ServerResponseCode.DISCON:
case ServerResponseCode.SERVICE_NOT_AVAILABLE:
e.Completed += this.rejectConnectionDelegate;
break;
default:
e.Completed += this.DataSentDelegate;
break;
}
// Blast that data down the wire yo:
m_WorkerSocket.SendAsync(e);
}
private void Socket_Completed_SendAgain(object sender, SocketAsyncEventArgs e)
{
Socket socket = null;
try
{
e.Completed -= this.Socket_Completed_SendAgain;
socket = ((System.Net.Sockets.Socket)sender);
if (e.SocketError == SocketError.Success)
{
var socketArgs = new SocketAsyncEventArgs() { RemoteEndPoint = e.RemoteEndPoint };
try
{
socketArgs.Completed += new EventHandler<SocketAsyncEventArgs>(Socket_Completed_Receive);
socketArgs.SetBuffer(e.Buffer, 0, e.Buffer.Length);
if (!socket.SendAsync(socketArgs))
Socket_Completed_Receive(socket, socketArgs);
}
catch
{
socketArgs.Completed -= this.Socket_Completed_Receive;
throw;
}
}
else
throw NtpNetworkExceptionFromSocketArgs(e);
}
catch (Exception ex)
{
OnErrorOccurredAndDisposeSocket(ex, socket);
}
}
private void Accept_Completed(object sender, SocketAsyncEventArgs e)
{
Socket ClientSocket = e.AcceptSocket;
Console.WriteLine("Accepting connection");
byte[] bytesFrom = new byte[LENGTH.MAX_PACKET_LEN];
string dataFromClient = null;
ClientSocket.Receive(bytesFrom);
dataFromClient = System.Text.Encoding.UTF8.GetString(bytesFrom);
ChatProtocol chatProtocol = JsonConvert.DeserializeObject<ChatProtocol>(dataFromClient);
socketToClient.Add(ClientSocket, chatProtocol.sender_id);
clientToSocket.Add(chatProtocol.sender_id, ClientSocket);
Console.WriteLine(chatProtocol.sender_id + " Joined ");
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
szData = new byte[1024];
args.SetBuffer(szData, 0, 1024);
args.Completed
+= new EventHandler<SocketAsyncEventArgs>(Receive_Completed);
ClientSocket.ReceiveAsync(args);
e.AcceptSocket = null;
m_ServerSocket.AcceptAsync(e);
}
// Removes a SocketAsyncEventArgs instance from the pool.
// returns SocketAsyncEventArgs removed from the pool.
public SocketAsyncEventArgs Pop()
{
lock (this.pool)
{
SocketAsyncEventArgs args = null;
if (pool.Count > 0)
{
args = this.pool.Pop();
}
else
{
args = new SocketAsyncEventArgs();
byte[] buffer = new byte[1024];
args.SetBuffer(buffer, 0, buffer.Length);
SockState recState = new SockState(args, buffer.Length, null);
recState.IsCached = false;
recState.ID = Interlocked.Decrement(ref SockStateID);
args.UserToken = recState;
recState.BufferBlockOffset = 0;
recState.BufferBlockLength = 1024;
}
return args;
}
}
public void SendBytes(byte[] data)
{
SocketAsyncEventArgs enew = new SocketAsyncEventArgs();
enew.Completed += SockAsyncEventArgs_Completed;
enew.SetBuffer(data, 0, data.Length);
SendAsync(enew);
}
private void Receive_Completed(object sender, SocketAsyncEventArgs e)
{
Socket ClientSocket = (Socket)sender;
Console.WriteLine("Receiving data");
if (ClientSocket.Connected && e.BytesTransferred > 0)
{
byte[] bytesFrom = e.Buffer; // 데이터 수신
String dataFromLobby = System.Text.Encoding.UTF8.GetString(bytesFrom);
gameRoomInfo gameroominfo = JsonConvert.DeserializeObject<gameRoomInfo>(dataFromLobby);
if (gameroominfo != null)
{
GameRoom gameRoom = new GameRoom(gameroominfo);
Console.WriteLine("Game Created");
//string Test = sData.Replace("\0", "").Trim();
for (int i = 0; i < szData.Length; i++)
{
szData[i] = 0;
}
e.SetBuffer(szData, 0, 1024);
ClientSocket.ReceiveAsync(e);
}
}
else
{
Console.WriteLine("Lobby Server Disconnected");
ClientSocket.Disconnect(false);
ClientSocket.Dispose();
}
}
/// <summary>Sends data to remote host.</summary>
/// <param name="buffer">Data to send.</param>
/// <param name="offset">Offset.</param>
/// <param name="count">Amount of bytes to send.</param>
public void Send(byte[] buffer, int offset, int count)
{
var evnt = new SocketAsyncEventArgs();
evnt.Completed += OnSendComplete;
evnt.SetBuffer(buffer, offset, count);
_socket.SendAsync(evnt);
}
// Default constructor
public OSServer(IEFMagLinkRepository repository)
{
_repository = repository;
exceptionthrown = false;
// First we set up our mutex and semaphore
mutex = new Mutex();
numconnections = 0;
// Then we create our stack of read sockets
socketpool = new OSAsyncEventStack(Convert.ToInt32(Settings._instance.NumConnect));
// Now we create enough read sockets to service the maximum number of clients
// that we will allow on the server
// We also assign the event handler for IO Completed to each socket as we create it
// and set up its buffer to the right size.
// Then we push it onto our stack to wait for a client connection
for (Int32 i = 0; i < Convert.ToInt32(Settings._instance.NumConnect); i++)
{
SocketAsyncEventArgs item = new SocketAsyncEventArgs();
item.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);
item.SetBuffer(new Byte[Convert.ToInt32(Settings._instance.BufferSize)], 0, Convert.ToInt32(Settings._instance.BufferSize));
socketpool.Push(item);
}
}
public static IAwaitable SendAsync(this Socket socket, byte[] buffer)
{
var args = new SocketAsyncEventArgs();
args.SetBuffer(buffer);
var awaitable = new SocketAwaitable(args);
return socket.SendAsync(awaitable);
}
public HttpServer(int maxAccept, int maxConnections, int bufferSize)
{
timeoutTimer = new System.Timers.Timer(Timeout);
timeoutTimer.Elapsed += timeoutTimer_Elapsed;
this.maxAccept = maxAccept;
this.maxConnections = maxConnections;
this.bufferSize = bufferSize;
this.enforceMaxClients = new Semaphore (maxConnections, maxConnections);
this.bufferManager = BufferManager.CreateBufferManager (maxConnections, maxConnections * bufferSize * 2);
for (int i = 0; i < maxAccept; i++) {
var acceptArgs = new SocketAsyncEventArgs ();
acceptArgs.Completed += HandleAcceptCompleted;
this.acceptPool.Push (acceptArgs);
}
for (int i = 0; i < maxConnections; i++) {
var readWriteArgs = new SocketAsyncEventArgs ();
var client = new HttpClient ();
readWriteArgs.UserToken = client;
readWriteArgs.SetBuffer (this.bufferManager.TakeBuffer (bufferSize), 0, bufferSize);
readWriteArgs.Completed += HandleReadWriteCompleted;
this.readWritePool.Push (readWriteArgs);
}
timeoutTimer.Start();
}
internal static void Receive_Completed(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
BufferBlock block = e.UserToken as BufferBlock;
if (block == null)
{
return;
}
Network <T> network = block.UserToken as Network <T>;
e.UserToken = null;
if (network?.HandleReceived(e) == true)
{
if (!network.isDisconnected)
{
BufferBlock newBlock = BufferManager.Instance.RequestBufferBlock();
newBlock.UserToken = network;
e.UserToken = newBlock;
e.SetBuffer(newBlock.Buffer, newBlock.StartIndex, newBlock.MaxLength);
try
{
if (!network.sock.ReceiveAsync(e))
{
Receive_Completed(null, e);
}
}
catch (Exception ex)
{
Logger.Log.Error(ex);
newBlock.Free();
}
}
}
else
{
if (network != null)
{
if (network.autoLock)
{
ClientManager.EnterCriticalArea();
}
network.Disconnect();
if (network.autoLock)
{
ClientManager.LeaveCriticalArea();
}
}
else
{
Logger.Log.Warn("network == null");
}
}
block.Free();
}
private void Client_MessageReceived(object sender, SocketAsyncEventArgs e)
{
e.Completed -= Client_MessageReceived;
EnsureSocketSuccess(e, () =>
{
SocketAsyncEventArgsUserToken userToken = (SocketAsyncEventArgsUserToken)e.UserToken;
userToken.CurrentRawMessageLength += e.BytesTransferred;
userToken.CurrentRawMessage += Encoding.UTF8.GetString(e.Buffer, e.Offset, e.BytesTransferred);
if (userToken.MoreBytesNeedToBeRead)
{
byte[] messageBuffer = new byte[userToken.RemainingBytesToReceive];
e.SetBuffer(messageBuffer, 0, messageBuffer.Length);
e.Completed += Client_MessageReceived;
userToken.Socket.InvokeAsyncMethod(userToken.Socket.ReceiveAsync, Client_MessageReceived, e);
return;
}
if (userToken.MessageID.HasValue)
{
if ((userToken.MessageID & CALLBACK_IDENTIFIER) == 0)
{
// message is a callback
XElement messageElement = TryParseXElement(userToken.CurrentRawMessage);
if (messageElement != null && !Callbacks.CheckForKnownMethodCallback(messageElement))
{
CoreLogger.UniqueInstance.Error("Found unknown callback: " + userToken.CurrentRawMessage);
}
}
else
{
// message is a method reply
lock (_methodResponsesLockObject)
{
MethodResponses[userToken.MessageID.Value] = userToken.CurrentRawMessage;
}
}
}
else if (string.Compare(userToken.CurrentRawMessage, "GBXRemote 2", StringComparison.OrdinalIgnoreCase) != 0)
{
OnSocketError(System.Net.Sockets.SocketError.ProtocolNotSupported);
return;
}
else
{
ThreadPool.QueueUserWorkItem(x => OnReadyForSendingCommands());
}
ReadMessageWithPrefix(e, true);
});
}
private void ReadMessageWithPrefix(SocketAsyncEventArgs e, bool includeMessageID)
{
EnsureSocketSuccess(e, () =>
{
SocketAsyncEventArgsUserToken userToken = (SocketAsyncEventArgsUserToken)e.UserToken;
byte[] sizeBuffer = new byte[includeMessageID ? 8 : 4];
e.SetBuffer(sizeBuffer, 0, sizeBuffer.Length);
e.Completed += Client_SizeReceived;
userToken.Socket.InvokeAsyncMethod(userToken.Socket.ReceiveAsync, Client_SizeReceived, e);
});
}
void SocketAsyncEventArgs_AcceptCompleted(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
if (e != null)
{
if (e.AcceptSocket != null && e.AcceptSocket.RemoteEndPoint != null && e.LastOperation == SocketAsyncOperation.Accept)
{
Debug.WriteLine(e.AcceptSocket.RemoteEndPoint.ToString());
System.Net.Sockets.SocketAsyncEventArgs saea = new System.Net.Sockets.SocketAsyncEventArgs();
saea.Completed += SocketAsyncEventArgs_ReceiveCompleted;
saea.AcceptSocket = e.AcceptSocket;
saea.UserToken = e.AcceptSocket.RemoteEndPoint.ToString();
saea.SetBuffer(new byte[BufferSize], 0, BufferSize);
e.AcceptSocket.ReceiveAsync(saea);
}
else
{
Debug.WriteLine("Stop");
}
}
bool Crashed = false;
try
{
Crashed = ServerSocket == null || ServerSocket.LocalEndPoint == null;
}
catch { }
if (Crashed && _Status == ServerStatus.Running)
{
Clients.Clear();
ServerSocket = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.Tcp);
ServerSocket.Bind(new IPEndPoint(IPAddress.Parse(Address), Port));
ServerSocket.Listen(BackLog);
Debug.WriteLine(String.Format("Listen at {0}:{1}", Address, Port));
//
SocketAsyncEventArgs_AcceptCompleted(null, null);
}
else if (ServerSocket != null)
{
System.Net.Sockets.SocketAsyncEventArgs saea = new System.Net.Sockets.SocketAsyncEventArgs();
saea.Completed += SocketAsyncEventArgs_AcceptCompleted;
ServerSocket.AcceptAsync(saea);
}
}
private void SendCompleted(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
{
if (e.BytesTransferred < e.Count)
{
e.SetBuffer(e.Offset + e.BytesTransferred, e.Count - e.BytesTransferred);
if (!mSocket.SendAsync(e))
{
SendCompleted(this, e);
}
}
}
else
{
ReleaseSocket();
}
}
private void SendCompleted(object sender, System.Net.Sockets.SocketAsyncEventArgs e)
{
this.sendEventArgsPool.Push(e);
e.UserToken = null;
if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
{
if (e.BytesTransferred < e.Count)
{
e.SetBuffer(e.Offset + e.BytesTransferred, e.Count - e.BytesTransferred);
if (!this.clientSocket.SendAsync(e))
{
SendCompleted(this, e);
}
}
}
else
{
IsConnected = false;
this.RaiseEvent(this.Disconnected, new AsyncSocketTokenEventArgs(this.clientSocket));
}
}
// Called when the DNS query completes (either synchronously or asynchronously). Checks for failure and
// starts the first connection attempt if it succeeded. Returns true if the operation will be asynchronous,
// false if it has failed synchronously.
private bool DoDnsCallback(IAsyncResult result, bool sync)
{
Exception exception = null;
lock (_lockObject)
{
// If the connection attempt was canceled during the dns query, the user's callback has already been
// called asynchronously and we simply need to return.
if (_state == State.Canceled)
{
return(true);
}
if (_state != State.DnsQuery)
{
NetEventSource.Fail(this, "MultipleConnectAsync.DoDnsCallback(): Unexpected object state");
}
try
{
_addressList = Dns.EndGetHostAddresses(result);
if (_addressList == null)
{
NetEventSource.Fail(this, "MultipleConnectAsync.DoDnsCallback(): EndGetHostAddresses returned null!");
}
}
catch (Exception e)
{
_state = State.Completed;
exception = e;
}
// If the dns query succeeded, try to connect to the first address
if (exception == null)
{
_state = State.ConnectAttempt;
_internalArgs = new SocketAsyncEventArgs();
_internalArgs.Completed += InternalConnectCallback;
_internalArgs.SetBuffer(_userArgs.Buffer, _userArgs.Offset, _userArgs.Count);
exception = AttemptConnection();
if (exception != null)
{
// There was a synchronous error while connecting
_state = State.Completed;
}
}
}
// Call this outside of the lock because it might call the user's callback.
if (exception != null)
{
return(Fail(sync, exception));
}
else
{
return(true);
}
}
