← Back to branch summary

~ubuntu-branches/ubuntu/wily/bluez/wily

« back to all changes in this revision

Viewing changes to network/manager.c

Import upstream version 4.81

Show diffs side-by-side

added added

removed removed

Lines of Context:
network/manager.c
2
2
 *
3
3
 *  BlueZ - Bluetooth protocol stack for Linux
4
4
 *
5
 
 *  Copyright (C) 2004-2009  Marcel Holtmann <marcel@holtmann.org>
 
5
 *  Copyright (C) 2004-2010  Marcel Holtmann <marcel@holtmann.org>
6
6
 *
7
7
 *
8
8
 *  This program is free software; you can redistribute it and/or modify
26
26
#endif
27
27
 
28
28
#include <bluetooth/bluetooth.h>
29
 
#include <bluetooth/hci.h>
30
29
#include <bluetooth/bnep.h>
31
30
#include <bluetooth/sdp.h>
32
31
 
33
32
#include <glib.h>
34
33
#include <gdbus.h>
35
34
 
36
 
#include "logging.h"
 
35
#include "log.h"
37
36
 
38
37
#include "adapter.h"
39
38
#include "device.h"
40
 
#include "bridge.h"
41
39
#include "manager.h"
42
40
#include "common.h"
43
41
#include "connection.h"
44
42
#include "server.h"
45
43
 
46
 
#define IFACE_PREFIX "bnep%d"
47
 
#define GN_IFACE  "pan0"
48
 
#define NAP_IFACE "pan1"
49
 
 
50
 
static struct btd_adapter_driver network_panu_server_driver;
51
 
static struct btd_adapter_driver network_gn_server_driver;
52
 
static struct btd_adapter_driver network_nap_server_driver;
53
 
 
54
44
static DBusConnection *connection = NULL;
55
45
 
56
 
static struct network_conf {
57
 
        gboolean connection_enabled;
58
 
        gboolean server_enabled;
59
 
        gboolean security;
60
 
        char *iface_prefix;
61
 
        char *panu_script;
62
 
        char *gn_script;
63
 
        char *nap_script;
64
 
        char *gn_iface;
65
 
        char *nap_iface;
66
 
} conf = {
67
 
        .connection_enabled = TRUE,
68
 
        .server_enabled = TRUE,
69
 
        .security = TRUE,
70
 
        .iface_prefix = NULL,
71
 
        .panu_script = NULL,
72
 
        .gn_script = NULL,
73
 
        .nap_script = NULL,
74
 
        .gn_iface = NULL,
75
 
        .nap_iface = NULL
76
 
};
77
 
 
78
 
static void conf_cleanup(void)
79
 
{
80
 
        g_free(conf.iface_prefix);
81
 
        g_free(conf.panu_script);
82
 
        g_free(conf.gn_script);
83
 
        g_free(conf.nap_script);
84
 
        g_free(conf.gn_iface);
85
 
        g_free(conf.nap_iface);
86
 
}
 
46
static gboolean conf_security = TRUE;
87
47
 
88
48
static void read_config(const char *file)
89
49
{
90
50
        GKeyFile *keyfile;
91
51
        GError *err = NULL;
92
 
        char **disabled;
93
52
 
94
53
        keyfile = g_key_file_new();
95
54
 
96
55
        if (!g_key_file_load_from_file(keyfile, file, 0, &err)) {
97
 
                error("Parsing %s failed: %s", file, err->message);
98
56
                g_clear_error(&err);
99
57
                goto done;
100
58
        }
101
59
 
102
 
        disabled = g_key_file_get_string_list(keyfile, "General",
103
 
                                                "Disable", NULL, &err);
104
 
        if (err) {
105
 
                debug("%s: %s", file, err->message);
106
 
                g_clear_error(&err);
107
 
        } else {
108
 
                int i;
109
 
                for (i = 0; disabled[i] != NULL; i++) {
110
 
                        if (g_str_equal(disabled[i], "Connection"))
111
 
                                conf.connection_enabled = FALSE;
112
 
                        else if (g_str_equal(disabled[i], "Server"))
113
 
                                conf.server_enabled = FALSE;
114
 
                }
115
 
                g_strfreev(disabled);
116
 
        }
117
 
 
118
 
        conf.security = !g_key_file_get_boolean(keyfile, "General",
 
60
        conf_security = !g_key_file_get_boolean(keyfile, "General",
119
61
                                                "DisableSecurity", &err);
120
62
        if (err) {
121
 
                debug("%s: %s", file, err->message);
122
 
                g_clear_error(&err);
123
 
        }
124
 
 
125
 
#if 0
126
 
        conf.panu_script = g_key_file_get_string(keyfile, "PANU Role",
127
 
                                                "Script", &err);
128
 
        if (err) {
129
 
                debug("%s: %s", file, err->message);
130
 
                g_clear_error(&err);
131
 
        }
132
 
 
133
 
        conf.gn_script = g_key_file_get_string(keyfile, "GN Role",
134
 
                                                "Script", &err);
135
 
        if (err) {
136
 
                debug("%s: %s", file, err->message);
137
 
                g_clear_error(&err);
138
 
        }
139
 
 
140
 
        conf.nap_script = g_key_file_get_string(keyfile, "NAP Role",
141
 
                                                "Script", &err);
142
 
        if (err) {
143
 
                debug("%s: %s", file, err->message);
144
 
                g_clear_error(&err);
145
 
        }
146
 
#endif
147
 
 
148
 
        conf.iface_prefix = g_key_file_get_string(keyfile, "PANU Role",
149
 
                                                "Interface", &err);
150
 
        if (err) {
151
 
                debug("%s: %s", file, err->message);
152
 
                g_clear_error(&err);
153
 
        }
154
 
 
155
 
        conf.gn_iface = g_key_file_get_string(keyfile, "GN Role",
156
 
                                                "Interface", &err);
157
 
        if (err) {
158
 
                debug("%s: %s", file, err->message);
159
 
                g_clear_error(&err);
160
 
        }
161
 
 
162
 
        conf.nap_iface = g_key_file_get_string(keyfile, "NAP Role",
163
 
                                                "Interface", &err);
164
 
        if (err) {
165
 
                debug("%s: %s", file, err->message);
 
63
                DBG("%s: %s", file, err->message);
166
64
                g_clear_error(&err);
167
65
        }
168
66
 
169
67
done:
170
68
        g_key_file_free(keyfile);
171
69
 
172
 
        if (!conf.iface_prefix)
173
 
                conf.iface_prefix = g_strdup(IFACE_PREFIX);
174
 
 
175
 
        if (!conf.gn_iface)
176
 
                conf.gn_iface = g_strdup(GN_IFACE);
177
 
        if (!conf.nap_iface)
178
 
                conf.nap_iface = g_strdup(NAP_IFACE);
179
 
 
180
 
        debug("Config options: InterfacePrefix=%s, PANU_Script=%s, "
181
 
                "GN_Script=%s, NAP_Script=%s, GN_Interface=%s, "
182
 
                "NAP_Interface=%s, Security=%s",
183
 
                conf.iface_prefix, conf.panu_script, conf.gn_script,
184
 
                conf.nap_script, conf.gn_iface, conf.nap_iface,
185
 
                conf.security ? "true" : "false");
 
70
        DBG("Config options: Security=%s",
 
71
                                conf_security ? "true" : "false");
186
72
}
187
73
 
188
74
static int network_probe(struct btd_device *device, GSList *uuids, uint16_t id)
196
82
        adapter_get_address(adapter, &src);
197
83
        device_get_address(device, &dst);
198
84
 
199
 
        return connection_register(path, &src, &dst, id);
 
85
        return connection_register(device, path, &src, &dst, id);
200
86
}
201
87
 
202
88
static void network_remove(struct btd_device *device, uint16_t id)
238
124
        network_remove(device, BNEP_SVC_NAP);
239
125
}
240
126
 
241
 
static int network_server_probe(struct btd_adapter *adapter, uint16_t id)
242
 
{
243
 
        const gchar *path = adapter_get_path(adapter);
244
 
        bdaddr_t src;
245
 
 
246
 
        DBG("path %s", path);
247
 
 
248
 
        if (!conf.server_enabled)
249
 
                return 0;
250
 
 
251
 
        adapter_get_address(adapter, &src);
252
 
 
253
 
        return server_register(path, &src, id);
254
 
}
255
 
 
256
 
static void network_server_remove(struct btd_adapter *adapter, uint16_t id)
257
 
{
258
 
        const gchar *path = adapter_get_path(adapter);
259
 
 
260
 
        DBG("path %s", path);
261
 
 
262
 
        server_unregister(path, id);
263
 
}
264
 
 
265
 
static int panu_server_probe(struct btd_adapter *adapter)
266
 
{
267
 
        return network_server_probe(adapter, BNEP_SVC_PANU);
268
 
}
269
 
 
270
 
static int gn_server_probe(struct btd_adapter *adapter)
271
 
{
272
 
        return network_server_probe(adapter, BNEP_SVC_GN);
273
 
}
274
 
 
275
 
static int nap_server_probe(struct btd_adapter *adapter)
276
 
{
277
 
        return network_server_probe(adapter, BNEP_SVC_NAP);
278
 
}
279
 
 
280
 
static void panu_server_remove(struct btd_adapter *adapter)
281
 
{
282
 
        network_server_remove(adapter, BNEP_SVC_PANU);
283
 
}
284
 
 
285
 
static void gn_server_remove(struct btd_adapter *adapter)
286
 
{
287
 
        network_server_remove(adapter, BNEP_SVC_GN);
288
 
}
289
 
 
290
 
static void nap_server_remove(struct btd_adapter *adapter)
291
 
{
292
 
        network_server_remove(adapter, BNEP_SVC_NAP);
 
127
static int network_server_probe(struct btd_adapter *adapter)
 
128
{
 
129
        const gchar *path = adapter_get_path(adapter);
 
130
 
 
131
        DBG("path %s", path);
 
132
 
 
133
        return server_register(adapter);
 
134
}
 
135
 
 
136
static void network_server_remove(struct btd_adapter *adapter)
 
137
{
 
138
        const gchar *path = adapter_get_path(adapter);
 
139
 
 
140
        DBG("path %s", path);
 
141
 
 
142
        server_unregister(adapter);
293
143
}
294
144
 
295
145
static struct btd_device_driver network_panu_driver = {
313
163
        .remove = nap_remove,
314
164
};
315
165
 
316
 
static struct btd_adapter_driver network_panu_server_driver = {
317
 
        .name   = "network-panu-server",
318
 
        .probe  = panu_server_probe,
319
 
        .remove = panu_server_remove,
320
 
};
321
 
 
322
 
static struct btd_adapter_driver network_gn_server_driver = {
323
 
        .name   = "network-gn-server",
324
 
        .probe  = gn_server_probe,
325
 
        .remove = gn_server_remove,
326
 
};
327
 
 
328
 
static struct btd_adapter_driver network_nap_server_driver = {
329
 
        .name   = "network-nap-server",
330
 
        .probe  = nap_server_probe,
331
 
        .remove = nap_server_remove,
 
166
static struct btd_adapter_driver network_server_driver = {
 
167
        .name   = "network-server",
 
168
        .probe  = network_server_probe,
 
169
        .remove = network_server_remove,
332
170
};
333
171
 
334
172
int network_manager_init(DBusConnection *conn)
335
173
{
336
174
        read_config(CONFIGDIR "/network.conf");
337
175
 
338
 
        if (bnep_init(conf.panu_script, conf.gn_script, conf.nap_script)) {
 
176
        if (bnep_init()) {
339
177
                error("Can't init bnep module");
340
178
                return -1;
341
179
        }
346
184
         * (setup connection request) contains the destination service
347
185
         * field that defines which service the source is connecting to.
348
186
         */
349
 
        if (bridge_init(conf.gn_iface, conf.nap_iface) < 0) {
350
 
                error("Can't init bridge module");
351
 
                return -1;
352
 
        }
353
 
 
354
 
        if (server_init(conn, conf.iface_prefix, conf.security) < 0)
355
 
                return -1;
356
 
 
357
 
        /* Register PANU, GN and NAP servers if they don't exist */
358
 
        btd_register_adapter_driver(&network_panu_server_driver);
359
 
        btd_register_adapter_driver(&network_gn_server_driver);
360
 
        btd_register_adapter_driver(&network_nap_server_driver);
361
 
 
362
 
        if (connection_init(conn, conf.iface_prefix) < 0)
 
187
 
 
188
        if (server_init(conn, conf_security) < 0)
 
189
                return -1;
 
190
 
 
191
        /* Register network server if it doesn't exist */
 
192
        btd_register_adapter_driver(&network_server_driver);
 
193
 
 
194
        if (connection_init(conn) < 0)
363
195
                return -1;
364
196
 
365
197
        btd_register_device_driver(&network_panu_driver);
373
205
 
374
206
void network_manager_exit(void)
375
207
{
376
 
        if (conf.server_enabled)
377
 
                server_exit();
378
 
 
379
 
        if (conf.connection_enabled) {
380
 
                btd_unregister_device_driver(&network_panu_driver);
381
 
                btd_unregister_device_driver(&network_gn_driver);
382
 
                btd_unregister_device_driver(&network_nap_driver);
383
 
                connection_exit();
384
 
        }
385
 
 
386
 
        btd_unregister_adapter_driver(&network_panu_server_driver);
387
 
        btd_unregister_adapter_driver(&network_gn_server_driver);
388
 
        btd_unregister_adapter_driver(&network_nap_server_driver);
 
208
        server_exit();
 
209
 
 
210
        btd_unregister_device_driver(&network_panu_driver);
 
211
        btd_unregister_device_driver(&network_gn_driver);
 
212
        btd_unregister_device_driver(&network_nap_driver);
 
213
 
 
214
        connection_exit();
 
215
 
 
216
        btd_unregister_adapter_driver(&network_server_driver);
389
217
 
390
218
        dbus_connection_unref(connection);
391
219
        connection = NULL;
392
220
 
393
221
        bnep_cleanup();
394
 
        bridge_cleanup();
395
 
        conf_cleanup();
396
222
}