bool getCheckNFC() {
// start bytes 0, 1
// len of data
// LCS = 0 - len
// TFI
// message type
// message
// DCS = 0 - TFI - message
char inbyte;
char len;
// get start bytes
while(1) { // loop until a proper message is received
while(1) { // loop for start bytes
if (xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY)) {
if (inbyte == '\0') {
while(!xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY));
if (inbyte == '\xff') {
break;
}
}
}
}
// get len
while(!xQueueReceive(nfc_appData.rxQ, &len, portMAX_DELAY));
// get LCS
while(!xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY));
if (len - inbyte != 0) {
sendNACK();
continue;
}
// get TFI
while(!xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY));
// get message type
while(!xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY));
if (inbyte != '\x4b') {
sendNACK();
continue;
}
// get number of targets
while(!xQueueReceive(nfc_appData.rxQ, &inbyte, portMAX_DELAY));
if (inbyte == '\0') {
return pdFALSE;
}
else {
return pdTRUE;
}
}
}
void slip_main(void)
{
uchar ret = 0;
ret = processing_slipcmd();
if( ret == ERROR_OK)
{
sendACK();
run_cmd();
}
else if (ret == ERROR_INVALID_PACKET)
{
sendNACK();
}
rs485_cmd_finish = 0;
rs485_cmd_count = 0;
rs485bufferclear(cmdrspbuffer, RS485BUF_SIZE);
rs485bufferclear(cmd_bytes, RS485CMD_SIZE);
}
void NFC_APP_Tasks ( void )
{
char inChar;
while(1) {
while(!xQueueReceive(nfc_appData.inQ, &inChar, portMAX_DELAY));
sendDebugMessage("CHECK NFC\0");
checkNFC();
sendDebugMessage("WAIT ON ACK\0");
while(!getACK()) {
sendDebugMessage("SEND NACK\0");
sendNACK();
}
sendDebugMessage("GOT ACK\0");
if (getCheckNFC()) {
sendDebugMessage("TOKEN FOUND\0");
addToUartTXQ(tokenFound());
}
else {
sendDebugMessage("NO TOKEN\0");
}
}
}
bool ShinyFilesystemMediator::handleMessage( zmq::socket_t * sock, std::vector<zmq::message_t *> & msgList ) {
zmq::message_t * fuseRoute = msgList[0];
zmq::message_t * blankMsg = msgList[1];
// Following the protocol (briefly) laid out in ShinyFuse.h;
uint8_t type = parseTypeMsg(msgList[2]);
switch( type ) {
case ShinyFilesystemMediator::DESTROY: {
// No actual response data, just sending response just to be polite
sendACK( sock, fuseRoute );
// return false as we're signaling to mediator that it's time to die. >:}
return false;
}
case ShinyFilesystemMediator::GETATTR: {
// Let's actually get the data fuse wants!
char * path = parseStringMsg( msgList[3] );
// If the node even exists;
ShinyMetaNode * node = fs->findNode( path );
if( node ) {
// we're just going to serialize it and send it on it's way!
// Opportunity for zero-copy here!
uint64_t len = node->serializedLen();
char * buff = new char[len];
node->serialize(buff);
zmq::message_t ackMsg; buildTypeMsg( ShinyFilesystemMediator::ACK, &ackMsg );
zmq::message_t nodeTypeMsg; buildTypeMsg( node->getNodeType(), &nodeTypeMsg );
zmq::message_t nodeMsg; buildDataMsg( buff, len, &nodeMsg );
sendMessages( sock, 5, fuseRoute, blankMsg, &ackMsg, &nodeTypeMsg, &nodeMsg );
delete( buff );
} else
sendNACK( sock, fuseRoute );
// cleanup after the parseStringMsg()
delete( path );
break;
}
case ShinyFilesystemMediator::SETATTR: {
char * path = parseStringMsg( msgList[3] );
ShinyMetaNode * node = fs->findNode( path );
if( node ) {
const char * data = (const char *) msgList[4]->data();
// Apply the data to the node
node->unserialize( &data );
// Send back ACK
sendACK( sock, fuseRoute );
} else
sendNACK( sock, fuseRoute );
delete( path );
break;
}
case ShinyFilesystemMediator::READDIR: {
char * path = parseStringMsg( msgList[3] );
// If the node even exists;
ShinyMetaNode * node = fs->findNode( path );
if( node && (node->getNodeType() == ShinyMetaNode::TYPE_DIR || node->getNodeType() == ShinyMetaNode::TYPE_ROOTDIR) ) {
const std::vector<ShinyMetaNode *> * children = ((ShinyMetaDir *) node)->getNodes();
// Here is my crucible, to hold data to be pummeled out of the networking autocannon, ZMQ
std::vector<zmq::message_t *> list( 1 + 1 + 1 + children->size() );
list[0] = fuseRoute;
list[1] = blankMsg;
zmq::message_t ackMsg; buildTypeMsg( ShinyFilesystemMediator::ACK, &ackMsg );
list[2] = &ackMsg;
for( uint64_t i=0; i<children->size(); ++i ) {
zmq::message_t * childMsg = new zmq::message_t(); buildStringMsg( (*children)[i]->getName(), childMsg );
list[3+i] = childMsg;
}
sendMessages( sock, list );
// Free up those childMsg structures and ackMsg while we're at it (ackMsg is list[1])
for( uint64_t i=3; i<list.size(); ++i ) {
delete( list[i] );
}
} else
sendNACK( sock, fuseRoute );
// cleanup, cleanup everybody everywhere!
delete( path );
break;
}
case ShinyFilesystemMediator::OPEN: {
// Grab the path, shove it into an std::string for searching openFiles
char * path = parseStringMsg( msgList[3] );
std::string pathStr( path );
// This is our file that we'll eventually send back, or not, if we can't find the file
ShinyMetaNode * node = NULL;
// First, make sure that there is not already an OpenFileInfo corresponding to this path:
std::map<std::string, OpenFileInfo *>::iterator itty = this->openFiles.find( pathStr );
// If there isn't, let's get one! (if it exists)
if( itty == this->openFiles.end() ) {
node = fs->findNode( path );
if( node && node->getNodeType() == ShinyMetaNode::TYPE_FILE ) {
// Create the new OpenFileInfo, initialize it to 1 opens, so only 1 close required to
// flush this data out of the map
OpenFileInfo * ofi = new OpenFileInfo();
ofi->file = (ShinyMetaFile *) node;
ofi->opens = 1;
// Aaaand, put it into the list!
this->openFiles[pathStr] = ofi;
}
} else {
// Check to make sure this guy isn't on death row 'cause of an unlink()
if( !(*itty).second->shouldDelete ) {
// Otherwise, it's in the list, so let's return the cached copy!
node = (ShinyMetaNode *) (*itty).second->file;
// Increment the number of times this file has been opened...
(*itty).second->opens++;
// If it was going to be closed, let's stop that from happening now
(*itty).second->shouldClose = false;
}
}
// If we were indeed able to find the file; write back an ACK, otherwise, NACK it up!
if( node )
sendACK( sock, fuseRoute );
else
sendNACK( sock, fuseRoute );
// Don't forget this too!
delete( path );
break;
}
case ShinyFilesystemMediator::CLOSE: {
// Grab the path, just like in open
char * path = parseStringMsg( msgList[3] );
std::string pathStr( path );
// This time, we _only_ check openFiles
std::map<std::string, OpenFileInfo *>::iterator itty = this->openFiles.find( pathStr );
// If it's there,
if( itty != this->openFiles.end() ) {
OpenFileInfo * ofi = (*itty).second;
// decrement the opens!
ofi->opens--;
// Should we purge this ofi from the cache?
if( ofi->opens == 0 ) {
// If we are currently write locked, or we have reads ongoing, we must
// wait 'till those are exuahsted, and so we will just mark ourselves as suicidal
if( ofi->writeLocked || ofi->reads > 0 ) {
// This will cause it to be closed once all READs and WRITEs are finished
ofi->shouldClose = true;
} else
this->closeOFI( itty );
}
// Aaaand, send an ACK, just for fun
sendACK( sock, fuseRoute );
} else {
// NACK! NACK I SAY!
sendNACK( sock, fuseRoute );
}
// You just gotta free it up, fre-fre-free it all up now, 'come on!
delete( path );
break;
}
case ShinyFilesystemMediator::READREQ:
case ShinyFilesystemMediator::WRITEREQ:
case ShinyFilesystemMediator::TRUNCREQ: {
// Grab the path, and the itty
char * path = parseStringMsg( msgList[3] );
std::string pathStr( path );
std::map<std::string, OpenFileInfo *>::iterator itty = this->openFiles.find( pathStr );
// If it is in openFiles,
if( itty != this->openFiles.end() ) {
OpenFileInfo * ofi = (*itty).second;
// first, we put it into our queue of file operations,
zmq::message_t * savedRoute = new zmq::message_t();
savedRoute->copy( fuseRoute );
// Queue this request for later
ofi->queuedFileOperations.push_back( QueuedFO( savedRoute, type ) );
// Then, we try to start up more file operations. the subroutine will check to see
// if we actually can or not. It's amazing! Magical, even.
this->startQueuedFO( sock, ofi );
} else
sendNACK( sock, fuseRoute );
// darn all these paths. :P
delete( path );
break;
}
case ShinyFilesystemMediator::READDONE:
case ShinyFilesystemMediator::WRITEDONE:
case ShinyFilesystemMediator::TRUNCDONE: {
// Grab the path, and the itty
char * path = parseStringMsg( msgList[3] );
std::string pathStr( path );
std::map<std::string, OpenFileInfo *>::iterator itty = this->openFiles.find( pathStr );
// If it is in openFiles,
if( itty != this->openFiles.end() ) {
OpenFileInfo * ofi = (*itty).second;
if( type == ShinyFilesystemMediator::WRITEDONE || type == ShinyFilesystemMediator::TRUNCDONE ) {
// We're not writelocked! (at least, util we start writing again. XD)
ofi->writeLocked = false;
} else if( type == ShinyFilesystemMediator::READDONE ) {
// Decrease the number of concurrently running READS!
ofi->reads--;
}
// Update the file with the serialized version sent back
//LOG( "Updating %s due to a %s", path, (type == READDONE ? "READDONE" : (type == WRITEDONE ? "WRITEDONE" : "TRUNCDONE")) );
const char * data = (const char *) msgList[4]->data();
ofi->file->unserialize(&data);
//delete( fs );
if( !ofi->writeLocked || ofi->reads == 0 ) {
// Check to see if there's stuff queued, and if the conditions are right, start that queued stuff!
if( !ofi->queuedFileOperations.empty() )
this->startQueuedFO( sock, ofi );
else {
// If there is nothing queued, and we should close this file, CLOSE IT!
if( ofi->shouldClose )
this->closeOFI( itty );
}
}
}
delete( path );
break;
}
case ShinyFilesystemMediator::CREATEFILE:
case ShinyFilesystemMediator::CREATEDIR: {
// Grab the path,
char * path = parseStringMsg( msgList[3] );
// See if the file already exists
ShinyMetaNode * node = fs->findNode( path );
if( node ) {
// If it does, I can't very well create a file here, now can I?
sendNACK( sock, fuseRoute );
} else {
// If not, check that the parent exists;
ShinyMetaDir * parent = fs->findParentNode(path);
if( !parent ) {
// If it doesn't, send a NACK!
sendNACK( sock, fuseRoute );
} else {
// Otherwise, let's create the dir/file
if( type == ShinyFilesystemMediator::CREATEFILE )
node = new ShinyMetaFile( ShinyMetaNode::basename( path ), parent );
else
node = new ShinyMetaDir( ShinyMetaNode::basename( path), parent );
// If they have included it, set the permissions away from the defaults
if( msgList.size() > 4 ) {
uint16_t mode = *((uint16_t *) parseDataMsg( msgList[4] ));
node->setPermissions( mode );
}
// And send back an ACK
sendACK( sock, fuseRoute );
}
}
delete( path );
break;
}
case ShinyFilesystemMediator::DELETE: {
// Grab the path,
char * path = parseStringMsg( msgList[3] );
// Check to make sure the file exists
ShinyMetaNode * node = fs->findNode( path );
if( !node ) {
// If it doesn'y, I can't very well delete it, can I?
sendNACK( sock, fuseRoute );
} else {
// Since it exists, let's make sure it's not open right now
std::string pathStr( path );
std::map<std::string, OpenFileInfo *>::iterator itty = this->openFiles.find( pathStr );
// If it is open, queue the deletion for later
if( itty != this->openFiles.end() ) {
OpenFileInfo * ofi = (*itty).second;
ofi->shouldDelete = true;
} else {
// Tell the db to delete him, if it's a file
if( node->getNodeType() == ShinyMetaNode::TYPE_FILE )
((ShinyMetaFile *)node)->setLen( 0 );
// actually delete the sucker
delete( node );
}
// AFFLACK. AFFFFFLAACK.
sendACK( sock, fuseRoute );
}
delete( path );
break;
}
case ShinyFilesystemMediator::RENAME: {
// Grab the path, and the new path
char * path = parseStringMsg( msgList[3] );
char * newPath = parseStringMsg( msgList[4] );
// Check that their parents actually exist
ShinyMetaDir * oldParent = fs->findParentNode( path );
ShinyMetaDir * newParent = fs->findParentNode( newPath );
if( oldParent && newParent ) {
// Now that we know the parents are real, find the child
const char * oldName = ShinyMetaNode::basename( path );
const char * newName = ShinyMetaNode::basename( newPath );
ShinyMetaNode * node = oldParent->findNode( oldName );
if( node ) {
// Check to make sure we need to move it at all
if( oldParent != newParent ) {
oldParent->delNode( node );
newParent->addNode( node );
}
// Don't setName to the same thing we had before, lol
if( strcmp( oldName, newName) != 0 )
node->setName( newName );
// Send an ACK, for a job well done
sendACK( sock, fuseRoute );
} else {
// We cannae faind tha node cap'n!
sendNACK( sock, fuseRoute );
}
} else {
// Oh noes, we couldn't find oldParent or we couldn't find newParent!
sendNACK( sock, fuseRoute );
}
delete( path );
delete( newPath );
break;
}
case ShinyFilesystemMediator::CHMOD: {
// Grab the path, and the new path
char * path = parseStringMsg( msgList[3] );
uint16_t mode = *((uint16_t *) parseDataMsg( msgList[4] ));
// Find node
ShinyMetaNode * node = fs->findNode( path );
if( node ) {
// Set the permissionse
node->setPermissions( mode );
// ACK
sendACK( sock, fuseRoute );
} else
sendNACK( sock, fuseRoute );
delete( path );
break;
}
default: {
WARN( "Unknown ShinyFuse message type! (%d) Sending NACK:", type );
sendNACK( sock, fuseRoute );
break;
}
}
return true;
}