private void Form1_Load(object sender, EventArgs e)
{
_socket = new AsyncSocket();
_socket.CouldNotConnect += _socket_CouldNotConnect;
_socket.SocketConnected += _socket_SocketConnected;
_socket.SocketDataArrival += _socket_SocketDataArrival;
_socket.SocketDisconnected += _socket_SocketDisconnected;
_socket.SocketError += _socket_SocketError;
}
public void RemoveSocket(AsyncSocket socket)
{
AdjustLoad(-1);
var item = m_sockets[socket];
m_sockets.Remove(socket);
item.Cancelled = true;
}
// 소켓연결이 해제되었습니다.
public void NotifyReleaseSocket(ASSOCKDESC sockdesc, AsyncSocket socket)
{
Console.WriteLine(sockdesc.ManagedID + " Disconnected");
lock (this)
{
theSessions.Remove(sockdesc.ManagedID);
}
sockdesc.NetSender.ReleaseASSOCKDESC(sockdesc);
}
public PgmSession([NotNull] PgmSocket pgmSocket, [NotNull] Options options)
{
m_handle = pgmSocket.Handle;
m_options = options;
m_data = new byte[Config.PgmMaxTPDU];
m_joined = false;
m_state = State.Idle;
}
public override void OnSocketDisposed(AsyncSocket so)
{
var connector = so.Connector as ConnectorEx;
Agent.TryClearLeader(connector, so);
base.OnSocketDisposed(so);
connector.IsAutoReconnect = true;
connector.TryReconnect();
}
public void RemoteEndPoint()
{
CompletionPort completionPort = CompletionPort.Create();
var listenSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(listenSocket, null);
listenSocket.Bind(IPAddress.Any, 0);
int port = listenSocket.LocalEndPoint.Port;
listenSocket.Listen(1);
listenSocket.Accept();
var clientSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(clientSocket, null);
clientSocket.Bind(IPAddress.Any, 0);
clientSocket.Connect("localhost", port);
CompletionStatus completionStatus;
bool accepted = false;
bool connected = false;
while (!accepted || !connected)
{
completionPort.GetQueuedCompletionStatus(-1, out completionStatus);
if (completionStatus.AsyncSocket == clientSocket && !connected)
{
Assert.AreEqual(OperationType.Connect, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
connected = true;
}
else if (completionStatus.AsyncSocket == listenSocket && !accepted)
{
Assert.AreEqual(OperationType.Accept, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
accepted = true;
}
else
{
Assert.Fail();
}
}
var server = listenSocket.GetAcceptedSocket();
Assert.AreEqual(clientSocket.LocalEndPoint, server.RemoteEndPoint);
Assert.AreEqual(clientSocket.RemoteEndPoint, server.LocalEndPoint);
completionPort.Dispose();
listenSocket.Dispose();
server.Dispose();
clientSocket.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="GNTPWebSocketReader"/> class.
/// </summary>
/// <param name="socket">The <see cref="AsyncSocket"/></param>
/// <param name="passwordManager">The <see cref="PasswordManager"/> containing a list of allowed passwords</param>
/// <param name="passwordRequired">Indicates if a password is required</param>
/// <param name="allowNetworkNotifications">Indicates if network requests are allowed</param>
/// <param name="allowBrowserConnections">Indicates if browser requests are allowed</param>
/// <param name="allowSubscriptions">Indicates if SUBSCRIPTION requests are allowed</param>
/// <param name="requestInfo">The <see cref="RequestInfo"/> associated with this request</param>
public GNTPWebSocketReader(AsyncSocket socket, PasswordManager passwordManager, bool passwordRequired, bool allowNetworkNotifications, bool allowBrowserConnections, bool allowSubscriptions, RequestInfo requestInfo)
: base(socket, passwordManager, passwordRequired, allowNetworkNotifications, allowBrowserConnections, allowSubscriptions, requestInfo)
{
this.allowed = allowBrowserConnections;
parser = new GNTPParser2(passwordManager, passwordRequired, allowNetworkNotifications, allowBrowserConnections, allowSubscriptions, requestInfo);
parser.MessageParsed += new GNTPParser2.GNTPParserMessageParsedEventHandler(parser_MessageParsed);
parser.Error += new GNTPParser2.GNTPParserErrorEventHandler(parser_Error);
}
public void EventDisconnected(String addr, AsyncSocket ch)
{
if ((m_monitorEvents & SocketEvent.Disconnected) == 0)
{
return;
}
MonitorEvent(new MonitorEvent(SocketEvent.Disconnected, addr, ch));
}
public void EventListening(String addr, AsyncSocket ch)
{
if ((m_monitorEvents & SocketEvent.Listening) == 0)
{
return;
}
MonitorEvent(new MonitorEvent(SocketEvent.Listening, addr, ch));
}
/// <summary>
/// Initializes a new instance of the <see cref="GNTPSocketReader"/> class.
/// </summary>
/// <param name="socket">The <see cref="AsyncSocket"/></param>
/// <param name="passwordManager">The <see cref="PasswordManager"/> containing a list of allowed passwords</param>
/// <param name="passwordRequired">Indicates if a password is required</param>
/// <param name="allowNetworkNotifications">Indicates if network requests are allowed</param>
/// <param name="allowBrowserConnections">Indicates if browser requests are allowed</param>
/// <param name="allowSubscriptions">Indicates if SUBSCRIPTION requests are allowed</param>
/// <param name="requestInfo">The <see cref="RequestInfo"/> associated with this request</param>
public GNTPSocketReader(AsyncSocket socket, PasswordManager passwordManager, bool passwordRequired, bool allowNetworkNotifications, bool allowBrowserConnections, bool allowSubscriptions, RequestInfo requestInfo)
{
this.parser = new GNTPParser(passwordManager, passwordRequired, allowNetworkNotifications, allowBrowserConnections, allowSubscriptions, requestInfo);
parser.Error += new GNTPParser.GNTPParserErrorEventHandler(parser_Error);
parser.MessageParsed += new GNTPParser.GNTPParserMessageParsedEventHandler(parser_MessageParsed);
this.socket = socket;
this.socket.Tag = parser;
}
public void AddSocket(AsyncSocket socket, IProactorEvents proactorEvents)
{
var item = new Item(proactorEvents);
m_sockets.Add(socket, item);
m_completionPort.AssociateSocket(socket, item);
AdjustLoad(1);
}
public static void ReceiveData(AsyncSocket socket)
{
string ip_port = NetUtil.ToIportString(socket.RemoteEndPoint);
lock (m_lock)
{
m_ip_port_sockets[ip_port] = socket;
}
ReceiveData(ip_port);
}
public ClientThreadT(AsyncSocket clientSocket, SelItem clientItem, String name)
{
m_clientSocket = clientSocket;
m_clientItem = clientItem;
m_name = name;
m_thread = new Thread(thread_fun);
m_thread.IsBackground = true;
m_thread.Start();
}
/// <summary>
/// Handles the socket's DidWrite event.
/// Calls the callback.
/// </summary>
/// <param name="sender">The <see cref="AsyncSocket"/>.</param>
/// <param name="tag">The tag identifying the write request.</param>
void socket_DidWrite(AsyncSocket sender, long tag)
{
// remove this since we dont need it any more
sender.DidWrite -= new AsyncSocket.SocketDidWrite(socket_DidWrite);
if (tag == HANDSHAKE_RESPONSE_TAG)
{
this.callback.BeginInvoke(null, null);
}
}
public PgmSession(PgmSocket pgmSocket, Options options)
{
m_handle = pgmSocket.Handle;
m_pgmSocket = pgmSocket;
m_options = options;
data = new byte[Config.PgmMaxTPDU];
m_joined = false;
m_state = State.Idle;
}
private void asyncSocket_DidClose(AsyncSocket sender)
{
LogInfo("Disconnected from host");
asyncSocket = null;
CreateAndSetupAsyncSocket();
fetchButton.Enabled = true;
sslCheckBox.Enabled = true;
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected void Dispose(bool disposing)
{
if (disposing)
{
try
{
Stop();
if (this.listenSocket != null)
{
this.listenSocket.DidAccept -= new AsyncSocket.SocketDidAccept(listenSocket_DidAccept);
this.listenSocket = null;
}
if (this.socketCleanupTimer != null)
{
this.socketCleanupTimer.Elapsed -= new System.Timers.ElapsedEventHandler(socketCleanupTimer_Elapsed);
this.socketCleanupTimer.Close();
this.socketCleanupTimer.Dispose();
this.socketCleanupTimer = null;
}
if (this.bonjour != null)
{
this.bonjour.Stop();
this.bonjour.Dispose();
this.bonjour = null;
}
}
catch
{
// suppress
}
}
}
private void asyncSocket_DidClose(AsyncSocket sender)
{
#if IS_MULTITHREADED
lock (connectedSockets)
{
connectedSockets.Remove(sender);
}
#else
connectedSockets.Remove(sender);
#endif
}
/// <summary>
/// Checks to see if any open sockets have disconnected and cleans them up.
/// </summary>
/// <param name="sender">The sender</param>
/// <param name="e">Event args</param>
void socketCleanupTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
this.socketCleanupTimer.Stop();
int count = this.connectedSockets.Count;
if (count > 0)
{
Queue <AsyncSocket> queue = new Queue <AsyncSocket>(this.connectedSockets.Count);
lock (syncLock)
{
foreach (ConnectedSocket cs in this.connectedSockets)
{
queue.Enqueue(cs.Socket);
}
}
while (queue.Count > 0)
{
AsyncSocket socket = queue.Dequeue();
if (socket != null)
{
if (this.connectedSockets.Contains(socket))
{
bool safeToDisconnect = this.connectedSockets[socket].SafeToDisconnect;
if (safeToDisconnect && !socket.SmartConnected)
{
// socket is disconnected from the other end
socket.Close();
}
}
}
}
}
if (this.isStarted)
{
this.socketCleanupTimer.Start();
}
}
public override void OnSocketConnectError(AsyncSocket so, Exception e)
{
base.OnSocketConnectError(so, e);
var agent = so.UserState as GlobalAgent.Agent;
if (null == e)
{
e = new Exception("Normal Connect Error???"); // ConnectError 应该 e != null 吧，懒得确认了。
}
agent.Logined.TrySetException(e);
}
public override void OnHandshakeDone(AsyncSocket so)
{
base.OnHandshakeDone(so);
var agent = so.UserState as GlobalAgent.Agent;
if (agent.LoginedTimes.Get() > 1)
{
var relogin = new GlobalCacheManager.ReLogin();
relogin.Argument.AutoKeyLocalId = Zeze.Config.AutoKeyLocalId;
relogin.Argument.GlobalCacheManagerHashIndex = agent.GlobalCacheManagerHashIndex;
relogin.Send(so,
(_) =>
{
if (relogin.IsTimeout)
{
agent.Logined.TrySetException(new Exception("GloalAgent.ReLogin Timeout"));;
}
else if (relogin.ResultCode != 0)
{
agent.Logined.TrySetException(new Exception($"GlobalAgent.ReLogoin Error {relogin.ResultCode}"));
}
else
{
agent.LoginedTimes.IncrementAndGet();
agent.Logined.SetResult(so);
}
return(0);
});
}
else
{
var login = new GlobalCacheManager.Login();
login.Argument.AutoKeyLocalId = Zeze.Config.AutoKeyLocalId;
login.Argument.GlobalCacheManagerHashIndex = agent.GlobalCacheManagerHashIndex;
login.Send(so,
(_) =>
{
if (login.IsTimeout)
{
agent.Logined.TrySetException(new Exception("GloalAgent.Login Timeout"));;
}
else if (login.ResultCode != 0)
{
agent.Logined.TrySetException(new Exception($"GlobalAgent.Logoin Error {login.ResultCode}"));
}
else
{
agent.LoginedTimes.IncrementAndGet();
agent.Logined.SetResult(so);
}
return(0);
});
}
}
static ProtocolState()
{
Settings = new XmppSettings();
Events = new XmppEvents();
Socket = new AsyncSocket();
State = new DisconnectedState();
Events.OnNewTag += EventsOnOnNewTag;
Events.OnConnect += EventsOnOnConnect;
Events.OnDisconnect += EventsOnOnDisconnect;
}
// 소켓연결이 해제되었습니다.
public void OnReleaseSocket(AsyncSocketContext sockdesc, AsyncSocket socket)
{
Console.WriteLine(sockdesc.ManagedID + " Disconnected");
lock (this)
{
theSessions.Remove(sockdesc.ManagedID);
}
sockdesc.NetSender.ReleaseAsyncSocketContext(sockdesc);
}
public override void OnSocketClose(AsyncSocket so, Exception e)
{
base.OnSocketClose(so, e);
var agent = so.UserState as GlobalAgent.Agent;
if (null == e)
{
e = new Exception("Peer Normal Close.");
}
agent.OnSocketClose(this, e);
}
void ISocketEventListener.OnConnect(BaseSocket sock)
{
#if !NO_SSL
if ((bool)m_listener[Options.SSL])
{
AsyncSocket s = sock as AsyncSocket;
m_listener[Options.REMOTE_CERTIFICATE] = s.RemoteCertificate;
}
#endif
m_listener.Connected();
}
/// <summary>
/// Listens for an inbound connection.
/// </summary>
public override void Accept()
{
AsyncSocket s = new AsyncSocket(null, this, (bool)m_listener[Options.SSL], false);
s.LocalCertificate = m_listener[Options.LOCAL_CERTIFICATE] as
System.Security.Cryptography.X509Certificates.X509Certificate2;
m_sock = s;
m_sock.Accept(new Address((int)m_listener[Options.PORT]));
m_sock.RequestAccept();
}
public void EnhancedSocket_Async_SendRecv()
{
AsyncSocket sockListen = null;
AsyncSocket sock1 = null;
AsyncSocket sock2 = null;
int cb;
try
{
sockListen = new AsyncSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sockListen.ListenOn(new IPEndPoint(IPAddress.Any, 45001));
sock1 = new AsyncSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock1.Connect(new IPEndPoint(IPAddress.Loopback, 45001));
sock2 = sockListen.Accept();
for (int i = 0; i < 1000; i++)
{
byte[] buf10 = new byte[10];
byte[] buf5 = new byte[5];
sock1.Send(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
cb = sock2.Receive(buf10);
Assert.AreEqual(10, cb);
CollectionAssert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, buf10);
sock2.Send(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
cb = sock1.Receive(buf5);
Assert.AreEqual(5, cb);
CollectionAssert.AreEqual(new byte[] { 0, 1, 2, 3, 4 }, buf5);
cb = sock1.Receive(buf5);
Assert.AreEqual(5, cb);
CollectionAssert.AreEqual(new byte[] { 5, 6, 7, 8, 9 }, buf5);
}
}
finally
{
if (sockListen != null)
{
sockListen.Close();
}
if (sock1 != null)
{
sock1.Close();
}
if (sock2 != null)
{
sock2.Close();
}
}
}
private void asyncSocket_DidReadPartial(AsyncSocket sender, int partialLength, long tag)
{
if (tag == HTTP_BODY)
{
totalBytesReceived += partialLength;
float percentComplete = (float)totalBytesReceived / (float)fileSizeInBytes;
progressBar.Value = (int)(percentComplete * 100);
}
}
private void Server()
{
SocketWatcher s_w = new SocketWatcher(20);
//s_w.RequireClientCert = true;
X509Certificate2 c2;
X509Store store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadWrite);
X509Certificate2Collection cert = store.Certificates.Find(X509FindType.FindBySubjectName, "localhost", true);
if (cert.Count == 0)
{
c2 = new X509Certificate2("../../localhost-cert.p12", "test");
store.Add(c2);
}
else
{
c2 = cert[0];
}
Assert.IsTrue(c2.HasPrivateKey);
Assert.IsNotNull(c2.PrivateKey);
Assert.AreEqual(typeof(X509Certificate2), c2.GetType());
cert = store.Certificates.Find(X509FindType.FindByThumbprint, c2.GetCertHashString(), false);
c2 = cert[0];
Assert.AreEqual(typeof(X509Certificate2), c2.GetType());
Assert.IsTrue(c2.HasPrivateKey);
Assert.IsNotNull(c2.PrivateKey);
store.Close();
s_w.LocalCertificate = c2;
s_w.Synchronous = true;
m_listen = s_w.CreateListenSocket(this, a, true);
lock (start)
{
Monitor.Pulse(start);
}
try
{
m_listen.RequestAccept();
}
catch (Exception ex)
{
lock (done)
{
succeeded = false;
errorMessage = ex.Message;
Monitor.Pulse(done);
}
}
}
public void Disconnect()
{
Connected = false;
Authenticated = false;
if (socket != null)
{
socket.Close();
socket = null;
}
}
public async Task<bool> Connect(string host)
{
IPHostEntry hostEntry = null;
hostEntry = Dns.GetHostEntry(host);
foreach (IPAddress address in hostEntry.AddressList)
{
IPEndPoint ipe = new IPEndPoint(address, 6667);
AsyncSocket temp = new AsyncSocket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Unspecified);
await temp.ConnectTaskAsync(ipe);
if (temp.Connected)
{
s = temp;
break;
}
}
return s.Connected;
}
public override void AssociateSocket(AsyncSocket socket, object state)
{
if (!(socket is Windows.Socket))
{
throw new ArgumentException("socket must be of type Windows.Socket", "socket");
}
Socket windowsSocket = socket as Socket;
if (windowsSocket.CompletionPort != this)
{
IntPtr result = UnsafeMethods.CreateIoCompletionPort(windowsSocket.Handle, m_completionPortHandle,
SocketCompletionKey, 0);
if (result == InvalidCompletionPort || result == InvalidCompletionPortMinusOne)
{
throw new Win32Exception();
}
}
windowsSocket.SetCompletionPort(this, state);
}
public void EngageWith(AsyncSocket.ISocket socket)
{
_pipeline.EngageWith(socket);
}
private void _listenSocket_ConnectionAccept(AsyncSocket tempSocket)
{
try {
_clientSocket.PassSocket(lStatus.GetObject(lStatus.ActiveIndex).sWindow) = tempSocket;
} catch (Exception ex) {
throw ex;
}
}
public override void Accept(AsyncSocket socket)
{
if (m_acceptSocketBufferAddress == IntPtr.Zero)
{
m_acceptSocketBufferSize = (m_boundAddress.Size + 16) * 2;
m_acceptSocketBufferAddress = Marshal.AllocHGlobal(m_acceptSocketBufferSize);
}
int bytesReceived;
m_acceptSocket = socket as Windows.Socket;
m_inOverlapped.StartOperation(OperationType.Accept);
if (!m_acceptEx(Handle, m_acceptSocket.Handle, m_acceptSocketBufferAddress, 0,
m_acceptSocketBufferSize / 2,
m_acceptSocketBufferSize / 2, out bytesReceived, m_inOverlapped.Address))
{
var socketError = (SocketError)Marshal.GetLastWin32Error();
if (socketError != SocketError.IOPending)
{
throw new SocketException((int)socketError);
}
}
else
{
CompletionPort.PostCompletionStatus(m_inOverlapped.Address);
}
}
public override void Accept(AsyncSocket socket)
{
NativeSocket nativeSocket = (NativeSocket)socket;
m_inSocketAsyncEventArgs.AcceptSocket = nativeSocket.m_socket;
if (!m_socket.AcceptAsync(m_inSocketAsyncEventArgs))
{
CompletionStatus completionStatus = new CompletionStatus(this, m_state, OperationType.Accept, SocketError.Success, 0);
m_completionPort.Queue(ref completionStatus);
}
}
public void NewSocket(int id, Form form)
{
try {
socket = new AsyncSocket();
statusId = id;
_invoke = new Form();
_invoke = form;
} catch (Exception ex) {
throw ex;
}
}
