cmd_type commBase::read() { //Required - insures we can read the packets startListening(); cmd_type ret = PKT_EMPTY; byte packet[PACKET_SIZE]; //packet buffer if (com.available()) { delay(5); com.read(packet, PACKET_SIZE); } else return ret; for (int i = 0; i < PACKET_SIZE; i++) PT(packet[i]); PTL(); byte cmd = packet[0]; //first packet gives the type of packet if (cmd == PKT_UPDATE_TEMPERATURE) { PT("Updating Temp "); float * value = (float*)&packet[1]; temperature_sensor = *value; ret = PKT_UPDATE_TEMPERATURE; PTL(*value); } // stopListening(); return ret; }
eServerSocket::eServerSocket(int port, eMainloop *ml): eSocket(ml) { int res; struct addrinfo *addr = NULL; struct addrinfo hints; char portnumber[16]; okflag = 0; strRemoteHost = ""; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; /* both ipv4 and ipv6 */ hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; /* any */ #ifdef AI_ADDRCONFIG hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_ADDRCONFIG; /* only return ipv6 if we have an ipv6 address ourselves, and ipv4 if we have an ipv4 address ourselves */ #else hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* AI_ADDRCONFIG is not available */ #endif snprintf(portnumber, sizeof(portnumber), "%d", port); if ((res = getaddrinfo(NULL, portnumber, &hints, &addr)) || !addr) { eDebug("[eServerSocket] getaddrinfo: %s", gai_strerror(res)); return; } if (startListening(addr) >= 0) { okflag = 1; rsn->setRequested(eSocketNotifier::Read); } freeaddrinfo(addr); }
FileTransferServer::FileTransferServer(QString file, bool isSender, QTcpSocket* withWho, QObject *parent) : m_fileName(file), m_state(IDLE), m_sender(isSender), m_withWho(withWho) { m_parentThread = QThread::currentThread(); connect(&m_serverThread, SIGNAL(started()), this, SLOT(startListening())); }
eServerSocket::eServerSocket(std::string path, eMainloop *ml) : eSocket(ml) { struct sockaddr_un serv_addr_un; struct addrinfo addr; okflag = 0; strRemoteHost = ""; memset(&serv_addr_un, 0, sizeof(serv_addr_un)); serv_addr_un.sun_family = AF_LOCAL; strcpy(serv_addr_un.sun_path, path.c_str()); memset(&addr, 0, sizeof(addr)); addr.ai_family = AF_LOCAL; addr.ai_socktype = SOCK_STREAM; addr.ai_protocol = 0; /* any */ addr.ai_addr = (struct sockaddr *)&serv_addr_un; addr.ai_addrlen = sizeof(serv_addr_un); unlink(path.c_str()); if (startListening(&addr) >= 0) { okflag = 1; rsn->setRequested(eSocketNotifier::Read); } }
void UdpAsyncComm::listen(UdpPacketCallback receive) { if (!listener) startListening(); onUnhandledReceive = receive; }
static void initHardware(void) { Chip_SetupXtalClocking(); Chip_SYSCTL_SetFLASHAccess(FLASHTIM_100MHZ_CPU); SystemCoreClockUpdate(); /*====================[PARA MODULO RF]====================*/ Chip_GPIO_WriteDirBit(LPC_GPIO, CE_PIN, 1); //Puerto CE Chip_GPIO_SetPinOutLow(LPC_GPIO, CE_PIN); //Puerto CE InitSPI (); begin(); setPALevel(RF24_PA_LOW); openWritingPipe(&addresses2[0]); openReadingPipe(1,&addresses1[0]); //1Node: Transmite paquetes el tx por este pide (addres) startListening(); /*========================================================*/ // Board_Init(); // Board_LED_Set(0, false); SysTick_Config(SystemCoreClock/1000); //1000 ticks por segundo InitPWM_motores(0); //Función inicialización modulo PWM InitPWM_motores(1); //Función inicialización modulo PWM InitPWM_motores(2); //Función inicialización modulo PWM InitPWM_motores(3); //Función inicialización modulo PWM InitPWM0(); InitGPIO(0); //Llamo función para inicializar GPIO InitGPIO(1); //Llamo función para inicializar GPIO InitGPIO(2); //Llamo función para inicializar GPIO InitGPIO(3); //Llamo función para inicializar GPIO Stop_and_Default(0); //Condiciones iniciales Stop_and_Default(1); //Condiciones iniciales Stop_and_Default(2); //Condiciones iniciales Stop_and_Default(3); //Condiciones iniciales P2_6ER = 1; P2_7ER = 1; P2_8ER = 1; P2_6EF = 1; P2_7EF = 1; P2_8EF = 1; P0_15ER = 1; P0_16ER = 1; P2_9ER = 1; P0_15EF = 1; P0_16EF = 1; P2_9EF = 1; NVIC_SetPriority(EINT3_IRQn,1); //Le pongo la mayor prioridad a la interrupcion NVIC_EnableIRQ(EINT3_IRQn); }
RpcService::RpcService(const char* path, int port) : IOHandler(), _path(path), _port(port), _service(new rpcbuf), _running(false) { startListening(); }
bool Server::serve(const char* staticPath, int port) { setStaticPath(staticPath); if (!startListening(port)) { return false; } return loop(); }
void DeviceEventDispatcherBase::addController(DeviceEventControllerBase* controller) { bool wasEmpty = m_controllers.isEmpty(); if (!m_controllers.contains(controller)) m_controllers.append(controller); if (wasEmpty) startListening(); }
void PlatformEventDispatcher::addController(PlatformEventController* controller) { bool wasEmpty = m_controllers.isEmpty(); if (!m_controllers.contains(controller)) m_controllers.append(controller); if (wasEmpty) startListening(); }
RpcService::RpcService(int port) : IOHandler(), _path(nil), _port(port), _service(new rpcbuf), _running(false) { startListening(); }
SocketServer::SocketServer(int id, unsigned short port, ISocketCallback* callback) : id_(id), port_(port), callback_(callback), clientSocket_(0), serverSocket_(0) { startListening(); }
int establishConnection(){ int serverSock,clientSock; serverSock=createTcpSocket(); bindToIpv4(serverSock,ip_addr,port_no); startListening(serverSock,2); clientSock=acceptConnections(serverSock); return clientSock; }
void handleConnect (RPCServerImp::pointer new_connection, boost::system::error_code const& error) { bool delay = false; if (!error) { // Restrict callers by IP // VFALCO NOTE Prevent exceptions from being thrown at all. try { if (! isClientAllowed (new_connection->getRemoteAddressText ())) { startListening (); return; } } catch (...) { // client may have disconnected startListening (); return; } new_connection->getSocket ().async_handshake (AutoSocket::ssl_socket::server, boost::bind (&RPCServer::connected, new_connection)); } else { if (error == boost::system::errc::too_many_files_open) delay = true; WriteLog (lsINFO, RPCDoor) << "RPCDoorImp::handleConnect Error: " << error; } if (delay) { mDelayTimer.expires_from_now (boost::posix_time::milliseconds (1000)); mDelayTimer.async_wait (boost::bind (&RPCDoorImp::startListening, this)); } else { startListening (); } }
void ServerClientProxy::threadedFunction(){ startListening(); while(isThreadRunning()) { this->update(); this->listenTCP(); this->synchronizeSpeeds(); sleep(25); } TCP.close(); }
SocketServer::SocketServer(int id, unsigned short port, ISocketCallback* callback, int timeoutSeconds, int timeoutMicroseconds) : id_(id), port_(port), callback_(callback), clientSocket_(0), serverSocket_(0), timeoutSeconds_(timeoutSeconds), timeoutMicroseconds_(timeoutMicroseconds) { startListening(); }
listener::listener(const char *id, bool listening) { #ifdef WIN32 this->id = _strdup(id); #else this->id = strdup(id); #endif this->listening = false; if (listening) { startListening(); } }
/* * Host constructor: opens a socket on the specified port * and listens for and accepts connections (on separate thread if specified). */ tcpSocket::tcpSocket(int port, bool threaded) { std::cout << "opening port " << port << std::endl; this->port = port; this->threaded = threaded; openSocket(); startListening(); std::thread t(&tcpSocket::acceptConnections, this); t.detach(); }
void commBase::begin() { com.begin(); // Set the PA Level low to prevent power supply related issues since this is a // getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default. com.setPALevel(RF24_PA_LOW); com.openWritingPipe(ADDR_BASE); com.openReadingPipe(1,ADDR_REMOTE); // Start the radio listening for data startListening(); }
int main(int argc, char *argv[]){ int numPort,longMax,socketIdC,i=0,j=0; socketStruct *socketStC; pthread_t thread_id[100]; /***/ int valor,proc; char * retorno; char **mensaje; int read_size; int len; char limitador[2] = "\r\n"; char *ptr; char ** contestacion; /***/ if(argc != 4){ printf("Error en el numero de parametros\n"); return ERROR; } usersHash_init(); channelsHash_init(); numPort = atoi(argv[2]); longMax = atoi(argv[3]); strcpy(servidor,argv[1]); if(initServer(argv[1],numPort,longMax)==ERROR){ syslog(LOG_ERR,"Error al abrir el servidor\n"); exit(ERROR); } i=0; syslog(LOG_INFO,"Esperando conexion\n"); socketStC = (socketStruct*) calloc(512,sizeof(socketStruct)); while(1){ socketIdC = startListening(socketId); if(socketIdC < 0){ syslog(LOG_ERR,"Error al conectar con el cliente \n"); return ERROR; } socketStC[socketIdC].socketId = socketIdC; socketStC[socketIdC].buffer = calloc (50,sizeof(char)); if(pthread_create(&thread_id[i],NULL,conexionCliente,(void*) &socketStC[socketIdC]) < 0){ printf("No se ha podido crear el hilo.\n"); return ERROR; } i++; } return OK; }
void handleConnect (RPCServerImp::pointer new_connection, boost::system::error_code const& error) { bool delay = false; if (!error) { // Restrict callers by IP std::string client_ip ( new_connection->getRemoteEndpoint ().address ().to_string ()); if (! isClientAllowed (client_ip)) { startListening (); return; } new_connection->getSocket ().async_handshake (AutoSocket::ssl_socket::server, std::bind (&RPCServer::connected, new_connection)); } else { if (error == boost::system::errc::too_many_files_open) delay = true; WriteLog (lsINFO, RPCDoor) << "RPCDoorImp::handleConnect Error: " << error; } if (delay) { mDelayTimer.expires_from_now (boost::posix_time::milliseconds (1000)); mDelayTimer.async_wait (std::bind (&RPCDoorImp::startListening, this)); } else { startListening (); } }
void MainWindow::toggleRun(bool buttonPressed) { if (buttonPressed) { ui->pushButtonRun->setText("stop"); params->setOutputDir(ui->lineEdit->text()); qDebug() << "Setting output dir: " << params->getOutDir().absolutePath(); emit startListening(); } else { emit stopListening(); ui->pushButtonRun->setText("run "); newSession(); } }
void TcpAsyncServer::handle_accept(std::shared_ptr<TcpAsyncStream> connection, const boost::system::error_code& error) { if (!error) { connection->setAsConnected(); if (acceptCallback) acceptCallback(connection); startListening(); } else TCP_LOG("accept: " << error.message()) }
void PlatformEventDispatcher::addController(PlatformEventController* controller) { ASSERT(controller); // TODO: If we can avoid to register a same controller twice, we can change // this 'if' to ASSERT. if (m_controllers.contains(controller)) return; m_controllers.add(controller); if (!m_isListening) { startListening(); m_isListening = true; } }
RPCDoorImp (boost::asio::io_service& io_service, RPCServer::Handler& handler) : m_rpcServerHandler (handler) , mAcceptor (io_service, boost::asio::ip::tcp::endpoint (boost::asio::ip::address::from_string (getConfig ().getRpcIP ()), getConfig ().getRpcPort ())) , mDelayTimer (io_service) , m_sslContext ((getConfig ().RPC_SECURE == 0) ? RippleSSLContext::createBare () : RippleSSLContext::createAuthenticated ( getConfig ().RPC_SSL_KEY, getConfig ().RPC_SSL_CERT, getConfig ().RPC_SSL_CHAIN)) { WriteLog (lsINFO, RPCDoor) << "RPC port: " << getConfig ().getRpcAddress().toRawUTF8() << " allow remote: " << getConfig ().RPC_ALLOW_REMOTE; startListening (); }
Server::Server() { // Sets listeners as non-blocking. listener.setBlocking(false); // Opens thread to listen. startListening(); // Initializes random seed. srand(time(NULL)); // Initializes first position to be filled later. // The clients vectors must always have one free position for someone to fill. // Reason: sf::TcpSocket not copyable/movable. clients.emplace_back(); }
void DlgPrefController::showLearningWizard() { // If the user has checked the "Enabled" checkbox but they haven't hit OK to // apply it yet, prompt them to apply the settings before we open the // learning dialog. If we don't apply the settings first and open the // device, the dialog won't react to controller messages. if (m_ui.chkEnabledDevice->isChecked() && !m_pController->isOpen()) { QMessageBox::StandardButton result = QMessageBox::question( this, tr("Apply device settings?"), tr("Your settings must be applied before starting the learning wizard.\n" "Apply settings and continue?"), QMessageBox::Ok | QMessageBox::Cancel, // Buttons to be displayed QMessageBox::Ok); // Default button // Stop if the user has not pressed the Ok button, // which could be the Cancel or the Close Button. if (result != QMessageBox::Ok) { return; } } slotApply(); // After this point we consider the mapping wizard as dirtying the preset. slotDirty(); // Note that DlgControllerLearning is set to delete itself on close using // the Qt::WA_DeleteOnClose attribute (so this "new" doesn't leak memory) m_pDlgControllerLearning = new DlgControllerLearning(this, m_pController); m_pDlgControllerLearning->show(); ControllerLearningEventFilter* pControllerLearning = m_pControllerManager->getControllerLearningEventFilter(); pControllerLearning->startListening(); connect(pControllerLearning, SIGNAL(controlClicked(ControlObject*)), m_pDlgControllerLearning, SLOT(controlClicked(ControlObject*))); connect(m_pDlgControllerLearning, SIGNAL(listenForClicks()), pControllerLearning, SLOT(startListening())); connect(m_pDlgControllerLearning, SIGNAL(stopListeningForClicks()), pControllerLearning, SLOT(stopListening())); connect(m_pDlgControllerLearning, SIGNAL(stopLearning()), this, SLOT(show())); connect(m_pDlgControllerLearning, SIGNAL(inputMappingsLearned(MidiInputMappings)), this, SLOT(midiInputMappingsLearned(MidiInputMappings))); emit(mappingStarted()); connect(m_pDlgControllerLearning, SIGNAL(stopLearning()), this, SIGNAL(mappingEnded())); }
bool NetworkManager::startConnection() { bool cont = true; while (cont) { // Server setup if (m_configDialog->isServer()) { cont = !startListening(); m_port = m_configDialog->getPort(); } else { m_port = m_configDialog->getPort(); m_address = m_configDialog->getHost(); if(startConnectionToServer()) { cont = false; } } if(cont) { m_dialog->startTimer(); int value = m_dialog->exec(); if(value == QDialog::Accepted) { cont = true; } else { cont = false; return false; } } } m_playersList->sendOffLocalPlayerInformations(); m_playersList->sendOffFeatures(m_localPlayer); setConnectionState(true); return true; }
QWidget *TcpServerListener::requestGui(QWidget *parent) { NetworkConfWidget *ncw = new(std::nothrow)NetworkConfWidget(NetworkConfWidget::TCP_SERVER,parent); if (ncw == NULL) { qFatal("Cannot allocate memory for NetworkConfWidget X{"); } ncw->setPort(port); ncw->setIP(listeningAddress); ncw->enableDecodeEncodeOption(true); connect(ncw, SIGNAL(newIp(QHostAddress)), this, SLOT(setListeningAddress(QHostAddress))); connect(ncw, SIGNAL(newPort(quint16)), this, SLOT(setPort(quint16))); connect(ncw, SIGNAL(start()), this, SLOT(startListening())); connect(ncw, SIGNAL(stop()), this, SLOT(stopListening())); connect(ncw,SIGNAL(restart()), this, SLOT(restart())); connect(this, SIGNAL(started()), ncw, SLOT(onServerStarted())); connect(this, SIGNAL(stopped()), ncw, SLOT(onServerStopped())); return ncw; }
void TcpServerListener::handlingClient(int socketDescriptor) #endif { TcpListener * listener = new(std::nothrow) TcpListener(socketDescriptor); if (listener != NULL) { // qDebug() << "Listener created" << listener; listener->setDecodeinput(decodeInput); listener->setEncodeOutput(encodeOutput); clients.append(listener); listener->moveToThread(workerThread); connect(listener, SIGNAL(blockReceived(Block)), SLOT(onClientReceivedBlock(Block))); connect(listener, SIGNAL(stopped()), SLOT(clientFinished())); connect(listener, SIGNAL(error(QString,QString)), SIGNAL(error(QString,QString))); connect(listener, SIGNAL(status(QString,QString)), SIGNAL(status(QString,QString))); QTimer::singleShot(0,listener,SLOT(startListening())); } else { qFatal("Cannot allocate memory for TcpListener X{"); } }