Use network details also for Ethernet devices
[platform/upstream/connman.git] / plugins / ethernet.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <errno.h>
27 #include <net/if.h>
28
29 #ifndef IFF_LOWER_UP
30 #define IFF_LOWER_UP    0x10000
31 #endif
32
33 #include <glib.h>
34
35 #define CONNMAN_API_SUBJECT_TO_CHANGE
36 #include <connman/plugin.h>
37 #include <connman/device.h>
38 #include <connman/inet.h>
39 #include <connman/rtnl.h>
40 #include <connman/log.h>
41
42 struct ethernet_data {
43         int index;
44         unsigned flags;
45         unsigned int watch;
46         struct connman_network *network;
47 };
48
49 static int cable_probe(struct connman_network *network)
50 {
51         DBG("network %p", network);
52
53         return 0;
54 }
55
56 static void cable_remove(struct connman_network *network)
57 {
58         DBG("network %p", network);
59 }
60
61 static int cable_connect(struct connman_network *network)
62 {
63         DBG("network %p", network);
64
65         return 0;
66 }
67
68 static int cable_disconnect(struct connman_network *network)
69 {
70         DBG("network %p", network);
71
72         return 0;
73 }
74
75 static struct connman_network_driver cable_driver = {
76         .name           = "cable",
77         .type           = CONNMAN_NETWORK_TYPE_ETHERNET,
78         .probe          = cable_probe,
79         .remove         = cable_remove,
80         .connect        = cable_connect,
81         .disconnect     = cable_disconnect,
82 };
83
84 static void add_network(struct connman_device *device)
85 {
86         struct connman_network *network;
87         int index;
88
89         network = connman_network_create("carrier",
90                                         CONNMAN_NETWORK_TYPE_ETHERNET);
91         if (network == NULL)
92                 return;
93
94         index = connman_device_get_index(device);
95         connman_network_set_index(network, index);
96
97         connman_network_set_name(network, "Wired");
98         connman_network_set_protocol(network, CONNMAN_NETWORK_PROTOCOL_IP);
99
100         if (connman_device_add_network(device, network) < 0) {
101                 connman_network_unref(network);
102                 return;
103         }
104
105         connman_network_set_available(network, TRUE);
106         connman_network_set_connected(network, TRUE);
107
108         connman_network_set_group(network, "cable");
109 }
110
111 static void ethernet_newlink(unsigned flags, unsigned change, void *user_data)
112 {
113         struct connman_device *device = user_data;
114         struct ethernet_data *ethernet = connman_device_get_data(device);
115
116         DBG("index %d flags %d change %d", ethernet->index, flags, change);
117
118         if ((ethernet->flags & IFF_UP) != (flags & IFF_UP)) {
119                 if (flags & IFF_UP) {
120                         DBG("power on");
121                         connman_device_set_powered(device, TRUE);
122                 } else {
123                         DBG("power off");
124                         connman_device_set_powered(device, FALSE);
125                 }
126         }
127
128         if ((ethernet->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
129                 if (flags & IFF_LOWER_UP) {
130                         DBG("carrier on");
131                         add_network(device);
132                 } else {
133                         DBG("carrier off");
134                         connman_device_remove_all_networks(device);
135                 }
136         }
137
138         ethernet->flags = flags;
139 }
140
141 static int ethernet_probe(struct connman_device *device)
142 {
143         struct ethernet_data *ethernet;
144
145         DBG("device %p", device);
146
147         ethernet = g_try_new0(struct ethernet_data, 1);
148         if (ethernet == NULL)
149                 return -ENOMEM;
150
151         connman_device_set_data(device, ethernet);
152
153         ethernet->index = connman_device_get_index(device);
154         ethernet->flags = 0;
155
156         ethernet->watch = connman_rtnl_add_newlink_watch(ethernet->index,
157                                                 ethernet_newlink, device);
158
159         return 0;
160 }
161
162 static void ethernet_remove(struct connman_device *device)
163 {
164         struct ethernet_data *ethernet = connman_device_get_data(device);
165
166         DBG("device %p", device);
167
168         connman_device_set_data(device, NULL);
169
170         connman_rtnl_remove_watch(ethernet->watch);
171
172         connman_device_remove_all_networks(device);
173
174         g_free(ethernet);
175 }
176
177 static int ethernet_enable(struct connman_device *device)
178 {
179         struct ethernet_data *ethernet = connman_device_get_data(device);
180
181         DBG("device %p", device);
182
183         return connman_inet_ifup(ethernet->index);
184 }
185
186 static int ethernet_disable(struct connman_device *device)
187 {
188         struct ethernet_data *ethernet = connman_device_get_data(device);
189
190         DBG("device %p", device);
191
192         return connman_inet_ifdown(ethernet->index);
193 }
194
195 static struct connman_device_driver ethernet_driver = {
196         .name           = "ethernet",
197         .type           = CONNMAN_DEVICE_TYPE_ETHERNET,
198         .probe          = ethernet_probe,
199         .remove         = ethernet_remove,
200         .enable         = ethernet_enable,
201         .disable        = ethernet_disable,
202 };
203
204 static int ethernet_init(void)
205 {
206         int err;
207
208         err = connman_network_driver_register(&cable_driver);
209         if (err < 0)
210                 return err;
211
212         err = connman_device_driver_register(&ethernet_driver);
213         if (err < 0) {
214                 connman_network_driver_unregister(&cable_driver);
215                 return err;
216         }
217
218         return 0;
219 }
220
221 static void ethernet_exit(void)
222 {
223         connman_network_driver_unregister(&cable_driver);
224
225         connman_device_driver_unregister(&ethernet_driver);
226 }
227
228 CONNMAN_PLUGIN_DEFINE(ethernet, "Ethernet interface plugin", VERSION,
229                 CONNMAN_PLUGIN_PRIORITY_DEFAULT, ethernet_init, ethernet_exit)