ConsoleWindow *
MessageHandler::createConsoleWindow()
{
if (! this->_consoleWindow)
return this->_consoleWindow;
// alloc: QSharedPointer here, plus it sets Qt::WA_DeleteOnClose
// in its constructor.
this->_consoleWindow = new ConsoleWindow(0);
if (! QObject::connect(MessageHandler::p(),
SIGNAL(deliverMessage(QString)),
this->_consoleWindow,
SLOT(printMessage(QString))))
qWarning() << "Could not connect console.";
QObject::connect(this->_consoleWindow,
SIGNAL(destroyed(QObject*)),
this,
SLOT(notifyQObjectDestroyed(QObject*)));
this->_consoleWindow->show();
this->_consoleWindow->raise();
this->_consoleWindow->activateWindow();
foreach(QString m, this->_buffer)
emit deliverMessage(m);
return this->_consoleWindow;
}
void
MessageHandler::message(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
QString message;
message = QDateTime::currentDateTime().toString(Qt::ISODate) + " ";
switch (type)
{
case QtDebugMsg: message += ""; break;
case QtWarningMsg: message += "Warning:"; break;
case QtCriticalMsg: message += "Critical:"; break;
case QtFatalMsg: message += "Fatal:"; break;
default: message += "Message:";
}
message += QString(" ") + msg;
message += QString(" (line #") + context.line + QString(" in ") + context.file + QString(")");
emit deliverMessage(message);
this->_buffer.enqueue(message);
if (this->_buffer.length() > this->_bufferLength)
this->_buffer.dequeue();
std::cerr << message.toStdString() << std::endl;
if (type == QtFatalMsg)
abort();
}
/**
* Since certain setups have proximity responses coming from another message stream
* Those messages should be shunted to this function and processed
*/
virtual void processProxCallback(const ObjectReference&destination,
const Sirikata::Protocol::IProxCall&callInfo,
const void *optionalSerializedProxCall=NULL,
size_t optionalSerializedProxCallSize=0) {
RoutableMessage delivery;
constructMessage(delivery,NULL,&destination,"ProxCall",callInfo,optionalSerializedProxCall,optionalSerializedProxCallSize);
deliverMessage(destination,delivery,NULL,0);
}
DelayedJabberMessage::DelayedJabberMessage(const QString &message, int msec) :
QTimer(),
m_message(message) {
connect(this, SIGNAL(timeout()), SLOT(deliverMessage()));
start(msec);
}
void accept_loop(void* thread_args) {
struct socket *so = (struct socket*) thread_args;
struct socket* rsock;
struct sockaddr sender_addr;
int error, read;
char msg[3];
log_debug("Starting accept_loop");
for (;;) {
error = my_kern_accept(so, &rsock);
if (error) {
log_warn("error in my_kern_accept in accept_loop: %d", error);
if (error == ECONNABORTED)
goto completed;
goto continue_listen;
}
log_debug("A connection accepted in accept_loop");
bzero((char*) msg, sizeof(msg));
//read the message 't' or 'T' or 'r'
error = my_kern_recv(rsock, msg, 1, &read, NULL);
if (error || read != 1) {
log_warn("error in my_kern_recv in accept_loop(1): %d", error);
goto continue_listen;
}
// exit if exit_message received
if (strcmp(msg, MESSAGE_EXIT) == 0) {
log_info("Received exit message: exiting");
goto completed;
}
// read sender address
error = my_kern_recv(rsock, &sender_addr, sizeof(struct sockaddr),
&read, NULL);
if (error || read != sizeof(struct sockaddr)) {
log_warn("error in my_kern_recv in accept_loop(2): %d", error);
goto continue_listen;
}
// process delivered message
deliverMessage(&sender_addr, msg);
continue_listen: //
if (rsock != NULL) {
soclose(rsock);
rsock = NULL;
}
}
completed: // on error
if (error)
log_error("Error in accept_loop [%d]\n", error);
if (so != NULL)
soclose(so);
if (rsock != NULL)
soclose(rsock);
log_info("accept_loop exit");
kthread_exit();
}
int deliverMessageSuid(char *interface, char *message )
{
#ifdef NESSIE
return (deliverMessage( interface, message ));
#else
return(-1);
#endif
}
int sendToVnmr(char *msge )
{
CommPort vnmr_addr = &comm_addr[VNMR_COMM_ID];
#ifdef NESSIE
return( deliverMessage( vnmr_addr->path, msge ) );
#else
SendAsync2( vnmr_addr, msge );
return( 0 );
#endif
}
int main(int argc, char** argv) {
//initialize the node
ros::init(argc, argv, "message_delivery");
ros::NodeHandle privateNode("~");
privateNode.param<std::string>("location",location, /*default*/ "");
privateNode.param<std::string>("message",message,"");
privateNode.param<int32_t>("speed",speed,160);
privateNode.param<std::string>("voice",voice,"default");
privateNode.param<int32_t>("pitch",pitch,50);
if (location.compare("") != 0) {
goToLocation();
deliverMessage();
}
}
void send_data()
{
int i;
int rc;
while(1)
{
for(i = 0; i < num_clients; ++i)
{
if(client_tcp_sock > 0)
{
int shift=0;
char buffer[POWER_UPDATE_SIZE];
struct Power_Update msg;
msg.hdr.type=1;
msg.hdr.len=htons(4);
msg.hdr.nodeID = htonl(100 + i);
memcpy(buffer+shift,&msg.hdr.type,1); shift+=1;
memcpy(buffer+shift,&msg.hdr.len,2); shift+=2;
memcpy(buffer+shift,&msg.hdr.nodeID,4); shift+=4;
uint16_t power = (1000*i) + (rand() % 499);
msg.top_power = htons(power);
memcpy(buffer+shift,&msg.top_power,sizeof(uint16_t)); shift+=2;
power = (1000*i) + (rand() % 499) + 500;
msg.bot_power = htons(power);
memcpy(buffer+shift,&msg.bot_power,sizeof(uint16_t));
//send reading
rc = deliverMessage(buffer, POWER_UPDATE_SIZE, i);
if(rc < 0)
QUIT();
}
}
attempt_recieve();
}
}
int cycle(Client* c, Timer* timer)
{
// read the socket, see what work is due
unsigned short packet_type = readPacket(c, timer);
int len = 0,
rc = SUCCESS;
switch (packet_type)
{
case CONNACK:
case PUBACK:
case SUBACK:
break;
case PUBLISH:
{
MQTTString topicName;
MQTTMessage msg;
if (MQTTDeserialize_publish((unsigned char*)&msg.dup, (int*)&msg.qos, (unsigned char*)&msg.retained, (unsigned short*)&msg.id, &topicName,
(unsigned char**)&msg.payload, (int*)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
goto exit;
deliverMessage(c, &topicName, &msg);
if (msg.qos != QOS0)
{
if (msg.qos == QOS1)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
else if (msg.qos == QOS2)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
if (len <= 0)
rc = FAILURE;
else
rc = sendPacket(c, len, timer);
if (rc == FAILURE)
goto exit; // there was a problem
}
break;
}
case PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = FAILURE;
else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0)
rc = FAILURE;
else if ((rc = sendPacket(c, len, timer)) != SUCCESS) // send the PUBREL packet
rc = FAILURE; // there was a problem
if (rc == FAILURE)
goto exit; // there was a problem
break;
}
case PUBCOMP:
break;
case PINGRESP:
{
INFO("<--PINGRESP");
c->ping_outstanding = 0;
countdown(&c->ping_timer, c->keepAliveInterval);
break;
}
}
rc = keepalive(c);
exit:
if (rc == SUCCESS)
rc = packet_type;
return rc;
}
int procQTask()
{
char ProcId[EXPID_LEN];
char ActiveId[EXPID_LEN];
int proctype,activetype,fgbg,pid;
long fid,ct;
int dCode,eCode;
int activeDcode;
DPRINT(1,"Procproc: start procQtask()(chk processing Q)\n");
if ( procQget(&proctype, ProcId, &fid, &ct, &dCode, &eCode) == -1) /* nothin in Q ? */
return(0);
DPRINT2(1,"Procproc: got Qed Task, Done Code: %d Error Code: %d\n",dCode,eCode);
if (activeQget(&activetype, ActiveId, &fgbg, &pid, &activeDcode ) == -1) /* no active processing */
{
if (ProcExpInfo.ExpInfo == NULL)
{
/* map in new processing Exp Info file */
strncpy(ProcExpInfo.ExpId,ProcId,EXPID_LEN);
ProcExpInfo.ExpId[EXPID_LEN-1] = '\0';
if (mapInExp(&ProcExpInfo) == -1)
{
/* if expinfo file not there skip this processing,
* remove it from the process queue, and get the next
* queued item.
*/
ProcExpInfo.ExpInfo = NULL;
procQdelete(proctype, 1);
procQTask();
return(0);
}
/* Both ProcExpInfo & ActiveExpInfo were NULL so they will be
the same */
/* memcpy((char*)&ActiveExpInfo,(char*)&ProcExpInfo,
sizeof(ExpInfoEntry)); */
UpdateStatus(&ProcExpInfo);
}
else /* is the present ProcExpInfo the right one */
{
if( strcmp(ProcExpInfo.ExpId,ProcId) != 0) /* NO, close one, open new */
{
mapOutExp(&ProcExpInfo);
/* map in new processing Exp Info file */
strncpy(ProcExpInfo.ExpId,ProcId,EXPID_LEN);
ProcExpInfo.ExpId[EXPID_LEN-1] = '\0';
if (mapInExp(&ProcExpInfo) == -1)
{
/* if expinfo file not there skip this processing,
* remove it from the process queue, and get the next
* queued item.
*/
ProcExpInfo.ExpInfo = NULL;
procQdelete(proctype, 1);
procQTask();
return(0);
}
UpdateStatus(&ProcExpInfo);
}
}
BeginProcessing(&ProcExpInfo, proctype, fid, ct, dCode, eCode);
}
else /* There is an active processing going on */
{
if ( (proctype != WEXP_WAIT) && (proctype != WEXP) &&
(proctype != WERR) )
{
/* Only check active queue at WEXP and WERR */
return(0);
}
if (ActiveExpInfo.ExpInfo == NULL)
{
char vnhost[256];
int vnport, vnpid;
/* map in new processing Exp Info file */
strncpy(ActiveExpInfo.ExpId,ActiveId,EXPID_LEN);
ActiveExpInfo.ExpId[EXPID_LEN-1] = '\0';
if (mapInExp(&ActiveExpInfo) == -1)
{
/* If the info file is not there, active element is done */
ActiveExpInfo.ExpInfo = NULL;
activeQdelete(FG,pid);
procQTask();
return(0);
}
if (fgbg == BG)
{
vnpid = pid;
}
else
{
sscanf(ActiveExpInfo.ExpInfo->MachineID, "%s %d %d", vnhost,&vnport,&vnpid);
}
if (( kill(vnpid,0) == -1) && (errno == ESRCH))
{
/* if the process which was doing active processing is gone,
* remove the active element
*/
activeQdelete(FG,pid);
mapOutExp(&ActiveExpInfo);
ActiveExpInfo.ExpInfo = NULL;
unlink(ActiveId); /* delete exp info file */
procQTask();
}
else if (fgbg == BG)
{
/* if the process which was doing active processing is present,
* but in background, just let it continue
*/
mapOutExp(&ActiveExpInfo);
ActiveExpInfo.ExpInfo = NULL;
}
else if (recheckFG)
{
char msgestring[256];
/* if the process which was doing active processing is present,
* send another message for FGcomplt(). If it is still busy,
* the message will be queued and an extra FGcomplt will be
* delivered. It will be ignored.
*/
sprintf(msgestring,"acqsend('%d,0,','check')\n", (int)FGkey);
deliverMessage( ActiveExpInfo.ExpInfo->MachineID, msgestring );
mapOutExp(&ActiveExpInfo);
ActiveExpInfo.ExpInfo = NULL;
/*
* avoid sending a lot of these messages. This gets reset to 1 whenever
* a FG message is received.
*/
recheckFG = 0;
}
}
}
return(0);
}
/*------------------------------------------------------------------------
|
| BeginProcessing()/1
| Fork & Exec a child for BackGround vnmr processing
| Send commands to Vnmr for ForeGround processing
|
| Author Greg Brissey 9/7/94
|
+-----------------------------------------------------------------------*/
void BeginProcessing(ExpInfoEntry* pProcExpInfo, int proctype, long fid, long ct,
int dCode, int eCode)
{
char cmdstring[1024];
char procmsge[1024];
char msgestring[1024];
int process2do;
MSG_Q_ID pAutoMsgQ;
/* we no longer pass the actual command string to Vnmr but just it's
type, and Vnmr will read it's procpar to get the command string
This means for Wexp, Wnt & Wexp will need tobe concatenated
*/
process2do = pProcExpInfo->ExpInfo->ProcMask;
DPRINT3(1,"BeginProcessing(): type = %d dcode: %d ecode: %d \n",
proctype,dCode,eCode);
switch(proctype)
{
case WEXP_WAIT:
case WEXP:
if (pProcExpInfo->ExpInfo->GoFlag != EXEC_GO)
{
process2do &= WHEN_SU_PROC;
eCode = pProcExpInfo->ExpInfo->GoFlag; /* type of su done */
}
else
{
process2do &= WHEN_GA_PROC | WHEN_EXP_PROC | WHEN_NT_PROC;
}
break;
case WERR:
if (dCode == EXP_STARTED)
process2do = 0;
else
process2do &= WHEN_ERR_PROC;
break;
case WFID:
process2do &= (WHEN_NT_PROC | WHEN_GA_PROC);
break;
case WBS:
process2do &= WHEN_BS_PROC;
break;
default:
process2do = 0; /* don't do any */
break;
}
if (++FGkey > 1024)
FGkey = 1L;
DPRINT2(1,"BeginProcessing(): flags: automode= %d vpmode= %d\n",
pProcExpInfo->ExpInfo->ExpFlags & AUTOMODE_BIT,pProcExpInfo->ExpInfo->ExpFlags & VPMODE_BIT);
/*
sprintf(msgestring,"acqcp('exp%d','%s',%d,%d,%d,%d,%lu,%lu,%lu)\n",
pProcExpInfo->ExpInfo->ExpNum,
pProcExpInfo->ExpId,0,0,process2do,(int)FGkey, fid, ct);
*/
if ( (pProcExpInfo->ExpInfo->ExpFlags & VPMODE_BIT) &&
(pProcExpInfo->ExpInfo->ExpFlags & AUTOMODE_BIT) )
sprintf(msgestring,"acqsend(5,'%d',0,%d,'vpa',%d,%d,%lu,%lu,'%s')\n",
(int)FGkey, process2do,dCode,eCode, fid, ct,
pProcExpInfo->ExpInfo->DataFile);
else if (pProcExpInfo->ExpInfo->ExpFlags & VPMODE_BIT)
sprintf(msgestring,"acqsend(5,'%d',0,%d,'vp',%d,%d,%lu,%lu,'%s')\n",
(int)FGkey, process2do,dCode,eCode, fid, ct,
pProcExpInfo->ExpInfo->DataFile);
else
sprintf(msgestring,"acqsend(5,'%d',%d,%d,'exp%d',%d,%d,%lu,%lu)\n",
(int)FGkey,pProcExpInfo->ExpInfo->ExpNum,
process2do,pProcExpInfo->ExpInfo->ExpNum,dCode,eCode, fid, ct);
/* --- If FG Vnmr is in Process Exp# & Wexp Not Processing in FG, --- */
/* And not in automation mode */
/* --- Then do FG processing else do it in BG --- */
/* FG is Never done for automation Experiments! */
if ( (strlen(pProcExpInfo->ExpInfo->MachineID) > (size_t) 1) &&
(verifyInterface( pProcExpInfo->ExpInfo->MachineID )) &&
( !(pProcExpInfo->ExpInfo->ExpFlags & AUTOMODE_BIT) ||
( ((pProcExpInfo->ExpInfo->ExpFlags & VPMODE_BIT) && (pProcExpInfo->ExpInfo->ExpFlags & AUTOMODE_BIT)) ) ) )
{
/* acqcp('exp#','ExpInfo',donecode,errorcode,WprocType,fid,ct) */
DPRINT(1,"Send Vnmr(MachineId): acqsend(5,FGkey,Exp#,Process2Do,'exp#',dcode,ecode,fid,ct)\n");
DPRINT2(1,"Send Vnmr(%s): '%s'\n",
pProcExpInfo->ExpInfo->MachineID,
msgestring);
deliverMessage( pProcExpInfo->ExpInfo->MachineID, msgestring );
DPRINT(1,"BeginProcessing: FG calling activeQadd\n");
activeQadd(pProcExpInfo->ExpId, proctype, fid, ct, FG, (int) FGkey, dCode, eCode );
procQdelete(proctype, 1);
}
else /* ----- process in BackGround ----- */
{
char vnmrmode[20];
char expnum[16];
char fidpath[128];
char userpath[128];
char host[128];
char vnmr_acqid[16];
int ret;
int len;
int uid;
int gid;
/* Be Absolutely sure there is a Vnmr out there to RUN */
if ( access(Vnmrpath,R_OK | X_OK) != 0)
{
errLogRet(ErrLogOp,debugInfo,
"WARNING: BG '%s' Processing for '%s' was NOT performed, \n",
procmsge, pProcExpInfo->ExpId);
errLogRet(ErrLogOp,debugInfo,
" '%s' not found or can not run.\n",
Vnmrpath);
return; /* don't do any more */
}
/*
Common Arguments for NORMAL or AUTOMATION Vnmr Arguments
*/
/* below we first copy the string "acqsend('5',..." to
cmdstring (why? I don't know, msgestring isn't used anymore)
and then set the 8th character to '6'. So the cmdstring then
reads as "acqsend('6',...". By the way, in acqproc the digits
5 and 6 are defines as FGREPLY and FGNOREPLY respectively.
For those that need to maintain software this may be of help.
*/
strcpy(cmdstring,msgestring);
cmdstring[8] = '6';
sprintf(userpath,"-u%s",pProcExpInfo->ExpInfo->UsrDirFile);
sprintf(host,"-h%s",pProcExpInfo->ExpInfo->MachineID);
sprintf(vnmr_acqid,"-i%d",pProcExpInfo->ExpInfo->ExpNum);
sprintf(fidpath,"-d%s",pProcExpInfo->ExpInfo->DataFile);
/* Are we in Automation Mode ? */
if ( !(pProcExpInfo->ExpInfo->ExpFlags & AUTOMODE_BIT) )
{
/* back mode is used because the experiment will need to be
* locked by the background Vnmr. The acq mode expects the
* experiment to already be locked.
*/
sprintf(vnmrmode,"-mback");
sprintf(expnum,"-n%d",pProcExpInfo->ExpInfo->ExpNum);
}
else /* Automation Mode */
{
/* Use Exp2 & Exp3 in automation mode */
if (proctype == WEXP)
sprintf(expnum,"-n2");
else
sprintf(expnum,"-n3");
sprintf(vnmrmode,"-mauto");
len = strlen(fidpath);
/* Test Auto_Pid ? */
/* if acquisition in automode and go neither a go(nowait) */
/* or Werror issue a resume to autoproc prior to processing */
if ( (pProcExpInfo->ExpInfo->ProcWait == AU_NOWAIT) &&
(proctype != WERR) )
{
DPRINT(1,"BeginProcessing: Prior to vfork - Send Resume\n");
pAutoMsgQ = openMsgQ("Autoproc");
if (pAutoMsgQ != NULL)
{
sendMsgQ(pAutoMsgQ, "resume", strlen("resume"), MSGQ_NORMAL,
WAIT_FOREVER); /* NO_WAIT */
closeMsgQ(pAutoMsgQ);
}
}
}
/* save User is a static location for forked child */
strcpy(User,pProcExpInfo->ExpInfo->UserName);
umask4Vnmr = pProcExpInfo->ExpInfo->UserUmask;
childpid = fork(); /* fork a child */
DPRINT1(1,"Start BG process ---- childpid = %d\n",childpid);
/* ----- Parent vs Child ---- */
if (childpid == 0)
{
sigset_t signalmask;
/* set signal mask for child ti zip */
sigemptyset( &signalmask );
sigprocmask( SIG_SETMASK, &signalmask, NULL );
/* change the user and group ID of the child so that VNMR
will run with those ID's */
getUserUid(User, &uid, &gid);
seteuid(getuid());
freopen("/dev/null","r",stdin);
freopen("/dev/console","a",stdout);
freopen("/dev/console","a",stderr);
if ( setgid(gid) )
{
DPRINT(1,"BGprocess: cannot set group ID\n");
}
if ( setuid(uid) )
{
DPRINT(1,"BGprocess: cannot set user ID\n");
}
/* set umask to be that requested by PSG */
umask( umask4Vnmr );
ret=execl(Vnmrpath,"Vnmr",vnmrmode,host,vnmr_acqid,expnum,userpath,fidpath,cmdstring,NULL);
if (ret == -1)
{
errLogRet(ErrLogOp,debugInfo,
"WARNING: BG '%s' for Exp%d was NOT performed, \n",
proctype,pProcExpInfo->ExpInfo->ExpNum);
errLogRet(ErrLogOp,debugInfo, " execl on '%s' failed.\n",
Vnmrpath);
return; /* don't do any more */
}
}
else /* if (childpid != 0) Child */
{
DPRINT(1,"BeginProcessing: BG calling activeQadd()\n");
activeQadd(pProcExpInfo->ExpId, proctype, fid, ct, BG, childpid, dCode, eCode);
procQdelete(proctype, 1);
}
}
}
/*
success ->
return packet type
fail->
return FAIL
*/
int cycle(MQTTClient* c, Timer* timer)
{
int packet_type = readPacket(c, timer);
int len = 0;
int rc = SUCCESS;
if (FAILURE == packet_type) {
packet_type = NOPACKET;
goto exit;
}
printf("received %s\n", MQTTPacket_names[packet_type]);
switch (packet_type)
{
case CONNACK:
case PUBACK:
case SUBACK:
break;
case PUBLISH:
{
MQTTString topicName;
MQTTMessage msg;
int intQoS;
if (MQTTDeserialize_publish(&msg.dup, &intQoS, &msg.retained, &msg.id, &topicName,
(unsigned char**)&msg.payload, (int*)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
goto exit;
msg.qos = (enum QoS)intQoS;
//deliverMessage(c, &topicName, &msg);
if (msg.qos != QOS0) {
if (msg.qos == QOS1)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
else if (msg.qos == QOS2)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
if (len <= 0)
rc = FAILURE;
else
rc = sendPacket(c, len, timer);
if (rc == FAILURE)
goto exit; // there was a problem
}
deliverMessage(c, &topicName, &msg);
break;
}
case PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = FAILURE;
else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0)
rc = FAILURE;
else if ((rc = sendPacket(c, len, timer)) != SUCCESS) // send the PUBREL packet
rc = FAILURE; // there was a problem
if (rc == FAILURE)
goto exit; // there was a problem
break;
}
case PUBCOMP:
break;
case PINGRESP:
c->ping_outstanding = 0;
//c->keepAliveFailCount = 0;
break;
case PUBREL:
{
unsigned short mypacketid;
unsigned char dup, type;
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = FAILURE;
else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBCOMP, 0, mypacketid)) <= 0)
rc = FAILURE;
else if ((rc = sendPacket(c, len, timer)) != SUCCESS) // send the PUBCOMP packet
rc = FAILURE; // there was a problem
if (rc == FAILURE)
goto exit; // there was a problem
break;
}
}
exit:
if (FAILURE == keepalive(c)) {
rc = FAILURE;
}
if (rc == SUCCESS)
rc = packet_type;
return rc;
}
/**
* Process a message that may be meant for the proximity system
* \returns true if object was deleted
*/
OpaqueMessageReturnValue internalProcessOpaqueProximityMessage(
const ObjectReference*object,
const RoutableMessageHeader& hdr,
const void *serializedMessageBody,
size_t serializedMessageBodySize,
bool trusted) {
try {
RoutableMessage msg(hdr,serializedMessageBody,serializedMessageBodySize);
MessageBundle sendState=DELIVER_TO_UNKNOWN;
bool deliverAllMessages=true;
int len=msg.body().message_size();
OpaqueMessageReturnValue obj_is_deleted=OBJECT_NOT_DESTROYED;
bool disconnection=false;
bool registration=false;
for (int i=0;i<len;++i) {
if (trusted||(hdr.has_source_object()&&hdr.source_object()==ObjectReference::spaceServiceID()&&hdr.source_port()==mRegistrationPort)) {
if(msg.body().message_names(i)=="DelObj") {
disconnection=true;
obj_is_deleted=OBJECT_DELETED;
}
if(msg.body().message_names(i)=="RetObj") {
registration=true;
Sirikata::Protocol::RetObj ro;
ro.ParseFromString(msg.body().message_arguments(i));
newObj(ro,msg.body().message_arguments(i).data(),msg.body().message_arguments(i).size());
}
}
if (!forwardThisName(disconnection,msg.body().message_names(i))) {
if (len==1) return obj_is_deleted;
deliverAllMessages=false;
}else {
if (msg.body().message_names(i)==proxCallbackName()) {
if (sendState==DELIVER_TO_UNKNOWN||sendState==DELIVER_TO_OBJECT)
sendState=DELIVER_TO_OBJECT;
else
sendState=DELIVER_TO_BOTH;
}else{
if (sendState==DELIVER_TO_UNKNOWN||sendState==DELIVER_TO_PROX)
sendState=DELIVER_TO_PROX;
else
sendState=DELIVER_TO_BOTH;
}
}
}
if (sendState==DELIVER_TO_UNKNOWN)
return obj_is_deleted;//no messages considered worth forwarding to the proximity system
if (sendState==DELIVER_TO_BOTH) {
SILOG(prox,info,"Message with recipients both proximity and object bundled into the same message: not delivering.");
return obj_is_deleted;
}
/* NOT SURE THIS IS NECESSARY -- do these messages already have addresses on them?*/
DidAlterMessage alteration;
if (sendState==DELIVER_TO_PROX)
alteration=addressMessage(msg,object,NULL);
else
alteration=addressMessage(msg,NULL,object);
if (deliverAllMessages&&sendState==DELIVER_TO_PROX) {
sendMessage(*object,msg,serializedMessageBody,serializedMessageBodySize);
} else if (deliverAllMessages&&sendState==DELIVER_TO_OBJECT) {
deliverMessage(*object,msg,serializedMessageBody,serializedMessageBodySize);
}else {
//some messages are not considered worth forwarding to the proximity system or there's a mishmash of destinations
if (msg.body().message_size()<len) {
len=msg.body().message_size();
}
RoutableMessage newMsg (msg);
newMsg.body().clear_message();
for (int i=0;i<len;++i) {
if (forwardThisName(registration||disconnection,msg.body().message_names(i))) {
newMsg.body().add_message(msg.body().message_names(i), msg.body().message_arguments(i));
}
}
if (sendState==DELIVER_TO_OBJECT)
deliverMessage(*object,newMsg,NULL,0);
if (sendState==DELIVER_TO_PROX)
sendMessage(*object,newMsg,NULL,0);
}
return obj_is_deleted;
}catch(std::invalid_argument&ia) {
SILOG(proximity,warning,"Could not parse message");
return OBJECT_NOT_DESTROYED;
}
}
int cycle(Client* c, Timer* timer)
{
// read the socket, see what work is due
int read_status;
unsigned short packet_type;
read_status = readPacket(c, timer);
packet_type = (unsigned short )read_status;
if(read_status == SOCKET_CLOSED)
{
MQTTReConnect(c);
goto exit;
}
int len = 0,
rc = SUCCESS;
switch (packet_type)
{
case CONNACK:
{
{
unsigned char connack_rc = 255;
char sessionPresent = 0;
if (MQTTDeserialize_connack((unsigned char*)&sessionPresent, &connack_rc, c->readbuf, c->readbuf_size) == 1)
{
c->isconnected = 1;
//开cloud灯
system(SET_LIGHT_CLOUD);
log_printf(LOG_NOTICE, "[MqttConnected]: recv connack\n");
//subtopics and pubtopics init
sprintf(&subtopics[0][0], "%s%s", SUBTOPIC_PRE1, gateway_info.did);
sprintf(&subtopics[1][0], "%s%s", SUBTOPIC_PRE2, gateway_info.productkey);
sprintf(&subtopics[2][0], "%s%s/#", SUBTOPIC_PRE3, gateway_info.did);
sprintf(&pubtopics[0][0], "%s%s", PUBTOPIC_PRE1, gateway_info.did);
sprintf(&pubtopics[1][0], "%s%s", PUBTOPIC_PRE2, gateway_info.did);
sprintf(&pubtopics[2][0], "%s%s/#", PUBTOPIC_PRE3, gateway_info.did);
rc = MQTTSubscribe(c, subtopics[c->suborder], 0, mh[c->suborder]); //for test
log_printf(LOG_NOTICE, "Subscribing to %s\n", subtopics[c->suborder]);
c->suborder++;
}
}
}
break;
case PUBACK:
break;
case SUBACK:
{
int count = 0, grantedQoS = -1;
unsigned short mypacketid;
if (MQTTDeserialize_suback(&mypacketid, 1, &count, &grantedQoS, c->readbuf, c->readbuf_size) == 1)
rc = grantedQoS; // 0, 1, 2 or 0x80
if (rc != 0x80)
{
if(c->suborder <subscribe_over)
{
rc = MQTTSubscribe(c, subtopics[c->suborder], 0, mh[c->suborder]);
log_printf(LOG_NOTICE, "Subscribing to %s\n",subtopics[c->suborder]);
c->suborder++;
}
// int i;
// for (i = 0; i < MAX_MESSAGE_HANDLERS; ++i)
// {
// if (c->messageHandlers[i].topicFilter == 0)
// {
// c->messageHandlers[i].topicFilter = mytopics[i];
// c->messageHandlers[i].fp = mh[i];
// rc = 0;
// break;
// }
// }
}
else
{
log_printf(LOG_ERROR, "SUCACK FAILED\n");
//TODO: error handle
}
}
break;
case PUBLISH:
{
if(c->suborder != subscribe_over)
{
log_printf(LOG_ERROR, "[REC_MSG] rece publish msg but subcribe not over\n");
//TODO: error
}
MQTTString topicName = MQTTString_initializer;
MQTTMessage msg;
if (MQTTDeserialize_publish((unsigned char*)&msg.dup, (int*)&msg.qos, (unsigned char*)&msg.retained, (unsigned short*)&msg.id, &topicName,
(unsigned char**)&msg.payload, (int*)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
goto exit;
deliverMessage(c, &topicName, &msg);
// MQTTPublish(c, "applerespond", &msg); //add by yaly for test
if (msg.qos != QOS0)
{
if (msg.qos == QOS1)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
else if (msg.qos == QOS2)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
if (len <= 0)
rc = FAILURE;
else
rc = sendPacket_ev(c, len);
if (rc == FAILURE)
goto exit;
}
}
break;
case PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = FAILURE;
else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0)
rc = FAILURE;
else if ((rc = sendPacket_ev(c, len)) != SUCCESS) // send the PUBREL packet
rc = FAILURE;
if (rc == FAILURE)
goto exit;
break;
}
break;
case PUBCOMP:
break;
case PINGRESP:
log_printf(LOG_NOTICE, "[MqttPingResp]\n");
c->ping_outstanding = 0;
break;
}
// keepalive(c); //modify by yanly
exit:
if (rc == SUCCESS)
rc = packet_type;
return rc;
}
int cycle( Client* c, Timer* timer )
{
// read the socket, see what work is due
unsigned short packet_type = readPacket( c, timer );
int len = 0;
int rc = MQTT_SUCCESS;
WPRINT_APP_INFO( ("Packet Type %d\n", packet_type) );
switch ( packet_type )
{
case CONNACK:
case PUBACK:
case SUBACK:
break;
case PUBLISH:
{
MQTTString topicName;
MQTTMessage msg;
if ( MQTTDeserialize_publish( (unsigned char*) &msg.dup, (int*) &msg.qos, (unsigned char*) &msg.retained, (unsigned short*) &msg.id, &topicName, (unsigned char**) &msg.payload, (int*) &msg.payloadlen, c->readbuf, c->readbuf_size ) != 1 )
{
goto exit;
}
deliverMessage( c, &topicName, &msg );
if ( msg.qos != QOS0 )
{
if ( msg.qos == QOS1 )
{
len = MQTTSerialize_ack( c->buf, c->buf_size, PUBACK, 0, msg.id );
}
else if ( msg.qos == QOS2 )
{
len = MQTTSerialize_ack( c->buf, c->buf_size, PUBREC, 0, msg.id );
}
if ( len <= 0 )
{
rc = MQTT_FAILURE;
}
else
{
rc = sendPacket( c, len, timer );
}
if ( rc == MQTT_FAILURE )
{
goto exit;
// there was a problem
}
}
break;
}
case PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
if ( MQTTDeserialize_ack( &type, &dup, &mypacketid, c->readbuf, c->readbuf_size ) != 1 )
{
rc = MQTT_FAILURE;
}
else if ( ( len = MQTTSerialize_ack( c->buf, c->buf_size, PUBREL, 0, mypacketid ) ) <= 0 )
{
rc = MQTT_FAILURE;
}
else if ( ( rc = sendPacket( c, len, timer ) ) != MQTT_SUCCESS ) // send the PUBREL packet
{
rc = MQTT_FAILURE; // there was a problem
}
if ( rc == MQTT_FAILURE )
{
goto exit;
// there was a problem
}
break;
}
case PUBCOMP:
break;
case PINGRESP:
c->ping_outstanding = 0;
break;
}
keepalive( c );
exit: if ( rc == MQTT_SUCCESS )
{
rc = packet_type;
}
return rc;
}
int cycle(MQTTClient* c, Timer* timer)
{
Timer t;
platform_timer_init(&t);
int len = 0, packet_type, rc = MQTT_SUCCESS;
// read the socket, see what work is due
if ((packet_type = readPacket(c, timer)) == MQTT_CONNECTION_LOST)
{
rc = MQTT_CONNECTION_LOST;
goto exit;
}
switch (packet_type)
{
case CONNACK:
case PUBACK:
case SUBACK:
break;
case PUBLISH:
{
MQTTString topicName;
MQTTMessage msg = {0};
int intQoS;
if (MQTTDeserialize_publish(&msg.dup, &intQoS, &msg.retained, &msg.id, &topicName,
(unsigned char**)&msg.payload, &msg.payloadlen, c->readbuf, c->readbuf_size) != 1)
goto exit;
msg.qos = (enum QoS)intQoS;
deliverMessage(c, &topicName, &msg);
if (msg.qos != QOS0)
{
if (msg.qos == QOS1)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
else if (msg.qos == QOS2)
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
if (len <= 0)
rc = MQTT_FAILURE;
else
{
platform_timer_countdown(&t, c->command_timeout_ms);
rc = sendPacket(c, len, &t);
}
if (rc == MQTT_FAILURE)
goto exit; // there was a problem
}
break;
}
case PUBREC:
{
unsigned short mypacketid;
unsigned char dup, type;
platform_timer_countdown(&t, c->command_timeout_ms);
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1)
rc = MQTT_FAILURE;
else if ((len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREL, 0, mypacketid)) <= 0)
rc = MQTT_FAILURE;
else if ((rc = sendPacket(c, len, &t)) != MQTT_SUCCESS) // send the PUBREL packet
rc = MQTT_FAILURE; // there was a problem
if (rc == MQTT_FAILURE)
goto exit; // there was a problem
break;
}
case PUBCOMP:
break;
case PINGRESP:
c->ping_outstanding = 0;
platform_printf("received ping response\n");
break;
}
keepalive(c);
if (c->ping_outstanding && platform_timer_isexpired(&c->pingresp_timer))
{
c->ping_outstanding = 0;
platform_printf("ping response was not received within keepalive timeout of %d\n",
c->keepAliveInterval);
rc = MQTT_CONNECTION_LOST;
}
exit:
if (rc == MQTT_SUCCESS)
rc = packet_type;
return rc;
}
int cycle(MQTTClient *c, Timer *timer)
{
int len = 0,
rc = SUCCESS;
int packet_type = readPacket(c, timer); /* read the socket, see what work is due */
switch (packet_type) {
default:
/* no more data to read, unrecoverable. Or read packet fails due to unexpected network error */
rc = packet_type;
goto exit;
case 0: /* timed out reading packet */
break;
case CONNACK:
case PUBACK:
case SUBACK:
case UNSUBACK:
break;
case PUBLISH: {
MQTTString topicName;
MQTTMessage msg;
int intQoS;
msg.payloadlen = 0; /* this is a size_t, but deserialize publish sets this as int */
if (MQTTDeserialize_publish(&msg.dup, &intQoS, &msg.retained, &msg.id, &topicName,
(unsigned char **)&msg.payload, (int *)&msg.payloadlen, c->readbuf, c->readbuf_size) != 1) {
goto exit;
}
msg.qos = (enum QoS)intQoS;
deliverMessage(c, &topicName, &msg);
if (msg.qos != QOS0) {
if (msg.qos == QOS1) {
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBACK, 0, msg.id);
} else if (msg.qos == QOS2) {
len = MQTTSerialize_ack(c->buf, c->buf_size, PUBREC, 0, msg.id);
}
if (len <= 0) {
rc = FAILURE;
} else {
rc = sendPacket(c, len, timer);
}
if (rc == FAILURE) {
goto exit; // there was a problem
}
}
break;
}
case PUBREC:
case PUBREL: {
unsigned short mypacketid;
unsigned char dup, type;
if (MQTTDeserialize_ack(&type, &dup, &mypacketid, c->readbuf, c->readbuf_size) != 1) {
rc = FAILURE;
} else if ((len = MQTTSerialize_ack(c->buf, c->buf_size,
(packet_type == PUBREC) ? PUBREL : PUBCOMP, 0, mypacketid)) <= 0) {
rc = FAILURE;
} else if ((rc = sendPacket(c, len, timer)) != SUCCESS) { // send the PUBREL packet
rc = FAILURE; // there was a problem
}
if (rc == FAILURE) {
goto exit; // there was a problem
}
break;
}
case PUBCOMP:
break;
case PINGRESP:
c->ping_outstanding = 0;
break;
}
if (keepalive(c) != SUCCESS) {
//check only keepalive FAILURE status so that previous FAILURE status can be considered as FAULT
rc = FAILURE;
}
exit:
if (rc == SUCCESS) {
rc = packet_type;
} else if (c->isconnected) {
MQTTCloseSession(c);
}
return rc;
}
