int clSocketBase::Read(char* buffer, size_t bufferSize, size_t& bytesRead, long timeout) throw(clSocketException)
{
if(SelectRead(timeout) == kTimeout) {
return kTimeout;
}
memset(buffer, 0, bufferSize);
bytesRead = recv(m_socket, buffer, bufferSize, 0);
return kSuccess;
}
int clSocketBase::Read(char* buffer, size_t bufferSize, size_t& bytesRead, long timeout)
{
if(SelectRead(timeout) == kTimeout) {
return kTimeout;
}
memset(buffer, 0, bufferSize);
const int res = recv(m_socket, buffer, bufferSize, 0);
if(res < 0) {
const int err = GetLastError();
if(eWouldBlock == err) {
return kTimeout;
}
throw clSocketException("Read failed: " + error(err));
}
else if(0 == res) {
throw clSocketException("Read failed: " + error());
}
bytesRead = static_cast<size_t>(res);
return kSuccess;
}
/**
* This function receives data from a connected socket
*/
static jdwpTransportError
ReceiveData(jdwpTransportEnv* env, SOCKET sckt, char* buffer, int dataLength, jlong deadline = 0, int* readByte = 0)
{
long left = dataLength;
long off = 0;
int ret;
if (readByte != 0) {
*readByte = 0;
}
while (left > 0) {
jdwpTransportError err = SelectRead(env, sckt, deadline);
if (err != JDWPTRANSPORT_ERROR_NONE) {
return err;
}
ret = recv(sckt, (buffer + off), left, 0);
if (ret == SOCKET_ERROR) {
int err = GetLastErrorStatus();
// ignore signal interruption
if (err != SOCKET_ERROR_EINTR) {
SetLastTranError(env, "data receiving failed", err);
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
}
if (ret == 0) {
SetLastTranError(env, "premature EOF", 0);
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
left -= ret;
off += ret;
if (readByte != 0) {
*readByte = off;
}
} //while
return JDWPTRANSPORT_ERROR_NONE;
} // ReceiveData
/**
* This function implements jdwpTransportEnv::Accept
*/
static jdwpTransportError JNICALL
TCPIPSocketTran_Accept(jdwpTransportEnv* env, jlong acceptTimeout,
jlong handshakeTimeout)
{
if (acceptTimeout < 0) {
SetLastTranError(env, "acceptTimeout timeout is negative", 0);
return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT;
}
if (handshakeTimeout < 0) {
SetLastTranError(env, "handshakeTimeout timeout is negative", 0);
return JDWPTRANSPORT_ERROR_ILLEGAL_ARGUMENT;
}
SOCKET envClientSocket = ((internalEnv*)env->functions->reserved1)->envClientSocket;
if (envClientSocket != INVALID_SOCKET) {
SetLastTranError(env, "there is already an open connection to the debugger", 0);
return JDWPTRANSPORT_ERROR_ILLEGAL_STATE ;
}
SOCKET envServerSocket = ((internalEnv*)env->functions->reserved1)->envServerSocket;
if (envServerSocket == INVALID_SOCKET) {
SetLastTranError(env, "transport is not currently in listen mode", 0);
return JDWPTRANSPORT_ERROR_ILLEGAL_STATE ;
}
struct sockaddr serverSockAddr;
socklen_t len = sizeof(serverSockAddr);
int res = getsockname(envServerSocket, &serverSockAddr, &len);
if (res == SOCKET_ERROR) {
SetLastTranError(env, "connection failed", GetLastErrorStatus());
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
jlong deadline = (acceptTimeout == 0) ? 0 : (jlong)GetTickCount() + acceptTimeout;
jdwpTransportError err = SelectRead(env, envServerSocket, deadline);
if (err != JDWPTRANSPORT_ERROR_NONE) {
return err;
}
SOCKET clientSocket = accept(envServerSocket, &serverSockAddr, &len);
if (clientSocket == INVALID_SOCKET) {
SetLastTranError(env, "socket accept failed", GetLastErrorStatus());
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
if (!SetSocketBlockingMode(env, clientSocket, false)) {
return JDWPTRANSPORT_ERROR_IO_ERROR;
}
EnterCriticalSendSection(env);
EnterCriticalReadSection(env);
((internalEnv*)env->functions->reserved1)->envClientSocket = clientSocket;
err = CheckHandshaking(env, clientSocket, (long)handshakeTimeout);
LeaveCriticalReadSection(env);
LeaveCriticalSendSection(env);
if (err != JDWPTRANSPORT_ERROR_NONE) {
TCPIPSocketTran_Close(env);
return err;
}
return JDWPTRANSPORT_ERROR_NONE;
} //TCPIPSocketTran_Accept
