void CPipeState_Listening::ProcessEvent(bool bRead,bool /*bWrite*/,bool /*bError*/)
{
if( !bRead )
return;
for(;;)
{
SOCKET Socket = accept( m_Socket , NULL , NULL );
if( INVALID_SOCKET == Socket )
{
int nErrorCode=SocketGetLastError();
switch(nErrorCode)
{
#ifndef _WIN32
case ECONNABORTED:
case EMFILE:
#endif
case EWOULDBLOCK:
return;
}
ostringstream strm;
strm<<"accept failed with error code:"<<nErrorCode<<".";
GenErr(strm.str());
}
u_long uParam=1;
if( SOCKET_ERROR == ioctlsocket( Socket , FIONBIO , &uParam ) )
{
closesocket( Socket );
ostringstream strm;
strm<<"ioctlsocket failed with error code "<< SocketGetLastError() <<".";
GenErr(strm.str());
}
bool bDisconnected;
CSyncPipe* pNewPipe = new CSyncPipe( NULL , GetPipe()->m_OutBuffer.OutBufferGetSize() ,
GetPipe()->m_InBuffer.InBufferGetSize(),Socket , GetPipe()->m_uCreationFlag,bDisconnected );
if( bDisconnected )
{
delete pNewPipe;
}
else
{
GetPipe()->AddEventAccepted( pNewPipe );
}
}
}
gboolean
Socket_Send(SOCKET fd, // IN
char *buf, // IN
int len) // IN
{
int left = len;
int sent = 0;
int rv;
int sysErr;
while (left > 0) {
rv = send(fd, buf + sent, left, 0);
if (rv == SOCKET_ERROR) {
sysErr = SocketGetLastError();
if (sysErr == SYSERR_EINTR) {
continue;
}
Warning(LGPFX "Send error for socket %d: %d[%s]", fd, sysErr,
Err_Errno2String(sysErr));
return FALSE;
}
left -= rv;
sent += rv;
}
Debug(LGPFX "Sent %d bytes from socket %d\n", len, fd);
return TRUE;
}
CPipeState_Listening::CPipeState_Listening(CSyncPipe* pPipe,SOCKET Socket)
:CPipeState_Busy(pPipe,Socket)
{
CPipeState* pState=GetPipe()->m_pState;
GetPipe()->m_pState=NULL;
delete pState;
GetPipe()->m_pState=this;
#ifdef _WIN32
SQR_TRY
{
m_Event.Create(m_Socket);
}
SQR_CATCH(exp)
{
LogExp(exp);
closesocket(m_Socket);
throw;
}
SQR_TRY_END;
#endif
Register();
if( listen(m_Socket,SOMAXCONN) )
{
ostringstream strm;
strm<<"listen failed with error code:"<<SocketGetLastError()<<".";
GenErr(strm.str());
}
}
gboolean
Socket_Recv(SOCKET fd, // IN
char *buf, // OUT
int len) // IN
{
int remaining = len;
int rv;
int sysErr;
while (remaining > 0) {
rv = recv(fd, buf , remaining, 0);
if (rv == 0) {
Warning(LGPFX "Socket %d closed by peer.", fd);
return FALSE;
}
if (rv == SOCKET_ERROR) {
sysErr = SocketGetLastError();
if (sysErr == SYSERR_EINTR) {
continue;
}
Warning(LGPFX "Recv error for socket %d: %d[%s]", fd, sysErr,
Err_Errno2String(sysErr));
return FALSE;
}
remaining -= rv;
buf += rv;
}
Debug(LGPFX "Recved %d bytes from socket %d\n", len, fd);
return TRUE;
}
gboolean
Socket_RecvPacket(SOCKET sock, // IN
char **payload, // OUT
int *payloadLen) // OUT
{
gboolean ok;
int32 packetLen;
int packetLenSize = sizeof packetLen;
int fullPktLen;
char *recvBuf;
int recvBufLen;
ok = Socket_Recv(sock, (char *)&packetLen, packetLenSize);
if (!ok) {
Debug(LGPFX "error in recving packet header, err=%d\n",
SocketGetLastError());
return FALSE;
}
fullPktLen = ntohl(packetLen) + packetLenSize;
recvBufLen = fullPktLen;
recvBuf = malloc(recvBufLen);
if (recvBuf == NULL) {
Debug(LGPFX "Could not allocate recv buffer.\n");
return FALSE;
}
memcpy(recvBuf, &packetLen, packetLenSize);
ok = Socket_Recv(sock, recvBuf + packetLenSize,
fullPktLen - packetLenSize);
if (!ok) {
Debug(LGPFX "error in recving packet, err=%d\n",
SocketGetLastError());
free(recvBuf);
return FALSE;
}
ok = Socket_DecodePacket(recvBuf, fullPktLen, payload, payloadLen);
free(recvBuf);
return ok;
}
int API_recv(SOCKETDESC *desc, void *data, size_t cbMaxData)
{
PyClient *client = (PyClient *) desc->prv;
if (client == NULL)
{
PyErr_Format(PyExc_IOError, "No client object");
PRINTMARK();
return -1;
}
int result;
while (true)
{
result = recv ( client->sockfd, (char *) data, cbMaxData, MSG_NOSIGNAL);
if (result == 0)
{
PRINTMARK();
PyErr_Format(PyExc_IOError, "Connection reset by peer while reading on socket");
return -1;
}
if (result > 0)
{
PRINTMARK();
break;
}
PRINTMARK();
if (!SocketWouldBlock(client->sockfd))
{
PyErr_Format(PyExc_IOError, "Socket error %d when reading", SocketGetLastError());
return -1;
}
PRINTMARK();
if (API_wouldBlock_gevent(client->sock, client->sockfd, 1, 10) == 0)
{
PRINTMARK();
return -1;
}
PRINTMARK();
}
return result;
}
void
Socket_Close(SOCKET sock)
{
int res;
#if defined(_WIN32)
res = closesocket(sock);
#else
res = close(sock);
#endif
if (res == SOCKET_ERROR) {
int err = SocketGetLastError();
Warning(LGPFX "Error in closing socket %d: %d[%s]\n",
sock, err, Err_Errno2String(err));
}
SocketCleanup();
}
int CPipeState_Listening::CreateBindedSocket(SOCKET& SocketOut,const CAddress& Address)
{
SOCKET Socket=CreateSocket();
sockaddr_in saiAddress;
memset(&saiAddress,0,sizeof(saiAddress));
saiAddress.sin_addr.s_addr = inet_addr( Address.GetAddress() );
saiAddress.sin_port = htons( static_cast<u_short>( Address.GetPort() ) );
saiAddress.sin_family = AF_INET;
//bind
if( bind( Socket,reinterpret_cast<sockaddr*>( &saiAddress) , sizeof(sockaddr) ) )
{
closesocket(Socket);
return SocketGetLastError();
}
SocketOut=Socket;
return 0;
}
SOCKET
Socket_ConnectVMCI(unsigned int cid, // IN
unsigned int port, // IN
gboolean isPriv, // IN
SockConnError *outError) // OUT
{
struct sockaddr_vm addr;
SOCKET fd;
SockConnError error = SOCKERR_GENERIC;
int sysErr;
socklen_t addrLen = sizeof addr;
int vsockDev = -1;
int family = VMCISock_GetAFValueFd(&vsockDev);
if (outError) {
*outError = SOCKERR_SUCCESS;
}
if (!SocketStartup()) {
goto error;
}
if (family == -1) {
Warning(LGPFX "Couldn't get VMCI socket family info.");
goto error;
}
memset((char *)&addr, 0, sizeof addr);
addr.svm_family = family;
addr.svm_cid = cid;
addr.svm_port = port;
Debug(LGPFX "creating new socket, connecting to %u:%u\n", cid, port);
fd = socket(addr.svm_family, SOCK_STREAM, 0);
if (fd == INVALID_SOCKET) {
sysErr = SocketGetLastError();
Warning(LGPFX "failed to create socket, error %d: %s\n",
sysErr, Err_Errno2String(sysErr));
goto error;
}
if (isPriv) {
struct sockaddr_vm localAddr;
gboolean bindOk = FALSE;
int localPort;
memset(&localAddr, 0, sizeof localAddr);
localAddr.svm_family = addr.svm_family;
localAddr.svm_cid = VMCISock_GetLocalCID();
/* Try to bind to port 1~1023 for a privileged user. */
for (localPort = PRIVILEGED_PORT_MAX;
localPort >= PRIVILEGED_PORT_MIN; localPort--) {
localAddr.svm_port = localPort;
if (bind(fd, (struct sockaddr *)&localAddr, sizeof localAddr) != 0) {
sysErr = SocketGetLastError();
if (sysErr == SYSERR_EACCESS) {
Warning(LGPFX "Couldn't bind to privileged port for "
"socket %d\n", fd);
error = SOCKERR_EACCESS;
Socket_Close(fd);
goto error;
}
if (sysErr == SYSERR_EADDRINUSE) {
continue;
}
Warning(LGPFX "could not bind socket, error %d: %s\n", sysErr,
Err_Errno2String(sysErr));
Socket_Close(fd);
error = SOCKERR_BIND;
goto error;
} else {
bindOk = TRUE;
break;
}
}
if (!bindOk) {
Warning(LGPFX "Failed to bind to privileged port for socket %d, "
"no port available\n", fd);
error = SOCKERR_BIND;
Socket_Close(fd);
goto error;
} else {
Debug(LGPFX "Successfully bound to port %d for socket %d\n",
localAddr.svm_port, fd);
}
}
if (connect(fd, (struct sockaddr *)&addr, addrLen) != 0) {
sysErr = SocketGetLastError();
Warning(LGPFX "socket connect failed, error %d: %s\n",
sysErr, Err_Errno2String(sysErr));
Socket_Close(fd);
error = SOCKERR_CONNECT;
goto error;
}
VMCISock_ReleaseAFValueFd(vsockDev);
Debug(LGPFX "socket %d connected\n", fd);
return fd;
error:
if (outError) {
*outError = error;
}
VMCISock_ReleaseAFValueFd(vsockDev);
return INVALID_SOCKET;
}
CPipeState_Connecting::CPipeState_Connecting(CSyncPipe* pPipe,const CAddress& Address,uint32& uResult)
:CPipeState_Busy(pPipe)
{
pPipe->m_OutBuffer.OutBufferClear();
pPipe->m_InBuffer.InBufferClear();
CPipeState* pState=GetPipe()->m_pState;
GetPipe()->m_pState=NULL;
delete pState;
GetPipe()->m_pState=this;
const SOCKET& Socket=m_Socket;
#ifdef _WIN32
SQR_TRY
{
m_Event.Create(Socket);
}
SQR_CATCH (exp)
{
LogExp(exp);
closesocket(m_Socket);
throw;
}
SQR_TRY_END;
#endif
Register();
sockaddr_in saiAddress;
::memset(&saiAddress,0,sizeof(saiAddress));
saiAddress.sin_addr.s_addr = inet_addr(Address.GetAddress());
saiAddress.sin_port = htons(static_cast<u_short>(Address.GetPort()));
saiAddress.sin_family = AF_INET;
//连接
int nResult;
nResult=connect(Socket,reinterpret_cast<sockaddr*>(&saiAddress),sizeof(sockaddr));
if(SOCKET_ERROR!=nResult)
{
uResult=0;
}
else
{
int nError=SocketGetLastError();
switch(nError)
{
#if defined(__linux__)
case EINPROGRESS:
#elif defined(_WIN32)
case EWOULDBLOCK:
#endif
uResult=1;
break;
#ifdef _WIN32
case ECONNABORTED://Windows下还真会出现这种情况
case ENOBUFS:
uResult=2;
GetPipe()->AddEventConnectFailed(ePCFR_OSERROR);
return;
#endif
case ECONNRESET:
case ECONNREFUSED:
uResult=2;
GetPipe()->AddEventConnectFailed(ePCFR_REFUSED);
return;
case ETIMEDOUT:
case ENETRESET:
case EHOSTUNREACH:
case ENETUNREACH:
uResult=2;
GetPipe()->AddEventConnectFailed(ePCFR_UNREACHABLE);
return;
default:
closesocket(m_Socket);
stringstream strm;
strm<<"connect failed with error code "<<nError<<".";
GenErr(strm.str());
}
}
m_RemoteAddress=Address;
}
