← Back to branch summary

~ubuntu-branches/ubuntu/natty/sflphone/natty

« back to all changes in this revision

Viewing changes to sflphone-common/src/dbus/configurationmanager.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2010-12-24 16:33:55 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101224163355-tkvvikqxbrbav6up
Tags: 0.9.11-1
* New upstream release
* Add new build dependencies on libwebkit-dev and libyaml-dev

* Bump Standards-Version up to 3.9.1
* Bump debhelper compatibility to 8
* Patch another typo in the upstream code (lintian notice)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sflphone-common/src/dbus/configurationmanager.cpp
35
35
#include <sstream>
36
36
#include "../manager.h"
37
37
#include "sip/sipvoiplink.h"
 
38
#include "sip/sipaccount.h"
38
39
 
39
40
const char* ConfigurationManager::SERVER_PATH =
40
 
                "/org/sflphone/SFLphone/ConfigurationManager";
41
 
 
42
 
ConfigurationManager::ConfigurationManager(DBus::Connection& connection) :
43
 
        DBus::ObjectAdaptor(connection, SERVER_PATH) {
44
 
        shortcutsKeys.push_back("pick_up");
45
 
        shortcutsKeys.push_back("hang_up");
46
 
        shortcutsKeys.push_back("popup_window");
47
 
        shortcutsKeys.push_back("toggle_pick_up_hang_up");
48
 
        shortcutsKeys.push_back("toggle_hold");
49
 
}
50
 
 
51
 
std::map<std::string, std::string> ConfigurationManager::getAccountDetails(
52
 
                const std::string& accountID) {
53
 
        return Manager::instance().getAccountDetails(accountID);
54
 
}
55
 
 
56
 
std::map<std::string, std::string> ConfigurationManager::getTlsSettingsDefault(
57
 
                void) {
58
 
 
59
 
        std::map<std::string, std::string> tlsSettingsDefault;
60
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
61
 
                        TLS_LISTENER_PORT, DEFAULT_SIP_TLS_PORT));
62
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
63
 
                        TLS_CA_LIST_FILE, ""));
64
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
65
 
                        TLS_CERTIFICATE_FILE, ""));
66
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
67
 
                        TLS_PRIVATE_KEY_FILE, ""));
68
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(TLS_PASSWORD,
69
 
                        ""));
70
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(TLS_METHOD,
71
 
                        "TLSv1"));
72
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(TLS_CIPHERS,
73
 
                        ""));
74
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
75
 
                        TLS_SERVER_NAME, ""));
76
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
77
 
                        TLS_VERIFY_SERVER, "true"));
78
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
79
 
                        TLS_VERIFY_CLIENT, "true"));
80
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
81
 
                        TLS_REQUIRE_CLIENT_CERTIFICATE, "true"));
82
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
83
 
                        TLS_NEGOTIATION_TIMEOUT_SEC, "2"));
84
 
        tlsSettingsDefault.insert(std::pair<std::string, std::string>(
85
 
                        TLS_NEGOTIATION_TIMEOUT_MSEC, "0"));
86
 
 
87
 
        return tlsSettingsDefault;
88
 
}
89
 
 
90
 
std::map<std::string, std::string> ConfigurationManager::getIp2IpDetails(void) {
91
 
 
92
 
        std::map<std::string, std::string> ip2ipAccountDetails;
93
 
 
94
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(ACCOUNT_ID,
95
 
                        IP2IP_PROFILE));
96
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
97
 
                        SRTP_KEY_EXCHANGE, Manager::instance().getConfigString(
98
 
                                        IP2IP_PROFILE, SRTP_KEY_EXCHANGE)));
99
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(SRTP_ENABLE,
100
 
                        Manager::instance().getConfigString(IP2IP_PROFILE, SRTP_ENABLE)));
101
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
102
 
                        SRTP_RTP_FALLBACK, Manager::instance().getConfigString(
103
 
                                        IP2IP_PROFILE, SRTP_RTP_FALLBACK)));
104
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
105
 
                        ZRTP_DISPLAY_SAS, Manager::instance().getConfigString(
106
 
                                        IP2IP_PROFILE, ZRTP_DISPLAY_SAS)));
107
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
108
 
                        ZRTP_HELLO_HASH, Manager::instance().getConfigString(IP2IP_PROFILE,
109
 
                                        ZRTP_HELLO_HASH)));
110
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
111
 
                        ZRTP_NOT_SUPP_WARNING, Manager::instance().getConfigString(
112
 
                                        IP2IP_PROFILE, ZRTP_NOT_SUPP_WARNING)));
113
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
114
 
                        ZRTP_DISPLAY_SAS_ONCE, Manager::instance().getConfigString(
115
 
                                        IP2IP_PROFILE, ZRTP_DISPLAY_SAS_ONCE)));
116
 
 
117
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(
118
 
                        LOCAL_INTERFACE, Manager::instance().getConfigString(IP2IP_PROFILE,
119
 
                                        LOCAL_INTERFACE)));
120
 
        ip2ipAccountDetails.insert(std::pair<std::string, std::string>(LOCAL_PORT,
121
 
                        Manager::instance().getConfigString(IP2IP_PROFILE, LOCAL_PORT)));
122
 
 
123
 
        std::map<std::string, std::string> tlsSettings;
124
 
        tlsSettings = getTlsSettings(IP2IP_PROFILE);
125
 
        std::copy(tlsSettings.begin(), tlsSettings.end(), std::inserter(
126
 
                        ip2ipAccountDetails, ip2ipAccountDetails.end()));
127
 
 
128
 
        return ip2ipAccountDetails;
129
 
 
130
 
}
131
 
 
132
 
void ConfigurationManager::setIp2IpDetails(const std::map<std::string,
133
 
                std::string>& details) {
134
 
        std::map<std::string, std::string> map_cpy = details;
135
 
        std::map<std::string, std::string>::iterator it;
136
 
 
137
 
        it = map_cpy.find(LOCAL_INTERFACE);
138
 
 
139
 
        if (it != details.end()) {
140
 
                Manager::instance().setConfig(IP2IP_PROFILE, LOCAL_INTERFACE,
141
 
                                it->second);
142
 
        }
143
 
 
144
 
        it = map_cpy.find(LOCAL_PORT);
145
 
 
146
 
        if (it != details.end()) {
147
 
                Manager::instance().setConfig(IP2IP_PROFILE, LOCAL_PORT, it->second);
148
 
        }
149
 
 
150
 
        it = map_cpy.find(SRTP_ENABLE);
151
 
 
152
 
        if (it != details.end()) {
153
 
                Manager::instance().setConfig(IP2IP_PROFILE, SRTP_ENABLE, it->second);
154
 
        }
155
 
 
156
 
        it = map_cpy.find(SRTP_RTP_FALLBACK);
157
 
 
158
 
        if (it != details.end()) {
159
 
                Manager::instance().setConfig(IP2IP_PROFILE, SRTP_RTP_FALLBACK,
160
 
                                it->second);
161
 
        }
162
 
 
163
 
        it = map_cpy.find(SRTP_KEY_EXCHANGE);
164
 
 
165
 
        if (it != details.end()) {
166
 
                Manager::instance().setConfig(IP2IP_PROFILE, SRTP_KEY_EXCHANGE,
167
 
                                it->second);
168
 
        }
169
 
 
170
 
        it = map_cpy.find(ZRTP_DISPLAY_SAS);
171
 
 
172
 
        if (it != details.end()) {
173
 
                Manager::instance().setConfig(IP2IP_PROFILE, ZRTP_DISPLAY_SAS,
174
 
                                it->second);
175
 
        }
176
 
 
177
 
        it = map_cpy.find(ZRTP_NOT_SUPP_WARNING);
178
 
 
179
 
        if (it != details.end()) {
180
 
                Manager::instance().setConfig(IP2IP_PROFILE, ZRTP_NOT_SUPP_WARNING,
181
 
                                it->second);
182
 
        }
183
 
 
184
 
        it = map_cpy.find(ZRTP_HELLO_HASH);
185
 
 
186
 
        if (it != details.end()) {
187
 
                Manager::instance().setConfig(IP2IP_PROFILE, ZRTP_HELLO_HASH,
188
 
                                it->second);
189
 
        }
190
 
 
191
 
        it = map_cpy.find(ZRTP_DISPLAY_SAS_ONCE);
192
 
 
193
 
        if (it != details.end()) {
194
 
                Manager::instance().setConfig(IP2IP_PROFILE, ZRTP_DISPLAY_SAS_ONCE,
195
 
                                it->second);
196
 
        }
197
 
 
198
 
        setTlsSettings(IP2IP_PROFILE, details);
199
 
 
200
 
        Manager::instance().saveConfig();
201
 
 
202
 
        // Update account details to the client side
203
 
        accountsChanged();
204
 
 
205
 
        // Reload account settings from config
206
 
        Manager::instance().getAccount(IP2IP_PROFILE)->loadConfig();
207
 
 
208
 
}
209
 
 
210
 
std::map<std::string, std::string> ConfigurationManager::getTlsSettings(
211
 
                const std::string& section) {
212
 
        std::map<std::string, std::string> tlsSettings;
213
 
 
214
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_LISTENER_PORT,
215
 
                        Manager::instance().getConfigString(section, TLS_LISTENER_PORT)));
216
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_ENABLE,
217
 
                        Manager::instance().getConfigString(section, TLS_ENABLE)));
218
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_CA_LIST_FILE,
219
 
                        Manager::instance().getConfigString(section, TLS_CA_LIST_FILE)));
220
 
        tlsSettings.insert(std::pair<std::string, std::string>(
221
 
                        TLS_CERTIFICATE_FILE, Manager::instance().getConfigString(section,
222
 
                                        TLS_CERTIFICATE_FILE)));
223
 
        tlsSettings.insert(std::pair<std::string, std::string>(
224
 
                        TLS_PRIVATE_KEY_FILE, Manager::instance().getConfigString(section,
225
 
                                        TLS_PRIVATE_KEY_FILE)));
226
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_PASSWORD,
227
 
                        Manager::instance().getConfigString(section, TLS_PASSWORD)));
228
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_METHOD,
229
 
                        Manager::instance().getConfigString(section, TLS_METHOD)));
230
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_CIPHERS,
231
 
                        Manager::instance().getConfigString(section, TLS_CIPHERS)));
232
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_SERVER_NAME,
233
 
                        Manager::instance().getConfigString(section, TLS_SERVER_NAME)));
234
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_VERIFY_SERVER,
235
 
                        Manager::instance().getConfigString(section, TLS_VERIFY_SERVER)));
236
 
        tlsSettings.insert(std::pair<std::string, std::string>(TLS_VERIFY_CLIENT,
237
 
                        Manager::instance().getConfigString(section, TLS_VERIFY_CLIENT)));
238
 
        tlsSettings.insert(std::pair<std::string, std::string>(
239
 
                        TLS_REQUIRE_CLIENT_CERTIFICATE,
240
 
                        Manager::instance().getConfigString(section,
241
 
                                        TLS_REQUIRE_CLIENT_CERTIFICATE)));
242
 
        tlsSettings.insert(std::pair<std::string, std::string>(
243
 
                        TLS_NEGOTIATION_TIMEOUT_SEC, Manager::instance().getConfigString(
244
 
                                        section, TLS_NEGOTIATION_TIMEOUT_SEC)));
245
 
        tlsSettings.insert(std::pair<std::string, std::string>(
246
 
                        TLS_NEGOTIATION_TIMEOUT_MSEC, Manager::instance().getConfigString(
247
 
                                        section, TLS_NEGOTIATION_TIMEOUT_MSEC)));
248
 
        return tlsSettings;
249
 
}
250
 
 
251
 
void ConfigurationManager::setTlsSettings(const std::string& section,
252
 
                const std::map<std::string, std::string>& details) {
253
 
        std::map<std::string, std::string> map_cpy = details;
254
 
        std::map<std::string, std::string>::iterator it;
255
 
 
256
 
        it = map_cpy.find(TLS_LISTENER_PORT);
257
 
        if (it != details.end()) {
258
 
                Manager::instance().setConfig(section, TLS_LISTENER_PORT, it->second);
259
 
        }
260
 
 
261
 
        it = map_cpy.find(TLS_ENABLE);
262
 
 
263
 
        if (it != details.end()) {
264
 
                Manager::instance().setConfig(section, TLS_ENABLE, it->second);
265
 
        }
266
 
 
267
 
        it = map_cpy.find(TLS_CA_LIST_FILE);
268
 
 
269
 
        if (it != map_cpy.end()) {
270
 
                Manager::instance().setConfig(section, TLS_CA_LIST_FILE, it->second);
271
 
        }
272
 
 
273
 
        it = map_cpy.find(TLS_CERTIFICATE_FILE);
274
 
 
275
 
        if (it != map_cpy.end()) {
276
 
                Manager::instance().setConfig(section, TLS_CERTIFICATE_FILE, it->second);
277
 
        }
278
 
 
279
 
        it = map_cpy.find(TLS_PRIVATE_KEY_FILE);
280
 
 
281
 
        if (it != map_cpy.end()) {
282
 
                Manager::instance().setConfig(section, TLS_PRIVATE_KEY_FILE, it->second);
283
 
        }
284
 
 
285
 
        it = map_cpy.find(TLS_PASSWORD);
286
 
 
287
 
        if (it != map_cpy.end()) {
288
 
                Manager::instance().setConfig(section, TLS_PASSWORD, it->second);
289
 
        }
290
 
 
291
 
        it = map_cpy.find(TLS_METHOD);
292
 
 
293
 
        if (it != map_cpy.end()) {
294
 
                Manager::instance().setConfig(section, TLS_METHOD, it->second);
295
 
        }
296
 
 
297
 
        it = map_cpy.find(TLS_CIPHERS);
298
 
 
299
 
        if (it != map_cpy.end()) {
300
 
                Manager::instance().setConfig(section, TLS_CIPHERS, it->second);
301
 
        }
302
 
 
303
 
        it = map_cpy.find(TLS_SERVER_NAME);
304
 
 
305
 
        if (it != map_cpy.end()) {
306
 
                Manager::instance().setConfig(section, TLS_SERVER_NAME, it->second);
307
 
        }
308
 
 
309
 
        it = map_cpy.find(TLS_VERIFY_CLIENT);
310
 
 
311
 
        if (it != map_cpy.end()) {
312
 
                Manager::instance().setConfig(section, TLS_VERIFY_CLIENT, it->second);
313
 
        }
314
 
 
315
 
        it = map_cpy.find(TLS_REQUIRE_CLIENT_CERTIFICATE);
316
 
 
317
 
        if (it != map_cpy.end()) {
318
 
                Manager::instance().setConfig(section, TLS_REQUIRE_CLIENT_CERTIFICATE,
319
 
                                it->second);
320
 
        }
321
 
 
322
 
        it = map_cpy.find(TLS_NEGOTIATION_TIMEOUT_SEC);
323
 
 
324
 
        if (it != map_cpy.end()) {
325
 
                Manager::instance().setConfig(section, TLS_NEGOTIATION_TIMEOUT_SEC,
326
 
                                it->second);
327
 
        }
328
 
 
329
 
        it = map_cpy.find(TLS_NEGOTIATION_TIMEOUT_MSEC);
330
 
 
331
 
        if (it != map_cpy.end()) {
332
 
                Manager::instance().setConfig(section, TLS_NEGOTIATION_TIMEOUT_MSEC,
333
 
                                it->second);
334
 
        }
335
 
 
336
 
        Manager::instance().saveConfig();
337
 
 
338
 
        // Update account details to the client side
339
 
        accountsChanged();
340
 
 
341
 
}
342
 
 
343
 
std::map<std::string, std::string> ConfigurationManager::getCredential(
344
 
                const std::string& accountID, const int32_t& index) {
345
 
 
346
 
        std::string credentialIndex;
347
 
        std::stringstream streamOut;
348
 
        streamOut << index;
349
 
        credentialIndex = streamOut.str();
350
 
 
351
 
        std::string section = std::string("Credential") + std::string(":")
352
 
                        + accountID + std::string(":") + credentialIndex;
353
 
 
354
 
        std::map<std::string, std::string> credentialInformation;
355
 
        std::string username = Manager::instance().getConfigString(section,
356
 
                        USERNAME);
357
 
        std::string password = Manager::instance().getConfigString(section,
358
 
                        PASSWORD);
359
 
        std::string realm = Manager::instance().getConfigString(section, REALM);
360
 
 
361
 
        credentialInformation.insert(std::pair<std::string, std::string>(USERNAME,
362
 
                        username));
363
 
        credentialInformation.insert(std::pair<std::string, std::string>(PASSWORD,
364
 
                        password));
365
 
        credentialInformation.insert(std::pair<std::string, std::string>(REALM,
366
 
                        realm));
367
 
 
368
 
        return credentialInformation;
369
 
}
370
 
 
371
 
int32_t ConfigurationManager::getNumberOfCredential(
372
 
                const std::string& accountID) {
373
 
        return Manager::instance().getConfigInt(accountID, CONFIG_CREDENTIAL_NUMBER);
374
 
}
375
 
 
376
 
void ConfigurationManager::setNumberOfCredential(const std::string& accountID,
377
 
                const int32_t& number) {
378
 
        if (accountID != AccountNULL || !accountID.empty()) {
379
 
                Manager::instance().setConfig(accountID, CONFIG_CREDENTIAL_NUMBER,
380
 
                                number);
381
 
        }
382
 
}
383
 
 
384
 
void ConfigurationManager::setCredential(const std::string& accountID,
385
 
                const int32_t& index, const std::map<std::string, std::string>& details) {
386
 
        Manager::instance().setCredential(accountID, index, details);
387
 
}
388
 
 
389
 
void ConfigurationManager::deleteAllCredential(const std::string& accountID) {
390
 
        Manager::instance().deleteAllCredential(accountID);
391
 
}
392
 
 
393
 
void ConfigurationManager::setAccountDetails(const std::string& accountID,
394
 
                const std::map<std::string, std::string>& details) {
395
 
        Manager::instance().setAccountDetails(accountID, details);
396
 
}
397
 
 
398
 
void ConfigurationManager::sendRegister(const std::string& accountID,
399
 
                const int32_t& expire) {
400
 
        Manager::instance().sendRegister(accountID, expire);
401
 
}
402
 
 
403
 
std::string ConfigurationManager::addAccount(const std::map<std::string,
404
 
                std::string>& details) {
405
 
        return Manager::instance().addAccount(details);
406
 
}
407
 
 
408
 
void ConfigurationManager::removeAccount(const std::string& accoundID) {
409
 
        return Manager::instance().removeAccount(accoundID);
410
 
}
411
 
 
412
 
std::vector<std::string> ConfigurationManager::getAccountList() {
413
 
        return Manager::instance().getAccountList();
414
 
}
415
 
 
416
 
//TODO
417
 
std::vector<std::string> ConfigurationManager::getToneLocaleList() {
418
 
        std::vector<std::string> ret;
419
 
        return ret;
420
 
}
421
 
 
422
 
//TODO
423
 
std::string ConfigurationManager::getVersion() {
424
 
        std::string ret("");
425
 
        return ret;
426
 
}
427
 
 
428
 
//TODO
429
 
std::vector<std::string> ConfigurationManager::getRingtoneList() {
430
 
        std::vector<std::string> ret;
431
 
        return ret;
 
41
    "/org/sflphone/SFLphone/ConfigurationManager";
 
42
 
 
43
ConfigurationManager::ConfigurationManager (DBus::Connection& connection) :
 
44
    DBus::ObjectAdaptor (connection, SERVER_PATH)
 
45
{
 
46
    shortcutsKeys.push_back ("pick_up");
 
47
    shortcutsKeys.push_back ("hang_up");
 
48
    shortcutsKeys.push_back ("popup_window");
 
49
    shortcutsKeys.push_back ("toggle_pick_up_hang_up");
 
50
    shortcutsKeys.push_back ("toggle_hold");
 
51
}
 
52
 
 
53
std::map<std::string, std::string> ConfigurationManager::getAccountDetails (
 
54
    const std::string& accountID)
 
55
{
 
56
 
 
57
    _debug ("ConfigurationManager: get account details %s", accountID.c_str());
 
58
    return Manager::instance().getAccountDetails (accountID);
 
59
}
 
60
 
 
61
std::map<std::string, std::string> ConfigurationManager::getTlsSettingsDefault (
 
62
    void)
 
63
{
 
64
 
 
65
    std::map<std::string, std::string> tlsSettingsDefault;
 
66
 
 
67
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
68
                                   TLS_LISTENER_PORT, DEFAULT_SIP_TLS_PORT));
 
69
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
70
                                   TLS_CA_LIST_FILE, ""));
 
71
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
72
                                   TLS_CERTIFICATE_FILE, ""));
 
73
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
74
                                   TLS_PRIVATE_KEY_FILE, ""));
 
75
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (TLS_PASSWORD,
 
76
                               ""));
 
77
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (TLS_METHOD,
 
78
                               "TLSv1"));
 
79
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (TLS_CIPHERS,
 
80
                               ""));
 
81
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
82
                                   TLS_SERVER_NAME, ""));
 
83
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
84
                                   TLS_VERIFY_SERVER, "true"));
 
85
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
86
                                   TLS_VERIFY_CLIENT, "true"));
 
87
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
88
                                   TLS_REQUIRE_CLIENT_CERTIFICATE, "true"));
 
89
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
90
                                   TLS_NEGOTIATION_TIMEOUT_SEC, "2"));
 
91
    tlsSettingsDefault.insert (std::pair<std::string, std::string> (
 
92
                                   TLS_NEGOTIATION_TIMEOUT_MSEC, "0"));
 
93
 
 
94
    return tlsSettingsDefault;
 
95
}
 
96
 
 
97
std::map<std::string, std::string> ConfigurationManager::getIp2IpDetails (void)
 
98
{
 
99
 
 
100
    std::map<std::string, std::string> ip2ipAccountDetails;
 
101
 
 
102
    SIPAccount *sipaccount = (SIPAccount *) Manager::instance().getAccount (IP2IP_PROFILE);
 
103
 
 
104
    if (!sipaccount) {
 
105
        _error ("ConfigurationManager: could not find account");
 
106
        return ip2ipAccountDetails;
 
107
    }
 
108
 
 
109
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (ACCOUNT_ID, IP2IP_PROFILE));
 
110
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (SRTP_KEY_EXCHANGE, sipaccount->getSrtpKeyExchange()));
 
111
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (SRTP_ENABLE, sipaccount->getSrtpEnable() ? "true" : "false"));
 
112
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (SRTP_RTP_FALLBACK, sipaccount->getSrtpFallback() ? "true" : "false"));
 
113
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (ZRTP_DISPLAY_SAS, sipaccount->getZrtpDisplaySas() ? "true" : "false"));
 
114
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (ZRTP_HELLO_HASH, sipaccount->getZrtpHelloHash() ? "true" : "false"));
 
115
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (ZRTP_NOT_SUPP_WARNING, sipaccount->getZrtpNotSuppWarning() ? "true" : "false"));
 
116
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (ZRTP_DISPLAY_SAS_ONCE, sipaccount->getZrtpDiaplaySasOnce() ? "true" : "false"));
 
117
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (LOCAL_INTERFACE, sipaccount->getLocalInterface()));
 
118
    std::stringstream portstr;
 
119
    portstr << sipaccount->getLocalPort();
 
120
    ip2ipAccountDetails.insert (std::pair<std::string, std::string> (LOCAL_PORT, portstr.str()));
 
121
 
 
122
    std::map<std::string, std::string> tlsSettings;
 
123
    tlsSettings = getTlsSettings();
 
124
    std::copy (tlsSettings.begin(), tlsSettings.end(), std::inserter (
 
125
                   ip2ipAccountDetails, ip2ipAccountDetails.end()));
 
126
 
 
127
    return ip2ipAccountDetails;
 
128
 
 
129
}
 
130
 
 
131
void ConfigurationManager::setIp2IpDetails (const std::map<std::string,
 
132
        std::string>& details)
 
133
{
 
134
    std::map<std::string, std::string> map_cpy = details;
 
135
    std::map<std::string, std::string>::iterator it;
 
136
 
 
137
    SIPAccount *sipaccount = (SIPAccount *) Manager::instance().getAccount (IP2IP_PROFILE);
 
138
 
 
139
    if (!sipaccount) {
 
140
        _error ("ConfigurationManager: could not find account");
 
141
    }
 
142
 
 
143
 
 
144
    it = map_cpy.find (LOCAL_INTERFACE);
 
145
 
 
146
    if (it != details.end()) sipaccount->setLocalInterface (it->second);
 
147
 
 
148
    it = map_cpy.find (LOCAL_PORT);
 
149
 
 
150
    if (it != details.end()) sipaccount->setLocalPort (atoi (it->second.data()));
 
151
 
 
152
    it = map_cpy.find (SRTP_ENABLE);
 
153
 
 
154
    if (it != details.end()) sipaccount->setSrtpEnable ( (it->second == "true"));
 
155
 
 
156
    it = map_cpy.find (SRTP_RTP_FALLBACK);
 
157
 
 
158
    if (it != details.end()) sipaccount->setSrtpFallback ( (it->second == "true"));
 
159
 
 
160
    it = map_cpy.find (SRTP_KEY_EXCHANGE);
 
161
 
 
162
    if (it != details.end()) sipaccount->setSrtpKeyExchange (it->second);
 
163
 
 
164
    it = map_cpy.find (ZRTP_DISPLAY_SAS);
 
165
 
 
166
    if (it != details.end()) sipaccount->setZrtpDisplaySas ( (it->second == "true"));
 
167
 
 
168
    it = map_cpy.find (ZRTP_NOT_SUPP_WARNING);
 
169
 
 
170
    if (it != details.end()) sipaccount->setZrtpNotSuppWarning ( (it->second == "true"));
 
171
 
 
172
    it = map_cpy.find (ZRTP_HELLO_HASH);
 
173
 
 
174
    if (it != details.end()) sipaccount->setZrtpHelloHash ( (it->second == "true"));
 
175
 
 
176
    it = map_cpy.find (ZRTP_DISPLAY_SAS_ONCE);
 
177
 
 
178
    if (it != details.end()) sipaccount->setZrtpDiaplaySasOnce ( (it->second == "true"));
 
179
 
 
180
    setTlsSettings (details);
 
181
 
 
182
    Manager::instance().saveConfig();
 
183
 
 
184
    // Update account details to the client side
 
185
    accountsChanged();
 
186
 
 
187
    // Reload account settings from config
 
188
    Manager::instance().getAccount (IP2IP_PROFILE)->loadConfig();
 
189
 
 
190
}
 
191
 
 
192
std::map<std::string, std::string> ConfigurationManager::getTlsSettings()
 
193
{
 
194
 
 
195
    std::map<std::string, std::string> tlsSettings;
 
196
 
 
197
    SIPAccount *sipaccount = (SIPAccount *) Manager::instance().getAccount (IP2IP_PROFILE);
 
198
 
 
199
    if (!sipaccount)
 
200
        return tlsSettings;
 
201
 
 
202
    std::stringstream portstr;
 
203
    portstr << sipaccount->getTlsListenerPort();
 
204
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_LISTENER_PORT, portstr.str()));
 
205
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_ENABLE, sipaccount->getTlsEnable()));
 
206
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_CA_LIST_FILE, sipaccount->getTlsCaListFile()));
 
207
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_CERTIFICATE_FILE, sipaccount->getTlsCertificateFile()));
 
208
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_PRIVATE_KEY_FILE, sipaccount->getTlsPrivateKeyFile()));
 
209
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_PASSWORD, sipaccount->getTlsPassword()));
 
210
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_METHOD, sipaccount->getTlsMethod()));
 
211
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_CIPHERS, sipaccount->getTlsCiphers()));
 
212
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_SERVER_NAME, sipaccount->getTlsServerName()));
 
213
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_VERIFY_SERVER, sipaccount->getTlsVerifyServer() ? "true" : "false"));
 
214
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_VERIFY_CLIENT, sipaccount->getTlsVerifyClient() ? "true" : "false"));
 
215
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_REQUIRE_CLIENT_CERTIFICATE, sipaccount->getTlsRequireClientCertificate() ? "true" : "false"));
 
216
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_NEGOTIATION_TIMEOUT_SEC, sipaccount->getTlsNegotiationTimeoutSec()));
 
217
    tlsSettings.insert (std::pair<std::string, std::string> (TLS_NEGOTIATION_TIMEOUT_MSEC, sipaccount->getTlsNegotiationTimeoutMsec()));
 
218
 
 
219
    return tlsSettings;
 
220
}
 
221
 
 
222
void ConfigurationManager::setTlsSettings (const std::map<std::string, std::string>& details)
 
223
{
 
224
 
 
225
    std::map<std::string, std::string> map_cpy = details;
 
226
    std::map<std::string, std::string>::iterator it;
 
227
 
 
228
    SIPAccount * sipaccount = (SIPAccount *) Manager::instance().getAccount (IP2IP_PROFILE);
 
229
 
 
230
    if (!sipaccount) {
 
231
        _debug ("ConfigurationManager: Error: No valid account in set TLS settings");
 
232
        return;
 
233
    }
 
234
 
 
235
    it = map_cpy.find (TLS_LISTENER_PORT);
 
236
 
 
237
    if (it != details.end()) sipaccount->setTlsListenerPort (atoi (it->second.data()));
 
238
 
 
239
    it = map_cpy.find (TLS_ENABLE);
 
240
 
 
241
    if (it != details.end()) sipaccount->setTlsEnable (it->second);
 
242
 
 
243
    it = map_cpy.find (TLS_CA_LIST_FILE);
 
244
 
 
245
    if (it != map_cpy.end()) sipaccount->setTlsCaListFile (it->second);
 
246
 
 
247
    it = map_cpy.find (TLS_CERTIFICATE_FILE);
 
248
 
 
249
    if (it != map_cpy.end()) sipaccount->setTlsCertificateFile (it->second);
 
250
 
 
251
    it = map_cpy.find (TLS_PRIVATE_KEY_FILE);
 
252
 
 
253
    if (it != map_cpy.end()) sipaccount->setTlsPrivateKeyFile (it->second);
 
254
 
 
255
    it = map_cpy.find (TLS_PASSWORD);
 
256
 
 
257
    if (it != map_cpy.end()) sipaccount->setTlsPassword (it->second);
 
258
 
 
259
    it = map_cpy.find (TLS_METHOD);
 
260
 
 
261
    if (it != map_cpy.end()) sipaccount->setTlsMethod (it->second);
 
262
 
 
263
    it = map_cpy.find (TLS_CIPHERS);
 
264
 
 
265
    if (it != map_cpy.end()) sipaccount->setTlsCiphers (it->second);
 
266
 
 
267
    it = map_cpy.find (TLS_SERVER_NAME);
 
268
 
 
269
    if (it != map_cpy.end()) sipaccount->setTlsServerName (it->second);
 
270
 
 
271
    it = map_cpy.find (TLS_VERIFY_CLIENT);
 
272
 
 
273
    if (it != map_cpy.end()) sipaccount->setTlsVerifyClient ( (it->second == "true") ? true : false);
 
274
 
 
275
    it = map_cpy.find (TLS_REQUIRE_CLIENT_CERTIFICATE);
 
276
 
 
277
    if (it != map_cpy.end()) sipaccount->setTlsRequireClientCertificate ( (it->second == "true") ? true : false);
 
278
 
 
279
    it = map_cpy.find (TLS_NEGOTIATION_TIMEOUT_SEC);
 
280
 
 
281
    if (it != map_cpy.end()) sipaccount->setTlsNegotiationTimeoutSec (it->second);
 
282
 
 
283
    it = map_cpy.find (TLS_NEGOTIATION_TIMEOUT_MSEC);
 
284
 
 
285
    if (it != map_cpy.end()) sipaccount->setTlsNegotiationTimeoutMsec (it->second);
 
286
 
 
287
    Manager::instance().saveConfig();
 
288
 
 
289
    // Update account details to the client side
 
290
    accountsChanged();
 
291
 
 
292
}
 
293
 
 
294
std::map<std::string, std::string> ConfigurationManager::getCredential (
 
295
    const std::string& accountID, const int32_t& index)
 
296
{
 
297
 
 
298
    Account *account = Manager::instance().getAccount (accountID);
 
299
 
 
300
    std::map<std::string, std::string> credentialInformation;
 
301
 
 
302
    if (account->getType() != "SIP")
 
303
        return credentialInformation;
 
304
 
 
305
    SIPAccount *sipaccount = (SIPAccount *) account;
 
306
 
 
307
 
 
308
    if (index == 0) {
 
309
        std::string username = sipaccount->getUsername();
 
310
        std::string password = sipaccount->getPassword();
 
311
        std::string realm = sipaccount->getRealm();
 
312
 
 
313
        credentialInformation.insert (std::pair<std::string, std::string> (USERNAME, username));
 
314
        credentialInformation.insert (std::pair<std::string, std::string> (PASSWORD, password));
 
315
        credentialInformation.insert (std::pair<std::string, std::string> (REALM, realm));
 
316
    } else {
 
317
 
 
318
        // TODO: implement for extra credentials
 
319
        std::string username = sipaccount->getUsername();
 
320
        std::string password = sipaccount->getPassword();
 
321
        std::string realm = sipaccount->getRealm();
 
322
 
 
323
        credentialInformation.insert (std::pair<std::string, std::string> (USERNAME, username));
 
324
        credentialInformation.insert (std::pair<std::string, std::string> (PASSWORD, password));
 
325
        credentialInformation.insert (std::pair<std::string, std::string> (REALM, realm));
 
326
    }
 
327
 
 
328
    return credentialInformation;
 
329
}
 
330
 
 
331
int32_t ConfigurationManager::getNumberOfCredential (
 
332
    const std::string& accountID)
 
333
{
 
334
 
 
335
    Account *account = Manager::instance().getAccount (accountID);
 
336
 
 
337
    if (!account)
 
338
        return 0;
 
339
 
 
340
    if (account->getType() == "SIP") {
 
341
        SIPAccount *sipaccount = static_cast<SIPAccount *> (account);
 
342
        return sipaccount->getCredentialCount();
 
343
    } else
 
344
        return 0;
 
345
}
 
346
 
 
347
void ConfigurationManager::setCredential (const std::string& accountID,
 
348
        const int32_t& index, const std::map<std::string, std::string>& details)
 
349
{
 
350
    Manager::instance().setCredential (accountID, index, details);
 
351
}
 
352
 
 
353
void ConfigurationManager::deleteAllCredential (const std::string& accountID)
 
354
{
 
355
    Manager::instance().deleteAllCredential (accountID);
 
356
}
 
357
 
 
358
void ConfigurationManager::setAccountDetails (const std::string& accountID,
 
359
        const std::map<std::string, std::string>& details)
 
360
{
 
361
    Manager::instance().setAccountDetails (accountID, details);
 
362
}
 
363
 
 
364
void ConfigurationManager::sendRegister (const std::string& accountID,
 
365
        const int32_t& expire)
 
366
{
 
367
    Manager::instance().sendRegister (accountID, expire);
 
368
}
 
369
 
 
370
std::string ConfigurationManager::addAccount (const std::map<std::string,
 
371
        std::string>& details)
 
372
{
 
373
    return Manager::instance().addAccount (details);
 
374
}
 
375
 
 
376
void ConfigurationManager::removeAccount (const std::string& accoundID)
 
377
{
 
378
    return Manager::instance().removeAccount (accoundID);
 
379
}
 
380
 
 
381
std::vector<std::string> ConfigurationManager::getAccountList()
 
382
{
 
383
    return Manager::instance().getAccountList();
 
384
}
 
385
 
 
386
//TODO
 
387
std::vector<std::string> ConfigurationManager::getToneLocaleList()
 
388
{
 
389
    std::vector<std::string> ret;
 
390
    return ret;
 
391
}
 
392
 
 
393
//TODO
 
394
std::string ConfigurationManager::getVersion()
 
395
{
 
396
    std::string ret ("");
 
397
    return ret;
 
398
}
 
399
 
 
400
//TODO
 
401
std::vector<std::string> ConfigurationManager::getRingtoneList()
 
402
{
 
403
    std::vector<std::string> ret;
 
404
    return ret;
432
405
}
433
406
 
434
407
/**
435
408
 * Send the list of all codecs loaded to the client through DBus.
436
409
 * Can stay global, as only the active codecs will be set per accounts
437
410
 */
438
 
std::vector<std::string> ConfigurationManager::getCodecList(void) {
439
 
 
440
 
        std::vector<std::string> list;
441
 
 
442
 
        CodecsMap codecs =
443
 
                        Manager::instance().getCodecDescriptorMap().getCodecsMap();
444
 
        CodecsMap::iterator iter = codecs.begin();
445
 
 
446
 
        while (iter != codecs.end()) {
447
 
                std::stringstream ss;
448
 
 
449
 
                if (iter->second != NULL) {
450
 
                        ss << iter->first;
451
 
                        list.push_back((ss.str()).data());
452
 
                }
453
 
 
454
 
                iter++;
455
 
        }
456
 
 
457
 
        return list;
458
 
}
459
 
 
460
 
std::vector<std::string> ConfigurationManager::getSupportedTlsMethod(void) {
461
 
        std::vector<std::string> method;
462
 
        method.push_back("Default");
463
 
        method.push_back("TLSv1");
464
 
        method.push_back("SSLv2");
465
 
        method.push_back("SSLv3");
466
 
        method.push_back("SSLv23");
467
 
        return method;
468
 
}
469
 
 
470
 
std::vector<std::string> ConfigurationManager::getCodecDetails(
471
 
                const int32_t& payload) {
472
 
 
473
 
        return Manager::instance().getCodecDescriptorMap().getCodecSpecifications(
474
 
                        payload);
475
 
}
476
 
 
477
 
std::vector<std::string> ConfigurationManager::getActiveCodecList(
478
 
                const std::string& accountID) {
479
 
 
480
 
        _debug("Send active codec list for account %s", accountID.c_str ());
481
 
 
482
 
        std::vector<std::string> v;
483
 
        Account *acc;
484
 
        CodecOrder active;
485
 
        unsigned int i = 0;
486
 
        size_t size;
487
 
 
488
 
        acc = Manager::instance().getAccount(accountID);
489
 
        if (acc != NULL) {
490
 
                active = acc->getActiveCodecs();
491
 
                size = active.size();
492
 
                while (i < size) {
493
 
                        std::stringstream ss;
494
 
                        ss << active[i];
495
 
                        v.push_back((ss.str()).data());
496
 
                        i++;
497
 
                }
498
 
        }
499
 
 
500
 
        return v;
501
 
 
502
 
}
503
 
 
504
 
void ConfigurationManager::setActiveCodecList(
505
 
                const std::vector<std::string>& list, const std::string& accountID) {
506
 
 
507
 
        _debug ("ConfigurationManager: Active codec list received");
508
 
 
509
 
        Account *acc;
510
 
 
511
 
        // Save the codecs list per account
512
 
        acc = Manager::instance().getAccount(accountID);
513
 
        if (acc != NULL) {
514
 
                acc->setActiveCodecs(list);
515
 
        }
516
 
}
517
 
 
518
 
 
519
 
// Audio devices related methods
520
 
std::vector<std::string> ConfigurationManager::getInputAudioPluginList() {
521
 
 
522
 
        _debug("ConfigurationManager: Active codec list received");
523
 
 
524
 
        std::vector<std::string> v;
525
 
 
526
 
        v.push_back("default");
527
 
        v.push_back("surround40");
528
 
        v.push_back("plug:hw");
529
 
 
530
 
        return v;
531
 
}
532
 
 
533
 
 
534
 
 
535
 
std::vector<std::string> ConfigurationManager::getOutputAudioPluginList() {
536
 
 
537
 
        std::vector<std::string> v;
538
 
 
539
 
        v.push_back(PCM_DEFAULT);
540
 
        v.push_back(PCM_DMIX);
541
 
 
542
 
        return v;
543
 
}
544
 
 
545
 
 
546
 
void ConfigurationManager::setInputAudioPlugin(const std::string& audioPlugin) {
547
 
        return Manager::instance().setInputAudioPlugin(audioPlugin);
548
 
}
549
 
 
550
 
void ConfigurationManager::setOutputAudioPlugin(const std::string& audioPlugin) {
551
 
        return Manager::instance().setOutputAudioPlugin(audioPlugin);
552
 
}
553
 
 
554
 
std::vector<std::string> ConfigurationManager::getAudioOutputDeviceList() {
555
 
        return Manager::instance().getAudioOutputDeviceList();
556
 
}
557
 
 
558
 
void ConfigurationManager::setAudioOutputDevice(const int32_t& index) {
559
 
        return Manager::instance().setAudioOutputDevice(index);
560
 
}
561
 
 
562
 
std::vector<std::string> ConfigurationManager::getAudioInputDeviceList() {
563
 
        return Manager::instance().getAudioInputDeviceList();
564
 
}
565
 
 
566
 
void ConfigurationManager::setAudioInputDevice(const int32_t& index) {
567
 
        return Manager::instance().setAudioInputDevice(index);
568
 
}
569
 
 
570
 
std::vector<std::string> ConfigurationManager::getCurrentAudioDevicesIndex() {
571
 
        return Manager::instance().getCurrentAudioDevicesIndex();
572
 
}
573
 
 
574
 
int32_t ConfigurationManager::getAudioDeviceIndex(const std::string& name) {
575
 
        return Manager::instance().getAudioDeviceIndex(name);
576
 
}
577
 
 
578
 
std::string ConfigurationManager::getCurrentAudioOutputPlugin(void) {
579
 
        return Manager::instance().getCurrentAudioOutputPlugin();
580
 
}
581
 
 
582
 
std::vector<std::string> ConfigurationManager::getPlaybackDeviceList() {
583
 
        std::vector<std::string> ret;
584
 
        return ret;
585
 
}
586
 
 
587
 
std::vector<std::string> ConfigurationManager::getRecordDeviceList() {
588
 
        std::vector<std::string> ret;
589
 
        return ret;
590
 
 
591
 
}
592
 
 
593
 
bool ConfigurationManager::isMd5CredentialHashing(void) {
594
 
        bool isEnabled = Manager::instance().getConfigBool(PREFERENCES,
595
 
                        CONFIG_MD5HASH);
596
 
        return isEnabled;
597
 
}
598
 
 
599
 
void ConfigurationManager::setMd5CredentialHashing(const bool& enabled) {
600
 
        if (enabled) {
601
 
                Manager::instance().setConfig(PREFERENCES, CONFIG_MD5HASH, TRUE_STR);
602
 
        } else {
603
 
                Manager::instance().setConfig(PREFERENCES, CONFIG_MD5HASH, FALSE_STR);
604
 
        }
605
 
}
606
 
 
607
 
int32_t ConfigurationManager::isIax2Enabled(void) {
608
 
        return Manager::instance().isIax2Enabled();
609
 
}
610
 
 
611
 
void ConfigurationManager::ringtoneEnabled(void) {
612
 
        Manager::instance().ringtoneEnabled();
613
 
}
614
 
 
615
 
int32_t ConfigurationManager::isRingtoneEnabled(void) {
616
 
        return Manager::instance().isRingtoneEnabled();
617
 
}
618
 
 
619
 
std::string ConfigurationManager::getRingtoneChoice(void) {
620
 
        return Manager::instance().getRingtoneChoice();
621
 
}
622
 
 
623
 
void ConfigurationManager::setRingtoneChoice(const std::string& tone) {
624
 
        Manager::instance().setRingtoneChoice(tone);
625
 
}
626
 
 
627
 
std::string ConfigurationManager::getRecordPath(void) {
628
 
        return Manager::instance().getRecordPath();
629
 
}
630
 
 
631
 
void ConfigurationManager::setRecordPath(const std::string& recPath) {
632
 
        Manager::instance().setRecordPath(recPath);
633
 
}
634
 
 
 
411
std::vector<std::string> ConfigurationManager::getCodecList (void)
 
412
{
 
413
 
 
414
    std::vector<std::string> list;
 
415
 
 
416
    CodecsMap codecs = Manager::instance().getCodecDescriptorMap().getCodecsMap();
 
417
    CodecsMap::iterator iter = codecs.begin();
 
418
 
 
419
    while (iter != codecs.end()) {
 
420
        std::stringstream ss;
 
421
 
 
422
        if (iter->second != NULL) {
 
423
            ss << iter->first;
 
424
            list.push_back ( (ss.str()).data());
 
425
        }
 
426
 
 
427
        iter++;
 
428
    }
 
429
 
 
430
    return list;
 
431
}
 
432
 
 
433
std::vector<std::string> ConfigurationManager::getSupportedTlsMethod (void)
 
434
{
 
435
    std::vector<std::string> method;
 
436
    method.push_back ("Default");
 
437
    method.push_back ("TLSv1");
 
438
    method.push_back ("SSLv2");
 
439
    method.push_back ("SSLv3");
 
440
    method.push_back ("SSLv23");
 
441
    return method;
 
442
}
 
443
 
 
444
std::vector<std::string> ConfigurationManager::getCodecDetails (
 
445
    const int32_t& payload)
 
446
{
 
447
 
 
448
    return Manager::instance().getCodecDescriptorMap().getCodecSpecifications (
 
449
               payload);
 
450
}
 
451
 
 
452
std::vector<std::string> ConfigurationManager::getActiveCodecList (
 
453
    const std::string& accountID)
 
454
{
 
455
 
 
456
    _debug ("Send active codec list for account %s", accountID.c_str ());
 
457
 
 
458
    std::vector<std::string> v;
 
459
    Account *acc;
 
460
    CodecOrder active;
 
461
    unsigned int i = 0;
 
462
    size_t size;
 
463
 
 
464
    acc = Manager::instance().getAccount (accountID);
 
465
 
 
466
    if (acc != NULL) {
 
467
        active = acc->getActiveCodecs();
 
468
        size = active.size();
 
469
 
 
470
        while (i < size) {
 
471
            std::stringstream ss;
 
472
            ss << active[i];
 
473
            v.push_back ( (ss.str()).data());
 
474
            i++;
 
475
        }
 
476
    }
 
477
 
 
478
    return v;
 
479
 
 
480
}
 
481
 
 
482
void ConfigurationManager::setActiveCodecList (
 
483
    const std::vector<std::string>& list, const std::string& accountID)
 
484
{
 
485
 
 
486
    _debug ("ConfigurationManager: Active codec list received");
 
487
 
 
488
    Account *acc;
 
489
 
 
490
    // Save the codecs list per account
 
491
    acc = Manager::instance().getAccount (accountID);
 
492
 
 
493
    if (acc != NULL) {
 
494
        acc->setActiveCodecs (list);
 
495
    }
 
496
}
 
497
 
 
498
 
 
499
std::vector<std::string> ConfigurationManager::getAudioPluginList()
 
500
{
 
501
 
 
502
    std::vector<std::string> v;
 
503
 
 
504
    v.push_back (PCM_DEFAULT);
 
505
    // v.push_back(PCM_DMIX);
 
506
    v.push_back (PCM_DMIX_DSNOOP);
 
507
 
 
508
    return v;
 
509
}
 
510
 
 
511
 
 
512
void ConfigurationManager::setAudioPlugin (const std::string& audioPlugin)
 
513
{
 
514
    _debug ("ConfigurationManager: Set audio plugin %s", audioPlugin.c_str());
 
515
 
 
516
    return Manager::instance().setAudioPlugin (audioPlugin);
 
517
}
 
518
 
 
519
std::vector<std::string> ConfigurationManager::getAudioOutputDeviceList()
 
520
{
 
521
    return Manager::instance().getAudioOutputDeviceList();
 
522
}
 
523
 
 
524
std::vector<std::string> ConfigurationManager::getAudioInputDeviceList()
 
525
{
 
526
    return Manager::instance().getAudioInputDeviceList();
 
527
}
 
528
 
 
529
void ConfigurationManager::setAudioOutputDevice (const int32_t& index)
 
530
{
 
531
    return Manager::instance().setAudioDevice (index, SFL_PCM_PLAYBACK);
 
532
}
 
533
 
 
534
void ConfigurationManager::setAudioInputDevice (const int32_t& index)
 
535
{
 
536
    return Manager::instance().setAudioDevice (index, SFL_PCM_CAPTURE);
 
537
}
 
538
 
 
539
void ConfigurationManager::setAudioRingtoneDevice (const int32_t& index)
 
540
{
 
541
    return Manager::instance().setAudioDevice (index, SFL_PCM_RINGTONE);
 
542
}
 
543
 
 
544
std::vector<std::string> ConfigurationManager::getCurrentAudioDevicesIndex()
 
545
{
 
546
    return Manager::instance().getCurrentAudioDevicesIndex();
 
547
}
 
548
 
 
549
int32_t ConfigurationManager::getAudioDeviceIndex (const std::string& name)
 
550
{
 
551
    return Manager::instance().getAudioDeviceIndex (name);
 
552
}
 
553
 
 
554
std::string ConfigurationManager::getCurrentAudioOutputPlugin (void)
 
555
{
 
556
    _debug ("ConfigurationManager: Get audio plugin %s", Manager::instance().getCurrentAudioOutputPlugin().c_str());
 
557
 
 
558
    return Manager::instance().getCurrentAudioOutputPlugin();
 
559
}
 
560
 
 
561
std::string ConfigurationManager::getNoiseSuppressState (void)
 
562
{
 
563
    return Manager::instance().getNoiseSuppressState();
 
564
}
 
565
 
 
566
void ConfigurationManager::setNoiseSuppressState (const std::string& state)
 
567
{
 
568
    Manager::instance().setNoiseSuppressState (state);
 
569
}
 
570
 
 
571
std::vector<std::string> ConfigurationManager::getPlaybackDeviceList()
 
572
{
 
573
    std::vector<std::string> ret;
 
574
    return ret;
 
575
}
 
576
 
 
577
std::vector<std::string> ConfigurationManager::getRecordDeviceList()
 
578
{
 
579
    std::vector<std::string> ret;
 
580
    return ret;
 
581
 
 
582
}
 
583
 
 
584
bool ConfigurationManager::isMd5CredentialHashing (void)
 
585
{
 
586
    return Manager::instance().preferences.getMd5Hash();
 
587
}
 
588
 
 
589
void ConfigurationManager::setMd5CredentialHashing (const bool& enabled)
 
590
{
 
591
    Manager::instance().preferences.setMd5Hash (enabled);
 
592
}
 
593
 
 
594
int32_t ConfigurationManager::isIax2Enabled (void)
 
595
{
 
596
    return Manager::instance().isIax2Enabled();
 
597
}
 
598
 
 
599
void ConfigurationManager::ringtoneEnabled (const std::string& accountID)
 
600
{
 
601
    Manager::instance().ringtoneEnabled (accountID);
 
602
}
 
603
 
 
604
int32_t ConfigurationManager::isRingtoneEnabled (const std::string& accountID)
 
605
{
 
606
    return Manager::instance().isRingtoneEnabled (accountID);
 
607
}
 
608
 
 
609
std::string ConfigurationManager::getRingtoneChoice (const std::string& accountID)
 
610
{
 
611
    return Manager::instance().getRingtoneChoice (accountID);
 
612
}
 
613
 
 
614
void ConfigurationManager::setRingtoneChoice (const std::string& accountID, const std::string& tone)
 
615
{
 
616
    Manager::instance().setRingtoneChoice (accountID, tone);
 
617
}
 
618
 
 
619
std::string ConfigurationManager::getRecordPath (void)
 
620
{
 
621
    return Manager::instance().getRecordPath();
 
622
}
 
623
 
 
624
void ConfigurationManager::setRecordPath (const std::string& recPath)
 
625
{
 
626
    Manager::instance().setRecordPath (recPath);
 
627
}
 
628
 
 
629
/*
635
630
int32_t ConfigurationManager::getDialpad(void) {
636
631
        return Manager::instance().getDialpad();
637
632
}
655
650
void ConfigurationManager::setVolumeControls(const bool& display) {
656
651
        Manager::instance().setVolumeControls(display);
657
652
}
658
 
 
659
 
int32_t ConfigurationManager::getHistoryLimit(void) {
660
 
        return Manager::instance().getHistoryLimit();
661
 
}
662
 
 
663
 
void ConfigurationManager::setHistoryLimit(const int32_t& days) {
664
 
        Manager::instance().setHistoryLimit(days);
665
 
}
666
 
 
 
653
*/
 
654
 
 
655
int32_t ConfigurationManager::getHistoryLimit (void)
 
656
{
 
657
    return Manager::instance().getHistoryLimit();
 
658
}
 
659
 
 
660
void ConfigurationManager::setHistoryLimit (const int32_t& days)
 
661
{
 
662
    Manager::instance().setHistoryLimit (days);
 
663
}
 
664
 
 
665
/*
667
666
void ConfigurationManager::setHistoryEnabled(void) {
668
667
        Manager::instance().setHistoryEnabled();
669
668
}
695
694
int32_t ConfigurationManager::getNotify(void) {
696
695
        return Manager::instance().getNotify();
697
696
}
698
 
 
699
 
void ConfigurationManager::setAudioManager(const int32_t& api) {
700
 
        Manager::instance().setAudioManager(api);
701
 
}
702
 
 
703
 
int32_t ConfigurationManager::getAudioManager(void) {
704
 
        return Manager::instance().getAudioManager();
705
 
}
706
 
 
707
 
void ConfigurationManager::setMailNotify(void) {
708
 
        Manager::instance().setMailNotify();
709
 
}
710
 
 
711
 
int32_t ConfigurationManager::getMailNotify(void) {
712
 
        return Manager::instance().getMailNotify();
713
 
}
714
 
 
715
 
std::map<std::string, int32_t> ConfigurationManager::getAddressbookSettings(
716
 
                void) {
717
 
        return Manager::instance().getAddressbookSettings();
718
 
}
719
 
 
720
 
void ConfigurationManager::setAddressbookSettings(const std::map<std::string,
721
 
                int32_t>& settings) {
722
 
        Manager::instance().setAddressbookSettings(settings);
723
 
}
724
 
 
725
 
std::vector<std::string> ConfigurationManager::getAddressbookList(void) {
726
 
        return Manager::instance().getAddressbookList();
727
 
}
728
 
 
729
 
void ConfigurationManager::setAddressbookList(
730
 
                const std::vector<std::string>& list) {
731
 
        Manager::instance().setAddressbookList(list);
732
 
}
733
 
 
734
 
std::map<std::string, std::string> ConfigurationManager::getHookSettings(void) {
735
 
        return Manager::instance().getHookSettings();
736
 
}
737
 
 
738
 
void ConfigurationManager::setHookSettings(const std::map<std::string,
739
 
                std::string>& settings) {
740
 
        Manager::instance().setHookSettings(settings);
741
 
}
742
 
 
743
 
void ConfigurationManager::setAccountsOrder(const std::string& order) {
744
 
        Manager::instance().setAccountsOrder(order);
745
 
}
746
 
 
747
 
std::map<std::string, std::string> ConfigurationManager::getHistory(void) {
748
 
        return Manager::instance().send_history_to_client();
749
 
}
750
 
 
751
 
void ConfigurationManager::setHistory(
752
 
                const std::map<std::string, std::string>& entries) {
753
 
        Manager::instance().receive_history_from_client(entries);
754
 
}
755
 
 
756
 
std::string ConfigurationManager::getAddrFromInterfaceName(
757
 
                const std::string& interface) {
758
 
 
759
 
        std::string address = SIPVoIPLink::instance("")->getInterfaceAddrFromName(
760
 
                        interface);
761
 
 
762
 
        return address;
763
 
}
764
 
 
765
 
std::vector<std::string> ConfigurationManager::getAllIpInterface(void) {
766
 
 
767
 
        std::vector<std::string> vector;
768
 
        SIPVoIPLink * sipLink = NULL;
769
 
        sipLink = SIPVoIPLink::instance("");
770
 
 
771
 
        if (sipLink != NULL) {
772
 
                vector = sipLink->getAllIpInterface();
773
 
        }
774
 
 
775
 
        return vector;
776
 
}
777
 
 
778
 
std::vector<std::string> ConfigurationManager::getAllIpInterfaceByName(void) {
779
 
        std::vector<std::string> vector;
780
 
        SIPVoIPLink * sipLink = NULL;
781
 
        sipLink = SIPVoIPLink::instance("");
782
 
 
783
 
        if (sipLink != NULL) {
784
 
                vector = sipLink->getAllIpInterfaceByName();
785
 
        }
786
 
 
787
 
        return vector;
788
 
}
789
 
 
790
 
int32_t ConfigurationManager::getWindowWidth(void) {
791
 
 
792
 
        return Manager::instance().getConfigInt(PREFERENCES, WINDOW_WIDTH);
793
 
}
794
 
 
795
 
int32_t ConfigurationManager::getWindowHeight(void) {
796
 
 
797
 
        return Manager::instance().getConfigInt(PREFERENCES, WINDOW_HEIGHT);
798
 
}
799
 
 
800
 
void ConfigurationManager::setWindowWidth(const int32_t& width) {
801
 
 
802
 
        Manager::instance().setConfig(PREFERENCES, WINDOW_WIDTH, width);
803
 
}
804
 
 
805
 
void ConfigurationManager::setWindowHeight(const int32_t& height) {
806
 
 
807
 
        Manager::instance().setConfig(PREFERENCES, WINDOW_HEIGHT, height);
808
 
}
809
 
 
810
 
int32_t ConfigurationManager::getWindowPositionX(void) {
811
 
 
812
 
        return Manager::instance().getConfigInt(PREFERENCES, WINDOW_POSITION_X);
813
 
}
814
 
 
815
 
int32_t ConfigurationManager::getWindowPositionY(void) {
816
 
 
817
 
        return Manager::instance().getConfigInt(PREFERENCES, WINDOW_POSITION_Y);
818
 
}
819
 
 
820
 
void ConfigurationManager::setWindowPositionX(const int32_t& posX) {
821
 
 
822
 
        Manager::instance().setConfig(PREFERENCES, WINDOW_POSITION_X, posX);
823
 
}
824
 
 
825
 
void ConfigurationManager::setWindowPositionY(const int32_t& posY) {
826
 
 
827
 
        Manager::instance().setConfig(PREFERENCES, WINDOW_POSITION_Y, posY);
828
 
}
829
 
 
830
 
std::map<std::string, int32_t> ConfigurationManager::getShortcuts() {
831
 
 
832
 
        std::map<std::string, int> shortcutsMap;
833
 
        int shortcut;
834
 
 
835
 
        for (int i = 0; i < (int)shortcutsKeys.size(); i++) {
836
 
                std::string key = shortcutsKeys.at(i);
837
 
                shortcut = Manager::instance().getConfigInt("Shortcuts", key);
838
 
                shortcutsMap.insert(std::pair<std::string, int>(key, shortcut));
839
 
        }
840
 
 
841
 
        return shortcutsMap;
842
 
}
843
 
 
844
 
void ConfigurationManager::setShortcuts(
845
 
                const std::map<std::string, int32_t>& shortcutsMap) {
846
 
 
847
 
        std::map<std::string, int> map_cpy = shortcutsMap;
848
 
        std::map<std::string, int>::iterator it;
849
 
 
850
 
        for (int i = 0; i < (int)shortcutsKeys.size(); i++) {
851
 
                std::string key = shortcutsKeys.at(i);
852
 
                it = map_cpy.find(key);
853
 
                if (it != shortcutsMap.end()) {
854
 
                        Manager::instance().setConfig("Shortcuts", key, it->second);
855
 
                }
856
 
        }
857
 
 
858
 
        Manager::instance().saveConfig();
859
 
}
860
 
 
861
 
void ConfigurationManager::enableStatusIcon (const std::string& value) {
862
 
 
863
 
        Manager::instance ().setConfig (PREFERENCES, SHOW_STATUSICON, value);
864
 
}
865
 
 
866
 
std::string ConfigurationManager::isStatusIconEnabled (void) {
867
 
 
868
 
        return Manager::instance ().getConfigString (PREFERENCES, SHOW_STATUSICON);
869
 
}
 
697
*/
 
698
 
 
699
void ConfigurationManager::setAudioManager (const int32_t& api)
 
700
{
 
701
    Manager::instance().setAudioManager (api);
 
702
}
 
703
 
 
704
int32_t ConfigurationManager::getAudioManager (void)
 
705
{
 
706
    return Manager::instance().getAudioManager();
 
707
}
 
708
 
 
709
void ConfigurationManager::setMailNotify (void)
 
710
{
 
711
    Manager::instance().setMailNotify();
 
712
}
 
713
 
 
714
int32_t ConfigurationManager::getMailNotify (void)
 
715
{
 
716
    return Manager::instance().getMailNotify();
 
717
}
 
718
 
 
719
std::map<std::string, int32_t> ConfigurationManager::getAddressbookSettings (
 
720
    void)
 
721
{
 
722
    return Manager::instance().getAddressbookSettings();
 
723
}
 
724
 
 
725
void ConfigurationManager::setAddressbookSettings (const std::map<std::string,
 
726
        int32_t>& settings)
 
727
{
 
728
    Manager::instance().setAddressbookSettings (settings);
 
729
}
 
730
 
 
731
std::vector<std::string> ConfigurationManager::getAddressbookList (void)
 
732
{
 
733
    return Manager::instance().getAddressbookList();
 
734
}
 
735
 
 
736
void ConfigurationManager::setAddressbookList (
 
737
    const std::vector<std::string>& list)
 
738
{
 
739
    Manager::instance().setAddressbookList (list);
 
740
}
 
741
 
 
742
std::map<std::string, std::string> ConfigurationManager::getHookSettings (void)
 
743
{
 
744
    return Manager::instance().getHookSettings();
 
745
}
 
746
 
 
747
void ConfigurationManager::setHookSettings (const std::map<std::string,
 
748
        std::string>& settings)
 
749
{
 
750
    Manager::instance().setHookSettings (settings);
 
751
}
 
752
 
 
753
void ConfigurationManager::setAccountsOrder (const std::string& order)
 
754
{
 
755
    Manager::instance().setAccountsOrder (order);
 
756
}
 
757
 
 
758
std::map<std::string, std::string> ConfigurationManager::getHistory (void)
 
759
{
 
760
    return Manager::instance().send_history_to_client();
 
761
}
 
762
 
 
763
void ConfigurationManager::setHistory (
 
764
    const std::map<std::string, std::string>& entries)
 
765
{
 
766
    Manager::instance().receive_history_from_client (entries);
 
767
}
 
768
 
 
769
std::string ConfigurationManager::getAddrFromInterfaceName (
 
770
    const std::string& interface)
 
771
{
 
772
 
 
773
    std::string address = SIPVoIPLink::instance ("")->getInterfaceAddrFromName (
 
774
                              interface);
 
775
 
 
776
    return address;
 
777
}
 
778
 
 
779
std::vector<std::string> ConfigurationManager::getAllIpInterface (void)
 
780
{
 
781
 
 
782
    std::vector<std::string> vector;
 
783
    SIPVoIPLink * sipLink = NULL;
 
784
    sipLink = SIPVoIPLink::instance ("");
 
785
 
 
786
    if (sipLink != NULL) {
 
787
        vector = sipLink->getAllIpInterface();
 
788
    }
 
789
 
 
790
    return vector;
 
791
}
 
792
 
 
793
std::vector<std::string> ConfigurationManager::getAllIpInterfaceByName (void)
 
794
{
 
795
    std::vector<std::string> vector;
 
796
    SIPVoIPLink * sipLink = NULL;
 
797
    sipLink = SIPVoIPLink::instance ("");
 
798
 
 
799
    if (sipLink != NULL) {
 
800
        vector = sipLink->getAllIpInterfaceByName();
 
801
    }
 
802
 
 
803
    return vector;
 
804
}
 
805
 
 
806
 
 
807
std::map<std::string, std::string> ConfigurationManager::getShortcuts()
 
808
{
 
809
 
 
810
    return Manager::instance().shortcutPreferences.getShortcuts();
 
811
}
 
812
 
 
813
void ConfigurationManager::setShortcuts (
 
814
    const std::map<std::string, std::string>& shortcutsMap)
 
815
{
 
816
 
 
817
    std::map<std::string, std::string> map_cpy = shortcutsMap;
 
818
    /*
 
819
      std::map<std::string, std::string> map_cpy = shortcutsMap;
 
820
      std::map<std::string, std::string>::iterator it;
 
821
 
 
822
      for (int i = 0; i < (int)shortcutsKeys.size(); i++) {
 
823
        std::string key = shortcutsKeys.at(i);
 
824
        it = map_cpy.find(key);
 
825
        if (it != shortcutsMap.end()) {
 
826
 
 
827
                Manager::instance().setConfig("Shortcuts", key, it->second);
 
828
        }
 
829
      }
 
830
    */
 
831
    Manager::instance().shortcutPreferences.setShortcuts (map_cpy);
 
832
 
 
833
    Manager::instance().saveConfig();
 
834
}
 
835