1
=== modified file 'plugins/cellular/CMakeLists.txt'
2
--- plugins/cellular/CMakeLists.txt	2015-03-26 21:57:53 +0000
3
+++ plugins/cellular/CMakeLists.txt	2015-05-18 15:06:15 +0000
4
@@ -6,6 +6,7 @@
5
6
set(QML_SOURCES
6
set(QML_SOURCES
6
7
    apn.js
7
    apn.js
7
8
    carriers.js
8
    carriers.js
8
9
    Common.qml
9
9
    CustomApnEditor.qml
10
    CustomApnEditor.qml
10
10
    PageChooseApn.qml
11
    PageChooseApn.qml
11
11
    PageChooseCarrier.qml
12
    PageChooseCarrier.qml
12
12
13
13
=== added file 'plugins/cellular/Common.qml'
14
--- plugins/cellular/Common.qml	1970-01-01 00:00:00 +0000
15
+++ plugins/cellular/Common.qml	2015-05-18 15:06:15 +0000
16
@@ -0,0 +1,97 @@
17
1
/*
18
2
 * Copyright (C) 2015 Canonical Ltd
19
3
 *
20
4
 * This program is free software: you can redistribute it and/or modify
21
5
 * it under the terms of the GNU General Public License version 3 as
22
6
 * published by the Free Software Foundation.
23
7
 *
24
8
 * This program is distributed in the hope that it will be useful,
25
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27
11
 * GNU General Public License for more details.
28
12
 *
29
13
 * You should have received a copy of the GNU General Public License
30
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
31
15
 *
32
16
 * Authors:
33
17
 * Jonas G. Drange <jonas.drange@canonical.com>
34
18
 *
35
19
*/
36
20
import QtQuick 2.0
37
21
38
22
Item {
39
23
    /*
40
24
        The mapping of code to string is taken from
41
25
        http://bazaar.launchpad.net/~vcs-imports/
42
26
            network-manager/trunk/view/head:/cli/src/common.c
43
27
44
28
        NetworkManager documentation: https://developer.gnome.org/
45
29
            NetworkManager/0.9/spec.html#type-NM_DEVICE_STATE_REASON
46
30
    */
47
31
    function reasonToString (reason) {
48
32
        switch (reason) {
49
33
            case 0:
50
34
                return i18n.tr("Unknown error");
51
35
            case 1:
52
36
                return i18n.tr("No reason given");
53
37
            case 2:
54
38
                return i18n.tr("Device is now managed");
55
39
            case 3:
56
40
                return i18n.tr("Device is now unmanaged");
57
41
            case 4:
58
42
                return i18n.tr("The device could not be readied for configuration");
59
43
            case 5:
60
44
                return i18n.tr("IP configuration could not be reserved (no available address, timeout, etc.)");
61
45
            case 6:
62
46
                return i18n.tr("The IP configuration is no longer valid");
63
47
            case 7:
64
48
                return i18n.tr("Your authentication details were incorrect");
65
49
            case 8:
66
50
                return i18n.tr("802.1X supplicant disconnected");
67
51
            case 9:
68
52
                return i18n.tr("802.1X supplicant configuration failed");
69
53
            case 10:
70
54
                return i18n.tr("802.1X supplicant failed");
71
55
            case 11:
72
56
                return i18n.tr("802.1X supplicant took too long to authenticate");
73
57
            case 15:
74
58
                return i18n.tr("DHCP client failed to start");
75
59
            case 16:
76
60
                return i18n.tr("DHCP client error");
77
61
            case 17:
78
62
                return i18n.tr("DHCP client failed");
79
63
            case 18:
80
64
                return i18n.tr("Shared connection service failed to start");
81
65
            case 19:
82
66
                return i18n.tr("Shared connection service failed");
83
67
            case 35:
84
68
                return i18n.tr("Necessary firmware for the device may be missing");
85
69
            case 36:
86
70
                return i18n.tr("The device was removed");
87
71
            case 37:
88
72
                return i18n.tr("NetworkManager went to sleep");
89
73
            case 38:
90
74
                return i18n.tr("The device's active connection disappeared");
91
75
            case 39:
92
76
                return i18n.tr("Device disconnected by user or client");
93
77
            case 41:
94
78
                return i18n.tr("The device's existing connection was assumed");
95
79
            case 42:
96
80
                return i18n.tr("The supplicant is now available");
97
81
            case 43:
98
82
                return i18n.tr("The modem could not be found");
99
83
            case 44:
100
84
                return i18n.tr("The Bluetooth connection failed or timed out");
101
85
            case 50:
102
86
                return i18n.tr("A dependency of the connection failed");
103
87
            case 52:
104
88
                return i18n.tr("ModemManager is unavailable");
105
89
            case 53:
106
90
                return i18n.tr("The Wi-Fi network could not be found");
107
91
            case 54:
108
92
                return i18n.tr("A secondary connection of the base connection failed");
109
93
            default:
110
94
                return i18n.tr("Unknown");
111
95
        }
112
96
    }
113
97
}
114
0
98
115
=== modified file 'plugins/cellular/Components/MultiSim.qml'
116
--- plugins/cellular/Components/MultiSim.qml	2015-01-21 20:44:20 +0000
117
+++ plugins/cellular/Components/MultiSim.qml	2015-05-18 15:06:15 +0000
118
@@ -22,6 +22,7 @@
119
22
import SystemSettings 1.0
22
import SystemSettings 1.0
120
23
import Ubuntu.Components 0.1
23
import Ubuntu.Components 0.1
121
24
import Ubuntu.Components.ListItems 0.1 as ListItem
24
import Ubuntu.Components.ListItems 0.1 as ListItem
122
25
import Ubuntu.SystemSettings.Update 1.0
123
25
26
124
26
Column {
27
Column {
125
27
    objectName: "multiSim"
28
    objectName: "multiSim"
126
@@ -58,9 +59,13 @@
127
58
        text: i18n.tr("Wi-Fi hotspot")
59
        text: i18n.tr("Wi-Fi hotspot")
128
59
        progression: true
60
        progression: true
129
60
        onClicked: {
61
        onClicked: {
131
61
            pageStack.push(Qt.resolvedUrl("Hotspot.qml"))
62
            pageStack.push(Qt.resolvedUrl("../Hotspot.qml"))
132
62
        }
63
        }
134
63
        visible: showAllUI && (actionGroup.actionObject.valid ? actionGroup.actionObject.state : false)
64
        visible: (showAllUI &&
135
65
                 (actionGroup.actionObject.valid ?
136
66
                     actionGroup.actionObject.state : false) &&
137
67
                 UpdateManager.deviceName !== "mako")
138
68
139
64
    }
69
    }
140
65
70
141
66
    ListItem.Standard {
71
    ListItem.Standard {
142
67
72
143
=== modified file 'plugins/cellular/Components/SingleSim.qml'
144
--- plugins/cellular/Components/SingleSim.qml	2015-01-20 12:23:34 +0000
145
+++ plugins/cellular/Components/SingleSim.qml	2015-05-18 15:06:15 +0000
146
@@ -67,12 +67,16 @@
147
67
67
148
68
    ListItem.SingleValue {
68
    ListItem.SingleValue {
149
69
        id: hotspotItem
69
        id: hotspotItem
150
70
        objectName: "hotspotEntry"
151
70
        text: i18n.tr("Wi-Fi hotspot")
71
        text: i18n.tr("Wi-Fi hotspot")
152
71
        progression: true
72
        progression: true
153
72
        onClicked: {
73
        onClicked: {
155
73
            pageStack.push(Qt.resolvedUrl("Hotspot.qml"))
74
            pageStack.push(Qt.resolvedUrl("../Hotspot.qml"))
156
74
        }
75
        }
158
75
        visible: showAllUI && (actionGroup.actionObject.valid ? actionGroup.actionObject.state : false)
76
        visible: (showAllUI &&
159
77
                 (actionGroup.actionObject.valid ?
160
78
                     actionGroup.actionObject.state : false) &&
161
79
                 UpdateManager.deviceName !== "mako")
162
76
    }
80
    }
163
77
81
164
78
    ListItem.Standard {
82
    ListItem.Standard {
165
79
83
166
=== modified file 'plugins/cellular/Hotspot.qml'
167
--- plugins/cellular/Hotspot.qml	2014-07-29 15:39:08 +0000
168
+++ plugins/cellular/Hotspot.qml	2015-05-18 15:06:15 +0000
169
@@ -21,56 +21,73 @@
170
21
import Ubuntu.Components 0.1
21
import Ubuntu.Components 0.1
171
22
import Ubuntu.Components.ListItems 0.1 as ListItem
22
import Ubuntu.Components.ListItems 0.1 as ListItem
172
23
import Ubuntu.SystemSettings.Cellular 1.0
23
import Ubuntu.SystemSettings.Cellular 1.0
173
24
import Ubuntu.Components.Popups 0.1
174
24
25
175
25
ItemPage {
26
ItemPage {
176
26
27
177
27
    id: hotspot
28
    id: hotspot
178
29
    objectName: "hotspotPage"
179
28
30
180
29
    title: i18n.tr("Wi-Fi hotspot")
31
    title: i18n.tr("Wi-Fi hotspot")
181
30
32
182
31
    HotspotManager {
33
    HotspotManager {
183
32
        id: hotspotManager
34
        id: hotspotManager
184
35
        // TODO(jgdx): Figure out why serverCheckedChanged is not fired
185
36
        // automatically whenever hotspotManager.enabled changes.
186
37
        onEnabledChanged: {
187
38
            hotspotSwitch.serverChecked = enabled;
188
39
            hotspotSwitch.serverCheckedChanged();
189
40
        }
190
41
    }
191
42
192
43
    Loader {
193
44
        id: setup
194
45
        asynchronous: false
195
33
    }
46
    }
196
34
47
197
35
    Column {
48
    Column {
198
36
49
199
37
        anchors.fill: parent
50
        anchors.fill: parent
200
51
        spacing: units.gu(2)
201
38
52
202
39
        ListItem.Standard {
53
        ListItem.Standard {
203
40
            text: i18n.tr("Hotspot")
54
            text: i18n.tr("Hotspot")
204
55
            enabled: hotspotManager.stored
205
41
            control: Switch {
56
            control: Switch {
206
42
                id: hotspotSwitch
57
                id: hotspotSwitch
215
43
                checked: hotspotManager.isHotspotActive()
58
                objectName: "hotspotSwitch"
216
44
                onTriggered: {
59
                property bool serverChecked: hotspotManager.enabled
217
45
                    if(checked) {
60
                onServerCheckedChanged: checked = serverChecked
218
46
                        hotspotManager.enableHotspot()
61
                Component.onCompleted: checked = serverChecked
219
47
                    } else {
62
                onTriggered: hotspotManager.enabled = checked
212
48
                        hotspotManager.disableHotspot()
213
49
                    }
214
50
                }
220
51
            }
63
            }
221
52
        }
64
        }
222
53
65
229
54
        Label {
66
        ListItem.Caption {
230
55
            width: parent.width
67
            anchors {
231
56
            wrapMode: Text.WordWrap
68
                left: parent.left
232
57
            anchors.leftMargin: units.gu(2)
69
                right: parent.right
233
58
            anchors.rightMargin: units.gu(2)
70
                leftMargin: units.gu(2)
234
59
            text : hotspotSwitch.enabled ?
71
                rightMargin: units.gu(2)
235
72
            }
236
73
            text : hotspotSwitch.stored ?
237
60
              i18n.tr("When hotspot is on, other devices can use your cellular data connection over Wi-Fi. Normal data charges apply.")
74
              i18n.tr("When hotspot is on, other devices can use your cellular data connection over Wi-Fi. Normal data charges apply.")
239
61
              : i18n.tr("Other devices can use your cellular data connection over the Wi-Fi network. Normal data charges apply.") 
75
              : i18n.tr("Other devices can use your cellular data connection over the Wi-Fi network. Normal data charges apply.")
240
62
        }
76
        }
241
63
77
242
64
        Button {
78
        Button {
248
65
            text: i18n.tr("Set up hotspot")
79
            objectName: "hotspotSetupEntry"
249
66
            anchors.left: parent.left
80
            anchors.horizontalCenter: parent.horizontalCenter
250
67
            anchors.right: parent.right
81
            width: parent.width - units.gu(4)
251
68
            anchors.leftMargin: units.gu(2)
82
            text: hotspotManager.stored ?
252
69
            anchors.rightMargin: units.gu(2)
83
                i18n.tr("Change password/setup…") : i18n.tr("Set up hotspot…")
253
84
254
70
            onClicked: {
85
            onClicked: {
256
71
                pageStack.push(Qt.resolvedUrl("HotspotSetup.qml"), {hotspotManager: hotspotManager})
86
                setup.setSource(Qt.resolvedUrl("HotspotSetup.qml"));
257
87
                PopupUtils.open(setup.item, hotspot, {
258
88
                    hotspotManager: hotspotManager
259
89
                });
260
72
            }
90
            }
261
73
        }
91
        }
262
74
263
75
    }
92
    }
264
76
}
93
}
265
77
94
266
=== modified file 'plugins/cellular/HotspotSetup.qml'
267
--- plugins/cellular/HotspotSetup.qml	2014-07-04 11:32:33 +0000
268
+++ plugins/cellular/HotspotSetup.qml	2015-05-18 15:06:15 +0000
269
@@ -22,82 +22,313 @@
270
22
import Ubuntu.Components 0.1
22
import Ubuntu.Components 0.1
271
23
import Ubuntu.Components.ListItems 0.1 as ListItem
23
import Ubuntu.Components.ListItems 0.1 as ListItem
272
24
import Ubuntu.SystemSettings.Cellular 1.0
24
import Ubuntu.SystemSettings.Cellular 1.0
276
25
25
import Ubuntu.Components.Popups 0.1
277
26
ItemPage {
26
278
27
27
Component {
279
28
    id: hotspotSetup
28
    id: hotspotSetup
323
29
    title: i18n.tr("Change hotspot setup")
29
324
30
30
    Dialog {
325
31
    property var hotspotManager: null
31
        id: hotspotSetupDialog
326
32
32
        property var hotspotManager: null
327
33
33
328
34
    Column {
34
        /* hotspotManager.stored changes as soon as the user has added a
329
35
35
        hotspot, and we use this value when we choose between e.g. "Change" and
330
36
        anchors.fill: parent
36
        "Setup". We'd like the narrative to be consistent, so we stick with
331
37
37
        what the stored value was at component completion.
332
38
        ListItem.Standard {
38
        */
333
39
            id: ssidLabel
39
        property bool stored: false
334
40
            text: i18n.tr("Hotspot name")
40
        Component.onCompleted: stored = hotspotManager.stored;
335
41
        }
41
336
42
42
        objectName: "hotspotSetup"
337
43
        TextField {
43
        anchorToKeyboard: true
338
44
            id: ssidField
44
339
45
            text: hotspotManager.getHotspotName()
45
        function settingsValid() {
340
46
            anchors.left: parent.left
46
            return ssidField.text != "" && passwordField.length >= 8;
341
47
            anchors.right: parent.right
47
        }
342
48
            anchors.leftMargin: units.gu(2)
48
343
49
            anchors.rightMargin: units.gu(2)
49
        title: stored ?
344
50
        }
50
            i18n.tr("Change hotspot setup") : i18n.tr("Setup hotspot")
345
51
51
        text: feedback.enabled ? feedback.text : "";
346
52
        ListItem.Standard {
52
347
53
            id: passwordLabel
53
        Common {
348
54
            text: i18n.tr("Key (must be 8 characters or longer)")
54
            id: common
349
55
        }
55
        }
350
56
56
351
57
        TextField {
57
        states: [
352
58
            id: passwordField
58
            State {
353
59
            text: hotspotManager.getHotspotPassword()
59
                name: "STARTING"
354
60
            echoMode: passwordVisibleSwitch.checked ? TextInput.Normal : TextInput.Password
60
                PropertyChanges {
355
61
            anchors.left: parent.left
61
                    target: workingIndicator
356
62
            anchors.right: parent.right
62
                    running: true
357
63
            anchors.leftMargin: units.gu(2)
63
                }
358
64
            anchors.rightMargin: units.gu(2)
64
                PropertyChanges {
359
65
        }
65
                    target: ssidLabel
360
66
66
                    opacity: 0.5
361
67
        ListItem.Standard {
67
                }
362
68
            text: i18n.tr("Show key")
68
                PropertyChanges {
363
69
            id: passwordVisible
69
                    target: ssidField
364
70
            control: Switch {
70
                    enabled: false
365
71
                id: passwordVisibleSwitch
71
                }
366
72
                PropertyChanges {
367
73
                    target: passwordLabel
368
74
                    opacity: 0.5
369
75
                }
370
76
                PropertyChanges {
371
77
                    target: passwordField
372
78
                    enabled: false
373
79
                }
374
80
                PropertyChanges {
375
81
                    target: feedback
376
82
                    enabled: true
377
83
                }
378
84
                PropertyChanges {
379
85
                    target: confirmButton
380
86
                    enabled: false
381
87
                }
382
88
            },
383
89
384
90
            State {
385
91
                name: "FAILED"
386
92
                PropertyChanges {
387
93
                    target: feedback
388
94
                    enabled: true
389
95
                }
390
96
                PropertyChanges {
391
97
                    target: ssidField
392
98
                    errorHighlight: true
393
99
                }
394
100
                StateChangeScript {
395
101
                    script: ssidField.forceActiveFocus()
396
102
                }
397
103
            },
398
104
399
105
            State {
400
106
                name: "SUCCEEDED"
401
107
                PropertyChanges {
402
108
                    target: successIcon
403
109
                    visible: true
404
110
                }
405
111
                PropertyChanges {
406
112
                    target: successIndicator
407
113
                    running: true
408
114
                }
409
115
                PropertyChanges {
410
116
                    target: ssidLabel
411
117
                    opacity: 0.5
412
118
                }
413
119
                PropertyChanges {
414
120
                    target: ssidField
415
121
                    enabled: false
416
122
                }
417
123
                PropertyChanges {
418
124
                    target: passwordLabel
419
125
                    opacity: 0.5
420
126
                }
421
127
                PropertyChanges {
422
128
                    target: passwordField
423
129
                    enabled: false
424
130
                }
425
131
                PropertyChanges {
426
132
                    target: confirmButton
427
133
                    enabled: false
428
134
                }
429
72
            }
135
            }
431
73
        }
136
        ]
432
74
137
434
75
        RowLayout {
138
        Column {
435
76
            anchors {
139
            anchors {
436
77
                left: parent.left
140
                left: parent.left
437
78
                right: parent.right
141
                right: parent.right
460
79
                margins: units.gu(2)
142
            }
461
80
            }
143
            spacing: units.gu(1)
462
81
            
144
463
82
        Button {
145
            Label {
464
83
            id: cancelButton
146
                property bool enabled: false
465
84
            Layout.fillWidth: true
147
                id: feedback
466
85
            text: i18n.tr("Cancel")
148
                horizontalAlignment: Text.AlignHCenter
467
86
            onClicked: {
149
                height: contentHeight
468
87
                pageStack.pop()
150
                wrapMode: Text.WordWrap
469
88
            }
151
                visible: false
470
89
        }
152
            }
471
90
153
472
91
        Button {
154
            Label {
473
92
            id: connectButton
155
                id: ssidLabel
474
93
            Layout.fillWidth: true
156
                text: i18n.tr("Hotspot name")
475
94
            text: i18n.tr("Change")
157
                fontSize: "medium"
476
95
            enabled: ssidField.text != "" && passwordField.length >= 8
158
                font.bold: true
477
96
            onClicked: {
159
                color: Theme.palette.selected.backgroundText
478
97
                hotspotManager.setupHotspot(ssidField.text, passwordField.text)
160
                elide: Text.ElideRight
479
98
                pageStack.pop()
161
            }
480
99
            }
162
481
100
        }
163
            TextField {
482
164
                id: ssidField
483
165
                objectName: "ssidField"
484
166
                text: hotspotManager.ssid
485
167
                inputMethodHints: Qt.ImhNoAutoUppercase | Qt.ImhNoPredictiveText
486
168
                Component.onCompleted: forceActiveFocus()
487
169
                width: parent.width
488
170
            }
489
171
490
172
            Label {
491
173
                id: passwordLabel
492
174
                text: i18n.tr("Key (must be 8 characters or longer)")
493
175
                fontSize: "medium"
494
176
                font.bold: true
495
177
                color: Theme.palette.selected.backgroundText
496
178
                wrapMode: Text.WordWrap
497
179
                width: parent.width
498
180
            }
499
181
500
182
            TextField {
501
183
                id: passwordField
502
184
                objectName: "passwordField"
503
185
                text: hotspotManager.password
504
186
                echoMode: passwordVisibleSwitch.checked ?
505
187
                    TextInput.Normal : TextInput.Password
506
188
                inputMethodHints: Qt.ImhNoAutoUppercase | Qt.ImhNoPredictiveText
507
189
                width: parent.width
508
190
            }
509
191
510
192
            ListItem.Standard {
511
193
                text: i18n.tr("Show key")
512
194
                id: passwordVisible
513
195
                onClicked: passwordVisibleSwitch.trigger()
514
196
                control: Switch {
515
197
                    id: passwordVisibleSwitch
516
198
                    activeFocusOnPress: false
517
199
                }
518
200
            }
519
201
520
202
            Row {
521
203
522
204
                anchors {
523
205
                    left: parent.left
524
206
                    right: parent.right
525
207
                }
526
208
                width: parent.width
527
209
                spacing: units.gu(2)
528
210
529
211
                Button {
530
212
                    id: cancelButton
531
213
                    width: (parent.width / 2) - units.gu(1)
532
214
                    text: i18n.tr("Cancel")
533
215
                    activeFocusOnPress: false
534
216
                    onClicked: PopupUtils.close(hotspotSetupDialog)
535
217
                }
536
218
537
219
                Button {
538
220
                    id: confirmButton
539
221
                    objectName: "confirmButton"
540
222
                    width: (parent.width / 2) - units.gu(1)
541
223
                    text: hotspotSetupDialog.stored ? i18n.tr("Change") :
542
224
                        i18n.tr("Enable")
543
225
                    enabled: settingsValid()
544
226
                    activeFocusOnPress: false
545
227
                    onClicked: {
546
228
                        if (hotspotSetupDialog.stored) {
547
229
                            changeAction.trigger()
548
230
                        } else {
549
231
                            enableAction.trigger();
550
232
                        }
551
233
                    }
552
234
553
235
                    Icon {
554
236
                        id: successIcon
555
237
                        anchors.centerIn: parent
556
238
                        height: parent.height - units.gu(1.5)
557
239
                        width: parent.height - units.gu(1.5)
558
240
                        name: "tick"
559
241
                        color: "green"
560
242
                        visible: false
561
243
                    }
562
244
563
245
                    ActivityIndicator {
564
246
                        id: workingIndicator
565
247
                        anchors.centerIn: parent
566
248
                        running: false
567
249
                        visible: running
568
250
                        height: parent.height - units.gu(1.5)
569
251
                    }
570
252
                }
571
253
            }
572
254
        }
573
255
574
256
        Action {
575
257
            id: enableAction
576
258
            enabled: settingsValid()
577
259
            onTriggered: {
578
260
                hotspotSetupDialog.state = "STARTING";
579
261
580
262
                function hotspotEnabledHandler (enabled) {
581
263
                    if (enabled) {
582
264
                        hotspotSetupDialog.state = "SUCCEEDED";
583
265
                        hotspotManager.enabledChanged.disconnect(
584
266
                            hotspotEnabledHandler);
585
267
                    }
586
268
                }
587
269
588
270
                hotspotManager.ssid = ssidField.text;
589
271
                hotspotManager.password = passwordField.text;
590
272
                hotspotManager.enabledChanged.connect(hotspotEnabledHandler);
591
273
                hotspotManager.enabled = true;
592
274
            }
593
275
        }
594
276
595
277
        Action {
596
278
            id: changeAction
597
279
            enabled: settingsValid()
598
280
            onTriggered: {
599
281
600
282
                function hotspotEnabledHandler (enabled) {
601
283
                    if (enabled) {
602
284
                        hotspotSetupDialog.state = "SUCCEEDED";
603
285
                        hotspotManager.enabledChanged.disconnect(
604
286
                            hotspotEnabledHandler);
605
287
                    }
606
288
                }
607
289
608
290
                function hotspotDisabledHandler (enabled) {
609
291
                    if (!enabled) {
610
292
                        hotspotManager.enabledChanged.connect(hotspotEnabledHandler);
611
293
                        hotspotManager.enabled = true;
612
294
                        hotspotManager.enabledChanged.disconnect(
613
295
                            hotspotDisabledHandler);
614
296
                    }
615
297
                }
616
298
617
299
                hotspotManager.ssid = ssidField.text;
618
300
                hotspotManager.password = passwordField.text;
619
301
620
302
                if (hotspotManager.enabled) {
621
303
                    hotspotSetupDialog.state = "STARTING";
622
304
                    hotspotManager.enabledChanged.connect(
623
305
                        hotspotDisabledHandler);
624
306
                    hotspotManager.enabled = false;
625
307
                } else {
626
308
                    PopupUtils.close(hotspotSetupDialog);
627
309
                }
628
310
            }
629
311
        }
630
312
631
313
        /* Timer that shows a tick in the connect button once we have
632
314
        successfully changed/started a hotspot. */
633
315
        Timer {
634
316
            id: successIndicator
635
317
            interval: 2000
636
318
            running: false
637
319
            repeat: false
638
320
            onTriggered: PopupUtils.close(hotspotSetupDialog)
639
321
        }
640
322
641
323
        Connections {
642
324
            target: hotspotManager
643
325
644
326
            onReportError: {
645
327
                if (hotspotSetupDialog.state === "STARTING") {
646
328
                    hotspotSetupDialog.state = "FAILED";
647
329
                    feedback.text = common.reasonToString(reason);
648
330
                }
649
331
            }
650
101
        }
332
        }
651
102
    }
333
    }
652
103
}
334
}
653
104
335
654
=== modified file 'plugins/cellular/hotspotmanager.cpp'
655
--- plugins/cellular/hotspotmanager.cpp	2014-07-23 13:44:31 +0000
656
+++ plugins/cellular/hotspotmanager.cpp	2015-05-18 15:06:15 +0000
657
@@ -1,8 +1,9 @@
658
1
/*
1
/*
660
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014, 2015 Canonical, Ltd.
661
3
 *
3
 *
662
4
 * Authors:
4
 * Authors:
663
5
 *    Jussi Pakkanen <jussi.pakkanen@canonical.com>
5
 *    Jussi Pakkanen <jussi.pakkanen@canonical.com>
664
6
 *    Jonas G. Drange <jonas.drange@canonical.com>
665
6
 *
7
 *
666
7
 * This program is free software: you can redistribute it and/or modify it
8
 * This program is free software: you can redistribute it and/or modify it
667
8
 * under the terms of the GNU General Public License version 3, as published
9
 * under the terms of the GNU General Public License version 3, as published
668
@@ -15,13 +16,9 @@
669
15
 *
16
 *
670
16
 * You should have received a copy of the GNU General Public License
17
 * You should have received a copy of the GNU General Public License
671
17
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
673
18
 */
19
*/
674
19
20
675
20
#include "hotspotmanager.h"
21
#include "hotspotmanager.h"
676
21
677
22
#include "nm_manager_proxy.h"
678
23
#include "nm_settings_proxy.h"
679
24
#include "nm_settings_connection_proxy.h"
680
25
#include <QStringList>
22
#include <QStringList>
681
26
#include <QDBusReply>
23
#include <QDBusReply>
682
27
#include <QtDebug>
24
#include <QtDebug>
683
@@ -31,31 +28,156 @@
684
31
typedef QMap<QString, QVariantMap> nmConnectionArg;
28
typedef QMap<QString, QVariantMap> nmConnectionArg;
685
32
Q_DECLARE_METATYPE(nmConnectionArg)
29
Q_DECLARE_METATYPE(nmConnectionArg)
686
33
30
688
34
namespace {
31
namespace  { // wpa_supplicant interaction
689
32
690
33
const QString wpa_supplicant_service("fi.w1.wpa_supplicant1");
691
34
const QString wpa_supplicant_interface("fi.w1.wpa_supplicant1");
692
35
const QString wpa_supplicant_path("/fi/w1/wpa_supplicant1");
693
36
694
37
bool isHybrisWlan() {
695
38
    QString program("getprop");
696
39
    QStringList arguments;
697
40
    arguments << "urfkill.hybris.wlan";
698
41
699
42
    QProcess *getprop = new QProcess();
700
43
    getprop->start(program, arguments);
701
44
702
45
    if (!getprop->waitForFinished()) {
703
46
        qCritical() << "getprop process failed:" << getprop->errorString();
704
47
        delete getprop;
705
48
        return false;
706
49
    }
707
50
708
51
    int index = getprop->readAllStandardOutput().indexOf("1");
709
52
    delete getprop;
710
53
711
54
    // A non-negative integer means getprop returned 1
712
55
    return index >= 0;
713
56
}
714
57
715
58
// True if changed successfully, or there was no need. Otherwise false.
716
59
// Supported modes are 'p2p', 'sta' and 'ap'.
717
60
bool changeInterfaceFirmware(const QString interface, const QString mode) {
718
61
    // Not supported.
719
62
    if (mode == "adhoc") {
720
63
        return true;
721
64
    }
722
65
723
66
    if (isHybrisWlan()) {
724
67
        QDBusInterface wpasIface (
725
68
            wpa_supplicant_service, wpa_supplicant_path, wpa_supplicant_interface,
726
69
            QDBusConnection::systemBus());
727
70
728
71
        const QDBusObjectPath interface_path(interface);
729
72
730
73
        // TODO(jgdx): We need to guard against calling this
731
74
        // when the interface is not soft blocked.
732
75
        auto set_interface = wpasIface.call("SetInterfaceFirmware",
733
76
            QVariant::fromValue(interface_path), QVariant(mode));
734
77
735
78
        if (set_interface.type() == QDBusMessage::ErrorMessage) {
736
79
            qCritical() << "Failed to change interface firmware:"
737
80
                << set_interface.errorMessage();
738
81
            return false;
739
82
        } else {
740
83
            return true;
741
84
        }
742
85
    }
743
86
744
87
    // We had no need to change the firmware.
745
88
    return true;
746
89
}
747
90
} // wpa_supplicant interaction
748
91
749
92
namespace  { // UrfKill interaction
750
93
751
94
const QString urfkill_service("org.freedesktop.URfkill");
752
95
const QString urfkill_interface("org.freedesktop.URfkill");
753
96
const QString urfkill_path("/org/freedesktop/URfkill");
754
97
755
98
// True if call went through and returned true.
756
99
bool setWifiBlock(bool block) {
757
100
    QDBusInterface urfkill_dbus_interface(urfkill_service, urfkill_path,
758
101
        urfkill_interface, QDBusConnection::systemBus());
759
102
760
103
    const unsigned int device_type = 1; /* wifi type */
761
104
    auto reply = urfkill_dbus_interface.call("Block", device_type, block);
762
105
763
106
    if (reply.type() == QDBusMessage::ErrorMessage) {
764
107
        qCritical() << "Failed to block wifi" << reply.errorMessage();
765
108
        return false;
766
109
    }
767
110
768
111
    // We got exactly one argument back, and it's not an error.
769
112
    if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 1) {
770
113
        // returned false from call
771
114
        if (!qdbus_cast<bool>(reply.arguments().at(0))) {
772
115
            qCritical() << "URfkill Block call did not succeed";
773
116
            return false;
774
117
        } else {
775
118
            return true;
776
119
        }
777
120
    }
778
121
    // We did not get what we wanted from dbus, so we treat that as failure.
779
122
    return false;
780
123
}
781
124
} // UrfKill interaction
782
125
783
126
namespace { // NetworkManager interaction
784
35
127
785
36
const QString nm_service("org.freedesktop.NetworkManager");
128
const QString nm_service("org.freedesktop.NetworkManager");
786
129
const QString nm_object("/org/freedesktop/NetworkManager");
787
37
const QString nm_settings_object("/org/freedesktop/NetworkManager/Settings");
130
const QString nm_settings_object("/org/freedesktop/NetworkManager/Settings");
788
38
const QString nm_settings_interface("org.freedesktop.NetworkManager.Settings");
131
const QString nm_settings_interface("org.freedesktop.NetworkManager.Settings");
789
39
const QString nm_connection_interface("org.freedesktop.NetworkManager.Settings.Connection");
132
const QString nm_connection_interface("org.freedesktop.NetworkManager.Settings.Connection");
791
40
const QString nm_dbus_path("/org/freedesktop/NetworkManager");
133
const QString nm_connection_active_interface("org.freedesktop.NetworkManager.Connection.Active");
792
41
const QString nm_device_interface("org.freedesktop.NetworkManager.Device");
134
const QString nm_device_interface("org.freedesktop.NetworkManager.Device");
797
42
135
const QString dbus_properties_interface("org.freedesktop.DBus.Properties");
798
43
#define NM_METHOD_NAME "AddAndActivateConnection"
136
const QString connection_property("Connection");
799
44
137
800
45
void startAdhoc(const QByteArray &ssid, const QString &password, const QDBusObjectPath &devicePath) {
138
// NetworkManager dbus interface proxy we will use to query
801
139
// against NetworkManager. See
802
140
// https://developer.gnome.org/NetworkManager/0.9/spec.html
803
141
//     #org.freedesktop.NetworkManager
804
142
OrgFreedesktopNetworkManagerInterface nm_manager(
805
143
    nm_service, nm_object, QDBusConnection::systemBus());
806
144
807
145
// NetworkManager Settings interface proxy we use to get
808
146
// the list of connections, as well as adding connections.
809
147
// See https://developer.gnome.org/NetworkManager/0.9/spec.html
810
148
//     #org.freedesktop.NetworkManager.Settings
811
149
OrgFreedesktopNetworkManagerSettingsInterface nm_settings(
812
150
    nm_service, nm_settings_object, QDBusConnection::systemBus());
813
151
814
152
// Helper that maps QStrings to other QVariantMaps, i.e.
815
153
// QMap<QString, QVariantMap>. QVariantMap is an alias for
816
154
// QMap<QString, QVariant>.
817
155
// See http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef and
818
156
// https://developer.gnome.org/NetworkManager/0.9/spec.html
819
157
//     #type-String_String_Variant_Map_Map
820
158
nmConnectionArg createConnectionSettings(
821
159
    const QByteArray &ssid, const QString &password,
822
160
    const QDBusObjectPath &devicePath, QString mode, bool autoConnect = true) {
823
161
    Q_UNUSED(devicePath);
824
46
    nmConnectionArg connection;
162
    nmConnectionArg connection;
825
47
163
827
48
    QDBusObjectPath specific("/");
164
    QString s_ssid = QString::fromLatin1(ssid);
828
165
    QString s_uuid = QUuid().createUuid().toString();
829
166
    // Remove {} from the generated uuid.
830
167
    s_uuid.remove(0, 1);
831
168
    s_uuid.remove(s_uuid.size() - 1, 1);
832
49
169
833
50
    QVariantMap wireless;
170
    QVariantMap wireless;
834
51
    wireless[QStringLiteral("security")] = QVariant(QStringLiteral("802-11-wireless-security"));
171
    wireless[QStringLiteral("security")] = QVariant(QStringLiteral("802-11-wireless-security"));
835
52
    wireless[QStringLiteral("ssid")] = QVariant(ssid);
172
    wireless[QStringLiteral("ssid")] = QVariant(ssid);
837
53
    wireless[QStringLiteral("mode")] = QVariant(QStringLiteral("adhoc"));
173
    wireless[QStringLiteral("mode")] = QVariant(mode);
838
174
839
54
    connection["802-11-wireless"] = wireless;
175
    connection["802-11-wireless"] = wireless;
840
55
176
841
56
    QVariantMap connsettings;
177
    QVariantMap connsettings;
844
57
    connsettings[QStringLiteral("autoconnect")] = QVariant(false);
178
    connsettings[QStringLiteral("autoconnect")] = QVariant(autoConnect);
845
58
    connsettings[QStringLiteral("uuid")] = QVariant(QStringLiteral("aab22b5d-7342-48dc-8920-1b7da31d6829"));
179
    connsettings[QStringLiteral("id")] = QVariant(s_ssid);
846
180
    connsettings[QStringLiteral("uuid")] = QVariant(s_uuid);
847
59
    connsettings[QStringLiteral("type")] = QVariant(QStringLiteral("802-11-wireless"));
181
    connsettings[QStringLiteral("type")] = QVariant(QStringLiteral("802-11-wireless"));
848
60
    connection["connection"] = connsettings;
182
    connection["connection"] = connsettings;
849
61
183
850
@@ -66,6 +188,10 @@
851
66
    ipv4[QStringLiteral("routes")] = QVariant(QStringList());
188
    ipv4[QStringLiteral("routes")] = QVariant(QStringList());
852
67
    connection["ipv4"] = ipv4;
189
    connection["ipv4"] = ipv4;
853
68
190
854
191
    QVariantMap ipv6;
855
192
    ipv6[QStringLiteral("method")] = QVariant(QStringLiteral("ignore"));
856
193
    connection["ipv6"] = ipv6;
857
194
858
69
    QVariantMap security;
195
    QVariantMap security;
859
70
    security[QStringLiteral("proto")] = QVariant(QStringList{"rsn"});
196
    security[QStringLiteral("proto")] = QVariant(QStringList{"rsn"});
860
71
    security[QStringLiteral("pairwise")] = QVariant(QStringList{"ccmp"});
197
    security[QStringLiteral("pairwise")] = QVariant(QStringList{"ccmp"});
861
@@ -74,176 +200,510 @@
862
74
    security[QStringLiteral("psk")] = QVariant(password);
200
    security[QStringLiteral("psk")] = QVariant(password);
863
75
    connection["802-11-wireless-security"] = security;
201
    connection["802-11-wireless-security"] = security;
864
76
202
893
77
    OrgFreedesktopNetworkManagerInterface mgr(nm_service,
203
    return connection;
894
78
            nm_dbus_path,
204
}
895
79
            QDBusConnection::systemBus());
205
896
80
    auto reply = mgr.AddAndActivateConnection(connection, devicePath, specific);
206
// Helper that returns a QMap<QString, QVariantMap> given a QDBusObjectPath.
897
81
    reply.waitForFinished();
207
// See https://developer.gnome.org/NetworkManager/0.9/spec.html
898
82
    if(!reply.isValid()) {
208
//     #org.freedesktop.NetworkManager.Settings.Connection.GetSettings
899
83
        qWarning() << "Failed to start adhoc network: " << reply.error().message() << "\n";
209
nmConnectionArg getConnectionSettings (QDBusObjectPath connection) {
900
84
    }
210
    OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(
901
85
}
211
        nm_service, connection.path(), QDBusConnection::systemBus());
902
86
212
903
87
bool detectAdhoc(QString &dbusPath, QByteArray &ssid, QString &password, bool &isActive) {
213
    auto connection_settings = conn.GetSettings();
904
88
    static const QString activeIface("org.freedesktop.NetworkManager.Connection.Active");
214
    connection_settings.waitForFinished();
905
89
    static const QString connProp("Connection");
215
    return connection_settings.value();
906
90
    OrgFreedesktopNetworkManagerInterface mgr(nm_service,
216
}
907
91
            nm_dbus_path,
217
908
92
            QDBusConnection::systemBus());
218
909
93
    auto activeConnections = mgr.activeConnections();
219
// Helper that returns a QMap<QString, QVariantMap> given a QDBusObjectPath.
910
94
    OrgFreedesktopNetworkManagerSettingsInterface settings(nm_service, nm_settings_object,
220
// See https://developer.gnome.org/NetworkManager/0.9/spec.html
911
95
            QDBusConnection::systemBus());
221
//     #org.freedesktop.NetworkManager.Settings.Connection.GetSettings
912
96
    QSet<QDBusObjectPath> actives;
222
nmConnectionArg getConnectionSecrets (QDBusObjectPath connection,
913
97
    auto r = settings.ListConnections();
223
    const QString key) {
914
98
    r.waitForFinished();
224
    OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(
915
99
    for(const auto &conn : activeConnections) {
225
        nm_service, connection.path(), QDBusConnection::systemBus());
916
100
        QDBusInterface iface(nm_service, conn.path(), "org.freedesktop.DBus.Properties",
226
    auto connection_secrets = conn.GetSecrets(key);
917
101
                QDBusConnection::systemBus());
227
    connection_secrets.waitForFinished();
918
102
        QDBusReply<QVariant> conname = iface.call("Get", activeIface, connProp);
228
    return connection_secrets.value();
919
103
        if(!conname.isValid()) {
229
}
920
104
            qWarning() << "Error getting connamd: " << conname.error().message() << "\n";
230
921
231
// Helper that adds a connection and returns the QDBusObjectPath
922
232
// of the newly created connection.
923
233
// See https://developer.gnome.org/NetworkManager/0.9/spec.html
924
234
//     #org.freedesktop.NetworkManager.Settings.AddConnection
925
235
QDBusObjectPath addConnection(
926
236
    const QByteArray &ssid, const QString &password,
927
237
    const QDBusObjectPath &devicePath, QString mode) {
928
238
    QDBusObjectPath invalid("");
929
239
930
240
    nmConnectionArg connection = createConnectionSettings(ssid, password,
931
241
        devicePath, mode);
932
242
933
243
    auto add_connection_reply = nm_settings.AddConnection(connection);
934
244
    add_connection_reply.waitForFinished();
935
245
936
246
    if(!add_connection_reply.isValid()) {
937
247
        qCritical() << "Failed to add connection: "
938
248
            << add_connection_reply.error().message();
939
249
        return invalid;
940
250
    }
941
251
    return add_connection_reply.argumentAt<0>();
942
252
}
943
253
944
254
// Returns a QDBusObjectPath of a hotspot given a mode.
945
255
// Valid modes are 'p2p', 'ap' and 'adhoc'.
946
256
QDBusObjectPath getHotspot(QString mode) {
947
257
    const char wifi_key[] = "802-11-wireless";
948
258
949
259
    auto listed_connections = nm_settings.ListConnections();
950
260
    listed_connections.waitForFinished();
951
261
952
262
    for(const auto &connection : listed_connections.value()) {
953
263
        OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(
954
264
        nm_service, connection.path(), QDBusConnection::systemBus());
955
265
956
266
        auto connection_settings = getConnectionSettings(connection);
957
267
958
268
        if(connection_settings.find(wifi_key) != connection_settings.end()) {
959
269
            auto wifi_setup = connection_settings[wifi_key];
960
270
            QString wifi_mode = wifi_setup["mode"].toString();
961
271
962
272
            if(wifi_mode == mode) {
963
273
                return connection;
964
274
            }
965
275
        }
966
276
    }
967
277
    return QDBusObjectPath();
968
278
}
969
279
970
280
// Returns a QDBusObjectPath of a wireless device. For now
971
281
// it returns the first device.
972
282
QDBusObjectPath getWirelessDevice () {
973
283
    // find the first wlan adapter for now
974
284
    auto reply1 = nm_manager.GetDevices();
975
285
    reply1.waitForFinished();
976
286
977
287
    if(!reply1.isValid()) {
978
288
        qCritical() << "Could not get network device: "
979
289
            << reply1.error().message();
980
290
        return QDBusObjectPath();
981
291
    }
982
292
    auto devices = reply1.value();
983
293
984
294
    QDBusObjectPath dev;
985
295
    for (const auto &d : devices) {
986
296
        QDBusInterface iface(nm_service, d.path(), nm_device_interface,
987
297
            QDBusConnection::systemBus());
988
298
        auto type_v = iface.property("DeviceType");
989
299
990
300
        if (type_v.toUInt() == 2 /* NM_DEVICE_TYPE_WIFI */) {
991
301
            return d;
992
302
        }
993
303
    }
994
304
    qCritical() << "Wireless device not found, hotspot functionality is inoperative.";
995
305
    return dev;
996
306
}
997
307
998
308
// Helper to check if the hotspot on a given QDBusObjectPath is active
999
309
// or not. It checks if the Connection.Active [1] for the given
1000
310
// path is in NetworkManager's ActiveConnections property [2].
1001
311
// [1] https://developer.gnome.org/NetworkManager/0.9/spec.html
1002
312
//     #org.freedesktop.NetworkManager.Connection.Active
1003
313
// [2] https://developer.gnome.org/NetworkManager/0.9/spec.html
1004
314
//     #org.freedesktop.NetworkManager
1005
315
bool isHotspotActive (QDBusObjectPath path) {
1006
316
    QSet<QDBusObjectPath> active_relevant_connections;
1007
317
    auto active_connections = nm_manager.activeConnections();
1008
318
    for(const auto &active_connection : active_connections) {
1009
319
1010
320
        // Active connection interface proxy. It might have a connection
1011
321
        // property we can use to deduce if this active connection represents
1012
322
        // our active hotspot.
1013
323
        QDBusInterface active_connection_dbus_interface(
1014
324
        nm_service, active_connection.path(), dbus_properties_interface,
1015
325
        QDBusConnection::systemBus());
1016
326
1017
327
        // Get the Connection property, if any.
1018
328
        QDBusReply<QVariant> connection_property =
1019
329
            active_connection_dbus_interface.call("Get",
1020
330
                nm_connection_active_interface, "Connection");
1021
331
1022
332
        // The Connection property did not exist, so ignore this
1023
333
        // active connection.
1024
334
        if(!connection_property.isValid()) {
1025
105
            continue;
335
            continue;
1026
106
        }
336
        }
1055
107
        QDBusObjectPath mainConnection = qvariant_cast<QDBusObjectPath>(conname.value());
337
1056
108
        actives.insert(mainConnection);
338
        // It does exist, cast it to a object path.
1057
109
    }
339
        QDBusObjectPath connection_path = qvariant_cast<QDBusObjectPath>(
1058
110
    const char wifiKey[] = "802-11-wireless";
340
            connection_property.value());
1059
111
    for(const auto &i : r.value()) {
341
1060
112
        OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(nm_service,
342
        // The object path is the same as the given hotspot path.
1061
113
                i.path(),
343
        if (path == connection_path) {
1062
114
                QDBusConnection::systemBus());
344
            return true;
1035
115
        auto reply = conn.GetSettings();
1036
116
        reply.waitForFinished();
1037
117
        auto s = reply.value();
1038
118
        if(s.find(wifiKey) != s.end()) {
1039
119
            auto wsetup = s[wifiKey];
1040
120
            if(wsetup["mode"] == "adhoc") {
1041
121
                dbusPath = i.path();
1042
122
                ssid = wsetup["ssid"].toByteArray();
1043
123
                auto pwdReply = conn.GetSecrets("802-11-wireless-security");
1044
124
                pwdReply.waitForFinished();
1045
125
                password = pwdReply.value()["802-11-wireless-security"]["psk"].toString();
1046
126
                isActive = false;
1047
127
                for(const auto &ac : actives) {
1048
128
                    if(i == ac) {
1049
129
                        isActive = true;
1050
130
                        break;
1051
131
                    }
1052
132
                }
1053
133
                return true;
1054
134
            }
1063
135
        }
345
        }
1064
136
    }
346
    }
1065
347
1066
348
    // No active connection had a Connection property equal to the
1067
349
    // given path, so return false.
1068
137
    return false;
350
    return false;
1069
138
}
351
}
1070
139
352
1071
140
QDBusObjectPath detectWirelessDevice() {
1072
141
    OrgFreedesktopNetworkManagerInterface mgr(nm_service,
1073
142
            nm_dbus_path,
1074
143
            QDBusConnection::systemBus());
1075
144
    auto devices = mgr.GetDevices();
1076
145
    devices.waitForFinished();
1077
146
    for(const auto &dpath : devices.value()) {
1078
147
        QDBusInterface iface(nm_service, dpath.path(), "org.freedesktop.DBus.Properties",
1079
148
                QDBusConnection::systemBus());
1080
149
        QDBusReply<QVariant> typeReply = iface.call("Get", "org.freedesktop.NetworkManager.Device", "DeviceType");
1081
150
        auto typeInt = qvariant_cast<int>(typeReply.value());
1082
151
        if(typeInt == 2) {
1083
152
            return dpath; // Assumptions are that there is only one wifi device and it is not hotpluggable.
1084
153
        }
1085
154
    }
1086
155
    qWarning() << "Wireless device not found, hotspot functionality is inoperative.\n";
1087
156
    return QDBusObjectPath();
1088
157
}
1089
158
1090
159
std::string generate_password() {
353
std::string generate_password() {
1091
160
    static const std::string items("abcdefghijklmnopqrstuvwxyz01234567890");
354
    static const std::string items("abcdefghijklmnopqrstuvwxyz01234567890");
1093
161
    const int passwordLength = 8;
355
    const int password_length = 8;
1094
162
    std::string result;
356
    std::string result;
1096
163
    for(int i=0; i<passwordLength; i++) {
357
1097
358
    for(int i=0; i<password_length; i++) {
1098
164
        result.push_back(items[std::rand() % items.length()]);
359
        result.push_back(items[std::rand() % items.length()]);
1099
165
    }
360
    }
1100
166
    return result;
361
    return result;
1101
167
}
362
}
1107
168
363
} // NetworkManager interaction
1108
169
}
364
1109
170
365
HotspotManager::HotspotManager(QObject *parent) :
1110
171
HotspotManager::HotspotManager(QObject *parent) : QObject(parent),
366
    QObject(parent), m_mode("ap"), m_enabled(false), m_stored(false),
1111
172
        m_devicePath(detectWirelessDevice()) {
367
    m_password(generate_password().c_str()), m_ssid(QByteArray("Ubuntu")),
1112
368
    m_device_path(getWirelessDevice()) {
1113
173
    static bool isRegistered = false;
369
    static bool isRegistered = false;
1114
370
1115
174
    if(!isRegistered) {
371
    if(!isRegistered) {
1116
175
        qDBusRegisterMetaType<nmConnectionArg>();
372
        qDBusRegisterMetaType<nmConnectionArg>();
1117
176
        isRegistered = true;
373
        isRegistered = true;
1118
177
    }
374
    }
1128
178
    if(!detectAdhoc(m_settingsPath, m_ssid, m_password, m_isActive)) {
375
1129
179
        m_settingsPath = "";
376
    // Stored is false if hotspot path is empty.
1130
180
        m_ssid = "Ubuntu hotspot";
377
    m_hotspot_path = getHotspot(m_mode);
1131
181
        m_password = generate_password().c_str();
378
    setStored(!m_hotspot_path.path().isEmpty());
1132
182
        m_isActive = false;
379
1133
183
    }
380
    if (m_stored) {
1134
184
}
381
        updateSettingsFromDbus(m_hotspot_path);
1135
185
382
    }
1136
186
QByteArray HotspotManager::getHotspotName() {
383
1137
384
    // Watches for new connections added to NetworkManager's Settings
1138
385
    // interface.
1139
386
    nm_settings.connection().connect(
1140
387
        nm_settings.service(), nm_settings_object, nm_settings_interface,
1141
388
        "NewConnection", this, SLOT(onNewConnection(QDBusObjectPath)));
1142
389
1143
390
    // Watches changes in NetworkManager.
1144
391
    nm_manager.connection().connect(
1145
392
        nm_manager.service(), nm_object, nm_service, "PropertiesChanged", this,
1146
393
        SLOT(onPropertiesChanged(QMap<QString, QVariant>)));
1147
394
}
1148
395
1149
396
void HotspotManager::setEnabled(bool value) {
1150
397
    bool blocked = setWifiBlock(true);
1151
398
1152
399
    // Failed to soft block, here we revert the enabled setting.
1153
400
    if (!blocked) {
1154
401
        // "The device could not be readied for configuration"
1155
402
        Q_EMIT reportError(5);
1156
403
        setEnable(false);
1157
404
        return;
1158
405
    }
1159
406
1160
407
    // We are enabling a hotspot
1161
408
    if (value) {
1162
409
        // If the SSID is empty, we report an error. The UI should strive
1163
410
        // to prevent us from reaching this part of the code.
1164
411
        if (m_ssid.isEmpty()) {
1165
412
            Q_EMIT reportError(1);
1166
413
            setEnable(false);
1167
414
            return;
1168
415
        }
1169
416
1170
417
        bool changed = changeInterfaceFirmware("/", m_mode);
1171
418
        if (!changed) {
1172
419
            // Necessary firmware for the device may be missing
1173
420
            Q_EMIT reportError(35);
1174
421
            setEnable(false);
1175
422
            setWifiBlock(false);
1176
423
            return;
1177
424
        }
1178
425
1179
426
        if (m_stored) {
1180
427
            // we defer enabling until old hotspot is deleted
1181
428
            // if we can delete the old one
1182
429
            // If not, unset stored flag and call this method.
1183
430
            if (!destroy(m_hotspot_path)) {
1184
431
                setStored(false);
1185
432
                setEnabled(true);
1186
433
                setEnable(true);
1187
434
            }
1188
435
        } else {
1189
436
            // we defer enabling until new hotspot is created
1190
437
            m_hotspot_path = addConnection(m_ssid, m_password, m_device_path, m_mode);
1191
438
            if (m_hotspot_path.path().isEmpty()) {
1192
439
                // Emit "Unknown Error".
1193
440
                Q_EMIT reportError(0);
1194
441
                setEnable(false);
1195
442
                setWifiBlock(false);
1196
443
            }
1197
444
        }
1198
445
1199
446
    } else {
1200
447
        // Disabling the hotspot.
1201
448
        disable();
1202
449
        setEnable(false);
1203
450
1204
451
        bool unblocked = setWifiBlock(false);
1205
452
        if (!unblocked) {
1206
453
            // "The device could not be readied for configuration"
1207
454
            Q_EMIT reportError(5);
1208
455
        }
1209
456
    }
1210
457
}
1211
458
1212
459
// Disables a hotspot.
1213
460
void HotspotManager::disable() {
1214
461
    QDBusObjectPath hotspot = getHotspot(m_mode);
1215
462
    if (hotspot.path().isEmpty()) {
1216
463
        qWarning() << "Could not find a hotspot setup to disable.\n";
1217
464
        return;
1218
465
    }
1219
466
1220
467
    // Create Connection.Settings proxy for hotspot
1221
468
    OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(
1222
469
        nm_service, hotspot.path(), QDBusConnection::systemBus());
1223
470
1224
471
    // Get new settings
1225
472
    nmConnectionArg new_settings = createConnectionSettings(m_ssid, m_password,
1226
473
        m_device_path, m_mode, false);
1227
474
    auto updating = conn.Update(new_settings);
1228
475
    updating.waitForFinished();
1229
476
    if(!updating.isValid()) {
1230
477
        qCritical() << "Could not update connection with autoconnect=false: "
1231
478
        << updating.error().message();
1232
479
    }
1233
480
1234
481
    auto active_connections = nm_manager.activeConnections();
1235
482
    for(const auto &active_connection : active_connections) {
1236
483
        // DBus Properties interface proxy of the active connection. We use
1237
484
        // this proxy to get to the Connection property.
1238
485
        QDBusInterface iface(
1239
486
            nm_service, active_connection.path(),
1240
487
            "org.freedesktop.DBus.Properties", QDBusConnection::systemBus());
1241
488
1242
489
        // Call to get the Connection property.
1243
490
        QDBusReply<QVariant> conname = iface.call(
1244
491
            "Get", nm_connection_active_interface, "Connection");
1245
492
1246
493
        // Cast the property to a object path.
1247
494
        QDBusObjectPath backingConnection = qvariant_cast<QDBusObjectPath>(
1248
495
            conname.value());
1249
496
1250
497
        // This active connection's Connection property was our hotspot,
1251
498
        // so we will deactivate it. Note that we do not remove the hotspot,
1252
499
        // as we are storing the ssid, password and mode on the connection.
1253
500
        if(backingConnection == m_hotspot_path) {
1254
501
            // Deactivate the connection.
1255
502
            auto deactivation = nm_manager.DeactivateConnection(active_connection);
1256
503
            deactivation.waitForFinished();
1257
504
            if(!deactivation.isValid()) {
1258
505
                qCritical() << "Could not get deactivate connection: "
1259
506
                    << deactivation.error().message();
1260
507
            }
1261
508
            return;
1262
509
        }
1263
510
    }
1264
511
    return;
1265
512
}
1266
513
1267
514
bool HotspotManager::enabled() const {
1268
515
    return m_enabled;
1269
516
}
1270
517
1271
518
void HotspotManager::setEnable(bool value) {
1272
519
    if (m_enabled != value) {
1273
520
        m_enabled = value;
1274
521
        Q_EMIT enabledChanged(value);
1275
522
    }
1276
523
}
1277
524
1278
525
bool HotspotManager::stored() const {
1279
526
    return m_stored;
1280
527
}
1281
528
1282
529
void HotspotManager::setStored(bool value) {
1283
530
    if (m_stored != value) {
1284
531
        m_stored = value;
1285
532
        Q_EMIT storedChanged(value);
1286
533
    }
1287
534
}
1288
535
1289
536
QByteArray HotspotManager::ssid() const {
1290
187
    return m_ssid;
537
    return m_ssid;
1291
188
}
538
}
1292
189
539
1294
190
QString HotspotManager::getHotspotPassword() {
540
void HotspotManager::setSsid(QByteArray value) {
1295
541
    if (m_ssid != value) {
1296
542
        m_ssid = value;
1297
543
        Q_EMIT ssidChanged(value);
1298
544
    }
1299
545
}
1300
546
1301
547
QString HotspotManager::password() const {
1302
191
    return m_password;
548
    return m_password;
1303
192
}
549
}
1304
193
550
1342
194
void HotspotManager::setupHotspot(QByteArray ssid_, QString password_) {
551
void HotspotManager::setPassword(QString value) {
1343
195
    m_ssid = ssid_;
552
    if (m_password != value) {
1344
196
    m_password = password_;
553
        m_password = value;
1345
197
}
554
        Q_EMIT passwordChanged(value);
1346
198
555
    }
1347
199
void HotspotManager::enableHotspot() {
556
}
1348
200
    if(!m_settingsPath.isEmpty()) {
557
1349
201
        // Prints a warning message if the connection has disappeared already.
558
QString HotspotManager::mode() const {
1350
202
        destroyHotspot();
559
    return m_mode;
1351
203
        // NM returns from the dbus call immediately but only destroys the
560
}
1352
204
        // connection some time later. There is no callback for when this happens.
561
1353
205
        // So this is the best we can do with reasonable effort.
562
void HotspotManager::setMode(QString value) {
1354
206
        QThread::sleep(1);
563
    if (m_mode != value) {
1355
207
    }
564
        m_mode = value;
1356
208
    startAdhoc(m_ssid, m_password, m_devicePath);
565
        Q_EMIT modeChanged(value);
1357
209
    detectAdhoc(m_settingsPath, m_ssid, m_password, m_isActive);
566
    }
1358
210
}
567
}
1359
211
568
1360
212
bool HotspotManager::isHotspotActive() {
569
void HotspotManager::onNewConnection(QDBusObjectPath path) {
1361
213
    return m_isActive;
570
    // The new connection is the same as the stored hotspot path.
1362
214
}
571
    if (path == m_hotspot_path) {
1363
215
572
        // If a new hotspot was added, it is also given that
1364
216
void HotspotManager::disableHotspot() {
573
        // Wi-Fi has been soft blocked. We can now unblock Wi-Fi
1365
217
    static const QString activeIface("org.freedesktop.NetworkManager.Connection.Active");
574
        // and let NetworkManager pick up the newly created
1366
218
    static const QString connProp("Connection");
575
        // connection.
1367
219
    OrgFreedesktopNetworkManagerInterface mgr(nm_service,
576
        bool unblocked = setWifiBlock(false);
1368
220
            nm_dbus_path,
577
        if (!unblocked) {
1369
221
            QDBusConnection::systemBus());
578
            // "The device could not be readied for configuration"
1370
222
    auto activeConnections = mgr.activeConnections();
579
            Q_EMIT reportError(5);
1371
223
    for(const auto &aConn : activeConnections) {
580
        } else {
1372
224
        QDBusInterface iface(nm_service, aConn.path(), "org.freedesktop.DBus.Properties",
581
            // We successfully unblocked the Wi-Fi, so set m_enable to true.
1373
225
                QDBusConnection::systemBus());
582
            setEnable(true);
1337
226
        QDBusReply<QVariant> conname = iface.call("Get", activeIface, connProp);
1338
227
        QDBusObjectPath backingConnection = qvariant_cast<QDBusObjectPath>(conname.value());
1339
228
        if(backingConnection.path() == m_settingsPath) {
1340
229
            mgr.DeactivateConnection(aConn);
1341
230
            return;
1374
231
        }
583
        }
1382
232
    }
584
1383
233
    qWarning() << "Could not find a hotspot setup to disable.\n";
585
        // This also mean we have successfully created a hotspot connection
1384
234
}
586
        // object in NetworkManager, so m_stored should now be true.
1385
235
587
        setStored(true);
1386
236
void HotspotManager::destroyHotspot() {
588
    }
1387
237
    if(m_settingsPath.isEmpty()) {
589
}
1388
238
        qWarning() << "Tried to destroy nonexisting hotspot.\n";
590
1389
591
1390
592
bool HotspotManager::destroy(QDBusObjectPath path) {
1391
593
    if(path.path().isEmpty()) {
1392
594
        return false;
1393
595
    }
1394
596
1395
597
    // Connection Settings interface proxy for the connection
1396
598
    // we are about to delete.
1397
599
    OrgFreedesktopNetworkManagerSettingsConnectionInterface conn(
1398
600
        nm_service, path.path(), QDBusConnection::systemBus());
1399
601
1400
602
    // Subscribe to the connection proxy's Removed signal.
1401
603
    conn.connection().connect(conn.service(), path.path(), conn.interface(),
1402
604
        "Removed", this, SLOT(onRemoved()));
1403
605
1404
606
    auto del = conn.Delete();
1405
607
    del.waitForFinished();
1406
608
    return del.isValid();
1407
609
}
1408
610
1409
611
void HotspotManager::onRemoved() {
1410
612
    // The UI does not support direct deletion of a hotspot, and given how
1411
613
    // hotspots currently work, every time we want to re-use a hotspot, we
1412
614
    // delete it an add a new one.
1413
615
    // Thus, if a hotspot was deleted, we now create a new one.
1414
616
    m_hotspot_path = addConnection(m_ssid, m_password, m_device_path, m_mode);
1415
617
1416
618
    // We could not add a connection, so report, disable and unblock.
1417
619
    if (m_hotspot_path.path().isEmpty()) {
1418
620
        // Emit "Unknown Error".
1419
621
        Q_EMIT reportError(0);
1420
622
        setEnable(false);
1421
623
        setWifiBlock(false);
1422
624
    }
1423
625
}
1424
626
1425
627
void HotspotManager::onPropertiesChanged(QVariantMap properties) {
1426
628
    // If we have no hotspot path, ignore changes in NetworkManager.
1427
629
    if (m_hotspot_path.path().isEmpty()) {
1428
239
        return;
630
        return;
1429
240
    }
631
    }
1437
241
    QDBusInterface control(nm_service, m_settingsPath, nm_connection_interface,
632
1438
242
            QDBusConnection::systemBus());
633
    // Set flag so we know that ActiveConnections changed.
1439
243
    QDBusReply<void> reply = control.call("Delete");
634
    bool active_connection_changed = false;
1440
244
    if(!reply.isValid()) {
635
1441
245
        qWarning() << "Could not disconnect adhoc network: " << reply.error().message() << "\n";
636
    for(QVariantMap::const_iterator iter = properties.begin(); iter != properties.end(); ++iter) {
1442
246
    } else {
637
        if (iter.key() == "ActiveConnections") {
1443
247
        m_isActive = false;
638
            active_connection_changed = true;
1444
639
1445
640
            const QDBusArgument args = qvariant_cast<QDBusArgument>(iter.value());
1446
641
            if (args.currentType() == QDBusArgument::ArrayType) {
1447
642
                args.beginArray();
1448
643
1449
644
                while (!args.atEnd()) {
1450
645
                    QDBusObjectPath path = qdbus_cast<QDBusObjectPath>(args);
1451
646
1452
647
                    QDBusInterface active_connection_dbus_interface(
1453
648
                        nm_service, path.path(), dbus_properties_interface,
1454
649
                        QDBusConnection::systemBus());
1455
650
1456
651
                    QDBusReply<QVariant> connection_property = active_connection_dbus_interface.call(
1457
652
                        "Get", nm_connection_active_interface, "Connection");
1458
653
1459
654
                    // Active connection did not have a connection property,
1460
655
                    // so ignore it.
1461
656
                    if(!connection_property.isValid()) {
1462
657
                        continue;
1463
658
                    }
1464
659
1465
660
                    QDBusObjectPath connection_path = qvariant_cast<QDBusObjectPath>(
1466
661
                        connection_property.value());
1467
662
1468
663
                    // We see our connection as being active, so we emit that is
1469
664
                    // enabled and return.
1470
665
                    if (connection_path == m_hotspot_path) {
1471
666
                        setEnable(true);
1472
667
                        return;
1473
668
                    }
1474
669
                }
1475
670
                args.endArray();
1476
671
            }
1477
672
        }
1478
673
    }
1479
674
1480
675
    // At this point ActiveConnections changed, but
1481
676
    // our hotspot was not in that list.
1482
677
    if (active_connection_changed) {
1483
678
        setEnable(false);
1484
679
    }
1485
680
}
1486
681
1487
682
void HotspotManager::updateSettingsFromDbus(QDBusObjectPath path) {
1488
683
    setEnable(isHotspotActive(m_hotspot_path));
1489
684
1490
685
    nmConnectionArg settings = getConnectionSettings(path);
1491
686
    const char wifi_key[] = "802-11-wireless";
1492
687
    const char security_key[] = "802-11-wireless-security";
1493
688
1494
689
    if (settings.find(wifi_key) != settings.end()) {
1495
690
        QByteArray ssid = settings[wifi_key]["ssid"].toByteArray();
1496
691
        if (!ssid.isEmpty()) {
1497
692
            setSsid(ssid);
1498
693
        }
1499
694
1500
695
        QString mode = settings[wifi_key]["mode"].toString();
1501
696
        if (!mode.isEmpty()) {
1502
697
            setMode(mode);
1503
698
        }
1504
699
    }
1505
700
1506
701
    nmConnectionArg secrets = getConnectionSecrets(path, security_key);
1507
702
1508
703
    if (secrets.find(security_key) != secrets.end()) {
1509
704
        QString pwd = secrets[security_key]["psk"].toString();
1510
705
        if (!pwd.isEmpty()) {
1511
706
            setPassword(pwd);
1512
707
        }
1513
248
    }
708
    }
1514
249
}
709
}
1515
250
710
1516
=== modified file 'plugins/cellular/hotspotmanager.h'
1517
--- plugins/cellular/hotspotmanager.h	2014-07-23 13:44:31 +0000
1518
+++ plugins/cellular/hotspotmanager.h	2015-05-18 15:06:15 +0000
1519
@@ -1,8 +1,9 @@
1520
1
/*
1
/*
1522
2
 * Copyright (C) 2014 Canonical, Ltd.
2
 * Copyright (C) 2014, 2015 Canonical, Ltd.
1523
3
 *
3
 *
1524
4
 * Authors:
4
 * Authors:
1525
5
 *    Jussi Pakkanen <jussi.pakkanen@canonical.com>
5
 *    Jussi Pakkanen <jussi.pakkanen@canonical.com>
1526
6
 *    Jonas G. Drange <jonas.drange@canonical.com>
1527
6
 *
7
 *
1528
7
 * This program is free software: you can redistribute it and/or modify it
8
 * This program is free software: you can redistribute it and/or modify it
1529
8
 * under the terms of the GNU General Public License version 3, as published
9
 * under the terms of the GNU General Public License version 3, as published
1530
@@ -15,39 +16,166 @@
1531
15
 *
16
 *
1532
16
 * You should have received a copy of the GNU General Public License
17
 * You should have received a copy of the GNU General Public License
1533
17
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1535
18
 */
19
 *
1536
20
 *
1537
21
 * HotspotManager API
1538
22
 * ==============================
1539
23
 *
1540
24
 * Methods
1541
25
 *
1542
26
 * Signals
1543
27
 *   enabledChanged(bool enabled)
1544
28
 *     Signal that gets emitted when the hotspot is disabled or enabled.
1545
29
 *
1546
30
 *   storedChanged(bool stored)
1547
31
 *     Signal that gets emitted when a hotspot was stored.
1548
32
 *
1549
33
 *   ssidChanged(QByteArray ssid)
1550
34
 *     Signal that gets emitted when the ssid of the hotspot was changed.
1551
35
 *
1552
36
 *   passwordChanged(QString password)
1553
37
 *     Signal that gets emitted when the password of the hotspot was changed.
1554
38
 *
1555
39
 *   modeChanged(QString mode)
1556
40
 *     Signal that gets emitted when the mode was changed.
1557
41
 *
1558
42
 *   authChanged(QString auth)
1559
43
 *
1560
44
 *   Note that none of these signal will be emitted if a change to the hotspot
1561
45
 *   was made by anyone else than the HotspotManager. Right now, the canonical
1562
46
 *   way to edit a hotspot, is through the hotspot manager.
1563
47
 *
1564
48
 *
1565
49
 *   reportError(int reason)
1566
50
 *     The reasons correspond to https://developer.gnome.org/
1567
51
 *         NetworkManager/0.9/spec.html#type-NM_DEVICE_STATE_REASON
1568
52
 *
1569
53
 * Properties
1570
54
 *   bool enabled [readwrite]
1571
55
 *     Whether or not the hotspot is enabled.
1572
56
 *
1573
57
 *   bool stored [readonly]
1574
58
 *     Whether or not a hotspot is known to the hotspotmanager.
1575
59
 *
1576
60
 *   QByteArray ssid [readwrite]
1577
61
 *     The current SSID of the hotspot.
1578
62
 *
1579
63
 *   QString auth [readwrite]
1580
64
 *     The current authentication of the hotspot. The default for this property
1581
65
 *     is "wpa-psk" and is currently the only supported scheme. WEP is unsupported
1582
66
 *     by design, as is no scheme at all.
1583
67
 *
1584
68
 *     TODO: Check/add support for wpa-eap
1585
69
 *
1586
70
 *   QString password [readwrite]
1587
71
 *     The current Pre-Shared-Key for the hotspot. If the key is 64-characters
1588
72
 *     long, it must contain only hexadecimal characters and is interpreted as a
1589
73
 *     hexadecimal WPA key. Otherwise, the key must be between 8 and 63 ASCII
1590
74
 *     characters and is interpreted as a WPA passphrase.
1591
75
 *
1592
76
 *   QString mode [readwrite, optional]
1593
77
 *     The current hotspot mode. The default of this value is "ap", but can be
1594
78
 *     set to "p2p" or "adhoc". "p2p" and "adhoc" is currently not fully supported.
1595
79
 *
1596
80
 *     TODO: Complete support for adhoc and p2p modes.
1597
81
*/
1598
19
82
1601
20
#ifndef CELLULAR_DBUS_HELPER
83
#ifndef HOTSPOTMANAGER_H
1602
21
#define CELLULAR_DBUS_HELPER
84
#define HOTSPOTMANAGER_H
1603
22
85
1604
23
#include <QObject>
86
#include <QObject>
1605
24
#include <QDBusObjectPath>
87
#include <QDBusObjectPath>
1609
25
/**
88
#include <QUuid>
1610
26
 * For exposing dbus data to Qml.
89
1611
27
 */
90
#include "nm_manager_proxy.h"
1612
91
#include "nm_settings_proxy.h"
1613
92
#include "nm_settings_connection_proxy.h"
1614
28
93
1615
29
class HotspotManager : public QObject {
94
class HotspotManager : public QObject {
1616
30
    Q_OBJECT
95
    Q_OBJECT
1617
96
    Q_PROPERTY( bool enabled
1618
97
        READ enabled
1619
98
        WRITE setEnabled
1620
99
        NOTIFY enabledChanged)
1621
100
    Q_PROPERTY( QByteArray ssid
1622
101
        READ ssid
1623
102
        WRITE setSsid
1624
103
        NOTIFY ssidChanged)
1625
104
    Q_PROPERTY( QString auth
1626
105
        READ auth
1627
106
        WRITE setAuth
1628
107
        NOTIFY authChanged)
1629
108
    Q_PROPERTY( QString password
1630
109
        READ password
1631
110
        WRITE setPassword
1632
111
        NOTIFY passwordChanged)
1633
112
    Q_PROPERTY( QString mode
1634
113
        READ mode
1635
114
        WRITE setMode
1636
115
        NOTIFY modeChanged)
1637
116
    Q_PROPERTY( bool stored
1638
117
        READ stored
1639
118
        NOTIFY storedChanged)
1640
31
119
1641
32
public:
120
public:
1642
33
    explicit HotspotManager(QObject *parent = nullptr);
121
    explicit HotspotManager(QObject *parent = nullptr);
1643
34
    ~HotspotManager() {};
122
    ~HotspotManager() {};
1644
35
123
1652
36
    Q_INVOKABLE QByteArray getHotspotName();
124
    bool enabled() const;
1653
37
    Q_INVOKABLE QString getHotspotPassword();
125
    void setEnabled(bool);
1654
38
    Q_INVOKABLE void setupHotspot(QByteArray ssid, QString password);
126
    bool stored() const;
1655
39
    Q_INVOKABLE bool isHotspotActive();
127
1656
40
    Q_INVOKABLE void enableHotspot();
128
    QByteArray ssid() const;
1657
41
    Q_INVOKABLE void disableHotspot();
129
    void setSsid(QByteArray);
1658
42
    void destroyHotspot();
130
1659
131
    QString password() const;
1660
132
    void setPassword(QString);
1661
133
1662
134
    QString mode() const;
1663
135
    void setMode(QString);
1664
136
1665
137
    QString auth() const;
1666
138
    void setAuth(QString);
1667
139
1668
140
Q_SIGNALS:
1669
141
    void enabledChanged(bool enabled);
1670
142
    void storedChanged(bool stored);
1671
143
    void ssidChanged(const QByteArray ssid);
1672
144
    void passwordChanged(const QString password);
1673
145
    void modeChanged(const QString mode);
1674
146
    void authChanged(const QString auth);
1675
147
1676
148
    /*
1677
149
    The mapping of code to string is taken from
1678
150
    http://bazaar.launchpad.net/~vcs-imports/
1679
151
      network-manager/trunk/view/head:/cli/src/common.c
1680
152
1681
153
    NetworkManager documentation: https://developer.gnome.org/
1682
154
      NetworkManager/0.9/spec.html#type-NM_DEVICE_STATE_REASON
1683
155
    */
1684
156
    void reportError(const int &reason);
1685
157
1686
158
public Q_SLOTS:
1687
159
    void onNewConnection(const QDBusObjectPath);
1688
160
    void onRemoved();
1689
161
    void onPropertiesChanged(const QVariantMap);
1690
43
162
1691
44
private:
163
private:
1692
164
    QString m_mode;
1693
165
    bool m_enabled;
1694
166
    bool m_stored;
1695
167
    QString m_password;
1696
45
    QByteArray m_ssid;
168
    QByteArray m_ssid;
1701
46
    QString m_password;
169
    QDBusObjectPath m_device_path;
1702
47
    QString m_settingsPath;
170
    QDBusObjectPath m_hotspot_path;
1703
48
    QDBusObjectPath m_devicePath;
171
1704
49
    bool m_isActive;
172
    void disable();
1705
173
1706
174
    bool destroy(QDBusObjectPath);
1707
175
1708
176
    void setStored(bool);
1709
177
    void setEnable(bool);
1710
178
    void updateSettingsFromDbus(QDBusObjectPath);
1711
50
};
179
};
1712
51
180
1713
52
1714
53
#endif
181
#endif
1715
54
182
1716
=== modified file 'plugins/system-update/system_update.cpp'
1717
--- plugins/system-update/system_update.cpp	2014-10-28 17:49:47 +0000
1718
+++ plugins/system-update/system_update.cpp	2015-05-18 15:06:15 +0000
1719
@@ -105,6 +105,7 @@
1720
105
    reply.waitForFinished();
105
    reply.waitForFinished();
1721
106
    if (reply.isValid()) {
106
    if (reply.isValid()) {
1722
107
        m_currentBuildNumber = reply.argumentAt<0>();
107
        m_currentBuildNumber = reply.argumentAt<0>();
1723
108
        m_deviceName = reply.argumentAt<2>();
1724
108
        m_lastUpdateDate = QDateTime::fromString(reply.argumentAt<3>(), Qt::ISODate);
109
        m_lastUpdateDate = QDateTime::fromString(reply.argumentAt<3>(), Qt::ISODate);
1725
109
        m_detailedVersion = reply.argumentAt<4>();
110
        m_detailedVersion = reply.argumentAt<4>();
1726
110
        Q_EMIT versionChanged();
111
        Q_EMIT versionChanged();
1727
@@ -129,6 +130,12 @@
1728
129
    return target > current;
130
    return target > current;
1729
130
}
131
}
1730
131
132
1731
133
QString SystemUpdate::deviceName() {
1732
134
        if (m_deviceName.isNull())
1733
135
            setCurrentDetailedVersion();
1734
136
1735
137
        return m_deviceName;
1736
138
}
1737
132
139
1738
133
QDateTime SystemUpdate::lastUpdateDate() {
140
QDateTime SystemUpdate::lastUpdateDate() {
1739
134
    if (!m_lastUpdateDate.isValid())
141
    if (!m_lastUpdateDate.isValid())
1740
135
142
1741
=== modified file 'plugins/system-update/system_update.h'
1742
--- plugins/system-update/system_update.h	2014-09-26 20:14:54 +0000
1743
+++ plugins/system-update/system_update.h	2015-05-18 15:06:15 +0000
1744
@@ -48,6 +48,7 @@
1745
48
    int currentBuildNumber();
48
    int currentBuildNumber();
1746
49
    QString currentUbuntuBuildNumber();
49
    QString currentUbuntuBuildNumber();
1747
50
    QString currentDeviceBuildNumber();
50
    QString currentDeviceBuildNumber();
1748
51
    QString deviceName();
1749
51
52
1750
52
    void checkForUpdate();
53
    void checkForUpdate();
1751
53
    void downloadUpdate();
54
    void downloadUpdate();
1752
@@ -80,6 +81,7 @@
1753
80
    QMap<QString, QString> m_detailedVersion;
81
    QMap<QString, QString> m_detailedVersion;
1754
81
    QDateTime m_lastUpdateDate;
82
    QDateTime m_lastUpdateDate;
1755
82
    int m_downloadMode;
83
    int m_downloadMode;
1756
84
    QString m_deviceName;
1757
83
85
1758
84
    QDBusConnection m_systemBusConnection;
86
    QDBusConnection m_systemBusConnection;
1759
85
    QString m_objectPath;
87
    QString m_objectPath;
1760
86
88
1761
=== modified file 'plugins/system-update/update_manager.h'
1762
--- plugins/system-update/update_manager.h	2015-03-16 13:51:36 +0000
1763
+++ plugins/system-update/update_manager.h	2015-05-18 15:06:15 +0000
1764
@@ -62,6 +62,8 @@
1765
62
               NOTIFY versionChanged)
62
               NOTIFY versionChanged)
1766
63
    Q_PROPERTY(QString currentDeviceBuildNumber READ currentDeviceBuildNumber
63
    Q_PROPERTY(QString currentDeviceBuildNumber READ currentDeviceBuildNumber
1767
64
               NOTIFY versionChanged)
64
               NOTIFY versionChanged)
1768
65
    Q_PROPERTY(QString deviceName READ deviceName
1769
66
               NOTIFY deviceNameChanged)
1770
65
67
1771
66
Q_SIGNALS:
68
Q_SIGNALS:
1772
67
    void checkFinished();
69
    void checkFinished();
1773
@@ -78,6 +80,7 @@
1774
78
    void updateProcessFailed(QString message);
80
    void updateProcessFailed(QString message);
1775
79
    void systemUpdateFailed(int consecutiveFailureCount, QString lastReason);
81
    void systemUpdateFailed(int consecutiveFailureCount, QString lastReason);
1776
80
    void versionChanged();
82
    void versionChanged();
1777
83
    void deviceNameChanged();
1778
81
    void rebooting(bool status);
84
    void rebooting(bool status);
1779
82
85
1780
83
public:
86
public:
1781
@@ -97,6 +100,7 @@
1782
97
    QDateTime lastUpdateDate() { return m_systemUpdate.lastUpdateDate(); }
100
    QDateTime lastUpdateDate() { return m_systemUpdate.lastUpdateDate(); }
1783
98
    QString currentUbuntuBuildNumber() { return m_systemUpdate.currentUbuntuBuildNumber(); }
101
    QString currentUbuntuBuildNumber() { return m_systemUpdate.currentUbuntuBuildNumber(); }
1784
99
    QString currentDeviceBuildNumber() { return m_systemUpdate.currentDeviceBuildNumber(); }
102
    QString currentDeviceBuildNumber() { return m_systemUpdate.currentDeviceBuildNumber(); }
1785
103
    QString deviceName() { return m_systemUpdate.deviceName(); }
1786
100
    bool checkTarget() { return m_systemUpdate.checkTarget(); }
104
    bool checkTarget() { return m_systemUpdate.checkTarget(); }
1787
101
105
1788
102
106
1789
103
107
1790
=== modified file 'tests/autopilot/ubuntu_system_settings/__init__.py'
1791
--- tests/autopilot/ubuntu_system_settings/__init__.py	2015-05-12 16:29:02 +0000
1792
+++ tests/autopilot/ubuntu_system_settings/__init__.py	2015-05-18 15:06:15 +0000
1793
@@ -306,6 +306,138 @@
1794
306
        field.write(name)
306
        field.write(name)
1795
307
        self.pointing_device.click_object(ok)
307
        self.pointing_device.click_object(ok)
1796
308
308
1797
309
    """
1798
310
    :returns: Whether or not hotspot can be used.
1799
311
    """
1800
312
    @autopilot.logging.log_action(logger.debug)
1801
313
    def have_hotspot(self):
1802
314
        return self.wait_select_single(objectName='hotspotEntry').visible
1803
315
1804
316
    """
1805
317
    :param: Configuration with keys ssid and password.
1806
318
    :returns: Hotspot page.
1807
319
    """
1808
320
    @autopilot.logging.log_action(logger.debug)
1809
321
    def setup_hotspot(self, config=None):
1810
322
        hotspot_page = self._enter_hotspot()
1811
323
        hotspot_page.setup_hotspot(config)
1812
324
        return hotspot_page
1813
325
1814
326
    """
1815
327
    Enables hotspot.
1816
328
    :returns: Hotspot page.
1817
329
    """
1818
330
    @autopilot.logging.log_action(logger.debug)
1819
331
    def enable_hotspot(self):
1820
332
        hotspot_page = self._enter_hotspot()
1821
333
        hotspot_page.enable_hotspot()
1822
334
        return hotspot_page
1823
335
1824
336
    """
1825
337
    Disables hotspot.
1826
338
    :returns: Hotspot page.
1827
339
    """
1828
340
    @autopilot.logging.log_action(logger.debug)
1829
341
    def disable_hotspot(self):
1830
342
        hotspot_page = self._enter_hotspot()
1831
343
        hotspot_page.disable_hotspot()
1832
344
        return hotspot_page
1833
345
1834
346
    @autopilot.logging.log_action(logger.debug)
1835
347
    def _enter_hotspot(self):
1836
348
        obj = self.wait_select_single(objectName="hotspotEntry")
1837
349
        self.pointing_device.click_object(obj)
1838
350
        return self.get_root_instance().wait_select_single(
1839
351
            objectName='hotspotPage')
1840
352
1841
353
1842
354
class Hotspot(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
1843
355
1844
356
    """Autopilot helper for Hotspot page."""
1845
357
1846
358
    @classmethod
1847
359
    def validate_dbus_object(cls, path, state):
1848
360
        name = introspection.get_classname_from_path(path)
1849
361
        if name == b'ItemPage':
1850
362
            if state['objectName'][1] == 'hotspotPage':
1851
363
                return True
1852
364
        return False
1853
365
1854
366
    @property
1855
367
    def _switch(self):
1856
368
        return self.wait_select_single(
1857
369
            ubuntuuitoolkit.CheckBox,
1858
370
            objectName='hotspotSwitch')
1859
371
1860
372
    @autopilot.logging.log_action(logger.debug)
1861
373
    def enable_hotspot(self):
1862
374
        self._switch.check()
1863
375
1864
376
    @autopilot.logging.log_action(logger.debug)
1865
377
    def disable_hotspot(self):
1866
378
        self._switch.uncheck()
1867
379
1868
380
    @autopilot.logging.log_action(logger.debug)
1869
381
    def setup_hotspot(self, config):
1870
382
        obj = self.select_single(objectName='hotspotSetupEntry')
1871
383
        self.pointing_device.click_object(obj)
1872
384
        setup = self.get_root_instance().wait_select_single(
1873
385
            objectName='hotspotSetup')
1874
386
        if config:
1875
387
            if 'ssid' in config:
1876
388
                setup.set_ssid(config['ssid'])
1877
389
            if 'password' in config:
1878
390
                setup.set_password(config['password'])
1879
391
        setup.enable()
1880
392
        if setup:
1881
393
            setup.wait_until_destroyed()
1882
394
1883
395
    @autopilot.logging.log_action(logger.debug)
1884
396
    def get_hotspot_status(self):
1885
397
        return self._switch.checked
1886
398
1887
399
1888
400
class HotspotSetup(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
1889
401
1890
402
    """Autopilot helper for Hotspot setup."""
1891
403
1892
404
    @classmethod
1893
405
    def validate_dbus_object(cls, path, state):
1894
406
        name = introspection.get_classname_from_path(path)
1895
407
        if name == b'Dialog':
1896
408
            if state['objectName'][1] == 'hotspotSetup':
1897
409
                return True
1898
410
        return False
1899
411
1900
412
    @property
1901
413
    def _ssid_field(self):
1902
414
        return self.wait_select_single(
1903
415
            ubuntuuitoolkit.TextField,
1904
416
            objectName='ssidField')
1905
417
1906
418
    @property
1907
419
    def _password_field(self):
1908
420
        return self.wait_select_single(
1909
421
            ubuntuuitoolkit.TextField,
1910
422
            objectName='passwordField')
1911
423
1912
424
    @property
1913
425
    def _enable_button(self):
1914
426
        return self.wait_select_single(
1915
427
            'Button', objectName='confirmButton')
1916
428
1917
429
    @autopilot.logging.log_action(logger.debug)
1918
430
    def set_ssid(self, ssid):
1919
431
        self._ssid_field.write(ssid)
1920
432
1921
433
    @autopilot.logging.log_action(logger.debug)
1922
434
    def set_password(self, password):
1923
435
        self._password_field.write(password)
1924
436
1925
437
    @autopilot.logging.log_action(logger.debug)
1926
438
    def enable(self):
1927
439
        self.pointing_device.click_object(self._enable_button)
1928
440
1929
309
441
1930
310
class BluetoothPage(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
442
class BluetoothPage(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
1931
311
443
1932
312
444
1933
=== modified file 'tests/autopilot/ubuntu_system_settings/tests/__init__.py'
1934
--- tests/autopilot/ubuntu_system_settings/tests/__init__.py	2015-04-16 15:24:41 +0000
1935
+++ tests/autopilot/ubuntu_system_settings/tests/__init__.py	2015-05-18 15:06:15 +0000
1936
@@ -31,7 +31,6 @@
1937
31
from gi.repository import UPowerGlib
31
from gi.repository import UPowerGlib
1938
32
from testtools.matchers import Equals, NotEquals, GreaterThan
32
from testtools.matchers import Equals, NotEquals, GreaterThan
1939
33
33
1940
34
1941
35
ACCOUNTS_IFACE = 'org.freedesktop.Accounts'
34
ACCOUNTS_IFACE = 'org.freedesktop.Accounts'
1942
36
ACCOUNTS_USER_IFACE = 'org.freedesktop.Accounts.User'
35
ACCOUNTS_USER_IFACE = 'org.freedesktop.Accounts.User'
1943
37
ACCOUNTS_OBJ = '/org/freedesktop/Accounts'
36
ACCOUNTS_OBJ = '/org/freedesktop/Accounts'
1944
@@ -384,6 +383,68 @@
1945
384
        self.cellular_page = self.main_view.go_to_cellular_page()
383
        self.cellular_page = self.main_view.go_to_cellular_page()
1946
385
384
1947
386
385
1948
386
class HotspotBaseTestCase(CellularBaseTestCase):
1949
387
1950
388
    @classmethod
1951
389
    def setUpClass(cls):
1952
390
        super(HotspotBaseTestCase, cls).setUpClass()
1953
391
        nm_tmpl = os.path.join(os.path.dirname(__file__), 'networkmanager.py')
1954
392
        (cls.n_mock, cls.obj_nm) = cls.spawn_server_template(
1955
393
            nm_tmpl, stdout=subprocess.PIPE)
1956
394
        (cls.u_mock, cls.obj_urf) = cls.spawn_server_template(
1957
395
            'urfkill', stdout=subprocess.PIPE)
1958
396
1959
397
    @classmethod
1960
398
    def tearDownClass(cls):
1961
399
        cls.n_mock.terminate()
1962
400
        cls.n_mock.wait()
1963
401
        cls.u_mock.terminate()
1964
402
        cls.u_mock.wait()
1965
403
        super(HotspotBaseTestCase, cls).tearDownClass()
1966
404
1967
405
    def tearDown(self):
1968
406
        self.obj_nm.Reset()
1969
407
        self.urfkill_mock.ClearCalls()
1970
408
        super(HotspotBaseTestCase, self).tearDown()
1971
409
1972
410
    def setUp(self):
1973
411
        self.patch_environment("USS_SHOW_ALL_UI", "1")
1974
412
        self.nm_mock = dbus.Interface(self.obj_nm, dbusmock.MOCK_IFACE)
1975
413
        self.device_path = self.obj_nm.AddWiFiDevice('test0', 'Barbaz', 1)
1976
414
        self.device_mock = dbus.Interface(self.dbus_con.get_object(
1977
415
            NM_SERVICE, self.device_path),
1978
416
            'org.freedesktop.DBus.Properties')
1979
417
        self.urfkill_mock = dbus.Interface(self.obj_urf, dbusmock.MOCK_IFACE)
1980
418
        super(HotspotBaseTestCase, self).setUp()
1981
419
1982
420
    def add_hotspot(self, name, password, secured=True, enabled=False):
1983
421
        settings = {
1984
422
            'connection': {
1985
423
                'id': dbus.String('Test AP', variant_level=1),
1986
424
                'type': dbus.String('802-11-wireless', variant_level=1), },
1987
425
            '802-11-wireless': {
1988
426
                'mode': dbus.String('ap', variant_level=1),
1989
427
                'ssid': dbus.String(name, variant_level=1),
1990
428
            }
1991
429
        }
1992
430
1993
431
        if secured:
1994
432
            settings['802-11-wireless']['security'] = dbus.String(
1995
433
                '802-11-wireless-security', variant_level=1)
1996
434
            settings['802-11-wireless-security'] = {
1997
435
                'auth-alg': dbus.String('shared', variant_level=1),
1998
436
                'key-mgmt': dbus.String('wpa-psk', variant_level=1),
1999
437
                'psk': dbus.String(password, variant_level=1),
2000
438
            }
2001
439
2002
440
        if enabled:
2003
441
            settings['connection']['autoconnect'] = True
2004
442
2005
443
        connection_path = self.obj_nm.SettingsAddConnection(settings)
2006
444
2007
445
        return connection_path
2008
446
2009
447
2010
387
class BluetoothBaseTestCase(UbuntuSystemSettingsTestCase):
448
class BluetoothBaseTestCase(UbuntuSystemSettingsTestCase):
2011
388
449
2012
389
    def setUp(self):
450
    def setUp(self):
2013
390
451
2014
=== added file 'tests/autopilot/ubuntu_system_settings/tests/networkmanager.py'
2015
--- tests/autopilot/ubuntu_system_settings/tests/networkmanager.py	1970-01-01 00:00:00 +0000
2016
+++ tests/autopilot/ubuntu_system_settings/tests/networkmanager.py	2015-05-18 15:06:15 +0000
2017
@@ -0,0 +1,902 @@
2018
1
'''NetworkManager mock template
2019
2
2020
3
This creates the expected methods and properties of the main
2021
4
org.freedesktop.NetworkManager object, but no devices. You can specify any
2022
5
property such as 'NetworkingEnabled', or 'WirelessEnabled' etc. in
2023
6
"parameters".
2024
7
'''
2025
8
2026
9
# This program is free software; you can redistribute it and/or modify it under
2027
10
# the terms of the GNU Lesser General Public License as published by the Free
2028
11
# Software Foundation; either version 3 of the License, or (at your option) any
2029
12
# later version.  See http://www.gnu.org/copyleft/lgpl.html for the full text
2030
13
# of the license.
2031
14
2032
15
__author__ = 'Iftikhar Ahmad'
2033
16
__email__ = 'iftikhar.ahmad@canonical.com'
2034
17
__copyright__ = '(c) 2012 Canonical Ltd.'
2035
18
__license__ = 'LGPL 3+'
2036
19
2037
20
import dbus
2038
21
import uuid
2039
22
import binascii
2040
23
2041
24
from dbusmock import MOCK_IFACE
2042
25
import dbusmock
2043
26
2044
27
2045
28
BUS_NAME = 'org.freedesktop.NetworkManager'
2046
29
MAIN_OBJ = '/org/freedesktop/NetworkManager'
2047
30
MAIN_IFACE = 'org.freedesktop.NetworkManager'
2048
31
SETTINGS_OBJ = '/org/freedesktop/NetworkManager/Settings'
2049
32
SETTINGS_IFACE = 'org.freedesktop.NetworkManager.Settings'
2050
33
DEVICE_IFACE = 'org.freedesktop.NetworkManager.Device'
2051
34
WIRELESS_DEVICE_IFACE = 'org.freedesktop.NetworkManager.Device.Wireless'
2052
35
ACCESS_POINT_IFACE = 'org.freedesktop.NetworkManager.AccessPoint'
2053
36
CSETTINGS_IFACE = 'org.freedesktop.NetworkManager.Settings.Connection'
2054
37
ACTIVE_CONNECTION_IFACE = 'org.freedesktop.NetworkManager.Connection.Active'
2055
38
SYSTEM_BUS = True
2056
39
2057
40
2058
41
class NMState:
2059
42
    '''Global state
2060
43
2061
44
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2062
45
    type-NM_STATE
2063
46
    '''
2064
47
    NM_STATE_UNKNOWN = 0
2065
48
    NM_STATE_ASLEEP = 10
2066
49
    NM_STATE_DISCONNECTED = 20
2067
50
    NM_STATE_DISCONNECTING = 30
2068
51
    NM_STATE_CONNECTING = 40
2069
52
    NM_STATE_CONNECTED_LOCAL = 50
2070
53
    NM_STATE_CONNECTED_SITE = 60
2071
54
    NM_STATE_CONNECTED_GLOBAL = 70
2072
55
2073
56
2074
57
class NMConnectivityState:
2075
58
    '''Connectvity state
2076
59
2077
60
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2078
61
    type-NM_CONNECTIVITY
2079
62
    '''
2080
63
    NM_CONNECTIVITY_UNKNOWN = 0
2081
64
    NM_CONNECTIVITY_NONE = 1
2082
65
    NM_CONNECTIVITY_PORTAL = 2
2083
66
    NM_CONNECTIVITY_LIMITED = 3
2084
67
    NM_CONNECTIVITY_FULL = 4
2085
68
2086
69
2087
70
class NMActiveConnectionState:
2088
71
    '''Active connection state
2089
72
2090
73
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2091
74
    type-NM_ACTIVE_CONNECTION_STATE
2092
75
    '''
2093
76
    NM_ACTIVE_CONNECTION_STATE_UNKNOWN = 0
2094
77
    NM_ACTIVE_CONNECTION_STATE_ACTIVATING = 1
2095
78
    NM_ACTIVE_CONNECTION_STATE_ACTIVATED = 2
2096
79
    NM_ACTIVE_CONNECTION_STATE_DEACTIVATING = 3
2097
80
    NM_ACTIVE_CONNECTION_STATE_DEACTIVATED = 4
2098
81
2099
82
2100
83
class InfrastructureMode:
2101
84
    '''Infrastructure mode
2102
85
2103
86
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2104
87
    type-NM_802_11_MODE
2105
88
    '''
2106
89
    NM_802_11_MODE_UNKNOWN = 0
2107
90
    NM_802_11_MODE_ADHOC = 1
2108
91
    NM_802_11_MODE_INFRA = 2
2109
92
    NM_802_11_MODE_AP = 3
2110
93
2111
94
    NAME_MAP = {
2112
95
        NM_802_11_MODE_UNKNOWN: 'unknown',
2113
96
        NM_802_11_MODE_ADHOC: 'adhoc',
2114
97
        NM_802_11_MODE_INFRA: 'infrastructure',
2115
98
        NM_802_11_MODE_AP: 'access-point',
2116
99
    }
2117
100
2118
101
2119
102
class DeviceState:
2120
103
    '''Device states
2121
104
2122
105
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2123
106
    type-NM_DEVICE_STATE
2124
107
    '''
2125
108
    UNKNOWN = 0
2126
109
    UNMANAGED = 10
2127
110
    UNAVAILABLE = 20
2128
111
    DISCONNECTED = 30
2129
112
    PREPARE = 40
2130
113
    CONFIG = 50
2131
114
    NEED_AUTH = 60
2132
115
    IP_CONFIG = 70
2133
116
    IP_CHECK = 80
2134
117
    SECONDARIES = 90
2135
118
    ACTIVATED = 100
2136
119
    DEACTIVATING = 110
2137
120
    FAILED = 120
2138
121
2139
122
2140
123
class NM80211ApSecurityFlags:
2141
124
    '''Security flags
2142
125
2143
126
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2144
127
    type-NM_802_11_AP_SEC
2145
128
    '''
2146
129
    NM_802_11_AP_SEC_NONE = 0x00000000
2147
130
    NM_802_11_AP_SEC_PAIR_WEP40 = 0x00000001
2148
131
    NM_802_11_AP_SEC_PAIR_WEP104 = 0x00000002
2149
132
    NM_802_11_AP_SEC_PAIR_TKIP = 0x00000004
2150
133
    NM_802_11_AP_SEC_PAIR_CCMP = 0x00000008
2151
134
    NM_802_11_AP_SEC_GROUP_WEP40 = 0x00000010
2152
135
    NM_802_11_AP_SEC_GROUP_WEP104 = 0x00000020
2153
136
    NM_802_11_AP_SEC_GROUP_TKIP = 0x00000040
2154
137
    NM_802_11_AP_SEC_GROUP_CCMP = 0x00000080
2155
138
    NM_802_11_AP_SEC_KEY_MGMT_PSK = 0x00000100
2156
139
    NM_802_11_AP_SEC_KEY_MGMT_802_1X = 0x00000200
2157
140
2158
141
    NAME_MAP = {
2159
142
        NM_802_11_AP_SEC_KEY_MGMT_PSK: {
2160
143
            'key-mgmt': 'wpa-psk',
2161
144
            'auth-alg': 'open'
2162
145
        },
2163
146
    }
2164
147
2165
148
2166
149
class NM80211ApFlags:
2167
150
    '''Device flags
2168
151
2169
152
    As per https://developer.gnome.org/NetworkManager/unstable/spec.html#
2170
153
    type-NM_802_11_AP_FLAGS
2171
154
    '''
2172
155
    NM_802_11_AP_FLAGS_NONE = 0x00000000
2173
156
    NM_802_11_AP_FLAGS_PRIVACY = 0x00000001
2174
157
2175
158
2176
159
def activate_connection(self, conn, dev, ap):
2177
160
    name = ap.rsplit('/', 1)[1]
2178
161
    RemoveActiveConnection(
2179
162
        self, dev, '/org/freedesktop/NetworkManager/ActiveConnection/' + name)
2180
163
2181
164
    state = dbus.UInt32(
2182
165
        NMActiveConnectionState.NM_ACTIVE_CONNECTION_STATE_ACTIVATED)
2183
166
    active_conn = dbus.ObjectPath(
2184
167
        AddActiveConnection(self, [dev], conn, ap, name, state))
2185
168
2186
169
    return active_conn
2187
170
2188
171
2189
172
def deactivate_connection(self, active_conn_path):
2190
173
    NM = dbusmock.get_object(MAIN_OBJ)
2191
174
2192
175
    for dev_path in NM.GetDevices():
2193
176
        RemoveActiveConnection(self, dev_path, active_conn_path)
2194
177
2195
178
2196
179
def add_and_activate_connection(self, conn_conf, dev, ap):
2197
180
    name = ap.rsplit('/', 1)[1]
2198
181
    RemoveWifiConnection(
2199
182
        self, dev, '/org/freedesktop/NetworkManager/Settings/' + name)
2200
183
2201
184
    raw_ssid = ''.join([
2202
185
        chr(byte) for byte in conn_conf["802-11-wireless"]["ssid"]])
2203
186
    wifi_conn = dbus.ObjectPath(
2204
187
        AddWiFiConnection(self, dev, name, raw_ssid, ""))
2205
188
2206
189
    active_conn = activate_connection(self, wifi_conn, dev, ap)
2207
190
2208
191
    return (wifi_conn, active_conn)
2209
192
2210
193
2211
194
def load(mock, parameters):
2212
195
    mock.activate_connection = activate_connection
2213
196
    mock.deactivate_connection = deactivate_connection
2214
197
    mock.add_and_activate_connection = add_and_activate_connection
2215
198
    mock.AddMethods(MAIN_IFACE, [
2216
199
        ('GetDevices', '', 'ao',
2217
200
         'ret = [k for k in objects.keys() if "/Devices" in k]'),
2218
201
        ('GetPermissions', '', 'a{ss}', 'ret = {}'),
2219
202
        ('state', '', 'u', "ret = self.Get('%s', 'State')" % MAIN_IFACE),
2220
203
        (
2221
204
            'CheckConnectivity', '', 'u',
2222
205
            "ret = self.Get('%s', 'Connectivity')" % MAIN_IFACE),
2223
206
        (
2224
207
            'ActivateConnection', 'ooo', 'o',
2225
208
            "ret = self.activate_connection(self, args[0], args[1], args[2])"),
2226
209
        (
2227
210
            'DeactivateConnection', 'o', '',
2228
211
            "self.deactivate_connection(self, args[0])"),
2229
212
        (
2230
213
            'AddAndActivateConnection', 'a{sa{sv}}oo', 'oo',
2231
214
            "ret = self.add_and_activate_connection("
2232
215
            "self, args[0], args[1], args[2])"),
2233
216
    ])
2234
217
2235
218
    mock.AddProperties(
2236
219
        '',
2237
220
        {
2238
221
            'ActiveConnections': dbus.Array([], signature='o'),
2239
222
            'Devices': dbus.Array([], signature='o'),
2240
223
            'NetworkingEnabled': parameters.get('NetworkingEnabled', True),
2241
224
            'Connectivity': parameters.get(
2242
225
                'Connectivity',
2243
226
                dbus.UInt32(NMConnectivityState.NM_CONNECTIVITY_FULL)),
2244
227
            'State': parameters.get(
2245
228
                'State', dbus.UInt32(NMState.NM_STATE_CONNECTED_GLOBAL)),
2246
229
            'Startup': False,
2247
230
            'Version': parameters.get('Version', '0.9.6.0'),
2248
231
            'WimaxEnabled': parameters.get('WimaxEnabled', True),
2249
232
            'WimaxHardwareEnabled': parameters.get(
2250
233
                'WimaxHardwareEnabled', True),
2251
234
            'WirelessEnabled': parameters.get('WirelessEnabled', True),
2252
235
            'WirelessHardwareEnabled': parameters.get(
2253
236
                'WirelessHardwareEnabled', True),
2254
237
            'WwanEnabled': parameters.get('WwanEnabled', False),
2255
238
            'WwanHardwareEnabled': parameters.get('WwanHardwareEnabled', True)
2256
239
        })
2257
240
2258
241
    settings_props = {'Hostname': 'hostname',
2259
242
                      'CanModify': True,
2260
243
                      'Connections': dbus.Array([], signature='o')}
2261
244
    settings_methods = [(
2262
245
                        'ListConnections', '', 'ao',
2263
246
                        "ret = self.Get('%s', 'Connections')" %
2264
247
                        SETTINGS_IFACE),
2265
248
                        ('GetConnectionByUuid', 's', 'o', ''),
2266
249
                        (
2267
250
                            'AddConnection', 'a{sa{sv}}', 'o',
2268
251
                            'ret = self.SettingsAddConnection(args[0])'),
2269
252
                        ('SaveHostname', 's', '', '')]
2270
253
    mock.AddObject(SETTINGS_OBJ,
2271
254
                   SETTINGS_IFACE,
2272
255
                   settings_props,
2273
256
                   settings_methods)
2274
257
2275
258
2276
259
@dbus.service.method(MOCK_IFACE,
2277
260
                     in_signature='sssv', out_signature='')
2278
261
def SetProperty(self, path, iface, name, value):
2279
262
    obj = dbusmock.get_object(path)
2280
263
    obj.Set(iface, name, value)
2281
264
    obj.EmitSignal(iface, 'PropertiesChanged', 'a{sv}', [{name: value}])
2282
265
2283
266
2284
267
@dbus.service.method(MOCK_IFACE,
2285
268
                     in_signature='u', out_signature='')
2286
269
def SetGlobalConnectionState(self, state):
2287
270
    self.SetProperty(MAIN_OBJ, MAIN_IFACE, 'State',
2288
271
                     dbus.UInt32(state, variant_level=1))
2289
272
    self.EmitSignal(MAIN_IFACE, 'StateChanged', 'u', [state])
2290
273
2291
274
2292
275
@dbus.service.method(MOCK_IFACE,
2293
276
                     in_signature='u', out_signature='')
2294
277
def SetConnectivity(self, connectivity):
2295
278
    self.SetProperty(MAIN_OBJ, MAIN_IFACE, 'Connectivity',
2296
279
                     dbus.UInt32(connectivity, variant_level=1))
2297
280
2298
281
2299
282
@dbus.service.method(MOCK_IFACE,
2300
283
                     in_signature='ss', out_signature='')
2301
284
def SetDeviceActive(self, device_path, active_connection_path):
2302
285
    dev_obj = dbusmock.get_object(device_path)
2303
286
    dev_obj.Set(DEVICE_IFACE, 'ActiveConnection',
2304
287
                dbus.ObjectPath(active_connection_path))
2305
288
    old_state = dev_obj.Get(DEVICE_IFACE, 'State')
2306
289
    dev_obj.Set(DEVICE_IFACE, 'State', dbus.UInt32(DeviceState.ACTIVATED))
2307
290
2308
291
    dev_obj.EmitSignal(DEVICE_IFACE, 'StateChanged', 'uuu', [
2309
292
        dbus.UInt32(DeviceState.ACTIVATED), old_state, dbus.UInt32(1)])
2310
293
2311
294
2312
295
@dbus.service.method(MOCK_IFACE,
2313
296
                     in_signature='s', out_signature='')
2314
297
def SetDeviceDisconnected(self, device_path):
2315
298
    dev_obj = dbusmock.get_object(device_path)
2316
299
    dev_obj.Set(DEVICE_IFACE, 'ActiveConnection', dbus.ObjectPath('/'))
2317
300
    old_state = dev_obj.Get(DEVICE_IFACE, 'State')
2318
301
    dev_obj.Set(DEVICE_IFACE, 'State', dbus.UInt32(DeviceState.DISCONNECTED))
2319
302
2320
303
    dev_obj.EmitSignal(DEVICE_IFACE, 'StateChanged', 'uuu', [
2321
304
        dbus.UInt32(DeviceState.DISCONNECTED), old_state, dbus.UInt32(1)])
2322
305
2323
306
2324
307
@dbus.service.method(MOCK_IFACE,
2325
308
                     in_signature='ssi', out_signature='s')
2326
309
def AddEthernetDevice(self, device_name, iface_name, state):
2327
310
    '''Add an ethernet device.
2328
311
2329
312
    You have to specify device_name, device interface name (e. g. eth0), and
2330
313
    state. You can use the predefined DeviceState values (e. g.
2331
314
    DeviceState.ACTIVATED) or supply a numeric value. For valid state values
2332
315
    please visit
2333
316
    http://projects.gnome.org/NetworkManager/developers/api/09/spec.html#
2334
317
    type-NM_DEVICE_STATE
2335
318
2336
319
    Please note that this does not set any global properties.
2337
320
2338
321
    Returns the new object path.
2339
322
    '''
2340
323
    path = '/org/freedesktop/NetworkManager/Devices/' + device_name
2341
324
    wired_props = {'Carrier': False,
2342
325
                   'HwAddress': dbus.String('78:DD:08:D2:3D:43'),
2343
326
                   'PermHwAddress': dbus.String('78:DD:08:D2:3D:43'),
2344
327
                   'Speed': dbus.UInt32(0)}
2345
328
    self.AddObject(path,
2346
329
                   'org.freedesktop.NetworkManager.Device.Wired',
2347
330
                   wired_props,
2348
331
                   [])
2349
332
2350
333
    props = {'DeviceType': dbus.UInt32(1),
2351
334
             'State': dbus.UInt32(state),
2352
335
             'Interface': iface_name,
2353
336
             'AvailableConnections': dbus.Array([], signature='o'),
2354
337
             'IpInterface': ''}
2355
338
2356
339
    obj = dbusmock.get_object(path)
2357
340
    obj.AddProperties(DEVICE_IFACE, props)
2358
341
2359
342
    devices = self.Get(MAIN_IFACE, 'Devices')
2360
343
    devices.append(path)
2361
344
    self.Set(MAIN_IFACE, 'Devices', devices)
2362
345
2363
346
    self.EmitSignal('org.freedesktop.NetworkManager', 'DeviceAdded', 'o',
2364
347
                    [path])
2365
348
2366
349
    return path
2367
350
2368
351
2369
352
@dbus.service.method(MOCK_IFACE,
2370
353
                     in_signature='ssi', out_signature='s')
2371
354
def AddWiFiDevice(self, device_name, iface_name, state):
2372
355
    '''Add a WiFi Device.
2373
356
2374
357
    You have to specify device_name, device interface name (e. g.  wlan0) and
2375
358
    state. You can use the predefined DeviceState values (e. g.
2376
359
    DeviceState.ACTIVATED) or supply a numeric value. For valid state values,
2377
360
    please visit
2378
361
    http://projects.gnome.org/NetworkManager/developers/api/09/spec.html#
2379
362
    type-NM_DEVICE_STATE
2380
363
2381
364
    Please note that this does not set any global properties.
2382
365
2383
366
    Returns the new object path.
2384
367
    '''
2385
368
2386
369
    path = '/org/freedesktop/NetworkManager/Devices/' + device_name
2387
370
    self.AddObject(path,
2388
371
                   WIRELESS_DEVICE_IFACE,
2389
372
                   {
2390
373
                       'HwAddress': dbus.String('11:22:33:44:55:66'),
2391
374
                       'PermHwAddress': dbus.String('11:22:33:44:55:66'),
2392
375
                       'Bitrate': dbus.UInt32(5400),
2393
376
                       'Mode': dbus.UInt32(2),
2394
377
                       'WirelessCapabilities': dbus.UInt32(255),
2395
378
                       'AccessPoints': dbus.Array([], signature='o'),
2396
379
                   },
2397
380
                   [
2398
381
                       ('GetAccessPoints', '', 'ao',
2399
382
                        'ret = self.access_points'),
2400
383
                       ('GetAllAccessPoints', '', 'ao',
2401
384
                        'ret = self.access_points'),
2402
385
                       ('RequestScan', 'a{sv}', '', ''),
2403
386
                   ])
2404
387
2405
388
    dev_obj = dbusmock.get_object(path)
2406
389
    dev_obj.access_points = []
2407
390
    dev_obj.AddProperties(DEVICE_IFACE,
2408
391
                          {
2409
392
                              'ActiveConnection': dbus.ObjectPath('/'),
2410
393
                              'AvailableConnections':
2411
394
                              dbus.Array([], signature='o'),
2412
395
                              'AutoConnect': False,
2413
396
                              'Managed': True,
2414
397
                              'Driver': 'dbusmock',
2415
398
                              'DeviceType': dbus.UInt32(2),
2416
399
                              'State': dbus.UInt32(state),
2417
400
                              'Interface': iface_name,
2418
401
                              'IpInterface': iface_name,
2419
402
                          })
2420
403
2421
404
    devices = self.Get(MAIN_IFACE, 'Devices')
2422
405
    devices.append(path)
2423
406
    self.Set(MAIN_IFACE, 'Devices', devices)
2424
407
2425
408
    self.EmitSignal('org.freedesktop.NetworkManager', 'DeviceAdded', 'o',
2426
409
                    [path])
2427
410
2428
411
    return path
2429
412
2430
413
2431
414
@dbus.service.method(MOCK_IFACE,
2432
415
                     in_signature='ssssuuuyu', out_signature='s')
2433
416
def AddAccessPoint(self, dev_path, ap_name, ssid, hw_address,
2434
417
                   mode, frequency, rate, strength, security):
2435
418
    '''Add an access point to an existing WiFi device.
2436
419
2437
420
    You have to specify WiFi Device path, Access Point object name,
2438
421
    ssid, hw_address, mode, frequency, rate, strength and security.
2439
422
    For valid access point property values, please visit
2440
423
    http://projects.gnome.org/NetworkManager/developers/api/09/spec.html#
2441
424
    org.freedesktop.NetworkManager.AccessPoint
2442
425
2443
426
    Please note that this does not set any global properties.
2444
427
2445
428
    Returns the new object path.
2446
429
    '''
2447
430
    dev_obj = dbusmock.get_object(dev_path)
2448
431
    ap_path = '/org/freedesktop/NetworkManager/AccessPoint/' + ap_name
2449
432
    if ap_path in dev_obj.access_points:
2450
433
        raise dbus.exceptions.DBusException(
2451
434
            'Access point %s on device %s already exists' % (ap_name,
2452
435
                                                             dev_path),
2453
436
            name=MAIN_IFACE + '.AlreadyExists')
2454
437
2455
438
    flags = NM80211ApFlags.NM_802_11_AP_FLAGS_PRIVACY
2456
439
    if security == NM80211ApSecurityFlags.NM_802_11_AP_SEC_NONE:
2457
440
        flags = NM80211ApFlags.NM_802_11_AP_FLAGS_NONE
2458
441
2459
442
    self.AddObject(ap_path,
2460
443
                   ACCESS_POINT_IFACE,
2461
444
                   {'Ssid': dbus.ByteArray(ssid.encode('UTF-8')),
2462
445
                    'HwAddress': dbus.String(hw_address),
2463
446
                    'Flags': dbus.UInt32(flags),
2464
447
                    'LastSeen': dbus.Int32(1),
2465
448
                    'Frequency': dbus.UInt32(frequency),
2466
449
                    'MaxBitrate': dbus.UInt32(rate),
2467
450
                    'Mode': dbus.UInt32(mode),
2468
451
                    'RsnFlags': dbus.UInt32(security),
2469
452
                    'WpaFlags': dbus.UInt32(security),
2470
453
                    'Strength': dbus.Byte(strength)},
2471
454
                   [])
2472
455
2473
456
    dev_obj.access_points.append(ap_path)
2474
457
2475
458
    aps = dev_obj.Get(WIRELESS_DEVICE_IFACE, 'AccessPoints')
2476
459
    aps.append(ap_path)
2477
460
    dev_obj.Set(WIRELESS_DEVICE_IFACE, 'AccessPoints', aps)
2478
461
2479
462
    dev_obj.EmitSignal(WIRELESS_DEVICE_IFACE, 'AccessPointAdded', 'o',
2480
463
                       [ap_path])
2481
464
2482
465
    return ap_path
2483
466
2484
467
2485
468
@dbus.service.method(MOCK_IFACE,
2486
469
                     in_signature='ssss', out_signature='s')
2487
470
def AddWiFiConnection(self, dev_path, connection_name, ssid_name, key_mgmt):
2488
471
    '''Add an available connection to an existing WiFi device and access point.
2489
472
2490
473
    You have to specify WiFi Device path, Connection object name,
2491
474
    SSID and key management.
2492
475
2493
476
    The SSID must match one of the previously created access points.
2494
477
2495
478
    Please note that this does not set any global properties.
2496
479
2497
480
    Returns the new object path.
2498
481
    '''
2499
482
2500
483
    dev_obj = dbusmock.get_object(dev_path)
2501
484
    connection_path = ('/org/freedesktop/NetworkManager/Settings/%s' %
2502
485
                       connection_name)
2503
486
    connections = dev_obj.Get(DEVICE_IFACE, 'AvailableConnections')
2504
487
2505
488
    settings_obj = dbusmock.get_object(SETTINGS_OBJ)
2506
489
    main_connections = settings_obj.ListConnections()
2507
490
2508
491
    ssid = ssid_name.encode('UTF-8')
2509
492
2510
493
    # Find the access point by ssid
2511
494
    access_point = None
2512
495
    access_points = dev_obj.access_points
2513
496
    for ap_path in access_points:
2514
497
        ap = dbusmock.get_object(ap_path)
2515
498
        if ap.Get(ACCESS_POINT_IFACE, 'Ssid') == ssid:
2516
499
            access_point = ap
2517
500
            break
2518
501
2519
502
    if not access_point:
2520
503
        raise dbus.exceptions.DBusException(
2521
504
            'Access point with SSID [%s] could not be found' % (ssid_name),
2522
505
            name=MAIN_IFACE + '.DoesNotExist')
2523
506
2524
507
    hw_address = access_point.Get(ACCESS_POINT_IFACE, 'HwAddress')
2525
508
    mode = access_point.Get(ACCESS_POINT_IFACE, 'Mode')
2526
509
    security = access_point.Get(ACCESS_POINT_IFACE, 'WpaFlags')
2527
510
2528
511
    if connection_path in connections or connection_path in main_connections:
2529
512
        raise dbus.exceptions.DBusException(
2530
513
            'Connection %s on device %s already exists' % (
2531
514
                connection_name, dev_path),
2532
515
            name=MAIN_IFACE + '.AlreadyExists')
2533
516
2534
517
    # Parse mac address string into byte array
2535
518
    mac_bytes = binascii.unhexlify(hw_address.replace(':', ''))
2536
519
2537
520
    settings = {
2538
521
        '802-11-wireless': {
2539
522
            'seen-bssids': [hw_address],
2540
523
            'ssid': dbus.ByteArray(ssid),
2541
524
            'mac-address': dbus.ByteArray(mac_bytes),
2542
525
            'mode': InfrastructureMode.NAME_MAP[mode]
2543
526
        },
2544
527
        'connection': {
2545
528
            'timestamp': dbus.UInt64(1374828522),
2546
529
            'type': '802-11-wireless',
2547
530
            'id': ssid_name,
2548
531
            'uuid': str(uuid.uuid4())
2549
532
        },
2550
533
    }
2551
534
2552
535
    if security != NM80211ApSecurityFlags.NM_802_11_AP_SEC_NONE:
2553
536
        settings['802-11-wireless']['security'] = '802-11-wireless-security'
2554
537
        sec = NM80211ApSecurityFlags.NAME_MAP[security]
2555
538
        settings['802-11-wireless-security'] = sec
2556
539
2557
540
    self.AddObject(connection_path,
2558
541
                   CSETTINGS_IFACE,
2559
542
                   {
2560
543
                       'Settings': dbus.Dictionary(
2561
544
                           settings, signature='sa{sv}'),
2562
545
                       'Secrets': dbus.Dictionary({}, signature='sa{sv}'),
2563
546
                   },
2564
547
                   [
2565
548
                       (
2566
549
                           'Delete', '', '',
2567
550
                           'self.ConnectionDelete("%s")' % connection_path),
2568
551
                       (
2569
552
                           'GetSettings', '', 'a{sa{sv}}',
2570
553
                           "ret = self.Get('%s', 'Settings')" %
2571
554
                           CSETTINGS_IFACE),
2572
555
                       (
2573
556
                           'GetSecrets', 's', 'a{sa{sv}}',
2574
557
                           "ret = self.Get('%s', 'Secrets')" %
2575
558
                           CSETTINGS_IFACE),
2576
559
                       (
2577
560
                           'Update', 'a{sa{sv}}', '',
2578
561
                           'self.ConnectionUpdate("%s", args[0])' %
2579
562
                           connection_path),
2580
563
                   ])
2581
564
2582
565
    connections.append(dbus.ObjectPath(connection_path))
2583
566
    dev_obj.Set(DEVICE_IFACE, 'AvailableConnections', connections)
2584
567
2585
568
    main_connections.append(connection_path)
2586
569
    settings_obj.Set(SETTINGS_IFACE, 'Connections', main_connections)
2587
570
2588
571
    settings_obj.EmitSignal(SETTINGS_IFACE, 'NewConnection', 'o', [ap_path])
2589
572
2590
573
    return connection_path
2591
574
2592
575
2593
576
@dbus.service.method(MOCK_IFACE,
2594
577
                     in_signature='assssu', out_signature='s')
2595
578
def AddActiveConnection(self, devices, connection_device, specific_object,
2596
579
                        name, state):
2597
580
    '''Add an active connection to an existing WiFi device.
2598
581
2599
582
    You have to a list of the involved WiFi devices, the connection path,
2600
583
    the access point path, ActiveConnection object name and connection
2601
584
    state.
2602
585
2603
586
    Please note that this does not set any global properties.
2604
587
2605
588
    Returns the new object path.
2606
589
    '''
2607
590
2608
591
    conn_obj = dbusmock.get_object(connection_device)
2609
592
    settings = conn_obj.Get(CSETTINGS_IFACE, 'Settings')
2610
593
    conn_uuid = settings['connection']['uuid']
2611
594
2612
595
    device_objects = [dbus.ObjectPath(dev) for dev in devices]
2613
596
2614
597
    active_connection_path = ('/org/freedesktop/NetworkManager/'
2615
598
                              'ActiveConnection/%s' % name)
2616
599
    self.AddObject(active_connection_path,
2617
600
                   ACTIVE_CONNECTION_IFACE,
2618
601
                   {
2619
602
                       'Devices': device_objects,
2620
603
                       'Default6': False,
2621
604
                       'Default': True,
2622
605
                       'Vpn': False,
2623
606
                       'Connection': dbus.ObjectPath(connection_device),
2624
607
                       'Master': dbus.ObjectPath('/'),
2625
608
                       'SpecificObject': dbus.ObjectPath(specific_object),
2626
609
                       'Uuid': conn_uuid,
2627
610
                       'State': state,
2628
611
                   },
2629
612
                   [])
2630
613
2631
614
    for dev_path in devices:
2632
615
        self.SetDeviceActive(dev_path, active_connection_path)
2633
616
2634
617
    active_connections = self.Get(MAIN_IFACE, 'ActiveConnections')
2635
618
    active_connections.append(dbus.ObjectPath(active_connection_path))
2636
619
    self.SetProperty(MAIN_OBJ, MAIN_IFACE, 'ActiveConnections',
2637
620
                     active_connections)
2638
621
2639
622
    return active_connection_path
2640
623
2641
624
2642
625
@dbus.service.method(MOCK_IFACE,
2643
626
                     in_signature='ss', out_signature='')
2644
627
def RemoveAccessPoint(self, dev_path, ap_path):
2645
628
    '''Remove the specified access point.
2646
629
2647
630
    You have to specify the device to remove the access point from, and the
2648
631
    path of the access point.
2649
632
2650
633
    Please note that this does not set any global properties.
2651
634
    '''
2652
635
2653
636
    dev_obj = dbusmock.get_object(dev_path)
2654
637
2655
638
    aps = dev_obj.Get(WIRELESS_DEVICE_IFACE, 'AccessPoints')
2656
639
    aps.remove(ap_path)
2657
640
    dev_obj.Set(WIRELESS_DEVICE_IFACE, 'AccessPoints', aps)
2658
641
2659
642
    dev_obj.access_points.remove(ap_path)
2660
643
2661
644
    dev_obj.EmitSignal(WIRELESS_DEVICE_IFACE, 'AccessPointRemoved', 'o',
2662
645
                       [ap_path])
2663
646
2664
647
    self.RemoveObject(ap_path)
2665
648
2666
649
2667
650
@dbus.service.method(MOCK_IFACE,
2668
651
                     in_signature='ss', out_signature='')
2669
652
def RemoveWifiConnection(self, dev_path, connection_path):
2670
653
    '''Remove the specified WiFi connection.
2671
654
2672
655
    You have to specify the device to remove the connection from, and the
2673
656
    path of the Connection.
2674
657
2675
658
    Please note that this does not set any global properties.
2676
659
    '''
2677
660
2678
661
    dev_obj = dbusmock.get_object(dev_path)
2679
662
    settings_obj = dbusmock.get_object(SETTINGS_OBJ)
2680
663
2681
664
    connections = dev_obj.Get(DEVICE_IFACE, 'AvailableConnections')
2682
665
    main_connections = settings_obj.ListConnections()
2683
666
2684
667
    if (connection_path not in connections and
2685
668
            connection_path not in main_connections):
2686
669
        return
2687
670
2688
671
    connections.remove(dbus.ObjectPath(connection_path))
2689
672
    dev_obj.Set(DEVICE_IFACE, 'AvailableConnections', connections)
2690
673
2691
674
    main_connections.remove(connection_path)
2692
675
    settings_obj.Set(SETTINGS_IFACE, 'Connections', main_connections)
2693
676
2694
677
    settings_obj.EmitSignal(SETTINGS_IFACE, 'ConnectionRemoved', 'o',
2695
678
                            [connection_path])
2696
679
2697
680
    connection_obj = dbusmock.get_object(connection_path)
2698
681
    connection_obj.EmitSignal(CSETTINGS_IFACE, 'Removed', '', [])
2699
682
2700
683
    self.RemoveObject(connection_path)
2701
684
2702
685
2703
686
@dbus.service.method(MOCK_IFACE,
2704
687
                     in_signature='ss', out_signature='')
2705
688
def RemoveActiveConnection(self, dev_path, active_connection_path):
2706
689
    '''Remove the specified ActiveConnection.
2707
690
2708
691
    You have to specify the device to remove the connection from, and the
2709
692
    path of the ActiveConnection.
2710
693
2711
694
    Please note that this does not set any global properties.
2712
695
    '''
2713
696
    self.SetDeviceDisconnected(dev_path)
2714
697
2715
698
    active_connections = self.Get(MAIN_IFACE, 'ActiveConnections')
2716
699
2717
700
    if active_connection_path not in active_connections:
2718
701
        return
2719
702
2720
703
    active_connections.remove(dbus.ObjectPath(active_connection_path))
2721
704
    self.SetProperty(MAIN_OBJ, MAIN_IFACE, 'ActiveConnections',
2722
705
                     active_connections)
2723
706
2724
707
    self.RemoveObject(active_connection_path)
2725
708
2726
709
2727
710
@dbus.service.method(SETTINGS_IFACE,
2728
711
                     in_signature='a{sa{sv}}', out_signature='o')
2729
712
def SettingsAddConnection(self, connection_settings):
2730
713
    '''Add a connection.
2731
714
2732
715
    connection_settings is a String String Variant Map Map. See
2733
716
    https://developer.gnome.org/NetworkManager/0.9/spec.html
2734
717
        #type-String_String_Variant_Map_Map
2735
718
2736
719
    If you omit uuid, this method adds one for you.
2737
720
    '''
2738
721
2739
722
    if 'uuid' not in connection_settings['connection']:
2740
723
        connection_settings['connection']['uuid'] = str(uuid.uuid4())
2741
724
2742
725
    NM = dbusmock.get_object(MAIN_OBJ)
2743
726
    settings_obj = dbusmock.get_object(SETTINGS_OBJ)
2744
727
    main_connections = settings_obj.ListConnections()
2745
728
2746
729
    # Mimic how NM names connections
2747
730
    connection_name = str(len(main_connections))
2748
731
2749
732
    connection_path = SETTINGS_OBJ + '/' + connection_name
2750
733
2751
734
    if connection_path in main_connections:
2752
735
        raise dbus.exceptions.DBusException(
2753
736
            'Connection %s already exists' % connection_path,
2754
737
            name=MAIN_IFACE + '.AlreadyExists',)
2755
738
2756
739
    self.AddObject(connection_path,
2757
740
                   CSETTINGS_IFACE,
2758
741
                   {
2759
742
                       'Settings': dbus.Dictionary(connection_settings,
2760
743
                                                   signature='sa{sv}'),
2761
744
                       'Secrets': dbus.Dictionary({}, signature='sa{sv}'),
2762
745
                   },
2763
746
                   [
2764
747
                       (
2765
748
                           'Delete', '', '',
2766
749
                           'self.ConnectionDelete("%s")' % connection_path),
2767
750
                       (
2768
751
                           'GetSettings', '', 'a{sa{sv}}',
2769
752
                           "ret = self.Get('%s', 'Settings')" %
2770
753
                           CSETTINGS_IFACE),
2771
754
                       (
2772
755
                           'GetSecrets', 's', 'a{sa{sv}}',
2773
756
                           "ret = self.Get('%s', 'Secrets')" %
2774
757
                           CSETTINGS_IFACE),
2775
758
                       (
2776
759
                           'Update', 'a{sa{sv}}', '',
2777
760
                           'self.ConnectionUpdate("%s", args[0])' %
2778
761
                           connection_path),
2779
762
                   ])
2780
763
2781
764
    main_connections.append(connection_path)
2782
765
    settings_obj.Set(SETTINGS_IFACE, 'Connections', main_connections)
2783
766
2784
767
    settings_obj.EmitSignal(SETTINGS_IFACE, 'NewConnection', 'o',
2785
768
                            [connection_path])
2786
769
2787
770
    auto_connect = False
2788
771
    if 'autoconnect' in connection_settings['connection']:
2789
772
        auto_connect = connection_settings['connection']['autoconnect']
2790
773
2791
774
    if auto_connect:
2792
775
        dev = None
2793
776
        devices = NM.GetDevices()
2794
777
2795
778
        # Grab the first device.
2796
779
        if len(devices) > 0:
2797
780
            dev = devices[0]
2798
781
2799
782
        if dev:
2800
783
            activate_connection(NM, connection_path, dev, connection_path)
2801
784
2802
785
    return connection_path
2803
786
2804
787
2805
788
@dbus.service.method(CSETTINGS_IFACE,
2806
789
                     in_signature='oa{sa{sv}}', out_signature='')
2807
790
def ConnectionUpdate(self, connection_path, settings):
2808
791
    '''Update settings on a connection.
2809
792
2810
793
    settings is a String String Variant Map Map. See
2811
794
    https://developer.gnome.org/NetworkManager/0.9/spec.html
2812
795
        #type-String_String_Variant_Map_Map
2813
796
    '''
2814
797
    NM = dbusmock.get_object(MAIN_OBJ)
2815
798
    settings_obj = dbusmock.get_object(SETTINGS_OBJ)
2816
799
    conn_obj = dbusmock.get_object(connection_path)
2817
800
2818
801
    main_connections = settings_obj.ListConnections()
2819
802
2820
803
    if connection_path not in main_connections:
2821
804
        raise dbus.exceptions.DBusException(
2822
805
            'Connection %s does not exist' % connection_path,
2823
806
            name=MAIN_IFACE + '.DoesNotExist',)
2824
807
2825
808
    conn_settings = conn_obj.Get(CSETTINGS_IFACE, 'Settings')
2826
809
    changed_settings = {}
2827
810
    for key, value in settings.items():
2828
811
        for k, v in value.items():
2829
812
            changed_settings[k] = v
2830
813
2831
814
            if key not in conn_settings:
2832
815
                conn_settings[key] = dbus.Dictionary({}, signature='sv')
2833
816
2834
817
            conn_settings[key][k] = v
2835
818
2836
819
    conn_obj.Set(CSETTINGS_IFACE, 'Settings', conn_settings)
2837
820
2838
821
    settings_obj.EmitSignal(CSETTINGS_IFACE, 'PropertiesChanged', 'a{sv}',
2839
822
                            [changed_settings])
2840
823
    settings_obj.EmitSignal(CSETTINGS_IFACE, 'Updated', '', [])
2841
824
2842
825
    auto_connect = False
2843
826
    if 'autoconnect' in settings['connection']:
2844
827
        auto_connect = settings['connection']['autoconnect']
2845
828
2846
829
    if auto_connect:
2847
830
        dev = None
2848
831
        devices = NM.GetDevices()
2849
832
2850
833
        # Grab the first device.
2851
834
        if len(devices) > 0:
2852
835
            dev = devices[0]
2853
836
2854
837
        if dev:
2855
838
            activate_connection(NM, connection_path, dev, connection_path)
2856
839
2857
840
    return connection_path
2858
841
2859
842
2860
843
@dbus.service.method(CSETTINGS_IFACE,
2861
844
                     in_signature='o', out_signature='')
2862
845
def ConnectionDelete(self, connection_path):
2863
846
    '''Deletes a connection.
2864
847
2865
848
    This also
2866
849
        * removes the deleted connection from any device,
2867
850
        * removes any active connection(s) it might be associated with,
2868
851
        * removes it from the Settings interface,
2869
852
        * as well as deletes the object from the mock.
2870
853
2871
854
    Note: If this was the only active connection, we change the global
2872
855
    connection state.
2873
856
    '''
2874
857
    NM = dbusmock.get_object(MAIN_OBJ)
2875
858
    settings_obj = dbusmock.get_object(SETTINGS_OBJ)
2876
859
2877
860
    # Find the associated active connection(s).
2878
861
    active_connections = NM.Get(MAIN_IFACE, 'ActiveConnections')
2879
862
    associated_active_connections = []
2880
863
    for ac in active_connections:
2881
864
        ac_obj = dbusmock.get_object(ac)
2882
865
        ac_con = ac_obj.Get(ACTIVE_CONNECTION_IFACE, 'Connection')
2883
866
        if ac_con == connection_path:
2884
867
            associated_active_connections.append(ac)
2885
868
2886
869
    # We found that the connection we are deleting are associated to all
2887
870
    # active connections and subsequently set the global state to
2888
871
    # disconnected.
2889
872
    if len(active_connections) == len(associated_active_connections):
2890
873
        self.SetGlobalConnectionState(NMState.NM_STATE_DISCONNECTED)
2891
874
2892
875
    # Remove the connection from all associated devices.
2893
876
    # We also remove all associated active connections.
2894
877
    for dev_path in NM.GetDevices():
2895
878
        dev_obj = dbusmock.get_object(dev_path)
2896
879
        connections = dev_obj.Get(DEVICE_IFACE, 'AvailableConnections')
2897
880
2898
881
        for ac in associated_active_connections:
2899
882
            NM.RemoveActiveConnection(dev_path, ac)
2900
883
2901
884
        if connection_path not in connections:
2902
885
            continue
2903
886
2904
887
        connections.remove(dbus.ObjectPath(connection_path))
2905
888
        dev_obj.Set(DEVICE_IFACE, 'AvailableConnections', connections)
2906
889
2907
890
    # Remove the connection from the settings interface
2908
891
    main_connections = settings_obj.ListConnections()
2909
892
    if connection_path not in main_connections:
2910
893
        return
2911
894
    main_connections.remove(connection_path)
2912
895
    settings_obj.Set(SETTINGS_IFACE, 'Connections', main_connections)
2913
896
    settings_obj.EmitSignal(SETTINGS_IFACE, 'ConnectionRemoved', 'o',
2914
897
                            [connection_path])
2915
898
2916
899
    # Remove the connection from the mock
2917
900
    connection_obj = dbusmock.get_object(connection_path)
2918
901
    connection_obj.EmitSignal(CSETTINGS_IFACE, 'Removed', '', [])
2919
902
    self.RemoveObject(connection_path)
2920
0
903
2921
=== modified file 'tests/autopilot/ubuntu_system_settings/tests/test_cellular.py'
2922
--- tests/autopilot/ubuntu_system_settings/tests/test_cellular.py	2014-10-29 15:51:17 +0000
2923
+++ tests/autopilot/ubuntu_system_settings/tests/test_cellular.py	2015-05-18 15:06:15 +0000
2924
@@ -5,6 +5,7 @@
2925
5
# under the terms of the GNU General Public License version 3, as published
5
# under the terms of the GNU General Public License version 3, as published
2926
6
# by the Free Software Foundation.
6
# by the Free Software Foundation.
2927
7
7
2928
8
import dbus
2929
8
from gi.repository import Gio, GLib
9
from gi.repository import Gio, GLib
2930
9
from time import sleep
10
from time import sleep
2931
10
11
2932
@@ -13,7 +14,14 @@
2933
13
from testtools.matchers import Equals, raises, StartsWith
14
from testtools.matchers import Equals, raises, StartsWith
2934
14
15
2935
15
from ubuntu_system_settings.tests import (
16
from ubuntu_system_settings.tests import (
2937
16
    CellularBaseTestCase, CONNMAN_IFACE, RDO_IFACE, NETREG_IFACE)
17
    CellularBaseTestCase, HotspotBaseTestCase, CONNMAN_IFACE, RDO_IFACE,
2938
18
    NETREG_IFACE)
2939
19
2940
20
from ubuntu_system_settings.tests.networkmanager import (
2941
21
    CSETTINGS_IFACE, MAIN_OBJ as NM_PATH, MAIN_IFACE as NM_IFACE,
2942
22
)
2943
23
2944
24
DEV_IFACE = 'org.freedesktop.NetworkManager.Device'
2945
17
25
2946
18
26
2947
19
class CellularTestCase(CellularBaseTestCase):
27
class CellularTestCase(CellularBaseTestCase):
2948
@@ -288,3 +296,116 @@
2949
288
            lambda:
296
            lambda:
2950
289
                gsettings.get_value('default-sim-for-messages').get_string(),
297
                gsettings.get_value('default-sim-for-messages').get_string(),
2951
290
            Eventually(Equals('/ril_1')))
298
            Eventually(Equals('/ril_1')))
2952
299
2953
300
2954
301
class HotspotTestCase(HotspotBaseTestCase):
2955
302
2956
303
    def test_setup(self):
2957
304
        if not self.cellular_page.have_hotspot():
2958
305
            self.skipTest('Cannot test hotspot since wifi is disabled.')
2959
306
2960
307
        ssid = 'Ubuntu'
2961
308
        password = 'abcdefgh'
2962
309
        config = {'password': password}
2963
310
        active_con_path = NM_PATH + '/ActiveConnection/0'
2964
311
        con_path = NM_PATH + '/Settings/0'
2965
312
2966
313
        hotspot_page = self.cellular_page.setup_hotspot(config)
2967
314
2968
315
        # Assert that the switch is on.
2969
316
        self.assertTrue(hotspot_page.get_hotspot_status())
2970
317
2971
318
        # Assert that Block on Urfkill is called twice.
2972
319
        self.assertThat(
2973
320
            lambda: len(self.urfkill_mock.GetMethodCalls('Block')),
2974
321
            Eventually(Equals(2))
2975
322
        )
2976
323
2977
324
        # Assert that we get one active connection.
2978
325
        self.assertThat(
2979
326
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
2980
327
            Eventually(Equals(1))
2981
328
        )
2982
329
2983
330
        # Assert that the active connection has a certain path.
2984
331
        self.assertThat(
2985
332
            lambda: self.obj_nm.GetAll(NM_IFACE)['ActiveConnections'][0],
2986
333
            Eventually(Equals(active_con_path))
2987
334
        )
2988
335
2989
336
        # Assert the device's active connection
2990
337
        self.assertThat(
2991
338
            lambda: self.device_mock.Get(DEV_IFACE, 'ActiveConnection'),
2992
339
            Eventually(Equals(active_con_path))
2993
340
        )
2994
341
2995
342
        connection_mock = dbus.Interface(self.dbus_con.get_object(
2996
343
            NM_IFACE, con_path), CSETTINGS_IFACE)
2997
344
2998
345
        settings = connection_mock.GetSettings()
2999
346
3000
347
        # Assert that autoconnect is true, that ssid and password is what we
3001
348
        # expect them to be.
3002
349
        self.assertTrue(settings['connection']['autoconnect'])
3003
350
3004
351
        s_ssid = bytearray(settings['802-11-wireless']['ssid']).decode('utf-8')
3005
352
        self.assertEqual(s_ssid, ssid)
3006
353
        self.assertEqual(settings['802-11-wireless-security']['psk'], password)
3007
354
3008
355
    def test_enabling(self):
3009
356
        if not self.cellular_page.have_hotspot():
3010
357
            self.skipTest('Cannot test hotspot since wifi is disabled.')
3011
358
3012
359
        self.add_hotspot('foo', 'abcdefgh', enabled=False)
3013
360
3014
361
        self.assertThat(
3015
362
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
3016
363
            Eventually(Equals(0))
3017
364
        )
3018
365
3019
366
        self.cellular_page.enable_hotspot()
3020
367
3021
368
        self.assertThat(
3022
369
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
3023
370
            Eventually(Equals(1))
3024
371
        )
3025
372
3026
373
    def test_disabling(self):
3027
374
        if not self.cellular_page.have_hotspot():
3028
375
            self.skipTest('Cannot test hotspot since wifi is disabled.')
3029
376
3030
377
        self.add_hotspot('foo', 'abcdefgh', enabled=True)
3031
378
3032
379
        self.assertThat(
3033
380
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
3034
381
            Eventually(Equals(1))
3035
382
        )
3036
383
3037
384
        self.cellular_page.disable_hotspot()
3038
385
3039
386
        self.assertThat(
3040
387
            lambda: len(self.obj_nm.GetAll(NM_IFACE)['ActiveConnections']),
3041
388
            Eventually(Equals(0))
3042
389
        )
3043
390
3044
391
    def test_changing(self):
3045
392
        if not self.cellular_page.have_hotspot():
3046
393
            self.skipTest('Cannot test hotspot since wifi is disabled.')
3047
394
3048
395
        con_path = self.add_hotspot('foo', 'abcdefgh', enabled=True)
3049
396
3050
397
        ssid = 'bar'
3051
398
        password = 'zomgzomg'
3052
399
        config = {'ssid': ssid, 'password': password}
3053
400
        self.cellular_page.setup_hotspot(config)
3054
401
3055
402
        con_path = NM_PATH + '/Settings/0'
3056
403
3057
404
        con_mock = dbus.Interface(self.dbus_con.get_object(
3058
405
            NM_IFACE, con_path), CSETTINGS_IFACE)
3059
406
3060
407
        settings = con_mock.GetSettings()
3061
408
3062
409
        s_ssid = bytearray(settings['802-11-wireless']['ssid']).decode('utf-8')
3063
410
        self.assertEqual(s_ssid, ssid)
3064
411
        self.assertEqual(settings['802-11-wireless-security']['psk'], password)
3065
291
412
3066
=== modified file 'tests/plugins/system-update/fakesystemupdate.h'
3067
--- tests/plugins/system-update/fakesystemupdate.h	2014-10-24 20:06:13 +0000
3068
+++ tests/plugins/system-update/fakesystemupdate.h	2015-05-18 15:06:15 +0000
3069
@@ -38,6 +38,7 @@
3070
38
    int currentBuildNumber() { return 123;}
38
    int currentBuildNumber() { return 123;}
3071
39
    QString currentUbuntuBuildNumber() { return QString("20140927");}
39
    QString currentUbuntuBuildNumber() { return QString("20140927");}
3072
40
    QString currentDeviceBuildNumber() { return QString("20140927");}
40
    QString currentDeviceBuildNumber() { return QString("20140927");}
3073
41
    QString deviceName() { return QString("mako");}
3074
41
    QDateTime lastUpdateDate() { return QDateTime::currentDateTime(); }
42
    QDateTime lastUpdateDate() { return QDateTime::currentDateTime(); }
3075
42
43
3076
43
    void checkForUpdate() {}
44
    void checkForUpdate() {}
Status:	Superseded
Proposed branch:	lp:~jonas-drange/ubuntu-system-settings/hotspots-binding
Merge into:	lp:ubuntu-system-settings
Diff against target:	3076 lines (+2449/-276) 16 files modified plugins/cellular/CMakeLists.txt (+1/-0) plugins/cellular/Common.qml (+97/-0) plugins/cellular/Components/MultiSim.qml (+7/-2) plugins/cellular/Components/SingleSim.qml (+6/-2) plugins/cellular/Hotspot.qml (+39/-22) plugins/cellular/HotspotSetup.qml (+301/-70) plugins/cellular/hotspotmanager.cpp (+619/-159) plugins/cellular/hotspotmanager.h (+147/-19) plugins/system-update/system_update.cpp (+7/-0) plugins/system-update/system_update.h (+2/-0) plugins/system-update/update_manager.h (+4/-0) tests/autopilot/ubuntu_system_settings/__init__.py (+132/-0) tests/autopilot/ubuntu_system_settings/tests/__init__.py (+62/-1) tests/autopilot/ubuntu_system_settings/tests/networkmanager.py (+902/-0) tests/autopilot/ubuntu_system_settings/tests/test_cellular.py (+122/-1) tests/plugins/system-update/fakesystemupdate.h (+1/-0)
To merge this branch:	bzr merge lp:~jonas-drange/ubuntu-system-settings/hotspots-binding
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Ken VanDine		2015-03-09	Needs Fixing on 2015-05-15
PS Jenkins bot	continuous-integration		Approve on 2015-05-13
Mathieu Trudel-Lapierre (community)			Abstain on 2015-03-19
Matthew Paul Thomas	design	2015-03-10	Pending
Review via email: mp+252296@code.launchpad.net