bool MqttClient::connect(String clientName, String username, String password) { if (getConnectionState() != eTCS_Ready) { close(); debugf("MQTT closed previous connection"); } debugf("MQTT start connection"); mqtt_init(&broker, clientName.c_str()); if (clientName.length() > 0) mqtt_init_auth(&broker, username.c_str(), password.c_str()); if(server) { TcpClient::connect(server, port); } else { TcpClient::connect(serverIp, port); } mqtt_set_alive(&broker, keepAlive); broker.socket_info = (void*)this; broker.send = staticSendPacket; int res = mqtt_connect(&broker); setTimeOut(USHRT_MAX); return res > 0; }
bool IRCClient::part ( std::string channel, std::string reason ) { // we need to have at LEAST sent the username and stuff if (getConnectionState() < eSentNickAndUSer) return false; IRCCommandInfo info; info.target = channel; if ( reason.size()) info.params.push_back(reason); if (!sendIRCCommand(eCMD_PART,info)) { log("part Failed: PART command not sent",0); return false; } // notify that we parted the channel std::string nick = getNick(); userManager.userPartChannel(nick, channel); trClientPartEventInfo eventInfo; eventInfo.eventType = eIRCChannelPartEvent; eventInfo.reason = reason; eventInfo.user = getNick(); callEventHandler(eventInfo.eventType,eventInfo); // todo, we really should go and remove the channel from our listing and kill any dead users return true; }
Connection *createConnection(void) { Connection *conn = NULL; ListElement *elem = NULL; if (!(conn = malloc(sizeof(Connection)))) ERREXIT("Cannot allocate memory for connection."); pthread_rwlock_init(&(conn->state.rwlock), NULL); pthread_mutex_init(&(conn->sock.mtx), NULL); conn->state.value = RUSP_CLOSED; conn->sock.fd = -1; elem = CONPOOL.head; while (elem) { if (getConnectionState((Connection *) elem->value) == RUSP_TIMEWT) { usleep(RUSP_TIMEWTTM); elem = CONPOOL.head; } else { elem = elem->next; } } conn->connid = (ConnectionId) addElementToList(&CONPOOL, conn); return conn; }
void SIPCall::onAnswered() { if (getConnectionState() != ConnectionState::CONNECTED) { setState(CallState::ACTIVE, ConnectionState::CONNECTED); Manager::instance().peerAnsweredCall(*this); } }
virtual void printInfo(std::ostream& out) { out << "RPCChannel: "; out << getChannelName(); out << " ["; out << Channel::ConnectionStateNames[getConnectionState()]; out << "]"; }
void PanelConfig::initialize(QMap<QString, QString> config) { configuration = config; emit getConnectionState(); readXML("panel_config.xml"); setupConfigList(); setupTableHeader(); selectConfig(0); }
void PanelPlot::initialize(QMap<QString, QString> config) { configuration = config; emit getConnectionState(); readXML("panel_plot.xml"); setupPlotList(); initializePlot(0); setupPlotNames(0); }
bool KMKMqttClient::disconnect() { int res=mqtt_disconnect(&broker); if (getConnectionState() != eTCS_Ready) { close(); debugf("KMKMQTT closed connection"); } return res>0; }
void setListeningConnection(Connection *conn, const struct sockaddr_in laddr) { if (getConnectionState(conn) != RUSP_CLOSED) ERREXIT("Cannot setup listening connection: connection not closed."); conn->sock.fd = openSocket(); setSocketReusable(conn->sock.fd); bindSocket(conn->sock.fd, &laddr); setConnectionState(conn, RUSP_LISTEN); }
void SIPCall::refuse() { if (!isIncoming() or getConnectionState() == ConnectionState::CONNECTED or !inv) return; stopAllMedia(); // Notify the peer terminateSipSession(PJSIP_SC_DECLINE); setState(Call::ConnectionState::DISCONNECTED, ECONNABORTED); removeCall(); }
bool SIPCall::onhold() { if (not setState(CallState::HOLD)) return false; stopAllMedia(); if (getConnectionState() == ConnectionState::CONNECTED) { if (SIPSessionReinvite() != PJ_SUCCESS) RING_WARN("[call:%s] Reinvite failed", getCallId().c_str()); } return true; }
bool IRCClient::mode ( std::string theMode, std::string target, std::string option ) { // we need to have at LEAST sent the username and stuff if (getConnectionState() < eSentNickAndUSer) return false; IRCCommandInfo info; info.target = target; info.params.push_back(theMode); if (option.size()) info.params.push_back(option); sendIRCCommand(eCMD_MODE,info); return true; }
bool IRCClient::login ( std::string &nick, std::string &username, std::string &thenumericmode, std::string &fullname) { if (!tcpClient || !tcpClient->connected()) return false; char someNumber[64]; sprintf(someNumber,"%d",rand()); if (!nick.size()) nick = std::string("SomeLazyUser") + std::string(someNumber); if (!username.size()) username = "******"; if (!thenumericmode.size()) thenumericmode = "8"; // Sets user as invisible if (!fullname.size()) fullname = "Lazy libIRC programmer"; requestedNick = nick; IRCCommandInfo info; info.params.push_back(nick); if (!sendIRCCommand(eCMD_NICK,info)) { log("Login Failed: NICK command not sent",0); return false; } info.params.clear(); info.params.push_back(username); info.params.push_back(thenumericmode); info.params.push_back("*"); info.params.push_back(fullname); if (!sendIRCCommand(eCMD_USER,info)) { log("Login Failed: USER command not sent",0); return false; } if (getConnectionState() < eSentNickAndUSer) setConnectionState(eSentNickAndUSer); return true; }
bool IRCClient::loginLegacy ( std::string &nick, std::string &username, std::string &fullname, std::string &host ) { if (!tcpClient || !tcpClient->connected()) return false; char someNumber[64]; sprintf(someNumber,"%d",rand()); if (!nick.size()) nick = std::string("SomeLazyUser") + std::string(someNumber); if (!username.size()) username = "******"; if (!fullname.size()) fullname = "Lazy libIRC programmer"; if (!host.size()) host = "localhost"; requestedNick = nick; IRCCommandInfo info; info.params.push_back(nick); if (!sendIRCCommand(eCMD_NICK,info)) { log("Login Failed: NICK command not sent",0); return false; } info.params.clear(); info.params.push_back(username); info.params.push_back(host); info.params.push_back(ircServerName); info.params.push_back(fullname); if (!sendIRCCommand(eCMD_USER,info)) { log("Login Failed: USER command not sent",0); return false; } if (getConnectionState() < eSentNickAndUSer) setConnectionState(eSentNickAndUSer); return true; }
bool SIPCall::internalOffHold(const std::function<void()>& sdp_cb) { if (not setState(CallState::ACTIVE)) return false; sdp_cb(); if (getConnectionState() == ConnectionState::CONNECTED) { if (SIPSessionReinvite() != PJ_SUCCESS) { RING_WARN("[call:%s] resuming hold", getCallId().c_str()); onhold(); return false; } } return true; }
bool IRCClient::kick ( std::string user, std::string channel, std::string reason ) { // we need to have at LEAST sent the username and stuff if (getConnectionState() < eSentNickAndUSer) return false; if (!userManager.userInChannel(user,channel)) return false; IRCCommandInfo info; info.target = channel; info.params.push_back(user); info.params.push_back(reason); if (!sendIRCCommand(eCMD_KICK,info)) { log("Kick Failed: KICK command not sent",0); return false; } return true; }
bool IRCClient::join ( std::string channel ) { // we need to have at LEAST sent the username and stuff if (getConnectionState() < eSentNickAndUSer) return false; IRCCommandInfo info; info.target = channel; if (!sendIRCCommand(eCMD_JOIN,info)) { log("Join Failed: JOIN command not sent",0); return false; } if (!sendIRCCommand(eCMD_MODE,info)) { log("Join Failed: MODE command not sent",0); return false; } return true; }
void RpcLibClientBase::confirmConnection() { ClockBase* clock = ClockFactory::get(); // make sure we can talk to the DroneServer //std::cout << "Contacting DroneServer..." << std::flush; //command_context.client.ping(); //std::cout << "DroneServer is responding." << std::endl; std::cout << "Waiting for connection - " << std::flush; const TTimeDelta pause_time = 1; while (getConnectionState() != RpcLibClientBase::ConnectionState::Connected) { std::cout << "X" << std::flush; clock->sleep_for(pause_time); } std::cout << std::endl << "Connected!" << std::endl; auto server_ver = getServerVersion(); auto client_ver = getClientVersion(); auto server_min_ver = getMinRequiredServerVersion(); auto client_min_ver = getMinRequiredClientVersion(); std::string ver_info = Utils::stringf("Client Ver:%i (Min Req:%i), Server Ver:%i (Min Req:%i)", client_ver, client_min_ver, server_ver, server_min_ver); if (server_ver < server_min_ver) { std::cerr << std::endl << ver_info << std::endl; std::cerr << std::endl << "AirSim server is of older version and not supported by this client. Please upgrade!" << std::endl; } else if (client_ver < client_min_ver) { std::cerr << std::endl << ver_info << std::endl; std::cerr << std::endl << "AirSim client is of older version and not supported by this server. Please upgrade!" << std::endl; } else std::cout << std::endl << ver_info << std::endl; }
static void processRcvWndBase(Connection *conn, const Segment sgm) { switch (getConnectionState(conn)) { case RUSP_ESTABL: if (sgm.hdr.plds != 0) { writeStrBuff(&(conn->rcvusrbuff), sgm.pld, sgm.hdr.plds); slideWindow(&(conn->rcvwnd), sgm.hdr.plds); DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff))); } if (sgm.hdr.ctrl & RUSP_PSH) allignStrBuffSizeUsr(&(conn->rcvusrbuff)); if (sgm.hdr.ctrl & RUSP_FIN) { allignStrBuffSizeUsr(&(conn->rcvusrbuff)); setConnectionState(conn, RUSP_CLOSWT); slideWindow(&(conn->rcvwnd), 1); DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff))); } break; case RUSP_LSTACK: if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) { setConnectionState(conn, RUSP_CLOSED); pthread_exit(NULL); } break; case RUSP_FINWT1: if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) { setConnectionState(conn, RUSP_FINWT2); } else if ((sgm.hdr.ctrl & (RUSP_FIN | RUSP_SACK)) && (sgm.hdr.ackn != getWindowNext(&(conn->sndwnd)))) { setConnectionState(conn, RUSP_CLOSIN); slideWindow(&(conn->rcvwnd), 1); DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff))); } else if ((sgm.hdr.ctrl & (RUSP_FIN | RUSP_SACK)) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) { setConnectionState(conn, RUSP_TIMEWT); slideWindow(&(conn->rcvwnd), 1); DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff))); createThread(timeWaitFunction, conn, THREAD_DETACHED); pthread_exit(NULL); } break; case RUSP_FINWT2: if (sgm.hdr.ctrl & RUSP_FIN) { setConnectionState(conn, RUSP_TIMEWT); slideWindow(&(conn->rcvwnd), 1); DBGPRINT(RUSP_DEBUG, "RCV (WND): base:%u end:%u RCVUSRBUFF:%zu RCVSGMBUFF:%ld", getWindowBase(&(conn->rcvwnd)), getWindowEnd(&(conn->rcvwnd)), getStrBuffSize(&(conn->rcvusrbuff)), getSgmBuffSize(&(conn->rcvsgmbuff))); createThread(timeWaitFunction, conn, THREAD_DETACHED); pthread_exit(NULL); } break; case RUSP_CLOSIN: if ((sgm.hdr.ctrl & RUSP_SACK) && (sgm.hdr.ackn == getWindowNext(&(conn->sndwnd)))) { setConnectionState(conn, RUSP_TIMEWT); createThread(timeWaitFunction, conn, THREAD_DETACHED); pthread_exit(NULL); } break; default: break; } }
ConnectionId passiveOpen(Connection *lconn) { Connection *aconn = NULL; Segment syn, synack, acksynack; char ssyn[RUSP_SGMS + 1], ssynack[RUSP_SGMS + 1], sacksynack[RUSP_SGMS + 1]; int asock, synackretrans; struct sockaddr_in caddr; struct timespec start, end; long double sampleRTT; while (getConnectionState(lconn) == RUSP_LISTEN) { readUSocket(lconn->sock.fd, &caddr, ssyn, RUSP_SGMS); deserializeSegment(ssyn, &syn); DBGFUNC(RUSP_DEBUG, printInSegment(caddr, syn)); if (syn.hdr.ctrl != RUSP_SYN) continue; setConnectionState(lconn, RUSP_SYNRCV); asock = openSocket(); synack = createSegment(RUSP_SYN | RUSP_SACK, 0, 10, RUSP_NXTSEQN(syn.hdr.seqn, 1), NULL); serializeSegment(synack, ssynack); for (synackretrans = 0; synackretrans < RUSP_RETR; synackretrans++) { clock_gettime(CLOCK_MONOTONIC, &start); writeUSocket(asock, caddr, ssynack, strlen(ssynack)); DBGFUNC(RUSP_DEBUG, printOutSegment(caddr, synack)); setConnectionState(lconn, RUSP_SYNSND); if (!selectSocket(asock, RUSP_SAMPLRTT)) continue; readUSocket(asock, &caddr, sacksynack, RUSP_SGMS); clock_gettime(CLOCK_MONOTONIC, &end); sampleRTT = getElapsed(start, end); deserializeSegment(sacksynack, &acksynack); DBGFUNC(RUSP_DEBUG, printInSegment(caddr, acksynack)); if ((acksynack.hdr.ctrl == RUSP_SACK) & (acksynack.hdr.seqn == synack.hdr.ackn) & (acksynack.hdr.ackn == RUSP_NXTSEQN(synack.hdr.seqn, 1))) { aconn = createConnection(); setConnectionState(aconn, RUSP_SYNSND); setupConnection(aconn, asock, caddr, acksynack.hdr.ackn, acksynack.hdr.seqn, sampleRTT); setConnectionState(lconn, RUSP_LISTEN); return aconn->connid; } } closeSocket(asock); setConnectionState(lconn, RUSP_LISTEN); } return -1; }
int activeOpen(Connection *conn, const struct sockaddr_in laddr) { Segment syn, synack, acksynack; char ssyn[RUSP_SGMS + 1], ssynack[RUSP_SGMS + 1], sacksynack[RUSP_SGMS + 1]; int asock, synretrans; struct sockaddr_in aaddr; struct timespec start, end; long double sampleRTT; if (getConnectionState(conn) != RUSP_CLOSED) ERREXIT("Cannot synchronize connection: connection not closed."); asock = openSocket(); syn = createSegment(RUSP_SYN, 0, 0, 0, NULL); serializeSegment(syn, ssyn); for (synretrans = 0; synretrans < RUSP_SYN_RETR; synretrans++) { clock_gettime(CLOCK_MONOTONIC, &start); writeUSocket(asock, laddr, ssyn, strlen(ssyn)); DBGFUNC(RUSP_DEBUG, printOutSegment(laddr, syn)); setConnectionState(conn, RUSP_SYNSND); if (!selectSocket(asock, RUSP_SAMPLRTT)) continue; readUSocket(asock, &aaddr, ssynack, RUSP_SGMS); clock_gettime(CLOCK_MONOTONIC, &end); sampleRTT = getElapsed(start, end); deserializeSegment(ssynack, &synack); DBGFUNC(RUSP_DEBUG, printInSegment(aaddr, synack)); if ((synack.hdr.ctrl == (RUSP_SYN | RUSP_SACK)) & (synack.hdr.ackn == RUSP_NXTSEQN(syn.hdr.seqn, 1))) { setConnectionState(conn, RUSP_SYNRCV); acksynack = createSegment(RUSP_SACK, 0, RUSP_NXTSEQN(syn.hdr.seqn, 1), RUSP_NXTSEQN(synack.hdr.seqn, 1), NULL); serializeSegment(acksynack, sacksynack); writeUSocket(asock, aaddr, sacksynack, strlen(sacksynack)); DBGFUNC(RUSP_DEBUG, printOutSegment(aaddr, acksynack)); setupConnection(conn, asock, aaddr, acksynack.hdr.seqn, acksynack.hdr.ackn, sampleRTT); return conn->connid; } } closeSocket(asock); setConnectionState(conn, RUSP_CLOSED); return -1; }
void EventConnection::processEvent(NetEvent *theEvent) { if(getConnectionState() == NetConnection::Connected) theEvent->process(this); }
void PanelMonitor::initialize(QMap<QString, QString> config) { configuration = config; emit getConnectionState(); }
bool EventConnection::postNetEvent(NetEvent *theEvent) { // Check if the direction this event moves is a valid direction. TNLAssertV( (theEvent->getEventDirection() != NetEvent::DirUnset) && (theEvent->getEventDirection() != NetEvent::DirServerToClient || !isConnectionToServer()) && (theEvent->getEventDirection() != NetEvent::DirClientToServer || !isConnectionToClient()), ("Trying to send wrong event direction in %s", theEvent->getClassName())); S32 classId = theEvent->getClassId(getNetClassGroup()); if(U32(classId) >= mEventClassCount && getConnectionState() == Connected) { theEvent->incRef(); theEvent->decRef(); // Avoids some type of memory leak by deleting here if nothing reference it. return false; } theEvent->notifyPosted(this); EventNote *event = mEventNoteChunker.alloc(); event->mEvent = theEvent; event->mNextEvent = NULL; if(event->mEvent->mGuaranteeType == NetEvent::GuaranteedOrdered) { event->mSeqCount = mNextSendEventSeq++; if(!mSendEventQueueHead) mSendEventQueueHead = event; else mSendEventQueueTail->mNextEvent = event; mSendEventQueueTail = event; } else if(event->mEvent->mGuaranteeType == NetEvent::GuaranteedOrderedBigData) { BitStream bstream; const U32 start = 0; const U32 partsSize = 512; if(mConnectionParameters.mDebugObjectSizes) bstream.advanceBitPosition(BitStreamPosBitSize); S32 classId = event->mEvent->getClassId(getNetClassGroup()); bstream.writeInt(classId, mEventClassBitSize); event->mEvent->pack(this, &bstream); logprintf(LogConsumer::LogEventConnection, "EventConnection %s: WroteEvent %s - %d bits", getNetAddressString(), event->mEvent->getDebugName(), bstream.getBitPosition() - start); if(mConnectionParameters.mDebugObjectSizes) bstream.writeIntAt(bstream.getBitPosition(), BitStreamPosBitSize, start); U32 size = bstream.getBytePosition(); for(U32 i=0; i<size; i+=partsSize) { if(i+partsSize < size) { ByteBuffer *bytebuffer = new ByteBuffer(&bstream.getBuffer()[i], partsSize); bytebuffer->takeOwnership(); // may have to use this to prevent errors. s2rTNLSendDataParts(0, ByteBufferPtr(bytebuffer)); } else { ByteBuffer *bytebuffer = new ByteBuffer(&bstream.getBuffer()[i], size-i); bytebuffer->takeOwnership(); s2rTNLSendDataParts(1, ByteBufferPtr(bytebuffer)); } } mEventNoteChunker.free(event); } else { event->mSeqCount = InvalidSendEventSeq; if(!mUnorderedSendEventQueueHead) mUnorderedSendEventQueueHead = event; else mUnorderedSendEventQueueTail->mNextEvent = event; mUnorderedSendEventQueueTail = event; } return true; }
/** * @return if the client is connected to the server */ bool ClientConnectionAdapter::isConnected() { return getConnectionState()==&ClientConnectionState::IN_SYNC_WITH_SERVER; }