void IpcServer::testCaseShutdownOnRequest() { LOG4CPLUS_TRACE_METHOD(mLogger, __PRETTY_FUNCTION__); mIpc->beginWaitForConnection(); for (int i = 0; i < mClientsNumber; i++) { mConnectionSema.wait(); } mIpc->endWaitForConnection(); assert (mIpc->isConnected()); assert (mClients.size() == mClientsNumber); LOG4CPLUS_INFO(mLogger, "Established connection with all expected clients: " + convertIntegerToString(mClientsNumber)); if (mClientsNumber == 1) { sendPing(); sendKill(); } else { for (int i = 0; i < mClientsNumber; i++) { sendPing(&mClients.at(i)); } for (int i = 0; i < mClientsNumber; i++) { sendKill(&mClients.at(i)); } } LOG4CPLUS_INFO(mLogger, "Test passed successfully!"); }
void GGWrapper::enterLoop() { while(!mWorkerThread.interruption_requested()) { boost::any item = mpQueue->poll(); if(item.empty()) { //Logger::log("Looping\r\n"); gg_event *event = pollGGEvent(); if(event != 0) { processGGEvent(*event); gg_free_event(event); } } else { processEvent(boost::any_cast<ggEvent&>(item)); } sendPing(); } Logger::log("Finished Looping!"); //probably here some cleaning or just do everything in destructor; }
//----------------------------------------------------------------------------- int IoHandler::openComPort(const QString &portName) { unsigned int baudrate; // Determine baudrate; the MSP430 Virtual UART only supports 9600 baudrate= portName.contains("MSP430 Application UART") ? 9600: 38400; if (comPort->Open(portName,baudrate)) { if (comPort->Read()) { // Check that the connection is established with a ping. // Start a one shot timer to check if ping response has been received. sendPing(); pingAnswered = false; QTimer::singleShot(TIMER_PING, this, SLOT(checkPing())); return IO_SUCCESS; } else { return IO_ERROR; } } else { return IO_ERROR; } }
void Transmitter::enableAutoPing(bool enable) { if (!enable) { // Disable autopinging, if running if (autoPing) { autoPing->stop(); delete autoPing; autoPing = NULL; return; } } // Start autopinging, if not not running already if (autoPing) { return; } autoPing = new QTimer(); // Send ping every second (sending a high priority package restarts the timer) connect(autoPing, SIGNAL(timeout()), this, SLOT(sendPing())); autoPing->start(1000); }
tlen::tlen( QObject* parent ): QObject( parent ) { state = tlen::Disconnected; hostname = "s1.tlen.pl"; hostport = 443; Secure = false; Reconnect = false; Status= tlen::unavailable; Descr=""; tmpDoc=new QDomDocument; socket=new QTcpSocket(); ping=new QTimer(); connect(socket, SIGNAL(connected()), this, SLOT(socketConnected())); connect(socket, SIGNAL(readyRead()), this, SLOT(socketReadyRead())); connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); connect(this, SIGNAL(tlenLoggedIn()), this, SLOT(writeStatus())); connect(this, SIGNAL(statusUpdate()), this, SLOT(writeStatus())); connect(this, SIGNAL(eventReceived(QDomNode)), this, SLOT(event(QDomNode))); connect(ping, SIGNAL(timeout()), this, SLOT(sendPing())); srand(time(NULL)); }
WSMessageRequest TembooMessaging::poll() { startMessaging(); long int now = millis(); WSMessageRequest rc = WS_NO_MESSAGE; while (millis() - now < POLL_TIMEOUT) { if (millis() - m_lastPingTime >= MCU_PING_PERIOD_MS) { m_lastPingTime = millis(); sendPing(); } if (Mailbox.messageAvailable()) { uint8_t msg[MAX_MAILBOX_MESSAGE_SIZE] = {0}; int recvLen = Mailbox.readMessage(msg, MAX_MAILBOX_MESSAGE_SIZE); if (recvLen > 0) { rc = handleResponse(msg, m_sensorTable, m_sensorTableDepth, m_connectionStatus); if (rc == WS_UPDATE_CONNECTED) { //logTembooDebug("Connected to Temboo"); m_connectionStatus = true; } else if (rc == WS_UPDATE_DISCONNECTED) { //logTembooDebug("Disconnected from Temboo"); m_connectionStatus = false; } else if (rc == WS_REQUEST_ERROR) { // disconnect sendError("Message request error"); } } } } return rc; }
// --------------------------------------------------------------------------------------------------------------------------------------------------- // void CommonTimeBase::_update(ofEventArgs &e) { int currentLocalMillis = getInternalTimeMillis(); if( (currentLocalMillis-lastPingSentTimeMillis) > millisBetweenPings ) { sendPing(); lastPingSentTimeMillis = currentLocalMillis; } // Ease the timing offset if this is activated if( easeOffset ) { if( offsetMillis != offsetMillisTarget ) { float tmpDiff = (offsetMillisTarget-offsetMillis)/10.0; if( fabsf(tmpDiff) < 1.0f ) { offsetMillis = offsetMillisTarget; } else { offsetMillis += tmpDiff; } } } else { offsetMillis = offsetMillisTarget; } }
void sig_alrm (int signo){ if(isTourOver == 0){ sendPing(); alarm(1); } return; }
/** * This callback is triggered when the service receives a job. * The job can be addressed to this service or to another service. */ void JobHandler::notifyMessage(const JobInfo *job) { xlog::trace(className, "notifyMessage"); if (! job) { xlog::warn(className, "notifyMessage", "empty message"); return; } if (job->jobID == BroadcastStartupID) { // sent on master start xlog::debug(className, "notifyMessage", "master started"); sendPing(); m_ignoreBroadcast = false; } else if (job->jobID == BroadcastID) { // broadcast from the master if (! m_ignoreBroadcast) { sendPing(); xlog::debug(className, "notifyMessage", "replied to broadcast"); m_ignoreBroadcast = true; } else { xlog::debug(className, "notifyMessage", "broadcast ignored"); m_broadcastCounter++; if (m_broadcastCounter > MaxBroadcastNumber) { m_ignoreBroadcast = false; m_broadcastCounter= 0; } } } else if (m_serviceId == job->handlerID) { // if the current instructions are for this processor, launch the process m_available = false; handle(job); m_available = true; m_ignoreBroadcast = false; } else { // job for another service xlog::debug(className, "notifyMessage", ("message to "+job->handlerID).c_str()); } }
int main () { std::string addr = "10.1.15.8"; int port = 5810; udp_client_server::udp_client client (addr, port); sendPing(client); return 0; }
NetworkMonitor::NetworkMonitor( int listenPort, int sendPort ) { this->listenPort = listenPort; this->sendPort = sendPort; connect( &socket, SIGNAL(readyRead()), this, SLOT( processPendingDatagrams() ) ); connect( &pingTimer, SIGNAL( timeout() ), this, SLOT( sendPing() ) ); createPing( ); }
double GetTime () { struct timeval tp; (void) gettimeofday( &tp, NULL ); sendPing (); return (tp.tv_sec + ((double) tp.tv_usec)/1000000.0); }
Client::Client(QTcpSocket *socket, FenPrincipale *parent) : m_parent(parent), m_socket(socket), m_taillePaquet(0), m_pseudo(""), m_account(""), m_loginLevel(0), m_idCompte(0), m_logoutMessage(""), m_sessionState(NOT_CHECKED), m_channel(0), m_pingsPending(0), m_ping(0) { connect(m_socket, SIGNAL(readyRead()), this, SLOT(donneesRecues())); connect(m_socket, SIGNAL(disconnected()), this, SLOT(deconnexion())); //Création du timer pour le lancement des pings. m_pingTimer = new QTimer(this); connect(m_pingTimer, SIGNAL(timeout()), this, SLOT(sendPing())); m_pingTimer->start(m_parent->getPingInterval()); sendPing(); //On lance un ping //Génération du hash de l'IP. //4 caractères hexa. m_hashIP = QCryptographicHash::hash(m_socket->peerAddress().toString().toUtf8(), QCryptographicHash::Md5).toHex().left(4); }
void sJarvisNode::ping() { sendPing(); qDebug() << "KeepATimer:" <<m_keepAliveTimer.elapsed(); if(m_keepAliveTimer.elapsed() > 25000) { emit rawInput("Timeout, Disconnected!"); this->closeTCP(); } }
KegMeterConnection::KegMeterConnection(MainWindow* mainWindow, QObject* parent) : QTcpSocket(parent), mainWindow(mainWindow) { assert(mainWindow != NULL); QObject::connect(this, SIGNAL(readyRead()), this, SLOT(processReadyRead())); QObject::connect(this, SIGNAL(disconnected()), &this->pingTimer, SLOT(stop())); QObject::connect(&this->pingTimer, SIGNAL(timeout()), this, SLOT(sendPing())); QObject::connect(this, SIGNAL(connected()), this, SLOT(onConnected())); }
// Incoming message which has passed through the cryptoauth and needs to be forwarded to the switch. static Iface_DEFUN receivedPostCryptoAuth(struct Message* msg, struct Peer* ep, struct InterfaceController_pvt* ic) { ep->bytesIn += msg->length; int caState = CryptoAuth_getState(ep->caSession); if (ep->state < InterfaceController_PeerState_ESTABLISHED) { // EP states track CryptoAuth states... ep->state = caState; SwitchCore_setInterfaceState(&ep->switchIf, SwitchCore_setInterfaceState_ifaceState_UP); Bits_memcpy(ep->addr.key, ep->caSession->herPublicKey, 32); Address_getPrefix(&ep->addr); if (caState == CryptoAuth_ESTABLISHED) { moveEndpointIfNeeded(ep); //sendPeer(0xffffffff, PFChan_Core_PEER, ep);// version is not known at this point. } else { // prevent some kinds of nasty things which could be done with packet replay. // This is checking the message switch header and will drop it unless the label // directs it to *this* router. if (msg->length < 8 || msg->bytes[7] != 1) { Log_info(ic->logger, "DROP message because CA is not established."); return 0; } else { // When a "server" gets a new connection from a "client" the router doesn't // know about that client so if the client sends a packet to the server, the // server will be unable to handle it until the client has sent inter-router // communication to the server. Here we will ping the client so when the // server gets the ping response, it will insert the client into its table // and know its version. // prevent DoS by limiting the number of times this can be called per second // limit it to 7, this will affect innocent packets but it doesn't matter much // since this is mostly just an optimization and for keeping the tests happy. if ((ep->pingCount + 1) % 7) { sendPing(ep); } } } } else if (ep->state == InterfaceController_PeerState_UNRESPONSIVE && caState == CryptoAuth_ESTABLISHED) { ep->state = InterfaceController_PeerState_ESTABLISHED; SwitchCore_setInterfaceState(&ep->switchIf, SwitchCore_setInterfaceState_ifaceState_UP); } else { ep->timeOfLastMessage = Time_currentTimeMilliseconds(ic->eventBase); } Identity_check(ep); Assert_true(!(msg->capacity % 4)); return Iface_next(&ep->switchIf, msg); }
// Incoming message which has passed through the cryptoauth and needs to be forwarded to the switch. static uint8_t receivedAfterCryptoAuth(struct Message* msg, struct Interface* cryptoAuthIf) { struct InterfaceController_Peer* ep = Identity_check((struct InterfaceController_Peer*) cryptoAuthIf->receiverContext); struct InterfaceController_pvt* ic = ifcontrollerForPeer(ep); // nonce added by the CryptoAuth session. Message_pop(msg, NULL, 4, NULL); ep->bytesIn += msg->length; int caState = CryptoAuth_getState(cryptoAuthIf); if (ep->state < InterfaceController_PeerState_ESTABLISHED) { // EP states track CryptoAuth states... ep->state = caState; if (caState == CryptoAuth_ESTABLISHED) { moveEndpointIfNeeded(ep, ic); } else { // prevent some kinds of nasty things which could be done with packet replay. // This is checking the message switch header and will drop it unless the label // directs it to *this* router. if (msg->length < 8 || msg->bytes[7] != 1) { Log_info(ic->logger, "DROP message because CA is not established."); return Error_NONE; } else { // When a "server" gets a new connection from a "client" the router doesn't // know about that client so if the client sends a packet to the server, the // server will be unable to handle it until the client has sent inter-router // communication to the server. Here we will ping the client so when the // server gets the ping response, it will insert the client into its table // and know its version. // prevent DoS by limiting the number of times this can be called per second // limit it to 7, this will affect innocent packets but it doesn't matter much // since this is mostly just an optimization and for keeping the tests happy. if ((ep->pingCount + 1) % 7) { sendPing(ep); } } } } else if (ep->state == InterfaceController_PeerState_UNRESPONSIVE && caState == CryptoAuth_ESTABLISHED) { ep->state = InterfaceController_PeerState_ESTABLISHED; } else { ep->timeOfLastMessage = Time_currentTimeMilliseconds(ic->eventBase); } Identity_check(ep); Assert_true(!(msg->capacity % 4)); return Interface_receiveMessage(&ep->switchIf, msg); }
/** * Enter the receive loop */ void JobHandler::plug() { xlog::trace(className, "plug"); sendPing(); while (true) { if (m_dispatchChannel.waitForMessageWithTimeout(ReadRetryInterval)) { // messages published m_dispatchChannel.handleMessages(); } } }
/** * @brief ToolPing::ping plays the ping animation at the given position * @param pos position to play the animation at */ void ToolPing::ping(QPointF pos){ if(!m_Pinging){ emit sendPing(pos); QRectF rect(pos, QSizeF(32, 32)); rect.moveCenter(pos); m_Proxy->setGeometry(rect); m_Movie->start(); m_Proxy->show(); m_Pinging = true; startTimer(1000); } }
// //////////////////////////////////////////////////////////////////////////// // Droid checking info. keep position and damage in sync. BOOL sendCheck(void) { UDWORD i; NETgetBytesSent(); // update stats. NETgetBytesRecvd(); NETgetPacketsSent(); NETgetPacketsRecvd(); // dont send checks till all players are present. for(i=0;i<MAX_PLAYERS;i++) { if(isHumanPlayer(i) && ingame.JoiningInProgress[i]) { return true; } } // send Checks. note each send has it's own send criteria, so might not send anything. // Priority is droids -> structures -> power -> score -> ping sendDroidCheck(); sync_counter.sentDroidCheck++; sendStructureCheck(); sync_counter.sentStructureCheck++; sendPowerCheck(); sync_counter.sentPowerCheck++; if(okToSend()) { sendScoreCheck(); sync_counter.sentScoreCheck++; } else { sync_counter.unsentScoreCheck++; } if(okToSend()) { sendPing(); sync_counter.sentPing++; } else { sync_counter.unsentPing++; } return true; }
MrimConnection::MrimConnection(MrimAccount *account) : p(new MrimConnectionPrivate(account)) { connect(p->SrvReqSocket(),SIGNAL(connected()),this,SLOT(connected())); connect(p->SrvReqSocket(),SIGNAL(disconnected()),this,SLOT(disconnected())); connect(p->SrvReqSocket(),SIGNAL(readyRead()),this,SLOT(readyRead())); connect(p->IMSocket(),SIGNAL(connected()),this,SLOT(connected())); connect(p->IMSocket(),SIGNAL(disconnected()),this,SLOT(disconnected())); connect(p->IMSocket(),SIGNAL(readyRead()),this,SLOT(readyRead())); connect(p->ReadyReadTimer(),SIGNAL(timeout()),this,SLOT(readyRead())); connect(p->pingTimer.data(),SIGNAL(timeout()),this,SLOT(sendPing())); registerPacketHandler(this); MrimUserAgent qutimAgent(QApplication::applicationName(),QApplication::applicationVersion(), "(git)",PROTO_VERSION_MAJOR,PROTO_VERSION_MINOR); //TODO: real build version p->selfID = qutimAgent; p->messages = new MrimMessages(this); registerPacketHandler(p->messages); }
Connection::Connection(QObject *parent) : QTcpSocket(parent) { greetingMessage = tr("undefined"); username = tr("unknown"); state = WaitingForGreeting; currentDataType = Undefined; numBytesForCurrentDataType = -1; transferTimerId = 0; isGreetingMessageSent = false; pingTimer.setInterval(PingInterval); QObject::connect(this, SIGNAL(readyRead()), this, SLOT(processReadyRead())); QObject::connect(this, SIGNAL(disconnected()), &pingTimer, SLOT(stop())); QObject::connect(&pingTimer, SIGNAL(timeout()), this, SLOT(sendPing())); QObject::connect(this, SIGNAL(connected()), this, SLOT(sendGreetingMessage())); }
/******************************************************************** Update sends a keep alive ping and connects / reconnects to slack ********************************************************************/ void ArduinoSlackBot::update(){ webSocket.loop(); if (connected) { // Send ping every 5 seconds, to keep the connection alive if (millis() - lastPing > 5000) { sendPing(); lastPing = millis(); } } else { // Try to connect / reconnect to slack connected = connect(); if (!connected) { delay(500); } } }
int main(int argc, char *argv[]) { motor_t rightMotor = { &PORTB, &DDRB, PORTB7, // PWM &PORTC, &DDRC, PORTC1, // Direction &OCR0A // Top value }; motor_t leftMotor = { &PORTD, &DDRD, PORTD0, // PWM &PORTB, &DDRB, PORTB0, // Direction &OCR0B // Top value }; //uint8_t sonarDistance = 0; cli(); NO_CLK_PRESCALE(); //uart_init(); radio_init(HOV1_ADDRESS, RECEIVE_MODE); sonar_init(); motorInit(&rightMotor); motorInit(&leftMotor); pwmInit(); sei(); stop = Event_Init(); sendPing(); while(!receivedInit); Task_Create((void*)(&motor_task),0, PERIODIC, MOTOR); Task_Create((void*)(&fire_sonar),0, PERIODIC, FIRE); Task_Create((void*)(&listen_sonar),0,PERIODIC, LISTEN); Task_Create((void*)(&sendRadio),0,PERIODIC, RADIO); Task_Create((void*)(&stopSystem), 0,SYSTEM, STOP); setMotorDirection(&rightMotor, FORWARD); setMotorDirection(&leftMotor, FORWARD); return 0; }
void MainWindow::OnPingTimer(wxTimerEvent & event) { if (! (executing_request || awaiting_input)) { DRUID::SerialUIUserPtr serial_user = connection->serialUser(); DRUIDString inbufStr = serial_user->getAndClearBufferedMessage(); if (inbufStr.size()) { DRUID_DEBUG2("******** PING appending buffer: ", inbufStr); outputTextCtrl->AppendText(DRUID_STDSTRING_TOWX(inbufStr)); } if (serial_user->messageReceived()) { inbufStr = serial_user->lastMessage(); if (inbufStr.size()) { serial_user->lastMessageClear(); DRUID_DEBUG2("******** PING appending lastMessage: ", inbufStr); outputTextCtrl->AppendText(DRUID_STDSTRING_TOWX(inbufStr)); } } time_t time_now = time(NULL); int ping_interval = (tracking_interval_seconds == TRACKING_PERIOD_DISABLED) ? TRACKING_PERIOD_STANDARD : tracking_interval_seconds; if (time_now - last_interaction >= ping_interval) { sendPing(serial_user); last_interaction = time_now; } } }
/* * Handles the ping processing for a channel. Sends a ping to the * server if the next send ping time has arrived and checks if a * ping has been received from the server within the next receive * ping time. * chnl - The channel to handle pings for */ static void handlePings(RsslChannel* chnl) { time_t currentTime = 0; /* get current time */ time(¤tTime); /* handle client pings */ if (currentTime >= nextSendPingTime) { /* send ping to server */ if (sendPing(chnl) != RSSL_RET_SUCCESS) { cleanUpAndExit(); } /* set time to send next ping from client */ nextSendPingTime = currentTime + (time_t)pingTimeoutClient; } /* handle server pings */ if (currentTime >= nextReceivePingTime) { /* check if client received message from server since last time */ if (receivedServerMsg) { /* reset flag for server message received */ receivedServerMsg = RSSL_FALSE; /* set time client should receive next message/ping from server */ nextReceivePingTime = currentTime + (time_t)pingTimeoutServer; } else /* lost contact with server */ { printf("\nLost contact with server...\n"); cleanUpAndExit(); } } }
CClient::CClient(QWidget *parent, const QString &address, const QString &nick) : m_address(address), m_nick(nick) { m_gameBoard = new CGameBoard(this, QPoint(10, 10), QSize(630, 510)); m_gameBoard->setNick(nick.toStdString()); m_chatBox = new QTextEdit(this); m_chatBox->setReadOnly(true); m_chatBox->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn); m_chatBox->move(QPoint(10, 530)); m_chatBox->resize(QSize(530, 100)); m_message = new QLineEdit(this); m_message->move(QPoint(10, 640)); m_message->resize(QSize(420, 20)); m_message->installEventFilter(this); m_btn_send = new QPushButton(this); m_btn_send->setText(tr("Send")); m_btn_send->move(QPoint(440, 640)); m_btn_send->resize(QSize(100, 20)); m_lst_users = new QListWidget(this); m_lst_users->move(QPoint(550, 530)); m_lst_users->resize(QSize(90, 100)); m_socket = new QTcpSocket(); m_gameBoard->setSocket(m_socket); m_pingTimer = new QTimer(this); m_pingTimer->start(PingSendingTime); QObject::connect(m_btn_send, SIGNAL(clicked()), this, SLOT(sendMessage())); QObject::connect(m_pingTimer, SIGNAL(timeout()), this, SLOT(sendPing())); setFixedSize(650, 680); connectToServer(); }
jbool JConnection::isDead(){ jbool isDead=false; jint oldTimeout=socket->getSoTimeout(); try{ sendPing(); if (connections==NULL){ socket->setSoTimeout(transport->getTransportConfiguration()->getPingTimeout()->get()); } else { socket->setSoTimeout(connections->getTransport()->getTransportConfiguration()->getPingTimeout()->get()); } if (!readOk()) { isDead = true; } }catch(JIOException* e){ delete e; isDead=true; } if (isDead && !socket->isClosed()){ socket->close(); } socket->setSoTimeout(oldTimeout); return isDead; }
/** * Check the table for nodes which might need to be pinged, ping a node if necessary. * If a node has not responded in unresponsiveAfterMilliseconds then mark them as unresponsive * and if the connection is incoming and the node has not responded in forgetAfterMilliseconds * then drop them entirely. * This is called every PING_INTERVAL_MILLISECONDS but pingCallback is a misleading name. */ static void pingCallback(void* vic) { struct InterfaceController_pvt* ic = Identity_check((struct InterfaceController_pvt*) vic); if (!ic->peerMap.count) { return; } uint64_t now = Time_currentTimeMilliseconds(ic->eventBase); // scan for endpoints have not sent anything recently. uint32_t startAt = Random_uint32(ic->rand) % ic->peerMap.count; for (uint32_t i = startAt, count = 0; (!count || i != startAt) && count <= ic->peerMap.count;) { i = (i + 1) % ic->peerMap.count; count++; struct InterfaceController_Peer* ep = ic->peerMap.values[i]; if (now < ep->timeOfLastMessage + ic->pingAfterMilliseconds) { if (now < ep->timeOfLastPing + ic->pingAfterMilliseconds) { // Possibly an out-of-date node which is mangling packets, don't ping too often // because it causes the RumorMill to be filled with this node over and over. continue; } struct Node_Link* link = Router_linkForPath(ic->router, ep->switchLabel); // It exists, it's parent is the self-node, and it's label is equal to the switchLabel. if (link && Node_getBestParent(link->child) && Node_getBestParent(link->child)->parent->address.path == 1 && Node_getBestParent(link->child)->cannonicalLabel == ep->switchLabel) { continue; } } #ifdef Log_DEBUG uint8_t key[56]; Base32_encode(key, 56, CryptoAuth_getHerPublicKey(ep->cryptoAuthIf), 32); #endif if (ep->isIncomingConnection && now > ep->timeOfLastMessage + ic->forgetAfterMilliseconds) { Log_debug(ic->logger, "Unresponsive peer [%s.k] has not responded in [%u] " "seconds, dropping connection", key, ic->forgetAfterMilliseconds / 1024); Allocator_free(ep->external->allocator); continue; } bool unresponsive = (now > ep->timeOfLastMessage + ic->unresponsiveAfterMilliseconds); if (unresponsive) { // our link to the peer is broken... Router_disconnectedPeer(ic->router, ep->switchLabel); // Lets skip 87% of pings when they're really down. if (ep->pingCount % 8) { ep->pingCount++; continue; } ep->state = InterfaceController_PeerState_UNRESPONSIVE; } #ifdef Log_DEBUG uint32_t lag = (now - ep->timeOfLastMessage) / 1024; Log_debug(ic->logger, "Pinging %s peer [%s.k] lag [%u]", (unresponsive ? "unresponsive" : "lazy"), key, lag); #endif sendPing(ep); // we only ping one node return; } }
int InterfaceController_bootstrapPeer(struct InterfaceController* ifc, int interfaceNumber, uint8_t* herPublicKey, const struct Sockaddr* lladdrParm, String* password, String* login, String* user, struct Allocator* alloc) { struct InterfaceController_pvt* ic = Identity_check((struct InterfaceController_pvt*) ifc); Assert_true(herPublicKey); Assert_true(password); struct InterfaceController_Iface_pvt* ici = ArrayList_OfIfaces_get(ic->icis, interfaceNumber); if (!ici) { return InterfaceController_bootstrapPeer_BAD_IFNUM; } Log_debug(ic->logger, "bootstrapPeer total [%u]", ici->peerMap.count); uint8_t ip6[16]; AddressCalc_addressForPublicKey(ip6, herPublicKey); if (!AddressCalc_validAddress(ip6) || !Bits_memcmp(ic->ca->publicKey, herPublicKey, 32)) { return InterfaceController_bootstrapPeer_BAD_KEY; } struct Allocator* epAlloc = Allocator_child(ici->alloc); struct Sockaddr* lladdr = Sockaddr_clone(lladdrParm, epAlloc); // TODO(cjd): eps are created in 3 places, there should be a factory function. struct Peer* ep = Allocator_calloc(epAlloc, sizeof(struct Peer), 1); int index = Map_EndpointsBySockaddr_put(&lladdr, &ep, &ici->peerMap); Assert_true(index >= 0); ep->alloc = epAlloc; ep->handle = ici->peerMap.handles[index]; ep->lladdr = lladdr; ep->ici = ici; ep->isIncomingConnection = false; Bits_memcpy(ep->addr.key, herPublicKey, 32); Address_getPrefix(&ep->addr); Identity_set(ep); Allocator_onFree(epAlloc, closeInterface, ep); Allocator_onFree(alloc, freeAlloc, epAlloc); ep->peerLink = PeerLink_new(ic->eventBase, epAlloc); ep->caSession = CryptoAuth_newSession(ic->ca, epAlloc, herPublicKey, false, "outer"); CryptoAuth_setAuth(password, login, ep->caSession); if (user) { ep->caSession->displayName = String_clone(user, epAlloc); } ep->switchIf.send = sendFromSwitch; if (SwitchCore_addInterface(ic->switchCore, &ep->switchIf, epAlloc, &ep->addr.path)) { Log_debug(ic->logger, "bootstrapPeer() SwitchCore out of space"); Allocator_free(epAlloc); return InterfaceController_bootstrapPeer_OUT_OF_SPACE; } // We want the node to immedietly be pinged but we don't want it to appear unresponsive because // the pinger will only ping every (PING_INTERVAL * 8) so we set timeOfLastMessage to // (now - pingAfterMilliseconds - 1) so it will be considered a "lazy node". ep->timeOfLastMessage = Time_currentTimeMilliseconds(ic->eventBase) - ic->pingAfterMilliseconds - 1; if (Defined(Log_INFO)) { struct Allocator* tempAlloc = Allocator_child(alloc); String* addrStr = Address_toString(&ep->addr, tempAlloc); Log_info(ic->logger, "Adding peer [%s] from bootstrapPeer()", addrStr->bytes); Allocator_free(tempAlloc); } // We can't just add the node directly to the routing table because we do not know // the version. We'll send it a switch ping and when it responds, we will know it's // key (if we don't already) and version number. sendPing(ep); return 0; }