int SocketRedirect() {
int n;
int i;
n = SocketReceive(socketRedirectPointer, socketRedirectTemp, 2);
if (n <= 0) {
return n;
}
if (n < 2) {
fprintf(stderr, "Cannot receive length of text!\n");
return -1;
}
n = (unsigned char)socketRedirectTemp[1];
if (n == 0) {
return 0;
}
n = SocketReceive(socketRedirectPointer, socketRedirectTemp+2, n);
if (n <= 0) {
return n;
}
if (socketRedirectTemp[0] == SOCKET_REDIRECT_STDOUT) {
for (i=0; i<n; i++) {
fprintf(stdout, "%c", socketRedirectTemp[i+2]);
}
} else if (socketRedirectTemp[0] == SOCKET_REDIRECT_STDERR) {
for (i=0; i<n; i++) {
fprintf(stderr, "%c", socketRedirectTemp[i+2]);
}
} else {
// reserved
fprintf(stderr, "Unknown stream type! The original text:\n");
for (i=0; i<n; i++) {
fprintf(stderr, "%c", socketRedirectTemp[i+2]);
}
}
return n;
}
// Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
void NetworkUpdate()
{
// CheckSockets
//
// If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady
//
// If the socket is ready, attempt to receive data from the socket
// int bytesRecv = 0;
// if (IsSocketReady(server_res->socket)) {
// bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// }
int bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime();
if (elapsed > delay) {
if (ping) {
ping = false;
SocketSend(server_res->socket, pingmsg, msglen);
} else if (pong) {
pong = false;
SocketSend(server_res->socket, pongmsg, msglen);
}
elapsed = 0.0f;
}
}
const bool RemoteMinerClient::Update(const int ms)
{
if(IsConnected())
{
m_timeval.tv_sec=0;
m_timeval.tv_usec=ms*1000;
FD_ZERO(&m_readfs);
FD_ZERO(&m_writefs);
FD_SET(m_socket,&m_readfs);
if(m_sendbuffer.size()>0)
{
FD_SET(m_socket,&m_writefs);
}
select(m_socket+1,&m_readfs,&m_writefs,0,&m_timeval);
if(IsConnected() && FD_ISSET(m_socket,&m_readfs))
{
SocketReceive();
}
if(IsConnected() && FD_ISSET(m_socket,&m_writefs))
{
SocketSend();
}
}
if(IsConnected())
{
return true;
}
else
{
return false;
}
}
////////////////////////////////////////////////////////////
/// User protocol parser
////////////////////////////////////////////////////////////
void UserParseData(void * User)
{
// Socket incoming buffer
Int8 Buffer[4096];
// Socket incoming data size
Int32 SizeRecived = 0;
// User
struct UserData * UserPtr = (struct UserData*)User;
// Socket receive loop
do
{
// Receive data
if (SocketReceive(&UserPtr->Connection.Socket, Buffer, 4096, &SizeRecived) == Done)
{
// Lock until the user hasn't been processed
MutexLock(&UserPtr->MutexData);
if (!ProtocolParser(UserPtr, (UInt8*)Buffer, SizeRecived))
{
MutexUnlock(&UserPtr->MutexData);
// Remove it
UserRemove(UserPtr);
return;
}
MutexUnlock(&UserPtr->MutexData);
}
} while (SizeRecived > 0);
// Remove it
UserRemove(UserPtr);
}
NTSTATUS SocketTest(PVOID Context)
{
PSOCKET_FACTORY SocketFactory = NULL;
PSOCKET Socket;
NTSTATUS Status;
CHAR HttpResponse[4];
CHAR HttpRequest[] = "GET / HTTP/1.1\nHost: rbc.ru\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64)\nAccept: */*\n\n";
ULONG Sent, Received;
BOOLEAN Disconnected;
SocketFactory = NpAlloc(sizeof(*SocketFactory), TESTS_TAG);
if (!SocketFactory)
return STATUS_INSUFFICIENT_RESOURCES;
Status = SocketFactoryInit(SocketFactory);
if (!NT_SUCCESS(Status)) {
KLErr("SocketFactoryInit failed Status 0x%x", Status);
goto socket_factory_free;
}
Status = SocketConnect(SocketFactory, L"rbc.ru", L"80", &Socket);
if (!NT_SUCCESS(Status)) {
KLErr("SocketConnect failed Status 0x%x", Status);
goto socket_factory_release;
}
Status = SocketSend(Socket, HttpRequest, sizeof(HttpRequest), &Sent);
if (!NT_SUCCESS(Status)) {
KLErr("SocketSend failed Status 0x%x", Status);
goto socket_close;
}
if (Sent != sizeof(HttpRequest)) {
Status = STATUS_UNSUCCESSFUL;
KLErr("SocketSend failed Sent %d", Sent);
goto socket_close;
}
Status = SocketReceive(Socket, HttpResponse, sizeof(HttpResponse), &Received, &Disconnected);
if (!NT_SUCCESS(Status)) {
KLErr("SocketReceive failed Status 0x%x", Status);
goto socket_close;
}
if ((Received != sizeof(HttpResponse)) || Disconnected) {
KLErr("Received %d Disconnected %d", Received, Disconnected);
Status = STATUS_UNSUCCESSFUL;
goto socket_close;
}
if (4 != RtlCompareMemory(HttpResponse, "HTTP", 4)) {
KLErr("Incorrect data received");
Status = STATUS_UNSUCCESSFUL;
goto socket_close;
}
Status = STATUS_SUCCESS;
socket_close:
SocketClose(Socket);
socket_factory_release:
SocketFactoryRelease(SocketFactory);
socket_factory_free:
NpFree(SocketFactory, TESTS_TAG);
KLInf("SocketTest Status 0x%x", Status);
return Status;
}
void IRCClientThread::thread()
{
int ciphersuites[] =
{
SSL_EDH_RSA_AES_256_SHA,
SSL_EDH_RSA_CAMELLIA_256_SHA,
SSL_EDH_RSA_AES_128_SHA,
SSL_EDH_RSA_CAMELLIA_128_SHA,
SSL_EDH_RSA_DES_168_SHA,
SSL_RSA_AES_256_SHA,
SSL_RSA_CAMELLIA_256_SHA,
SSL_RSA_AES_128_SHA,
SSL_RSA_CAMELLIA_128_SHA,
SSL_RSA_DES_168_SHA,
SSL_RSA_RC4_128_SHA,
SSL_RSA_RC4_128_MD5,
0
};
int rval=0;
fd_set readfs;
fd_set writefs;
struct timeval tv;
std::string temp("");
// setup SSL connection first
if(m_contype==IRCClientConnection::CON_SSL)
{
m_log->Error("IRCClientThread::thread SSL handshaking with client");
ssl_set_ciphersuites(&(m_ssl->m_ssl),ciphersuites);
rval=ssl_handshake(&(m_ssl->m_ssl));
if(rval!=0)
{
StringFunctions::Convert(rval,temp);
m_log->Error("IRCClientThread::thread couldn't handshake with client - return value = "+temp);
Disconnect();
return;
}
}
while(should_stop()==false && IsConnected()==true)
{
tv.tv_sec=0;
tv.tv_usec=100000;
FD_ZERO(&readfs);
FD_ZERO(&writefs);
FD_SET(m_socket,&readfs);
if(SendBufferSize()>0)
{
FD_SET(m_socket,&writefs);
}
rval=select(m_socket+1,&readfs,&writefs,0,&tv);
if(rval>0)
{
if(FD_ISSET(m_socket,&readfs))
{
SocketReceive();
}
if(IsConnected() && FD_ISSET(m_socket,&writefs))
{
SocketSend();
}
}
if(m_wantdisconnect==true)
{
Disconnect();
}
}
}
