int main(int argc, char *argv[]) { QGuiApplication app(argc, argv); qmlRegisterType<Graph>("Graph", 1, 0, "Graph"); QQmlApplicationEngine engine; engine.load(QUrl(QStringLiteral("qrc:/main.qml"))); app.setWindowIcon(QIcon(":/content/icon.png")); QMLHandlerCppSide alertLamp(engine.rootObjects()[0], "alertLamp"); QMLHandlerCppSide lineSens(engine.rootObjects()[0], "lineSens"); QMLHandlerCppSide textAccelX(engine.rootObjects()[0], "textAccelX"); QMLHandlerCppSide textAccelY(engine.rootObjects()[0], "textAccelY"); QMLHandlerCppSide textAccelZ(engine.rootObjects()[0], "textAccelZ"); QMLHandlerCppSide textGyroX(engine.rootObjects()[0], "textGyroX"); QMLHandlerCppSide textGyroY(engine.rootObjects()[0], "textGyroY"); QMLHandlerCppSide textGyroZ(engine.rootObjects()[0], "textGyroZ"); QMLHandlerCppSide textCurStatus(engine.rootObjects()[0], "textCurStatus"); QMLHandlerCppSide comboSetStatus(engine.rootObjects()[0], "comboSetStatus"); QMLHandlerCppSide textCurSpeed(engine.rootObjects()[0], "textCurSpeed"); QMLHandlerCppSide editSetSpeed(engine.rootObjects()[0], "editSetSpeed"); QMLHandlerCppSide wheels(engine.rootObjects()[0], "wheels"); QMLHandlerCppSide carAccelY(engine.rootObjects()[0], "carAccelY"); QMLHandlerCppSide carGyroX(engine.rootObjects()[0], "carGyroX"); QMLHandlerCppSide carGyroY(engine.rootObjects()[0], "carGyroY"); QMLHandlerCppSide carGyroZ(engine.rootObjects()[0], "carGyroZ"); QMLHandlerCppSide statusHistory(engine.rootObjects()[0], "statusHistory"); QMLHandlerCppSide speedGraph(engine.rootObjects()[0], "speedGraph"); QMLHandlerCppSide buttonConDiscon(engine.rootObjects()[0], "buttonConDiscon"); QMLHandlerCppSide buttonSendStatus(engine.rootObjects()[0], "buttonSendStatus"); QMLHandlerCppSide buttonSendSpeed(engine.rootObjects()[0], "buttonSendSpeed"); QMLHandlerCppSide buttonCarSelfTest(engine.rootObjects()[0], "buttonCarSelfTest"); GuiHandler guihandle(&alertLamp, &lineSens, &textAccelX, &textAccelY, &textAccelZ, &textGyroX, &textGyroY, &textGyroZ, &textCurStatus, &comboSetStatus, &textCurSpeed, &editSetSpeed, &wheels, &carAccelY, &carGyroX, &carGyroY, &carGyroZ, &statusHistory, &speedGraph, &buttonConDiscon, &buttonSendStatus, &buttonSendSpeed, &buttonCarSelfTest); Robot mikrobi; QObject::connect(&guihandle, SIGNAL(buttonConClicked()), &mikrobi, SLOT(connect())); QObject::connect(&guihandle, SIGNAL(buttonDisClicked()), &mikrobi, SLOT(disconnect())); QObject::connect(&guihandle, SIGNAL(buttonCarSelfTestClicked()), &mikrobi, SLOT(selfTest())); QObject::connect(&guihandle, SIGNAL(buttonSendStatusClicked(QString)), &mikrobi, SLOT(status(QString))); QObject::connect(&guihandle, SIGNAL(buttonSendSpeedClicked(float)), &mikrobi, SLOT(speed(float))); QObject::connect(&mikrobi, SIGNAL(connected()), &guihandle, SLOT(robotConnected())); QObject::connect(&mikrobi, SIGNAL(setAlert(int)), &guihandle, SLOT(setAlert(int))); QObject::connect(&mikrobi, SIGNAL(disconnected()), &guihandle, SLOT(robotDisconnected())); QObject::connect(&mikrobi, SIGNAL(setLedStrip(QVarLengthArray<bool>)), &guihandle, SLOT(setLedStrip(QVarLengthArray<bool>))); QObject::connect(&mikrobi, SIGNAL(setTextAccelX(float)), &guihandle, SLOT(setTextAccelX(float))); QObject::connect(&mikrobi, SIGNAL(setTextAccelY(float)), &guihandle, SLOT(setTextAccelY(float))); QObject::connect(&mikrobi, SIGNAL(setTextAccelZ(float)), &guihandle, SLOT(setTextAccelZ(float))); QObject::connect(&mikrobi, SIGNAL(setTextGyroX(float)), &guihandle, SLOT(setTextGyroX(float))); QObject::connect(&mikrobi, SIGNAL(setTextGyroY(float)), &guihandle, SLOT(setTextGyroY(float))); QObject::connect(&mikrobi, SIGNAL(setTextGyroZ(float)), &guihandle, SLOT(setTextGyroZ(float))); QObject::connect(&mikrobi, SIGNAL(setTextStatus(QString)), &guihandle, SLOT(setTextStatus(QString))); QObject::connect(&mikrobi, SIGNAL(setTextSpeed(float)), &guihandle, SLOT(setTextSpeed(float))); QObject::connect(&mikrobi, SIGNAL(setWheels(QVarLengthArray<float>, const float)), &guihandle, SLOT(setWheels(QVarLengthArray<float>, const float))); QObject::connect(&mikrobi, SIGNAL(setCarAccelY(QVarLengthArray<float>, float)), &guihandle, SLOT(setCarAccelY(QVarLengthArray<float>, float))); QObject::connect(&mikrobi, SIGNAL(setCarGyroX(float)), &guihandle, SLOT(setCarGyroX(float))); QObject::connect(&mikrobi, SIGNAL(setCarGyroY(float)), &guihandle, SLOT(setCarGyroY(float))); QObject::connect(&mikrobi, SIGNAL(setCarGyroZ(float)), &guihandle, SLOT(setCarGyroZ(float))); QObject::connect(&mikrobi, SIGNAL(drawSpeedGraph(float)), &guihandle, SLOT(drawSpeedGraph(float))); QObject::connect(&mikrobi, SIGNAL(setTextStatus(QString)), &guihandle, SLOT(addStatusHistory(QString))); return app.exec(); }
/** * write all message body / payload to Stream * @param stream Stream * * @return bytes written ( negative values are error codes ) */ int HTTPClient::writeToStream(Stream * stream) { if(!stream) { return returnError(HTTPC_ERROR_NO_STREAM); } if(!connected()) { return returnError(HTTPC_ERROR_NOT_CONNECTED); } // get length of document (is -1 when Server sends no Content-Length header) int len = _size; int ret = 0; if(_transferEncoding == HTTPC_TE_IDENTITY) { ret = writeToStreamDataBlock(stream, len); // have we an error? if(ret < 0) { return returnError(ret); } } else if(_transferEncoding == HTTPC_TE_CHUNKED) { int size = 0; while(1) { if(!connected()) { return returnError(HTTPC_ERROR_CONNECTION_LOST); } String chunkHeader = _tcp->readStringUntil('\n'); if(chunkHeader.length() <= 0) { return returnError(HTTPC_ERROR_READ_TIMEOUT); } chunkHeader.trim(); // remove \r // read size of chunk len = (uint32_t) strtol((const char *) chunkHeader.c_str(), NULL, 16); size += len; DEBUG_HTTPCLIENT("[HTTP-Client] read chunk len: %d\n", len); // data left? if(len > 0) { int r = writeToStreamDataBlock(stream, len); if(r < 0) { // error in writeToStreamDataBlock return returnError(r); } ret += r; } else { // if no length Header use global chunk size if(_size <= 0) { _size = size; } // check if we have write all data out if(ret != _size) { return returnError(HTTPC_ERROR_STREAM_WRITE); } break; } delay(0); } } else { return returnError(HTTPC_ERROR_ENCODING); } end(); return ret; }
/** * write one Data Block to Stream * @param stream Stream * * @param size int * @return < 0 = error >= 0 = size written */ int HTTPClient::writeToStreamDataBlock(Stream * stream, int size) { int buff_size = HTTP_TCP_BUFFER_SIZE; int len = size; int bytesWritten = 0; // if possible create smaller buffer then HTTP_TCP_BUFFER_SIZE if((len > 0) && (len < HTTP_TCP_BUFFER_SIZE)) { buff_size = len; } // create buffer for read uint8_t * buff = (uint8_t *) malloc(buff_size); if(buff) { // read all data from server while(connected() && (len > 0 || len == -1)) { // get available data size size_t sizeAvailable = _tcp->available(); if(sizeAvailable) { int readBytes = sizeAvailable; // read only the asked bytes if(len > 0 && readBytes > len) { readBytes = len; } // not read more the buffer can handle if(readBytes > buff_size) { readBytes = buff_size; } // read data int bytesRead = _tcp->readBytes(buff, readBytes); // write it to Stream int bytesWrite = stream->write(buff, bytesRead); bytesWritten += bytesWrite; // are all Bytes a writen to stream ? if(bytesWrite != bytesRead) { DEBUG_HTTPCLIENT("[HTTP-Client][writeToStream] short write asked for %d but got %d retry...\n", bytesRead, bytesWrite); // check for write error if(stream->getWriteError()) { DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] stream write error %d\n", stream->getWriteError()); //reset write error for retry stream->clearWriteError(); } // some time for the stream delay(1); int leftBytes = (readBytes - bytesWrite); // retry to send the missed bytes bytesWrite = stream->write((buff + bytesWrite), leftBytes); bytesWritten += bytesWrite; if(bytesWrite != leftBytes) { // failed again DEBUG_HTTPCLIENT("[HTTP-Client][writeToStream] short write asked for %d but got %d failed.\n", leftBytes, bytesWrite); free(buff); return HTTPC_ERROR_STREAM_WRITE; } } // check for write error if(stream->getWriteError()) { DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] stream write error %d\n", stream->getWriteError()); free(buff); return HTTPC_ERROR_STREAM_WRITE; } // count bytes to read left if(len > 0) { len -= readBytes; } delay(0); } else { delay(1); } } free(buff); DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] connection closed or file end (written: %d).\n", bytesWritten); if((size > 0) && (size != bytesWritten)) { DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] bytesWritten %d and size %d mismatch!.\n", bytesWritten, size); return HTTPC_ERROR_STREAM_WRITE; } } else { DEBUG_HTTPCLIENT("[HTTP-Client][writeToStreamDataBlock] too less ram! need %d\n", HTTP_TCP_BUFFER_SIZE); return HTTPC_ERROR_TOO_LESS_RAM; } return bytesWritten; }
/*------------------------------------------------------------------------------* *------------------------------------------------------------------------------*/ void WebProxy::processQuery() { QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender()); QByteArray requestData = socket->readAll(); int pos = requestData.indexOf("\r\n"); QByteArray requestLine = requestData.left(pos); requestData.remove(0, pos + 2); QList<QByteArray> entries = requestLine.split(' '); QByteArray method = entries.value(0); QByteArray address = entries.value(1); QByteArray version = entries.value(2); qDebug( ) << __FILE__ << __FUNCTION__ << "Processing " << address; QUrl url = QUrl::fromEncoded(address); if (!url.isValid()) { //qWarning() << "Invalid URL:" << url; socket->disconnectFromHost(); return; } //Act as server is request are for local server if ((url.host() == "") && (QFile(address).exists())) { //qDebug( ) << __FILE__ << __FUNCTION__ << "Sending " << address; QByteArray header; QTextStream headerStream(&header, QIODevice::WriteOnly); //Construct response header headerStream << "HTTP/1.0 200 OK" << endl; headerStream << "Server: gpsbook/" << qApp->applicationVersion() << endl; headerStream << "Date: " << QDateTime::currentDateTime().toUTC().toString("ddd, dd MMM yyyy hh:mm:ss") << "GMT" << endl; headerStream << "Content-Type: text/html; charset=utf-8" << endl; headerStream << "Connection: close" << endl; headerStream << "Pragma: no-cache" << endl; headerStream << "Cache-Control: no-cache" << endl; QFile file(address); if (!file.open(QFile::ReadOnly | QFile::Text)) { qWarning() << "Cannot open:" << address; socket->disconnectFromHost(); return ; } QByteArray content; QTextStream contentStream(&content, QIODevice::WriteOnly); while (!file.atEnd()) { contentStream << file.readLine() << endl; } headerStream << "Content-Length:" << content.size() << endl; headerStream << "" << endl; socket->write(header); socket->write(content); //qDebug( ) << __FILE__ << __FUNCTION__ << "File sent (" << content.size() << "bytes) :-)"; socket->disconnectFromHost(); return; } #if ( QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) ) // Some finction of QUrl have been deprecated // This code is require for the internet browser and should be reviewed. #else #ifdef Q_OS_LINUX //Remove advert to speedup development ;-) if (url.toString().contains("googlesyndication") || url.toString().contains("yieldmanager.com")) { socket->disconnectFromHost(); return; } #endif qDebug( ) << __FILE__ << __FUNCTION__ << "URL: " << url.toString(); QString host = url.host(); int port = (url.port() < 0) ? 80 : url.port(); QByteArray req = url.encodedPath(); if (url.hasQuery()) req.append('?').append(url.encodedQuery()); requestLine = method + " " + req + " " + version + "\r\n"; requestData.prepend(requestLine); QString key = host + ':' + QString::number(port); QTcpSocket *proxySocket = socket->findChild<QTcpSocket*>(key); if (proxySocket) { proxySocket->setObjectName(key); proxySocket->setProperty("url", url); proxySocket->setProperty("requestData", requestData); proxySocket->write(requestData); } else { proxySocket = new QTcpSocket(socket); proxySocket->setObjectName(key); proxySocket->setProperty("url", url); proxySocket->setProperty("requestData", requestData); connect(proxySocket, SIGNAL(connected()), this, SLOT(sendRequest())); connect(proxySocket, SIGNAL(readyRead()), this, SLOT(transferData())); connect(proxySocket, SIGNAL(disconnected()), this, SLOT(closeConnection())); connect(proxySocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(closeConnection())); proxySocket->connectToHost(host, port); } #endif } //WebProxy::processQuery
/** * set the timeout for the TCP connection * @param timeout unsigned int */ void HTTPClient::setTimeout(uint16_t timeout) { _tcpTimeout = timeout; if(connected()) { _tcp->setTimeout(timeout); } }
bool Client::handleNormalNode( Tag* tag ) { if( tag->name() == "features" && tag->xmlns() == XMLNS_STREAM ) { m_streamFeatures = getStreamFeatures( tag ); if( m_tls == TLSRequired && !m_encryptionActive && ( !m_encryption || !( m_streamFeatures & StreamFeatureStartTls ) ) ) { logInstance().err( LogAreaClassClient, "Client is configured to require" " TLS but either the server didn't offer TLS or" " TLS support is not compiled in." ); disconnect( ConnTlsNotAvailable ); } else if( m_tls > TLSDisabled && m_encryption && !m_encryptionActive && ( m_streamFeatures & StreamFeatureStartTls ) ) { notifyStreamEvent( StreamEventEncryption ); startTls(); } else if( m_compress && m_compression && !m_compressionActive && ( m_streamFeatures & StreamFeatureCompressZlib ) ) { notifyStreamEvent( StreamEventCompression ); logInstance().warn( LogAreaClassClient, "The server offers compression, but negotiating Compression at this stage is not recommended. See XEP-0170 for details. We'll continue anyway." ); negotiateCompression( StreamFeatureCompressZlib ); } else if( m_sasl ) { if( m_authed ) { if( m_streamFeatures & StreamFeatureBind ) { notifyStreamEvent( StreamEventResourceBinding ); bindResource( resource() ); } } else if( m_doAuth && !username().empty() && !password().empty() ) { if( m_streamFeatures & SaslMechDigestMd5 && m_availableSaslMechs & SaslMechDigestMd5 && !m_forceNonSasl ) { notifyStreamEvent( StreamEventAuthentication ); startSASL( SaslMechDigestMd5 ); } else if( m_streamFeatures & SaslMechPlain && m_availableSaslMechs & SaslMechPlain && !m_forceNonSasl ) { notifyStreamEvent( StreamEventAuthentication ); startSASL( SaslMechPlain ); } else if( m_streamFeatures & StreamFeatureIqAuth || m_forceNonSasl ) { notifyStreamEvent( StreamEventAuthentication ); nonSaslLogin(); } else { logInstance().err( LogAreaClassClient, "the server doesn't support" " any auth mechanisms we know about" ); disconnect( ConnNoSupportedAuth ); } } else if( m_doAuth && !m_clientCerts.empty() && !m_clientKey.empty() && m_streamFeatures & SaslMechExternal && m_availableSaslMechs & SaslMechExternal ) { notifyStreamEvent( StreamEventAuthentication ); startSASL( SaslMechExternal ); } #ifdef _WIN32 else if( m_doAuth && m_streamFeatures & SaslMechGssapi && m_availableSaslMechs & SaslMechGssapi ) { notifyStreamEvent( StreamEventAuthentication ); startSASL( SaslMechGssapi ); } #endif else if( m_doAuth && m_streamFeatures & SaslMechAnonymous && m_availableSaslMechs & SaslMechAnonymous ) { notifyStreamEvent( StreamEventAuthentication ); startSASL( SaslMechAnonymous ); } else { notifyStreamEvent( StreamEventFinished ); connected(); } } else if( m_compress && m_compression && !m_compressionActive && ( m_streamFeatures & StreamFeatureCompressZlib ) ) { notifyStreamEvent( StreamEventCompression ); negotiateCompression( StreamFeatureCompressZlib ); } // else if( ( m_streamFeatures & StreamFeatureCompressDclz ) // && m_connection->initCompression( StreamFeatureCompressDclz ) ) // { // negotiateCompression( StreamFeatureCompressDclz ); // } else if( m_streamFeatures & StreamFeatureIqAuth ) { notifyStreamEvent( StreamEventAuthentication ); nonSaslLogin(); } else { logInstance().err( LogAreaClassClient, "fallback: the server doesn't " "support any auth mechanisms we know about" ); disconnect( ConnNoSupportedAuth ); } } else { const std::string& name = tag->name(), xmlns = tag->findAttribute( XMLNS ); if( name == "proceed" && xmlns == XMLNS_STREAM_TLS ) { logInstance().dbg( LogAreaClassClient, "starting TLS handshake..." ); if( m_encryption ) { m_encryptionActive = true; m_encryption->handshake(); } } else if( name == "failure" ) { if( xmlns == XMLNS_STREAM_TLS ) { logInstance().err( LogAreaClassClient, "TLS handshake failed (server-side)!" ); disconnect( ConnTlsFailed ); } else if( xmlns == XMLNS_COMPRESSION ) { logInstance().err( LogAreaClassClient, "stream compression init failed!" ); disconnect( ConnCompressionFailed ); } else if( xmlns == XMLNS_STREAM_SASL ) { logInstance().err( LogAreaClassClient, "SASL authentication failed!" ); processSASLError( tag ); disconnect( ConnAuthenticationFailed ); } } else if( name == "compressed" && xmlns == XMLNS_COMPRESSION ) { logInstance().dbg( LogAreaClassClient, "stream compression inited" ); m_compressionActive = true; header(); } else if( name == "challenge" && xmlns == XMLNS_STREAM_SASL ) { logInstance().dbg( LogAreaClassClient, "processing SASL challenge" ); processSASLChallenge( tag->cdata() ); } else if( name == "success" && xmlns == XMLNS_STREAM_SASL ) { logInstance().dbg( LogAreaClassClient, "SASL authentication successful" ); setAuthed( true ); header(); } else return false; } return true; }
//! [connected] void ChatClient::connected() { emit connected(socket->peerName()); }
void start(const QVariant &vrequest, Mode mode) { outSeq = 0; outCredits = 0; quiet = false; ZhttpRequestPacket request; if(!request.fromVariant(vrequest)) { log_warning("failed to parse zurl request"); QVariantHash vhash = vrequest.toHash(); rid = vhash.value("id").toByteArray(); toAddress = vhash.value("from").toByteArray(); QByteArray type = vhash.value("type").toByteArray(); if(!toAddress.isEmpty() && type != "error" && type != "cancel") { QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); } else { cleanup(); QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection); } return; } rid = request.id; toAddress = request.from; userData = request.userData; sentHeader = false; stuffToRead = false; bytesReceived = 0; ignorePolicies = request.ignorePolicies; if(request.uri.isEmpty()) { log_warning("missing request uri"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } QString scheme = request.uri.scheme(); if(scheme == "https" || scheme == "http") { transport = HttpTransport; } else if(scheme == "wss" || scheme == "ws") { transport = WebSocketTransport; } else { log_warning("unsupported scheme"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } if(transport == WebSocketTransport && mode != Worker::Stream) { log_warning("websocket must be used from stream interface"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } int defaultPort; if(scheme == "https" || scheme == "wss") defaultPort = 443; else // http || wss defaultPort = 80; HttpHeaders headers = request.headers; if(transport == HttpTransport) { // fire and forget if(mode == Worker::Stream && (rid.isEmpty() || toAddress.isEmpty())) quiet = true; // streaming only allowed on streaming interface if(mode == Worker::Stream) outStream = request.stream; else outStream = false; if(request.method.isEmpty()) { log_warning("missing request method"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } log_info("IN id=%s, %s %s", request.id.data(), qPrintable(request.method), request.uri.toEncoded().data()); // inbound streaming must start with sequence number of 0 if(mode == Worker::Stream && request.more && request.seq != 0) { log_warning("streamed input must start with seq 0"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } // can't use these two together if(mode == Worker::Single && request.more) { log_warning("cannot use streamed input on router interface"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } bodySent = false; inSeq = request.seq; if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost))) { QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation")); return; } QByteArray hostHeader = request.uri.host().toUtf8(); // only tack on the port if it isn't being overridden int port = request.uri.port(defaultPort); if(request.connectPort == -1 && port != defaultPort) hostHeader += ":" + QByteArray::number(port); headers.removeAll("Host"); headers += HttpHeader("Host", hostHeader); hreq = new HttpRequest(dns, this); connect(hreq, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &))); connect(hreq, SIGNAL(readyRead()), SLOT(req_readyRead())); connect(hreq, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int))); connect(hreq, SIGNAL(error()), SLOT(req_error())); maxResponseSize = request.maxSize; sessionTimeout = request.timeout; if(!request.connectHost.isEmpty()) hreq->setConnectHost(request.connectHost); if(request.connectPort != -1) request.uri.setPort(request.connectPort); hreq->setIgnoreTlsErrors(request.ignoreTlsErrors); if(request.followRedirects) hreq->setFollowRedirects(8); if(request.credits != -1) outCredits += request.credits; } else // WebSocketTransport { log_info("IN id=%s, %s", request.id.data(), request.uri.toEncoded().data()); // inbound streaming must start with sequence number of 0 if(request.seq != 0) { log_warning("websocket input must start with seq 0"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } if(toAddress.isEmpty()) { log_warning("websocket input must provide from address"); QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request")); return; } inSeq = request.seq; if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost))) { QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation")); return; } QByteArray hostHeader = request.uri.host().toUtf8(); // only tack on the port if it isn't being overridden int port = request.uri.port(defaultPort); if(request.connectPort == -1 && port != defaultPort) hostHeader += ":" + QByteArray::number(port); headers.removeAll("Host"); headers += HttpHeader("Host", hostHeader); ws = new WebSocket(dns, this); connect(ws, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &))); connect(ws, SIGNAL(connected()), SLOT(ws_connected())); connect(ws, SIGNAL(readyRead()), SLOT(ws_readyRead())); connect(ws, SIGNAL(framesWritten(int)), SLOT(ws_framesWritten(int))); connect(ws, SIGNAL(peerClosing()), SLOT(ws_peerClosing())); connect(ws, SIGNAL(closed()), SLOT(ws_closed())); connect(ws, SIGNAL(error()), SLOT(ws_error())); if(!request.connectHost.isEmpty()) ws->setConnectHost(request.connectHost); if(request.connectPort != -1) request.uri.setPort(request.connectPort); ws->setIgnoreTlsErrors(request.ignoreTlsErrors); ws->setMaxFrameSize(config->sessionBufferSize); if(request.credits != -1) outCredits += request.credits; } httpActivityTimer = new QTimer(this); connect(httpActivityTimer, SIGNAL(timeout()), SLOT(httpActivity_timeout())); httpActivityTimer->setSingleShot(true); httpActivityTimer->start(config->activityTimeout * 1000); if(sessionTimeout != -1) { httpSessionTimer = new QTimer(this); connect(httpSessionTimer, SIGNAL(timeout()), SLOT(httpSession_timeout())); httpSessionTimer->setSingleShot(true); httpSessionTimer->start(sessionTimeout); } if(transport == WebSocketTransport || (transport == HttpTransport && mode == Worker::Stream)) { expireTimer = new QTimer(this); connect(expireTimer, SIGNAL(timeout()), SLOT(expire_timeout())); expireTimer->setSingleShot(true); expireTimer->start(SESSION_EXPIRE); keepAliveTimer = new QTimer(this); connect(keepAliveTimer, SIGNAL(timeout()), SLOT(keepAlive_timeout())); keepAliveTimer->start(SESSION_EXPIRE / 2); } if(transport == HttpTransport) { if(!request.body.isEmpty() && !request.more && !headers.contains("Content-Length")) headers += HttpHeader("Content-Length", QByteArray::number(request.body.size())); bool hasOrMightHaveBody = (!request.body.isEmpty() || request.more); hreq->start(request.method, request.uri, headers, hasOrMightHaveBody); if(hasOrMightHaveBody) { if(!request.body.isEmpty()) hreq->writeBody(request.body); if(!request.more) { bodySent = true; hreq->endBody(); } } else bodySent = true; if(mode == Stream) { if(request.more) { // send cts ZhttpResponsePacket resp; resp.type = ZhttpResponsePacket::Credit; resp.credits = config->sessionBufferSize; writeResponse(resp); } else { // send ack ZhttpResponsePacket resp; resp.type = ZhttpResponsePacket::KeepAlive; writeResponse(resp); } } } else // WebSocketTransport { ws->start(request.uri, headers); } }
void CoorImpl::emitConnected() { emit connected(); }
num degre(vertex v) { num aux=0; for( num k=0; k<size(); k++) aux+=connected(v,k); return aux; }
void TcpStream::onConnected(TcpSocket&) { connected(*this); }
Application::Application(int &argc, char **argv) : PsApplication(argc, argv), serverName(psServerPrefix() + cGUIDStr()), closing(false), updateRequestId(0), updateReply(0), updateThread(0), updateDownloader(0) { DEBUG_LOG(("Application Info: creation..")); QByteArray d(QDir((cPlatform() == dbipWindows ? cExeDir() : cWorkingDir()).toLower()).absolutePath().toUtf8()); char h[33] = { 0 }; hashMd5Hex(d.constData(), d.size(), h); serverName = psServerPrefix() + h + '-' + cGUIDStr(); if (mainApp) { DEBUG_LOG(("Application Error: another Application was created, terminating..")); exit(0); } mainApp = this; installEventFilter(new _DebugWaiter(this)); #if defined Q_OS_LINUX || defined Q_OS_LINUX64 QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/DejaVuSans.ttf")); QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/NanumMyeongjo-Regular.ttf")); #endif QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Regular.ttf")); QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Bold.ttf")); QFontDatabase::addApplicationFont(qsl(":/gui/art/fonts/OpenSans-Semibold.ttf")); float64 dpi = primaryScreen()->logicalDotsPerInch(); if (dpi <= 108) { // 0-96-108 cSetScreenScale(dbisOne); } else if (dpi <= 132) { // 108-120-132 cSetScreenScale(dbisOneAndQuarter); } else if (dpi <= 168) { // 132-144-168 cSetScreenScale(dbisOneAndHalf); } else { // 168-192-inf cSetScreenScale(dbisTwo); } if (devicePixelRatio() > 1) { cSetRetina(true); cSetRetinaFactor(devicePixelRatio()); cSetIntRetinaFactor(int32(cRetinaFactor())); } if (!cLangFile().isEmpty()) { LangLoaderPlain loader(cLangFile()); if (!loader.errors().isEmpty()) { LOG(("Lang load errors: %1").arg(loader.errors())); } else if (!loader.warnings().isEmpty()) { LOG(("Lang load warnings: %1").arg(loader.warnings())); } } Local::start(); style::startManager(); anim::startManager(); historyInit(); DEBUG_LOG(("Application Info: inited..")); window = new Window(); psInstallEventFilter(); connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected())); connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); connect(&socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(socketError(QLocalSocket::LocalSocketError))); connect(&socket, SIGNAL(bytesWritten(qint64)), this, SLOT(socketWritten(qint64))); connect(&socket, SIGNAL(readyRead()), this, SLOT(socketReading())); connect(&server, SIGNAL(newConnection()), this, SLOT(newInstanceConnected())); connect(this, SIGNAL(aboutToQuit()), this, SLOT(closeApplication())); connect(&updateCheckTimer, SIGNAL(timeout()), this, SLOT(startUpdateCheck())); connect(this, SIGNAL(updateFailed()), this, SLOT(onUpdateFailed())); connect(this, SIGNAL(updateReady()), this, SLOT(onUpdateReady())); connect(this, SIGNAL(applicationStateChanged(Qt::ApplicationState)), this, SLOT(onAppStateChanged(Qt::ApplicationState))); connect(&writeUserConfigTimer, SIGNAL(timeout()), this, SLOT(onWriteUserConfig())); writeUserConfigTimer.setSingleShot(true); connect(&killDownloadSessionsTimer, SIGNAL(timeout()), this, SLOT(killDownloadSessions())); if (cManyInstance()) { startApp(); } else { DEBUG_LOG(("Application Info: connecting local socket to %1..").arg(serverName)); socket.connectToServer(serverName); } }
void UsageTrackerPlugin::shutdown() { if (m_telemetryManager != NULL) { disconnect(m_telemetryManager, SIGNAL(connected()), this, SLOT(onAutopilotConnect())); } }
MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags) : QMainWindow(parent, flags), loginWindow_(NULL), connectWindow_(NULL), serverListWindow_(0), timer_(NULL), settingsMenu_(0), connected_(0), getServers_(NULL) { QCoreApplication::setOrganizationName("CPPP"); QCoreApplication::setApplicationName("VPNht"); ui.setupUi(this); setWindowTitle("VPN.ht " + QString(VERSION)); g_openVPNConnection = new OpenVPNConnectorQt(this); if (!g_openVPNConnection->installHelper(SERVICE_NAME)) { QMessageBox::information(this, "VPNht", "Failed to install helper for program. Please contact support."); QTimer::singleShot(1, this, SLOT(close())); return; } #if defined Q_OS_MAC //setAttribute(Qt::WA_QuitOnClose, false); #endif trayIcon_ = new QSystemTrayIcon(this); trayMenu_ = new QMenu(this); actConnect_ = new QAction("Connect", this); actDisconnect_ = new QAction("Disconnect", this); actHelp_ = new QAction("Help", this); actLiveChat_ = new QAction("Live chat", this); actExit_ = new QAction("Quit", this); trayMenu_->addAction(actConnect_); trayMenu_->addAction(actDisconnect_); trayMenu_->addSeparator(); trayMenu_->addAction(actHelp_); trayMenu_->addAction(actLiveChat_); trayMenu_->addAction(actExit_); trayIcon_->setContextMenu(trayMenu_); trayIcon_->hide(); setTrayStatusDisconnected(false); settingsMenu_ = new QMenu(this); settingsMenu_->addAction("Settings", this, SLOT(onSettings())); settingsMenu_->addAction("Status", this, SLOT(onStatus())); settingsMenu_->addAction("Help", this, SLOT(onHelp())); settingsMenu_->addAction("Proxy", this, SLOT(onProxy())); settingsMenu_->addAction("Show logs", this, SLOT(onShowLogs())); settingsMenu_->addAction("Logout", this, SLOT(onReturnToSignUp())); settingsMenu_->setStyleSheet(ctxMenuStyle); loginWindow_ = new LoginWindow(this); ui.verticalLayout->addWidget(loginWindow_); loginWindow_->loadSettings(); loginWindow_->hide(); connect(loginWindow_, SIGNAL(signedIn(QString, QString)), SLOT(onSignIn(QString, QString))); waitWindow_ = new WaitWindow(this); ui.verticalLayout->addWidget(waitWindow_); settingsWindow_ = new SettingsWindow(settingsMenu_, this); connect(settingsWindow_, SIGNAL(back()), SLOT(onBack())); ui.verticalLayout->addWidget(settingsWindow_); settingsWindow_->hide(); connectWindow_ = new ConnectWindow(settingsMenu_, this); connect(connectWindow_, SIGNAL(serverList()), SLOT(onServerList())); connect(connectWindow_, SIGNAL(connected()), SLOT(onConnected())); ui.verticalLayout->addWidget(connectWindow_); ui.verticalLayout->addWidget(connectWindow_); connectWindow_->hide(); serverListWindow_ = new ServerListWindow(this); connect(serverListWindow_, SIGNAL(serverSelected(const QString &)), this, SLOT( onChangeServer(const QString &) )); ui.verticalLayout->addWidget(serverListWindow_); serverListWindow_->hide(); proxySettingsWindow_ = new ProxySettingsWindow(settingsMenu_, this); connect(proxySettingsWindow_, SIGNAL(back()), SLOT(onBack())); ui.verticalLayout->addWidget(proxySettingsWindow_); proxySettingsWindow_->hide(); // tray action connect(actConnect_, SIGNAL(triggered()), connectWindow_, SLOT(onClickConnect())); connect(actDisconnect_, SIGNAL(triggered()), connectWindow_, SLOT(onClickConnect())); connect(actHelp_, SIGNAL(triggered()), SLOT(onActHelp())); connect(actLiveChat_, SIGNAL(triggered()), SLOT(onLiveChat())); connect(actExit_, SIGNAL(triggered()), SLOT(onExit())); #if defined Q_OS_WIN connect(trayIcon_, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), SLOT( onTrayActivated(QSystemTrayIcon::ActivationReason) )); #endif QSettings settings; if (settings.value("savePass", "true").toString() == "true") { QString username = settings.value("login", "").toString(); QString password = settings.value("password", "").toString(); if (!username.isEmpty() && !password.isEmpty()) { adjustSize(); setFixedSize(size()); skipLoginScreen(username, password); } else { waitWindow_->hide(); loginWindow_->show(); adjustSize(); setFixedSize(size()); } } else { waitWindow_->hide(); loginWindow_->show(); adjustSize(); setFixedSize(size()); } }
void Simulator::onStart() { QMutexLocker locker(&lock); QThread *mainThread = QThread::currentThread(); qDebug() << "Simulator Thread: " << mainThread; // Get required UAVObjects ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); UAVObjectManager *objManager = pm->getObject<UAVObjectManager>(); actDesired = ActuatorDesired::GetInstance(objManager); actCommand = ActuatorCommand::GetInstance(objManager); manCtrlCommand = ManualControlCommand::GetInstance(objManager); gcsReceiver = GCSReceiver::GetInstance(objManager); flightStatus = FlightStatus::GetInstance(objManager); posHome = HomeLocation::GetInstance(objManager); velActual = VelocityActual::GetInstance(objManager); posActual = PositionActual::GetInstance(objManager); baroAlt = BaroAltitude::GetInstance(objManager); flightBatt = FlightBatteryState::GetInstance(objManager); airspeedActual = AirspeedActual::GetInstance(objManager); attActual = AttitudeActual::GetInstance(objManager); attSettings = AttitudeSettings::GetInstance(objManager); accels = Accels::GetInstance(objManager); gyros = Gyros::GetInstance(objManager); gpsPos = GPSPosition::GetInstance(objManager); gpsVel = GPSVelocity::GetInstance(objManager); telStats = GCSTelemetryStats::GetInstance(objManager); groundTruth = GroundTruth::GetInstance(objManager); // Listen to autopilot connection events TelemetryManager *telMngr = pm->getObject<TelemetryManager>(); connect(telMngr, SIGNAL(connected()), this, SLOT(onAutopilotConnect())); connect(telMngr, SIGNAL(disconnected()), this, SLOT(onAutopilotDisconnect())); // connect(telStats, SIGNAL(objectUpdated(UAVObject*)), this, SLOT(telStatsUpdated(UAVObject*))); // If already connect setup autopilot GCSTelemetryStats::DataFields stats = telStats->getData(); if (stats.Status == GCSTelemetryStats::STATUS_CONNECTED) { onAutopilotConnect(); } inSocket = new QUdpSocket(); outSocket = new QUdpSocket(); setupUdpPorts(settings.hostAddress, settings.inPort, settings.outPort); emit processOutput("\nLocal interface: " + settings.hostAddress + "\n" + \ "Remote interface: " + settings.remoteAddress + "\n" + \ "inputPort: " + QString::number(settings.inPort) + "\n" + \ "outputPort: " + QString::number(settings.outPort) + "\n"); qxtLog->info("\nLocal interface: " + settings.hostAddress + "\n" + \ "Remote interface: " + settings.remoteAddress + "\n" + \ "inputPort: " + QString::number(settings.inPort) + "\n" + \ "outputPort: " + QString::number(settings.outPort) + "\n"); // if(!inSocket->waitForConnected(5000)) // emit processOutput(QString("Can't connect to %1 on %2 port!").arg(settings.hostAddress).arg(settings.inPort)); // outSocket->connectToHost(settings.hostAddress,settings.outPort); // FG // if(!outSocket->waitForConnected(5000)) // emit processOutput(QString("Can't connect to %1 on %2 port!").arg(settings.hostAddress).arg(settings.outPort)); connect(inSocket, SIGNAL(readyRead()), this, SLOT(receiveUpdate()), Qt::DirectConnection); // Setup transmit timer txTimer = new QTimer(); connect(txTimer, SIGNAL(timeout()), this, SLOT(transmitUpdate()), Qt::DirectConnection); txTimer->setInterval(updatePeriod); txTimer->start(); // Setup simulator connection timer simTimer = new QTimer(); connect(simTimer, SIGNAL(timeout()), this, SLOT(onSimulatorConnectionTimeout()), Qt::DirectConnection); simTimer->setInterval(simTimeout); simTimer->start(); // setup time time = new QTime(); time->start(); current.T = 0; current.i = 0; }
MainWindow::MainWindow(QWidget *parent, const QString& theHostName) : QMainWindow(parent), hostName(theHostName) { setObjectName(QStringLiteral("MainWindow")); resize(400, 300); QMediaPlaylist* playlist = new QMediaPlaylist; playlist->addMedia(QUrl("http://" + hostName + "/~andreas/out.mpg")); // playlist->addMedia(QUrl("http://" + hostName + ":1234/dvd.mp4")); player = new QMediaPlayer(this); // , QMediaPlayer::StreamPlayback); player->setPlaylist(playlist); QWidget* centralWidget = new QWidget(this); QBoxLayout* mainLayout = new QVBoxLayout(); centralWidget->setLayout(mainLayout); QWidget* buttonArea = new QWidget(this); QHBoxLayout* buttonLayout = new QHBoxLayout(); buttonArea->setLayout(buttonLayout); QVideoWidget* videoWidget = new QVideoWidget(centralWidget); mainLayout->addWidget(videoWidget, 1); mainLayout->addWidget(buttonArea); connectButton = new QPushButton("Connect", buttonArea); startPlayButton = new QPushButton("Play", buttonArea); startPlayButton->setEnabled(false); stopPlayButton = new QPushButton("Stop", buttonArea); stopPlayButton->setEnabled(false); streamButton = new QPushButton("Stream", buttonArea); streamButton->setEnabled(false); buttonLayout->addWidget(connectButton); buttonLayout->addWidget(startPlayButton); buttonLayout->addWidget(stopPlayButton); buttonLayout->addWidget(streamButton); tcpSocket = new QTcpSocket(this); connect(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)), this, SLOT(statusChanged(QMediaPlayer::MediaStatus))); connect(connectButton, SIGNAL(clicked()), this, SLOT(doConnect())); connect(startPlayButton, SIGNAL(clicked()), this, SLOT(doStartPlay())); connect(stopPlayButton, SIGNAL(clicked()), this, SLOT(doStopPlay())); connect(streamButton, SIGNAL(clicked()), this, SLOT(doStream())); connect(tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); connect(tcpSocket, SIGNAL(connected()), this, SLOT(socketConnected())); connect(tcpSocket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(readData())); player->setVideoOutput(videoWidget); setCentralWidget(centralWidget); player->play(); }
int main(int argc, char* argv[]) { // a global variable defined in errno.h that's "set by system // calls and some library functions [to a nonzero value] // in the event of an error to indicate what went wrong" errno = 0; // default to a random port int port = 0; // usage const char* usage = "Usage: server [-p port] /path/to/root"; // parse command-line arguments int opt; while ((opt = getopt(argc, argv, "hp:")) != -1) { switch (opt) { // -h case 'h': printf("%s\n", usage); return 0; // -p port case 'p': port = atoi(optarg); break; } } // ensure port is a non-negative short and path to server's root is specified if (port < 0 || port > SHRT_MAX || argv[optind] == NULL || strlen(argv[optind]) == 0) { // announce usage printf("%s\n", usage); // return 2 just like bash's builtins return 2; } // start server start(port, argv[optind]); // listen for SIGINT (aka control-c) signal(SIGINT, handler); // accept connections one at a time while (true) { // reset server's state reset(); // wait until client is connected if (connected()) { // parse client's HTTP request ssize_t octets = parse(); if (octets == -1) { continue; } // extract request's request-line // http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html const char* haystack = request; char* needle = strstr(haystack, "\r\n"); if (needle == NULL) { error(400); continue; } else if (needle - haystack + 2 > LimitRequestLine) { error(414); continue; } char line[needle - haystack + 2 + 1]; strncpy(line, haystack, needle - haystack + 2); line[needle - haystack + 2] = '\0'; // log request-line printf("%s", line); // validate request-line char lineTokens[needle - haystack + 1]; strncpy(lineTokens, haystack, needle - haystack); lineTokens[needle - haystack + 1] = '\0'; char* requestLine[3] = {NULL, NULL, NULL}; requestLine[METHOD] = strtok(lineTokens, " "); int i = 0; while (requestLine[i] != NULL && i < 2) { i++; requestLine[i] = strtok(lineTokens, " "); } if (requestLine[METHOD] == NULL || strcmp("GET", requestLine[METHOD]) != 0) { error(405); continue; } if (requestLine[REQUEST_TARGET] == NULL) { error(400); continue; } else if (requestLine[REQUEST_TARGET][0] != '/') { error(501); continue; } else if (strchr(requestLine[REQUEST_TARGET], '\"') != NULL); { error(400); continue; } if (requestLine[HTTP_VERSION] == NULL || strcmp("HTTP/1.1", requestLine[HTTP_VERSION]) != 0) { error(505); continue; } // extract query from request-target char* queryInd = strchrnul(requestLine[REQUEST_TARGET], '?'); char* eosInd = strchr(requestLine[REQUEST_TARGET], '\0'); char query[(eosInd - queryInd < 1) ? 1 : eosInd - queryInd]; memcpy(query, (strncmp(queryInd, "\0", 1) ? queryInd : queryInd + 1), (eosInd - queryInd < 1) ? 1 : eosInd - queryInd); // get absolute-path char* query_Ind = strchrnul(requestLine[REQUEST_TARGET], '?'); char absolutePath[query_Ind - requestLine[REQUEST_TARGET] + 1]; strncpy(absolutePath, requestLine[REQUEST_TARGET], query_Ind - requestLine[REQUEST_TARGET]); absolutePath[query_Ind - requestLine[REQUEST_TARGET]] = '\0'; // is absolute path missing a "." for the extension? char* extInd = strchr(absolutePath, '.'); if (extInd == NULL) { error(501); continue; } // extract path extension char* eos_Ind = strchr(absolutePath, '\0'); char extension[eos_Ind - extInd]; memcpy(extension, extInd + 1, eos_Ind - extInd); // concatenate root and absolute-path char path[strlen(root) + strlen(absolutePath) + 1]; strcpy(path, root); strcat(path, absolutePath); // ensure path exists if (access(path, F_OK) == -1) { error(404); continue; } // ensure path is readable if (access(path, R_OK) == -1) { error(403); continue; } // dynamic content if (strcasecmp("php", extension) == 0) { // open pipe to PHP interpreter char* format = "QUERY_STRING=\"%s\" REDIRECT_STATUS=200 SCRIPT_FILENAME=\"%s\" php-cgi"; char command[strlen(format) + (strlen(path) - 2) + (strlen(query) - 2) + 1]; sprintf(command, format, query, path); file = popen(command, "r"); if (file == NULL) { error(500); continue; } // load file ssize_t size = load(); if (size == -1) { error(500); continue; } // subtract php-cgi's headers from body's size to get content's length haystack = body; needle = memmem(haystack, size, "\r\n\r\n", 4); if (needle == NULL) { error(500); continue; } size_t length = size - (needle - haystack + 4); // respond to client if (dprintf(cfd, "HTTP/1.1 200 OK\r\n") < 0) { continue; } if (dprintf(cfd, "Connection: close\r\n") < 0) { continue; } if (dprintf(cfd, "Content-Length: %i\r\n", length) < 0) { continue; } if (write(cfd, body, size) == -1) { continue; } } // static content else { // look up file's MIME type const char* type = lookup(extension); if (type == NULL) { error(501); continue; } // open file file = fopen(path, "r"); if (file == NULL) { error(500); continue; } // load file ssize_t length = load(); if (length == -1) { error(500); continue; } // respond to client if (dprintf(cfd, "HTTP/1.1 200 OK\r\n") < 0) { continue; } if (dprintf(cfd, "Connection: close\r\n") < 0) { continue; } if (dprintf(cfd, "Content-Length: %i\r\n", length) < 0) { continue; } if (dprintf(cfd, "Content-Type: %s\r\n\r\n", type) < 0) { continue; } if (write(cfd, body, length) == -1) { continue; } } // announce OK printf("\033[32m"); printf("HTTP/1.1 200 OK"); printf("\033[39m\n"); } } }
XMPP::XMPP(QObject *parent) : QXmppClient(parent), m_Hub(NULL), m_App(NULL), m_Connected(false), m_LastError(0), m_SendContactWhenAvailable(false), m_ConnectionType(OTHER), m_Port(27015), m_NotificationEnabled(true), m_Restarting(false), m_VcardManagerConnected(false) { m_PauseService = false; bool check = connect(this, SIGNAL(messageReceived(QXmppMessage)), this, SLOT(messageReceived(QXmppMessage))); Q_ASSERT(check); check = connect(&this->rosterManager(), SIGNAL(rosterReceived()), this, SLOT(rosterReceived())); Q_ASSERT(check); Q_UNUSED(check); check = connect(this, SIGNAL(connected()), this, SLOT(logConnection())); Q_ASSERT(check); Q_UNUSED(check); check = connect(this, SIGNAL(error(QXmppClient::Error)), this, SLOT(logConnectionError(QXmppClient::Error))); Q_ASSERT(check); check = connect(&this->rosterManager(), SIGNAL(presenceChanged(QString,QString)), SLOT(presenceChanged(QString,QString))); Q_ASSERT(check); // --------------------------------------------------------------------- // communication controls m_Server = boost::shared_ptr<QTcpServer>(new QTcpServer(this)); bool ok = connect(m_Server.get(), SIGNAL(newConnection()), this, SLOT(newConnection())); Q_ASSERT(ok); Q_UNUSED(ok); // put the handling of the server into a thread --> avoid blocking the XMPP client while listening a new UI client... m_TcpThreadBind = boost::shared_ptr<TcpThreadBind>(new TcpThreadBind()); m_TcpThreadBind->m_Server = m_Server; m_TcpThreadBind->m_Port = m_Port; initOTR(); // --------------------------------------------------------------------- // connection using oauth (PREFERED) QSettings settings("Amonchakai", "Hg10"); if(!settings.value("access_token").value<QString>().isEmpty()) { m_GoogleConnect = boost::shared_ptr<GoogleConnectController>(new GoogleConnectController()); bool check = connect(m_GoogleConnect.get(), SIGNAL(tokenObtained(const QString&)), this, SLOT(readyRestart(const QString &))); Q_ASSERT(check); Q_UNUSED(check); check = connect(m_GoogleConnect.get(), SIGNAL(failedRenew()), this, SLOT(oauth2Restart())); Q_ASSERT(check); //check = connect(m_GoogleConnect.get(), SIGNAL(failedConnection()), this, SLOT(waitForInternet())); //Q_ASSERT(check); check = connect(this, SIGNAL(disconnected()), this, SLOT(oauthDisconnected())); Q_ASSERT(check); oauth2Restart(); } else {
void AccountNotificationService::ignoreErrors(const Notification ¬ification) { auto account = qvariant_cast<Account>(notification.data[QStringLiteral("account")]); account.addProperty(QStringLiteral("notify:ignore-connection-errors"), false, CustomProperties::NonStorable); connect(account, SIGNAL(connected()), this, SLOT(accountConnected())); }
ConfigServoWidget::ConfigServoWidget(QWidget *parent) : ConfigTaskWidget(parent) { m_config = new Ui_SettingsWidget(); m_config->setupUi(this); ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); UAVObjectManager *objManager = pm->getObject<UAVObjectManager>(); // First of all, put all the channel widgets into lists, so that we can // manipulate those: // NOTE: for historical reasons, we have objects below called ch0 to ch7, but the convention for OP is Channel 1 to Channel 8. outLabels << m_config->ch0OutValue << m_config->ch1OutValue << m_config->ch2OutValue << m_config->ch3OutValue << m_config->ch4OutValue << m_config->ch5OutValue << m_config->ch6OutValue << m_config->ch7OutValue; outSliders << m_config->ch0OutSlider << m_config->ch1OutSlider << m_config->ch2OutSlider << m_config->ch3OutSlider << m_config->ch4OutSlider << m_config->ch5OutSlider << m_config->ch6OutSlider << m_config->ch7OutSlider; outMin << m_config->ch0OutMin << m_config->ch1OutMin << m_config->ch2OutMin << m_config->ch3OutMin << m_config->ch4OutMin << m_config->ch5OutMin << m_config->ch6OutMin << m_config->ch7OutMin; outMax << m_config->ch0OutMax << m_config->ch1OutMax << m_config->ch2OutMax << m_config->ch3OutMax << m_config->ch4OutMax << m_config->ch5OutMax << m_config->ch6OutMax << m_config->ch7OutMax; reversals << m_config->ch0Rev << m_config->ch1Rev << m_config->ch2Rev << m_config->ch3Rev << m_config->ch4Rev << m_config->ch5Rev << m_config->ch6Rev << m_config->ch7Rev; inMaxLabels << m_config->ch0Max << m_config->ch1Max << m_config->ch2Max << m_config->ch3Max << m_config->ch4Max << m_config->ch5Max << m_config->ch6Max << m_config->ch7Max; inMinLabels << m_config->ch0Min << m_config->ch1Min << m_config->ch2Min << m_config->ch3Min << m_config->ch4Min << m_config->ch5Min << m_config->ch6Min << m_config->ch7Min; inNeuLabels << m_config->ch0Cur << m_config->ch1Cur << m_config->ch2Cur << m_config->ch3Cur << m_config->ch4Cur << m_config->ch5Cur << m_config->ch6Cur << m_config->ch7Cur; inSliders << m_config->inSlider0 << m_config->inSlider1 << m_config->inSlider2 << m_config->inSlider3 << m_config->inSlider4 << m_config->inSlider5 << m_config->inSlider6 << m_config->inSlider7; // Now connect the widget to the ManualControlCommand / Channel UAVObject UAVDataObject* obj = dynamic_cast<UAVDataObject*>(objManager->getObject(QString("ManualControlCommand"))); connect(obj, SIGNAL(objectUpdated(UAVObject*)), this, SLOT(updateChannels(UAVObject*))); // Get the receiver types supported by OpenPilot and fill the corresponding // dropdown menu: obj = dynamic_cast<UAVDataObject*>(objManager->getObject(QString("ManualControlSettings"))); QString fieldName = QString("InputMode"); UAVObjectField *field = obj->getField(fieldName); m_config->receiverType->addItems(field->getOptions()); m_config->receiverType->setDisabled(true); // This option does not work for now, it is a compile-time option. // Fill in the dropdown menus for the channel RC Input assignement. QStringList channelsList; channelsList << "None"; QList<UAVObjectField*> fieldList = obj->getFields(); foreach (UAVObjectField* field, fieldList) { if (field->getUnits().contains("channel")) { channelsList.append(field->getName()); } } m_config->ch0Assign->addItems(channelsList); m_config->ch1Assign->addItems(channelsList); m_config->ch2Assign->addItems(channelsList); m_config->ch3Assign->addItems(channelsList); m_config->ch4Assign->addItems(channelsList); m_config->ch5Assign->addItems(channelsList); m_config->ch6Assign->addItems(channelsList); m_config->ch7Assign->addItems(channelsList); // And for the channel output assignement options m_config->ch0Output->addItem("None"); m_config->ch1Output->addItem("None"); m_config->ch2Output->addItem("None"); m_config->ch3Output->addItem("None"); m_config->ch4Output->addItem("None"); m_config->ch5Output->addItem("None"); m_config->ch6Output->addItem("None"); m_config->ch7Output->addItem("None"); // And the flight mode settings: field = obj->getField(QString("FlightModePosition")); m_config->fmsModePos1->addItems(field->getOptions()); m_config->fmsModePos2->addItems(field->getOptions()); m_config->fmsModePos3->addItems(field->getOptions()); field = obj->getField(QString("Stabilization1Settings")); channelsList.clear(); channelsList.append(field->getOptions()); m_config->fmsSsPos1Roll->addItems(channelsList); m_config->fmsSsPos1Pitch->addItems(channelsList); m_config->fmsSsPos1Yaw->addItems(channelsList); m_config->fmsSsPos2Roll->addItems(channelsList); m_config->fmsSsPos2Pitch->addItems(channelsList); m_config->fmsSsPos2Yaw->addItems(channelsList); m_config->fmsSsPos3Roll->addItems(channelsList); m_config->fmsSsPos3Pitch->addItems(channelsList); m_config->fmsSsPos3Yaw->addItems(channelsList); // And the Armin configurations: field = obj->getField(QString("Arming")); m_config->armControl->clear(); m_config->armControl->addItems(field->getOptions()); obj = dynamic_cast<UAVDataObject*>(objManager->getObject(QString("ActuatorSettings"))); fieldList = obj->getFields(); foreach (UAVObjectField* field, fieldList) { if (field->getUnits().contains("channel")) { m_config->ch0Output->addItem(field->getName()); m_config->ch1Output->addItem(field->getName()); m_config->ch2Output->addItem(field->getName()); m_config->ch3Output->addItem(field->getName()); m_config->ch4Output->addItem(field->getName()); m_config->ch5Output->addItem(field->getName()); m_config->ch6Output->addItem(field->getName()); m_config->ch7Output->addItem(field->getName()); } } // set the RC input tneutral value textees for (int i = 0; i < 8; i++) inNeuLabels[i]->setText(QString::number(inSliders[i]->value())); for (int i = 0; i < 8; i++) { connect(outMin[i], SIGNAL(editingFinished()), this, SLOT(setChOutRange())); connect(outMax[i], SIGNAL(editingFinished()), this, SLOT(setChOutRange())); connect(reversals[i], SIGNAL(toggled(bool)), this, SLOT(reverseChannel(bool))); // Now connect the channel out sliders to our signal to send updates in test mode connect(outSliders[i], SIGNAL(valueChanged(int)), this, SLOT(sendChannelTest(int))); } connect(m_config->channelOutTest, SIGNAL(toggled(bool)), this, SLOT(runChannelTests(bool))); requestRCInputUpdate(); requestRCOutputUpdate(); connect(m_config->saveRCInputToSD, SIGNAL(clicked()), this, SLOT(saveRCInputObject())); connect(m_config->saveRCInputToRAM, SIGNAL(clicked()), this, SLOT(sendRCInputUpdate())); connect(m_config->getRCInputCurrent, SIGNAL(clicked()), this, SLOT(requestRCInputUpdate())); // Flightmode panel is connected to the same as rcinput because // the underlying object is the same! connect(m_config->saveFmsToSD, SIGNAL(clicked()), this, SLOT(saveRCInputObject())); connect(m_config->saveFmsToRAM, SIGNAL(clicked()), this, SLOT(sendRCInputUpdate())); connect(m_config->getFmsCurrent, SIGNAL(clicked()), this, SLOT(requestRCInputUpdate())); connect(m_config->saveArmToSD, SIGNAL(clicked()), this, SLOT(saveRCInputObject())); connect(m_config->saveArmToRAM, SIGNAL(clicked()), this, SLOT(sendRCInputUpdate())); connect(m_config->getArmCurrent, SIGNAL(clicked()), this, SLOT(requestRCInputUpdate())); connect(m_config->saveRCOutputToSD, SIGNAL(clicked()), this, SLOT(saveRCOutputObject())); connect(m_config->saveRCOutputToRAM, SIGNAL(clicked()), this, SLOT(sendRCOutputUpdate())); connect(m_config->getRCOutputCurrent, SIGNAL(clicked()), this, SLOT(requestRCOutputUpdate())); connect(parent, SIGNAL(autopilotConnected()),this, SLOT(requestRCInputUpdate())); connect(parent, SIGNAL(autopilotConnected()),this, SLOT(requestRCOutputUpdate())); connect(m_config->inSlider0, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged0(int))); connect(m_config->inSlider1, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged1(int))); connect(m_config->inSlider2, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged2(int))); connect(m_config->inSlider3, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged3(int))); connect(m_config->inSlider4, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged4(int))); connect(m_config->inSlider5, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged5(int))); connect(m_config->inSlider6, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged6(int))); connect(m_config->inSlider7, SIGNAL(valueChanged(int)),this, SLOT(onInSliderValueChanged7(int))); firstUpdate = true; enableControls(false); // Listen to telemetry connection events if (pm) { TelemetryManager *tm = pm->getObject<TelemetryManager>(); if (tm) { connect(tm, SIGNAL(myStart()), this, SLOT(onTelemetryStart())); connect(tm, SIGNAL(myStop()), this, SLOT(onTelemetryStop())); connect(tm, SIGNAL(connected()), this, SLOT(onTelemetryConnect())); connect(tm, SIGNAL(disconnected()), this, SLOT(onTelemetryDisconnect())); } } }
void BooRedisAsync::doWrite(const std::string &msg) { m_writeBuffer.push_back(msg); if (connected() && !m_writeInProgress) writeStart(); }
int user_find_cuts(void *user, int varnum, int iter_num, int level, int index, double objval, int *indices, double *values, double ub, double etol, int *num_cuts, int *alloc_cuts, cut_data ***cuts) { vrp_cg_problem *vrp = (vrp_cg_problem *)user; int vertnum = vrp->vertnum; network *n; vertex *verts = NULL; int *compdemands = NULL, *compnodes = NULL, *compnodes_copy = NULL; int *compmembers = NULL, comp_num = 0; /*__BEGIN_EXPERIMENTAL_SECTION__*/ int *compdemands_copy = NULL; double *compcuts_copy = NULL, *compdensity = NULL, density; /*___END_EXPERIMENTAL_SECTION___*/ double node_cut, max_node_cut, *compcuts = NULL; int rcnt, cur_bins = 0, k; char **coef_list; int i, max_node; double cur_slack = 0.0; int capacity = vrp->capacity; int cut_size = (vertnum >> DELETE_POWER) + 1; cut_data *new_cut = NULL; elist *cur_edge = NULL; int which_connected_routine = vrp->par.which_connected_routine; int *ref = vrp->ref; double *cut_val = vrp->cut_val; char *in_set = vrp->in_set; char *cut_list = vrp->cut_list; elist *cur_edge1 = NULL, *cur_edge2 = NULL; /*__BEGIN_EXPERIMENTAL_SECTION__*/ #ifdef COMPILE_OUR_DECOMP edge *edge_pt; #endif /*___END_EXPERIMENTAL_SECTION___*/ int node1 = 0, node2 = 0; int *demand = vrp->demand; int *new_demand = vrp->new_demand; int total_demand = demand[0]; int num_routes = vrp->numroutes, num_trials; int triangle_cuts = 0; char *coef; if (iter_num == 1) SRANDOM(1); /*__BEGIN_EXPERIMENTAL_SECTION__*/ #if 0 CCutil_sprand(1, &rand_state); #endif /*___END_EXPERIMENTAL_SECTION___*/ /*__BEGIN_EXPERIMENTAL_SECTION__*/ #if 0 if (vrp->dg_id && vrp->par.verbosity > 3){ sprintf(name, "support graph"); display_support_graph(vrp->dg_id, (p->cur_sol.xindex == 0 && p->cur_sol.xiter_num == 1) ? TRUE: FALSE, name, varnum, xind, xval, etol, CTOI_WAIT_FOR_CLICK_AND_REPORT); } #endif /*___END_EXPERIMENTAL_SECTION___*/ /* This creates a fractional graph representing the LP solution */ n = createnet(indices, values, varnum, etol, vrp->edges, demand, vertnum); if (n->is_integral){ /* if the network is integral, check for connectivity */ check_connectivity(n, etol, capacity, num_routes, cuts, num_cuts, alloc_cuts); free_net(n); return(USER_SUCCESS); } #ifdef DO_TSP_CUTS if (vrp->par.which_tsp_cuts && vrp->par.tsp_prob){ tsp_cuts(n, vrp->par.verbosity, vrp->par.tsp_prob, vrp->par.which_tsp_cuts, cuts, num_cuts, alloc_cuts); free_net(n); return(USER_SUCCESS); } #endif /*__BEGIN_EXPERIMENTAL_SECTION__*/ if (!vrp->par.always_do_mincut){/*user_par.always_do_mincut indicates whether we should just always do the min_cut routine or whether we should also try this routine*/ /*___END_EXPERIMENTAL_SECTION___*/ /*UNCOMMENT FOR PRODUCTION CODE*/ #if 0 { #endif verts = n->verts; if (which_connected_routine == BOTH) which_connected_routine = CONNECTED; new_cut = (cut_data *) calloc(1, sizeof(cut_data)); new_cut->size = cut_size; compnodes_copy = (int *) malloc((vertnum + 1) * sizeof(int)); compmembers = (int *) malloc((vertnum + 1) * sizeof(int)); /*__BEGIN_EXPERIMENTAL_SECTION__*/ compdemands_copy = (int *) calloc(vertnum + 1, sizeof(int)); compcuts_copy = (double *) calloc(vertnum + 1, sizeof(double)); #ifdef COMPILE_OUR_DECOMP compdensity = vrp->par.do_our_decomp ? (double *) calloc(vertnum+1, sizeof(double)) : NULL; #endif /*___END_EXPERIMENTAL_SECTION___*/ do{ compnodes = (int *) calloc(vertnum + 1, sizeof(int)); compdemands = (int *) calloc(vertnum + 1, sizeof(int)); compcuts = (double *) calloc(vertnum + 1, sizeof(double)); /*------------------------------------------------------------------*\ * Get the connected components of the solution graph without the * depot and see if the number of components is more than one \*------------------------------------------------------------------*/ rcnt = (which_connected_routine == BICONNECTED ? biconnected(n, compnodes, compdemands, compcuts) : connected(n, compnodes, compdemands, compmembers, /*__BEGIN_EXPERIMENTAL_SECTION__*/ compcuts, compdensity)); /*___END_EXPERIMENTAL_SECTION___*/ /*UNCOMMENT FOR PRODUCTION CODE*/ #if 0 compcuts, NULL)); #endif /* copy the arrays as they will be needed later */ if (!which_connected_routine && /*__BEGIN_EXPERIMENTAL_SECTION__*/ (vrp->par.do_greedy || vrp->par.do_our_decomp)){ /*___END_EXPERIMENTAL_SECTION___*/ /*UNCOMMENT FOR PRODUCTION CODE*/ #if 0 vrp->par.do_greedy){ #endif compnodes_copy = (int *) memcpy((char *)compnodes_copy, (char*)compnodes, (vertnum+1)*sizeof(int)); /*__BEGIN_EXPERIMENTAL_SECTION__*/ compdemands_copy = (int *) memcpy((char *)compdemands_copy, (char *)compdemands, (vertnum+1)*ISIZE); compcuts_copy = (double *) memcpy((char *)compcuts_copy, (char *)compcuts, (vertnum+1)*DSIZE); /*___END_EXPERIMENTAL_SECTION___*/ n->compnodes = compnodes_copy; comp_num = rcnt; } if (rcnt > 1){ /*---------------------------------------------------------------*\ * If the number of components is more then one, then check each * component to see if it violates a capacity constraint \*---------------------------------------------------------------*/ coef_list = (char **) calloc(rcnt, sizeof(char *)); coef_list[0] = (char *) calloc(rcnt*cut_size, sizeof(char)); for(i = 1; i<rcnt; i++) coef_list[i] = coef_list[0]+i*cut_size; for(i = 1; i < vertnum; i++) (coef_list[(verts[i].comp)-1][i >> DELETE_POWER]) |= (1 << (i & DELETE_AND)); for (i = 0; i < rcnt; i++){ if (compnodes[i+1] < 2) continue; /*check ith component to see if it violates a constraint*/ if (vrp->par.which_connected_routine == BOTH && which_connected_routine == BICONNECTED && compcuts[i+1]==0) continue; if (compcuts[i+1] < 2*BINS(compdemands[i+1], capacity)-etol){ /*the constraint is violated so impose it*/ new_cut->coef = (char *) (coef_list[i]); new_cut->type = (compnodes[i+1] < vertnum/2 ? SUBTOUR_ELIM_SIDE:SUBTOUR_ELIM_ACROSS); new_cut->rhs = (new_cut->type == SUBTOUR_ELIM_SIDE ? RHS(compnodes[i+1],compdemands[i+1], capacity): 2*BINS(compdemands[i+1], capacity)); cg_send_cut(new_cut, num_cuts, alloc_cuts, cuts); } else{/*if the constraint is not violated, then try generating a violated constraint by deleting customers that don't change the number of trucks required by the customers in the component but decrease the value of the cut*/ cur_bins = BINS(compdemands[i+1], capacity);/*the current number of trucks required*/ /*current slack in the constraint*/ cur_slack = (compcuts[i+1] - 2*cur_bins); while (compnodes[i+1]){/*while there are still nodes in the component*/ for (max_node = 0, max_node_cut = 0, k = 1; k < vertnum; k++){ if (verts[k].comp == i+1){ if (BINS(compdemands[i+1]-verts[k].demand, capacity) == cur_bins){ /*if the number of trucks doesn't decrease upon deleting this customer*/ for (node_cut = 0, cur_edge = verts[k].first; cur_edge; cur_edge = cur_edge->next_edge){ node_cut += (cur_edge->other_end ? -cur_edge->data->weight : cur_edge->data->weight); } if (node_cut > max_node_cut){/*check whether the value of the cut decrease is the best seen so far*/ max_node = k; max_node_cut = node_cut; } } } } if (!max_node){ break; } /*delete the customer that exhibited the greatest decrease in cut value*/ compnodes[i+1]--; compdemands[i+1] -= verts[max_node].demand; compcuts[i+1] -= max_node_cut; cur_slack -= max_node_cut; verts[max_node].comp = 0; coef_list[i][max_node >> DELETE_POWER] ^= (1 << (max_node & DELETE_AND)); if (cur_slack < 0){/*if the cut is now violated, impose it*/ new_cut->coef = (char *) (coef_list[i]); new_cut->type = (compnodes[i+1] < vertnum/2 ? SUBTOUR_ELIM_SIDE:SUBTOUR_ELIM_ACROSS); new_cut->size = cut_size; new_cut->rhs = (new_cut->type == SUBTOUR_ELIM_SIDE ? RHS(compnodes[i+1], compdemands[i+1], capacity): 2*cur_bins); cg_send_cut(new_cut, num_cuts, alloc_cuts, cuts); break; } } } } FREE(coef_list[0]); FREE(coef_list); } which_connected_routine++; FREE(compnodes); FREE(compdemands); FREE(compcuts); }while((!(*num_cuts) && vrp->par.which_connected_routine == BOTH)
JAccount::JAccount(const QString &id) : Account(id, JProtocol::instance()), d_ptr(new JAccountPrivate(this)) { Q_D(JAccount); d->client.reset(new Client(id)); connect(d->client.data(), SIGNAL(disconnected(Jreen::Client::DisconnectReason)), this, SLOT(_q_disconnected(Jreen::Client::DisconnectReason))); connect(d->client.data(), SIGNAL(serverFeaturesReceived(QSet<QString>)), this ,SLOT(_q_init_extensions(QSet<QString>))); Account::setStatus(Status::instance(Status::Offline, "jabber")); d->loadedModules = 0; d->roster = new JRoster(this); d->privacyManager = new PrivacyManager(d->client.data()); Jreen::Capabilities::Ptr caps = d->client->presence().payload<Jreen::Capabilities>(); caps->setNode(QLatin1String("http://qutim.org/")); d->privateXml = new Jreen::PrivateXml(d->client.data()); d->pubSubManager = new Jreen::PubSub::Manager(d->client.data()); d->conferenceManager = new JMUCManager(this, this); d->messageSessionManager = new JMessageSessionManager(this); d->softwareDetection = new JSoftwareDetection(this); d->client->presence().addExtension(new VCardUpdate()); Jreen::Disco *disco = d->client->disco(); disco->setSoftwareVersion(QLatin1String("qutIM"), versionString(), SystemInfo::getFullName()); disco->addIdentity(Jreen::Disco::Identity(QLatin1String("client"), QLatin1String("type"), QLatin1String("qutIM"), QLatin1String("en"))); QString qutim = tr("qutIM", "Local qutIM's name"); QString lang = tr("en", "Default language"); if(qutim != QLatin1String("qutIM") && lang != QLatin1String("en")) disco->addIdentity(Jreen::Disco::Identity(QLatin1String("client"), QLatin1String("type"),qutim,lang)); connect(d->roster, SIGNAL(loaded()), &d->signalMapper, SLOT(map())); connect(d->privacyManager, SIGNAL(listsReceived()), &d->signalMapper, SLOT(map())); d->signalMapper.setMapping(d->roster, 1); d->signalMapper.setMapping(d->privacyManager, 2); connect(d->client.data(), SIGNAL(connected()), d->privacyManager, SLOT(request())); connect(&d->signalMapper, SIGNAL(mapped(int)), this, SLOT(_q_on_module_loaded(int))); // connect(d->roster, SIGNAL(loaded()), d, SLOT(onConnected())); // connect(d->client.data(),SIGNAL(connected()), d, SLOT(onConnected())); d->roster->loadFromStorage(); connect(d->conferenceManager.data(), SIGNAL(conferenceCreated(qutim_sdk_0_3::Conference*)), this, SIGNAL(conferenceCreated(qutim_sdk_0_3::Conference*))); // d->params.addItem<Jreen::Client>(d->client); // d->params.addItem<Jreen::PubSub::Manager>(d->pubSubManager); // d->params.addItem<Adhoc>(p->adhoc); // d->params.addItem<VCardManager>(p->vCardManager->manager()); // d->params.addItem<SIManager>(p->siManager); // d->softwareDetection = new JSoftwareDetection(p->account, p->params); foreach (const ObjectGenerator *gen, ObjectGenerator::module<JabberExtension>()) { if (JabberExtension *ext = gen->generate<JabberExtension>()) { d->extensions.append(ext); ext->init(this); } } }
int main(int argc, char* argv[]) { // a global variable defined in errno.h that's "set by system // calls and some library functions [to a nonzero value] // in the event of an error to indicate what went wrong" errno = 0; // default to port 8080 int port = 8080; // usage const char* usage = "Usage: server [-p port] /path/to/root"; // parse command-line arguments int opt; while ((opt = getopt(argc, argv, "hp:")) != -1) { switch (opt) { // -h case 'h': printf("%s\n", usage); return 0; // -p port case 'p': port = atoi(optarg); break; } } // ensure port is a non-negative short and path to server's root is specified if (port < 0 || port > SHRT_MAX || argv[optind] == NULL || strlen(argv[optind]) == 0) { // announce usage printf("%s\n", usage); // return 2 just like bash's builtins return 2; } // start server start(port, argv[optind]); // listen for SIGINT (aka control-c) struct sigaction act; act.sa_handler = handler; act.sa_flags = 0; sigemptyset(&act.sa_mask); sigaction(SIGINT, &act, NULL); // a message and its length char* message = NULL; size_t length = 0; // path requested char* path = NULL; // accept connections one at a time while (true) { // free last path, if any if (path != NULL) { free(path); path = NULL; } // free last message, if any if (message != NULL) { free(message); message = NULL; } length = 0; // close last client's socket, if any if (cfd != -1) { close(cfd); cfd = -1; } // check for control-c if (signaled) { stop(); } // check whether client has connected if (connected()) { // check for request if (request(&message, &length)) { // extract message's request-line // http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html const char* haystack = message; const char* needle = strstr(haystack, "\r\n"); if (needle == NULL) { error(500); continue; } char line[needle - haystack + 2 + 1]; strncpy(line, haystack, needle - haystack + 2); line[needle - haystack + 2] = '\0'; // log request-line printf("%s", line); // parse request-line char abs_path[LimitRequestLine + 1]; char query[LimitRequestLine + 1]; if (parse(line, abs_path, query)) { // URL-decode absolute-path char* p = urldecode(abs_path); if (p == NULL) { error(500); continue; } // resolve absolute-path to local path path = malloc(strlen(root) + strlen(p) + 1); if (path == NULL) { error(500); continue; } strcpy(path, root); strcat(path, p); free(p); // ensure path exists if (access(path, F_OK) == -1) { error(404); continue; } // if path to directory struct stat sb; if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) { // redirect from absolute-path to absolute-path/ if (abs_path[strlen(abs_path) - 1] != '/') { char uri[strlen(abs_path) + 1 + 1]; strcpy(uri, abs_path); strcat(uri, "/"); redirect(uri); continue; } // use path/index.php or path/index.html, if present, instead of directory's path char* index = indexes(path); if (index != NULL) { free(path); path = index; } // list contents of directory else { list(path); continue; } } // look up MIME type for file at path const char* type = lookup(path); if (type == NULL) { error(501); continue; } // interpret PHP script at path if (strcasecmp("text/x-php", type) == 0) { interpret(path, query); } // transfer file at path else { transfer(path, type); } } } } } }
/** * sendRequest * @param type const char * "GET", "POST", .... * @param stream Stream * data stream for the message body * @param size size_t size for the message body if 0 not Content-Length is send * @return -1 if no info or > 0 when Content-Length is set by server */ int HTTPClient::sendRequest(const char * type, Stream * stream, size_t size) { if(!stream) { return returnError(HTTPC_ERROR_NO_STREAM); } // connect to server if(!connect()) { return returnError(HTTPC_ERROR_CONNECTION_REFUSED); } if(size > 0) { addHeader("Content-Length", String(size)); } // send Header if(!sendHeader(type)) { return returnError(HTTPC_ERROR_SEND_HEADER_FAILED); } int buff_size = HTTP_TCP_BUFFER_SIZE; int len = size; int bytesWritten = 0; if(len == 0) { len = -1; } // if possible create smaller buffer then HTTP_TCP_BUFFER_SIZE if((len > 0) && (len < HTTP_TCP_BUFFER_SIZE)) { buff_size = len; } // create buffer for read uint8_t * buff = (uint8_t *) malloc(buff_size); if(buff) { // read all data from stream and send it to server while(connected() && (stream->available() > -1) && (len > 0 || len == -1)) { // get available data size int sizeAvailable = stream->available(); if(sizeAvailable) { int readBytes = sizeAvailable; // read only the asked bytes if(len > 0 && readBytes > len) { readBytes = len; } // not read more the buffer can handle if(readBytes > buff_size) { readBytes = buff_size; } // read data int bytesRead = stream->readBytes(buff, readBytes); // write it to Stream int bytesWrite = _tcp->write((const uint8_t *) buff, bytesRead); bytesWritten += bytesWrite; // are all Bytes a writen to stream ? if(bytesWrite != bytesRead) { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %d but got %d retry...\n", bytesRead, bytesWrite); // check for write error if(_tcp->getWriteError()) { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] stream write error %d\n", _tcp->getWriteError()); //reset write error for retry _tcp->clearWriteError(); } // some time for the stream delay(1); int leftBytes = (readBytes - bytesWrite); // retry to send the missed bytes bytesWrite = _tcp->write((const uint8_t *) (buff + bytesWrite), leftBytes); bytesWritten += bytesWrite; if(bytesWrite != leftBytes) { // failed again DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %d but got %d failed.\n", leftBytes, bytesWrite); free(buff); return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED); } } // check for write error if(_tcp->getWriteError()) { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] stream write error %d\n", _tcp->getWriteError()); free(buff); return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED); } // count bytes to read left if(len > 0) { len -= readBytes; } delay(0); } else { delay(1); } } free(buff); if(size && (int) size != bytesWritten) { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] Stream payload bytesWritten %d and size %d mismatch!.\n", bytesWritten, size); DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] ERROR SEND PAYLOAD FAILED!"); return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED); } else { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] Stream payload written: %d\n", bytesWritten); } } else { DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] too less ram! need %d\n", HTTP_TCP_BUFFER_SIZE); return returnError(HTTPC_ERROR_TOO_LESS_RAM); } // handle Server Response (Header) return returnError(handleHeaderResponse()); }
bool CSSLComm::PushNotification(const char *pToken, const char *pMsg) { CMyLock lock(&m_lock); bool bResult = false; if (connected()) { // 填入数据 PUSHDATA pushdata; memset(&pushdata, 0, sizeof(pushdata)); int nDataLen = Gen(pToken, pMsg, pushdata); // 发送 //for (int i = 0; i < 10; i++) { int ret = SSL_write(m_pssl, (void*)&pushdata, nDataLen); printf("ret:%d, nDataLen:%d, Identifier:%d\n", ret, nDataLen, pushdata.nIdentifier); if (ret == nDataLen) { //// 发送成功 //unsigned char buffer[1024] = {0}; //int len = SSL_read(m_pssl, buffer, sizeof(buffer)); //printf("len:%d\n", len); //if (len >= sizeof(PUSHRETURN)) { // PUSHRETURN* pPushReturn = (PUSHRETURN*)buffer; // printf("Command:%d, Status:%d, Identifier:%d\n", pPushReturn->nCommand, pPushReturn->nStatus, pPushReturn->nIdentifier); // switch(pPushReturn->nStatus) // { // case 0: // printf("Success\n"); // break; // case 1: // printf("Processing error\n"); // break; // case 2: // printf("Missing device token\n"); // break; // case 3: // printf("Missing topic\n"); // break; // case 4: // printf("Missing payload\n"); // break; // case 5: // printf("Invalid token size\n"); // break; // case 6: // printf("Invalid topic size\n"); // break; // case 7: // printf("Invalid payload size\n"); // break; // case 8: // printf("Invalid token\n"); // break; // case 10: // printf("Shutdown\n"); // break; // case 255: // printf("None (unknown)\n"); // break; // } //} } printf("\n"); //int ret1 = SSL_read(m_pssl, buffer, 10240); //ret = SSL_write(m_pssl, (void*)"123456789", 10); //ret = SSL_get_error(m_pssl, ret); //SSL_ERROR_SSL bResult = ret > 0; //} } /*int paylen = GenPayloadData(1,pMsg); GenPushData(pToken); int ret = SSL_write(m_pssl, (void*)&m_data, 35 + paylen);*/ return bResult; }
/** * reads the response from the server * @return int http code */ int HTTPClient::handleHeaderResponse() { if(!connected()) { return HTTPC_ERROR_NOT_CONNECTED; } String transferEncoding; _returnCode = -1; _size = -1; _transferEncoding = HTTPC_TE_IDENTITY; while(connected()) { size_t len = _tcp->available(); if(len > 0) { String headerLine = _tcp->readStringUntil('\n'); headerLine.trim(); // remove \r DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] RX: '%s'\n", headerLine.c_str()); if(headerLine.startsWith("HTTP/1.")) { _returnCode = headerLine.substring(9, headerLine.indexOf(' ', 9)).toInt(); } else if(headerLine.indexOf(':')) { String headerName = headerLine.substring(0, headerLine.indexOf(':')); String headerValue = headerLine.substring(headerLine.indexOf(':') + 2); if(headerName.equalsIgnoreCase("Content-Length")) { _size = headerValue.toInt(); } if(headerName.equalsIgnoreCase("Connection")) { _canReuse = headerValue.equalsIgnoreCase("keep-alive"); } if(headerName.equalsIgnoreCase("Transfer-Encoding")) { transferEncoding = headerValue; } for(size_t i = 0; i < _headerKeysCount; i++) { if(_currentHeaders[i].key.equalsIgnoreCase(headerName)) { _currentHeaders[i].value = headerValue; break; } } } if(headerLine == "") { DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] code: %d\n", _returnCode); if(_size > 0) { DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] size: %d\n", _size); } if(transferEncoding.length() > 0) { DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] Transfer-Encoding: %s\n", transferEncoding.c_str()); if(transferEncoding.equalsIgnoreCase("chunked")) { _transferEncoding = HTTPC_TE_CHUNKED; } else { return HTTPC_ERROR_ENCODING; } } else { _transferEncoding = HTTPC_TE_IDENTITY; } if(_returnCode) { return _returnCode; } else { DEBUG_HTTPCLIENT("[HTTP-Client][handleHeaderResponse] Remote host is not an HTTP Server!"); return HTTPC_ERROR_NO_HTTP_SERVER; } } } else { delay(0); } } return HTTPC_ERROR_CONNECTION_LOST; }
void HttpPoll::http_result() { // check for death :) QPointer<QObject> self = this; syncFinished(); if(!self) return; // get id and packet QString id; QString cookie = d->http.getHeader("Set-Cookie"); int n = cookie.indexOf("ID="); if(n == -1) { reset(); error(ErrRead); return; } n += 3; int n2 = cookie.indexOf(';', n); if(n2 != -1) id = cookie.mid(n, n2-n); else id = cookie.mid(n); QByteArray block = d->http.body(); // session error? if(id.right(2) == ":0") { if(id == "0:0" && d->state == 2) { reset(); connectionClosed(); return; } else { reset(); error(ErrRead); return; } } d->ident = id; bool justNowConnected = false; if(d->state == 1) { d->state = 2; justNowConnected = true; } // sync up again soon if(bytesToWrite() > 0 || !d->closing) { d->t->start(d->polltime * 1000); } // connecting if(justNowConnected) { connected(); } else { if(!d->out.isEmpty()) { int x = d->out.size(); d->out.resize(0); takeWrite(x); bytesWritten(x); } } if(!self) return; if(!block.isEmpty()) { appendRead(block); readyRead(); } if(!self) return; if(bytesToWrite() > 0) { do_sync(); } else { if(d->closing) { reset(); delayedCloseFinished(); return; } } }
void HTTPClientSession::setHost(const std::string& host) { if (!connected()) _host = host; else throw IllegalStateException("Cannot set the host for an already connected session"); }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { _port = new QSpinBox(this); _port->setMaximum(99999); _port->setValue(8796); _host = new QLineEdit(this); _host->setFixedWidth(100); _connectServer = new QPushButton(tr("Connect"), this); _connectServer->setCheckable(true); _consult = new QPushButton(tr("Consult"), this); _sendCmd = new QPushButton(tr("Send"), this); _cmd = new QLineEdit(this); _serverOutput = new QTextEdit(this); _serverOutput->setReadOnly(true); _codeEditor = new CodeEditor(this); _consult->setEnabled(false); _cmd->setEnabled(false); _sendCmd->setEnabled(false); _client = new Client(); QObject::connect(_connectServer, SIGNAL(clicked(bool)), this, SLOT(changeServerStatus(bool))); QObject::connect(_client, SIGNAL(connected()), this, SLOT(serverConnected())); QObject::connect(_client, SIGNAL(disconnected()), this, SLOT(serverDisconnected())); QObject::connect(_client, SIGNAL(dataReceived(QString)), this, SLOT(writeServerOutput(QString))); QObject::connect(_client, SIGNAL(errorSocket(QString)), this, SLOT(writeServerOutput(QString))); QObject::connect(_sendCmd, SIGNAL(clicked()), this, SLOT(sendCmd())); QObject::connect(_consult, SIGNAL(clicked()), this, SLOT(consultFile())); QHBoxLayout *layoutHeader = new QHBoxLayout; layoutHeader->setContentsMargins(10,0,0,10); layoutHeader->addWidget(new QLabel(tr("Host"), this)); layoutHeader->addWidget(_host); layoutHeader->addSpacing(10); layoutHeader->addWidget(new QLabel(tr("Port"), this)); layoutHeader->addWidget(_port); layoutHeader->addStretch(100); layoutHeader->addWidget(_connectServer); QSplitter *centralSplitter = new QSplitter(this); centralSplitter->addWidget(_codeEditor); centralSplitter->addWidget(_serverOutput); QHBoxLayout *layoutBottom = new QHBoxLayout; layoutBottom->addWidget(_consult, 1); layoutBottom->addWidget(_cmd, 100); layoutBottom->addWidget(_sendCmd, 1); QVBoxLayout *mainLayout = new QVBoxLayout; mainLayout->setMargin(0); mainLayout->setSpacing(0); mainLayout->addLayout(layoutHeader, 1); mainLayout->addWidget(centralSplitter); mainLayout->addLayout(layoutBottom, 1); QWidget *centralWidget = new QWidget(this); centralWidget->setLayout(mainLayout); this->setCentralWidget(centralWidget); }