/***************************************************************************** * Close: destroy interface *****************************************************************************/ static void Close(vlc_object_t *p_this) { sout_stream_t *p_stream = (sout_stream_t *)p_this; sout_stream_sys_t *p_sys = p_stream->p_sys; vlc_cancel(p_sys->chromecastThread); vlc_join(p_sys->chromecastThread, NULL); switch (p_sys->i_status) { case CHROMECAST_MEDIA_LOAD_SENT: case CHROMECAST_APP_STARTED: // Generate the close messages. msgClose(p_stream, p_sys->appTransportId); // ft case CHROMECAST_AUTHENTICATED: msgClose(p_stream, "receiver-0"); // Send the just added close messages. sendMessages(p_stream); // ft default: break; } Clean(p_stream); }
KNSingletonApplication::KNSingletonApplication(int &argc, char **argv, const QString uniqueKey) : QApplication(argc, argv), m_messageServer(nullptr), m_uniqueKeyMemeory(new QSharedMemory(uniqueKey, this)), m_isInstanceRunning(false) { //We used the QSharedMemory for singleton detecting. Give the QSharedMemory //the unique key, check the shared memory and we will know whether this is //first instance. if(m_uniqueKeyMemeory->attach()) { //We detect another instance running. m_isInstanceRunning=false; //Get the arguments. QStringList &&pendingMessages=arguments(); //Check out the pending message. If there's valid file path, then it //will be send to the main instance. //Send the messages. if(pendingMessages.size()>1 && sendMessages(uniqueKey, pendingMessages)) { //Complete the mission. return; } } //If we could go here, then means we couldn't send the message to the //previous instance. //Set running instance m_isInstanceRunning=true; //Create a small part of shared memory for instance flag. if(m_uniqueKeyMemeory->size()==0 && (!m_uniqueKeyMemeory->create(1))) { //Unable to create single instance. qDebug("Unable to create the single instance."); return; } //Create a local server for listening incoming message. m_messageServer=new QLocalServer(this); //When there's another instance which is being created, it will send the //arguments to message server from the other instance. connect(m_messageServer, &QLocalServer::newConnection, this, &KNSingletonApplication::onMessageReceive, Qt::QueuedConnection); //The unique key will be used as the connections name as well. if(!m_messageServer->listen(uniqueKey)) { //If we are failed to start listening, and it was caused by address has //been taken, it must be a previous instance crashed and left those data //there. Remove it and listen again. if(QAbstractSocket::AddressInUseError==m_messageServer->serverError()) { //Remove the server and start listen again. QLocalServer::removeServer(uniqueKey); //Start listen once more. m_messageServer->listen(uniqueKey); } } }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void QcPlugin::update() { QcParameter *qcp = _qcProcessor->getState(); if ( _qcProcessor->isValid() ) _qcBuffer->push_back(qcp); sendMessages(qcp->recordEndTime); }
// Extreme laziness function to send a NACK to the other side void sendNACK( zmq::socket_t * sock, zmq::message_t * routing ) { // Send back failure, we couldn't find that node! zmq::message_t nackMsg; buildTypeMsg( ShinyFilesystemMediator::NACK, &nackMsg ); zmq::message_t blankMsg; sendMessages(sock, 3, routing, &blankMsg, &nackMsg ); }
void SenderThread::iterate(lethe::Handle handle) { if(handle == m_channel.getHandle()) receiveMessage(); if(m_messagesSent == m_messagesReleased) sendMessages(); else if(handle == INVALID_HANDLE_VALUE) LogInfo("Sender timed out waiting for all responses"); ++m_iterationCount; }
int connectionSendFrameEnd (int connSock) { assert (connSock != -1); wireworld_message_t message = A_FRAME_END; int res = sendMessages (connSock, &message, 1); if (res == -1) { fprintf (stderr, "Error while sending A_FRAME_END\n"); return -1; } else if (res == 1) { return 1; // End of connection } else { return 0; } }
ShinyFilesystemMediator::~ShinyFilesystemMediator() { zmq::socket_t * killSock = this->getMediator(); // build a message that says "destroy" and send it zmq::message_t destroyMsg; buildTypeMsg( ShinyFilesystemMediator::DESTROY, &destroyMsg ); sendMessages(killSock, 1, &destroyMsg ); if( pthread_join( this->thread, NULL ) != 0 ) { ERROR( "pthread_join() failed on destruction of mediator thread!" ); } // Lol, can't believe I forgot this delete( killSock ); }
void QQmlProfilerService::stateAboutToBeChanged(QQmlDebugService::State newState) { QMutexLocker lock(&m_initializeMutex); if (state() == newState) return; if (state() == Enabled && m_enabled) { stopProfilingImpl(); sendMessages(); } if (state() != Enabled) { // wake up constructor in blocking mode // (we might got disabled before first message arrived) m_initializeCondition.wakeAll(); } }
void QQmlProfilerService::messageReceived(const QByteArray &message) { QMutexLocker lock(&m_initializeMutex); QByteArray rwData = message; QQmlDebugStream stream(&rwData, QIODevice::ReadOnly); bool enabled; stream >> enabled; if (enabled) { startProfilingImpl(); } else { if (stopProfilingImpl()) sendMessages(); } // wake up constructor in blocking mode m_initializeCondition.wakeAll(); }
void update(int sockfd) { int from, to, cost, numbytes; struct top_edge new_edge; while (scanf("%d %d %d", &from, &to, &cost)) { printf("new topology edge: from %d to %d with a distance of %d", from, to, cost); topology[from-1][to-1] = cost; topology[to-1][from-1] = cost; new_edge.from = from; new_edge.cost = cost; new_edge.to = to; for (int i = 0; i < 16; i ++) { if (numbytes = sendto(sockfd, &new_edge, sizeof(new_edge), 0, (struct sockaddr *) &(router_addr[i]), sizeof(router_addr[i])) == -1) { perror("sendto"); exit(1); } } sendMessages(sockfd); } }
void BehaviorsModule::run_ () { PROF_ENTER(P_BEHAVIORS); static unsigned int num_crashed = 0; if (error_state && num_crashed < NUM_PYTHON_RESTARTS_MAX) { this->reload_hard(); error_state = false; num_crashed++; } // Latch incoming messages and prepare outgoing messages prepareMessages(); PROF_ENTER(P_PYTHON); // Call main run() method of Brain if (brain_instance != NULL) { PyObject *result = PyObject_CallMethod(brain_instance, "run", NULL); if (result == NULL) { // set BehaviorsModule in error state error_state = true; // report error std::cout << "Error occurred in Brain.run() method" << std::endl; if (PyErr_Occurred()) { PyErr_Print(); } else { std::cout << " No Python exception information available" << std::endl; } } else { Py_DECREF(result); } } PROF_EXIT(P_PYTHON); // Send outgoing messages sendMessages(); PROF_EXIT(P_BEHAVIORS); }
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; }
void intf_sys_t::handleMessages() { unsigned i_received = 0; uint8_t p_packet[PACKET_MAX_LEN]; bool b_pingTimeout = false; int i_waitdelay = PING_WAIT_TIME; int i_retries = PING_WAIT_RETRIES; bool b_msgReceived = false; uint32_t i_payloadSize = 0; int i_ret = recvPacket(p_stream, b_msgReceived, i_payloadSize, i_sock_fd, p_tls, &i_received, p_packet, &b_pingTimeout, &i_waitdelay, &i_retries); int canc = vlc_savecancel(); // Not cancellation-safe part. #if defined(_WIN32) if ((i_ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK) || (i_ret == 0)) #else if ((i_ret < 0 && errno != EAGAIN) || i_ret == 0) #endif { msg_Err(p_stream, "The connection to the Chromecast died (receiving)."); vlc_mutex_locker locker(&lock); setConnectionStatus(CHROMECAST_CONNECTION_DEAD); vlc_restorecancel(canc); return; } if (b_pingTimeout) { msgPing(); msgReceiverGetStatus(); } if (b_msgReceived) { castchannel::CastMessage msg; msg.ParseFromArray(p_packet + PACKET_HEADER_LEN, i_payloadSize); processMessage(msg); } // Send the answer messages if there is any. if (!messagesToSend.empty()) { i_ret = sendMessages(); #if defined(_WIN32) if ((i_ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK) || (i_ret == 0)) #else if ((i_ret < 0 && errno != EAGAIN) || i_ret == 0) #endif { msg_Err(p_stream, "The connection to the Chromecast died (sending)."); vlc_mutex_locker locker(&lock); setConnectionStatus(CHROMECAST_CONNECTION_DEAD); } } vlc_restorecancel(canc); }
void QQmlDebugService::sendMessage(const QByteArray &message) { sendMessages(QList<QByteArray>() << message); }
int main(int argc, char *argv[]) { if (argc != 3) { perror("usage: manager topologyfile messagefile"); } router_addr = (struct sockaddr_storage *) malloc(sizeof(struct sockaddr_storage) * 16); for (int i = 0; i < 16; i ++) { online[i] = false; exist[i] = false; } int sockfd; struct addrinfo hints, *servinfo, *p; int rv; int numbytes; struct sockaddr_storage their_addr; char buf[MAXBUFLEN]; socklen_t addr_len; char s[INET6_ADDRSTRLEN]; memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; // set to AF_INET to force IPv4 hints.ai_socktype = SOCK_DGRAM; hints.ai_flags = AI_PASSIVE; // use my IP if ((rv = getaddrinfo(NULL, MYPORT, &hints, &servinfo)) != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); return 1; } // loop through all the results and bind to the first we can for(p = servinfo; p != NULL; p = p->ai_next) { if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("manager: socket"); continue; } if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) { close(sockfd); perror("manager: bind"); continue; } break; } if (p == NULL) { fprintf(stderr, "manager: failed to bind socket\n"); return 2; } freeaddrinfo(servinfo); readFiles(argv[1], argv[2]); //start to build topology addr_len = sizeof (router_addr[0]); int id; int terminator = 77; //char adjacent[16]; //int pos = 0; for (int i = 0; i < numNode; i ++) { id = i + 1; if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0, (struct sockaddr *) &(router_addr[id-1]), &addr_len)) == -1) { perror("recvfrom"); exit(1); } //send node ID to node and set it to online online[id-1] = true; if (numbytes = sendto(sockfd, &id, sizeof(id), 0, (struct sockaddr *) &(router_addr[id - 1]), sizeof(router_addr[id - 1])) == -1) { perror("sendto"); exit(1); } printf("set new node with ID %d\n", id); //send adjacent node information to nodes int adjacentnum = 0; for (int i = 0; i < 16; i ++) { if (exist[i] && topology[i][id-1] > 0 && i != id - 1) { adjacentnum ++; } } if (numbytes = sendto(sockfd, &numNode, sizeof(int), 0, (struct sockaddr *) &(router_addr[id-1]), sizeof(router_addr[id-1])) == -1) { perror("sendto"); exit(1); } if (numbytes = sendto(sockfd, &adjacentnum, sizeof(int), 0, (struct sockaddr *) &(router_addr[id-1]), sizeof(router_addr[id-1])) == -1) { perror("sendto"); exit(1); } printf("start sending node %d its neignbor information\n", id); struct adjacent_node n; for (int i = 0; i < 16; i ++) { if (exist[i] && topology[i][id-1] > 0 && i != id - 1) { //set adjacent node values n.id = i + 1; if(online[i]) { memcpy(&(n.router_addr),&(router_addr[i]), sizeof(struct sockaddr_storage)); n.online = true; } else { // n.router_addr = NULL; n.online = false; } n.cost = topology[i][id-1]; //send adjacent node value information to nodes if (numbytes = sendto(sockfd, &n, sizeof(n), 0, (struct sockaddr *) &(router_addr[id-1]), sizeof(router_addr[id-1])) == -1) { perror("sendto"); exit(1); } } } printf("finish sending neighbor information\n"); //if a new node is online, should send this update to all adjacent nodes that are already online n.id = id; n.online = true; // n.router_addr = router_addr[id-1]; memcpy(&(n.router_addr),&(router_addr[id-1]), sizeof(struct sockaddr_storage)); for (int i = 0; i < 16 ; i ++) { if(exist[i] && topology[i][id-1] > 0 && i != id-1 && online[i]) { //n.cost = topology[i][id-1]; if (numbytes = sendto(sockfd, &id, sizeof(id), 0, (struct sockaddr *) &(router_addr[i]), sizeof(router_addr[i])) == -1) { perror("sendto"); exit(1); } if (numbytes = sendto(sockfd, &(router_addr[id-1]), sizeof(router_addr[id-1]), 0, (struct sockaddr *) &(router_addr[i]), sizeof(router_addr[i])) == -1) { perror("sendto"); exit(1); } /* if (numbytes = sendto(sockfd, &n, sizeof(n), 0, (struct sockaddr *) &(router_addr[i]), sizeof(router_addr[i])) == -1) { perror("sendto"); exit(1); } */ } } /* if ((numbytes = sendto(sockfd, &terminator, sizeof(terminator), 0, router_addr[id-1], sizeof(router_addr[id-1])) == -1) { perror("sendto"); exit(1); } */ } printf("All nodes are online now!\n"); //broadcast information that all nodes are online char temp[2]; temp[0] = 's'; temp[1] = '\0'; for (int i = 0; i < 16; i ++) { if(exist[i] && online[i]) { if (numbytes = sendto(sockfd, temp, sizeof(temp), 0, (struct sockaddr *) &(router_addr[i]), sizeof(router_addr[i])) == -1) { perror("sendto"); exit(1); } } } //wait for all nodes to announce convergence int finished = 0; temp[0] = 'f'; temp[1] = '\0'; while (finished != numNode) { if ((numbytes = recvfrom(sockfd, buf, MAXBUFLEN-1 , 0, (struct sockaddr *)&their_addr, &addr_len)) == -1) { perror("recvfrom"); exit(1); } if(!strcmp(temp, buf)) finished ++; } //send messgae information to corresponding nodes sendMessages(sockfd); update(sockfd); close(sockfd); return 0; }
MessageModel::StatusCode MessageModel::sendMessages(const QList<SendMessagesRecipient> &recipients) { return sendMessages(recipients, "anon"); }
/***************************************************************************** * Chromecast thread *****************************************************************************/ static void* chromecastThread(void* p_data) { int canc = vlc_savecancel(); // Not cancellation-safe part. sout_stream_t* p_stream = (sout_stream_t*)p_data; sout_stream_sys_t* p_sys = p_stream->p_sys; unsigned i_received = 0; char p_packet[PACKET_MAX_LEN]; bool b_pingTimeout = false; int i_waitdelay = PING_WAIT_TIME; int i_retries = PING_WAIT_RETRIES; msgAuth(p_stream); sendMessages(p_stream); vlc_restorecancel(canc); while (1) { bool b_msgReceived = false; uint32_t i_payloadSize = 0; int i_ret = recvPacket(p_stream, b_msgReceived, i_payloadSize, p_sys->i_sock_fd, p_sys->p_tls, &i_received, p_packet, &b_pingTimeout, &i_waitdelay, &i_retries); canc = vlc_savecancel(); // Not cancellation-safe part. #if defined(_WIN32) if ((i_ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK) || (i_ret == 0)) #else if ((i_ret < 0 && errno != EAGAIN) || i_ret == 0) #endif { msg_Err(p_stream, "The connection to the Chromecast died."); vlc_mutex_locker locker(&p_sys->lock); p_sys->i_status = CHROMECAST_CONNECTION_DEAD; atomic_store(&p_sys->ab_error, true); break; } if (b_pingTimeout) { msgPing(p_stream); msgStatus(p_stream); } if (b_msgReceived) { castchannel::CastMessage msg; msg.ParseFromArray(p_packet + PACKET_HEADER_LEN, i_payloadSize); processMessage(p_stream, msg); } // Send the answer messages if there is any. if (!p_sys->messagesToSend.empty()) { i_ret = sendMessages(p_stream); #if defined(_WIN32) if ((i_ret < 0 && WSAGetLastError() != WSAEWOULDBLOCK) || (i_ret == 0)) #else if ((i_ret < 0 && errno != EAGAIN) || i_ret == 0) #endif { msg_Err(p_stream, "The connection to the Chromecast died."); vlc_mutex_locker locker(&p_sys->lock); p_sys->i_status = CHROMECAST_CONNECTION_DEAD; } } vlc_mutex_lock(&p_sys->lock); if ( p_sys->i_status == CHROMECAST_CONNECTION_DEAD ) { atomic_store(&p_sys->ab_error, true); vlc_mutex_unlock(&p_sys->lock); break; } vlc_mutex_unlock(&p_sys->lock); vlc_restorecancel(canc); } return NULL; }
void OscService::update(){ if(connected){ sendMessages(); } }
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void QcPlugin::done() { sendMessages(Core::Time()); }
static void negotiate(SecOTRSessionRef* aliceSession, SecOTRSessionRef* bobSession, bool serializeNegotiating, bool serializeMessaging, bool textMode, bool compact) { const int kEmptyMessageSize = textMode ? 6 : 0; // Step 1: Create a start packet for each side of the transaction CFMutableDataRef bobStartPacket = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSAppendStartPacket(*bobSession, bobStartPacket), "Bob start packet"); if (serializeNegotiating) serializeAndDeserialize(bobSession); CFMutableDataRef aliceStartPacket = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSAppendStartPacket(*aliceSession, aliceStartPacket), "Alice start packet"); if (serializeNegotiating) serializeAndDeserialize(aliceSession); // Step 2: Exchange the start packets, forcing the DH commit messages to collide CFMutableDataRef aliceDHKeyResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*aliceSession, bobStartPacket, aliceDHKeyResponse), "Bob DH packet failed"); if (serializeNegotiating) serializeAndDeserialize(aliceSession); CFReleaseNull(bobStartPacket); CFMutableDataRef bobDHKeyResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*bobSession, aliceStartPacket, bobDHKeyResponse), "Alice DH packet failed"); if (serializeNegotiating) serializeAndDeserialize(bobSession); CFReleaseNull(aliceStartPacket); // Step 3: With one "real" DH key message, and one replayed DH commit message, try to get a "reveal sig" out of one side CFMutableDataRef bobRevealSigResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*bobSession, aliceDHKeyResponse, bobRevealSigResponse), "Alice DH Key packet failed"); if (serializeNegotiating) serializeAndDeserialize(bobSession); CFReleaseNull(aliceDHKeyResponse); CFMutableDataRef aliceRevealSigResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*aliceSession, bobDHKeyResponse, aliceRevealSigResponse), "Bob DH Key packet failed"); if (serializeNegotiating) serializeAndDeserialize(aliceSession); CFReleaseNull(bobDHKeyResponse); // Step 4: Having gotten the reveal signature, now work for the signature CFMutableDataRef aliceSigResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*aliceSession, bobRevealSigResponse, aliceSigResponse), "Bob Reveal sig failed"); if (serializeNegotiating) serializeAndDeserialize(aliceSession); CFReleaseNull(bobRevealSigResponse); CFMutableDataRef bobSigResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*bobSession, aliceRevealSigResponse, bobSigResponse), "Alice Reveal sig failed"); if (serializeNegotiating) serializeAndDeserialize(bobSession); CFReleaseNull(aliceRevealSigResponse); // Step 5: All the messages have been sent, now deal with any replays from the collision handling CFMutableDataRef bobFinalResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*bobSession, aliceSigResponse, bobFinalResponse), "Alice Final Sig failed"); if (serializeNegotiating) serializeAndDeserialize(bobSession); CFMutableDataRef aliceFinalResponse = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSProcessPacket(*aliceSession, bobSigResponse, aliceFinalResponse), "Bob Final Sig failed"); is(kEmptyMessageSize, CFDataGetLength(aliceFinalResponse), "Alice had nothing left to say"); CFReleaseNull(aliceFinalResponse); CFReleaseNull(bobSigResponse); if (serializeNegotiating) serializeAndDeserialize(aliceSession); is(kEmptyMessageSize, CFDataGetLength(bobFinalResponse), "Bob had nothing left to say"); ok(SecOTRSGetIsReadyForMessages(*bobSession), "Bob is ready"); ok(SecOTRSGetIsReadyForMessages(*aliceSession), "Alice is ready"); CFReleaseNull(aliceSigResponse); CFReleaseNull(bobFinalResponse); sendMessages(5, bobSession, aliceSession, serializeMessaging); const char* aliceToBob = "deferredMessage"; CFDataRef rawAliceToBob = CFDataCreate(kCFAllocatorDefault, (const uint8_t*)aliceToBob, (CFIndex) strlen(aliceToBob)); CFMutableDataRef protectedAliceToBob = CFDataCreateMutable(kCFAllocatorDefault, 0); CFMutableDataRef bobDecode = CFDataCreateMutable(kCFAllocatorDefault, 0); ok_status(SecOTRSSignAndProtectMessage(*aliceSession, rawAliceToBob, protectedAliceToBob), "encode message"); sendMessages(1, bobSession, aliceSession, serializeMessaging); is(SecOTRSVerifyAndExposeMessage(*bobSession, protectedAliceToBob, bobDecode), errSecOTRTooOld, "Decode old message"); sendMessages(1, bobSession, aliceSession, serializeMessaging); is(SecOTRSVerifyAndExposeMessage(*bobSession, protectedAliceToBob, bobDecode), errSecOTRTooOld, "Decode excessively old message"); sendMessages(3, bobSession, aliceSession, serializeMessaging); CFReleaseNull(rawAliceToBob); CFReleaseNull(protectedAliceToBob); CFReleaseNull(bobDecode); }