// this method is called when REST response is received for request to get user information: void handleMe(boost::system::error_code err, const Http::Message& response) { #ifndef WT_TARGET_JAVA WApplication::instance()->resumeRendering(); #endif if (!err && response.status() == 200) { #ifndef WT_TARGET_JAVA Json::ParseError e; Json::Object me; bool ok = Json::parse(response.body(), me, e); #else Json::Object me; try { me = (Json::Object)Json::Parser().parse(response.body()); } catch (Json::ParseError pe) { } bool ok = me.isNull(); #endif if (!ok) { LOG_ERROR("could not parse JSON: '" << response.body() << "'"); setError(ERROR_MSG("badjson")); authenticated().emit(Identity::Invalid); } else { std::string id = me.get("id"); std::string email = me.get("emailAddress"); if (getUserProfileAsJson) { // In the Identity's name field more complete user info is passed in JSON format as returned from LinkedIn, see details at: // https://developer.linkedin.com/docs/fields/basic-profile authenticated().emit(Identity(service().name(), id, response.body(), email, true)); } else { std::string name = me.get("firstName"); name += std::string(" "); name += std::string(me.get("lastName")); authenticated().emit(Identity(service().name(), id, name, email, true)); } } } else { if (!err) { LOG_ERROR("user info request returned: " << response.status()); LOG_ERROR("with: " << response.body()); } else { LOG_ERROR("handleMe(): " << err.message()); } setError(ERROR_MSG("badresponse")); authenticated().emit(Identity::Invalid); } }
static void auth_global() { if (!authenticated()) { if (sk_auth(getpassw(SKPROMPT))) { eprintf("Go away with that, poor boy!\n"); exit(1); } } eprintf("%s", BANNER); eprintf("Kernel side version: %s\n", authenticated()); }
void LastFm::authenticationResponse(QByteArray bytes) { QXmlStreamReader xml(bytes); while(!xml.atEnd() && !xml.hasError()) { QXmlStreamReader::TokenType token = xml.readNext(); if(token == QXmlStreamReader::StartElement && xml.name() == "session") { while (xml.readNextStartElement()) { if (xml.name() == "name") { username = xml.readElementText(); } else if (xml.name() == "key") { sessionKey = xml.readElementText(); } } } } if(xml.hasError()) { qWarning() << xml.errorString(); emit error(xml.errorString()); } if (!sessionKey.isEmpty()) { QSettings settings; settings.setValue("lastFmSessionKey", sessionKey); emit authenticated(); } else qDebug() << "Missing sessionKey"; }
void AuthenticationDialog::urlChanged(const QUrl &url) { qDebug() << "Navigating to" << url; if (url.host() == QStringLiteral("oauth.vk.com") && url.path() == QStringLiteral("/blank.html")) { const QUrlQuery query(url); d->error = query.queryItemValue(QStringLiteral("error")); d->errorDescription = query.queryItemValue(QStringLiteral("error_description")).replace(QLatin1Char('+'), QLatin1Char(' ')); if (!d->error.isEmpty() || !d->errorDescription.isEmpty()) { QTimer::singleShot(0, this, SLOT(showErrorDialog())); return; } // The URL comes in the form "bla#access_token=bla&expires_in=foo", we need to convert from // # to ? const QUrl fixedURL = QUrl::fromUserInput(url.toString().replace(QLatin1Char('#'), QLatin1Char('?'))); const QUrlQuery fixedQuery(fixedURL); const QString accessToken = fixedQuery.queryItemValue(QStringLiteral("access_token")); const QString tokenExpiresIn = fixedQuery.queryItemValue(QStringLiteral("expires_in")); // TODO: use this for something? if (!accessToken.isEmpty()) { emit authenticated(accessToken); QTimer::singleShot(0, this, SLOT(close())); } } }
ClientTest(const QString &_host, int _port, const QString &_proto, const QString &_authzid, const QString &_realm, const QString &_user, const QString &_pass, bool _no_authzid, bool _no_realm) : host(_host), proto(_proto), authzid(_authzid), realm(_realm), user(_user), pass(_pass), port(_port), no_authzid(_no_authzid), no_realm(_no_realm), sock_done(false), waitCycles(0) { sock = new QTcpSocket(this); connect(sock, SIGNAL(connected()), SLOT(sock_connected())); connect(sock, SIGNAL(readyRead()), SLOT(sock_readyRead())); connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(sock_error(QAbstractSocket::SocketError))); sasl = new QCA::SASL(this); connect(sasl, SIGNAL(clientStarted(bool, const QByteArray &)), SLOT(sasl_clientFirstStep(bool, const QByteArray &))); connect(sasl, SIGNAL(nextStep(const QByteArray &)), SLOT(sasl_nextStep(const QByteArray &))); connect(sasl, SIGNAL(needParams(const QCA::SASL::Params &)), SLOT(sasl_needParams(const QCA::SASL::Params &))); connect(sasl, SIGNAL(authenticated()), SLOT(sasl_authenticated())); connect(sasl, SIGNAL(readyRead()), SLOT(sasl_readyRead())); connect(sasl, SIGNAL(readyReadOutgoing()), SLOT(sasl_readyReadOutgoing())); connect(sasl, SIGNAL(error()), SLOT(sasl_error())); }
Mail::Mail() : CodeClass() { connect(&mSmtp, SIGNAL(connected()), this, SLOT(connected())); connect(&mSmtp, SIGNAL(connectionFailed(QByteArray)), this, SLOT(connectionFailed(QByteArray))); connect(&mSmtp, SIGNAL(encrypted()), this, SLOT(encrypted())); connect(&mSmtp, SIGNAL(encryptionFailed(QByteArray)), this, SLOT(encryptionFailed(QByteArray))); connect(&mSmtp, SIGNAL(authenticated()), this, SLOT(authenticated())); connect(&mSmtp, SIGNAL(authenticationFailed(QByteArray)), this, SLOT(authenticationFailed(QByteArray))); connect(&mSmtp, SIGNAL(senderRejected(int,QString,QByteArray)), this, SLOT(senderRejected(int,QString,QByteArray))); connect(&mSmtp, SIGNAL(recipientRejected(int,QString,QByteArray)), this, SLOT(recipientRejected(int,QString,QByteArray))); connect(&mSmtp, SIGNAL(mailFailed(int,int,QByteArray)), this, SLOT(mailFailed(int,int,QByteArray))); connect(&mSmtp, SIGNAL(mailSent(int)), this, SLOT(mailSent(int))); connect(&mSmtp, SIGNAL(finished()), this, SLOT(finished())); connect(&mSmtp, SIGNAL(disconnected()), this, SLOT(disconnected())); }
QScriptValue Mail::waitForAuthenticated(int waitTime) { QxtSignalWaiter waiter(&mSmtp, SIGNAL(authenticated())); if(!waiter.wait(waitTime)) throwError("AuthenticationError", tr("Cannot authenticate to the server")); return thisObject(); }
void handleMe(boost::system::error_code err, const Http::Message& response) { #ifndef WT_TARGET_JAVA WApplication::instance()->resumeRendering(); #endif if (!err && response.status() == 200) { #ifndef WT_TARGET_JAVA Json::ParseError e; Json::Object me; bool ok = Json::parse(response.body(), me, e); #else Json::Object me; try { me = (Json::Object)Json::Parser().parse(response.body()); } catch (Json::ParseError pe) { } bool ok = me.isNull(); #endif if (!ok) { LOG_ERROR("could not parse Json: '" << response.body() << "'"); setError(ERROR_MSG("badjson")); authenticated().emit(Identity::Invalid); } else { std::string id = me.get("id"); WT_USTRING userName = me.get("name"); std::string email = me.get("email").orIfNull(""); bool emailVerified = !me.get("email").isNull(); authenticated().emit(Identity(service().name(), id, userName, email, emailVerified)); } } else { if (!err) { LOG_ERROR("user info request returned: " << response.status()); LOG_ERROR("with: " << response.body()); } else LOG_ERROR("handleMe(): " << err.message()); setError(ERROR_MSG("badresponse")); authenticated().emit(Identity::Invalid); } }
PendingRecommendedArtists::PendingRecommendedArtists (Authenticator *auth, QNetworkAccessManager *nam, int num, QObject *obj) : BaseSimilarArtists (QString (), num, obj) , NAM_ (nam) { if (auth->IsAuthenticated ()) request (); else connect (auth, SIGNAL (authenticated ()), this, SLOT (request ())); }
RecEventsFetcher::RecEventsFetcher (Authenticator *auth, QNetworkAccessManager *nam, Type type, QObject *parent) : QObject (parent) , NAM_ (nam) , Type_ (type) { if (auth->IsAuthenticated ()) request (); else connect (auth, SIGNAL (authenticated ()), this, SLOT (request ())); }
void UBAbstractPublisher::processAuthenticationTokenResponse(bool success, const QByteArray& payload) { if (mTokenRequest) mTokenRequest->deleteLater(); if (success) { /* <publishing-token> ... <token>iFzZIXhPxHTLhJeHWFF9BDVblMDWU546rpzoEEfxMSLrftMq444w4BuoisnNtRAjm6ht3hKUIHmMKA3xGN2Hlaof8tbYNLHmzf2R1dO439vnXFiHMPLBi7nFpSEPtBNJ</token> <uuid>26fea4c0-1319-012d-d0fc-001f5b3d920c</uuid> ... </publishing-token> */ QDomDocument doc("publishing-token"); doc.setContent(payload, false); QDomElement root = doc.documentElement(); const QString token = root.firstChildElement("token").text(); const QString uuid = root.firstChildElement("uuid").text(); if (token.length() > 0 && uuid.length() > 0) { const QByteArray encrypted = encrypt(token); QString encryptedBase64 = QString::fromAscii(encrypted.toBase64()); UBApplication::showMessage(tr("Found %1").arg(UBSettings::settings()->uniboardWebUrl->get().toString()), false); emit authenticated(QUuid(uuid), encryptedBase64); } else { qWarning() << "Authentication failed" << QString::fromUtf8(payload); emit authenticationFailure(); UBApplication::showMessage(tr("Cannot Authenticate with %1").arg(UBSettings::settings()->uniboardWebUrl->get().toString())); } } else { qWarning() << "Authentication failed" << QString::fromUtf8(payload); emit authenticationFailure(); UBApplication::showMessage(tr("Cannot Authenticate with %1").arg(UBSettings::settings()->uniboardWebUrl->get().toString())); } }
void HelperApp::doAuth() { SafeDataStream str(m_socket); str << Msg::HELLO << m_id; str.send(); if (str.status() != QDataStream::Ok) qCritical() << "Couldn't write initial message:" << str.status(); if (!m_backend->start(m_user)) { authenticated(QString("")); exit(Auth::HELPER_AUTH_ERROR); return; } if (!m_backend->authenticate()) { authenticated(QString("")); exit(Auth::HELPER_AUTH_ERROR); return; } m_user = m_backend->userName(); QProcessEnvironment env = authenticated(m_user); if (!m_session->path().isEmpty()) { env.insert(m_session->processEnvironment()); m_session->setProcessEnvironment(env); if (!m_backend->openSession()) { sessionOpened(false); exit(Auth::HELPER_SESSION_ERROR); return; } sessionOpened(true); } else exit(Auth::HELPER_SUCCESS); return; }
NXClientLib::NXClientLib(QObject *parent) : QObject(parent) { isFinished = false; proxyData.encrypted = false; password = false; connect(&session, SIGNAL(authenticated()), this, SLOT(doneAuth())); connect(&session, SIGNAL(loginFailed()), this, SLOT(failedLogin())); connect(&session, SIGNAL(finished()), this, SLOT(finished())); connect(&session, SIGNAL(sessionsSignal(QList<NXResumeData>)), this, SLOT(suspendedSessions(QList<NXResumeData>))); connect(&session, SIGNAL(noSessions()), this, SLOT(noSuspendedSessions())); connect(&nxproxyProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(reset())); }
bool CreateGameHandler::handle(CMSGCreateGame *p) { auto client = std::dynamic_pointer_cast<Client > (p->source()); if (!client) { WARN("NO SOURCE TO CREATE GAME"); return true; } auto response = std::make_shared<SMSGCreateGame > (p->source()); if (!client->authenticated()) { response->data_.set_success(false); response->data_.set_errormsg("You are not authenticated so you cannot create a new game."); client->pushPacket(response); return true; } if (p->data_.gamename() == "") { response->data_.set_success(false); response->data_.set_errormsg("Name cannot be empty;"); } for (auto game : Server::instance().games()) { if (game->name() == p->data_.gamename()) { WARN("Game with is name already exists, not creating"); response->data_.set_success(false); response->data_.set_errormsg("Name already taken."); p->source()->pushPacket(response); return true; } } std::string sceneName; if (p->data_.has_scenename()) sceneName = p->data_.scenename(); else sceneName = "Test Level"; std::shared_ptr<Game> g(new Game(sceneName)); g->name(p->data_.gamename()); response->data_.set_success(true); response->data_.set_gameuuid(g->uuid()); p->source()->pushPacket(response); Server::instance().addGame(g); return true; }
Rotor::Rotor(QSettings *settings, RotorButtons *buttons,QWidget *parent) : QWidget(parent) { this->settings = settings; this->buttons = buttons; // Update timer QTimer *timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(fetchStatus())); timer->start(1000*settings->value("System/statusInterval",300).toInt()); dir = -1; aim = -1; // Buttons init connect(buttons,SIGNAL(goButtonPressed(int)),this,SLOT(goAntenna(int))); connect(buttons,SIGNAL(gotoButtonPressed(int)),this,SLOT(aimAntenna(int))); connect(buttons,SIGNAL(stopButtonPressed()),this,SLOT(stopAntenna())); // MMQ Init mmq = new MMQ(this); connect(mmq, SIGNAL(connected()),this, SLOT(connected())); connect(mmq, SIGNAL(authenticated()),this, SLOT(authenticated())); connect(mmq, SIGNAL(packet(QString,QJsonValue)),this, SLOT(packet(QString,QJsonValue))); connect(mmq, SIGNAL(disconnected()),this, SLOT(disconnected())); connect(mmq, SIGNAL(error(qint64)),this, SLOT(error(qint64))); mmq->setKey(settings->value("System/password").toString()); mmq->doConnect( settings->value("System/hostname",QString("localhost")).toString(), settings->value("System/port",4343).toInt()); // Load rotor Image rotorImg = QImage(settings->value("System/backgroundImage",QString("rotor.png")).toString()); Q_ASSERT(!img.isNull()); }
static void auth_local() { if (!authenticated()) { char *p; uchar h[20]; p = getpassw(SKPROMPT); sha1_asm(h, p, strlen(p)); if (memcmp(cfg.hashpass, h, 20)) { eprintf("Go away with that, poor boy!\n"); exit(1); } eprintf("%s", BANNER); sk_auth(p); } }
/** * @brief libmicrohttpd_cb called when the client do a request to this server * @param cls unused * @param connection - client connection * @param url - which url was called * @param method - POST / GET / ... * @param version http 1.0 or 1.1 * @param upload_data - unused * @param upload_data_size - unused * @param ptr - unused * @return */ int libmicrohttpd_cb(void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **ptr) { t_client *client; char *ip_addr; char *mac; int ret; debug(LOG_DEBUG, "access: %s %s", method, url); /* only allow get */ if(0 != strcmp(method, "GET")) { debug(LOG_DEBUG, "Unsupported http method %s", method); return send_error(connection, 503); } /* switch between preauth, authenticated */ /* - always - set caching headers * a) possible implementation - redirect first and serve them using a tempo redirect * b) serve direct * should all requests redirected? even those to .css, .js, ... or respond with 404/503/... */ ip_addr = get_ip(connection); mac = arp_get(ip_addr); client = client_list_find(ip_addr, mac); if(client) { if(client->fw_connection_state == FW_MARK_AUTHENTICATED || client->fw_connection_state == FW_MARK_TRUSTED) { /* client already authed - dangerous!!! This should never happen */ ret = authenticated(connection, ip_addr, mac, url, client); free(mac); free(ip_addr); return ret; } } ret = preauthenticated(connection, ip_addr, mac, url, client); free(mac); free(ip_addr); return ret; }
void AMGithubManager::onAuthenicatedRequestReturned(){ QJson::Parser parser; QVariant githubFullReply = parser.parse(authenticateReply_->readAll()); authenticated_ = false; if(githubFullReply.canConvert(QVariant::Map)){ QVariantMap jsonMap = githubFullReply.toMap(); QMap<QString, QVariant>::const_iterator i = jsonMap.constBegin(); if(i.key() == "message" && i.value().toString() == "Bad credentials") authenticated_ = false; else authenticated_ = true; } disconnect(authenticateReply_, 0); authenticateReply_->deleteLater(); authenticateReply_ = 0; emit authenticated(authenticated_); }
void Plugin::Init (ICoreProxy_ptr proxy) { Util::InstallTranslator ("lastfmscrobble"); Proxy_ = proxy; XmlSettingsDialog_.reset (new Util::XmlSettingsDialog ()); XmlSettingsDialog_->RegisterObject (&XmlSettingsManager::Instance (), "lastfmscrobblesettings.xml"); Auth_ = new Authenticator (proxy->GetNetworkAccessManager (), proxy, this); LFSubmitter_ = new LastFMSubmitter (Proxy_->GetNetworkAccessManager (), this); connect (Auth_, SIGNAL (authenticated ()), LFSubmitter_, SLOT (handleAuthenticated ())); RadioRoot_ = new QStandardItem ("Last.FM"); RadioRoot_->setEditable (false); RadioRoot_->setIcon (QIcon (":/resources/images/lastfm.png")); auto addPredefined = [this] (const QString& name, const QString& id, const QIcon& icon) -> QStandardItem* { auto item = new QStandardItem (name); item->setData (Media::RadioType::Predefined, Media::RadioItemRole::ItemType); item->setData (id, Media::RadioItemRole::RadioID); item->setEditable (false); item->setIcon (icon); RadioRoot_->appendRow (item); return item; }; addPredefined (tr ("Library"), "library", QIcon (":/resources/images/personal.png")); addPredefined (tr ("Recommendations"), "recommendations", QIcon (":/resources/images/recs.png")); addPredefined (tr ("Loved"), "loved", QIcon (":/resources/images/loved.png")); addPredefined (tr ("Neighbourhood"), "neighbourhood", QIcon (":/resources/images/neighbours.png")); auto similarItem = addPredefined (tr ("Similar artists"), QString (), QIcon (":/resources/images/radio.png")); similarItem->setData (Media::RadioType::SimilarArtists, Media::RadioItemRole::ItemType); auto globalItem = addPredefined (tr ("Global tag"), QString (), QIcon (":/resources/images/tag.png")); globalItem->setData (Media::RadioType::GlobalTag, Media::RadioItemRole::ItemType);; RadioModel_ = new QStandardItemModel; RadioModel_->appendRow (RadioRoot_); }
void GoogleSession::authResult(bool errorFlag) { if (errorFlag) { qDebug() << "Auth http error" << http->errorString(); setState(Invalid); emit error(AuthenticationFailed, http->errorString()); } else { QString resp = http->readAll(); //qDebug() << resp; QStringList keys = resp.split("\n"); QHash<QString, QString> keyMap; for (QStringList::iterator it = keys.begin(); it!=keys.end(); it++) { int sep = it->indexOf('='); QString key = it->left(sep); QString value = it->right(it->length()-sep-1); keyMap[key] = value; //qDebug() << key << value; } if (http->lastResponse().statusCode()==200) // OK { if (keyMap.contains("Auth")) { authKey = keyMap["Auth"]; qDebug() << "Authenticated" << authKey; setState(Authenticated); emit authenticated(); } else { setState(Invalid); emit error(AuthenticationFailed, "No Auth key"); } } else { qDebug() << "ERROR Response header:" << http->lastResponse().statusCode() << http->lastResponse().reasonPhrase(); qDebug() << "ERROR reason" << keyMap["Error"]; setState(Invalid); emit error(AuthenticationFailed, keyMap["Error"]); } } }
QxtSmtp::QxtSmtp(QObject* parent) : QObject(parent) { QXT_INIT_PRIVATE(QxtSmtp); qxt_d().state = QxtSmtpPrivate::Disconnected; qxt_d().nextID = 0; #ifndef QT_NO_OPENSSL qxt_d().socket = new QSslSocket(this); QObject::connect(socket(), SIGNAL(encrypted()), this, SIGNAL(encrypted())); //QObject::connect(socket(), SIGNAL(encrypted()), &qxt_d(), SLOT(ehlo())); #else qxt_d().socket = new QTcpSocket(this); #endif QObject::connect(socket(), SIGNAL(connected()), this, SIGNAL(connected())); QObject::connect(socket(), SIGNAL(disconnected()), this, SIGNAL(disconnected())); QObject::connect(socket(), SIGNAL(error(QAbstractSocket::SocketError)), &qxt_d(), SLOT(socketError(QAbstractSocket::SocketError))); QObject::connect(this, SIGNAL(authenticated()), &qxt_d(), SLOT(sendNext())); QObject::connect(socket(), SIGNAL(readyRead()), &qxt_d(), SLOT(socketRead())); }
void SmppClient::handleBindTransiverResp(const QByteArray &pdu) { Smpp::BindTransceiverResp bindTransceiverResp; try { bindTransceiverResp.decode((const Smpp::Uint8 *) pdu.data()); } catch (Smpp::Error e) { printErrorAndDisconnect(e); return; } if (bindTransceiverResp.command_status() != 0) { m_needInformAbountDisconnect = false; onDisconnectHelper(); emit disconnected(AuthenticationProblem); logMsg("Authentication problem"); } else { logMsg("Authentication on smpp server passed"); emit authenticated(); m_timerForEnquireLink->start(); } }
void LYGithubManager::onAuthenicatedRequestReturned(){ QJson::Parser parser; QVariant githubFullReply = parser.parse(authenticateReply_->readAll()); authenticated_ = false; if(githubFullReply.canConvert(QVariant::Map)){ QVariantMap jsonMap = githubFullReply.toMap(); QMap<QString, QVariant>::const_iterator i = jsonMap.constBegin(); if(i.key() == "message" && i.value().toString() == "Bad credentials") authenticated_ = false; else authenticated_ = true; } LYGithubProductBacklogStatusLog::statusLog()->appendStatusMessage(QString("Received authentication request return as %1").arg(authenticated_)); disconnect(authenticateReply_, 0); authenticateReply_->deleteLater(); authenticateReply_ = 0; emit authenticated(authenticated_); }
void Authenticator::getSessionKey () { QNetworkReply *reply = qobject_cast<QNetworkReply*> (sender ()); if (!reply) return; reply->deleteLater (); QDomDocument doc; doc.setContent (QString::fromUtf8 (reply->readAll ())); if (CheckError (doc)) return; const auto& domList = doc.documentElement ().elementsByTagName ("key"); if (!domList.size ()) return; IsAuthenticated_ = true; lastfm::ws::SessionKey = domList.at (0).toElement ().text (); emit authenticated (); }
void YouTubeProvider::parserFinished(Joschy::AbstractJob *job) { JOSCHY_DEBUG() << "parser finsihed...."; Joschy::ResponseParser *parser = static_cast<Joschy::ResponseParser*>(job); const QString id = parser->id(); const ResponseParser::Type type = m_actions.take(id); const QString errorString = parser->errorString(); const Plugin::ErrorType errorType = parser->errorType(); const bool hasError = parser->error(); if (hasError) { emit error(id, errorType, errorString); } else { switch (type) { case ResponseParser::AuthenticationType: { m_tokens.insert(parser->login(), parser->token()); emit authenticated(id); break; } case ResponseParser::UploadType: { emit uploadFinished(id, parser->getVideo()); break; } case ResponseParser::SearchType: { QList<Joschy::Video> videos = parser->getVideos(); emit searchFinished(id, videos); break; } case ResponseParser::UpdateThumbnailType: { const QString thumbnail = m_thumbnails.take(id); QFile file(thumbnail); if (!file.open(QIODevice::WriteOnly)) { JOSCHY_DEBUG() << "open failed:" << thumbnail << file.errorString(); emit error(id, Plugin::CannotOpenError, file.errorString()); } else { if (file.write(parser->image()) == -1) { file.close(); JOSCHY_DEBUG() << file.error() << file.errorString(); emit error(id, Plugin::UnknownError, file.errorString()); } else { file.close(); emit thumbnailUpdated(id); } } break; } case ResponseParser::UpdateCategorysType: { m_categorys = parser->getCategorys(); QHash<QString, QVariant> hash; QHashIterator<QString, QString> it(m_categorys); while (it.hasNext()) { it.next(); hash[it.key()] = it.value(); } save("YouTube-Categorys", QVariant(hash)); save("YouTube-CategoryDate", QVariant(QDateTime::currentDateTime())); emit categorysChanged(categorys()); break; } default: break; } } m_parser.removeAll(parser); delete parser; layer()->freeId(id); }
void CloudAuthenticator::replyFinished(QNetworkReply *reply) { int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(); // token request if (m_tokenRequests.contains(reply)) { QByteArray data = reply->readAll(); m_tokenRequests.removeAll(reply); if (reply->error() != QNetworkReply::NoError) { qCWarning(dcCloud()) << "Authenticator: Request token reply error:" << status << reply->errorString(); m_error = Cloud::CloudErrorIdentityServerNotReachable; setAuthenticated(false); reply->deleteLater(); return; } // check HTTP status code if (status != 200) { qCWarning(dcCloud()) << "Authenticator: Request token reply HTTP error:" << status << reply->errorString(); qCWarning(dcCloud()) << data; m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } // check JSON QJsonParseError error; QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error); if (error.error != QJsonParseError::NoError) { qCWarning(dcCloud()) << "Authenticator: Request token reply JSON error:" << error.errorString(); m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } if (!jsonDoc.toVariant().toMap().contains("access_token")) { qCWarning(dcCloud()) << "Authenticator: Could not get access token" << jsonDoc.toJson(); m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } m_error = Cloud::CloudErrorNoError; setToken(jsonDoc.toVariant().toMap().value("access_token").toString()); setAuthenticated(true); // Save the username GuhSettings settings(GuhSettings::SettingsRoleDevices); settings.beginGroup("Cloud"); settings.setValue("userName", m_username); settings.endGroup(); if (jsonDoc.toVariant().toMap().contains("expires_in") && jsonDoc.toVariant().toMap().contains("refresh_token")) { int expireTime = jsonDoc.toVariant().toMap().value("expires_in").toInt(); setRefreshToken(jsonDoc.toVariant().toMap().value("refresh_token").toString()); qCDebug(dcCloud()) << "Authenticator: Token will be refreshed in" << expireTime << "[s]"; m_timer->start((expireTime - 20) * 1000); } } else if (m_refreshTokenRequests.contains(reply)) { QByteArray data = reply->readAll(); m_refreshTokenRequests.removeAll(reply); if (reply->error() != QNetworkReply::NoError) { qCWarning(dcCloud()) << "Authenticator: Request token reply error:" << status << reply->errorString(); m_error = Cloud::CloudErrorIdentityServerNotReachable; setAuthenticated(false); reply->deleteLater(); return; } // check HTTP status code if (status != 200) { qCWarning(dcCloud()) << "Authenticator: Refresh token reply HTTP error:" << status << reply->errorString(); m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } // check JSON QJsonParseError error; QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error); if (error.error != QJsonParseError::NoError) { qCWarning(dcCloud()) << "Authenticator: Refresh token reply JSON error:" << error.errorString(); m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } if (!jsonDoc.toVariant().toMap().contains("access_token")) { qCWarning(dcCloud()) << "Authenticator: Could not get access token after refresh" << jsonDoc.toJson(); m_error = Cloud::CloudErrorAuthenticationFailed; setAuthenticated(false); reply->deleteLater(); return; } m_error = Cloud::CloudErrorNoError; setToken(jsonDoc.toVariant().toMap().value("access_token").toString()); qCDebug(dcCloud()) << "Authenticator: Token refreshed successfully"; if (jsonDoc.toVariant().toMap().contains("expires_in") && jsonDoc.toVariant().toMap().contains("refresh_token")) { int expireTime = jsonDoc.toVariant().toMap().value("expires_in").toInt(); setRefreshToken(jsonDoc.toVariant().toMap().value("refresh_token").toString()); qCDebug(dcCloud()) << "Authenticator: Token will be refreshed in" << expireTime << "[s]"; m_timer->start((expireTime - 20) * 1000); } if (!authenticated()) setAuthenticated(true); } reply->deleteLater(); }
int configure(char *f, struct config *c) { int first = 0; char buf[512]; if (!c->hidestr[0]) first++; if (first) { eprintf( "%s\n" "You have not configured suckit yet. Now I'll ask\n" "you few important questions, next time you can change\n" "configuration by running `%s C`\n\n", BANNER, f); } if (authenticated() && (is_same(f, strcat(get_khome(), "/sk")))) { eprintf( "WARNING: This file (%s) is actually used by currently\n" "running installation of suckit. Changing it's configuration\n" "without re-installation is not so good idea. Create a separate\n" "copy of this file and then you can config it.\n", f); return 1; } eprintf( "Suckit hides files containing magic string in their suffix\n" "Example: with suffix 'iamsoelite' the 'myfileiamsoelit' or\n" "'myfile.iamsoelite' files will not be shown to the rest of\n" "the system\n"); do { input("Magic file-hiding suffix", c->hidestr, sizeof(c->hidestr)); if (!c->hidestr[0]) { eprintf("Huh?!\n"); continue; } if (strchr(c->hidestr, '/')) { eprintf("Having a path delimiter (/) is not good idea!\n"); continue; } break; } while (1); eprintf( "Home directory will be your directory for logins. It will\n" "also contain .sniffer file with tty sniffer logs.\n" "It's name should have hide string as suffix, thus it will\n" "be hidden for the rest of system too.\n" "Example: for hiding-suffix equal to '%s' you could have\n" "something like /usr/share/man/man1/.%s\n", c->hidestr, c->hidestr); do { input("Home directory", c->home, sizeof(c->home)); if (c->home[0] != '/') { eprintf("Your home directory _must_ be at absolute path!\n"); continue; } break; } while (1); eprintf( "Suckit password is used for authentication of remote/local\n" "user. Please use at least 4 characters.\n"); if (!first) { eprintf("Hit enter to keep previous password\n"); } do { strcpy(buf, getpassw("\e[1;37mPassword\e[0m: ")); if ((!buf[0]) && (!first)) goto oldpass; if (strlen(buf) < 4) { eprintf("Way too short, ehh ?\n"); continue; } if (strcmp(buf, getpassw("\e[1;37mRetype password\e[0m: "))) { eprintf("Sorry, password do not match!\n"); continue; } break; } while (1);
int start_command(JNIEnv *env, jclass clazz __attribute__((unused)), jstring jhandler, jstring jcmd, jobjectArray jenv) { const char *utf; handler *h; int id; struct cmd_start_info *start_info; message *m; child_node *c; id = -1; m=NULL; c=NULL; utf=NULL; if(!authenticated()) { LOGE("%s: not authenticated", __func__); return -1; } if(!jhandler) { LOGE("%s: handler cannot be null", __func__); return -1; } utf = (*env)->GetStringUTFChars(env, jhandler, NULL); if(!utf) { LOGE("%s: cannot get handler name", __func__); goto jni_error; } h = get_handler_by_name(utf); if(!h) { LOGE("%s: handler \"%s\" not found", __func__, utf); goto exit; } (*env)->ReleaseStringUTFChars(env, jhandler, utf); utf=NULL; m = create_message(get_sequence(&ctrl_seq, &ctrl_seq_lock), sizeof(struct cmd_start_info), CTRL_ID); if(!m) { LOGE("%s: cannot create messages", __func__); goto exit; } start_info = (struct cmd_start_info *) m->data; start_info->cmd_action = CMD_START; start_info->hid = h->id; if(jcmd && parse_cmd(env, h, jcmd, m)) { LOGE("%s: cannot parse command", __func__); goto exit; } if(jenv && parse_env(env, jenv, m)) { LOGE("%s: cannot parse environment", __func__); goto exit; } // create child c = create_child(m->head.seq); if(!c) { LOGE("%s: cannot craete child", __func__); goto exit; } c->handler = h; // add child to list pthread_mutex_lock(&(children.control.mutex)); list_add(&(children.list), (node *) c); pthread_mutex_unlock(&(children.control.mutex)); // send message to cSploitd pthread_mutex_lock(&write_lock); // OPTIMIZATION: use id to store return value for later check id = send_message(sockfd, m); pthread_mutex_unlock(&write_lock); if(id) { LOGE("%s: cannot send messages", __func__); // mark it as failed c->id = CTRL_ID; c->seq = 0; } id=-1; // wait for CMD_STARTED or CMD_FAIL pthread_mutex_lock(&(children.control.mutex)); while(c->seq && children.control.active) pthread_cond_wait(&(children.control.cond), &(children.control.mutex)); if(c->id == CTRL_ID || c->seq) { // command failed list_del(&(children.list), (node *) c); } else { id = c->id; } c->pending = 0; pthread_mutex_unlock(&(children.control.mutex)); pthread_cond_broadcast(&(children.control.cond)); if(id != -1) { LOGI("%s: child #%d started", __func__, id); } else if(c->seq) { LOGW("%s: pending child cancelled", __func__); } else { LOGW("%s: cannot start command", __func__); } goto exit; jni_error: if((*env)->ExceptionCheck(env)) { (*env)->ExceptionDescribe(env); (*env)->ExceptionClear(env); } exit: if(m) free_message(m); if(utf) (*env)->ReleaseStringUTFChars(env, jhandler, utf); return id; }
int start_command(JNIEnv *env, jclass clazz __attribute__((unused)), jstring jhandler, jstring jcmd) { char status; char *pos, *start, *end, *rpos, *wpos; const char *utf; jstring *utf_parent; handler *h; uint32_t msg_size; // big enought to check for uint16_t overflow int id; size_t arg_len, escapes; struct cmd_start_info *start_info; message *m; child_node *c; id = -1; m=NULL; c=NULL; if(!authenticated()) { LOGE("%s: not authenticated", __func__); return -1; } utf = (*env)->GetStringUTFChars(env, jhandler, NULL); utf_parent = &jhandler; if(!utf) { LOGE("%s: cannot get handler name", __func__); goto jni_error; } arg_len = (*env)->GetStringUTFLength(env, jhandler); if(!arg_len) { LOGE("%s: empty handler name", __func__); goto jni_error; } arg_len++; // test even the '\0' for(h=(handler *) handlers.list.head;h && strncmp(utf, h->name, arg_len);h=(handler *) h->next); if(!h) { LOGE("%s: handler \"%s\" not found", __func__, utf); goto exit; } (*env)->ReleaseStringUTFChars(env, jhandler, utf); utf = (*env)->GetStringUTFChars(env, jcmd, NULL); utf_parent = &jcmd; if(!utf) { LOGE("%s: cannot get command string", __func__); goto jni_error; } LOGD("%s: parsing \"%s\"", __func__, utf); msg_size = sizeof(struct cmd_start_info); m = create_message(get_sequence(&ctrl_seq, &ctrl_seq_lock), msg_size, CTRL_ID); if(!m) { LOGE("%s: cannot create messages", __func__); goto exit; } start_info = (struct cmd_start_info *) m->data; start_info->cmd_action = CMD_START; start_info->hid = h->id; status = 0; arg_len = 0; escapes = 0; start = end = NULL; for(pos=(char *) utf;!(status & END_OF_STRING);pos++) { // string status parser switch (*pos) { case '"': if(status & ESCAPE_FOUND) { escapes++; } else if(status & (INSIDE_SINGLE_QUOTE)) { // copy it as a normal char } else if(status & INSIDE_DOUBLE_QUOTE) { status &= ~INSIDE_DOUBLE_QUOTE; end = pos; } else { status |= INSIDE_DOUBLE_QUOTE; } break; case '\'': if(status & ESCAPE_FOUND) { escapes++; } else if(status & INSIDE_DOUBLE_QUOTE) { // copy it as a normal char } else if(status & INSIDE_SINGLE_QUOTE) { status &= ~INSIDE_SINGLE_QUOTE; end = pos; } else { status |= INSIDE_SINGLE_QUOTE; } break; case '\\': if(status & ESCAPE_FOUND) { // copy it as normal char escapes++; } else { status |= ESCAPE_FOUND; continue; } break; case ' ': // if(isspace(*pos)) case '\t': if(status & ESCAPE_FOUND) { escapes++; } else if(!status && start) { end=pos; } break; case '\0': status |= END_OF_STRING; end=pos; break; default: if(!start) start=pos; } status &= ~ESCAPE_FOUND; // copy the arg if found if(start && end) { LOGD("%s: argument found: start=%d, end=%d", __func__, (start-utf), (end-utf)); arg_len=(end-start); arg_len-= escapes; msg_size+=arg_len + 1; if(msg_size > UINT16_MAX) { LOGW("%s: command too long: \"%s\"", __func__, utf); goto exit; } m->data = realloc(m->data, msg_size); if(!m->data) { LOGE("%s: realloc: %s", __func__, strerror(errno)); goto exit; } wpos = m->data + m->head.size; for(rpos=start;rpos<end;rpos++) { if(status & ESCAPE_FOUND) { status &= ~ESCAPE_FOUND; if( *rpos != '\\' && *rpos != '"' && *rpos != '\'' && *rpos != ' ' && *rpos != '\t') { // unrecognized escape sequence, copy the backslash as it is. *wpos = '\\'; wpos++; } } else if(*rpos == '\\') { status |= ESCAPE_FOUND; continue; } *wpos=*rpos; wpos++; } *(m->data + msg_size -1) = '\0'; m->head.size = msg_size; start = end = NULL; escapes = 0; } } // create child c = create_child(m->head.seq); if(!c) { LOGE("%s: cannot craete child", __func__); goto exit; } c->handler = h; // add child to list pthread_mutex_lock(&(children.control.mutex)); list_add(&(children.list), (node *) c); pthread_mutex_unlock(&(children.control.mutex)); // send message to dSploitd pthread_mutex_lock(&write_lock); // OPTIMIZATION: use escapes to store return value for later check escapes = send_message(sockfd, m); pthread_mutex_unlock(&write_lock); if(escapes) { LOGE("%s: cannot send messages", __func__); goto exit; } // wait for CMD_STARTED or CMD_FAIL pthread_mutex_lock(&(children.control.mutex)); while(c->seq && children.control.active) pthread_cond_wait(&(children.control.cond), &(children.control.mutex)); if(c->id == CTRL_ID || c->seq) { // command failed list_del(&(children.list), (node *) c); } else { id = c->id; } c->pending = 0; pthread_mutex_unlock(&(children.control.mutex)); pthread_cond_broadcast(&(children.control.cond)); if(id != -1) { LOGI("%s: child #%d started", __func__, id); } else if(c->seq) { LOGW("%s: pending child cancelled", __func__); } else { LOGW("%s: cannot start command", __func__); } goto exit; jni_error: if((*env)->ExceptionCheck(env)) { (*env)->ExceptionDescribe(env); (*env)->ExceptionClear(env); } exit: if(c && id==-1) { pthread_mutex_lock(&(children.control.mutex)); list_del(&(children.list), (node *) c); pthread_mutex_unlock(&(children.control.mutex)); pthread_cond_broadcast(&(children.control.cond)); free_child(c); } if(m) free_message(m); if(utf) (*env)->ReleaseStringUTFChars(env, *utf_parent, utf); return id; }
bool RDUser::checkPassword(const QString &password,bool webuser) { user_password=password; return authenticated(webuser); }