void ClientUdpSocket::onReadPendingDatagram()
{
while (hasPendingDatagrams()) {
QByteArray datagram;
QHostAddress sender;
quint16 senderPort;
datagram.resize(pendingDatagramSize());
readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
QDataStream in(datagram);
quint8 magic = 0;
in >> magic;
if (magic != DGMAGICBIT) {
qDebug() << QString("Datagram with invalid magic byte (size=%1)").arg(datagram.size());
continue;
}
quint8 type;
in >> type;
switch (type) {
case DGHELLO:
processHello(in, sender, senderPort);
break;
case DGDATA:
processFileData(in, sender, senderPort);
break;
default:
qDebug() << QString("Unknown datagram type");
break;
}
}
}
void* listenerThread(void *arg)
{
struct sockaddr_in addr;
int fd, nbytes;
unsigned int addrlen;
struct ip_mreq mreq;
char msgbuf[MSGBUFSIZE];
u_int yes=1;
/* create what looks like an ordinary UDP socket */
if ((fd=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
perror("socket");
return NULL;
}
/* allow multiple sockets to use the same PORT number */
if (setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(yes)) < 0) {
perror("Reusing ADDR failed");
return NULL;
}
/* set up destination address */
memset(&addr,0,sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=htonl(INADDR_ANY); /* N.B.: differs from sender */
addr.sin_port=htons(INTERCOM_PORT);
/* bind to receive address */
if (bind(fd,(struct sockaddr *) &addr,sizeof(addr)) < 0) {
perror("bind");
return NULL;
}
/* use setsockopt() to request that the kernel join a multicast group */
mreq.imr_multiaddr.s_addr=inet_addr(INTERCOM_GROUP);
mreq.imr_interface.s_addr=htonl(INADDR_ANY);
if (setsockopt(fd,IPPROTO_IP,IP_ADD_MEMBERSHIP,&mreq,sizeof(mreq)) < 0) {
perror("setsockopt");
return NULL;
}
/* now just enter the read loop */
while (bRun) {
char *pt;
char srcIP[IPSTRSIZE];
station_diag_t *pOther;
addrlen=sizeof(addr);
if ((nbytes=recvfrom(fd,msgbuf,MSGBUFSIZE,0,(struct sockaddr *) &addr,&addrlen)) < 0 ) {
perror("recvfrom");
return NULL;
}
// Zero terminate the string
msgbuf[nbytes]=0;
inet_ntop(AF_INET, &addr.sin_addr, srcIP, sizeof(srcIP));
if(strcmp( srcIP,myIP)==0) {
// Ignore our own transmission
continue;
}
pOther = updateDiagData( srcIP, msgbuf, nbytes );
// Look for version 1.0 header in the message
// Format as follow: HEADER:CMD
// HELO:<IP>
// SYNC:<idx>,<state>
// EVNT:<idx>,<state>
pt = msgbuf;
if(strncmp(pt,HEADER,strlen(HEADER))==0) {
pt = pt + strlen(HEADER);
if( strncmp(pt,EVENT_CMD,strlen(EVENT_CMD))==0) {
pt = pt + strlen(EVENT_CMD);
if( processEvent( pt ) < 0 )
{
// printf( "Malformed CMD: '%s'\n", msgbuf );
diag.errCnt++;
if( pOther ) pOther->mlfrmdRxErrCnt++;
}
}
else if( strncmp(pt,HELLO_CMD,strlen(HELLO_CMD))==0) {
pt = pt + strlen(HELLO_CMD);
if( processHello( pt ) < 0 )
{
// printf( "Malformed HELLO: '%s'\n", msgbuf );
diag.errCnt++;
if( pOther ) pOther->mlfrmdRxErrCnt++;
}
}
else if( strncmp(pt,SYNC_CMD,strlen(SYNC_CMD))==0) {
pt = pt + strlen(SYNC_CMD);
if( processEvent( pt ) < 0 )
{
// printf( "Malformed SYNC: '%s'\n", msgbuf );
diag.errCnt++;
if( pOther ) pOther->mlfrmdRxErrCnt++;
}
}
else if( strncmp(pt,RESET_CMD,strlen(RESET_CMD))==0) {
pt = pt + strlen(RESET_CMD);
idx = 0;
}
else
{
diag.errCnt++;
if( pOther ) pOther->mlfrmdRxErrCnt++;
// printf( "Unknown command: '%s'\n", msgbuf );
}
}
else
{
diag.errCnt++;
if( pOther ) pOther->unxpctdRxErrCnt++;
// printf( "Unknown packet: '%s'\n", msgbuf );
}
}
return NULL;
}
void JRoomModelClientRoomProcessor::process(JSocket* , const QByteArray& data)
{
QDataStream stream(data);
JID protocol;
stream>>protocol;
switch(protocol){
case ERP_Hello:
{
JCode result;
stream>>result;
processHello(result);
}
break;
case ERP_RoomList:
{
QList<JRoom> roomlist;
stream>>roomlist;
processRoomList(roomlist);
}
break;
case ERP_AddRoom:
{
JID roomId;
stream>>roomId;
processAddRoom(roomId);
}
break;
case ERP_EnterRoom:
{
JID userId;
JID roomId;
JCode code;
stream>>userId;
stream>>roomId;
stream>>code;
processEnterRoom(userId,roomId,code);
}
break;
case ERP_RoomInfo:
{
JRoom room;
stream>>room;
processRoomInfo(room);
}
break;
case ERP_RoomRemoved:
{
JID roomId;
stream>>roomId;
processRoomRemoved(roomId);
}
break;
case ERP_RoomChat:
{
JID userId;
JID roomId;
QString text;
stream>>userId;
stream>>roomId;
stream>>text;
emit receiveRoomChat(userId,roomId,text);
}
break;
default:
qDebug()<<"JRoomModelClientRoomProcessor::process : unknown protocol : "<<protocol;
}
}
int dispatch_msg(const char* p_msg)
{
log_debug("parsing message: %s", p_msg);
struct json_object* pobj = json_tokener_parse(p_msg);
if((NULL == pobj) || (is_error(pobj)))
{
log_err("error: message does not appear to be a valid json message: %s", p_msg);
return(-1);
}
// param 0 is the function name
const char* fcn;
int rc = get_string_from_array(pobj, 0, &fcn);
if(0 != rc)
{
log_err("error: failed to get function name from message");
return(-1);
}
if(0 == strcmp("pulseRelay", fcn))
{
// ["pulseRelay",1,250]
int num;
rc = get_int_from_array(pobj, 1, &num);
if(0 != rc)
{
log_err("error: pulseRelay: failed to extract param0 relay num");
return(-1);
}
if((num < 0) || (num > 255))
{
log_err("error: pulseRelay: relay num out of range (0-255): [%d]", num);
return(-1);
}
int ms;
rc = get_int_from_array(pobj, 2, &ms);
if(0 != rc)
{
log_debug("pulseRelay: no cycle ms specified, defaulting to 250ms");
ms = 250;
}
if((ms < 0) || (ms > 255))
{
log_err("error: pulseRelay: pulse duration ms out of range (0-255): [%dms]", ms);
return(-1);
}
pulseRelay((uint8_t)num, (uint8_t)ms);
}
else if(0 == strcmp("writeOutputRegister", fcn))
{
// ["writeOutputRegister",1,255]
int val;
rc = get_int_from_array(pobj, 1, &val);
if(0 != rc)
{
log_err("error: writeOutputRegister: failed to extract param0 'value'");
return(-1);
}
if((val < 0) || (val > 255))
{
log_err("error: writeOutputRegister: register value out of range (0-255): [%d]", val);
return(-1);
}
int mask;
rc = get_int_from_array(pobj, 2, &mask);
if(0 != rc)
{
log_err("error: writeOutputRegister: failed to extract param1 'mask'");
return(-1);
}
if((mask < 0) || (mask > 255))
{
log_err("error: writeOutputRegister: register mask out of range (0-255): [%d]", mask);
return(-1);
}
writeOutputRegister((uint8_t)val, (uint8_t)mask);
}
else if(0 == strcmp("dialModem", fcn))
{
// ["dialModem","ATD3,4,4;"]
const char* val;
rc = get_string_from_array(pobj, 1, &val);
if(0 != rc)
{
log_err("error: dialModem: failed to extract param0 dial string");
return(-1);
}
dialModem(val);
}
else if(0 == strcmp("hello", fcn))
{
// ["hello","<device id>"]
const char* str;
rc = get_string_from_array(pobj, 1, &str);
if(0 != rc)
{
log_err("error: hello: failed to extract param0 device id");
return(-1);
}
processHello(str);
}
else if(0 == strcmp("requestIpv4Addresses", fcn))
{
requestIpv4Addresses();
}
else
{
log_err("error: unknown function: [%s]", fcn);
}
return(0);
}
