void ReceiveThread(int* s, int id)
{
bool paskafix = true;
char* buf = (char*)malloc(sizeof(int));
recvThreadMutex.lock();
while (1)
{
if(purkka != 0)
{
memset((void*)buf, 0, sizeof(int));
if (recv(*s, buf, sizeof(int), 0) == SOCKET_ERROR)
{
int errsave = errno;
printf("recvfrom(...) failed! Error code : %d\n", errsave);
free(buf);
return;
}
if (paskafix)
{
recvThreadMutex.unlock();
paskafix = false;
}
ParseMessage(buf, *s, id);
}
else
return;
}
}
/**
* Handle as message from JavaScript on the worker thread.
*
* @param[in] message The message to parse and handle.
*/
static void HandleMessage(struct PP_Var message)
{
const char *function_name,*error;
struct PP_Var params,result_var;
if ( ParseMessage(message, &function_name, ¶ms) != 0 )
{
PostMessage("Error: Unable to parse message");
return;
}
HandleFunc function = GetFunctionByName(function_name);
if ( function == 0 )
{
PostMessage("Error: Unknown function \"%s\"", function_name); // Function name wasn't found.
return;
}
// Function name was found, call it.
int result = (*function)(params, &result_var, &error);
if ( result != 0 )
{
if ( error != NULL )
{
PostMessage("Error: \"%s\" failed: %s.", function_name, error);
free((void*)error);
}
else PostMessage("Error: \"%s\" failed.", function_name);
return;
}
// Function returned an output dictionary. Send it to JavaScript.
g_ppb_messaging->PostMessage(g_instance, result_var);
g_ppb_var->Release(result_var);
}
void RemoteClient::IncomingData() {
while (client_->bytesAvailable()) {
if (!reading_protobuf_) {
// Read the length of the next message
QDataStream s(client_);
s >> expected_length_;
// Receiving more than 128mb is very unlikely
// Flush the data and disconnect the client
if (expected_length_ > 134217728) {
qLog(Debug) << "Received invalid data, disconnect client";
qLog(Debug) << "expected_length_ =" << expected_length_;
client_->close();
return;
}
reading_protobuf_ = true;
}
// Read some of the message
buffer_.write(
client_->read(expected_length_ - buffer_.size()));
// Did we get everything?
if (buffer_.size() == expected_length_) {
// Parse the message
ParseMessage(buffer_.data());
// Clear the buffer
buffer_.close();
buffer_.setData(QByteArray());
buffer_.open(QIODevice::ReadWrite);
reading_protobuf_ = false;
}
}
int DiskoveryListener::svc()
{
core_.LogMessage(&device_, "Starting Diskovery Listener Thread", true);
char answer[MM::MaxStrLength];
std::string term = "\r\n";
int ret = DEVICE_OK;
while (!stop_)
{
ret = core_.GetSerialAnswer(&device_, port_.c_str(), MM::MaxStrLength, answer, term.c_str());
// serial timeout should be set to a number larger than 5 seconds
// and a timeout indicates that the device is not here.
// TODO: communicate this fact back to the adapter
if (ret == DEVICE_SERIAL_TIMEOUT)
{
}
if (ret == DEVICE_OK) {
ParseMessage(answer);
} else
{
// this can only be bad
// TODO: communicate the bad situation and bail
}
}
return 0;
}
void service::ParseIRCCommand( QString command ) {
QStringList section = command.split(" ");
if( section[0] == "PING" ) {
qDebug() << "Received PING, sending PONG";
server->send( QString("PONG :tmi.twitch.tv\r\n") );
} else {
ParseMessage( section );
}
}
void ParsePacket(const char *buf, size_t len) {
// uint16_t hdr_len = read16(buf);
int count = read8(buf + 2);
uint32_t seqno = read32(buf + 4);
buf += 8;
for (int i = 0; i < count; ++i) {
uint8_t msg_len = read8(buf);
ParseMessage(seqno + i, buf);
buf += msg_len;
}
}
bool ParseMessage(const std::string& msg_json, IMMessage& message)
{
Json::Value values;
Json::Reader reader;
if (reader.parse(msg_json, values) && values.isObject())
{
ParseMessage(values, message);
return true;
}
return false;
}
size_t ParseStream(const char *buf, size_t len) {
size_t i = 0;
while (i < len) {
int msg_len = read8(buf + i);
if (i + msg_len > len) {
break;
}
ParseMessage(0, buf + i);
i += msg_len;
}
return i;
}
static uint8_t RAPP_OnPacketRx(RPHY_PacketDesc *packet) {
uint8_t size;
uint8_t *data;
RAPP_MSG_Type type;
RNWK_ShortAddrType srcAddr;
type = (RAPP_MSG_Type)RAPP_BUF_TYPE(packet->phyData);
size = RAPP_BUF_SIZE(packet->phyData);
data = RAPP_BUF_PAYLOAD_START(packet->phyData);
srcAddr = RNWK_BUF_GET_SRC_ADDR(packet->phyData);
return ParseMessage(type, size, data, srcAddr, packet);
}
BOOL SipMessageCallback(char *string, char *ip, int port)
{
MESSAGE *message = CreateMessage();
SetMessageAddr(message, ip);
SetMessagePort(message, port);
if (ParseMessage(string, message) < 0) {
return FALSE;
}
return SipMessageInput(message);
}
TEST(TryingMessageBuildTestGroup, TryingMessageCallIdTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct CallIdHeader *inviteCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, invite);
struct CallIdHeader *tryingCallId = (struct CallIdHeader *)MessageGetHeader(HEADER_NAME_CALLID, trying);
CHECK_TRUE(CallIdHeaderMatched(inviteCallId, tryingCallId));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageCSeqTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct CSeqHeader *inviteCSeq = (struct CSeqHeader *)MessageGetHeader(HEADER_NAME_CSEQ, invite);
struct CSeqHeader *tryingCSeq = (struct CSeqHeader *)MessageGetHeader(HEADER_NAME_CSEQ, trying);
CHECK_TRUE(CSeqHeadersMatched(inviteCSeq, tryingCSeq));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageFromHeaderTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
CONTACT_HEADER *inviteFrom = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_FROM, invite);
CONTACT_HEADER *tryingFrom = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_FROM, trying);
CHECK_TRUE(ContactHeaderMatched(inviteFrom, tryingFrom));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageViaTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
VIA_HEADER *inviteVia = (VIA_HEADER *)MessageGetHeader(HEADER_NAME_VIA, invite);
VIA_HEADER *tryingVia = (VIA_HEADER *)MessageGetHeader(HEADER_NAME_VIA, trying);
CHECK_TRUE(ViaHeaderMatched(inviteVia, tryingVia));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
bool ParseReceiveMessage(const std::string& msg_json, IMMessage& message)
{
Json::Value values;
Json::Reader reader;
if (reader.parse(msg_json, values) && values.isObject())
{
message.rescode_ = (NIMResCode)values[kNIMMsgKeyLocalRescode].asUInt();
message.feature_ = (NIMMessageFeature)values[kNIMMsgKeyLocalMsgFeature].asUInt();
ParseMessage(values[kNIMMsgKeyLocalReceiveMsgContent], message);
return true;
}
return false;
}
TEST(TryingMessageBuildTestGroup, TryingMessageToWithTagTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE_WITH_TO_TAG, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
CONTACT_HEADER *inviteTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, invite);
CONTACT_HEADER *tryingTo = (CONTACT_HEADER *)MessageGetHeader(HEADER_NAME_TO, trying);
CHECK_TRUE(ContactHeaderMatched(inviteTo, tryingTo));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
TEST(TryingMessageBuildTestGroup, TryingMessageStatusLineTest)
{
MESSAGE *invite = CreateMessage();
ParseMessage(INCOMMING_INVITE_MESSAGE, invite);
MESSAGE *trying = BuildResponse(invite, STATUS_CODE_TRYING);
struct StatusLine *status = MessageGetStatusLine(trying);
CHECK_TRUE(status != NULL);
STRCMP_EQUAL(SIP_VERSION, StatusLineGetSipVersion(status));
CHECK_EQUAL(100, StatusLineGetStatusCode(status));
STRCMP_EQUAL("Trying", StatusLineGetReasonPhrase(status));
DestroyMessage(&trying);
DestroyMessage(&invite);
}
/** Handle as message from JavaScript on the worker thread.
*
* @param[in] message The message to parse and handle. */
static void HandleMessage(char* message) {
char* function_name;
char* params[MAX_PARAMS];
size_t num_params;
char* output = NULL;
int result;
HandleFunc function;
num_params = ParseMessage(message, &function_name, ¶ms[0], MAX_PARAMS);
function = GetFunctionByName(function_name);
if (!function) {
/* Function name wasn't found. Error. */
ppb_messaging_interface->PostMessage(
g_instance, PrintfToVar("Error: Unknown function \"%s\"", function));
}
/* Function name was found, call it. */
result = (*function)(num_params, ¶ms[0], &output);
if (result != 0) {
/* Error. */
struct PP_Var var;
if (output != NULL) {
var = PrintfToVar("Error: Function \"%s\" returned error %d. "
"Additional output: %s",
function_name,
result,
output);
free(output);
} else {
var = PrintfToVar(
"Error: Function \"%s\" returned error %d.", function_name, result);
}
/* Post the error to JavaScript, so the user can see it. */
ppb_messaging_interface->PostMessage(g_instance, var);
return;
}
if (output != NULL) {
/* Function returned an output string. Send it to JavaScript. */
ppb_messaging_interface->PostMessage(g_instance, CStrToVar(output));
free(output);
}
}
int main(int argc, char **argv) {
char data[512];
char host[4];
init(argc, argv);
pthread_mutex_init(&client_lock, NULL);
pthread_create(&data_thread, NULL, DataSender, NULL);
while (true) {
char type;
char client;
int direction;
int port;
if (Listen(data))
continue;
ParseMessage(data, &type, &client);
switch(type) {
case CONNECT:
ParseConnect(data, host, &port, &client);
pthread_mutex_lock(&client_lock);
DoConnect(host, port);
pthread_mutex_unlock(&client_lock);
break;
case DISCONNECT:
pthread_mutex_lock(&client_lock);
DoDisconnect(client);
pthread_mutex_unlock(&client_lock);
break;
case ENGINE:
ParseEngine(data, &direction);
DoEngine(client, direction);
break;
case TURN:
ParseTurn(data, &direction);
DoTurn(client, direction);
break;
default:
fprintf(stderr, "Unknown message:\t%d\n", &type);
break;
}
}
}
static void HandleMessage(char* message) {
char* function_name;
char* params[MAX_PARAMS];
size_t num_params;
char* output = NULL;
int result;
HandleFunc function;
num_params = ParseMessage(message, &function_name, ¶ms[0], MAX_PARAMS);
function = GetFunctionByName(function_name);
if (!function) {
ppb_messaging_interface->PostMessage(
g_instance,
PrintfToVar("Error: Unknown function \"%s\"", function_name));
return;
}
result = (*function)(num_params, ¶ms[0], &output);
if (result != 0) {
struct PP_Var var;
if (output != NULL) {
var = PrintfToVar("Error: \"%s\" failed: %d: %s.", function_name,
result, output);
free(output);
} else {
var = PrintfToVar(
"Error: \"%s\" failed: %d.", function_name, result);
}
ppb_messaging_interface->PostMessage(g_instance, var);
return;
}
if (output != NULL) {
ppb_messaging_interface->PostMessage(g_instance, CStrToVar(output));
free(output);
}
}
int CSubscriptionMgr::RefreshMailbox(TerminalState &terminalState, vector<MsgStruct> &msgStruct)
{
//获取请求地址
string url = m_Interface->GetUrl();
if (url.empty())
{
TEX0_LOG_ERROR("RefreshMailbox::Get server url failed, please login first");
return TEX0_URL_EMPTY;
}
url.append("/action.cgi?ActionID=WEB_GetMailboxDataAPI");
//设置请求参数
REQUEST_OPTIONS request;
request.strUrl = url;
request.uiTimeOut = TIMEOUT_2S;
request.uiVersion = VERSION_1_1;
request.uiReqMode = MODE_POST;
request.ReqHeader.push_back(m_Interface->GetCookie());
//发送请求
string rspBody;
string rspHeader;
int ret = eSDK_HTTP_SendRequest(request, rspBody, rspHeader);
if (RET_OK != ret)
{
TEX0_LOG_ERROR("RefreshMailbox::Send http request failed, url[%s] time out[%d] http version[%d] mode[%d] data[%s], error code[%d]",
request.strUrl.c_str(), request.uiTimeOut, request.uiVersion, request.uiReqMode, request.strReqData.c_str(), ret);
return TEX0_SEND_REQUEST_FAILED;
}
//解析响应
bool success;
string data;
int id, code;
string paras;
ret = ParseResponse(rspBody, success, data, id, code, paras);
if (TEX0_SUCCESS != ret)
{
TEX0_LOG_ERROR("RefreshMailbox::Invalid response, not json form or missing something[%s]", rspBody.c_str());
return ret;
}
return success ? ParseMessage(data, terminalState, msgStruct) : code;
}
/**
\brief Read feedback from 2FOC
\pre */
static void read_feedback(void *arg, long period)
{
int nbytes=0;
int n;
FOC_data_t *focrxdata = NULL;
// point to first axis data
focrxdata = arg;
rmw = RD(map_MiscAddress + PMODA_OUTREG);
rmw = rmw | 0x01;
rmw = rmw & 0xFD;
WR(map_MiscAddress + PMODA_OUTREG, rmw);
// for each FOC axis
for (n = 0; n < num_chan; n++) {
// procede to periodic CAN data exchange only if FOC in 'enable operation'
if( false != FOCAxisIsOperationEnable[n] ) {
// parse all messages (eventually) in the rx queue
do {
// read data (hopefully not-blocking)
nbytes = read (sock[n], &rxframe[n], sizeof (struct can_frame));
if (nbytes >= 0) {
// parse packet type, mask away CAN address
if ( 0 != ParseMessage(&(rxframe[n]), n, focrxdata) ){
//exit(-1);
}
}
} while ( 0 < nbytes );
}
// move to next axis
focrxdata++;
}
rmw = rmw & 0xFE;
WR(map_MiscAddress + PMODA_OUTREG, rmw);
}
/**
* Handle as message from JavaScript on the worker thread.
*
* @param[in] message The message to parse and handle.
*/
static void HandleMessage(struct PP_Var message) {
pp_post_message("debug", "Received a message.");
char* command;
struct PP_Var params;
if (ParseMessage(message, &command, ¶ms)) {
pp_post_message("error", "Unable to parse message.");
return;
}
if (!strcmp(command, "k2pdfopt")) {
pp_post_message("debug", "Received k2pdfopt command.");
int numargs = g_ppb_var_array->GetLength(params);
int argc = numargs + 1;
char **argv;
argv = malloc(argc * sizeof(char*));
argv[0] = command;
for (int i=0; i<numargs; i++) {
struct PP_Var argvar = g_ppb_var_array->Get(params, i);
argv[i+1] = VarToCStr(argvar);
g_ppb_var->Release(argvar);
}
pp_post_message("status", "start");
k2pdfoptmain(numargs+1, argv);
pp_post_message("status", "done");
// Fre argv[1...numargs+1]; argv[0] will be freed below by calling free(command)
for (int i=1; i<numargs+1; i++) {
free(argv[i]);
}
free(argv);
}
free(command);
}
void
Client::Receive()
{
SocketMessage msg;
try {
msg = FetchMessage();
} catch (Exception& e) {
if (e.ErrorNumber()==11000) // client has been disconnected
throw Exception(__PRETTY_FUNCTION__, "Some other socket asked for this client's disconnection. Obtemperating...", Fatal);
}
if (msg.GetKey()==MASTER_DISCONNECT) {
throw Exception(__PRETTY_FUNCTION__, "Master disconnected!", Fatal);
}
else if (msg.GetKey()==OTHER_CLIENT_DELETED) {
throw Exception(__PRETTY_FUNCTION__, "Some other socket asked for this client's disconnection. Obtemperating...", Fatal);
}
else if (msg.GetKey()==GET_CLIENT_TYPE) {
Send(SocketMessage(CLIENT_TYPE, static_cast<int>(GetType())));
}
else if (msg.GetKey()==PING_CLIENT) {
std::ostringstream os; os << "Pong. My name is " << GetSocketId() << " and I feel fine, thank you!";
Send(SocketMessage(PING_ANSWER, os.str()));
PrintInfo("Got a ping, answering...");
}
else if (msg.GetKey()==CLIENTS_LIST) {
VectorValue vals = msg.GetVectorValue();
int i = 0; std::ostringstream o; o << "List of members on the socket:\n\t";
for (VectorValue::const_iterator v=vals.begin(); v!=vals.end(); v++, i++) {
if (i!=0) o << ", ";
o << *v;
}
PrintInfo(o.str());
}
else {
ParseMessage(msg);
}
}
Boolean OSCBeProductiveWhileWaiting(void) {
/* Here's where we could be clever if an allocation fails.
(I.e., if we're out of QD objects, we should avoid
parsing bundles.) The code isn't that smart yet. */
queuedData *qd;
if (globals.timePassed) {
OSCQueueScanStart(globals.TheQueue);
}
while (1) {
qd = (queuedData *) OSCQueueScanNext(globals.TheQueue);
if (qd == 0) return FALSE;
if (qd->type == BUNDLE) {
ParseBundle(qd);
OSCQueueRemoveCurrentScanItem(globals.TheQueue);
return TRUE;
} else {
if (qd->data.message.callbacks == NOT_DISPATCHED_YET) {
if (ParseMessage(qd) == FALSE) {
/* Problem with this message - flush it. */
DropMessage(qd->data.message.messageName,
qd->data.message.length,
qd->myPacket);
OSCQueueRemoveCurrentScanItem(globals.TheQueue);
PacketRemoveRef(qd->myPacket);
FreeQD(qd);
}
return TRUE;
}
/* The item we found was an already-dispatched message,
so continue the while loop. */
}
}
}
void ReceiveThread(int s, int recvLength)
{
bool paskafix = true;
char* buf = (char*)malloc(recvLength);
recvThreadMutex.lock();
while (1)
{
if (recv(s, buf, recvLength, 0) == SOCKET_ERROR)
{
printf("recvfrom(...) failed! Error code : %d\n", WSAGetLastError());
recvThreadMutex.unlock();
return;
}
if (paskafix)
{
recvThreadMutex.unlock();
paskafix = false;
}
ParseMessage(buf);
}
}
JaMessage CJabloDongle::ParseMessage(std::string msgstring) {
JaMessage msg;
std::stringstream msgstream(msgstring);
std::string msgtok;
int tokNum;
bool singlePlaceTemp = false;
if(msgstring == "\nOK\n") {
msg.mtype = JMTYPE_OK;
}
else if(msgstring == "\nERROR\n") {
msg.mtype = JMTYPE_ERR;
}
else if(!msgstring.compare(0, 16, "\nTURRIS DONGLE V") && (msgstring.length() > 17)) {
msg.mtype = JMTYPE_VERSION;
msg.version = std::string(msgstring.c_str() + 16);
msg.version.erase(msg.version.size() - 1);
}
else if(!msgstring.compare(0, 6, "\nSLOT:")) {
if(sscanf(msgstring.c_str(), "\nSLOT:%u [%u]\n", &msg.slot_num, &msg.slot_val) == 2) {
msg.mtype = JMTYPE_SLOT;
}
else if(sscanf(msgstring.c_str(), "\nSLOT:%u [--------]\n", &msg.slot_num) == 1) {
msg.mtype = JMTYPE_SLOT;
msg.slot_val = 0;
}
}
else {
tokNum = 0;
while(msgstream >> msgtok) {
if(tokNum == 0) {
if(sscanf(msgtok.c_str(), "[%u]", &msg.did) != 1)
break;
}
#ifdef OLDFW
else if(tokNum == 1) {
if(sscanf(msgtok.c_str(), "ID:%u", &msg.mid) != 1) {
msg.mid = -1;
if(msgtok.compare("ID:---") != 0)
break;
}
}
#endif
#ifdef OLDFW
else if(tokNum == 2) {
#else
else if(tokNum == 1) {
#endif
msg.devmodel = msgtok;
}
#ifdef OLDFW
else if(tokNum == 3) {
#else
else if(tokNum == 2) {
#endif
if(msgtok == "SENSOR") {
msg.mtype = JMTYPE_SENSOR;
}
else if(msgtok == "TAMPER") {
msg.mtype = JMTYPE_TAMPER;
}
else if(msgtok == "BEACON") {
msg.mtype = JMTYPE_BEACON;
}
else if(msgtok == "BUTTON") {
msg.mtype = JMTYPE_BUTTON;
}
else if(msgtok == "ARM:1") {
msg.mtype = JMTYPE_ARM;
}
else if(msgtok == "ARM:0") {
msg.mtype = JMTYPE_DISARM;
}
else if(sscanf(msgtok.c_str(), "SET:%f", &msg.temp) == 1) {
msg.mtype = JMTYPE_SET;
}
else if(sscanf(msgtok.c_str(), "INT:%f", &msg.temp) == 1) {
msg.mtype = JMTYPE_INT;
}
else if(msgtok == "SET:") {
msg.mtype = JMTYPE_SET;
singlePlaceTemp = true;
}
else if(msgtok == "INT:") {
msg.mtype = JMTYPE_INT;
singlePlaceTemp = true;
}
else {
msg.mtype = JMTYPE_UNDEF;
}
}
#ifdef OLDFW
else if((tokNum == 4) && (singlePlaceTemp == true)) {
#else
else if((tokNum == 3) && (singlePlaceTemp == true)) {
#endif
if(sscanf(msgtok.c_str(), "%f", &msg.temp) != 1) {
msg.temp = 0;
msg.mtype = JMTYPE_UNDEF;
}
singlePlaceTemp = false;
}
else {
if(sscanf(msgtok.c_str(), "LB:%d", &msg.lb) != 1)
if(sscanf(msgtok.c_str(), "ACT:%d", &msg.act) != 1)
sscanf(msgtok.c_str(), "BLACKOUT:%d", &msg.blackout);
}
tokNum++;
}
}
return msg;
}
void CJabloDongle::ProcessMessage(JaMessage jmsg) {
Ja_device *jdev;
if((jmsg.mtype != JMTYPE_SLOT) && (jmsg.mtype != JMTYPE_VERSION) && (jmsg.mtype != JMTYPE_OK) && (jmsg.mtype != JMTYPE_ERR)) {
_log.Log(LOG_STATUS, "Received message of type %s from device %d (%s)", jmsg.MtypeAsString().c_str(), jmsg.did, jmsg.devmodel.c_str());
}
switch(jmsg.mtype) {
case JMTYPE_SLOT: {
SlotReadCallback(jmsg.slot_num, jmsg.slot_val);
readSlotsCond.notify_one();
break;
}
case JMTYPE_VERSION: {
ProbeCallback(jmsg.version);
probeCond.notify_one();
break;
}
case JMTYPE_SENSOR: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_SENSOR";
SendSwitch(jmsg.did, SUBSWITCH_SENSOR, (jmsg.lb == 1) ? 0 : 100, (jmsg.act == -1) ? 1 : jmsg.act, 0, dev_desc.str());
break;
}
case JMTYPE_TAMPER: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_TAMPER";
SendSwitch(jmsg.did, SUBSWITCH_TAMPER, (jmsg.lb == 1) ? 0 : 100, (jmsg.act == -1) ? 1 : jmsg.act, 0, dev_desc.str());
break;
}
case JMTYPE_BUTTON: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_BUTTON";
SendSwitch(jmsg.did, SUBSWITCH_BUTTON, (jmsg.lb == 1) ? 0 : 100, (jmsg.act == -1) ? 1 : jmsg.act, 0, dev_desc.str());
break;
}
case JMTYPE_ARM:
case JMTYPE_DISARM: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_ARM";
SendSwitch(jmsg.did, SUBSWITCH_ARM, (jmsg.lb == 1) ? 0 : 100, (jmsg.mtype == JMTYPE_ARM) ? 1 : 0, 0, dev_desc.str());
break;
}
case JMTYPE_SET: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_SET";
SendSetPointSensor(jmsg.did, (jmsg.lb == 1) ? 0 : 100, jmsg.temp, dev_desc.str());
break;
}
case JMTYPE_INT: {
std::stringstream dev_desc;
dev_desc << jmsg.devmodel << "_" << std::setfill('0') << jmsg.did << "_INT";
SendTempSensor(jmsg.did, (jmsg.lb == 1) ? 0 : 100, jmsg.temp, dev_desc.str());
break;
}
}
}
void CJabloDongle::ReadCallback(const char *data, size_t len)
{
unsigned char *mf, *ml;
unsigned char *bufptr;
unsigned char msgline[128];
JaMessage jmsg;
bool messagesInBuffer;
boost::lock_guard<boost::mutex> l(readQueueMutex);
if (!m_bIsStarted)
return;
if (!m_bEnableReceive)
return;
//receive data to buffer
if((m_bufferpos + len) < sizeof(m_buffer)) {
memcpy(m_buffer + m_bufferpos, data, len);
m_bufferpos += len;
}
else {
_log.Log(LOG_STATUS, "JabloDongle: Buffer Full");
}
//m_buffer[m_bufferpos] = '\0';
//_log.Log(LOG_STATUS, "Pokus received: %s", m_buffer);
do {
messagesInBuffer = false;
//find sync sequence \n[
bufptr = m_buffer;
while((mf = (unsigned char*)strchr((const char*)bufptr, '\n')) != NULL) {
//check if character after newline is printable character
if((mf[1] > 32 && (mf[1] < 127)))
break;
bufptr = mf + 1;
}
//is there at least 1 whole msg in buffer?
if((mf != NULL) && (strlen((char*)mf) > 2)) {
ml = (unsigned char*)strchr((char*)mf + 2, '\n');
if(ml != NULL)
messagesInBuffer = true;
}
if(messagesInBuffer) {
//copy single message into separate buffer
memcpy(msgline, mf, ml - mf + 1);
msgline[ml - mf + 1] = '\0';
//shift message buffer and adjust end pointer
memmove(m_buffer, ml + 1, m_bufferpos);
m_bufferpos -= (ml - m_buffer) + 1;
//process message
//_log.Log(LOG_STATUS, "Received line %s", msgline);
jmsg = ParseMessage(std::string((char*)msgline));
#ifdef OLDFW
//quick and dirty hack for msg deduplication, will be removed in final version
if((jmsg.mid == -1) && ((jmsg.mtype != last_mtype) || ((jmsg.mtype != JMTYPE_SET) && (jmsg.mtype != JMTYPE_INT)))) {
ProcessMessage(jmsg);
last_mtype = jmsg.mtype;
}
else if(jmsg.mid != last_mid) {
ProcessMessage(jmsg);
last_mid = jmsg.mid;
}
#else
ProcessMessage(jmsg);
#endif
}
}while(messagesInBuffer);
}
void CJabloDongle::SendTempSensor(int NodeID, const int BatteryLevel, const float temperature, const std::string &defaultname)
{
bool bDeviceExits = true;
std::stringstream szQuery;
std::vector<std::vector<std::string> > result;
NodeID &= 0xFFFF; //TEMP packet has only 2 bytes for ID.
char szTmp[30];
sprintf(szTmp, "%d", (unsigned int)NodeID);
szQuery << "SELECT Name FROM DeviceStatus WHERE (HardwareID==" << m_HwdID << ") AND (DeviceID=='" << szTmp << "') AND (Type==" << int(pTypeTEMP) << ") AND (Subtype==" << int(sTypeTemperature) << ")";
result = m_sql.query(szQuery.str());
if (result.size() < 1)
{
bDeviceExits = false;
}
RBUF tsen;
memset(&tsen, 0, sizeof(RBUF));
tsen.TEMP.packetlength = sizeof(tsen.TEMP) - 1;
tsen.TEMP.packettype = pTypeTEMP;
tsen.TEMP.subtype = sTypeTemperature;
tsen.TEMP.battery_level = BatteryLevel;
tsen.TEMP.rssi = 12;
tsen.TEMP.id1 = (NodeID & 0xFF00) >> 8;
tsen.TEMP.id2 = NodeID & 0xFF;
tsen.TEMP.tempsign = (temperature >= 0) ? 0 : 1;
int at10 = round(temperature*10.0f);
tsen.TEMP.temperatureh = (BYTE)(at10 / 256);
at10 -= (tsen.TEMP.temperatureh * 256);
tsen.TEMP.temperaturel = (BYTE)(at10);
sDecodeRXMessage(this, (const unsigned char *)&tsen.TEMP);
if (!bDeviceExits)
{
//Assign default name for device
szQuery.clear();
szQuery.str("");
szQuery << "UPDATE DeviceStatus SET Name='" << defaultname << "' WHERE (HardwareID==" << m_HwdID << ") AND (DeviceID=='" << szTmp << "') AND (Type==" << int(pTypeTEMP) << ") AND (Subtype==" << int(sTypeTemperature) << ")";
m_sql.query(szQuery.str());
}
}
bool
DirectParser::Read (DirectMessage & msg)
{
msg.Clear ();
if (!bufLock.tryLock (5000)) {
qDebug () << "WARNING: Mutex locked 5 seconds, giving up";
return false;
}
QXmlStreamReader xread (&inbuf);
QXmlStreamReader::TokenType tokt;
bool finished (false);
bool complete (false);
bool good (false);
bool badData (false);
QString topname;
QString bottomtag;
QString version;
qint64 offset (0);
while (!finished) {
tokt = ReadNext (xread);
offset = xread.characterOffset ();
qDebug () << " Direct token " << xread.tokenString();
switch (tokt) {
case QXmlStreamReader::NoToken :
qDebug () << " no token found";
finished = true; complete = false; good = false;
lastErr = Proto_EmptyInput;
break;
case QXmlStreamReader::Invalid :
qDebug () << " bad token";
qDebug () << " text until here: " << inbuf.buffer().left(offset);
finished = true; complete = false; good = false;
lastErr = Proto_BadTag;
badData = true;
break;
case QXmlStreamReader::StartElement:
topname = xread.name().toString().toLower();
if (topname == oldTopTag) {
ParseOld (xread, msg, offset, complete, good);
msg.SetAttribute ("version","0.1");
} else if (topname == topTag) {
version = xread.documentVersion ().toString();
msg.SetAttribute ("version",version);
ParseMessage (xread, msg, offset, complete, good);
} else {
qDebug () << " topname unknown: " << topname;
finished = true; complete = false; good = false;
lastErr = Proto_WrongProtocol;
}
break;
case QXmlStreamReader::EndElement:
bottomtag = xread.name().toString().toLower();
if (bottomtag == topname) {
finished = true;
}
break;
case QXmlStreamReader::EndDocument :
finished = true;
break;
case QXmlStreamReader::Characters:
break;
case QXmlStreamReader::StartDocument:
case QXmlStreamReader::Comment:
case QXmlStreamReader::DTD:
case QXmlStreamReader::EntityReference:
case QXmlStreamReader::ProcessingInstruction:
break;
default:
qDebug () << " unknown token type " << tokt;
lastErr = Proto_Unknown;
finished = true; complete = false; good = false;
break;
}
}
if (good && complete) {
/// we have consumed a message, so get rid of the raw data
/// so we can read the next message next time
qDebug () << " trailing token " << xread.tokenString ();
while (!xread.atEnd() && xread.tokenType() != QXmlStreamReader::EndDocument) {
xread.readNext();
qDebug () << " consumed " << xread.tokenString ();
}
qDebug () << " remove " << offset << " bytes from buffer: ";
qDebug () << inbuf.buffer().left(offset);
inbuf.buffer().remove (0,offset+1);
inbuf.seek (0);
} else {
msg.Clear ();
}
qDebug () << " after DirectParser::Read buffer has [[" << inbuf.buffer() << "]]";
qDebug () << " token " << xread.tokenString() << " error " << xread.error();
if (!good) {
if (xread.error () == QXmlStreamReader::PrematureEndOfDocumentError) {
complete = false;
good = true;
}
}
lastComplete = complete;
lastGood = good;
bufLock.unlock ();
return good && complete;
}
bool Talk::ParseIMMessage(const std::string& json_msg, IMMessage& msg)
{
return ParseMessage(json_msg, msg);
}
Boolean OSCInvokeMessagesThatAreReady(OSCTimeTag now) {
queuedData *x;
OSCTimeTag thisTimeTag;
globals.lastTimeTag = now;
globals.timePassed = TRUE;
thisTimeTag = OSCQueueEarliestTimeTag(globals.TheQueue);
if (OSCTT_Compare(thisTimeTag, now) > 0) {
/* No messages ready yet. */
return FALSE;
}
#ifdef DEBUG
printf("OSCInvokeMessagesThatAreReady(%llx) - yes, some are ready; earliest %llx\n", now, thisTimeTag);
#endif
while (OSCTT_Compare(thisTimeTag, OSCQueueEarliestTimeTag(globals.TheQueue)) == 0) {
x = (queuedData *) OSCQueueRemoveEarliest(globals.TheQueue);
#ifdef DEBUG
printf("...Just removed earliest entry from queue: %p, TT %llx, %s\n",
x, x->timetag, x->type == MESSAGE ? "message" : "bundle");
if (x->type == MESSAGE) {
printf("...message %s, len %d, args %p, arglen %d, callbacks %p\n",
x->data.message.messageName, x->data.message.length, x->data.message.args,
x->data.message.argLength, x->data.message.callbacks);
} else {
if (x->data.bundle.length == 0) {
printf("...bundle is empty.\n");
} else {
printf("...bundle len %d, first count %d, first msg %s\n",
x->data.bundle.length, *((int *) x->data.bundle.bytes), x->data.bundle.bytes+4);
}
}
PrintPacket(x->myPacket);
#endif
if (x->type == BUNDLE) {
ParseBundle(x);
} else {
if (x->data.message.callbacks == NOT_DISPATCHED_YET) {
if (ParseMessage(x) == FALSE) {
/* Problem with this message - flush it. */
PacketRemoveRef(x->myPacket);
FreeQD(x);
continue;
}
}
CallWholeCallbackList(x->data.message.callbacks,
x->data.message.argLength,
x->data.message.args,
thisTimeTag,
x->myPacket->returnAddrOK ? x->myPacket->returnAddr : 0);
PacketRemoveRef(x->myPacket);
FreeQD(x);
}
}
#ifdef PARANOID
if (OSCTT_Compare(thisTimeTag, OSCQueueEarliestTimeTag(globals.TheQueue)) > 0) {
fatal_error("OSCInvokeMessagesThatAreReady: corrupt queue!\n"
" just did %llx; earliest in queue is now %llx",
thisTimeTag, OSCQueueEarliestTimeTag(globals.TheQueue));
}
#endif
return OSCTT_Compare(OSCQueueEarliestTimeTag(globals.TheQueue), now) <= 0;
}