1
diff --git a/MAINTAINERS b/MAINTAINERS
2
index 420159f..1fed46c 100644
3
--- a/MAINTAINERS
4
+++ b/MAINTAINERS
5
@@ -1 +1,2 @@
6
1
Simon Fels <simon.fels@canonical.com>
1
Simon Fels <simon.fels@canonical.com>
7
2
Matteo Croce <matteo.croce@canonical.com>
8
diff --git a/README.md b/README.md
9
index 3c89bcd..1a49a98 100644
10
--- a/README.md
11
+++ b/README.md
12
@@ -5,6 +5,41 @@ This snap provided WiFi AP functionality out of the box.
13
5
Documentation is currently available at
5
Documentation is currently available at
14
6
https://docs.google.com/document/d/1vNu3fBqpOkBkjv_Vs9NZyTv50vOEfugrQqgxD0_f0rE/edit#
6
https://docs.google.com/document/d/1vNu3fBqpOkBkjv_Vs9NZyTv50vOEfugrQqgxD0_f0rE/edit#
15
7
7
16
8
## Development
17
9
18
10
To modify any of the included services written in Go you need setup
19
11
your build environment first.
20
12
21
13
```
22
14
 $ snapcraft clean
23
15
 $ snapcraft
24
16
```
25
17
26
18
Now we need to export the GOPATH and point it to the directory
27
19
snapcraft already created for us.
28
20
29
21
```
30
22
 $ export GOPATH=$PWD/parts/management-service/go
31
23
```
32
24
33
25
Now you can build the management-service by running
34
26
35
27
```
36
28
 $ cd cmd/service
37
29
 $ go build -o management-service *.go
38
30
```
39
31
40
32
If you want to start it afterwards outside of a snap environment you
41
33
need to setup the right environment variables.
42
34
43
35
```
44
36
 # Needs to be the top source dir which contains the snapcraft.yaml
45
37
 $ export SNAP=`pwd`
46
38
 $ mkdir tmp-data
47
39
 $ export SNAP_DATA=$PWD/tmp-data
48
40
 $ cmd/service/management-service
49
41
```
50
42
51
8
## Running tests
43
## Running tests
52
9
44
53
10
We have a set of spread (https://github.com/snapcore/spread) tests which
45
We have a set of spread (https://github.com/snapcore/spread) tests which
54
diff --git a/bin/ap.sh b/bin/ap.sh
55
index 54c12ac..be8dac4 100755
56
--- a/bin/ap.sh
57
+++ b/bin/ap.sh
58
@@ -39,10 +39,18 @@ if ! ifconfig $WIFI_INTERFACE ; then
59
39
fi
39
fi
60
40
40
61
41
cleanup_on_exit() {
41
cleanup_on_exit() {
62
42
	read HOSTAPD_PID <$SNAP_DATA/hostapd.pid
63
43
	if [ -n "$HOSTAPD_PID" ] ; then
64
44
		kill -TERM $HOSTAPD_PID || true
65
45
		wait $HOSTAPD_PID
66
46
	fi
67
47
68
42
	read DNSMASQ_PID <$SNAP_DATA/dnsmasq.pid
48
	read DNSMASQ_PID <$SNAP_DATA/dnsmasq.pid
72
43
	# If dnsmasq is already gone don't error out here
49
	if [ -n "$DNSMASQ_PID" ] ; then
73
44
	kill -TERM $DNSMASQ_PID || true
50
		# If dnsmasq is already gone don't error out here
74
45
	wait $DNSMASQ_PID
51
		kill -TERM $DNSMASQ_PID || true
75
52
		wait $DNSMASQ_PID
76
53
	fi
77
46
54
78
47
	iface=$WIFI_INTERFACE
55
	iface=$WIFI_INTERFACE
79
48
	if [ "$WIFI_INTERFACE_MODE" = "virtual" ] ; then
56
	if [ "$WIFI_INTERFACE_MODE" = "virtual" ] ; then
80
@@ -56,18 +64,22 @@ cleanup_on_exit() {
81
56
		sysctl -w net.ipv4.ip_forward=0
64
		sysctl -w net.ipv4.ip_forward=0
82
57
	fi
65
	fi
83
58
66
84
59
	if [ "$WIFI_INTERFACE_MODE" = "virtual" ] && does_interface_exist $iface ; then
85
60
		$SNAP/bin/iw dev $iface del
86
61
	fi
87
62
88
63
	if is_nm_running ; then
67
	if is_nm_running ; then
89
64
		# Hand interface back to network-manager. This will also trigger the
68
		# Hand interface back to network-manager. This will also trigger the
90
65
		# auto connection process inside network-manager to get connected
69
		# auto connection process inside network-manager to get connected
91
66
		# with the previous network.
70
		# with the previous network.
92
67
		$SNAP/bin/nmcli d set $iface managed yes
71
		$SNAP/bin/nmcli d set $iface managed yes
93
68
	fi
72
	fi
94
73
95
74
	if [ "$WIFI_INTERFACE_MODE" = "virtual" ] ; then
96
75
		$SNAP/bin/iw dev $iface del
97
76
	fi
98
69
}
77
}
99
70
78
100
79
# We need to install this right before we do anything to
101
80
# ensure that we cleanup everything again when we termiante.
102
81
trap cleanup_on_exit TERM
103
82
104
71
iface=$WIFI_INTERFACE
83
iface=$WIFI_INTERFACE
105
72
if [ "$WIFI_INTERFACE_MODE" = "virtual" ] ; then
84
if [ "$WIFI_INTERFACE_MODE" = "virtual" ] ; then
106
73
	iface=$DEFAULT_ACCESS_POINT_INTERFACE
85
	iface=$DEFAULT_ACCESS_POINT_INTERFACE
107
@@ -139,7 +151,13 @@ if [ $SHARE_DISABLED -eq 0 ] ; then
108
139
fi
151
fi
109
140
152
110
141
generate_dnsmasq_config $SNAP_DATA/dnsmasq.conf
153
generate_dnsmasq_config $SNAP_DATA/dnsmasq.conf
112
142
$SNAP/bin/dnsmasq -k -C $SNAP_DATA/dnsmasq.conf -l $SNAP_DATA/dnsmasq.leases -x $SNAP_DATA/dnsmasq.pid &
154
$SNAP/bin/dnsmasq \
113
155
	-k \
114
156
	-C $SNAP_DATA/dnsmasq.conf \
115
157
	-l $SNAP_DATA/dnsmasq.leases \
116
158
	-x $SNAP_DATA/dnsmasq.pid \
117
159
	-u root -g root \
118
160
	&
119
143
161
120
144
driver=$WIFI_HOSTAPD_DRIVER
162
driver=$WIFI_HOSTAPD_DRIVER
121
145
if [ "$driver" = "rtl8188" ] ; then
163
if [ "$driver" = "rtl8188" ] ; then
122
@@ -219,6 +237,10 @@ case "$WIFI_HOSTAPD_DRIVER" in
123
219
esac
237
esac
124
220
238
125
221
# Startup hostapd with the configuration we've put in place
239
# Startup hostapd with the configuration we've put in place
127
222
$hostapd $EXTRA_ARGS $SNAP_DATA/hostapd.conf
240
$hostapd $EXTRA_ARGS $SNAP_DATA/hostapd.conf &
128
241
hostapd_pid=$!
129
242
echo $hostapd_pid > $SNAP_DATA/hostapd.pid
130
243
wait $hostapd_pid
131
244
132
223
cleanup_on_exit
245
cleanup_on_exit
133
224
exit 0
246
exit 0
134
diff --git a/bin/helper.sh b/bin/helper.sh
135
index 718a2d6..4a557d6 100644
136
--- a/bin/helper.sh
137
+++ b/bin/helper.sh
138
@@ -56,6 +56,5 @@ generate_dnsmasq_config() {
139
56
56
140
57
is_nm_running() {
57
is_nm_running() {
141
58
	nm_status=`$SNAP/bin/nmcli -t -f RUNNING general`
58
	nm_status=`$SNAP/bin/nmcli -t -f RUNNING general`
144
59
	[ "$nm_status" = "running" ] && return 1
59
	[ "$nm_status" = "running" ]
143
60
	return 0
145
61
}
60
}
146
diff --git a/cmd/client/client.go b/cmd/client/client.go
147
index 0a770d7..ec8bb76 100644
148
--- a/cmd/client/client.go
149
+++ b/cmd/client/client.go
150
@@ -25,6 +25,7 @@ import (
151
25
const (
25
const (
152
26
	servicePort        = 5005
26
	servicePort        = 5005
153
27
	configurationV1Uri = "/v1/configuration"
27
	configurationV1Uri = "/v1/configuration"
154
28
	statusV1Uri        = "/v1/status"
155
28
)
29
)
156
29
30
157
30
type serviceResponse struct {
31
type serviceResponse struct {
158
@@ -38,6 +39,10 @@ func getServiceConfigurationURI() string {
159
38
	return fmt.Sprintf("http://localhost:%d%s", servicePort, configurationV1Uri)
39
	return fmt.Sprintf("http://localhost:%d%s", servicePort, configurationV1Uri)
160
39
}
40
}
161
40
41
162
42
func getServiceStatusURI() string {
163
43
	return fmt.Sprintf("http://localhost:%d%s", servicePort, statusV1Uri)
164
44
}
165
45
166
41
type doer interface {
46
type doer interface {
167
42
	Do(*http.Request) (*http.Response, error)
47
	Do(*http.Request) (*http.Response, error)
168
43
}
48
}
169
diff --git a/cmd/client/cmd_config.go b/cmd/client/cmd_config.go
170
index 8a82f4a..f0d6b4c 100644
171
--- a/cmd/client/cmd_config.go
172
+++ b/cmd/client/cmd_config.go
173
@@ -20,7 +20,6 @@ import (
174
20
	"encoding/json"
20
	"encoding/json"
175
21
	"fmt"
21
	"fmt"
176
22
	"os"
22
	"os"
177
23
	"sort"
178
24
)
23
)
179
25
24
180
26
type setCommand struct{}
25
type setCommand struct{}
181
@@ -58,14 +57,7 @@ func (cmd *getCommand) Execute(args []string) error {
182
58
			return fmt.Errorf("Config item '%s' does not exist", wantedKey)
57
			return fmt.Errorf("Config item '%s' does not exist", wantedKey)
183
59
		}
58
		}
184
60
	} else {
59
	} else {
193
61
		sortedKeys := make([]string, 0, len(response.Result))
60
		printMapSorted(response.Result)
186
62
		for key, _ := range response.Result {
187
63
			sortedKeys = append(sortedKeys, key)
188
64
		}
189
65
		sort.Strings(sortedKeys)
190
66
		for n := range sortedKeys {
191
67
			fmt.Fprintf(os.Stdout, "%s: %s\n", sortedKeys[n], response.Result[sortedKeys[n]])
192
68
		}
194
69
	}
61
	}
195
70
62
196
71
	return nil
63
	return nil
197
@@ -78,7 +70,7 @@ func (cmd *configCommand) Execute(args []string) error {
198
78
}
70
}
199
79
71
200
80
func init() {
72
func init() {
204
81
	cmdConfig, _ := addCommand("config", "Adjust the service configuration", "", &configCommand{})
73
	cmd, _ := addCommand("config", "Adjust the service configuration", "", &configCommand{})
205
82
	cmdConfig.AddCommand("set", "", "", &setCommand{})
74
	cmd.AddCommand("set", "", "", &setCommand{})
206
83
	cmdConfig.AddCommand("get", "", "", &getCommand{})
75
	cmd.AddCommand("get", "", "", &getCommand{})
207
84
}
76
}
208
diff --git a/cmd/client/cmd_status.go b/cmd/client/cmd_status.go
209
85
new file mode 100644
77
new file mode 100644
210
index 0000000..e120e47
211
--- /dev/null
212
+++ b/cmd/client/cmd_status.go
213
@@ -0,0 +1,58 @@
214
1
//
215
2
// Copyright (C) 2016 Canonical Ltd
216
3
//
217
4
// This program is free software: you can redistribute it and/or modify
218
5
// it under the terms of the GNU General Public License version 3 as
219
6
// published by the Free Software Foundation.
220
7
//
221
8
// This program is distributed in the hope that it will be useful,
222
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
223
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
224
11
// GNU General Public License for more details.
225
12
//
226
13
// You should have received a copy of the GNU General Public License
227
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
228
15
229
16
package main
230
17
231
18
import (
232
19
	"bytes"
233
20
	"encoding/json"
234
21
)
235
22
236
23
type restartCommand struct{}
237
24
238
25
func (cmd *restartCommand) Execute(args []string) error {
239
26
	req := make(map[string]string)
240
27
	req["action"] = "restart-ap"
241
28
242
29
	b, err := json.Marshal(req)
243
30
	if err != nil {
244
31
		return err
245
32
	}
246
33
247
34
	_, err = sendHTTPRequest(getServiceStatusURI(), "POST", bytes.NewReader(b))
248
35
	if err != nil {
249
36
		return err
250
37
	}
251
38
252
39
	return nil
253
40
}
254
41
255
42
type statusCommand struct{}
256
43
257
44
func (cmd *statusCommand) Execute(args []string) error {
258
45
	response, err := sendHTTPRequest(getServiceStatusURI(), "GET", nil)
259
46
	if err != nil {
260
47
		return err
261
48
	}
262
49
	printMapSorted(response.Result)
263
50
	return nil
264
51
}
265
52
266
53
func init() {
267
54
	cmd, _ := addCommand("status", "Show various status information about the access point", "", &statusCommand{})
268
55
	cmd.SubcommandsOptional = true
269
56
270
57
	cmd.AddCommand("restart-ap", "Restart access point", "", &restartCommand{})
271
58
}
272
diff --git a/cmd/client/utils.go b/cmd/client/utils.go
273
0
new file mode 100644
59
new file mode 100644
274
index 0000000..f5c55a3
275
--- /dev/null
276
+++ b/cmd/client/utils.go
277
@@ -0,0 +1,33 @@
278
1
//
279
2
// Copyright (C) 2016 Canonical Ltd
280
3
//
281
4
// This program is free software: you can redistribute it and/or modify
282
5
// it under the terms of the GNU General Public License version 3 as
283
6
// published by the Free Software Foundation.
284
7
//
285
8
// This program is distributed in the hope that it will be useful,
286
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
287
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
288
11
// GNU General Public License for more details.
289
12
//
290
13
// You should have received a copy of the GNU General Public License
291
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
292
15
293
16
package main
294
17
295
18
import (
296
19
	"fmt"
297
20
	"os"
298
21
	"sort"
299
22
)
300
23
301
24
func printMapSorted(m map[string]string) {
302
25
	sortedKeys := make([]string, 0, len(m))
303
26
	for key, _ := range m {
304
27
		sortedKeys = append(sortedKeys, key)
305
28
	}
306
29
	sort.Strings(sortedKeys)
307
30
	for _, k := range sortedKeys {
308
31
		fmt.Fprintf(os.Stdout, "%s: %s\n", k, m[k])
309
32
	}
310
33
}
311
diff --git a/cmd/service/api.go b/cmd/service/api.go
312
0
new file mode 100644
34
new file mode 100644
313
index 0000000..5c4c6fd
314
--- /dev/null
315
+++ b/cmd/service/api.go
316
@@ -0,0 +1,176 @@
317
1
//
318
2
// Copyright (C) 2016 Canonical Ltd
319
3
//
320
4
// This program is free software: you can redistribute it and/or modify
321
5
// it under the terms of the GNU General Public License version 3 as
322
6
// published by the Free Software Foundation.
323
7
//
324
8
// This program is distributed in the hope that it will be useful,
325
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
326
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
327
11
// GNU General Public License for more details.
328
12
//
329
13
// You should have received a copy of the GNU General Public License
330
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
331
15
332
16
package main
333
17
334
18
import (
335
19
	"encoding/json"
336
20
	"fmt"
337
21
	"io/ioutil"
338
22
	"net/http"
339
23
	"os"
340
24
)
341
25
342
26
var api = []*serviceCommand{
343
27
	configurationCmd,
344
28
	statusCmd,
345
29
}
346
30
347
31
var (
348
32
	configurationCmd = &serviceCommand{
349
33
		Path: "/v1/configuration",
350
34
		GET:  getConfiguration,
351
35
		POST: postConfiguration,
352
36
	}
353
37
	statusCmd = &serviceCommand{
354
38
		Path: "/v1/status",
355
39
		GET:  getStatus,
356
40
		POST: postStatus,
357
41
	}
358
42
	validTokens map[string]bool
359
43
)
360
44
361
45
func getConfiguration(c *serviceCommand, writer http.ResponseWriter, request *http.Request) {
362
46
	config := make(map[string]string)
363
47
	if err := readConfiguration(configurationPaths, config); err == nil {
364
48
		sendHTTPResponse(writer, makeResponse(http.StatusOK, config))
365
49
	} else {
366
50
		resp := makeErrorResponse(http.StatusInternalServerError, "Failed to read configuration data", "internal-error")
367
51
		sendHTTPResponse(writer, resp)
368
52
	}
369
53
}
370
54
371
55
func postConfiguration(c *serviceCommand, writer http.ResponseWriter, request *http.Request) {
372
56
	path := getConfigOnPath(os.Getenv("SNAP_DATA"))
373
57
	config := map[string]string{}
374
58
	if readConfiguration([]string{path}, config) != nil {
375
59
		resp := makeErrorResponse(http.StatusInternalServerError,
376
60
			"Failed to read existing configuration file", "internal-error")
377
61
		sendHTTPResponse(writer, resp)
378
62
		return
379
63
	}
380
64
381
65
	if validTokens == nil || len(validTokens) == 0 {
382
66
		errResponse := makeErrorResponse(http.StatusInternalServerError, "No default configuration file available", "internal-error")
383
67
		sendHTTPResponse(writer, errResponse)
384
68
		return
385
69
	}
386
70
387
71
	file, err := os.Create(path)
388
72
	if err != nil {
389
73
		resp := makeErrorResponse(http.StatusInternalServerError, "Can't write configuration file", "internal-error")
390
74
		sendHTTPResponse(writer, resp)
391
75
		return
392
76
	}
393
77
	defer file.Close()
394
78
395
79
	body, err := ioutil.ReadAll(request.Body)
396
80
	if err != nil {
397
81
		resp := makeErrorResponse(http.StatusInternalServerError, "Error reading the request body", "internal-error")
398
82
		sendHTTPResponse(writer, resp)
399
83
		return
400
84
	}
401
85
402
86
	var items map[string]string
403
87
	if err = json.Unmarshal(body, &items); err != nil {
404
88
		resp := makeErrorResponse(http.StatusInternalServerError, "Malformed request", "internal-error")
405
89
		sendHTTPResponse(writer, resp)
406
90
		return
407
91
	}
408
92
409
93
	// Add the items in the config, but only if all are in the whitelist
410
94
	for key, value := range items {
411
95
		if _, present := validTokens[key]; !present {
412
96
			errResponse := makeErrorResponse(http.StatusInternalServerError, `Invalid key "`+key+`"`, "internal-error")
413
97
			sendHTTPResponse(writer, errResponse)
414
98
			return
415
99
		}
416
100
		config[key] = value
417
101
	}
418
102
419
103
	for key, value := range config {
420
104
		key = convertKeyToStorageFormat(key)
421
105
		value = escapeTextForShell(value)
422
106
		file.WriteString(fmt.Sprintf("%s=%s\n", key, value))
423
107
	}
424
108
425
109
	if err := restartAccessPoint(c); err != nil {
426
110
		resp := makeErrorResponse(http.StatusInternalServerError, "Failed to restart AP process", "internal-error")
427
111
		sendHTTPResponse(writer, resp)
428
112
		return
429
113
	}
430
114
431
115
	sendHTTPResponse(writer, makeResponse(http.StatusOK, nil))
432
116
}
433
117
434
118
func restartAccessPoint(c *serviceCommand) error {
435
119
	if c.s.ap != nil {
436
120
		// Now that we have all configuration changes successfully applied
437
121
		// we can safely restart the service.
438
122
		if err := c.s.ap.Restart(); err != nil {
439
123
			return err
440
124
		}
441
125
	}
442
126
	return nil
443
127
}
444
128
445
129
func getStatus(c *serviceCommand, writer http.ResponseWriter, request *http.Request) {
446
130
	status := make(map[string]string)
447
131
448
132
	status["ap.active"] = "0"
449
133
	if c.s.ap != nil && c.s.ap.Running() {
450
134
		status["ap.active"] = "1"
451
135
	}
452
136
453
137
	sendHTTPResponse(writer, makeResponse(http.StatusOK, status))
454
138
}
455
139
456
140
func postStatus(c *serviceCommand, writer http.ResponseWriter, request *http.Request) {
457
141
	body, err := ioutil.ReadAll(request.Body)
458
142
	if err != nil {
459
143
		resp := makeErrorResponse(http.StatusInternalServerError, "Error reading the request body", "internal-error")
460
144
		sendHTTPResponse(writer, resp)
461
145
		return
462
146
	}
463
147
464
148
	var items map[string]string
465
149
	if json.Unmarshal(body, &items) != nil {
466
150
		resp := makeErrorResponse(http.StatusInternalServerError, "Malformed request", "internal-error")
467
151
		sendHTTPResponse(writer, resp)
468
152
		return
469
153
	}
470
154
471
155
	action, ok := items["action"]
472
156
	if !ok {
473
157
		resp := makeErrorResponse(http.StatusInternalServerError, "Mailformed request", "internal-error")
474
158
		sendHTTPResponse(writer, resp)
475
159
		return
476
160
	}
477
161
478
162
	switch action {
479
163
	case "restart-ap":
480
164
		if err = restartAccessPoint(c); err != nil {
481
165
			resp := makeErrorResponse(http.StatusInternalServerError, "Failed to restart AP process", "internal-error")
482
166
			sendHTTPResponse(writer, resp)
483
167
			return
484
168
		}
485
169
486
170
		resp := makeResponse(http.StatusOK, nil)
487
171
		sendHTTPResponse(writer, resp)
488
172
	}
489
173
490
174
	resp := makeErrorResponse(http.StatusInternalServerError, "Invalid request", "internal-error")
491
175
	sendHTTPResponse(writer, resp)
492
176
}
493
diff --git a/cmd/service/api_test.go b/cmd/service/api_test.go
494
0
new file mode 100644
177
new file mode 100644
495
index 0000000..433843b
496
--- /dev/null
497
+++ b/cmd/service/api_test.go
498
@@ -0,0 +1,344 @@
499
1
//
500
2
// Copyright (C) 2016 Canonical Ltd
501
3
//
502
4
// This program is free software: you can redistribute it and/or modify
503
5
// it under the terms of the GNU General Public License version 3 as
504
6
// published by the Free Software Foundation.
505
7
//
506
8
// This program is distributed in the hope that it will be useful,
507
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
508
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
509
11
// GNU General Public License for more details.
510
12
//
511
13
// You should have received a copy of the GNU General Public License
512
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
513
15
514
16
package main
515
17
516
18
import (
517
19
	"bytes"
518
20
	"encoding/json"
519
21
	"io/ioutil"
520
22
	"net/http"
521
23
	"net/http/httptest"
522
24
	"os"
523
25
	"path/filepath"
524
26
	"strings"
525
27
	"testing"
526
28
527
29
	"gopkg.in/check.v1"
528
30
)
529
31
530
32
// gopkg.in/check.v1 stuff
531
33
func Test(t *testing.T) { check.TestingT(t) }
532
34
533
35
type S struct{}
534
36
535
37
var _ = check.Suite(&S{})
536
38
537
39
type mockBackgroundProcess struct {
538
40
	running bool
539
41
}
540
42
541
43
func (p *mockBackgroundProcess) Start() error {
542
44
	p.running = true
543
45
	return nil
544
46
}
545
47
546
48
func (p *mockBackgroundProcess) Stop() error {
547
49
	p.running = false
548
50
	return nil
549
51
}
550
52
551
53
func (p *mockBackgroundProcess) Restart() error {
552
54
	p.running = true
553
55
	return nil
554
56
}
555
57
556
58
func (p *mockBackgroundProcess) Running() bool {
557
59
	return p.running
558
60
}
559
61
560
62
func newMockServiceCommand() *serviceCommand {
561
63
	return &serviceCommand{
562
64
		s: &service{
563
65
			ap: &mockBackgroundProcess{},
564
66
		},
565
67
	}
566
68
}
567
69
568
70
func (s *S) TestGetConfiguration(c *check.C) {
569
71
	// Check it we get a valid JSON as configuration
570
72
	req, err := http.NewRequest(http.MethodGet, "/v1/configuration", nil)
571
73
	c.Assert(err, check.IsNil)
572
74
573
75
	rec := httptest.NewRecorder()
574
76
575
77
	cmd := newMockServiceCommand()
576
78
	getConfiguration(cmd, rec, req)
577
79
578
80
	body, err := ioutil.ReadAll(rec.Body)
579
81
	c.Assert(err, check.IsNil)
580
82
581
83
	// Parse the returned JSON
582
84
	var resp serviceResponse
583
85
	err = json.Unmarshal(body, &resp)
584
86
	c.Assert(err, check.IsNil)
585
87
586
88
	// Check for 200 status code
587
89
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
588
90
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
589
91
	c.Assert(resp.Type, check.Equals, "sync")
590
92
}
591
93
592
94
func (s *S) TestNoDefaultConfiguration(c *check.C) {
593
95
	oldsnap := os.Getenv("SNAP")
594
96
	os.Setenv("SNAP", "/nodir")
595
97
	os.Setenv("SNAP_DATA", "/tmp")
596
98
597
99
	req, err := http.NewRequest(http.MethodPost, "/v1/configuration", nil)
598
100
	c.Assert(err, check.IsNil)
599
101
600
102
	rec := httptest.NewRecorder()
601
103
	cmd := newMockServiceCommand()
602
104
603
105
	validTokens = nil
604
106
605
107
	postConfiguration(cmd, rec, req)
606
108
607
109
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
608
110
609
111
	body, err := ioutil.ReadAll(rec.Body)
610
112
	c.Assert(err, check.IsNil)
611
113
612
114
	// Parse the returned JSON
613
115
	var resp serviceResponse
614
116
	err = json.Unmarshal(body, &resp)
615
117
	c.Assert(err, check.IsNil)
616
118
617
119
	// Check for 500 status code and other error fields
618
120
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
619
121
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
620
122
	c.Assert(resp.Type, check.Equals, "error")
621
123
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
622
124
	c.Assert(resp.Result["message"], check.Equals, "No default configuration file available")
623
125
624
126
	os.Setenv("SNAP", oldsnap)
625
127
}
626
128
627
129
func (s *S) TestWriteError(c *check.C) {
628
130
	// Test a non writable path:
629
131
	os.Setenv("SNAP_DATA", "/nodir")
630
132
631
133
	req, err := http.NewRequest(http.MethodPost, "/v1/configuration", nil)
632
134
	c.Assert(err, check.IsNil)
633
135
634
136
	rec := httptest.NewRecorder()
635
137
	cmd := newMockServiceCommand()
636
138
637
139
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
638
140
	c.Assert(validTokens, check.NotNil)
639
141
	c.Assert(err, check.IsNil)
640
142
641
143
	postConfiguration(cmd, rec, req)
642
144
643
145
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
644
146
645
147
	body, err := ioutil.ReadAll(rec.Body)
646
148
	c.Assert(err, check.IsNil)
647
149
648
150
	// Parse the returned JSON
649
151
	var resp serviceResponse
650
152
	err = json.Unmarshal(body, &resp)
651
153
	c.Assert(err, check.IsNil)
652
154
653
155
	// Check for 500 status code and other error fields
654
156
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
655
157
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
656
158
	c.Assert(resp.Type, check.Equals, "error")
657
159
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
658
160
	c.Assert(resp.Result["message"], check.Equals, "Can't write configuration file")
659
161
}
660
162
661
163
func (s *S) TestInvalidJSON(c *check.C) {
662
164
	// Test an invalid JSON
663
165
	os.Setenv("SNAP_DATA", "/tmp")
664
166
	req, err := http.NewRequest(http.MethodPost, "/v1/configuration", strings.NewReader("not a JSON content"))
665
167
	c.Assert(err, check.IsNil)
666
168
667
169
	rec := httptest.NewRecorder()
668
170
	cmd := newMockServiceCommand()
669
171
670
172
	postConfiguration(cmd, rec, req)
671
173
672
174
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
673
175
674
176
	body, err := ioutil.ReadAll(rec.Body)
675
177
	c.Assert(err, check.IsNil)
676
178
677
179
	// Parse the returned JSON
678
180
	resp := serviceResponse{}
679
181
	err = json.Unmarshal(body, &resp)
680
182
	c.Assert(err, check.IsNil)
681
183
682
184
	// Check for 500 status code and other error fields
683
185
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
684
186
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
685
187
	c.Assert(resp.Type, check.Equals, "error")
686
188
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
687
189
	c.Assert(resp.Result["message"], check.Equals, "Malformed request")
688
190
}
689
191
690
192
func (s *S) TestInvalidToken(c *check.C) {
691
193
	// Test a succesful configuration set
692
194
	// Values to be used in the config
693
195
	values := map[string]string{
694
196
		"wifi.security":            "wpa2",
695
197
		"wifi.ssid":                "UbuntuAP",
696
198
		"wifi.security-passphrase": "12345678",
697
199
		"bad.token":                "xyz",
698
200
	}
699
201
700
202
	// Convert the map into JSON
701
203
	args, err := json.Marshal(values)
702
204
	c.Assert(err, check.IsNil)
703
205
704
206
	req, err := http.NewRequest(http.MethodPost, "/v1/configuration", bytes.NewReader(args))
705
207
	c.Assert(err, check.IsNil)
706
208
707
209
	rec := httptest.NewRecorder()
708
210
	cmd := newMockServiceCommand()
709
211
710
212
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
711
213
	c.Assert(validTokens, check.NotNil)
712
214
	c.Assert(err, check.IsNil)
713
215
714
216
	// Do the request
715
217
	postConfiguration(cmd, rec, req)
716
218
717
219
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
718
220
719
221
	// Read the result JSON
720
222
	body, err := ioutil.ReadAll(rec.Body)
721
223
	c.Assert(err, check.IsNil)
722
224
723
225
	// Parse the returned JSON
724
226
	resp := serviceResponse{}
725
227
	err = json.Unmarshal(body, &resp)
726
228
	c.Assert(err, check.IsNil)
727
229
728
230
	// Check for 500 status code and other succesful fields
729
231
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
730
232
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
731
233
	c.Assert(resp.Type, check.Equals, "error")
732
234
}
733
235
734
236
func (s *S) TestChangeConfiguration(c *check.C) {
735
237
	// Values to be used in the config
736
238
	values := map[string]string{
737
239
		"disabled":                 "0",
738
240
		"wifi.security":            "wpa2",
739
241
		"wifi.ssid":                "UbuntuAP",
740
242
		"wifi.security-passphrase": "12345678",
741
243
	}
742
244
743
245
	// Convert the map into JSON
744
246
	args, err := json.Marshal(values)
745
247
	c.Assert(err, check.IsNil)
746
248
747
249
	req, err := http.NewRequest(http.MethodPost, "/v1/configuration", bytes.NewReader(args))
748
250
	c.Assert(err, check.IsNil)
749
251
750
252
	rec := httptest.NewRecorder()
751
253
	cmd := newMockServiceCommand()
752
254
753
255
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
754
256
	c.Assert(validTokens, check.NotNil)
755
257
	c.Assert(err, check.IsNil)
756
258
757
259
	// Do the request
758
260
	postConfiguration(cmd, rec, req)
759
261
760
262
	c.Assert(rec.Code, check.Equals, http.StatusOK)
761
263
762
264
	// Read the result JSON
763
265
	body, err := ioutil.ReadAll(rec.Body)
764
266
	c.Assert(err, check.IsNil)
765
267
766
268
	// Parse the returned JSON
767
269
	resp := serviceResponse{}
768
270
	err = json.Unmarshal(body, &resp)
769
271
	c.Assert(err, check.IsNil)
770
272
771
273
	// Check for 200 status code and other succesful fields
772
274
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
773
275
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
774
276
	c.Assert(resp.Type, check.Equals, "sync")
775
277
776
278
	// Read the generated config and check that values were set
777
279
	config, err := ioutil.ReadFile(getConfigOnPath(os.Getenv("SNAP_DATA")))
778
280
	c.Assert(err, check.IsNil)
779
281
780
282
	for key, value := range values {
781
283
		c.Assert(strings.Contains(string(config),
782
284
			convertKeyToStorageFormat(key)+"="+value+"\n"),
783
285
			check.Equals, true)
784
286
	}
785
287
786
288
	// As we've set 'disabled' to '0' above the AP should be active
787
289
	// now as the configuration post request will trigger an automatic
788
290
	// restart of the relevant background processes.
789
291
	c.Assert(cmd.s.ap.Running(), check.Equals, true)
790
292
791
293
	// Don't leave garbage in /tmp
792
294
	os.Remove(getConfigOnPath(os.Getenv("SNAP_DATA")))
793
295
}
794
296
795
297
func (s *S) TestGetStatusDefaultOk(c *check.C) {
796
298
	req, err := http.NewRequest(http.MethodGet, "/v1/status", nil)
797
299
	c.Assert(err, check.IsNil)
798
300
799
301
	rec := httptest.NewRecorder()
800
302
801
303
	cmd := newMockServiceCommand()
802
304
803
305
	getStatus(cmd, rec, req)
804
306
805
307
	body, err := ioutil.ReadAll(rec.Body)
806
308
	c.Assert(err, check.IsNil)
807
309
808
310
	var resp serviceResponse
809
311
	err = json.Unmarshal(body, &resp)
810
312
	c.Assert(err, check.IsNil)
811
313
812
314
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
813
315
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
814
316
	c.Assert(resp.Type, check.Equals, "sync")
815
317
816
318
	c.Assert(resp.Result["ap.active"], check.Equals, "0")
817
319
}
818
320
819
321
func (s *S) TestGetStatusReturnsCorrectApStatus(c *check.C) {
820
322
	req, err := http.NewRequest(http.MethodGet, "/v1/status", nil)
821
323
	c.Assert(err, check.IsNil)
822
324
823
325
	rec := httptest.NewRecorder()
824
326
825
327
	cmd := newMockServiceCommand()
826
328
	cmd.s.ap.Start()
827
329
828
330
	getStatus(cmd, rec, req)
829
331
830
332
	body, err := ioutil.ReadAll(rec.Body)
831
333
	c.Assert(err, check.IsNil)
832
334
833
335
	var resp serviceResponse
834
336
	err = json.Unmarshal(body, &resp)
835
337
	c.Assert(err, check.IsNil)
836
338
837
339
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
838
340
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
839
341
	c.Assert(resp.Type, check.Equals, "sync")
840
342
841
343
	c.Assert(resp.Result["ap.active"], check.Equals, "1")
842
344
}
843
diff --git a/cmd/service/background_process.go b/cmd/service/background_process.go
844
0
new file mode 100644
345
new file mode 100644
845
index 0000000..6a1ea7e
846
--- /dev/null
847
+++ b/cmd/service/background_process.go
848
@@ -0,0 +1,147 @@
849
1
//
850
2
// Copyright (C) 2016 Canonical Ltd
851
3
//
852
4
// This program is free software: you can redistribute it and/or modify
853
5
// it under the terms of the GNU General Public License version 3 as
854
6
// published by the Free Software Foundation.
855
7
//
856
8
// This program is distributed in the hope that it will be useful,
857
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
858
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
859
11
// GNU General Public License for more details.
860
12
//
861
13
// You should have received a copy of the GNU General Public License
862
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
863
15
864
16
package main
865
17
866
18
import (
867
19
	"fmt"
868
20
	"os"
869
21
	"os/exec"
870
22
	"syscall"
871
23
	"sync"
872
24
	"time"
873
25
874
26
	"gopkg.in/tomb.v2"
875
27
)
876
28
877
29
type backgroundProcessImpl struct {
878
30
	path    string
879
31
	args    []string
880
32
	command *exec.Cmd
881
33
	tomb    *tomb.Tomb
882
34
	mutex   sync.Mutex
883
35
}
884
36
885
37
// BackgroundProcess provides control over a process running in the
886
38
// background.
887
39
type BackgroundProcess interface {
888
40
	Start() error
889
41
	Stop() error
890
42
	Restart() error
891
43
	Running() bool
892
44
}
893
45
894
46
func NewBackgroundProcess(path string, args ...string) (BackgroundProcess, error) {
895
47
	p := &backgroundProcessImpl{
896
48
		path:    path,
897
49
		args:    args,
898
50
		command: nil,
899
51
	}
900
52
	if p == nil {
901
53
		return nil, fmt.Errorf("Failed to create background process")
902
54
	}
903
55
904
56
	return p, nil
905
57
}
906
58
907
59
func (p *backgroundProcessImpl) Start() error {
908
60
	if p.Running() {
909
61
		return fmt.Errorf("Background process is already running")
910
62
	}
911
63
912
64
	p.mutex.Lock()
913
65
914
66
	p.command = exec.Command(p.path, p.args...)
915
67
	if p.command == nil {
916
68
		return fmt.Errorf("Failed to create background process")
917
69
	}
918
70
919
71
	// Forward output to regular stdout/stderr
920
72
	p.command.Stdout = os.Stdout
921
73
	p.command.Stderr = os.Stderr
922
74
923
75
	// Create a new process group
924
76
	p.command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
925
77
926
78
	// We need to recreate the tomb here everytime as otherwise
927
79
	// it will not cleanup its state from the last time.
928
80
	p.tomb = &tomb.Tomb{}
929
81
930
82
	c := make(chan int)
931
83
	p.tomb.Go(func() error {
932
84
		err := p.command.Start()
933
85
		if err != nil {
934
86
			fmt.Printf("Failed to execute process for binary '%s'", p.path)
935
87
			return err
936
88
		}
937
89
		c <- 1
938
90
		p.command.Wait()
939
91
		p.command = nil
940
92
		return nil
941
93
	})
942
94
943
95
	// Wait until the process is really started
944
96
	_ = <-c
945
97
946
98
	p.mutex.Unlock()
947
99
948
100
	return nil
949
101
}
950
102
951
103
func (p *backgroundProcessImpl) Restart() error {
952
104
	if err := p.Stop(); err != nil {
953
105
		return err
954
106
	}
955
107
	if err := p.Start(); err != nil {
956
108
		return err
957
109
	}
958
110
	return nil
959
111
}
960
112
961
113
func (p *backgroundProcessImpl) killProcess(signal syscall.Signal) error {
962
114
	if p == nil || p.command == nil {
963
115
		return fmt.Errorf("Process is not running")
964
116
	}
965
117
	// We need to kill the whole process group as otherwise some
966
118
	// child processes are still around
967
119
	pgid, err := syscall.Getpgid(p.command.Process.Pid)
968
120
	if err == nil {
969
121
		syscall.Kill(-pgid, signal)
970
122
	} else {
971
123
		syscall.Kill(p.command.Process.Pid, signal)
972
124
	}
973
125
	return nil
974
126
}
975
127
976
128
func (p *backgroundProcessImpl) Stop() error {
977
129
	if !p.Running() {
978
130
		return nil
979
131
	}
980
132
	p.mutex.Lock()
981
133
	timer := time.AfterFunc(10*time.Second, func() {
982
134
		p.killProcess(syscall.SIGKILL)
983
135
	})
984
136
	p.killProcess(syscall.SIGTERM)
985
137
	p.tomb.Kill(nil)
986
138
	p.tomb.Wait()
987
139
	timer.Stop()
988
140
	p.mutex.Unlock()
989
141
	p.command = nil
990
142
	return nil
991
143
}
992
144
993
145
func (p *backgroundProcessImpl) Running() bool {
994
146
	return p.command != nil
995
147
}
996
diff --git a/cmd/service/background_process_test.go b/cmd/service/background_process_test.go
997
0
new file mode 100644
148
new file mode 100644
998
index 0000000..5ae9cd7
999
--- /dev/null
1000
+++ b/cmd/service/background_process_test.go
1001
@@ -0,0 +1,36 @@
1002
1
//
1003
2
// Copyright (C) 2016 Canonical Ltd
1004
3
//
1005
4
// This program is free software: you can redistribute it and/or modify
1006
5
// it under the terms of the GNU General Public License version 3 as
1007
6
// published by the Free Software Foundation.
1008
7
//
1009
8
// This program is distributed in the hope that it will be useful,
1010
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1011
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1012
11
// GNU General Public License for more details.
1013
12
//
1014
13
// You should have received a copy of the GNU General Public License
1015
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1016
15
1017
16
package main
1018
17
1019
18
import (
1020
19
	"fmt"
1021
20
1022
21
	"gopkg.in/check.v1"
1023
22
)
1024
23
1025
24
func (s *S) TestBackgroundProcessStartStop(c *check.C) {
1026
25
	p, err := NewBackgroundProcess("/bin/sleep", "1000")
1027
26
	c.Assert(err, check.IsNil)
1028
27
	c.Assert(p.Running(), check.Equals, false)
1029
28
	c.Assert(p.Start(), check.IsNil)
1030
29
	c.Assert(p.Running(), check.Equals, true)
1031
30
	c.Assert(p.Stop(), check.IsNil)
1032
31
	c.Assert(p.Running(), check.Equals, false)
1033
32
	c.Assert(p.Restart(), check.IsNil)
1034
33
	c.Assert(p.Running(), check.Equals, true)
1035
34
	c.Assert(p.Start(), check.DeepEquals, fmt.Errorf("Background process is already running"))
1036
35
	c.Assert(p.Running(), check.Equals, true)
1037
36
}
1038
diff --git a/cmd/service/config.go b/cmd/service/config.go
1039
0
new file mode 100644
37
new file mode 100644
1040
index 0000000..bbc047e
1041
--- /dev/null
1042
+++ b/cmd/service/config.go
1043
@@ -0,0 +1,140 @@
1044
1
//
1045
2
// Copyright (C) 2016 Canonical Ltd
1046
3
//
1047
4
// This program is free software: you can redistribute it and/or modify
1048
5
// it under the terms of the GNU General Public License version 3 as
1049
6
// published by the Free Software Foundation.
1050
7
//
1051
8
// This program is distributed in the hope that it will be useful,
1052
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1053
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1054
11
// GNU General Public License for more details.
1055
12
//
1056
13
// You should have received a copy of the GNU General Public License
1057
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1058
15
1059
16
package main
1060
17
1061
18
import (
1062
19
	"bufio"
1063
20
	"fmt"
1064
21
	"os"
1065
22
	"path/filepath"
1066
23
	"regexp"
1067
24
	"strings"
1068
25
)
1069
26
1070
27
func getConfigOnPath(path string) string {
1071
28
	return filepath.Join(path, "config")
1072
29
}
1073
30
1074
31
// Array of paths where the config file can be found.
1075
32
// The first one is readonly, the others are writable
1076
33
// they are readed in order and the configuration is merged
1077
34
var configurationPaths = []string{
1078
35
	filepath.Join(os.Getenv("SNAP"), "conf", "default-config"),
1079
36
	getConfigOnPath(os.Getenv("SNAP_DATA")),
1080
37
	getConfigOnPath(os.Getenv("SNAP_USER_DATA"))}
1081
38
1082
39
// Convert eg. WIFI_OPERATION_MODE to wifi.operation-mode
1083
40
func convertKeyToRepresentationFormat(key string) string {
1084
41
	newKey := strings.ToLower(key)
1085
42
	newKey = strings.Replace(newKey, "_", ".", 1)
1086
43
	return strings.Replace(newKey, "_", "-", -1)
1087
44
}
1088
45
1089
46
func convertKeyToStorageFormat(key string) string {
1090
47
	// Convert eg. wifi.operation-mode to WIFI_OPERATION_MODE
1091
48
	newKey := strings.ToUpper(key)
1092
49
	newKey = strings.Replace(newKey, ".", "_", -1)
1093
50
	return strings.Replace(newKey, "-", "_", -1)
1094
51
}
1095
52
1096
53
func readConfigurationFile(filePath string, config map[string]string) (err error) {
1097
54
	file, err := os.Open(filePath)
1098
55
	if err != nil {
1099
56
		return nil
1100
57
	}
1101
58
1102
59
	defer file.Close()
1103
60
1104
61
	for scanner := bufio.NewScanner(file); scanner.Scan(); {
1105
62
		// Ignore all empty or commented lines
1106
63
		if line := scanner.Text(); len(line) != 0 && line[0] != '#' {
1107
64
			// Line must be in the KEY=VALUE format
1108
65
			if parts := strings.Split(line, "="); len(parts) == 2 {
1109
66
				value := unescapeTextByShell(parts[1])
1110
67
				config[convertKeyToRepresentationFormat(parts[0])] = value
1111
68
			}
1112
69
		}
1113
70
	}
1114
71
1115
72
	return nil
1116
73
}
1117
74
1118
75
func readConfiguration(paths []string, config map[string]string) (err error) {
1119
76
	for _, location := range paths {
1120
77
		if readConfigurationFile(location, config) != nil {
1121
78
			return fmt.Errorf("Failed to read configuration file '%s'", location)
1122
79
		}
1123
80
	}
1124
81
1125
82
	return nil
1126
83
}
1127
84
1128
85
// Escape shell special characters, avoid injection
1129
86
// eg. SSID set to "My AP$(nc -lp 2323 -e /bin/sh)"
1130
87
// to get a root shell
1131
88
func escapeTextForShell(input string) string {
1132
89
	if strings.ContainsAny(input, "\\\"'`$\n\t #") {
1133
90
		input = strings.Replace(input, `\`, `\\`, -1)
1134
91
		input = strings.Replace(input, `"`, `\"`, -1)
1135
92
		input = strings.Replace(input, "`", "\\`", -1)
1136
93
		input = strings.Replace(input, `$`, `\$`, -1)
1137
94
1138
95
		input = `"` + input + `"`
1139
96
	}
1140
97
	return input
1141
98
}
1142
99
1143
100
// Do the reverse of escapeTextForShell() here
1144
101
// strip any \ followed by \$`"
1145
102
func unescapeTextByShell(input string) string {
1146
103
	input = strings.Trim(input, `"'`)
1147
104
	if strings.ContainsAny(input, "\\") {
1148
105
		re := regexp.MustCompile("\\\\([\\\\$\\`\\\"])")
1149
106
		input = re.ReplaceAllString(input, "$1")
1150
107
	}
1151
108
	return input
1152
109
}
1153
110
1154
111
func loadValidTokens(path string) (map[string]bool, error) {
1155
112
	def, err := os.Open(path)
1156
113
	if err != nil {
1157
114
		return nil, err
1158
115
	}
1159
116
	defer def.Close()
1160
117
1161
118
	tokens := map[string]bool{}
1162
119
1163
120
	scanner := bufio.NewScanner(def)
1164
121
	for scanner.Scan() {
1165
122
		line := scanner.Text()
1166
123
1167
124
		// Skip empty lines and comments
1168
125
		if len(line) == 0 || line[0] == '#' {
1169
126
			continue
1170
127
		}
1171
128
1172
129
		// Get the substring before the '='
1173
130
		if eq := strings.IndexRune(line, '='); eq > 0 {
1174
131
			// Add the token to the whitelist, converted in our format
1175
132
			tokens[convertKeyToRepresentationFormat(line[:eq])] = true
1176
133
		}
1177
134
	}
1178
135
	if err := scanner.Err(); err != nil {
1179
136
		return nil, err
1180
137
	}
1181
138
1182
139
	return tokens, nil
1183
140
}
1184
diff --git a/cmd/service/config_test.go b/cmd/service/config_test.go
1185
0
new file mode 100644
141
new file mode 100644
1186
index 0000000..9f59ea9
1187
--- /dev/null
1188
+++ b/cmd/service/config_test.go
1189
@@ -0,0 +1,66 @@
1190
1
//
1191
2
// Copyright (C) 2016 Canonical Ltd
1192
3
//
1193
4
// This program is free software: you can redistribute it and/or modify
1194
5
// it under the terms of the GNU General Public License version 3 as
1195
6
// published by the Free Software Foundation.
1196
7
//
1197
8
// This program is distributed in the hope that it will be useful,
1198
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1199
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1200
11
// GNU General Public License for more details.
1201
12
//
1202
13
// You should have received a copy of the GNU General Public License
1203
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1204
15
1205
16
package main
1206
17
1207
18
import (
1208
19
	"gopkg.in/check.v1"
1209
20
)
1210
21
1211
22
// Test the config file path append routine
1212
23
func (s *S) TestPath(c *check.C) {
1213
24
	c.Assert(getConfigOnPath("/test"), check.Equals, "/test/config")
1214
25
}
1215
26
1216
27
// List of tokens to be translated
1217
28
var cfgKeys = [...][2]string{
1218
29
	{"DISABLED", "disabled"},
1219
30
	{"WIFI_SSID", "wifi.ssid"},
1220
31
	{"WIFI_INTERFACE", "wifi.interface"},
1221
32
	{"WIFI_INTERFACE_MODE", "wifi.interface-mode"},
1222
33
	{"DHCP_RANGE_START", "dhcp.range-start"},
1223
34
	{"MYTOKEN", "mytoken"},
1224
35
	{"CFG_TOKEN", "cfg.token"},
1225
36
	{"MY_TOKEN$", "my.token$"},
1226
37
}
1227
38
1228
39
// Test token conversion from internal format
1229
40
func (s *S) TestConvertKeyToRepresentationFormat(c *check.C) {
1230
41
	for _, st := range cfgKeys {
1231
42
		c.Assert(convertKeyToRepresentationFormat(st[0]), check.Equals, st[1])
1232
43
	}
1233
44
}
1234
45
1235
46
// Test token conversion to internal format
1236
47
func (s *S) TestConvertKeyToStorageFormat(c *check.C) {
1237
48
	for _, st := range cfgKeys {
1238
49
		c.Assert(convertKeyToStorageFormat(st[1]), check.Equals, st[0])
1239
50
	}
1240
51
}
1241
52
1242
53
// List of malicious tokens which needs to be escaped
1243
54
func (s *S) TestEscapeShell(c *check.C) {
1244
55
	cmds := [...][2]string{
1245
56
		{"my_ap", "my_ap"},
1246
57
		{`my ap`, `"my ap"`},
1247
58
		{`my "ap"`, `"my \"ap\""`},
1248
59
		{`$(ps ax)`, `"\$(ps ax)"`},
1249
60
		{"`ls /`", "\"\\`ls /\\`\""},
1250
61
		{`c:\dir`, `"c:\\dir"`},
1251
62
	}
1252
63
	for _, st := range cmds {
1253
64
		c.Assert(escapeTextForShell(st[0]), check.Equals, st[1])
1254
65
	}
1255
66
}
1256
diff --git a/cmd/service/main.go b/cmd/service/main.go
1257
index 0fd82e7..ae5e679 100644
1258
--- a/cmd/service/main.go
1259
+++ b/cmd/service/main.go
1260
@@ -1,4 +1,3 @@
1261
1
//
1262
2
// Copyright (C) 2016 Canonical Ltd
1
// Copyright (C) 2016 Canonical Ltd
1263
3
//
2
//
1264
4
// This program is free software: you can redistribute it and/or modify
3
// This program is free software: you can redistribute it and/or modify
1265
@@ -16,277 +15,23 @@
1266
16
package main
15
package main
1267
17
16
1268
18
import (
17
import (
1269
19
	"bufio"
1270
20
	"encoding/json"
1271
21
	"fmt"
1272
22
	"io/ioutil"
1273
23
	"log"
18
	"log"
1274
24
	"net/http"
1275
25
	"os"
19
	"os"
1350
26
	"path/filepath"
20
	"os/signal"
1351
27
	"regexp"
21
	"syscall"
1278
28
	"strconv"
1279
29
	"strings"
1280
30
1281
31
	"github.com/gorilla/mux"
1282
32
)
1283
33
1284
34
/* JSON message format, as described here:
1285
35
{
1286
36
	"result": {
1287
37
		"key" : "val"
1288
38
	},
1289
39
	"status": "OK",
1290
40
	"status-code": 200,
1291
41
	"type": "sync"
1292
42
}
1293
43
*/
1294
44
1295
45
type serviceResponse struct {
1296
46
	Result     map[string]string `json:"result"`
1297
47
	Status     string            `json:"status"`
1298
48
	StatusCode int               `json:"status-code"`
1299
49
	Type       string            `json:"type"`
1300
50
}
1301
51
1302
52
func makeErrorResponse(code int, message, kind string) *serviceResponse {
1303
53
	return &serviceResponse{
1304
54
		Type:       "error",
1305
55
		Status:     http.StatusText(code),
1306
56
		StatusCode: code,
1307
57
		Result: map[string]string{
1308
58
			"message": message,
1309
59
			"kind":    kind,
1310
60
		},
1311
61
	}
1312
62
}
1313
63
1314
64
func makeResponse(status int, result map[string]string) *serviceResponse {
1315
65
	resp := &serviceResponse{
1316
66
		Type:       "sync",
1317
67
		Status:     http.StatusText(status),
1318
68
		StatusCode: status,
1319
69
		Result:     result,
1320
70
	}
1321
71
1322
72
	if resp.Result == nil {
1323
73
		resp.Result = make(map[string]string)
1324
74
	}
1325
75
1326
76
	return resp
1327
77
}
1328
78
1329
79
func sendHTTPResponse(writer http.ResponseWriter, response *serviceResponse) {
1330
80
	writer.WriteHeader(response.StatusCode)
1331
81
	data, _ := json.Marshal(response)
1332
82
	fmt.Fprintln(writer, string(data))
1333
83
}
1334
84
1335
85
func getConfigOnPath(confPath string) string {
1336
86
	return filepath.Join(confPath, "config")
1337
87
}
1338
88
1339
89
// Array of paths where the config file can be found.
1340
90
// The first one is readonly, the others are writable
1341
91
// they are readed in order and the configuration is merged
1342
92
var configurationPaths = []string{
1343
93
	filepath.Join(os.Getenv("SNAP"), "conf", "default-config"),
1344
94
	getConfigOnPath(os.Getenv("SNAP_DATA")),
1345
95
	getConfigOnPath(os.Getenv("SNAP_USER_DATA"))}
1346
96
1347
97
const (
1348
98
	servicePort        = 5005
1349
99
	configurationV1Uri = "/v1/configuration"
1352
100
)
22
)
1353
101
23
1354
102
var validTokens map[string]bool
1355
103
1356
104
func loadValidTokens(path string) (map[string]bool, error) {
1357
105
	def, err := os.Open(path)
1358
106
	if err != nil {
1359
107
		return nil, err
1360
108
	}
1361
109
	defer def.Close()
1362
110
1363
111
	tokens := map[string]bool{}
1364
112
1365
113
	scanner := bufio.NewScanner(def)
1366
114
	for scanner.Scan() {
1367
115
		line := scanner.Text()
1368
116
1369
117
		// Skip empty lines and comments
1370
118
		if len(line) == 0 || line[0] == '#' {
1371
119
			continue
1372
120
		}
1373
121
1374
122
		// Get the substring before the '='
1375
123
		if eq := strings.IndexRune(line, '='); eq > 0 {
1376
124
			// Add the token to the whitelist, converted in our format
1377
125
			tokens[convertKeyToRepresentationFormat(line[:eq])] = true
1378
126
		}
1379
127
	}
1380
128
	if err := scanner.Err(); err != nil {
1381
129
		return nil, err
1382
130
	}
1383
131
1384
132
	return tokens, nil
1385
133
}
1386
134
1387
135
func main() {
24
func main() {
1389
136
	r := mux.NewRouter().StrictSlash(true)
25
	s := &service{}
1390
137
26
1395
138
	var err error
27
	c := make(chan os.Signal, 1)
1396
139
	if validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "conf", "default-config")); err != nil {
28
	signal.Notify(c, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
1397
140
		log.Println("Failed to read default configuration:", err)
29
	go func(s *service) {
1398
141
	}
30
		_ = <-c
1399
31
		s.Shutdown()
1400
32
	}(s)
1401
142
33
1450
143
	r.HandleFunc(configurationV1Uri, getConfiguration).Methods(http.MethodGet)
34
	if err := s.Run(); err != nil {
1451
144
	r.HandleFunc(configurationV1Uri, changeConfiguration).Methods(http.MethodPost)
35
		log.Fatalf("Failed to start service: %s", err)
1404
145
1405
146
	log.Fatal(http.ListenAndServe("127.0.0.1:"+strconv.Itoa(servicePort), r))
1406
147
}
1407
148
1408
149
// Convert eg. WIFI_OPERATION_MODE to wifi.operation-mode
1409
150
func convertKeyToRepresentationFormat(key string) string {
1410
151
	newKey := strings.ToLower(key)
1411
152
	newKey = strings.Replace(newKey, "_", ".", 1)
1412
153
	return strings.Replace(newKey, "_", "-", -1)
1413
154
}
1414
155
1415
156
func convertKeyToStorageFormat(key string) string {
1416
157
	// Convert eg. wifi.operation-mode to WIFI_OPERATION_MODE
1417
158
	newKey := strings.ToUpper(key)
1418
159
	newKey = strings.Replace(newKey, ".", "_", -1)
1419
160
	return strings.Replace(newKey, "-", "_", -1)
1420
161
}
1421
162
1422
163
func readConfigurationFile(filePath string, config map[string]string) (err error) {
1423
164
	file, err := os.Open(filePath)
1424
165
	if err != nil {
1425
166
		return nil
1426
167
	}
1427
168
1428
169
	defer file.Close()
1429
170
1430
171
	for scanner := bufio.NewScanner(file); scanner.Scan(); {
1431
172
		// Ignore all empty or commented lines
1432
173
		if line := scanner.Text(); len(line) != 0 && line[0] != '#' {
1433
174
			// Line must be in the KEY=VALUE format
1434
175
			if parts := strings.Split(line, "="); len(parts) == 2 {
1435
176
				key := convertKeyToRepresentationFormat(parts[0])
1436
177
				value := unescapeTextByShell(parts[1])
1437
178
				config[key] = value
1438
179
			}
1439
180
		}
1440
181
	}
1441
182
1442
183
	return nil
1443
184
}
1444
185
1445
186
func readConfiguration(paths []string, config map[string]string) (err error) {
1446
187
	for _, location := range paths {
1447
188
		if readConfigurationFile(location, config) != nil {
1448
189
			return fmt.Errorf(`Failed to read configuration file "%s"`, location)
1449
190
		}
1452
191
	}
36
	}
1453
192
1454
193
	return nil
1455
194
}
1456
195
1457
196
func getConfiguration(writer http.ResponseWriter, request *http.Request) {
1458
197
	config := make(map[string]string)
1459
198
	if err := readConfiguration(configurationPaths, config); err == nil {
1460
199
		sendHTTPResponse(writer, makeResponse(http.StatusOK, config))
1461
200
	} else {
1462
201
		log.Println("Read configuration failed:", err)
1463
202
		errResponse := makeErrorResponse(http.StatusInternalServerError, "Failed to read configuration data", "internal-error")
1464
203
		sendHTTPResponse(writer, errResponse)
1465
204
	}
1466
205
}
1467
206
1468
207
// Escape shell special characters, avoid injection
1469
208
// eg. SSID set to "My AP$(nc -lp 2323 -e /bin/sh)"
1470
209
// to get a root shell
1471
210
func escapeTextForShell(input string) string {
1472
211
	if strings.ContainsAny(input, "\\\"'`$\n\t #") {
1473
212
		input = strings.Replace(input, `\`, `\\`, -1)
1474
213
		input = strings.Replace(input, `"`, `\"`, -1)
1475
214
		input = strings.Replace(input, "`", "\\`", -1)
1476
215
		input = strings.Replace(input, `$`, `\$`, -1)
1477
216
1478
217
		input = `"` + input + `"`
1479
218
	}
1480
219
	return input
1481
220
}
1482
221
1483
222
// Do the reverse of escapeTextForShell() here
1484
223
// strip any \ followed by \$`"
1485
224
func unescapeTextByShell(input string) string {
1486
225
	input = strings.Trim(input, `"'`)
1487
226
	if strings.ContainsAny(input, "\\") {
1488
227
		re := regexp.MustCompile("\\\\([\\\\$\\`\\\"])")
1489
228
		input = re.ReplaceAllString(input, "$1")
1490
229
	}
1491
230
	return input
1492
231
}
1493
232
1494
233
func changeConfiguration(writer http.ResponseWriter, request *http.Request) {
1495
234
	path := getConfigOnPath(os.Getenv("SNAP_DATA"))
1496
235
	config := map[string]string{}
1497
236
	if readConfiguration([]string{path}, config) != nil {
1498
237
		errResponse := makeErrorResponse(http.StatusInternalServerError,
1499
238
			"Failed to read existing configuration file", "internal-error")
1500
239
		sendHTTPResponse(writer, errResponse)
1501
240
		return
1502
241
	}
1503
242
1504
243
	if validTokens == nil || len(validTokens) == 0 {
1505
244
		errResponse := makeErrorResponse(http.StatusInternalServerError, "No default configuration file available", "internal-error")
1506
245
		sendHTTPResponse(writer, errResponse)
1507
246
		return
1508
247
	}
1509
248
1510
249
	file, err := os.Create(path)
1511
250
	if err != nil {
1512
251
		log.Printf("Write to %q failed: %v\n", path, err)
1513
252
		errResponse := makeErrorResponse(http.StatusInternalServerError, "Can't write configuration file", "internal-error")
1514
253
		sendHTTPResponse(writer, errResponse)
1515
254
		return
1516
255
	}
1517
256
	defer file.Close()
1518
257
1519
258
	body, err := ioutil.ReadAll(request.Body)
1520
259
	if err != nil {
1521
260
		log.Println("Failed to process incoming configuration change request:", err)
1522
261
		errResponse := makeErrorResponse(http.StatusInternalServerError, "Error reading the request body", "internal-error")
1523
262
		sendHTTPResponse(writer, errResponse)
1524
263
		return
1525
264
	}
1526
265
1527
266
	var items map[string]string
1528
267
	if err = json.Unmarshal(body, &items); err != nil {
1529
268
		log.Println("Invalid input data", err)
1530
269
		errResponse := makeErrorResponse(http.StatusInternalServerError, "Malformed request", "internal-error")
1531
270
		sendHTTPResponse(writer, errResponse)
1532
271
		return
1533
272
	}
1534
273
1535
274
	// Add the items in the config, but only if all are in the whitelist
1536
275
	for key, value := range items {
1537
276
		if _, present := validTokens[key]; !present {
1538
277
			log.Println(`Invalid key "` + key + `": ignoring request`)
1539
278
			errResponse := makeErrorResponse(http.StatusInternalServerError, `Invalid key "`+key+`"`, "internal-error")
1540
279
			sendHTTPResponse(writer, errResponse)
1541
280
			return
1542
281
		}
1543
282
		config[key] = value
1544
283
	}
1545
284
1546
285
	for key, value := range config {
1547
286
		key = convertKeyToStorageFormat(key)
1548
287
		value = escapeTextForShell(value)
1549
288
		file.WriteString(fmt.Sprintf("%s=%s\n", key, value))
1550
289
	}
1551
290
1552
291
	sendHTTPResponse(writer, makeResponse(http.StatusOK, nil))
1553
292
}
37
}
1554
diff --git a/cmd/service/main_test.go b/cmd/service/main_test.go
1555
293
deleted file mode 100644
38
deleted file mode 100644
1556
index d0fc6be..0000000
1557
--- a/cmd/service/main_test.go
1558
+++ /dev/null
1559
@@ -1,298 +0,0 @@
1560
1
//
1561
2
// Copyright (C) 2016 Canonical Ltd
1562
3
//
1563
4
// This program is free software: you can redistribute it and/or modify
1564
5
// it under the terms of the GNU General Public License version 3 as
1565
6
// published by the Free Software Foundation.
1566
7
//
1567
8
// This program is distributed in the hope that it will be useful,
1568
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1569
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1570
11
// GNU General Public License for more details.
1571
12
//
1572
13
// You should have received a copy of the GNU General Public License
1573
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1574
15
1575
16
package main
1576
17
1577
18
import (
1578
19
	"bytes"
1579
20
	"encoding/json"
1580
21
	"io/ioutil"
1581
22
	"net/http"
1582
23
	"net/http/httptest"
1583
24
	"os"
1584
25
	"path/filepath"
1585
26
	"strings"
1586
27
	"testing"
1587
28
1588
29
	"gopkg.in/check.v1"
1589
30
)
1590
31
1591
32
// gopkg.in/check.v1 stuff
1592
33
func Test(t *testing.T) { check.TestingT(t) }
1593
34
1594
35
type S struct{}
1595
36
1596
37
var _ = check.Suite(&S{})
1597
38
1598
39
// Test the config file path append routine
1599
40
func (s *S) TestPath(c *check.C) {
1600
41
	c.Assert(getConfigOnPath("/test"), check.Equals, "/test/config")
1601
42
}
1602
43
1603
44
// List of tokens to be translated
1604
45
var cfgKeys = [...][2]string{
1605
46
	{"DISABLED", "disabled"},
1606
47
	{"WIFI_SSID", "wifi.ssid"},
1607
48
	{"WIFI_INTERFACE", "wifi.interface"},
1608
49
	{"WIFI_INTERFACE_MODE", "wifi.interface-mode"},
1609
50
	{"DHCP_RANGE_START", "dhcp.range-start"},
1610
51
	{"MYTOKEN", "mytoken"},
1611
52
	{"CFG_TOKEN", "cfg.token"},
1612
53
	{"MY_TOKEN$", "my.token$"},
1613
54
}
1614
55
1615
56
// Test token conversion from internal format
1616
57
func (s *S) TestConvertKeyToRepresentationFormat(c *check.C) {
1617
58
	for _, st := range cfgKeys {
1618
59
		c.Assert(convertKeyToRepresentationFormat(st[0]), check.Equals, st[1])
1619
60
	}
1620
61
}
1621
62
1622
63
// Test token conversion to internal format
1623
64
func (s *S) TestConvertKeyToStorageFormat(c *check.C) {
1624
65
	for _, st := range cfgKeys {
1625
66
		c.Assert(convertKeyToStorageFormat(st[1]), check.Equals, st[0])
1626
67
	}
1627
68
}
1628
69
1629
70
// List of malicious tokens which needs to be escaped
1630
71
func (s *S) TestEscapeShell(c *check.C) {
1631
72
	cmds := [...][2]string{
1632
73
		{"my_ap", "my_ap"},
1633
74
		{`my ap`, `"my ap"`},
1634
75
		{`my "ap"`, `"my \"ap\""`},
1635
76
		{`$(ps ax)`, `"\$(ps ax)"`},
1636
77
		{"`ls /`", "\"\\`ls /\\`\""},
1637
78
		{`c:\dir`, `"c:\\dir"`},
1638
79
	}
1639
80
	for _, st := range cmds {
1640
81
		c.Assert(escapeTextForShell(st[0]), check.Equals, st[1])
1641
82
	}
1642
83
}
1643
84
1644
85
func (s *S) TestGetConfiguration(c *check.C) {
1645
86
	// Check it we get a valid JSON as configuration
1646
87
	req, err := http.NewRequest(http.MethodGet, configurationV1Uri, nil)
1647
88
	c.Assert(err, check.IsNil)
1648
89
1649
90
	rec := httptest.NewRecorder()
1650
91
1651
92
	getConfiguration(rec, req)
1652
93
1653
94
	body, err := ioutil.ReadAll(rec.Body)
1654
95
	c.Assert(err, check.IsNil)
1655
96
1656
97
	// Parse the returned JSON
1657
98
	var resp serviceResponse
1658
99
	err = json.Unmarshal(body, &resp)
1659
100
	c.Assert(err, check.IsNil)
1660
101
1661
102
	// Check for 200 status code
1662
103
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
1663
104
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
1664
105
	c.Assert(resp.Type, check.Equals, "sync")
1665
106
}
1666
107
1667
108
func (s *S) TestNoDefaultConfiguration(c *check.C) {
1668
109
	oldsnap := os.Getenv("SNAP")
1669
110
	os.Setenv("SNAP", "/nodir")
1670
111
	os.Setenv("SNAP_DATA", "/tmp")
1671
112
1672
113
	req, err := http.NewRequest(http.MethodPost, configurationV1Uri, nil)
1673
114
	c.Assert(err, check.IsNil)
1674
115
1675
116
	rec := httptest.NewRecorder()
1676
117
1677
118
	validTokens = nil
1678
119
1679
120
	changeConfiguration(rec, req)
1680
121
1681
122
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
1682
123
1683
124
	body, err := ioutil.ReadAll(rec.Body)
1684
125
	c.Assert(err, check.IsNil)
1685
126
1686
127
	// Parse the returned JSON
1687
128
	var resp serviceResponse
1688
129
	err = json.Unmarshal(body, &resp)
1689
130
	c.Assert(err, check.IsNil)
1690
131
1691
132
	// Check for 500 status code and other error fields
1692
133
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
1693
134
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
1694
135
	c.Assert(resp.Type, check.Equals, "error")
1695
136
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
1696
137
	c.Assert(resp.Result["message"], check.Equals, "No default configuration file available")
1697
138
1698
139
	os.Setenv("SNAP", oldsnap)
1699
140
}
1700
141
1701
142
func (s *S) TestWriteError(c *check.C) {
1702
143
	// Test a non writable path:
1703
144
	os.Setenv("SNAP_DATA", "/nodir")
1704
145
1705
146
	req, err := http.NewRequest(http.MethodPost, configurationV1Uri, nil)
1706
147
	c.Assert(err, check.IsNil)
1707
148
1708
149
	rec := httptest.NewRecorder()
1709
150
1710
151
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
1711
152
	c.Assert(validTokens, check.NotNil)
1712
153
	c.Assert(err, check.IsNil)
1713
154
1714
155
	changeConfiguration(rec, req)
1715
156
1716
157
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
1717
158
1718
159
	body, err := ioutil.ReadAll(rec.Body)
1719
160
	c.Assert(err, check.IsNil)
1720
161
1721
162
	// Parse the returned JSON
1722
163
	var resp serviceResponse
1723
164
	err = json.Unmarshal(body, &resp)
1724
165
	c.Assert(err, check.IsNil)
1725
166
1726
167
	// Check for 500 status code and other error fields
1727
168
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
1728
169
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
1729
170
	c.Assert(resp.Type, check.Equals, "error")
1730
171
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
1731
172
	c.Assert(resp.Result["message"], check.Equals, "Can't write configuration file")
1732
173
}
1733
174
1734
175
func (s *S) TestInvalidJSON(c *check.C) {
1735
176
	// Test an invalid JSON
1736
177
	os.Setenv("SNAP_DATA", "/tmp")
1737
178
	req, err := http.NewRequest(http.MethodPost, configurationV1Uri, strings.NewReader("not a JSON content"))
1738
179
	c.Assert(err, check.IsNil)
1739
180
1740
181
	rec := httptest.NewRecorder()
1741
182
1742
183
	changeConfiguration(rec, req)
1743
184
1744
185
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
1745
186
1746
187
	body, err := ioutil.ReadAll(rec.Body)
1747
188
	c.Assert(err, check.IsNil)
1748
189
1749
190
	// Parse the returned JSON
1750
191
	resp := serviceResponse{}
1751
192
	err = json.Unmarshal(body, &resp)
1752
193
	c.Assert(err, check.IsNil)
1753
194
1754
195
	// Check for 500 status code and other error fields
1755
196
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
1756
197
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
1757
198
	c.Assert(resp.Type, check.Equals, "error")
1758
199
	c.Assert(resp.Result["kind"], check.Equals, "internal-error")
1759
200
	c.Assert(resp.Result["message"], check.Equals, "Malformed request")
1760
201
}
1761
202
1762
203
func (s *S) TestInvalidToken(c *check.C) {
1763
204
	// Test a succesful configuration set
1764
205
	// Values to be used in the config
1765
206
	values := map[string]string{
1766
207
		"wifi.security":            "wpa2",
1767
208
		"wifi.ssid":                "UbuntuAP",
1768
209
		"wifi.security-passphrase": "12345678",
1769
210
		"bad.token":                "xyz",
1770
211
	}
1771
212
1772
213
	// Convert the map into JSON
1773
214
	args, err := json.Marshal(values)
1774
215
	c.Assert(err, check.IsNil)
1775
216
1776
217
	req, err := http.NewRequest(http.MethodPost, configurationV1Uri, bytes.NewReader(args))
1777
218
	c.Assert(err, check.IsNil)
1778
219
1779
220
	rec := httptest.NewRecorder()
1780
221
1781
222
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
1782
223
	c.Assert(validTokens, check.NotNil)
1783
224
	c.Assert(err, check.IsNil)
1784
225
1785
226
	// Do the request
1786
227
	changeConfiguration(rec, req)
1787
228
1788
229
	c.Assert(rec.Code, check.Equals, http.StatusInternalServerError)
1789
230
1790
231
	// Read the result JSON
1791
232
	body, err := ioutil.ReadAll(rec.Body)
1792
233
	c.Assert(err, check.IsNil)
1793
234
1794
235
	// Parse the returned JSON
1795
236
	resp := serviceResponse{}
1796
237
	err = json.Unmarshal(body, &resp)
1797
238
	c.Assert(err, check.IsNil)
1798
239
1799
240
	// Check for 500 status code and other succesful fields
1800
241
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusInternalServerError))
1801
242
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
1802
243
	c.Assert(resp.Type, check.Equals, "error")
1803
244
}
1804
245
1805
246
func (s *S) TestChangeConfiguration(c *check.C) {
1806
247
	// Values to be used in the config
1807
248
	values := map[string]string{
1808
249
		"wifi.security":            "wpa2",
1809
250
		"wifi.ssid":                "UbuntuAP",
1810
251
		"wifi.security-passphrase": "12345678",
1811
252
	}
1812
253
1813
254
	// Convert the map into JSON
1814
255
	args, err := json.Marshal(values)
1815
256
	c.Assert(err, check.IsNil)
1816
257
1817
258
	req, err := http.NewRequest(http.MethodPost, configurationV1Uri, bytes.NewReader(args))
1818
259
	c.Assert(err, check.IsNil)
1819
260
1820
261
	rec := httptest.NewRecorder()
1821
262
1822
263
	validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "/conf/default-config"))
1823
264
	c.Assert(validTokens, check.NotNil)
1824
265
	c.Assert(err, check.IsNil)
1825
266
1826
267
	// Do the request
1827
268
	changeConfiguration(rec, req)
1828
269
1829
270
	c.Assert(rec.Code, check.Equals, http.StatusOK)
1830
271
1831
272
	// Read the result JSON
1832
273
	body, err := ioutil.ReadAll(rec.Body)
1833
274
	c.Assert(err, check.IsNil)
1834
275
1835
276
	// Parse the returned JSON
1836
277
	resp := serviceResponse{}
1837
278
	err = json.Unmarshal(body, &resp)
1838
279
	c.Assert(err, check.IsNil)
1839
280
1840
281
	// Check for 200 status code and other succesful fields
1841
282
	c.Assert(resp.Status, check.Equals, http.StatusText(http.StatusOK))
1842
283
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
1843
284
	c.Assert(resp.Type, check.Equals, "sync")
1844
285
1845
286
	// Read the generated config and check that values were set
1846
287
	config, err := ioutil.ReadFile(getConfigOnPath(os.Getenv("SNAP_DATA")))
1847
288
	c.Assert(err, check.IsNil)
1848
289
1849
290
	for key, value := range values {
1850
291
		c.Assert(strings.Contains(string(config),
1851
292
			convertKeyToStorageFormat(key)+"="+value+"\n"),
1852
293
			check.Equals, true)
1853
294
	}
1854
295
1855
296
	// Don't leave garbage in /tmp
1856
297
	os.Remove(getConfigOnPath(os.Getenv("SNAP_DATA")))
1857
298
}
1858
diff --git a/cmd/service/response.go b/cmd/service/response.go
1859
299
new file mode 100644
0
new file mode 100644
1860
index 0000000..cc8a558
1861
--- /dev/null
1862
+++ b/cmd/service/response.go
1863
@@ -0,0 +1,73 @@
1864
1
//
1865
2
// Copyright (C) 2016 Canonical Ltd
1866
3
//
1867
4
// This program is free software: you can redistribute it and/or modify
1868
5
// it under the terms of the GNU General Public License version 3 as
1869
6
// published by the Free Software Foundation.
1870
7
//
1871
8
// This program is distributed in the hope that it will be useful,
1872
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1873
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1874
11
// GNU General Public License for more details.
1875
12
//
1876
13
// You should have received a copy of the GNU General Public License
1877
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1878
15
1879
16
package main
1880
17
1881
18
import (
1882
19
	"encoding/json"
1883
20
	"fmt"
1884
21
	"net/http"
1885
22
)
1886
23
1887
24
/* JSON message format, as described here:
1888
25
{
1889
26
	"result": {
1890
27
		"key" : "val"
1891
28
	},
1892
29
	"status": "OK",
1893
30
	"status-code": 200,
1894
31
	"type": "sync"
1895
32
}
1896
33
*/
1897
34
1898
35
type serviceResponse struct {
1899
36
	Result     map[string]string `json:"result"`
1900
37
	Status     string            `json:"status"`
1901
38
	StatusCode int               `json:"status-code"`
1902
39
	Type       string            `json:"type"`
1903
40
}
1904
41
1905
42
func makeErrorResponse(code int, message, kind string) *serviceResponse {
1906
43
	return &serviceResponse{
1907
44
		Type:       "error",
1908
45
		Status:     http.StatusText(code),
1909
46
		StatusCode: code,
1910
47
		Result: map[string]string{
1911
48
			"message": message,
1912
49
			"kind":    kind,
1913
50
		},
1914
51
	}
1915
52
}
1916
53
1917
54
func makeResponse(status int, result map[string]string) *serviceResponse {
1918
55
	resp := &serviceResponse{
1919
56
		Type:       "sync",
1920
57
		Status:     http.StatusText(status),
1921
58
		StatusCode: status,
1922
59
		Result:     result,
1923
60
	}
1924
61
1925
62
	if resp.Result == nil {
1926
63
		resp.Result = make(map[string]string)
1927
64
	}
1928
65
1929
66
	return resp
1930
67
}
1931
68
1932
69
func sendHTTPResponse(writer http.ResponseWriter, response *serviceResponse) {
1933
70
	writer.WriteHeader(response.StatusCode)
1934
71
	data, _ := json.Marshal(response)
1935
72
	fmt.Fprintln(writer, string(data))
1936
73
}
1937
diff --git a/cmd/service/response_test.go b/cmd/service/response_test.go
1938
0
new file mode 100644
74
new file mode 100644
1939
index 0000000..07d78f3
1940
--- /dev/null
1941
+++ b/cmd/service/response_test.go
1942
@@ -0,0 +1,47 @@
1943
1
//
1944
2
// Copyright (C) 2016 Canonical Ltd
1945
3
//
1946
4
// This program is free software: you can redistribute it and/or modify
1947
5
// it under the terms of the GNU General Public License version 3 as
1948
6
// published by the Free Software Foundation.
1949
7
//
1950
8
// This program is distributed in the hope that it will be useful,
1951
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
1952
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1953
11
// GNU General Public License for more details.
1954
12
//
1955
13
// You should have received a copy of the GNU General Public License
1956
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
1957
15
1958
16
package main
1959
17
1960
18
import (
1961
19
	"gopkg.in/check.v1"
1962
20
	"net/http"
1963
21
)
1964
22
1965
23
func (s *S) TestMakeErrorResponse(c *check.C) {
1966
24
	resp := makeErrorResponse(http.StatusInternalServerError, "my error message", "internal-error")
1967
25
	c.Assert(resp.Result, check.DeepEquals, map[string]string{
1968
26
		"message": "my error message",
1969
27
		"kind":    "internal-error",
1970
28
	})
1971
29
	c.Assert(resp.Status, check.Equals, "Internal Server Error")
1972
30
	c.Assert(resp.StatusCode, check.Equals, http.StatusInternalServerError)
1973
31
	c.Assert(resp.Type, check.Equals, "error")
1974
32
}
1975
33
1976
34
func (s *S) TestMakeResponse(c *check.C) {
1977
35
	resp := makeResponse(http.StatusOK, nil)
1978
36
	c.Assert(resp.Result, check.DeepEquals, map[string]string{})
1979
37
	c.Assert(resp.Status, check.Equals, "OK")
1980
38
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
1981
39
	c.Assert(resp.Type, check.Equals, "sync")
1982
40
1983
41
	data := map[string]string{"foo": "bar"}
1984
42
	resp = makeResponse(http.StatusOK, data)
1985
43
	c.Assert(resp.Result, check.DeepEquals, data)
1986
44
	c.Assert(resp.Status, check.Equals, "OK")
1987
45
	c.Assert(resp.StatusCode, check.Equals, http.StatusOK)
1988
46
	c.Assert(resp.Type, check.Equals, "sync")
1989
47
}
1990
diff --git a/cmd/service/service.go b/cmd/service/service.go
1991
0
new file mode 100644
48
new file mode 100644
1992
index 0000000..0ee04a8
1993
--- /dev/null
1994
+++ b/cmd/service/service.go
1995
@@ -0,0 +1,159 @@
1996
1
//
1997
2
// Copyright (C) 2016 Canonical Ltd
1998
3
//
1999
4
// This program is free software: you can redistribute it and/or modify
2000
5
// it under the terms of the GNU General Public License version 3 as
2001
6
// published by the Free Software Foundation.
2002
7
//
2003
8
// This program is distributed in the hope that it will be useful,
2004
9
// but WITHOUT ANY WARRANTY; without even the implied warranty of
2005
10
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2006
11
// GNU General Public License for more details.
2007
12
//
2008
13
// You should have received a copy of the GNU General Public License
2009
14
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
2010
15
2011
16
package main
2012
17
2013
18
import (
2014
19
	"fmt"
2015
20
	"github.com/gorilla/mux"
2016
21
	"log"
2017
22
	"net"
2018
23
	"net/http"
2019
24
	"os"
2020
25
	"path"
2021
26
	"path/filepath"
2022
27
	"time"
2023
28
2024
29
	"gopkg.in/tomb.v2"
2025
30
)
2026
31
2027
32
const (
2028
33
	serviceAddress = "127.0.0.1"
2029
34
	servicePort    = 5005
2030
35
)
2031
36
2032
37
type responceFunc func(*serviceCommand, http.ResponseWriter, *http.Request)
2033
38
2034
39
type serviceCommand struct {
2035
40
	Path   string
2036
41
	GET    responceFunc
2037
42
	PUT    responceFunc
2038
43
	POST   responceFunc
2039
44
	DELETE responceFunc
2040
45
	s      *service
2041
46
}
2042
47
2043
48
type service struct {
2044
49
	tomb     tomb.Tomb
2045
50
	server   *http.Server
2046
51
	listener net.Listener
2047
52
	router   *mux.Router
2048
53
	ap       BackgroundProcess
2049
54
}
2050
55
2051
56
func (c *serviceCommand) ServeHTTP(w http.ResponseWriter, r *http.Request) {
2052
57
	var rspf responceFunc
2053
58
2054
59
	switch r.Method {
2055
60
	case "GET":
2056
61
		rspf = c.GET
2057
62
	case "PUT":
2058
63
		rspf = c.PUT
2059
64
	case "POST":
2060
65
		rspf = c.POST
2061
66
	case "DELETE":
2062
67
		rspf = c.DELETE
2063
68
	}
2064
69
2065
70
	if rspf == nil {
2066
71
		rsp := makeErrorResponse(http.StatusInternalServerError, "Invalid method called", "internal-error")
2067
72
		sendHTTPResponse(w, rsp)
2068
73
		return
2069
74
	}
2070
75
2071
76
	rspf(c, w, r)
2072
77
}
2073
78
2074
79
func (s *service) addRoutes() {
2075
80
	s.router = mux.NewRouter()
2076
81
2077
82
	for _, c := range api {
2078
83
		c.s = s
2079
84
		log.Println("Adding route for ", c.Path)
2080
85
		s.router.Handle(c.Path, c).Name(c.Path)
2081
86
	}
2082
87
}
2083
88
2084
89
func (s *service) setupAccesPoint() error {
2085
90
	path := path.Join(os.Getenv("SNAP"), "bin", "ap.sh")
2086
91
	ap, err := NewBackgroundProcess(path)
2087
92
	if err != nil {
2088
93
		return err
2089
94
	}
2090
95
2091
96
	s.ap = ap
2092
97
	err = s.ap.Start()
2093
98
	if err != nil {
2094
99
		return err
2095
100
	}
2096
101
2097
102
	return nil
2098
103
}
2099
104
2100
105
func (s *service) Shutdown() {
2101
106
	log.Println("Shutting down ...")
2102
107
	s.listener.Close()
2103
108
	s.tomb.Kill(nil)
2104
109
	s.tomb.Wait()
2105
110
}
2106
111
2107
112
func (s *service) Run() error {
2108
113
	s.addRoutes()
2109
114
	if err := s.setupAccesPoint(); err != nil {
2110
115
		return err
2111
116
	}
2112
117
2113
118
	var err error
2114
119
	if validTokens, err = loadValidTokens(filepath.Join(os.Getenv("SNAP"), "conf", "default-config")); err != nil {
2115
120
		log.Println("Failed to read default configuration:", err)
2116
121
	}
2117
122
2118
123
	addr := fmt.Sprintf("%s:%d", serviceAddress, servicePort)
2119
124
	s.server = &http.Server{Addr: addr, Handler: s.router}
2120
125
	s.listener, err = net.Listen("tcp", addr)
2121
126
	if err != nil {
2122
127
		return err
2123
128
	}
2124
129
2125
130
	s.tomb.Go(func() error {
2126
131
		err := s.server.Serve(tcpKeepAliveListener{s.listener.(*net.TCPListener)})
2127
132
		if err != nil {
2128
133
			return fmt.Errorf("Failed to server HTTP: %s", err)
2129
134
		}
2130
135
		return nil
2131
136
	})
2132
137
2133
138
	s.tomb.Wait()
2134
139
2135
140
	if s.ap.Running() {
2136
141
		s.ap.Stop()
2137
142
	}
2138
143
2139
144
	return nil
2140
145
}
2141
146
2142
147
type tcpKeepAliveListener struct {
2143
148
	*net.TCPListener
2144
149
}
2145
150
2146
151
func (ln tcpKeepAliveListener) Accept() (c net.Conn, err error) {
2147
152
	tc, err := ln.AcceptTCP()
2148
153
	if err != nil {
2149
154
		return
2150
155
	}
2151
156
	tc.SetKeepAlive(true)
2152
157
	tc.SetKeepAlivePeriod(3 * time.Minute)
2153
158
	return tc, nil
2154
159
}
2155
diff --git a/snapcraft.yaml b/snapcraft.yaml
2156
index 3a7d218..072189b 100644
2157
--- a/snapcraft.yaml
2158
+++ b/snapcraft.yaml
2159
@@ -11,18 +11,14 @@ description: |
2160
11
grade: stable
11
grade: stable
2161
12
12
2162
13
apps:
13
apps:
2163
14
  backend:
2164
15
    command: bin/ap.sh
2165
16
    daemon: simple
2166
17
    plugs:
2167
18
      - network-control
2168
19
      - firewall-control
2169
20
      - network-bind
2170
21
      - network-manager
2171
22
  config:
14
  config:
2172
23
    command: bin/client config
15
    command: bin/client config
2173
24
    plugs:
16
    plugs:
2174
25
      - network
17
      - network
2175
18
  status:
2176
19
    command: bin/client status
2177
20
    plugs:
2178
21
      - network
2179
26
  setup-wizard:
22
  setup-wizard:
2180
27
    command: bin/client wizard
23
    command: bin/client wizard
2181
28
    plugs:
24
    plugs:
2182
@@ -32,6 +28,9 @@ apps:
2183
32
    daemon: simple
28
    daemon: simple
2184
33
    plugs:
29
    plugs:
2185
34
      - network-bind
30
      - network-bind
2186
31
      - network-control
2187
32
      - firewall-control
2188
33
      - network-manager
2189
35
34
2190
36
parts:
35
parts:
2191
37
  common:
36
  common:
2192
@@ -74,6 +73,7 @@ parts:
2193
74
      - bin
73
      - bin
2194
75
    build-packages:
74
    build-packages:
2195
76
      - golang-github-gorilla-mux-dev
75
      - golang-github-gorilla-mux-dev
2196
76
      - golang-gopkg-tomb.v2-dev
2197
77
77
2198
78
  dnsmasq:
78
  dnsmasq:
2199
79
    plugin: make
79
    plugin: make
2200
diff --git a/tests/lib/prepare-all.sh b/tests/lib/prepare-all.sh
2201
index 290b3ed..59e1349 100644
2202
--- a/tests/lib/prepare-all.sh
2203
+++ b/tests/lib/prepare-all.sh
2204
@@ -6,6 +6,13 @@ if [ -n "$SNAP_CHANNEL" ] ; then
2205
6
	exit 0
6
	exit 0
2206
7
fi
7
fi
2207
8
8
2208
9
# If there is a wifi-ap snap prebuilt for us, lets take
2209
10
# that one to speed things up.
2210
11
if [ -e /home/wifi-ap/wifi-ap_*_amd64.snap ] ; then
2211
12
	exit 0
2212
13
fi
2213
14
2214
15
2215
9
# Setup classic snap and build the wifi-ap snap in there
16
# Setup classic snap and build the wifi-ap snap in there
2216
10
snap install --devmode --beta classic
17
snap install --devmode --beta classic
2217
11
cat <<-EOF > /home/test/build-snap.sh
18
cat <<-EOF > /home/test/build-snap.sh
2218
diff --git a/tests/lib/restore-each.sh b/tests/lib/restore-each.sh
2219
index 799c605..1193b58 100644
2220
--- a/tests/lib/restore-each.sh
2221
+++ b/tests/lib/restore-each.sh
2222
@@ -21,7 +21,6 @@ rm -rf /var/snap/$SNAP_NAME/common/*
2223
21
rm -rf /var/snap/$SNAP_NAME/current/*
21
rm -rf /var/snap/$SNAP_NAME/current/*
2224
22
# Depending on what the test did both services are not meant to be
22
# Depending on what the test did both services are not meant to be
2225
23
# running here.
23
# running here.
2226
24
systemctl stop snap.wifi-ap.backend || true
2227
25
systemctl stop snap.wifi-ap.management-service || true
24
systemctl stop snap.wifi-ap.management-service || true
2228
26
25
2229
27
# Drop any generated or modified netplan configuration files. The original
26
# Drop any generated or modified netplan configuration files. The original
2230
@@ -40,7 +39,5 @@ netplan generate
2231
40
netplan apply
39
netplan apply
2232
41
40
2233
42
# Start services again now that the system is restored
41
# Start services again now that the system is restored
2234
43
systemctl start snap.wifi-ap.backend
2235
44
systemctl start snap.wifi-ap.management-service
42
systemctl start snap.wifi-ap.management-service
2236
45
wait_for_systemd_service snap.wifi-ap.backend
2237
46
wait_for_systemd_service snap.wifi-ap.management-service
43
wait_for_systemd_service snap.wifi-ap.management-service
2238
diff --git a/tests/main/background-process-control/task.yaml b/tests/main/background-process-control/task.yaml
2239
47
new file mode 100644
44
new file mode 100644
2240
index 0000000..c884b52
2241
--- /dev/null
2242
+++ b/tests/main/background-process-control/task.yaml
2243
@@ -0,0 +1,46 @@
2244
1
summary: Test correct service behavior to ensure the background AP process is running
2245
2
2246
3
prepare: |
2247
4
    # Simulate two WiFi radio network interfaces
2248
5
    modprobe mac80211_hwsim radios=2
2249
6
2250
7
    # We need some tools for scanning etc.
2251
8
    snap install wireless-tools
2252
9
    snap connect wireless-tools:network-control core
2253
10
2254
11
restore: |
2255
12
    rmmod mac80211_hwsim
2256
13
2257
14
execute: |
2258
15
    # Verify first the management service is up and running
2259
16
    /snap/bin/wifi-ap.config get
2260
17
    test "`/snap/bin/wifi-ap.config get disabled`" = "1"
2261
18
2262
19
    # AP should be not active at this time as still disabled
2263
20
    /snap/bin/wifi-ap.status | grep "ap.active: 0"
2264
21
2265
22
    # Now start the AP and ensure its reported as active
2266
23
    /snap/bin/wifi-ap.config set disabled 0
2267
24
    /snap/bin/wifi-ap.status | grep "ap.active: 1"
2268
25
    # And if we wait a bit more it should be still active
2269
26
    sleep 5
2270
27
    /snap/bin/wifi-ap.status | grep "ap.active: 1"
2271
28
2272
29
    # Scan for networks on the other side of the WiFi network
2273
30
    # and ensure the network is available.
2274
31
    ifconfig wlan1 up
2275
32
    /snap/bin/wireless-tools.iw dev wlan1 scan | grep 'SSID: Ubuntu'
2276
33
2277
34
    # Restart should get us back into the same state we were in before
2278
35
    /snap/bin/wifi-ap.status restart-ap
2279
36
    # Restart needs some time 
2280
37
    sleep 5
2281
38
    /snap/bin/wifi-ap.status | grep "ap.active: 1"
2282
39
    /snap/bin/wireless-tools.iw dev wlan1 scan | grep 'SSID: Ubuntu'
2283
40
2284
41
    # If we now stop the management-service the hostapd and dnsmasq
2285
42
    # instances should go away.
2286
43
    systemctl stop snap.wifi-ap.management-service
2287
44
    while /snap/bin/wifi-ap.status | grep "ap.active: 1" ; do
2288
45
        sleep 0.5
2289
46
    done
2290
diff --git a/tests/main/default-conf-brings-up-ap/task.yaml b/tests/main/default-conf-brings-up-ap/task.yaml
2291
index c8a09dd..5239813 100644
2292
--- a/tests/main/default-conf-brings-up-ap/task.yaml
2293
+++ b/tests/main/default-conf-brings-up-ap/task.yaml
2294
@@ -13,9 +13,6 @@ execute: |
2295
13
    # Default configuration will use wlan0 which we just created
13
    # Default configuration will use wlan0 which we just created
2296
14
    /snap/bin/wifi-ap.config set disabled 0
14
    /snap/bin/wifi-ap.config set disabled 0
2297
15
15
2298
16
    systemctl restart snap.wifi-ap.backend
2299
17
    wait_for_systemd_service snap.wifi-ap.backend
2300
18
2301
19
    snap install wireless-tools
16
    snap install wireless-tools
2302
20
    snap connect wireless-tools:network-control core
17
    snap connect wireless-tools:network-control core
2303
21
18
2304
diff --git a/tests/main/stress-ap-status-control/task.yaml b/tests/main/stress-ap-status-control/task.yaml
2305
22
new file mode 100644
19
new file mode 100644
2306
index 0000000..62f24d7
2307
--- /dev/null
2308
+++ b/tests/main/stress-ap-status-control/task.yaml
2309
@@ -0,0 +1,75 @@
2310
1
summary: Stress test for the AP status control API
2311
2
2312
3
environment:
2313
4
    RESTART_ITERATIONS: 15
2314
5
    SCAN_ITERATIONS: 10
2315
6
2316
7
prepare: |
2317
8
    # Simulate two WiFi radio network interfaces
2318
9
    modprobe mac80211_hwsim radios=2
2319
10
2320
11
    # We need some tools for scanning etc.
2321
12
    snap install wireless-tools
2322
13
    snap connect wireless-tools:network-control core
2323
14
2324
15
restore: |
2325
16
    rmmod mac80211_hwsim
2326
17
2327
18
execute: |
2328
19
    # Bring up the access point first
2329
20
    /snap/bin/wifi-ap.config set disabled 0
2330
21
    while ! /snap/bin/wifi-ap.status | grep "ap.active: 1" ; do
2331
22
        sleep 0.5
2332
23
    done
2333
24
2334
25
    # Scan for networks on the other side of the WiFi network
2335
26
    # and ensure the network is available.
2336
27
    ifconfig wlan1 up
2337
28
    n=0
2338
29
    found_ap=0
2339
30
    while [ $n -lt $SCAN_ITERATIONS ] ; do
2340
31
        if /snap/bin/wireless-tools.iw dev wlan1 scan | grep 'SSID: Ubuntu'; then
2341
32
            found_ap=1
2342
33
            break
2343
34
        fi
2344
35
        sleep 0.5
2345
36
        let n=n+1
2346
37
    done
2347
38
    test $found_ap -eq 1
2348
39
2349
40
    # We will restart the AP a huge number of times again and again
2350
41
    # and expect that the AP afterwards comes back up normally and
2351
42
    # we can still search and connect to it.
2352
43
    n=0
2353
44
    while [ $n -lt $RESTART_ITERATIONS ] ; do
2354
45
        /snap/bin/wifi-ap.status restart-ap
2355
46
        sleep 0.5
2356
47
        let n=n+1
2357
48
    done
2358
49
2359
50
    # Wait for AP to be marked as active again
2360
51
    while ! /snap/bin/wifi-ap.status | grep "ap.active: 1" ; do
2361
52
        sleep 0.5
2362
53
    done
2363
54
2364
55
    # The AP should be still available in our scan result
2365
56
    n=0
2366
57
    found_ap=0
2367
58
    while [ $n -lt $SCAN_ITERATIONS ] ; do
2368
59
        if /snap/bin/wireless-tools.iw dev wlan1 scan | grep 'SSID: Ubuntu'; then
2369
60
            found_ap=1
2370
61
            break
2371
62
        fi
2372
63
        sleep 0.5
2373
64
        let n=n+1
2374
65
    done
2375
66
    test $found_ap -eq 1
2376
67
2377
68
    # Verify we can associate with the AP
2378
69
    sudo /snap/bin/wireless-tools.iw wlan1 connect Ubuntu
2379
70
    sudo /snap/bin/wireless-tools.iw dev wlan1 link | grep 'SSID: Ubuntu'
2380
71
2381
72
    # We should only have one hostapd and one dnsmasq process at this time
2382
73
    # (we have to ignore the grep'ing process as otherwise we get a count of 2)
2383
74
    test `ps axu | grep hostapd | grep -v grep | wc -l` -eq 1
2384
75
    test `ps axu | grep dnsmasq | grep -v grep | wc -l` -eq 1
2385
diff --git a/tests/main/utf8-ssid/task.yaml b/tests/main/utf8-ssid/task.yaml
2386
index 903bfdb..67c334f 100644
2387
--- a/tests/main/utf8-ssid/task.yaml
2388
+++ b/tests/main/utf8-ssid/task.yaml
2389
@@ -13,11 +13,15 @@ execute: |
2390
13
    wait_for_systemd_service snap.wifi-ap.management-service
13
    wait_for_systemd_service snap.wifi-ap.management-service
2391
14
14
2392
15
    # Default configuration will use wlan0 which we just created
15
    # Default configuration will use wlan0 which we just created
2393
16
    /snap/bin/wifi-ap.config set disabled 0
2394
17
    /snap/bin/wifi-ap.config set wifi.ssid 'Ubuntu👍'
16
    /snap/bin/wifi-ap.config set wifi.ssid 'Ubuntu👍'
2395
17
    /snap/bin/wifi-ap.config set disabled 0
2396
18
18
2399
19
    systemctl restart snap.wifi-ap.backend
19
    # Wait for AP to become active
2400
20
    wait_for_systemd_service snap.wifi-ap.backend
20
    while ! /snap/bin/wifi-ap.status | grep 'ap.active: 1' ; do
2401
21
        sleep 0.5
2402
22
    done
2403
23
    # Give AP a bit more to settle until it's marked as active
2404
24
    sleep 3
2405
21
25
2406
22
    snap install wireless-tools
26
    snap install wireless-tools
2407
23
    snap connect wireless-tools:network-control core
27
    snap connect wireless-tools:network-control core
Status:	Merged
Approved by:	Matteo Croce on 2016-11-30
Approved revision:	b5e4aca99518cb7f691ed0d021e8c423eb561b2e
Merged at revision:	4318e8678f66ecc1c602b3c8735aac1a0f809a70
Proposed branch:	~morphis/snappy-hwe-snaps/+git/wifi-ap:merge-mgmt-and-ap
Merge into:	~snappy-hwe-team/snappy-hwe-snaps/+git/wifi-ap:master
Prerequisite:	~morphis/snappy-hwe-snaps/+git/wifi-ap:rework-test-infrastructure
Diff against target:	2407 lines (+1510/-604) 26 files modified MAINTAINERS (+1/-0) README.md (+35/-0) bin/ap.sh (+31/-9) bin/helper.sh (+1/-2) cmd/client/client.go (+5/-0) cmd/client/cmd_config.go (+4/-12) cmd/client/cmd_status.go (+58/-0) cmd/client/utils.go (+33/-0) cmd/service/api.go (+176/-0) cmd/service/api_test.go (+344/-0) cmd/service/background_process.go (+147/-0) cmd/service/background_process_test.go (+36/-0) cmd/service/config.go (+140/-0) cmd/service/config_test.go (+66/-0) cmd/service/main.go (+11/-266) cmd/service/response.go (+73/-0) cmd/service/response_test.go (+47/-0) cmd/service/service.go (+159/-0) dev/null (+0/-298) snapcraft.yaml (+8/-8) tests/lib/prepare-all.sh (+7/-0) tests/lib/restore-each.sh (+0/-3) tests/main/background-process-control/task.yaml (+46/-0) tests/main/default-conf-brings-up-ap/task.yaml (+0/-3) tests/main/stress-ap-status-control/task.yaml (+75/-0) tests/main/utf8-ssid/task.yaml (+7/-3)
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
System Enablement Bot	continuous-integration	2016-11-24	Approve on 2016-11-30
Matteo Croce (community)		2016-11-24	Approve on 2016-11-28
Konrad Zapałowicz (community)	code		Approve on 2016-11-28
Review via email: mp+311704@code.launchpad.net