MessageSent MessagesClient::sendMessageToSelf(
const SendableMessage &message,
const std::vector<unsigned char> &meta,
const Protocol::ProgressHandler &onProgress)
{
auto result = doSendMessage(nullptr, message, meta, onProgress);
kulloAssert(result.messageSent);
return *(result.messageSent);
}
void SmalltalkVM::doSendMessage(TVMExecutionContext& ec)
{
TObjectArray* messageArguments = ec.stackPop<TObjectArray>();
// These do not need to be hptr'ed
TSymbolArray& literals = * ec.currentContext->method->literals;
TSymbol* messageSelector = literals[ec.instruction.getArgument()];
doSendMessage(ec, messageSelector, messageArguments);
}
std::size_t MessagesClient::sendMessage(
const KulloAddress &recipient,
const SendableMessage &message,
const ProgressHandler &onProgress)
{
auto result = doSendMessage(
&recipient,
message,
std::vector<unsigned char>(),
onProgress);
return result.requestBodySize;
}
void SmalltalkVM::doSendBinary(TVMExecutionContext& ec)
{
// Loading the operand objects
TObject* rightObject = ec.stackPop();
TObject* leftObject = ec.stackPop();
// If operands are both small integers, we may handle it ourselves
if (isSmallInteger(leftObject) && isSmallInteger(rightObject)) {
// Loading actual operand values
int32_t rightOperand = TInteger(rightObject);
int32_t leftOperand = TInteger(leftObject);
bool unusedCondition;
// Performing an operation
switch ( static_cast<binaryBuiltIns::Operator>(ec.instruction.getArgument()) ) {
case binaryBuiltIns::operatorLess:
ec.returnedValue = (leftOperand < rightOperand) ? globals.trueObject : globals.falseObject;
break;
case binaryBuiltIns::operatorLessOrEq:
ec.returnedValue = (leftOperand <= rightOperand) ? globals.trueObject : globals.falseObject;
break;
case binaryBuiltIns::operatorPlus:
ec.returnedValue = callSmallIntPrimitive(primitive::smallIntAdd, leftOperand, rightOperand, unusedCondition);
break;
default:
std::fprintf(stderr, "VM: Invalid opcode %d passed to sendBinary\n", ec.instruction.getArgument());
std::exit(1);
}
ec.stackPush( ec.returnedValue );
m_messagesSent++;
} else {
// This binary operator is performed on an ordinary object.
// We do not know how to handle it, thus send the message to the receiver
// Protecting pointers in case if GC occurs
hptr<TObject> pRightObject = newPointer(rightObject);
hptr<TObject> pLeftObject = newPointer(leftObject);
hptr<TObjectArray> messageArguments = newObject<TObjectArray>(2/*, false*/);
messageArguments[1] = pRightObject;
messageArguments[0] = pLeftObject;
TSymbol* messageSelector = static_cast<TSymbol*>( globals.binaryMessages[ec.instruction.getArgument()] );
doSendMessage(ec, messageSelector, messageArguments);
}
}
void MinecraftDynmapProto::SendMsgWorker(void *p)
{
if (p == NULL)
return;
ScopedLock s(send_message_lock_);
std::string data = *(std::string*)p;
delete (std::string*)p;
data = utils::text::trim(data);
if (isOnline() && data.length()) {
doSendMessage(data);
}
}
SmalltalkVM::TExecuteResult SmalltalkVM::doSpecial(hptr<TProcess>& process, TVMExecutionContext& ec)
{
TObjectArray& arguments = * ec.currentContext->arguments;
TSymbolArray& literals = * ec.currentContext->method->literals;
switch(ec.instruction.getArgument())
{
case special::selfReturn: {
ec.returnedValue = arguments[0]; // arguments[0] always keep self
ec.currentContext = ec.currentContext->previousContext;
if (ec.currentContext.rawptr() == globals.nilObject) {
process->context = ec.currentContext;
process->result = ec.returnedValue;
return returnReturned;
}
ec.loadPointers();
ec.stackPush( ec.returnedValue );
} break;
case special::stackReturn: {
ec.returnedValue = ec.stackPop();
ec.currentContext = ec.currentContext->previousContext;
if (ec.currentContext.rawptr() == globals.nilObject) {
process->context = ec.currentContext;
process->result = ec.returnedValue;
return returnReturned;
}
ec.loadPointers();
ec.stackPush( ec.returnedValue );
} break;
case special::blockReturn: {
ec.returnedValue = ec.stackPop();
TBlock* contextAsBlock = ec.currentContext.cast<TBlock>();
ec.currentContext = contextAsBlock->creatingContext->previousContext;
if (ec.currentContext.rawptr() == globals.nilObject) {
process->context = ec.currentContext;
process->result = ec.returnedValue;
return returnReturned;
}
ec.loadPointers();
ec.stackPush( ec.returnedValue );
} break;
case special::duplicate: {
// Duplicate an object on the stack
TObject* copy = ec.stackLast();
ec.stackPush(copy);
} break;
case special::popTop:
ec.stackPop();
break;
case special::branch:
ec.bytePointer = ec.instruction.getExtra();
break;
case special::branchIfTrue: {
ec.returnedValue = ec.stackPop();
if (ec.returnedValue == globals.trueObject)
ec.bytePointer = ec.instruction.getExtra();
} break;
case special::branchIfFalse: {
ec.returnedValue = ec.stackPop();
if (ec.returnedValue == globals.falseObject)
ec.bytePointer = ec.instruction.getExtra();
} break;
case special::sendToSuper: {
uint32_t literalIndex = ec.instruction.getExtra();
TSymbol* messageSelector = literals[literalIndex];
TClass* receiverClass = ec.currentContext->method->klass->parentClass;
TObjectArray* messageArguments = ec.stackPop<TObjectArray>();
doSendMessage(ec, messageSelector, messageArguments, receiverClass);
} break;
}
return returnNoReturn;
}
SmalltalkVM::TExecuteResult SmalltalkVM::execute(TProcess* p, uint32_t ticks)
{
// Protecting the process pointer
hptr<TProcess> currentProcess = newPointer(p);
assert(currentProcess->context != 0);
assert(currentProcess->context->method != 0);
// Initializing an execution context
TVMExecutionContext ec(m_memoryManager, this);
ec.currentContext = currentProcess->context;
ec.loadPointers(); // Loads bytePointer & stackTop
while (true)
{
assert(ec.currentContext != 0);
assert(ec.currentContext->method != 0);
assert(ec.currentContext->stack != 0);
assert(ec.bytePointer <= ec.currentContext->method->byteCodes->getSize());
assert(ec.currentContext->arguments->getSize() >= 1);
assert(ec.currentContext->arguments->getField(0) != 0);
// Initializing helper references
TByteObject& byteCodes = * ec.currentContext->method->byteCodes;
TObjectArray& temporaries = * ec.currentContext->temporaries;
TObjectArray& arguments = * ec.currentContext->arguments;
TObjectArray& instanceVariables = * arguments.getField<TObjectArray>(0);
TSymbolArray& literals = * ec.currentContext->method->literals;
if (ticks && (--ticks == 0)) {
// Time frame expired
ec.storePointers();
currentProcess->context = ec.currentContext;
currentProcess->result = ec.returnedValue;
return returnTimeExpired;
}
// Decoding the instruction
const uint16_t lastBytePointer = ec.bytePointer;
ec.instruction = st::InstructionDecoder::decodeAndShiftPointer(byteCodes, ec.bytePointer);
// And executing it
switch (ec.instruction.getOpcode()) {
case opcode::pushInstance: ec.stackPush(instanceVariables[ec.instruction.getArgument()]); break;
case opcode::pushArgument: ec.stackPush(arguments[ec.instruction.getArgument()]); break;
case opcode::pushTemporary: ec.stackPush(temporaries[ec.instruction.getArgument()]); break;
case opcode::pushLiteral: ec.stackPush(literals[ec.instruction.getArgument()]); break;
case opcode::pushConstant: doPushConstant(ec); break;
case opcode::pushBlock: doPushBlock(ec); break;
case opcode::assignTemporary: temporaries[ec.instruction.getArgument()] = ec.stackLast(); break;
case opcode::assignInstance: {
TObject* newValue = ec.stackLast();
TObject** objectSlot = & instanceVariables[ec.instruction.getArgument()];
// Checking whether we need to register current object slot in the GC
checkRoot(newValue, objectSlot);
// Performing the assignment
*objectSlot = newValue;
} break;
case opcode::markArguments: doMarkArguments(ec); break;
case opcode::sendMessage: doSendMessage(ec); break;
case opcode::sendUnary: doSendUnary(ec); break;
case opcode::sendBinary: doSendBinary(ec); break;
case opcode::doPrimitive: {
TExecuteResult result = doPrimitive(currentProcess, ec);
if (result != returnNoReturn)
return result;
} break;
case opcode::doSpecial: {
TExecuteResult result = doSpecial(currentProcess, ec);
if (result != returnNoReturn)
return result;
} break;
default:
std::fprintf(stderr, "VM: Invalid opcode %d at offset %d in method ", ec.instruction.getOpcode(), lastBytePointer);
std::fprintf(stderr, "'%s'\n", ec.currentContext->method->name->toString().c_str() );
std::exit(1);
}
}
}
SendMessageReply *MessageSession::sendMessage(const Message &message)
{
return doSendMessage(message);
}
void QtUdpSocketPlugin::sendMessage(const QString & message) {
emit doSendMessage(message);
}
QtUdpSocketPlugin::QtUdpSocketPlugin() : _socket(nullptr), _helperReceiveCallback(), _checkerReceiveCallback(), _messageCounter(0), _conditionLock(), _conditionVariable(), _targetHost(), _targetPort(0) {
QObject::connect(this, SIGNAL(doListen(quint16)), this, SLOT(onListen(quint16)));
QObject::connect(this, SIGNAL(doConnect(QString, quint16)), this, SLOT(onConnect(QString, quint16)));
QObject::connect(this, SIGNAL(doSendMessage(QString)), this, SLOT(onSendMessage(QString)));
QObject::connect(this, SIGNAL(doDisconnect()), this, SLOT(onDisconnect()));
}
void CWSAThread::doWSAEvent()
{
SOCKET_KEY* pkey = NULL;
while (m_bOperate)
{
//TODO check here, WSA_MAXIMUM_WAIT_EVENTS
int nIndex = ::WSAWaitForMultipleEvents(m_nEventTotal, m_eventArray, FALSE, 10, FALSE);
nIndex = nIndex - WSA_WAIT_EVENT_0;
for (int i = nIndex; i < m_nEventTotal; ++i)
{
if (m_eventArray[i] == WSA_INVALID_EVENT)
{
continue;
}
int nret = ::WSAWaitForMultipleEvents(1, &m_eventArray[i], TRUE, 10, FALSE);
if (nret == WSA_WAIT_FAILED || nret == WSA_WAIT_TIMEOUT)
{
if (nret == WSA_WAIT_FAILED)
LOG(_ERROR_, "CWSAThread::doWSAEvent() error, (nIndex == WSA_WAIT_FAILED)");
continue;
}
else
{
WSANETWORKEVENTS event;
if (::WSAEnumNetworkEvents(m_sockArray[i], m_eventArray[i], &event) == SOCKET_ERROR)
{
LOG(_ERROR_, "CWSAThread::doWSAEvent() error, ::WSAEnumNetworkEvents() failed, error=%s", WSAGetLastError());
continue;
}
SOCKET_KEY* pkey = m_keymap[i];
if (pkey == NULL)
{
LOG(_ERROR_, "CWSAThread::doWSAEvent() error, pkey == NULL, SOCKET_KEY* pkey = m_keymap[%d]", i);
continue;
}
if (event.lNetworkEvents & FD_ACCEPT)
{
LOG(_INFO_, "CWSAThread::doWSAEvent(), FD_ACCEPT, m_listenfd=%d, m_sockArray[i]=%d", m_listenfd, m_sockArray[i]);
if (event.iErrorCode[FD_ACCEPT_BIT] == 0)
{
if (m_nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)
{
LOG(_INFO_, "CWSAThread::doWSAEvent() error, m_nEventTotal > WSA_MAXIMUM_WAIT_EVENTS");
continue;
}
if (m_listenfd == m_sockArray[i] && m_listenfd == pkey->fd)
{
if (!doAccept(m_listenfd))
{
LOG(_ERROR_, "CWSAThread::doWSAEvent() error, m_listenfd=%d", m_listenfd);
}
}
}
}
else if (event.lNetworkEvents & FD_READ)
{
LOG(_INFO_, "CWSAThread::doWSAEvent(), FD_READ, m_listenfd=%d, m_sockArray[i]=%d", m_listenfd, m_sockArray[i]);
if (event.iErrorCode[FD_ACCEPT_BIT] == 0)
{
if (m_nEventTotal > WSA_MAXIMUM_WAIT_EVENTS)
{
LOG(_INFO_, "CWSAThread::doWSAEvent() error, m_nEventTotal > WSA_MAXIMUM_WAIT_EVENTS");
continue;
}
if (m_listenfd == m_sockArray[i] && m_listenfd == pkey->fd)
{
if (!doAccept(m_listenfd))
{
LOG(_ERROR_, "CWSAThread::doWSAEvent() error, m_listenfd=%d", m_listenfd);
}
continue;
}
doRecvMessage(pkey);
}
}
else if (event.lNetworkEvents & FD_WRITE)
{
LOG(_INFO_, "CWSAThread::doWSAEvent(), FD_WRITE, m_listenfd=%d, m_sockArray[i]=%d", m_listenfd, m_sockArray[i]);
if (doSendMessage(pkey) < 0)
{
closeClient(pkey->fd, pkey->connect_time);
}
else
{
//TODO reset socket event here ?
}
}
else
{
LOG(_INFO_, "CWSAThread::doWSAEvent(), FD_XXX, m_listenfd=%d, m_sockArray[i]=%d", m_listenfd, m_sockArray[i]);
closeClient(pkey->fd, pkey->connect_time);
}
}
}//end for
//// end handle WSAWaitForMultipleEvents /////
/////////////////begin copy all recv message to recv list/////////////////
if (m_recvtmplst.size() > 0)
{
CSysQueue<NET_DATA>* precvlist = CGlobalMgr::getInstance()->getRecvQueue();
precvlist->Lock();
list<NET_DATA*>::iterator iter = m_recvtmplst.begin();
for (; iter != m_recvtmplst.end(); ++iter)
{
if ( (*iter) == NULL)
continue;
if (!precvlist->inQueueWithoutLock(*iter, false))
{
LOG(_ERROR_, "CWSAThread::doEpollEvent() error, inQueueWithoutLock() failed");
delete (*iter);
}
}
precvlist->UnLock();
m_recvtmplst.clear();
}
/////////////////end copy all recv message to recv list/////////////////
//////////////////begin handle system events////////////////////////////
doSystemEvent();
//////////////////end handle system events//////////////////////////////////
//////////////////begin set write wsa event by sendset////////////////
CGlobalMgr::getInstance()->switchSendMap();
map<int, list<NET_DATA*>*>* psendmap = CGlobalMgr::getInstance()->getBakSendMap();
for (map<int, list<NET_DATA*>*>::iterator itersendmap = psendmap->begin(); itersendmap != psendmap->end(); ++itersendmap)
{
map<int, SOCKET_SET*>::iterator itersockmap = m_socketmap.find(itersendmap->first);
if (itersockmap == m_socketmap.end() || itersockmap->second == NULL || itersockmap->second->key == NULL)
{
LOG(_ERROR_, "CEpollThread::doEpollEvent() error, m_socketmap.find(fd) failed");
m_delsendfdlist.push_back(itersendmap->first);
continue;
}
int i = 0;
for (; i < WSA_MAXIMUM_WAIT_EVENTS; ++i)
{
if (itersendmap->first == m_sockArray[i])
break;
}
if (i > WSA_MAXIMUM_WAIT_EVENTS)
{
LOG(_ERROR_, "CEpollThread::doEpollEvent() error, m_sockArray[i] can't find(fd) failed");
m_delsendfdlist.push_back(itersendmap->first);
continue;
}
if (::WSAEventSelect(m_sockArray[i], m_eventArray[i], FD_WRITE) == SOCKET_ERROR)
{
LOG(_ERROR_, "CWSAThread::doEpollEvent() error, WSAEventSelect() failed, listen fd=%d, error=%ld", m_listenfd, WSAGetLastError());
break;
}
}
for (list<int>::iterator iterdelsendfdlist = m_delsendfdlist.begin(); iterdelsendfdlist != m_delsendfdlist.end(); ++iterdelsendfdlist)
{
deleteSendMsgFromSendMap(*iterdelsendfdlist);
}
m_delsendfdlist.clear();
doKeepaliveTimeout();
doSendKeepaliveToServer();
}//end while
}
