static int
dis_format2(uint32_t *pc, uint32_t inst)
{
int op2 = OP2(inst);
switch(op2) {
case 0:
(void)printf("%p:\tilltrap\n", (void *)pc);
return OK;
case 1:
return dis_bpcc(pc, inst);
case 2:
return dis_bicc(pc, inst);
case 3:
return dis_bpr(pc, inst);
case 4:
if ((RD(inst) == 0) && (IMM22(inst) == 0)) {
(void)printf("%p:\tnop\n", (void *)pc);
return OK;
}
(void)printf("%p:\tsethi\t0x%x, %s\n", (void *)pc,
IMM22(inst) << 10, sregs[RD(inst)]);
return OK;
case 5:
return dis_fbpfcc(pc, inst);
case 6:
return dis_fbfcc(pc, inst);
case 7:
ILLEGAL;
}
return ERR;
}
void NET_BaseSocket::PrivateOnSend()
{
if (!m_created)
return;
MutexWrap out_read_access(m_out_data->m_r_mutex);
int filled_size;
{
MutexWrap out_write_access(m_out_data->m_w_mutex);
filled_size = m_out_data->NoLockSpaceFor(RingBuffer_READ);
}
if (filled_size <= 0)
return;
int size_to_send = min((int)m_out_buf_size, filled_size);
m_out_data->Read(m_out_buf, size_to_send);
DWORD bytes_written = 0, flags = 0;
m_out_wsa_buf.buf = m_out_buf;
m_out_wsa_buf.len = size_to_send;
m_last_error = 0;
OP2( WSASend(m_socket, &m_out_wsa_buf, 1, &bytes_written, flags, m_write_thread.GetOverlapped(), NULL), m_last_error != WSA_IO_PENDING, "NET_BaseSocket::PrivateOnSend, WSASend" );
if (m_last_error == WSA_IO_PENDING)
{
WSAResetEvent(m_write_thread.GetOverlapped()->hEvent);
return;
}
CHECK(bytes_written == size_to_send);
OnSend();
}
void NET_Server::PrivateStopListen()
{
if (!m_created || !m_listening)
return;
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, GetName() + "::PrivateStopListen() started");
CHECK(m_socket != INVALID_SOCKET);
SelectEvent(m_wait_thread.Event(WT_ACCEPTED), 0);
{
MutexWrap connections_access(m_connections_mutex);
while (!m_connections.empty())
{
NET_Connection* connection = m_connections.back();
connection->m_read_thread.Stop();
connection->m_write_thread.Stop();
connection->m_server = NULL;
m_connections.pop_back();
connection->PrivateClose();
OnConnectionClosed(connection);
delete connection;
}
}
m_wait_thread.Stop();
OP2( shutdown(m_socket, SD_BOTH), m_last_error != WSAENOTCONN, "NET_Server::PrivateStopListen, shutdown" );
OP( closesocket(m_socket), "NET_Server::PrivateStopListen, closesocket" );
m_socket = INVALID_SOCKET;
m_listening = false;
m_listening_port = -1;
m_created = false;
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, GetName() + "::PrivateStopListen() finished");
}
void NET_BaseSocket::PrivateClose(bool from_thread)
{
if (!m_created)
return;
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, GetName() + "::PrivateClose() started");
{
if (m_socket_type != NET_TYPE_SERVER)
{
m_read_thread.Stop();
m_write_thread.Stop();
}
if (m_socket_type != NET_TYPE_CONNECTION)
m_wait_thread.Stop();
if (m_socket != INVALID_SOCKET)
{
OP2( shutdown(m_socket, SD_BOTH), m_last_error != WSAENOTCONN && m_last_error != WSANOTINITIALISED, "NET_BaseSocket::PrivateClose, shutdown" );
OP3( closesocket(m_socket), "NET_BaseSocket::PrivateClose, closesocket" );
m_socket = INVALID_SOCKET;
}
PrivateDestroyBuffers();
if (m_created)
m_created = false;
switch (m_socket_type)
{
case NET_TYPE_CONNECTION:
break;
case NET_TYPE_CLIENT:
((NET_Client*)this)->PrivateOnClose();
OnClose();
break;
case NET_TYPE_SERVER:
((NET_Server*)this)->PrivateOnClose();
OnClose();
break;
default:
OnError("NET_BaseSocket::PrivateClose, unknown socket type");
}
}
if (m_socket_type == NET_TYPE_CONNECTION)
((NET_Connection*)this)->PrivateOnClose();
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, GetName() + "::PrivateClose() finished");
}
int read_opcode(void)
{
uint16_t inst;
if (cpu.PC == MEM_SIZE)
return EOF;
if (cpu.PC == rom_size)
return END_ROM;
inst = (mem[cpu.PC]<<8) | mem[cpu.PC+1];
op1 = OP1(inst);
op2 = OP2(inst);
op3 = OP3(inst);
op4 = OP4(inst);
cpu.PC += 2;
return cpu.PC;
}
void NET_BaseSocket::PrivateOnReceived()
{
if (!m_created)
return;
DWORD to_read, received = 0, flags = 0, space;
OP( ioctlsocket(m_socket, FIONREAD, &to_read), "NET_BaseSocket::PrivateOnReceived, ioctlsocket" );
bool repeat = to_read > m_in_buf_size;
if (repeat)
to_read = m_in_buf_size;
m_in_wsa_buf.buf = m_in_buf;
m_in_wsa_buf.len = to_read;
m_last_error = 0;
OP2( WSARecv(m_socket, &m_in_wsa_buf, 1, &received, &flags, m_read_thread.GetOverlapped(), NULL), m_last_error != WSA_IO_PENDING, "NET_BaseSocket::PrivateOnReceived, WSARecv" );
if (m_last_error == WSA_IO_PENDING)
{
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, TXT("%s::PrivateOnReceived -- PENDING") << GetName());
WSAResetEvent(m_read_thread.GetOverlapped()->hEvent);
return;
}
{
MutexWrap in_write_access(m_in_data->m_w_mutex);
{
MutexWrap in_read_access(m_in_data->m_r_mutex);
space = m_in_data->SpaceFor(RingBuffer_WRITE);
}
if (space < received)
OnError("NET_BaseSocket::PrivateOnReceived -- space < received !!!");
else
{
LOG_V0_AddMessage(LOG_V0_DEBUG_MESSAGE, TXT("%s -- получено %d") << GetName() << received);
m_in_data->Write(m_in_buf, received);
}
}
OnReceived();
if (repeat || received < to_read)
WSASetEvent(m_read_thread.Event(0));
}
