void Server::_registerIncomingSocket( SOCKET socket )
{
BOOL success = BindIoCompletionCallback((HANDLE)socket, &_onIOComplete, 0);
if (!success) {
printError("BindIoCompletionCallback");
}
}
/**
*@创建socket客户端（连接池元素）
*/
BOOL iocp_create_client( SOCKET m_sockListen , int timeout ){
SOCKET client = WSASocket(AF_INET,SOCK_STREAM,IPPROTO_TCP,0,0,WSA_FLAG_OVERLAPPED);
if( INVALID_SOCKET == client )
{
return 0;
}
if( !BindIoCompletionCallback( (HANDLE)client ,icop_worker_thread,0) )
{
closesocket(client);
return 0;
}
iocp_overlapped *povl = new iocp_overlapped();
if( NULL == povl )
{
closesocket(client);
return 0;
}
DWORD dwBytes = 0;
ZeroMemory(povl,sizeof(iocp_overlapped));
povl->m_ol.Offset = 0;
povl->m_ol.OffsetHigh = 0;
povl->m_iOpType = OP_ACCEPT;
povl->m_skServer = m_sockListen;
povl->m_skClient = client;
povl->m_timeout = timeout;
povl->m_isUsed = 0;
povl->m_active = 0;
povl->m_isCrashed = 0;
povl->m_online = 0;
povl->m_usenum = 1;
int server_size = sizeof(povl->m_addrServer);
ZeroMemory( &povl->m_addrServer,server_size );
getpeername( povl->m_skServer, (SOCKADDR *)&povl->m_addrServer, &server_size );
int error_code = WingAcceptEx( m_sockListen,povl->m_skClient,povl->m_pBuf,0,sizeof(SOCKADDR_IN)+16,sizeof(SOCKADDR_IN)+16,NULL, (LPOVERLAPPED)povl );
int last_error = WSAGetLastError() ;
if( !error_code && ERROR_IO_PENDING != last_error && WSAECONNRESET != last_error)
{
closesocket( client );
client = povl->m_skClient = INVALID_SOCKET;
delete povl;
povl = NULL;
return 0;
}
iocp_add_to_map( (unsigned long)client , (unsigned long)povl );
return 1;
}
bool NetChannel::StartChannel()
{
if(!NetChannelBase::StartChannel())
return false;
assert( m_hExitSending.IsValid() && m_hExitReceiving.IsValid() );
m_socket.SetNonBlocking(false);
if(!BindIoCompletionCallback( (HANDLE)m_socket.GetSocket(), AsynIoCompleteProc, 0))
return false;
m_pRecvBuffer = new BYTE[m_sockRcBuffSize];
if( !m_pRecvBuffer)
return false;
{
MYOVERLAPPED& olp = m_OLPSend;
memset( &olp, 0, sizeof(MYOVERLAPPED));
olp.pChannel = this;
olp.bSend = true;
}
{
MYOVERLAPPED& olp = m_OLPRecv;
memset( &olp, 0, sizeof(MYOVERLAPPED));
olp.pChannel = this;
olp.bSend = false;
}
if(!StartNewRecv( sizeof( BlockHeadT)))
return false;
return true;
}
XStreamNode* XSocketMgr::CreateStream(
SOCKET nSocket, const char cszRemoteIP[], int nRemotePort, time_t nTimeNow, size_t uMaxPackLen
)
{
XStreamNode* pResult = NULL;
int nRetCode = 0;
int nSocketOpt = 0;
XStreamNode* pNode = NULL;
BYTE* pbyBuffer = NULL;
XY_FAILED_JUMP(m_pStreamNodeFree);
pNode = m_pStreamNodeFree;
m_pStreamNodeFree = m_pStreamNodeFree->pNext;
pbyBuffer = new BYTE[uMaxPackLen];
XY_FAILED_JUMP(pbyBuffer);
nRetCode = BindIoCompletionCallback((HANDLE)nSocket, IOCompletionCallBack, 0);
XY_FAILED_JUMP(nRetCode);
nRetCode = SafeCopyString(pNode->szRemoteIP, sizeof(pNode->szRemoteIP), cszRemoteIP);
XY_FAILED_JUMP(nRetCode);
pNode->bListener = false;
pNode->nSocket = nSocket;
pNode->bUsrClose = false;
pNode->pbyBuffer = pbyBuffer;
pNode->uBufferSize = uMaxPackLen;
pNode->pbyDataBegin = pbyBuffer;
pNode->pbyDataEnd = pbyBuffer;
pNode->nRemotePort = nRemotePort;
pNode->bErrNotified = false;
pNode->nSysErr = 0;
pNode->nUsrErr = 0;
pNode->nTimeoutSeconds = -1;
pNode->uLastPackTime = nTimeNow;
pNode->pDataProc = NULL;
pNode->pErrProc = NULL;
pNode->pvUsrData = NULL;
pNode->bComplete = true;
pNode->nSendRetryCount = 0;
pNode->nSendRetrySleep = 0;
pNode->pNext = m_StreamHeadNode.pNext;
m_StreamHeadNode.pNext = pNode;
pResult = pNode;
Exit0:
if (pResult == NULL)
{
XY_DELETE_ARRAY(pbyBuffer);
if (pNode)
{
pNode->pNext = m_pStreamNodeFree;
m_pStreamNodeFree = pNode;
pNode = NULL;
}
}
return pResult;
}
LIBFREESPACE_API int freespace_openDevice(FreespaceDeviceId id) {
int idx;
struct FreespaceDeviceStruct* device = freespace_private_getDeviceById(id);
if (device == NULL) {
return FREESPACE_ERROR_NO_DEVICE;
}
if (device->isOpened_) {
// Each device can only be opened once.
return FREESPACE_ERROR_BUSY;
}
for (idx = 0; idx < device->handleCount_; idx++) {
struct FreespaceSubStruct* s = &device->handle_[idx];
if (s->handle_ != NULL) {
// Device was partially (incorrectly) opened.
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_BUSY;
}
if (s->devicePath == NULL) {
// Device was not fully enumerated.
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
DEBUG_WPRINTF(L"Open %s\n", s->devicePath);
s->handle_ = CreateFile(s->devicePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);
{
DWORD d;
if (!GetHandleInformation(s->handle_, &d)) {
// We do not have the correct handle.
DEBUG_PRINTF("freespace_openDevice failed with code %d\n", GetLastError());
}
}
if (s->handle_ == INVALID_HANDLE_VALUE) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
if (!BindIoCompletionCallback(s->handle_, freespace_private_overlappedCallback, 0)) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
if (!HidD_SetNumInputBuffers(s->handle_, HID_NUM_INPUT_BUFFERS)) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
// Create the read event.
s->readOverlapped_.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (s->readOverlapped_.hEvent == NULL) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
s->readOverlapped_.Offset = 0;
s->readOverlapped_.OffsetHigh = 0;
s->readStatus_ = FALSE;
}
device->isOpened_ = TRUE;
// Enable send by initializing all send events.
for (idx = 0; idx < FREESPACE_MAXIMUM_SEND_MESSAGE_COUNT; idx++) {
device->send_[idx].overlapped_.hEvent = NULL;
if (initializeSendStruct(&device->send_[idx]) != FREESPACE_SUCCESS) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
}
// If async mode has been enabled already, then start the receive
// process going.
if (freespace_instance_->fdAddedCallback_) {
int rc;
rc = initiateAsyncReceives(device);
if (rc != FREESPACE_SUCCESS) {
freespace_private_forceCloseDevice(device);
return rc;
}
}
return FREESPACE_SUCCESS;
}
