/**

* @file ssudeviceinfo.cpp

* @copyright 2013 2013 Jolla Ltd.

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

* @date 2013

*/

#include <QTextStream>

#include <QDir>

#include <QDBusMessage>

#include <QDBusConnection>

#include <QDBusArgument>

#include <sys/utsname.h>

#include "../constants.h"

if (!model.isEmpty())

cachedModel = model;

}

QStringList SsuDeviceInfo::adaptationRepos(){

QStringList result;

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

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

return result;

}

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

SsuLog *ssuLog = SsuLog::instance();

QStringList adaptationRepoList = adaptationRepos();

// 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

QRegExp regex("adaptation\\\d*", Qt::CaseSensitive, QRegExp::RegExp2);

if (regex.exactMatch(adaptationName)){

regex.setPattern("\\\d*");

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);

// 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

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";

}

return adaptationName;

}

void SsuDeviceInfo::clearCache(){

cachedFamily = "";

cachedModel = "";

cachedVariant = "";

}

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;

}

if (!cachedFamily.isEmpty())

return cachedFamily;

if (boardMappings->contains(model + "/family"))

cachedFamily = boardMappings->value(model + "/family").toString();

return cachedFamily;

}

if (!cachedVariant.isEmpty())

return cachedVariant;

cachedVariant = "";

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

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

}

if (cachedVariant == "" && fallback)

return deviceModel();

return cachedVariant;

}

QString SsuDeviceInfo::deviceModel(){

QDir dir;

QFile procCpuinfo;

QStringList keys;

if (!cachedModel.isEmpty())

return cachedModel;

boardMappings->beginGroup("file.exists");

keys = boardMappings->allKeys();

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

foreach (const QString &key, keys){

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

cachedModel = key;

break;

}

}

boardMappings->endGroup();

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

// check if the device can be identified by a string in /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;

// only makes sense for x86

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

keys = boardMappings->allKeys();

foreach (const QString &key, keys){

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

cachedModel = key;

break;

}

}

boardMappings->endGroup();

if (cachedModel.isEmpty()) cachedModel = "UNKNOWN";

return cachedModel;

}

static QStringList

ofonoGetImeis()

{

QStringList result;

QDBusMessage reply = QDBusConnection::systemBus().call(

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

"org.ofono.Manager", "GetModems"));

foreach (const QVariant &v, reply.arguments()) {

if (v.canConvert<QDBusArgument>()) {

const QDBusArgument arg = v.value<QDBusArgument>();

if (arg.currentType() == QDBusArgument::ArrayType) {

arg.beginArray();

while (!arg.atEnd()) {

if (arg.currentType() == QDBusArgument::StructureType) {

QString path;

QVariantMap props;

arg.beginStructure();

arg >> path >> props;

arg.endStructure();

if (props.contains("Serial")) {

result << props["Serial"].toString();

}

}

}

arg.endArray();

}

}

}

return result;

}

QString SsuDeviceInfo::deviceUid(){

QStringList imeis = ofonoGetImeis();

if (imeis.size() == 0) {

qWarning() << "Could not get IMEI(s) from ofono, 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);

if (machineId.open(QFile::ReadOnly | QFile::Text)) {

QTextStream in(&machineId);

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

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

}

}

qCritical() << "Could not read fallback UID - returning empty string";

return "";

}

QStringList SsuDeviceInfo::disabledRepos(){

QStringList result;

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

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

return result;

}

QString SsuDeviceInfo::displayName(const int type){

QString model = deviceModel();

QString variant = deviceVariant(false);

QString value, key;

switch (type){

case Ssu::DeviceManufacturer:

key = "/deviceManufacturer";

break;

case Ssu::DeviceModel:

key = "/prettyModel";

break;

case Ssu::DeviceDesignation:

key = "/deviceDesignation";

break;

default:

return "";

}

/*

* 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();

else if (variant != "" && boardMappings->contains(variant + key))

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));

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

if (repoSettings.contains(repoKey))

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

// 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);

}

return result;

}

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

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

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

section = "var-" + section;

}

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

section = "var-" + section;

}

void SsuDeviceInfo::setDeviceModel(QString model){

if (model == "")

cachedModel = "";

else

cachedModel = model;

cachedFamily = "";

cachedVariant = "";

}

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

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

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

}

return value;

}

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;

}

hwRelease.close();

}

return result;

}