/**

* @file ssudeviceinfo.cpp

* @copyright 2013 2013 Jolla Ltd.

* @author Bernd Wachter <bwachter@lart.info>

* @date 2013

*/

#include <QTextStream>

#include <QDir>

#include <QDBusConnection>

#include <QDBusArgument>

#include <sys/utsname.h>

#include "ssucoreconfig_p.h"

#include "ssulog_p.h"

#include "ssuvariables_p.h"

#include "../constants.h"

SsuDeviceInfo::SsuDeviceInfo(const QString &model)

: QObject()

}

SsuDeviceInfo::~SsuDeviceInfo()

{

delete boardMappings;

}

QStringList SsuDeviceInfo::adaptationRepos()

{

QStringList result;

if (boardMappings->contains(model + "/adaptation-repos"))

result = boardMappings->value(model + "/adaptation-repos").toStringList();

}

QString SsuDeviceInfo::adaptationVariables(const QString &adaptationName, QHash<QString, QString> *storageHash)

{

SsuLog *ssuLog = SsuLog::instance();

QStringList adaptationRepoList = adaptationRepos();

QString model = deviceVariant(true);

// special handling for adaptation-repositories

// - check if repo is in right format (adaptation\d*)

// - check if the configuration has that many adaptation repos

// - export the entry in the adaptation list as %(adaptation)

// - look up variables for that adaptation, and export matching

// adaptation variable

regex.lastIndexIn(adaptationName);

int n = regex.cap().toInt();

if (!adaptationRepoList.isEmpty()) {

if (adaptationRepoList.size() <= n) {

ssuLog->print(LOG_INFO, "Note: repo index out of bounds, substituting 0" + adaptationName);

n = 0;

}

QString adaptationRepo = adaptationRepoList.at(n);

storageHash->insert("adaptation", adaptationRepo);

ssuLog->print(LOG_DEBUG, "Found first adaptation " + adaptationName);

QHash<QString, QString> h;

// add global variables for this model

if (boardMappings->contains(model + "/variables")) {

QStringList sections = boardMappings->value(model + "/variables").toStringList();

foreach (const QString &section, sections)

variableSection(section, &h);

}

// override with variables specific to this repository

variableSection(adaptationRepo, &h);

QHash<QString, QString>::const_iterator i = h.constBegin();

while (i != h.constEnd()) {

storageHash->insert(i.key(), i.value());

i++;

}

} else

ssuLog->print(LOG_INFO, "Note: adaptation repo for invalid repo requested " + adaptationName);

return "adaptation";

}

// If adaptation has defined repository-specific-variables and it matches to the

// repository name then also get those variables.

else if (boardMappings->contains(model + "/repository-specific-variables")) {

QStringList sections = boardMappings->value(model + "/repository-specific-variables").toStringList();

if (sections.contains(model + "-" + adaptationName)) {

QHash<QString, QString> h;

variableSection(model + "-" + adaptationName, &h);

QHash<QString, QString>::const_iterator i = h.constBegin();

while (i != h.constEnd()) {

storageHash->insert(i.key(), i.value());

i++;

}

}

}

}

void SsuDeviceInfo::clearCache()

{

cachedFamily.clear();

cachedModel.clear();

cachedVariant.clear();

}

bool SsuDeviceInfo::contains(const QString &model)

{

QString oldModel = deviceModel();

bool found = false;

if (!model.isEmpty()) {

clearCache();

setDeviceModel(model);

}

if (!deviceVariant(false).isEmpty())

found = true;

if (boardMappings->childGroups().contains(deviceModel()))

found = true;

if (!model.isEmpty()) {

clearCache();

setDeviceModel(oldModel);

}

return found;

}

QString SsuDeviceInfo::deviceFamily()

{

if (!cachedFamily.isEmpty())

return cachedFamily;

} else {

// In case family is not defined, lets use device variant, which

// falls back to device model. This way we can use the deviceFamily

// in common repository names where we want to have same feature package

// for multiple devices some of which have family and some which do not.

cachedFamily = model;

}

}

QString SsuDeviceInfo::deviceVariant(bool fallback)

{

if (!cachedVariant.isEmpty())

return cachedVariant;

if (boardMappings->contains("variants/" + deviceModel())) {

cachedVariant = boardMappings->value("variants/" + deviceModel()).toString();

}

}

QString SsuDeviceInfo::deviceModel()

{

if (!cachedModel.isEmpty())

return cachedModel;

// check if the device can be identified by testing for a file

foreach (const QString &key, keys) {

QString value = boardMappings->value(key).toString();

if (dir.exists(Sandbox::map(value))) {

cachedModel = key;

break;

}

}

boardMappings->endGroup();

if (!cachedModel.isEmpty()) return cachedModel;

// check if the device can be identified by a string in /proc/cpuinfo

procCpuinfo.setFileName(Sandbox::map("/proc/cpuinfo"));

procCpuinfo.open(QIODevice::ReadOnly | QIODevice::Text);

if (procCpuinfo.isOpen()) {

QTextStream in(&procCpuinfo);

QString cpuinfo = in.readAll();

boardMappings->beginGroup("cpuinfo.contains");

keys = boardMappings->allKeys();

foreach (const QString &key, keys) {

QString value = boardMappings->value(key).toString();

if (cpuinfo.contains(value)) {

cachedModel = key;

break;

}

}

boardMappings->endGroup();

}

if (!cachedModel.isEmpty()) return cachedModel;

// mer-hybris adaptations: /etc/hw-release MER_HA_DEVICE variable

QString hwReleaseDevice = hwRelease()["MER_HA_DEVICE"];

if (!hwReleaseDevice.isEmpty()) {

boardMappings->beginGroup("hwrelease.device");

keys = boardMappings->allKeys();

foreach (const QString &key, keys) {

QString value = boardMappings->value(key).toString();

if (hwReleaseDevice == value) {

cachedModel = key;

break;

}

}

boardMappings->endGroup();

}

if (!cachedModel.isEmpty()) return cachedModel;

// check if the device can be identified by the kernel version string

struct utsname buf;

if (!uname(&buf)) {

QString utsRelease(buf.release);

boardMappings->beginGroup("uname-release.contains");

keys = boardMappings->allKeys();

foreach (const QString &key, keys) {

QString value = boardMappings->value(key).toString();

if (utsRelease.contains(value)) {

cachedModel = key;

break;

}

}

boardMappings->endGroup();

}

if (!cachedModel.isEmpty()) return cachedModel;

// check if there's a match on arch of generic fallback. This probably

// only makes sense for x86

boardMappings->beginGroup("arch.equals");

keys = boardMappings->allKeys();

QString value = boardMappings->value(key).toString();

if (settings->value("arch").toString() == value) {

cachedModel = key;

break;

}

}

boardMappings->endGroup();

}

static QStringList

ofonoGetImeis()

{

QStringList result;

QDBusMessage::createMethodCall("org.ofono", "/",

"org.nemomobile.ofono.ModemManager", "GetIMEI"));

if (reply.isValid()) {

result = reply.value();

return result;

}

static QStringList

getWlanMacs()

{

// Based on QtSystems' qnetworkinfo_linux.cpp

QStringList result;

QStringList dirs = QDir(QLatin1String("/sys/class/net/"))

foreach (const QString &dir, dirs) {

QFile carrier(QString("/sys/class/net/%1/address").arg(dir));

if (carrier.open(QIODevice::ReadOnly)) {

result.append(QString::fromLatin1(carrier.readAll().simplified().data()));

}

}

return result;

}

static QString

{

// Normalize by stripping colons, dashes and making it lowercase

return uid.trimmed().replace(":", "").replace("-", "").toLower();

}

QString SsuDeviceInfo::deviceUid()

{

SsuLog *ssuLog = SsuLog::instance();

QStringList imeis = ofonoGetImeis();

if (imeis.size() > 0) {

return imeis[0];

}

QStringList wlanMacs = getWlanMacs();

if (wlanMacs.size() > 0) {

return normalizeUid(wlanMacs[0]);

}

ssuLog->print(LOG_WARNING, "Could not get IMEI(s) from ofono, nor WLAN mac, trying fallback");

// The fallback list is taken from QtSystems' qdeviceinfo_linux.cpp

QStringList fallbackFiles;

fallbackFiles << "/sys/devices/virtual/dmi/id/product_uuid";

fallbackFiles << "/etc/machine-id";

fallbackFiles << "/etc/unique-id";

fallbackFiles << "/var/lib/dbus/machine-id";

foreach (const QString &filename, fallbackFiles) {

QFile machineId(filename);

QTextStream in(&machineId);

return normalizeUid(in.readAll());

}

}

ssuLog->print(LOG_CRIT, "Could not read fallback UID - returning empty string");

QStringList SsuDeviceInfo::disabledRepos()

{

QStringList result;

if (boardMappings->contains(model + "/disabled-repos"))

result = boardMappings->value(model + "/disabled-repos").toStringList();

}

{

QString model = deviceModel();

QString variant = deviceVariant(false);

QString value, key;

key = "/deviceManufacturer";

break;

key = "/prettyModel";

break;

key = "/deviceDesignation";

break;

}

/*

* Go through different levels of fallbacks:

* 1. model specific setting

* 2. variant specific setting

* 3. global setting

* 4. return model name, or "UNKNOWN" in case query was for manufacturer

*/

if (boardMappings->contains(model + key))

value = boardMappings->value(model + key).toString();

value = boardMappings->value(variant + key).toString();

else if (boardMappings->contains(key))

value = boardMappings->value(key).toString();

else if (type != Ssu::DeviceManufacturer)

value = model;

else

value = "UNKNOWN";

return value;

}

// this half belongs into repo-manager, as it not only handles board-specific

// repositories. Right now this one looks like the better place due to the

// connection to board specific stuff, though

QStringList SsuDeviceInfo::repos(bool rnd, int filter)

{

int adaptationCount = adaptationRepos().size();

QStringList result;

///@TODO move this to a hash, containing repo and enabled|disabled

/// write repos with enabled/disabled to disks

/// for the compat functions providing a stringlist, do the filtering

/// run only when creating the list, based on the enabled|disabled flags

if (filter == Ssu::NoFilter ||

filter == Ssu::BoardFilter ||

filter == Ssu::BoardFilterUserBlacklist) {

// for repo names we have adaptation0, adaptation1, ..., adaptationN

for (int i = 0; i < adaptationCount; i++)

result.append(QString("adaptation%1").arg(i));

// now read the release/rnd repos

SsuSettings repoSettings(SSU_REPO_CONFIGURATION, QSettings::IniFormat);

QString repoKey = (rnd ? "default-repos/rnd" : "default-repos/release");

if (repoSettings.contains(repoKey))

result.append(repoSettings.value(repoKey).toStringList());

// TODO: add specific repos (developer, sdk, ..)

// add device configured repos

if (boardMappings->contains(deviceVariant(true) + "/repos"))

result.append(boardMappings->value(deviceVariant(true) + "/repos").toStringList());

// add device configured repos only valid for rnd and/or release

repoKey = (rnd ? "/repos-rnd" : "/repos-release");

if (boardMappings->contains(deviceVariant(true) + repoKey))

result.append(boardMappings->value(deviceVariant(true) + repoKey).toStringList());

// read the disabled repositories for this device

// user can override repositories disabled here in the user configuration

foreach (const QString &key, disabledRepos())

result.removeAll(key);

}

result.removeDuplicates();

return result;

}

{

/// @todo compat-setting as ssudeviceinfo guaranteed to prepend sections with var-;

/// SsuVariables does not have this guarantee. Remove from here as well.

QString varSection(section);

if (!varSection.startsWith("var-"))

varSection = "var-" + varSection;

}

QString varSection(section);

if (!varSection.startsWith("var-"))

varSection = "var-" + varSection;

}

if (model.isEmpty())

cachedModel.clear();

else

cachedModel = model;

cachedFamily.clear();

cachedVariant.clear();

QVariant SsuDeviceInfo::value(const QString &key, const QVariant &value)

{

if (boardMappings->contains(deviceModel() + "/" + key)) {

return boardMappings->value(deviceModel() + "/" + key);

} else if (boardMappings->contains(deviceVariant() + "/" + key)) {

return boardMappings->value(deviceVariant() + "/" + key);

}

QMap<QString, QString> SsuDeviceInfo::hwRelease()

{

QMap<QString, QString> result;

// Specification of the format, encoding is similar to /etc/os-release

// http://www.freedesktop.org/software/systemd/man/os-release.html

QFile hwRelease("/etc/hw-release");

if (hwRelease.open(QIODevice::ReadOnly | QIODevice::Text)) {

QTextStream in(&hwRelease);

// "All strings should be in UTF-8 format, and non-printable characters

// should not be used."

in.setCodec("UTF-8");

while (!in.atEnd()) {

QString line = in.readLine();

// "Lines beginning with "#" shall be ignored as comments."

if (line.startsWith('#')) {

continue;

}

QString key = line.section('=', 0, 0);

QString value = line.section('=', 1);

// Remove trailing whitespace in value

value = value.trimmed();

// POSIX.1-2001 says uppercase, digits and underscores.

//

// Bash uses "[a-zA-Z_]+[a-zA-Z0-9_]*", so we'll use that too,

// as we can safely assume that "shell-compatible variable

// assignments" means it should be compatible with bash.

//

// see http://stackoverflow.com/a/2821183

// and http://stackoverflow.com/a/2821201

if (!QRegExp("[a-zA-Z_]+[a-zA-Z0-9_]*").exactMatch(key)) {

qWarning("Invalid key in input line: '%s'", qPrintable(line));

continue;

}

// "Variable assignment values should be enclosed in double or

// single quotes if they include spaces, semicolons or other

// special characters outside of A-Z, a-z, 0-9."

if (((value.at(0) == '\'') || (value.at(0) == '"'))) {

if (value.at(0) != value.at(value.size() - 1)) {

qWarning("Quoting error in input line: '%s'", qPrintable(line));

continue;

}

// Remove the quotes

value = value.mid(1, value.size() - 2);

}

// "If double or single quotes or backslashes are to be used within

// variable assignments, they should be escaped with backslashes,

// following shell style."

value = value.replace("\\\"", "\"");

value = value.replace("\\'", "'");

value = value.replace("\\\\", "\\");

result[key] = value;

}

}