void RtBroker::issueOrder(BrkLib::BrokerSession &session, Order const& order)
{
BrkLib::RtSession &rtsession = (BrkLib::RtSession &)session;
bool result = true;
CppUtils::String reason;
try {
if (!order.ID_m.isValid()) {
THROW_BRK(getName().c_str(), "exc_InvalidOrderID", "ctx_issueOrder", "");
}
//
if (order.orderType_m & BrkLib::OP_HANDSHAKE) {
// handshake
BrokerResponseOrder brokerResponse;
processHandshake(order, rtsession, brokerResponse);
onBrokerResponseArrived(rtsession, brokerResponse);
}
else if (order.orderType_m & BrkLib::OP_GET_SYMBOL_METAINFO) {
BrokerResponseMetaInfo brespMinfo;
getSymbolMetainfo(order, rtsession, brespMinfo);
onBrokerResponseArrived(rtsession, brespMinfo);
}
else {
engine_m.onNewOrderArrived( order, rtsession );
}
}
catch(CppUtils::Exception& e)
{
result = false;
reason.append("Exception occured: ");
reason += EXC2STR(e);
}
catch(...)
{
result = false;
reason.append("Unknown exception occured");
}
if (!result) {
// TODO
BrokerResponseOrder brokerResponse;
BRK_LOG(getName().c_str(), BRK_MSG_ERROR, RTBROKER, "Error occured: " << reason);
sendErrorResponse(order,rtsession, brokerResponse, -1, reason );
onBrokerResponseArrived(rtsession, brokerResponse);
}
}
/*!
\internal
*/
void QWebSocketPrivate::processData()
{
Q_ASSERT(m_pSocket);
while (m_pSocket->bytesAvailable()) {
if (state() == QAbstractSocket::ConnectingState)
processHandshake(m_pSocket.data());
else
m_dataProcessor.process(m_pSocket.data());
}
}
/*!
\internal
*/
void WebSocket::processData()
{
while (m_pSocket->bytesAvailable())
{
if (state() == QAbstractSocket::ConnectingState)
{
processHandshake(m_pSocket);
}
else
{
m_dataProcessor.process(m_pSocket);
}
}
}
void CrossfireServer::received(wchar_t* msg) {
if (!m_handshakeReceived) {
if (wcsncmp(msg, HANDSHAKE, wcslen(HANDSHAKE)) == 0) {
processHandshake(msg);
m_lastRequestSeq = -1;
} else {
Logger::error("Crossfire content received before handshake, not processing it");
}
return;
}
m_inProgressPacket->append(std::wstring(msg));
std::wstring packet;
do {
wchar_t* parseErrorMessage = NULL;
bool errorMessageRequiresFree = false;
int code = CODE_OK;
packet.clear();
if (m_inProgressPacket->find(HEADER_CONTENTLENGTH) != 0) {
code = CODE_MALFORMED_PACKET;
parseErrorMessage = L"request packet does not start with 'Content-Length:', not processing it";
m_inProgressPacket->clear();
break;
}
size_t endIndex = m_inProgressPacket->find(wchar_t('\r'));
if (endIndex == std::wstring::npos) {
code = CODE_MALFORMED_PACKET;
parseErrorMessage = L"request packet does not contain '\r', not processing it";
m_inProgressPacket->clear();
break;
}
size_t headerLength = wcslen(HEADER_CONTENTLENGTH);
std::wstring lengthString = m_inProgressPacket->substr(headerLength, endIndex - headerLength);
int lengthValue = _wtoi(lengthString.c_str());
if (!lengthValue) {
code = CODE_MALFORMED_PACKET;
parseErrorMessage = L"request packet does not have a valid 'Content-Length' value, not processing it";
m_inProgressPacket->clear();
break;
}
if (m_inProgressPacket->find(L"\r\n", endIndex) != endIndex) {
code = CODE_MALFORMED_PACKET;
parseErrorMessage = L"request packet does not follow initial '\\r' with '\\n', not processing it";
m_inProgressPacket->clear();
break;
}
// TODO for now just skip over "tool:" lines, though these should really be validated
size_t toolEnd = m_inProgressPacket->find(L"\r\n\r\n", endIndex);
if (toolEnd == std::wstring::npos) {
code = CODE_MALFORMED_PACKET;
parseErrorMessage = L"request packet does not contain '\\r\\n\\r\\n' to delimit its header, not processing it";
m_inProgressPacket->clear();
break;
}
size_t toolsLength = toolEnd - endIndex;
size_t targetLength = wcslen(HEADER_CONTENTLENGTH) + lengthString.length() + 3 * LINEBREAK_LENGTH + toolsLength + lengthValue;
if (targetLength <= m_inProgressPacket->length()) {
packet.assign(m_inProgressPacket->substr(0, targetLength));
m_inProgressPacket->erase(0, targetLength);
}
if (packet.length()) {
CrossfireRequest* request = NULL;
code = m_processor->parseRequestPacket(&packet, &request, &parseErrorMessage);
if (code != CODE_OK) {
errorMessageRequiresFree = true;
} else {
unsigned int seq = request->getSeq();
if (!(m_lastRequestSeq == -1 || seq == m_lastRequestSeq + 1)) {
// TODO handle out-of-order packets
Logger::log("packet received out of sequence, still processing it");
}
m_lastRequestSeq = seq;
m_processingRequest = true;
if (!performRequest(request)) {
/*
* the request's command was not handled by the server,
* so try to delegate to the specified context, if any
*/
CrossfireContext* context = getRequestContext(request);
if (!context) {
Logger::error("request command was unknown to the server and a valid context id was not provided, not processing it");
} else {
if (!context->performRequest(request)) {
Logger::error("request command was unknown to the server and to the specified context, not processing it");
}
}
}
m_processingRequest = false;
delete request;
/*
* Debugger events may have been received in response to the request that was
* just processed. These events can be sent now that processing of the request
* is complete.
*/
sendPendingEvents();
}
}
if (code) {
CrossfireResponse response;
response.setCode(CODE_MALFORMED_PACKET);
response.setMessage(parseErrorMessage);
if (errorMessageRequiresFree) {
free(parseErrorMessage);
}
Value emptyBody;
emptyBody.setType(TYPE_OBJECT);
response.setBody(&emptyBody);
sendResponse(&response);
}
} while (packet.length() > 0 && m_inProgressPacket->length() > 0);
}
bool Connection::connect(const char *_host, int _port, const char *_username, const char *_password, const char *_database, int *_autoCommit, MYSQL_CHARSETS _charset)
{
m_dbgMethodProgress ++;
if (m_dbgMethodProgress > 1)
{
/*
NOTE: We don't call setError here because it will close the socket worsening the concurrent access error making it impossible to trace */
m_errorMessage = "Concurrent access in connect method";
m_errno = 0;
m_errorType = UME_OTHER;
m_dbgMethodProgress --;
return false;
}
if (m_sockInst != NULL)
{
m_dbgMethodProgress --;
setError ("Socket already connected", 0, UME_OTHER);
return false;
}
m_host = _host ? _host : "localhost";
m_port = _port ? _port : 3306;
m_username = _username ? _username : "";
m_password = _password ? _password : "";
m_database = _database ? _database : "";
m_autoCommit = _autoCommit ? (*_autoCommit) != 0 : false;
m_charset = _charset;
PRINTMARK();
m_sockInst = m_capi.getSocket();
if (m_sockInst == NULL)
{
m_dbgMethodProgress --;
return false;
}
if (m_timeout != -1)
{
if (!setTimeout (m_timeout))
{
m_dbgMethodProgress --;
return false;
}
}
if (!connectSocket())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
if (!recvPacket())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
if (!processHandshake())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
if (!sendPacket())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
m_writer.reset();
if (!recvPacket())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
UINT8 result = m_reader.readByte();
if (result == 0xff)
{
handleErrorPacket();
m_dbgMethodProgress --;
return false;
}
m_reader.skip();
PRINTMARK();
if (_autoCommit)
{
PRINTMARK();
char strTemp[256 + 1];
PRINTMARK();
size_t len = snprintf (strTemp, 256, "SET AUTOCOMMIT = %d", *_autoCommit);
PRINTMARK();
m_writer.reset();
m_writer.writeByte(MC_QUERY);
m_writer.writeBytes ( (void *) strTemp, len);
m_writer.finalize(0);
PRINTMARK();
if (!sendPacket())
{
m_dbgMethodProgress --;
return false;
}
PRINTMARK();
if (!recvPacket())
{
m_dbgMethodProgress --;
return false;
}
m_reader.skip();
}
PRINTMARK();
m_state = QUERY_WAIT;
m_dbgMethodProgress --;
return true;
}
// process an incoming raw VAST message (given its header)
// whatever bytestring received is processed here in its entirety
// returns NET_ID_UNASSIGNED for serious error
bool
VASTnet::processVASTMessage (VASTHeader &header, const char *p, id_t remote_id)
{
// convert byte string to Message object here
Message *msg = new Message (0);
if (msg->deserialize (p, header.msg_size) == 0)
{
printf ("VASTnet::processVASTMessage () deserialize message fail, from [%llu], size: %lu\n", remote_id, header.msg_size);
delete msg;
return false;
}
//printf ("header.type=%d\n", (int)header.type);
switch (header.type)
{
// from a joining host to gateway
case ID_REQUEST:
{
// get actual detected IP for remote host
IPaddr actual_IP;
_manager->getRemoteAddress (remote_id, actual_IP);
// obtain or assign new ID
id_t new_id = processIDRequest (*msg, actual_IP);
// if new ID is accepted or assigned successfully
if (new_id != NET_ID_UNASSIGNED)
{
// switch ID mapping, because the remote host's actual ID could differ from what we locally determine
_manager->switchID (remote_id, new_id);
// send back reply to ID request
// NOTE: we need to use the new ID now, as the id to connection mapping has changed
printf ("ID_ASSIGN remote host [%llu]\n", new_id);
sendMessage (new_id, *msg, true, ID_ASSIGN);
}
else
printf ("processVASTMessage (): BUG new id [%llu] differs from detected id [%llu]\n", new_id, remote_id);
}
break;
// from gateway to joining host
case ID_ASSIGN:
{
processIDAssignment (*msg);
}
break;
// from initiating host to accepting host
case HANDSHAKE:
{
// process handshake message
id_t id = processHandshake (*msg);
// register this connection with its ID if available, or terminate otherwise
if (id == NET_ID_UNASSIGNED)
printf ("VASTnet::processVASTMessage () cannot determine remote host's ID from handshake\n");
else
_manager->switchID (remote_id, id);
//register_conn (remote_id, handler);
}
break;
// regular messages after handshake is successful
case REGULAR:
// TODO: check with net_manager for successful handshake first
{
// return first so Message object would not be de-allocated, unless store was unsuccessful
storeVASTMessage (remote_id, msg);
return true;
}
break;
default:
printf ("VASTnet::processVASTMessage () unreconginzed message\n");
break;
}
// delete temporary message
delete msg;
return true;
}
