← Back to branch summary

~ci-train-bot/online-accounts-api/online-accounts-api-ubuntu-xenial-landing-033

« back to all changes in this revision

Viewing changes to src/daemon/manager.cpp

  • Committer: Alberto Mardegan
  • Date: 2015-02-18 08:09:05 UTC
  • mfrom: (4.2.4 style)
  • Revision ID: alberto.mardegan@canonical.com-20150218080905-bqo9e9xdaizagxpv
style

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/daemon/manager.cpp
1
1
#include "manager.h"
 
2
 
 
3
#include <QDBusMessage>
2
4
#include <QDebug>
3
 
#include <QDBusMessage>
4
5
#include "aacontext.h"
5
6
 
6
 
using namespace std;
7
 
 
8
7
static const char FORBIDDEN_ERROR[] = "com.ubuntu.OnlineAccounts.Error.Forbidden";
9
8
 
10
 
QDBusArgument &operator<<(QDBusArgument &argument, const AccountInfo &info) {
11
 
    argument.beginStructure();
12
 
    argument << info.account_id << info.details;
13
 
    argument.endStructure();
14
 
    return argument;
15
 
}
16
 
 
17
 
const QDBusArgument &operator>>(const QDBusArgument &argument, AccountInfo &info) {
18
 
    argument.beginStructure();
19
 
    argument >> info.account_id >> info.details;
20
 
    argument.endStructure();
21
 
    return argument;
22
 
}
23
 
 
24
 
 
25
 
struct Manager::Private {
26
 
    AppArmorContext apparmor;
 
9
QDBusArgument &operator<<(QDBusArgument &argument, const AccountInfo &info)
 
10
{
 
11
    argument.beginStructure();
 
12
    argument << info.accountId << info.details;
 
13
    argument.endStructure();
 
14
    return argument;
 
15
}
 
16
 
 
17
const QDBusArgument &operator>>(const QDBusArgument &argument,
 
18
                                AccountInfo &info)
 
19
{
 
20
    argument.beginStructure();
 
21
    argument >> info.accountId >> info.details;
 
22
    argument.endStructure();
 
23
    return argument;
 
24
}
 
25
 
 
26
class ManagerPrivate {
 
27
public:
 
28
    AppArmorContext m_apparmor;
27
29
};
28
30
 
29
 
Manager::Manager(QObject *parent)
30
 
    : QObject(parent), p(new Private) {
31
 
}
32
 
 
33
 
Manager::~Manager() {
34
 
}
35
 
 
36
 
bool Manager::canAccess(const QString &service_id) {
37
 
    QString context = p->apparmor.getPeerSecurityContext(connection(), message());
 
31
Manager::Manager(QObject *parent):
 
32
    QObject(parent),
 
33
    d_ptr(new ManagerPrivate)
 
34
{
 
35
}
 
36
 
 
37
Manager::~Manager()
 
38
{
 
39
    delete d_ptr;
 
40
}
 
41
 
 
42
bool Manager::canAccess(const QString &serviceId)
 
43
{
 
44
    Q_D(Manager);
 
45
 
 
46
    QString context = d->m_apparmor.getPeerSecurityContext(connection(),
 
47
                                                           message());
38
48
    // Could not determine peer's AppArmor context, so deny access
39
49
    if (context.isEmpty()) {
40
50
        return false;
55
65
    // Do the same on the service ID: we are only dealing with
56
66
    // confined apps at this point, so only $pkgname prefixed
57
67
    // services are accessible.
58
 
    pos = service_id.indexOf('_');
 
68
    pos = serviceId.indexOf('_');
59
69
    if (pos < 0) {
60
70
        return false;
61
71
    }
62
 
    return service_id.left(pos) == pkgname;
 
72
    return serviceId.left(pos) == pkgname;
63
73
}
64
74
 
65
 
bool Manager::checkAccess(const QString &service_id) {
66
 
    bool has_access = canAccess(service_id);
67
 
    if (!has_access) {
68
 
        sendErrorReply(FORBIDDEN_ERROR, QString("Access to service ID %1 forbidden").arg(service_id));
 
75
bool Manager::checkAccess(const QString &serviceId)
 
76
{
 
77
    bool hasAccess = canAccess(serviceId);
 
78
    if (!hasAccess) {
 
79
        sendErrorReply(FORBIDDEN_ERROR,
 
80
                       QString("Access to service ID %1 forbidden").arg(serviceId));
69
81
    }
70
 
    return has_access;
 
82
    return hasAccess;
71
83
}
72
84
 
73
 
QList<AccountInfo> Manager::GetAccounts(const QStringList &service_ids) {
74
 
    for (const auto &service_id : service_ids) {
75
 
        if (!checkAccess(service_id)) {
 
85
QList<AccountInfo> Manager::GetAccounts(const QStringList &serviceIds)
 
86
{
 
87
    Q_FOREACH(const QString &serviceId, serviceIds) {
 
88
        if (!checkAccess(serviceId)) {
76
89
            return QList<AccountInfo>();
77
90
        }
78
91
    }
80
93
    return QList<AccountInfo>({AccountInfo(0, QVariantMap())});
81
94
}
82
95
 
83
 
AccountInfo Manager::GetAccountInfo(const QString &service_id, uint account_id) {
84
 
    if (!checkAccess(service_id)) {
 
96
AccountInfo Manager::GetAccountInfo(const QString &serviceId, uint accountId)
 
97
{
 
98
    Q_UNUSED(accountId);
 
99
 
 
100
    if (!checkAccess(serviceId)) {
85
101
        return AccountInfo();
86
102
    }
87
103
 
88
 
    return AccountInfo(account_id, QVariantMap());
 
104
    return AccountInfo(accountId, QVariantMap());
89
105
}
90
106
 
91
 
QVariantMap Manager::Authenticate(const QString &service_id, uint account_id, bool interactive, bool invalidate) {
92
 
    if (!checkAccess(service_id)) {
 
107
QVariantMap Manager::Authenticate(const QString &serviceId, uint accountId,
 
108
                                  bool interactive, bool invalidate)
 
109
{
 
110
    Q_UNUSED(accountId);
 
111
    Q_UNUSED(interactive);
 
112
    Q_UNUSED(invalidate);
 
113
 
 
114
    if (!checkAccess(serviceId)) {
93
115
        return QVariantMap();
94
116
    }
95
117
 
96
118
    return QVariantMap();
97
119
}
98
120
 
99
 
AccountInfo Manager::Register(const QString &service_id, QVariantMap &credentials) {
100
 
    if (!checkAccess(service_id)) {
 
121
AccountInfo Manager::Register(const QString &serviceId, QVariantMap &credentials)
 
122
{
 
123
    Q_UNUSED(credentials);
 
124
 
 
125
    if (!checkAccess(serviceId)) {
101
126
        return AccountInfo();
102
127
    }
103
128