316 lines
9.0 KiB
C++
316 lines
9.0 KiB
C++
/* Copyright 2013-2021 MultiMC Contributors
|
|
*
|
|
* Authors: Orochimarufan <orochimarufan.x3@gmail.com>
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "MojangAccount.h"
|
|
#include "flows/RefreshTask.h"
|
|
#include "flows/AuthenticateTask.h"
|
|
|
|
#include <QUuid>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QRegExp>
|
|
#include <QStringList>
|
|
#include <QJsonDocument>
|
|
|
|
#include <QDebug>
|
|
|
|
MojangAccountPtr MojangAccount::loadFromJson(const QJsonObject &object)
|
|
{
|
|
// The JSON object must at least have a username for it to be valid.
|
|
if (!object.value("username").isString())
|
|
{
|
|
qCritical() << "Can't load Mojang account info from JSON object. Username field is "
|
|
"missing or of the wrong type.";
|
|
return nullptr;
|
|
}
|
|
|
|
QString username = object.value("username").toString("");
|
|
QString clientToken = object.value("clientToken").toString("");
|
|
QString accessToken = object.value("accessToken").toString("");
|
|
|
|
QJsonArray profileArray = object.value("profiles").toArray();
|
|
if (profileArray.size() < 1)
|
|
{
|
|
qCritical() << "Can't load Mojang account with username \"" << username
|
|
<< "\". No profiles found.";
|
|
return nullptr;
|
|
}
|
|
|
|
QList<AccountProfile> profiles;
|
|
for (QJsonValue profileVal : profileArray)
|
|
{
|
|
QJsonObject profileObject = profileVal.toObject();
|
|
QString id = profileObject.value("id").toString("");
|
|
QString name = profileObject.value("name").toString("");
|
|
bool legacy = profileObject.value("legacy").toBool(false);
|
|
if (id.isEmpty() || name.isEmpty())
|
|
{
|
|
qWarning() << "Unable to load a profile because it was missing an ID or a name.";
|
|
continue;
|
|
}
|
|
profiles.append({id, name, legacy});
|
|
}
|
|
|
|
MojangAccountPtr account(new MojangAccount());
|
|
if (object.value("user").isObject())
|
|
{
|
|
User u;
|
|
QJsonObject userStructure = object.value("user").toObject();
|
|
u.id = userStructure.value("id").toString();
|
|
/*
|
|
QJsonObject propMap = userStructure.value("properties").toObject();
|
|
for(auto key: propMap.keys())
|
|
{
|
|
auto values = propMap.operator[](key).toArray();
|
|
for(auto value: values)
|
|
u.properties.insert(key, value.toString());
|
|
}
|
|
*/
|
|
account->m_user = u;
|
|
}
|
|
account->m_username = username;
|
|
account->m_clientToken = clientToken;
|
|
account->m_accessToken = accessToken;
|
|
account->m_profiles = profiles;
|
|
|
|
// Get the currently selected profile.
|
|
QString currentProfile = object.value("activeProfile").toString("");
|
|
if (!currentProfile.isEmpty())
|
|
account->setCurrentProfile(currentProfile);
|
|
|
|
return account;
|
|
}
|
|
|
|
MojangAccountPtr MojangAccount::createFromUsername(const QString &username)
|
|
{
|
|
MojangAccountPtr account(new MojangAccount());
|
|
account->m_clientToken = QUuid::createUuid().toString().remove(QRegExp("[{}-]"));
|
|
account->m_username = username;
|
|
return account;
|
|
}
|
|
|
|
QJsonObject MojangAccount::saveToJson() const
|
|
{
|
|
QJsonObject json;
|
|
json.insert("username", m_username);
|
|
json.insert("clientToken", m_clientToken);
|
|
json.insert("accessToken", m_accessToken);
|
|
|
|
QJsonArray profileArray;
|
|
for (AccountProfile profile : m_profiles)
|
|
{
|
|
QJsonObject profileObj;
|
|
profileObj.insert("id", profile.id);
|
|
profileObj.insert("name", profile.name);
|
|
profileObj.insert("legacy", profile.legacy);
|
|
profileArray.append(profileObj);
|
|
}
|
|
json.insert("profiles", profileArray);
|
|
|
|
QJsonObject userStructure;
|
|
{
|
|
userStructure.insert("id", m_user.id);
|
|
/*
|
|
QJsonObject userAttrs;
|
|
for(auto key: m_user.properties.keys())
|
|
{
|
|
auto array = QJsonArray::fromStringList(m_user.properties.values(key));
|
|
userAttrs.insert(key, array);
|
|
}
|
|
userStructure.insert("properties", userAttrs);
|
|
*/
|
|
}
|
|
json.insert("user", userStructure);
|
|
|
|
if (m_currentProfile != -1)
|
|
json.insert("activeProfile", currentProfile()->id);
|
|
|
|
return json;
|
|
}
|
|
|
|
bool MojangAccount::setCurrentProfile(const QString &profileId)
|
|
{
|
|
for (int i = 0; i < m_profiles.length(); i++)
|
|
{
|
|
if (m_profiles[i].id == profileId)
|
|
{
|
|
m_currentProfile = i;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const AccountProfile *MojangAccount::currentProfile() const
|
|
{
|
|
if (m_currentProfile == -1)
|
|
return nullptr;
|
|
return &m_profiles[m_currentProfile];
|
|
}
|
|
|
|
AccountStatus MojangAccount::accountStatus() const
|
|
{
|
|
if (m_accessToken.isEmpty())
|
|
return NotVerified;
|
|
else
|
|
return Verified;
|
|
}
|
|
|
|
std::shared_ptr<YggdrasilTask> MojangAccount::login(AuthSessionPtr session, QString password)
|
|
{
|
|
Q_ASSERT(m_currentTask.get() == nullptr);
|
|
|
|
// take care of the true offline status
|
|
if (accountStatus() == NotVerified && password.isEmpty())
|
|
{
|
|
if (session)
|
|
{
|
|
session->status = AuthSession::RequiresPassword;
|
|
fillSession(session);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
if(accountStatus() == Verified && !session->wants_online)
|
|
{
|
|
session->status = AuthSession::PlayableOffline;
|
|
session->auth_server_online = false;
|
|
fillSession(session);
|
|
return nullptr;
|
|
}
|
|
else
|
|
{
|
|
if (password.isEmpty())
|
|
{
|
|
m_currentTask.reset(new RefreshTask(this));
|
|
}
|
|
else
|
|
{
|
|
m_currentTask.reset(new AuthenticateTask(this, password));
|
|
}
|
|
m_currentTask->assignSession(session);
|
|
|
|
connect(m_currentTask.get(), SIGNAL(succeeded()), SLOT(authSucceeded()));
|
|
connect(m_currentTask.get(), SIGNAL(failed(QString)), SLOT(authFailed(QString)));
|
|
}
|
|
return m_currentTask;
|
|
}
|
|
|
|
void MojangAccount::authSucceeded()
|
|
{
|
|
auto session = m_currentTask->getAssignedSession();
|
|
if (session)
|
|
{
|
|
session->status =
|
|
session->wants_online ? AuthSession::PlayableOnline : AuthSession::PlayableOffline;
|
|
fillSession(session);
|
|
session->auth_server_online = true;
|
|
}
|
|
m_currentTask.reset();
|
|
emit changed();
|
|
}
|
|
|
|
void MojangAccount::authFailed(QString reason)
|
|
{
|
|
auto session = m_currentTask->getAssignedSession();
|
|
// This is emitted when the yggdrasil tasks time out or are cancelled.
|
|
// -> we treat the error as no-op
|
|
if (m_currentTask->state() == YggdrasilTask::STATE_FAILED_SOFT)
|
|
{
|
|
if (session)
|
|
{
|
|
session->status = accountStatus() == Verified ? AuthSession::PlayableOffline
|
|
: AuthSession::RequiresPassword;
|
|
session->auth_server_online = false;
|
|
fillSession(session);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_accessToken = QString();
|
|
emit changed();
|
|
if (session)
|
|
{
|
|
session->status = AuthSession::RequiresPassword;
|
|
session->auth_server_online = true;
|
|
fillSession(session);
|
|
}
|
|
}
|
|
m_currentTask.reset();
|
|
}
|
|
|
|
void MojangAccount::fillSession(AuthSessionPtr session)
|
|
{
|
|
// the user name. you have to have an user name
|
|
session->username = m_username;
|
|
// volatile auth token
|
|
session->access_token = m_accessToken;
|
|
// the semi-permanent client token
|
|
session->client_token = m_clientToken;
|
|
if (currentProfile())
|
|
{
|
|
// profile name
|
|
session->player_name = currentProfile()->name;
|
|
// profile ID
|
|
session->uuid = currentProfile()->id;
|
|
// 'legacy' or 'mojang', depending on account type
|
|
session->user_type = currentProfile()->legacy ? "legacy" : "mojang";
|
|
if (!session->access_token.isEmpty())
|
|
{
|
|
session->session = "token:" + m_accessToken + ":" + m_profiles[m_currentProfile].id;
|
|
}
|
|
else
|
|
{
|
|
session->session = "-";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
session->player_name = "Player";
|
|
session->session = "-";
|
|
}
|
|
session->u = user();
|
|
session->m_accountPtr = shared_from_this();
|
|
}
|
|
|
|
void MojangAccount::decrementUses()
|
|
{
|
|
Usable::decrementUses();
|
|
if(!isInUse())
|
|
{
|
|
emit changed();
|
|
qWarning() << "Account" << m_username << "is no longer in use.";
|
|
}
|
|
}
|
|
|
|
void MojangAccount::incrementUses()
|
|
{
|
|
bool wasInUse = isInUse();
|
|
Usable::incrementUses();
|
|
if(!wasInUse)
|
|
{
|
|
emit changed();
|
|
qWarning() << "Account" << m_username << "is now in use.";
|
|
}
|
|
}
|
|
|
|
void MojangAccount::invalidateClientToken()
|
|
{
|
|
m_clientToken = QUuid::createUuid().toString().remove(QRegExp("[{}-]"));
|
|
emit changed();
|
|
}
|