5 * Copyright (C) 2007 Intel Corporation. All rights reserved.
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.
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.
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
31 #include <sys/ioctl.h>
32 #include <sys/socket.h>
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
36 #include <net/route.h>
38 #include <linux/netlink.h>
39 #include <linux/rtnetlink.h>
44 #include <hal/libhal.h>
48 static DBusConnection *connection = NULL;
50 static gchar *ifname_filter = NULL;
52 static GSList *drivers = NULL;
54 int connman_iface_register(struct connman_iface_driver *driver)
56 DBG("driver %p", driver);
58 drivers = g_slist_append(drivers, driver);
63 void connman_iface_unregister(struct connman_iface_driver *driver)
65 DBG("driver %p", driver);
67 drivers = g_slist_remove(drivers, driver);
70 static GSList *interfaces = NULL;
72 struct connman_iface *__connman_iface_find(int index)
76 for (list = interfaces; list; list = list->next) {
77 struct connman_iface *iface = list->data;
79 if (iface->index == index)
86 void __connman_iface_list(DBusMessageIter *iter)
92 for (list = interfaces; list; list = list->next) {
93 struct connman_iface *iface = list->data;
95 dbus_message_iter_append_basic(iter,
96 DBUS_TYPE_OBJECT_PATH, &iface->path);
100 static void append_entry(DBusMessageIter *dict,
101 const char *key, int type, void *val)
103 DBusMessageIter entry, value;
104 const char *signature;
106 dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
109 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
112 case DBUS_TYPE_STRING:
113 signature = DBUS_TYPE_STRING_AS_STRING;
115 case DBUS_TYPE_UINT16:
116 signature = DBUS_TYPE_UINT16_AS_STRING;
119 signature = DBUS_TYPE_VARIANT_AS_STRING;
123 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
125 dbus_message_iter_append_basic(&value, type, val);
126 dbus_message_iter_close_container(&entry, &value);
128 dbus_message_iter_close_container(dict, &entry);
131 static gboolean scan_timeout(gpointer user_data)
133 struct connman_iface *iface = user_data;
135 switch (iface->state) {
136 case CONNMAN_IFACE_STATE_SCANNING:
137 if (iface->driver->scan)
138 iface->driver->scan(iface);
147 static void state_changed(struct connman_iface *iface)
149 const char *str = __connman_iface_state2string(iface->state);
150 enum connman_iface_state state = iface->state;
152 DBG("iface %p state %s", iface, str);
154 g_dbus_emit_signal(connection, iface->path,
155 CONNMAN_IFACE_INTERFACE, "StateChanged",
156 DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID);
158 switch (iface->state) {
159 case CONNMAN_IFACE_STATE_OFF:
160 __connman_iface_stop(iface);
163 case CONNMAN_IFACE_STATE_ENABLED:
164 __connman_iface_start(iface);
165 if (iface->flags & CONNMAN_IFACE_FLAG_SCANNING)
166 state = CONNMAN_IFACE_STATE_SCANNING;
169 case CONNMAN_IFACE_STATE_SCANNING:
170 if (iface->driver->scan)
171 iface->driver->scan(iface);
172 g_timeout_add(8000, scan_timeout, iface);
175 case CONNMAN_IFACE_STATE_CARRIER:
176 if (iface->policy == CONNMAN_IFACE_POLICY_AUTO)
177 state = CONNMAN_IFACE_STATE_CONFIGURE;
180 case CONNMAN_IFACE_STATE_CONFIGURE:
181 __connman_dhcp_request(iface);
184 case CONNMAN_IFACE_STATE_SHUTDOWN:
185 __connman_iface_stop(iface);
186 if (iface->policy != CONNMAN_IFACE_POLICY_AUTO)
187 state = CONNMAN_IFACE_STATE_OFF;
190 case CONNMAN_IFACE_STATE_READY:
197 if (iface->state != state) {
198 iface->state = state;
199 state_changed(iface);
203 static void switch_policy(struct connman_iface *iface)
205 DBG("iface %p policy %d", iface, iface->policy);
207 switch (iface->policy) {
208 case CONNMAN_IFACE_POLICY_OFF:
209 __connman_iface_stop(iface);
212 case CONNMAN_IFACE_POLICY_IGNORE:
215 case CONNMAN_IFACE_POLICY_AUTO:
216 case CONNMAN_IFACE_POLICY_ASK:
217 __connman_iface_start(iface);
225 void connman_iface_indicate_ifup(struct connman_iface *iface)
227 DBG("iface %p state %d", iface, iface->state);
229 switch (iface->state) {
230 case CONNMAN_IFACE_STATE_OFF:
231 iface->state = CONNMAN_IFACE_STATE_ENABLED;
232 state_changed(iface);
239 void connman_iface_indicate_ifdown(struct connman_iface *iface)
241 DBG("iface %p state %d", iface, iface->state);
243 if (iface->policy == CONNMAN_IFACE_POLICY_AUTO)
244 iface->state = CONNMAN_IFACE_STATE_ENABLED;
246 iface->state = CONNMAN_IFACE_STATE_SHUTDOWN;
248 state_changed(iface);
251 void connman_iface_indicate_connected(struct connman_iface *iface)
253 DBG("iface %p state %d", iface, iface->state);
255 switch (iface->state) {
256 case CONNMAN_IFACE_STATE_CONNECT:
257 iface->state = CONNMAN_IFACE_STATE_CONNECTED;
258 state_changed(iface);
265 void connman_iface_indicate_carrier_on(struct connman_iface *iface)
267 DBG("iface %p state %d", iface, iface->state);
269 switch (iface->state) {
270 case CONNMAN_IFACE_STATE_ENABLED:
271 case CONNMAN_IFACE_STATE_CONNECT:
272 case CONNMAN_IFACE_STATE_CONNECTED:
273 iface->state = CONNMAN_IFACE_STATE_CARRIER;
274 state_changed(iface);
281 void connman_iface_indicate_carrier_off(struct connman_iface *iface)
283 DBG("iface %p state %d", iface, iface->state);
285 switch (iface->state) {
286 case CONNMAN_IFACE_STATE_CARRIER:
287 case CONNMAN_IFACE_STATE_CONFIGURE:
288 case CONNMAN_IFACE_STATE_READY:
289 __connman_iface_disconnect(iface);
290 if (iface->flags & CONNMAN_IFACE_FLAG_SCANNING)
291 iface->state = CONNMAN_IFACE_STATE_SCANNING;
293 iface->state = CONNMAN_IFACE_STATE_ENABLED;
294 state_changed(iface);
301 void connman_iface_indicate_configured(struct connman_iface *iface)
303 DBG("iface %p state %d", iface, iface->state);
305 switch (iface->state) {
306 case CONNMAN_IFACE_STATE_CONFIGURE:
307 iface->state = CONNMAN_IFACE_STATE_READY;
308 state_changed(iface);
309 __connman_iface_store_current_network(iface);
316 static void append_station(DBusMessage *reply, const char *name,
317 int signal, int security)
319 DBusMessageIter array, dict;
320 const char *wpa = "WPA";
322 dbus_message_iter_init_append(reply, &array);
324 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
325 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
326 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
327 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
329 append_entry(&dict, "ESSID", DBUS_TYPE_STRING, &name);
330 append_entry(&dict, "Signal", DBUS_TYPE_UINT16, &signal);
333 append_entry(&dict, "Security", DBUS_TYPE_STRING, &wpa);
335 dbus_message_iter_close_container(&array, &dict);
338 void connman_iface_indicate_station(struct connman_iface *iface,
339 const char *name, int strength, int security)
342 char *ssid, *passphrase;
345 DBG("iface %p security %d name %s", iface, security, name);
347 if (name == NULL || strlen(name) == 0)
350 signal = dbus_message_new_signal(iface->path,
351 CONNMAN_IFACE_INTERFACE, "NetworkFound");
355 append_station(signal, name, strength, security);
357 dbus_connection_send(connection, signal, NULL);
358 dbus_message_unref(signal);
360 switch (iface->state) {
361 case CONNMAN_IFACE_STATE_CONNECT:
362 case CONNMAN_IFACE_STATE_CONNECTED:
363 case CONNMAN_IFACE_STATE_CARRIER:
364 case CONNMAN_IFACE_STATE_CONFIGURE:
365 case CONNMAN_IFACE_STATE_READY:
376 /* The D-Link access points return a 0x05 at the end of the SSID */
377 if (ssid[len - 1] == '\05')
378 ssid[len - 1] = '\0';
380 passphrase = __connman_iface_find_passphrase(iface, ssid);
381 if (passphrase != NULL) {
382 DBG("network %s passphrase %s", ssid, passphrase);
384 g_free(iface->network.identifier);
385 iface->network.identifier = g_strdup(ssid);
386 g_free(iface->network.passphrase);
387 iface->network.passphrase = passphrase;
389 __connman_iface_connect(iface, &iface->network);
391 iface->state = CONNMAN_IFACE_STATE_CONNECT;
392 state_changed(iface);
398 int connman_iface_get_ipv4(struct connman_iface *iface,
399 struct connman_ipv4 *ipv4)
407 if ((iface->flags & CONNMAN_IFACE_FLAG_RTNL) == 0)
410 DBG("iface %p ipv4 %p", iface, ipv4);
412 memset(&req, 0, sizeof(req));
413 req.hdr.nlmsg_len = sizeof(req.hdr) + sizeof(req.msg);
414 req.hdr.nlmsg_type = RTM_GETADDR;
415 req.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
416 req.hdr.nlmsg_pid = 0;
417 req.hdr.nlmsg_seq = 4711;
418 req.msg.rtgen_family = AF_INET;
420 __connman_rtnl_send(&req, sizeof(req));
426 int connman_iface_set_ipv4(struct connman_iface *iface,
427 struct connman_ipv4 *ipv4)
431 struct sockaddr_in *addr;
434 if ((iface->flags & CONNMAN_IFACE_FLAG_RTNL) == 0)
437 DBG("iface %p ipv4 %p", iface, ipv4);
439 sk = socket(PF_INET, SOCK_DGRAM, 0);
443 memset(&ifr, 0, sizeof(ifr));
444 ifr.ifr_ifindex = iface->index;
446 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
451 DBG("ifname %s", ifr.ifr_name);
453 addr = (struct sockaddr_in *) &ifr.ifr_addr;
454 addr->sin_family = AF_INET;
455 addr->sin_addr = ipv4->address;
457 err = ioctl(sk, SIOCSIFADDR, &ifr);
460 DBG("address setting failed (%s)", strerror(errno));
462 addr = (struct sockaddr_in *) &ifr.ifr_netmask;
463 addr->sin_family = AF_INET;
464 addr->sin_addr = ipv4->netmask;
466 err = ioctl(sk, SIOCSIFNETMASK, &ifr);
469 DBG("netmask setting failed (%s)", strerror(errno));
471 addr = (struct sockaddr_in *) &ifr.ifr_broadaddr;
472 addr->sin_family = AF_INET;
473 addr->sin_addr = ipv4->broadcast;
475 err = ioctl(sk, SIOCSIFBRDADDR, &ifr);
478 DBG("broadcast setting failed (%s)", strerror(errno));
480 memset(&rt, 0, sizeof(rt));
481 rt.rt_flags = RTF_UP | RTF_GATEWAY;
483 addr = (struct sockaddr_in *) &rt.rt_dst;
484 addr->sin_family = AF_INET;
485 addr->sin_addr.s_addr = INADDR_ANY;
487 addr = (struct sockaddr_in *) &rt.rt_gateway;
488 addr->sin_family = AF_INET;
489 addr->sin_addr = ipv4->gateway;
491 addr = (struct sockaddr_in *) &rt.rt_genmask;
492 addr->sin_family = AF_INET;
493 addr->sin_addr.s_addr = INADDR_ANY;
495 err = ioctl(sk, SIOCADDRT, &rt);
500 DBG("default route failed (%s)", strerror(errno));
504 __connman_resolver_append(iface, inet_ntoa(ipv4->nameserver));
509 int connman_iface_clear_ipv4(struct connman_iface *iface)
512 struct sockaddr_in *addr;
515 if ((iface->flags & CONNMAN_IFACE_FLAG_RTNL) == 0)
518 DBG("iface %p", iface);
520 sk = socket(PF_INET, SOCK_DGRAM, 0);
524 memset(&ifr, 0, sizeof(ifr));
525 ifr.ifr_ifindex = iface->index;
527 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
532 DBG("ifname %s", ifr.ifr_name);
534 addr = (struct sockaddr_in *) &ifr.ifr_addr;
535 addr->sin_family = AF_INET;
536 addr->sin_addr.s_addr = INADDR_ANY;
538 //err = ioctl(sk, SIOCDIFADDR, &ifr);
539 err = ioctl(sk, SIOCSIFADDR, &ifr);
543 if (err < 0 && errno != EADDRNOTAVAIL) {
544 DBG("address removal failed (%s)", strerror(errno));
548 __connman_resolver_remove(iface);
553 static DBusMessage *scan_iface(DBusConnection *conn,
554 DBusMessage *msg, void *data)
556 struct connman_iface *iface = data;
557 struct connman_iface_driver *driver = iface->driver;
560 DBG("conn %p", conn);
562 reply = dbus_message_new_method_return(msg);
566 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
568 switch (iface->state) {
569 case CONNMAN_IFACE_STATE_CONNECT:
570 case CONNMAN_IFACE_STATE_CONFIGURE:
582 static DBusMessage *get_properties(DBusConnection *conn,
583 DBusMessage *msg, void *data)
585 struct connman_iface *iface = data;
587 DBusMessageIter array, dict;
590 DBG("conn %p", conn);
592 reply = dbus_message_new_method_return(msg);
596 dbus_message_iter_init_append(reply, &array);
598 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
599 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
600 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
601 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
603 str = __connman_iface_type2string(iface->type);
604 append_entry(&dict, "Type", DBUS_TYPE_STRING, &str);
606 str = __connman_iface_state2string(iface->state);
607 append_entry(&dict, "State", DBUS_TYPE_STRING, &str);
609 if (iface->type == CONNMAN_IFACE_TYPE_80211) {
610 dbus_uint16_t signal = 75;
611 append_entry(&dict, "Signal", DBUS_TYPE_UINT16, &signal);
614 str = __connman_iface_policy2string(iface->policy);
615 append_entry(&dict, "Policy", DBUS_TYPE_STRING, &str);
617 if (iface->device.driver != NULL)
618 append_entry(&dict, "Driver",
619 DBUS_TYPE_STRING, &iface->device.driver);
621 if (iface->device.vendor != NULL)
622 append_entry(&dict, "Vendor",
623 DBUS_TYPE_STRING, &iface->device.vendor);
625 if (iface->device.product != NULL)
626 append_entry(&dict, "Product",
627 DBUS_TYPE_STRING, &iface->device.product);
629 dbus_message_iter_close_container(&array, &dict);
634 static DBusMessage *get_state(DBusConnection *conn,
635 DBusMessage *msg, void *data)
637 struct connman_iface *iface = data;
641 DBG("conn %p", conn);
643 reply = dbus_message_new_method_return(msg);
647 state = __connman_iface_state2string(iface->state);
649 dbus_message_append_args(reply, DBUS_TYPE_STRING, &state,
655 static DBusMessage *get_signal(DBusConnection *conn,
656 DBusMessage *msg, void *data)
658 struct connman_iface *iface = data;
660 dbus_uint16_t signal;
662 DBG("conn %p", conn);
664 reply = dbus_message_new_method_return(msg);
668 if (iface->type == CONNMAN_IFACE_TYPE_80211)
673 dbus_message_append_args(reply, DBUS_TYPE_UINT16, &signal,
679 static DBusMessage *get_policy(DBusConnection *conn,
680 DBusMessage *msg, void *data)
682 struct connman_iface *iface = data;
686 DBG("conn %p", conn);
688 reply = dbus_message_new_method_return(msg);
692 policy = __connman_iface_policy2string(iface->policy);
694 dbus_message_append_args(reply, DBUS_TYPE_STRING, &policy,
700 static DBusMessage *set_policy(DBusConnection *conn,
701 DBusMessage *msg, void *data)
703 struct connman_iface *iface = data;
705 enum connman_iface_policy new_policy;
708 DBG("conn %p", conn);
710 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &policy,
713 new_policy = __connman_iface_string2policy(policy);
715 reply = dbus_message_new_method_return(msg);
719 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
721 if (iface->policy != new_policy) {
722 iface->policy = new_policy;
723 __connman_iface_store(iface);
725 switch_policy(iface);
726 policy = __connman_iface_policy2string(new_policy);
728 g_dbus_emit_signal(conn, iface->path, CONNMAN_IFACE_INTERFACE,
729 "PolicyChanged", DBUS_TYPE_STRING, &policy,
736 static void append_network(DBusMessage *reply,
737 struct connman_iface *iface, gboolean secrets)
739 DBusMessageIter array, dict;
741 dbus_message_iter_init_append(reply, &array);
743 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
744 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
745 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
746 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
748 switch (iface->type) {
749 case CONNMAN_IFACE_TYPE_80211:
750 if (iface->network.identifier != NULL)
751 append_entry(&dict, "ESSID",
752 DBUS_TYPE_STRING, &iface->network.identifier);
753 if (secrets == TRUE && iface->network.passphrase != NULL)
754 append_entry(&dict, "PSK",
755 DBUS_TYPE_STRING, &iface->network.passphrase);
761 dbus_message_iter_close_container(&array, &dict);
764 static DBusMessage *get_network(DBusConnection *conn,
765 DBusMessage *msg, void *data)
767 struct connman_iface *iface = data;
770 DBG("conn %p", conn);
772 reply = dbus_message_new_method_return(msg);
776 append_network(reply, iface, TRUE);
781 static DBusMessage *set_network(DBusConnection *conn,
782 DBusMessage *msg, void *data)
784 struct connman_iface *iface = data;
785 DBusMessage *reply, *signal;
786 DBusMessageIter array, dict;
787 gboolean changed = FALSE;
789 DBG("conn %p", conn);
791 dbus_message_iter_init(msg, &array);
793 dbus_message_iter_recurse(&array, &dict);
795 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
796 DBusMessageIter entry, value;
797 const char *key, *val;
799 dbus_message_iter_recurse(&dict, &entry);
800 dbus_message_iter_get_basic(&entry, &key);
802 dbus_message_iter_next(&entry);
804 dbus_message_iter_recurse(&entry, &value);
806 //type = dbus_message_iter_get_arg_type(&value);
807 dbus_message_iter_get_basic(&value, &val);
809 if (g_strcasecmp(key, "ESSID") == 0) {
810 g_free(iface->network.identifier);
811 iface->network.identifier = g_strdup(val);
815 if (g_strcasecmp(key, "PSK") == 0) {
816 g_free(iface->network.passphrase);
817 iface->network.passphrase = g_strdup(val);
821 dbus_message_iter_next(&dict);
824 reply = dbus_message_new_method_return(msg);
828 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
830 if (changed == TRUE) {
831 __connman_iface_store(iface);
833 signal = dbus_message_new_signal(iface->path,
834 CONNMAN_IFACE_INTERFACE, "NetworkChanged");
835 if (signal != NULL) {
836 append_network(signal, iface, FALSE);
837 dbus_connection_send(conn, signal, NULL);
838 dbus_message_unref(signal);
841 __connman_iface_connect(iface, &iface->network);
847 static DBusMessage *select_network(DBusConnection *conn,
848 DBusMessage *msg, void *data)
850 struct connman_iface *iface = data;
855 DBG("conn %p", conn);
857 dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &network,
860 passphrase = __connman_iface_find_passphrase(iface, network);
861 if (passphrase == NULL)
864 g_free(iface->network.identifier);
865 iface->network.identifier = g_strdup(network);
866 g_free(iface->network.passphrase);
867 iface->network.passphrase = passphrase;
869 __connman_iface_connect(iface, &iface->network);
872 reply = dbus_message_new_method_return(msg);
876 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
881 static void append_ipv4(DBusMessage *reply, struct connman_iface *iface)
883 DBusMessageIter array, dict;
886 dbus_message_iter_init_append(reply, &array);
888 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
889 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
890 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
891 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
893 str = __connman_ipv4_method2string(CONNMAN_IPV4_METHOD_DHCP);
894 append_entry(&dict, "Method", DBUS_TYPE_STRING, &str);
896 if (iface->ipv4.address.s_addr != INADDR_ANY) {
897 str = inet_ntoa(iface->ipv4.address);
898 append_entry(&dict, "Address", DBUS_TYPE_STRING, &str);
901 if (iface->ipv4.netmask.s_addr != INADDR_ANY) {
902 str = inet_ntoa(iface->ipv4.netmask);
903 append_entry(&dict, "Netmask", DBUS_TYPE_STRING, &str);
906 if (iface->ipv4.gateway.s_addr != INADDR_ANY) {
907 str = inet_ntoa(iface->ipv4.gateway);
908 append_entry(&dict, "Gateway", DBUS_TYPE_STRING, &str);
911 dbus_message_iter_close_container(&array, &dict);
914 static DBusMessage *get_ipv4(DBusConnection *conn,
915 DBusMessage *msg, void *data)
917 struct connman_iface *iface = data;
920 DBG("conn %p", conn);
922 switch (iface->policy) {
923 case CONNMAN_IFACE_POLICY_OFF:
924 case CONNMAN_IFACE_POLICY_IGNORE:
925 return dbus_message_new_error(msg, CONNMAN_ERROR_INTERFACE
926 ".NotAvailable", "");
931 reply = dbus_message_new_method_return(msg);
935 append_ipv4(reply, iface);
940 static DBusMessage *set_ipv4(DBusConnection *conn,
941 DBusMessage *msg, void *data)
943 struct connman_iface *iface = data;
944 DBusMessage *reply, *signal;
945 DBusMessageIter array, dict;
946 gboolean changed = FALSE;
948 DBG("conn %p", conn);
950 return dbus_message_new_error(msg, CONNMAN_ERROR_INTERFACE
951 ".NotImplemented", "");
953 dbus_message_iter_init(msg, &array);
955 dbus_message_iter_recurse(&array, &dict);
957 while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
958 DBusMessageIter entry, value;
959 const char *key, *val;
960 enum connman_ipv4_method method;
963 dbus_message_iter_recurse(&dict, &entry);
964 dbus_message_iter_get_basic(&entry, &key);
966 dbus_message_iter_next(&entry);
968 dbus_message_iter_recurse(&entry, &value);
970 //type = dbus_message_iter_get_arg_type(&value);
971 dbus_message_iter_get_basic(&value, &val);
973 if (g_strcasecmp(key, "Method") == 0) {
974 method = __connman_ipv4_string2method(val);
975 if (iface->ipv4.method != method) {
976 iface->ipv4.method = method;
981 if (g_strcasecmp(key, "Address") == 0) {
982 addr = inet_addr(val);
983 if (iface->ipv4.address.s_addr != addr) {
984 iface->ipv4.address.s_addr = addr;
989 if (g_strcasecmp(key, "Netmask") == 0) {
990 addr = inet_addr(val);
991 if (iface->ipv4.netmask.s_addr != addr) {
992 iface->ipv4.netmask.s_addr = addr;
997 if (g_strcasecmp(key, "Gateway") == 0) {
998 addr = inet_addr(val);
999 if (iface->ipv4.gateway.s_addr != addr) {
1000 iface->ipv4.gateway.s_addr = addr;
1005 dbus_message_iter_next(&dict);
1008 reply = dbus_message_new_method_return(msg);
1012 dbus_message_append_args(reply, DBUS_TYPE_INVALID);
1014 if (changed == TRUE) {
1015 __connman_iface_store(iface);
1017 signal = dbus_message_new_signal(iface->path,
1018 CONNMAN_IFACE_INTERFACE, "IPv4Changed");
1019 if (signal != NULL) {
1020 append_ipv4(signal, iface);
1021 dbus_connection_send(conn, signal, NULL);
1022 dbus_message_unref(signal);
1029 static GDBusMethodTable iface_methods[] = {
1030 { "Scan", "", "", scan_iface },
1031 { "GetProperties", "", "a{sv}", get_properties },
1032 { "GetState", "", "s", get_state },
1033 { "GetSignal", "", "q", get_signal },
1034 { "GetPolicy", "", "s", get_policy },
1035 { "SetPolicy", "s", "", set_policy },
1036 { "GetNetwork", "", "a{sv}", get_network },
1037 { "SetNetwork", "a{sv}", "", set_network },
1038 { "SelectNetwork", "s", "", select_network },
1039 { "GetIPv4", "", "a{sv}", get_ipv4 },
1040 { "SetIPv4", "a{sv}", "", set_ipv4 },
1044 static GDBusSignalTable iface_signals[] = {
1045 { "StateChanged", "s" },
1046 { "SignalChanged", "q" },
1047 { "PolicyChanged", "s" },
1048 { "NetworkFound", "a{sv}" },
1049 { "NetworkChanged", "a{sv}" },
1050 { "IPv4Changed", "a{sv}" },
1054 static void device_free(void *data)
1056 struct connman_iface *iface = data;
1058 DBG("iface %p", iface);
1060 connman_iface_clear_ipv4(iface);
1062 if (iface->driver && iface->driver->remove)
1063 iface->driver->remove(iface);
1065 g_free(iface->path);
1067 g_free(iface->sysfs);
1068 g_free(iface->identifier);
1069 g_free(iface->network.identifier);
1070 g_free(iface->network.passphrase);
1071 g_free(iface->device.driver);
1072 g_free(iface->device.vendor);
1073 g_free(iface->device.product);
1077 static void detect_device_info(LibHalContext *ctx, struct connman_iface *iface)
1079 char *parent, *subsys, *value;
1081 parent = libhal_device_get_property_string(ctx, iface->udi,
1082 "info.parent", NULL);
1084 subsys = libhal_device_get_property_string(ctx, iface->udi,
1085 "linux.subsystem", NULL);
1087 value = libhal_device_get_property_string(ctx, iface->udi,
1088 "info.linux.driver", NULL);
1089 if (value == NULL) {
1090 value = libhal_device_get_property_string(ctx, parent,
1091 "info.linux.driver", NULL);
1093 iface->device.driver = g_strdup(value);
1096 if (strcmp(subsys, "net") == 0) {
1097 value = libhal_device_get_property_string(ctx, parent,
1098 "info.vendor", NULL);
1100 iface->device.vendor = g_strdup(value);
1102 value = libhal_device_get_property_string(ctx, parent,
1103 "info.product", NULL);
1105 iface->device.product = g_strdup(value);
1109 static int probe_device(LibHalContext *ctx,
1110 struct connman_iface_driver *driver, const char *udi)
1112 DBusConnection *conn;
1113 struct connman_iface *iface;
1114 char *temp, *sysfs, *ifname;
1117 DBG("ctx %p driver %p udi %s", ctx, driver, udi);
1122 iface = g_try_new0(struct connman_iface, 1);
1126 temp = g_path_get_basename(udi);
1127 iface->path = g_strdup_printf("%s/%s", CONNMAN_IFACE_BASEPATH, temp);
1130 iface->udi = g_strdup(udi);
1132 DBG("iface %p path %s", iface, iface->path);
1134 sysfs = libhal_device_get_property_string(ctx, udi,
1135 "linux.sysfs_path", NULL);
1137 iface->sysfs = g_strdup(sysfs);
1139 detect_device_info(ctx, iface);
1143 if (g_str_has_prefix(driver->capability, "net") == TRUE) {
1144 iface->index = libhal_device_get_property_int(ctx, udi,
1145 "net.linux.ifindex", NULL);
1147 ifname = libhal_device_get_property_string(ctx, udi,
1148 "net.interface", NULL);
1149 if (ifname != NULL && ifname_filter != NULL &&
1150 *ifname_filter != '\0' &&
1151 g_str_equal(ifname, ifname_filter) == FALSE) {
1157 iface->type = CONNMAN_IFACE_TYPE_UNKNOWN;
1159 iface->state = CONNMAN_IFACE_STATE_UNKNOWN;
1160 iface->policy = CONNMAN_IFACE_POLICY_UNKNOWN;
1162 err = driver->probe(iface);
1168 __connman_iface_create_identifier(iface);
1170 __connman_iface_init_via_inet(iface);
1172 iface->driver = driver;
1174 iface->policy = CONNMAN_IFACE_POLICY_AUTO;
1176 __connman_iface_load(iface);
1178 DBG("iface %p network %s secret %s", iface,
1179 iface->network.identifier,
1180 iface->network.passphrase);
1182 conn = libhal_ctx_get_dbus_connection(ctx);
1184 g_dbus_register_object(conn, iface->path, iface, device_free);
1186 interfaces = g_slist_append(interfaces, iface);
1188 if (iface->flags & CONNMAN_IFACE_FLAG_IPV4) {
1189 connman_iface_get_ipv4(iface, &iface->ipv4);
1191 DBG("address %s", inet_ntoa(iface->ipv4.address));
1194 g_dbus_register_interface(conn, iface->path,
1195 CONNMAN_IFACE_INTERFACE,
1196 iface_methods, iface_signals, NULL);
1198 DBG("iface %p identifier %s", iface, iface->identifier);
1200 g_dbus_emit_signal(conn, CONNMAN_MANAGER_PATH,
1201 CONNMAN_MANAGER_INTERFACE,
1203 DBUS_TYPE_OBJECT_PATH, &iface->path,
1206 switch_policy(iface);
1208 state_changed(iface);
1213 static void device_added(LibHalContext *ctx, const char *udi)
1217 DBG("ctx %p udi %s", ctx, udi);
1219 for (list = drivers; list; list = list->next) {
1220 struct connman_iface_driver *driver = list->data;
1222 if (driver->capability == NULL)
1225 if (libhal_device_query_capability(ctx, udi,
1226 driver->capability, NULL) == TRUE) {
1227 if (probe_device(ctx, driver, udi) == 0)
1233 static void device_removed(LibHalContext *ctx, const char *udi)
1235 DBusConnection *conn;
1238 DBG("ctx %p udi %s", ctx, udi);
1240 conn = libhal_ctx_get_dbus_connection(ctx);
1242 for (list = interfaces; list; list = list->next) {
1243 struct connman_iface *iface = list->data;
1245 if (strcmp(udi, iface->udi) == 0) {
1246 g_dbus_emit_signal(conn, CONNMAN_MANAGER_PATH,
1247 CONNMAN_MANAGER_INTERFACE,
1249 DBUS_TYPE_OBJECT_PATH, &iface->path,
1251 interfaces = g_slist_remove(interfaces, iface);
1252 g_dbus_unregister_interface(conn, iface->path,
1253 CONNMAN_IFACE_INTERFACE);
1254 g_dbus_unregister_object(conn, iface->path);
1260 static void probe_driver(LibHalContext *ctx,
1261 struct connman_iface_driver *driver)
1266 DBG("ctx %p driver %p", ctx, driver);
1268 list = libhal_find_device_by_capability(ctx,
1269 driver->capability, &num, NULL);
1274 probe_device(ctx, driver, *tmp);
1278 libhal_free_string_array(list);
1282 static void find_devices(LibHalContext *ctx)
1288 for (list = drivers; list; list = list->next) {
1289 struct connman_iface_driver *driver = list->data;
1291 DBG("driver %p", driver);
1293 if (driver->capability == NULL)
1296 probe_driver(ctx, driver);
1300 static LibHalContext *hal_ctx = NULL;
1302 static void hal_init(void *data)
1304 DBusConnection *conn = data;
1306 DBG("conn %p", conn);
1308 if (hal_ctx != NULL)
1311 hal_ctx = libhal_ctx_new();
1312 if (hal_ctx == NULL)
1315 if (libhal_ctx_set_dbus_connection(hal_ctx, conn) == FALSE) {
1316 libhal_ctx_free(hal_ctx);
1320 if (libhal_ctx_init(hal_ctx, NULL) == FALSE) {
1321 libhal_ctx_free(hal_ctx);
1325 libhal_ctx_set_device_added(hal_ctx, device_added);
1326 libhal_ctx_set_device_removed(hal_ctx, device_removed);
1328 //libhal_ctx_set_device_new_capability(hal_ctx, new_capability);
1329 //libhal_ctx_set_device_lost_capability(hal_ctx, lost_capability);
1331 find_devices(hal_ctx);
1334 static void hal_cleanup(void *data)
1336 DBusConnection *conn = data;
1339 DBG("conn %p", conn);
1341 if (hal_ctx == NULL)
1344 for (list = interfaces; list; list = list->next) {
1345 struct connman_iface *iface = list->data;
1347 DBG("path %s", iface->path);
1349 g_dbus_emit_signal(conn, CONNMAN_MANAGER_PATH,
1350 CONNMAN_MANAGER_INTERFACE,
1352 DBUS_TYPE_OBJECT_PATH, &iface->path,
1355 g_dbus_unregister_interface(conn, iface->path,
1356 CONNMAN_IFACE_INTERFACE);
1358 g_dbus_unregister_object(conn, iface->path);
1361 g_slist_free(interfaces);
1365 libhal_ctx_shutdown(hal_ctx, NULL);
1367 libhal_ctx_free(hal_ctx);
1372 static guint hal_watch = 0;
1374 int __connman_iface_init(DBusConnection *conn, const char *interface)
1376 DBG("conn %p", conn);
1378 connection = dbus_connection_ref(conn);
1379 if (connection == NULL)
1382 if (interface != NULL)
1383 ifname_filter = g_strdup(interface);
1385 hal_init(connection);
1387 hal_watch = g_dbus_add_watch(connection, "org.freedesktop.Hal",
1388 hal_init, hal_cleanup, connection, NULL);
1393 void __connman_iface_cleanup(void)
1395 DBG("conn %p", connection);
1397 g_dbus_remove_watch(connection, hal_watch);
1399 hal_cleanup(connection);
1401 g_free(ifname_filter);
1403 dbus_connection_unref(connection);